adorn-api 1.0.23 → 1.0.24

package/dist/express.js

@@ -1,1150 +0,0 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// src/runtime/polyfill.ts
-Symbol.metadata ??= /* @__PURE__ */ Symbol("Symbol.metadata");
-
-// src/adapter/express/router.ts
-import { Router } from "express";
-import { join } from "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
-import crypto from "crypto";
-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 crypto.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
-import Ajv from "ajv";
-import addFormats from "ajv-formats";
-var ValidationErrorResponse = class extends Error {
-  /**
-   * HTTP status code for validation errors.
-   */
-  statusCode;
-  /**
-   * Detailed validation errors.
-   */
-  errors;
-  /**
-   * Creates a new ValidationErrorResponse.
-   * 
-   * @param statusCode - HTTP status code (typically 400)
-   * @param errors - Array of validation errors
-   */
-  constructor(statusCode, errors) {
-    super("Validation failed");
-    this.name = "ValidationErrorResponse";
-    this.statusCode = statusCode;
-    this.errors = errors;
-  }
-};
-function createValidator() {
-  const ajv = new Ajv.default({
-    allErrors: true,
-    coerceTypes: false,
-    strict: false,
-    validateFormats: true
-  });
-  addFormats.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
-import fs from "fs";
-import path from "path";
-import { stat } from "fs/promises";
-var artifactCache = /* @__PURE__ */ new Map();
-async function getMtime(filePath) {
-  try {
-    const stats = await stat(filePath);
-    return stats.mtimeMs;
-  } catch {
-    return null;
-  }
-}
-async function loadArtifacts(options) {
-  const { outDir } = options;
-  const cacheKey = path.resolve(outDir);
-  const entry = artifactCache.get(cacheKey);
-  const openapiPath = path.join(outDir, "openapi.json");
-  const manifestPath = path.join(outDir, "manifest.json");
-  const validatorsPath = path.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 = fs.readFileSync(openapiPath, "utf-8");
-  const manifestContent = fs.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(path.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/openapi.ts
-function toOpenApiPath(path3) {
-  return path3.replace(/:([^/]+)/g, "{$1}");
-}
-function getOpenApiOperation(openapi, route) {
-  const pathKey = toOpenApiPath(route.fullPath);
-  const pathItem = openapi.paths?.[pathKey];
-  if (!pathItem) return null;
-  return pathItem[route.httpMethod.toLowerCase()] ?? null;
-}
-function getParamSchemaIndex(operation) {
-  const index = /* @__PURE__ */ new Map();
-  const params = operation?.parameters ?? [];
-  for (const param of params) {
-    if (!param?.name || !param?.in) continue;
-    if (param.schema) {
-      index.set(`${param.in}:${param.name}`, param.schema);
-    }
-  }
-  return index;
-}
-function getParamSchemaFromIndex(index, location, name) {
-  return index.get(`${location}:${name}`) ?? null;
-}
-function getRequestBodySchema(operation, contentType) {
-  const content = operation?.requestBody?.content;
-  if (!content) return null;
-  if (contentType && content[contentType]?.schema) {
-    return content[contentType].schema;
-  }
-  const first = Object.values(content)[0];
-  return first?.schema ?? null;
-}
-function schemaFromType(schemaType) {
-  if (!schemaType) return null;
-  return { type: schemaType };
-}
-function resolveSchema(schema, components, seen = /* @__PURE__ */ new Set()) {
-  const ref = schema.$ref;
-  if (typeof ref !== "string" || !ref.startsWith("#/components/schemas/")) {
-    return schema;
-  }
-  const name = ref.replace("#/components/schemas/", "");
-  if (seen.has(name)) return schema;
-  const next = components[name];
-  if (!next) return schema;
-  seen.add(name);
-  return resolveSchema(next, components, seen);
-}
-function getSchemaByRef(openapi, ref) {
-  if (!ref.startsWith("#/components/schemas/")) return null;
-  const schemaName = ref.replace("#/components/schemas/", "");
-  return openapi.components.schemas[schemaName] || null;
-}
-
-// src/adapter/express/coercion.ts
-function normalizeCoerceOptions(coerce) {
-  return {
-    body: coerce?.body ?? false,
-    query: coerce?.query ?? false,
-    path: coerce?.path ?? false,
-    header: coerce?.header ?? false,
-    cookie: coerce?.cookie ?? false,
-    dateTime: coerce?.dateTime ?? false,
-    date: coerce?.date ?? false
-  };
-}
-function getDateCoercionOptions(coerce, location) {
-  const enabled = coerce[location];
-  return {
-    dateTime: enabled && coerce.dateTime,
-    date: enabled && coerce.date
-  };
-}
-function coerceDatesWithSchema(value, schema, dateCoercion, components) {
-  if (!schema || !dateCoercion.date && !dateCoercion.dateTime) return value;
-  return coerceWithSchema(value, schema, dateCoercion, components, { coercePrimitives: false });
-}
-function coerceParamValue(value, schema, dateCoercion, components) {
-  if (!schema) return value;
-  return coerceWithSchema(value, schema, dateCoercion, components, { coercePrimitives: true });
-}
-function coerceWithSchema(value, schema, dateCoercion, components, options) {
-  if (value === void 0 || value === null) return value;
-  if (value instanceof Date) return value;
-  const resolved = resolveSchema(schema, components);
-  const override = resolved["x-adorn-coerce"];
-  const allowDateTime = override === true ? true : override === false ? false : dateCoercion.dateTime;
-  const allowDate = override === true ? true : override === false ? false : dateCoercion.date;
-  const byFormat = coerceDateString(value, resolved, allowDateTime, allowDate);
-  if (byFormat !== value) return byFormat;
-  const allOf = resolved.allOf;
-  if (Array.isArray(allOf)) {
-    let out = value;
-    for (const entry of allOf) {
-      out = coerceWithSchema(out, entry, { dateTime: allowDateTime, date: allowDate }, components, options);
-    }
-    return out;
-  }
-  const variants = resolved.oneOf ?? resolved.anyOf;
-  if (Array.isArray(variants)) {
-    for (const entry of variants) {
-      const out = coerceWithSchema(value, entry, { dateTime: allowDateTime, date: allowDate }, components, options);
-      if (out !== value) return out;
-    }
-  }
-  const schemaType = resolved.type;
-  const types = Array.isArray(schemaType) ? schemaType : schemaType ? [schemaType] : [];
-  if ((types.includes("array") || resolved.items) && Array.isArray(value)) {
-    const itemSchema = resolved.items ?? {};
-    return value.map((item) => coerceWithSchema(item, itemSchema, { dateTime: allowDateTime, date: allowDate }, components, options));
-  }
-  if ((types.includes("object") || resolved.properties || resolved.additionalProperties) && isPlainObject(value)) {
-    const props = resolved.properties;
-    const out = { ...value };
-    if (props) {
-      for (const [key, propSchema] of Object.entries(props)) {
-        if (Object.prototype.hasOwnProperty.call(value, key)) {
-          out[key] = coerceWithSchema(value[key], propSchema, { dateTime: allowDateTime, date: allowDate }, components, options);
-        }
-      }
-    }
-    const additional = resolved.additionalProperties;
-    if (additional && typeof additional === "object") {
-      for (const [key, entry] of Object.entries(value)) {
-        if (props && Object.prototype.hasOwnProperty.call(props, key)) continue;
-        out[key] = coerceWithSchema(entry, additional, { dateTime: allowDateTime, date: allowDate }, components, options);
-      }
-    }
-    return out;
-  }
-  if (options.coercePrimitives) {
-    return coercePrimitiveValue(value, types);
-  }
-  return value;
-}
-function coerceDateString(value, schema, allowDateTime, allowDate) {
-  if (typeof value !== "string") return value;
-  const format = schema.format;
-  const schemaType = schema.type;
-  const types = Array.isArray(schemaType) ? schemaType : schemaType ? [schemaType] : [];
-  const allowsString = types.length === 0 || types.includes("string");
-  if (format === "date-time" && allowDateTime && allowsString) {
-    const parsed = new Date(value);
-    if (Number.isNaN(parsed.getTime())) {
-      throw new Error(`Invalid date-time: ${value}`);
-    }
-    return parsed;
-  }
-  if (format === "date" && allowDate && allowsString) {
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
-      throw new Error(`Invalid date: ${value}`);
-    }
-    const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
-    if (Number.isNaN(parsed.getTime())) {
-      throw new Error(`Invalid date: ${value}`);
-    }
-    return parsed;
-  }
-  return value;
-}
-function coercePrimitiveValue(value, types) {
-  if (value === void 0 || value === null) return value;
-  if (types.includes("number") || types.includes("integer")) {
-    const num = Number(value);
-    if (Number.isNaN(num)) {
-      throw new Error(`Invalid number: ${value}`);
-    }
-    return num;
-  }
-  if (types.includes("boolean")) {
-    if (value === "true") return true;
-    if (value === "false") return false;
-    if (typeof value === "boolean") return value;
-    throw new Error(`Invalid boolean: ${value}`);
-  }
-  return value;
-}
-function isPlainObject(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-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 getRawQueryString(req) {
-  const url = req.originalUrl ?? req.url ?? "";
-  const index = url.indexOf("?");
-  if (index === -1) return "";
-  return url.slice(index + 1);
-}
-function parseDeepObjectParams(rawQuery, names, maxDepth = 5) {
-  const out = {};
-  if (!rawQuery || names.size === 0) return out;
-  const params = new URLSearchParams(rawQuery);
-  for (const [key, value] of params.entries()) {
-    const path3 = parseBracketPath(key);
-    if (path3.length === 0) continue;
-    if (path3.length > maxDepth) {
-      throw new Error(`Query parameter nesting depth (${path3.length}) exceeds maximum of ${maxDepth}`);
-    }
-    const root = path3[0];
-    if (!names.has(root)) continue;
-    assignDeepValue(out, path3, value);
-  }
-  return out;
-}
-function parseBracketPath(key) {
-  const parts = [];
-  let current = "";
-  for (let i = 0; i < key.length; i++) {
-    const ch = key[i];
-    if (ch === "[") {
-      if (current) parts.push(current);
-      current = "";
-      continue;
-    }
-    if (ch === "]") {
-      if (current) parts.push(current);
-      current = "";
-      continue;
-    }
-    current += ch;
-  }
-  if (current) parts.push(current);
-  return parts;
-}
-function assignDeepValue(target, path3, value) {
-  let cursor = target;
-  for (let i = 0; i < path3.length; i++) {
-    const key = path3[i];
-    if (!key) continue;
-    const isLast = i === path3.length - 1;
-    if (isLast) {
-      const existing = cursor[key];
-      if (existing === void 0) {
-        cursor[key] = value;
-      } else if (Array.isArray(existing)) {
-        existing.push(value);
-      } else {
-        cursor[key] = [existing, value];
-      }
-      return;
-    }
-    const next = cursor[key];
-    if (!isPlainObject(next)) {
-      cursor[key] = {};
-    }
-    cursor = cursor[key];
-  }
-}
-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 normalizeSort(sort) {
-  if (Array.isArray(sort)) {
-    return sort.map((s) => String(s));
-  }
-  if (typeof sort === "string") {
-    return sort.split(",").map((s) => s.trim()).filter(Boolean);
-  }
-  return [];
-}
-
-// src/adapter/express/auth.ts
-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();
-  };
-}
-
-// src/adapter/express/validation.ts
-function validateRequestWithPrecompiled(route, req, validators, maxDepth = 5) {
-  const errors = [];
-  const deepNames = new Set(route.args.query.filter((q) => q.serialization?.style === "deepObject").map((q) => q.name));
-  const deepValues = deepNames.size > 0 ? parseDeepObjectParams(getRawQueryString(req), deepNames, maxDepth) : {};
-  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) {
-    let value = q.serialization?.style === "deepObject" ? deepValues[q.name] : req.query[q.name];
-    if (q.content === "application/json" && typeof value === "string") {
-      try {
-        value = JSON.parse(value);
-      } catch {
-        errors.push({
-          path: `#/query/${q.name}`,
-          message: "Invalid JSON string",
-          keyword: "json",
-          params: {}
-        });
-        continue;
-      }
-    }
-  }
-  return errors.length > 0 ? errors : null;
-}
-function validateRequest(route, req, openapi, validator, maxDepth = 5) {
-  const openapiOperation = getOpenApiOperation(openapi, route);
-  const paramSchemaIndex = getParamSchemaIndex(openapiOperation);
-  const deepNames = new Set(route.args.query.filter((q) => q.serialization?.style === "deepObject").map((q) => q.name));
-  const deepValues = deepNames.size > 0 ? parseDeepObjectParams(getRawQueryString(req), deepNames, maxDepth) : {};
-  const errors = [];
-  if (route.args.body) {
-    const bodySchema = getSchemaByRef(openapi, 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) {
-    let value = q.serialization?.style === "deepObject" ? deepValues[q.name] : req.query[q.name];
-    if (q.content === "application/json" && typeof value === "string") {
-      try {
-        value = JSON.parse(value);
-      } catch {
-        errors.push({
-          path: `#/query/${q.name}`,
-          message: "Invalid JSON string",
-          keyword: "json",
-          params: {}
-        });
-        continue;
-      }
-    }
-    const openapiSchema = getParamSchemaFromIndex(paramSchemaIndex, "query", q.name);
-    let schema = {};
-    if (openapiSchema) {
-      schema = resolveSchema(openapiSchema, openapi.components.schemas);
-    } else {
-      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(openapi, q.schemaRef);
-        if (inlineSchema) {
-          Object.assign(schema, inlineSchema);
-        }
-      }
-    }
-    const coerced = coerceParamValue(value, schema, { dateTime: false, date: false }, openapi.components.schemas);
-    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 openapiSchema = getParamSchemaFromIndex(paramSchemaIndex, "path", p.name);
-    let schema = {};
-    if (openapiSchema) {
-      schema = resolveSchema(openapiSchema, openapi.components.schemas);
-    } else {
-      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(openapi, p.schemaRef);
-        if (inlineSchema) {
-          Object.assign(schema, inlineSchema);
-        }
-      }
-    }
-    const coerced = coerceParamValue(value, schema, { dateTime: false, date: false }, openapi.components.schemas);
-    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;
-}
-
-// src/adapter/express/router.ts
-async function createExpressRouter(options) {
-  const { controllers, artifactsDir = ".adorn", middleware = {}, defaultPageSize = 10, queryOptions } = 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 = 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 = Router();
-  const instanceCache = /* @__PURE__ */ new Map();
-  const coerce = normalizeCoerceOptions(options.coerce);
-  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;
-    });
-  }
-  for (const route of routes) {
-    const method = route.httpMethod.toLowerCase();
-    const openapiOperation = getOpenApiOperation(openapi, route);
-    const paramSchemaIndex = getParamSchemaIndex(openapiOperation);
-    const bodySchema = getRequestBodySchema(openapiOperation, route.args.body?.contentType) ?? (route.args.body ? getSchemaByRef(openapi, route.args.body.schemaRef) : null);
-    const coerceBodyDates = getDateCoercionOptions(coerce, "body");
-    const coerceQueryDates = getDateCoercionOptions(coerce, "query");
-    const coercePathDates = getDateCoercionOptions(coerce, "path");
-    const coerceHeaderDates = getDateCoercionOptions(coerce, "header");
-    const coerceCookieDates = getDateCoercionOptions(coerce, "cookie");
-    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 maxDepth = queryOptions?.maxNestingDepth ?? 5;
-        const validationErrors = precompiledValidators ? validateRequestWithPrecompiled(route, req, precompiledValidators, maxDepth) : validateRequest(route, req, openapi, validator, maxDepth);
-        if (validationErrors) {
-          return res.status(400).json(formatValidationErrors(validationErrors));
-        }
-        const deepNames = new Set(
-          route.args.query.filter((q) => q.serialization?.style === "deepObject").map((q) => q.name)
-        );
-        const deepValues = deepNames.size > 0 ? parseDeepObjectParams(getRawQueryString(req), deepNames, maxDepth) : {};
-        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) {
-          const coercedBody = (coerceBodyDates.date || coerceBodyDates.dateTime) && bodySchema ? coerceDatesWithSchema(req.body, bodySchema, coerceBodyDates, openapi.components.schemas) : req.body;
-          args[route.args.body.index] = coercedBody;
-        }
-        for (const pathArg of route.args.path) {
-          const rawValue = req.params[pathArg.name];
-          const paramSchema = getParamSchemaFromIndex(paramSchemaIndex, "path", pathArg.name) ?? (pathArg.schemaRef ? getSchemaByRef(openapi, pathArg.schemaRef) : null) ?? schemaFromType(pathArg.schemaType);
-          const coerced = coerceParamValue(rawValue, paramSchema, coercePathDates, openapi.components.schemas);
-          args[pathArg.index] = coerced;
-        }
-        if (route.args.query.length > 0) {
-          const jsonArgs = route.args.query.filter((q) => q.content === "application/json");
-          const standardArgs = route.args.query.filter((q) => q.content !== "application/json");
-          const queryArgIndex = standardArgs[0]?.index;
-          if (queryArgIndex !== void 0) {
-            args[queryArgIndex] = {};
-          }
-          if (jsonArgs.length > 0) {
-            for (const q of jsonArgs) {
-              const rawValue = q.serialization?.style === "deepObject" ? deepValues[q.name] : req.query[q.name];
-              if (rawValue === void 0 || rawValue === null) continue;
-              let parsed = rawValue;
-              if (typeof rawValue === "string" && rawValue.length > 0) {
-                try {
-                  parsed = JSON.parse(rawValue);
-                } catch {
-                  parsed = rawValue;
-                }
-              }
-              const paramSchema = getParamSchemaFromIndex(paramSchemaIndex, "query", q.name) ?? (q.schemaRef ? getSchemaByRef(openapi, q.schemaRef) : null) ?? schemaFromType(q.schemaType);
-              const coerced = coerceParamValue(parsed, paramSchema, coerceQueryDates, openapi.components.schemas);
-              if (!args[q.index] || typeof args[q.index] !== "object") {
-                args[q.index] = {};
-              }
-              Object.assign(args[q.index], coerced);
-            }
-          }
-          if (standardArgs.length > 0) {
-            for (const q of standardArgs) {
-              const rawValue = q.serialization?.style === "deepObject" ? deepValues[q.name] : req.query[q.name];
-              if (rawValue === void 0) continue;
-              const parsed = parseQueryValue(rawValue, q);
-              const paramSchema = getParamSchemaFromIndex(paramSchemaIndex, "query", q.name) ?? (q.schemaRef ? getSchemaByRef(openapi, q.schemaRef) : null) ?? schemaFromType(q.schemaType);
-              const coerced = coerceParamValue(parsed, paramSchema, coerceQueryDates, openapi.components.schemas);
-              if (!args[q.index] || typeof args[q.index] !== "object") {
-                args[q.index] = {};
-              }
-              args[q.index][q.name] = coerced;
-            }
-          }
-          if (queryArgIndex !== void 0 && args[queryArgIndex]) {
-            const queryObj = args[queryArgIndex];
-            if (queryObj.page === void 0) {
-              queryObj.page = 1;
-            }
-            if (queryObj.pageSize === void 0) {
-              queryObj.pageSize = defaultPageSize;
-            }
-            if (queryObj.sort) {
-              queryObj.sort = normalizeSort(queryObj.sort);
-            }
-          }
-        }
-        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()];
-              const paramSchema = getParamSchemaFromIndex(paramSchemaIndex, "header", h.name) ?? (h.schemaRef ? getSchemaByRef(openapi, h.schemaRef) : null) ?? schemaFromType(h.schemaType);
-              const coerced = coerceParamValue(headerValue, paramSchema, coerceHeaderDates, openapi.components.schemas);
-              args[firstHeaderIndex][h.name] = coerced ?? void 0;
-            }
-          } else {
-            for (const h of route.args.headers) {
-              const headerValue = req.headers[h.name.toLowerCase()];
-              const paramSchema = getParamSchemaFromIndex(paramSchemaIndex, "header", h.name) ?? (h.schemaRef ? getSchemaByRef(openapi, h.schemaRef) : null) ?? schemaFromType(h.schemaType);
-              const coerced = coerceParamValue(headerValue, paramSchema, coerceHeaderDates, openapi.components.schemas);
-              args[h.index] = coerced ?? 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 paramSchema = getParamSchemaFromIndex(paramSchemaIndex, "cookie", c.name) ?? (c.schemaRef ? getSchemaByRef(openapi, c.name) : null) ?? schemaFromType(c.schemaType);
-              const coerced = coerceParamValue(cookieValue, paramSchema, coerceCookieDates, openapi.components.schemas);
-              args[firstCookieIndex][c.name] = coerced;
-            }
-          } else {
-            for (const c of route.args.cookies) {
-              const cookieValue = cookies[c.name];
-              const paramSchema = getParamSchemaFromIndex(paramSchemaIndex, "cookie", c.name) ?? (c.schemaRef ? getSchemaByRef(openapi, c.name) : null) ?? schemaFromType(c.schemaType);
-              const coerced = coerceParamValue(cookieValue, paramSchema, coerceCookieDates, openapi.components.schemas);
-              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;
-}
-
-// src/adapter/express/swagger.ts
-import { Router as Router2 } from "express";
-import { readFileSync, existsSync } from "fs";
-import { resolve, isAbsolute, join as join2 } from "path";
-import swaggerUi from "swagger-ui-express";
-var DEFAULT_SWAGGER_UI_OPTIONS = {
-  docExpansion: "none",
-  // Collapse all by default for better performance
-  filter: true,
-  // Show filter input
-  showRequestDuration: true,
-  // Show request duration
-  displayRequestDuration: true,
-  operationsSorter: "alpha",
-  // Sort operations alphabetically
-  tagsSorter: "alpha",
-  // Sort tags alphabetically
-  persistAuthorization: true
-  // Persist authorization across reloads
-};
-function isSplitMode(openapiPath) {
-  const schemasDir = join2(openapiPath, "..", "schemas");
-  return existsSync(schemasDir);
-}
-function createSchemaRouter(artifactsDir) {
-  const router = Router2();
-  const schemasDir = isAbsolute(artifactsDir) ? resolve(artifactsDir, "schemas") : resolve(process.cwd(), artifactsDir, "schemas");
-  router.get("/schemas/:filename", (req, res, next) => {
-    const { filename } = req.params;
-    const filePath = resolve(schemasDir, filename);
-    if (!existsSync(filePath)) {
-      return res.status(404).json({ error: "Schema file not found" });
-    }
-    try {
-      const content = readFileSync(filePath, "utf-8");
-      res.setHeader("Content-Type", "application/json");
-      res.send(content);
-    } catch (error) {
-      next(error);
-    }
-  });
-  return router;
-}
-function setupSwagger(options = {}) {
-  const {
-    artifactsDir = ".adorn",
-    jsonPath = "/docs/openapi.json",
-    uiPath = "/docs",
-    swaggerOptions = {},
-    swaggerUiOptions = {}
-  } = options;
-  const router = Router2();
-  const openApiPath = isAbsolute(artifactsDir) ? resolve(artifactsDir, "openapi.json") : resolve(process.cwd(), artifactsDir, "openapi.json");
-  const splitMode = isSplitMode(openApiPath);
-  router.get(jsonPath, (req, res) => {
-    if (!existsSync(openApiPath)) {
-      return res.status(404).json({ error: "OpenAPI spec not found" });
-    }
-    const content = readFileSync(openApiPath, "utf-8");
-    res.setHeader("Content-Type", "application/json");
-    res.send(content);
-  });
-  if (splitMode) {
-    router.use("/schemas", createSchemaRouter(artifactsDir));
-  }
-  const mergedSwaggerOptions = {
-    ...DEFAULT_SWAGGER_UI_OPTIONS,
-    ...swaggerOptions
-  };
-  router.use(uiPath, swaggerUi.serve, swaggerUi.setup(null, {
-    swaggerOptions: {
-      url: jsonPath,
-      ...mergedSwaggerOptions,
-      // Add support for external $ref references in split mode
-      supportedSubmitMethods: ["get", "put", "post", "delete", "options", "head", "patch"]
-    },
-    ...swaggerUiOptions
-  }));
-  return router;
-}
-
-// src/adapter/express/bootstrap.ts
-import express from "express";
-import cors from "cors";
-import path2 from "path";
-var DEFAULT_CORS_CONFIG = {
-  origin: (origin, callback) => {
-    const allowedOrigins = process.env.CORS_ALLOWED_ORIGINS ? process.env.CORS_ALLOWED_ORIGINS.split(",") : ["http://localhost:*", "http://127.0.0.1:*"];
-    if (!origin) {
-      return callback(null, true);
-    }
-    const isAllowed = allowedOrigins.some((allowed) => {
-      if (allowed === "*") return true;
-      if (allowed.includes("*")) {
-        const regex = new RegExp(allowed.replace("*", ".*"));
-        return regex.test(origin);
-      }
-      return origin === allowed;
-    });
-    callback(null, isAllowed);
-  },
-  methods: ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
-  allowedHeaders: ["Content-Type", "Authorization", "X-Requested-With"],
-  credentials: false,
-  optionsSuccessStatus: 204,
-  maxAge: 86400
-};
-function applyCors(app, config) {
-  if (typeof config === "function") {
-    config(app);
-    return;
-  }
-  if (config === true) {
-    app.use(cors(DEFAULT_CORS_CONFIG));
-    return;
-  }
-  app.use(cors(config));
-}
-function bootstrap(options) {
-  return new Promise((resolve2, reject) => {
-    const {
-      controllers,
-      port: userPort,
-      host: userHost,
-      artifactsDir: userArtifactsDir = ".adorn",
-      enableSwagger = true,
-      swaggerPath = "/docs",
-      swaggerJsonPath = "/docs/openapi.json",
-      middleware,
-      auth,
-      coerce,
-      cors: cors2
-    } = 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 = path2.isAbsolute(userArtifactsDir) ? userArtifactsDir : path2.resolve(process.cwd(), userArtifactsDir);
-    const app = express();
-    app.use(express.json());
-    if (cors2 !== void 0 && cors2 !== false) {
-      applyCors(app, cors2);
-    }
-    createExpressRouter({
-      controllers,
-      artifactsDir: absoluteArtifactsDir,
-      middleware,
-      auth,
-      coerce
-    }).then((router) => {
-      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 }],
-              ...options.swaggerOptions
-            },
-            swaggerUiOptions: options.swaggerUiOptions
-          })
-        );
-      }
-      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(reject);
-  });
-}
-export {
-  ValidationErrorResponse,
-  bindRoutes,
-  bootstrap,
-  createExpressRouter,
-  createValidator,
-  formatValidationErrors,
-  setupSwagger
-};
-//# sourceMappingURL=express.js.map