lambder 2.0.4 → 2.0.7

package/Readme.md

@@ -70,7 +70,7 @@ const app = lambder
     });
 
 // Export the inferred contract for the frontend
-export type AppContract = typeof lambder.ApiContractType;
+export type AppContract = typeof lambder.ApiContract;
 
 // Export the handler
 export const handler = lambder.getHandler();
@@ -196,7 +196,7 @@ import { userApi } from "./user-api";
 const lambder = new Lambder()
     .use(userApi);
 
-export type AppContract = typeof lambder.ApiContractType;
+export type AppContract = typeof lambder.ApiContract;
 ```
 
 
@@ -457,7 +457,7 @@ const lambder = new Lambder({ apiPath: '/api' })
         return res.api({ id: ctx.apiPayload.userId, name: "John" });
     });
 
-export type AppContract = typeof lambder.ApiContractType;
+export type AppContract = typeof lambder.ApiContract;
 export const handler = lambder.getHandler();
 ```
 

package/dist/Lambder.d.ts

@@ -1,43 +1,12 @@
 import { z } from "zod";
-import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
+import type { APIGatewayProxyEvent, Context } from "aws-lambda";
 import LambderResolver from "./LambderResolver.js";
 import LambderResponseBuilder, { LambderResolverResponse } from "./LambderResponseBuilder.js";
 import LambderUtils from "./LambderUtils.js";
-import { type LambderSessionContext } from "./LambderSessionManager.js";
 import LambderSessionController from "./LambderSessionController.js";
 import type { MergeContract } from "./LambderApiContract.js";
+import { type LambderRenderContext, type LambderSessionRenderContext } from "./LambderContext.js";
 type Path = `/${string}`;
-export type LambderRenderContext<TApiPayload = any> = {
-    host: string;
-    path: string;
-    pathParams: Record<string, any> | null;
-    method: string;
-    get: Record<string, any>;
-    post: Record<string, any>;
-    cookie: Record<string, any>;
-    session: null;
-    apiName: string;
-    apiPayload: TApiPayload;
-    headers: APIGatewayProxyEventHeaders;
-    event: APIGatewayProxyEvent;
-    lambdaContext: Context;
-    _otherInternal: {
-        isApiCall: boolean;
-        requestVersion: string | null;
-        setHeaderFnAccumulator: {
-            key: string;
-            value: string | string[];
-        }[];
-        addHeaderFnAccumulator: {
-            key: string;
-            value: string;
-        }[];
-        logToApiResponseAccumulator: any[];
-    };
-};
-export type LambderSessionRenderContext<TApiPayload = any, SessionData = any> = Omit<LambderRenderContext<TApiPayload>, 'session'> & {
-    session: LambderSessionContext<SessionData>;
-};
 type ConditionFunction = (ctx: LambderRenderContext<any>) => boolean;
 type ActionFunction = (ctx: LambderRenderContext<any>, resolver: LambderResolver) => LambderResolverResponse | Promise<LambderResolverResponse>;
 type SessionActionFunction<SessionData = any> = (ctx: LambderSessionRenderContext<any, SessionData>, resolver: LambderResolver) => LambderResolverResponse | Promise<LambderResolverResponse>;
@@ -48,7 +17,7 @@ type HookFallbackFunction = (ctx: LambderRenderContext<any>, resolver: LambderRe
 type GlobalErrorHandlerFunction = (err: Error, ctx: LambderRenderContext<any> | null, response: LambderResponseBuilder, logListToApiResponse?: any[]) => LambderResolverResponse | Promise<LambderResolverResponse>;
 type RouteFallbackHandlerFunction = (ctx: LambderRenderContext<any>, resolver: LambderResolver) => LambderResolverResponse;
 type ApiFallbackHandlerFunction = (ctx: LambderRenderContext<any>, resolver: LambderResolver) => LambderResolverResponse;
-export declare const createContext: (event: APIGatewayProxyEvent, lambdaContext: Context, apiPath: string) => LambderRenderContext<any>;
+type ApiInputValidationErrorHandlerFunction = (ctx: LambderRenderContext<any>, resolver: LambderResolver, zodError: z.ZodError) => LambderResolverResponse | Promise<LambderResolverResponse>;
 /**
  * Main Lambder class for building type-safe serverless APIs
  *
@@ -77,15 +46,16 @@ export default class Lambder<TSessionData = any, _TContract extends Record<strin
      * @example
      * ```typescript
      * const lambder = new Lambder().addApi(...).addApi(...);
-     * export type AppContract = typeof lambder.ApiContractType;
+     * export type AppContract = typeof lambder.ApiContract;
      * ```
      */
-    readonly ApiContractType: _TContract;
+    readonly ApiContract: _TContract;
     private actionList;
     private hookList;
     private globalErrorHandler;
     private routeFallbackHandler;
     private apiFallbackHandler;
+    private apiInputValidationErrorHandler;
     utils: LambderUtils;
     private lambderSessionManager?;
     private sessionTokenCookieKey;
@@ -109,6 +79,7 @@ export default class Lambder<TSessionData = any, _TContract extends Record<strin
     setSessionCookieKey(sessionTokenCookieKey: string, sessionCsrfCookieKey: string): this;
     setRouteFallbackHandler(routeFallbackHandler: RouteFallbackHandlerFunction): this;
     setApiFallbackHandler(apiFallbackHandler: ApiFallbackHandlerFunction): this;
+    setApiInputValidationErrorHandler(apiInputValidationErrorHandler: ApiInputValidationErrorHandlerFunction): this;
     setGlobalErrorHandler(globalErrorHandler: GlobalErrorHandlerFunction): this;
     private getPatternMatch;
     private testPatternMatch;

package/dist/Lambder.js

@@ -1,53 +1,10 @@
-import cookieParser from "cookie";
 import { match } from "path-to-regexp";
 import LambderResolver from "./LambderResolver.js";
 import LambderResponseBuilder from "./LambderResponseBuilder.js";
 import LambderUtils from "./LambderUtils.js";
 import LambderSessionManager from "./LambderSessionManager.js";
 import LambderSessionController from "./LambderSessionController.js";
-export const createContext = (event, lambdaContext, apiPath) => {
-    const host = event.headers.Host || event.headers.host || "";
-    const path = event.path;
-    const pathParams = null;
-    const get = event.queryStringParameters || {};
-    const method = event.httpMethod;
-    const cookie = cookieParser.parse(event.headers.Cookie || event.headers.cookie || "");
-    const headers = event.headers;
-    // Decode body for the post
-    let post = {};
-    try {
-        const decodedBody = event.isBase64Encoded ? (event.body ? Buffer.from(event.body, "base64").toString() : "{}") : (event.body || "{}");
-        try {
-            post = JSON.parse(decodedBody) || {};
-        }
-        catch (e) {
-            const params = new URLSearchParams(decodedBody);
-            post = {};
-            for (const [key, value] of params.entries()) {
-                post[key] = value;
-            }
-        }
-    }
-    catch (e) { }
-    // Parse api variables
-    const isApiCall = method === "POST" && apiPath && path === apiPath && post.apiName;
-    const apiName = isApiCall ? post.apiName : null;
-    const apiPayload = isApiCall ? post.payload : null;
-    const requestVersion = isApiCall ? post.version : null;
-    return {
-        host, path, pathParams, method,
-        get, post, cookie, event,
-        session: null,
-        apiName, apiPayload,
-        headers, lambdaContext,
-        _otherInternal: {
-            isApiCall, requestVersion,
-            setHeaderFnAccumulator: [],
-            addHeaderFnAccumulator: [],
-            logToApiResponseAccumulator: [],
-        }
-    };
-};
+import { createContext } from "./LambderContext.js";
 /**
  * Main Lambder class for building type-safe serverless APIs
  *
@@ -76,15 +33,16 @@ export default class Lambder {
      * @example
      * ```typescript
      * const lambder = new Lambder().addApi(...).addApi(...);
-     * export type AppContract = typeof lambder.ApiContractType;
+     * export type AppContract = typeof lambder.ApiContract;
      * ```
      */
-    ApiContractType;
+    ApiContract;
     actionList;
     hookList;
     globalErrorHandler = null;
     routeFallbackHandler = null;
     apiFallbackHandler = null;
+    apiInputValidationErrorHandler = null;
     utils;
     lambderSessionManager;
     sessionTokenCookieKey = "LMDRSESSIONTKID";
@@ -125,6 +83,10 @@ export default class Lambder {
         this.apiFallbackHandler = apiFallbackHandler;
         return this;
     }
+    setApiInputValidationErrorHandler(apiInputValidationErrorHandler) {
+        this.apiInputValidationErrorHandler = apiInputValidationErrorHandler;
+        return this;
+    }
     setGlobalErrorHandler(globalErrorHandler) {
         this.globalErrorHandler = globalErrorHandler;
         return this;
@@ -211,6 +173,9 @@ export default class Lambder {
                 // Validate Input
                 const inputResult = schema.input.safeParse(ctx.apiPayload);
                 if (!inputResult.success) {
+                    if (this.apiInputValidationErrorHandler) {
+                        return await this.apiInputValidationErrorHandler(ctx, resolver, inputResult.error);
+                    }
                     return resolver.raw({
                         statusCode: 400,
                         body: JSON.stringify({ error: "Input validation failed", zodError: inputResult.error }),
@@ -237,6 +202,9 @@ export default class Lambder {
                 // Validate Input
                 const inputResult = schema.input.safeParse(ctx.apiPayload);
                 if (!inputResult.success) {
+                    if (this.apiInputValidationErrorHandler) {
+                        return await this.apiInputValidationErrorHandler(ctx, resolver, inputResult.error);
+                    }
                     return resolver.raw({
                         statusCode: 400,
                         body: JSON.stringify({ error: "Input validation failed", zodError: inputResult.error }),

package/dist/LambderApiContract.d.ts

@@ -1,7 +1,7 @@
 /**
  * Lambder API Contract System
  *
- * Contracts are built via method chaining and inferred using typeof lambder.ApiContractType
+ * Contracts are built via method chaining and inferred using typeof lambder.ApiContract
  */
 /**
  * Base shape for API contracts - used by LambderCaller and LambderMSW

package/dist/LambderApiContract.js

@@ -1,6 +1,6 @@
 /**
  * Lambder API Contract System
  *
- * Contracts are built via method chaining and inferred using typeof lambder.ApiContractType
+ * Contracts are built via method chaining and inferred using typeof lambder.ApiContract
  */
 export {};

package/dist/LambderContext.d.ts

@@ -0,0 +1,34 @@
+import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
+import type { LambderSessionContext } from "./LambderSessionManager.js";
+export type LambderRenderContext<TApiPayload = any> = {
+    host: string;
+    path: string;
+    pathParams: Record<string, any> | null;
+    method: string;
+    get: Record<string, any>;
+    post: Record<string, any>;
+    cookie: Record<string, any>;
+    session: null;
+    apiName: string;
+    apiPayload: TApiPayload;
+    headers: APIGatewayProxyEventHeaders;
+    event: APIGatewayProxyEvent;
+    lambdaContext: Context;
+    _otherInternal: {
+        isApiCall: boolean;
+        requestVersion: string | null;
+        setHeaderFnAccumulator: {
+            key: string;
+            value: string | string[];
+        }[];
+        addHeaderFnAccumulator: {
+            key: string;
+            value: string;
+        }[];
+        logToApiResponseAccumulator: any[];
+    };
+};
+export type LambderSessionRenderContext<TApiPayload = any, SessionData = any> = Omit<LambderRenderContext<TApiPayload>, 'session'> & {
+    session: LambderSessionContext<SessionData>;
+};
+export declare const createContext: (event: APIGatewayProxyEvent, lambdaContext: Context, apiPath: string) => LambderRenderContext<any>;

package/dist/LambderContext.js

@@ -0,0 +1,44 @@
+import cookieParser from "cookie";
+export const createContext = (event, lambdaContext, apiPath) => {
+    const host = event.headers.Host || event.headers.host || "";
+    const path = event.path;
+    const pathParams = null;
+    const get = event.queryStringParameters || {};
+    const method = event.httpMethod;
+    const cookie = cookieParser.parse(event.headers.Cookie || event.headers.cookie || "");
+    const headers = event.headers;
+    // Decode body for the post
+    let post = {};
+    try {
+        const decodedBody = event.isBase64Encoded ? (event.body ? Buffer.from(event.body, "base64").toString() : "{}") : (event.body || "{}");
+        try {
+            post = JSON.parse(decodedBody) || {};
+        }
+        catch (e) {
+            const params = new URLSearchParams(decodedBody);
+            post = {};
+            for (const [key, value] of params.entries()) {
+                post[key] = value;
+            }
+        }
+    }
+    catch (e) { }
+    // Parse api variables
+    const isApiCall = method === "POST" && apiPath && path === apiPath && post.apiName;
+    const apiName = isApiCall ? post.apiName : null;
+    const apiPayload = isApiCall ? post.payload : null;
+    const requestVersion = isApiCall ? post.version : null;
+    return {
+        host, path, pathParams, method,
+        get, post, cookie, event,
+        session: null,
+        apiName, apiPayload,
+        headers, lambdaContext,
+        _otherInternal: {
+            isApiCall, requestVersion,
+            setHeaderFnAccumulator: [],
+            addHeaderFnAccumulator: [],
+            logToApiResponseAccumulator: [],
+        }
+    };
+};

package/dist/LambderResolver.d.ts

@@ -1,4 +1,4 @@
-import type { LambderRenderContext } from "./Lambder.js";
+import type { LambderRenderContext } from "./LambderContext.js";
 import LambderResponseBuilder, { LambderResolverResponse } from "./LambderResponseBuilder.js";
 import LambderUtils from "./LambderUtils.js";
 type MethodType<T, M extends keyof T> = T[M] extends (...args: any[]) => any ? T[M] : never;

package/dist/LambderResponseBuilder.d.ts

@@ -1,5 +1,5 @@
 import LambderUtils from "./LambderUtils.js";
-import { LambderRenderContext } from "./Lambder.js";
+import { LambderRenderContext } from "./LambderContext.js";
 export type LambderResolverResponse = {
     statusCode: number;
     multiValueHeaders?: Record<string, string[]>;

package/dist/LambderResponseBuilder.js

@@ -68,7 +68,7 @@ export default class LambderResponseBuilder {
             throw new Error(".setHeader function is not available within this hook");
         else {
             this.ctx._otherInternal.addHeaderFnAccumulator = this.ctx._otherInternal.addHeaderFnAccumulator
-                .filter(header => header.key !== key);
+                .filter((header) => header.key !== key);
             this.ctx._otherInternal.setHeaderFnAccumulator.push({ key, value });
         }
     }

package/dist/LambderSessionController.d.ts

@@ -1,4 +1,4 @@
-import { LambderRenderContext, LambderSessionRenderContext } from "./Lambder.js";
+import { LambderRenderContext, LambderSessionRenderContext } from "./LambderContext.js";
 import type LambderSessionManager from "./LambderSessionManager.js";
 import type { LambderSessionContext } from "./LambderSessionManager.js";
 export default class LambderSessionController<TSessionData = any> {

package/dist/index.d.ts

@@ -6,3 +6,5 @@ export { default as LambderResolver } from "./LambderResolver.js";
 export { default as LambderSessionManager } from "./LambderSessionManager.js";
 export { default as LambderMSW } from "./LambderMSW.js";
 export { type ApiContractShape, } from "./LambderApiContract.js";
+export type { LambderRenderContext, LambderSessionRenderContext } from "./LambderContext.js";
+export { createContext } from "./LambderContext.js";

package/dist/index.js

@@ -5,3 +5,4 @@ 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 { createContext } from "./LambderContext.js";

package/docs/LAMBDER_MSW.md

@@ -56,23 +56,32 @@ afterAll(() => server.close());
 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 } 
-    }
-}>;
+// backend/index.ts (define your APIs with Lambder)
+import { z } from 'zod';
+import Lambder from 'lambder';
+
+const lambder = new Lambder({ apiPath: '/secure' })
+    .addApi('getUserById', {
+        input: z.object({ userId: z.string() }),
+        output: z.object({ id: z.string(), name: z.string(), email: z.string() })
+    }, async (ctx, resolver) => {
+        // Implementation...
+        return resolver.api({ id: ctx.apiPayload.userId, name: 'John', email: 'john@example.com' });
+    })
+    .addApi('createUser', {
+        input: z.object({ name: z.string(), email: z.string() }),
+        output: z.object({ id: z.string(), name: z.string(), email: z.string() })
+    }, async (ctx, resolver) => {
+        // Implementation...
+        return resolver.api({ id: '123', ...ctx.apiPayload });
+    });
+
+// Export the inferred contract type
+export type MyApiContract = typeof lambder.ApiContract;
 
 // test/setup.ts
 import { LambderMSW } from 'lambder';
-import type { MyApiContract } from '../shared/apiContract';
+import type { MyApiContract } from '../backend';
 
 const lambderMSW = new LambderMSW<MyApiContract>({
     apiPath: '/secure',
@@ -208,7 +217,7 @@ 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';
+import type { MyApiContract } from '../backend'; // Type-only import from your backend
 
 // Setup MSW
 const lambderMSW = new LambderMSW<MyApiContract>({
@@ -305,7 +314,7 @@ 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 '../shared/apiContract';
+import type { MyApiContract } from '../backend'; // Type-only import from your backend
 
 const lambderMSW = new LambderMSW<MyApiContract>({
     apiPath: '/secure'

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.ApiContractType;
+export type AppContract = typeof lambder.ApiContract;
 
 export const handler = lambder.getHandler();
 ```

package/examples/msw-testing-example.ts

@@ -40,7 +40,7 @@ const lambder = new Lambder()
         output: z.object({ success: z.boolean() })
     }, async () => ({} as any));
 
-type TestApiContract = typeof lambder.ApiContractType;
+type TestApiContract = typeof lambder.ApiContract;
 
 // Setup LambderMSW with type safety
 const lambderMSW = new LambderMSW<TestApiContract>({

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

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

package/package.json

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

package/src/Lambder.ts

@@ -1,44 +1,17 @@
-import cookieParser from "cookie";
 import { match } from "path-to-regexp";
 import { z } from "zod";
 
-import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
+import type { APIGatewayProxyEvent, Context } from "aws-lambda";
 import LambderResolver from "./LambderResolver.js";
 import LambderResponseBuilder, { LambderResolverResponse } from "./LambderResponseBuilder.js";
 import LambderUtils from "./LambderUtils.js";
-import LambderSessionManager, { type LambderSessionContext } from "./LambderSessionManager.js";
+import LambderSessionManager from "./LambderSessionManager.js";
 import LambderSessionController from "./LambderSessionController.js";
 import type { MergeContract } from "./LambderApiContract.js";
+import { createContext, type LambderRenderContext, type LambderSessionRenderContext } from "./LambderContext.js";
 
 type Path = `/${string}`;
 
-export type LambderRenderContext<TApiPayload = any> = {
-    host: string;
-    path: string;
-    pathParams: Record<string, any> | null;
-    method: string;
-    get: Record<string, any>;
-    post: Record<string, any>;
-    cookie: Record<string, any>;
-    session: null;
-    apiName: string;
-    apiPayload: TApiPayload;
-    headers: APIGatewayProxyEventHeaders;
-    event: APIGatewayProxyEvent;
-    lambdaContext: Context;
-    _otherInternal: { 
-        isApiCall: boolean,
-        requestVersion: string|null;
-        setHeaderFnAccumulator: { key:string, value:string|string[] }[];
-        addHeaderFnAccumulator: { key:string, value:string }[];
-        logToApiResponseAccumulator: any[];
-    };
-};
-
-export type LambderSessionRenderContext<
-    TApiPayload = any, SessionData = any
-> = Omit<LambderRenderContext<TApiPayload>, 'session'> & { session: LambderSessionContext<SessionData> };
-
 type ConditionFunction = (ctx: LambderRenderContext<any>) => boolean;
 type ActionFunction = (ctx: LambderRenderContext<any>, resolver: LambderResolver) => LambderResolverResponse|Promise<LambderResolverResponse>;
 type SessionActionFunction<SessionData = any> = (ctx: LambderSessionRenderContext<any, SessionData>, resolver: LambderResolver) => LambderResolverResponse|Promise<LambderResolverResponse>;
@@ -54,55 +27,7 @@ type HookFallbackFunction = (ctx: LambderRenderContext<any>, resolver: LambderRe
 type GlobalErrorHandlerFunction = (err: Error, ctx: LambderRenderContext<any>|null, response: LambderResponseBuilder, logListToApiResponse?: any[]) => LambderResolverResponse|Promise<LambderResolverResponse>;
 type RouteFallbackHandlerFunction = (ctx:LambderRenderContext<any>, resolver: LambderResolver) => LambderResolverResponse;
 type ApiFallbackHandlerFunction = (ctx:LambderRenderContext<any>, resolver: LambderResolver) => LambderResolverResponse;
-
-
-export const createContext = (
-    event: APIGatewayProxyEvent, 
-    lambdaContext: Context,
-    apiPath: string,
-):LambderRenderContext<any> => {
-    const host = event.headers.Host || event.headers.host || "";
-    const path = event.path;
-    const pathParams = null;
-    const get: Record<string, any> = event.queryStringParameters || {};
-    const method = event.httpMethod;
-    const cookie = cookieParser.parse(event.headers.Cookie || event.headers.cookie || "");
-    const headers = event.headers;
-    
-    // Decode body for the post
-    let post: Record<string, any> = {};
-    try {
-        const decodedBody = event.isBase64Encoded ? ( event.body ? Buffer.from(event.body,"base64").toString() : "{}" ) : ( event.body || "{}" );
-        try { post = JSON.parse(decodedBody) || {}; }
-        catch(e){ 
-            const params = new URLSearchParams(decodedBody);
-            post = {};
-            for(const [key, value] of params.entries()){
-                post[key] = value;
-            }
-        }
-    }catch(e){}
-    // Parse api variables
-
-    const isApiCall = method === "POST" && apiPath && path === apiPath && post.apiName;
-    const apiName:string = isApiCall ? post.apiName : null;
-    const apiPayload:string = isApiCall ? post.payload : null;
-    const requestVersion:string = isApiCall ? post.version : null;
-
-    return { 
-        host, path, pathParams, method, 
-        get, post, cookie, event,
-        session: null,
-        apiName, apiPayload, 
-        headers, lambdaContext, 
-        _otherInternal: { 
-            isApiCall, requestVersion,
-            setHeaderFnAccumulator: [], 
-            addHeaderFnAccumulator: [], 
-            logToApiResponseAccumulator: [], 
-        } 
-    };
-}
+type ApiInputValidationErrorHandlerFunction = (ctx: LambderRenderContext<any>, resolver: LambderResolver, zodError: z.ZodError) => LambderResolverResponse|Promise<LambderResolverResponse>;
 
 /**
  * Main Lambder class for building type-safe serverless APIs
@@ -133,10 +58,10 @@ export default class Lambder<TSessionData = any, _TContract extends Record<strin
      * @example
      * ```typescript
      * const lambder = new Lambder().addApi(...).addApi(...);
-     * export type AppContract = typeof lambder.ApiContractType;
+     * export type AppContract = typeof lambder.ApiContract;
      * ```
      */
-    public readonly ApiContractType!: _TContract;
+    public readonly ApiContract!: _TContract;
     
     private actionList: ActionObject[];
     private hookList: { 
@@ -147,6 +72,7 @@ export default class Lambder<TSessionData = any, _TContract extends Record<strin
     private globalErrorHandler: GlobalErrorHandlerFunction|null = null;
     private routeFallbackHandler: RouteFallbackHandlerFunction|null = null;
     private apiFallbackHandler: ApiFallbackHandlerFunction|null = null;
+    private apiInputValidationErrorHandler: ApiInputValidationErrorHandlerFunction|null = null;
 
     public utils: LambderUtils;
 
@@ -202,6 +128,10 @@ export default class Lambder<TSessionData = any, _TContract extends Record<strin
         this.apiFallbackHandler = apiFallbackHandler;
         return this;
     }
+    setApiInputValidationErrorHandler(apiInputValidationErrorHandler: ApiInputValidationErrorHandlerFunction): this {
+        this.apiInputValidationErrorHandler = apiInputValidationErrorHandler;
+        return this;
+    }
     setGlobalErrorHandler(globalErrorHandler: GlobalErrorHandlerFunction): this {
         this.globalErrorHandler = globalErrorHandler;
         return this;
@@ -308,6 +238,9 @@ export default class Lambder<TSessionData = any, _TContract extends Record<strin
                 // Validate Input
                 const inputResult = schema.input.safeParse(ctx.apiPayload);
                 if (!inputResult.success) {
+                    if (this.apiInputValidationErrorHandler) {
+                        return await this.apiInputValidationErrorHandler(ctx, resolver, inputResult.error);
+                    }
                     return resolver.raw({
                         statusCode: 400,
                         body: JSON.stringify({ error: "Input validation failed", zodError: inputResult.error }),
@@ -346,6 +279,9 @@ export default class Lambder<TSessionData = any, _TContract extends Record<strin
                 // Validate Input
                 const inputResult = schema.input.safeParse(ctx.apiPayload);
                 if (!inputResult.success) {
+                    if (this.apiInputValidationErrorHandler) {
+                        return await this.apiInputValidationErrorHandler(ctx, resolver, inputResult.error);
+                    }
                     return resolver.raw({
                         statusCode: 400,
                         body: JSON.stringify({ error: "Input validation failed", zodError: inputResult.error }),

package/src/LambderApiContract.ts

@@ -1,7 +1,7 @@
 /**
  * Lambder API Contract System
  * 
- * Contracts are built via method chaining and inferred using typeof lambder.ApiContractType
+ * Contracts are built via method chaining and inferred using typeof lambder.ApiContract
  */
 
 /**

package/src/LambderContext.ts

@@ -0,0 +1,78 @@
+import cookieParser from "cookie";
+import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
+import type { LambderSessionContext } from "./LambderSessionManager.js";
+
+export type LambderRenderContext<TApiPayload = any> = {
+    host: string;
+    path: string;
+    pathParams: Record<string, any> | null;
+    method: string;
+    get: Record<string, any>;
+    post: Record<string, any>;
+    cookie: Record<string, any>;
+    session: null;
+    apiName: string;
+    apiPayload: TApiPayload;
+    headers: APIGatewayProxyEventHeaders;
+    event: APIGatewayProxyEvent;
+    lambdaContext: Context;
+    _otherInternal: { 
+        isApiCall: boolean,
+        requestVersion: string|null;
+        setHeaderFnAccumulator: { key:string, value:string|string[] }[];
+        addHeaderFnAccumulator: { key:string, value:string }[];
+        logToApiResponseAccumulator: any[];
+    };
+};
+
+export type LambderSessionRenderContext<
+    TApiPayload = any, SessionData = any
+> = Omit<LambderRenderContext<TApiPayload>, 'session'> & { session: LambderSessionContext<SessionData> };
+
+export const createContext = (
+    event: APIGatewayProxyEvent, 
+    lambdaContext: Context,
+    apiPath: string,
+):LambderRenderContext<any> => {
+    const host = event.headers.Host || event.headers.host || "";
+    const path = event.path;
+    const pathParams = null;
+    const get: Record<string, any> = event.queryStringParameters || {};
+    const method = event.httpMethod;
+    const cookie = cookieParser.parse(event.headers.Cookie || event.headers.cookie || "");
+    const headers = event.headers;
+    
+    // Decode body for the post
+    let post: Record<string, any> = {};
+    try {
+        const decodedBody = event.isBase64Encoded ? ( event.body ? Buffer.from(event.body,"base64").toString() : "{}" ) : ( event.body || "{}" );
+        try { post = JSON.parse(decodedBody) || {}; }
+        catch(e){ 
+            const params = new URLSearchParams(decodedBody);
+            post = {};
+            for(const [key, value] of params.entries()){
+                post[key] = value;
+            }
+        }
+    }catch(e){}
+    // Parse api variables
+
+    const isApiCall = method === "POST" && apiPath && path === apiPath && post.apiName;
+    const apiName:string = isApiCall ? post.apiName : null;
+    const apiPayload:string = isApiCall ? post.payload : null;
+    const requestVersion:string = isApiCall ? post.version : null;
+
+    return { 
+        host, path, pathParams, method, 
+        get, post, cookie, event,
+        session: null,
+        apiName, apiPayload, 
+        headers, lambdaContext, 
+        _otherInternal: { 
+            isApiCall, requestVersion,
+            setHeaderFnAccumulator: [], 
+            addHeaderFnAccumulator: [], 
+            logToApiResponseAccumulator: [], 
+        } 
+    };
+}

package/src/LambderResolver.ts

@@ -1,4 +1,4 @@
-import type { LambderRenderContext } from "./Lambder.js";
+import type { LambderRenderContext } from "./LambderContext.js";
 import LambderResponseBuilder, { LambderResolverResponse } from "./LambderResponseBuilder.js";
 import LambderUtils from "./LambderUtils.js";
 

package/src/LambderResponseBuilder.ts

@@ -1,6 +1,6 @@
 import mimeTypeResolver from "mime-types";
 import LambderUtils from "./LambderUtils.js";
-import { LambderRenderContext } from "./Lambder.js";
+import { LambderRenderContext } from "./LambderContext.js";
 import { getFS, getPath } from "./node-polyfills.js";
 
 const convertToMultiHeader = (
@@ -102,7 +102,7 @@ export default class LambderResponseBuilder<TResponse = any> {
         if(!this.ctx) throw new Error(".setHeader function is not available within this hook"); 
         else{
             this.ctx._otherInternal.addHeaderFnAccumulator = this.ctx._otherInternal.addHeaderFnAccumulator
-                .filter(header=>header.key !== key);
+                .filter((header: { key: string, value: string }) => header.key !== key);
             this.ctx._otherInternal.setHeaderFnAccumulator.push({ key, value });
         }
     };

package/src/LambderSessionController.ts

@@ -1,4 +1,4 @@
-import { LambderRenderContext, LambderSessionRenderContext } from "./Lambder.js";
+import { LambderRenderContext, LambderSessionRenderContext } from "./LambderContext.js";
 import type LambderSessionManager from "./LambderSessionManager.js";
 import type { LambderSessionContext } from "./LambderSessionManager.js";
 

package/src/index.ts

@@ -11,3 +11,7 @@ export { default as LambderMSW } from "./LambderMSW.js";
 export { 
     type ApiContractShape,
 } from "./LambderApiContract.js";
+
+// Context types and utilities
+export type { LambderRenderContext, LambderSessionRenderContext } from "./LambderContext.js";
+export { createContext } from "./LambderContext.js";

package/tests/type-safety.test.ts

@@ -34,7 +34,7 @@ describe('LambderCaller Type Safety', () => {
             return resolver.api({ id: '1', ...ctx.apiPayload });
         });
 
-        type TestApiContract = typeof lambder.ApiContractType;
+        type TestApiContract = typeof lambder.ApiContract;
 
         const caller = new LambderCaller<TestApiContract>({
             apiPath: '/api',
@@ -181,7 +181,7 @@ describe('apiRaw Method Type Safety', () => {
             return resolver.api({ id: ctx.apiPayload.userId, name: 'Test' });
         });
 
-        type TestApiContract = typeof lambder.ApiContractType;
+        type TestApiContract = typeof lambder.ApiContract;
 
         const caller = new LambderCaller<TestApiContract>({
             apiPath: '/api',

package/tests/use-plugin.test.ts

@@ -70,7 +70,7 @@ describe('Plugin System - Basic Usage', () => {
         const result = await handler(event, createMockContext());
 
         expect(result.statusCode).toBe(200);
-        const body = JSON.parse(result.body);
+        const body = JSON.parse(result.body || '{}');
         expect(body.payload).toEqual({ id: '123', name: 'John Doe' });
     });
 
@@ -90,7 +90,7 @@ describe('Plugin System - Basic Usage', () => {
             apiPath: '/api'
         }).use(userPlugin);
 
-        type AppContract = typeof lambder.ApiContractType;
+        type AppContract = typeof lambder.ApiContract;
 
         const caller = new LambderCaller<AppContract>({
             apiPath: '/api',
@@ -163,19 +163,19 @@ describe('Plugin System - Multiple Plugins', () => {
         const userEvent = createMockEvent('getUser', { userId: '123' });
         const userResult = await handler(userEvent, createMockContext());
         expect(userResult.statusCode).toBe(200);
-        expect(JSON.parse(userResult.body).payload.name).toBe('John');
+        expect(JSON.parse(userResult.body || '{}').payload.name).toBe('John');
 
         // Test product API
         const productEvent = createMockEvent('getProduct', { productId: 'prod-456' });
         const productResult = await handler(productEvent, createMockContext());
         expect(productResult.statusCode).toBe(200);
-        expect(JSON.parse(productResult.body).payload.title).toBe('Test Product');
+        expect(JSON.parse(productResult.body || '{}').payload.title).toBe('Test Product');
 
         // Test order API
         const orderEvent = createMockEvent('createOrder', { userId: '123', productId: 'prod-456' });
         const orderResult = await handler(orderEvent, createMockContext());
         expect(orderResult.statusCode).toBe(200);
-        expect(JSON.parse(orderResult.body).payload.orderId).toBe('order-123');
+        expect(JSON.parse(orderResult.body || '{}').payload.orderId).toBe('order-123');
     });
 
     it('should accumulate types from multiple plugins', () => {
@@ -206,7 +206,7 @@ describe('Plugin System - Multiple Plugins', () => {
             .use(userPlugin)
             .use(productPlugin);
 
-        type AppContract = typeof lambder.ApiContractType;
+        type AppContract = typeof lambder.ApiContract;
 
         const caller = new LambderCaller<AppContract>({
             apiPath: '/api',
@@ -263,17 +263,17 @@ describe('Plugin System - Mixed Usage', () => {
         // Test direct API before plugin
         const healthEvent = createMockEvent('healthCheck', undefined);
         const healthResult = await handler(healthEvent, createMockContext());
-        expect(JSON.parse(healthResult.body).payload.status).toBe('ok');
+        expect(JSON.parse(healthResult.body || '{}').payload.status).toBe('ok');
 
         // Test plugin API
         const userEvent = createMockEvent('getUser', { userId: '123' });
         const userResult = await handler(userEvent, createMockContext());
-        expect(JSON.parse(userResult.body).payload.name).toBe('John');
+        expect(JSON.parse(userResult.body || '{}').payload.name).toBe('John');
 
         // Test direct API after plugin
         const versionEvent = createMockEvent('getVersion', undefined);
         const versionResult = await handler(versionEvent, createMockContext());
-        expect(JSON.parse(versionResult.body).payload.version).toBe('2.0');
+        expect(JSON.parse(versionResult.body || '{}').payload.version).toBe('2.0');
     });
 });
 
@@ -424,7 +424,7 @@ describe('Plugin System - Type Safety', () => {
             .use(plugin1)
             .use(plugin2);
 
-        type Contract = typeof lambder.ApiContractType;
+        type Contract = typeof lambder.ApiContract;
 
         // Type assertions - both api1 and api2 should be in the contract
         // We test this at runtime by creating a caller
@@ -446,12 +446,14 @@ describe('Plugin System - Non-Generic Plugins', () => {
         const plugin2 = (l: Lambder) => l.addApi('api2', { input: z.void(), output: z.void() }, async (ctx, res) => res.raw({ statusCode: 200, body: '' }));
 
         const lambder = new Lambder({ publicPath: '', apiPath: '' })
+            .addApi('initialApi', { input: z.void(), output: z.void() }, async (ctx, res) => res.raw({ statusCode: 200, body: '' }))
             .use(plugin1)
             .use(plugin2);
 
-        type Contract = typeof lambder.ApiContractType;
+        type Contract = typeof lambder.ApiContract;
         
         // Check if both api1 and api2 exist in Contract
+        expectTypeOf<Contract>().toHaveProperty('initialApi');
         expectTypeOf<Contract>().toHaveProperty('api1');
         expectTypeOf<Contract>().toHaveProperty('api2');
     });