@live-state/sync 0.0.7-canary-2 → 0.0.7-canary-4

package/dist/server.d.cts

@@ -216,19 +216,19 @@ declare function createServerDB<TSchema extends Schema<any>>(storage: Storage, s
 /** biome-ignore-all lint/suspicious/noExplicitAny: false positive */
 /** biome-ignore-all lint/style/noNonNullAssertion: false positive */
 
-type AnyProcedureRoute = ProcedureRoute<Middleware<any>, Record<string, any>, Record<string, any>, any>;
+type AnyProcedureRoute = ProcedureRoute<Middleware<any>, Record<string, any>, Record<string, any>, any, any>;
 type AnyRouteOrProcedure = AnyRoute | AnyProcedureRoute;
 type RouteRecord = Record<string, AnyRouteOrProcedure>;
 declare class Router<TRoutes extends RouteRecord> {
     readonly routes: TRoutes;
-    readonly hooksRegistry: Map<string, Hooks<any>>;
+    readonly hooksRegistry: Map<string, Hooks<any, any, any>>;
     private constructor();
     static create<TRoutes extends RouteRecord>(opts: {
         routes: TRoutes;
     }): Router<TRoutes>;
-    getHooks(resourceName: string): Hooks<any> | undefined;
+    getHooks(resourceName: string): Hooks<any, any, any> | undefined;
 }
-declare const router: <TSchema extends Schema<any>, TRoutes extends Record<keyof TSchema, Route<any, any, any, any, any>> & Record<string, Route<any, any, any, any, any> | ProcedureRoute<any, any, any, any>>>(opts: {
+declare const router: <TSchema extends Schema<any>, TRoutes extends Record<keyof TSchema, Route<any, any, any, any, any, any>> & Record<string, Route<any, any, any, any, any, any> | ProcedureRoute<any, any, any, any, any>>>(opts: {
     schema: TSchema;
     routes: TRoutes;
 }) => Router<TRoutes>;
@@ -241,91 +241,90 @@ type MutationResult<TShape extends LiveObjectAny> = {
     data: MaterializedLiveType<TShape>;
     acceptedValues: Record<string, any> | null;
 };
-type Mutation<TInputValidator extends StandardSchemaV1<any, any> | never, TOutput> = {
+type Mutation<TInputValidator extends StandardSchemaV1<any, any> | never, TOutput, TContext = Record<string, any>> = {
     _type: "mutation";
     inputValidator: TInputValidator;
     handler: (opts: {
-        req: MutationRequest<TInputValidator extends StandardSchemaV1<any, any> ? StandardSchemaV1.InferOutput<TInputValidator> : undefined>;
+        req: MutationRequest<TInputValidator extends StandardSchemaV1<any, any> ? StandardSchemaV1.InferOutput<TInputValidator> : undefined, TContext>;
         db: ServerDB<any>;
     }) => TOutput;
 };
-interface QueryProcedureRequest<TInput = any> extends BaseRequest {
+interface QueryProcedureRequest<TInput = any, TContext = Record<string, any>> extends BaseRequest<TContext> {
     type: "CUSTOM_QUERY";
     input: TInput;
     resource: string;
     procedure: string;
 }
-type Query<TInputValidator extends StandardSchemaV1<any, any> | never, TOutput> = {
+type Query<TInputValidator extends StandardSchemaV1<any, any> | never, TOutput, TContext = Record<string, any>> = {
     _type: "query";
     inputValidator: TInputValidator;
     handler: (opts: {
-        req: QueryProcedureRequest<TInputValidator extends StandardSchemaV1<any, any> ? StandardSchemaV1.InferOutput<TInputValidator> : undefined>;
+        req: QueryProcedureRequest<TInputValidator extends StandardSchemaV1<any, any> ? StandardSchemaV1.InferOutput<TInputValidator> : undefined, TContext>;
         db: ServerDB<any>;
     }) => TOutput;
 };
-type Procedure<TInputValidator extends StandardSchemaV1<any, any> | never, TOutput> = Mutation<TInputValidator, TOutput> | Query<TInputValidator, TOutput>;
-type QueryCreator<TSchema extends Schema<any> = Schema<any>> = {
+type Procedure<TInputValidator extends StandardSchemaV1<any, any> | never, TOutput, TContext = Record<string, any>> = Mutation<TInputValidator, TOutput, TContext> | Query<TInputValidator, TOutput, TContext>;
+type QueryCreator<TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> = {
     (): {
         handler: <TOutput>(handler: (opts: {
-            req: QueryProcedureRequest<undefined>;
+            req: QueryProcedureRequest<undefined, TContext>;
             db: ServerDB<TSchema>;
-        }) => TOutput) => Query<StandardSchemaV1<any, undefined>, TOutput>;
+        }) => TOutput) => Query<StandardSchemaV1<any, undefined>, TOutput, TContext>;
     };
     <TInputValidator extends StandardSchemaV1<any, any>>(validator: TInputValidator): {
         handler: <THandler extends (opts: {
-            req: QueryProcedureRequest<StandardSchemaV1.InferOutput<TInputValidator>>;
+            req: QueryProcedureRequest<StandardSchemaV1.InferOutput<TInputValidator>, TContext>;
             db: ServerDB<TSchema>;
-        }) => any>(handler: THandler) => Query<TInputValidator, ReturnType<THandler>>;
+        }) => any>(handler: THandler) => Query<TInputValidator, ReturnType<THandler>, TContext>;
     };
 };
-type MutationCreator<TSchema extends Schema<any> = Schema<any>> = {
+type MutationCreator<TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> = {
     (): {
         handler: <TOutput>(handler: (opts: {
-            req: MutationRequest<undefined>;
+            req: MutationRequest<undefined, TContext>;
             db: ServerDB<TSchema>;
-        }) => TOutput) => Mutation<StandardSchemaV1<any, undefined>, TOutput>;
+        }) => TOutput) => Mutation<StandardSchemaV1<any, undefined>, TOutput, TContext>;
     };
     <TInputValidator extends StandardSchemaV1<any, any>>(validator: TInputValidator): {
         handler: <THandler extends (opts: {
-            req: MutationRequest<StandardSchemaV1.InferOutput<TInputValidator>>;
+            req: MutationRequest<StandardSchemaV1.InferOutput<TInputValidator>, TContext>;
             db: ServerDB<TSchema>;
-        }) => any>(handler: THandler) => Mutation<TInputValidator, ReturnType<THandler>>;
+        }) => any>(handler: THandler) => Mutation<TInputValidator, ReturnType<THandler>, TContext>;
     };
 };
-declare const mutationCreator: MutationCreator;
-type ReadAuthorizationHandler<TShape extends LiveObjectAny> = (opts: {
-    ctx: BaseRequest["context"];
+type ReadAuthorizationHandler<TShape extends LiveObjectAny, TContext = Record<string, any>> = (opts: {
+    ctx: TContext;
 }) => WhereClause<TShape> | boolean;
-type MutationAuthorizationHandler<TShape extends LiveObjectAny> = (opts: {
-    ctx: BaseRequest["context"];
+type MutationAuthorizationHandler<TShape extends LiveObjectAny, TContext = Record<string, any>> = (opts: {
+    ctx: TContext;
     value: Simplify<InferLiveObjectWithRelationalIds<TShape>>;
 }) => WhereClause<TShape> | boolean;
-type Authorization<TShape extends LiveObjectAny> = {
-    read?: ReadAuthorizationHandler<TShape>;
-    insert?: MutationAuthorizationHandler<TShape>;
+type Authorization<TShape extends LiveObjectAny, TContext = Record<string, any>> = {
+    read?: ReadAuthorizationHandler<TShape, TContext>;
+    insert?: MutationAuthorizationHandler<TShape, TContext>;
     update?: {
-        preMutation?: MutationAuthorizationHandler<TShape>;
-        postMutation?: MutationAuthorizationHandler<TShape>;
+        preMutation?: MutationAuthorizationHandler<TShape, TContext>;
+        postMutation?: MutationAuthorizationHandler<TShape, TContext>;
     };
 };
-type BeforeInsertHook<TShape extends LiveObjectAny, TSchema extends Schema<any> = Schema<any>> = (opts: {
-    ctx?: Record<string, any>;
+type BeforeInsertHook<TShape extends LiveObjectAny, TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> = (opts: {
+    ctx?: TContext;
     value: Simplify<InferLiveObjectWithRelationalIds<TShape>> & {
         id: string;
     };
     rawValue: MaterializedLiveType<TShape>;
     db: ServerDB<TSchema>;
 }) => Promise<MaterializedLiveType<TShape> | void> | MaterializedLiveType<TShape> | void;
-type AfterInsertHook<TShape extends LiveObjectAny, TSchema extends Schema<any> = Schema<any>> = (opts: {
-    ctx?: Record<string, any>;
+type AfterInsertHook<TShape extends LiveObjectAny, TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> = (opts: {
+    ctx?: TContext;
     value: Simplify<InferLiveObjectWithRelationalIds<TShape>> & {
         id: string;
     };
     rawValue: MaterializedLiveType<TShape>;
     db: ServerDB<TSchema>;
 }) => Promise<void> | void;
-type BeforeUpdateHook<TShape extends LiveObjectAny, TSchema extends Schema<any> = Schema<any>> = (opts: {
-    ctx?: Record<string, any>;
+type BeforeUpdateHook<TShape extends LiveObjectAny, TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> = (opts: {
+    ctx?: TContext;
     value: Simplify<InferLiveObjectWithRelationalIds<TShape>> & {
         id: string;
     };
@@ -336,8 +335,8 @@ type BeforeUpdateHook<TShape extends LiveObjectAny, TSchema extends Schema<any>
     previousRawValue?: MaterializedLiveType<TShape>;
     db: ServerDB<TSchema>;
 }) => Promise<MaterializedLiveType<TShape> | void> | MaterializedLiveType<TShape> | void;
-type AfterUpdateHook<TShape extends LiveObjectAny, TSchema extends Schema<any> = Schema<any>> = (opts: {
-    ctx?: Record<string, any>;
+type AfterUpdateHook<TShape extends LiveObjectAny, TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> = (opts: {
+    ctx?: TContext;
     value: Simplify<InferLiveObjectWithRelationalIds<TShape>> & {
         id: string;
     };
@@ -348,37 +347,37 @@ type AfterUpdateHook<TShape extends LiveObjectAny, TSchema extends Schema<any> =
     previousRawValue?: MaterializedLiveType<TShape>;
     db: ServerDB<TSchema>;
 }) => Promise<void> | void;
-type Hooks<TShape extends LiveObjectAny, TSchema extends Schema<any> = Schema<any>> = {
-    beforeInsert?: BeforeInsertHook<TShape, TSchema>;
-    afterInsert?: AfterInsertHook<TShape, TSchema>;
-    beforeUpdate?: BeforeUpdateHook<TShape, TSchema>;
-    afterUpdate?: AfterUpdateHook<TShape, TSchema>;
+type Hooks<TShape extends LiveObjectAny, TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> = {
+    beforeInsert?: BeforeInsertHook<TShape, TSchema, TContext>;
+    afterInsert?: AfterInsertHook<TShape, TSchema, TContext>;
+    beforeUpdate?: BeforeUpdateHook<TShape, TSchema, TContext>;
+    afterUpdate?: AfterUpdateHook<TShape, TSchema, TContext>;
 };
-declare class Route<TResourceSchema extends LiveObjectAny, TMiddleware extends Middleware<any>, TCustomMutations extends Record<string, Mutation<any, any>>, TCustomQueries extends Record<string, Query<any, any>>, TSchema extends Schema<any> = Schema<any>> {
+declare class Route<TResourceSchema extends LiveObjectAny, TMiddleware extends Middleware<any>, TCustomMutations extends Record<string, Mutation<any, any>>, TCustomQueries extends Record<string, Query<any, any>>, TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> {
     readonly resourceSchema: TResourceSchema;
     readonly middlewares: Set<TMiddleware>;
     readonly customMutations: TCustomMutations;
     readonly customQueries: TCustomQueries;
-    readonly authorization?: Authorization<TResourceSchema>;
-    readonly hooks?: Hooks<TResourceSchema, TSchema>;
-    constructor(resourceSchema: TResourceSchema, customMutations?: TCustomMutations, customQueries?: TCustomQueries, authorization?: Authorization<TResourceSchema>, hooks?: Hooks<TResourceSchema, TSchema>);
+    readonly authorization?: Authorization<TResourceSchema, TContext>;
+    readonly hooks?: Hooks<TResourceSchema, TSchema, TContext>;
+    constructor(resourceSchema: TResourceSchema, customMutations?: TCustomMutations, customQueries?: TCustomQueries, authorization?: Authorization<TResourceSchema, TContext>, hooks?: Hooks<TResourceSchema, TSchema, TContext>);
     use(...middlewares: TMiddleware[]): this;
-    withProcedures<T extends Record<string, Procedure<any, any>>>(procedureFactory: (opts: {
-        mutation: MutationCreator<TSchema>;
-        query: QueryCreator<TSchema>;
-    }) => T): Route<TResourceSchema, TMiddleware, { [K in keyof T as T[K] extends Mutation<any, any> ? K : never]: T[K]; } & Record<string, Mutation<any, any>>, { [K_1 in keyof T as T[K_1] extends Query<any, any> ? K_1 : never]: T[K_1]; } & Record<string, Query<any, any>>, TSchema>;
+    withProcedures<T extends Record<string, Procedure<any, any, any>>>(procedureFactory: (opts: {
+        mutation: MutationCreator<TSchema, TContext>;
+        query: QueryCreator<TSchema, TContext>;
+    }) => T): Route<TResourceSchema, TMiddleware, { [K in keyof T as T[K] extends Mutation<any, any, Record<string, any>> ? K : never]: T[K]; } & Record<string, Mutation<any, any, Record<string, any>>>, { [K_1 in keyof T as T[K_1] extends Query<any, any, Record<string, any>> ? K_1 : never]: T[K_1]; } & Record<string, Query<any, any, Record<string, any>>>, TSchema, TContext>;
     /**
      * @deprecated Use `withProcedures` instead
      */
     withMutations<T extends Record<string, Mutation<any, any>>>(mutationFactory: (opts: {
-        mutation: typeof mutationCreator;
-    }) => T): Route<TResourceSchema, TMiddleware, { [K in keyof T as T[K] extends Mutation<any, any> ? K : never]: T[K]; } & Record<string, Mutation<any, any>>, { [K_1 in keyof T as T[K_1] extends Query<any, any> ? K_1 : never]: T[K_1]; } & Record<string, Query<any, any>>, TSchema>;
-    withHooks(hooks: Hooks<TResourceSchema, TSchema>): Route<TResourceSchema, TMiddleware, TCustomMutations, TCustomQueries, TSchema>;
+        mutation: MutationCreator<TSchema, TContext>;
+    }) => T): Route<TResourceSchema, TMiddleware, { [K in keyof T as T[K] extends Mutation<any, any, Record<string, any>> ? K : never]: T[K]; } & Record<string, Mutation<any, any, Record<string, any>>>, { [K_1 in keyof T as T[K_1] extends Query<any, any, Record<string, any>> ? K_1 : never]: T[K_1]; } & Record<string, Query<any, any, Record<string, any>>>, TSchema, TContext>;
+    withHooks(hooks: Hooks<TResourceSchema, TSchema, TContext>): Route<TResourceSchema, TMiddleware, TCustomMutations, TCustomQueries, TSchema, TContext>;
     getAuthorizationClause(req: QueryRequest): WhereClause<TResourceSchema> | undefined | boolean;
     private handleSet;
     private wrapInMiddlewares;
 }
-declare class ProcedureRoute<TMiddleware extends Middleware<any>, TCustomMutations extends Record<string, Mutation<any, any>>, TCustomQueries extends Record<string, Query<any, any>>, TSchema extends Schema<any> = Schema<any>> {
+declare class ProcedureRoute<TMiddleware extends Middleware<any>, TCustomMutations extends Record<string, Mutation<any, any>>, TCustomQueries extends Record<string, Query<any, any>>, TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> {
     readonly resourceSchema: undefined;
     readonly middlewares: Set<TMiddleware>;
     readonly customMutations: TCustomMutations;
@@ -388,19 +387,31 @@ declare class ProcedureRoute<TMiddleware extends Middleware<any>, TCustomMutatio
     getAuthorizationClause(): undefined;
     private wrapInMiddlewares;
 }
-declare class RouteFactory<TSchema extends Schema<any> = Schema<any>> {
+type TypedMiddleware<TContextIn, TContextOut> = {
+    _brand: "TypedMiddleware";
+    _rawMiddleware: Middleware<any>;
+    _contextIn?: TContextIn;
+    _contextOut?: TContextOut;
+};
+declare function createMiddleware<TContextIn, TContextOut = TContextIn>(fn: (opts: {
+    ctx: TContextIn;
+    req: Request<TContextIn>;
+    next: (ctx: TContextOut) => any;
+}) => any): TypedMiddleware<TContextIn, TContextOut>;
+declare class RouteFactory<TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> {
     private middlewares;
     private constructor();
-    collectionRoute<T extends LiveObjectAny>(shape: T, authorization?: Authorization<T>): Route<T, Middleware<any>, Record<string, never>, Record<string, never>, TSchema>;
-    withProcedures<T extends Record<string, Procedure<any, any>>>(procedureFactory: (opts: {
-        mutation: MutationCreator<TSchema>;
-        query: QueryCreator<TSchema>;
-    }) => T): ProcedureRoute<Middleware<any>, { [K in keyof T as T[K] extends Mutation<any, any> ? K : never]: T[K]; } & Record<string, Mutation<any, any>>, { [K_1 in keyof T as T[K_1] extends Query<any, any> ? K_1 : never]: T[K_1]; } & Record<string, Query<any, any>>, TSchema>;
-    use(...middlewares: Middleware<any>[]): RouteFactory<TSchema>;
-    static create<TSchema extends Schema<any> = Schema<any>>(): RouteFactory<TSchema>;
+    collectionRoute<T extends LiveObjectAny>(shape: T, authorization?: Authorization<T, TContext>): Route<T, Middleware<any>, Record<string, never>, Record<string, never>, TSchema, TContext>;
+    withProcedures<T extends Record<string, Procedure<any, any, any>>>(procedureFactory: (opts: {
+        mutation: MutationCreator<TSchema, TContext>;
+        query: QueryCreator<TSchema, TContext>;
+    }) => T): ProcedureRoute<Middleware<any>, { [K in keyof T as T[K] extends Mutation<any, any, Record<string, any>> ? K : never]: T[K]; } & Record<string, Mutation<any, any, Record<string, any>>>, { [K_1 in keyof T as T[K_1] extends Query<any, any, Record<string, any>> ? K_1 : never]: T[K_1]; } & Record<string, Query<any, any, Record<string, any>>>, TSchema, TContext>;
+    use<TNewContext>(mw: TypedMiddleware<TContext, TNewContext>): RouteFactory<TSchema, TNewContext>;
+    use(...middlewares: Middleware<any>[]): RouteFactory<TSchema, TContext>;
+    static create<TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>>(): RouteFactory<TSchema, TContext>;
 }
 declare const routeFactory: typeof RouteFactory.create;
-type AnyRoute = Route<LiveObjectAny, Middleware<any>, Record<string, any>, Record<string, any>, any>;
+type AnyRoute = Route<LiveObjectAny, Middleware<any>, Record<string, any>, Record<string, any>, any, any>;
 
 /** biome-ignore-all lint/suspicious/noExplicitAny: false positive */
 
@@ -453,51 +464,58 @@ declare class SQLStorage extends Storage {
     private notifyMutations;
 }
 
-declare const expressAdapter: (app: Application, server: Server<AnyRouter>, options?: {
+declare const expressAdapter: (app: Application, server: Server<AnyRouter, any>, options?: {
     basePath?: string;
 }) => void;
 
-interface BaseRequest {
+interface BaseRequest<TContext = Record<string, any>> {
     headers: Record<string, string>;
     cookies: Record<string, string>;
     queryParams: Record<string, string>;
-    context: Record<string, any>;
+    context: TContext;
 }
-interface QueryRequest extends BaseRequest, RawQueryRequest {
+interface QueryRequest<TContext = Record<string, any>> extends BaseRequest<TContext>, RawQueryRequest {
     type: "QUERY";
 }
-interface MutationRequest<TInput = any> extends BaseRequest {
+interface MutationRequest<TInput = any, TContext = Record<string, any>> extends BaseRequest<TContext> {
     type: "MUTATE";
     input: TInput;
     resource: string;
     resourceId?: string;
     procedure: string;
 }
-type Request = QueryRequest | MutationRequest | QueryProcedureRequest;
-type ContextProvider = (req: Omit<BaseRequest, "context"> & {
+type Request<TContext = Record<string, any>> = QueryRequest<TContext> | MutationRequest<any, TContext> | QueryProcedureRequest<any, TContext>;
+type ContextProvider<TContext = Record<string, any>> = (req: Omit<BaseRequest, "context"> & {
     transport: "HTTP" | "WEBSOCKET";
-}) => Record<string, any>;
+}) => TContext | Promise<TContext>;
 type NextFunction<O, R = Request> = (req: R) => PromiseOrSync<O>;
 type Middleware<T = any> = (opts: {
     req: Request;
     next: NextFunction<T>;
 }) => ReturnType<NextFunction<T>>;
-declare class Server<TRouter extends AnyRouter> {
+declare class Server<TRouter extends AnyRouter, TContext = Record<string, any>> {
     readonly router: TRouter;
     readonly storage: Storage;
     readonly schema: Schema<any>;
     readonly middlewares: Set<Middleware<any>>;
     readonly logger: Logger;
-    contextProvider?: ContextProvider;
+    contextProvider?: ContextProvider<TContext>;
     private constructor();
     static create<TRouter extends AnyRouter>(opts: {
         router: TRouter;
         storage: Storage;
         schema: Schema<any>;
         middlewares?: Middleware<any>[];
-        contextProvider?: ContextProvider;
         logLevel?: LogLevel;
-    }): Server<TRouter>;
+    }): Server<TRouter, Record<string, any>>;
+    static create<TRouter extends AnyRouter, TContext>(opts: {
+        router: TRouter;
+        storage: Storage;
+        schema: Schema<any>;
+        middlewares?: Middleware<any>[];
+        contextProvider: ContextProvider<TContext>;
+        logLevel?: LogLevel;
+    }): Server<TRouter, TContext>;
     handleQuery(opts: {
         req: QueryRequest;
         subscription?: (mutation: DefaultMutation) => void;
@@ -510,9 +528,9 @@ declare class Server<TRouter extends AnyRouter> {
         subscription?: (mutation: DefaultMutation) => void;
     }): Promise<any>;
     use(middleware: Middleware<any>): this;
-    context(contextProvider: ContextProvider): this;
+    context(contextProvider: ContextProvider<TContext>): this;
     private wrapInMiddlewares;
 }
 declare const server: typeof Server.create;
 
-export { type AfterInsertHook, type AfterUpdateHook, type AnyProcedureRoute, type AnyRoute, type AnyRouteOrProcedure, type AnyRouter, type Authorization, type BaseRequest, type BeforeInsertHook, type BeforeUpdateHook, type ContextProvider, type Hooks, type Middleware, type Mutation, type MutationAuthorizationHandler, type MutationRequest, type MutationResult, type NextFunction, type Procedure, ProcedureRoute, type Query, type QueryProcedureRequest, type QueryRequest, type QueryResult, type ReadAuthorizationHandler, type Request, Route, RouteFactory, type RouteRecord, Router, SQLStorage, Server, type ServerCollection, type ServerDB, Storage, createServerDB, expressAdapter, routeFactory, router, server };
+export { type AfterInsertHook, type AfterUpdateHook, type AnyProcedureRoute, type AnyRoute, type AnyRouteOrProcedure, type AnyRouter, type Authorization, type BaseRequest, type BeforeInsertHook, type BeforeUpdateHook, type ContextProvider, type Hooks, type Middleware, type Mutation, type MutationAuthorizationHandler, type MutationRequest, type MutationResult, type NextFunction, type Procedure, ProcedureRoute, type Query, type QueryProcedureRequest, type QueryRequest, type QueryResult, type ReadAuthorizationHandler, type Request, Route, RouteFactory, type RouteRecord, Router, SQLStorage, Server, type ServerCollection, type ServerDB, Storage, type TypedMiddleware, createMiddleware, createServerDB, expressAdapter, routeFactory, router, server };