next-openapi-gen 0.10.0 → 0.10.2

package/README.md

@@ -72,7 +72,7 @@ During initialization (`npx next-openapi-gen init`), a configuration file `next.
   ],
   "apiDir": "src/app/api", // or "pages/api" for Pages Router
   "routerType": "app", // "app" (default) or "pages" for legacy Pages Router
-  "schemaDir": "src/types", // or "src/schemas" for Zod schemas
+  "schemaDir": "src/types", // or ["src/types", "src/schemas"] for multiple directories
   "schemaType": "zod", // or "typescript", or ["zod", "typescript"] for multiple
   "schemaFiles": [], // Optional: ["./schemas/models.yaml", "./schemas/api.json"]
   "outputFile": "openapi.json",
@@ -90,7 +90,7 @@ During initialization (`npx next-openapi-gen init`), a configuration file `next.
 | ---------------------- | ----------------------------------------------------------------------------- |
 | `apiDir`               | Path to the API directory                                                     |
 | `routerType`           | Router type: `"app"` (default) or `"pages"` for legacy Pages Router           |
-| `schemaDir`            | Path to the types/schemas directory                                           |
+| `schemaDir`            | Path to types/schemas directory, or array of paths for multiple directories   |
 | `schemaType`           | Schema type: `"zod"`, `"typescript"`, or `["zod", "typescript"]` for multiple |
 | `schemaFiles`          | Optional: Array of custom OpenAPI schema files (YAML/JSON) to include         |
 | `outputFile`           | Name of the OpenAPI output file                                               |

package/dist/lib/drizzle-zod-processor.js

@@ -119,7 +119,6 @@ export class DrizzleZodProcessor {
                 ? node.callee.property.name
                 : null;
             if (methodName === "optional" ||
-                methodName === "nullable" ||
                 methodName === "nullish") {
                 return true;
             }
@@ -291,10 +290,13 @@ export class DrizzleZodProcessor {
                 result.type = "integer";
                 break;
             case "optional":
+                // Handled by isFieldOptional check, no schema modification needed
+                break;
             case "nullable":
+                result.nullable = true;
+                break;
             case "nullish":
-                // These are handled by the isFieldOptional check
-                // Don't modify the schema here
+                result.nullable = true;
                 break;
             case "describe":
                 if (args.length > 0 && t.isStringLiteral(args[0])) {

package/dist/lib/schema-processor.js

@@ -14,8 +14,14 @@ import { logger } from "./logger.js";
 function normalizeSchemaTypes(schemaType) {
     return Array.isArray(schemaType) ? schemaType : [schemaType];
 }
+/**
+ * Normalize schemaDir to array
+ */
+function normalizeSchemaDirs(schemaDir) {
+    return Array.isArray(schemaDir) ? schemaDir : [schemaDir];
+}
 export class SchemaProcessor {
-    schemaDir;
+    schemaDirs;
     typeDefinitions = {};
     openapiDefinitions = {};
     contentType = "";
@@ -31,7 +37,7 @@ export class SchemaProcessor {
     importMap = {}; // { filePath: { importName: importPath } }
     currentFilePath = ""; // Track the file being processed
     constructor(schemaDir, schemaType = "typescript", schemaFiles) {
-        this.schemaDir = path.resolve(schemaDir);
+        this.schemaDirs = normalizeSchemaDirs(schemaDir).map((d) => path.resolve(d));
         this.schemaTypes = normalizeSchemaTypes(schemaType);
         // Initialize Zod converter if Zod is enabled
         if (this.schemaTypes.includes("zod")) {
@@ -140,9 +146,18 @@ export class SchemaProcessor {
             logger.debug(`No Zod schema found for ${schemaName}, trying TypeScript fallback`);
         }
         // Fall back to TypeScript types
-        this.scanSchemaDir(this.schemaDir, schemaName);
+        this.scanAllSchemaDirs(schemaName);
         return this.openapiDefinitions[schemaName] || {};
     }
+    scanAllSchemaDirs(schemaName) {
+        for (const dir of this.schemaDirs) {
+            if (!fs.existsSync(dir)) {
+                logger.warn(`Schema directory not found: ${dir}`);
+                continue;
+            }
+            this.scanSchemaDir(dir, schemaName);
+        }
+    }
     scanSchemaDir(dir, schemaName) {
         let files = this.directoryCache[dir];
         if (typeof files === "undefined") {
@@ -1229,7 +1244,7 @@ export class SchemaProcessor {
         }
         const { baseTypeName, typeArguments } = parsed;
         // Find the base generic type definition
-        this.scanSchemaDir(this.schemaDir, baseTypeName);
+        this.scanAllSchemaDirs(baseTypeName);
         const genericDefEntry = this.typeDefinitions[baseTypeName];
         const genericTypeDefinition = genericDefEntry?.node || genericDefEntry;
         if (!genericTypeDefinition) {
@@ -1241,7 +1256,7 @@ export class SchemaProcessor {
             // If it's a simple type reference (not another generic), find its definition
             if (!argTypeName.includes("<") &&
                 !this.isGenericTypeParameter(argTypeName)) {
-                this.scanSchemaDir(this.schemaDir, argTypeName);
+                this.scanAllSchemaDirs(argTypeName);
             }
         });
         // Create AST nodes for the type arguments by parsing them

package/dist/lib/zod-converter.js

@@ -11,7 +11,7 @@ import { DrizzleZodProcessor } from "./drizzle-zod-processor.js";
  * Class for converting Zod schemas to OpenAPI specifications
  */
 export class ZodSchemaConverter {
-    schemaDir;
+    schemaDirs;
     zodSchemas = {};
     processingSchemas = new Set();
     processedModules = new Set();
@@ -26,7 +26,8 @@ export class ZodSchemaConverter {
     currentAST;
     currentImports;
     constructor(schemaDir) {
-        this.schemaDir = path.resolve(schemaDir);
+        const dirs = Array.isArray(schemaDir) ? schemaDir : [schemaDir];
+        this.schemaDirs = dirs.map((d) => path.resolve(d));
     }
     /**
      * Find a Zod schema by name and convert it to OpenAPI spec
@@ -63,8 +64,12 @@ export class ZodSchemaConverter {
                     return this.zodSchemas[schemaName];
                 }
             }
-            // Scan schema directory
-            this.scanDirectoryForZodSchema(this.schemaDir, schemaName);
+            // Scan schema directories
+            for (const dir of this.schemaDirs) {
+                this.scanDirectoryForZodSchema(dir, schemaName);
+                if (this.zodSchemas[schemaName])
+                    break;
+            }
             // Return the schema if found, or null if not
             if (this.zodSchemas[schemaName]) {
                 logger.debug(`Found and processed Zod schema: ${schemaName}`);
@@ -347,12 +352,8 @@ export class ZodSchemaConverter {
                                     }
                                     break;
                                 case "partial":
-                                    // All fields become optional
+                                    // All fields become optional (T | undefined), not nullable
                                     if (schema.properties) {
-                                        Object.keys(schema.properties).forEach((key) => {
-                                            schema.properties[key].nullable = true;
-                                        });
-                                        // Remove all required
                                         delete schema.required;
                                     }
                                     break;
@@ -390,14 +391,9 @@ export class ZodSchemaConverter {
                                     }
                                     break;
                                 case "required":
-                                    // All fields become required
+                                    // All fields become required — preserve genuine nullable flags
                                     if (schema.properties) {
-                                        const requiredFields = Object.keys(schema.properties);
-                                        schema.required = requiredFields;
-                                        // Remove nullable from fields
-                                        Object.keys(schema.properties).forEach((key) => {
-                                            delete schema.properties[key].nullable;
-                                        });
+                                        schema.required = Object.keys(schema.properties);
                                     }
                                     break;
                                 case "extend":
@@ -418,8 +414,9 @@ export class ZodSchemaConverter {
                                                     const propSchema = this.processZodNode(prop.value);
                                                     if (propSchema) {
                                                         extensionProperties[key] = propSchema;
-                                                        // Check if the schema itself has nullable set (which processZodNode sets for optional fields)
-                                                        const isOptional = propSchema.nullable === true;
+                                                        const isOptional = 
+                                                        // @ts-ignore
+                                                        this.isOptional(prop.value) || this.hasOptionalMethod(prop.value);
                                                         if (!isOptional) {
                                                             extensionRequired.push(key);
                                                         }
@@ -1239,20 +1236,17 @@ export class ZodSchemaConverter {
         // Apply the current method
         switch (methodName) {
             case "optional":
-                // Don't add nullable for schema references wrapped in allOf
-                // as it doesn't make sense in that context
-                if (!schema.allOf) {
-                    schema.nullable = true;
-                }
+                // optional means T | undefined — not in required array, no nullable flag
+                // Required array exclusion is handled by hasOptionalMethod() in processZodObject()
                 break;
             case "nullable":
-                // Don't add nullable for schema references wrapped in allOf
+                // nullable means T | null — field stays required but can be null
                 if (!schema.allOf) {
                     schema.nullable = true;
                 }
                 break;
-            case "nullish": // Handles both null and undefined
-                // Don't add nullable for schema references wrapped in allOf
+            case "nullish": // T | null | undefined
+                // Not in required array (handled by hasOptionalMethod) AND can be null
                 if (!schema.allOf) {
                     schema.nullable = true;
                 }
@@ -1540,7 +1534,6 @@ export class ZodSchemaConverter {
         if (t.isMemberExpression(node.callee) &&
             t.isIdentifier(node.callee.property) &&
             (node.callee.property.name === "optional" ||
-                node.callee.property.name === "nullable" ||
                 node.callee.property.name === "nullish")) {
             return true;
         }
@@ -1566,8 +1559,10 @@ export class ZodSchemaConverter {
         for (const routeFile of routeFiles) {
             this.scanFileForTypeMappings(routeFile);
         }
-        // Scan schema directory
-        this.scanDirectoryForTypeMappings(this.schemaDir);
+        // Scan schema directories
+        for (const dir of this.schemaDirs) {
+            this.scanDirectoryForTypeMappings(dir);
+        }
     }
     /**
      * Scan a single file for type mappings

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-openapi-gen",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "description": "Automatically generate OpenAPI 3.0 documentation from Next.js projects, with support for Zod schemas and TypeScript types.",
   "type": "module",
   "main": "dist/index.js",