@forinda/kickjs 8.2.1 → 8.3.0

package/dist/application-DIxWiYOw.d.mts

@@ -1,496 +0,0 @@
-
-import { t as Container } from "./container-Dpvd66Yt.mjs";
-import { m as ContributorRegistrations, r as AppModuleEntry } from "./app-module-DyqiS9rQ.mjs";
-import { b as RuntimeCapabilities, f as HttpRuntime, lt as KickPlugin, r as AppAdapter, s as ActiveRuntime, ut as ModuleRegistry, x as RuntimeResponse } from "./adapter-CvHtIu8A.mjs";
-import http from "node:http";
-import { Express, RequestHandler } from "express";
-//#region src/http/application.d.ts
-/**
- * A middleware entry in the declarative pipeline.
- * Can be a bare handler or an object with path scoping.
- */
-type MiddlewareEntry = RequestHandler | {
-  path: string;
-  handler: RequestHandler;
-};
-/** Options for {@link Application.shutdown}. */
-interface ShutdownOptions {
-  /**
-   * Close the HTTP server and drain in-flight requests. Default `true`.
-   *
-   * Set `false` for a dev HMR rebuild, where the server is shared across
-   * reloads — adapters, plugins, and disposables are still torn down, which is
-   * the part a reload needs.
-   */
-  closeServer?: boolean;
-}
-interface ApplicationOptions {
-  /**
-   * Feature modules to load. Accepts both class form
-   * (`SomeModule extends AppModule`, instantiated via `new`) and
-   * instance form (output of {@link defineModule}'s factory call,
-   * e.g. `TasksModule({ scope: 'admin' })`) — the loader discriminates
-   * and either `new`-s the class or uses the instance directly.
-   *
-   * Static path — for conditional / dynamic registration, use the
-   * {@link ApplicationOptions.setup} callback instead.
-   */
-  modules: AppModuleEntry[];
-  /**
-   * Imperative module registration callback. Receives a
-   * {@link ModuleRegistry} you call `.mount(module)` on to register
-   * modules conditionally — based on env flags, runtime config, a
-   * tenant list, etc. Runs after every plugin's `setup()` hook and
-   * after the static `modules: [...]` array is collected.
-   *
-   * @example
-   * ```ts
-   * bootstrap({
-   *   modules: [HelloModule()],
-   *   setup(registry) {
-   *     if (env.ENABLE_ADMIN) registry.mount(AdminModule())
-   *   },
-   * })
-   * ```
-   */
-  setup?(registry: ModuleRegistry): void;
-  /** Adapters that hook into the lifecycle (DB, Redis, Swagger, etc.) */
-  adapters?: AppAdapter[];
-  /** Server port (falls back to PORT env var, then 3000) */
-  port?: number;
-  /** Global API prefix (default: '/api'). Pass `''` to mount at the root. */
-  apiPrefix?: string;
-  /**
-   * Default API version (default: 1) — routes become /{prefix}/v{version}/{path}.
-   *
-   * `false` opts out of URL versioning: routes mount at /{prefix}/{path}.
-   * A module can still version itself by setting `version` on its
-   * `ModuleRoutes` — the per-mount value always wins over this default, in
-   * either direction.
-   */
-  defaultVersion?: number | false;
-  /**
-   * Global middleware pipeline. Declared in order.
-   * Replaces the hardcoded middleware stack — you control exactly what runs.
-   *
-   * @example
-   * ```ts
-   * bootstrap({
-   *   modules,
-   *   middlewares: [
-   *     helmet(),
-   *     cors(),
-   *     compression(),
-   *     morgan('dev'),
-   *     express.json({ limit: '1mb' }),
-   *   ],
-   * })
-   * ```
-   *
-   * If omitted, a sensible default is applied:
-   *   requestId(), express.json({ limit: '100kb' })
-   */
-  middlewares?: MiddlewareEntry[];
-  /** Plugins that bundle modules, adapters, middleware, and DI bindings */
-  plugins?: KickPlugin[];
-  /**
-   * Global Context Contributors (#107) that apply to every route in the
-   * application. Merge into the per-route pipeline at the `'global'`
-   * precedence level — they lose to module, adapter, class, and method
-   * contributors with the same key, providing app-wide defaults that any
-   * narrower scope can override.
-   *
-   * @example
-   * ```ts
-   * const StartedAt = defineContextDecorator({
-   *   key: 'requestStartedAt',
-   *   resolve: () => Date.now(),
-   * })
-   *
-   * bootstrap({
-   *   modules,
-   *   contributors: [StartedAt.registration],
-   * })
-   * ```
-   */
-  contributors?: ContributorRegistrations;
-  /**
-   * Backing store strategy for {@link RequestContext} `set/get` and the
-   * Context Contributor pipeline (#107).
-   *
-   * - `'auto'` (default) — Application mounts {@link requestScopeMiddleware}
-   *   automatically before any user middleware. If the user-supplied
-   *   `middleware` list already includes `requestScopeMiddleware()`,
-   *   detection skips the auto-mount so adopters can control its position.
-   * - `'manual'` — Application never mounts the wrapper. The Context
-   *   Contributor pipeline still runs on every route — the runner is
-   *   inserted by `router-builder` regardless of ALS state. What
-   *   degrades without an ALS frame is the *backing store*:
-   *   REQUEST-scoped DI throws (no `requestStore.getStore()` to read
-   *   from) and `RequestContext.set/get` throws. Use `'manual'` only when you
-   *   genuinely intend to wrap requests in your own ALS frame (rare —
-   *   multi-tenant adapters used to do this; post-Phase 3 they share
-   *   the framework's frame instead).
-   */
-  contextStore?: 'auto' | 'manual';
-  /**
-   * Controls whether KickJS registers process-level handlers at bootstrap.
-   *
-   * - `'auto'` (default) — register `uncaughtException` /
-   *   `unhandledRejection` loggers AND `SIGINT` / `SIGTERM` →
-   *   `app.shutdown()` → `process.exit(0)`.
-   * - `'errors-only'` — register the error loggers; skip the signal
-   *   handlers. Use this when you have your own shutdown choreographer
-   *   (OpenTelemetry SDK, Sentry, custom orchestrator) that calls
-   *   `app.shutdown()` itself and you don't want two listeners racing
-   *   to call `process.exit`.
-   * - `'manual'` — skip everything. Adopter is responsible for both
-   *   error logging and signal-driven shutdown.
-   *
-   * Background: many observability SDKs install their own SIGTERM
-   * handler to flush spans/metrics before the process exits. Two
-   * separate handlers calling `process.exit(0)` race each other and
-   * can truncate the in-flight flush. Setting this to `'errors-only'`
-   * or `'manual'` lets the SDK own the lifecycle while still letting
-   * KickJS surface uncaught exceptions / rejections via the logger.
-   *
-   * The dev mode auto-detect (`__kickjs_httpServer` set by the Vite
-   * plugin) suppresses signal registration regardless of this option,
-   * since Vite owns the lifecycle in development.
-   */
-  processHooks?: 'auto' | 'errors-only' | 'manual';
-  /**
-   * The HTTP engine driver. Defaults to {@link expressRuntime} — Express stays
-   * the zero-config default, so existing apps are unaffected.
-   *
-   * Any `HttpRuntime` is accepted — pass `fastifyRuntime()` (from
-   * `@forinda/kickjs/fastify`) or a custom engine driver. Defaults to
-   * {@link expressRuntime}. The engine-native escape hatches
-   * (`getRuntimeApp()`, `AdapterContext.app`) follow the active runtime via the
-   * registry (`ActiveRuntime`, spec §4.3b) — Express by default, or the augmented
-   * engine once the `kick/runtime` typegen output is present.
-   */
-  /**
-   * Mount the built-in `GET /health/live` and `GET /health/ready`.
-   *
-   * On by default. Set `false` to take them over completely — supply your own
-   * module at `/health` and nothing collides. The built-in is registered last,
-   * so an app module claiming the same path already wins without this.
-   *
-   * They mount as an ordinary module, which means they sit inside the
-   * middleware chain: whatever guards the rest of the app guards these too.
-   * Exempt the path if your orchestrator must reach them unauthenticated.
-   */
-  health?: boolean;
-  runtime?: HttpRuntime;
-  /** Express `trust proxy` setting */
-  trustProxy?: boolean | number | string | ((ip: string, hopIndex: number) => boolean);
-  /** Maximum JSON body size (only used when middleware is not provided) */
-  jsonLimit?: string | number;
-  /**
-   * Print the route table on startup. Default: `false`. Set to `true`
-   * to log a per-controller summary (method counts + mount paths) once
-   * the app has mounted. Emitted at `info` level, so it is still subject
-   * to `LOG_LEVEL` filtering (visible at the default `info`; hidden at
-   * `warn`/`error`/`silent`).
-   */
-  logRouteTable?: boolean;
-  /**
-   * @deprecated Use {@link ApplicationOptions.logRouteTable}. Kept as an
-   * alias for back-compat; `logRouteTable` wins when both are set.
-   */
-  logRoutesTable?: boolean;
-  /**
-   * Maximum time (ms) to wait for graceful shutdown before forcing exit.
-   * Default: 30000 (30 seconds). Set to 0 to disable forced exit.
-   */
-  shutdownTimeout?: number;
-  /**
-   * Enable cluster mode for multi-core utilization.
-   *
-   * When enabled, the primary process forks worker processes that share the
-   * same port via Node's built-in `cluster` module (OS load balancing).
-   *
-   * - `true` — use all available CPU cores
-   * - `{ workers: N }` — use exactly N workers
-   *
-   * Workers are auto-restarted on crash. SIGTERM/SIGINT on the primary is
-   * forwarded to all workers.
-   *
-   * @example
-   * ```ts
-   * bootstrap({ modules, cluster: true })
-   * bootstrap({ modules, cluster: { workers: 4 } })
-   * ```
-   */
-  cluster?: boolean | {
-    workers?: number;
-  };
-  /**
-   * Custom 404 handler for unmatched routes. When omitted, the built-in
-   * handler returns `{ message: 'Not Found' }` with status 404.
-   *
-   * Connect-**shaped**, not Express-**semantic** — see {@link onError} for the
-   * per-runtime table. The same two caveats apply: `next()` is inert on
-   * Fastify and h3, and Express-only request members (`req.originalUrl`,
-   * `req.path`, `req.ip`) are `undefined` there, so read `req.url`.
-   *
-   * @example
-   * ```ts
-   * bootstrap({
-   *   modules,
-   *   onNotFound: (req, res) => {
-   *     // `req.originalUrl` is Express-only — use `req.url` for portability.
-   *     res.status(404).json({ error: 'Route not found', path: req.url })
-   *   },
-   * })
-   * ```
-   */
-  onNotFound?: (req: any, res: RuntimeResponse, next: (err?: unknown) => void) => void;
-  /**
-   * Custom global error handler, receiving `(err, req, res, next)`. When
-   * omitted, the built-in handler formats ZodError, HttpException, and
-   * unexpected errors.
-   *
-   * The shape is connect-style, but it is NOT "the standard Express error
-   * handler" on every engine — what you actually receive differs, and the
-   * differences bite:
-   *
-   * | | `req` | `res` | `next` |
-   * | --- | --- | --- | --- |
-   * | Express | native `Request` | native `Response` | real `next` |
-   * | Fastify | `request.raw` | reply driver | **no-op** |
-   * | h3 | `event.node.req` | response driver | no-op (or dev fall-through) |
-   *
-   * Two consequences worth knowing before you write one:
-   *
-   * - **`next(err)` does nothing on Fastify and h3.** It is a no-op function
-   *   there, so delegating to the default handler silently drops the error.
-   *   Send a response yourself rather than passing it on.
-   * - **Express-only request members are `undefined` elsewhere.**
-   *   `req.originalUrl`, `req.path`, and `req.ip` do not exist on the raw node
-   *   request — use `req.url` and the `x-forwarded-*` headers, or reach for
-   *   `ctx.ip` in a contributor / guard where a `RequestContext` is available.
-   *
-   * `res` is typed {@link RuntimeResponse} because that is what every engine
-   * genuinely provides: `status`, `json`, `send`, `setHeader`, `render`,
-   * `writeHead`, `end`. Express's own `Response` satisfies it.
-   *
-   * @example
-   * ```ts
-   * bootstrap({
-   *   modules,
-   *   onError: (err, req, res) => {
-   *     logger.error(err, `${req.method} ${req.url}`) // not `originalUrl`
-   *     res.status(err.status ?? 500).json({ error: err.message })
-   *   },
-   * })
-   * ```
-   */
-  onError?: (err: any, req: any, res: RuntimeResponse, next: (err?: unknown) => void) => void;
-  /**
-   * Security defaults applied automatically unless opted out.
-   *
-   * When not specified, secure defaults are applied:
-   * - Helmet security headers are auto-injected
-   * - JSON body limit defaults to 1MB
-   *
-   * @example
-   * ```ts
-   * bootstrap({
-   *   modules,
-   *   security: {
-   *     helmet: false,     // disable auto-helmet
-   *   },
-   * })
-   * ```
-   */
-  security?: {
-    /** Auto-inject helmet security headers. Default: true */
-    helmet?: boolean;
-  };
-}
-declare class Application {
-  private readonly options;
-  private app;
-  /** The HTTP engine driver. Defaults to {@link expressRuntime}. */
-  private readonly runtime;
-  private container;
-  private httpServer;
-  private readonly adapters;
-  /**
-   * Flags of every mounted route, for middleware that runs before routing and
-   * therefore cannot read `ctx.route` (the connect-style rate limiter). Handed
-   * to middleware that declares the slot — see `core/route-policy.ts`.
-   */
-  private readonly routePolicy;
-  private readonly plugins;
-  /**
-   * Snapshot of every module-level Context Contributor registration
-   * captured during `setup()`. The registrations themselves are
-   * frozen by `defineContextDecorator`, so storing references is
-   * safe — they outlive the module instances they came from.
-   *
-   * Used by {@link getContributors} so DevTools and adopter tooling
-   * can render the module-level contributors alongside the adapter /
-   * plugin / global ones. Populated once per `setup()` call; cleared
-   * at the start of each invocation so a re-setup (test harnesses,
-   * dev-server restarts) doesn't accumulate stale entries.
-   */
-  private _moduleContributors;
-  /** Number of HTTP requests currently being processed */
-  private _inFlightRequests;
-  /** Whether the application is draining (shutting down gracefully) */
-  private _draining;
-  /** Whether shutdown has already been initiated (prevents double-shutdown) */
-  private _shutdownInitiated;
-  /** Resolvers waiting for in-flight requests to reach zero */
-  private _drainResolvers;
-  constructor(options: ApplicationOptions);
-  /** Whether the application is currently draining in-flight requests */
-  get isDraining(): boolean;
-  /** Number of HTTP requests currently being processed */
-  get inFlightRequests(): number;
-  /** Get the DI container instance */
-  getContainer(): Container;
-  /**
-   * Express request handler — delegates to the internal Express app.
-   *
-   * Used by the Vite dev-server plugin to route requests through KickJS:
-   * ```ts
-   * const mod = await ssrLoadModule('virtual:kickjs/app')
-   * mod.app.handle(req, res, next)
-   * ```
-   *
-   * Also works as a standard Node.js request handler for production:
-   * ```ts
-   * http.createServer(app.handle.bind(app))
-   * ```
-   */
-  handle(req: http.IncomingMessage, res: http.ServerResponse, next?: (err?: any) => void): void;
-  /**
-   * Full setup pipeline:
-   * 1. Adapter beforeMount hooks (early routes — e.g. docs UI)
-   * 2. Adapter middleware (phase: beforeGlobal)
-   * 3. Global middleware (user-declared or defaults)
-   * 4. Adapter middleware (phase: afterGlobal)
-   * 5. Module registration + DI bootstrap (the built-in health module mounts
-   *    here with everything else — it is NOT an early route)
-   * 6. Adapter middleware (phase: beforeRoutes)
-   * 7. Module route mounting
-   * 8. Adapter middleware (phase: afterRoutes)
-   * 9. Adapter beforeStart hooks
-   * 10. Error handlers (notFound + global)
-   */
-  /** Build the adapter context object (shared across all hooks) */
-  private adapterCtx;
-  /**
-   * The engine-agnostic HTTP surface handed to adapters as `ctx.http`. Each
-   * call routes through the active runtime over the current `this.app`, so an
-   * adapter written against this works under any runtime.
-   */
-  private adapterHttp;
-  /** Call an adapter hook, awaiting async hooks and catching errors */
-  private callHook;
-  setup(): Promise<void>;
-  /** Register modules and DI without starting the HTTP server (used by kick tinker) */
-  registerOnly(): Promise<void>;
-  /**
-   * Start the HTTP server.
-   *
-   * In **dev mode** (Vite plugin active): reuses `globalThis.__kickjs_httpServer`
-   * created by Vite. Adapters (WsAdapter, Socket.IO, etc.) receive the real
-   * `http.Server` through `afterStart({ server })` — zero adapter changes needed.
-   *
-   * In **production**: creates its own `http.Server` and binds to the port.
-   */
-  start(): Promise<void>;
-  /** HMR rebuild: swap Express handler without restarting the server */
-  rebuild(): Promise<void>;
-  /**
-   * Graceful shutdown with request draining.
-   *
-   * 1. Stops accepting new connections (server.close())
-   * 2. Waits for in-flight requests to complete (up to shutdownTimeout)
-   * 3. Calls adapter.shutdown() for all registered adapters
-   * 4. Force-closes after timeout
-   *
-   * Safe to call multiple times — subsequent calls return the same promise.
-   */
-  shutdown(options?: ShutdownOptions): Promise<void>;
-  /**
-   * The engine-native app instance, typed from the active runtime
-   * ({@link ActiveRuntime} — Express by default). Prefer this over
-   * {@link getExpressApp}; under a non-Express runtime the type follows the
-   * augmented registry.
-   */
-  getRuntimeApp(): ActiveRuntime['app'];
-  /**
-   * The active HTTP runtime's identity + capabilities — `name` is `'express'`
-   * (default), `'fastify'`, or `'h3'`; `capabilities` reports what the engine
-   * supports (render / uploads / connectMiddleware / nativeBodyParsing).
-   * Surfaced by DevTools and the VS Code extension so tooling can show which
-   * engine the app is running on. Cheap, side-effect free.
-   */
-  getActiveRuntime(): {
-    name: string;
-    capabilities: RuntimeCapabilities;
-  };
-  /** @deprecated Use {@link getRuntimeApp}. Returns the engine-native app. */
-  getExpressApp(): Express;
-  /** Get registered adapters — used by DevToolsAdapter for peer discovery */
-  getAdapters(): AppAdapter[];
-  /**
-   * Get registered plugins — used by DevToolsAdapter for topology
-   * introspection (architecture.md §23). Read-only; returns the
-   * already-sorted plugin list (post-`dependsOn` topo-sort).
-   */
-  getPlugins(): readonly KickPlugin[];
-  /**
-   * Snapshot of every Context Contributor reachable from this app —
-   * walks **four** registration sites: adapters, plugins, modules,
-   * and the bootstrap `contributors` option. The devtools Topology
-   * tab consumes this for the Contributors panel; tests + adopters
-   * can call it for diagnostics.
-   *
-   * Per-route (method/class-decorator) registrations are NOT included
-   * here — they live on the route registry rather than on any of
-   * the four collection sites this method walks. A future RPC will
-   * surface them separately.
-   *
-   * Result shape stays minimal — `{ key, source, label, dependsOn }`
-   * — so we don't leak `resolve` closures or other internal fields.
-   * `source` matches the five-level precedence union from
-   * `ContributorSource` (minus `'method'` / `'class'` which require
-   * the per-route walk noted above).
-   */
-  getContributors(): ReadonlyArray<{
-    key: string;
-    source: 'module' | 'adapter' | 'plugin' | 'global';
-    label: string;
-    dependsOn: readonly string[];
-  }>;
-  getHttpServer(): http.Server | null;
-  /**
-   * Decide whether {@link Application} should auto-mount the
-   * {@link requestScopeMiddleware} ALS wrapper.
-   *
-   * Returns `false` when:
-   * - `contextStore: 'manual'` was set (caller manages ALS frames), or
-   * - the user-supplied `middleware` list already includes a
-   *   `requestScopeMiddleware()` (detected via the symbol marker stamped
-   *   in `middleware/request-scope.ts`).
-   *
-   * Otherwise `true` — preserves the historical default of "always wrap
-   * requests in an ALS frame" so existing apps see no behavior change.
-   */
-  private shouldAutoMountRequestScope;
-  private collectAdapterMiddleware;
-  private mountMiddlewareList;
-  private mountMiddlewareEntry;
-  /** Middleware that tracks in-flight requests for graceful draining */
-  private requestTrackingMiddleware;
-}
-//#endregion
-export { ShutdownOptions as i, ApplicationOptions as n, MiddlewareEntry as r, Application as t };
-//# sourceMappingURL=application-DIxWiYOw.d.mts.map

package/dist/application-DIxWiYOw.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"application-DIxWiYOw.d.mts","names":[],"sources":["../src/http/application.ts"],"mappings":";;;;;;;;;;;KA4DY,kBAAkB;EAAmB;EAAc,SAAS;;;UAGvD;;;;;;;;EAQf;;UAGe;;;;;;;;;;;EAWf,SAAS;;;;;;;;;;;;;;;;;;EAmBT,OAAO,UAAU;;EAEjB,WAAW;;EAEX;;EAEA;;;;;;;;;EASA;;;;;;;;;;;;;;;;;;;;;;EAuBA,cAAc;;EAGd,UAAU;;;;;;;;;;;;;;;;;;;;;EAsBV,eAAe;;;;;;;;;;;;;;;;;;;EAoBf;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BA;;;;;;;;;;;;;;;;;;;;;;;EAwBA;EAEA,UAAU;;EAGV,2CAA2C,YAAY;;EAEvD;;;;;;;;EAQA;;;;;EAKA;;;;;EAKA;;;;;;;;;;;;;;;;;;;EAoBA;IAAsB;;;;;;;;;;;;;;;;;;;;;;EAsBtB,cAAc,UAAU,KAAK,iBAAiB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0CrD,WAAW,UAAU,UAAU,KAAK,iBAAiB,OAAO;;;;;;;;;;;;;;;;;;EAmB5D;;IAEE;;;cAwHS;mBA0CkB;UAzCrB;;mBAES;UACT;UACA;mBACS;;;;;;mBAMA;mBAEA;;;;;;;;;;;;;UAcT;;UAMA;;UAEA;;UAEA;;UAEA;EAER,YAA6B,SAAS;;MAyClC;;MAKA;;EAKJ,gBAAgB;;;;;;;;;;;;;;;EAkBhB,OAAO,KAAK,KAAK,iBAAiB,KAAK,KAAK,gBAAgB,QAAQ;;;;;;;;;;;;;;;;UAwB5D;;;;;;UAiBA;;UA0BM;EAeR,SAAS;;EA4YT,gBAAgB;;;;;;;;;;EAahB,SAAS;;EA0ET,WAAW;;;;;;;;;;;EA8CX,SAAS,UAAS,kBAAuB;;;;;;;EAuJ/C,iBAAiB;;;;;;;;EAWjB;IAAsB;IAAc,cAAc;;;EAKlD,iBAAiB;;EAKjB,eAAe;;;;;;EASf,uBAAuB;;;;;;;;;;;;;;;;;;;EAsBvB,mBAAmB;IACjB;IACA;IACA;IACA;;EA6CF,iBAAiB,KAAK;;;;;;;;;;;;;;UAmBd;UAWA;UAmBA;UAUA;;UASA"}

package/dist/bootstrap-DCUWJRmN.d.mts

@@ -1,27 +0,0 @@
-
-import { n as ApplicationOptions, t as Application } from "./application-DIxWiYOw.mjs";
-//#region src/http/bootstrap.d.ts
-/**
- * Bootstrap a KickJS application.
- *
- * Creates the Express app, registers modules and adapters, and starts
- * the HTTP server. In dev mode (`kick dev`), the Vite plugin manages
- * the server and HMR — source changes are picked up instantly without
- * losing database connections or WebSocket state.
- *
- * @returns The {@link Application} instance.
- *
- * @example
- * ```ts
- * // src/index.ts
- * import 'reflect-metadata'
- * import { bootstrap } from '@forinda/kickjs'
- * import { modules } from './modules'
- *
- * export const app = await bootstrap({ modules })
- * ```
- */
-declare function bootstrap(options: ApplicationOptions): Promise<Application>;
-//#endregion
-export { bootstrap as t };
-//# sourceMappingURL=bootstrap-DCUWJRmN.d.mts.map

package/dist/bootstrap-DCUWJRmN.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bootstrap-DCUWJRmN.d.mts","names":[],"sources":["../src/http/bootstrap.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;iBAqCsB,UAAU,SAAS,qBAAqB,QAAQ"}

package/dist/route-flag-C6VJQ2el.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"route-flag-C6VJQ2el.d.mts","names":[],"sources":["../src/core/route-flag.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAkDiB;;;;;;;KAQL,uBAAuB,iDAEzB;;;;;KAME,eAAe,kBAAkB,sBAAsB,gBAAgB,iBAC/E,eAAe,KACf;;UAmBa;WACN;;WAEA;;;;;;;;;;;;;;UAeM;;;;;;;GAOd,QAAQ;;;;;GAKR,gBAAgB,8BAA8B,aAAa;;;UAI7C,gBAAgB;GAC9B,OAAO,KAAK,gBAAgB;;;;;;;;;WASpB,KAAK;WACL;;;;;;;;;;;KAYC,UAAU,yBAAyB,IAC3C,gBAAgB,gBAAgB,KAChC,gBAAgB;;;;;;;;;;;;;;;;;;;;;;iBA2CJ,sBAAsB,UAAU,eAC9C,MAAM,IACL,UAAU,eAAe;iBACZ,gBAAgB,GAAG,MAAM,gBAAgB,UAAU;;;;;;;;;;;iBAkEnD,kBACd,4BAA4B,wBAC5B,6BAA6B,yBAC5B;;;;;;;;;UA0Bc,mBAAmB;EAClC,IAAI,MAAM;EACV,IAAI,UAAU,eAAe,MAAM,IAAI,eAAe;;;;;;;;UASvC;WACN,OAAO;WACP;aACE;aACA;aACA;aACA;;;;;;;;;;;;;;;;KAiBD,sBAAsB,KAAK;;;;;;;;;;;;;;;;;;;;;KAsB3B,2BAA2B;;;;;;;;;;;;;;;KAgB3B,gBACR,gBACA,gCACS,2BACA,yBACT;;;;;;;;iBASY,gBACd,MAAM,eACN,OAAO,wBACP,QAAQ;;;;;;;;;;;;;;;;;;;iBA4FM,cAAc,yBAAyB,sBAAsB"}

package/dist/route-flag-DTfTiScc.mjs

@@ -1,12 +0,0 @@
-/**
- * @forinda/kickjs v8.2.1
- *
- * Copyright (c) Felix Orinda
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @license MIT
- */
-import{METADATA}from"./core/interfaces.mjs";import{a as getMethodMeta,c as pushClassMeta,l as pushMethodMeta,t as getClassMeta}from"./metadata-C-9GVv_0.mjs";const FLAG_UNSET=Symbol(`kick.flagUnset`);function isDecoratorApplication(args){let[target,propertyKey]=args;return typeof propertyKey==`string`||typeof propertyKey==`symbol`||args.length===1&&typeof target==`function`}function defineRouteFlag(name){if(name.startsWith(`!`))throw Error(`defineRouteFlag('${name}'): a flag name cannot start with '!' — that prefix is reserved for negated tests ('!${name.slice(1)}' means "does not carry ${name.slice(1)}"). Rename the flag.`);function apply(value,target,propertyKey){let declaration={name,value};if(propertyKey===void 0){pushClassMeta(METADATA.CLASS_FLAGS,target,declaration);return}pushMethodMeta(METADATA.METHOD_FLAGS,target.constructor,String(propertyKey),declaration)}let flag=(...args)=>{if(isDecoratorApplication(args)){apply(!0,args[0],args[1]);return}let value=args[0];return(target,propertyKey)=>{apply(value,target,propertyKey)}};return Object.defineProperty(flag,"flagName",{value:name,enumerable:!0}),Object.defineProperty(flag,"off",{value:(target,propertyKey)=>{apply(FLAG_UNSET,target,propertyKey)},enumerable:!0}),flag}function resolveRouteFlags(classDeclarations,methodDeclarations){let resolved=new Map;for(let{name,value}of[...classDeclarations,...methodDeclarations]){if(value===FLAG_UNSET){resolved.delete(name);continue}resolved.set(name,value)}return resolved}function matchesFlagTest(test,flags,route){let resolved=flags??EMPTY_FLAGS;if(typeof test==`function`)return test({flags:resolved,route});if(typeof test==`string`)return isNegated(test)?!resolved.has(stripNegation(test)):resolved.has(test);if(test.length===0)return!1;let negated=isNegated(test[0]);if(test.some(name=>isNegated(name)!==negated))throw Error(`Route flag test mixes polarities: [${test.map(n=>`'${n}'`).join(`, `)}]. A list is either all names ("carries any of these") or all negated ("carries none of these") — for anything else, pass a predicate.`);return negated?test.every(name=>!resolved.has(stripNegation(name))):test.some(name=>resolved.has(name))}function assertFlagTest(test,site){if(typeof test==`function`||typeof test==`string`||test.length===0)return;let negated=isNegated(test[0]);if(test.some(name=>isNegated(name)!==negated))throw Error(`${site}: route flag test mixes polarities: [${test.map(n=>`'${n}'`).join(`, `)}]. A list is either all names ("carries any of these") or all negated ("carries none of these") — for anything else, pass a predicate.`)}const isNegated=name=>name.startsWith(`!`),stripNegation=name=>name.slice(1),EMPTY_FLAGS=new Map,ROUTE_SLOT=Symbol.for(`kick.route`);function getRouteFlags(controllerClass,handlerName){return resolveRouteFlags(getClassFlagDeclarations(controllerClass),getMethodFlagDeclarations(controllerClass,handlerName))}function getClassFlagDeclarations(controllerClass){return getClassMeta(METADATA.CLASS_FLAGS,controllerClass,[])}function getMethodFlagDeclarations(controllerClass,handlerName){return getMethodMeta(METADATA.METHOD_FLAGS,controllerClass,handlerName,[])}export{getMethodFlagDeclarations as a,resolveRouteFlags as c,getClassFlagDeclarations as i,assertFlagTest as n,getRouteFlags as o,defineRouteFlag as r,matchesFlagTest as s,ROUTE_SLOT as t};
-//# sourceMappingURL=route-flag-DTfTiScc.mjs.map

package/dist/route-flag-DTfTiScc.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"route-flag-DTfTiScc.mjs","names":[],"sources":["../src/core/route-flag.ts"],"sourcesContent":["/**\n * Route flags — a named, inheritable fact about a route (spec:\n * `route-flags-design.md`).\n *\n * A flag carries no behaviour. It records something about the route that any\n * consumer may read: `auth.public`, `csrf.exempt`, `rate.limit`. Auth reads it\n * to skip a contributor, a guard reads it to return early, Swagger reads it to\n * mark a security scheme — none of them needs to know about the others.\n *\n * The rule that makes presence checks safe: a flag resolves to **absent**, or\n * **present with a value**. `@Public.off` on a method removes what the class\n * set, rather than storing something falsy — so `flags.has(name)` is always the\n * right question for a boolean flag. Without that, `has('auth.public')` could\n * answer `true` for the route that just opted back IN, which is an\n * authorization bypass rather than a papercut.\n */\nimport { METADATA } from './interfaces'\nimport { getClassMeta, getMethodMeta, pushClassMeta, pushMethodMeta } from './metadata'\n\n/**\n * Augmentable route-flag registry — the flag counterpart of `ContextMeta`.\n *\n * Declare a project's flags here and every use of them narrows: a misspelt\n * name is a compile error rather than a flag that silently never matches, and\n * `flags.get('rate.limit')` comes back typed instead of `unknown`.\n *\n * ```ts\n * declare module '@forinda/kickjs' {\n *   interface KickRouteFlags {\n *     'auth.public': true\n *     'rate.limit': { rpm: number }\n *   }\n * }\n * ```\n *\n * The interface is empty by default, and everything below falls back to plain\n * `string` while it stays that way — a project that has not augmented anything\n * keeps compiling exactly as before. The narrowing switches on with the first\n * declaration.\n *\n * The framework itself declares nothing here: it ships the mechanism and names\n * no flags, so `auth.public` above is a name you chose.\n *\n * Two constraints on what you can declare:\n * - A name cannot start with `!` — that prefix means \"does not carry this flag\"\n *   in a {@link RouteFlagTest}, and `defineRouteFlag` rejects it.\n * - Removal is `@Flag.off`, not `@Flag(false)` — so `false` stays usable as a\n *   real value for a flag declared `boolean`.\n */\n// eslint-disable-next-line @typescript-eslint/no-empty-interface\nexport interface KickRouteFlags {}\n\n/**\n * A flag name. Narrows to the declared keys once {@link KickRouteFlags} is\n * augmented, and stays `string` until then — the same\n * `[Known] extends [never]` fallback `ContextMetaKey` uses, for the same\n * reason: first-day code must keep compiling.\n */\nexport type RouteFlagName = [keyof KickRouteFlags] extends [never]\n  ? string\n  : keyof KickRouteFlags & string\n\n/**\n * The value type declared for a flag, defaulting to `true` for a bare flag and\n * `unknown` for a name the registry does not know.\n */\nexport type RouteFlagValue<K extends string, Fallback = unknown> = K extends keyof KickRouteFlags\n  ? KickRouteFlags[K]\n  : Fallback\n\n/**\n * Marks a declaration as \"remove this flag\" during resolution.\n *\n * A dedicated sentinel rather than `false`: `false` is a perfectly good flag\n * VALUE (a registry entry typed `boolean`), and overloading it meant\n * `@Enabled(false)` deleted the flag while `flags.get('enabled')` could never\n * return `false`. With the sentinel, `false` stores like any other value and\n * removal is spelled `@Enabled.off`.\n *\n * Module-private and NOT `Symbol.for`: a registry-global symbol is reachable\n * by application code, so a flag declared with a `symbol` value could be handed\n * this exact sentinel and be deleted instead of stored. It is created and\n * consumed in this module, so it never needs to cross a realm.\n */\nconst FLAG_UNSET: unique symbol = Symbol('kick.flagUnset') as never\n\n/** One `@Flag` application, before precedence resolution. */\nexport interface RouteFlagDeclaration {\n  readonly name: string\n  /** `false` means \"remove whatever a lower-precedence site declared\". */\n  readonly value: unknown\n}\n\n/**\n * A flag decorator. Usable bare (`@Public`) or called with a value\n * (`@Public(false)`, `@RateLimit({ rpm: 10 })`), on a class or a method.\n */\n/**\n * The bare application forms — `@Public` with no call.\n *\n * Split out so they can be withheld from a flag whose declared value is not\n * assignable from `true`: applying `@Limit` bare would store `true` while\n * `flags.get('rate.limit')` promises `{ rpm: number }`, and nothing would catch\n * the mismatch until a consumer read the wrong shape at runtime.\n */\nexport interface BareRouteFlag {\n  /**\n   * Bare on a class. Typed against `Function` rather than `object` so a flag\n   * VALUE that happens to be an object (`@Limit({ rpm: 10 })`) cannot match\n   * this signature: overload resolution would otherwise pick it, return\n   * `void`, and fail with \"Type 'void' has no call signatures\".\n   */\n  (target: Function): void\n  /**\n   * Bare on a method. `propertyKey` is required for the same reason — it makes\n   * a one-argument call unambiguous.\n   */\n  (target: object, propertyKey: string | symbol, descriptor?: PropertyDescriptor): void\n}\n\n/** The called form — `@Limit({ rpm: 10 })` — plus removal via `.off`. */\nexport interface ValuedRouteFlag<V> {\n  (value: V): (target: object, propertyKey?: string | symbol) => void\n  /**\n   * Remove the flag on this route — `@Public.off` on a method drops what the\n   * controller set.\n   *\n   * Applied bare, like the flag itself. Spelled as its own member rather than\n   * `@Public(false)` so that `false` stays available as a real value: a flag\n   * declared `boolean` can store it, and `flags.get()` can return it.\n   */\n  readonly off: BareRouteFlag\n  readonly flagName: string\n}\n\n/**\n * A flag decorator.\n *\n * Bare application is available only when `true` is a valid value for the flag\n * — which is every flag until {@link KickRouteFlags} declares a value type for\n * it. Declare `'rate.limit': { rpm: number }` and `@RateLimit` on its own stops\n * compiling, because the value it would store is not the value the registry\n * promises readers.\n */\nexport type RouteFlag<V = true> = true extends V\n  ? BareRouteFlag & ValuedRouteFlag<V>\n  : ValuedRouteFlag<V>\n\n/**\n * True when the arguments look like a decorator application rather than a\n * value. The two forms are `@Public` (TS calls it for us) and `@Public(v)`\n * (we return the decorator).\n *\n * Discrimination has to be exact, because a value can be an object:\n * `@RateLimit({ rpm: 10 })` is a single object argument, and treating it as a\n * class-decorator target silently drops the flag.\n *\n * - method decorator → `(prototype, 'name', descriptor?)`, so arg 1 is a\n *   string or symbol\n * - class decorator → `(constructor)`, a single *function* argument\n * - anything else → a value\n */\nfunction isDecoratorApplication(args: unknown[]): boolean {\n  const [target, propertyKey] = args\n  if (typeof propertyKey === 'string' || typeof propertyKey === 'symbol') return true\n  return args.length === 1 && typeof target === 'function'\n}\n\n/**\n * Define a route flag.\n *\n * ```ts\n * export const Public = defineRouteFlag('auth.public')\n * export const RateLimit = defineRouteFlag<{ rpm: number }>('rate.limit')\n * ```\n *\n * Once {@link KickRouteFlags} declares the name, the value type comes from the\n * registry and the explicit generic is redundant:\n *\n * ```ts\n * declare module '@forinda/kickjs' {\n *   interface KickRouteFlags {\n *     'rate.limit': { rpm: number }\n *   }\n * }\n *\n * const RateLimit = defineRouteFlag('rate.limit') // RouteFlag<{ rpm: number }>\n * ```\n */\nexport function defineRouteFlag<const N extends RouteFlagName>(\n  name: N,\n): RouteFlag<RouteFlagValue<N, true>>\nexport function defineRouteFlag<V>(name: RouteFlagName): RouteFlag<V>\nexport function defineRouteFlag(name: string): RouteFlag<never> {\n  // `!` is reserved: a test string starting with it means \"does NOT carry this\n  // flag\", so a flag literally named '!x' would be indistinguishable from the\n  // negation of 'x' — `exemptWhen: '!x'` would silently stop meaning what the\n  // author wrote. Rejecting at definition is the only point where the two can\n  // still be told apart.\n  if (name.startsWith('!')) {\n    throw new Error(\n      `defineRouteFlag('${name}'): a flag name cannot start with '!' — that prefix is reserved ` +\n        `for negated tests ('!${name.slice(1)}' means \"does not carry ${name.slice(1)}\"). ` +\n        `Rename the flag.`,\n    )\n  }\n\n  function apply(value: unknown, target: object, propertyKey?: string | symbol): void {\n    const declaration: RouteFlagDeclaration = { name, value }\n    if (propertyKey === undefined) {\n      pushClassMeta<RouteFlagDeclaration>(METADATA.CLASS_FLAGS, target, declaration)\n      return\n    }\n    // Method decorators receive the prototype; metadata helpers key off the\n    // constructor so class + method lookups land in the same place.\n    pushMethodMeta<RouteFlagDeclaration>(\n      METADATA.METHOD_FLAGS,\n      (target as { constructor: object }).constructor,\n      String(propertyKey),\n      declaration,\n    )\n  }\n\n  const flag = (...args: unknown[]): unknown => {\n    if (isDecoratorApplication(args)) {\n      // Bare form: @Public\n      apply(true, args[0] as object, args[1] as string | symbol | undefined)\n      return undefined\n    }\n    // Called form: @Public(false) / @RateLimit({ rpm: 10 })\n    const value = args[0]\n    return (target: object, propertyKey?: string | symbol): void => {\n      apply(value, target, propertyKey)\n    }\n  }\n\n  Object.defineProperty(flag, 'flagName', { value: name, enumerable: true })\n  // `.off` is the removal decorator: bare-applicable, and the only way to drop\n  // an inherited flag now that `false` is an ordinary value.\n  Object.defineProperty(flag, 'off', {\n    value: (target: object, propertyKey?: string | symbol): void => {\n      apply(FLAG_UNSET, target, propertyKey)\n    },\n    enumerable: true,\n  })\n  return flag as unknown as RouteFlag<never>\n}\n\n/**\n * Resolve the flags in force for one route.\n *\n * Precedence is method > class, matching the contributor pipeline's top two\n * levels. Within a level the last declaration wins (decorators apply bottom-up,\n * so the one nearest the handler is applied last).\n *\n * A resolved `false` deletes the key rather than storing it — see the module\n * docblock.\n */\nexport function resolveRouteFlags(\n  classDeclarations: readonly RouteFlagDeclaration[],\n  methodDeclarations: readonly RouteFlagDeclaration[],\n): RouteFlags {\n  const resolved = new Map<string, unknown>()\n\n  // Lowest precedence first, so higher levels overwrite.\n  for (const { name, value } of [...classDeclarations, ...methodDeclarations]) {\n    if (value === FLAG_UNSET) {\n      resolved.delete(name)\n      continue\n    }\n    resolved.set(name, value)\n  }\n\n  // The map is built from declarations, so its value types are whatever the\n  // registry says they are — this cast is the one place that knowledge crosses\n  // from runtime data into the type system.\n  return resolved as RouteFlags\n}\n\n/**\n * The resolved flags for a route.\n *\n * A `ReadonlyMap` whose `has` is narrowed to known names and whose `get`\n * returns the declared value type — so `flags.get('rate.limit')` is\n * `{ rpm: number } | undefined` rather than `unknown`, once the registry\n * declares it. Until then it behaves like `ReadonlyMap<string, unknown>`.\n */\nexport interface RouteFlags extends ReadonlyMap<string, unknown> {\n  has(name: RouteFlagName): boolean\n  get<K extends RouteFlagName>(name: K): RouteFlagValue<K> | undefined\n}\n\n/**\n * Argument handed to a flag predicate.\n *\n * `route` is undefined only where flags are consulted outside a matched route,\n * which today means a non-HTTP transport running the same contributor pipeline.\n */\nexport interface RouteFlagContext {\n  readonly flags: RouteFlags\n  readonly route?: {\n    readonly method: string\n    readonly path: string\n    readonly controller?: unknown\n    readonly handlerName?: string\n  }\n}\n\n/**\n * A predicate form of a flag test, for conditions a single name cannot express:\n * two flags together, a flag's *value*, a path or controller check, an env\n * switch.\n *\n * ```ts\n * skipWhen: ({ flags }) => flags.has('auth.public') || flags.has('internal'),\n * skipWhen: ({ flags }) => (flags.get('rate.limit') as { rpm: number })?.rpm === 0,\n * skipWhen: ({ route }) => route?.path.startsWith('/webhooks') ?? false,\n * ```\n *\n * Keep predicates pure and cheap — they run per request, per contributor.\n */\nexport type RouteFlagPredicate = (ctx: RouteFlagContext) => boolean\n\n/**\n * How a consumer names the routes it cares about.\n *\n * A bare name for the common case, a list when several flags mean the same\n * thing (matched **any-of**), a predicate for everything else — all-of, a\n * flag's value, the route's path.\n *\n * ```ts\n * skipWhen: 'auth.public'\n * skipWhen: ['auth.public', 'health.probe']            // either one\n * skipWhen: ({ flags }) => flags.has('a') && flags.has('b')   // both\n * ```\n */\n/**\n * A flag name with `!` in front — matches routes that do **not** carry it.\n *\n * Narrows with the registry like the positive form: once `KickRouteFlags`\n * declares `'auth.public'`, this is `'!auth.public' | …`, so a misspelt\n * negation is a compile error too.\n */\nexport type NegatedRouteFlagName = `!${RouteFlagName}`\n\n/**\n * How a consumer names the routes it cares about.\n *\n * - `'auth.public'` — carries the flag\n * - `'!auth.public'` — does **not** carry it\n * - `['a', 'b']` — carries **any** of them\n * - `['!a', '!b']` — carries **none** of them\n * - a predicate — anything else: all-of, a flag's value, the route's path\n *\n * Lists are single-polarity by construction: `['a', '!b']` matches neither\n * array member of this union, so it is a compile error. Mixed polarity has no\n * reading everyone agrees on — under any-of it means \"a present OR b absent\",\n * which most readers parse as \"and\" — and a predicate says it unambiguously.\n */\nexport type RouteFlagTest =\n  | RouteFlagName\n  | NegatedRouteFlagName\n  | readonly RouteFlagName[]\n  | readonly NegatedRouteFlagName[]\n  | RouteFlagPredicate\n\n/**\n * Evaluate a {@link RouteFlagTest} against a route's resolved flags.\n *\n * Shared by every consumer that can be exempted per route — the contributor\n * runner, `csrfGuard`, `rateLimitGuard` — so \"which routes does this apply to\"\n * means the same thing everywhere, and a list is any-of in all of them.\n */\nexport function matchesFlagTest(\n  test: RouteFlagTest,\n  flags: RouteFlags | undefined,\n  route?: RouteFlagContext['route'],\n): boolean {\n  const resolved = flags ?? EMPTY_FLAGS\n  if (typeof test === 'function') return test({ flags: resolved, route })\n\n  if (typeof test === 'string') {\n    return isNegated(test)\n      ? !resolved.has(stripNegation(test))\n      : resolved.has(test as RouteFlagName)\n  }\n\n  if (test.length === 0) return false\n\n  // Single polarity per list — the type forbids mixing, and this guards the\n  // untyped callers (plain JS, a value read from config) that the type cannot.\n  const negated = isNegated(test[0])\n  if (test.some((name) => isNegated(name) !== negated)) {\n    throw new Error(\n      `Route flag test mixes polarities: [${test.map((n) => `'${n}'`).join(', ')}]. ` +\n        `A list is either all names (\"carries any of these\") or all negated ` +\n        `(\"carries none of these\") — for anything else, pass a predicate.`,\n    )\n  }\n\n  // Positive list is any-of; negated list is its complement, none-of. The two\n  // read as opposites, which is what makes flipping every entry do what a\n  // reader expects.\n  return negated\n    ? test.every((name) => !resolved.has(stripNegation(name)))\n    : test.some((name) => resolved.has(name as RouteFlagName))\n}\n\n/**\n * Reject a mixed-polarity list at construction time.\n *\n * A list like `['auth.public', '!metered']` is a static mistake, so it fails\n * where it is written — when the contributor or guard is built — rather than\n * on the first request that reaches it. Same reasoning as the contributor\n * pipeline failing a dependency cycle at boot.\n *\n * Call from every factory that accepts a {@link RouteFlagTest}; the check in\n * {@link matchesFlagTest} stays as a backstop for direct callers.\n */\nexport function assertFlagTest(test: RouteFlagTest, site: string): void {\n  if (typeof test === 'function' || typeof test === 'string' || test.length === 0) return\n  const negated = isNegated(test[0])\n  if (test.some((name) => isNegated(name) !== negated)) {\n    throw new Error(\n      `${site}: route flag test mixes polarities: [${test.map((n) => `'${n}'`).join(', ')}]. ` +\n        `A list is either all names (\"carries any of these\") or all negated ` +\n        `(\"carries none of these\") — for anything else, pass a predicate.`,\n    )\n  }\n}\n\nconst isNegated = (name: string): boolean => name.startsWith('!')\nconst stripNegation = (name: string): RouteFlagName => name.slice(1) as RouteFlagName\n\nconst EMPTY_FLAGS: RouteFlags = new Map()\n\n/**\n * Where the matched route is stashed for `ctx.route` to read.\n *\n * It lives on the **request object**, not on the RequestContext: the Express\n * runtime constructs a fresh `RequestContext` per middleware, so anything\n * written to one ctx is invisible to the next and to the handler. Fastify and\n * h3 build a single ctx per request and would not have shown the difference —\n * the cross-runtime test is what surfaced it.\n *\n * `Symbol.for` rather than a private symbol so a duplicated module instance\n * (pnpm hoisting, a bundled copy) still reads the same slot.\n */\nexport const ROUTE_SLOT: unique symbol = Symbol.for('kick.route') as never\n\n/**\n * Resolve the flags in force for one handler, straight from the controller\n * class — the same method-over-class result `buildRouteTable` computes.\n *\n * For consumers that see a controller and a method name rather than a live\n * request: an adapter's `onRouteMount`, an OpenAPI generator, a DevTools route\n * listing. Inside a request, read `ctx.route.flags` instead — it is already\n * resolved.\n *\n * ```ts\n * // Mark flagged routes public in the OpenAPI spec:\n * SwaggerAdapter({\n *   bearerAuth: true,\n *   securityResolver: ({ controllerClass, handlerName }) =>\n *     getRouteFlags(controllerClass, handlerName).has('auth.public') ? null : undefined,\n * })\n * ```\n */\nexport function getRouteFlags(controllerClass: object, handlerName: string): RouteFlags {\n  return resolveRouteFlags(\n    getClassFlagDeclarations(controllerClass),\n    getMethodFlagDeclarations(controllerClass, handlerName),\n  )\n}\n\n/** Read the class-level declarations off a controller. */\nexport function getClassFlagDeclarations(controllerClass: object): RouteFlagDeclaration[] {\n  return getClassMeta<RouteFlagDeclaration[]>(METADATA.CLASS_FLAGS, controllerClass, [])\n}\n\n/** Read the method-level declarations off a controller method. */\nexport function getMethodFlagDeclarations(\n  controllerClass: object,\n  handlerName: string,\n): RouteFlagDeclaration[] {\n  return getMethodMeta<RouteFlagDeclaration[]>(\n    METADATA.METHOD_FLAGS,\n    controllerClass,\n    handlerName,\n    [],\n  )\n}\n"],"mappings":";;;;;;;;;;6JAoFA,MAAM,WAA4B,OAAO,gBAAgB,EA8EzD,SAAS,uBAAuB,KAA0B,CACxD,GAAM,CAAC,OAAQ,aAAe,KAE9B,OADI,OAAO,aAAgB,UAAY,OAAO,aAAgB,UACvD,KAAK,SAAW,GAAK,OAAO,QAAW,UAChD,CA2BA,SAAgB,gBAAgB,KAAgC,CAM9D,GAAI,KAAK,WAAW,GAAG,EACrB,MAAU,MACR,oBAAoB,KAAK,uFACC,KAAK,MAAM,CAAC,EAAE,0BAA0B,KAAK,MAAM,CAAC,EAAE,qBAElF,EAGF,SAAS,MAAM,MAAgB,OAAgB,YAAqC,CAClF,IAAM,YAAoC,CAAE,KAAM,KAAM,EACxD,GAAI,cAAgB,IAAA,GAAW,CAC7B,cAAoC,SAAS,YAAa,OAAQ,WAAW,EAC7E,MACF,CAGA,eACE,SAAS,aACR,OAAmC,YACpC,OAAO,WAAW,EAClB,WACF,CACF,CAEA,IAAM,MAAQ,GAAG,OAA6B,CAC5C,GAAI,uBAAuB,IAAI,EAAG,CAEhC,MAAM,GAAM,KAAK,GAAc,KAAK,EAAiC,EACrE,MACF,CAEA,IAAM,MAAQ,KAAK,GACnB,OAAQ,OAAgB,cAAwC,CAC9D,MAAM,MAAO,OAAQ,WAAW,CAClC,CACF,EAWA,OATA,OAAO,eAAe,KAAM,WAAY,CAAE,MAAO,KAAM,WAAY,EAAK,CAAC,EAGzE,OAAO,eAAe,KAAM,MAAO,CACjC,OAAQ,OAAgB,cAAwC,CAC9D,MAAM,WAAY,OAAQ,WAAW,CACvC,EACA,WAAY,EACd,CAAC,EACM,IACT,CAYA,SAAgB,kBACd,kBACA,mBACY,CACZ,IAAM,SAAW,IAAI,IAGrB,IAAK,GAAM,CAAE,KAAM,QAAW,CAAC,GAAG,kBAAmB,GAAG,kBAAkB,EAAG,CAC3E,GAAI,QAAU,WAAY,CACxB,SAAS,OAAO,IAAI,EACpB,QACF,CACA,SAAS,IAAI,KAAM,KAAK,CAC1B,CAKA,OAAO,QACT,CAgGA,SAAgB,gBACd,KACA,MACA,MACS,CACT,IAAM,SAAW,OAAS,YAC1B,GAAI,OAAO,MAAS,WAAY,OAAO,KAAK,CAAE,MAAO,SAAU,KAAM,CAAC,EAEtE,GAAI,OAAO,MAAS,SAClB,OAAO,UAAU,IAAI,EACjB,CAAC,SAAS,IAAI,cAAc,IAAI,CAAC,EACjC,SAAS,IAAI,IAAqB,EAGxC,GAAI,KAAK,SAAW,EAAG,MAAO,GAI9B,IAAM,QAAU,UAAU,KAAK,EAAE,EACjC,GAAI,KAAK,KAAM,MAAS,UAAU,IAAI,IAAM,OAAO,EACjD,MAAU,MACR,sCAAsC,KAAK,IAAK,GAAM,IAAI,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,EAAE,uIAG7E,EAMF,OAAO,QACH,KAAK,MAAO,MAAS,CAAC,SAAS,IAAI,cAAc,IAAI,CAAC,CAAC,EACvD,KAAK,KAAM,MAAS,SAAS,IAAI,IAAqB,CAAC,CAC7D,CAaA,SAAgB,eAAe,KAAqB,KAAoB,CACtE,GAAI,OAAO,MAAS,YAAc,OAAO,MAAS,UAAY,KAAK,SAAW,EAAG,OACjF,IAAM,QAAU,UAAU,KAAK,EAAE,EACjC,GAAI,KAAK,KAAM,MAAS,UAAU,IAAI,IAAM,OAAO,EACjD,MAAU,MACR,GAAG,KAAK,uCAAuC,KAAK,IAAK,GAAM,IAAI,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,EAAE,uIAGtF,CAEJ,CAEA,MAAM,UAAa,MAA0B,KAAK,WAAW,GAAG,EAC1D,cAAiB,MAAgC,KAAK,MAAM,CAAC,EAE7D,YAA0B,IAAI,IAcvB,WAA4B,OAAO,IAAI,YAAY,EAoBhE,SAAgB,cAAc,gBAAyB,YAAiC,CACtF,OAAO,kBACL,yBAAyB,eAAe,EACxC,0BAA0B,gBAAiB,WAAW,CACxD,CACF,CAGA,SAAgB,yBAAyB,gBAAiD,CACxF,OAAO,aAAqC,SAAS,YAAa,gBAAiB,CAAC,CAAC,CACvF,CAGA,SAAgB,0BACd,gBACA,YACwB,CACxB,OAAO,cACL,SAAS,aACT,gBACA,YACA,CAAC,CACH,CACF"}

package/dist/router-builder-CxRFEM9j.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"router-builder-CxRFEM9j.d.mts","names":[],"sources":["../src/http/router-builder.ts"],"mappings":";;;;iBAoCgB,+BAA+B,kBAAkB;;;;;;;;;;;iBAcjD,kBACd,UAAU,qBACV,gBACA,kBACA;UAUe;;;;;;;EAOf,2BAA2B;;;;;;;;;;;;;;;;;;;;;;iBAuBb,gBACd,sBACA,UAAS,qBACR"}

package/dist/router-builder-DP6CbI7S.mjs

@@ -1,12 +0,0 @@
-/**
- * @forinda/kickjs v8.2.1
- *
- * Copyright (c) Felix Orinda
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @license MIT
- */
-import{METADATA}from"./core/interfaces.mjs";import{o as duplicateRouteError,t as Container}from"./container-CZPSM8p-.mjs";import{a as getMethodMeta,o as getMethodMetaOrUndefined,t as getClassMeta}from"./metadata-C-9GVv_0.mjs";import{a as getMethodFlagDeclarations,c as resolveRouteFlags,i as getClassFlagDeclarations}from"./route-flag-DTfTiScc.mjs";import{i as MissingContributorError,n as DuplicateContributorError,t as ContributorCycleError}from"./context-errors-CkXOg4qD.mjs";import{t as runContributors}from"./contributor-runner-r-_idhMs.mjs";const PRECEDENCE_ORDER=[`method`,`class`,`module`,`adapter`,`global`];function buildPipeline(sources,options={}){let route=options.route,bySource=new Map;for(let src of PRECEDENCE_ORDER)bySource.set(src,[]);for(let entry of sources)bySource.get(entry.source).push(entry);let winners=new Map;for(let src of PRECEDENCE_ORDER){let rows=bySource.get(src),keysAtThisLevel=new Map;for(let row of rows){let key=row.registration.key,existing=keysAtThisLevel.get(key)??[];existing.push(row),keysAtThisLevel.set(key,existing)}for(let[key,rowsForKey]of keysAtThisLevel){if(rowsForKey.length>1)throw new DuplicateContributorError(key,rowsForKey.map((r,i)=>r.label??`${src}#${i}`));winners.has(key)||winners.set(key,rowsForKey[0])}}let survivors=[...winners.values()].map(r=>r.registration),allKeys=new Set(survivors.map(r=>r.key));for(let reg of survivors)for(let dep of reg.dependsOn)if(!allKeys.has(dep))throw new MissingContributorError(dep,reg.key,route,reg.definedAt);let sorted=topoSort(survivors,route);return Object.freeze({contributors:Object.freeze(sorted),keys:allKeys})}function topoSort(registrations,route){let indegree=new Map,dependents=new Map,byKey=new Map;for(let reg of registrations)indegree.set(reg.key,reg.dependsOn.length),byKey.set(reg.key,reg);for(let reg of registrations)for(let dep of reg.dependsOn){let list=dependents.get(dep)??[];list.push(reg),dependents.set(dep,list)}let queue=[];for(let reg of registrations)indegree.get(reg.key)===0&&queue.push(reg);let sorted=[];for(;queue.length>0;){let node=queue.shift();sorted.push(node);for(let dependent of dependents.get(node.key)??[]){let next=(indegree.get(dependent.key)??0)-1;indegree.set(dependent.key,next),next===0&&queue.push(dependent)}}if(sorted.length!==registrations.length)throw new ContributorCycleError(reconstructCycle(registrations.filter(r=>(indegree.get(r.key)??0)>0),byKey),route);return sorted}function reconstructCycle(residual,byKey){let residualKeys=new Set(residual.map(r=>r.key)),start=residual[0].key,path=[start],seen=new Set([start]),cursor=start;for(;;){let nextDep=byKey.get(cursor).dependsOn.find(d=>residualKeys.has(d));if(nextDep===void 0)break;if(seen.has(nextDep)){let cycleStart=path.indexOf(nextDep);return[...path.slice(cycleStart),nextDep]}path.push(nextDep),seen.add(nextDep),cursor=nextDep}return path}let _externalContributorSources=[];function _setExternalContributorSources(sources){_externalContributorSources=sources}function assertRouteUnique(registry,method,fullPath,owner){let key=`${method.toUpperCase()} ${fullPath.replace(/:[^/]+/g,`:*`)}`,prior=registry.get(key);if(prior!==void 0)throw duplicateRouteError(method.toUpperCase(),fullPath,owner,prior);registry.set(key,owner)}function buildRouteTable(controllerClass,options={}){let container=Container.getInstance(),externalSources=options.externalSources??_externalContributorSources,routes=getClassMeta(METADATA.ROUTES,controllerClass,[]),classMiddlewares=getClassMeta(METADATA.CLASS_MIDDLEWARES,controllerClass,[]),classContributors=getClassMeta(METADATA.CLASS_CONTRIBUTORS,controllerClass,[]),classFlagDeclarations=getClassFlagDeclarations(controllerClass),entries=[];for(let route of routes){let method=route.method.toUpperCase(),fullPath=route.path||`/`,methodMiddlewares=getMethodMeta(METADATA.METHOD_MIDDLEWARES,controllerClass,route.handlerName,[]),fileUploadConfig=getMethodMetaOrUndefined(METADATA.FILE_UPLOAD,controllerClass,route.handlerName),methodContributors=getMethodMeta(METADATA.METHOD_CONTRIBUTORS,controllerClass,route.handlerName,[]),flags=resolveRouteFlags(classFlagDeclarations,getMethodFlagDeclarations(controllerClass,route.handlerName)),contributorRunner=null;if(classContributors.length>0||methodContributors.length>0||externalSources.length>0){let pipeline=buildPipeline([...methodContributors.map((registration,i)=>({source:`method`,registration,label:`${controllerClass.name}.${String(route.handlerName)}#${i}(${registration.key})`})),...classContributors.map((registration,i)=>({source:`class`,registration,label:`${controllerClass.name}.@class#${i}(${registration.key})`})),...externalSources],{route:`${method} ${fullPath}`});contributorRunner=ctx=>runContributors({pipeline,ctx,container,flags})}let handler=ctx=>container.resolve(controllerClass)[route.handlerName](ctx);entries.push({method,path:fullPath,middlewares:[...classMiddlewares,...methodMiddlewares],contributorRunner,handler,meta:{controller:controllerClass,handlerName:route.handlerName,validation:route.validation,upload:fileUploadConfig,flags}})}return entries}export{buildPipeline as i,assertRouteUnique as n,buildRouteTable as r,_setExternalContributorSources as t};
-//# sourceMappingURL=router-builder-DP6CbI7S.mjs.map