@dunx/http 1.1.0 → 1.2.1

package/dist/index.js

@@ -1,7 +1,11 @@
 // @bun
 import {
-  HttpStatusCode
-} from "./chunk-x80f562w.js";
+  HttpStatusCode,
+  __decorateElement,
+  __decoratorMetadata,
+  __decoratorStart,
+  __runInitializers
+} from "./chunk-5z96f3gr.js";
 
 // src/route/marker.ts
 var ROUTE = Symbol.for("dunx.route");
@@ -114,15 +118,166 @@ var discoverRoutes = (instance) => {
   }
   return routes;
 };
+// src/inspect.ts
+import {
+  collectModules,
+  dependenciesOf,
+  readControllers
+} from "@dunx/core";
+
+// src/ws/discover.ts
+import {
+  AppError
+} from "@dunx/core";
+
+// src/ws/marker.ts
+var HANDLER = Symbol.for("dunx.ws.handler");
+var GATEWAY = Symbol.for("dunx.ws.gateway");
+var HandlerKind = Object.freeze({
+  UPGRADE: "upgrade",
+  OPEN: "open",
+  MESSAGE: "message",
+  CLOSE: "close",
+  DRAIN: "drain",
+  PING: "ping",
+  PONG: "pong"
+});
+var markHandler = (target, meta2) => {
+  Object.defineProperty(target, HANDLER, { value: meta2, configurable: true });
+};
+var handlerMetaOf = (value) => typeof value === "function" ? value[HANDLER] : undefined;
+var markGateway = (target, path) => {
+  Object.defineProperty(target, GATEWAY, { value: path, configurable: true });
+};
+var gatewayPathOf = (target) => target[GATEWAY] ?? "/";
+var isGateway = (target) => target[GATEWAY] !== undefined;
+
+// src/ws/discover.ts
+var normalizePath = (path) => {
+  const joined = `/${path}`.replace(/\/{2,}/g, "/");
+  return joined.length > 1 ? joined.replace(/\/$/, "") : "/";
+};
+var eachHandler = (start) => {
+  const found = [];
+  const seen = new Set;
+  for (let proto = start;proto !== null && proto !== Object.prototype; proto = Object.getPrototypeOf(proto)) {
+    for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(proto))) {
+      if (name === "constructor" || seen.has(name))
+        continue;
+      const meta2 = handlerMetaOf(descriptor.value);
+      if (!meta2)
+        continue;
+      seen.add(name);
+      found.push([name, meta2]);
+    }
+  }
+  return found;
+};
+var discoverGateway = (instance) => {
+  const klass = instance.constructor;
+  const members = instance;
+  return {
+    name: klass.name,
+    path: normalizePath(gatewayPathOf(klass)),
+    handlers: eachHandler(Object.getPrototypeOf(instance)).map(([name, meta2]) => ({
+      kind: meta2.kind,
+      event: meta2.event,
+      method: name,
+      invoke: members[name].bind(instance)
+    }))
+  };
+};
+var findHandlerMethod = (ctor) => eachHandler(ctor.prototype)[0]?.[0];
+var classOf = (entry) => {
+  if (typeof entry === "function")
+    return { token: entry, ctor: entry };
+  return entry.provider.kind === "class" ? { token: entry.token, ctor: entry.provider.ctor } : undefined;
+};
+var discoverGateways = (modules, resolve) => {
+  const discovered = [];
+  for (const module of modules) {
+    for (const entry of module.options.providers ?? []) {
+      const candidate = classOf(entry);
+      if (!candidate)
+        continue;
+      if (isGateway(candidate.ctor)) {
+        discovered.push(discoverGateway(resolve(candidate.token)));
+        continue;
+      }
+      const orphan = findHandlerMethod(candidate.ctor);
+      if (orphan !== undefined) {
+        throw new AppError(`${candidate.ctor.name}.${orphan}() is a websocket handler, but ` + `${candidate.ctor.name} is not a gateway. Decorate the class with ` + "@Gateway(path), or drop the handler decorator.");
+      }
+    }
+  }
+  return discovered;
+};
+
+// src/inspect.ts
+var vendorOf = (schema) => schema?.["~standard"]?.vendor;
+var validatesIn = (options) => {
+  const body = vendorOf(options?.body);
+  const query = vendorOf(options?.query);
+  const params = vendorOf(options?.params);
+  return {
+    ...body === undefined ? {} : { body },
+    ...query === undefined ? {} : { query },
+    ...params === undefined ? {} : { params }
+  };
+};
+var rolesIn = (route) => {
+  const roles = route.meta?.get(ROLES.id);
+  if (roles === undefined || roles === null)
+    return null;
+  return (Array.isArray(roles) ? roles : [roles]).map(String);
+};
+var nodeFor = (route, module) => ({
+  method: route.method,
+  path: route.path,
+  controller: route.controller,
+  handler: route.handlerName,
+  module,
+  public: route.meta?.get(PUBLIC.id) === true,
+  roles: rolesIn(route),
+  guards: (route.guards ?? []).map((guard) => guard.name),
+  hidden: route.meta?.get(HIDDEN.id) === true,
+  validates: validatesIn(route.options),
+  status: route.options?.status ?? null,
+  responses: Object.keys(route.options?.response ?? {}).map(Number)
+});
+var routesOf = (root) => collectModules(root).flatMap((module) => readControllers(module).flatMap((controller) => {
+  const { prototype } = controller;
+  return discoverRoutes(Object.create(prototype)).map((route) => nodeFor(route, module.name));
+}));
+var gatewayFor = (ctor, module) => {
+  const { name, path, handlers } = discoverGateway(Object.create(ctor.prototype));
+  return {
+    name,
+    path,
+    module,
+    dependencies: dependenciesOf(ctor),
+    handlers: handlers.map((handler) => ({
+      kind: handler.kind,
+      event: handler.event ?? null,
+      method: handler.method
+    }))
+  };
+};
+var classOf2 = (entry) => {
+  if (typeof entry === "function")
+    return entry;
+  return entry.provider.kind === "class" ? entry.provider.ctor : undefined;
+};
+var gatewaysOf = (root) => collectModules(root).flatMap((module) => (module.options.providers ?? []).map(classOf2).filter((ctor) => ctor !== undefined).filter(isGateway).map((ctor) => gatewayFor(ctor, module.name)));
 // src/server/client-address.ts
-import { AppError } from "@dunx/core";
+import { AppError as AppError2 } from "@dunx/core";
 var sources = new WeakMap;
 
 class ClientAddress {
   of(req) {
     const source = sources.get(this);
     if (!source) {
-      throw new AppError("ClientAddress has no server yet. The address comes from the live Bun " + "server, so it is only available once listen() has run.");
+      throw new AppError2("ClientAddress has no server yet. The address comes from the live Bun " + "server, so it is only available once listen() has run.");
     }
     if (source.trustProxy) {
       const forwarded = req.headers.get("x-forwarded-for")?.split(",")[0]?.trim();
@@ -199,8 +354,8 @@ var preflight = (options, methods) => {
   };
 };
 // src/server/errors.ts
-import { AppError as AppError2, ConsoleLogger } from "@dunx/core";
-class HttpError extends AppError2 {
+import { AppError as AppError3, ConsoleLogger } from "@dunx/core";
+class HttpError extends AppError3 {
   status;
   name = "HttpError";
   constructor(status, message, options) {
@@ -246,12 +401,12 @@ var errorMapper = (logger) => (error) => {
 var defaultErrorMapper = errorMapper(new ConsoleLogger);
 // src/server/factory.ts
 import {
-  collectModules,
+  collectModules as collectModules2,
   AppError as AppError8,
   AppFactory,
   Logger as Logger3,
   provide,
-  readControllers,
+  readControllers as readControllers2,
   RequestContext as RequestContext2
 } from "@dunx/core";
 
@@ -273,35 +428,11 @@ var decode = (message) => {
 };
 
 // src/ws/runtime.ts
-import { AppError as AppError3 } from "@dunx/core";
-
-// src/ws/marker.ts
-var HANDLER = Symbol.for("dunx.ws.handler");
-var GATEWAY = Symbol.for("dunx.ws.gateway");
-var HandlerKind = Object.freeze({
-  UPGRADE: "upgrade",
-  OPEN: "open",
-  MESSAGE: "message",
-  CLOSE: "close",
-  DRAIN: "drain",
-  PING: "ping",
-  PONG: "pong"
-});
-var markHandler = (target, meta2) => {
-  Object.defineProperty(target, HANDLER, { value: meta2, configurable: true });
-};
-var handlerMetaOf = (value) => typeof value === "function" ? value[HANDLER] : undefined;
-var markGateway = (target, path) => {
-  Object.defineProperty(target, GATEWAY, { value: path, configurable: true });
-};
-var gatewayPathOf = (target) => target[GATEWAY] ?? "/";
-var isGateway = (target) => target[GATEWAY] !== undefined;
-
-// src/ws/runtime.ts
+import { AppError as AppError4 } from "@dunx/core";
 var slotOf = (handler) => handler.kind === HandlerKind.MESSAGE && handler.event !== undefined ? `message ${JSON.stringify(handler.event)}` : handler.kind;
 var buildRuntime = (gateway) => {
   if (gateway.handlers.length === 0) {
-    throw new AppError3(`${gateway.name} is registered as a gateway but declares no handlers. ` + "Add an @OnMessage/@OnOpen/... method, or drop the @Gateway decorator.");
+    throw new AppError4(`${gateway.name} is registered as a gateway but declares no handlers. ` + "Add an @OnMessage/@OnOpen/... method, or drop the @Gateway decorator.");
   }
   const owners = new Map;
   const events = new Map;
@@ -309,7 +440,7 @@ var buildRuntime = (gateway) => {
     const slot = slotOf(handler);
     const existing = owners.get(slot);
     if (existing) {
-      throw new AppError3(`Handler collision in ${gateway.name}: ${slot} is claimed by ` + `${existing.method}() and by ${handler.method}(). One handler per event.`);
+      throw new AppError4(`Handler collision in ${gateway.name}: ${slot} is claimed by ` + `${existing.method}() and by ${handler.method}(). One handler per event.`);
     }
     owners.set(slot, handler);
     if (handler.kind === HandlerKind.MESSAGE && handler.event !== undefined) {
@@ -335,7 +466,7 @@ var buildGateways = (discovered) => {
   for (const gateway of discovered) {
     const existing = byPath.get(gateway.path);
     if (existing) {
-      throw new AppError3(`Gateway path collision: ${gateway.path} is served by ${existing.name} ` + `and by ${gateway.name}. One gateway per path.`);
+      throw new AppError4(`Gateway path collision: ${gateway.path} is served by ${existing.name} ` + `and by ${gateway.name}. One gateway per path.`);
     }
     byPath.set(gateway.path, buildRuntime(gateway));
   }
@@ -468,70 +599,6 @@ var buildWebSocket = (discovered, options = {}) => {
   };
 };
 
-// src/ws/discover.ts
-import {
-  AppError as AppError4
-} from "@dunx/core";
-var normalizePath = (path) => {
-  const joined = `/${path}`.replace(/\/{2,}/g, "/");
-  return joined.length > 1 ? joined.replace(/\/$/, "") : "/";
-};
-var eachHandler = (start) => {
-  const found = [];
-  const seen = new Set;
-  for (let proto = start;proto !== null && proto !== Object.prototype; proto = Object.getPrototypeOf(proto)) {
-    for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(proto))) {
-      if (name === "constructor" || seen.has(name))
-        continue;
-      const meta2 = handlerMetaOf(descriptor.value);
-      if (!meta2)
-        continue;
-      seen.add(name);
-      found.push([name, meta2]);
-    }
-  }
-  return found;
-};
-var discoverGateway = (instance) => {
-  const klass = instance.constructor;
-  const members = instance;
-  return {
-    name: klass.name,
-    path: normalizePath(gatewayPathOf(klass)),
-    handlers: eachHandler(Object.getPrototypeOf(instance)).map(([name, meta2]) => ({
-      kind: meta2.kind,
-      event: meta2.event,
-      method: name,
-      invoke: members[name].bind(instance)
-    }))
-  };
-};
-var findHandlerMethod = (ctor) => eachHandler(ctor.prototype)[0]?.[0];
-var classOf = (entry) => {
-  if (typeof entry === "function")
-    return { token: entry, ctor: entry };
-  return entry.provider.kind === "class" ? { token: entry.token, ctor: entry.provider.ctor } : undefined;
-};
-var discoverGateways = (modules, resolve) => {
-  const discovered = [];
-  for (const module of modules) {
-    for (const entry of module.options.providers ?? []) {
-      const candidate = classOf(entry);
-      if (!candidate)
-        continue;
-      if (isGateway(candidate.ctor)) {
-        discovered.push(discoverGateway(resolve(candidate.token)));
-        continue;
-      }
-      const orphan = findHandlerMethod(candidate.ctor);
-      if (orphan !== undefined) {
-        throw new AppError4(`${candidate.ctor.name}.${orphan}() is a websocket handler, but ` + `${candidate.ctor.name} is not a gateway. Decorate the class with ` + "@Gateway(path), or drop the handler decorator.");
-      }
-    }
-  }
-  return discovered;
-};
-
 // src/ws/pubsub.ts
 import { AppError as AppError5 } from "@dunx/core";
 
@@ -726,6 +793,7 @@ class RequestLoggingMiddleware {
   #requestBody;
   #responseBody;
   #ignore;
+  #ignorePrefix;
   #correlateIgnored;
   #correlate;
   constructor(logger, context, options = {}) {
@@ -735,15 +803,23 @@ class RequestLoggingMiddleware {
     this.#requestBody = options.requestBody ?? false;
     this.#responseBody = options.responseBody ?? false;
     this.#ignore = new Set(options.ignore ?? []);
+    this.#ignorePrefix = options.ignorePrefix ?? [];
     this.#correlateIgnored = options.correlateIgnored ?? false;
     this.#correlate = options.correlate ?? true;
   }
+  #ignored(path) {
+    if (this.#ignore.size > 0 && this.#ignore.has(path))
+      return true;
+    if (this.#ignorePrefix.length === 0)
+      return false;
+    return this.#ignorePrefix.some((prefix) => path.startsWith(prefix));
+  }
   handle(req, ctx, next) {
     const url = req.url;
     const from = url.indexOf("/", url.indexOf("://") + 3);
     const mark = from === -1 ? -1 : url.indexOf("?", from);
     const path = from === -1 ? "/" : mark === -1 ? url.slice(from) : url.slice(from, mark);
-    if (this.#ignore.size > 0 && this.#ignore.has(path)) {
+    if (this.#ignored(path)) {
       return this.#correlateIgnored ? this.#correlated(req, ctx, path, next) : next();
     }
     const started = Bun.nanoseconds();
@@ -1295,11 +1371,11 @@ class HttpFactory {
       exports: providers.map((entry) => typeof entry === "function" ? entry : entry.token)
     };
     const app = await AppFactory.create(scope, options.overrides ? { overrides: options.overrides } : {});
-    const modules = collectModules(scope);
+    const modules = collectModules2(scope);
     const discovered = [];
     for (const module of modules) {
       const moduleMiddleware = module.options.middleware ?? [];
-      for (const controller of readControllers(module)) {
+      for (const controller of readControllers2(module)) {
         const routes = discoverRoutes(app.get(controller, module.ref));
         if (routes.length === 0) {
           throw new AppError8(`${controller.name} is registered as a controller but declares no routes. ` + "Add a @Get/@Post/... method, or move it to providers.");
@@ -1319,6 +1395,129 @@ class HttpFactory {
     return new HttpApplication(app, discovered, options, root, websocket);
   }
 }
+// src/static/files.ts
+import { join, normalize, resolve } from "path";
+
+// src/static/options.ts
+class StaticOptions {
+  root;
+  path;
+  maxAge;
+  immutable;
+  constructor(init) {
+    this.root = init.root;
+    this.path = normalizePrefix(init.path ?? "/");
+    this.maxAge = init.maxAge ?? 60;
+    this.immutable = init.immutable ?? (() => false);
+  }
+}
+Object.defineProperty(StaticOptions, Symbol.for("dunx.deps"), {
+  value: () => [{ unresolved: "init: StaticOptionsInit" }]
+});
+var normalizePrefix = (path) => {
+  const trimmed = path.split("/").filter(Boolean).join("/");
+  return trimmed === "" ? "/" : `/${trimmed}`;
+};
+
+// src/static/files.ts
+class StaticFiles {
+  #options;
+  #root;
+  #prefix;
+  constructor(options) {
+    this.#options = options;
+    this.#root = resolve(options.root);
+    this.#prefix = options.path === "/" ? "/" : `${options.path}/`;
+  }
+  resolvePath(pathname) {
+    const relative = pathname.startsWith(this.#prefix) ? pathname.slice(this.#prefix.length) : pathname.slice(this.#options.path.length);
+    let decoded;
+    try {
+      decoded = decodeURIComponent(relative);
+    } catch {
+      return;
+    }
+    if (decoded.includes("\x00"))
+      return;
+    const candidate = resolve(join(this.#root, normalize(decoded)));
+    if (candidate !== this.#root && !candidate.startsWith(`${this.#root}/`)) {
+      return;
+    }
+    return candidate;
+  }
+  #cacheControl(pathname) {
+    const { immutable, maxAge } = this.#options;
+    return immutable(pathname) ? "public, max-age=31536000, immutable" : `public, max-age=${maxAge}`;
+  }
+  async handle(req, _ctx, next) {
+    const { pathname } = new URL(req.url);
+    if (pathname !== this.#options.path && !pathname.startsWith(this.#prefix)) {
+      return next();
+    }
+    if (req.method !== "GET" && req.method !== "HEAD")
+      return next();
+    const path = this.resolvePath(pathname);
+    if (path === undefined)
+      return next();
+    const file = Bun.file(path);
+    if (!await file.exists())
+      return next();
+    return new Response(file, {
+      headers: {
+        "cache-control": this.#cacheControl(pathname),
+        ...file.type === "" ? { "content-type": "application/octet-stream" } : {},
+        "x-content-type-options": "nosniff"
+      }
+    });
+  }
+}
+Object.defineProperty(StaticFiles, Symbol.for("dunx.deps"), {
+  value: () => [StaticOptions]
+});
+// src/static/module.ts
+import {
+  Module,
+  provide as provide2
+} from "@dunx/core";
+var files = () => provide2(StaticFiles, {
+  useFactory: (options) => new StaticFiles(options),
+  inject: [StaticOptions]
+});
+var _dec = [
+  Module({})
+];
+var _init = __decoratorStart(undefined);
+
+class StaticModule {
+  static forRoot(init) {
+    return {
+      module: StaticModule,
+      exports: [StaticOptions, StaticFiles],
+      providers: [
+        provide2(StaticOptions, { useValue: new StaticOptions(init) }),
+        files()
+      ]
+    };
+  }
+  static forRootAsync(config) {
+    return {
+      module: StaticModule,
+      ...config.imports && { imports: config.imports },
+      exports: [StaticOptions, StaticFiles],
+      providers: [
+        provide2(StaticOptions, {
+          useFactory: async (...deps) => new StaticOptions(await config.useFactory(...deps)),
+          inject: config.inject ?? []
+        }),
+        files()
+      ]
+    };
+  }
+}
+StaticModule = __decorateElement(_init, 0, "StaticModule", _dec, StaticModule);
+__runInitializers(_init, 1, StaticModule);
+__decoratorMetadata(_init, StaticModule);
+let _StaticModule = StaticModule;
 // src/ws/decorators.ts
 var Gateway = (path = "/") => (target) => {
   markGateway(target, path);
@@ -1435,7 +1634,9 @@ export {
   withUpgradeRoutes,
   withCors,
   toErrorMapper,
+  routesOf,
   preflight,
+  normalizePrefix,
   normalizePath,
   metaOf,
   metaKey,
@@ -1445,6 +1646,7 @@ export {
   isGateway,
   isErrorFilter,
   guardsOf,
+  gatewaysOf,
   errorMapper,
   encodeRelay,
   encode,
@@ -1466,6 +1668,9 @@ export {
   ValidationError,
   UseGuards,
   UNMATCHED,
+  StaticOptions,
+  StaticModule,
+  StaticFiles,
   Roles,
   RequestLoggingMiddleware,
   RedisRelay,
@@ -1499,5 +1704,5 @@ export {
   ApiHidden
 };
 
-//# debugId=B4FE7D323451AFAC64756E2164756E21
+//# debugId=70611CF4C37807EE64756E2164756E21
 //# sourceMappingURL=index.js.map