@taserjs/router 0.0.2 → 0.0.4

package/src/define/middleware.ts

@@ -1,289 +1,289 @@
-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 {
+  LayoutId,
+  ResolveLayoutMiddlewaresState,
+  ResolveLayoutsState,
+} from "../types/index.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, {}>
->
+  MiddlewareReturnFromParts<unknown, unknown, unknown, {}>,
+  {},
+  null,
+  {}
+>;
 
-type MiddlewareBuilderState<
+export type DefineMiddlewareOptions<
+  TState = unknown,
+  TRequires = {},
   TQuery = unknown,
   TParams = unknown,
   TBody = unknown,
-  TState = unknown,
-  TCtx = unknown,
   TReturns extends ReturnsMap = {},
+  TQueryIn = unknown,
+  TParamsIn = unknown,
+  TBodyIn = unknown,
+  TAppContext extends Record<string, unknown> = AppContext,
+  R = unknown,
 > = {
-  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>
+  query?: Schema<TQuery, TQueryIn>;
+  params?: Schema<TParams, TParamsIn>;
+  body?: Schema<TBody, TBodyIn>;
+  returns?: TReturns;
+  handler: (
+    ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext, TRequires>,
+    next: NextFn<NoInfer<TState>>,
+  ) => Awaitable<R>;
+};
 
-type FluentMiddlewareBuilder<
+export type ScopedMiddlewareOptions<
+  Layout extends LayoutId,
+  TState = unknown,
+  TRequires = {},
   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<
+  query?: Schema<TQuery, TQueryIn>;
+  params?: Schema<TParams, TParamsIn>;
+  body?: Schema<TBody, TBodyIn>;
+  returns?: TReturns;
+  handler: (
+    ctx: StandaloneMiddlewareContext<
       TQuery,
       TParams,
       TBody,
-      TState extends undefined ? {} : TState,
-      TCtx extends undefined ? {} : TCtx
+      TAppContext,
+      ResolveLayoutMiddlewaresState<Layout> & TRequires
     >,
-    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>
-}
+    next: NextFn<NoInfer<TState>>,
+  ) => Awaitable<R>;
+};
 
-export function defineMiddleware(middleware: HonoMiddlewareHandler): HonoMiddlewareUnit
-
-export function defineMiddleware<
-  TAppContext extends Record<string, unknown> = AppContext,
+export type MultiScopedMiddlewareOptions<
+  Layouts extends readonly LayoutId[],
   TState = unknown,
-  TCtx = unknown,
+  TRequires = {},
   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
->
-
-export function defineMiddleware<
+  TQueryIn = unknown,
+  TParamsIn = unknown,
+  TBodyIn = unknown,
   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
->
+  R = unknown,
+> = {
+  query?: Schema<TQuery, TQueryIn>;
+  params?: Schema<TParams, TParamsIn>;
+  body?: Schema<TBody, TBodyIn>;
+  returns?: TReturns;
+  handler: (
+    ctx: StandaloneMiddlewareContext<
+      TQuery,
+      TParams,
+      TBody,
+      TAppContext,
+      ResolveLayoutsState<Layouts> & TRequires
+    >,
+    next: NextFn<NoInfer<TState>>,
+  ) => Awaitable<R>;
+};
+
+export function defineMiddleware(middleware: HonoMiddlewareHandler): HonoMiddlewareUnit;
 
 export function defineMiddleware<
+  const Layout extends LayoutId,
+  TState = unknown,
+  TRequires = {},
   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>
-  },
+  layout: Layout,
+  options: ScopedMiddlewareOptions<
+    Layout,
+    TState,
+    TRequires,
+    TQuery,
+    TParams,
+    TBody,
+    TReturns,
+    TQueryIn,
+    TParamsIn,
+    TBodyIn,
+    TAppContext,
+    R
+  >,
 ): MiddlewareUnit<
-  MiddlewareReturnFromParts<TQuery, TParams, TBody, {}, TCtx>,
-  TReturns
->
+  MiddlewareReturnFromParts<
+    TQuery,
+    TParams,
+    TBody,
+    IsUnknown<TState> extends true ? ExtractState<R> : TState,
+    TQueryIn,
+    TParamsIn,
+    TBodyIn
+  >,
+  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,
 >(
-  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>
-  },
+  layouts: Layouts,
+  options: MultiScopedMiddlewareOptions<
+    Layouts,
+    TState,
+    TRequires,
+    TQuery,
+    TParams,
+    TBody,
+    TReturns,
+    TQueryIn,
+    TParamsIn,
+    TBodyIn,
+    TAppContext,
+    R
+  >,
 ): MiddlewareUnit<
-  MiddlewareReturnFromParts<TQuery, TParams, TBody, {}>,
-  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>
+  MiddlewareReturnFromParts<
+    TQuery,
+    TParams,
+    TBody,
+    IsUnknown<TState> extends true ? ExtractState<R> : TState,
+    TQueryIn,
+    TParamsIn,
+    TBodyIn
+  >,
+  TReturns,
+  Layouts,
+  TRequires
+>;
 
 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<
+  TRequires = {},
   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>
-  },
-): FluentMiddlewareBuilder<TQuery, TParams, TBody, undefined, TCtx, {}, TAppContext>
+  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
+>;
 
-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(
+  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 {
+  if (typeof first === "string" || Array.isArray(first)) {
+    const options = second!;
+    const unit = {
+      ...options,
+      __middlewareAcc: undefined as unknown,
+      ...(options?.returns ? { __returns: options.returns } : {}),
+      __requiredLayouts: first,
+    };
+    return unit;
+  }
 
-export function defineMiddleware(options?: unknown): unknown {
-  if (typeof options === 'function') {
-    const honoMiddleware = options as HonoMiddlewareHandler
+  if (typeof first === "function") {
+    const honoMiddleware = first 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 options = first as DefineMiddlewareOptions<
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any
+  >;
+  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;
 }