lambder 1.0.132 → 1.0.134

package/Readme.md

@@ -544,6 +544,42 @@ const user = await caller.api('getUserById', { userId: '123' });
 
 📖 **[Read the Quick Start Guide](docs/TYPE_SAFE_QUICK_START.md)** for more details and examples!
 
+## Testing with LambderMSW
+
+LambderMSW provides seamless integration with [MSW (Mock Service Worker)](https://mswjs.io/) for testing your APIs. It works perfectly with type-safe API contracts!
+
+```typescript
+import { LambderMSW } from 'lambder';
+import { setupServer } from 'msw/node';
+import type { MyApiContract } from './shared/apiContract';
+
+const lambderMSW = new LambderMSW<MyApiContract>({
+    apiPath: '/api',
+});
+
+const handlers = [
+    // Mock API with full type safety! ✨
+    lambderMSW.mockApi('getUserById', async (payload) => {
+        return {
+            id: payload.userId,
+            name: 'John Doe',
+            email: 'john@example.com'
+        };
+    }),
+    
+    // Mock errors, delays, and more
+    lambderMSW.mockApi('createUser', async (payload) => {
+        return { id: '123', ...payload };
+    }, { delay: 500 }),
+    
+    lambderMSW.mockSessionExpired('protectedApi'),
+];
+
+const server = setupServer(...handlers);
+```
+
+📖 **[Read the LambderMSW Guide](docs/LAMBDER_MSW.md)** for complete testing documentation!
+
 ## Contributing
 
 Contributions are welcome! Especially for documentation. If you have an idea for an improvement or have found a bug, please open an issue or submit a pull request.

package/dist/LambderMSW.d.ts

@@ -23,27 +23,32 @@ export default class LambderMSW<TContract extends ApiContractShape = any> {
      * @param apiName - The name of the API to mock
      * @param handler - Function that returns the mock payload
      * @param options - Additional response options (session expired, version expired, etc.)
+     *
+     * Note: TypeScript will check that the return type is assignable to the output type,
+     * but due to structural typing, extra properties are allowed. Enable strict checks
+     * in your tsconfig.json with "noUncheckedIndexedAccess" and "exactOptionalPropertyTypes"
+     * for better type safety.
      */
-    mockApi<TApiName extends keyof TContract & string, TOutput = TApiName extends keyof TContract ? TContract[TApiName]['output'] : any, TInput = TApiName extends keyof TContract ? TContract[TApiName]['input'] : any>(apiName: TApiName, handler: (payload?: TInput) => Promise<TOutput> | TOutput, options?: MockApiOptions): RequestHandler;
+    mockApi<TApiName extends keyof TContract>(apiName: TApiName, handler: (payload?: TContract[TApiName]['input']) => Promise<TContract[TApiName]['output']> | TContract[TApiName]['output'], options?: MockApiOptions): RequestHandler;
     /**
      * Mock an API endpoint that returns a session expired error
      */
-    mockSessionExpired<TApiName extends keyof TContract & string>(apiName: TApiName): RequestHandler;
+    mockSessionExpired<TApiName extends keyof TContract>(apiName: TApiName): RequestHandler;
     /**
      * Mock an API endpoint that returns a version expired error
      */
-    mockVersionExpired<TApiName extends keyof TContract & string>(apiName: TApiName): RequestHandler;
+    mockVersionExpired<TApiName extends keyof TContract>(apiName: TApiName): RequestHandler;
     /**
      * Mock an API endpoint that returns a not authorized error
      */
-    mockNotAuthorized<TApiName extends keyof TContract & string>(apiName: TApiName): RequestHandler;
+    mockNotAuthorized<TApiName extends keyof TContract>(apiName: TApiName): RequestHandler;
     /**
      * Mock an API endpoint that returns an error message
      */
-    mockError<TApiName extends keyof TContract & string>(apiName: TApiName, errorMessage: string): RequestHandler;
+    mockError<TApiName extends keyof TContract>(apiName: TApiName, errorMessage: string): RequestHandler;
     /**
      * Mock an API endpoint with a custom message
      */
-    mockWithMessage<TApiName extends keyof TContract & string, TOutput = TApiName extends keyof TContract ? TContract[TApiName]['output'] : any, TInput = TApiName extends keyof TContract ? TContract[TApiName]['input'] : any>(apiName: TApiName, handler: (payload?: TInput) => Promise<TOutput> | TOutput, message: any): RequestHandler;
+    mockWithMessage<TApiName extends keyof TContract>(apiName: TApiName, handler: (payload?: TContract[TApiName]['input']) => Promise<TContract[TApiName]['output']> | TContract[TApiName]['output'], message: any): RequestHandler;
 }
 export {};

package/dist/LambderMSW.js

@@ -21,38 +21,57 @@ export default class LambderMSW {
      * @param apiName - The name of the API to mock
      * @param handler - Function that returns the mock payload
      * @param options - Additional response options (session expired, version expired, etc.)
+     *
+     * Note: TypeScript will check that the return type is assignable to the output type,
+     * but due to structural typing, extra properties are allowed. Enable strict checks
+     * in your tsconfig.json with "noUncheckedIndexedAccess" and "exactOptionalPropertyTypes"
+     * for better type safety.
      */
     mockApi(apiName, handler, options) {
         return this.http.post(this.apiPath, async ({ request }) => {
+            let body;
             try {
-                const body = await request.json();
-                console.log("LambderMSW called for:", body?.apiName, "matching against:", apiName);
-                // Check if this is the API we're mocking
-                if (body?.apiName === apiName) {
-                    // Add artificial delay if specified
-                    if (options?.delay) {
-                        await new Promise(resolve => setTimeout(resolve, options.delay));
-                    }
-                    // Call the handler with the payload from the request
-                    const payload = await handler(body?.payload);
-                    console.log("Matched! Returning payload for:", apiName);
-                    const response = {
-                        apiVersion: this.apiVersion,
-                        payload,
-                        ...(options?.versionExpired ? { versionExpired: options.versionExpired } : {}),
-                        ...(options?.sessionExpired ? { sessionExpired: options.sessionExpired } : {}),
-                        ...(options?.notAuthorized ? { notAuthorized: options.notAuthorized } : {}),
-                        ...(options?.message ? { message: options.message } : {}),
-                        ...(options?.errorMessage ? { errorMessage: options.errorMessage } : {}),
-                        ...(options?.logList?.length ? { logList: options.logList } : {}),
-                    };
-                    return this.HttpResponse.json(response);
-                }
+                body = await request.json();
+            }
+            catch (parseErr) {
+                // If JSON parsing fails, return undefined to let other handlers try
+                console.warn("LambderMSW: Failed to parse request body as JSON");
+                return;
+            }
+            // Check if body is valid and has apiName
+            if (!body || typeof body.apiName !== 'string') {
+                // Invalid request format, let other handlers try
+                return;
+            }
+            console.log("LambderMSW called for:", body.apiName, "matching against:", apiName);
+            // Check if this is the API we're mocking
+            if (body.apiName !== apiName) {
                 // If this handler doesn't match, return undefined to let MSW try other handlers
                 return;
             }
+            try {
+                // Add artificial delay if specified
+                if (options?.delay) {
+                    await new Promise(resolve => setTimeout(resolve, options.delay));
+                }
+                // Call the handler with the payload from the request
+                const payload = await handler(body.payload);
+                console.log("Matched! Returning payload for:", apiName);
+                const response = {
+                    apiVersion: this.apiVersion,
+                    payload,
+                    ...(options?.versionExpired ? { versionExpired: options.versionExpired } : {}),
+                    ...(options?.sessionExpired ? { sessionExpired: options.sessionExpired } : {}),
+                    ...(options?.notAuthorized ? { notAuthorized: options.notAuthorized } : {}),
+                    ...(options?.message ? { message: options.message } : {}),
+                    ...(options?.errorMessage ? { errorMessage: options.errorMessage } : {}),
+                    ...(options?.logList?.length ? { logList: options.logList } : {}),
+                };
+                return this.HttpResponse.json(response);
+            }
             catch (err) {
-                console.error("Error in LambderMSW:", err);
+                // Only handle errors that occur during handler execution for matched APIs
+                console.error("Error in LambderMSW handler for", apiName, ":", err);
                 const errorResponse = {
                     apiVersion: this.apiVersion,
                     payload: null,

package/docs/LAMBDER_MSW.md

@@ -0,0 +1,430 @@
+# LambderMSW - Mock Service Worker Integration
+
+LambderMSW provides seamless integration with [MSW (Mock Service Worker)](https://mswjs.io/) for testing your Lambder APIs. It allows you to mock API endpoints with full type safety when using TypeScript API contracts.
+
+## Installation
+
+First, install MSW as a dev dependency:
+
+```bash
+npm install msw --save-dev
+# or
+yarn add msw --dev
+```
+
+## Basic Setup
+
+```typescript
+import { LambderMSW } from 'lambder';
+import { setupServer } from 'msw/node';
+
+// Create an MSW instance
+const lambderMSW = new LambderMSW({
+    apiPath: '/secure',  // Must match your Lambder backend apiPath
+});
+
+// Create mock handlers
+const handlers = [
+    lambderMSW.mockApi('getUserById', async (payload) => {
+        return {
+            id: payload.userId,
+            name: 'John Doe',
+            email: 'john@example.com'
+        };
+    }),
+    
+    lambderMSW.mockApi('createUser', async (payload) => {
+        return {
+            id: '123',
+            name: payload.name,
+            email: payload.email
+        };
+    })
+];
+
+// Setup MSW server
+const server = setupServer(...handlers);
+
+// Start server before tests
+beforeAll(() => server.listen());
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+```
+
+## Type-Safe Mocking
+
+When using TypeScript API contracts, LambderMSW provides full type safety:
+
+```typescript
+// shared/apiContract.ts
+import type { ApiContract } from 'lambder';
+
+export type MyApiContract = ApiContract<{
+    getUserById: { 
+        input: { userId: string }, 
+        output: { id: string, name: string, email: string } 
+    },
+    createUser: { 
+        input: { name: string, email: string }, 
+        output: { id: string, name: string, email: string } 
+    }
+}>;
+
+// test/setup.ts
+import { LambderMSW } from 'lambder';
+import type { MyApiContract } from '../shared/apiContract';
+
+const lambderMSW = new LambderMSW<MyApiContract>({
+    apiPath: '/secure',
+    apiVersion: '1.0.0'
+});
+
+// Now mockApi is fully typed! ✨
+const handler = lambderMSW.mockApi('getUserById', async (payload) => {
+    // payload is automatically typed as { userId: string }
+    // Return value is type-checked against output type
+    return {
+        id: payload.userId,
+        name: 'John Doe',
+        email: 'john@example.com'
+    };
+});
+```
+
+## API Reference
+
+### `new LambderMSW(options)`
+
+Creates a new LambderMSW instance.
+
+**Parameters:**
+- `apiPath` (string): The API endpoint path (must match your Lambder backend)
+- `apiVersion` (string, optional): API version to include in responses
+
+### `mockApi(apiName, handler, options?)`
+
+Mock an API endpoint with a custom handler.
+
+**Parameters:**
+- `apiName` (string): Name of the API to mock
+- `handler` (function): Async or sync function that returns the mock payload
+  - Input: API payload from the request
+  - Output: The mocked response payload
+- `options` (object, optional):
+  - `versionExpired` (boolean): Simulate version expired error
+  - `sessionExpired` (boolean): Simulate session expired error
+  - `notAuthorized` (boolean): Simulate not authorized error
+  - `message` (any): Custom message to include in response
+  - `errorMessage` (any): Error message to include in response
+  - `logList` (array): Array of log entries
+  - `delay` (number): Artificial delay in milliseconds to simulate network latency
+
+**Returns:** MSW RequestHandler
+
+**Example:**
+```typescript
+lambderMSW.mockApi('getCompanyPage', async (payload) => {
+    return {
+        companyName: payload.companyName,
+        description: 'Mock company description',
+        employees: 100
+    };
+}, {
+    delay: 500,  // Simulate 500ms network delay
+    message: 'Data fetched successfully'
+});
+```
+
+### `mockSessionExpired(apiName)`
+
+Mock an API that returns a session expired error.
+
+**Parameters:**
+- `apiName` (string): Name of the API to mock
+
+**Example:**
+```typescript
+lambderMSW.mockSessionExpired('getProtectedData');
+```
+
+### `mockVersionExpired(apiName)`
+
+Mock an API that returns a version expired error.
+
+**Parameters:**
+- `apiName` (string): Name of the API to mock
+
+**Example:**
+```typescript
+lambderMSW.mockVersionExpired('getUserProfile');
+```
+
+### `mockNotAuthorized(apiName)`
+
+Mock an API that returns a not authorized error.
+
+**Parameters:**
+- `apiName` (string): Name of the API to mock
+
+**Example:**
+```typescript
+lambderMSW.mockNotAuthorized('deleteUser');
+```
+
+### `mockError(apiName, errorMessage)`
+
+Mock an API that returns a custom error message.
+
+**Parameters:**
+- `apiName` (string): Name of the API to mock
+- `errorMessage` (string): The error message to return
+
+**Example:**
+```typescript
+lambderMSW.mockError('submitOrder', 'Payment processing failed');
+```
+
+### `mockWithMessage(apiName, handler, message)`
+
+Mock an API with a custom success message.
+
+**Parameters:**
+- `apiName` (string): Name of the API to mock
+- `handler` (function): Handler function that returns the mock payload
+- `message` (any): Custom message to include in response
+
+**Example:**
+```typescript
+lambderMSW.mockWithMessage('updateProfile', async (payload) => {
+    return { userId: payload.userId, updated: true };
+}, 'Profile updated successfully');
+```
+
+## Complete Testing Example
+
+```typescript
+// test/api.test.ts
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import { setupServer } from 'msw/node';
+import { LambderMSW } from 'lambder';
+import { LambderCaller } from 'lambder';
+import type { MyApiContract } from '../shared/apiContract';
+
+// Setup MSW
+const lambderMSW = new LambderMSW<MyApiContract>({
+    apiPath: '/secure',
+    apiVersion: '1.0.0'
+});
+
+const handlers = [
+    lambderMSW.mockApi('getUserById', async (payload) => {
+        if (payload.userId === '123') {
+            return {
+                id: '123',
+                name: 'John Doe',
+                email: 'john@example.com'
+            };
+        }
+        return null;
+    }),
+    
+    lambderMSW.mockApi('createUser', async (payload) => {
+        return {
+            id: Math.random().toString(),
+            name: payload.name,
+            email: payload.email
+        };
+    }, { delay: 100 }),  // Simulate 100ms delay
+    
+    lambderMSW.mockSessionExpired('getProtectedData'),
+    
+    lambderMSW.mockError('failingApi', 'Something went wrong')
+];
+
+const server = setupServer(...handlers);
+
+beforeAll(() => server.listen());
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+
+// Setup LambderCaller
+const caller = new LambderCaller<MyApiContract>({
+    apiPath: '/secure',
+    isCorsEnabled: false
+});
+
+describe('User APIs', () => {
+    it('should fetch user by id', async () => {
+        const result = await caller.api('getUserById', { userId: '123' });
+        
+        expect(result).toEqual({
+            id: '123',
+            name: 'John Doe',
+            email: 'john@example.com'
+        });
+    });
+    
+    it('should create a new user', async () => {
+        const result = await caller.api('createUser', {
+            name: 'Jane Smith',
+            email: 'jane@example.com'
+        });
+        
+        expect(result?.name).toBe('Jane Smith');
+        expect(result?.email).toBe('jane@example.com');
+        expect(result?.id).toBeDefined();
+    });
+    
+    it('should handle session expired', async () => {
+        try {
+            await caller.api('getProtectedData', {});
+            // Should not reach here
+            expect(true).toBe(false);
+        } catch (error: any) {
+            expect(error.sessionExpired).toBe(true);
+        }
+    });
+    
+    it('should handle errors', async () => {
+        try {
+            await caller.api('failingApi', {});
+            // Should not reach here
+            expect(true).toBe(false);
+        } catch (error: any) {
+            expect(error.errorMessage).toBe('Something went wrong');
+        }
+    });
+});
+```
+
+## Browser Testing
+
+LambderMSW also works in browser environments with MSW's browser integration:
+
+```typescript
+// test/browser-setup.ts
+import { setupWorker } from 'msw/browser';
+import { LambderMSW } from 'lambder';
+import type { MyApiContract } from '../shared/apiContract';
+
+const lambderMSW = new LambderMSW<MyApiContract>({
+    apiPath: '/secure'
+});
+
+const handlers = [
+    lambderMSW.mockApi('getUserById', async (payload) => {
+        return {
+            id: payload.userId,
+            name: 'John Doe',
+            email: 'john@example.com'
+        };
+    })
+];
+
+const worker = setupWorker(...handlers);
+
+// Start the worker
+worker.start();
+```
+
+## Advanced Usage
+
+### Dynamic Mock Responses
+
+```typescript
+lambderMSW.mockApi('searchUsers', async (payload) => {
+    const { query, limit } = payload;
+    
+    // Return different responses based on input
+    if (query === 'admin') {
+        return [{
+            id: '1',
+            name: 'Admin User',
+            role: 'admin'
+        }];
+    }
+    
+    return Array.from({ length: limit }, (_, i) => ({
+        id: `${i}`,
+        name: `User ${i}`,
+        role: 'user'
+    }));
+});
+```
+
+### Simulating Network Conditions
+
+```typescript
+// Slow network
+lambderMSW.mockApi('slowApi', async () => {
+    return { data: 'slow response' };
+}, { delay: 3000 });  // 3 second delay
+
+// Intermittent failures
+let callCount = 0;
+lambderMSW.mockApi('flakeyApi', async () => {
+    callCount++;
+    if (callCount % 3 === 0) {
+        throw new Error('Random failure');
+    }
+    return { success: true };
+});
+```
+
+### Override Handlers Per Test
+
+```typescript
+it('should handle specific user', async () => {
+    // Override the default handler for this test
+    server.use(
+        lambderMSW.mockApi('getUserById', async (payload) => {
+            return {
+                id: payload.userId,
+                name: 'Special User',
+                email: 'special@example.com'
+            };
+        })
+    );
+    
+    const result = await caller.api('getUserById', { userId: '999' });
+    expect(result?.name).toBe('Special User');
+});
+```
+
+## Benefits
+
+✅ **Type Safety** - Full TypeScript support with API contracts  
+✅ **Simple API** - Intuitive methods matching Lambder's API structure  
+✅ **Flexible** - Mock success, errors, delays, and custom responses  
+✅ **Isolated** - Tests run without real backend dependencies  
+✅ **Fast** - No network calls, instant test execution  
+✅ **Realistic** - Simulate real-world scenarios (delays, errors, etc.)  
+
+## Troubleshooting
+
+### MSW Not Found Error
+
+If you see "MSW (Mock Service Worker) is required", make sure MSW is installed:
+
+```bash
+npm install msw --save-dev
+```
+
+### Handler Not Matching
+
+LambderMSW matches handlers based on the `apiName` in the request body. Make sure:
+1. Your `apiPath` matches between backend, frontend, and mocks
+2. The API name string matches exactly
+3. Handlers are registered before making requests
+
+### Console Warnings
+
+LambderMSW logs matching information to console for debugging. To see these logs:
+- Check browser console for "LambderMSW called for:" messages
+- Verify "Matched!" appears when handler should execute
+
+## See Also
+
+- [MSW Documentation](https://mswjs.io/)
+- [Type-Safe Quick Start](./TYPE_SAFE_QUICK_START.md)
+- [Lambder Main Documentation](../Readme.md)

package/docs/TYPE_SAFE_QUICK_START.md

@@ -156,6 +156,38 @@ lambder.addApi('anyApi', async (ctx, resolver) => {
 
 See [simplified-typed-api-example.ts](../examples/simplified-typed-api-example.ts) for a complete working example.
 
+## Testing Your Type-Safe APIs
+
+LambderMSW provides full type safety for testing your APIs with MSW (Mock Service Worker):
+
+```typescript
+import { LambderMSW } from 'lambder';
+import { setupServer } from 'msw/node';
+import type { MyApiContract } from './shared/apiContract';
+
+// Create type-safe MSW instance
+const lambderMSW = new LambderMSW<MyApiContract>({
+    apiPath: '/api'
+});
+
+// Mock with full type safety! ✨
+const handlers = [
+    lambderMSW.mockApi('getUserById', async (payload) => {
+        // payload is typed as { userId: string }
+        // Return value is type-checked against output
+        return {
+            id: payload.userId,
+            name: 'John Doe',
+            email: 'john@example.com'
+        };
+    })
+];
+
+const server = setupServer(...handlers);
+```
+
+📖 See [LAMBDER_MSW.md](./LAMBDER_MSW.md) for complete testing documentation.
+
 ## Key Points
 
 - **Contract is just a TypeScript type** - No runtime code!
@@ -165,3 +197,4 @@ See [simplified-typed-api-example.ts](../examples/simplified-typed-api-example.t
 - **Opt-in** - Use types when you want them
 - **Simple** - Just pass type to constructor
 - **Autocomplete** - IDE shows available APIs as you type
+- **Testing support** - LambderMSW provides type-safe mocking

package/examples/msw-testing-example.ts

@@ -0,0 +1,277 @@
+/**
+ * LambderMSW Testing Example
+ * 
+ * This example shows how to use LambderMSW with MSW (Mock Service Worker)
+ * to test your Lambder APIs with full type safety.
+ * 
+ * To run this example:
+ * 1. Install MSW: npm install msw --save-dev
+ * 2. Install a test runner: npm install vitest --save-dev
+ * 3. Create this file in your test directory
+ * 
+ * NOTE: This is an example file. Type errors are expected since dependencies
+ * may not be installed in the examples directory. Copy this to your project's
+ * test directory to use it.
+ */
+
+// @ts-nocheck - Example file, types may not be available
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import { setupServer } from 'msw/node';
+import { LambderMSW, LambderCaller, type ApiContract } from '../src/index.ts';
+
+// Define your API contract
+type TestApiContract = ApiContract<{
+    getUserById: {
+        input: { userId: string };
+        output: { id: string; name: string; email: string } | null;
+    };
+    createUser: {
+        input: { name: string; email: string };
+        output: { id: string; name: string; email: string };
+    };
+    getUsers: {
+        input: { limit?: number };
+        output: Array<{ id: string; name: string; email: string }>;
+    };
+    deleteUser: {
+        input: { userId: string };
+        output: { success: boolean };
+    };
+}>;
+
+// Setup LambderMSW with type safety
+const lambderMSW = new LambderMSW<TestApiContract>({
+    apiPath: '/secure',
+    apiVersion: '1.0.0',
+});
+
+// Create mock handlers
+const handlers = [
+    // Mock getUserById - returns user or null
+    lambderMSW.mockApi('getUserById', async (payload) => {
+        const users: Record<string, { id: string; name: string; email: string }> = {
+            '1': { id: '1', name: 'John Doe', email: 'john@example.com' },
+            '2': { id: '2', name: 'Jane Smith', email: 'jane@example.com' },
+        };
+        
+        return users[payload?.userId || ''] || null;
+    }),
+
+    // Mock createUser - simulates creating a user
+    lambderMSW.mockApi('createUser', async (payload) => {
+        return {
+            id: Math.random().toString(36).substring(7),
+            name: payload?.name || '',
+            email: payload?.email || '',
+        };
+    }, { 
+        delay: 100, // Simulate 100ms network delay
+        message: 'User created successfully'
+    }),
+
+    // Mock getUsers - returns a list of users
+    lambderMSW.mockApi('getUsers', async (payload) => {
+        const allUsers = [
+            { id: '1', name: 'John Doe', email: 'john@example.com' },
+            { id: '2', name: 'Jane Smith', email: 'jane@example.com' },
+            { id: '3', name: 'Bob Johnson', email: 'bob@example.com' },
+        ];
+        
+        const limit = payload?.limit || 10;
+        return allUsers.slice(0, limit);
+    }),
+
+    // Mock deleteUser - simulate authorization error
+    lambderMSW.mockNotAuthorized('deleteUser'),
+];
+
+// Setup MSW server
+const server = setupServer(...handlers);
+
+// Setup LambderCaller
+const caller = new LambderCaller<TestApiContract>({
+    apiPath: '/secure',
+    isCorsEnabled: false,
+});
+
+// Test suite
+describe('LambderMSW Testing Example', () => {
+    beforeAll(() => {
+        server.listen({ onUnhandledRequest: 'error' });
+    });
+
+    afterEach(() => {
+        server.resetHandlers();
+    });
+
+    afterAll(() => {
+        server.close();
+    });
+
+    it('should fetch user by id', async () => {
+        const user = await caller.api('getUserById', { userId: '1' });
+        
+        expect(user).toEqual({
+            id: '1',
+            name: 'John Doe',
+            email: 'john@example.com',
+        });
+    });
+
+    it('should return null for non-existent user', async () => {
+        const user = await caller.api('getUserById', { userId: '999' });
+        
+        expect(user).toBeNull();
+    });
+
+    it('should create a new user with delay', async () => {
+        const startTime = Date.now();
+        
+        const newUser = await caller.api('createUser', {
+            name: 'Alice Wonder',
+            email: 'alice@example.com',
+        });
+        
+        const endTime = Date.now();
+        
+        expect(newUser?.name).toBe('Alice Wonder');
+        expect(newUser?.email).toBe('alice@example.com');
+        expect(newUser?.id).toBeDefined();
+        
+        // Check that delay was applied (at least 100ms)
+        expect(endTime - startTime).toBeGreaterThanOrEqual(100);
+    });
+
+    it('should fetch list of users', async () => {
+        const users = await caller.api('getUsers', { limit: 2 });
+        
+        expect(users).toHaveLength(2);
+        expect(users?.[0]?.name).toBe('John Doe');
+        expect(users?.[1]?.name).toBe('Jane Smith');
+    });
+
+    it('should handle authorization error', async () => {
+        let errorCaught = false;
+        
+        try {
+            await caller.api('deleteUser', { userId: '1' });
+        } catch (error: any) {
+            errorCaught = true;
+            expect(error.notAuthorized).toBe(true);
+        }
+        
+        expect(errorCaught).toBe(true);
+    });
+
+    it('should override handler for specific test', async () => {
+        // Override the getUserById handler for this test only
+        server.use(
+            lambderMSW.mockApi('getUserById', async (payload) => {
+                return {
+                    id: payload?.userId || '',
+                    name: 'Override User',
+                    email: 'override@example.com',
+                };
+            })
+        );
+
+        const user = await caller.api('getUserById', { userId: '999' });
+        
+        expect(user?.name).toBe('Override User');
+    });
+
+    it('should simulate session expired', async () => {
+        // Add a handler that simulates session expiration
+        server.use(
+            lambderMSW.mockSessionExpired('getUserById')
+        );
+
+        let errorCaught = false;
+        
+        try {
+            await caller.api('getUserById', { userId: '1' });
+        } catch (error: any) {
+            errorCaught = true;
+            expect(error.sessionExpired).toBe(true);
+        }
+        
+        expect(errorCaught).toBe(true);
+    });
+
+    it('should simulate custom error', async () => {
+        server.use(
+            lambderMSW.mockError('createUser', 'Email already exists')
+        );
+
+        let errorCaught = false;
+        
+        try {
+            await caller.api('createUser', {
+                name: 'Duplicate',
+                email: 'john@example.com',
+            });
+        } catch (error: any) {
+            errorCaught = true;
+            expect(error.errorMessage).toBe('Email already exists');
+        }
+        
+        expect(errorCaught).toBe(true);
+    });
+});
+
+// Example: Testing with dynamic responses
+describe('Dynamic Response Testing', () => {
+    beforeAll(() => server.listen());
+    afterEach(() => server.resetHandlers());
+    afterAll(() => server.close());
+
+    it('should handle different query parameters', async () => {
+        server.use(
+            lambderMSW.mockApi('getUsers', async (payload) => {
+                const limit = payload?.limit || 10;
+                
+                // Generate mock users based on limit
+                return Array.from({ length: limit }, (_, i) => ({
+                    id: `${i + 1}`,
+                    name: `User ${i + 1}`,
+                    email: `user${i + 1}@example.com`,
+                }));
+            })
+        );
+
+        const users3 = await caller.api('getUsers', { limit: 3 });
+        expect(users3).toHaveLength(3);
+
+        const users5 = await caller.api('getUsers', { limit: 5 });
+        expect(users5).toHaveLength(5);
+    });
+});
+
+// Example: Testing error conditions
+describe('Error Handling', () => {
+    beforeAll(() => server.listen());
+    afterEach(() => server.resetHandlers());
+    afterAll(() => server.close());
+
+    it('should handle handler throwing error', async () => {
+        server.use(
+            lambderMSW.mockApi('getUserById', async () => {
+                throw new Error('Database connection failed');
+            })
+        );
+
+        let errorCaught = false;
+        
+        try {
+            await caller.api('getUserById', { userId: '1' });
+        } catch (error: any) {
+            errorCaught = true;
+            expect(error.errorMessage).toBe('Database connection failed');
+        }
+        
+        expect(errorCaught).toBe(true);
+    });
+});
+
+console.log('✅ LambderMSW example tests configured!');
+console.log('📖 See docs/LAMBDER_MSW.md for more information');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lambder",
-  "version": "1.0.132",
+  "version": "1.0.134",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/LambderMSW.ts

@@ -50,52 +50,68 @@ export default class LambderMSW<TContract extends ApiContractShape = any> {
      * @param apiName - The name of the API to mock
      * @param handler - Function that returns the mock payload
      * @param options - Additional response options (session expired, version expired, etc.)
+     * 
+     * Note: TypeScript will check that the return type is assignable to the output type,
+     * but due to structural typing, extra properties are allowed. Enable strict checks
+     * in your tsconfig.json with "noUncheckedIndexedAccess" and "exactOptionalPropertyTypes"
+     * for better type safety.
      */
-    mockApi<
-        TApiName extends keyof TContract & string,
-        TOutput = TApiName extends keyof TContract ? TContract[TApiName]['output'] : any,
-        TInput = TApiName extends keyof TContract ? TContract[TApiName]['input'] : any
-    >(
+    mockApi<TApiName extends keyof TContract>(
         apiName: TApiName,
-        handler: (payload?: TInput) => Promise<TOutput> | TOutput,
+        handler: (payload?: TContract[TApiName]['input']) => Promise<TContract[TApiName]['output']> | TContract[TApiName]['output'],
         options?: MockApiOptions
     ): RequestHandler {
         return this.http.post(this.apiPath, async ({ request }: any) => {
+            let body: any;
+            
             try {
-                const body: any = await request.json();
-                
-                console.log("LambderMSW called for:", body?.apiName, "matching against:", apiName);
-                
-                // Check if this is the API we're mocking
-                if (body?.apiName === apiName) {
-                    // Add artificial delay if specified
-                    if (options?.delay) {
-                        await new Promise(resolve => setTimeout(resolve, options.delay));
-                    }
-
-                    // Call the handler with the payload from the request
-                    const payload = await handler(body?.payload as TInput);
-                    
-                    console.log("Matched! Returning payload for:", apiName);
-
-                    const response: MockApiResponse<TOutput> = {
-                        apiVersion: this.apiVersion,
-                        payload,
-                        ...(options?.versionExpired ? { versionExpired: options.versionExpired } : {}),
-                        ...(options?.sessionExpired ? { sessionExpired: options.sessionExpired } : {}),
-                        ...(options?.notAuthorized ? { notAuthorized: options.notAuthorized } : {}),
-                        ...(options?.message ? { message: options.message } : {}),
-                        ...(options?.errorMessage ? { errorMessage: options.errorMessage } : {}),
-                        ...(options?.logList?.length ? { logList: options.logList } : {}),
-                    };
-
-                    return this.HttpResponse.json(response);
-                }
-
+                body = await request.json();
+            } catch (parseErr) {
+                // If JSON parsing fails, return undefined to let other handlers try
+                console.warn("LambderMSW: Failed to parse request body as JSON");
+                return;
+            }
+            
+            // Check if body is valid and has apiName
+            if (!body || typeof body.apiName !== 'string') {
+                // Invalid request format, let other handlers try
+                return;
+            }
+            
+            console.log("LambderMSW called for:", body.apiName, "matching against:", apiName);
+            
+            // Check if this is the API we're mocking
+            if (body.apiName !== apiName) {
                 // If this handler doesn't match, return undefined to let MSW try other handlers
                 return;
+            }
+            
+            try {
+                // Add artificial delay if specified
+                if (options?.delay) {
+                    await new Promise(resolve => setTimeout(resolve, options.delay));
+                }
+
+                // Call the handler with the payload from the request
+                const payload = await handler(body.payload as TContract[TApiName]['input']);
+                
+                console.log("Matched! Returning payload for:", apiName);
+
+                const response: MockApiResponse<TContract[TApiName]['output']> = {
+                    apiVersion: this.apiVersion,
+                    payload,
+                    ...(options?.versionExpired ? { versionExpired: options.versionExpired } : {}),
+                    ...(options?.sessionExpired ? { sessionExpired: options.sessionExpired } : {}),
+                    ...(options?.notAuthorized ? { notAuthorized: options.notAuthorized } : {}),
+                    ...(options?.message ? { message: options.message } : {}),
+                    ...(options?.errorMessage ? { errorMessage: options.errorMessage } : {}),
+                    ...(options?.logList?.length ? { logList: options.logList } : {}),
+                };
+
+                return this.HttpResponse.json(response);
             } catch (err: any) {
-                console.error("Error in LambderMSW:", err);
+                // Only handle errors that occur during handler execution for matched APIs
+                console.error("Error in LambderMSW handler for", apiName, ":", err);
                 
                 const errorResponse: MockApiResponse<null> = {
                     apiVersion: this.apiVersion,
@@ -111,7 +127,7 @@ export default class LambderMSW<TContract extends ApiContractShape = any> {
     /**
      * Mock an API endpoint that returns a session expired error
      */
-    mockSessionExpired<TApiName extends keyof TContract & string>(
+    mockSessionExpired<TApiName extends keyof TContract>(
         apiName: TApiName
     ): RequestHandler {
         return this.mockApi(
@@ -124,7 +140,7 @@ export default class LambderMSW<TContract extends ApiContractShape = any> {
     /**
      * Mock an API endpoint that returns a version expired error
      */
-    mockVersionExpired<TApiName extends keyof TContract & string>(
+    mockVersionExpired<TApiName extends keyof TContract>(
         apiName: TApiName
     ): RequestHandler {
         return this.mockApi(
@@ -137,7 +153,7 @@ export default class LambderMSW<TContract extends ApiContractShape = any> {
     /**
      * Mock an API endpoint that returns a not authorized error
      */
-    mockNotAuthorized<TApiName extends keyof TContract & string>(
+    mockNotAuthorized<TApiName extends keyof TContract>(
         apiName: TApiName
     ): RequestHandler {
         return this.mockApi(
@@ -150,7 +166,7 @@ export default class LambderMSW<TContract extends ApiContractShape = any> {
     /**
      * Mock an API endpoint that returns an error message
      */
-    mockError<TApiName extends keyof TContract & string>(
+    mockError<TApiName extends keyof TContract>(
         apiName: TApiName,
         errorMessage: string
     ): RequestHandler {
@@ -164,13 +180,9 @@ export default class LambderMSW<TContract extends ApiContractShape = any> {
     /**
      * Mock an API endpoint with a custom message
      */
-    mockWithMessage<
-        TApiName extends keyof TContract & string,
-        TOutput = TApiName extends keyof TContract ? TContract[TApiName]['output'] : any,
-        TInput = TApiName extends keyof TContract ? TContract[TApiName]['input'] : any
-    >(
+    mockWithMessage<TApiName extends keyof TContract>(
         apiName: TApiName,
-        handler: (payload?: TInput) => Promise<TOutput> | TOutput,
+        handler: (payload?: TContract[TApiName]['input']) => Promise<TContract[TApiName]['output']> | TContract[TApiName]['output'],
         message: any
     ): RequestHandler {
         return this.mockApi(apiName, handler, { message });

package/test-type-enforcement.ts

@@ -0,0 +1,111 @@
+// Test file to verify LambderMSW type enforcement
+import LambderMSW from './src/LambderMSW';
+import type { ApiContract } from './src/LambderApiContract';
+
+// Define a test API contract
+type TestContract = ApiContract<{
+    'public.getInitialPageData': {
+        input: void;
+        output: {
+            userLocationData: {
+                country: string;
+                region: string;
+                regionCode: string;
+                city: string;
+                zipCode: string;
+                lat: number;
+                lng: number;
+            };
+            sessionUser: {
+                id: string;
+                username: string;
+                email: string;
+                name: string;
+                bio: string;
+                // NOTE: 's' property should NOT be here
+            };
+        };
+    };
+}>;
+
+const apiMocker = new LambderMSW<TestContract>({
+    apiPath: '/secure',
+});
+
+// TEST 1: Extra properties - TypeScript allows this due to structural typing
+const handler1 = apiMocker.mockApi(
+    'public.getInitialPageData',
+    async () => {
+        return {
+            userLocationData: {
+                country: 'United States',
+                region: 'California',
+                regionCode: 'CA',
+                city: 'San Francisco',
+                zipCode: '94102',
+                lat: 37.7749,
+                lng: -122.4194,
+            },
+            sessionUser: {
+                id: 'mock-user-123',
+                username: 'mockuser',
+                email: 'mock@example.com',
+                name: 'Mock User',
+                bio: 'This is a mock user for development',
+                s: 43  // ⚠️ Extra property - TypeScript structural typing allows this
+            },
+        };
+    }
+);
+
+// TEST 2: Missing required property - THIS WILL CAUSE AN ERROR!
+const handler2 = apiMocker.mockApi(
+    'public.getInitialPageData',
+    async () => {
+        return {
+            userLocationData: {
+                country: 'United States',
+                region: 'California',
+                regionCode: 'CA',
+                city: 'San Francisco',
+                zipCode: '94102',
+                lat: 37.7749,
+                lng: -122.4194,
+            },
+            sessionUser: {
+                id: 'mock-user-123',
+                username: 'mockuser',
+                email: 'mock@example.com',
+                name: 'Mock User',
+                // bio: 'This is a mock user for development',  // ❌ Missing required property - ERROR!
+            },
+        };
+    }
+);
+
+// TEST 3: Wrong type - THIS WILL CAUSE AN ERROR!
+const handler3 = apiMocker.mockApi(
+    'public.getInitialPageData',
+    async () => {
+        return {
+            userLocationData: {
+                country: 'United States',
+                region: 'California',
+                regionCode: 'CA',
+                city: 'San Francisco',
+                zipCode: '94102',
+                lat: 37.7749,
+                lng: -122.4194,
+            },
+            sessionUser: {
+                id: 123,  // ❌ Wrong type - should be string - ERROR!
+                username: 'mockuser',
+                email: 'mock@example.com',
+                name: 'Mock User',
+                bio: 'This is a mock user for development',
+            },
+        };
+    }
+);
+
+console.log('Check for TypeScript errors above!');