lambder 2.0.13 → 2.0.15

package/Readme.md

@@ -27,17 +27,16 @@ yarn add lambder zod
 ### Basic Setup
 
 ```typescript
-import Lambder, { InferLambderContract } from 'lambder';
+import Lambder from 'lambder';
 import { z } from 'zod';
 import * as path from 'path';
 
 const lambder = new Lambder({
     apiPath: "/api",
     publicPath: path.resolve(`./public`),
-    // ejsPath: path.resolve(`./ejs-templates`), // Optional
 });
 
-// Enable session and CORS - all chainable!
+// Enable session and CORS
 lambder
     .enableDdbSession({
         tableName: "website-session",
@@ -47,7 +46,7 @@ lambder
     .enableCors(true);
 
 // Define type-safe APIs with Zod schemas
-const app = lambder
+lambder
     .addApi("getCompanyPage", {
         input: z.object({ companyName: z.string() }),
         output: z.object({ id: z.string(), name: z.string(), description: z.string() })
@@ -70,7 +69,7 @@ const app = lambder
     });
 
 // Export the inferred contract for the frontend
-export type AppContract = typeof lambder.ApiContract;
+export type ApiContractType = typeof lambder.ApiContract;
 
 // Export the handler
 export const handler = lambder.getHandler();
@@ -78,8 +77,6 @@ export const handler = lambder.getHandler();
 
 ### Adding Routes
 
-Routes are fully chainable for a fluent interface.
-
 ```typescript
 lambder
     // Define a simple route
@@ -100,25 +97,6 @@ lambder
     .addRoute((ctx)=>ctx.path === '/hello-fn-route', (ctx, res) => {
         return res.html("Hello from a function route");
     })
-    // Define a simple route that serves an EJS template file
-    .addRoute("/product/:productId", async (ctx, res) => {
-        const product = await getProduct(ctx.pathParams.productId);
-        // Serve the file from ejsPath defined above.
-        return await res.ejsFile("productPage.html.ejs", { product });
-    })
-    // Serve sitemap using an ejs template
-    .addRoute("/sitemap", async (ctx, res) => {
-        const templateString = `
-            <?xml version="1.0" encoding="UTF-8"?>
-            <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-            <%~
-                page.urlList.map(url => \`<url><loc>\${url}</loc></url>\`).join("")
-            %>
-            </urlset>
-        `.trim();
-        const urlList = await getUrlList();
-        return await res.ejsTemplate(templateString, { urlList }, { "Content-Type": ["application/xml; charset=utf-8"]});
-    })
     // Match all other paths and serve static files from publicPath
     .addRoute("/(.*)", (ctx, res)=>{
         return res.file(ctx.path, {}, "index.html");
@@ -127,6 +105,14 @@ lambder
     .setRouteFallbackHandler((ctx, res) => {
         return res.status404("Not Found");
     })
+    // Set a fallback handler for unmatched APIs
+    .setApiFallbackHandler((ctx, res) => {
+        return res.api(null, { errorMessage: "API not found" });
+    })
+    // Handle Zod validation errors for API inputs
+    .setApiInputValidationErrorHandler((ctx, res, zodError) => {
+        return res.api(null, { errorMessage: zodError.errors });
+    })
     // Global error handler
     .setGlobalErrorHandler((err, ctx, res) => {
         console.error("Error:", err);
@@ -134,35 +120,21 @@ lambder
     });
 ```
 
-### Adding APIs
+### Session-Protected APIs
 
-All APIs in v2.0 must use Zod schemas for type safety and runtime validation. Use method chaining for a clean API definition.
+Use `addSessionApi` for endpoints that require authentication:
 
 ```typescript
-import { z } from 'zod';
-
-lambder
-    // Add a typed API
-    .addApi("getUserById", {
-        input: z.object({ userId: z.string() }),
-        output: z.object({ id: z.string(), name: z.string(), email: z.string() })
-    }, async (ctx, res) => {
-        // ctx.apiPayload is typed as { userId: string }
-        const user = await db.getUser(ctx.apiPayload.userId);
-        return res.api(user); // Type-checked against output schema
-    })
-    // Session-protected API
-    .addSessionApi("getProfile", {
-        input: z.void(),
-        output: z.object({ userId: z.string(), username: z.string() })
-    }, async (ctx, res) => {
-        // Session is automatically fetched and validated
-        // ctx.session.data contains your session data
-        return res.api({
-            userId: ctx.session.data.userId,
-            username: ctx.session.data.username
-        });
+lambder.addSessionApi("getProfile", {
+    input: z.void(),
+    output: z.object({ userId: z.string(), username: z.string() })
+}, async (ctx, res) => {
+    // Session is automatically fetched and validated
+    return res.api({
+        userId: ctx.session.data.userId,
+        username: ctx.session.data.username
     });
+});
 ```
 
 ### Modular APIs with .use()
@@ -193,10 +165,10 @@ export const userApi = <T>(l: Lambder<T>) => {
 // index.ts
 import { userApi } from "./user-api";
 
-const lambder = new Lambder()
+const lambder = new Lambder({ publicPath: './public' })
     .use(userApi);
 
-export type AppContract = typeof lambder.ApiContract;
+export type ApiContractType = typeof lambder.ApiContract;
 ```
 
 
@@ -217,24 +189,28 @@ lambder
         // Modify response before sending
         console.log("Response status:", response.statusCode);
         return response;
+    })
+    // Fallback hook - runs when no route/API matches
+    .addHook("fallback", async (ctx, res) => {
+        // Perform cleanup or logging for unmatched requests
+        console.log("No handler matched for:", ctx.path);
     });
 ```
 
 ### Session Management
 
-Enable DynamoDB-based session management - fully chainable:
+Enable DynamoDB-based sessions with `enableDdbSession()`. Optional configuration:
 
 ```typescript
-// Enable sessions using a DynamoDB session table - chainable!
-const lambder = new Lambder({ apiPath: '/api', publicPath: './public' })
+lambder
     .enableDdbSession({
         tableName: "website-session",
         tableRegion: "us-east-1",
         sessionSalt: "CHANGE-THIS-TO-A-SECURE-RANDOM-STRING",
         enableSlidingExpiration: true // Optional: extend session on each access
     })
-    .enableCors(true)
-    .addApi(...);
+    // Optionally customize session cookie names (defaults: LMDRSESSIONTKID, LMDRSESSIONCSTK)
+    .setSessionCookieKey("MY_SESSION_TOKEN", "MY_CSRF_TOKEN");
 ```
 
 #### DynamoDB Session Table Structure
@@ -247,71 +223,17 @@ See [docs/DYNAMODB_SETUP.md](docs/DYNAMODB_SETUP.md) for detailed setup instruct
 
 #### Session Controller
 
-After enabling sessions, you can access the session controller:
-
-```typescript
-const sessionController = lambder.getSessionController(ctx);
-
-// Available methods:
-await sessionController.createSession(sessionKey, data, ttlInSeconds);
-// Starts a new session and persists the session data to DDB.
+Access the session controller with `lambder.getSessionController(ctx)`:
 
-await sessionController.fetchSession();
-// Fetch and validate if there is an existing session
-// This is automatically done for addSessionRoute and addSessionApi
-// Throws if session not found
-
-await sessionController.fetchSessionIfExists();
-// Returns session if found, otherwise null
-
-await sessionController.updateSessionData(updatedData);
-// Updates the active session's data and persists it to DDB
-
-await sessionController.endSession();
-// End session and delete from DDB
-
-await sessionController.endSessionAll();
-// Ends and deletes all sessions for this sessionKey across all devices
-
-await sessionController.regenerateSession();
-// Regenerates session token (use after password change, etc.)
-```
-
-#### Session Examples
-
-```typescript
-lambder
-    .addApi("createSession", {
-        input: z.object({ userId: z.string() }),
-        output: z.object({ success: z.boolean() })
-    }, async (ctx, res) => {
-        // Create a new session
-        const userId = ctx.apiPayload.userId;
-        await lambder.getSessionController(ctx)
-            .createSession(userId, { business: "Session data goes here" });
-        
-        console.log(ctx.session?.sessionKey); // userId
-        console.log(ctx.session?.data?.business); // "Session data goes here"
-        
-        return res.api({ success: true });
-    })
-    .addSessionApi("updateSession", {
-        input: z.object({ newData: z.string() }),
-        output: z.object({ success: z.boolean() })
-    }, async (ctx, res) => {
-        // Session is automatically fetched
-        console.log(ctx.session.sessionKey); // userId
-        
-        // Update session data
-        await lambder.getSessionController(ctx)
-            .updateSessionData({ business2: ctx.apiPayload.newData });
-        
-        console.log(ctx.session.data.business); // undefined
-        console.log(ctx.session.data.business2); // newData value
-        
-        return res.api({ success: true });
-    });
-```
+| Method | Description |
+|--------|-------------|
+| `createSession(sessionKey, data?, ttlInSeconds?)` | Start new session, persist to DDB |
+| `fetchSession()` | Fetch & validate existing session (throws if not found) |
+| `fetchSessionIfExists()` | Returns session or null |
+| `updateSessionData(newData)` | Update session data in DDB |
+| `endSession()` | End session, delete from DDB |
+| `endSessionAll()` | End all sessions for this sessionKey (all devices) |
+| `regenerateSession()` | Regenerate token (use after password change) |
 
 ### EJS Templates
 
@@ -339,75 +261,52 @@ Example partial:
 
 ### Render Context (ctx) Variables
 
-```typescript
-lambder
-    .addApi("exampleApi", {
-        input: z.object({ value: z.string() }),
-        output: z.object({ result: z.string() })
-    }, async (ctx, res) => {
-        const { 
-            host,        // Request host: "www.example.com"
-            path,        // Request path: "/api"
-            get,         // GET query parameters: { userId: "342" }
-            post,        // POST body (parsed): { userId: "342" }
-            cookie,      // Cookies: { "rememberMe": "true" }
-            headers,     // Request headers
-            apiName,     // API name: "exampleApi"
-            apiPayload,  // Validated input (same as post.payload)
-            session,     // Session (null for addApi, available for addSessionApi)
-        } = ctx;
-        
-        return res.api({ result: ctx.apiPayload.value });
-    });
-```
+The `ctx` object provides access to request data:
+
+| Property | Description | Example |
+|----------|-------------|----------|
+| `host` | Request host | `"www.example.com"` |
+| `path` | Request path | `"/api"` |
+| `pathParams` | Path parameters (routes) | `{ userId: "123" }` |
+| `method` | HTTP method | `"GET"`, `"POST"` |
+| `get` | Query parameters | `{ page: "1" }` |
+| `post` | POST body (parsed) | `{ name: "John" }` |
+| `cookie` | Cookies | `{ rememberMe: "true" }` |
+| `headers` | Request headers | `{ "Content-Type": "..." }` |
+| `event` | Raw APIGatewayProxyEvent | - |
+| `lambdaContext` | AWS Lambda Context | - |
+| `apiName` | API name (for API calls) | `"getUser"` |
+| `apiPayload` | Validated input | `{ userId: "123" }` |
+| `session` | Session data | Available in `addSessionApi` |
 
 ### Resolver Methods
 
-Available response methods:
-
-```typescript
-return res.raw(param);
-// Sends a custom HTTP response. Useful for non-standard responses.
-
-return res.json(data, headers);
-// Sends a JSON response with optional headers.
-
-return res.xml(data);
-// Sends an XML response (base64 encoded).
-
-return res.html(data, headers); 
-// Sends an HTML response (base64 encoded).
-
-return res.status301(url, headers); 
-// Redirects to the specified URL with a 301 status code.
-
-return res.status404(data, headers); 
-// Sends a 404 Not Found response.
-
-return res.cors(); 
-// Sends a 200 OK response with CORS headers (for preflight requests).
-
-return res.fileBase64(fileBase64, mimeType, headers); 
-// Sends a file response from base64 content.
-
-return res.file(filePath, headers, fallbackFilePath); 
-// Serves a file from the public directory.
-
-return await res.ejsFile(filePath, pageData, headers); 
-// Renders and serves an EJS file.
-
-return await res.ejsTemplate(template, pageData, headers); 
-// Renders and serves an EJS template string.
-
-return res.api(payload, config, headers); 
-// Sends a standardized API response for use with LambderCaller.
-// Config: { notAuthorized, message, errorMessage, versionExpired, sessionExpired }
-
-// res.die.* - Same as res.* but immediately returns and skips afterRender hooks
-return res.die.json(data, headers); 
-return res.die.api(payload, config, headers);
-// ... etc
-```
+**Header Manipulation** (call before returning response):
+- `res.addHeader(key, value)` - Adds a header value (can be called multiple times for same key)
+- `res.setHeader(key, value)` - Sets a header (replaces existing values)
+- `res.logToApiResponse(data)` - Adds data to logList in API responses (debugging)
+
+**Response Methods**:
+
+| Method | Description |
+|--------|-------------|
+| `res.raw(param)` | Custom HTTP response |
+| `res.json(data, headers?)` | JSON response |
+| `res.xml(data)` | XML response (base64 encoded) |
+| `res.html(data, headers?)` | HTML response (base64 encoded) |
+| `res.redirect(url, statusCode?, headers?)` | Redirect (default: 302) |
+| `res.status404(data, headers?)` | 404 Not Found response |
+| `res.cors()` | 200 OK with CORS headers (preflight) |
+| `res.fileBase64(base64, mimeType, headers?)` | File from base64 content |
+| `res.file(path, headers?, fallbackPath?)` | Serve file from public directory |
+| `await res.ejsFile(path, pageData, headers?)` | Render EJS file |
+| `await res.ejsTemplate(template, pageData, headers?)` | Render EJS template string |
+| `res.api(payload, config?, headers?)` | Standardized API response |
+| `res.apiBinary(payload, config?, headers?)` | Gzip-compressed API response |
+
+**API Config Options**: `{ notAuthorized, message, errorMessage, versionExpired, sessionExpired, logList }`
+
+**Die Methods**: `res.die.*` - Same as above but immediately returns, skipping `afterRender` hooks.
 
 ## Frontend Usage with LambderCaller
 
@@ -417,9 +316,9 @@ LambderCaller is a frontend companion library for Lambder (only 2kb compressed)
 
 ```typescript
 import { LambderCaller } from "lambder";
-import type { AppContract } from "./backend/handler"; // Import the inferred contract type
+import type { ApiContractType } from "./backend/handler"; // Import the inferred contract type
 
-const lambderCaller = new LambderCaller<AppContract>({
+const lambderCaller = new LambderCaller<ApiContractType>({
     apiPath: "/api",
     isCorsEnabled: false,
     fetchStartedHandler: ({ fetchParams, activeFetchList }) => {
@@ -441,38 +340,6 @@ const user = await lambderCaller.api("getCompanyPage", { companyName: "Acme" });
 // - Expected output type
 ```
 
-### How Type Safety Works
-
-1. **Backend**: Chain your APIs and export the inferred contract
-```typescript
-// backend/handler.ts
-import Lambder from 'lambder';
-import { z } from 'zod';
-
-const lambder = new Lambder({ apiPath: '/api' })
-    .addApi('getUser', {
-        input: z.object({ userId: z.string() }),
-        output: z.object({ id: z.string(), name: z.string() })
-    }, async (ctx, res) => {
-        return res.api({ id: ctx.apiPayload.userId, name: "John" });
-    });
-
-export type AppContract = typeof lambder.ApiContract;
-export const handler = lambder.getHandler();
-```
-
-2. **Frontend**: Import the **type** (not the code) and use it
-```typescript
-// frontend/api.ts
-import { LambderCaller } from 'lambder';
-import type { AppContract } from '../backend/handler'; // Type-only import
-
-const lambderCaller = new LambderCaller<AppContract>({ apiPath: '/api' });
-
-// ✅ Fully typed - TypeScript knows all APIs and their input/output types
-const user = await lambderCaller.api('getUser', { userId: '123' });
-```
-
 ### Benefits
 
 ✅ **No Manual Type Definitions** - Types are inferred from your Zod schemas  
@@ -491,9 +358,9 @@ LambderMSW provides seamless integration with [MSW (Mock Service Worker)](https:
 ```typescript
 import { LambderMSW } from 'lambder';
 import { setupServer } from 'msw/node';
-import type { AppContract } from './backend/handler';
+import type { ApiContractType } from './backend/handler';
 
-const lambderMSW = new LambderMSW<AppContract>({
+const lambderMSW = new LambderMSW<ApiContractType>({
     apiPath: '/api',
 });
 

package/dist/Lambder.d.ts

@@ -46,7 +46,7 @@ export default class Lambder<TSessionData = any, _TContract extends Record<strin
      * @example
      * ```typescript
      * const lambder = new Lambder().addApi(...).addApi(...);
-     * export type AppContract = typeof lambder.ApiContract;
+     * export type ApiContractType = typeof lambder.ApiContract;
      * ```
      */
     readonly ApiContract: _TContract;

package/dist/Lambder.js

@@ -33,7 +33,7 @@ export default class Lambder {
      * @example
      * ```typescript
      * const lambder = new Lambder().addApi(...).addApi(...);
-     * export type AppContract = typeof lambder.ApiContract;
+     * export type ApiContractType = typeof lambder.ApiContract;
      * ```
      */
     ApiContract;
@@ -120,10 +120,9 @@ export default class Lambder {
     }
     addRoute(condition, actionFn) {
         this.actionList.push({
-            conditionFn: (ctx) => (ctx.method === "GET" &&
-                ((typeof condition === "string" && this.testPatternMatch(condition, ctx.path)) ||
-                    (typeof condition === "function" && condition(ctx)) ||
-                    (condition?.constructor == RegExp && condition.test(ctx.path)))),
+            conditionFn: (ctx) => (((typeof condition === "string" && this.testPatternMatch(condition, ctx.path)) ||
+                (typeof condition === "function" && condition(ctx)) ||
+                (condition?.constructor == RegExp && condition.test(ctx.path)))),
             actionFn: async (ctx, resolver) => {
                 if (typeof condition === "string") {
                     ctx.pathParams = this.getPatternMatch(condition, ctx.path);
@@ -139,10 +138,9 @@ export default class Lambder {
     }
     addSessionRoute(condition, actionFn) {
         this.actionList.push({
-            conditionFn: (ctx) => (ctx.method === "GET" &&
-                ((typeof condition === "string" && this.testPatternMatch(condition, ctx.path)) ||
-                    (typeof condition === "function" && condition(ctx)) ||
-                    (condition?.constructor == RegExp && condition.test(ctx.path)))),
+            conditionFn: (ctx) => (((typeof condition === "string" && this.testPatternMatch(condition, ctx.path)) ||
+                (typeof condition === "function" && condition(ctx)) ||
+                (condition?.constructor == RegExp && condition.test(ctx.path)))),
             actionFn: async (ctx, resolver) => {
                 if (typeof condition === "string") {
                     ctx.pathParams = this.getPatternMatch(condition, ctx.path);

package/docs/LAMBDER_MSW.md

@@ -31,14 +31,6 @@ const handlers = [
             name: 'John Doe',
             email: 'john@example.com'
         };
-    }),
-    
-    lambderMSW.mockApi('createUser', async (payload) => {
-        return {
-            id: '123',
-            name: payload.name,
-            email: payload.email
-        };
     })
 ];
 
@@ -60,7 +52,7 @@ When using TypeScript API contracts, LambderMSW provides full type safety:
 import { z } from 'zod';
 import Lambder from 'lambder';
 
-const lambder = new Lambder({ apiPath: '/secure' })
+const lambder = new Lambder({ apiPath: '/secure', publicPath: './public' })
     .addApi('getUserById', {
         input: z.object({ userId: z.string() }),
         output: z.object({ id: z.string(), name: z.string(), email: z.string() })
@@ -77,13 +69,13 @@ const lambder = new Lambder({ apiPath: '/secure' })
     });
 
 // Export the inferred contract type
-export type MyApiContract = typeof lambder.ApiContract;
+export type ApiContractType = typeof lambder.ApiContract;
 
 // test/setup.ts
 import { LambderMSW } from 'lambder';
-import type { MyApiContract } from '../backend';
+import type { ApiContractType } from '../backend';
 
-const lambderMSW = new LambderMSW<MyApiContract>({
+const lambderMSW = new LambderMSW<ApiContractType>({
     apiPath: '/secure',
     apiVersion: '1.0.0'
 });
@@ -215,12 +207,11 @@ lambderMSW.mockWithMessage('updateProfile', async (payload) => {
 // 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 '../backend'; // Type-only import from your backend
+import { LambderMSW, LambderCaller } from 'lambder';
+import type { ApiContractType } from '../backend'; // Type-only import from your backend
 
 // Setup MSW
-const lambderMSW = new LambderMSW<MyApiContract>({
+const lambderMSW = new LambderMSW<ApiContractType>({
     apiPath: '/secure',
     apiVersion: '1.0.0'
 });
@@ -257,7 +248,7 @@ afterEach(() => server.resetHandlers());
 afterAll(() => server.close());
 
 // Setup LambderCaller
-const lambderCaller = new LambderCaller<MyApiContract>({
+const lambderCaller = new LambderCaller<ApiContractType>({
     apiPath: '/secure',
     isCorsEnabled: false
 });
@@ -314,9 +305,9 @@ LambderMSW also works in browser environments with MSW's browser integration:
 // test/browser-setup.ts
 import { setupWorker } from 'msw/browser';
 import { LambderMSW } from 'lambder';
-import type { MyApiContract } from '../backend'; // Type-only import from your backend
+import type { ApiContractType } from '../backend'; // Type-only import from your backend
 
-const lambderMSW = new LambderMSW<MyApiContract>({
+const lambderMSW = new LambderMSW<ApiContractType>({
     apiPath: '/secure'
 });
 
@@ -361,25 +352,6 @@ lambderMSW.mockApi('searchUsers', async (payload) => {
 });
 ```
 
-### 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
@@ -402,12 +374,10 @@ it('should handle specific user', async () => {
 
 ## 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.)  
+- Full TypeScript support with API contracts
+- Intuitive methods matching Lambder's API structure
+- Test isolation without real backend dependencies
+- Simulate real-world scenarios (delays, errors, etc.)
 
 ## Troubleshooting
 

package/docs/TYPE_SAFE_QUICK_START.md

@@ -29,7 +29,7 @@ const lambder = new Lambder({
 });
 
 // Export the inferred contract type
-export type AppContract = typeof lambder.ApiContract;
+export type ApiContractType = typeof lambder.ApiContract;
 
 export const handler = lambder.getHandler();
 ```
@@ -40,9 +40,9 @@ Import the type (not the code) and use `LambderCaller`.
 
 ```typescript
 import { LambderCaller } from "lambder";
-import type { AppContract } from "./backend"; // Type-only import
+import type { ApiContractType } from "./backend"; // Type-only import
 
-const lambderCaller = new LambderCaller<AppContract>({
+const lambderCaller = new LambderCaller<ApiContractType>({
     apiPath: "/api"
 });
 
@@ -72,6 +72,6 @@ export const userApi = <T>(l: Lambder<T>) => {
 // index.ts
 import { userApi } from "./api.user";
 
-const lambder = new Lambder()
+const lambder = new Lambder({ publicPath: './public' })
     .use(userApi); // Types are preserved!
 ```

package/examples/msw-testing-example.ts

@@ -22,7 +22,7 @@ import { LambderMSW, LambderCaller } from '../src/index.ts';
 import Lambder from '../src/Lambder.js';
 
 // Define your API contract using Lambder chaining
-const lambder = new Lambder()
+const lambder = new Lambder({ publicPath: './public' })
     .addApi('getUserById', {
         input: z.object({ userId: z.string() }),
         output: z.object({ id: z.string(), name: z.string(), email: z.string() }).nullable()
@@ -40,10 +40,10 @@ const lambder = new Lambder()
         output: z.object({ success: z.boolean() })
     }, async () => ({} as any));
 
-type TestApiContract = typeof lambder.ApiContract;
+type ApiContractType = typeof lambder.ApiContract;
 
 // Setup LambderMSW with type safety
-const lambderMSW = new LambderMSW<TestApiContract>({
+const lambderMSW = new LambderMSW<ApiContractType>({
     apiPath: '/secure',
     apiVersion: '1.0.0',
 });
@@ -92,7 +92,7 @@ const handlers = [
 const server = setupServer(...handlers);
 
 // Setup LambderCaller
-const lambderCaller = new LambderCaller<TestApiContract>({
+const lambderCaller = new LambderCaller<ApiContractType>({
     apiPath: '/secure',
     isCorsEnabled: false,
 });

package/examples/zod-chained-api-example.ts

@@ -45,8 +45,8 @@ const lambder = new Lambder({
         });
     });
 
-// 3. Export the inferred contract type for Frontend
-export type AppContract = typeof lambder.ApiContract;
+// 3. Export the inferred contract type for frontend use
+export type ApiContractType = typeof lambder.ApiContract;
 
 // 4. Modular example using .use()
 const authApi = <T>(l: Lambder<T>) => {

package/package.json

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

package/src/Lambder.ts

@@ -58,7 +58,7 @@ export default class Lambder<TSessionData = any, _TContract extends Record<strin
      * @example
      * ```typescript
      * const lambder = new Lambder().addApi(...).addApi(...);
-     * export type AppContract = typeof lambder.ApiContract;
+     * export type ApiContractType = typeof lambder.ApiContract;
      * ```
      */
     public readonly ApiContract!: _TContract;
@@ -163,7 +163,6 @@ export default class Lambder<TSessionData = any, _TContract extends Record<strin
     addRoute(condition: Path|ConditionFunction|RegExp, actionFn: ActionFunction): this {
         this.actionList.push({ 
             conditionFn: (ctx:LambderRenderContext<any>) => (
-                ctx.method === "GET" && 
                 (
                     (typeof condition === "string" && this.testPatternMatch(condition, ctx.path)) ||
                     (typeof condition === "function" && condition(ctx)) ||
@@ -187,7 +186,6 @@ export default class Lambder<TSessionData = any, _TContract extends Record<strin
     addSessionRoute(condition: Path|ConditionFunction|RegExp, actionFn: SessionActionFunction<TSessionData>): this {
         this.actionList.push({ 
             conditionFn: (ctx:LambderRenderContext<any>) => (
-                ctx.method === "GET" &&
                 (
                     (typeof condition === "string" && this.testPatternMatch(condition, ctx.path)) ||
                     (typeof condition === "function" && condition(ctx)) ||

package/tests/routes.test.ts

@@ -518,13 +518,13 @@ describe('Routes - Wildcard and Catch-all Routes', () => {
 });
 
 describe('Routes - Method Filtering', () => {
-    it('should only match GET requests', async () => {
+    it('should match all HTTP methods when no method is specified', async () => {
         const lambder = new Lambder({
             publicPath: './public',
             apiPath: '/api'
         })
             .addRoute('/resource', (ctx, res) => {
-                return res.html('GET Response');
+                return res.html(`${ctx.method} Response`);
             });
 
         const handler = lambder.getHandler();
@@ -534,9 +534,10 @@ describe('Routes - Method Filtering', () => {
         const getResult = await handler(getEvent, createMockContext());
         expect(Buffer.from(getResult.body || '', 'base64').toString()).toBe('GET Response');
 
-        // POST should not match routes (should hit fallback)
+        // POST should also work (no method restriction)
         const postEvent = createMockEvent('/resource', 'POST');
         const postResult = await handler(postEvent, createMockContext());
-        expect(postResult.statusCode).toBe(204); // Default fallback
+        expect(postResult.statusCode).toBe(200);
+        expect(Buffer.from(postResult.body || '', 'base64').toString()).toBe('POST Response');
     });
 });

package/tests/UNTESTED_FEATURES.md

@@ -1,263 +0,0 @@
-# Untested Features in Lambder
-
-This document lists features that currently lack test coverage.
-
-## ✅ Currently Tested Features
-
-Based on existing test files:
-
-1. **Type Safety** (`type-safety.test.ts`)
-   - LambderCaller type inference
-   - Lambder API type safety
-   - Input/output type enforcement
-   - Complex type patterns
-   - Type inference from contracts
-
-2. **Session Management** (`session.test.ts`)
-   - Session creation, fetching, updating, deletion
-   - Session regeneration
-   - Session security (CSRF, validation)
-   - Session type safety
-   - Sliding expiration
-
-3. **Output Type Runtime** (`output-type-runtime.test.ts`)
-   - Runtime validation of API outputs
-   - Zod schema enforcement at runtime
-   - API response format validation
-
-4. **Plugin System** (`use-plugin.test.ts`)
-   - Basic plugin usage
-   - Multiple plugin chaining
-   - Plugin type accumulation
-   - Nested plugins
-   - Plugin reusability
-
-## ❌ Untested Features (Needs Test Coverage)
-
-### 1. Routes (`addRoute`, `addSessionRoute`)
-**Priority: HIGH**
-
-- [x] Basic route matching (string paths)
-- [ ] Path parameter extraction (e.g., `/user/:userId`)
-- [ ] RegExp route matching
-- [ ] Function-based conditional routing
-- [ ] Session-protected routes (`addSessionRoute`)
-- [ ] Route priority/ordering
-- [ ] Wildcard routes
-
-**Suggested test file:** `tests/routes.test.ts`
-
-### 2. Hooks System
-**Priority: HIGH**
-
-- [ ] `beforeRender` hook execution
-- [ ] `afterRender` hook execution
-- [ ] `fallback` hook execution
-- [ ] `created` hook execution
-- [ ] Hook priority ordering
-- [ ] Multiple hooks of same type
-- [ ] Hook error handling
-- [ ] Context modification in hooks
-- [ ] Response modification in hooks
-
-**Suggested test file:** `tests/hooks.test.ts`
-
-### 3. Error Handling
-**Priority: HIGH**
-
-- [ ] `setGlobalErrorHandler` functionality
-- [ ] Error handling with context available
-- [ ] Error handling with null context
-- [ ] Custom error responses
-- [ ] Error in API handlers
-- [ ] Error in route handlers
-- [ ] Error in hooks
-- [ ] Error log accumulation
-
-**Suggested test file:** `tests/error-handling.test.ts`
-
-### 4. Fallback Handlers
-**Priority: MEDIUM**
-
-- [ ] `setRouteFallbackHandler` for unmatched routes
-- [ ] `setApiFallbackHandler` for unmatched APIs
-- [ ] Default fallback behavior (no handler set)
-- [ ] Fallback handler with custom responses
-
-**Suggested test file:** `tests/fallback-handlers.test.ts`
-
-### 5. Response Methods (LambderResolver/LambderResponseBuilder)
-**Priority: MEDIUM**
-
-- [x] `res.api()` - tested in output-type-runtime
-- [ ] `res.json()`
-- [ ] `res.html()`
-- [ ] `res.xml()`
-- [ ] `res.raw()`
-- [ ] `res.file()` with fallback
-- [ ] `res.fileBase64()`
-- [ ] `res.ejsFile()`
-- [ ] `res.ejsTemplate()`
-- [ ] `res.redirect()` (redirects)
-- [ ] `res.status404()`
-- [ ] `res.cors()`
-- [ ] `res.die.*` methods (skip afterRender hooks)
-- [ ] Custom headers in responses
-- [ ] `setHeader()` and `addHeader()` in context
-
-**Suggested test file:** `tests/response-methods.test.ts`
-
-### 6. CORS Support
-**Priority: MEDIUM**
-
-- [ ] `enableCors(true)` functionality
-- [ ] CORS headers in responses
-- [ ] OPTIONS request handling (preflight)
-- [ ] CORS disabled behavior
-
-**Suggested test file:** `tests/cors.test.ts`
-
-### 7. API Version Management
-**Priority: MEDIUM**
-
-- [ ] Setting `apiVersion` in constructor
-- [ ] Version mismatch detection
-- [ ] Version expired response
-- [ ] Client version validation
-- [ ] Version header handling
-
-**Suggested test file:** `tests/api-versioning.test.ts`
-
-### 8. Context Variables
-**Priority: LOW**
-
-- [ ] `ctx.host` extraction
-- [ ] `ctx.path` extraction
-- [ ] `ctx.pathParams` for route parameters
-- [ ] `ctx.get` (query parameters)
-- [ ] `ctx.post` (POST body parsing)
-- [ ] `ctx.cookie` parsing
-- [ ] `ctx.headers` access
-- [ ] `ctx.event` (raw Lambda event)
-- [ ] `ctx.lambdaContext` (raw Lambda context)
-- [ ] Base64 encoded body handling
-- [ ] URL-encoded form data parsing
-
-**Suggested test file:** `tests/context-extraction.test.ts`
-
-### 9. LambderCaller Features
-**Priority: MEDIUM**
-
-- [x] Basic API calls - tested in type-safety
-- [ ] `apiRaw()` method
-- [ ] `fetchStartedHandler` callback
-- [ ] `fetchEndedHandler` callback
-- [ ] `errorMessageHandler` callback
-- [ ] `activeFetchList` tracking
-- [ ] Error response handling
-- [ ] Session expired handling
-- [ ] Version expired handling
-- [ ] Not authorized handling
-- [ ] Custom headers in requests
-- [ ] CORS mode handling
-
-**Suggested test file:** `tests/lambder-caller.test.ts`
-
-### 10. LambderMSW Features
-**Priority: MEDIUM**
-
-- [ ] `mockApi()` basic functionality
-- [ ] `mockSessionExpired()` helper
-- [ ] `mockNotAuthorized()` helper
-- [ ] `mockVersionExpired()` helper
-- [ ] Custom mock options (delay, message, errorMessage)
-- [ ] Type safety in mocks
-- [ ] Multiple API mocks
-- [ ] Mock priority/ordering
-
-**Suggested test file:** `tests/lambder-msw.test.ts`
-
-### 11. EJS Template Rendering
-**Priority: LOW**
-
-- [ ] `res.ejsFile()` rendering
-- [ ] `res.ejsTemplate()` rendering
-- [ ] Template `page` variable
-- [ ] Partial `partial` variable
-- [ ] `include()` function in templates
-- [ ] Template error handling
-- [ ] Custom headers with EJS
-
-**Suggested test file:** `tests/ejs-templates.test.ts`
-
-### 12. File Serving
-**Priority: LOW**
-
-- [ ] Static file serving with `res.file()`
-- [ ] Fallback file (e.g., index.html)
-- [ ] MIME type detection
-- [ ] Base64 file responses
-- [ ] File not found handling
-- [ ] Public path configuration
-
-**Suggested test file:** `tests/file-serving.test.ts`
-
-### 13. Utility Methods
-**Priority: LOW**
-
-- [ ] `lambder.utils.*` methods
-- [ ] `getSessionController()` helper
-- [ ] `getResponseBuilder()` helper
-- [ ] `getHandler()` export
-
-**Suggested test file:** `tests/utilities.test.ts`
-
-### 14. Edge Cases & Integration
-**Priority: LOW**
-
-- [ ] Multiple simultaneous requests
-- [ ] Race conditions in session management
-- [ ] Large payload handling
-- [ ] Invalid JSON in request body
-- [ ] Missing required fields
-- [ ] Empty/null payloads
-- [ ] Very long session data
-- [ ] Malformed Lambda events
-
-**Suggested test file:** `tests/edge-cases.test.ts`
-
-## Test Coverage Priorities
-
-### Must Have (Before v2.0 stable)
-1. Routes and path parameters
-2. Hooks system
-3. Error handling
-4. Response methods (at least common ones)
-
-### Should Have (Before v2.1)
-1. CORS support
-2. API versioning
-3. LambderCaller edge cases
-4. Fallback handlers
-
-### Nice to Have (Future releases)
-1. EJS templates
-2. File serving
-3. Edge cases and stress testing
-4. Integration tests
-
-## How to Run Tests
-
-```bash
-# Run all tests
-npm run test
-
-# Run specific test file
-npm run test -- tests/routes.test.ts
-
-# Run tests in watch mode
-npm run test -- --watch
-
-# Run tests with coverage
-npm run test -- --coverage
-```