@theokit/http 0.5.4 → 0.7.0

package/dist/index.js

@@ -2,35 +2,44 @@ import {
   TheoApp,
   createStaticHandler,
   getMimeType,
-  isSafePath
-} from "./chunk-NDD7ANXZ.js";
+  getRequestContext,
+  isSafePath,
+  renderToStream,
+  streamToResponse,
+  tryGetRequestContext
+} from "./chunk-GXTGOPRU.js";
 import {
   MiddlewareConsumerImpl,
+  isControllerClass,
+  loadControllerWithSwc,
+  loadControllersFromGlob,
   middlewareMatchesPath,
-  runMiddleware
-} from "./chunk-LWCNTZN6.js";
+  runMiddleware,
+  transformControllerSource
+} from "./chunk-OBHHOS6E.js";
 import {
   HttpDecoratorsConfigError,
   createExecutionContext,
   joinPath,
   resolveDtoSchema,
   walkControllerMetadata
-} from "./chunk-QGB5YC4T.js";
+} from "./chunk-JQMJK47T.js";
 import {
   createNodeAdapter
 } from "./chunk-HLW7YKZE.js";
 import {
   runInterceptors
-} from "./chunk-U46H4CGF.js";
+} from "./chunk-ELCXHPAD.js";
 import {
   runExceptionFilters
-} from "./chunk-34KOKJ5M.js";
+} from "./chunk-CMPP4ULU.js";
 import {
   BadGatewayException,
   BadRequestException,
   CATCH_EXCEPTIONS,
   CONTROLLER_PREFIX,
   ConflictException,
+  EXPOSE_AGENT,
   ForbiddenException,
   GatewayTimeoutException,
   GoneException,
@@ -61,10 +70,10 @@ import {
   UnsupportedMediaTypeException,
   getMeta,
   setMeta
-} from "./chunk-3PGQVQWG.js";
+} from "./chunk-KPC7AIVC.js";
 import {
   resolveOrNew
-} from "./chunk-LKNI6QEP.js";
+} from "./chunk-MQAJWR3K.js";
 import {
   __name
 } from "./chunk-7QVYU63E.js";
@@ -170,6 +179,20 @@ function Res(opts) {
 }
 __name(Res, "Res");
 
+// src/decorators/expose.ts
+function Expose(agent, opts = {}) {
+  return (target, propertyKey) => {
+    const existing = getMeta(EXPOSE_AGENT, target.constructor) ?? [];
+    existing.push({
+      agent,
+      opts,
+      propertyKey
+    });
+    setMeta(EXPOSE_AGENT, target.constructor, existing);
+  };
+}
+__name(Expose, "Expose");
+
 // src/decorators/response.ts
 function HttpCode(status) {
   return (target, propertyKey) => {
@@ -415,11 +438,12 @@ __name(registerControllers, "registerControllers");
 
 // src/bridge/create-server.ts
 import "reflect-metadata";
-function createDecoratorServer(controllersOrOpts) {
-  const { controllers, container, configure } = Array.isArray(controllersOrOpts) ? {
+function createDecoratorHandler(controllersOrOpts) {
+  const { controllers, container, configure, serveAgent } = Array.isArray(controllersOrOpts) ? {
     controllers: controllersOrOpts,
     container: void 0,
-    configure: void 0
+    configure: void 0,
+    serveAgent: void 0
   } : controllersOrOpts;
   const middlewareConsumer = new MiddlewareConsumerImpl(container);
   if (configure) configure(middlewareConsumer);
@@ -448,24 +472,33 @@ function createDecoratorServer(controllersOrOpts) {
     if (aP !== bP) return aP ? 1 : -1;
     return 0;
   });
+  const handler = /* @__PURE__ */ __name((request) => handleRequest(routes, request, container, middlewareEntries, serveAgent), "handler");
+  handler.matches = (method, pathname) => findRoute(routes, method.toUpperCase(), pathname) !== null;
+  return handler;
+}
+__name(createDecoratorHandler, "createDecoratorHandler");
+function createDecoratorServer(controllersOrOpts) {
+  const handle = createDecoratorHandler(controllersOrOpts);
   const adapter = createNodeAdapter();
-  const handler = /* @__PURE__ */ __name((request) => handleRequest(routes, request, container, middlewareEntries), "handler");
-  return adapter.createServer(handler);
+  return adapter.createServer(async (request) => {
+    const res = await handle(request);
+    if (res) return res;
+    const { pathname } = new URL(request.url);
+    return jsonResponse(404, {
+      error: {
+        code: "NOT_FOUND",
+        message: `No route for ${request.method.toUpperCase()} ${pathname}`
+      }
+    });
+  });
 }
 __name(createDecoratorServer, "createDecoratorServer");
-async function handleRequest(routes, request, container, middlewareEntries = []) {
+async function handleRequest(routes, request, container, middlewareEntries = [], serveAgent) {
   const url = new URL(request.url);
   const method = request.method.toUpperCase();
   const pathname = url.pathname;
   const match = findRoute(routes, method, pathname);
-  if (!match) {
-    return jsonResponse(404, {
-      error: {
-        code: "NOT_FOUND",
-        message: `No route for ${method} ${pathname}`
-      }
-    });
-  }
+  if (!match) return null;
   const { walk, instance, params } = match;
   try {
     const mwResponse = await runMiddleware(middlewareEntries, request, pathname);
@@ -473,6 +506,17 @@ async function handleRequest(routes, request, container, middlewareEntries = [])
     const ctx = createExecutionContext(request, instance.constructor, walk.propertyKey);
     const guardResponse = await runGuards(walk.guards, ctx, container);
     if (guardResponse) return guardResponse;
+    if (walk.agent) {
+      if (!serveAgent) {
+        return jsonResponse(500, {
+          error: {
+            code: "AGENT_SERVER_NOT_WIRED",
+            message: `Controller route ${String(walk.propertyKey)} is @Expose-bound but no serveAgent was provided to createDecoratorHandler. The framework must wire serveAgent (mountAgent).`
+          }
+        });
+      }
+      return await serveAgent(walk.agent.module, request, walk.agent.opts);
+    }
     const body = await resolveBody(method, request, walk);
     if (body instanceof Response) return body;
     const args = buildArgs(walk.paramEntries, {
@@ -491,6 +535,7 @@ async function handleRequest(routes, request, container, middlewareEntries = [])
     }
     const handlerFn = instance[walk.propertyKey];
     const result = await runInterceptors(walk.interceptors, () => handlerFn.apply(instance, args), request, container);
+    if (result instanceof Response) return result;
     return buildResponse(result, walk, method);
   } catch (err) {
     return runExceptionFilters(err, walk.filters, request, container);
@@ -690,6 +735,152 @@ function contract(routes) {
   return routes;
 }
 __name(contract, "contract");
+
+// src/error-digest.ts
+function djb2(input) {
+  let hash = 5381;
+  for (let i = 0; i < input.length; i++) {
+    hash = (hash << 5) + hash + input.charCodeAt(i) | 0;
+  }
+  return (hash >>> 0).toString(16);
+}
+__name(djb2, "djb2");
+function digestError(err, context = {}) {
+  const message = extractMessage(err);
+  const status = extractStatus(err);
+  const rawStack = extractStack(err);
+  const digest = djb2(message);
+  const isProduction = process.env.NODE_ENV === "production";
+  return {
+    digest,
+    message,
+    status,
+    context,
+    ...rawStack && !isProduction ? {
+      stack: rawStack
+    } : {}
+  };
+}
+__name(digestError, "digestError");
+function extractMessage(err) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  if (typeof err === "string") {
+    return err;
+  }
+  if (typeof err === "number") {
+    return String(err);
+  }
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return "Unknown error";
+  }
+}
+__name(extractMessage, "extractMessage");
+function extractStatus(err) {
+  if (err instanceof HttpException) {
+    return err.statusCode;
+  }
+  return 500;
+}
+__name(extractStatus, "extractStatus");
+function extractStack(err) {
+  if (err instanceof Error) {
+    return err.stack;
+  }
+  return void 0;
+}
+__name(extractStack, "extractStack");
+
+// src/component-tree.ts
+function createErrorBoundary(React, FallbackComponent) {
+  return class ErrorBoundary extends React.Component {
+    static {
+      __name(this, "ErrorBoundary");
+    }
+    constructor(props) {
+      super(props);
+      this.state = {
+        hasError: false
+      };
+    }
+    static getDerivedStateFromError() {
+      return {
+        hasError: true
+      };
+    }
+    render() {
+      if (this.state.hasError) {
+        return React.createElement(FallbackComponent);
+      }
+      return React.createElement(React.Fragment, null, this.props.children);
+    }
+  };
+}
+__name(createErrorBoundary, "createErrorBoundary");
+async function composeComponentTree(tree) {
+  const React = await import("react");
+  return composeNode(React, tree);
+}
+__name(composeComponentTree, "composeComponentTree");
+function composeNode(React, node) {
+  const { layout: Layout, page: Page, loading: Loading, error: ErrorFallback } = node;
+  if (!Page) {
+    return null;
+  }
+  let element = React.createElement(Page);
+  if (Loading) {
+    element = React.createElement(React.Suspense, {
+      fallback: React.createElement(Loading)
+    }, element);
+  }
+  if (ErrorFallback) {
+    const Boundary = createErrorBoundary(React, ErrorFallback);
+    element = React.createElement(Boundary, null, element);
+  }
+  if (Layout) {
+    element = React.createElement(Layout, null, element);
+  }
+  return element;
+}
+__name(composeNode, "composeNode");
+
+// src/cache-signal.ts
+function revalidateTag(tag) {
+  collectSignal({
+    kind: "tag",
+    value: tag,
+    timestamp: Date.now()
+  });
+}
+__name(revalidateTag, "revalidateTag");
+function revalidatePath(path) {
+  collectSignal({
+    kind: "path",
+    value: path,
+    timestamp: Date.now()
+  });
+}
+__name(revalidatePath, "revalidatePath");
+function getRevalidationSignals() {
+  const ctx = tryGetRequestContext();
+  if (!ctx) return [];
+  return ctx._revalidationSignals ?? [];
+}
+__name(getRevalidationSignals, "getRevalidationSignals");
+function collectSignal(signal) {
+  const ctx = tryGetRequestContext();
+  if (!ctx) {
+    console.warn("[theokit] revalidateTag/revalidatePath called outside a request context. Signal ignored.");
+    return;
+  }
+  const extended = ctx;
+  extended._revalidationSignals ??= [];
+  extended._revalidationSignals.push(signal);
+}
+__name(collectSignal, "collectSignal");
 export {
   All,
   BadGatewayException,
@@ -701,6 +892,8 @@ export {
   ConflictException,
   Controller,
   Delete,
+  EXPOSE_AGENT,
+  Expose,
   ForbiddenException,
   GatewayTimeoutException,
   Get,
@@ -757,26 +950,40 @@ export {
   UseFilters,
   UseGuards,
   UseInterceptors,
+  composeComponentTree,
   contract,
   createDecorator,
+  createDecoratorHandler,
   createDecoratorServer,
   createExecutionContext,
   createStaticHandler,
   createTypedClient,
+  digestError,
   getMeta,
   getMimeType,
+  getRequestContext,
+  getRevalidationSignals,
   getThrottleOptions,
+  isControllerClass,
   isSafePath,
   isThrottleSkipped,
   joinPath,
+  loadControllerWithSwc,
+  loadControllersFromGlob,
   middlewareMatchesPath,
   registerControllers,
+  renderToStream,
   resolveDtoSchema,
   resolveOrNew,
+  revalidatePath,
+  revalidateTag,
   runExceptionFilters,
   runInterceptors,
   runMiddleware,
   setMeta,
+  streamToResponse,
+  transformControllerSource,
+  tryGetRequestContext,
   walkControllerMetadata
 };
 //# sourceMappingURL=index.js.map