adorn-api 1.0.23 → 1.0.24

package/dist/index.js

@@ -1,638 +1,19 @@
-// 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
-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 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
-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
-  };
-}
-function clearArtifactCache(outDir) {
-  if (outDir) {
-    const cacheKey = path.resolve(outDir);
-    artifactCache.delete(cacheKey);
-  } else {
-    artifactCache.clear();
-  }
-}
-function getArtifactCacheStats() {
-  return {
-    size: artifactCache.size,
-    keys: Array.from(artifactCache.keys())
-  };
-}
-
-// src/utils/port.ts
-import { createServer } from "net";
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
-async function isPortAvailable(port, host = "0.0.0.0") {
-  return new Promise((resolve) => {
-    const server = 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;
-}
-export {
-  ADORN_META2 as 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,
-  PartType as PartType2,
-  Patch,
-  Pattern,
-  Post,
-  Produces,
-  Public,
-  Put,
-  Schema,
-  Union,
-  Use,
-  ValidationErrorResponse,
-  clearArtifactCache,
-  createValidator,
-  findProcessOnPort,
-  formatValidationErrors,
-  getArtifactCacheStats,
-  isPortAvailable,
-  killProcess,
-  loadArtifacts,
-  readAdornBucket,
-  waitForPort
-};
+// Decorators
+export * from "./decorators/index.js";
+// Core
+export { ExpressAdapter, HttpError, isHttpError, } from "./core/express-adapter.js";
+// Metadata
+export { metadataStorage } from "./metadata/metadata-storage.js";
+// Types
+export * from "./types/controller.js";
+export * from "./types/metadata.js";
+export * from "./types/openapi.js";
+export * from "./types/common.js";
+// OpenAPI
+export { OpenApiGenerator } from "./openapi/openapi-generator.js";
+export { setupSwaggerUi } from "./openapi/swagger-ui.js";
+// Integrations
+export * from "./metal-orm-integration/index.js";
+// Validation
+export { createZodValidationMiddleware, formatZodErrors, } from "./validation/zod-adapter.js";
 //# sourceMappingURL=index.js.map