@theokit/http 0.4.0

package/dist/chunk-HLW7YKZE.js

@@ -0,0 +1,99 @@
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/bridge/runtime/node.ts
+import { createServer } from "http";
+import { Readable } from "stream";
+function nodeIncomingToRequest(nodeReq) {
+  const proto = nodeReq.headers["x-forwarded-proto"] ?? "http";
+  const host = nodeReq.headers.host ?? "localhost";
+  const url = `${proto}://${host}${nodeReq.url ?? "/"}`;
+  const method = nodeReq.method ?? "GET";
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(nodeReq.headers)) {
+    if (value !== void 0) {
+      if (Array.isArray(value)) {
+        for (const v of value) headers.append(key, v);
+      } else {
+        headers.set(key, value);
+      }
+    }
+  }
+  const hasBody = method !== "GET" && method !== "HEAD" && method !== "OPTIONS";
+  const body = hasBody ? Readable.toWeb(nodeReq) : void 0;
+  return new Request(url, {
+    method,
+    headers,
+    body,
+    // @ts-expect-error — duplex is required for streaming bodies in Node 18+
+    duplex: hasBody ? "half" : void 0
+  });
+}
+__name(nodeIncomingToRequest, "nodeIncomingToRequest");
+async function writeResponseToNode(response, nodeRes) {
+  nodeRes.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+  if (!response.body) {
+    nodeRes.end();
+    return;
+  }
+  const reader = response.body.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (nodeRes.destroyed) break;
+      nodeRes.write(value);
+    }
+  } finally {
+    reader.releaseLock();
+    if (!nodeRes.destroyed) nodeRes.end();
+  }
+}
+__name(writeResponseToNode, "writeResponseToNode");
+function createNodeAdapter() {
+  return {
+    createServer(handler) {
+      const server = createServer((nodeReq, nodeRes) => {
+        void (async () => {
+          try {
+            const request = nodeIncomingToRequest(nodeReq);
+            const response = await handler(request);
+            await writeResponseToNode(response, nodeRes);
+          } catch (err) {
+            if (!nodeRes.destroyed) {
+              nodeRes.writeHead(500, {
+                "content-type": "application/json"
+              });
+              nodeRes.end(JSON.stringify({
+                error: {
+                  code: "INTERNAL_SERVER_ERROR",
+                  message: err instanceof Error ? err.message : "Unknown error"
+                }
+              }));
+            }
+          }
+        })();
+      });
+      return {
+        listen: /* @__PURE__ */ __name((port, cb) => server.listen(port, cb), "listen"),
+        close: /* @__PURE__ */ __name((cb) => server.close(cb), "close"),
+        address: /* @__PURE__ */ __name(() => {
+          const addr = server.address();
+          if (typeof addr === "string" || addr === null) return null;
+          return {
+            port: addr.port
+          };
+        }, "address")
+      };
+    }
+  };
+}
+__name(createNodeAdapter, "createNodeAdapter");
+
+export {
+  nodeIncomingToRequest,
+  writeResponseToNode,
+  createNodeAdapter
+};
+//# sourceMappingURL=chunk-HLW7YKZE.js.map

package/dist/chunk-HLW7YKZE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/bridge/runtime/node.ts"],"sourcesContent":["/**\n * Node.js runtime adapter — converts IncomingMessage/ServerResponse ↔ Request/Response.\n *\n * Per ADR D460: node:http types live ONLY in this adapter file.\n * The rest of the pipeline operates on Web Standard Request/Response.\n *\n * EC-1: Body converted via Readable.toWeb() for streaming (no full buffering).\n */\nimport { createServer, type IncomingMessage, type ServerResponse } from 'node:http'\nimport { Readable } from 'node:stream'\n\nimport type { RuntimeAdapter } from './types.js'\n\n/** Convert Node.js IncomingMessage to Web Standard Request. */\nexport function nodeIncomingToRequest(nodeReq: IncomingMessage): Request {\n  const proto = nodeReq.headers['x-forwarded-proto'] ?? 'http'\n  const host = nodeReq.headers.host ?? 'localhost'\n  const url = `${proto}://${host}${nodeReq.url ?? \"/\"}` // eslint-disable-line @typescript-eslint/restrict-template-expressions -- proto/host are string|string[]\n  const method = nodeReq.method ?? 'GET'\n\n  const headers = new Headers()\n  for (const [key, value] of Object.entries(nodeReq.headers)) {\n    if (value !== undefined) {\n      if (Array.isArray(value)) {\n        for (const v of value) headers.append(key, v)\n      } else {\n        headers.set(key, value)\n      }\n    }\n  }\n\n  // EC-1: Streaming body via Readable.toWeb() — no full buffering\n  const hasBody = method !== 'GET' && method !== 'HEAD' && method !== 'OPTIONS'\n  const body = hasBody ? Readable.toWeb(nodeReq) as ReadableStream : undefined\n\n  return new Request(url, {\n    method,\n    headers,\n    body,\n    // @ts-expect-error — duplex is required for streaming bodies in Node 18+\n    duplex: hasBody ? 'half' : undefined,\n  })\n}\n\n/** Write Web Standard Response to Node.js ServerResponse. */\nexport async function writeResponseToNode(response: Response, nodeRes: ServerResponse): Promise<void> {\n  nodeRes.writeHead(response.status, Object.fromEntries(response.headers.entries()))\n\n  if (!response.body) {\n    nodeRes.end()\n    return\n  }\n\n  const reader = response.body.getReader()\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- intentional infinite loop with break\n    while (true) {\n      const { done, value } = await reader.read()\n      if (done) break\n      if (nodeRes.destroyed) break\n      nodeRes.write(value)\n    }\n  } finally {\n    reader.releaseLock()\n    if (!nodeRes.destroyed) nodeRes.end()\n  }\n}\n\n/** Create a Node.js HTTP server that delegates to a Web Standard handler. */\nexport function createNodeAdapter(): RuntimeAdapter {\n  return {\n    createServer(handler) {\n      const server = createServer((nodeReq, nodeRes) => {\n        void (async () => {\n        try {\n          const request = nodeIncomingToRequest(nodeReq)\n          const response = await handler(request)\n          await writeResponseToNode(response, nodeRes)\n        } catch (err) {\n          if (!nodeRes.destroyed) {\n            nodeRes.writeHead(500, { 'content-type': 'application/json' })\n            nodeRes.end(JSON.stringify({\n              error: { code: 'INTERNAL_SERVER_ERROR', message: err instanceof Error ? err.message : 'Unknown error' },\n            }))\n          }\n        }\n        })()\n      })\n\n      return {\n        listen: (port: number, cb?: () => void) => server.listen(port, cb),\n        close: (cb?: () => void) => server.close(cb),\n        address: () => {\n          const addr = server.address()\n          if (typeof addr === 'string' || addr === null) return null\n          return { port: addr.port }\n        },\n      }\n    },\n  }\n}\n"],"mappings":";;;;;AAQA,SAASA,oBAA+D;AACxE,SAASC,gBAAgB;AAKlB,SAASC,sBAAsBC,SAAwB;AAC5D,QAAMC,QAAQD,QAAQE,QAAQ,mBAAA,KAAwB;AACtD,QAAMC,OAAOH,QAAQE,QAAQC,QAAQ;AACrC,QAAMC,MAAM,GAAGH,KAAAA,MAAWE,IAAAA,GAAOH,QAAQI,OAAO,GAAA;AAChD,QAAMC,SAASL,QAAQK,UAAU;AAEjC,QAAMH,UAAU,IAAII,QAAAA;AACpB,aAAW,CAACC,KAAKC,KAAAA,KAAUC,OAAOC,QAAQV,QAAQE,OAAO,GAAG;AAC1D,QAAIM,UAAUG,QAAW;AACvB,UAAIC,MAAMC,QAAQL,KAAAA,GAAQ;AACxB,mBAAWM,KAAKN,MAAON,SAAQa,OAAOR,KAAKO,CAAAA;MAC7C,OAAO;AACLZ,gBAAQc,IAAIT,KAAKC,KAAAA;MACnB;IACF;EACF;AAGA,QAAMS,UAAUZ,WAAW,SAASA,WAAW,UAAUA,WAAW;AACpE,QAAMa,OAAOD,UAAUE,SAASC,MAAMpB,OAAAA,IAA6BW;AAEnE,SAAO,IAAIU,QAAQjB,KAAK;IACtBC;IACAH;IACAgB;;IAEAI,QAAQL,UAAU,SAASN;EAC7B,CAAA;AACF;AA5BgBZ;AA+BhB,eAAsBwB,oBAAoBC,UAAoBC,SAAuB;AACnFA,UAAQC,UAAUF,SAASG,QAAQlB,OAAOmB,YAAYJ,SAAStB,QAAQQ,QAAO,CAAA,CAAA;AAE9E,MAAI,CAACc,SAASN,MAAM;AAClBO,YAAQI,IAAG;AACX;EACF;AAEA,QAAMC,SAASN,SAASN,KAAKa,UAAS;AACtC,MAAI;AAEF,WAAO,MAAM;AACX,YAAM,EAAEC,MAAMxB,MAAK,IAAK,MAAMsB,OAAOG,KAAI;AACzC,UAAID,KAAM;AACV,UAAIP,QAAQS,UAAW;AACvBT,cAAQU,MAAM3B,KAAAA;IAChB;EACF,UAAA;AACEsB,WAAOM,YAAW;AAClB,QAAI,CAACX,QAAQS,UAAWT,SAAQI,IAAG;EACrC;AACF;AArBsBN;AAwBf,SAASc,oBAAAA;AACd,SAAO;IACLC,aAAaC,SAAO;AAClB,YAAMC,SAASF,aAAa,CAACtC,SAASyB,YAAAA;AACpC,cAAM,YAAA;AACN,cAAI;AACF,kBAAMgB,UAAU1C,sBAAsBC,OAAAA;AACtC,kBAAMwB,WAAW,MAAMe,QAAQE,OAAAA;AAC/B,kBAAMlB,oBAAoBC,UAAUC,OAAAA;UACtC,SAASiB,KAAK;AACZ,gBAAI,CAACjB,QAAQS,WAAW;AACtBT,sBAAQC,UAAU,KAAK;gBAAE,gBAAgB;cAAmB,CAAA;AAC5DD,sBAAQI,IAAIc,KAAKC,UAAU;gBACzBC,OAAO;kBAAEC,MAAM;kBAAyBC,SAASL,eAAeM,QAAQN,IAAIK,UAAU;gBAAgB;cACxG,CAAA,CAAA;YACF;UACF;QACA,GAAA;MACF,CAAA;AAEA,aAAO;QACLE,QAAQ,wBAACC,MAAcC,OAAoBX,OAAOS,OAAOC,MAAMC,EAAAA,GAAvD;QACRC,OAAO,wBAACD,OAAoBX,OAAOY,MAAMD,EAAAA,GAAlC;QACPE,SAAS,6BAAA;AACP,gBAAMC,OAAOd,OAAOa,QAAO;AAC3B,cAAI,OAAOC,SAAS,YAAYA,SAAS,KAAM,QAAO;AACtD,iBAAO;YAAEJ,MAAMI,KAAKJ;UAAK;QAC3B,GAJS;MAKX;IACF;EACF;AACF;AA/BgBb;","names":["createServer","Readable","nodeIncomingToRequest","nodeReq","proto","headers","host","url","method","Headers","key","value","Object","entries","undefined","Array","isArray","v","append","set","hasBody","body","Readable","toWeb","Request","duplex","writeResponseToNode","response","nodeRes","writeHead","status","fromEntries","end","reader","getReader","done","read","destroyed","write","releaseLock","createNodeAdapter","createServer","handler","server","request","err","JSON","stringify","error","code","message","Error","listen","port","cb","close","address","addr"]}

package/dist/chunk-LKNI6QEP.js

@@ -0,0 +1,20 @@
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/bridge/di-resolve.ts
+function resolveOrNew(Ctor, container) {
+  if (container) {
+    try {
+      return container.resolve(Ctor);
+    } catch {
+    }
+  }
+  return new Ctor();
+}
+__name(resolveOrNew, "resolveOrNew");
+
+export {
+  resolveOrNew
+};
+//# sourceMappingURL=chunk-LKNI6QEP.js.map

package/dist/chunk-LKNI6QEP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/bridge/di-resolve.ts"],"sourcesContent":["/**\n * Shared DI resolution helper for guards, interceptors, and middleware.\n * Extracted to avoid DRY violation (EC-3) — was duplicated in create-server.ts\n * and theokit-plugin.ts.\n */\n\n/** DI container interface — structural match for @theokit/di Container. */\nexport interface DiContainer {\n  resolve<T>(token: Function): T\n}\n\n/**\n * Resolve a class via DI container if provided; otherwise fall back to bare `new`.\n * Guards, interceptors, and middleware classes all use this pattern.\n */\nexport function resolveOrNew(Ctor: Function, container?: DiContainer): object {\n  if (container) {\n    try {\n      return container.resolve(Ctor)\n    } catch {\n      // MissingInjectableError or similar — fall back to bare new\n    }\n  }\n  return new (Ctor as new () => object)()\n}\n"],"mappings":";;;;;AAeO,SAASA,aAAaC,MAAgBC,WAAuB;AAClE,MAAIA,WAAW;AACb,QAAI;AACF,aAAOA,UAAUC,QAAQF,IAAAA;IAC3B,QAAQ;IAER;EACF;AACA,SAAO,IAAKA,KAAAA;AACd;AATgBD;","names":["resolveOrNew","Ctor","container","resolve"]}

package/dist/chunk-LWCNTZN6.js

@@ -0,0 +1,87 @@
+import {
+  resolveOrNew
+} from "./chunk-LKNI6QEP.js";
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/bridge/middleware-consumer.ts
+var MiddlewareConsumerImpl = class {
+  static {
+    __name(this, "MiddlewareConsumerImpl");
+  }
+  entries = [];
+  container;
+  constructor(container) {
+    this.container = container;
+  }
+  apply(...middleware) {
+    const resolved = middleware.map((m) => this.resolveMiddleware(m));
+    const excludePatterns = [];
+    const proxy = {
+      exclude: /* @__PURE__ */ __name((...routes) => {
+        for (const r of routes) excludePatterns.push(typeof r === "string" ? r : r.path);
+        return proxy;
+      }, "exclude"),
+      forRoutes: /* @__PURE__ */ __name((...routes) => {
+        const routePatterns = routes.map((r) => typeof r === "string" ? r : r.path);
+        for (const handler of resolved) {
+          this.entries.push({
+            handler,
+            routePatterns: [
+              ...routePatterns
+            ],
+            excludePatterns: [
+              ...excludePatterns
+            ]
+          });
+        }
+        return this;
+      }, "forRoutes")
+    };
+    return proxy;
+  }
+  getEntries() {
+    return this.entries;
+  }
+  resolveMiddleware(m) {
+    if (typeof m === "function" && !m.prototype?.use) {
+      return m;
+    }
+    const instance = resolveOrNew(m, this.container);
+    return (request, next) => instance.use(request, next);
+  }
+};
+function middlewareMatchesPath(entry, requestPath) {
+  for (const pattern of entry.excludePatterns) {
+    if (pathMatches(requestPath, pattern)) return false;
+  }
+  for (const pattern of entry.routePatterns) {
+    if (pathMatches(requestPath, pattern)) return true;
+  }
+  return false;
+}
+__name(middlewareMatchesPath, "middlewareMatchesPath");
+function pathMatches(requestPath, pattern) {
+  if (pattern === "*") return true;
+  const normPath = ("/" + requestPath).replace(/\/+/g, "/").replace(/\/$/, "");
+  const normPattern = ("/" + pattern).replace(/\/+/g, "/").replace(/\/$/, "");
+  return normPath === normPattern || normPath.startsWith(normPattern + "/");
+}
+__name(pathMatches, "pathMatches");
+async function runMiddleware(entries, request, requestPath) {
+  for (const entry of entries) {
+    if (!middlewareMatchesPath(entry, requestPath)) continue;
+    const response = await entry.handler(request, () => Promise.resolve(null));
+    if (response) return response;
+  }
+  return null;
+}
+__name(runMiddleware, "runMiddleware");
+
+export {
+  MiddlewareConsumerImpl,
+  middlewareMatchesPath,
+  runMiddleware
+};
+//# sourceMappingURL=chunk-LWCNTZN6.js.map

package/dist/chunk-LWCNTZN6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/bridge/middleware-consumer.ts"],"sourcesContent":["/**\n * NestJS-style Middleware support — Web Standard Request/Response.\n *\n * Middleware runs BEFORE guards: middleware → guards → interceptors → handler\n *\n * Supports class middleware (NestMiddleware) and functional middleware.\n * Returns a Response to short-circuit, or null to continue.\n */\nimport { resolveOrNew, type DiContainer } from './di-resolve.js'\n\n/** NestJS-compatible middleware interface — Web Standard. */\nexport interface NestMiddleware {\n  use(\n    request: Request,\n    next: () => Promise<Response | null>,\n  ): Response | null | Promise<Response | null>\n}\n\n/** Functional middleware. */\nexport type MiddlewareFn = (\n  request: Request,\n  next: () => Promise<Response | null>,\n) => Response | null | Promise<Response | null>\n\nexport interface ResolvedMiddleware {\n  handler: MiddlewareFn\n  routePatterns: string[]\n  excludePatterns: string[]\n}\n\nexport type RouteInfo = string | { path: string; method?: string }\n\nexport interface MiddlewareConfigProxy {\n  forRoutes(...routes: RouteInfo[]): MiddlewareConsumerImpl\n  exclude(...routes: RouteInfo[]): MiddlewareConfigProxy\n}\n\nexport class MiddlewareConsumerImpl {\n  private entries: ResolvedMiddleware[] = []\n  private container?: DiContainer\n\n  constructor(container?: DiContainer) {\n    this.container = container\n  }\n\n  apply(...middleware: (Function | MiddlewareFn)[]): MiddlewareConfigProxy {\n    const resolved = middleware.map((m) => this.resolveMiddleware(m))\n    const excludePatterns: string[] = []\n\n    const proxy: MiddlewareConfigProxy = {\n      exclude: (...routes: RouteInfo[]) => {\n        for (const r of routes) excludePatterns.push(typeof r === 'string' ? r : r.path)\n        return proxy\n      },\n      forRoutes: (...routes: RouteInfo[]) => {\n        const routePatterns = routes.map((r) => (typeof r === 'string' ? r : r.path))\n        for (const handler of resolved) {\n          this.entries.push({ handler, routePatterns: [...routePatterns], excludePatterns: [...excludePatterns] })\n        }\n        return this\n      },\n    }\n    return proxy\n  }\n\n  getEntries(): ResolvedMiddleware[] {\n    return this.entries\n  }\n\n  private resolveMiddleware(m: Function | MiddlewareFn): MiddlewareFn {\n    if (typeof m === 'function' && !m.prototype?.use) {\n      return m as MiddlewareFn\n    }\n    const instance = resolveOrNew(m, this.container) as NestMiddleware\n    return (request, next) => instance.use(request, next)\n  }\n}\n\nexport function middlewareMatchesPath(entry: ResolvedMiddleware, requestPath: string): boolean {\n  for (const pattern of entry.excludePatterns) {\n    if (pathMatches(requestPath, pattern)) return false\n  }\n  for (const pattern of entry.routePatterns) {\n    if (pathMatches(requestPath, pattern)) return true\n  }\n  return false\n}\n\nfunction pathMatches(requestPath: string, pattern: string): boolean {\n  if (pattern === '*') return true\n  const normPath = ('/' + requestPath).replace(/\\/+/g, '/').replace(/\\/$/, '')\n  const normPattern = ('/' + pattern).replace(/\\/+/g, '/').replace(/\\/$/, '')\n  return normPath === normPattern || normPath.startsWith(normPattern + '/')\n}\n\n/**\n * Run all matching middleware. Returns a Response if any short-circuited, null otherwise.\n */\nexport async function runMiddleware(\n  entries: ResolvedMiddleware[],\n  request: Request,\n  requestPath: string,\n): Promise<Response | null> {\n  for (const entry of entries) {\n    if (!middlewareMatchesPath(entry, requestPath)) continue\n    const response = await entry.handler(request, () => Promise.resolve(null))\n    if (response) return response // short-circuit\n  }\n  return null\n}\n"],"mappings":";;;;;;;;AAqCO,IAAMA,yBAAN,MAAMA;EArCb,OAqCaA;;;EACHC,UAAgC,CAAA;EAChCC;EAER,YAAYA,WAAyB;AACnC,SAAKA,YAAYA;EACnB;EAEAC,SAASC,YAAgE;AACvE,UAAMC,WAAWD,WAAWE,IAAI,CAACC,MAAM,KAAKC,kBAAkBD,CAAAA,CAAAA;AAC9D,UAAME,kBAA4B,CAAA;AAElC,UAAMC,QAA+B;MACnCC,SAAS,2BAAIC,WAAAA;AACX,mBAAWC,KAAKD,OAAQH,iBAAgBK,KAAK,OAAOD,MAAM,WAAWA,IAAIA,EAAEE,IAAI;AAC/E,eAAOL;MACT,GAHS;MAITM,WAAW,2BAAIJ,WAAAA;AACb,cAAMK,gBAAgBL,OAAON,IAAI,CAACO,MAAO,OAAOA,MAAM,WAAWA,IAAIA,EAAEE,IAAI;AAC3E,mBAAWG,WAAWb,UAAU;AAC9B,eAAKJ,QAAQa,KAAK;YAAEI;YAASD,eAAe;iBAAIA;;YAAgBR,iBAAiB;iBAAIA;;UAAiB,CAAA;QACxG;AACA,eAAO;MACT,GANW;IAOb;AACA,WAAOC;EACT;EAEAS,aAAmC;AACjC,WAAO,KAAKlB;EACd;EAEQO,kBAAkBD,GAA0C;AAClE,QAAI,OAAOA,MAAM,cAAc,CAACA,EAAEa,WAAWC,KAAK;AAChD,aAAOd;IACT;AACA,UAAMe,WAAWC,aAAahB,GAAG,KAAKL,SAAS;AAC/C,WAAO,CAACsB,SAASC,SAASH,SAASD,IAAIG,SAASC,IAAAA;EAClD;AACF;AAEO,SAASC,sBAAsBC,OAA2BC,aAAmB;AAClF,aAAWC,WAAWF,MAAMlB,iBAAiB;AAC3C,QAAIqB,YAAYF,aAAaC,OAAAA,EAAU,QAAO;EAChD;AACA,aAAWA,WAAWF,MAAMV,eAAe;AACzC,QAAIa,YAAYF,aAAaC,OAAAA,EAAU,QAAO;EAChD;AACA,SAAO;AACT;AARgBH;AAUhB,SAASI,YAAYF,aAAqBC,SAAe;AACvD,MAAIA,YAAY,IAAK,QAAO;AAC5B,QAAME,YAAY,MAAMH,aAAaI,QAAQ,QAAQ,GAAA,EAAKA,QAAQ,OAAO,EAAA;AACzE,QAAMC,eAAe,MAAMJ,SAASG,QAAQ,QAAQ,GAAA,EAAKA,QAAQ,OAAO,EAAA;AACxE,SAAOD,aAAaE,eAAeF,SAASG,WAAWD,cAAc,GAAA;AACvE;AALSH;AAUT,eAAsBK,cACpBlC,SACAuB,SACAI,aAAmB;AAEnB,aAAWD,SAAS1B,SAAS;AAC3B,QAAI,CAACyB,sBAAsBC,OAAOC,WAAAA,EAAc;AAChD,UAAMQ,WAAW,MAAMT,MAAMT,QAAQM,SAAS,MAAMa,QAAQC,QAAQ,IAAA,CAAA;AACpE,QAAIF,SAAU,QAAOA;EACvB;AACA,SAAO;AACT;AAXsBD;","names":["MiddlewareConsumerImpl","entries","container","apply","middleware","resolved","map","m","resolveMiddleware","excludePatterns","proxy","exclude","routes","r","push","path","forRoutes","routePatterns","handler","getEntries","prototype","use","instance","resolveOrNew","request","next","middlewareMatchesPath","entry","requestPath","pattern","pathMatches","normPath","replace","normPattern","startsWith","runMiddleware","response","Promise","resolve"]}

package/dist/chunk-SMWUPP2C.js

@@ -0,0 +1,125 @@
+import {
+  CONTROLLER_PREFIX,
+  ROUTE_HEADERS,
+  ROUTE_METHODS,
+  ROUTE_PARAMS,
+  ROUTE_REDIRECT,
+  ROUTE_STATUS,
+  USE_FILTERS,
+  USE_GUARDS,
+  USE_INTERCEPTORS,
+  getMeta
+} from "./chunk-3PGQVQWG.js";
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/bridge/execution-context.ts
+function createExecutionContext(request, controllerClass, methodName) {
+  const url = new URL(request.url);
+  return {
+    getRequest: /* @__PURE__ */ __name(() => request, "getRequest"),
+    getUrl: /* @__PURE__ */ __name(() => url, "getUrl"),
+    getClass: /* @__PURE__ */ __name(() => controllerClass, "getClass"),
+    getMethodName: /* @__PURE__ */ __name(() => methodName, "getMethodName")
+  };
+}
+__name(createExecutionContext, "createExecutionContext");
+
+// src/bridge/dto-zod.ts
+function resolveDtoSchema(dtoClass) {
+  if (typeof dtoClass !== "function") return void 0;
+  const maybe = dtoClass.schema;
+  if (maybe !== null && maybe !== void 0 && typeof maybe.safeParse === "function") {
+    return maybe;
+  }
+  return void 0;
+}
+__name(resolveDtoSchema, "resolveDtoSchema");
+
+// src/bridge/errors.ts
+var HttpDecoratorsConfigError = class extends Error {
+  static {
+    __name(this, "HttpDecoratorsConfigError");
+  }
+  name = "HttpDecoratorsConfigError";
+  constructor(message) {
+    super(message);
+  }
+};
+
+// src/bridge/walk-metadata.ts
+import "reflect-metadata";
+function joinPath(prefix, path) {
+  return ("/" + prefix + "/" + path).replace(/\/+/g, "/").replace(/\/$/, "") || "/";
+}
+__name(joinPath, "joinPath");
+function resolveBodySchema(paramEntries, ControllerClass, propertyKey) {
+  const bodyParam = paramEntries.find((p) => p.source === "body" && !p.key);
+  if (!bodyParam) return void 0;
+  if (bodyParam.schema) return bodyParam.schema;
+  const paramTypes = Reflect.getMetadata("design:paramtypes", ControllerClass.prototype, propertyKey) ?? [];
+  if (paramTypes.length > 0) {
+    return resolveDtoSchema(paramTypes[bodyParam.index]);
+  }
+  console.warn(`[@theokit/http] method ${String(propertyKey)} on ${ControllerClass.name}: @Body() without explicit schema and emitDecoratorMetadata is not active. Body will be passed raw (no validation). Fix: use @Body(zodSchema) for validation without metadata emission.`);
+  return void 0;
+}
+__name(resolveBodySchema, "resolveBodySchema");
+var walkCache = /* @__PURE__ */ new WeakMap();
+function walkControllerMetadata(ControllerClass) {
+  const cached = walkCache.get(ControllerClass);
+  if (cached) return cached;
+  const controllerMeta = getMeta(CONTROLLER_PREFIX, ControllerClass);
+  if (!controllerMeta) {
+    throw new HttpDecoratorsConfigError(`Controller class ${ControllerClass.name} is missing @Controller() decorator. Add @Controller('prefix') to the class declaration.`);
+  }
+  const { prefix, host } = controllerMeta;
+  if (host) {
+    console.warn(`[@theokit/http] @Controller host '${host}' captured but enforcement deferred to v0.2.0`);
+  }
+  const methods = getMeta(ROUTE_METHODS, ControllerClass) ?? [];
+  const paramsMap = getMeta(ROUTE_PARAMS, ControllerClass) ?? /* @__PURE__ */ new Map();
+  const classGuards = getMeta(USE_GUARDS, ControllerClass) ?? [];
+  const classInterceptors = getMeta(USE_INTERCEPTORS, ControllerClass) ?? [];
+  const classFilters = getMeta(USE_FILTERS, ControllerClass) ?? [];
+  const result = methods.map((m) => {
+    const paramEntries = paramsMap.get(m.propertyKey) ?? [];
+    const bodySchema = resolveBodySchema(paramEntries, ControllerClass, m.propertyKey);
+    const methodGuards = getMeta(USE_GUARDS, ControllerClass, m.propertyKey) ?? [];
+    const methodInterceptors = getMeta(USE_INTERCEPTORS, ControllerClass, m.propertyKey) ?? [];
+    return {
+      verb: m.verb,
+      fullPath: joinPath(prefix, m.path),
+      propertyKey: m.propertyKey,
+      bodySchema,
+      paramEntries: [
+        ...paramEntries
+      ].sort((a, b) => a.index - b.index),
+      status: getMeta(ROUTE_STATUS, ControllerClass, m.propertyKey),
+      headers: getMeta(ROUTE_HEADERS, ControllerClass, m.propertyKey) ?? [],
+      redirect: getMeta(ROUTE_REDIRECT, ControllerClass, m.propertyKey),
+      guards: [
+        ...classGuards,
+        ...methodGuards
+      ],
+      interceptors: [
+        ...classInterceptors,
+        ...methodInterceptors
+      ],
+      filters: getMeta(USE_FILTERS, ControllerClass, m.propertyKey) ?? classFilters
+    };
+  });
+  walkCache.set(ControllerClass, result);
+  return result;
+}
+__name(walkControllerMetadata, "walkControllerMetadata");
+
+export {
+  createExecutionContext,
+  resolveDtoSchema,
+  HttpDecoratorsConfigError,
+  joinPath,
+  walkControllerMetadata
+};
+//# sourceMappingURL=chunk-SMWUPP2C.js.map

package/dist/chunk-SMWUPP2C.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/bridge/execution-context.ts","../src/bridge/dto-zod.ts","../src/bridge/errors.ts","../src/bridge/walk-metadata.ts"],"sourcesContent":["/**\n * ExecutionContext — Web Standard Request-based context passed to guards.\n *\n * Per ADR D460: the pipeline operates on Web Standard Request/Response.\n * node:http types live ONLY in the runtime adapter (runtime/node.ts).\n *\n * Guards access request headers via request.headers.get('x-role'),\n * NOT via req.headers['x-role'].\n */\n\n/**\n * Execution context available in guards during request processing.\n * Uses Web Standard Request (works on Node, Bun, Deno, CF Workers).\n */\nexport interface ExecutionContext {\n  /** The Web Standard Request object. */\n  getRequest(): Request\n  /** Parsed URL (convenience — avoids re-parsing). */\n  getUrl(): URL\n  /** The controller class constructor. */\n  getClass(): Function\n  /** The handler method name (property key on the controller). */\n  getMethodName(): string | symbol\n}\n\n/**\n * Interface for guard classes (bound via @UseGuards).\n *\n * @example\n * ```ts\n * class RolesGuard implements CanActivate {\n *   canActivate(context: ExecutionContext): boolean {\n *     const request = context.getRequest()\n *     const role = request.headers.get('x-role')\n *     return role === 'admin'\n *   }\n * }\n * ```\n */\nexport interface CanActivate {\n  canActivate(context: ExecutionContext): boolean | Promise<boolean>\n}\n\n/** Create an ExecutionContext from a Web Standard Request. */\nexport function createExecutionContext(\n  request: Request,\n  controllerClass: Function,\n  methodName: string | symbol,\n): ExecutionContext {\n  const url = new URL(request.url)\n  return {\n    getRequest: () => request,\n    getUrl: () => url,\n    getClass: () => controllerClass,\n    getMethodName: () => methodName,\n  }\n}\n","import type { ZodTypeAny } from 'zod'\n\n/**\n * Resolves a Zod schema from a DTO class via the `static schema` convention (Pattern D2).\n * Returns undefined when the class doesn't carry a compatible schema.\n */\nexport function resolveDtoSchema(dtoClass: unknown): ZodTypeAny | undefined {\n  if (typeof dtoClass !== 'function') return undefined\n  const maybe = (dtoClass as unknown as Record<string, unknown>).schema\n  if (\n    maybe !== null &&\n    maybe !== undefined &&\n    typeof (maybe as Record<string, unknown>).safeParse === 'function'\n  ) {\n    return maybe as ZodTypeAny\n  }\n  return undefined\n}\n","/**\n * Configuration error thrown by the bridge when decorator setup is incomplete.\n * Carries actionable messages pointing consumers to the migration guide.\n */\nexport class HttpDecoratorsConfigError extends Error {\n  override readonly name = 'HttpDecoratorsConfigError'\n\n  constructor(message: string) {\n    super(message)\n  }\n}\n","import 'reflect-metadata'\nimport type { ZodTypeAny } from 'zod'\n\nimport type { ControllerMeta } from '../decorators/controller.js'\nimport type { RouteMethodEntry, HttpVerb } from '../decorators/methods.js'\nimport type { ParamEntry } from '../decorators/params.js'\nimport type { RedirectMeta } from '../decorators/response.js'\nimport {\n  getMeta,\n  CONTROLLER_PREFIX,\n  ROUTE_METHODS,\n  ROUTE_PARAMS,\n  ROUTE_STATUS,\n  ROUTE_HEADERS,\n  ROUTE_REDIRECT,\n  USE_GUARDS,\n  USE_INTERCEPTORS,\n  USE_FILTERS,\n} from '../metadata/index.js'\n\nimport { resolveDtoSchema } from './dto-zod.js'\nimport { HttpDecoratorsConfigError } from './errors.js'\n\nexport interface WalkResult {\n  verb: HttpVerb\n  fullPath: string\n  propertyKey: string | symbol\n  bodySchema?: ZodTypeAny\n  querySchema?: ZodTypeAny\n  paramsSchema?: ZodTypeAny\n  paramEntries: ParamEntry[]\n  status?: number\n  headers: [string, string][]\n  redirect?: RedirectMeta\n  guards: Function[]\n  interceptors: Function[]\n  filters: Function[]\n}\n\n/**\n * Normalize a joined path: strip doubles, trim trailing, ensure leading.\n * (EC-3)\n */\nexport function joinPath(prefix: string, path: string): string {\n  return ('/' + prefix + '/' + path).replace(/\\/+/g, '/').replace(/\\/$/, '') || '/'\n}\n\n/**\n * Resolve the Zod body schema for a method's @Body() param entry.\n *\n * Priority: explicit @Body(zodSchema) > design:paramtypes + DTO static schema.\n * EC-4 relaxed: warns (not throws) when paramtypes missing — @Body(zodSchema) is the fix.\n */\nfunction resolveBodySchema(\n  paramEntries: ParamEntry[],\n  ControllerClass: Function,\n  propertyKey: string | symbol,\n): ZodTypeAny | undefined {\n  const bodyParam = paramEntries.find((p) => p.source === 'body' && !p.key)\n  if (!bodyParam) return undefined\n\n  // Priority 1: explicit Zod schema from @Body(zodSchema)\n  if (bodyParam.schema) return bodyParam.schema\n\n  // Priority 2: design:paramtypes + DTO static schema (requires emitDecoratorMetadata)\n  const paramTypes: Function[] =\n    Reflect.getMetadata('design:paramtypes', ControllerClass.prototype, propertyKey) ?? []\n  if (paramTypes.length > 0) {\n    return resolveDtoSchema(paramTypes[bodyParam.index])\n  }\n\n  // EC-4 relaxed: warn when @Body() has no schema and no paramtypes\n  console.warn(\n    `[@theokit/http] method ${String(propertyKey)} on ` +\n      `${ControllerClass.name}: @Body() without explicit schema and ` +\n      `emitDecoratorMetadata is not active. Body will be passed raw (no validation). ` +\n      `Fix: use @Body(zodSchema) for validation without metadata emission.`,\n  )\n  return undefined\n}\n\n/** WeakMap cache — metadata is immutable; walk once, reuse forever. */\nconst walkCache = new WeakMap<Function, WalkResult[]>()\n\n/**\n * Walk all decorator metadata on a controller class and produce\n * a structured list of route descriptors. Memoized per class via WeakMap.\n */\nexport function walkControllerMetadata(ControllerClass: Function): WalkResult[] {\n  const cached = walkCache.get(ControllerClass)\n  if (cached) return cached\n  // EC-2: throw when @Controller decorator is missing\n  const controllerMeta = getMeta<ControllerMeta>(CONTROLLER_PREFIX, ControllerClass)\n  if (!controllerMeta) {\n    throw new HttpDecoratorsConfigError(\n      `Controller class ${ControllerClass.name} is missing @Controller() decorator. ` +\n        `Add @Controller('prefix') to the class declaration.`,\n    )\n  }\n  const { prefix, host } = controllerMeta\n\n  // Q4: host captured but enforcement deferred to v0.2.0\n  if (host) {\n    console.warn(\n      `[@theokit/http] @Controller host '${host}' captured but enforcement deferred to v0.2.0`,\n    )\n  }\n\n  const methods = getMeta<RouteMethodEntry[]>(ROUTE_METHODS, ControllerClass) ?? []\n  const paramsMap =\n    getMeta<Map<string | symbol, ParamEntry[]>>(ROUTE_PARAMS, ControllerClass) ?? new Map()\n\n  // Class-level guards/interceptors\n  const classGuards = getMeta<Function[]>(USE_GUARDS, ControllerClass) ?? []\n  const classInterceptors = getMeta<Function[]>(USE_INTERCEPTORS, ControllerClass) ?? []\n  const classFilters = getMeta<Function[]>(USE_FILTERS, ControllerClass) ?? []\n\n  const result = methods.map((m) => {\n    const paramEntries = paramsMap.get(m.propertyKey) ?? []\n    const bodySchema = resolveBodySchema(paramEntries, ControllerClass, m.propertyKey)\n\n    // Method-level guards/interceptors (composed: class FIRST per NestJS convention — EC-9)\n    const methodGuards = getMeta<Function[]>(USE_GUARDS, ControllerClass, m.propertyKey) ?? []\n    const methodInterceptors =\n      getMeta<Function[]>(USE_INTERCEPTORS, ControllerClass, m.propertyKey) ?? []\n\n    return {\n      verb: m.verb,\n      fullPath: joinPath(prefix, m.path),\n      propertyKey: m.propertyKey,\n      bodySchema,\n      paramEntries: [...paramEntries].sort((a, b) => a.index - b.index),\n      status: getMeta<number>(ROUTE_STATUS, ControllerClass, m.propertyKey),\n      headers: getMeta<[string, string][]>(ROUTE_HEADERS, ControllerClass, m.propertyKey) ?? [],\n      redirect: getMeta<RedirectMeta>(ROUTE_REDIRECT, ControllerClass, m.propertyKey),\n      guards: [...classGuards, ...methodGuards],\n      interceptors: [...classInterceptors, ...methodInterceptors],\n      filters: getMeta<Function[]>(USE_FILTERS, ControllerClass, m.propertyKey) ?? classFilters,\n    }\n  })\n\n  walkCache.set(ControllerClass, result)\n  return result\n}\n"],"mappings":"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","names":["createExecutionContext","request","controllerClass","methodName","url","URL","getRequest","getUrl","getClass","getMethodName","resolveDtoSchema","dtoClass","undefined","maybe","schema","safeParse","HttpDecoratorsConfigError","Error","name","message","joinPath","prefix","path","replace","resolveBodySchema","paramEntries","ControllerClass","propertyKey","bodyParam","find","p","source","key","undefined","schema","paramTypes","Reflect","getMetadata","prototype","length","resolveDtoSchema","index","console","warn","String","name","walkCache","WeakMap","walkControllerMetadata","cached","get","controllerMeta","getMeta","CONTROLLER_PREFIX","HttpDecoratorsConfigError","host","methods","ROUTE_METHODS","paramsMap","ROUTE_PARAMS","Map","classGuards","USE_GUARDS","classInterceptors","USE_INTERCEPTORS","classFilters","USE_FILTERS","result","map","m","bodySchema","methodGuards","methodInterceptors","verb","fullPath","sort","a","b","status","ROUTE_STATUS","headers","ROUTE_HEADERS","redirect","ROUTE_REDIRECT","guards","interceptors","filters","set"]}