lambder 1.0.128 → 1.0.130

package/tests/output-type-runtime.test.ts

@@ -0,0 +1,365 @@
+/**
+ * Output Type Enforcement Runtime Tests
+ * 
+ * These tests verify that the typed APIs work correctly at runtime
+ * while maintaining type safety at compile time.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { APIGatewayProxyEvent, Context } from 'aws-lambda';
+import Lambder from '../src/Lambder.js';
+import type { ApiContract } from '../src/index.js';
+
+// Mock AWS Lambda event and context
+const createMockEvent = (apiName: string, payload: any): APIGatewayProxyEvent => ({
+    body: JSON.stringify({ apiName, payload }),
+    headers: { Host: 'localhost' },
+    multiValueHeaders: {},
+    httpMethod: 'POST',
+    isBase64Encoded: false,
+    path: '/api',
+    pathParameters: null,
+    queryStringParameters: null,
+    multiValueQueryStringParameters: null,
+    stageVariables: null,
+    requestContext: {} as any,
+    resource: '',
+});
+
+const createMockContext = (): Context => ({
+    callbackWaitsForEmptyEventLoop: false,
+    functionName: 'test',
+    functionVersion: '1',
+    invokedFunctionArn: 'arn',
+    memoryLimitInMB: '128',
+    awsRequestId: '123',
+    logGroupName: 'group',
+    logStreamName: 'stream',
+    getRemainingTimeInMillis: () => 1000,
+    done: () => {},
+    fail: () => {},
+    succeed: () => {},
+});
+
+// Test contract
+type TestContract = ApiContract<{
+    echo: { input: { message: string }, output: { echo: string } },
+    add: { input: { a: number, b: number }, output: number },
+    getUser: { input: { userId: string }, output: { id: string, name: string, age: number } },
+    listUsers: { input: void, output: Array<{ id: string, name: string }> },
+    findUser: { input: { email: string }, output: { id: string, name: string } | null },
+    deleteUser: { input: { userId: string }, output: boolean },
+}>;
+
+// ============================================================================
+// Runtime Tests
+// ============================================================================
+
+describe('Output Type Enforcement - Runtime', () => {
+    it('should return correct primitive types', async () => {
+        const lambder = new Lambder<TestContract>({
+            publicPath: './public',
+            apiPath: '/api',
+        });
+
+        lambder.addApi('add', async (ctx, resolver) => {
+            const { a, b } = ctx.apiPayload;
+            const sum = a + b;
+            return resolver.api(sum);
+        });
+
+        const event = createMockEvent('add', { a: 5, b: 3 });
+        const context = createMockContext();
+        const response = await lambder.render(event, context);
+
+        expect(response.statusCode).toBe(200);
+        const body = JSON.parse(response.body || '{}');
+        expect(body.payload).toBe(8);
+    });
+
+    it('should return correct object types', async () => {
+        const lambder = new Lambder<TestContract>({
+            publicPath: './public',
+            apiPath: '/api',
+        });
+
+        lambder.addApi('getUser', async (ctx, resolver) => {
+            const userId = ctx.apiPayload.userId;
+            return resolver.api({
+                id: userId,
+                name: 'John Doe',
+                age: 30
+            });
+        });
+
+        const event = createMockEvent('getUser', { userId: '123' });
+        const context = createMockContext();
+        const response = await lambder.render(event, context);
+
+        expect(response.statusCode).toBe(200);
+        const body = JSON.parse(response.body || '{}');
+        expect(body.payload).toEqual({
+            id: '123',
+            name: 'John Doe',
+            age: 30
+        });
+    });
+
+    it('should return correct array types', async () => {
+        const lambder = new Lambder<TestContract>({
+            publicPath: './public',
+            apiPath: '/api',
+        });
+
+        lambder.addApi('listUsers', async (ctx, resolver) => {
+            return resolver.api([
+                { id: '1', name: 'Alice' },
+                { id: '2', name: 'Bob' }
+            ]);
+        });
+
+        const event = createMockEvent('listUsers', undefined);
+        const context = createMockContext();
+        const response = await lambder.render(event, context);
+
+        expect(response.statusCode).toBe(200);
+        const body = JSON.parse(response.body || '{}');
+        expect(body.payload).toEqual([
+            { id: '1', name: 'Alice' },
+            { id: '2', name: 'Bob' }
+        ]);
+    });
+
+    it('should handle null returns correctly', async () => {
+        const lambder = new Lambder<TestContract>({
+            publicPath: './public',
+            apiPath: '/api',
+        });
+
+        lambder.addApi('findUser', async (ctx, resolver) => {
+            const email = ctx.apiPayload.email;
+            if (email === 'notfound@example.com') {
+                return resolver.api(null);
+            }
+            return resolver.api({ id: '1', name: 'Found User' });
+        });
+
+        // Test null case
+        const event1 = createMockEvent('findUser', { email: 'notfound@example.com' });
+        const context1 = createMockContext();
+        const response1 = await lambder.render(event1, context1);
+
+        expect(response1.statusCode).toBe(200);
+        const body1 = JSON.parse(response1.body || '{}');
+        expect(body1.payload).toBeNull();
+
+        // Test found case
+        const event2 = createMockEvent('findUser', { email: 'found@example.com' });
+        const context2 = createMockContext();
+        const response2 = await lambder.render(event2, context2);
+
+        expect(response2.statusCode).toBe(200);
+        const body2 = JSON.parse(response2.body || '{}');
+        expect(body2.payload).toEqual({ id: '1', name: 'Found User' });
+    });
+
+    it('should return boolean types correctly', async () => {
+        const lambder = new Lambder<TestContract>({
+            publicPath: './public',
+            apiPath: '/api',
+        });
+
+        lambder.addApi('deleteUser', async (ctx, resolver) => {
+            const userId = ctx.apiPayload.userId;
+            // Mock deletion
+            const success = userId !== '';
+            return resolver.api(success);
+        });
+
+        const event = createMockEvent('deleteUser', { userId: '123' });
+        const context = createMockContext();
+        const response = await lambder.render(event, context);
+
+        expect(response.statusCode).toBe(200);
+        const body = JSON.parse(response.body || '{}');
+        expect(body.payload).toBe(true);
+    });
+
+    it('should work with die.api()', async () => {
+        const lambder = new Lambder<TestContract>({
+            publicPath: './public',
+            apiPath: '/api',
+        });
+
+        lambder.addApi('echo', async (ctx, resolver) => {
+            return resolver.die.api({ echo: ctx.apiPayload.message });
+        });
+
+        const event = createMockEvent('echo', { message: 'Hello!' });
+        const context = createMockContext();
+        const response = await lambder.render(event, context);
+
+        expect(response.statusCode).toBe(200);
+        const body = JSON.parse(response.body || '{}');
+        expect(body.payload).toEqual({ echo: 'Hello!' });
+    });
+
+    it('should work with session APIs', async () => {
+        const lambder = new Lambder<TestContract>({
+            publicPath: './public',
+            apiPath: '/api',
+        });
+
+        // Note: Session will fail without DynamoDB setup, but we're testing type enforcement
+        lambder.addSessionApi('getUser', async (ctx, resolver) => {
+            return resolver.api({
+                id: ctx.apiPayload.userId,
+                name: 'Session User',
+                age: 25
+            });
+        });
+
+        // This will return 500 error because session is not configured
+        const event = createMockEvent('getUser', { userId: '123' });
+        const context = createMockContext();
+        
+        const response = await lambder.render(event, context);
+        
+        // Should return 500 error when session is not configured
+        expect(response.statusCode).toBe(500);
+        expect(response.body).toBe('Internal Server Error.');
+    });
+});
+
+// ============================================================================
+// Input Type Tests
+// ============================================================================
+
+describe('Input Type Enforcement - Runtime', () => {
+    it('should receive correctly typed input', async () => {
+        const lambder = new Lambder<TestContract>({
+            publicPath: './public',
+            apiPath: '/api',
+        });
+
+        lambder.addApi('echo', async (ctx, resolver) => {
+            // Verify input is correctly typed at runtime
+            const message: string = ctx.apiPayload.message;
+            expect(typeof message).toBe('string');
+            return resolver.api({ echo: message });
+        });
+
+        const event = createMockEvent('echo', { message: 'Test Message' });
+        const context = createMockContext();
+        await lambder.render(event, context);
+    });
+
+    it('should handle void input correctly', async () => {
+        const lambder = new Lambder<TestContract>({
+            publicPath: './public',
+            apiPath: '/api',
+        });
+
+        lambder.addApi('listUsers', async (ctx, resolver) => {
+            // apiPayload should be undefined for void input
+            expect(ctx.apiPayload).toBeUndefined();
+            return resolver.api([]);
+        });
+
+        const event = createMockEvent('listUsers', undefined);
+        const context = createMockContext();
+        await lambder.render(event, context);
+    });
+
+    it('should handle complex input objects', async () => {
+        const lambder = new Lambder<TestContract>({
+            publicPath: './public',
+            apiPath: '/api',
+        });
+
+        lambder.addApi('add', async (ctx, resolver) => {
+            const { a, b } = ctx.apiPayload;
+            expect(typeof a).toBe('number');
+            expect(typeof b).toBe('number');
+            return resolver.api(a + b);
+        });
+
+        const event = createMockEvent('add', { a: 10, b: 20 });
+        const context = createMockContext();
+        const response = await lambder.render(event, context);
+
+        const body = JSON.parse(response.body || '{}');
+        expect(body.payload).toBe(30);
+    });
+});
+
+// ============================================================================
+// Edge Cases
+// ============================================================================
+
+describe('Edge Cases', () => {
+    it('should handle empty arrays', async () => {
+        const lambder = new Lambder<TestContract>({
+            publicPath: './public',
+            apiPath: '/api',
+        });
+
+        lambder.addApi('listUsers', async (ctx, resolver) => {
+            return resolver.api([]);
+        });
+
+        const event = createMockEvent('listUsers', undefined);
+        const context = createMockContext();
+        const response = await lambder.render(event, context);
+
+        expect(response.statusCode).toBe(200);
+        const body = JSON.parse(response.body || '{}');
+        expect(body.payload).toEqual([]);
+    });
+
+    it('should handle zero as a valid number', async () => {
+        const lambder = new Lambder<TestContract>({
+            publicPath: './public',
+            apiPath: '/api',
+        });
+
+        lambder.addApi('add', async (ctx, resolver) => {
+            return resolver.api(0);
+        });
+
+        const event = createMockEvent('add', { a: 0, b: 0 });
+        const context = createMockContext();
+        const response = await lambder.render(event, context);
+
+        expect(response.statusCode).toBe(200);
+        const body = JSON.parse(response.body || '{}');
+        expect(body.payload).toBe(0);
+    });
+
+    it('should handle empty strings in objects', async () => {
+        const lambder = new Lambder<TestContract>({
+            publicPath: './public',
+            apiPath: '/api',
+        });
+
+        lambder.addApi('getUser', async (ctx, resolver) => {
+            return resolver.api({
+                id: '',
+                name: '',
+                age: 0
+            });
+        });
+
+        const event = createMockEvent('getUser', { userId: '' });
+        const context = createMockContext();
+        const response = await lambder.render(event, context);
+
+        expect(response.statusCode).toBe(200);
+        const body = JSON.parse(response.body || '{}');
+        expect(body.payload).toEqual({
+            id: '',
+            name: '',
+            age: 0
+        });
+    });
+});

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! ✅
 // ============================================================================