next-openapi-gen 0.6.5 → 0.6.7

package/dist/lib/logger.js

@@ -18,21 +18,21 @@ class Logger {
         return 'Unknown';
     }
     log(message, ...args) {
-        if (this.config?.debug) {
-            const source = this.getCallerInfo();
-            console.log(`[${source}] ${message}`, ...args);
-        }
+        const source = this.getCallerInfo();
+        console.log(`[${source}] ${message}`, ...args);
     }
     warn(message, ...args) {
-        if (this.config?.debug) {
-            const source = this.getCallerInfo();
-            console.warn(`[${source}] ${message}`, ...args);
-        }
+        const source = this.getCallerInfo();
+        console.warn(`[${source}] ${message}`, ...args);
     }
     error(message, ...args) {
+        const source = this.getCallerInfo();
+        console.error(`[${source}] ${message}`, ...args);
+    }
+    debug(message, ...args) {
         if (this.config?.debug) {
             const source = this.getCallerInfo();
-            console.error(`[${source}] ${message}`, ...args);
+            console.log(`[${source}] ${message}`, ...args);
         }
     }
 }

package/dist/lib/openapi-generator.js

@@ -39,7 +39,7 @@ export class OpenApiGenerator {
         let appRouterApiDir = "";
         if (fs.existsSync(path.join(path.dirname(apiDir), "app", "api"))) {
             appRouterApiDir = path.join(path.dirname(apiDir), "app", "api");
-            logger.log(`Found app router API directory at ${appRouterApiDir}`);
+            logger.debug(`Found app router API directory at ${appRouterApiDir}`);
         }
         // Scan pages router routes
         this.routeProcessor.scanApiRoutes(apiDir);

package/dist/lib/route-processor.js

@@ -137,7 +137,7 @@ export class RouteProcessor {
                             const pathParams = extractPathParameters(routePath);
                             // If we have path parameters but no pathParamsType defined, we should log a warning
                             if (pathParams.length > 0 && !dataTypes.pathParamsType) {
-                                logger.warn(`Route ${routePath} contains path parameters ${pathParams.join(", ")} but no @pathParams type is defined.`);
+                                logger.debug(`Route ${routePath} contains path parameters ${pathParams.join(", ")} but no @pathParams type is defined.`);
                             }
                             this.addRouteToPaths(declaration.id.name, filePath, dataTypes);
                         }
@@ -154,7 +154,7 @@ export class RouteProcessor {
                                     const routePath = this.getRoutePath(filePath);
                                     const pathParams = extractPathParameters(routePath);
                                     if (pathParams.length > 0 && !dataTypes.pathParamsType) {
-                                        logger.warn(`Route ${routePath} contains path parameters ${pathParams.join(", ")} but no @pathParams type is defined.`);
+                                        logger.debug(`Route ${routePath} contains path parameters ${pathParams.join(", ")} but no @pathParams type is defined.`);
                                     }
                                     this.addRouteToPaths(decl.id.name, filePath, dataTypes);
                                 }
@@ -167,7 +167,7 @@ export class RouteProcessor {
         this.processFileTracker[filePath] = true;
     }
     scanApiRoutes(dir) {
-        logger.log(`Scanning API routes in: ${dir}`);
+        logger.debug(`Scanning API routes in: ${dir}`);
         let files = this.directoryCache[dir];
         if (!files) {
             files = fs.readdirSync(dir);

package/dist/lib/schema-processor.js

@@ -16,6 +16,7 @@ export class SchemaProcessor {
     processingTypes = new Set();
     zodSchemaConverter;
     schemaType;
+    isResolvingPickOmitBase = false;
     constructor(schemaDir, schemaType = "typescript") {
         this.schemaDir = path.resolve(schemaDir);
         this.schemaType = schemaType;
@@ -43,20 +44,20 @@ export class SchemaProcessor {
         this.contentType = contentType;
         // Check if we should use Zod schemas
         if (this.schemaType === "zod") {
-            logger.log(`Looking for Zod schema: ${schemaName}`);
+            logger.debug(`Looking for Zod schema: ${schemaName}`);
             // Check type mapping first
             const mappedSchemaName = this.zodSchemaConverter.typeToSchemaMapping[schemaName];
             if (mappedSchemaName) {
-                logger.log(`Type '${schemaName}' is mapped to Zod schema '${mappedSchemaName}'`);
+                logger.debug(`Type '${schemaName}' is mapped to Zod schema '${mappedSchemaName}'`);
             }
             // Try to convert Zod schema
             const zodSchema = this.zodSchemaConverter.convertZodSchemaToOpenApi(schemaName);
             if (zodSchema) {
-                logger.log(`Found and processed Zod schema: ${schemaName}`);
+                logger.debug(`Found and processed Zod schema: ${schemaName}`);
                 this.openapiDefinitions[schemaName] = zodSchema;
                 return zodSchema;
             }
-            logger.log(`No Zod schema found for ${schemaName}, trying TypeScript fallback`);
+            logger.debug(`No Zod schema found for ${schemaName}, trying TypeScript fallback`);
         }
         // Fall back to TypeScript types
         this.scanSchemaDir(this.schemaDir, schemaName);
@@ -166,10 +167,21 @@ export class SchemaProcessor {
                 const enumValues = this.processEnum(typeNode);
                 return enumValues;
             }
-            if (t.isTSTypeLiteral(typeNode) || t.isTSInterfaceBody(typeNode)) {
+            if (t.isTSTypeLiteral(typeNode) || t.isTSInterfaceBody(typeNode) || t.isTSInterfaceDeclaration(typeNode)) {
                 const properties = {};
-                if ("members" in typeNode) {
-                    (typeNode.members || []).forEach((member) => {
+                // Handle interface extends clause
+                if (t.isTSInterfaceDeclaration(typeNode) && typeNode.extends && typeNode.extends.length > 0) {
+                    typeNode.extends.forEach((extendedType) => {
+                        const extendedSchema = this.resolveTSNodeType(extendedType);
+                        if (extendedSchema.properties) {
+                            Object.assign(properties, extendedSchema.properties);
+                        }
+                    });
+                }
+                // Get members from interface declaration body or direct members
+                const members = t.isTSInterfaceDeclaration(typeNode) ? typeNode.body.body : typeNode.members;
+                if (members) {
+                    (members || []).forEach((member) => {
                         if (t.isTSPropertySignature(member) && t.isIdentifier(member.key)) {
                             const propName = member.key.name;
                             const options = this.getPropertyOptions(member);
@@ -192,6 +204,9 @@ export class SchemaProcessor {
             if (t.isTSUnionType(typeNode)) {
                 return this.resolveTSNodeType(typeNode);
             }
+            if (t.isTSTypeReference(typeNode)) {
+                return this.resolveTSNodeType(typeNode);
+            }
             return {};
         }
         finally {
@@ -250,6 +265,18 @@ export class SchemaProcessor {
                 };
             }
         }
+        // Handle TSExpressionWithTypeArguments (used in interface extends)
+        if (t.isTSExpressionWithTypeArguments(node)) {
+            if (t.isIdentifier(node.expression)) {
+                // Convert to TSTypeReference-like structure for processing
+                const syntheticNode = {
+                    type: 'TSTypeReference',
+                    typeName: node.expression,
+                    typeParameters: node.typeParameters
+                };
+                return this.resolveTSNodeType(syntheticNode);
+            }
+        }
         if (t.isTSTypeReference(node) && t.isIdentifier(node.typeName)) {
             const typeName = node.typeName.name;
             // Special handling for built-in types
@@ -284,6 +311,34 @@ export class SchemaProcessor {
                 }
             }
             if (typeName === "Pick" || typeName === "Omit") {
+                if (node.typeParameters && node.typeParameters.params.length > 1) {
+                    const baseTypeParam = node.typeParameters.params[0];
+                    const keysParam = node.typeParameters.params[1];
+                    // Resolve base type without adding it to schema definitions
+                    this.isResolvingPickOmitBase = true;
+                    const baseType = this.resolveTSNodeType(baseTypeParam);
+                    this.isResolvingPickOmitBase = false;
+                    if (baseType.properties) {
+                        const properties = {};
+                        const keyNames = this.extractKeysFromLiteralType(keysParam);
+                        if (typeName === "Pick") {
+                            keyNames.forEach(key => {
+                                if (baseType.properties[key]) {
+                                    properties[key] = baseType.properties[key];
+                                }
+                            });
+                        }
+                        else { // Omit
+                            Object.entries(baseType.properties).forEach(([key, value]) => {
+                                if (!keyNames.includes(key)) {
+                                    properties[key] = value;
+                                }
+                            });
+                        }
+                        return { type: "object", properties };
+                    }
+                }
+                // Fallback to just the base type if we can't process properly
                 if (node.typeParameters && node.typeParameters.params.length > 0) {
                     return this.resolveTSNodeType(node.typeParameters.params[0]);
                 }
@@ -395,7 +450,7 @@ export class SchemaProcessor {
         if (t.isTSTypeReference(node) && t.isIdentifier(node.typeName)) {
             return { $ref: `#/components/schemas/${node.typeName.name}` };
         }
-        logger.log("Unrecognized TypeScript type node:", node);
+        logger.debug("Unrecognized TypeScript type node:", node);
         return { type: "object" }; // By default we return an object
     }
     processSchemaFile(filePath, schemaName) {
@@ -413,7 +468,9 @@ export class SchemaProcessor {
             // Reset the set of processed types before each schema processing
             this.processingTypes.clear();
             const definition = this.resolveType(schemaName);
-            this.openapiDefinitions[schemaName] = definition;
+            if (!this.isResolvingPickOmitBase) {
+                this.openapiDefinitions[schemaName] = definition;
+            }
             this.processSchemaTracker[`${filePath}-${schemaName}`] = true;
             return definition;
         }
@@ -447,6 +504,21 @@ export class SchemaProcessor {
         });
         return enumSchema;
     }
+    extractKeysFromLiteralType(node) {
+        if (t.isTSLiteralType(node) && t.isStringLiteral(node.literal)) {
+            return [node.literal.value];
+        }
+        if (t.isTSUnionType(node)) {
+            const keys = [];
+            node.types.forEach((type) => {
+                if (t.isTSLiteralType(type) && t.isStringLiteral(type.literal)) {
+                    keys.push(type.literal.value);
+                }
+            });
+            return keys;
+        }
+        return [];
+    }
     getPropertyOptions(node) {
         const isOptional = !!node.optional; // check if property is optional
         let description = null;

package/dist/lib/zod-converter.js

@@ -24,11 +24,11 @@ export class ZodSchemaConverter {
         if (Object.keys(this.typeToSchemaMapping).length === 0) {
             this.preScanForTypeMappings();
         }
-        logger.log(`Looking for Zod schema: ${schemaName}`);
+        logger.debug(`Looking for Zod schema: ${schemaName}`);
         // Check mapped types
         const mappedSchemaName = this.typeToSchemaMapping[schemaName];
         if (mappedSchemaName) {
-            logger.log(`Type '${schemaName}' is mapped to schema '${mappedSchemaName}'`);
+            logger.debug(`Type '${schemaName}' is mapped to schema '${mappedSchemaName}'`);
             schemaName = mappedSchemaName;
         }
         // Check for circular references
@@ -47,7 +47,7 @@ export class ZodSchemaConverter {
             for (const routeFile of routeFiles) {
                 this.processFileForZodSchema(routeFile, schemaName);
                 if (this.zodSchemas[schemaName]) {
-                    logger.log(`Found Zod schema '${schemaName}' in route file: ${routeFile}`);
+                    logger.debug(`Found Zod schema '${schemaName}' in route file: ${routeFile}`);
                     return this.zodSchemas[schemaName];
                 }
             }
@@ -55,10 +55,10 @@ export class ZodSchemaConverter {
             this.scanDirectoryForZodSchema(this.schemaDir, schemaName);
             // Return the schema if found, or null if not
             if (this.zodSchemas[schemaName]) {
-                logger.log(`Found and processed Zod schema: ${schemaName}`);
+                logger.debug(`Found and processed Zod schema: ${schemaName}`);
                 return this.zodSchemas[schemaName];
             }
-            logger.log(`Could not find Zod schema: ${schemaName}`);
+            logger.debug(`Could not find Zod schema: ${schemaName}`);
             return null;
         }
         finally {
@@ -105,7 +105,7 @@ export class ZodSchemaConverter {
             }
         }
         catch (error) {
-            logger.log(`Error scanning directory ${dir} for route files: ${error}`);
+            logger.error(`Error scanning directory ${dir} for route files: ${error}`);
         }
     }
     /**
@@ -126,7 +126,7 @@ export class ZodSchemaConverter {
             }
         }
         catch (error) {
-            logger.log(`Error scanning directory ${dir}: ${error}`);
+            logger.error(`Error scanning directory ${dir}: ${error}`);
         }
     }
     /**
@@ -273,7 +273,7 @@ export class ZodSchemaConverter {
                                                         ? prop.key.value
                                                         : null;
                                                 if (key && schema.properties) {
-                                                    logger.log(`Removing property: ${key}`);
+                                                    logger.debug(`Removing property: ${key}`);
                                                     delete schema.properties[key];
                                                     if (schema.required) {
                                                         schema.required = schema.required.filter((r) => r !== key);
@@ -358,20 +358,20 @@ export class ZodSchemaConverter {
                         if (t.isCallExpression(path.node.init)) {
                             const baseSchemaName = findBaseSchema(path.node.init);
                             if (baseSchemaName && baseSchemaName !== "z") {
-                                logger.log(`Found chained call starting from: ${baseSchemaName}`);
+                                logger.debug(`Found chained call starting from: ${baseSchemaName}`);
                                 // First make sure the underlying schema is processed
                                 if (!this.zodSchemas[baseSchemaName]) {
-                                    logger.log(`Base schema ${baseSchemaName} not found, processing it first`);
+                                    logger.debug(`Base schema ${baseSchemaName} not found, processing it first`);
                                     this.processFileForZodSchema(filePath, baseSchemaName);
                                 }
                                 if (this.zodSchemas[baseSchemaName]) {
-                                    logger.log("Base schema found, applying transformations");
+                                    logger.debug("Base schema found, applying transformations");
                                     // Copy base schema
                                     const baseSchema = JSON.parse(JSON.stringify(this.zodSchemas[baseSchemaName]));
                                     // Process the entire call chain
                                     const finalSchema = processChainedCall(path.node.init, baseSchema);
                                     this.zodSchemas[schemaName] = finalSchema;
-                                    logger.log(`Created ${schemaName} with properties: ${Object.keys(finalSchema.properties || {})}`);
+                                    logger.debug(`Created ${schemaName} with properties: ${Object.keys(finalSchema.properties || {})}`);
                                     return;
                                 }
                             }
@@ -413,7 +413,7 @@ export class ZodSchemaConverter {
                                     const referencedSchemaName = param.exprName.name;
                                     // Save mapping: TypeName -> SchemaName
                                     this.typeToSchemaMapping[typeName] = referencedSchemaName;
-                                    logger.log(`Mapped type '${typeName}' to schema '${referencedSchemaName}'`);
+                                    logger.debug(`Mapped type '${typeName}' to schema '${referencedSchemaName}'`);
                                     // Process the referenced schema if not already processed
                                     if (!this.zodSchemas[referencedSchemaName]) {
                                         this.processFileForZodSchema(filePath, referencedSchemaName);
@@ -450,7 +450,7 @@ export class ZodSchemaConverter {
             });
         }
         catch (error) {
-            console.error(`Error processing file ${filePath} for schema ${schemaName}: ${error}`);
+            logger.error(`Error processing file ${filePath} for schema ${schemaName}: ${error}`);
         }
     }
     /**
@@ -490,7 +490,7 @@ export class ZodSchemaConverter {
             });
         }
         catch (error) {
-            console.error(`Error processing all schemas in file ${filePath}: ${error}`);
+            logger.error(`Error processing all schemas in file ${filePath}: ${error}`);
         }
     }
     /**
@@ -557,7 +557,7 @@ export class ZodSchemaConverter {
             node.arguments.length > 0) {
             return this.processZodLazy(node);
         }
-        console.warn("Unknown Zod schema node:", node);
+        logger.debug("Unknown Zod schema node:", node);
         return { type: "object" };
     }
     /**
@@ -736,7 +736,7 @@ export class ZodSchemaConverter {
                     propName = prop.key.value;
                 }
                 else {
-                    console.log(`Skipping property ${index} - unsupported key type`);
+                    logger.debug(`Skipping property ${index} - unsupported key type`);
                     return; // Skip if key is not identifier or string literal
                 }
                 if (t.isCallExpression(prop.value) &&
@@ -1223,7 +1223,7 @@ export class ZodSchemaConverter {
                             schema.description = baseSchema.description;
                     }
                     else {
-                        logger.warn("Could not resolve base schema for extend");
+                        logger.debug("Could not resolve base schema for extend");
                         schema = extendedProps || { type: "object" };
                     }
                 }
@@ -1314,7 +1314,7 @@ export class ZodSchemaConverter {
      * Pre-scan all files to build type mappings
      */
     preScanForTypeMappings() {
-        logger.log("Pre-scanning for type mappings...");
+        logger.debug("Pre-scanning for type mappings...");
         // Scan route files
         const routeFiles = this.findRouteFiles();
         for (const routeFile of routeFiles) {
@@ -1360,7 +1360,7 @@ export class ZodSchemaConverter {
                                 if (t.isTSTypeQuery(param) && t.isIdentifier(param.exprName)) {
                                     const referencedSchemaName = param.exprName.name;
                                     this.typeToSchemaMapping[typeName] = referencedSchemaName;
-                                    logger.log(`Pre-scan: Mapped type '${typeName}' to schema '${referencedSchemaName}'`);
+                                    logger.debug(`Pre-scan: Mapped type '${typeName}' to schema '${referencedSchemaName}'`);
                                 }
                             }
                         }
@@ -1369,7 +1369,7 @@ export class ZodSchemaConverter {
             });
         }
         catch (error) {
-            logger.log(`Error scanning file ${filePath} for type mappings: ${error}`);
+            logger.error(`Error scanning file ${filePath} for type mappings: ${error}`);
         }
     }
     /**
@@ -1413,7 +1413,7 @@ export class ZodSchemaConverter {
                                 // Check if is Zos schema
                                 if (this.isZodSchema(declaration.init) &&
                                     !this.zodSchemas[schemaName]) {
-                                    logger.log(`Pre-processing Zod schema: ${schemaName}`);
+                                    logger.debug(`Pre-processing Zod schema: ${schemaName}`);
                                     this.processingSchemas.add(schemaName);
                                     const schema = this.processZodNode(declaration.init);
                                     if (schema) {
@@ -1433,7 +1433,7 @@ export class ZodSchemaConverter {
                             if (this.isZodSchema(declaration.init) &&
                                 !this.zodSchemas[schemaName] &&
                                 !this.processingSchemas.has(schemaName)) {
-                                logger.log(`Pre-processing Zod schema: ${schemaName}`);
+                                logger.debug(`Pre-processing Zod schema: ${schemaName}`);
                                 this.processingSchemas.add(schemaName);
                                 const schema = this.processZodNode(declaration.init);
                                 if (schema) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-openapi-gen",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "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",