@cerios/openapi-to-zod 0.6.0 → 1.1.0

package/dist/internal.js

@@ -0,0 +1,592 @@
+"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/internal.ts
+var internal_exports = {};
+__export(internal_exports, {
+  LRUCache: () => LRUCache,
+  OperationFiltersSchema: () => OperationFiltersSchema,
+  RequestResponseOptionsSchema: () => RequestResponseOptionsSchema,
+  createFilterStatistics: () => createFilterStatistics,
+  createTypeScriptLoader: () => createTypeScriptLoader,
+  escapeJSDoc: () => escapeJSDoc,
+  executeBatch: () => executeBatch,
+  formatConfigValidationError: () => formatConfigValidationError,
+  formatFilterStatistics: () => formatFilterStatistics,
+  getBatchExitCode: () => getBatchExitCode,
+  shouldIncludeOperation: () => shouldIncludeOperation,
+  stripPathPrefix: () => stripPathPrefix,
+  stripPrefix: () => stripPrefix,
+  toCamelCase: () => toCamelCase,
+  toPascalCase: () => toPascalCase,
+  validateFilters: () => validateFilters
+});
+module.exports = __toCommonJS(internal_exports);
+
+// src/errors.ts
+var GeneratorError = class extends Error {
+  constructor(message, code, context) {
+    var _a;
+    super(message);
+    this.code = code;
+    this.context = context;
+    this.name = "GeneratorError";
+    (_a = Error.captureStackTrace) == null ? void 0 : _a.call(Error, this, this.constructor);
+  }
+};
+var ConfigurationError = class extends GeneratorError {
+  constructor(message, context) {
+    super(message, "CONFIGURATION_ERROR", context);
+    this.name = "ConfigurationError";
+  }
+};
+
+// src/batch-executor.ts
+async function processSpec(spec, index, total, createGenerator) {
+  const specInput = spec.input || "spec";
+  const specOutput = spec.output || "output";
+  console.log(`Processing [${index + 1}/${total}] ${specInput}...`);
+  try {
+    const generator = createGenerator(spec);
+    generator.generate();
+    return {
+      spec,
+      success: true
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`\u2717 Failed to generate ${specOutput}: ${errorMessage}`);
+    return {
+      spec,
+      success: false,
+      error: errorMessage
+    };
+  }
+}
+async function executeParallel(specs, createGenerator, batchSize) {
+  console.log(`
+Executing ${specs.length} specification(s) in parallel (batch size: ${batchSize})...
+`);
+  const results = [];
+  for (let i = 0; i < specs.length; i += batchSize) {
+    const batch = specs.slice(i, Math.min(i + batchSize, specs.length));
+    const batchPromises = batch.map(
+      (spec, batchIndex) => processSpec(spec, i + batchIndex, specs.length, createGenerator)
+    );
+    const batchResults = await Promise.allSettled(batchPromises);
+    for (let j = 0; j < batchResults.length; j++) {
+      const result = batchResults[j];
+      if (result.status === "fulfilled") {
+        results.push(result.value);
+      } else {
+        results.push({
+          spec: batch[j],
+          success: false,
+          error: result.reason instanceof Error ? result.reason.message : String(result.reason)
+        });
+      }
+    }
+  }
+  return results;
+}
+async function executeSequential(specs, createGenerator) {
+  console.log(`
+Executing ${specs.length} spec(s) sequentially...
+`);
+  const results = [];
+  for (let i = 0; i < specs.length; i++) {
+    const result = await processSpec(specs[i], i, specs.length, createGenerator);
+    results.push(result);
+  }
+  return results;
+}
+function printSummary(summary) {
+  console.log(`
+${"=".repeat(50)}`);
+  console.log("Batch Execution Summary");
+  console.log("=".repeat(50));
+  console.log(`Total specs: ${summary.total}`);
+  console.log(`Successful: ${summary.successful}`);
+  console.log(`Failed: ${summary.failed}`);
+  if (summary.failed > 0) {
+    console.log("\nFailed specs:");
+    for (const result of summary.results) {
+      if (!result.success) {
+        const specInput = result.spec.input || "spec";
+        console.error(`  \u2717 ${specInput}`);
+        console.error(`    Error: ${result.error}`);
+      }
+    }
+  }
+  console.log(`${"=".repeat(50)}
+`);
+}
+async function executeBatch(specs, executionMode = "parallel", createGenerator, batchSize) {
+  if (specs.length === 0) {
+    throw new ConfigurationError("No specs provided for batch execution", { specsCount: 0, executionMode });
+  }
+  let results = [];
+  try {
+    results = executionMode === "parallel" ? await executeParallel(specs, createGenerator, batchSize) : await executeSequential(specs, createGenerator);
+    const summary = {
+      total: results.length,
+      successful: results.filter((r) => r.success).length,
+      failed: results.filter((r) => !r.success).length,
+      results
+    };
+    printSummary(summary);
+    return summary;
+  } finally {
+    if (results.length > batchSize) {
+      for (const result of results) {
+        if (result.spec) {
+          result.spec = null;
+        }
+      }
+      if (global.gc) {
+        global.gc();
+      }
+    }
+  }
+}
+function getBatchExitCode(summary) {
+  return summary.failed > 0 ? 1 : 0;
+}
+
+// src/utils/config-schemas.ts
+var import_zod = require("zod");
+var RequestResponseOptionsSchema = import_zod.z.strictObject({
+  mode: import_zod.z.enum(["strict", "normal", "loose"]).optional(),
+  useDescribe: import_zod.z.boolean().optional(),
+  includeDescriptions: import_zod.z.boolean().optional()
+});
+var OperationFiltersSchema = import_zod.z.strictObject({
+  includeTags: import_zod.z.array(import_zod.z.string()).optional(),
+  excludeTags: import_zod.z.array(import_zod.z.string()).optional(),
+  includePaths: import_zod.z.array(import_zod.z.string()).optional(),
+  excludePaths: import_zod.z.array(import_zod.z.string()).optional(),
+  includeMethods: import_zod.z.array(import_zod.z.string()).optional(),
+  excludeMethods: import_zod.z.array(import_zod.z.string()).optional(),
+  includeOperationIds: import_zod.z.array(import_zod.z.string()).optional(),
+  excludeOperationIds: import_zod.z.array(import_zod.z.string()).optional(),
+  excludeDeprecated: import_zod.z.boolean().optional()
+});
+
+// src/utils/config-validation.ts
+function formatConfigValidationError(error, filepath, configPath, additionalNotes) {
+  var _a;
+  const formattedErrors = ((_a = error.issues) == null ? void 0 : _a.map((err) => {
+    const path = err.path.length > 0 ? err.path.join(".") : "root";
+    return `  - ${path}: ${err.message}`;
+  }).join("\n")) || "Unknown validation error";
+  const configSource = filepath || configPath || "config file";
+  const lines = [
+    `Invalid configuration file at: ${configSource}`,
+    "",
+    "Validation errors:",
+    formattedErrors,
+    "",
+    "Please check your configuration file and ensure:",
+    "  - All required fields are present (specs array with input/output)",
+    "  - Field names are spelled correctly (no typos)",
+    "  - Values match the expected types (e.g., mode: 'strict' | 'normal' | 'loose')",
+    "  - No unknown/extra properties are included"
+  ];
+  if (additionalNotes && additionalNotes.length > 0) {
+    lines.push(...additionalNotes.map((note) => `  - ${note}`));
+  }
+  return lines.join("\n");
+}
+
+// src/utils/lru-cache.ts
+var LRUCache = class {
+  constructor(maxSize) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+  }
+  get capacity() {
+    return this.maxSize;
+  }
+  get(key) {
+    if (!this.cache.has(key)) return void 0;
+    const value = this.cache.get(key);
+    if (value === void 0) return void 0;
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  size() {
+    return this.cache.size;
+  }
+};
+
+// src/utils/name-utils.ts
+function sanitizeIdentifier(str) {
+  return str.replace(/[^a-zA-Z0-9._\-\s]+/g, "_");
+}
+function toCamelCase(str, options) {
+  const sanitized = sanitizeIdentifier(str);
+  const words = sanitized.split(/[.\-_\s]+/).filter((word) => word.length > 0);
+  let name;
+  if (words.length === 0) {
+    name = str.charAt(0).toLowerCase() + str.slice(1);
+  } else if (words.length === 1) {
+    name = words[0].charAt(0).toLowerCase() + words[0].slice(1);
+  } else {
+    name = words[0].charAt(0).toLowerCase() + words[0].slice(1) + words.slice(1).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  }
+  if (options == null ? void 0 : options.prefix) {
+    const prefix = options.prefix.toLowerCase();
+    name = prefix + name.charAt(0).toUpperCase() + name.slice(1);
+  }
+  if (options == null ? void 0 : options.suffix) {
+    const suffix = options.suffix;
+    name = name + suffix.charAt(0).toUpperCase() + suffix.slice(1).toLowerCase();
+  }
+  return name;
+}
+function toPascalCase(str) {
+  const stringValue = String(str);
+  const isAlreadyValidCase = /^[a-zA-Z][a-zA-Z0-9]*$/.test(stringValue);
+  if (isAlreadyValidCase) {
+    return stringValue.charAt(0).toUpperCase() + stringValue.slice(1);
+  }
+  const sanitized = sanitizeIdentifier(stringValue);
+  const words = sanitized.split(/[.\-_\s]+/).filter((word) => word.length > 0);
+  let result;
+  if (words.length === 0) {
+    result = "Value";
+  } else {
+    result = words.map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  }
+  if (/^\d/.test(result)) {
+    result = `N${result}`;
+  }
+  if (!result || /^_+$/.test(result)) {
+    return "Value";
+  }
+  return result;
+}
+
+// src/utils/operation-filters.ts
+var import_minimatch = require("minimatch");
+function createFilterStatistics() {
+  return {
+    totalOperations: 0,
+    includedOperations: 0,
+    filteredByTags: 0,
+    filteredByPaths: 0,
+    filteredByMethods: 0,
+    filteredByOperationIds: 0,
+    filteredByDeprecated: 0
+  };
+}
+function matchesAnyPattern(value, patterns) {
+  if (!patterns || patterns.length === 0) {
+    return false;
+  }
+  if (!value) {
+    return false;
+  }
+  return patterns.some((pattern) => (0, import_minimatch.minimatch)(value, pattern));
+}
+function containsAny(arr, values) {
+  if (!values || values.length === 0) {
+    return false;
+  }
+  if (!arr || arr.length === 0) {
+    return false;
+  }
+  return values.some((value) => arr.includes(value));
+}
+function shouldIncludeOperation(operation, path, method, filters, stats) {
+  if (!filters) {
+    return true;
+  }
+  const methodLower = method.toLowerCase();
+  const operationId = operation == null ? void 0 : operation.operationId;
+  const tags = (operation == null ? void 0 : operation.tags) || [];
+  const deprecated = (operation == null ? void 0 : operation.deprecated) === true;
+  if (filters.includeTags && filters.includeTags.length > 0) {
+    if (!containsAny(tags, filters.includeTags)) {
+      if (stats) stats.filteredByTags++;
+      return false;
+    }
+  }
+  if (filters.includePaths && filters.includePaths.length > 0) {
+    if (!matchesAnyPattern(path, filters.includePaths)) {
+      if (stats) stats.filteredByPaths++;
+      return false;
+    }
+  }
+  if (filters.includeMethods && filters.includeMethods.length > 0) {
+    const methodsLower = filters.includeMethods.map((m) => m.toLowerCase());
+    if (!methodsLower.includes(methodLower)) {
+      if (stats) stats.filteredByMethods++;
+      return false;
+    }
+  }
+  if (filters.includeOperationIds && filters.includeOperationIds.length > 0) {
+    if (!matchesAnyPattern(operationId, filters.includeOperationIds)) {
+      if (stats) stats.filteredByOperationIds++;
+      return false;
+    }
+  }
+  if (filters.excludeDeprecated === true && deprecated) {
+    if (stats) stats.filteredByDeprecated++;
+    return false;
+  }
+  if (filters.excludeTags && filters.excludeTags.length > 0) {
+    if (containsAny(tags, filters.excludeTags)) {
+      if (stats) stats.filteredByTags++;
+      return false;
+    }
+  }
+  if (filters.excludePaths && filters.excludePaths.length > 0) {
+    if (matchesAnyPattern(path, filters.excludePaths)) {
+      if (stats) stats.filteredByPaths++;
+      return false;
+    }
+  }
+  if (filters.excludeMethods && filters.excludeMethods.length > 0) {
+    const methodsLower = filters.excludeMethods.map((m) => m.toLowerCase());
+    if (methodsLower.includes(methodLower)) {
+      if (stats) stats.filteredByMethods++;
+      return false;
+    }
+  }
+  if (filters.excludeOperationIds && filters.excludeOperationIds.length > 0) {
+    if (matchesAnyPattern(operationId, filters.excludeOperationIds)) {
+      if (stats) stats.filteredByOperationIds++;
+      return false;
+    }
+  }
+  return true;
+}
+function validateFilters(stats, filters) {
+  if (!filters || stats.totalOperations === 0) {
+    return;
+  }
+  if (stats.includedOperations === 0) {
+    console.warn(
+      `\u26A0\uFE0F  Warning: All ${stats.totalOperations} operations were filtered out. Check your operationFilters configuration.`
+    );
+    const filterBreakdown = [];
+    if (stats.filteredByTags > 0) filterBreakdown.push(`${stats.filteredByTags} by tags`);
+    if (stats.filteredByPaths > 0) filterBreakdown.push(`${stats.filteredByPaths} by paths`);
+    if (stats.filteredByMethods > 0) filterBreakdown.push(`${stats.filteredByMethods} by methods`);
+    if (stats.filteredByOperationIds > 0) filterBreakdown.push(`${stats.filteredByOperationIds} by operationIds`);
+    if (stats.filteredByDeprecated > 0) filterBreakdown.push(`${stats.filteredByDeprecated} by deprecated flag`);
+    if (filterBreakdown.length > 0) {
+      console.warn(`   Filtered: ${filterBreakdown.join(", ")}`);
+    }
+  }
+}
+function formatFilterStatistics(stats) {
+  if (stats.totalOperations === 0) {
+    return "";
+  }
+  const lines = [];
+  lines.push("Operation Filtering:");
+  lines.push(`  Total operations: ${stats.totalOperations}`);
+  lines.push(`  Included operations: ${stats.includedOperations}`);
+  const filteredCount = stats.filteredByTags + stats.filteredByPaths + stats.filteredByMethods + stats.filteredByOperationIds + stats.filteredByDeprecated;
+  if (filteredCount > 0) {
+    lines.push(`  Filtered operations: ${filteredCount}`);
+    if (stats.filteredByTags > 0) lines.push(`    - By tags: ${stats.filteredByTags}`);
+    if (stats.filteredByPaths > 0) lines.push(`    - By paths: ${stats.filteredByPaths}`);
+    if (stats.filteredByMethods > 0) lines.push(`    - By methods: ${stats.filteredByMethods}`);
+    if (stats.filteredByOperationIds > 0) lines.push(`    - By operationIds: ${stats.filteredByOperationIds}`);
+    if (stats.filteredByDeprecated > 0) lines.push(`    - By deprecated: ${stats.filteredByDeprecated}`);
+  }
+  return lines.join("\n");
+}
+
+// src/utils/pattern-utils.ts
+function isRegexPattern(pattern) {
+  if (pattern.startsWith("^") || pattern.endsWith("$")) {
+    return true;
+  }
+  if (/\\[dDwWsS]/.test(pattern)) {
+    return true;
+  }
+  if (/\.\*|\.\+/.test(pattern)) {
+    return true;
+  }
+  if (/[[\]()]/.test(pattern)) {
+    return true;
+  }
+  if (/[^/][+?*]\{/.test(pattern)) {
+    return true;
+  }
+  return false;
+}
+function patternToRegex(pattern) {
+  if (pattern instanceof RegExp) {
+    return pattern;
+  }
+  if (isRegexPattern(pattern)) {
+    try {
+      return new RegExp(pattern);
+    } catch (error) {
+      console.warn(`\u26A0\uFE0F  Invalid regex pattern "${pattern}": ${error instanceof Error ? error.message : String(error)}`);
+      return null;
+    }
+  }
+  return null;
+}
+function stripPrefix(input, pattern, ensureLeadingChar) {
+  if (!pattern) {
+    return input;
+  }
+  const regex = patternToRegex(pattern);
+  if (regex) {
+    const match = input.match(regex);
+    if (match && match.index === 0) {
+      const stripped = input.substring(match[0].length);
+      if (ensureLeadingChar) {
+        if (stripped === "") {
+          return ensureLeadingChar;
+        }
+        if (!stripped.startsWith(ensureLeadingChar)) {
+          return `${ensureLeadingChar}${stripped}`;
+        }
+      }
+      return stripped;
+    }
+  } else {
+    const stringPattern = pattern;
+    if (input.startsWith(stringPattern)) {
+      const stripped = input.substring(stringPattern.length);
+      if (ensureLeadingChar) {
+        if (stripped === "") {
+          return ensureLeadingChar;
+        }
+        if (!stripped.startsWith(ensureLeadingChar)) {
+          return `${ensureLeadingChar}${stripped}`;
+        }
+      }
+      return stripped;
+    }
+  }
+  return input;
+}
+function stripPathPrefix(path, pattern) {
+  if (!pattern) {
+    return path;
+  }
+  const regex = patternToRegex(pattern);
+  if (!regex) {
+    let normalizedPattern = pattern.trim();
+    if (!normalizedPattern.startsWith("/")) {
+      normalizedPattern = `/${normalizedPattern}`;
+    }
+    if (normalizedPattern.endsWith("/") && normalizedPattern !== "/") {
+      normalizedPattern = normalizedPattern.slice(0, -1);
+    }
+    return stripPrefix(path, normalizedPattern, "/");
+  }
+  return stripPrefix(path, regex, "/");
+}
+
+// src/utils/string-utils.ts
+function escapeJSDoc(str) {
+  return str.replace(/\*\//g, "*\\/");
+}
+
+// src/utils/typescript-loader.ts
+function createTypeScriptLoader() {
+  return async (filepath) => {
+    try {
+      const esbuild = await import("esbuild");
+      const fs = await import("fs");
+      const path = await import("path");
+      const tsCode = fs.readFileSync(filepath, "utf-8");
+      const result = await esbuild.build({
+        stdin: {
+          contents: tsCode,
+          loader: "ts",
+          resolveDir: path.dirname(filepath),
+          sourcefile: filepath
+        },
+        format: "cjs",
+        platform: "node",
+        target: "node18",
+        bundle: false,
+        write: false
+      });
+      const jsCode = result.outputFiles[0].text;
+      const module2 = { exports: {} };
+      const func = new Function("exports", "module", "require", "__filename", "__dirname", jsCode);
+      func(module2.exports, module2, require, filepath, path.dirname(filepath));
+      return module2.exports.default || module2.exports;
+    } catch (error) {
+      throw new Error(
+        `Failed to load TypeScript config from ${filepath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LRUCache,
+  OperationFiltersSchema,
+  RequestResponseOptionsSchema,
+  createFilterStatistics,
+  createTypeScriptLoader,
+  escapeJSDoc,
+  executeBatch,
+  formatConfigValidationError,
+  formatFilterStatistics,
+  getBatchExitCode,
+  shouldIncludeOperation,
+  stripPathPrefix,
+  stripPrefix,
+  toCamelCase,
+  toPascalCase,
+  validateFilters
+});
+//# sourceMappingURL=internal.js.map