@taserjs/router 0.0.4 → 0.0.5

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";

package/src/define/validators.ts

@@ -1,5 +1,5 @@
 import type { Schema } from "../types/schema.js";
-import { SCHEMA_KEYS, type SchemaKey } from "../constants.js";
+import { SCHEMA_KEYS, type SchemaKey } from "../builder/constants.js";
 
 export type SchemaValidators = {
   query?: Schema<unknown>;

package/src/index.ts

@@ -2,16 +2,20 @@ export type { RouterRegister } from "./register.js";
 export type {
   InferInput,
   InferOutput,
+  InferRouteContext,
+  InferRouteInput,
+  InferRouteOutput,
   Method,
   PathParams,
   ReturnsMap,
+  RouteDefinition,
+  RouteExport,
   RoutePath,
   Schema,
   Simplify,
 } from "./types/index.js";
 export type {
   ContextDefinition,
-  CreateContextArgs,
   CreateTaserAppOptions,
   InferAppContext,
   InferAppManifest,
@@ -20,13 +24,7 @@ export type {
   TaserHandler,
 } from "./types/app.js";
 
-export {
-  isReplyResult,
-  reply,
-  stream,
-  ValidationError,
-  validationErrorSchema,
-} from "@taserjs/router-utils";
+export { reply, stream, ValidationError, validationErrorSchema } from "@taserjs/router-utils";
 export type {
   ReplyBodyKind,
   ReplyOf,
@@ -35,10 +33,9 @@ export type {
   SuccessStatusCode,
 } from "@taserjs/router-utils";
 
-export { createAnyRoute, createAllRoute } from "./factories.js";
-export { createTaserApp, TaserRouter } from "./taser-router.js";
-export { TaserApp, TaserNativeBound } from "./taser-app.js";
-export { createContext } from "./create-context.js";
+export { createTaserApp, TaserRouter } from "./builder/router.js";
+export { TaserApp } from "./builder/app.js";
+export { createContext } from "./context/create-context.js";
 export { defineHandler } from "./define/handler.js";
 export { defineMiddleware } from "./define/middleware.js";
 

package/src/middleware/body-limit.ts

@@ -2,10 +2,10 @@ import { bodyLimit as honoBodyLimit } from "hono/body-limit";
 
 import { wrapHonoMiddleware } from "./wrap-hono.js";
 
-const honoBodyLimitMiddleware = wrapHonoMiddleware(honoBodyLimit);
+const wrapped = wrapHonoMiddleware(honoBodyLimit);
 
 export function bodyLimit(...args: Parameters<typeof honoBodyLimit>) {
-  return honoBodyLimitMiddleware(...args);
+  return wrapped(...args);
 }
 
 export type BodyLimitOptions = Parameters<typeof honoBodyLimit>[0];

package/src/middleware/compress.ts

@@ -2,10 +2,10 @@ import { compress as honoCompress } from "hono/compress";
 
 import { wrapHonoMiddleware } from "./wrap-hono.js";
 
-const honoCompressMiddleware = wrapHonoMiddleware(honoCompress);
+const wrapped = wrapHonoMiddleware(honoCompress);
 
 export function compress(...args: Parameters<typeof honoCompress>) {
-  return honoCompressMiddleware(...args);
+  return wrapped(...args);
 }
 
 export type CompressOptions = NonNullable<Parameters<typeof honoCompress>[0]>;

package/src/middleware/cors.ts

@@ -2,10 +2,10 @@ import { cors as honoCors } from "hono/cors";
 
 import { wrapHonoMiddleware } from "./wrap-hono.js";
 
-const honoCorsMiddleware = wrapHonoMiddleware(honoCors);
+const wrapped = wrapHonoMiddleware(honoCors);
 
 export function cors(...args: Parameters<typeof honoCors>) {
-  return honoCorsMiddleware(...args);
+  return wrapped(...args);
 }
 
 export type CorsOptions = NonNullable<Parameters<typeof honoCors>[0]>;

package/src/middleware/csrf.ts

@@ -2,10 +2,10 @@ import { csrf as honoCsrf } from "hono/csrf";
 
 import { wrapHonoMiddleware } from "./wrap-hono.js";
 
-const honoCsrfMiddleware = wrapHonoMiddleware(honoCsrf);
+const wrapped = wrapHonoMiddleware(honoCsrf);
 
 export function csrf(...args: Parameters<typeof honoCsrf>) {
-  return honoCsrfMiddleware(...args);
+  return wrapped(...args);
 }
 
 export type CsrfOptions = NonNullable<Parameters<typeof honoCsrf>[0]>;

package/src/middleware/etag.ts

@@ -2,10 +2,10 @@ import { etag as honoEtag } from "hono/etag";
 
 import { wrapHonoMiddleware } from "./wrap-hono.js";
 
-const honoEtagMiddleware = wrapHonoMiddleware(honoEtag);
+const wrapped = wrapHonoMiddleware(honoEtag);
 
 export function etag(...args: Parameters<typeof honoEtag>) {
-  return honoEtagMiddleware(...args);
+  return wrapped(...args);
 }
 
 export type EtagOptions = NonNullable<Parameters<typeof honoEtag>[0]>;

package/src/middleware/jwk.ts

@@ -1,9 +1,9 @@
-import { createTaserCompatHandler } from "@taserjs/router-core";
 import type { MiddlewareHandler } from "hono";
 import { jwk as honoJwk } from "hono/jwk";
 
 import { defineMiddleware } from "../define/middleware.js";
 import type { JwtMiddlewareUnit, JwtPayloadState } from "./jwt.js";
+import { extractJwtPayload } from "./wrap-hono.js";
 
 export type JwkOptions = Parameters<typeof honoJwk>[0];
 
@@ -44,11 +44,6 @@ export function jwk<TPayload = Record<string, unknown>>(
   const honoMw: MiddlewareHandler = honoJwk(honoOptions, safeInit);
 
   return defineMiddleware<JwtPayloadState<TPayload>>({
-    handler: (ctx, next) => {
-      return createTaserCompatHandler(honoMw)(ctx, async () => {
-        const payload = (ctx as unknown as { var: { jwtPayload?: unknown } }).var.jwtPayload;
-        return next({ jwtPayload: payload as TPayload });
-      });
-    },
+    handler: extractJwtPayload<TPayload>(honoMw),
   });
 }

package/src/middleware/jwt.ts

@@ -1,9 +1,9 @@
-import { createTaserCompatHandler } from "@taserjs/router-core";
 import type { MiddlewareHandler } from "hono";
 import { jwt as honoJwt } from "hono/jwt";
 
 import { defineMiddleware } from "../define/middleware.js";
 import type { MiddlewareReturnFromParts, MiddlewareUnit } from "../types/units.js";
+import { extractJwtPayload } from "./wrap-hono.js";
 
 export type JwtPayloadState<TPayload> = {
   jwtPayload: TPayload;
@@ -24,11 +24,6 @@ export function jwt<TPayload = Record<string, unknown>>(
 ): JwtMiddlewareUnit<TPayload> {
   const honoMw: MiddlewareHandler = honoJwt(options);
   return defineMiddleware<JwtPayloadState<TPayload>>({
-    handler: (ctx, next) => {
-      return createTaserCompatHandler(honoMw)(ctx, async () => {
-        const payload = (ctx as unknown as { var: { jwtPayload?: unknown } }).var.jwtPayload;
-        return next({ jwtPayload: payload as TPayload });
-      });
-    },
+    handler: extractJwtPayload<TPayload>(honoMw),
   });
 }

package/src/middleware/secure-headers.ts

@@ -2,10 +2,10 @@ import { secureHeaders as honoSecureHeaders } from "hono/secure-headers";
 
 import { wrapHonoMiddleware } from "./wrap-hono.js";
 
-const honoSecureHeadersMiddleware = wrapHonoMiddleware(honoSecureHeaders);
+const wrapped = wrapHonoMiddleware(honoSecureHeaders);
 
 export function secureHeaders(...args: Parameters<typeof honoSecureHeaders>) {
-  return honoSecureHeadersMiddleware(...args);
+  return wrapped(...args);
 }
 
 export type SecureHeadersOptions = NonNullable<Parameters<typeof honoSecureHeaders>[0]>;

package/src/middleware/timing.ts

@@ -2,10 +2,10 @@ import { timing as honoTiming } from "hono/timing";
 
 import { wrapHonoMiddleware } from "./wrap-hono.js";
 
-const honoTimingMiddleware = wrapHonoMiddleware(honoTiming);
+const wrapped = wrapHonoMiddleware(honoTiming);
 
 export function timing(...args: Parameters<typeof honoTiming>) {
-  return honoTimingMiddleware(...args);
+  return wrapped(...args);
 }
 
 export type TimingOptions = NonNullable<Parameters<typeof honoTiming>[0]>;

package/src/middleware/wrap-hono.ts

@@ -1,3 +1,4 @@
+import { createTaserCompatHandler } from "@taserjs/router-core";
 import type { MiddlewareHandler } from "hono";
 
 import { defineMiddleware } from "../define/middleware.js";
@@ -10,3 +11,15 @@ export function wrapHonoMiddleware<F extends (...args: never[]) => MiddlewareHan
 ) => MiddlewareUnit<MiddlewareReturnFromParts<unknown, unknown, unknown, {}>> {
   return (...args) => defineMiddleware(honoFactory(...args));
 }
+
+/** Extracts the jwtPayload from Hono's variable bag and forwards it into Taser's state via next(). */
+export function extractJwtPayload<TPayload>(
+  honoMw: MiddlewareHandler,
+): (ctx: unknown, next: (state: { jwtPayload: TPayload }) => unknown) => unknown {
+  const taserHandler = createTaserCompatHandler(honoMw);
+  return (ctx, next) =>
+    taserHandler(ctx, async () => {
+      const payload = (ctx as unknown as { var: { jwtPayload?: unknown } }).var.jwtPayload;
+      return next({ jwtPayload: payload as TPayload });
+    });
+}

package/src/types/app.ts

@@ -1,6 +1,7 @@
+import type { RouteManifestShape } from "@taserjs/router-core";
 import type { ResponseValidationFailureHandler } from "@taserjs/router-utils";
 
-import type { TaserApp } from "../taser-app.js";
+import type { TaserApp } from "../builder/app.js";
 import type { ReturnsMap } from "./returns.js";
 import type { Schema } from "./schema.js";
 
@@ -24,16 +25,12 @@ export type CreateTaserAppOptions = {
   };
 };
 
-export type CreateContextArgs = {
-  native?: import("./units.js").NativeContext;
-};
-
 export type ContextDefinition<
   TBoot extends Record<string, unknown> = Record<string, never>,
   TReq extends Record<string, unknown> = Record<string, never>,
 > = {
   boot?: () => TBoot | Promise<TBoot>;
-  request?: (args: CreateContextArgs) => TReq | Promise<TReq>;
+  request?: (req: Request) => TReq | Promise<TReq>;
 };
 
 export type InferAppContext<
@@ -45,7 +42,14 @@ export type OnErrorOptions<TResponses extends ReturnsMap = ReturnsMap> = {
   handle: (error: unknown, ctx?: unknown) => Response | Promise<Response>;
 };
 
-export type InferAppManifest<TApp> = TApp extends TaserApp<infer TManifest> ? TManifest : never;
+export type InferAppManifest<TApp> =
+  TApp extends TaserApp<infer TManifest>
+    ? TManifest
+    : TApp extends { manifest: infer TManifest }
+      ? TManifest
+      : TApp extends RouteManifestShape
+        ? TApp
+        : never;
 
 export type TaserHandler<TFrameworkApp> = {
   /**
@@ -60,4 +64,4 @@ export type { RouteManifestShape } from "@taserjs/router-core";
 
 export type { Schema };
 
-export type { TaserApp, TaserNativeBound } from "../taser-app.js";
+export type { TaserApp } from "../builder/app.js";