@taserjs/router 0.1.13 → 0.2.0

package/src/types/returns.ts

@@ -1,61 +0,0 @@
-import type { ReplyOf } from "@taserjs/router-utils/reply";
-import type { StatusCode } from "@taserjs/router-utils";
-
-import type { Simplify } from "./type-utils.js";
-import type { Schema } from "./schema.js";
-import type { InferOutput } from "./schema.js";
-
-export type { StatusCode };
-
-/** Status-code → Standard Schema map for route/middleware/handler outputs. */
-export type ReturnsMap = {
-  readonly [status: number]: Schema<unknown> | undefined;
-};
-
-/** Later map wins on overlapping status keys. */
-export type MergeReturns<A extends ReturnsMap, B extends ReturnsMap> = Omit<A, keyof B> & B;
-
-/** Typed reply union for statuses declared in a returns map. */
-export type ReplyFor<M extends ReturnsMap> = {
-  [S in keyof M & number]: M[S] extends Schema<unknown>
-    ? ReplyOf<S, Simplify<InferOutput<M[S]>>>
-    : never;
-}[keyof M & number];
-
-export type EmptyReturns = {};
-
-/** True when no status schemas have been declared yet. */
-export type HasReturns<M extends ReturnsMap> = [keyof M] extends [never] ? false : true;
-
-/**
- * Validate a concrete reply `R` against returns map `M`.
- * Declared statuses must match schema output; undeclared statuses stay open
- * (same rule as runtime `validateReply`).
- */
-export type ValidHandlerReply<R, M extends ReturnsMap> =
-  R extends ReplyOf<infer S, infer B>
-    ? S extends keyof M
-      ? M[S] extends Schema<unknown>
-        ? B extends Simplify<InferOutput<M[S]>>
-          ? R
-          : never
-        : R
-      : R
-    : R extends Response
-      ? R
-      : never;
-
-/**
- * Narrow a handler return so declared statuses are schema-checked without
- * breaking multi-status unions (avoids circular `R extends …<R>` constraints).
- */
-export type EnforceHandlerReply<R, M extends ReturnsMap> = [R] extends [ValidHandlerReply<R, M>]
-  ? R
-  : ValidHandlerReply<R, M>;
-
-/**
- * Expected `.handler` return type for a returns map.
- * Prefer constraining handler generics with {@link EnforceHandlerReply}.
- */
-export type HandlerReply<M extends ReturnsMap> =
-  HasReturns<M> extends true ? ReplyFor<M> | Response : Response;

package/src/types/schema.ts

@@ -1,21 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-
-import type { RequestShape } from "./type-utils.js";
-
-export type { StandardSchemaV1 } from "@standard-schema/spec";
-
-/**
- * A Standard Schema validator.
- * `TOutput` is the validated/output type; `TInput` is the pre-parse input (request shape).
- */
-export type Schema<TOutput = unknown, TInput = unknown> = StandardSchemaV1<TInput, TOutput>;
-
-/** Infers the output type from a Standard Schema. */
-export type InferOutput<S> = S extends StandardSchemaV1<unknown, infer O> ? O : never;
-
-/** Infers the input type from a Standard Schema. */
-export type InferInput<S> = S extends StandardSchemaV1<infer I, unknown> ? I : never;
-
-/** Pre-parse request shape from a Standard Schema. */
-export type SchemaRequestShape<S> =
-  S extends StandardSchemaV1<infer I, infer O> ? RequestShape<I, O> : S;

package/src/types/type-utils.ts

@@ -1,90 +0,0 @@
-import type { TaserCookieJar, TaserHeaders } from "@taserjs/router-core";
-import type { HttpMethod, HttpVerb } from "@taserjs/router-utils/http";
-
-export type Method = HttpMethod;
-export type { HttpMethod, HttpVerb };
-
-export type MiddlewareFieldName = "query" | "params" | "body" | "state";
-
-export type MiddlewareInputFieldName = "query" | "params" | "body";
-
-export type UnwrapPart<T> = unknown extends T ? {} : T;
-
-export type MergePart<T, Base> = unknown extends T ? Base : Base & T;
-
-/** Collapse intersections so `Omit`/`keyof` treat the result as one object type. */
-export type Simplify<T> = [T] extends [infer U] ? { [K in keyof U]: U[K] } : never;
-
-/**
- * Request prop: when schema input is `unknown` (e.g. zod coerce),
- * fall back to the validated output type.
- */
-type RequestPropType<TIn, TOut> = [unknown] extends [Exclude<TIn, undefined>] ? TOut : TIn;
-
-/**
- * Pre-parse request shape. Prefer input types (defaults → optional),
- * but replace `unknown` input props with output types.
- */
-export type RequestShape<TIn, TOut> = unknown extends TIn
-  ? UnwrapPart<TOut>
-  : Simplify<{
-      [K in keyof TIn]: K extends keyof TOut ? RequestPropType<TIn[K], TOut[K]> : TIn[K];
-    }>;
-
-export type UnionToIntersection<U> = (U extends unknown ? (value: U) => void : never) extends (
-  value: infer Value,
-) => void
-  ? Value
-  : never;
-
-export type MiddlewareField<Middleware, Field extends MiddlewareFieldName> = Field extends "query"
-  ? Middleware extends { query: infer Query }
-    ? Query
-    : {}
-  : Field extends "params"
-    ? Middleware extends { params: infer Params }
-      ? Params
-      : {}
-    : Field extends "body"
-      ? Middleware extends { body: infer Body }
-        ? Body
-        : {}
-      : Field extends "state"
-        ? Middleware extends { state: infer State }
-          ? State
-          : {}
-        : {};
-
-export type MiddlewareInputField<
-  Middleware,
-  Field extends MiddlewareInputFieldName,
-> = Middleware extends { input: { [K in Field]: infer V } } ? V : {};
-
-export type MergeMiddlewareField<
-  Middlewares extends readonly unknown[],
-  Field extends MiddlewareFieldName,
-> = Middlewares extends readonly []
-  ? {}
-  : Middlewares extends readonly [infer Head, ...infer Tail]
-    ? MiddlewareField<Head, Field> & MergeMiddlewareField<Tail, Field>
-    : MiddlewareField<Middlewares[number], Field>;
-
-export type MergeMiddlewareInputField<
-  Middlewares extends readonly unknown[],
-  Field extends MiddlewareInputFieldName,
-> = Middlewares extends readonly []
-  ? {}
-  : Middlewares extends readonly [infer Head, ...infer Tail]
-    ? MiddlewareInputField<Head, Field> & MergeMiddlewareInputField<Tail, Field>
-    : MiddlewareInputField<Middlewares[number], Field>;
-
-export type RuntimeContextFields = {
-  request: Request;
-  method: Method;
-  url: URL;
-  headers: TaserHeaders;
-  cookies: TaserCookieJar;
-  var: Record<string, unknown>;
-};
-
-export type UnitRuntimeContext = Omit<RuntimeContextFields, "var">;

package/src/types/units.ts

@@ -1,314 +0,0 @@
-import type {
-  MiddlewareDefinition as CoreMiddlewareDefinition,
-  TaserCookieJar,
-  TaserHeaders,
-} from "@taserjs/router-core";
-
-import type { RequestShape, Simplify, UnitRuntimeContext, UnwrapPart } from "./type-utils.js";
-import type { ReturnsMap } from "./returns.js";
-import type { Schema } from "./schema.js";
-
-export type { HttpMethod, Method } from "./type-utils.js";
-export type {
-  EmptyReturns,
-  MergeReturns,
-  ReturnsMap,
-  HandlerReply,
-  HasReturns,
-  StatusCode,
-  ValidHandlerReply,
-  EnforceHandlerReply,
-} from "./returns.js";
-
-/** Default empty app context for standalone units without a bound router instance. */
-export type EmptyAppContext = Record<never, never>;
-
-export type ValidatorParts = {
-  query?: unknown;
-  params?: unknown;
-  body?: unknown;
-  queryIn?: unknown;
-  paramsIn?: unknown;
-  bodyIn?: unknown;
-};
-
-export declare const StateBrand: unique symbol;
-
-export type NextResult<TState = unknown> = Response & {
-  readonly [StateBrand]?: TState;
-};
-
-export type ExtractStateFromUnion<T> = T extends { readonly [StateBrand]?: infer S }
-  ? [S] extends [never]
-    ? never
-    : [unknown] extends [S]
-      ? {}
-      : S
-  : never;
-
-export type ExtractState<T> = [ExtractStateFromUnion<Awaited<T>>] extends [never]
-  ? {}
-  : ExtractStateFromUnion<Awaited<T>>;
-
-export type IsUnknown<T> = [unknown] extends [T] ? true : false;
-
-export type NextFn<TExpectedState = unknown> =
-  IsUnknown<TExpectedState> extends true
-    ? <S extends Record<string, unknown> = {}>(state?: S) => Promise<NextResult<S>>
-    : (state: TExpectedState) => Promise<NextResult<TExpectedState>>;
-
-export type MiddlewareDefinition = CoreMiddlewareDefinition<ReturnsMap>;
-
-export type MiddlewareReturnFromParts<
-  TQuery,
-  TParams,
-  TBody,
-  TState,
-  TQueryIn = TQuery,
-  TParamsIn = TParams,
-  TBodyIn = TBody,
-> = {
-  query: UnwrapPart<TQuery>;
-  params: UnwrapPart<TParams>;
-  body: UnwrapPart<TBody>;
-  state: UnwrapPart<TState>;
-  /** Pre-parse shapes merged into route `$Infer.Input`. */
-  input: {
-    query: RequestShape<TQueryIn, TQuery>;
-    params: RequestShape<TParamsIn, TParams>;
-    body: RequestShape<TBodyIn, TBody>;
-  };
-};
-
-export type MiddlewareRequirements = {
-  query?: Record<string, unknown>;
-  params?: Record<string, unknown>;
-  body?: unknown;
-  state?: Record<string, unknown>;
-};
-
-export type DefineMiddlewareResult<
-  TQuery,
-  TParams,
-  TBody,
-  TState,
-  R,
-  TQueryIn = TQuery,
-  TParamsIn = TParams,
-  TBodyIn = TBody,
-  TReturns extends ReturnsMap = {},
-  TLayout = null,
-  TRequires extends MiddlewareRequirements = {},
-> = MiddlewareUnit<
-  MiddlewareReturnFromParts<
-    TQuery,
-    TParams,
-    TBody,
-    IsUnknown<TState> extends true ? ExtractState<R> : TState,
-    TQueryIn,
-    TParamsIn,
-    TBodyIn
-  >,
-  TReturns,
-  TLayout,
-  TRequires
->;
-
-export type StandaloneMiddlewareContext<
-  TQuery = unknown,
-  TParams = unknown,
-  TBody = unknown,
-  TAppContext extends Record<string, unknown> = EmptyAppContext,
-  TState = {},
-  TRequires extends MiddlewareRequirements = {},
-> = Simplify<
-  TAppContext &
-    UnitRuntimeContext & {
-      query: Simplify<
-        UnwrapPart<TQuery> &
-          (TRequires["query"] extends Record<string, unknown> ? TRequires["query"] : {})
-      >;
-      params: Simplify<
-        UnwrapPart<TParams> &
-          (TRequires["params"] extends Record<string, unknown> ? TRequires["params"] : {})
-      >;
-      body: Simplify<
-        UnwrapPart<TBody> &
-          (unknown extends TRequires["body"]
-            ? {}
-            : [TRequires["body"]] extends [undefined]
-              ? {}
-              : TRequires["body"])
-      >;
-      state: Simplify<
-        UnwrapPart<TState> &
-          (TRequires["state"] extends Record<string, unknown> ? TRequires["state"] : {})
-      >;
-      headers: TaserHeaders;
-      cookies: TaserCookieJar;
-    }
->;
-
-export declare const MiddlewareUnitBrand: unique symbol;
-
-export type MiddlewareUnit<
-  TAcc = unknown,
-  TReturns extends ReturnsMap = {},
-  TRequiredLayouts = unknown,
-  TRequires extends MiddlewareRequirements = {},
-> = MiddlewareDefinition & {
-  readonly [MiddlewareUnitBrand]: true;
-  readonly __middlewareAcc: TAcc;
-  readonly __returns?: TReturns;
-  readonly __requiredLayouts?: TRequiredLayouts;
-  readonly __requirements?: TRequires;
-};
-
-export type MiddlewareUnitBuilder<
-  TQuery = unknown,
-  TParams = unknown,
-  TBody = unknown,
-  TReturns extends ReturnsMap = {},
-  TRequiredLayouts = unknown,
-  TRequires extends MiddlewareRequirements = {},
-  TAppContext extends Record<string, unknown> = EmptyAppContext,
-  TInheritedState = {},
-  TQueryIn = unknown,
-  TParamsIn = unknown,
-  TBodyIn = unknown,
-  TExpectedState = unknown,
-> = MiddlewareUnit<
-  MiddlewareReturnFromParts<
-    TQuery,
-    TParams,
-    TBody,
-    IsUnknown<TExpectedState> extends true ? {} : TExpectedState,
-    TQueryIn,
-    TParamsIn,
-    TBodyIn
-  >,
-  TReturns,
-  TRequiredLayouts,
-  TRequires
-> & {
-  query<Q, QIn = unknown>(
-    schema: Schema<Q, QIn>,
-  ): MiddlewareUnitBuilder<
-    Q,
-    TParams,
-    TBody,
-    TReturns,
-    TRequiredLayouts,
-    TRequires,
-    TAppContext,
-    TInheritedState,
-    QIn,
-    TParamsIn,
-    TBodyIn,
-    TExpectedState
-  >;
-  params<P, PIn = unknown>(
-    schema: Schema<P, PIn>,
-  ): MiddlewareUnitBuilder<
-    TQuery,
-    P,
-    TBody,
-    TReturns,
-    TRequiredLayouts,
-    TRequires,
-    TAppContext,
-    TInheritedState,
-    TQueryIn,
-    PIn,
-    TBodyIn,
-    TExpectedState
-  >;
-  body<B, BIn = unknown>(
-    schema: Schema<B, BIn>,
-  ): MiddlewareUnitBuilder<
-    TQuery,
-    TParams,
-    B,
-    TReturns,
-    TRequiredLayouts,
-    TRequires,
-    TAppContext,
-    TInheritedState,
-    TQueryIn,
-    TParamsIn,
-    BIn,
-    TExpectedState
-  >;
-  body<Mode extends "json" | "form" | "urlencoded", B, BIn = unknown>(
-    mode: Mode,
-    schema: Schema<B, BIn>,
-  ): MiddlewareUnitBuilder<
-    TQuery,
-    TParams,
-    B,
-    TReturns,
-    TRequiredLayouts,
-    TRequires,
-    TAppContext,
-    TInheritedState,
-    TQueryIn,
-    TParamsIn,
-    BIn,
-    TExpectedState
-  >;
-  returns<const M extends ReturnsMap>(
-    map: M,
-  ): MiddlewareUnitBuilder<
-    TQuery,
-    TParams,
-    TBody,
-    Omit<TReturns, keyof M> & M,
-    TRequiredLayouts,
-    TRequires,
-    TAppContext,
-    TInheritedState,
-    TQueryIn,
-    TParamsIn,
-    TBodyIn,
-    TExpectedState
-  >;
-  requires<Requires extends MiddlewareRequirements>(): MiddlewareUnitBuilder<
-    TQuery,
-    TParams,
-    TBody,
-    TReturns,
-    TRequiredLayouts,
-    TRequires & Requires,
-    TAppContext,
-    TInheritedState,
-    TQueryIn,
-    TParamsIn,
-    TBodyIn,
-    TExpectedState
-  >;
-  handler<R>(
-    fn: (
-      ctx: StandaloneMiddlewareContext<
-        TQuery,
-        TParams,
-        TBody,
-        TAppContext,
-        TInheritedState,
-        TRequires
-      >,
-      next: NextFn<TExpectedState>,
-    ) => R,
-  ): DefineMiddlewareResult<
-    TQuery,
-    TParams,
-    TBody,
-    IsUnknown<TExpectedState> extends true ? ExtractState<R> : TExpectedState,
-    R,
-    TQueryIn,
-    TParamsIn,
-    TBodyIn,
-    TReturns,
-    TRequiredLayouts,
-    TRequires
-  >;
-};