@taserjs/router 0.0.3 → 0.0.5

package/src/builder/app.ts

@@ -0,0 +1,28 @@
+import type { RouteManifestShape, TaserRuntime } from "@taserjs/router-core";
+
+class TaserServeView {
+  readonly fetch: (
+    request: Request,
+    env?: unknown,
+    executionCtx?: unknown,
+  ) => Promise<Response> | Response;
+
+  constructor(protected readonly runtime: TaserRuntime) {
+    this.fetch = (request: Request, env?: unknown, executionCtx?: unknown) => {
+      return this.runtime.fetch(request, env, executionCtx as never);
+    };
+  }
+}
+
+export class TaserApp<
+  TManifest extends RouteManifestShape = RouteManifestShape,
+> extends TaserServeView {
+  readonly __manifest?: TManifest;
+
+  constructor(runtime: TaserRuntime, manifest?: TManifest) {
+    super(runtime);
+    if (manifest !== undefined) {
+      this.__manifest = manifest;
+    }
+  }
+}

package/src/{factories.ts → builder/factories.ts}

@@ -1,6 +1,6 @@
 import { createRouteBuilder } from "./route.js";
-import type { RouteBuilder, RoutePath, Schema } from "./types/index.js";
-import type { AppContext, HttpMethod } from "./types/units.js";
+import type { RouteBuilder, RoutePath, Schema } from "../types/index.js";
+import type { AppContext, HttpMethod } from "../types/units.js";
 
 type WithoutBodyOptions<TQuery, TParams, TQueryIn = unknown, TParamsIn = unknown> = {
   query?: Schema<TQuery, TQueryIn>;

package/src/{middleware.ts → builder/middleware.ts}

@@ -1,5 +1,5 @@
-import type { LayoutId, MiddlewareBuilder } from "./types/index.js";
-import type { MiddlewareDefinition } from "./types/units.js";
+import type { LayoutId, MiddlewareBuilder } from "../types/index.js";
+import type { MiddlewareDefinition } from "../types/units.js";
 
 export function createMiddleware<const Layout extends LayoutId>(
   layout: Layout,

package/src/{route.ts → builder/route.ts}

@@ -6,11 +6,17 @@ import {
   withAuto422,
 } from "@taserjs/router-utils";
 
-import type { Method, RouteBuilder, RoutePath, ReturnsMap, ValidatorParts } from "./types/index.js";
-import type { HttpMethod, MiddlewareDefinition } from "./types/units.js";
-import { isHandlerUnit } from "./types/units.js";
+import type {
+  Method,
+  RouteBuilder,
+  RoutePath,
+  ReturnsMap,
+  ValidatorParts,
+} from "../types/index.js";
+import type { HttpMethod, MiddlewareDefinition } from "../types/units.js";
+import { isHandlerUnit } from "../types/units.js";
 import { HANDLER_SCHEMA_KEY_MAP } from "./constants.js";
-import { pickDefinedSchemas, type SchemaValidators } from "./define/validators.js";
+import { pickDefinedSchemas, type SchemaValidators } from "../define/validators.js";
 
 function toUtilsMap(map: ReturnsMap | undefined): Record<number, StandardSchemaV1> {
   if (!map) {
@@ -90,49 +96,39 @@ export function createRouteBuilder(
       const routeSchemas = pickDefinedSchemas(validators);
       const base = buildRouteBase(path, method, methods, middlewares);
 
-      if (isHandlerUnit(fnOrUnit)) {
-        const handlerSchemas = pickDefinedSchemas(fnOrUnit, HANDLER_SCHEMA_KEY_MAP);
-        const returns = buildEffectiveReturns({
-          middlewareReturns: collectReturnsFromDefinitions(middlewares),
-          routeReturns: routeReturns,
-          handlerMiddlewareReturns: collectReturnsFromDefinitions(fnOrUnit.middlewares),
-          handlerReturns: fnOrUnit.returns,
-          schemas: {
-            ...validators,
-            handlerQuery: fnOrUnit.query,
-            handlerParams: fnOrUnit.params,
-            handlerBody: fnOrUnit.body,
-            middlewares,
-            handlerMiddlewares: fnOrUnit.middlewares,
-          },
-        });
+      const unit = isHandlerUnit(fnOrUnit)
+        ? fnOrUnit
+        : {
+            handler: fnOrUnit as (ctx: unknown) => Response | Promise<Response>,
+            middlewares: [] as MiddlewareDefinition[],
+            returns: undefined as ReturnsMap | undefined,
+          };
 
-        return {
-          ...base,
-          handlerMiddlewares: [...fnOrUnit.middlewares],
-          handler: fnOrUnit.handler,
-          ...routeSchemas,
-          ...handlerSchemas,
-          ...(returns ? { returns } : {}),
-        };
-      }
+      const handlerSchemas = isHandlerUnit(fnOrUnit)
+        ? pickDefinedSchemas(fnOrUnit, HANDLER_SCHEMA_KEY_MAP)
+        : {};
 
       const returns = buildEffectiveReturns({
         middlewareReturns: collectReturnsFromDefinitions(middlewares),
-        routeReturns: routeReturns,
-        handlerMiddlewareReturns: {},
-        handlerReturns: undefined,
+        routeReturns,
+        handlerMiddlewareReturns: collectReturnsFromDefinitions(unit.middlewares),
+        handlerReturns: unit.returns,
         schemas: {
           ...validators,
+          handlerQuery: (unit as any).query,
+          handlerParams: (unit as any).params,
+          handlerBody: (unit as any).body,
           middlewares,
+          handlerMiddlewares: unit.middlewares,
         },
       });
 
       return {
         ...base,
-        handlerMiddlewares: [],
-        handler: fnOrUnit as (ctx: unknown) => Response | Promise<Response>,
+        handlerMiddlewares: [...unit.middlewares],
+        handler: unit.handler,
         ...routeSchemas,
+        ...handlerSchemas,
         ...(returns ? { returns } : {}),
       };
     },

package/src/builder/router.ts

@@ -0,0 +1,347 @@
+import {
+  createTaserCompatHandler,
+  createTaserRuntime,
+  type NotFoundHandler,
+  type OnErrorHandler,
+  type RouteManifestShape,
+} from "@taserjs/router-core";
+import { isPromise, normalizeOnError } from "@taserjs/router-utils";
+
+import {
+  createAllRoute,
+  createAnyRoute,
+  createDeleteRoute,
+  createGetRoute,
+  createHeadRoute,
+  createOptionsRoute,
+  createPatchRoute,
+  createPostRoute,
+  createPutRoute,
+} from "./factories.js";
+import { defineHandler } from "../define/handler.js";
+import {
+  defineMiddleware,
+  type DefineMiddlewareOptions,
+  type MultiScopedMiddlewareOptions,
+  type ScopedMiddlewareOptions,
+} from "../define/middleware.js";
+import { createMiddleware } from "./middleware.js";
+import { TaserApp } from "./app.js";
+import type { ContextDefinition, CreateTaserAppOptions, OnErrorOptions } from "../types/app.js";
+import type {
+  AppContext,
+  ExtractState,
+  IsUnknown,
+  MiddlewareReturnFromParts,
+  MiddlewareUnit,
+} from "../types/units.js";
+import type { HandlerBuilder, LayoutId, MiddlewareBuilder } from "../types/index.js";
+import type { ReturnsMap } from "../types/returns.js";
+import type { Schema } from "../types/schema.js";
+import type {
+  CreateAllRoute,
+  CreateAnyRoute,
+  CreateWithBodyRoute,
+  CreateWithoutBodyRoute,
+} from "./factories.js";
+
+function toOnErrorHandler(
+  onErrorOptions: OnErrorOptions | OnErrorOptions["handle"],
+): OnErrorHandler {
+  return normalizeOnError(onErrorOptions);
+}
+
+type RouterState = {
+  options: CreateTaserAppOptions;
+  contextDef: ContextDefinition<Record<string, unknown>, Record<string, unknown>>;
+  onError?: OnErrorHandler;
+  notFound?: NotFoundHandler;
+};
+
+const emptyContext: ContextDefinition<Record<string, unknown>, Record<string, unknown>> = {};
+
+export class TaserRouter<TAppContext extends Record<string, unknown> = AppContext> {
+  private readonly state: RouterState;
+
+  constructor(options: CreateTaserAppOptions = {}, state?: Partial<Omit<RouterState, "options">>) {
+    this.state = {
+      options,
+      contextDef: state?.contextDef ?? emptyContext,
+      ...(state?.onError !== undefined ? { onError: state.onError } : {}),
+      ...(state?.notFound !== undefined ? { notFound: state.notFound } : {}),
+    };
+  }
+
+  context<TBoot extends Record<string, unknown>, TReq extends Record<string, unknown>>(
+    definition: ContextDefinition<TBoot, TReq>,
+  ): TaserRouter<TBoot & TReq> {
+    this.state.contextDef = definition;
+    return this as unknown as TaserRouter<TBoot & TReq>;
+  }
+
+  onError<TResponses extends ReturnsMap = ReturnsMap>(
+    options: OnErrorOptions<TResponses> | OnErrorOptions<TResponses>["handle"],
+  ): this {
+    this.state.onError = toOnErrorHandler(options);
+    return this;
+  }
+
+  notFound(handler: (ctx: unknown) => Response | Promise<Response> | unknown): this {
+    this.state.notFound = (ctx) => handler(ctx);
+    return this;
+  }
+
+  get: CreateWithoutBodyRoute<"GET", TAppContext> = createGetRoute as CreateWithoutBodyRoute<
+    "GET",
+    TAppContext
+  >;
+  post: CreateWithBodyRoute<"POST", TAppContext> = createPostRoute as CreateWithBodyRoute<
+    "POST",
+    TAppContext
+  >;
+  put: CreateWithBodyRoute<"PUT", TAppContext> = createPutRoute as CreateWithBodyRoute<
+    "PUT",
+    TAppContext
+  >;
+  patch: CreateWithBodyRoute<"PATCH", TAppContext> = createPatchRoute as CreateWithBodyRoute<
+    "PATCH",
+    TAppContext
+  >;
+  delete: CreateWithoutBodyRoute<"DELETE", TAppContext> =
+    createDeleteRoute as CreateWithoutBodyRoute<"DELETE", TAppContext>;
+  options: CreateWithoutBodyRoute<"OPTIONS", TAppContext> =
+    createOptionsRoute as CreateWithoutBodyRoute<"OPTIONS", TAppContext>;
+  head: CreateWithoutBodyRoute<"HEAD", TAppContext> = createHeadRoute as CreateWithoutBodyRoute<
+    "HEAD",
+    TAppContext
+  >;
+  any: CreateAnyRoute<TAppContext> = createAnyRoute as CreateAnyRoute<TAppContext>;
+  all: CreateAllRoute<TAppContext> = createAllRoute as CreateAllRoute<TAppContext>;
+
+  middleware<const Layout extends LayoutId>(
+    layout: Layout,
+  ): MiddlewareBuilder<Layout, readonly [], TAppContext> {
+    return createMiddleware(layout) as MiddlewareBuilder<Layout, readonly [], TAppContext>;
+  }
+
+  defineHandler<TQuery = unknown, TParams = unknown, TBody = unknown>(options?: {
+    query?: Schema<TQuery>;
+    params?: Schema<TParams>;
+    body?: Schema<TBody>;
+  }): HandlerBuilder<
+    readonly [],
+    { query: TQuery; params: TParams; body: TBody },
+    {},
+    TAppContext
+  > {
+    return options === undefined
+      ? defineHandler<TAppContext>()
+      : defineHandler<TAppContext>(options);
+  }
+
+  defineMiddleware(
+    middleware: Parameters<typeof createTaserCompatHandler>[0],
+  ): MiddlewareUnit<MiddlewareReturnFromParts<unknown, unknown, unknown, {}>, {}, null, {}>;
+
+  defineMiddleware<
+    const Layout extends LayoutId,
+    TState = unknown,
+    TRequires = {},
+    TQuery = unknown,
+    TParams = unknown,
+    TBody = unknown,
+    TReturns extends ReturnsMap = {},
+    TQueryIn = unknown,
+    TParamsIn = unknown,
+    TBodyIn = unknown,
+    R = unknown,
+  >(
+    layout: Layout,
+    options: ScopedMiddlewareOptions<
+      Layout,
+      TState,
+      TRequires,
+      TQuery,
+      TParams,
+      TBody,
+      TReturns,
+      TQueryIn,
+      TParamsIn,
+      TBodyIn,
+      TAppContext,
+      R
+    >,
+  ): MiddlewareUnit<
+    MiddlewareReturnFromParts<
+      TQuery,
+      TParams,
+      TBody,
+      IsUnknown<TState> extends true ? ExtractState<R> : TState,
+      TQueryIn,
+      TParamsIn,
+      TBodyIn
+    >,
+    TReturns,
+    Layout,
+    TRequires
+  >;
+
+  defineMiddleware<
+    const Layouts extends readonly [LayoutId, ...LayoutId[]],
+    TState = unknown,
+    TRequires = {},
+    TQuery = unknown,
+    TParams = unknown,
+    TBody = unknown,
+    TReturns extends ReturnsMap = {},
+    TQueryIn = unknown,
+    TParamsIn = unknown,
+    TBodyIn = unknown,
+    R = unknown,
+  >(
+    layouts: Layouts,
+    options: MultiScopedMiddlewareOptions<
+      Layouts,
+      TState,
+      TRequires,
+      TQuery,
+      TParams,
+      TBody,
+      TReturns,
+      TQueryIn,
+      TParamsIn,
+      TBodyIn,
+      TAppContext,
+      R
+    >,
+  ): MiddlewareUnit<
+    MiddlewareReturnFromParts<
+      TQuery,
+      TParams,
+      TBody,
+      IsUnknown<TState> extends true ? ExtractState<R> : TState,
+      TQueryIn,
+      TParamsIn,
+      TBodyIn
+    >,
+    TReturns,
+    Layouts,
+    TRequires
+  >;
+
+  defineMiddleware<
+    TState = unknown,
+    TRequires = {},
+    TQuery = unknown,
+    TParams = unknown,
+    TBody = unknown,
+    TReturns extends ReturnsMap = {},
+    TQueryIn = unknown,
+    TParamsIn = unknown,
+    TBodyIn = unknown,
+    R = unknown,
+  >(
+    options: DefineMiddlewareOptions<
+      TState,
+      TRequires,
+      TQuery,
+      TParams,
+      TBody,
+      TReturns,
+      TQueryIn,
+      TParamsIn,
+      TBodyIn,
+      TAppContext,
+      R
+    >,
+  ): MiddlewareUnit<
+    MiddlewareReturnFromParts<
+      TQuery,
+      TParams,
+      TBody,
+      IsUnknown<TState> extends true ? ExtractState<R> : TState,
+      TQueryIn,
+      TParamsIn,
+      TBodyIn
+    >,
+    TReturns,
+    null,
+    TRequires
+  >;
+
+  defineMiddleware(first: any, second?: any): any {
+    return defineMiddleware(first, second);
+  }
+
+  create<const TManifest extends RouteManifestShape>(manifest: TManifest): TaserApp<TManifest> {
+    const definition = this.state.contextDef;
+    const validateResponse = this.state.options.response?.validate ?? true;
+    const onValidationFailure = this.state.options.response?.onValidationFailure;
+    const basePath = this.state.options.basePath;
+
+    const hasCustomContext = definition.boot !== undefined || definition.request !== undefined;
+    let bootContextResolved: Record<string, unknown> | undefined;
+    let bootPromise: Promise<Record<string, unknown>> | undefined;
+
+    if (definition.boot !== undefined) {
+      const bootResult = definition.boot();
+      if (isPromise(bootResult)) {
+        bootPromise = bootResult.then((ctx) => {
+          bootContextResolved = (ctx ?? {}) as Record<string, unknown>;
+          return bootContextResolved;
+        });
+      } else {
+        bootContextResolved = (bootResult ?? {}) as Record<string, unknown>;
+      }
+    } else if (hasCustomContext) {
+      bootContextResolved = {};
+    }
+
+    const contextFactory = hasCustomContext
+      ? (req?: Request) => {
+          if (bootPromise !== undefined && bootContextResolved === undefined) {
+            return bootPromise.then(async (bootContext) => {
+              if (!definition.request) {
+                return { ...bootContext };
+              }
+              const requestResult = definition.request(req!);
+              const requestContext = isPromise(requestResult) ? await requestResult : requestResult;
+              return { ...bootContext, ...requestContext };
+            });
+          }
+
+          const bootContext = bootContextResolved ?? {};
+          if (!definition.request) {
+            return { ...bootContext };
+          }
+
+          const requestResult = definition.request(req!);
+          if (isPromise(requestResult)) {
+            return requestResult.then((requestContext) => ({
+              ...bootContext,
+              ...requestContext,
+            }));
+          }
+
+          return { ...bootContext, ...(requestResult as Record<string, unknown>) };
+        }
+      : () => ({});
+
+    const runtime = createTaserRuntime(manifest, contextFactory, {
+      ...(basePath !== undefined ? { basePath } : {}),
+      response: {
+        validate: validateResponse,
+        ...(onValidationFailure !== undefined ? { onValidationFailure } : {}),
+      },
+      ...(this.state.onError !== undefined ? { onError: this.state.onError } : {}),
+      ...(this.state.notFound !== undefined ? { notFound: this.state.notFound } : {}),
+      ...(this.state.options.cookies !== undefined ? { cookies: this.state.options.cookies } : {}),
+    });
+
+    return new TaserApp(runtime, manifest);
+  }
+}
+
+export function createTaserApp(options: CreateTaserAppOptions = {}): TaserRouter {
+  return new TaserRouter(options);
+}

package/src/{create-context.ts → context/create-context.ts}

@@ -1,6 +1,6 @@
 import type { ReservedContextKey } from "@taserjs/router-core";
 
-import type { ContextDefinition } from "./types/app.js";
+import type { ContextDefinition } from "../types/app.js";
 
 type NoReservedKeysConstraint<
   TBoot extends Record<string, unknown>,
@@ -16,4 +16,4 @@ export function createContext<
   return definition;
 }
 
-export type { ContextDefinition, InferAppContext } from "./types/app.js";
+export type { ContextDefinition, InferAppContext } from "../types/app.js";