@cerios/openapi-to-zod 1.1.0 → 1.1.1

package/README.md

@@ -187,7 +187,7 @@ Examples:
 | `schemaType` | `"all"` \| `"request"` \| `"response"` | Schema filtering |
 | `prefix` | `string` | Prefix for schema names |
 | `suffix` | `string` | Suffix for schema names |
-| `stripSchemaPrefix` | `string \| RegExp` | Strip prefix from schema names before generating (e.g., `"Company.Models."` or `/^[A-Z]+\./`) |
+| `stripSchemaPrefix` | `string` | Strip prefix from schema names before generating using glob patterns (e.g., `"Company.Models."` or `"*.Models."`) |
 | `showStats` | `boolean` | Include generation statistics |
 | `request` | `object` | Request-specific options (mode, includeDescriptions, useDescribe) |
 | `response` | `object` | Response-specific options (mode, includeDescriptions, useDescribe) |
@@ -571,10 +571,46 @@ OpenAPI's `nullable: true` is converted to `.nullable()`
 
 ### Enums
 
-Enums are generated as Zod enums with:
-- Proper string value handling
-- Zod schema using `z.enum()`
-- TypeScript type inference from the Zod schema
+Enums are generated based on their value types:
+
+- **String enums**: `z.enum()` for type-safe string unions
+- **Numeric enums**: `z.union([z.literal(n), ...])` for proper number types
+- **Boolean enums**: `z.boolean()` for true/false values
+- **Mixed enums**: `z.union([z.literal(...), ...])` for heterogeneous values
+
+**Examples:**
+
+```yaml
+# String enum
+Status:
+  type: string
+  enum: [active, inactive, pending]
+
+# Integer enum
+Priority:
+  type: integer
+  enum: [0, 1, 2, 3]
+
+# Mixed enum
+Value:
+  enum: [0, "none", 1, "some"]
+```
+
+**Generated schemas:**
+
+```typescript
+// String enum → z.enum()
+export const statusSchema = z.enum(["active", "inactive", "pending"]);
+export type Status = z.infer<typeof statusSchema>; // "active" | "inactive" | "pending"
+
+// Integer enum → z.union with z.literal
+export const prioritySchema = z.union([z.literal(0), z.literal(1), z.literal(2), z.literal(3)]);
+export type Priority = z.infer<typeof prioritySchema>; // 0 | 1 | 2 | 3
+
+// Mixed enum → z.union with z.literal
+export const valueSchema = z.union([z.literal(0), z.literal("none"), z.literal(1), z.literal("some")]);
+export type Value = z.infer<typeof valueSchema>; // 0 | "none" | 1 | "some"
+```
 
 ## Schema Naming
 
@@ -684,39 +720,39 @@ export default defineConfig({
 });
 ```
 
-#### Regex Patterns
+#### Glob Patterns
 
-Use regex patterns to strip dynamic prefixes:
+Use glob patterns to strip dynamic prefixes:
 
 ```typescript
 export default defineConfig({
   specs: [{
     input: 'openapi.yaml',
     output: 'schemas.ts',
-    // Strip any namespace prefix ending with a dot
-    stripSchemaPrefix: '^[A-Z][a-z]+\\.'
+    // Strip any namespace prefix with wildcard
+    stripSchemaPrefix: '*.Models.'
   }]
 });
 ```
 
-**Regex Auto-Detection:**
-
-Regex patterns are auto-detected if they contain: `^`, `$`, `\\d`, `\\w`, `\\s`, `.*`, `.+`, `[]`, `()`
+**Glob Pattern Syntax:**
 
-```typescript
-// These are all treated as regex patterns:
-stripSchemaPrefix: '^Company\\.'       // Starts with ^
-stripSchemaPrefix: '[A-Z]+\\.'         // Contains []
-stripSchemaPrefix: '.*\\.Models\\.'    // Contains .*
-
-// This is a literal string:
-stripSchemaPrefix: 'Company.Models.'   // No regex markers
-```
-
-For TypeScript configs, you can also use `RegExp` objects:
+Glob patterns support powerful matching using [minimatch](https://github.com/isaacs/minimatch):
+- `*` matches any characters within a single segment (stops at `.`)
+- `**` matches any characters across multiple segments (crosses `.` boundaries)
+- `?` matches a single character
+- `[abc]` matches any character in the set
+- `{a,b}` matches any of the alternatives
+- `!(pattern)` matches anything except the pattern
 
 ```typescript
-stripSchemaPrefix: /^[A-Z][a-z]+\./
+// Examples of glob patterns:
+stripSchemaPrefix: '*.Models.'                      // Matches Company.Models., App.Models.
+stripSchemaPrefix: '**.Models.'                     // Matches any depth: Company.Api.Models., App.V2.Models.
+stripSchemaPrefix: 'Company.{Models,Services}.'     // Matches Company.Models. or Company.Services.
+stripSchemaPrefix: 'api_v[0-9]_'                   // Matches api_v1_, api_v2_, etc.
+stripSchemaPrefix: 'v*.*.'                          // Matches v1.0., v2.1., etc.
+stripSchemaPrefix: '!(Internal)*.'                  // Matches any prefix except those starting with Internal
 ```
 
 #### Common Patterns
@@ -730,24 +766,44 @@ stripSchemaPrefix: /^[A-Z][a-z]+\./
 // Company.Models.Post → Post
 ```
 
-**Pattern 2: Multiple Namespaces**
+**Pattern 2: Multiple Namespaces with Wildcard**
 ```typescript
 {
-  stripSchemaPrefix: '^[A-Za-z]+\\.Models\\.'
+  stripSchemaPrefix: '*.Models.'
 }
 // MyApp.Models.User → User
 // OtherApp.Models.User → User
+// Company.Models.Post → Post
 ```
 
-**Pattern 3: Version Prefixes**
+**Pattern 3: Multiple Namespace Types**
 ```typescript
 {
-  stripSchemaPrefix: '^v\\d+\\.'
+  stripSchemaPrefix: '*.{Models,Services}.'
+}
+// App.Models.User → User
+// App.Services.UserService → UserService
+```
+
+**Pattern 4: Version Prefixes with Character Class**
+```typescript
+{
+  stripSchemaPrefix: 'v[0-9].'
 }
 // v1.User → User
 // v2.Product → Product
 ```
 
+**Pattern 5: Versioned Prefixes with Wildcards**
+```typescript
+{
+  stripSchemaPrefix: 'api_v*_'
+}
+// api_v1_User → User
+// api_v2_Product → Product
+// api_v10_Comment → Comment
+```
+
 #### Interaction with prefix/suffix Options
 
 `stripSchemaPrefix` is applied **before** `prefix` and `suffix` options:

package/dist/cli.js

@@ -5129,7 +5129,7 @@ function getBatchExitCode(summary) {
 init_cjs_shims();
 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/generators/enum-generator.ts
@@ -5192,8 +5192,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 };
 }
@@ -5207,7 +5225,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, "*\\/");
@@ -5337,61 +5355,36 @@ var LRUCache = class {
 
 // src/utils/pattern-utils.ts
 init_cjs_shims();
-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;
@@ -5400,8 +5393,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;
 }
@@ -6284,9 +6290,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(
@@ -6418,7 +6440,7 @@ var PropertyGenerator = _PropertyGenerator;
 
 // src/utils/operation-filters.ts
 init_cjs_shims();
-var import_minimatch = require("minimatch");
+var import_minimatch2 = require("minimatch");
 function createFilterStatistics() {
   return {
     totalOperations: 0,
@@ -6437,7 +6459,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) {
@@ -6664,6 +6686,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();
@@ -7152,7 +7177,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);
     });
   }
   /**
@@ -7240,8 +7265,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") {