ts-typed-api 0.1.21 → 0.1.22

package/dist/openapi-self.js

@@ -166,10 +166,47 @@ class SchemaRegistry {
                 };
             }
             if (zodSchema instanceof zod_1.ZodArray) {
-                const itemType = getZodType(zodSchema);
+                // Try multiple ways to get the array item type
+                let itemType;
+                // Method 1: Try _def.element (this is the correct property for ZodArray)
+                try {
+                    const def = getZodDef(zodSchema);
+                    if (def && def.element && typeof def.element === 'object' && def.element.constructor) {
+                        itemType = def.element;
+                    }
+                }
+                catch (error) {
+                    // Continue to next method
+                }
+                // Method 2: Try getZodType if method 1 failed
+                if (!itemType) {
+                    const typeResult = getZodType(zodSchema);
+                    if (typeResult && typeof typeResult === 'object' && typeResult.constructor) {
+                        itemType = typeResult;
+                    }
+                }
+                // Method 3: Direct access to _def.element as fallback
+                if (!itemType) {
+                    try {
+                        const directElement = zodSchema._def?.element;
+                        if (directElement && typeof directElement === 'object' && directElement.constructor) {
+                            itemType = directElement;
+                        }
+                    }
+                    catch (error) {
+                        // Continue to fallback
+                    }
+                }
+                if (itemType) {
+                    return {
+                        type: 'array',
+                        items: this.zodToOpenAPI(itemType, shouldRegister)
+                    };
+                }
+                // Ultimate fallback
                 return {
                     type: 'array',
-                    items: itemType ? this.zodToOpenAPI(itemType, shouldRegister) : { type: 'string' }
+                    items: { type: 'string' }
                 };
             }
             if (zodSchema instanceof zod_1.ZodObject) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-typed-api",
-  "version": "0.1.21",
+  "version": "0.1.22",
   "description": "A lightweight, type-safe RPC library for TypeScript with Zod validation",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/openapi-self.ts

@@ -270,10 +270,50 @@ class SchemaRegistry {
             }
 
             if (zodSchema instanceof ZodArray) {
-                const itemType = getZodType(zodSchema);
+                // Try multiple ways to get the array item type
+                let itemType: ZodTypeAny | undefined;
+
+                // Method 1: Try _def.element (this is the correct property for ZodArray)
+                try {
+                    const def = getZodDef(zodSchema);
+                    if (def && def.element && typeof def.element === 'object' && def.element.constructor) {
+                        itemType = def.element;
+                    }
+                } catch (error) {
+                    // Continue to next method
+                }
+
+                // Method 2: Try getZodType if method 1 failed
+                if (!itemType) {
+                    const typeResult = getZodType(zodSchema);
+                    if (typeResult && typeof typeResult === 'object' && typeResult.constructor) {
+                        itemType = typeResult;
+                    }
+                }
+
+                // Method 3: Direct access to _def.element as fallback
+                if (!itemType) {
+                    try {
+                        const directElement = (zodSchema as any)._def?.element;
+                        if (directElement && typeof directElement === 'object' && directElement.constructor) {
+                            itemType = directElement;
+                        }
+                    } catch (error) {
+                        // Continue to fallback
+                    }
+                }
+
+                if (itemType) {
+                    return {
+                        type: 'array',
+                        items: this.zodToOpenAPI(itemType, shouldRegister)
+                    };
+                }
+
+                // Ultimate fallback
                 return {
                     type: 'array',
-                    items: itemType ? this.zodToOpenAPI(itemType, shouldRegister) : { type: 'string' }
+                    items: { type: 'string' }
                 };
             }
 

package/tests/openapi-spec.test.ts

@@ -186,4 +186,134 @@ describe('OpenAPI Specification Generation', () => {
         // The enum should either have values or be a basic string type (no empty enum arrays)
         expect(resultProperty.enum.length).toBeGreaterThan(0);
     });
+
+    test('should handle nested object arrays correctly', () => {
+        // Test case for nested object array structure
+        const s1 = z.object({
+            version: z.number(),
+        });
+
+        const s2 = z.object({
+            versions: z.array(s1),
+        });
+
+        const NestedArrayTestDefinition = CreateApiDefinition({
+            endpoints: {
+                test: {
+                    nestedArrayEndpoint: {
+                        method: 'POST' as const,
+                        path: '/test/nested-array',
+                        body: s2,
+                        responses: {
+                            200: z.object({
+                                data: s2,
+                                success: z.boolean()
+                            })
+                        }
+                    }
+                }
+            }
+        });
+
+        const spec = generateOpenApiSpec(NestedArrayTestDefinition);
+
+        expect(spec).toBeDefined();
+        expect(spec.paths).toBeDefined();
+        expect(spec.components?.schemas).toBeDefined();
+
+        const nestedArrayEndpoint = spec.paths['/test/nested-array'];
+        expect(nestedArrayEndpoint).toBeDefined();
+        expect(nestedArrayEndpoint.post).toBeDefined();
+
+        // Check request body schema
+        const requestBodySchema = nestedArrayEndpoint.post?.requestBody?.content?.['application/json']?.schema;
+        expect(requestBodySchema).toBeDefined();
+
+        // The schema should be a reference to components
+        expect(requestBodySchema?.$ref).toBeDefined();
+        const schemaName = requestBodySchema?.$ref?.split('/').pop();
+        const actualSchema = spec.components?.schemas?.[schemaName!];
+        expect(actualSchema).toBeDefined();
+
+        expect(actualSchema?.type).toBe('object');
+        expect(actualSchema?.properties).toBeDefined();
+
+        // Verify the versions property is an array
+        const versionsProperty = actualSchema?.properties?.versions;
+        expect(versionsProperty).toBeDefined();
+        expect(versionsProperty?.type).toBe('array');
+        expect(versionsProperty?.items).toBeDefined();
+
+        // The array items should properly reference the nested object schema (s1)
+        const arrayItemsSchema = versionsProperty?.items;
+        if (arrayItemsSchema?.$ref) {
+            // If it's a reference, resolve it and check the object structure
+            const itemSchemaName = arrayItemsSchema.$ref.split('/').pop();
+            const itemSchema = spec.components?.schemas?.[itemSchemaName!];
+            expect(itemSchema).toBeDefined();
+            expect(itemSchema?.type).toBe('object');
+            expect(itemSchema?.properties?.version).toBeDefined();
+            expect(itemSchema?.properties?.version?.type).toBe('number');
+        } else {
+            // If it's inline, it should be an object with version property
+            expect(arrayItemsSchema?.type).toBe('object');
+            expect(arrayItemsSchema?.properties?.version).toBeDefined();
+            expect(arrayItemsSchema?.properties?.version?.type).toBe('number');
+        }
+
+        // Check response schema structure
+        const responseSchema = nestedArrayEndpoint.post?.responses?.['200']?.content?.['application/json']?.schema;
+        expect(responseSchema).toBeDefined();
+
+        expect(responseSchema?.$ref).toBeDefined();
+        const responseSchemaName = responseSchema?.$ref?.split('/').pop();
+        const actualResponseSchema = spec.components?.schemas?.[responseSchemaName!];
+        expect(actualResponseSchema).toBeDefined();
+
+        expect(actualResponseSchema?.type).toBe('object');
+        expect(actualResponseSchema?.properties).toBeDefined();
+        expect(actualResponseSchema?.properties?.data).toBeDefined();
+        expect(actualResponseSchema?.properties?.success).toBeDefined();
+        expect(actualResponseSchema?.properties?.success?.type).toBe('boolean');
+
+        // Verify that the nested data property has the correct structure
+        const dataProperty = actualResponseSchema?.properties?.data;
+        if (dataProperty?.$ref) {
+            // If data is a reference, resolve it
+            const dataSchemaName = dataProperty.$ref.split('/').pop();
+            const dataSchema = spec.components?.schemas?.[dataSchemaName!];
+            expect(dataSchema).toBeDefined();
+            expect(dataSchema?.type).toBe('object');
+            expect(dataSchema?.properties?.versions).toBeDefined();
+            expect(dataSchema?.properties?.versions?.type).toBe('array');
+
+            // The versions array items should be objects with version property
+            const dataVersionsItems = dataSchema?.properties?.versions?.items;
+            if (dataVersionsItems?.$ref) {
+                const dataItemSchemaName = dataVersionsItems.$ref.split('/').pop();
+                const dataItemSchema = spec.components?.schemas?.[dataItemSchemaName!];
+                expect(dataItemSchema?.type).toBe('object');
+                expect(dataItemSchema?.properties?.version?.type).toBe('number');
+            } else {
+                expect(dataVersionsItems?.type).toBe('object');
+                expect(dataVersionsItems?.properties?.version?.type).toBe('number');
+            }
+        } else {
+            // If data is inline
+            expect(dataProperty?.type).toBe('object');
+            expect(dataProperty?.properties?.versions).toBeDefined();
+            expect(dataProperty?.properties?.versions?.type).toBe('array');
+
+            const dataVersionsItems = dataProperty?.properties?.versions?.items;
+            if (dataVersionsItems?.$ref) {
+                const dataItemSchemaName = dataVersionsItems.$ref.split('/').pop();
+                const dataItemSchema = spec.components?.schemas?.[dataItemSchemaName!];
+                expect(dataItemSchema?.type).toBe('object');
+                expect(dataItemSchema?.properties?.version?.type).toBe('number');
+            } else {
+                expect(dataVersionsItems?.type).toBe('object');
+                expect(dataVersionsItems?.properties?.version?.type).toBe('number');
+            }
+        }
+    });
 });