@taserjs/router 0.1.12 → 0.2.0

package/src/builder/standalone.ts

@@ -1,79 +0,0 @@
-import type { AppContext, LayoutBuilder, RouteBuilder, RoutePath } from "../types/index.js";
-import type { HttpMethod } from "../types/units.js";
-import { createRouteBuilder } from "./route.js";
-import { createMiddleware } from "./middleware.js";
-import { middleware as createMiddlewareFn, type MiddlewareFn } from "../define/middleware.js";
-
-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>;
-
-export type CreateWithBodyRoute<
-  M extends "POST" | "PUT" | "PATCH" | "QUERY",
-  TAppContext extends Record<string, unknown> = AppContext,
-> = <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) =>
-    createRouteBuilder(path, method)) as unknown as CreateWithoutBodyRoute<M>;
-}
-
-function createWithBodyRoute<M extends "POST" | "PUT" | "PATCH" | "QUERY">(
-  method: M,
-): CreateWithBodyRoute<M> {
-  return ((path: string) => createRouteBuilder(path, method)) as unknown as CreateWithBodyRoute<M>;
-}
-
-export type TaserNamespace<TAppContext extends Record<string, unknown> = AppContext> = {
-  readonly get: CreateWithoutBodyRoute<"GET", TAppContext>;
-  readonly post: CreateWithBodyRoute<"POST", TAppContext>;
-  readonly put: CreateWithBodyRoute<"PUT", TAppContext>;
-  readonly patch: CreateWithBodyRoute<"PATCH", TAppContext>;
-  readonly delete: CreateWithoutBodyRoute<"DELETE", TAppContext>;
-  readonly options: CreateWithoutBodyRoute<"OPTIONS", TAppContext>;
-  readonly head: CreateWithoutBodyRoute<"HEAD", TAppContext>;
-  readonly query: CreateWithBodyRoute<"QUERY", TAppContext>;
-  readonly any: CreateAnyRoute<TAppContext>;
-  readonly all: CreateAllRoute<TAppContext>;
-  readonly layout: LayoutBuilder<TAppContext>;
-  readonly middleware: MiddlewareFn<TAppContext>;
-};
-
-export const middleware: MiddlewareFn<AppContext> = createMiddlewareFn as MiddlewareFn<AppContext>;
-
-export const t: TaserNamespace<AppContext> = {
-  get: createWithoutBodyRoute("GET"),
-  post: createWithBodyRoute("POST"),
-  put: createWithBodyRoute("PUT"),
-  patch: createWithBodyRoute("PATCH"),
-  delete: createWithoutBodyRoute("DELETE"),
-  options: createWithoutBodyRoute("OPTIONS"),
-  head: createWithoutBodyRoute("HEAD"),
-  query: createWithBodyRoute("QUERY"),
-  any: ((path: string, methods: readonly HttpMethod[]) =>
-    createRouteBuilder(path, "ANY", methods)) as unknown as CreateAnyRoute<AppContext>,
-  all: ((path: string) => createRouteBuilder(path, "ALL")) as unknown as CreateAllRoute<AppContext>,
-  layout: createMiddleware as LayoutBuilder<AppContext>,
-  middleware,
-};

package/src/context/create-context.ts

@@ -1,19 +0,0 @@
-import type { ReservedContextKey } from "@taserjs/router-core";
-
-import type { ContextDefinition } from "../types/app.js";
-
-type NoReservedKeysConstraint<
-  TBoot extends Record<string, unknown>,
-  TReq extends Record<string, unknown>,
-> = Extract<keyof TBoot | keyof TReq, ReservedContextKey> extends never ? unknown : never;
-
-export function createContext<
-  TBoot extends Record<string, unknown> = Record<string, never>,
-  TReq extends Record<string, unknown> = Record<string, never>,
->(
-  definition: ContextDefinition<TBoot, TReq> & NoReservedKeysConstraint<TBoot, TReq>,
-): ContextDefinition<TBoot, TReq> {
-  return definition;
-}
-
-export type { ContextDefinition, InferAppContext } from "../types/app.js";

package/src/define/middleware.ts

@@ -1,214 +0,0 @@
-import { createMiddlewareUnitBuilder } from "../builder/middleware-unit.js";
-import type {
-  DefineMiddlewareResult,
-  ExtractState,
-  IsUnknown,
-  MiddlewareRequirements,
-  MiddlewareUnitBuilder,
-  NextFn,
-  StandaloneMiddlewareContext,
-} from "../types/units.js";
-import type {
-  AppContext,
-  LayoutId,
-  LayoutParams,
-  ResolveLayoutMiddlewaresState,
-  ResolveLayoutsState,
-} from "../types/index.js";
-
-export interface MiddlewareFn<TAppContext extends Record<string, unknown> = AppContext> {
-  /**
-   * Defines a standalone, unscoped middleware using a short function signature.
-   *
-   * @example
-   * ```ts
-   * const auth = middleware((ctx, next) => {
-   *   return next({ user: "alice" });
-   * });
-   * ```
-   */
-  <TState = unknown, TRequires extends MiddlewareRequirements = {}, R = unknown>(
-    fn: (
-      ctx: StandaloneMiddlewareContext<unknown, unknown, unknown, TAppContext, {}, TRequires>,
-      next: NextFn<NoInfer<TState>>,
-    ) => R,
-  ): DefineMiddlewareResult<
-    unknown,
-    unknown,
-    unknown,
-    IsUnknown<TState> extends true ? ExtractState<R> : TState,
-    R,
-    unknown,
-    unknown,
-    unknown,
-    {},
-    null,
-    TRequires
-  >;
-
-  /**
-   * Constructs a fluent unscoped middleware builder, with optional explicit State generic.
-   *
-   * @example
-   * ```ts
-   * const auth = middleware<{ user: string }>()
-   *   .query(z.object({ token: z.string() }))
-   *   .body("form", z.object({ file: z.instanceof(File) }))
-   *   .returns({ 401: z.string() })
-   *   .handler(async (ctx, next) => next({ user: "alice" }));
-   * ```
-   */
-  <TState = unknown>(): MiddlewareUnitBuilder<
-    unknown,
-    unknown,
-    unknown,
-    {},
-    null,
-    {},
-    TAppContext,
-    {},
-    unknown,
-    unknown,
-    unknown,
-    TState
-  >;
-
-  /**
-   * Defines a standalone middleware scoped to a single layout branch using a short function signature.
-   */
-  <
-    const Layout extends LayoutId,
-    TState = unknown,
-    TRequires extends MiddlewareRequirements = {},
-    R = unknown,
-  >(
-    layout: Layout,
-    fn: (
-      ctx: StandaloneMiddlewareContext<
-        unknown,
-        LayoutParams<Layout>,
-        unknown,
-        TAppContext,
-        ResolveLayoutMiddlewaresState<Layout>,
-        TRequires
-      >,
-      next: NextFn<NoInfer<TState>>,
-    ) => R,
-  ): DefineMiddlewareResult<
-    unknown,
-    unknown,
-    unknown,
-    IsUnknown<TState> extends true ? ExtractState<R> : TState,
-    R,
-    unknown,
-    unknown,
-    unknown,
-    {},
-    Layout,
-    TRequires
-  >;
-
-  /**
-   * Defines a standalone middleware scoped to multiple layout branches using a short function signature.
-   */
-  <
-    const Layouts extends readonly [LayoutId, ...LayoutId[]],
-    TState = unknown,
-    TRequires extends MiddlewareRequirements = {},
-    R = unknown,
-  >(
-    layouts: Layouts,
-    fn: (
-      ctx: StandaloneMiddlewareContext<
-        unknown,
-        LayoutParams<Layouts[number]>,
-        unknown,
-        TAppContext,
-        ResolveLayoutsState<Layouts>,
-        TRequires
-      >,
-      next: NextFn<NoInfer<TState>>,
-    ) => R,
-  ): DefineMiddlewareResult<
-    unknown,
-    unknown,
-    unknown,
-    IsUnknown<TState> extends true ? ExtractState<R> : TState,
-    R,
-    unknown,
-    unknown,
-    unknown,
-    {},
-    Layouts,
-    TRequires
-  >;
-
-  /**
-   * Constructs a fluent middleware builder scoped to a single layout branch, with optional explicit State generic.
-   */
-  <const Layout extends LayoutId, TState = unknown>(
-    layout: Layout,
-  ): MiddlewareUnitBuilder<
-    unknown,
-    LayoutParams<Layout>,
-    unknown,
-    {},
-    Layout,
-    {},
-    TAppContext,
-    ResolveLayoutMiddlewaresState<Layout>,
-    unknown,
-    unknown,
-    unknown,
-    TState
-  >;
-
-  /**
-   * Constructs a fluent middleware builder scoped to multiple layout branches (branch union), with optional explicit State generic.
-   */
-  <const Layouts extends readonly [LayoutId, ...LayoutId[]], TState = unknown>(
-    layouts: Layouts,
-  ): MiddlewareUnitBuilder<
-    unknown,
-    LayoutParams<Layouts[number]>,
-    unknown,
-    {},
-    Layouts,
-    {},
-    TAppContext,
-    ResolveLayoutsState<Layouts>,
-    unknown,
-    unknown,
-    unknown,
-    TState
-  >;
-}
-
-export const middleware: MiddlewareFn<AppContext> = function middleware(
-  first?: any,
-  second?: any,
-): any {
-  if (first === undefined) {
-    return createMiddlewareUnitBuilder();
-  }
-
-  if (typeof first === "string" || Array.isArray(first)) {
-    if (typeof second === "function") {
-      return {
-        handler: second,
-        __middlewareAcc: undefined as unknown,
-        __requiredLayouts: first,
-      };
-    }
-    return createMiddlewareUnitBuilder(first);
-  }
-
-  if (typeof first === "function") {
-    return {
-      handler: first,
-      __middlewareAcc: undefined as unknown,
-    };
-  }
-
-  return createMiddlewareUnitBuilder();
-};

package/src/define/validators.ts

@@ -1,22 +0,0 @@
-import type { Schema } from "../types/schema.js";
-import { SCHEMA_KEYS, type SchemaKey } from "../builder/constants.js";
-
-export type SchemaValidators = {
-  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>> = {};
-  for (const key of SCHEMA_KEYS) {
-    const value = source[key];
-    if (value !== undefined) {
-      result[keyMap?.[key] ?? key] = value;
-    }
-  }
-  return result;
-}

package/src/middleware/hono-mw.ts

@@ -1,27 +0,0 @@
-import { createTaserCompatHandler } from "@taserjs/router-core";
-import type { MiddlewareHandler } from "hono";
-
-import type { NextFn } from "../types/units.js";
-
-/**
- * Adapts a standard Web / Hono-compatible middleware function `(c, next) => ...`
- * into a Taser.js-compatible middleware handler function `(ctx, next) => Promise<Response>`.
- *
- * @example
- * ```ts
- * import { honoMw } from "@taserjs/router";
- * import { cors } from "hono/cors";
- *
- * const app = t.get("/hello").use(honoMw(cors()));
- * // or
- * const customCors = middleware(honoMw(cors()));
- * ```
- */
-export function honoMw<TState extends Record<string, unknown> = {}>(
-  middleware: MiddlewareHandler,
-): (ctx: unknown, next: NextFn<TState>) => Promise<Response> {
-  return createTaserCompatHandler(middleware) as (
-    ctx: unknown,
-    next: NextFn<TState>,
-  ) => Promise<Response>;
-}

package/src/types/app.ts

@@ -1,48 +0,0 @@
-import type { CookieRuntimeConfig, RouteManifestShape } from "@taserjs/router-core";
-import type { ResponseValidationFailureHandler } from "@taserjs/router-utils";
-
-import type { TaserApp } from "../builder/app.js";
-import type { ReturnsMap } from "./returns.js";
-import type { Schema } from "./schema.js";
-
-export type CreateTaserAppOptions = {
-  response?: {
-    /** Validate handler replies against returns maps. Default true. */
-    validate?: boolean;
-    onValidationFailure?: ResponseValidationFailureHandler;
-  };
-  /** Global cookie defaults and signing secret. Per-call `ctx.cookies.set` options override defaults. */
-  cookies?: CookieRuntimeConfig;
-};
-
-export type ContextDefinition<
-  TBoot extends Record<string, unknown> = Record<string, never>,
-  TReq extends Record<string, unknown> = Record<string, never>,
-> = {
-  boot?: () => TBoot | Promise<TBoot>;
-  request?: (req: Request) => TReq | Promise<TReq>;
-};
-
-export type InferAppContext<
-  T extends ContextDefinition<Record<string, unknown>, Record<string, unknown>>,
-> = T extends ContextDefinition<infer TBoot, infer TReq> ? TBoot & TReq : Record<string, never>;
-
-export type OnErrorOptions<TResponses extends ReturnsMap = ReturnsMap> = {
-  responses?: TResponses;
-  handle: (error: unknown, ctx?: unknown) => Response | Promise<Response>;
-};
-
-export type InferAppManifest<TApp> =
-  TApp extends TaserApp<infer TManifest, any>
-    ? TManifest
-    : TApp extends { manifest: infer TManifest }
-      ? TManifest
-      : TApp extends RouteManifestShape
-        ? TApp
-        : never;
-
-export type { RouteManifestShape } from "@taserjs/router-core";
-
-export type { Schema };
-
-export type { TaserApp } from "../builder/app.js";