@taserjs/router 0.0.4 → 0.1.0

package/src/{taser-router.ts → builder/router.ts}

@@ -4,7 +4,7 @@ import {
   type OnErrorHandler,
   type RouteManifestShape,
 } from "@taserjs/router-core";
-import { normalizeOnError } from "@taserjs/router-utils";
+import { isPromise, normalizeOnError } from "@taserjs/router-utils";
 
 import {
   createAllRoute,
@@ -17,13 +17,15 @@ import {
   createPostRoute,
   createPutRoute,
 } from "./factories.js";
-import { defineHandler } from "./define/handler.js";
+import { defineHandler } from "../define/handler.js";
+import { defineMiddleware, type DefineMiddlewareFn } from "../define/middleware.js";
 import { createMiddleware } from "./middleware.js";
-import { TaserApp } from "./taser-app.js";
-import type { ContextDefinition, CreateTaserAppOptions, OnErrorOptions } from "./types/app.js";
-import type { AppContext } from "./types/units.js";
-import type { HandlerBuilder, LayoutId, MiddlewareBuilder } from "./types/index.js";
-import type { Schema } from "./types/schema.js";
+import { TaserApp } from "./app.js";
+import type { ContextDefinition, CreateTaserAppOptions, OnErrorOptions } from "../types/app.js";
+import type { AppContext } 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,
@@ -46,7 +48,10 @@ type RouterState = {
 
 const emptyContext: ContextDefinition<Record<string, unknown>, Record<string, unknown>> = {};
 
-export class TaserRouter<TAppContext extends Record<string, unknown> = AppContext> {
+export class TaserRouter<
+  TAppContext extends Record<string, unknown> = AppContext,
+  THasNotFound extends boolean = false,
+> {
   private readonly state: RouterState;
 
   constructor(options: CreateTaserAppOptions = {}, state?: Partial<Omit<RouterState, "options">>) {
@@ -60,22 +65,23 @@ export class TaserRouter<TAppContext extends Record<string, unknown> = AppContex
 
   context<TBoot extends Record<string, unknown>, TReq extends Record<string, unknown>>(
     definition: ContextDefinition<TBoot, TReq>,
-  ): TaserRouter<TBoot & TReq> {
+  ): TaserRouter<TBoot & TReq, THasNotFound> {
     this.state.contextDef = definition;
-    return this as unknown as TaserRouter<TBoot & TReq>;
+    return this as unknown as TaserRouter<TBoot & TReq, THasNotFound>;
   }
 
-  onError<
-    TResponses extends import("./types/returns.js").ReturnsMap =
-      import("./types/returns.js").ReturnsMap,
-  >(options: OnErrorOptions<TResponses> | OnErrorOptions<TResponses>["handle"]): this {
+  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 {
+  notFound(
+    handler: (ctx: unknown) => Response | Promise<Response> | unknown,
+  ): TaserRouter<TAppContext, true> {
     this.state.notFound = (ctx) => handler(ctx);
-    return this;
+    return this as unknown as TaserRouter<TAppContext, true>;
   }
 
   get: CreateWithoutBodyRoute<"GET", TAppContext> = createGetRoute as CreateWithoutBodyRoute<
@@ -126,22 +132,63 @@ export class TaserRouter<TAppContext extends Record<string, unknown> = AppContex
       : defineHandler<TAppContext>(options);
   }
 
-  create<const TManifest extends RouteManifestShape>(manifest: TManifest): TaserApp<TManifest> {
+  defineMiddleware: DefineMiddlewareFn<TAppContext> =
+    defineMiddleware as DefineMiddlewareFn<TAppContext>;
+
+  create<const TManifest extends RouteManifestShape>(
+    manifest: TManifest,
+    runtimeOptions?: { basePath?: string },
+  ): TaserApp<TManifest, THasNotFound> {
     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 basePath = runtimeOptions?.basePath;
 
     const hasCustomContext = definition.boot !== undefined || definition.request !== undefined;
-    const bootPromise = hasCustomContext
-      ? Promise.resolve(definition.boot?.() ?? ({} as Record<string, unknown>))
-      : 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
-      ? async ({ native }: { native?: unknown } = {}) => {
-          const bootContext = (await bootPromise) ?? {};
-          const requestContext = (await definition.request?.({ native: native as never })) ?? {};
-          return { ...bootContext, ...requestContext };
+      ? (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>) };
         }
       : () => ({});
 
@@ -156,10 +203,12 @@ export class TaserRouter<TAppContext extends Record<string, unknown> = AppContex
       ...(this.state.options.cookies !== undefined ? { cookies: this.state.options.cookies } : {}),
     });
 
-    return new TaserApp(runtime, manifest);
+    return new TaserApp(runtime, manifest) as unknown as TaserApp<TManifest, THasNotFound>;
   }
 }
 
-export function createTaserApp(options: CreateTaserAppOptions = {}): TaserRouter {
-  return new TaserRouter(options);
+export function createTaserApp(
+  options: CreateTaserAppOptions = {},
+): TaserRouter<AppContext, false> {
+  return new TaserRouter<AppContext, false>(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/middleware.ts

@@ -3,8 +3,7 @@ import { createTaserCompatHandler, type Awaitable } from "@taserjs/router-core";
 import type { ReturnsMap } from "../types/returns.js";
 import type {
   AppContext,
-  ExtractState,
-  IsUnknown,
+  DefineMiddlewareResult,
   MiddlewareReturnFromParts,
   MiddlewareUnit,
   NextFn,
@@ -17,9 +16,9 @@ import type {
 } from "../types/index.js";
 import type { Schema } from "../types/schema.js";
 
-type HonoMiddlewareHandler = Parameters<typeof createTaserCompatHandler>[0];
+export type HonoMiddlewareHandler = Parameters<typeof createTaserCompatHandler>[0];
 
-type HonoMiddlewareUnit = MiddlewareUnit<
+export type HonoMiddlewareUnit = MiddlewareUnit<
   MiddlewareReturnFromParts<unknown, unknown, unknown, {}>,
   {},
   null,
@@ -109,145 +108,137 @@ export type MultiScopedMiddlewareOptions<
   ) => Awaitable<R>;
 };
 
-export function defineMiddleware(middleware: HonoMiddlewareHandler): HonoMiddlewareUnit;
+export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown> = AppContext> {
+  (middleware: HonoMiddlewareHandler): HonoMiddlewareUnit;
 
-export function defineMiddleware<
-  const Layout extends LayoutId,
-  TState = unknown,
-  TRequires = {},
-  TAppContext extends Record<string, unknown> = AppContext,
-  TQuery = unknown,
-  TParams = unknown,
-  TBody = unknown,
-  TReturns extends ReturnsMap = {},
-  TQueryIn = unknown,
-  TParamsIn = unknown,
-  TBodyIn = unknown,
-  R = unknown,
->(
-  layout: Layout,
-  options: ScopedMiddlewareOptions<
-    Layout,
-    TState,
-    TRequires,
+  <
+    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
+    >,
+  ): DefineMiddlewareResult<
     TQuery,
     TParams,
     TBody,
-    TReturns,
+    TState,
+    R,
     TQueryIn,
     TParamsIn,
     TBodyIn,
-    TAppContext,
-    R
-  >,
-): MiddlewareUnit<
-  MiddlewareReturnFromParts<
-    TQuery,
-    TParams,
-    TBody,
-    IsUnknown<TState> extends true ? ExtractState<R> : TState,
-    TQueryIn,
-    TParamsIn,
-    TBodyIn
-  >,
-  TReturns,
-  Layout,
-  TRequires
->;
+    TReturns,
+    Layout,
+    TRequires
+  >;
 
-export function defineMiddleware<
-  const Layouts extends readonly [LayoutId, ...LayoutId[]],
-  TState = unknown,
-  TRequires = {},
-  TAppContext extends Record<string, unknown> = AppContext,
-  TQuery = unknown,
-  TParams = unknown,
-  TBody = unknown,
-  TReturns extends ReturnsMap = {},
-  TQueryIn = unknown,
-  TParamsIn = unknown,
-  TBodyIn = unknown,
-  R = unknown,
->(
-  layouts: Layouts,
-  options: MultiScopedMiddlewareOptions<
-    Layouts,
-    TState,
-    TRequires,
+  <
+    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
+    >,
+  ): DefineMiddlewareResult<
     TQuery,
     TParams,
     TBody,
-    TReturns,
+    TState,
+    R,
     TQueryIn,
     TParamsIn,
     TBodyIn,
-    TAppContext,
-    R
-  >,
-): MiddlewareUnit<
-  MiddlewareReturnFromParts<
-    TQuery,
-    TParams,
-    TBody,
-    IsUnknown<TState> extends true ? ExtractState<R> : TState,
-    TQueryIn,
-    TParamsIn,
-    TBodyIn
-  >,
-  TReturns,
-  Layouts,
-  TRequires
->;
+    TReturns,
+    Layouts,
+    TRequires
+  >;
 
-export function defineMiddleware<
-  TState = unknown,
-  TRequires = {},
-  TAppContext extends Record<string, unknown> = AppContext,
-  TQuery = unknown,
-  TParams = unknown,
-  TBody = unknown,
-  TReturns extends ReturnsMap = {},
-  TQueryIn = unknown,
-  TParamsIn = unknown,
-  TBodyIn = unknown,
-  R = unknown,
->(
-  options: DefineMiddlewareOptions<
-    TState,
-    TRequires,
+  <
+    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
+    >,
+  ): DefineMiddlewareResult<
     TQuery,
     TParams,
     TBody,
-    TReturns,
+    TState,
+    R,
     TQueryIn,
     TParamsIn,
     TBodyIn,
-    TAppContext,
-    R
-  >,
-): MiddlewareUnit<
-  MiddlewareReturnFromParts<
-    TQuery,
-    TParams,
-    TBody,
-    IsUnknown<TState> extends true ? ExtractState<R> : TState,
-    TQueryIn,
-    TParamsIn,
-    TBodyIn
-  >,
-  TReturns,
-  null,
-  TRequires
->;
+    TReturns,
+    null,
+    TRequires
+  >;
+}
 
-export function defineMiddleware(
-  first:
-    | string
-    | readonly string[]
-    | HonoMiddlewareHandler
-    | DefineMiddlewareOptions<any, any, any, any, any, any, any, any, any, any, any>,
-  second?: DefineMiddlewareOptions<any, any, any, any, any, any, any, any, any, any, any>,
-): unknown {
+export const defineMiddleware: DefineMiddlewareFn<AppContext> = function defineMiddleware(
+  first: any,
+  second?: any,
+): any {
   if (typeof first === "string" || Array.isArray(first)) {
     const options = second!;
     const unit = {
@@ -262,7 +253,8 @@ export function defineMiddleware(
   if (typeof first === "function") {
     const honoMiddleware = first as HonoMiddlewareHandler;
     return defineMiddleware({
-      handler: (ctx, next) => createTaserCompatHandler(honoMiddleware)(ctx, next),
+      handler: (ctx: unknown, next: (state?: Record<string, unknown>) => unknown) =>
+        createTaserCompatHandler(honoMiddleware)(ctx, next),
     });
   }
 
@@ -286,4 +278,4 @@ export function defineMiddleware(
   };
 
   return unit;
-}
+};

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

@@ -1,44 +1,37 @@
 export type { RouterRegister } from "./register.js";
 export type {
+  HttpMethod,
   InferInput,
   InferOutput,
+  InferRouteContext,
+  InferRouteInput,
+  InferRouteOutput,
   Method,
+  MiddlewareDefinition,
   PathParams,
   ReturnsMap,
+  RouteDefinition,
+  RouteExport,
   RoutePath,
   Schema,
   Simplify,
+  StatusCode,
 } from "./types/index.js";
 export type {
   ContextDefinition,
-  CreateContextArgs,
   CreateTaserAppOptions,
   InferAppContext,
   InferAppManifest,
   OnErrorOptions,
   RouteManifestShape,
-  TaserHandler,
 } from "./types/app.js";
 
-export {
-  isReplyResult,
-  reply,
-  stream,
-  ValidationError,
-  validationErrorSchema,
-} from "@taserjs/router-utils";
-export type {
-  ReplyBodyKind,
-  ReplyOf,
-  ResponseValidationFailureHandler,
-  SuccessReplyData,
-  SuccessStatusCode,
-} from "@taserjs/router-utils";
+export { ValidationError, validationErrorSchema } from "@taserjs/router-utils";
+export type { ResponseValidationFailureHandler, 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]>;