adorn-api 1.0.3 → 1.0.5

package/dist/express.cjs

@@ -0,0 +1,775 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/express.ts
+var express_exports = {};
+__export(express_exports, {
+  ValidationErrorResponse: () => ValidationErrorResponse,
+  bindRoutes: () => bindRoutes,
+  bootstrap: () => bootstrap,
+  createExpressRouter: () => createExpressRouter,
+  createValidator: () => createValidator,
+  formatValidationErrors: () => formatValidationErrors,
+  setupSwagger: () => setupSwagger
+});
+module.exports = __toCommonJS(express_exports);
+
+// src/runtime/polyfill.ts
+Symbol.metadata ??= /* @__PURE__ */ Symbol("Symbol.metadata");
+
+// src/adapter/express/index.ts
+var import_express2 = require("express");
+var import_node_fs2 = require("fs");
+var import_node_path3 = require("path");
+
+// src/runtime/metadata/key.ts
+var ADORN_META = /* @__PURE__ */ Symbol.for("adorn-api/meta");
+
+// src/runtime/metadata/read.ts
+function readAdornBucket(ctor) {
+  const metaSym = Symbol.metadata;
+  if (!metaSym) {
+    return null;
+  }
+  const classMetadata = ctor[metaSym];
+  if (!classMetadata) {
+    return null;
+  }
+  const bucket = classMetadata[ADORN_META];
+  return bucket ?? null;
+}
+
+// src/utils/operationId.ts
+function defaultOperationId(controllerName, methodName) {
+  return `${controllerName}_${methodName}`;
+}
+
+// src/utils/path.ts
+function joinPaths(base, sub) {
+  const b = base.endsWith("/") ? base.slice(0, -1) : base;
+  const s = sub.startsWith("/") ? sub : `/${sub}`;
+  return b + s || "/";
+}
+
+// src/adapter/express/merge.ts
+var import_node_crypto = __toESM(require("crypto"), 1);
+var routeCache = /* @__PURE__ */ new Map();
+function convertToExpressPath(path3) {
+  return path3.replace(/:([^/]+)/g, ":$1");
+}
+function computeManifestHash(manifest) {
+  const ops = manifest.controllers.flatMap((c) => c.operations.map((o) => o.operationId)).sort();
+  const data = JSON.stringify({
+    ops,
+    validation: manifest.validation
+  });
+  return import_node_crypto.default.createHash("sha256").update(data).digest("hex").slice(0, 16);
+}
+function getControllerUniqueIds(controllers) {
+  return controllers.map((c) => `${c.name}:${c.toString()}`);
+}
+function bindRoutes(params) {
+  const { controllers, manifest, useCache = true } = params;
+  if (useCache) {
+    const manifestHash = computeManifestHash(manifest);
+    const controllerIds = getControllerUniqueIds(controllers);
+    const cacheKey = `${manifestHash}:${controllerIds.join(",")}`;
+    const cached = routeCache.get(cacheKey);
+    if (cached) {
+      return cached.boundRoutes;
+    }
+    const bound = computeBoundRoutes(controllers, manifest);
+    routeCache.set(cacheKey, {
+      boundRoutes: bound,
+      manifestHash,
+      controllerIds
+    });
+    return bound;
+  }
+  return computeBoundRoutes(controllers, manifest);
+}
+function computeBoundRoutes(controllers, manifest) {
+  const manifestByOpId = /* @__PURE__ */ new Map();
+  for (const ctrl of manifest.controllers) {
+    for (const op of ctrl.operations) {
+      if (manifestByOpId.has(op.operationId)) {
+        throw new Error(`Duplicate operationId in manifest: ${op.operationId}`);
+      }
+      manifestByOpId.set(op.operationId, op);
+    }
+  }
+  const bound = [];
+  for (const ctor of controllers) {
+    const bucket = readAdornBucket(ctor);
+    if (!bucket) {
+      console.warn(`No decorator metadata found for ${ctor.name}, skipping`);
+      continue;
+    }
+    const basePath = bucket.basePath ?? "/";
+    for (const routeOp of bucket.ops) {
+      const opId = routeOp.operationId ?? defaultOperationId(ctor.name, routeOp.methodName);
+      const manifestOp = manifestByOpId.get(opId);
+      if (!manifestOp) {
+        throw new Error(
+          `No manifest entry for operationId="${opId}. Did you run "adorn-api build"? Are your operationId rules aligned?`
+        );
+      }
+      if (manifestOp.http.method !== routeOp.httpMethod || manifestOp.http.path !== routeOp.path) {
+        throw new Error(
+          `Route mismatch for ${opId}. Runtime: ${routeOp.httpMethod} ${routeOp.path}, Manifest: ${manifestOp.http.method} ${manifestOp.http.path}. Rebuild with "adorn-api build".`
+        );
+      }
+      const expressPath = convertToExpressPath(routeOp.path);
+      const fullPath = joinPaths(basePath, expressPath);
+      bound.push({
+        operationId: opId,
+        fullPath,
+        httpMethod: manifestOp.http.method,
+        controllerCtor: ctor,
+        methodName: routeOp.methodName,
+        args: manifestOp.args,
+        responses: manifestOp.responses,
+        use: routeOp.use,
+        auth: routeOp.auth,
+        controllerUse: bucket.controllerUse
+      });
+    }
+  }
+  return bound;
+}
+
+// src/runtime/validation/ajv.ts
+var import_ajv = __toESM(require("ajv"), 1);
+var import_ajv_formats = __toESM(require("ajv-formats"), 1);
+var ValidationErrorResponse = class extends Error {
+  constructor(statusCode, errors) {
+    super("Validation failed");
+    this.statusCode = statusCode;
+    this.errors = errors;
+    this.name = "ValidationErrorResponse";
+  }
+};
+function createValidator() {
+  const ajv = new import_ajv.default.default({
+    allErrors: true,
+    coerceTypes: false,
+    strict: false,
+    validateFormats: true
+  });
+  import_ajv_formats.default.default(ajv);
+  ajv.addFormat("br-phone", /^\(\d{2}\)\s\d{5}-\d{4}$/);
+  return ajv;
+}
+function formatValidationErrors(errors) {
+  const formatted = {};
+  for (const error of errors) {
+    const path3 = error.path || "body";
+    if (!formatted[path3]) {
+      formatted[path3] = [];
+    }
+    formatted[path3].push(error.message);
+  }
+  return {
+    error: "Validation failed",
+    details: formatted
+  };
+}
+
+// src/compiler/cache/loadArtifacts.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_promises = require("fs/promises");
+var artifactCache = /* @__PURE__ */ new Map();
+async function getMtime(filePath) {
+  try {
+    const stats = await (0, import_promises.stat)(filePath);
+    return stats.mtimeMs;
+  } catch {
+    return null;
+  }
+}
+async function loadArtifacts(options) {
+  const { outDir } = options;
+  const cacheKey = import_node_path.default.resolve(outDir);
+  let entry = artifactCache.get(cacheKey);
+  const openapiPath = import_node_path.default.join(outDir, "openapi.json");
+  const manifestPath = import_node_path.default.join(outDir, "manifest.json");
+  const validatorsPath = import_node_path.default.join(outDir, "validators.mjs");
+  const openapiMtime = await getMtime(openapiPath);
+  const manifestMtime = await getMtime(manifestPath);
+  const validatorsMtime = await getMtime(validatorsPath);
+  if (entry) {
+    const mtimesMatch = entry.mtimes.openapi === openapiMtime && entry.mtimes.manifest === manifestMtime && entry.mtimes.validators === validatorsMtime;
+    if (mtimesMatch) {
+      if (entry.openapi && entry.manifest) {
+        return {
+          openapi: entry.openapi,
+          manifest: entry.manifest,
+          validators: entry.validators
+        };
+      }
+    }
+  }
+  const openapiContent = import_node_fs.default.readFileSync(openapiPath, "utf-8");
+  const manifestContent = import_node_fs.default.readFileSync(manifestPath, "utf-8");
+  const openapi = JSON.parse(openapiContent);
+  const manifest = JSON.parse(manifestContent);
+  let validators = null;
+  if (manifest.validation.mode === "precompiled" && manifest.validation.precompiledModule) {
+    try {
+      const validatorsModule = await import(import_node_path.default.join(outDir, manifest.validation.precompiledModule));
+      validators = validatorsModule;
+    } catch (err) {
+      console.warn(`Failed to load precompiled validators: ${err}`);
+    }
+  }
+  artifactCache.set(cacheKey, {
+    openapi,
+    manifest,
+    validators,
+    mtimes: {
+      openapi: openapiMtime,
+      manifest: manifestMtime,
+      validators: validatorsMtime
+    }
+  });
+  return {
+    openapi,
+    manifest,
+    validators
+  };
+}
+
+// src/adapter/express/index.ts
+var import_swagger_ui_express = __toESM(require("swagger-ui-express"), 1);
+
+// src/adapter/express/bootstrap.ts
+var import_express = __toESM(require("express"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+function bootstrap(options) {
+  return new Promise(async (resolve2, reject) => {
+    try {
+      const {
+        controllers,
+        port: userPort,
+        host: userHost,
+        artifactsDir: userArtifactsDir = ".adorn",
+        enableSwagger = true,
+        swaggerPath = "/docs",
+        swaggerJsonPath = "/docs/openapi.json",
+        middleware,
+        auth
+      } = options;
+      if (controllers.length === 0) {
+        reject(new Error("At least one controller must be provided to bootstrap()."));
+        return;
+      }
+      const envPort = process.env.PORT;
+      const port = userPort ?? (envPort !== void 0 ? Number(envPort) : 3e3);
+      const host = userHost ?? process.env.HOST ?? "0.0.0.0";
+      if (isNaN(port) || port < 0 || port > 65535) {
+        reject(new Error(`Invalid port: ${port}. Port must be between 0 and 65535.`));
+        return;
+      }
+      const absoluteArtifactsDir = import_node_path2.default.isAbsolute(userArtifactsDir) ? userArtifactsDir : import_node_path2.default.resolve(process.cwd(), userArtifactsDir);
+      const app = (0, import_express.default)();
+      app.use(import_express.default.json());
+      const router = await createExpressRouter({
+        controllers,
+        artifactsDir: absoluteArtifactsDir,
+        middleware,
+        auth
+      });
+      app.use(router);
+      if (enableSwagger) {
+        const displayHost = host === "0.0.0.0" ? "localhost" : host;
+        const serverUrl = `http://${displayHost}:${port}`;
+        app.use(
+          setupSwagger({
+            artifactsDir: absoluteArtifactsDir,
+            jsonPath: swaggerJsonPath,
+            uiPath: swaggerPath,
+            swaggerOptions: {
+              servers: [{ url: serverUrl }]
+            }
+          })
+        );
+      }
+      const server = app.listen(port, host, () => {
+        const displayHost = host === "0.0.0.0" ? "localhost" : host;
+        const serverUrl = `http://${displayHost}:${port}`;
+        console.log(`\u{1F680} Server running on ${serverUrl}`);
+        if (enableSwagger) {
+          console.log(`\u{1F4DA} Swagger UI: ${serverUrl}${swaggerPath}`);
+        }
+        const result = {
+          server,
+          app,
+          url: serverUrl,
+          port,
+          host,
+          close: () => new Promise((closeResolve) => {
+            server.close(() => {
+              console.log("Server closed gracefully");
+              closeResolve();
+            });
+          })
+        };
+        resolve2(result);
+      });
+      server.on("error", (error) => {
+        if (error.code === "EADDRINUSE") {
+          reject(new Error(`Port ${port} already in use. Please choose a different port.`));
+        } else if (error.code === "EACCES") {
+          reject(new Error(`Permission denied for port ${port}. Ports below 1024 require root privileges.`));
+        } else {
+          reject(new Error(`Failed to start server: ${error.message}`));
+        }
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+// src/adapter/express/index.ts
+async function createExpressRouter(options) {
+  const { controllers, artifactsDir = ".adorn", middleware = {} } = options;
+  let manifest;
+  let openapi;
+  let precompiledValidators = null;
+  if (options.manifest && options.openapi) {
+    manifest = options.manifest;
+    openapi = options.openapi;
+    if (manifest.validation.mode === "precompiled" && manifest.validation.precompiledModule) {
+      try {
+        const validatorPath = (0, import_node_path3.join)(artifactsDir, manifest.validation.precompiledModule);
+        precompiledValidators = require(validatorPath).validators;
+      } catch (err) {
+        console.warn(`Failed to load precompiled validators: ${err}`);
+      }
+    }
+  } else {
+    const artifacts = await loadArtifacts({ outDir: artifactsDir });
+    manifest = artifacts.manifest;
+    openapi = artifacts.openapi;
+    precompiledValidators = artifacts.validators?.validators ?? null;
+  }
+  const routes = bindRoutes({ controllers, manifest });
+  const validator = precompiledValidators ? null : createValidator();
+  const router = (0, import_express2.Router)();
+  const instanceCache = /* @__PURE__ */ new Map();
+  function getInstance(Ctor) {
+    if (!instanceCache.has(Ctor)) {
+      instanceCache.set(Ctor, new Ctor());
+    }
+    return instanceCache.get(Ctor);
+  }
+  function resolveMiddleware(items, named = {}) {
+    return items.map((item) => {
+      if (typeof item === "string") {
+        const fn = named[item];
+        if (!fn) {
+          throw new Error(`Named middleware "${item}" not found in middleware registry`);
+        }
+        return fn;
+      }
+      return item;
+    });
+  }
+  function createAuthMiddleware(authConfig, routeAuth, globalSecurity) {
+    return async (req, res, next) => {
+      const isPublic = routeAuth === "public";
+      const hasAuthDecorator = routeAuth && routeAuth !== "public";
+      const hasGlobalSecurity = globalSecurity && globalSecurity.length > 0;
+      if (!hasAuthDecorator && !hasGlobalSecurity) {
+        return next();
+      }
+      if (isPublic) {
+        return next();
+      }
+      const authMeta = routeAuth;
+      const scheme = authMeta.scheme;
+      const requiredScopes = authMeta.scopes || [];
+      const isOptional = authMeta.optional ?? false;
+      const authRuntime = authConfig.schemes[scheme];
+      if (!authRuntime) {
+        throw new Error(`Auth scheme "${scheme}" not found in auth configuration`);
+      }
+      const result = await authRuntime.authenticate(req);
+      if (!result) {
+        if (isOptional) {
+          req.auth = null;
+          return next();
+        }
+        return authRuntime.challenge(res);
+      }
+      req.auth = result.principal;
+      if (authRuntime.authorize && requiredScopes.length > 0) {
+        if (!authRuntime.authorize(result, requiredScopes)) {
+          res.status(403).json({ error: "Forbidden", message: "Insufficient scopes" });
+          return;
+        }
+      }
+      next();
+    };
+  }
+  function getSchemaByRef(ref) {
+    if (!ref.startsWith("#/components/schemas/")) return null;
+    const schemaName = ref.replace("#/components/schemas/", "");
+    return openapi.components.schemas[schemaName] || null;
+  }
+  for (const route of routes) {
+    const method = route.httpMethod.toLowerCase();
+    const middlewareChain = [];
+    if (middleware.global) {
+      middlewareChain.push(...resolveMiddleware(middleware.global, middleware.named || {}));
+    }
+    if (route.controllerUse) {
+      middlewareChain.push(...resolveMiddleware(route.controllerUse, middleware.named || {}));
+    }
+    if (route.use) {
+      middlewareChain.push(...resolveMiddleware(route.use, middleware.named || {}));
+    }
+    if (options.auth) {
+      const authMw = createAuthMiddleware(options.auth, route.auth, openapi.security || []);
+      middlewareChain.push(authMw);
+    }
+    router[method](route.fullPath, ...middlewareChain, async (req, res, next) => {
+      try {
+        const validationErrors = precompiledValidators ? validateRequestWithPrecompiled(route, req, precompiledValidators) : validateRequest(route, req, openapi, validator);
+        if (validationErrors) {
+          return res.status(400).json(formatValidationErrors(validationErrors));
+        }
+        const instance = getInstance(route.controllerCtor);
+        const handler = instance[route.methodName];
+        if (typeof handler !== "function") {
+          throw new Error(`Method ${route.methodName} not found on controller`);
+        }
+        const args = [];
+        if (route.args.body) {
+          args[route.args.body.index] = req.body;
+        }
+        for (const pathArg of route.args.path) {
+          const coerced = coerceValue(req.params[pathArg.name], pathArg.schemaType);
+          args[pathArg.index] = coerced;
+        }
+        if (route.args.query.length > 0) {
+          const firstQueryIndex = route.args.query[0].index;
+          const allSameIndex = route.args.query.every((q) => q.index === firstQueryIndex);
+          if (allSameIndex) {
+            args[firstQueryIndex] = {};
+            for (const q of route.args.query) {
+              const parsed = parseQueryValue(req.query[q.name], q);
+              const coerced = coerceValue(parsed, q.schemaType);
+              args[firstQueryIndex][q.name] = coerced;
+            }
+          } else {
+            for (const q of route.args.query) {
+              const parsed = parseQueryValue(req.query[q.name], q);
+              const coerced = coerceValue(parsed, q.schemaType);
+              args[q.index] = coerced;
+            }
+          }
+        }
+        if (route.args.headers.length > 0) {
+          const firstHeaderIndex = route.args.headers[0].index;
+          const allSameIndex = route.args.headers.every((h) => h.index === firstHeaderIndex);
+          if (allSameIndex) {
+            args[firstHeaderIndex] = {};
+            for (const h of route.args.headers) {
+              const headerValue = req.headers[h.name.toLowerCase()];
+              args[firstHeaderIndex][h.name] = headerValue ?? void 0;
+            }
+          } else {
+            for (const h of route.args.headers) {
+              const headerValue = req.headers[h.name.toLowerCase()];
+              args[h.index] = headerValue ?? void 0;
+            }
+          }
+        }
+        if (route.args.cookies.length > 0) {
+          const firstCookieIndex = route.args.cookies[0].index;
+          const allSameIndex = route.args.cookies.every((c) => c.index === firstCookieIndex);
+          const cookies = parseCookies(req.headers.cookie);
+          if (allSameIndex) {
+            args[firstCookieIndex] = {};
+            for (const c of route.args.cookies) {
+              const cookieValue = cookies[c.name];
+              const coerced = coerceValue(cookieValue, c.schemaType);
+              args[firstCookieIndex][c.name] = coerced;
+            }
+          } else {
+            for (const c of route.args.cookies) {
+              const cookieValue = cookies[c.name];
+              const coerced = coerceValue(cookieValue, c.schemaType);
+              args[c.index] = coerced;
+            }
+          }
+        }
+        if (args.length === 0) {
+          args.push(req);
+        }
+        const result = await handler.apply(instance, args);
+        const primaryResponse = route.responses[0];
+        const status = primaryResponse?.status ?? 200;
+        res.status(status).json(result);
+      } catch (error) {
+        next(error);
+      }
+    });
+  }
+  return router;
+}
+function validateRequestWithPrecompiled(route, req, validators) {
+  const errors = [];
+  if (route.args.body) {
+    const validator = validators[route.operationId]?.body;
+    if (validator) {
+      const valid = validator(req.body);
+      if (!valid) {
+        const v = validators[route.operationId].body;
+        for (const err of v.errors || []) {
+          errors.push({
+            path: `#/body${err.instancePath}`,
+            message: err.message || "Invalid value",
+            keyword: err.keyword,
+            params: err.params
+          });
+        }
+      }
+    }
+  }
+  for (const q of route.args.query) {
+    const value = req.query[q.name];
+    if (value === void 0) continue;
+    const schema = {};
+    if (q.schemaType) {
+      const type = Array.isArray(q.schemaType) ? q.schemaType[0] : q.schemaType;
+      schema.type = type;
+    }
+    const coerced = coerceValue(value, q.schemaType);
+    if (Object.keys(schema).length > 0 && coerced !== void 0) {
+      errors.push({
+        path: `#/query/${q.name}`,
+        message: `Schema validation not supported for query params in precompiled mode`,
+        keyword: "notSupported",
+        params: {}
+      });
+    }
+  }
+  for (const p of route.args.path) {
+    const value = req.params[p.name];
+    if (value === void 0) continue;
+    const schema = {};
+    if (p.schemaType) {
+      const type = Array.isArray(p.schemaType) ? p.schemaType[0] : p.schemaType;
+      schema.type = type;
+    }
+    const coerced = coerceValue(value, p.schemaType);
+    if (Object.keys(schema).length > 0 && coerced !== void 0) {
+      errors.push({
+        path: `#/path/${p.name}`,
+        message: `Schema validation not supported for path params in precompiled mode`,
+        keyword: "notSupported",
+        params: {}
+      });
+    }
+  }
+  return errors.length > 0 ? errors : null;
+}
+function validateRequest(route, req, openapi, validator) {
+  function getSchemaByRef(ref) {
+    if (!ref.startsWith("#/components/schemas/")) return null;
+    const schemaName = ref.replace("#/components/schemas/", "");
+    return openapi.components.schemas[schemaName] || null;
+  }
+  const errors = [];
+  if (route.args.body) {
+    const bodySchema = getSchemaByRef(route.args.body.schemaRef);
+    if (bodySchema) {
+      const validate = validator.compile(bodySchema);
+      const valid = validate(req.body);
+      if (!valid) {
+        for (const err of validate.errors || []) {
+          errors.push({
+            path: `#/body${err.instancePath}`,
+            message: err.message || "Invalid value",
+            keyword: err.keyword,
+            params: err.params
+          });
+        }
+      }
+    }
+  }
+  for (const q of route.args.query) {
+    const value = req.query[q.name];
+    const schema = {};
+    if (q.schemaType) {
+      const type = Array.isArray(q.schemaType) ? q.schemaType[0] : q.schemaType;
+      schema.type = type;
+    }
+    if (q.schemaRef && q.schemaRef.includes("Inline")) {
+      const inlineSchema = getSchemaByRef(q.schemaRef);
+      if (inlineSchema) {
+        Object.assign(schema, inlineSchema);
+      }
+    }
+    const coerced = coerceValue(value, q.schemaType);
+    if (Object.keys(schema).length > 0 && coerced !== void 0) {
+      const validate = validator.compile(schema);
+      const valid = validate(coerced);
+      if (!valid) {
+        for (const err of validate.errors || []) {
+          errors.push({
+            path: `#/query/${q.name}`,
+            message: err.message || "Invalid value",
+            keyword: err.keyword,
+            params: err.params
+          });
+        }
+      }
+    }
+  }
+  for (const p of route.args.path) {
+    const value = req.params[p.name];
+    const schema = {};
+    if (p.schemaType) {
+      const type = Array.isArray(p.schemaType) ? p.schemaType[0] : p.schemaType;
+      schema.type = type;
+    }
+    if (p.schemaRef && p.schemaRef.includes("Inline")) {
+      const inlineSchema = getSchemaByRef(p.schemaRef);
+      if (inlineSchema) {
+        Object.assign(schema, inlineSchema);
+      }
+    }
+    const coerced = coerceValue(value, p.schemaType);
+    if (Object.keys(schema).length > 0 && coerced !== void 0) {
+      const validate = validator.compile(schema);
+      const valid = validate(coerced);
+      if (!valid) {
+        for (const err of validate.errors || []) {
+          errors.push({
+            path: `#/path/${p.name}`,
+            message: err.message || "Invalid value",
+            keyword: err.keyword,
+            params: err.params
+          });
+        }
+      }
+    }
+  }
+  return errors.length > 0 ? errors : null;
+}
+function coerceValue(value, schemaType) {
+  if (value === void 0 || value === null) return value;
+  const type = Array.isArray(schemaType) ? schemaType[0] : schemaType;
+  if (type === "number" || type === "integer") {
+    const num = Number(value);
+    if (isNaN(num)) {
+      throw new Error(`Invalid number: ${value}`);
+    }
+    return num;
+  }
+  if (type === "boolean") {
+    if (value === "true") return true;
+    if (value === "false") return false;
+    throw new Error(`Invalid boolean: ${value}`);
+  }
+  return value;
+}
+function parseQueryValue(value, param) {
+  if (value === void 0 || value === null) return value;
+  const isArray = Array.isArray(param.schemaType) ? param.schemaType.includes("array") : param.schemaType === "array";
+  if (!isArray) return value;
+  const style = param.serialization?.style ?? "form";
+  const explode = param.serialization?.explode ?? true;
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (style === "form") {
+    if (explode) {
+      return value;
+    }
+    return value.split(",");
+  }
+  if (style === "spaceDelimited") {
+    return value.split(" ");
+  }
+  if (style === "pipeDelimited") {
+    return value.split("|");
+  }
+  return value;
+}
+function parseCookies(cookieHeader) {
+  if (!cookieHeader) return {};
+  const cookies = {};
+  const pairs = cookieHeader.split(";");
+  for (const pair of pairs) {
+    const [name, ...valueParts] = pair.trim().split("=");
+    if (name) {
+      cookies[name] = valueParts.join("=");
+    }
+  }
+  return cookies;
+}
+function setupSwagger(options = {}) {
+  const {
+    artifactsDir = ".adorn",
+    jsonPath = "/docs/openapi.json",
+    uiPath = "/docs",
+    swaggerOptions = {}
+  } = options;
+  const router = (0, import_express2.Router)();
+  router.get(jsonPath, (req, res) => {
+    const openApiPath = (0, import_node_path3.isAbsolute)(artifactsDir) ? (0, import_node_path3.resolve)(artifactsDir, "openapi.json") : (0, import_node_path3.resolve)(process.cwd(), artifactsDir, "openapi.json");
+    const content = (0, import_node_fs2.readFileSync)(openApiPath, "utf-8");
+    res.setHeader("Content-Type", "application/json");
+    res.send(content);
+  });
+  router.use(uiPath, import_swagger_ui_express.default.serve, import_swagger_ui_express.default.setup(null, {
+    swaggerOptions: {
+      url: jsonPath,
+      ...swaggerOptions
+    }
+  }));
+  return router;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ValidationErrorResponse,
+  bindRoutes,
+  bootstrap,
+  createExpressRouter,
+  createValidator,
+  formatValidationErrors,
+  setupSwagger
+});
+//# sourceMappingURL=express.cjs.map