next-openapi-gen 0.8.8 → 0.8.9

package/README.md

@@ -784,6 +784,51 @@ Factory functions work with any naming convention and support:
 - Imported schemas
 - Multiple factory patterns in the same project
 
+### Schema Composition with `.extend()`
+
+Zod's `.extend()` method allows you to build upon existing schemas:
+
+```typescript
+// src/schemas/user.ts
+
+// Base user schema
+export const BaseUserSchema = z.object({
+  id: z.string().uuid().describe("User ID"),
+  email: z.string().email().describe("Email address"),
+});
+
+// Extend with additional fields
+export const UserProfileSchema = BaseUserSchema.extend({
+  name: z.string().describe("Full name"),
+  bio: z.string().optional().describe("User biography"),
+});
+
+// Multiple levels of extension
+export const AdminUserSchema = UserProfileSchema.extend({
+  role: z.enum(["admin", "moderator"]).describe("Admin role"),
+  permissions: z.array(z.string()).describe("Permission list"),
+});
+
+export const UserIdParams = z.object({
+  id: z.string().uuid().describe("User ID"),
+});
+
+// src/app/api/users/[id]/route.ts
+
+/**
+ * Get user profile
+ * @pathParams UserIdParams
+ * @response UserProfileSchema
+ * @openapi
+ */
+export async function GET(
+  request: NextRequest,
+  { params }: { params: { id: string } }
+) {
+  // Returns: { id, email, name, bio? }
+}
+```
+
 ### Drizzle-Zod Support
 
 The library fully supports **drizzle-zod** for generating Zod schemas from Drizzle ORM table definitions. This provides a single source of truth for your database schema, validation, and API documentation.

package/dist/lib/zod-converter.js

@@ -400,6 +400,54 @@ export class ZodSchemaConverter {
                                         });
                                     }
                                     break;
+                                case "extend":
+                                    // Extend the schema with new properties
+                                    if (node.arguments.length > 0 &&
+                                        t.isObjectExpression(node.arguments[0])) {
+                                        const extensionProperties = {};
+                                        const extensionRequired = [];
+                                        node.arguments[0].properties.forEach((prop) => {
+                                            if (t.isObjectProperty(prop)) {
+                                                const key = t.isIdentifier(prop.key)
+                                                    ? prop.key.name
+                                                    : t.isStringLiteral(prop.key)
+                                                        ? prop.key.value
+                                                        : null;
+                                                if (key) {
+                                                    // Process the Zod type for this property
+                                                    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;
+                                                        if (!isOptional) {
+                                                            extensionRequired.push(key);
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        });
+                                        // Merge with existing schema
+                                        if (schema.properties) {
+                                            schema.properties = {
+                                                ...schema.properties,
+                                                ...extensionProperties,
+                                            };
+                                        }
+                                        else {
+                                            schema.properties = extensionProperties;
+                                        }
+                                        // Merge required arrays
+                                        if (extensionRequired.length > 0) {
+                                            schema.required = [
+                                                ...(schema.required || []),
+                                                ...extensionRequired,
+                                            ];
+                                            // Deduplicate
+                                            schema.required = [...new Set(schema.required)];
+                                        }
+                                    }
+                                    break;
                             }
                             return schema;
                         };
@@ -989,8 +1037,9 @@ export class ZodSchemaConverter {
             properties,
         };
         if (required.length > 0) {
+            // Deduplicate required array using Set
             // @ts-ignore
-            schema.required = required;
+            schema.required = [...new Set(required)];
         }
         return schema;
     }
@@ -1371,7 +1420,24 @@ export class ZodSchemaConverter {
                 if (node.arguments.length > 0 &&
                     t.isObjectExpression(node.arguments[0])) {
                     // Get the base schema by processing the object that extend is called on
-                    const baseSchema = this.processZodNode(node.callee.object);
+                    const baseSchemaResult = this.processZodNode(node.callee.object);
+                    // If it's a reference, resolve it to the actual schema
+                    let baseSchema = baseSchemaResult;
+                    if (baseSchemaResult && baseSchemaResult.$ref) {
+                        const schemaName = baseSchemaResult.$ref.replace("#/components/schemas/", "");
+                        // Try to convert the base schema if not already processed
+                        if (!this.zodSchemas[schemaName]) {
+                            logger.debug(`[extend] Base schema ${schemaName} not found, attempting to convert it`);
+                            this.convertZodSchemaToOpenApi(schemaName);
+                        }
+                        // Now retrieve the converted schema
+                        if (this.zodSchemas[schemaName]) {
+                            baseSchema = this.zodSchemas[schemaName];
+                        }
+                        else {
+                            logger.debug(`Could not resolve reference for extend: ${schemaName}`);
+                        }
+                    }
                     // Process the extension object
                     const extendNode = {
                         type: "CallExpression",

package/package.json

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