ts-typed-api 0.1.14 → 0.1.15

package/dist/openapi.js

@@ -98,7 +98,7 @@ function generateOpenApiSpec(definitions, options = {}) {
                 };
                 // Register the route with the registry
                 // The path needs to be transformed from Express-style (:param) to OpenAPI-style ({param})
-                const openApiPath = route.path.replace(/:(\w+)/g, '{$1}');
+                const openApiPath = `/${definition.prefix ?? ''}${route.path}`.replace(/\/+/g, '/').replace(/:(\w+)/g, '{$1}');
                 registry.registerPath({
                     method: route.method.toLowerCase(), // Ensure method is lowercase
                     path: openApiPath,

package/package.json

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

package/src/openapi.ts

@@ -116,7 +116,7 @@ export function generateOpenApiSpec(
 
                 // Register the route with the registry
                 // The path needs to be transformed from Express-style (:param) to OpenAPI-style ({param})
-                const openApiPath = route.path.replace(/:(\w+)/g, '{$1}');
+                const openApiPath = `/${definition.prefix ?? ''}${route.path}`.replace(/\/+/g, '/').replace(/:(\w+)/g, '{$1}');
 
                 registry.registerPath({
                     method: route.method.toLowerCase() as any, // Ensure method is lowercase

package/tests/openapi-spec.test.ts

@@ -0,0 +1,86 @@
+import { describe, test, expect } from '@jest/globals';
+import { generateOpenApiSpec } from '../src/openapi';
+import { PublicApiDefinition } from '../examples/simple/definitions';
+import { PrivateApiDefinition } from '../examples/simple/definitions';
+import { z } from 'zod';
+import { CreateApiDefinition } from '../src/definition';
+
+describe('OpenAPI Specification Generation', () => {
+    test('should generate OpenAPI spec for a single definition', () => {
+        const spec = generateOpenApiSpec(PublicApiDefinition);
+
+        expect(spec).toBeDefined();
+        expect(spec.openapi).toBe('3.0.0');
+        expect(spec.info).toBeDefined();
+        expect(spec.paths).toBeDefined();
+    });
+
+    test('should generate OpenAPI spec for multiple definitions', () => {
+        const spec = generateOpenApiSpec([PublicApiDefinition, PrivateApiDefinition]);
+
+        expect(spec).toBeDefined();
+        expect(spec.openapi).toBe('3.0.0');
+        expect(spec.info).toBeDefined();
+        expect(spec.paths).toBeDefined();
+
+        // Verify paths from both definitions are included
+        const publicPaths = Object.keys(spec.paths ?? {}).filter(path =>
+            path.includes('/public/')
+        );
+        const privatePaths = Object.keys(spec.paths ?? {}).filter(path =>
+            path.includes('/private/')
+        );
+
+        expect(publicPaths.length).toBeGreaterThan(0);
+        expect(privatePaths.length).toBeGreaterThan(0);
+    });
+
+    test('should handle custom OpenAPI spec options', () => {
+        const spec = generateOpenApiSpec(PublicApiDefinition, {
+            info: {
+                title: 'Test API',
+                version: '2.0.0',
+                description: 'A test API description'
+            },
+            servers: [{ url: 'https://api.example.com', description: 'Production server' }]
+        });
+
+        expect(spec.info.title).toBe('Test API');
+        expect(spec.info.version).toBe('2.0.0');
+        expect(spec.info.description).toBe('A test API description');
+        expect(spec.servers?.[0]?.url).toBe('https://api.example.com');
+    });
+
+    test('should handle complex Zod schemas', () => {
+        // Create a complex Zod schema to test schema registration
+        const ComplexSchema = z.object({
+            id: z.string().uuid(),
+            name: z.string().min(3).max(50),
+            age: z.number().int().positive(),
+            metadata: z.record(z.string(), z.unknown()).optional(),
+            tags: z.array(z.string()).optional()
+        });
+
+        const TestDefinition = CreateApiDefinition({
+            endpoints: {
+                test: {
+                    complexEndpoint: {
+                        method: 'POST' as const,
+                        path: '/test/complex',
+                        body: ComplexSchema,
+                        responses: {
+                            200: ComplexSchema,
+                            422: z.object({ error: z.string() })
+                        }
+                    }
+                }
+            }
+        });
+
+        const spec = generateOpenApiSpec(TestDefinition);
+
+        expect(spec).toBeDefined();
+        expect(spec.components).toBeDefined();
+        expect(spec.components?.schemas).toBeDefined();
+    });
+});