@taserjs/router 0.0.0

package/src/factories.ts

@@ -0,0 +1,183 @@
+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>
+}
+
+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
+  >
+}
+
+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
+  >
+}
+
+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>
+}
+
+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>
+}
+
+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
+
+// 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

package/src/index.ts

@@ -0,0 +1,44 @@
+export type { RouterRegister } from './register.js'
+export type {
+  InferInput,
+  InferOutput,
+  Method,
+  PathParams,
+  ReturnsMap,
+  RoutePath,
+  Schema,
+  Simplify,
+} from './types/index.js'
+export type {
+  ContextDefinition,
+  CreateContextArgs,
+  CreateTaserAppOptions,
+  InferAppContext,
+  InferAppManifest,
+  OnErrorOptions,
+  RouteManifestShape,
+  TaserHandler,
+} from './types/app.js'
+
+export {
+  isReplyResult,
+  reply,
+  ValidationError,
+  validationErrorSchema,
+} from '@taserjs/router-utils'
+export type {
+  ReplyBodyKind,
+  ReplyOf,
+  ResponseValidationFailureHandler,
+  SuccessReplyData,
+  SuccessStatusCode,
+} 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 type { TaserCookieJar, TaserHeaders } from '@taserjs/router-core'

package/src/middleware/auth.ts

@@ -0,0 +1,51 @@
+import { createTaserCompatHandler } from '@taserjs/router-core'
+import { validateSchema, ValidationError } from '@taserjs/router-utils'
+import type { MiddlewareHandler } from 'hono'
+
+import { defineMiddleware } from '../define/middleware.js'
+import type { InferOutput, Schema } from '../types/schema.js'
+import type { MiddlewareReturnFromParts, MiddlewareUnit } from '../types/units.js'
+
+export function wrapHonoMiddleware<F extends (...args: never[]) => MiddlewareHandler>(
+  honoFactory: F,
+): (...args: Parameters<F>) => MiddlewareUnit<MiddlewareReturnFromParts<unknown, unknown, unknown, {}>> {
+  return (...args) => defineMiddleware(honoFactory(...args))
+}
+
+export type JwtPayloadState<TPayload> = {
+  jwtPayload: TPayload
+}
+
+export type AuthMiddlewareUnit<TPayload> = MiddlewareUnit<
+  MiddlewareReturnFromParts<unknown, unknown, unknown, JwtPayloadState<TPayload>>
+>
+
+function asJwtPayloadStateSchema<TPayload>(
+  payloadSchema: Schema<TPayload>,
+): Schema<JwtPayloadState<InferOutput<Schema<TPayload>>>> {
+  return payloadSchema as unknown as Schema<JwtPayloadState<InferOutput<Schema<TPayload>>>>
+}
+
+export function createAuthMiddleware<TPayload>(
+  payloadSchema: Schema<TPayload>,
+  honoMw: MiddlewareHandler,
+): AuthMiddlewareUnit<InferOutput<Schema<TPayload>>> {
+  return defineMiddleware({
+    state: asJwtPayloadStateSchema(payloadSchema),
+    handler: (ctx, next) => {
+      return createTaserCompatHandler(honoMw)(ctx, async () => {
+        const payload = (ctx.var as { jwtPayload?: unknown }).jwtPayload
+        try {
+          const validated = await validateSchema(payloadSchema, payload)
+          return next({ state: { jwtPayload: validated } })
+        }
+        catch (error) {
+          if (error instanceof ValidationError) {
+            return ctx.reply.forbidden({ error: 'Forbidden', issues: error.issues })
+          }
+          throw error
+        }
+      })
+    },
+  })
+}

package/src/middleware/body-limit.ts

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

package/src/middleware/compress.ts

@@ -0,0 +1,11 @@
+import { compress as honoCompress } from 'hono/compress'
+
+import { wrapHonoMiddleware } from './auth.js'
+
+const honoCompressMiddleware = wrapHonoMiddleware(honoCompress)
+
+export function compress(...args: Parameters<typeof honoCompress>) {
+  return honoCompressMiddleware(...args)
+}
+
+export type CompressOptions = NonNullable<Parameters<typeof honoCompress>[0]>

package/src/middleware/cors.ts

@@ -0,0 +1,11 @@
+import { cors as honoCors } from 'hono/cors'
+
+import { wrapHonoMiddleware } from './auth.js'
+
+const honoCorsMiddleware = wrapHonoMiddleware(honoCors)
+
+export function cors(...args: Parameters<typeof honoCors>) {
+  return honoCorsMiddleware(...args)
+}
+
+export type CorsOptions = NonNullable<Parameters<typeof honoCors>[0]>

package/src/middleware/csrf.ts

@@ -0,0 +1,11 @@
+import { csrf as honoCsrf } from 'hono/csrf'
+
+import { wrapHonoMiddleware } from './auth.js'
+
+const honoCsrfMiddleware = wrapHonoMiddleware(honoCsrf)
+
+export function csrf(...args: Parameters<typeof honoCsrf>) {
+  return honoCsrfMiddleware(...args)
+}
+
+export type CsrfOptions = NonNullable<Parameters<typeof honoCsrf>[0]>

package/src/middleware/etag.ts

@@ -0,0 +1,11 @@
+import { etag as honoEtag } from 'hono/etag'
+
+import { wrapHonoMiddleware } from './auth.js'
+
+const honoEtagMiddleware = wrapHonoMiddleware(honoEtag)
+
+export function etag(...args: Parameters<typeof honoEtag>) {
+  return honoEtagMiddleware(...args)
+}
+
+export type EtagOptions = NonNullable<Parameters<typeof honoEtag>[0]>

package/src/middleware/jwk.ts

@@ -0,0 +1,47 @@
+import { jwk as honoJwk } from 'hono/jwk'
+
+import { createAuthMiddleware, type AuthMiddlewareUnit } from './auth.js'
+import type { InferOutput, Schema } from '../types/schema.js'
+
+export type JwkOptions = Parameters<typeof honoJwk>[0]
+
+export type JwkRequestInit = Pick<RequestInit, 'headers'>
+
+export type JwkMiddlewareOptions = JwkOptions & {
+  /** Allow `http://` JWKS URLs (local dev). Default false — requires `https://`. */
+  allowInsecure?: boolean
+}
+
+function assertJwksScheme(jwksUri: string, allowInsecure: boolean): void {
+  const scheme = new URL(jwksUri).protocol.replace(':', '')
+  if (scheme === 'https') {
+    return
+  }
+  if (scheme === 'http' && allowInsecure) {
+    return
+  }
+  throw new Error(
+    `JWKS URL must use https:// (or http:// with allowInsecure: true): "${jwksUri}"`,
+  )
+}
+
+/**
+ * JWK auth middleware. Invalid or missing tokens return **401** (Hono).
+ * Valid tokens whose payload fails `payloadSchema` return **403**.
+ * Static `jwks_uri` must use HTTPS unless `allowInsecure: true`.
+ */
+export function jwk<TPayload>(
+  payloadSchema: Schema<TPayload>,
+  options: JwkMiddlewareOptions,
+  init?: JwkRequestInit,
+): AuthMiddlewareUnit<InferOutput<Schema<TPayload>>> {
+  const jwksUri = options.jwks_uri
+  if (typeof jwksUri === 'string') {
+    assertJwksScheme(jwksUri, options.allowInsecure ?? false)
+  }
+
+  const { allowInsecure: _allowInsecure, ...honoOptions } = options
+  const safeInit = init?.headers !== undefined ? { headers: init.headers } : undefined
+
+  return createAuthMiddleware(payloadSchema, honoJwk(honoOptions, safeInit))
+}

package/src/middleware/jwt.ts

@@ -0,0 +1,18 @@
+import { jwt as honoJwt } from 'hono/jwt'
+
+import { createAuthMiddleware, type AuthMiddlewareUnit } from './auth.js'
+import type { InferOutput, Schema } from '../types/schema.js'
+
+export type JwtOptions = Parameters<typeof honoJwt>[0]
+
+/**
+ * JWT auth middleware. Invalid or missing tokens return **401** (Hono).
+ * Valid tokens whose payload fails `payloadSchema` return **403**.
+ * Use optional schema fields for intentionally optional claims.
+ */
+export function jwt<TPayload>(
+  payloadSchema: Schema<TPayload>,
+  options: JwtOptions,
+): AuthMiddlewareUnit<InferOutput<Schema<TPayload>>> {
+  return createAuthMiddleware(payloadSchema, honoJwt(options))
+}

package/src/middleware/secure-headers.ts

@@ -0,0 +1,11 @@
+import { secureHeaders as honoSecureHeaders } from 'hono/secure-headers'
+
+import { wrapHonoMiddleware } from './auth.js'
+
+const honoSecureHeadersMiddleware = wrapHonoMiddleware(honoSecureHeaders)
+
+export function secureHeaders(...args: Parameters<typeof honoSecureHeaders>) {
+  return honoSecureHeadersMiddleware(...args)
+}
+
+export type SecureHeadersOptions = NonNullable<Parameters<typeof honoSecureHeaders>[0]>

package/src/middleware/timing.ts

@@ -0,0 +1,11 @@
+import { timing as honoTiming } from 'hono/timing'
+
+import { wrapHonoMiddleware } from './auth.js'
+
+const honoTimingMiddleware = wrapHonoMiddleware(honoTiming)
+
+export function timing(...args: Parameters<typeof honoTiming>) {
+  return honoTimingMiddleware(...args)
+}
+
+export type TimingOptions = NonNullable<Parameters<typeof honoTiming>[0]>

package/src/middleware.ts

@@ -0,0 +1,19 @@
+import type { LayoutId, MiddlewareBuilder } from './types/index.js'
+import type { MiddlewareDefinition } from './types/units.js'
+
+export function createMiddleware<const Layout extends LayoutId>(
+  layout: Layout,
+): MiddlewareBuilder<Layout, readonly []> {
+  const entries: MiddlewareDefinition[] = []
+
+  const chain = {
+    layout,
+    middlewares: entries,
+    use(definition: MiddlewareDefinition) {
+      entries.push(definition)
+      return chain
+    },
+  }
+
+  return chain as unknown as MiddlewareBuilder<Layout, readonly []>
+}

package/src/register.ts

@@ -0,0 +1 @@
+export interface RouterRegister {}

package/src/route.ts

@@ -0,0 +1,145 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+import {
+  collectReturnsFromDefinitions,
+  hasInputSchemas,
+  mergeReturnsMaps,
+  withAuto422,
+} from '@taserjs/router-utils'
+
+import type { Method, RouteBuilder, RoutePath, ReturnsMap, ValidatorParts } from './types/index.js'
+import type { HttpMethod, MiddlewareDefinition } from './types/units.js'
+import { isHandlerUnit } from './types/units.js'
+import { HANDLER_SCHEMA_KEY_MAP } from './constants.js'
+import {
+  pickDefinedSchemas,
+  type SchemaValidators,
+} from './define/validators.js'
+
+function toUtilsMap(map: ReturnsMap | undefined): Record<number, StandardSchemaV1> {
+  if (!map) {
+    return {}
+  }
+  const out: Record<number, StandardSchemaV1> = {}
+  for (const [key, schema] of Object.entries(map)) {
+    if (schema !== undefined) {
+      out[Number(key)] = schema
+    }
+  }
+  return out
+}
+
+function buildEffectiveReturns(args: {
+  middlewareReturns: ReturnsMap
+  routeReturns: ReturnsMap
+  handlerMiddlewareReturns: ReturnsMap
+  handlerReturns: ReturnsMap | undefined
+  schemas: {
+    query?: unknown
+    params?: unknown
+    body?: unknown
+    handlerQuery?: unknown
+    handlerParams?: unknown
+    handlerBody?: unknown
+    middlewares?: readonly MiddlewareDefinition[]
+    handlerMiddlewares?: readonly MiddlewareDefinition[]
+  }
+}): Record<number, StandardSchemaV1> | undefined {
+  const merged = mergeReturnsMaps(
+    toUtilsMap(args.middlewareReturns),
+    toUtilsMap(args.routeReturns),
+    toUtilsMap(args.handlerMiddlewareReturns),
+    toUtilsMap(args.handlerReturns),
+  )
+  const with422 = withAuto422(merged, hasInputSchemas(args.schemas))
+  return Object.keys(with422).length > 0 ? with422 : undefined
+}
+
+function buildRouteBase(
+  path: string,
+  method: HttpMethod | 'ANY' | 'ALL',
+  methods: readonly HttpMethod[] | undefined,
+  middlewares: MiddlewareDefinition[],
+) {
+  return {
+    path,
+    method,
+    ...(methods ? { methods: [...methods] } : {}),
+    middlewares: [...middlewares],
+  }
+}
+
+/** Shared internal builder — not part of the public `@taserjs/router` API. */
+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 builder = {
+    path,
+    method,
+    returns(map: ReturnsMap) {
+      routeReturns = { ...routeReturns, ...toUtilsMap(map) }
+      return builder
+    },
+    use(definition: MiddlewareDefinition) {
+      middlewares.push(definition)
+      return builder
+    },
+    handler(fnOrUnit: ((ctx: unknown) => unknown) | unknown) {
+      const routeSchemas = pickDefinedSchemas(validators)
+      const base = buildRouteBase(path, method, methods, middlewares)
+
+      if (isHandlerUnit(fnOrUnit)) {
+        const handlerSchemas = pickDefinedSchemas(fnOrUnit, HANDLER_SCHEMA_KEY_MAP)
+        const returns = buildEffectiveReturns({
+          middlewareReturns: collectReturnsFromDefinitions(middlewares),
+          routeReturns: routeReturns,
+          handlerMiddlewareReturns: collectReturnsFromDefinitions(fnOrUnit.middlewares),
+          handlerReturns: fnOrUnit.returns,
+          schemas: {
+            ...validators,
+            handlerQuery: fnOrUnit.query,
+            handlerParams: fnOrUnit.params,
+            handlerBody: fnOrUnit.body,
+            middlewares,
+            handlerMiddlewares: fnOrUnit.middlewares,
+          },
+        })
+
+        return {
+          ...base,
+          handlerMiddlewares: [...fnOrUnit.middlewares],
+          handler: fnOrUnit.handler,
+          ...routeSchemas,
+          ...handlerSchemas,
+          ...(returns ? { returns } : {}),
+        }
+      }
+
+      const returns = buildEffectiveReturns({
+        middlewareReturns: collectReturnsFromDefinitions(middlewares),
+        routeReturns: routeReturns,
+        handlerMiddlewareReturns: {},
+        handlerReturns: undefined,
+        schemas: {
+          ...validators,
+          middlewares,
+        },
+      })
+
+      return {
+        ...base,
+        handlerMiddlewares: [],
+        handler: fnOrUnit as (ctx: unknown) => Response | Promise<Response>,
+        ...routeSchemas,
+        ...(returns ? { returns } : {}),
+      }
+    },
+  }
+
+  return builder as unknown as RouteBuilder<RoutePath, Method, readonly [], ValidatorParts>
+}

package/src/taser-app.ts

@@ -0,0 +1,43 @@
+import type { TaserRuntime } from '@taserjs/router-core'
+import type { RouteManifestShape } from '@taserjs/router-core'
+
+class TaserServeView {
+  constructor(protected readonly runtime: TaserRuntime) { }
+
+  fetch(request: Request, env?: unknown, executionCtx?: unknown): Promise<Response> {
+    return this.runtime.fetch(request, env, executionCtx as never)
+  }
+
+  native(native: unknown): TaserNativeBound {
+    return new TaserNativeBound(this.runtime, native)
+  }
+}
+
+export class TaserNativeBound {
+  constructor(
+    private readonly runtime: TaserRuntime,
+    private readonly boundNative: unknown,
+  ) { }
+
+  fetch(request: Request, env?: unknown, executionCtx?: unknown): Promise<Response> {
+    return this.runtime.native(this.boundNative).fetch(request, env, executionCtx as never)
+  }
+}
+
+export class TaserMountedApp extends TaserServeView { }
+
+export class TaserApp<TManifest extends RouteManifestShape = RouteManifestShape> extends TaserServeView {
+  readonly __manifest?: TManifest
+
+  constructor(runtime: TaserRuntime, manifest?: TManifest) {
+    super(runtime)
+    if (manifest !== undefined) {
+      this.__manifest = manifest
+    }
+  }
+
+  base(prefix: string): TaserMountedApp {
+    this.runtime.registerRoutePrefix(prefix)
+    return new TaserMountedApp(this.runtime)
+  }
+}