@taserjs/router 0.0.1 → 0.0.3

package/src/define/middleware.ts

@@ -1,289 +1,99 @@
-import type { ReplyResult } from '@taserjs/router-utils'
-import { createTaserCompatHandler } from '@taserjs/router-core'
+import { createTaserCompatHandler, type Awaitable } from "@taserjs/router-core";
 
-import type { Awaitable, ReturnsMap } from '../types/index.js'
+import type { ReturnsMap } from "../types/returns.js";
 import type {
   AppContext,
+  ExtractState,
+  IsUnknown,
   MiddlewareReturnFromParts,
   MiddlewareUnit,
+  NextFn,
   StandaloneMiddlewareContext,
-} from '../types/units.js'
-import type { Schema } from '../types/schema.js'
+} from "../types/units.js";
+import type { Schema } from "../types/schema.js";
 
-type HonoMiddlewareHandler = Parameters<typeof createTaserCompatHandler>[0]
+type HonoMiddlewareHandler = Parameters<typeof createTaserCompatHandler>[0];
 
-type HonoMiddlewareUnit = MiddlewareUnit<
-  MiddlewareReturnFromParts<unknown, unknown, unknown, {}>
->
+type HonoMiddlewareUnit = MiddlewareUnit<MiddlewareReturnFromParts<unknown, unknown, unknown, {}>>;
 
-type MiddlewareBuilderState<
-  TQuery = unknown,
-  TParams = unknown,
-  TBody = unknown,
+export type DefineMiddlewareOptions<
   TState = unknown,
-  TCtx = unknown,
-  TReturns extends ReturnsMap = {},
-> = {
-  state?: Schema<TState>
-  ctx?: Schema<TCtx>
-  query?: Schema<TQuery>
-  params?: Schema<TParams>
-  body?: Schema<TBody>
-  returns?: TReturns
-}
-
-type FluentNext<TState, TCtx>
-  = [TState] extends [undefined]
-    ? [TCtx] extends [undefined]
-        ? () => Promise<ReplyResult>
-        : (args: { ctx: TCtx }) => Promise<ReplyResult>
-    : [TCtx] extends [undefined]
-        ? (args: { state: TState }) => Promise<ReplyResult>
-        : (args: { state: TState, ctx: TCtx }) => Promise<ReplyResult>
-
-type FluentMiddlewareBuilder<
   TQuery = unknown,
   TParams = unknown,
   TBody = unknown,
-  TState = undefined,
-  TCtx = undefined,
   TReturns extends ReturnsMap = {},
+  TQueryIn = unknown,
+  TParamsIn = unknown,
+  TBodyIn = unknown,
   TAppContext extends Record<string, unknown> = AppContext,
+  R = unknown,
 > = {
-  returns<const M extends ReturnsMap>(
-    map: M,
-  ): FluentMiddlewareBuilder<
-    TQuery,
-    TParams,
-    TBody,
-    TState,
-    TCtx,
-    Omit<TReturns, keyof M> & M,
-    TAppContext
-  >
-  handler(
-    fn: (
-      ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext>,
-      next: FluentNext<TState, TCtx>,
-    ) => Awaitable<ReplyResult | Response | unknown>,
-  ): MiddlewareUnit<
-    MiddlewareReturnFromParts<
-      TQuery,
-      TParams,
-      TBody,
-      TState extends undefined ? {} : TState,
-      TCtx extends undefined ? {} : TCtx
-    >,
-    TReturns
-  >
-}
-
-function createFluentBuilder<TAppContext extends Record<string, unknown> = AppContext>(
-  state: MiddlewareBuilderState,
-): FluentMiddlewareBuilder<unknown, unknown, unknown, undefined, undefined, {}, TAppContext> {
-  return {
-    returns(map: ReturnsMap) {
-      return createFluentBuilder<TAppContext>({
-        ...state,
-        returns: { ...(state.returns ?? {}), ...map },
-      })
-    },
-    handler(fn: (...args: never[]) => unknown) {
-      const unit = {
-        ...state,
-        handler: fn,
-        __middlewareAcc: undefined as unknown,
-        ...(state.returns ? { __returns: state.returns } : {}),
-      }
-      return unit as unknown as MiddlewareUnit<
-        MiddlewareReturnFromParts<unknown, unknown, unknown, unknown, unknown>,
-        ReturnsMap
-      >
-    },
-  } as unknown as FluentMiddlewareBuilder<unknown, unknown, unknown, undefined, undefined, {}, TAppContext>
-}
-
-export function defineMiddleware(middleware: HonoMiddlewareHandler): HonoMiddlewareUnit
-
-export function defineMiddleware<
-  TAppContext extends Record<string, unknown> = AppContext,
-  TState = unknown,
-  TCtx = unknown,
-  TQuery = unknown,
-  TParams = unknown,
-  TBody = unknown,
-  TReturns extends ReturnsMap = {},
->(
-  options: {
-    state: Schema<TState>
-    ctx: Schema<TCtx>
-    query?: Schema<TQuery>
-    params?: Schema<TParams>
-    body?: Schema<TBody>
-    returns?: TReturns
-    handler: (
-      ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext>,
-      next: (args: { state: TState, ctx: TCtx }) => Promise<ReplyResult>,
-    ) => Awaitable<ReplyResult | Response | unknown>
-  },
-): MiddlewareUnit<
-  MiddlewareReturnFromParts<TQuery, TParams, TBody, TState, TCtx>,
-  TReturns
->
+  query?: Schema<TQuery, TQueryIn>;
+  params?: Schema<TParams, TParamsIn>;
+  body?: Schema<TBody, TBodyIn>;
+  returns?: TReturns;
+  handler: (
+    ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext>,
+    next: NextFn<NoInfer<TState>>,
+  ) => Awaitable<R>;
+};
+
+export function defineMiddleware(middleware: HonoMiddlewareHandler): HonoMiddlewareUnit;
 
 export function defineMiddleware<
-  TAppContext extends Record<string, unknown> = AppContext,
   TState = unknown,
-  TQuery = unknown,
-  TParams = unknown,
-  TBody = unknown,
-  TReturns extends ReturnsMap = {},
->(
-  options: {
-    state: Schema<TState>
-    query?: Schema<TQuery>
-    params?: Schema<TParams>
-    body?: Schema<TBody>
-    returns?: TReturns
-    handler: (
-      ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext>,
-      next: (args: { state: TState }) => Promise<ReplyResult>,
-    ) => Awaitable<ReplyResult | Response | unknown>
-  },
-): MiddlewareUnit<
-  MiddlewareReturnFromParts<TQuery, TParams, TBody, TState>,
-  TReturns
->
-
-export function defineMiddleware<
   TAppContext extends Record<string, unknown> = AppContext,
-  TCtx = unknown,
   TQuery = unknown,
   TParams = unknown,
   TBody = unknown,
   TReturns extends ReturnsMap = {},
+  TQueryIn = unknown,
+  TParamsIn = unknown,
+  TBodyIn = unknown,
+  R = unknown,
 >(
-  options: {
-    ctx: Schema<TCtx>
-    query?: Schema<TQuery>
-    params?: Schema<TParams>
-    body?: Schema<TBody>
-    returns?: TReturns
-    handler: (
-      ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext>,
-      next: (args: { ctx: TCtx }) => Promise<ReplyResult>,
-    ) => Awaitable<ReplyResult | Response | unknown>
-  },
-): MiddlewareUnit<
-  MiddlewareReturnFromParts<TQuery, TParams, TBody, {}, TCtx>,
-  TReturns
->
-
-export function defineMiddleware<
-  TAppContext extends Record<string, unknown> = AppContext,
-  TQuery = unknown,
-  TParams = unknown,
-  TBody = unknown,
-  TReturns extends ReturnsMap = {},
->(
-  options: {
-    query?: Schema<TQuery>
-    params?: Schema<TParams>
-    body?: Schema<TBody>
-    returns?: TReturns
-    handler: (
-      ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext>,
-      next: () => Promise<ReplyResult>,
-    ) => Awaitable<ReplyResult | Response | unknown>
-  },
+  options: DefineMiddlewareOptions<
+    TState,
+    TQuery,
+    TParams,
+    TBody,
+    TReturns,
+    TQueryIn,
+    TParamsIn,
+    TBodyIn,
+    TAppContext,
+    R
+  >,
 ): MiddlewareUnit<
-  MiddlewareReturnFromParts<TQuery, TParams, TBody, {}>,
+  MiddlewareReturnFromParts<
+    TQuery,
+    TParams,
+    TBody,
+    IsUnknown<TState> extends true ? ExtractState<R> : TState,
+    TQueryIn,
+    TParamsIn,
+    TBodyIn
+  >,
   TReturns
->
-
-export function defineMiddleware<
-  TAppContext extends Record<string, unknown> = AppContext,
->(): FluentMiddlewareBuilder<unknown, unknown, unknown, undefined, undefined, {}, TAppContext>
-
-export function defineMiddleware<
-  TAppContext extends Record<string, unknown> = AppContext,
-  TQuery = unknown,
-  TParams = unknown,
-  TBody = unknown,
->(
-  options: {
-    query?: Schema<TQuery>
-    params?: Schema<TParams>
-    body?: Schema<TBody>
-  },
-): FluentMiddlewareBuilder<TQuery, TParams, TBody, undefined, undefined, {}, TAppContext>
-
-export function defineMiddleware<
-  TAppContext extends Record<string, unknown> = AppContext,
-  TState = unknown,
-  TQuery = unknown,
-  TParams = unknown,
-  TBody = unknown,
->(
-  options: {
-    state: Schema<TState>
-    query?: Schema<TQuery>
-    params?: Schema<TParams>
-    body?: Schema<TBody>
-  },
-): FluentMiddlewareBuilder<TQuery, TParams, TBody, TState, undefined, {}, TAppContext>
-
-export function defineMiddleware<
-  TAppContext extends Record<string, unknown> = AppContext,
-  TCtx = unknown,
-  TQuery = unknown,
-  TParams = unknown,
-  TBody = unknown,
->(
-  options: {
-    ctx: Schema<TCtx>
-    query?: Schema<TQuery>
-    params?: Schema<TParams>
-    body?: Schema<TBody>
-  },
-): FluentMiddlewareBuilder<TQuery, TParams, TBody, undefined, TCtx, {}, TAppContext>
-
-export function defineMiddleware<
-  TAppContext extends Record<string, unknown> = AppContext,
-  TState = unknown,
-  TCtx = unknown,
-  TQuery = unknown,
-  TParams = unknown,
-  TBody = unknown,
->(
-  options: {
-    state: Schema<TState>
-    ctx: Schema<TCtx>
-    query?: Schema<TQuery>
-    params?: Schema<TParams>
-    body?: Schema<TBody>
-  },
-): FluentMiddlewareBuilder<TQuery, TParams, TBody, TState, TCtx, {}, TAppContext>
-
-export function defineMiddleware(options?: unknown): unknown {
-  if (typeof options === 'function') {
-    const honoMiddleware = options as HonoMiddlewareHandler
+>;
+
+export function defineMiddleware(
+  options:
+    | HonoMiddlewareHandler
+    | DefineMiddlewareOptions<any, any, any, any, any, any, any, any, any, any>,
+): unknown {
+  if (typeof options === "function") {
+    const honoMiddleware = options as HonoMiddlewareHandler;
     return defineMiddleware({
       handler: (ctx, next) => createTaserCompatHandler(honoMiddleware)(ctx, next),
-    })
+    });
   }
 
-  if (options === undefined) {
-    return createFluentBuilder({})
-  }
-
-  if (
-    typeof options === 'object'
-    && options !== null
-    && !('handler' in options)
-  ) {
-    return createFluentBuilder(options)
-  }
+  const unit = {
+    ...options,
+    __middlewareAcc: undefined as unknown,
+    ...(options.returns ? { __returns: options.returns } : {}),
+  };
 
-  return options
+  return unit;
 }

package/src/define/validators.ts

@@ -1,22 +1,22 @@
-import type { Schema } from '../types/schema.js'
-import { SCHEMA_KEYS, type SchemaKey } from '../constants.js'
+import type { Schema } from "../types/schema.js";
+import { SCHEMA_KEYS, type SchemaKey } from "../constants.js";
 
 export type SchemaValidators = {
-  query?: Schema<unknown>
-  params?: Schema<unknown>
-  body?: Schema<unknown>
-}
+  query?: Schema<unknown>;
+  params?: Schema<unknown>;
+  body?: Schema<unknown>;
+};
 
 export function pickDefinedSchemas(
   source: SchemaValidators,
   keyMap?: Partial<Record<SchemaKey, string>>,
 ): Record<string, Schema<unknown>> {
-  const result: Record<string, Schema<unknown>> = {}
+  const result: Record<string, Schema<unknown>> = {};
   for (const key of SCHEMA_KEYS) {
-    const value = source[key]
+    const value = source[key];
     if (value !== undefined) {
-      result[keyMap?.[key] ?? key] = value
+      result[keyMap?.[key] ?? key] = value;
     }
   }
-  return result
+  return result;
 }

package/src/factories.ts

@@ -1,11 +1,11 @@
-import { createRouteBuilder } from './route.js'
-import type { RouteBuilder, RoutePath, Schema } from './types/index.js'
-import type { AppContext, HttpMethod } from './types/units.js'
+import { createRouteBuilder } from "./route.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>
-  params?: Schema<TParams, TParamsIn>
-}
+  query?: Schema<TQuery, TQueryIn>;
+  params?: Schema<TParams, TParamsIn>;
+};
 
 type WithBodyOptions<
   TQuery,
@@ -15,14 +15,16 @@ type WithBodyOptions<
   TParamsIn = unknown,
   TBodyIn = unknown,
 > = WithoutBodyOptions<TQuery, TParams, TQueryIn, TParamsIn> & {
-  body?: Schema<TBody, TBodyIn>
-}
+  body?: Schema<TBody, TBodyIn>;
+};
 
 export type CreateWithoutBodyRoute<
-  M extends 'GET' | 'DELETE' | 'OPTIONS' | 'HEAD',
+  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>(
+    path: Path,
+  ): RouteBuilder<Path, M, readonly [], {}, {}, TAppContext>;
   <
     const Path extends RoutePath,
     TQuery = unknown,
@@ -37,21 +39,23 @@ export type CreateWithoutBodyRoute<
     M,
     readonly [],
     {
-      query: TQuery
-      params: TParams
-      queryIn: TQueryIn
-      paramsIn: TParamsIn
+      query: TQuery;
+      params: TParams;
+      queryIn: TQueryIn;
+      paramsIn: TParamsIn;
     },
     {},
     TAppContext
-  >
-}
+  >;
+};
 
 export type CreateWithBodyRoute<
-  M extends 'POST' | 'PUT' | 'PATCH',
+  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>(
+    path: Path,
+  ): RouteBuilder<Path, M, readonly [], {}, {}, TAppContext>;
   <
     const Path extends RoutePath,
     TQuery = unknown,
@@ -68,23 +72,23 @@ export type CreateWithBodyRoute<
     M,
     readonly [],
     {
-      query: TQuery
-      params: TParams
-      body: TBody
-      queryIn: TQueryIn
-      paramsIn: TParamsIn
-      bodyIn: TBodyIn
+      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>
+  ): RouteBuilder<Path, Methods[number], readonly [], {}, {}, TAppContext>;
   <
     const Path extends RoutePath,
     const Methods extends readonly HttpMethod[],
@@ -103,20 +107,22 @@ export type CreateAnyRoute<TAppContext extends Record<string, unknown> = AppCont
     Methods[number],
     readonly [],
     {
-      query: TQuery
-      params: TParams
-      body: TBody
-      queryIn: TQueryIn
-      paramsIn: TParamsIn
-      bodyIn: TBodyIn
+      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>(
+    path: Path,
+  ): RouteBuilder<Path, HttpMethod, readonly [], {}, {}, TAppContext>;
   <
     const Path extends RoutePath,
     TQuery = unknown,
@@ -133,51 +139,47 @@ export type CreateAllRoute<TAppContext extends Record<string, unknown> = AppCont
     HttpMethod,
     readonly [],
     {
-      query: TQuery
-      params: TParams
-      body: TBody
-      queryIn: TQueryIn
-      paramsIn: TParamsIn
-      bodyIn: TBodyIn
+      query: TQuery;
+      params: TParams;
+      body: TBody;
+      queryIn: TQueryIn;
+      paramsIn: TParamsIn;
+      bodyIn: TBodyIn;
     },
     {},
     TAppContext
-  >
-}
+  >;
+};
 
-function createWithoutBodyRoute<M extends 'GET' | 'DELETE' | 'OPTIONS' | 'HEAD'>(
+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>
+    createRouteBuilder(path, method, options)) as unknown as CreateWithoutBodyRoute<M>;
 }
 
-function createWithBodyRoute<M extends 'POST' | 'PUT' | 'PATCH'>(
+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>
+    createRouteBuilder(path, method, options)) as unknown as CreateWithBodyRoute<M>;
 }
 
-export const createGetRoute = createWithoutBodyRoute('GET')
-export const createDeleteRoute = createWithoutBodyRoute('DELETE')
-export const createOptionsRoute = createWithoutBodyRoute('OPTIONS')
-export const createHeadRoute = createWithoutBodyRoute('HEAD')
-export const createPostRoute = createWithBodyRoute('POST')
-export const createPutRoute = createWithBodyRoute('PUT')
-export const createPatchRoute = createWithBodyRoute('PATCH')
+export const createGetRoute = createWithoutBodyRoute("GET");
+export const createDeleteRoute = createWithoutBodyRoute("DELETE");
+export const createOptionsRoute = createWithoutBodyRoute("OPTIONS");
+export const createHeadRoute = createWithoutBodyRoute("HEAD");
+export const createPostRoute = createWithBodyRoute("POST");
+export const createPutRoute = createWithBodyRoute("PUT");
+export const createPatchRoute = createWithBodyRoute("PATCH");
 
-// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
 export const createAnyRoute: CreateAnyRoute = ((
   path: string,
   methods: readonly HttpMethod[],
   options?: WithBodyOptions<unknown, unknown, unknown>,
-) => createRouteBuilder(path, 'ANY', options, methods)) as unknown as CreateAnyRoute
+) => createRouteBuilder(path, "ANY", options, methods)) as unknown as CreateAnyRoute;
 
-// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
 export const createAllRoute: CreateAllRoute = ((
   path: string,
   options?: WithBodyOptions<unknown, unknown, unknown>,
-) => createRouteBuilder(path, 'ALL', options)) as unknown as CreateAllRoute
+) => createRouteBuilder(path, "ALL", options)) as unknown as CreateAllRoute;

package/src/index.ts

@@ -1,4 +1,4 @@
-export type { RouterRegister } from './register.js'
+export type { RouterRegister } from "./register.js";
 export type {
   InferInput,
   InferOutput,
@@ -8,7 +8,7 @@ export type {
   RoutePath,
   Schema,
   Simplify,
-} from './types/index.js'
+} from "./types/index.js";
 export type {
   ContextDefinition,
   CreateContextArgs,
@@ -18,27 +18,28 @@ export type {
   OnErrorOptions,
   RouteManifestShape,
   TaserHandler,
-} from './types/app.js'
+} from "./types/app.js";
 
 export {
   isReplyResult,
   reply,
+  stream,
   ValidationError,
   validationErrorSchema,
-} from '@taserjs/router-utils'
+} from "@taserjs/router-utils";
 export type {
   ReplyBodyKind,
   ReplyOf,
   ResponseValidationFailureHandler,
   SuccessReplyData,
   SuccessStatusCode,
-} from '@taserjs/router-utils'
+} from "@taserjs/router-utils";
 
-export { createAnyRoute, createAllRoute } from './factories.js'
-export { createTaserApp, TaserRouter } from './taser-router.js'
-export { TaserApp, TaserMountedApp, TaserNativeBound } from './taser-app.js'
-export { createContext } from './create-context.js'
-export { defineHandler } from './define/handler.js'
-export { defineMiddleware } from './define/middleware.js'
+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 { defineHandler } from "./define/handler.js";
+export { defineMiddleware } from "./define/middleware.js";
 
-export type { TaserCookieJar, TaserHeaders } from '@taserjs/router-core'
+export type { TaserCookieJar, TaserHeaders } from "@taserjs/router-core";

package/src/middleware/body-limit.ts

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