@kabyeon/nexusjs 0.6.5

package/dist/openapi/index.js

@@ -0,0 +1,974 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/core/constants.ts
+var METADATA_KEY, PARAM_TYPES, HTTP_METHODS;
+var init_constants = __esm(() => {
+  METADATA_KEY = {
+    CONTROLLER: "nexus:controller",
+    INJECTABLE: "nexus:injectable",
+    REPOSITORY: "nexus:repository",
+    MODULE: "nexus:module",
+    ROUTES: "nexus:routes",
+    PARAMS: "nexus:params",
+    VALIDATE: "nexus:validate",
+    PARAMTYPES: "design:paramtypes",
+    TYPE: "design:type",
+    RETURNTYPE: "design:returntype",
+    INJECT: "nexus:inject"
+  };
+  PARAM_TYPES = {
+    REQUEST: 0,
+    RESPONSE: 1,
+    NEXT: 2,
+    BODY: 3,
+    QUERY: 4,
+    PARAM: 5,
+    HEADERS: 6,
+    CTX: 7,
+    USER: 8
+  };
+  HTTP_METHODS = [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "OPTIONS",
+    "HEAD"
+  ];
+});
+
+// src/core/decorators/controller.ts
+import"reflect-metadata";
+function Controller(prefix = "/") {
+  return (target) => {
+    const normalized = normalizePrefix(prefix);
+    const meta = { prefix: normalized };
+    Reflect.defineMetadata(METADATA_KEY.CONTROLLER, meta, target);
+  };
+}
+function getControllerMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.CONTROLLER, target) ?? { prefix: "/" };
+}
+function isController(target) {
+  return Reflect.hasMetadata(METADATA_KEY.CONTROLLER, target);
+}
+function normalizePrefix(prefix) {
+  if (!prefix)
+    return "";
+  if (prefix !== "/" && prefix.endsWith("/")) {
+    return prefix.slice(0, -1);
+  }
+  return prefix;
+}
+var init_controller = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/http-methods.ts
+import"reflect-metadata";
+function defineRoute(method, path) {
+  return (target, propertyKey, descriptor) => {
+    const routes = Reflect.getMetadata(METADATA_KEY.ROUTES, target.constructor) ?? [];
+    routes.push({
+      method,
+      path: normalizePath(path),
+      propertyKey,
+      handler: descriptor.value
+    });
+    Reflect.defineMetadata(METADATA_KEY.ROUTES, routes, target.constructor);
+  };
+}
+function normalizePath(path) {
+  if (!path || path === "/")
+    return "/";
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function getRoutes(target) {
+  return Reflect.getMetadata(METADATA_KEY.ROUTES, target) ?? [];
+}
+var Get = (path = "/") => defineRoute("GET", path), Post = (path = "/") => defineRoute("POST", path), Put = (path = "/") => defineRoute("PUT", path), Delete = (path = "/") => defineRoute("DELETE", path), Patch = (path = "/") => defineRoute("PATCH", path), Options = (path = "/") => defineRoute("OPTIONS", path), Head = (path = "/") => defineRoute("HEAD", path);
+var init_http_methods = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/params.ts
+import"reflect-metadata";
+function createParamDecorator(type, data) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey !== undefined) {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target, propertyKey);
+    } else {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target);
+    }
+  };
+}
+function getParamMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+}
+var Req = () => createParamDecorator(PARAM_TYPES.REQUEST), Res = () => createParamDecorator(PARAM_TYPES.RESPONSE), Next = () => createParamDecorator(PARAM_TYPES.NEXT), Body = (key) => createParamDecorator(PARAM_TYPES.BODY, key), Query = (key) => createParamDecorator(PARAM_TYPES.QUERY, key), Param = (key) => createParamDecorator(PARAM_TYPES.PARAM, key), Headers = (key) => createParamDecorator(PARAM_TYPES.HEADERS, key), Ctx = () => createParamDecorator(PARAM_TYPES.CTX), User = () => createParamDecorator(PARAM_TYPES.USER);
+var init_params = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/validate.ts
+import"reflect-metadata";
+function Validate(options) {
+  return (target, propertyKey, descriptor) => {
+    Reflect.defineMetadata(METADATA_KEY.VALIDATE, options, target.constructor, propertyKey);
+  };
+}
+function getValidationMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.VALIDATE, target, propertyKey);
+}
+var init_validate = __esm(() => {
+  init_constants();
+});
+
+// src/openapi/scalar.ts
+var exports_scalar = {};
+__export(exports_scalar, {
+  scalarHtml: () => scalarHtml
+});
+function scalarHtml(opts) {
+  const title = escapeHtml(opts.title);
+  const theme = opts.theme ?? "default";
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${title} \u2014 API Reference</title>
+  <meta name="description" content="API reference for ${title}, generated from OpenAPI." />
+  <style>
+    :root { color-scheme: light dark; }
+    body { margin: 0; font-family: ui-sans-serif, system-ui, sans-serif; }
+  </style>
+</head>
+<body>
+  <script
+    id="api-reference"
+    type="application/json"
+    data-url="${escapeHtml(opts.specUrl)}"
+    data-configuration='${escapeJsonForAttr(JSON.stringify({ theme, hideClientButton: true }))}'
+  ></script>
+  <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference@1.25.0"></script>
+</body>
+</html>`;
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function escapeJsonForAttr(s) {
+  return s.replace(/'/g, "&#39;").replace(/</g, "&lt;");
+}
+
+// src/openapi/types.ts
+import"reflect-metadata";
+var OPENAPI_META = {
+  TAGS: "nexus:openapi:tags",
+  OPERATION: "nexus:openapi:operation",
+  RESPONSES: "nexus:openapi:responses",
+  PARAMS: "nexus:openapi:params",
+  QUERIES: "nexus:openapi:queries",
+  BODY: "nexus:openapi:body",
+  PROPERTIES: "nexus:openapi:properties",
+  SECURITY: "nexus:openapi:security",
+  EXCLUDE: "nexus:openapi:exclude",
+  PRODUCES: "nexus:openapi:produces",
+  CONSUMES: "nexus:openapi:consumes"
+};
+// src/openapi/openapi.service.ts
+import"reflect-metadata";
+
+// src/core/decorators/module.ts
+init_constants();
+import"reflect-metadata";
+function Module(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.MODULE, options, target);
+  };
+}
+function getModuleOptions(target) {
+  return Reflect.getMetadata(METADATA_KEY.MODULE, target) ?? {};
+}
+
+// src/core/decorators/index.ts
+init_controller();
+
+// src/core/decorators/injectable.ts
+init_constants();
+import"reflect-metadata";
+function Injectable(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+    if (options.scope) {
+      Reflect.defineMetadata("nexus:di:scope", options.scope, target);
+    }
+  };
+}
+function isInjectable(target) {
+  return Reflect.hasMetadata(METADATA_KEY.INJECTABLE, target);
+}
+function getScope(target) {
+  return Reflect.getMetadata("nexus:di:scope", target);
+}
+function Inject(token) {
+  return (target, propertyKey, parameterIndex) => {
+    const existing = Reflect.getMetadata(METADATA_KEY.INJECT, target) ?? new Map;
+    existing.set(parameterIndex, token);
+    Reflect.defineMetadata(METADATA_KEY.INJECT, existing, target);
+  };
+}
+
+// src/core/decorators/index.ts
+init_http_methods();
+init_params();
+init_validate();
+
+// src/core/decorators/repository.ts
+init_constants();
+import"reflect-metadata";
+function Repository(entityToken) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.REPOSITORY, { entity: entityToken }, target);
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+  };
+}
+function getRepositoryMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.REPOSITORY, target);
+}
+function isRepository(target) {
+  return Reflect.hasMetadata(METADATA_KEY.REPOSITORY, target);
+}
+// src/core/decorators/metadata.ts
+init_constants();
+// src/openapi/zod-to-json-schema.ts
+function zodToJsonSchema(schema, opts = {}) {
+  const defs = opts.$defs ?? {};
+  const visited = opts.visited ?? new WeakSet;
+  if (visited.has(schema)) {
+    return {};
+  }
+  if (typeof schema === "object" && schema !== null) {
+    visited.add(schema);
+  }
+  const def = readDef(schema);
+  if (def.typeName === "ZodString")
+    return convertString(def);
+  if (def.typeName === "ZodNumber")
+    return convertNumber(def);
+  if (def.typeName === "ZodBigInt")
+    return { type: "integer", format: "int64" };
+  if (def.typeName === "ZodBoolean")
+    return { type: "boolean" };
+  if (def.typeName === "ZodDate")
+    return { type: "string", format: "date-time" };
+  if (def.typeName === "ZodNull")
+    return { type: "null" };
+  if (def.typeName === "ZodUndefined")
+    return { not: {} };
+  if (def.typeName === "ZodAny")
+    return {};
+  if (def.typeName === "ZodUnknown")
+    return {};
+  if (def.typeName === "ZodNever")
+    return { not: {} };
+  if (def.typeName === "ZodLiteral") {
+    const v = def.value;
+    return { type: jsonTypeOf(v), enum: [v] };
+  }
+  if (def.typeName === "ZodEnum") {
+    const values = def.values;
+    const t = values.every((v) => typeof v === "number") ? "number" : "string";
+    return { type: t, enum: [...values] };
+  }
+  if (def.typeName === "ZodNativeEnum") {
+    const values = def.values;
+    const entries = Object.entries(values).filter(([k, v]) => typeof v !== "number" || isNaN(Number(k)));
+    const opts2 = entries.map(([, v]) => v);
+    const t = opts2.every((v) => typeof v === "number") ? "number" : "string";
+    return { type: t, enum: opts2 };
+  }
+  if (def.typeName === "ZodObject") {
+    return convertObject(schema, def, defs, visited);
+  }
+  if (def.typeName === "ZodArray") {
+    return convertArray(schema, def, defs, visited);
+  }
+  if (def.typeName === "ZodTuple") {
+    const items = def.items;
+    return {
+      type: "array",
+      prefixItems: items.map((s) => zodToJsonSchema(s, { $defs: defs, visited })),
+      minItems: items.length,
+      maxItems: items.length
+    };
+  }
+  if (def.typeName === "ZodUnion" || def.typeName === "ZodDiscriminatedUnion") {
+    const options = def.options ?? def.optionsArray ?? [];
+    return {
+      oneOf: options.map((s) => zodToJsonSchema(s, { $defs: defs, visited }))
+    };
+  }
+  if (def.typeName === "ZodDiscriminatedUnion") {
+    const discriminator = def.discriminator;
+    const options = def.options ?? [];
+    const mapping = {};
+    for (const opt of options) {
+      const od = readDef(opt);
+      if (od.typeName === "ZodObject") {
+        const shape = od.shape();
+        const disc = shape[discriminator ?? ""];
+        if (disc && "value" in disc) {
+          mapping[String(disc.value)] = zodToJsonSchema(opt, { $defs: defs, visited });
+        }
+      }
+    }
+    return {
+      oneOf: Object.values(mapping),
+      discriminator: { propertyName: discriminator ?? "type" }
+    };
+  }
+  if (def.typeName === "ZodIntersection") {
+    const left = def._def?.left ?? def.left;
+    const right = def._def?.right ?? def.right;
+    return {
+      allOf: [
+        zodToJsonSchema(left, { $defs: defs, visited }),
+        zodToJsonSchema(right, { $defs: defs, visited })
+      ]
+    };
+  }
+  if (def.typeName === "ZodRecord") {
+    const valueType = def.valueType;
+    return {
+      type: "object",
+      additionalProperties: zodToJsonSchema(valueType, { $defs: defs, visited })
+    };
+  }
+  if (def.typeName === "ZodMap") {
+    const valueType = def.valueType;
+    return {
+      type: "object",
+      additionalProperties: zodToJsonSchema(valueType, { $defs: defs, visited })
+    };
+  }
+  if (def.typeName === "ZodOptional") {
+    const inner = def.innerType;
+    return zodToJsonSchema(inner, { $defs: defs, visited });
+  }
+  if (def.typeName === "ZodNullable") {
+    const inner = def.innerType;
+    return {
+      ...zodToJsonSchema(inner, { $defs: defs, visited }),
+      nullable: true
+    };
+  }
+  if (def.typeName === "ZodDefault") {
+    const inner = def.innerType;
+    const dv = def.defaultValue;
+    return {
+      ...zodToJsonSchema(inner, { $defs: defs, visited }),
+      default: safeCall(dv)
+    };
+  }
+  if (def.typeName === "ZodCatch") {
+    const inner = def.innerType;
+    return zodToJsonSchema(inner, { $defs: defs, visited });
+  }
+  if (def.typeName === "ZodBranded") {
+    const inner = def.type;
+    return zodToJsonSchema(inner, { $defs: defs, visited });
+  }
+  if (def.typeName === "ZodReadonly") {
+    const inner = def.innerType;
+    return zodToJsonSchema(inner, { $defs: defs, visited });
+  }
+  if (def.typeName === "ZodLazy") {
+    const getter = def.getter;
+    const inner = safeCall(getter);
+    return zodToJsonSchema(inner, { $defs: defs, visited });
+  }
+  if (def.typeName === "ZodEffects") {
+    const inner = def.source ?? def.schema ?? def.innerType;
+    return zodToJsonSchema(inner, { $defs: defs, visited });
+  }
+  if (def.typeName === "ZodPipeline") {
+    const inner = def.out;
+    return zodToJsonSchema(inner, { $defs: defs, visited });
+  }
+  if (def.typeName === "ZodFunction")
+    return { type: "null" };
+  if (def.typeName === "ZodPromise") {
+    const inner = def.innerType;
+    return zodToJsonSchema(inner, { $defs: defs, visited });
+  }
+  return {};
+}
+function readDef(schema) {
+  if (typeof schema !== "object" || schema === null)
+    return { typeName: "" };
+  const s = schema;
+  if (s._def && typeof s._def === "object")
+    return s._def;
+  return s;
+}
+function convertString(def) {
+  const out = { type: "string" };
+  const checks = def.checks ?? [];
+  for (const c of checks) {
+    switch (c.kind) {
+      case "email":
+        out.format = "email";
+        break;
+      case "url":
+        out.format = "uri";
+        break;
+      case "uuid":
+        out.format = "uuid";
+        break;
+      case "cuid":
+      case "cuid2":
+        out.format = "cuid";
+        break;
+      case "emoji":
+        break;
+      case "ip":
+        out.format = "ipv4";
+        break;
+      case "cidr":
+        out.format = "cidr";
+        break;
+      case "datetime":
+        out.format = "date-time";
+        break;
+      case "date":
+        out.format = "date";
+        break;
+      case "time":
+        out.format = "time";
+        break;
+      case "duration":
+        break;
+      case "min":
+      case "length":
+        out.minLength = Number(c.value);
+        break;
+      case "max":
+        out.maxLength = Number(c.value);
+        break;
+      case "regex":
+        if (c.regex)
+          out.pattern = c.regex.source;
+        break;
+      case "trim":
+      case "toLowerCase":
+      case "toUpperCase":
+      case "startsWith":
+      case "endsWith":
+      case "includes":
+        break;
+    }
+  }
+  return out;
+}
+function convertNumber(def) {
+  const out = { type: "number" };
+  const checks = def.checks ?? [];
+  let isInt = false;
+  for (const c of checks) {
+    switch (c.kind) {
+      case "int":
+      case "safeint":
+        isInt = true;
+        break;
+      case "min":
+        out.minimum = c.value;
+        break;
+      case "max":
+        out.maximum = c.value;
+        break;
+      case "finite":
+      case "multipleOf":
+        break;
+    }
+  }
+  if (isInt)
+    out.type = "integer";
+  return out;
+}
+function convertObject(_schema, def, defs, visited) {
+  const shapeFn = def.shape;
+  const shape = typeof shapeFn === "function" ? shapeFn() : shapeFn;
+  const properties = {};
+  const required = [];
+  const catchall = def.catchall;
+  if (shape && typeof shape === "object") {
+    for (const [key, value] of Object.entries(shape)) {
+      const child = zodToJsonSchema(value, { $defs: defs, visited });
+      const childDef = readDef(value);
+      const isOptional = childDef.typeName === "ZodOptional" || childDef.typeName === "ZodDefault" || childDef.typeName === "ZodCatch";
+      properties[key] = child;
+      if (!isOptional)
+        required.push(key);
+    }
+  }
+  const description = def.description;
+  const out = { type: "object", properties };
+  if (required.length > 0)
+    out.required = required;
+  if (typeof catchall === "object" && catchall !== null) {
+    const c = readDef(catchall);
+    if (c.typeName === "ZodNever")
+      out.additionalProperties = false;
+    else
+      out.additionalProperties = true;
+  }
+  if (description)
+    out.description = description;
+  return out;
+}
+function convertArray(_schema, def, defs, visited) {
+  const out = { type: "array" };
+  const element = def.element ?? def.type;
+  if (element)
+    out.items = zodToJsonSchema(element, { $defs: defs, visited });
+  const checks = def;
+  if (checks.minLength?.value != null)
+    out.minItems = checks.minLength.value;
+  if (checks.maxLength?.value != null)
+    out.maxItems = checks.maxLength.value;
+  return out;
+}
+function jsonTypeOf(v) {
+  if (v === null)
+    return "null";
+  if (typeof v === "string")
+    return "string";
+  if (typeof v === "number")
+    return "number";
+  if (typeof v === "boolean")
+    return "boolean";
+  return "object";
+}
+function safeCall(fn) {
+  try {
+    return fn();
+  } catch {
+    return;
+  }
+}
+
+// src/openapi/openapi.service.ts
+class OpenAPIService {
+  static TOKEN = Symbol.for("nexus:OpenAPIService");
+  #config;
+  #components = { schemas: new Map };
+  #routes = [];
+  constructor(config) {
+    this.#config = config;
+  }
+  setRoutes(routes) {
+    this.#routes = routes;
+  }
+  registerSchema(name, schema) {
+    this.#components.schemas.set(name, schema);
+  }
+  getSpec() {
+    const paths = {};
+    for (const route of this.#routes) {
+      if (Reflect.getMetadata(OPENAPI_META.EXCLUDE, route.target.constructor, route.propertyKey))
+        continue;
+      const op = this.buildOperation(route);
+      const normalized = this.normalizePath(route.path);
+      const method = route.method.toLowerCase();
+      if (!paths[normalized])
+        paths[normalized] = {};
+      paths[normalized][method] = op;
+    }
+    const doc = {
+      openapi: "3.1.0",
+      info: this.#config.info,
+      paths
+    };
+    if (this.#config.servers?.length)
+      doc.servers = this.#config.servers;
+    if (this.#config.tags?.length)
+      doc.tags = this.#config.tags;
+    if (this.#config.externalDocs)
+      doc.externalDocs = this.#config.externalDocs;
+    if (this.#components.schemas.size > 0) {
+      doc.components = {
+        schemas: Object.fromEntries(this.#components.schemas)
+      };
+    }
+    return doc;
+  }
+  buildOperation(route) {
+    const ctor = route.target.constructor ?? route.target;
+    const propKey = route.propertyKey;
+    const classTags = Reflect.getMetadata(OPENAPI_META.TAGS, ctor) ?? [];
+    const opMeta = Reflect.getMetadata(OPENAPI_META.OPERATION, ctor, propKey);
+    const opTags = opMeta?.tags ?? [];
+    const tags = [...new Set([...classTags, ...opTags])];
+    const params2 = [];
+    const pathParams = this.extractPathParams(route.path);
+    for (const name of pathParams) {
+      const override = (Reflect.getMetadata(OPENAPI_META.PARAMS, ctor, propKey) ?? []).find((p) => p.name === name);
+      params2.push({
+        name,
+        in: "path",
+        required: true,
+        description: override?.description,
+        schema: override?.schema ? this.toSchema(override.schema) : { type: "string" }
+      });
+    }
+    if (route.validation?.query) {
+      this.appendZodParams(ctor, propKey, "query", route.validation.query, params2, false);
+    }
+    if (route.validation?.headers) {
+      this.appendZodParams(ctor, propKey, "header", route.validation.headers, params2, false);
+    }
+    const explicitQueries = Reflect.getMetadata(OPENAPI_META.QUERIES, ctor, propKey) ?? [];
+    for (const q of explicitQueries) {
+      const idx = params2.findIndex((p) => p.in === "query" && p.name === q.name);
+      const param = {
+        name: q.name,
+        in: "query",
+        required: q.required ?? false,
+        description: q.description,
+        schema: q.schema ? this.toSchema(q.schema) : { type: "string" }
+      };
+      if (idx >= 0)
+        params2[idx] = param;
+      else
+        params2.push(param);
+    }
+    const explicitParams = Reflect.getMetadata(OPENAPI_META.PARAMS, ctor, propKey) ?? [];
+    for (const p of explicitParams) {
+      const idx = params2.findIndex((x) => x.in === "path" && x.name === p.name);
+      const param = {
+        name: p.name,
+        in: "path",
+        required: p.required ?? true,
+        description: p.description,
+        schema: p.schema ? this.toSchema(p.schema) : { type: "string" }
+      };
+      if (idx >= 0)
+        params2[idx] = param;
+      else
+        params2.push(param);
+    }
+    let requestBody;
+    const bodyMeta = Reflect.getMetadata(OPENAPI_META.BODY, ctor, propKey);
+    if (bodyMeta?.schema || route.validation?.body) {
+      const schema = bodyMeta?.schema ?? route.validation?.body;
+      const mediaType = { schema: this.toSchema(schema) };
+      if (bodyMeta?.example !== undefined)
+        mediaType.example = bodyMeta.example;
+      requestBody = {
+        description: bodyMeta?.description ?? "Request body",
+        content: { "application/json": mediaType },
+        required: bodyMeta?.required ?? true
+      };
+    }
+    const responses = {};
+    const responseMetas = Reflect.getMetadata(OPENAPI_META.RESPONSES, ctor, propKey) ?? [];
+    for (const [status, opt] of responseMetas) {
+      const r = { description: opt.description };
+      if (opt.schema) {
+        r.content = {
+          "application/json": {
+            schema: this.toSchema(opt.schema),
+            ...opt.example !== undefined ? { example: opt.example } : {}
+          }
+        };
+      }
+      responses[status] = r;
+    }
+    if (Object.keys(responses).length === 0) {
+      responses["200"] = { description: "Successful response" };
+    }
+    const op = {
+      responses
+    };
+    if (tags.length > 0)
+      op.tags = tags;
+    if (opMeta?.summary)
+      op.summary = opMeta.summary;
+    if (opMeta?.description)
+      op.description = opMeta.description;
+    if (opMeta?.operationId)
+      op.operationId = opMeta.operationId;
+    if (opMeta?.deprecated)
+      op.deprecated = true;
+    if (params2.length > 0)
+      op.parameters = params2;
+    if (requestBody)
+      op.requestBody = requestBody;
+    return op;
+  }
+  toSchema(input) {
+    if (input == null)
+      return {};
+    if (typeof input === "object" && !isZodLike(input)) {
+      return input;
+    }
+    try {
+      return zodToJsonSchema(input);
+    } catch {
+      return {};
+    }
+  }
+  appendZodParams(ctor, propKey, where, schema, params2, required) {
+    const json = this.toSchema(schema);
+    if (json.type === "object" && json.properties) {
+      const req = new Set(json.required ?? []);
+      for (const [name, sub] of Object.entries(json.properties)) {
+        params2.push({
+          name,
+          in: where,
+          required: required || req.has(name),
+          schema: sub
+        });
+      }
+    }
+  }
+  extractPathParams(path) {
+    const out = [];
+    const re = /:([A-Za-z0-9_]+)/g;
+    let m;
+    while ((m = re.exec(path)) !== null)
+      out.push(m[1]);
+    return out;
+  }
+  normalizePath(path) {
+    return path.replace(/:([A-Za-z0-9_]+)/g, "{$1}");
+  }
+}
+OpenAPIService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject("OPENAPI_CONFIG")),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof OpenAPIConfig === "undefined" ? Object : OpenAPIConfig
+  ])
+], OpenAPIService);
+function isZodLike(s) {
+  if (typeof s !== "object" || s === null)
+    return false;
+  const o = s;
+  const t = o._def?.typeName ?? o.typeName;
+  return typeof t === "string" && t.startsWith("Zod");
+}
+// src/openapi/openapi.module.ts
+import"reflect-metadata";
+class OpenAPIModule {
+  static forRoot(config) {
+    class ConfiguredOpenAPIModule {
+    }
+    ConfiguredOpenAPIModule = __legacyDecorateClassTS([
+      Module({
+        providers: [
+          OpenAPIService,
+          { provide: OpenAPIService.TOKEN, useExisting: OpenAPIService },
+          { provide: "OPENAPI_CONFIG", useValue: config }
+        ],
+        exports: [OpenAPIService, OpenAPIService.TOKEN]
+      })
+    ], ConfiguredOpenAPIModule);
+    Object.defineProperty(ConfiguredOpenAPIModule, "name", {
+      value: "ConfiguredOpenAPIModule"
+    });
+    return ConfiguredOpenAPIModule;
+  }
+  static mount(app, svc, config) {
+    const specPath = config.specPath ?? "/openapi.json";
+    const docsPath = config.path ?? "/docs";
+    app.get(specPath, (c) => c.json(svc.getSpec(), 200, { "Content-Type": "application/json" }));
+    app.get(docsPath, (c) => {
+      const { scalarHtml: scalarHtml2 } = __toCommonJS(exports_scalar);
+      const html = scalarHtml2({
+        title: config.info.title,
+        specUrl: specPath
+      });
+      return c.html(html, 200, { "Content-Type": "text/html; charset=utf-8" });
+    });
+  }
+}
+OpenAPIModule = __legacyDecorateClassTS([
+  Module({
+    providers: [
+      OpenAPIService,
+      { provide: OpenAPIService.TOKEN, useExisting: OpenAPIService }
+    ],
+    exports: [OpenAPIService, OpenAPIService.TOKEN]
+  })
+], OpenAPIModule);
+// src/openapi/decorators/tags.ts
+function ApiTags(...tags) {
+  return (target) => {
+    const existing = Reflect.getMetadata(OPENAPI_META.TAGS, target) ?? [];
+    Reflect.defineMetadata(OPENAPI_META.TAGS, [...existing, ...tags], target);
+  };
+}
+// src/openapi/decorators/operation.ts
+import"reflect-metadata";
+function ApiOperation(options) {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(OPENAPI_META.OPERATION, options, target.constructor, propertyKey);
+  };
+}
+// src/openapi/decorators/response.ts
+import"reflect-metadata";
+function ApiResponse(status, options) {
+  return (target, propertyKey) => {
+    const existing = Reflect.getMetadata(OPENAPI_META.RESPONSES, target.constructor, propertyKey) ?? [];
+    existing.push([String(status), options]);
+    Reflect.defineMetadata(OPENAPI_META.RESPONSES, existing, target.constructor, propertyKey);
+  };
+}
+// src/openapi/decorators/param.ts
+import"reflect-metadata";
+function ApiParam(options) {
+  return (target, propertyKey) => {
+    const existing = Reflect.getMetadata(OPENAPI_META.PARAMS, target.constructor, propertyKey) ?? [];
+    existing.push(options);
+    Reflect.defineMetadata(OPENAPI_META.PARAMS, existing, target.constructor, propertyKey);
+  };
+}
+function ApiQuery(options) {
+  return (target, propertyKey) => {
+    const existing = Reflect.getMetadata(OPENAPI_META.QUERIES, target.constructor, propertyKey) ?? [];
+    existing.push(options);
+    Reflect.defineMetadata(OPENAPI_META.QUERIES, existing, target.constructor, propertyKey);
+  };
+}
+// src/openapi/decorators/body.ts
+import"reflect-metadata";
+function ApiBody(options) {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(OPENAPI_META.BODY, options, target.constructor, propertyKey);
+  };
+}
+// src/openapi/decorators/property.ts
+import"reflect-metadata";
+function ApiProperty(options = {}) {
+  return (target, propertyKey) => {
+    const existing = Reflect.getMetadata(OPENAPI_META.PROPERTIES, target.constructor) ?? {};
+    existing[propertyKey] = options;
+    Reflect.defineMetadata(OPENAPI_META.PROPERTIES, existing, target.constructor);
+  };
+}
+function ApiSchema(name) {
+  return (target) => {
+    Reflect.defineMetadata("nexus:openapi:schemaName", name, target);
+  };
+}
+// src/openapi/decorators/security.ts
+import"reflect-metadata";
+function ApiSecurity(name, scopes = []) {
+  return (target, _propertyKey, _descriptor) => {
+    const key = OPENAPI_META.SECURITY;
+    const existing = typeof _propertyKey === "string" || typeof _propertyKey === "symbol" ? Reflect.getMetadata(key, target.constructor, _propertyKey) ?? [] : Reflect.getMetadata(key, target) ?? [];
+    existing.push({ [name]: scopes });
+    if (typeof _propertyKey === "string" || typeof _propertyKey === "symbol") {
+      Reflect.defineMetadata(key, existing, target.constructor, _propertyKey);
+    } else {
+      Reflect.defineMetadata(key, existing, target);
+    }
+  };
+}
+function ApiExclude() {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(OPENAPI_META.EXCLUDE, true, target.constructor, propertyKey);
+  };
+}
+export {
+  zodToJsonSchema,
+  scalarHtml,
+  OpenAPIService,
+  OpenAPIModule,
+  OPENAPI_META,
+  ApiTags,
+  ApiSecurity,
+  ApiSchema,
+  ApiResponse,
+  ApiQuery,
+  ApiProperty,
+  ApiParam,
+  ApiOperation,
+  ApiExclude,
+  ApiBody
+};
+
+//# debugId=A00AA811A516A55C64756E2164756E21
+//# sourceMappingURL=index.js.map