next-openapi-gen 0.6.6 → 0.6.7

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;
@@ -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]);
                 }
@@ -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/package.json

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