next-openapi-gen 0.8.5 → 0.8.7

package/README.md

@@ -842,29 +842,18 @@ Custom schema files support YAML/JSON in OpenAPI 3.0 format. See **[next15-app-m
 
 ## Examples
 
-This repository includes several complete example projects:
+Explore complete demo projects in the **[examples](./examples/)** directory, covering integrations with Zod, TypeScript, Drizzle and documentation tools like Scalar and Swagger.
 
-### 📦 Available Examples
-
-| Example                                                         | Description             | Features                                        |
-| --------------------------------------------------------------- | ----------------------- | ----------------------------------------------- |
-| **[next15-app-zod](./examples/next15-app-zod)**                 | Zod schemas example     | Users, Products, Orders API with Zod validation |
-| **[next15-app-drizzle-zod](./examples/next15-app-drizzle-zod)** | Drizzle-Zod integration | Blog API with Drizzle ORM + drizzle-zod         |
-| **[next15-app-mixed-schemas](./examples/next15-app-mixed-schemas)** 🆕          | Multiple schema types   | Zod + TypeScript + Custom YAML schemas combined |
-| **[next15-app-typescript](./examples/next15-app-typescript)**   | TypeScript types        | API with pure TypeScript type definitions       |
-| **[next15-app-scalar](./examples/next15-app-scalar)**           | Scalar UI               | Modern API documentation interface              |
-| **[next15-app-swagger](./examples/next15-app-swagger)**         | Swagger UI              | Classic Swagger documentation                   |
-
-### 🚀 Running Examples
+### 🚀 Run an Example
 
 ```bash
-cd examples/next15-app-drizzle-zod
+cd examples/next15-app-zod
 npm install
-npm run openapi:generate
+npx next-openapi-gen generate
 npm run dev
 ```
 
-Visit `http://localhost:3000/api-docs` to see the generated documentation.
+Then open `http://localhost:3000/api-docs` to view the generated docs.
 
 ## Available UI providers
 

package/dist/lib/route-processor.js

@@ -25,15 +25,39 @@ export class RouteProcessor {
         // 1. Add success response
         const successCode = dataTypes.successCode || this.getDefaultSuccessCode(method);
         if (dataTypes.responseType) {
-            // Ensure the schema is defined in components/schemas
+            // Handle array notation (e.g., "Type[]", "Type[][]", "Generic<T>[]")
+            let schema;
+            let baseType = dataTypes.responseType;
+            let arrayDepth = 0;
+            // Count and remove array brackets
+            while (baseType.endsWith('[]')) {
+                arrayDepth++;
+                baseType = baseType.slice(0, -2);
+            }
+            // Ensure the base schema is defined in components/schemas
             this.schemaProcessor.getSchemaContent({
-                responseType: dataTypes.responseType,
+                responseType: baseType,
             });
+            // Build schema reference
+            if (arrayDepth === 0) {
+                // Not an array
+                schema = { $ref: `#/components/schemas/${baseType}` };
+            }
+            else {
+                // Build nested array schema
+                schema = { $ref: `#/components/schemas/${baseType}` };
+                for (let i = 0; i < arrayDepth; i++) {
+                    schema = {
+                        type: "array",
+                        items: schema,
+                    };
+                }
+            }
             responses[successCode] = {
                 description: dataTypes.responseDescription || "Successful response",
                 content: {
                     "application/json": {
-                        schema: { $ref: `#/components/schemas/${dataTypes.responseType}` },
+                        schema: schema,
                     },
                 },
             };

package/dist/lib/schema-processor.js

@@ -825,12 +825,25 @@ export class SchemaProcessor {
         };
     }
     getSchemaContent({ tag, paramsType, pathParamsType, bodyType, responseType, }) {
+        // Helper function to strip array notation from type names
+        const stripArrayNotation = (typeName) => {
+            if (!typeName)
+                return typeName;
+            let baseType = typeName;
+            while (baseType.endsWith('[]')) {
+                baseType = baseType.slice(0, -2);
+            }
+            return baseType;
+        };
+        // Strip array notation for schema lookups
+        const baseBodyType = stripArrayNotation(bodyType);
+        const baseResponseType = stripArrayNotation(responseType);
         let params = paramsType ? this.openapiDefinitions[paramsType] : {};
         let pathParams = pathParamsType
             ? this.openapiDefinitions[pathParamsType]
             : {};
-        let body = bodyType ? this.openapiDefinitions[bodyType] : {};
-        let responses = responseType ? this.openapiDefinitions[responseType] : {};
+        let body = baseBodyType ? this.openapiDefinitions[baseBodyType] : {};
+        let responses = baseResponseType ? this.openapiDefinitions[baseResponseType] : {};
         if (paramsType && !params) {
             this.findSchemaDefinition(paramsType, "params");
             params = this.openapiDefinitions[paramsType] || {};
@@ -839,20 +852,20 @@ export class SchemaProcessor {
             this.findSchemaDefinition(pathParamsType, "pathParams");
             pathParams = this.openapiDefinitions[pathParamsType] || {};
         }
-        if (bodyType && !body) {
-            this.findSchemaDefinition(bodyType, "body");
-            body = this.openapiDefinitions[bodyType] || {};
+        if (baseBodyType && !body) {
+            this.findSchemaDefinition(baseBodyType, "body");
+            body = this.openapiDefinitions[baseBodyType] || {};
         }
-        if (responseType && !responses) {
-            this.findSchemaDefinition(responseType, "response");
-            responses = this.openapiDefinitions[responseType] || {};
+        if (baseResponseType && !responses) {
+            this.findSchemaDefinition(baseResponseType, "response");
+            responses = this.openapiDefinitions[baseResponseType] || {};
         }
         if (this.schemaTypes.includes("zod")) {
             const schemasToProcess = [
                 paramsType,
                 pathParamsType,
-                bodyType,
-                responseType,
+                baseBodyType,
+                baseResponseType,
             ].filter(Boolean);
             schemasToProcess.forEach((schemaName) => {
                 if (!this.openapiDefinitions[schemaName]) {

package/dist/lib/utils.js

@@ -159,9 +159,9 @@ export function extractJSDocComments(path) {
     };
 }
 export function extractTypeFromComment(commentValue, tag) {
-    // Updated regex to support generic types with angle brackets
+    // Updated regex to support generic types with angle brackets and array brackets
     return (commentValue
-        .match(new RegExp(`${tag}\\s*\\s*([\\w<>,\\s]+)`))?.[1]
+        .match(new RegExp(`${tag}\\s*\\s*([\\w<>,\\s\\[\\]]+)`))?.[1]
         ?.trim() || "");
 }
 export function cleanComment(commentValue) {

package/dist/lib/zod-converter.js

@@ -700,6 +700,16 @@ export class ZodSchemaConverter {
             }
             logger.debug(`[processZodNode] Could not expand factory function '${node.callee.name}' - missing context or not a factory`);
         }
+        // Handle standalone identifier references (e.g., userSchema used directly)
+        if (t.isIdentifier(node)) {
+            const schemaName = node.name;
+            // Try to find and process the referenced schema
+            if (!this.zodSchemas[schemaName]) {
+                this.convertZodSchemaToOpenApi(schemaName);
+            }
+            // Return a reference to the schema
+            return { $ref: `#/components/schemas/${schemaName}` };
+        }
         logger.debug("Unknown Zod schema node:", node);
         return { type: "object" };
     }
@@ -932,6 +942,7 @@ export class ZodSchemaConverter {
                         $ref: `#/components/schemas/${referencedSchemaName}`,
                     };
                     required.push(propName); // Assuming it's required unless marked optional
+                    return; // Skip further processing for this property
                 }
                 // For array of schemas (like z.array(PaymentMethodSchema))
                 if (t.isCallExpression(prop.value) &&
@@ -957,6 +968,7 @@ export class ZodSchemaConverter {
                     if (!isOptional) {
                         required.push(propName);
                     }
+                    return; // Skip further processing for this property
                 }
                 // Process property value (a Zod schema)
                 const propSchema = this.processZodNode(prop.value);

package/package.json

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