adorn-api 1.0.23 → 1.0.24

package/dist/index.cjs

@@ -1,724 +0,0 @@
-"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/index.ts
-var index_exports = {};
-__export(index_exports, {
-  ADORN_META: () => ADORN_META2,
-  AdditionalProperties: () => AdditionalProperties,
-  Auth: () => Auth,
-  Closed: () => Closed,
-  ClosedUnevaluated: () => ClosedUnevaluated,
-  Const: () => Const,
-  Consumes: () => Consumes,
-  Controller: () => Controller,
-  Default: () => Default,
-  Delete: () => Delete,
-  Description: () => Description,
-  Enum: () => Enum,
-  Example: () => Example,
-  Examples: () => Examples,
-  ExclusiveMax: () => ExclusiveMax,
-  ExclusiveMin: () => ExclusiveMin,
-  File: () => File,
-  Format: () => Format,
-  Get: () => Get,
-  Max: () => Max,
-  MaxItems: () => MaxItems,
-  MaxLength: () => MaxLength,
-  MaxProperties: () => MaxProperties,
-  Min: () => Min,
-  MinItems: () => MinItems,
-  MinLength: () => MinLength,
-  MinProperties: () => MinProperties,
-  MultipleOf: () => MultipleOf,
-  PartType: () => PartType,
-  PartType2: () => PartType,
-  Patch: () => Patch,
-  Pattern: () => Pattern,
-  Post: () => Post,
-  Produces: () => Produces,
-  Public: () => Public,
-  Put: () => Put,
-  Schema: () => Schema,
-  Union: () => Union,
-  Use: () => Use,
-  ValidationErrorResponse: () => ValidationErrorResponse,
-  clearArtifactCache: () => clearArtifactCache,
-  createValidator: () => createValidator,
-  findProcessOnPort: () => findProcessOnPort,
-  formatValidationErrors: () => formatValidationErrors,
-  getArtifactCacheStats: () => getArtifactCacheStats,
-  isPortAvailable: () => isPortAvailable,
-  killProcess: () => killProcess,
-  loadArtifacts: () => loadArtifacts,
-  readAdornBucket: () => readAdornBucket,
-  waitForPort: () => waitForPort
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/runtime/polyfill.ts
-Symbol.metadata ??= /* @__PURE__ */ Symbol("Symbol.metadata");
-
-// src/runtime/metadata/key.ts
-var ADORN_META = /* @__PURE__ */ Symbol.for("adorn-api/meta");
-
-// src/runtime/metadata/bucket.ts
-function getBucket(metadata) {
-  if (!metadata) {
-    throw new Error("Decorator context.metadata is undefined. Ensure Symbol.metadata polyfill runs before decorators.");
-  }
-  let bucket = metadata[ADORN_META];
-  if (!bucket) {
-    bucket = { ops: [], controllerUse: [] };
-    metadata[ADORN_META] = bucket;
-  }
-  if (!bucket.controllerUse) {
-    bucket.controllerUse = [];
-  }
-  return bucket;
-}
-
-// src/decorators/Controller.ts
-function Controller(basePath) {
-  return function(target, context) {
-    const bucket = getBucket(context.metadata);
-    bucket.basePath = basePath;
-  };
-}
-
-// src/decorators/methods.ts
-function createMethodDecorator(httpMethod, path2) {
-  return function(target, context) {
-    if (context.private || context.static) {
-      return;
-    }
-    const methodName = String(context.name);
-    const bucket = getBucket(context.metadata);
-    let op = bucket.ops.find((op2) => op2.methodName === methodName);
-    if (!op) {
-      op = {
-        httpMethod,
-        path: path2,
-        methodName
-      };
-      bucket.ops.push(op);
-    } else {
-      op.httpMethod = httpMethod;
-      op.path = path2;
-    }
-  };
-}
-var Get = (path2) => createMethodDecorator("GET", path2);
-var Post = (path2) => createMethodDecorator("POST", path2);
-var Put = (path2) => createMethodDecorator("PUT", path2);
-var Patch = (path2) => createMethodDecorator("PATCH", path2);
-var Delete = (path2) => createMethodDecorator("DELETE", path2);
-
-// src/decorators/Use.ts
-function Use(...middleware) {
-  return function(target, context) {
-    if (context.kind === "class") {
-      const bucket = getBucket(context.metadata);
-      if (!bucket.controllerUse) {
-        bucket.controllerUse = [];
-      }
-      bucket.controllerUse.push(...middleware);
-    } else if (context.kind === "method") {
-      const methodName = String(context.name);
-      const bucket = getBucket(context.metadata);
-      let op = bucket.ops.find((op2) => op2.methodName === methodName);
-      if (!op) {
-        op = {
-          httpMethod: "GET",
-          path: "/",
-          methodName
-        };
-        bucket.ops.push(op);
-      }
-      if (!op.use) {
-        op.use = [];
-      }
-      op.use.push(...middleware);
-    } else {
-      throw new Error("@Use decorator can only be applied to classes or methods");
-    }
-  };
-}
-
-// src/decorators/Auth.ts
-function Auth(scheme, options) {
-  return function(target, context) {
-    if (context.kind !== "method") {
-      throw new Error("@Auth decorator can only be applied to methods");
-    }
-    const methodName = String(context.name);
-    const bucket = getBucket(context.metadata);
-    let op = bucket.ops.find((op2) => op2.methodName === methodName);
-    if (!op) {
-      op = {
-        httpMethod: "GET",
-        path: "/",
-        methodName
-      };
-      bucket.ops.push(op);
-    }
-    op.auth = {
-      scheme,
-      scopes: options?.scopes,
-      optional: options?.optional ?? false
-    };
-  };
-}
-
-// src/decorators/Public.ts
-function Public() {
-  return function(target, context) {
-    if (context.kind !== "method") {
-      throw new Error("@Public decorator can only be applied to methods");
-    }
-    const methodName = String(context.name);
-    const bucket = getBucket(context.metadata);
-    let op = bucket.ops.find((op2) => op2.methodName === methodName);
-    if (!op) {
-      op = {
-        httpMethod: "GET",
-        path: "/",
-        methodName
-      };
-      bucket.ops.push(op);
-    }
-    op.auth = "public";
-  };
-}
-
-// 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/schema/decorators.ts
-var ADORN_META2 = /* @__PURE__ */ Symbol.for("adorn-api.metadata");
-function getOrCreateMetadata(metadata) {
-  const meta = metadata[ADORN_META2] ??= {};
-  meta.schema ??= { props: {} };
-  return meta;
-}
-function pushSchemaFrag(target, propertyKey, metadata, frag) {
-  const meta = getOrCreateMetadata(metadata);
-  const props = meta.schema.props;
-  (props[propertyKey] ??= []).push(frag);
-}
-function Schema(frag) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, frag);
-  };
-}
-function Min(n) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { minimum: n });
-  };
-}
-function Max(n) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { maximum: n });
-  };
-}
-function ExclusiveMin(n) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { exclusiveMinimum: n });
-  };
-}
-function ExclusiveMax(n) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { exclusiveMaximum: n });
-  };
-}
-function MinLength(n) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { minLength: n });
-  };
-}
-function MaxLength(n) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { maxLength: n });
-  };
-}
-function Pattern(re) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { pattern: typeof re === "string" ? re : re.source });
-  };
-}
-function Format(fmt) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { format: fmt });
-  };
-}
-function MinItems(n) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { minItems: n });
-  };
-}
-function MaxItems(n) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { maxItems: n });
-  };
-}
-function MinProperties(n) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { minProperties: n });
-  };
-}
-function MaxProperties(n) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { maxProperties: n });
-  };
-}
-function MultipleOf(n) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { multipleOf: n });
-  };
-}
-function Example(value) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { example: value });
-  };
-}
-function Examples(values) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { examples: values });
-  };
-}
-function Description(desc) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { description: desc });
-  };
-}
-function Enum(vals) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { enum: vals });
-  };
-}
-function Const(val) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { const: val });
-  };
-}
-function Default(val) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { default: val });
-  };
-}
-function AdditionalProperties(value) {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { additionalProperties: value });
-  };
-}
-function Closed() {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { additionalProperties: false });
-  };
-}
-function ClosedUnevaluated() {
-  return function(target, propertyKey) {
-    pushSchemaFrag(target, propertyKey, {}, { unevaluatedProperties: false });
-  };
-}
-function Union(mode) {
-  return function(target) {
-    target[ADORN_META2] = target[ADORN_META2] ?? {};
-    const meta = target[ADORN_META2];
-    meta.schema = meta.schema ?? { props: {} };
-    meta.schema.unionMode = mode;
-  };
-}
-
-// 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 {
-  /**
-   * 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 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 path2 = error.path || "body";
-    if (!formatted[path2]) {
-      formatted[path2] = [];
-    }
-    formatted[path2].push(error.message);
-  }
-  return {
-    error: "Validation failed",
-    details: formatted
-  };
-}
-
-// src/http.ts
-var ADORN_META3 = /* @__PURE__ */ Symbol.for("adorn-api.metadata");
-function getMetadata(target) {
-  const host = target;
-  const metadata = host[ADORN_META3] ?? {};
-  host[ADORN_META3] = metadata;
-  return metadata;
-}
-function PartType(contentTypeOrOptions) {
-  return function(target, propertyKey) {
-    const metadata = getMetadata(target);
-    const options = typeof contentTypeOrOptions === "string" ? { contentType: contentTypeOrOptions } : contentTypeOrOptions;
-    metadata.fileParts ??= {};
-    metadata.fileParts[propertyKey.toString()] = options;
-  };
-}
-function File() {
-  return function(target, propertyKey) {
-    const metadata = getMetadata(target);
-    metadata.fileParts ??= {};
-    metadata.fileParts[propertyKey.toString()] = metadata.fileParts[propertyKey.toString()] ?? {};
-  };
-}
-function Consumes(...contentTypes) {
-  return function(target) {
-    const metadata = getMetadata(target.prototype);
-    metadata.consumes = contentTypes;
-  };
-}
-function Produces(...contentTypes) {
-  return function(target) {
-    const metadata = getMetadata(target.prototype);
-    metadata.produces = contentTypes;
-  };
-}
-
-// 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);
-  const 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
-  };
-}
-function clearArtifactCache(outDir) {
-  if (outDir) {
-    const cacheKey = import_node_path.default.resolve(outDir);
-    artifactCache.delete(cacheKey);
-  } else {
-    artifactCache.clear();
-  }
-}
-function getArtifactCacheStats() {
-  return {
-    size: artifactCache.size,
-    keys: Array.from(artifactCache.keys())
-  };
-}
-
-// src/utils/port.ts
-var import_net = require("net");
-var import_child_process = require("child_process");
-var import_util = require("util");
-var execAsync = (0, import_util.promisify)(import_child_process.exec);
-async function isPortAvailable(port, host = "0.0.0.0") {
-  return new Promise((resolve) => {
-    const server = (0, import_net.createServer)();
-    server.on("error", (err) => {
-      if (err.code === "EADDRINUSE") {
-        resolve(false);
-      } else {
-        resolve(false);
-      }
-    });
-    server.once("listening", () => {
-      server.close(() => {
-        resolve(true);
-      });
-    });
-    server.listen(port, host);
-  });
-}
-async function findProcessOnPort(port) {
-  try {
-    const platform = process.platform;
-    if (platform === "win32") {
-      const { stdout } = await execAsync(`netstat -ano | findstr :${port}`);
-      for (const line of stdout.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.includes("PID")) continue;
-        const parts = trimmed.split(/\s+/);
-        if (parts.length >= 5) {
-          const address = parts[1];
-          const pid = parseInt(parts[parts.length - 1], 10);
-          if (address.includes(`:${port}`) && !isNaN(pid)) {
-            const command = await getProcessNameOnWindows(pid);
-            return { pid, command };
-          }
-        }
-      }
-    } else {
-      const { stdout } = await execAsync(`lsof -ti:${port}`);
-      const pids = stdout.trim().split("\n").filter(Boolean).map(Number);
-      if (pids.length > 0) {
-        const pid = pids[0];
-        const command = await getProcessNameOnUnix(pid);
-        return { pid, command };
-      }
-    }
-    return null;
-  } catch (error) {
-    if (error.message.includes("matches found")) {
-      return null;
-    }
-    return null;
-  }
-}
-async function getProcessNameOnWindows(pid) {
-  try {
-    const { stdout } = await execAsync(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`);
-    const line = stdout.trim().split("\n")[0];
-    if (line) {
-      const parts = line.split('","');
-      if (parts.length >= 2) {
-        return parts[0].replace(/"/g, "");
-      }
-    }
-  } catch {
-    return void 0;
-  }
-}
-async function getProcessNameOnUnix(pid) {
-  try {
-    const { stdout } = await execAsync(`ps -p ${pid} -o comm=`);
-    return stdout.trim() || void 0;
-  } catch {
-    return void 0;
-  }
-}
-async function killProcess(pid) {
-  try {
-    process.kill(pid, "SIGTERM");
-    await new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error("Process did not terminate gracefully"));
-      }, 5e3);
-      const check = () => {
-        try {
-          process.kill(pid, 0);
-          setTimeout(check, 500);
-        } catch {
-          clearInterval(interval);
-          clearTimeout(timeout);
-          resolve();
-        }
-      };
-      const interval = setInterval(check, 500);
-    });
-    return true;
-  } catch {
-    try {
-      process.kill(pid, "SIGKILL");
-      await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-          reject(new Error("Process did not terminate"));
-        }, 3e3);
-        setTimeout(() => {
-          try {
-            process.kill(pid, 0);
-            clearTimeout(timeout);
-            reject(new Error("Process still running"));
-          } catch {
-            clearTimeout(timeout);
-            resolve();
-          }
-        }, 1e3);
-      });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-async function waitForPort(port, host = "0.0.0.0", timeout = 5e3) {
-  const start = Date.now();
-  while (Date.now() - start < timeout) {
-    if (await isPortAvailable(port, host)) {
-      return true;
-    }
-    await new Promise((resolve) => setTimeout(resolve, 200));
-  }
-  return false;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ADORN_META,
-  AdditionalProperties,
-  Auth,
-  Closed,
-  ClosedUnevaluated,
-  Const,
-  Consumes,
-  Controller,
-  Default,
-  Delete,
-  Description,
-  Enum,
-  Example,
-  Examples,
-  ExclusiveMax,
-  ExclusiveMin,
-  File,
-  Format,
-  Get,
-  Max,
-  MaxItems,
-  MaxLength,
-  MaxProperties,
-  Min,
-  MinItems,
-  MinLength,
-  MinProperties,
-  MultipleOf,
-  PartType,
-  PartType2,
-  Patch,
-  Pattern,
-  Post,
-  Produces,
-  Public,
-  Put,
-  Schema,
-  Union,
-  Use,
-  ValidationErrorResponse,
-  clearArtifactCache,
-  createValidator,
-  findProcessOnPort,
-  formatValidationErrors,
-  getArtifactCacheStats,
-  isPortAvailable,
-  killProcess,
-  loadArtifacts,
-  readAdornBucket,
-  waitForPort
-});
-//# sourceMappingURL=index.cjs.map