lambder 1.0.128 → 1.0.129

package/tests/type-safety.test.ts

@@ -197,6 +197,318 @@ describe('Complex Types', () => {
     });
 });
 
+// ============================================================================
+// Test 6: Output Type Enforcement
+// ============================================================================
+
+describe('Output Type Enforcement', () => {
+    it('should enforce output types in resolver.api()', () => {
+        const lambder = new Lambder<TestApiContract>({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        // ✅ CORRECT: Return correct output type
+        lambder.addApi('getUser', async (ctx, resolver) => {
+            const userId = ctx.apiPayload.userId;
+            return resolver.api({ id: userId, name: 'John Doe' });
+        });
+
+        // ✅ CORRECT: Return null is allowed
+        lambder.addApi('getUser', async (ctx, resolver) => {
+            return resolver.api(null);
+        });
+
+        // ✅ CORRECT: Boolean output
+        lambder.addApi('deleteUser', async (ctx, resolver) => {
+            return resolver.api(true);
+        });
+
+        // ✅ CORRECT: Array output
+        lambder.addApi('listUsers', async (ctx, resolver) => {
+            return resolver.api([
+                { id: '1', name: 'User 1' },
+                { id: '2', name: 'User 2' }
+            ]);
+        });
+
+        // ✅ CORRECT: Empty array
+        lambder.addApi('listUsers', async (ctx, resolver) => {
+            return resolver.api([]);
+        });
+
+        expect(lambder).toBeDefined();
+
+        // ❌ These would cause TypeScript errors (commented out):
+        
+        // Wrong output type:
+        // lambder.addApi('getUser', async (ctx, resolver) => {
+        //     return resolver.api("wrong"); // Error: string not assignable to { id: string, name: string }
+        // });
+        
+        // Missing required property:
+        // lambder.addApi('getUser', async (ctx, resolver) => {
+        //     return resolver.api({ id: '123' }); // Error: missing 'name' property
+        // });
+        
+        // Wrong property type:
+        // lambder.addApi('getUser', async (ctx, resolver) => {
+        //     return resolver.api({ id: 123, name: 'Test' }); // Error: id should be string
+        // });
+        
+        // Wrong boolean output:
+        // lambder.addApi('deleteUser', async (ctx, resolver) => {
+        //     return resolver.api("true"); // Error: string not assignable to boolean
+        // });
+        
+        // Wrong array element type:
+        // lambder.addApi('listUsers', async (ctx, resolver) => {
+        //     return resolver.api([{ id: '1' }]); // Error: missing 'name' property
+        // });
+    });
+
+    it('should enforce output types in resolver.die.api()', () => {
+        const lambder = new Lambder<TestApiContract>({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        // ✅ CORRECT: die.api also enforces types
+        lambder.addApi('getUser', async (ctx, resolver) => {
+            return resolver.die.api({ id: ctx.apiPayload.userId, name: 'Test' });
+        });
+
+        // ✅ CORRECT: die.api with null
+        lambder.addApi('deleteUser', async (ctx, resolver) => {
+            return resolver.die.api(true);
+        });
+
+        expect(lambder).toBeDefined();
+
+        // ❌ These would cause TypeScript errors (commented out):
+        // lambder.addApi('getUser', async (ctx, resolver) => {
+        //     return resolver.die.api("wrong"); // Error: wrong type
+        // });
+    });
+
+    it('should enforce output types in addSessionApi()', () => {
+        const lambder = new Lambder<TestApiContract>({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        // ✅ CORRECT: Session APIs also enforce output types
+        lambder.addSessionApi('createUser', async (ctx, resolver) => {
+            const { name, email } = ctx.apiPayload;
+            return resolver.api({ id: '1', name, email });
+        });
+
+        // ✅ CORRECT: Session API with null
+        lambder.addSessionApi('deleteUser', async (ctx, resolver) => {
+            return resolver.api(true);
+        });
+
+        expect(lambder).toBeDefined();
+
+        // ❌ These would cause TypeScript errors (commented out):
+        // lambder.addSessionApi('createUser', async (ctx, resolver) => {
+        //     return resolver.api({ id: '1' }); // Error: missing name and email
+        // });
+    });
+});
+
+// ============================================================================
+// Test 7: Complex Output Types
+// ============================================================================
+
+type ComplexOutputContract = ApiContract<{
+    // Primitive outputs
+    getCount: { input: void, output: number },
+    getMessage: { input: void, output: string },
+    isActive: { input: void, output: boolean },
+    
+    // Nested objects
+    getStats: { 
+        input: void, 
+        output: { 
+            users: { total: number, active: number },
+            products: { total: number, inStock: number }
+        } 
+    },
+    
+    // Union types
+    findUser: { 
+        input: { email: string }, 
+        output: { id: string, name: string } | null 
+    },
+    
+    // Array of complex objects
+    getOrders: { 
+        input: { userId: string }, 
+        output: Array<{ 
+            id: string, 
+            items: Array<{ name: string, price: number }>,
+            total: number 
+        }> 
+    }
+}>;
+
+describe('Complex Output Types', () => {
+    it('should enforce primitive output types', () => {
+        const lambder = new Lambder<ComplexOutputContract>({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        // ✅ CORRECT: Primitive outputs
+        lambder.addApi('getCount', async (ctx, resolver) => {
+            return resolver.api(42);
+        });
+
+        lambder.addApi('getMessage', async (ctx, resolver) => {
+            return resolver.api("Hello World");
+        });
+
+        lambder.addApi('isActive', async (ctx, resolver) => {
+            return resolver.api(true);
+        });
+
+        expect(lambder).toBeDefined();
+
+        // ❌ These would cause TypeScript errors (commented out):
+        // lambder.addApi('getCount', async (ctx, resolver) => {
+        //     return resolver.api("42"); // Error: string not assignable to number
+        // });
+    });
+
+    it('should enforce nested object types', () => {
+        const lambder = new Lambder<ComplexOutputContract>({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        // ✅ CORRECT: Nested structure
+        lambder.addApi('getStats', async (ctx, resolver) => {
+            return resolver.api({
+                users: { total: 100, active: 75 },
+                products: { total: 50, inStock: 40 }
+            });
+        });
+
+        expect(lambder).toBeDefined();
+
+        // ❌ These would cause TypeScript errors (commented out):
+        // lambder.addApi('getStats', async (ctx, resolver) => {
+        //     return resolver.api({
+        //         users: { total: 100 } // Error: missing 'active'
+        //     });
+        // });
+    });
+
+    it('should enforce union types correctly', () => {
+        const lambder = new Lambder<ComplexOutputContract>({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        // ✅ CORRECT: Return object
+        lambder.addApi('findUser', async (ctx, resolver) => {
+            return resolver.api({ id: '123', name: 'John' });
+        });
+
+        // ✅ CORRECT: Return null (part of union)
+        lambder.addApi('findUser', async (ctx, resolver) => {
+            return resolver.api(null);
+        });
+
+        expect(lambder).toBeDefined();
+
+        // ❌ These would cause TypeScript errors (commented out):
+        // lambder.addApi('findUser', async (ctx, resolver) => {
+        //     return resolver.api(undefined); // Error: undefined not in union
+        // });
+    });
+
+    it('should enforce complex nested array types', () => {
+        const lambder = new Lambder<ComplexOutputContract>({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        // ✅ CORRECT: Complex nested array
+        lambder.addApi('getOrders', async (ctx, resolver) => {
+            return resolver.api([
+                {
+                    id: '1',
+                    items: [
+                        { name: 'Item 1', price: 10 },
+                        { name: 'Item 2', price: 20 }
+                    ],
+                    total: 30
+                }
+            ]);
+        });
+
+        expect(lambder).toBeDefined();
+
+        // ❌ These would cause TypeScript errors (commented out):
+        // lambder.addApi('getOrders', async (ctx, resolver) => {
+        //     return resolver.api([
+        //         {
+        //             id: '1',
+        //             items: [{ name: 'Item 1' }], // Error: missing 'price'
+        //             total: 30
+        //         }
+        //     ]);
+        // });
+    });
+});
+
+// ============================================================================
+// Test 8: Type Inference
+// ============================================================================
+
+describe('Type Inference', () => {
+    it('should infer types correctly from contract', () => {
+        const lambder = new Lambder<TestApiContract>({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        // Test that TypeScript correctly infers the types
+        lambder.addApi('getUser', async (ctx, resolver) => {
+            // ctx.apiPayload type should be inferred as { userId: string }
+            const userId: string = ctx.apiPayload.userId;
+            
+            // Variable with explicit type matching contract
+            const user: { id: string, name: string } = {
+                id: userId,
+                name: 'Test User'
+            };
+            
+            // Should accept the correctly typed variable
+            return resolver.api(user);
+        });
+
+        lambder.addApi('createUser', async (ctx, resolver) => {
+            // Input type inference
+            const name: string = ctx.apiPayload.name;
+            const email: string = ctx.apiPayload.email;
+            
+            // Output type inference
+            const result: { id: string, name: string, email: string } = {
+                id: '123',
+                name,
+                email
+            };
+            
+            return resolver.api(result);
+        });
+
+        expect(lambder).toBeDefined();
+    });
+});
+
 // ============================================================================
 // If this file compiles without errors, the type system is working! ✅
 // ============================================================================