lambder 1.0.131 → 1.0.133

package/Readme.md

@@ -5,11 +5,9 @@ Lambder is a highly opinionated dynamic serverless framework designed to facilit
 ## Features
 
 - **Simple API & Route Declaration**: Define your APIs and routes using concise and expressive syntax.
-- **Type-Safe API Contracts**: Full TypeScript type safety across frontend and backend with zero runtime overhead.
 - **Session Management**: Built-in session management to secure and personalize user experiences.
 - **Flexible Hooks System**: Employ hooks to execute code at different stages of the request lifecycle, enabling fine-grained control over the application flow.
 - **Error Handling**: Comprehensive error handling capabilities, including global error handlers and route-specific fallbacks.
-- **MSW Mocking Support**: Optional Mock Service Worker integration for easy API mocking in tests and development.
 - **Seamless Integration**: Designed to work effortlessly with AWS Lambda and API Gateway, providing a straightforward path to deploy serverless applications.
 
 ## Installation
@@ -546,52 +544,41 @@ 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 & Mocking with MSW
+## Testing with LambderMSW
 
-Lambder provides optional integration with [Mock Service Worker (MSW)](https://mswjs.io/) for easy API mocking in tests and development.
-
-### Installation
-
-```bash
-npm install --save-dev msw
-```
-
-### Quick Example
+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 { mockLambderApi } from 'lambder';
+import { LambderMSW } from 'lambder';
 import { setupServer } from 'msw/node';
-import type { MyApiContract } from './apiContract';
+import type { MyApiContract } from './shared/apiContract';
+
+const lambderMSW = new LambderMSW<MyApiContract>({
+    apiPath: '/api',
+});
 
-// Create type-safe mock handlers
 const handlers = [
-  mockLambderApi<MyApiContract, 'getUserById'>(
-    'getUserById',
-    (input) => ({
-      id: input.userId,
-      name: 'Test User',
-      email: 'test@example.com'
-    })
-  )
+    // 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'),
 ];
 
-// Set up MSW server
 const server = setupServer(...handlers);
-
-beforeAll(() => server.listen());
-afterEach(() => server.resetHandlers());
-afterAll(() => server.close());
 ```
 
-### Benefits
-
-✅ **Type-Safe Mocking** - Full TypeScript support for mock responses  
-✅ **Easy Setup** - Simple functions that match your API contract  
-✅ **Test Scenarios** - Mock errors, session expired, not authorized, etc.  
-✅ **Development Mode** - Use mocks while developing frontend features  
-✅ **Storybook Ready** - Perfect for component stories  
-
-📖 **[Read the MSW Mocking Guide](docs/MSW_MOCKING.md)** for detailed setup and examples!
+📖 **[Read the LambderMSW Guide](docs/LAMBDER_MSW.md)** for complete testing documentation!
 
 ## Contributing
 

package/dist/LambderMSW.d.ts

@@ -1,102 +1,49 @@
-import type { ApiContractShape } from './LambderApiContract.js';
-/**
- * Creates a mock handler for a Lambder API endpoint
- *
- * @example
- * ```typescript
- * mockLambderApi('public.getInitialPageData', () => ({
- *   userLocationData: { ... },
- *   sessionUser: null
- * }))
- * ```
- *
- * @example with dynamic response based on input
- * ```typescript
- * mockLambderApi('user.updateProfile', (input) => ({
- *   success: true,
- *   userId: input.userId
- * }))
- * ```
- */
-export declare function mockLambderApi<TContract extends ApiContractShape, TApiName extends keyof TContract & string>(apiName: TApiName, responseFactory: (input: TContract[TApiName]['input']) => TContract[TApiName]['output'] | Promise<TContract[TApiName]['output']>, options?: {
-    /** Custom API path, defaults to '/api' */
-    apiPath?: string;
-    /** Delay in ms before responding (for testing loading states) */
+import type { ApiContractShape } from './LambderApiContract';
+type RequestHandler = any;
+type MockApiOptions = {
+    versionExpired?: boolean;
+    sessionExpired?: boolean;
+    notAuthorized?: boolean;
+    message?: any;
+    errorMessage?: any;
+    logList?: any[];
     delay?: number;
-    /** Custom apiVersion to include in response */
-    apiVersion?: string | null;
-}): any;
-/**
- * Creates a mock handler that returns an error for a Lambder API endpoint
- *
- * @example
- * ```typescript
- * mockLambderApiError('user.deleteAccount', 'Account deletion failed')
- * ```
- */
-export declare function mockLambderApiError<TContract extends ApiContractShape, TApiName extends keyof TContract & string>(apiName: TApiName, errorMessage: string, options?: {
-    /** Custom API path, defaults to '/api' */
-    apiPath?: string;
-    /** Delay in ms before responding */
-    delay?: number;
-    /** Custom apiVersion to include in response */
-    apiVersion?: string | null;
-}): any;
-/**
- * Creates a mock handler that simulates a session expired error
- *
- * @example
- * ```typescript
- * mockLambderSessionExpired('user.updateProfile')
- * ```
- */
-export declare function mockLambderSessionExpired<TContract extends ApiContractShape, TApiName extends keyof TContract & string>(apiName: TApiName, options?: {
-    /** Custom API path, defaults to '/api' */
-    apiPath?: string;
-    /** Custom apiVersion to include in response */
-    apiVersion?: string | null;
-}): any;
-/**
- * Creates a mock handler that simulates a "not authorized" error
- *
- * @example
- * ```typescript
- * mockLambderNotAuthorized('admin.deleteUser')
- * ```
- */
-export declare function mockLambderNotAuthorized<TContract extends ApiContractShape, TApiName extends keyof TContract & string>(apiName: TApiName, options?: {
-    /** Custom API path, defaults to '/api' */
-    apiPath?: string;
-    /** Custom apiVersion to include in response */
-    apiVersion?: string | null;
-}): any;
-/**
- * Creates a mock handler that simulates a version expired error
- *
- * @example
- * ```typescript
- * mockLambderVersionExpired('user.updateProfile')
- * ```
- */
-export declare function mockLambderVersionExpired<TContract extends ApiContractShape, TApiName extends keyof TContract & string>(apiName: TApiName, options?: {
-    /** Custom API path, defaults to '/api' */
-    apiPath?: string;
-    /** Custom apiVersion to include in response */
-    apiVersion?: string | null;
-}): any;
-/**
- * Helper to combine multiple Lambder mock handlers
- * Since each handler checks for its specific apiName, you can just spread them into setupWorker/setupServer
- *
- * @deprecated This helper is not needed - just spread handlers directly into setupWorker/setupServer
- * @example
- * ```typescript
- * import { setupServer } from 'msw/node';
- *
- * const server = setupServer(
- *   mockLambderApi('user.getProfile', () => ({ name: 'Test User' })),
- *   mockLambderApi('user.updateProfile', (input) => ({ success: true }))
- * );
- * ```
- */
-export declare function createLambderApiHandler(apiPath: string, handlers: any[]): any[];
+};
+export default class LambderMSW<TContract extends ApiContractShape = any> {
+    private apiPath;
+    private apiVersion?;
+    private http;
+    private HttpResponse;
+    constructor({ apiPath, apiVersion, }: {
+        apiPath: string;
+        apiVersion?: string;
+    });
+    /**
+     * Mock an API endpoint with MSW
+     * @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.)
+     */
+    mockApi<TApiName extends keyof TContract & string>(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;
+    /**
+     * Mock an API endpoint that returns a version expired error
+     */
+    mockVersionExpired<TApiName extends keyof TContract & string>(apiName: TApiName): RequestHandler;
+    /**
+     * Mock an API endpoint that returns a not authorized error
+     */
+    mockNotAuthorized<TApiName extends keyof TContract & string>(apiName: TApiName): RequestHandler;
+    /**
+     * Mock an API endpoint that returns an error message
+     */
+    mockError<TApiName extends keyof TContract & string>(apiName: TApiName, errorMessage: string): RequestHandler;
+    /**
+     * Mock an API endpoint with a custom message
+     */
+    mockWithMessage<TApiName extends keyof TContract & string>(apiName: TApiName, handler: (payload?: TContract[TApiName]['input']) => Promise<TContract[TApiName]['output']> | TContract[TApiName]['output'], message: any): RequestHandler;
+}
+export {};

package/dist/LambderMSW.js

@@ -1,176 +1,109 @@
-/**
- * Creates a mock handler for a Lambder API endpoint
- *
- * @example
- * ```typescript
- * mockLambderApi('public.getInitialPageData', () => ({
- *   userLocationData: { ... },
- *   sessionUser: null
- * }))
- * ```
- *
- * @example with dynamic response based on input
- * ```typescript
- * mockLambderApi('user.updateProfile', (input) => ({
- *   success: true,
- *   userId: input.userId
- * }))
- * ```
- */
-export function mockLambderApi(apiName, responseFactory, options) {
-    const apiPath = options?.apiPath ?? '/api';
-    const delay = options?.delay ?? 0;
-    const apiVersion = options?.apiVersion ?? null;
-    // @ts-ignore - MSW is an optional peer dependency
-    const { http, HttpResponse } = require('msw');
-    return http.post(apiPath, async ({ request }) => {
-        const body = (await request.json());
-        // Only handle this specific API
-        if (body.apiName !== apiName) {
-            return;
+export default class LambderMSW {
+    apiPath;
+    apiVersion;
+    http;
+    HttpResponse;
+    constructor({ apiPath, apiVersion, }) {
+        this.apiPath = apiPath;
+        this.apiVersion = apiVersion;
+        // Dynamically import MSW - it needs to be installed by the user
+        try {
+            const msw = require('msw');
+            this.http = msw.http;
+            this.HttpResponse = msw.HttpResponse;
         }
-        console.log(`[MSW Lambder] Mocking ${apiName}`, body.payload);
-        // Apply delay if specified
-        if (delay > 0) {
-            await new Promise((resolve) => setTimeout(resolve, delay));
+        catch (err) {
+            throw new Error('MSW (Mock Service Worker) is required. Install it with: npm install msw --save-dev');
         }
-        // Generate the response
-        const payload = await responseFactory(body.payload);
-        // Return in Lambder API response format
-        return HttpResponse.json({
-            ...(apiVersion !== null ? { apiVersion } : {}),
-            payload,
+    }
+    /**
+     * Mock an API endpoint with MSW
+     * @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.)
+     */
+    mockApi(apiName, handler, options) {
+        return this.http.post(this.apiPath, async ({ request }) => {
+            let body;
+            try {
+                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) {
+                // 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,
+                    errorMessage: err.message || "Unknown error",
+                };
+                return this.HttpResponse.json(errorResponse, { status: 500 });
+            }
         });
-    });
-}
-/**
- * Creates a mock handler that returns an error for a Lambder API endpoint
- *
- * @example
- * ```typescript
- * mockLambderApiError('user.deleteAccount', 'Account deletion failed')
- * ```
- */
-export function mockLambderApiError(apiName, errorMessage, options) {
-    const apiPath = options?.apiPath ?? '/api';
-    const delay = options?.delay ?? 0;
-    const apiVersion = options?.apiVersion ?? null;
-    // @ts-ignore - MSW is an optional peer dependency
-    const { http, HttpResponse } = require('msw');
-    return http.post(apiPath, async ({ request }) => {
-        const body = (await request.json());
-        if (body.apiName !== apiName) {
-            return;
-        }
-        console.log(`[MSW Lambder] Mocking error for ${apiName}:`, errorMessage);
-        if (delay > 0) {
-            await new Promise((resolve) => setTimeout(resolve, delay));
-        }
-        return HttpResponse.json({
-            ...(apiVersion !== null ? { apiVersion } : {}),
-            payload: null,
-            errorMessage,
-        });
-    });
-}
-/**
- * Creates a mock handler that simulates a session expired error
- *
- * @example
- * ```typescript
- * mockLambderSessionExpired('user.updateProfile')
- * ```
- */
-export function mockLambderSessionExpired(apiName, options) {
-    const apiPath = options?.apiPath ?? '/api';
-    const apiVersion = options?.apiVersion ?? null;
-    // @ts-ignore - MSW is an optional peer dependency
-    const { http, HttpResponse } = require('msw');
-    return http.post(apiPath, async ({ request }) => {
-        const body = (await request.json());
-        if (body.apiName !== apiName) {
-            return;
-        }
-        console.log(`[MSW Lambder] Mocking session expired for ${apiName}`);
-        return HttpResponse.json({
-            ...(apiVersion !== null ? { apiVersion } : {}),
-            payload: null,
-            sessionExpired: true,
-            errorMessage: 'Session expired',
-        });
-    });
-}
-/**
- * Creates a mock handler that simulates a "not authorized" error
- *
- * @example
- * ```typescript
- * mockLambderNotAuthorized('admin.deleteUser')
- * ```
- */
-export function mockLambderNotAuthorized(apiName, options) {
-    const apiPath = options?.apiPath ?? '/api';
-    const apiVersion = options?.apiVersion ?? null;
-    // @ts-ignore - MSW is an optional peer dependency
-    const { http, HttpResponse } = require('msw');
-    return http.post(apiPath, async ({ request }) => {
-        const body = (await request.json());
-        if (body.apiName !== apiName) {
-            return;
-        }
-        console.log(`[MSW Lambder] Mocking not authorized for ${apiName}`);
-        return HttpResponse.json({
-            ...(apiVersion !== null ? { apiVersion } : {}),
-            payload: null,
-            notAuthorized: true,
-            errorMessage: 'Not authorized',
-        });
-    });
-}
-/**
- * Creates a mock handler that simulates a version expired error
- *
- * @example
- * ```typescript
- * mockLambderVersionExpired('user.updateProfile')
- * ```
- */
-export function mockLambderVersionExpired(apiName, options) {
-    const apiPath = options?.apiPath ?? '/api';
-    const apiVersion = options?.apiVersion ?? null;
-    // @ts-ignore - MSW is an optional peer dependency
-    const { http, HttpResponse } = require('msw');
-    return http.post(apiPath, async ({ request }) => {
-        const body = (await request.json());
-        if (body.apiName !== apiName) {
-            return;
-        }
-        console.log(`[MSW Lambder] Mocking version expired for ${apiName}`);
-        return HttpResponse.json({
-            ...(apiVersion !== null ? { apiVersion } : {}),
-            payload: null,
-            versionExpired: true,
-            errorMessage: 'Version expired',
-        });
-    });
-}
-/**
- * Helper to combine multiple Lambder mock handlers
- * Since each handler checks for its specific apiName, you can just spread them into setupWorker/setupServer
- *
- * @deprecated This helper is not needed - just spread handlers directly into setupWorker/setupServer
- * @example
- * ```typescript
- * import { setupServer } from 'msw/node';
- *
- * const server = setupServer(
- *   mockLambderApi('user.getProfile', () => ({ name: 'Test User' })),
- *   mockLambderApi('user.updateProfile', (input) => ({ success: true }))
- * );
- * ```
- */
-export function createLambderApiHandler(apiPath, handlers) {
-    // This is deprecated - users should just spread handlers directly
-    // Kept for backward compatibility
-    return handlers;
+    }
+    /**
+     * Mock an API endpoint that returns a session expired error
+     */
+    mockSessionExpired(apiName) {
+        return this.mockApi(apiName, async () => null, { sessionExpired: true });
+    }
+    /**
+     * Mock an API endpoint that returns a version expired error
+     */
+    mockVersionExpired(apiName) {
+        return this.mockApi(apiName, async () => null, { versionExpired: true });
+    }
+    /**
+     * Mock an API endpoint that returns a not authorized error
+     */
+    mockNotAuthorized(apiName) {
+        return this.mockApi(apiName, async () => null, { notAuthorized: true });
+    }
+    /**
+     * Mock an API endpoint that returns an error message
+     */
+    mockError(apiName, errorMessage) {
+        return this.mockApi(apiName, async () => null, { errorMessage });
+    }
+    /**
+     * Mock an API endpoint with a custom message
+     */
+    mockWithMessage(apiName, handler, message) {
+        return this.mockApi(apiName, handler, { message });
+    }
 }

package/dist/index.d.ts

@@ -4,5 +4,5 @@ export { default as LambderCaller } from "./LambderCaller.js";
 export { default as LambderResponseBuilder } from "./LambderResponseBuilder.js";
 export { default as LambderResolver } from "./LambderResolver.js";
 export { default as LambderSessionManager } from "./LambderSessionManager.js";
+export { default as LambderMSW } from "./LambderMSW.js";
 export { type ApiContractShape, type ApiContract, type ApiInput, type ApiOutput, } from "./LambderApiContract.js";
-export { mockLambderApi, mockLambderApiError, mockLambderSessionExpired, mockLambderNotAuthorized, mockLambderVersionExpired, createLambderApiHandler, } from "./LambderMSW.js";

package/dist/index.js

@@ -4,5 +4,4 @@ export { default as LambderCaller } from "./LambderCaller.js";
 export { default as LambderResponseBuilder } from "./LambderResponseBuilder.js";
 export { default as LambderResolver } from "./LambderResolver.js";
 export { default as LambderSessionManager } from "./LambderSessionManager.js";
-// MSW mocking utilities (optional - requires msw to be installed)
-export { mockLambderApi, mockLambderApiError, mockLambderSessionExpired, mockLambderNotAuthorized, mockLambderVersionExpired, createLambderApiHandler, } from "./LambderMSW.js";
+export { default as LambderMSW } from "./LambderMSW.js";