@cerios/openapi-to-zod 1.1.0 → 1.1.1

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { O as OpenApiGeneratorOptions } from './types-B7ePTDjr.mjs';
-export { C as CommonSchemaOptions, a as ConfigFile, E as ExecutionMode, b as OpenAPISchema, c as OpenAPISpec, d as OperationFilters, R as RequestOptions, e as ResponseOptions, f as defineConfig } from './types-B7ePTDjr.mjs';
+import { O as OpenApiGeneratorOptions } from './types-CI48CjiU.mjs';
+export { C as CommonSchemaOptions, a as ConfigFile, E as ExecutionMode, b as OpenAPISchema, c as OpenAPISpec, d as OperationFilters, R as RequestOptions, e as ResponseOptions, f as defineConfig } from './types-CI48CjiU.mjs';
 
 /**
  * Custom error classes for better error handling and debugging

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { O as OpenApiGeneratorOptions } from './types-B7ePTDjr.js';
-export { C as CommonSchemaOptions, a as ConfigFile, E as ExecutionMode, b as OpenAPISchema, c as OpenAPISpec, d as OperationFilters, R as RequestOptions, e as ResponseOptions, f as defineConfig } from './types-B7ePTDjr.js';
+import { O as OpenApiGeneratorOptions } from './types-CI48CjiU.js';
+export { C as CommonSchemaOptions, a as ConfigFile, E as ExecutionMode, b as OpenAPISchema, c as OpenAPISpec, d as OperationFilters, R as RequestOptions, e as ResponseOptions, f as defineConfig } from './types-CI48CjiU.js';
 
 /**
  * Custom error classes for better error handling and debugging

package/dist/index.js

@@ -94,7 +94,7 @@ var ConfigurationError = class extends GeneratorError {
 // src/openapi-generator.ts
 var import_node_fs = require("fs");
 var import_node_path = require("path");
-var import_minimatch2 = require("minimatch");
+var import_minimatch3 = require("minimatch");
 var import_yaml = require("yaml");
 
 // src/utils/name-utils.ts
@@ -153,8 +153,26 @@ function resolveRef(ref) {
 function generateEnum(name, values, options) {
   const schemaName = `${toCamelCase(name, options)}Schema`;
   const typeName = toPascalCase(name);
-  const enumValues = values.map((v) => `"${v}"`).join(", ");
-  const schemaCode = `export const ${schemaName} = z.enum([${enumValues}]);`;
+  const allBooleans = values.every((v) => typeof v === "boolean");
+  if (allBooleans) {
+    const schemaCode2 = `export const ${schemaName} = z.boolean();`;
+    const typeCode2 = `export type ${typeName} = z.infer<typeof ${schemaName}>;`;
+    return { schemaCode: schemaCode2, typeCode: typeCode2 };
+  }
+  const allStrings = values.every((v) => typeof v === "string");
+  if (allStrings) {
+    const enumValues = values.map((v) => `"${v}"`).join(", ");
+    const schemaCode2 = `export const ${schemaName} = z.enum([${enumValues}]);`;
+    const typeCode2 = `export type ${typeName} = z.infer<typeof ${schemaName}>;`;
+    return { schemaCode: schemaCode2, typeCode: typeCode2 };
+  }
+  const literalValues = values.map((v) => {
+    if (typeof v === "string") {
+      return `z.literal("${v}")`;
+    }
+    return `z.literal(${v})`;
+  }).join(", ");
+  const schemaCode = `export const ${schemaName} = z.union([${literalValues}]);`;
   const typeCode = `export type ${typeName} = z.infer<typeof ${schemaName}>;`;
   return { schemaCode, typeCode };
 }
@@ -164,7 +182,7 @@ function escapeDescription(str) {
   return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
 }
 function escapePattern(str) {
-  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  return str.replace(/\//g, "\\/");
 }
 function escapeJSDoc(str) {
   return str.replace(/\*\//g, "*\\/");
@@ -289,61 +307,36 @@ var LRUCache = class {
 };
 
 // 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)) {
+var import_minimatch = require("minimatch");
+function isValidGlobPattern(pattern) {
+  try {
+    new import_minimatch.minimatch.Minimatch(pattern);
     return true;
+  } catch {
+    return false;
   }
-  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 isGlobPattern(pattern) {
+  return /[*?[\]{}!]/.test(pattern);
 }
 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}`;
-        }
+  if (isGlobPattern(pattern) && !isValidGlobPattern(pattern)) {
+    console.warn(`\u26A0\uFE0F  Invalid glob pattern "${pattern}": Pattern is malformed`);
+    return input;
+  }
+  if (isGlobPattern(pattern)) {
+    let longestMatch = -1;
+    for (let i = 1; i <= input.length; i++) {
+      const testPrefix = input.substring(0, i);
+      if ((0, import_minimatch.minimatch)(testPrefix, pattern)) {
+        longestMatch = i;
       }
-      return stripped;
     }
-  } else {
-    const stringPattern = pattern;
-    if (input.startsWith(stringPattern)) {
-      const stripped = input.substring(stringPattern.length);
+    if (longestMatch > 0) {
+      const stripped = input.substring(longestMatch);
       if (ensureLeadingChar) {
         if (stripped === "") {
           return ensureLeadingChar;
@@ -352,8 +345,21 @@ function stripPrefix(input, pattern, ensureLeadingChar) {
           return `${ensureLeadingChar}${stripped}`;
         }
       }
-      return stripped;
+      return stripped === "" && !ensureLeadingChar ? input : stripped;
+    }
+    return input;
+  }
+  if (input.startsWith(pattern)) {
+    const stripped = input.substring(pattern.length);
+    if (ensureLeadingChar) {
+      if (stripped === "") {
+        return ensureLeadingChar;
+      }
+      if (!stripped.startsWith(ensureLeadingChar)) {
+        return `${ensureLeadingChar}${stripped}`;
+      }
     }
+    return stripped;
   }
   return input;
 }
@@ -1228,9 +1234,25 @@ var _PropertyGenerator = class _PropertyGenerator {
       return wrapNullable(zodLiteral, nullable);
     }
     if (schema.enum) {
-      const enumValues = schema.enum.map((v) => `"${v}"`).join(", ");
-      const zodEnum = `z.enum([${enumValues}])`;
-      return wrapNullable(zodEnum, nullable);
+      const allBooleans = schema.enum.every((v) => typeof v === "boolean");
+      if (allBooleans) {
+        const zodBoolean = "z.boolean()";
+        return wrapNullable(zodBoolean, nullable);
+      }
+      const allStrings = schema.enum.every((v) => typeof v === "string");
+      if (allStrings) {
+        const enumValues = schema.enum.map((v) => `"${v}"`).join(", ");
+        const zodEnum = `z.enum([${enumValues}])`;
+        return wrapNullable(zodEnum, nullable);
+      }
+      const literalValues = schema.enum.map((v) => {
+        if (typeof v === "string") {
+          return `z.literal("${v}")`;
+        }
+        return `z.literal(${v})`;
+      }).join(", ");
+      const zodUnion = `z.union([${literalValues}])`;
+      return wrapNullable(zodUnion, nullable);
     }
     if (schema.allOf) {
       let composition = generateAllOf(
@@ -1361,7 +1383,7 @@ _PropertyGenerator.INCLUSION_RULES = {
 var PropertyGenerator = _PropertyGenerator;
 
 // src/utils/operation-filters.ts
-var import_minimatch = require("minimatch");
+var import_minimatch2 = require("minimatch");
 function createFilterStatistics() {
   return {
     totalOperations: 0,
@@ -1380,7 +1402,7 @@ function matchesAnyPattern(value, patterns) {
   if (!value) {
     return false;
   }
-  return patterns.some((pattern) => (0, import_minimatch.minimatch)(value, pattern));
+  return patterns.some((pattern) => (0, import_minimatch2.minimatch)(value, pattern));
 }
 function containsAny(arr, values) {
   if (!values || values.length === 0) {
@@ -1607,6 +1629,9 @@ var OpenApiGenerator = class {
       throw new SpecValidationError("No schemas found in OpenAPI spec", { filePath: this.options.input });
     }
     for (const [name, schema] of Object.entries(this.spec.components.schemas)) {
+      if (this.options.operationFilters && this.schemaUsageMap.size > 0 && !this.schemaUsageMap.has(name)) {
+        continue;
+      }
       this.generateComponentSchema(name, schema);
     }
     this.generateQueryParameterSchemas();
@@ -2095,7 +2120,7 @@ ${propsCode}
     const headerLower = headerName.toLowerCase();
     return ignorePatterns.some((pattern) => {
       const patternLower = pattern.toLowerCase();
-      return (0, import_minimatch2.minimatch)(headerLower, patternLower);
+      return (0, import_minimatch3.minimatch)(headerLower, patternLower);
     });
   }
   /**
@@ -2183,8 +2208,22 @@ ${propsCode}
       return `${schemaName}Schema`;
     }
     if (schema.enum) {
-      const enumValues = schema.enum.map((v) => typeof v === "string" ? `"${v}"` : v).join(", ");
-      return `z.enum([${enumValues}])`;
+      const allBooleans = schema.enum.every((v) => typeof v === "boolean");
+      if (allBooleans) {
+        return "z.boolean()";
+      }
+      const allStrings = schema.enum.every((v) => typeof v === "string");
+      if (allStrings) {
+        const enumValues = schema.enum.map((v) => `"${v}"`).join(", ");
+        return `z.enum([${enumValues}])`;
+      }
+      const literalValues = schema.enum.map((v) => {
+        if (typeof v === "string") {
+          return `z.literal("${v}")`;
+        }
+        return `z.literal(${v})`;
+      }).join(", ");
+      return `z.union([${literalValues}])`;
     }
     const type = schema.type;
     if (type === "string") {