@cerios/openapi-to-zod 1.1.0 → 1.1.1

package/dist/cli.mjs

@@ -5197,8 +5197,26 @@ var init_name_utils = __esm({
 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 };
 }
@@ -5215,7 +5233,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, "*\\/");
@@ -5360,61 +5378,36 @@ var init_lru_cache = __esm({
 });
 
 // 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)) {
+import { minimatch } from "minimatch";
+function isValidGlobPattern(pattern) {
+  try {
+    new 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 (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;
@@ -5423,8 +5416,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;
 }
@@ -6363,9 +6369,25 @@ var init_property_generator = __esm({
           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(
@@ -6498,7 +6520,7 @@ var init_property_generator = __esm({
 });
 
 // src/utils/operation-filters.ts
-import { minimatch } from "minimatch";
+import { minimatch as minimatch2 } from "minimatch";
 function createFilterStatistics() {
   return {
     totalOperations: 0,
@@ -6517,7 +6539,7 @@ function matchesAnyPattern(value, patterns) {
   if (!value) {
     return false;
   }
-  return patterns.some((pattern) => minimatch(value, pattern));
+  return patterns.some((pattern) => minimatch2(value, pattern));
 }
 function containsAny(arr, values) {
   if (!values || values.length === 0) {
@@ -6640,7 +6662,7 @@ var init_operation_filters = __esm({
 // src/openapi-generator.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, normalize } from "path";
-import { minimatch as minimatch2 } from "minimatch";
+import { minimatch as minimatch3 } from "minimatch";
 import { parse } from "yaml";
 var OpenApiGenerator;
 var init_openapi_generator = __esm({
@@ -6767,6 +6789,9 @@ var init_openapi_generator = __esm({
           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();
@@ -7255,7 +7280,7 @@ ${propsCode}
         const headerLower = headerName.toLowerCase();
         return ignorePatterns.some((pattern) => {
           const patternLower = pattern.toLowerCase();
-          return minimatch2(headerLower, patternLower);
+          return minimatch3(headerLower, patternLower);
         });
       }
       /**
@@ -7343,8 +7368,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") {