next-openapi-gen 0.5.1 → 0.5.3

package/dist/lib/schema-processor.js

@@ -43,6 +43,11 @@ export class SchemaProcessor {
         // Check if we should use Zod schemas
         if (this.schemaType === "zod") {
             console.log(`Looking for Zod schema: ${schemaName}`);
+            // Check type mapping first
+            const mappedSchemaName = this.zodSchemaConverter.typeToSchemaMapping[schemaName];
+            if (mappedSchemaName) {
+                console.log(`Type '${schemaName}' is mapped to Zod schema '${mappedSchemaName}'`);
+            }
             // Try to convert Zod schema
             const zodSchema = this.zodSchemaConverter.convertZodSchemaToOpenApi(schemaName);
             if (zodSchema) {

package/dist/lib/zod-converter.js

@@ -11,6 +11,7 @@ export class ZodSchemaConverter {
     zodSchemas = {};
     processingSchemas = new Set();
     processedModules = new Set();
+    typeToSchemaMapping = {};
     constructor(schemaDir) {
         this.schemaDir = path.resolve(schemaDir);
     }
@@ -18,7 +19,17 @@ export class ZodSchemaConverter {
      * Find a Zod schema by name and convert it to OpenAPI spec
      */
     convertZodSchemaToOpenApi(schemaName) {
+        // Run pre-scan only one time
+        if (Object.keys(this.typeToSchemaMapping).length === 0) {
+            this.preScanForTypeMappings();
+        }
         console.log(`Looking for Zod schema: ${schemaName}`);
+        // Check mapped types
+        const mappedSchemaName = this.typeToSchemaMapping[schemaName];
+        if (mappedSchemaName) {
+            console.log(`Type '${schemaName}' is mapped to schema '${mappedSchemaName}'`);
+            schemaName = mappedSchemaName;
+        }
         // Check for circular references
         if (this.processingSchemas.has(schemaName)) {
             return { $ref: `#/components/schemas/${schemaName}` };
@@ -127,6 +138,12 @@ export class ZodSchemaConverter {
             if (!content.includes(schemaName)) {
                 return;
             }
+            // Pre-process all schemas in file
+            this.preprocessAllSchemasInFile(filePath);
+            // Return it, if the schema has already been processed during pre-processing
+            if (this.zodSchemas[schemaName]) {
+                return;
+            }
             // Parse the file
             const ast = parse(content, {
                 sourceType: "module",
@@ -240,22 +257,51 @@ export class ZodSchemaConverter {
                 },
                 // For type aliases that reference Zod schemas
                 TSTypeAliasDeclaration: (path) => {
-                    if (t.isIdentifier(path.node.id) &&
-                        path.node.id.name === schemaName) {
-                        // Try to find if this is a z.infer<typeof SchemaName> pattern
+                    if (t.isIdentifier(path.node.id)) {
+                        const typeName = path.node.id.name;
                         if (t.isTSTypeReference(path.node.typeAnnotation) &&
-                            t.isIdentifier(path.node.typeAnnotation.typeName) &&
-                            path.node.typeAnnotation.typeName.name === "infer" &&
-                            path.node.typeAnnotation.typeParameters &&
-                            path.node.typeAnnotation.typeParameters.params.length > 0) {
-                            const param = path.node.typeAnnotation.typeParameters.params[0];
-                            if (t.isTSTypeQuery(param) && t.isIdentifier(param.exprName)) {
-                                const referencedSchemaName = param.exprName.name;
-                                // Find the referenced schema
-                                this.processFileForZodSchema(filePath, referencedSchemaName);
-                                if (this.zodSchemas[referencedSchemaName]) {
-                                    this.zodSchemas[schemaName] =
-                                        this.zodSchemas[referencedSchemaName];
+                            t.isTSQualifiedName(path.node.typeAnnotation.typeName) &&
+                            t.isIdentifier(path.node.typeAnnotation.typeName.left) &&
+                            path.node.typeAnnotation.typeName.left.name === "z" &&
+                            t.isIdentifier(path.node.typeAnnotation.typeName.right) &&
+                            path.node.typeAnnotation.typeName.right.name === "infer") {
+                            // Extract schema name from z.infer<typeof SchemaName>
+                            if (path.node.typeAnnotation.typeParameters &&
+                                path.node.typeAnnotation.typeParameters.params.length > 0) {
+                                const param = path.node.typeAnnotation.typeParameters.params[0];
+                                if (t.isTSTypeQuery(param) && t.isIdentifier(param.exprName)) {
+                                    const referencedSchemaName = param.exprName.name;
+                                    // Save mapping: TypeName -> SchemaName
+                                    this.typeToSchemaMapping[typeName] = referencedSchemaName;
+                                    console.log(`Mapped type '${typeName}' to schema '${referencedSchemaName}'`);
+                                    // Process the referenced schema if not already processed
+                                    if (!this.zodSchemas[referencedSchemaName]) {
+                                        this.processFileForZodSchema(filePath, referencedSchemaName);
+                                    }
+                                    // Use the referenced schema for this type
+                                    if (this.zodSchemas[referencedSchemaName]) {
+                                        this.zodSchemas[typeName] =
+                                            this.zodSchemas[referencedSchemaName];
+                                    }
+                                }
+                            }
+                        }
+                        if (path.node.id.name === schemaName) {
+                            // Try to find if this is a z.infer<typeof SchemaName> pattern
+                            if (t.isTSTypeReference(path.node.typeAnnotation) &&
+                                t.isIdentifier(path.node.typeAnnotation.typeName) &&
+                                path.node.typeAnnotation.typeName.name === "infer" &&
+                                path.node.typeAnnotation.typeParameters &&
+                                path.node.typeAnnotation.typeParameters.params.length > 0) {
+                                const param = path.node.typeAnnotation.typeParameters.params[0];
+                                if (t.isTSTypeQuery(param) && t.isIdentifier(param.exprName)) {
+                                    const referencedSchemaName = param.exprName.name;
+                                    // Find the referenced schema
+                                    this.processFileForZodSchema(filePath, referencedSchemaName);
+                                    if (this.zodSchemas[referencedSchemaName]) {
+                                        this.zodSchemas[schemaName] =
+                                            this.zodSchemas[referencedSchemaName];
+                                    }
                                 }
                             }
                         }
@@ -553,6 +599,44 @@ export class ZodSchemaConverter {
                     console.log(`Skipping property ${index} - unsupported key type`);
                     return; // Skip if key is not identifier or string literal
                 }
+                if (t.isCallExpression(prop.value) &&
+                    t.isMemberExpression(prop.value.callee) &&
+                    t.isIdentifier(prop.value.callee.object)) {
+                    const schemaName = prop.value.callee.object.name;
+                    // @ts-ignore
+                    const methodName = prop.value.callee.property.name;
+                    // Process base schema first
+                    if (!this.zodSchemas[schemaName]) {
+                        this.convertZodSchemaToOpenApi(schemaName);
+                    }
+                    // For describe method, use reference with description
+                    if (methodName === "describe" && this.zodSchemas[schemaName]) {
+                        if (prop.value.arguments.length > 0 &&
+                            t.isStringLiteral(prop.value.arguments[0])) {
+                            properties[propName] = {
+                                allOf: [{ $ref: `#/components/schemas/${schemaName}` }],
+                                description: prop.value.arguments[0].value,
+                            };
+                        }
+                        else {
+                            properties[propName] = {
+                                $ref: `#/components/schemas/${schemaName}`,
+                            };
+                        }
+                        required.push(propName);
+                        return;
+                    }
+                    // For other methods, process normally
+                    const processedSchema = this.processZodNode(prop.value);
+                    if (processedSchema) {
+                        properties[propName] = processedSchema;
+                        const isOptional = this.isOptional(prop.value) || this.hasOptionalMethod(prop.value);
+                        if (!isOptional) {
+                            required.push(propName);
+                        }
+                    }
+                    return;
+                }
                 // Check if the property value is an identifier (reference to another schema)
                 if (t.isIdentifier(prop.value)) {
                     const referencedSchemaName = prop.value.name;
@@ -1058,4 +1142,142 @@ export class ZodSchemaConverter {
     getProcessedSchemas() {
         return this.zodSchemas;
     }
+    /**
+     * Pre-scan all files to build type mappings
+     */
+    preScanForTypeMappings() {
+        console.log("Pre-scanning for type mappings...");
+        // Scan route files
+        const routeFiles = this.findRouteFiles();
+        for (const routeFile of routeFiles) {
+            this.scanFileForTypeMappings(routeFile);
+        }
+        // Scan schema directory
+        this.scanDirectoryForTypeMappings(this.schemaDir);
+    }
+    /**
+     * Scan a single file for type mappings
+     */
+    scanFileForTypeMappings(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            const ast = parse(content, {
+                sourceType: "module",
+                plugins: ["typescript", "decorators-legacy"],
+            });
+            traverse.default(ast, {
+                TSTypeAliasDeclaration: (path) => {
+                    if (t.isIdentifier(path.node.id)) {
+                        const typeName = path.node.id.name;
+                        // Check for z.infer<typeof SchemaName> pattern
+                        if (t.isTSTypeReference(path.node.typeAnnotation)) {
+                            const typeRef = path.node.typeAnnotation;
+                            // Handle both z.infer and just infer (when z is imported)
+                            let isInferType = false;
+                            if (t.isTSQualifiedName(typeRef.typeName) &&
+                                t.isIdentifier(typeRef.typeName.left) &&
+                                typeRef.typeName.left.name === "z" &&
+                                t.isIdentifier(typeRef.typeName.right) &&
+                                typeRef.typeName.right.name === "infer") {
+                                isInferType = true;
+                            }
+                            else if (t.isIdentifier(typeRef.typeName) &&
+                                typeRef.typeName.name === "infer") {
+                                isInferType = true;
+                            }
+                            if (isInferType &&
+                                typeRef.typeParameters &&
+                                typeRef.typeParameters.params.length > 0) {
+                                const param = typeRef.typeParameters.params[0];
+                                if (t.isTSTypeQuery(param) && t.isIdentifier(param.exprName)) {
+                                    const referencedSchemaName = param.exprName.name;
+                                    this.typeToSchemaMapping[typeName] = referencedSchemaName;
+                                    console.log(`Pre-scan: Mapped type '${typeName}' to schema '${referencedSchemaName}'`);
+                                }
+                            }
+                        }
+                    }
+                },
+            });
+        }
+        catch (error) {
+            console.error(`Error scanning file ${filePath} for type mappings:`, error);
+        }
+    }
+    /**
+     * Recursively scan directory for type mappings
+     */
+    scanDirectoryForTypeMappings(dir) {
+        try {
+            const files = fs.readdirSync(dir);
+            for (const file of files) {
+                const filePath = path.join(dir, file);
+                const stats = fs.statSync(filePath);
+                if (stats.isDirectory()) {
+                    this.scanDirectoryForTypeMappings(filePath);
+                }
+                else if (file.endsWith(".ts") || file.endsWith(".tsx")) {
+                    this.scanFileForTypeMappings(filePath);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error scanning directory ${dir} for type mappings:`, error);
+        }
+    }
+    /**
+     * Pre-process all Zod schemas in a file
+     */
+    preprocessAllSchemasInFile(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            const ast = parse(content, {
+                sourceType: "module",
+                plugins: ["typescript", "decorators-legacy"],
+            });
+            // Collect all exported Zod schemas
+            traverse.default(ast, {
+                ExportNamedDeclaration: (path) => {
+                    if (t.isVariableDeclaration(path.node.declaration)) {
+                        path.node.declaration.declarations.forEach((declaration) => {
+                            if (t.isIdentifier(declaration.id) && declaration.init) {
+                                const schemaName = declaration.id.name;
+                                // Check if is Zos schema
+                                if (this.isZodSchema(declaration.init) &&
+                                    !this.zodSchemas[schemaName]) {
+                                    console.log(`Pre-processing Zod schema: ${schemaName}`);
+                                    this.processingSchemas.add(schemaName);
+                                    const schema = this.processZodNode(declaration.init);
+                                    if (schema) {
+                                        this.zodSchemas[schemaName] = schema;
+                                    }
+                                    this.processingSchemas.delete(schemaName);
+                                }
+                            }
+                        });
+                    }
+                },
+            });
+        }
+        catch (error) {
+            console.error(`Error pre-processing file ${filePath}:`, error);
+        }
+    }
+    /**
+     * Check if node is Zod schema
+     */
+    isZodSchema(node) {
+        if (t.isCallExpression(node)) {
+            if (t.isMemberExpression(node.callee) &&
+                t.isIdentifier(node.callee.object) &&
+                node.callee.object.name === "z") {
+                return true;
+            }
+            if (t.isMemberExpression(node.callee) &&
+                t.isCallExpression(node.callee.object)) {
+                return this.isZodSchema(node.callee.object);
+            }
+        }
+        return false;
+    }
 }

package/package.json

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