@taserjs/router 0.0.5 → 0.1.0

package/src/builder/factories.ts

@@ -1,168 +1,46 @@
 import { createRouteBuilder } from "./route.js";
-import type { RouteBuilder, RoutePath, Schema } from "../types/index.js";
+import type { RouteBuilder, RoutePath } from "../types/index.js";
 import type { AppContext, HttpMethod } from "../types/units.js";
 
-type WithoutBodyOptions<TQuery, TParams, TQueryIn = unknown, TParamsIn = unknown> = {
-  query?: Schema<TQuery, TQueryIn>;
-  params?: Schema<TParams, TParamsIn>;
-};
-
-type WithBodyOptions<
-  TQuery,
-  TParams,
-  TBody,
-  TQueryIn = unknown,
-  TParamsIn = unknown,
-  TBodyIn = unknown,
-> = WithoutBodyOptions<TQuery, TParams, TQueryIn, TParamsIn> & {
-  body?: Schema<TBody, TBodyIn>;
-};
-
 export type CreateWithoutBodyRoute<
   M extends "GET" | "DELETE" | "OPTIONS" | "HEAD",
   TAppContext extends Record<string, unknown> = AppContext,
-> = {
-  <const Path extends RoutePath>(
-    path: Path,
-  ): RouteBuilder<Path, M, readonly [], {}, {}, TAppContext>;
-  <
-    const Path extends RoutePath,
-    TQuery = unknown,
-    TParams = unknown,
-    TQueryIn = unknown,
-    TParamsIn = unknown,
-  >(
-    path: Path,
-    options: WithoutBodyOptions<TQuery, TParams, TQueryIn, TParamsIn>,
-  ): RouteBuilder<
-    Path,
-    M,
-    readonly [],
-    {
-      query: TQuery;
-      params: TParams;
-      queryIn: TQueryIn;
-      paramsIn: TParamsIn;
-    },
-    {},
-    TAppContext
-  >;
-};
+> = <const Path extends RoutePath>(
+  path: Path,
+) => RouteBuilder<Path, M, readonly [], {}, {}, TAppContext>;
 
 export type CreateWithBodyRoute<
   M extends "POST" | "PUT" | "PATCH",
   TAppContext extends Record<string, unknown> = AppContext,
-> = {
-  <const Path extends RoutePath>(
-    path: Path,
-  ): RouteBuilder<Path, M, readonly [], {}, {}, TAppContext>;
-  <
-    const Path extends RoutePath,
-    TQuery = unknown,
-    TParams = unknown,
-    TBody = unknown,
-    TQueryIn = unknown,
-    TParamsIn = unknown,
-    TBodyIn = unknown,
-  >(
-    path: Path,
-    options: WithBodyOptions<TQuery, TParams, TBody, TQueryIn, TParamsIn, TBodyIn>,
-  ): RouteBuilder<
-    Path,
-    M,
-    readonly [],
-    {
-      query: TQuery;
-      params: TParams;
-      body: TBody;
-      queryIn: TQueryIn;
-      paramsIn: TParamsIn;
-      bodyIn: TBodyIn;
-    },
-    {},
-    TAppContext
-  >;
-};
-
-export type CreateAnyRoute<TAppContext extends Record<string, unknown> = AppContext> = {
-  <const Path extends RoutePath, const Methods extends readonly HttpMethod[]>(
-    path: Path,
-    methods: Methods,
-  ): RouteBuilder<Path, Methods[number], readonly [], {}, {}, TAppContext>;
-  <
-    const Path extends RoutePath,
-    const Methods extends readonly HttpMethod[],
-    TQuery = unknown,
-    TParams = unknown,
-    TBody = unknown,
-    TQueryIn = unknown,
-    TParamsIn = unknown,
-    TBodyIn = unknown,
-  >(
-    path: Path,
-    methods: Methods,
-    options: WithBodyOptions<TQuery, TParams, TBody, TQueryIn, TParamsIn, TBodyIn>,
-  ): RouteBuilder<
-    Path,
-    Methods[number],
-    readonly [],
-    {
-      query: TQuery;
-      params: TParams;
-      body: TBody;
-      queryIn: TQueryIn;
-      paramsIn: TParamsIn;
-      bodyIn: TBodyIn;
-    },
-    {},
-    TAppContext
-  >;
-};
-
-export type CreateAllRoute<TAppContext extends Record<string, unknown> = AppContext> = {
-  <const Path extends RoutePath>(
-    path: Path,
-  ): RouteBuilder<Path, HttpMethod, readonly [], {}, {}, TAppContext>;
-  <
-    const Path extends RoutePath,
-    TQuery = unknown,
-    TParams = unknown,
-    TBody = unknown,
-    TQueryIn = unknown,
-    TParamsIn = unknown,
-    TBodyIn = unknown,
-  >(
-    path: Path,
-    options: WithBodyOptions<TQuery, TParams, TBody, TQueryIn, TParamsIn, TBodyIn>,
-  ): RouteBuilder<
-    Path,
-    HttpMethod,
-    readonly [],
-    {
-      query: TQuery;
-      params: TParams;
-      body: TBody;
-      queryIn: TQueryIn;
-      paramsIn: TParamsIn;
-      bodyIn: TBodyIn;
-    },
-    {},
-    TAppContext
-  >;
-};
+> = <const Path extends RoutePath>(
+  path: Path,
+) => RouteBuilder<Path, M, readonly [], {}, {}, TAppContext>;
+
+export type CreateAnyRoute<TAppContext extends Record<string, unknown> = AppContext> = <
+  const Path extends RoutePath,
+  const Methods extends readonly HttpMethod[],
+>(
+  path: Path,
+  methods: Methods,
+) => RouteBuilder<Path, Methods[number], readonly [], {}, {}, TAppContext>;
+
+export type CreateAllRoute<TAppContext extends Record<string, unknown> = AppContext> = <
+  const Path extends RoutePath,
+>(
+  path: Path,
+) => RouteBuilder<Path, HttpMethod, readonly [], {}, {}, TAppContext>;
 
 function createWithoutBodyRoute<M extends "GET" | "DELETE" | "OPTIONS" | "HEAD">(
   method: M,
 ): CreateWithoutBodyRoute<M> {
-  return ((path: string, options?: WithoutBodyOptions<unknown, unknown>) =>
-    createRouteBuilder(path, method, options)) as unknown as CreateWithoutBodyRoute<M>;
+  return ((path: string) =>
+    createRouteBuilder(path, method)) as unknown as CreateWithoutBodyRoute<M>;
 }
 
 function createWithBodyRoute<M extends "POST" | "PUT" | "PATCH">(
   method: M,
 ): CreateWithBodyRoute<M> {
-  return ((path: string, options?: WithBodyOptions<unknown, unknown, unknown>) =>
-    createRouteBuilder(path, method, options)) as unknown as CreateWithBodyRoute<M>;
+  return ((path: string) => createRouteBuilder(path, method)) as unknown as CreateWithBodyRoute<M>;
 }
 
 export const createGetRoute = createWithoutBodyRoute("GET");
@@ -173,13 +51,8 @@ export const createPostRoute = createWithBodyRoute("POST");
 export const createPutRoute = createWithBodyRoute("PUT");
 export const createPatchRoute = createWithBodyRoute("PATCH");
 
-export const createAnyRoute: CreateAnyRoute = ((
-  path: string,
-  methods: readonly HttpMethod[],
-  options?: WithBodyOptions<unknown, unknown, unknown>,
-) => createRouteBuilder(path, "ANY", options, methods)) as unknown as CreateAnyRoute;
+export const createAnyRoute: CreateAnyRoute = ((path: string, methods: readonly HttpMethod[]) =>
+  createRouteBuilder(path, "ANY", methods)) as unknown as CreateAnyRoute;
 
-export const createAllRoute: CreateAllRoute = ((
-  path: string,
-  options?: WithBodyOptions<unknown, unknown, unknown>,
-) => createRouteBuilder(path, "ALL", options)) as unknown as CreateAllRoute;
+export const createAllRoute: CreateAllRoute = ((path: string) =>
+  createRouteBuilder(path, "ALL")) as unknown as CreateAllRoute;

package/src/builder/route.ts

@@ -5,6 +5,7 @@ import {
   mergeReturnsMaps,
   withAuto422,
 } from "@taserjs/router-utils";
+import type { BodyMode } from "@taserjs/router-core";
 
 import type {
   Method,
@@ -12,6 +13,7 @@ import type {
   RoutePath,
   ReturnsMap,
   ValidatorParts,
+  Schema,
 } from "../types/index.js";
 import type { HttpMethod, MiddlewareDefinition } from "../types/units.js";
 import { isHandlerUnit } from "../types/units.js";
@@ -75,15 +77,36 @@ function buildRouteBase(
 export function createRouteBuilder(
   path: string,
   method: HttpMethod | "ANY" | "ALL",
-  validators: SchemaValidators = {},
   methods?: readonly HttpMethod[],
 ): RouteBuilder<RoutePath, Method, readonly [], ValidatorParts> {
   const middlewares: MiddlewareDefinition[] = [];
   let routeReturns: Record<number, StandardSchemaV1> = {};
+  const validators: SchemaValidators = {};
+  let bodyMode: BodyMode | undefined;
 
   const builder = {
     path,
     method,
+    query(schema: Schema<unknown>) {
+      validators.query = schema;
+      return builder;
+    },
+    params(schema: Schema<unknown>) {
+      validators.params = schema;
+      return builder;
+    },
+    body(modeOrSchema: BodyMode | Schema<unknown>, schema?: Schema<unknown>) {
+      if (typeof modeOrSchema === "string") {
+        bodyMode = modeOrSchema as BodyMode;
+        if (schema !== undefined) {
+          validators.body = schema;
+        }
+      } else {
+        bodyMode = "json";
+        validators.body = modeOrSchema;
+      }
+      return builder;
+    },
     returns(map: ReturnsMap) {
       routeReturns = { ...routeReturns, ...toUtilsMap(map) };
       return builder;
@@ -129,6 +152,7 @@ export function createRouteBuilder(
         handler: unit.handler,
         ...routeSchemas,
         ...handlerSchemas,
+        ...(bodyMode ? { bodyMode } : {}),
         ...(returns ? { returns } : {}),
       };
     },

package/src/builder/router.ts

@@ -1,5 +1,4 @@
 import {
-  createTaserCompatHandler,
   createTaserRuntime,
   type NotFoundHandler,
   type OnErrorHandler,
@@ -19,22 +18,11 @@ import {
   createPutRoute,
 } from "./factories.js";
 import { defineHandler } from "../define/handler.js";
-import {
-  defineMiddleware,
-  type DefineMiddlewareOptions,
-  type MultiScopedMiddlewareOptions,
-  type ScopedMiddlewareOptions,
-} from "../define/middleware.js";
+import { defineMiddleware, type DefineMiddlewareFn } 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 { 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";
@@ -60,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">>) {
@@ -74,9 +65,9 @@ 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 ReturnsMap = ReturnsMap>(
@@ -86,9 +77,11 @@ export class TaserRouter<TAppContext extends Record<string, unknown> = AppContex
     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<
@@ -139,145 +132,17 @@ export class TaserRouter<TAppContext extends Record<string, unknown> = AppContex
       : 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);
-  }
+  defineMiddleware: DefineMiddlewareFn<TAppContext> =
+    defineMiddleware as DefineMiddlewareFn<TAppContext>;
 
-  create<const TManifest extends RouteManifestShape>(manifest: TManifest): TaserApp<TManifest> {
+  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;
     let bootContextResolved: Record<string, unknown> | undefined;
@@ -338,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);
 }