feat(fab-spec#386): add support for typed settings

packages/core/src/runtime.ts

@@ -12,6 +12,7 @@ import {
   ResponseInterceptor,
 } from '@fab/core'
 import { Key, pathToRegexp } from 'path-to-regexp'
+import { FabSettings } from './types'
 
 export enum Priority {
   LAST,
@@ -29,8 +30,8 @@ export type RuntimeImports = Array<{
   args: PluginArgs
 }>
 
-export class FABRouter {
-  private pipeline: { [order in Priority]: FabRequestResponder[] }
+export class FABRouter<Settings extends FabSettings = FabSettings> {
+  private pipeline: { [order in Priority]: FabRequestResponder<Settings>[] }
 
   constructor() {
     this.pipeline = {
@@ -52,19 +53,26 @@ export class FABRouter {
     ]
   }
 
-  addToPipeline(responder: FabRequestResponder, priority: Priority = Priority.MIDDLE) {
+  addToPipeline(
+    responder: FabRequestResponder<Settings>,
+    priority: Priority = Priority.MIDDLE
+  ) {
     this.pipeline[priority].push(responder)
   }
 
-  on(route: string, responder: FabRequestResponderWithParams, priority?: Priority) {
+  on(
+    route: string,
+    responder: FabRequestResponderWithParams<Settings>,
+    priority?: Priority
+  ) {
     if (route === '*') {
       // Make this an alias for .onAll, with an empty params object
       this.onAll((context) => responder({ ...context, params: {} }), priority)
     } else {
       // Otherwise compile the route and generate a responder
       const groups: Key[] = []
       const regexp = pathToRegexp(route, groups)
-      this.addToPipeline(async (context: FabResponderArgs) => {
+      this.addToPipeline(async (context: FabResponderArgs<Settings>) => {
         const { pathname } = context.url
         // Only execute if this request matches our route
         const match = regexp.exec(pathname)
@@ -80,7 +88,7 @@ export class FABRouter {
     }
   }
 
-  onAll(responder: FabRequestResponder, priority?: Priority) {
+  onAll(responder: FabRequestResponder<Settings>, priority?: Priority) {
     this.addToPipeline(responder, priority)
   }
 
@@ -106,10 +114,13 @@ class NoopCache implements FabCache {
   getStream = async () => undefined
 }
 
-export class FABRuntime<T extends PluginMetadata = PluginMetadata> {
+export class FABRuntime<
+  T extends PluginMetadata = PluginMetadata,
+  Settings extends FabSettings = FabSettings
+> {
   Metadata: T
   FileMetadata: FabFileMetadata
-  Router: FABRouter
+  Router: FABRouter<Settings>
   Cache: FabCache
   ServerContext: FABServerContext
 

packages/core/src/types.ts

@@ -68,9 +68,9 @@ export type FabResponderMutableContext = {
 export type Cookies = {
   [key: string]: string
 }
-export type FabResponderArgs = {
+export type FabResponderArgs<Settings extends FabSettings = FabSettings> = {
   request: Request
-  settings: FabSettings
+  settings: Settings
   url: URL
   context: FabResponderMutableContext
   cookies: Cookies
@@ -80,15 +80,15 @@ export type FabResponderArgs = {
  * a Response. If this responder should not handle this request, it
  * returns undefined and the next renderer is invoked.
  * */
-export type FabRequestResponder = (
-  context: FabResponderArgs
+export type FabRequestResponder<Settings extends FabSettings = FabSettings> = (
+  context: FabResponderArgs<Settings>
 ) => Promise<undefined | Request | Response | Directive>
 
 export type MatchParams = { [match_name: string]: string }
 
-export type FabRequestResponderWithParams = (
-  contextWithParams: FabResponderArgs & { params: MatchParams }
-) => ReturnType<FabRequestResponder>
+export type FabRequestResponderWithParams<Settings extends FabSettings = FabSettings> = (
+  contextWithParams: FabResponderArgs<Settings> & { params: MatchParams }
+) => ReturnType<FabRequestResponder<Settings>>
 
 export type ResponseInterceptor = (response: Response) => Promise<Response>