lambder 1.0.147 → 2.0.2

package/dist/Lambder.d.ts

@@ -1,10 +1,11 @@
+import { z } from "zod";
 import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, 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 { ApiContractShape } from "./LambderApiContract.js";
+import type { MergeContract } from "./LambderApiContract.js";
 type Path = `/${string}`;
 export type LambderRenderContext<TApiPayload = any> = {
     host: string;
@@ -37,7 +38,6 @@ export type LambderRenderContext<TApiPayload = any> = {
 export type LambderSessionRenderContext<TApiPayload = any, SessionData = any> = Omit<LambderRenderContext<TApiPayload>, 'session'> & {
     session: LambderSessionContext<SessionData>;
 };
-type LambderModuleFunction = (lambderInstance: Lambder) => void | Promise<void>;
 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>;
@@ -49,12 +49,38 @@ type GlobalErrorHandlerFunction = (err: Error, ctx: LambderRenderContext<any> |
 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>;
-export default class Lambder<TContract extends ApiContractShape = any, TSessionData = any> {
+/**
+ * Main Lambder class for building type-safe serverless APIs
+ *
+ * @typeParam TSessionData - Type of session data stored in DynamoDB
+ * @typeParam _TContract - @internal Accumulates API contract during chaining (do not pass manually)
+ *
+ * @example
+ * ```typescript
+ * interface SessionData { userId: string; role: string; }
+ *
+ * const lambder = new Lambder<SessionData>({ apiPath: '/api' })
+ *   .addApi('getUser', { input: z.object({...}), output: z.object({...}) }, handler)
+ *   .addApi('createUser', { input: z.object({...}), output: z.object({...}) }, handler);
+ * ```
+ */
+export default class Lambder<TSessionData = any, _TContract extends Record<string, any> = {}> {
     apiPath: string;
     apiVersion: null | string;
     isCorsEnabled: boolean;
     publicPath: string;
     ejsPath: string;
+    /**
+     * Type property for extracting the API contract
+     * Use this to export your API types to the frontend
+     *
+     * @example
+     * ```typescript
+     * const lambder = new Lambder().addApi(...).addApi(...);
+     * export type AppContract = typeof lambder.ApiContractType;
+     * ```
+     */
+    readonly ApiContractType: _TContract;
     private actionList;
     private hookList;
     private globalErrorHandler;
@@ -70,7 +96,7 @@ export default class Lambder<TContract extends ApiContractShape = any, TSessionD
         ejsPath?: string;
         apiVersion?: string;
     });
-    enableCors(isCorsEnabled: boolean): void;
+    enableCors(isCorsEnabled: boolean): this;
     enableDdbSession({ tableName, tableRegion, sessionSalt, enableSlidingExpiration }: {
         tableName: string;
         tableRegion: string;
@@ -79,26 +105,25 @@ export default class Lambder<TContract extends ApiContractShape = any, TSessionD
     }, { partitionKey, sortKey }?: {
         partitionKey: string;
         sortKey: string;
-    }): void;
-    setSessionCookieKey(sessionTokenCookieKey: string, sessionCsrfCookieKey: string): void;
-    setRouteFallbackHandler(routeFallbackHandler: RouteFallbackHandlerFunction): void;
-    setApiFallbackHandler(apiFallbackHandler: ApiFallbackHandlerFunction): void;
-    setGlobalErrorHandler(globalErrorHandler: GlobalErrorHandlerFunction): void;
+    }): this;
+    setSessionCookieKey(sessionTokenCookieKey: string, sessionCsrfCookieKey: string): this;
+    setRouteFallbackHandler(routeFallbackHandler: RouteFallbackHandlerFunction): this;
+    setApiFallbackHandler(apiFallbackHandler: ApiFallbackHandlerFunction): this;
+    setGlobalErrorHandler(globalErrorHandler: GlobalErrorHandlerFunction): this;
     private getPatternMatch;
     private testPatternMatch;
     private handleNoMatchedAction;
-    addModule(moduleFn: LambderModuleFunction): Promise<void>;
-    importModule(moduleImport: Promise<{
-        default: LambderModuleFunction;
-    }>): Promise<void>;
-    addRoute(condition: Path | ConditionFunction | RegExp, actionFn: ActionFunction): void;
-    addSessionRoute(condition: Path | ConditionFunction | RegExp, actionFn: SessionActionFunction<TSessionData>): void;
-    addApi(apiName: ConditionFunction | RegExp, actionFn: ActionFunction): void;
-    addApi<TApiName extends keyof TContract & string>(apiName: TApiName, actionFn: (ctx: LambderRenderContext<TContract[TApiName]['input']>, resolver: LambderResolver<TContract, TApiName>) => LambderResolverResponse | Promise<LambderResolverResponse>): void;
-    addApi(apiName: string, actionFn: ActionFunction): void;
-    addSessionApi(apiName: ConditionFunction | RegExp, actionFn: SessionActionFunction<TSessionData>): void;
-    addSessionApi<TApiName extends keyof TContract & string>(apiName: TApiName, actionFn: (ctx: LambderSessionRenderContext<TContract[TApiName]['input'], TSessionData>, resolver: LambderResolver<TContract, TApiName>) => LambderResolverResponse | Promise<LambderResolverResponse>): void;
-    addSessionApi(apiName: string, actionFn: SessionActionFunction<TSessionData>): void;
+    addRoute(condition: Path | ConditionFunction | RegExp, actionFn: ActionFunction): this;
+    addSessionRoute(condition: Path | ConditionFunction | RegExp, actionFn: SessionActionFunction<TSessionData>): this;
+    use<_TNewContract extends Record<string, any>>(plugin: (lambder: Lambder<TSessionData, _TContract>) => Lambder<TSessionData, _TNewContract>): Lambder<TSessionData, _TNewContract>;
+    addApi<TName extends string, TInput extends z.ZodTypeAny, TOutput extends z.ZodTypeAny>(name: TName, schema: {
+        input: TInput;
+        output: TOutput;
+    }, handler: (ctx: LambderRenderContext<z.infer<TInput>>, resolver: LambderResolver<z.infer<TOutput>>) => LambderResolverResponse | Promise<LambderResolverResponse>): Lambder<TSessionData, MergeContract<_TContract, TName, z.infer<TInput>, z.infer<TOutput>>>;
+    addSessionApi<TName extends string, TInput extends z.ZodTypeAny, TOutput extends z.ZodTypeAny>(name: TName, schema: {
+        input: TInput;
+        output: TOutput;
+    }, handler: (ctx: LambderSessionRenderContext<z.infer<TInput>, TSessionData>, resolver: LambderResolver<z.infer<TOutput>>) => LambderResolverResponse | Promise<LambderResolverResponse>): Lambder<TSessionData, MergeContract<_TContract, TName, z.infer<TInput>, z.infer<TOutput>>>;
     addHook(hookEvent: 'created', hookFn: HookCreatedFunction, priority?: number): Promise<void>;
     addHook(hookEvent: 'beforeRender', hookFn: HookBeforeRenderFunction, priority?: number): Promise<void>;
     addHook(hookEvent: 'afterRender', hookFn: HookAfterRenderFunction, priority?: number): Promise<void>;
@@ -106,6 +131,7 @@ export default class Lambder<TContract extends ApiContractShape = any, TSessionD
     getSessionController(ctx: LambderRenderContext<any> | LambderSessionRenderContext<any, TSessionData>): LambderSessionController<TSessionData>;
     getResponseBuilder(): LambderResponseBuilder<any>;
     private getResolver;
+    getHandler(): (event: APIGatewayProxyEvent, context: Context) => Promise<LambderResolverResponse>;
     render(event: APIGatewayProxyEvent, lambdaContext: Context): Promise<LambderResolverResponse>;
 }
 export {};

package/dist/Lambder.js

@@ -48,12 +48,38 @@ export const createContext = (event, lambdaContext, apiPath) => {
         }
     };
 };
+/**
+ * Main Lambder class for building type-safe serverless APIs
+ *
+ * @typeParam TSessionData - Type of session data stored in DynamoDB
+ * @typeParam _TContract - @internal Accumulates API contract during chaining (do not pass manually)
+ *
+ * @example
+ * ```typescript
+ * interface SessionData { userId: string; role: string; }
+ *
+ * const lambder = new Lambder<SessionData>({ apiPath: '/api' })
+ *   .addApi('getUser', { input: z.object({...}), output: z.object({...}) }, handler)
+ *   .addApi('createUser', { input: z.object({...}), output: z.object({...}) }, handler);
+ * ```
+ */
 export default class Lambder {
     apiPath;
     apiVersion;
     isCorsEnabled = false;
     publicPath;
     ejsPath;
+    /**
+     * Type property for extracting the API contract
+     * Use this to export your API types to the frontend
+     *
+     * @example
+     * ```typescript
+     * const lambder = new Lambder().addApi(...).addApi(...);
+     * export type AppContract = typeof lambder.ApiContractType;
+     * ```
+     */
+    ApiContractType;
     actionList;
     hookList;
     globalErrorHandler = null;
@@ -78,24 +104,30 @@ export default class Lambder {
     }
     enableCors(isCorsEnabled) {
         this.isCorsEnabled = isCorsEnabled;
+        return this;
     }
     enableDdbSession({ tableName, tableRegion, sessionSalt, enableSlidingExpiration }, { partitionKey, sortKey } = { partitionKey: "pk", sortKey: "sk" }) {
         this.lambderSessionManager = new LambderSessionManager({
             tableName, tableRegion, partitionKey, sortKey, sessionSalt, enableSlidingExpiration
         });
+        return this;
     }
     setSessionCookieKey(sessionTokenCookieKey, sessionCsrfCookieKey) {
         this.sessionTokenCookieKey = sessionTokenCookieKey;
         this.sessionCsrfCookieKey = sessionCsrfCookieKey;
+        return this;
     }
     setRouteFallbackHandler(routeFallbackHandler) {
         this.routeFallbackHandler = routeFallbackHandler;
+        return this;
     }
     setApiFallbackHandler(apiFallbackHandler) {
         this.apiFallbackHandler = apiFallbackHandler;
+        return this;
     }
     setGlobalErrorHandler(globalErrorHandler) {
         this.globalErrorHandler = globalErrorHandler;
+        return this;
     }
     getPatternMatch(pattern, path) {
         const result = (match(pattern, { decode: decodeURIComponent }))(path);
@@ -124,12 +156,6 @@ export default class Lambder {
             resolver.resolve({ statusCode: 204, body: "Route handler not set.", });
         }
     }
-    async addModule(moduleFn) {
-        await moduleFn(this);
-    }
-    async importModule(moduleImport) {
-        await this.addModule((await moduleImport).default);
-    }
     addRoute(condition, actionFn) {
         this.actionList.push({
             conditionFn: (ctx) => (ctx.method === "GET" &&
@@ -141,13 +167,14 @@ export default class Lambder {
                     ctx.pathParams = this.getPatternMatch(condition, ctx.path);
                 }
                 else if (condition?.constructor == RegExp) {
-                    ctx.pathParams = ctx.path.match(condition);
+                    const match = ctx.path.match(condition);
+                    ctx.pathParams = match ? (match.groups || match) : {};
                 }
                 return await actionFn(ctx, resolver);
             }
         });
+        return this;
     }
-    ;
     addSessionRoute(condition, actionFn) {
         this.actionList.push({
             conditionFn: (ctx) => (ctx.method === "GET" &&
@@ -159,7 +186,8 @@ export default class Lambder {
                     ctx.pathParams = this.getPatternMatch(condition, ctx.path);
                 }
                 else if (condition?.constructor == RegExp) {
-                    ctx.pathParams = ctx.path.match(condition);
+                    const match = ctx.path.match(condition);
+                    ctx.pathParams = match ? (match.groups || match) : {};
                 }
                 const sessionCtx = ctx;
                 await this.getSessionController(ctx).fetchSession();
@@ -169,35 +197,59 @@ export default class Lambder {
                 return await actionFn(sessionCtx, resolver);
             }
         });
+        return this;
     }
-    ;
-    // Implementation
-    addApi(apiName, actionFn) {
+    // Plugin system
+    use(plugin) {
+        return plugin(this);
+    }
+    // Typed API with Zod
+    addApi(name, schema, handler) {
         this.actionList.push({
-            conditionFn: (ctx) => (!!ctx.apiName && ((typeof apiName === "string" && ctx.apiName === apiName) ||
-                (typeof apiName === "function" && apiName(ctx)) ||
-                (apiName?.constructor == RegExp && apiName.test(ctx.apiName)))),
-            actionFn: async (ctx, resolver) => await actionFn(ctx, resolver),
+            conditionFn: (ctx) => ctx.apiName === name,
+            actionFn: async (ctx, resolver) => {
+                // Validate Input
+                const inputResult = schema.input.safeParse(ctx.apiPayload);
+                if (!inputResult.success) {
+                    return resolver.raw({
+                        statusCode: 400,
+                        body: JSON.stringify({ error: "Input validation failed", zodError: inputResult.error }),
+                        multiValueHeaders: { "Content-Type": ["application/json"] }
+                    });
+                }
+                // Run Handler with validated data
+                ctx.apiPayload = inputResult.data;
+                return await handler(ctx, resolver);
+            },
         });
+        return this;
     }
-    ;
-    // Implementation
-    addSessionApi(apiName, actionFn) {
+    // Typed Session API with Zod
+    addSessionApi(name, schema, handler) {
         this.actionList.push({
-            conditionFn: (ctx) => (!!ctx.apiName && ((typeof apiName === "string" && ctx.apiName === apiName) ||
-                (typeof apiName === "function" && apiName(ctx)) ||
-                (apiName?.constructor == RegExp && apiName.test(ctx.apiName)))),
+            conditionFn: (ctx) => ctx.apiName === name,
             actionFn: async (ctx, resolver) => {
                 const sessionCtx = ctx;
                 await this.getSessionController(ctx).fetchSession();
                 if (!sessionCtx.session) {
                     throw new Error("Session not found.");
                 }
-                return await actionFn(sessionCtx, resolver);
+                // Validate Input
+                const inputResult = schema.input.safeParse(ctx.apiPayload);
+                if (!inputResult.success) {
+                    return resolver.raw({
+                        statusCode: 400,
+                        body: JSON.stringify({ error: "Input validation failed", zodError: inputResult.error }),
+                        multiValueHeaders: { "Content-Type": ["application/json"] }
+                    });
+                }
+                // Run Handler with validated data
+                ctx.apiPayload = inputResult.data;
+                return await handler(sessionCtx, resolver);
             }
         });
+        return this;
     }
-    ;
     async addHook(hookEvent, hookFn, priority = 0) {
         if (hookEvent === "created") {
             await hookFn(this);
@@ -236,6 +288,9 @@ export default class Lambder {
         });
     }
     ;
+    getHandler() {
+        return (event, context) => this.render(event, context);
+    }
     async render(event, lambdaContext) {
         let eventRenderContext = null;
         try {

package/dist/LambderApiContract.d.ts

@@ -1,53 +1,21 @@
 /**
- * Type-safe API Contract System
+ * Lambder API Contract System
  *
- * Define your API contract as a TypeScript type to get full type safety
- * across frontend and backend with no runtime overhead.
- *
- * Example:
- *
- * export type MyApiContract = {
- *     getUserById: { input: { userId: string }, output: User },
- *     createUser: { input: CreateUserInput, output: User },
- *     listUsers: { input: void, output: User[] }
- * }
- *
- * Frontend:
- * const caller = new LambderCaller<MyApiContract>({ ... });
- * const user = await caller.api('getUserById', { userId: '123' }); // typed!
- *
- * Backend:
- * const lambder = new Lambder<MyApiContract>({ ... });
- * lambder.addApi('getUserById', async (ctx, resolver) => {
- *     // ctx.apiPayload is typed as { userId: string }
- *     return resolver.api(user); // user is typed as User
- * });
+ * Contracts are built via method chaining and inferred using typeof lambder.ApiContractType
  */
 /**
- * Base type for API contracts
- *
- * Use this as a constraint when defining your API contract:
- *
- * export type MyApiContract = {
- *     echo: { input: { message: string }, output: { echo: string } }
- * } satisfies ApiContract;
- *
- * Or for backward compatibility without satisfies:
- *
- * export type MyApiContract = ApiContract & {
- *     echo: { input: { message: string }, output: { echo: string } }
- * }
+ * Base shape for API contracts - used by LambderCaller and LambderMSW
  */
 export type ApiContractShape = Record<string, {
     input: any;
     output: any;
 }>;
-export type ApiContract<T extends ApiContractShape> = T;
-/**
- * Extract input type from contract for a specific API
- */
-export type ApiInput<TContract extends ApiContractShape, TApiName extends keyof TContract> = TContract[TApiName]['input'];
 /**
- * Extract output type from contract for a specific API
+ * Helper type for merging new API into existing contract during chaining
  */
-export type ApiOutput<TContract extends ApiContractShape, TApiName extends keyof TContract> = TContract[TApiName]['output'];
+export type MergeContract<Old, Name extends string, In, Out> = Old & {
+    [K in Name]: {
+        input: In;
+        output: Out;
+    };
+};

package/dist/LambderApiContract.js

@@ -1,26 +1,6 @@
 /**
- * Type-safe API Contract System
+ * Lambder API Contract System
  *
- * Define your API contract as a TypeScript type to get full type safety
- * across frontend and backend with no runtime overhead.
- *
- * Example:
- *
- * export type MyApiContract = {
- *     getUserById: { input: { userId: string }, output: User },
- *     createUser: { input: CreateUserInput, output: User },
- *     listUsers: { input: void, output: User[] }
- * }
- *
- * Frontend:
- * const caller = new LambderCaller<MyApiContract>({ ... });
- * const user = await caller.api('getUserById', { userId: '123' }); // typed!
- *
- * Backend:
- * const lambder = new Lambder<MyApiContract>({ ... });
- * lambder.addApi('getUserById', async (ctx, resolver) => {
- *     // ctx.apiPayload is typed as { userId: string }
- *     return resolver.api(user); // user is typed as User
- * });
+ * Contracts are built via method chaining and inferred using typeof lambder.ApiContractType
  */
 export {};

package/dist/LambderCaller.js

@@ -71,9 +71,9 @@ export default class LambderCaller {
                     activeFetchList: this.fetchTrackerList.filter(v => !v.done),
                 });
             }
-            if (data && data.logList?.length) {
+            if (data && data.logList) {
                 for (const record of data.logList) {
-                    console.log("LogToApiResponse:", record);
+                    // Log to API response for debugging
                 }
             }
             if (data && data.versionExpired) {

package/dist/LambderMSW.js

@@ -1,5 +1,3 @@
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
 export default class LambderMSW {
     apiPath;
     apiVersion;
@@ -48,7 +46,6 @@ export default class LambderMSW {
             if (body.apiName !== apiName) {
                 return;
             }
-            console.log("LambderMSW called for:", body.apiName);
             try {
                 // Add artificial delay if specified
                 if (options?.delay) {
@@ -56,7 +53,6 @@ export default class LambderMSW {
                 }
                 // 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,

package/dist/LambderResolver.d.ts

@@ -1,26 +1,25 @@
 import type { LambderRenderContext } from "./Lambder.js";
 import LambderResponseBuilder, { LambderResolverResponse } from "./LambderResponseBuilder.js";
 import LambderUtils from "./LambderUtils.js";
-import type { ApiContractShape, ApiOutput } from "./LambderApiContract.js";
 type MethodType<T, M extends keyof T> = T[M] extends (...args: any[]) => any ? T[M] : never;
-interface DieResolverMethods<TContract extends ApiContractShape, TApiName extends keyof TContract & string> {
-    raw: MethodType<LambderResponseBuilder<TContract>, 'raw'>;
-    json: MethodType<LambderResponseBuilder<TContract>, 'json'>;
-    xml: MethodType<LambderResponseBuilder<TContract>, 'xml'>;
-    html: MethodType<LambderResponseBuilder<TContract>, 'html'>;
-    status301: MethodType<LambderResponseBuilder<TContract>, 'status301'>;
-    status404: MethodType<LambderResponseBuilder<TContract>, 'status404'>;
-    cors: MethodType<LambderResponseBuilder<TContract>, 'cors'>;
-    fileBase64: MethodType<LambderResponseBuilder<TContract>, 'fileBase64'>;
-    file: MethodType<LambderResponseBuilder<TContract>, 'file'>;
-    ejsFile: MethodType<LambderResponseBuilder<TContract>, 'ejsFile'>;
-    ejsTemplate: MethodType<LambderResponseBuilder<TContract>, 'ejsTemplate'>;
-    api: (payload: ApiOutput<TContract, TApiName> | null, config?: Parameters<LambderResponseBuilder<TContract>['api']>[1], headers?: Parameters<LambderResponseBuilder<TContract>['api']>[2]) => LambderResolverResponse;
+interface DieResolverMethods<TOutput> {
+    raw: MethodType<LambderResponseBuilder, 'raw'>;
+    json: MethodType<LambderResponseBuilder, 'json'>;
+    xml: MethodType<LambderResponseBuilder, 'xml'>;
+    html: MethodType<LambderResponseBuilder, 'html'>;
+    status301: MethodType<LambderResponseBuilder, 'status301'>;
+    status404: MethodType<LambderResponseBuilder, 'status404'>;
+    cors: MethodType<LambderResponseBuilder, 'cors'>;
+    fileBase64: MethodType<LambderResponseBuilder, 'fileBase64'>;
+    file: MethodType<LambderResponseBuilder, 'file'>;
+    ejsFile: MethodType<LambderResponseBuilder, 'ejsFile'>;
+    ejsTemplate: MethodType<LambderResponseBuilder, 'ejsTemplate'>;
+    api: (payload: TOutput | null, config?: Parameters<LambderResponseBuilder['api']>[1], headers?: Parameters<LambderResponseBuilder['api']>[2]) => LambderResolverResponse;
 }
-export default class LambderResolver<TContract extends ApiContractShape = any, TApiName extends keyof TContract & string = any> extends LambderResponseBuilder<TContract> {
+export default class LambderResolver<TOutput = any> extends LambderResponseBuilder<TOutput> {
     resolve: (response: LambderResolverResponse) => void;
     reject: (err: Error) => void;
-    die: DieResolverMethods<TContract, TApiName>;
+    die: DieResolverMethods<TOutput>;
     constructor({ isCorsEnabled, publicPath, apiVersion, lambderUtils, ctx, resolve, reject }: {
         isCorsEnabled: boolean;
         publicPath: string;
@@ -30,7 +29,7 @@ export default class LambderResolver<TContract extends ApiContractShape = any, T
         resolve: (response: LambderResolverResponse) => void;
         reject: (err: Error) => void;
     });
-    api(payload: ApiOutput<TContract, TApiName> | null, config?: Parameters<LambderResponseBuilder<TContract>['api']>[1], headers?: Parameters<LambderResponseBuilder<TContract>['api']>[2]): LambderResolverResponse;
+    api(payload: TOutput | null, config?: Parameters<LambderResponseBuilder['api']>[1], headers?: Parameters<LambderResponseBuilder['api']>[2]): LambderResolverResponse;
     private autoResolve;
     private autoResolvePromise;
 }

package/dist/LambderResponseBuilder.d.ts

@@ -1,6 +1,5 @@
 import LambderUtils from "./LambderUtils.js";
 import { LambderRenderContext } from "./Lambder.js";
-import type { ApiContractShape } from "./LambderApiContract.js";
 export type LambderResolverResponse = {
     statusCode: number;
     multiValueHeaders?: Record<string, string[]>;
@@ -18,7 +17,7 @@ export type LambderApiResponseConfig = {
 export type LambderApiResponse<T> = LambderApiResponseConfig & {
     payload?: T | null;
 };
-export default class LambderResponseBuilder<TContract extends ApiContractShape = any> {
+export default class LambderResponseBuilder<TResponse = any> {
     private isCorsEnabled;
     private publicPath;
     private apiVersion;
@@ -48,6 +47,6 @@ export default class LambderResponseBuilder<TContract extends ApiContractShape =
     file(filePath: string, headers?: Record<string, string | string[]>, fallbackFilePath?: string): Promise<LambderResolverResponse>;
     ejsTemplate(template: string, pageData: Record<string, any>, headers?: Record<string, string | string[]>): Promise<LambderResolverResponse>;
     ejsFile(filePath: string, pageData: Record<string, any>, headers?: Record<string, string | string[]>): Promise<LambderResolverResponse>;
-    api<T = any>(payload: T | null, { versionExpired, sessionExpired, notAuthorized, message, errorMessage, logList, }?: LambderApiResponseConfig, headers?: Record<string, string | string[]>): LambderResolverResponse;
+    api(payload: TResponse | null, { versionExpired, sessionExpired, notAuthorized, message, errorMessage, logList, }?: LambderApiResponseConfig, headers?: Record<string, string | string[]>): LambderResolverResponse;
     apiBinary<T = any>(payload: T | null, { versionExpired, sessionExpired, notAuthorized, message, errorMessage, logList, }?: LambderApiResponseConfig, headers?: Record<string, string | string[]>): LambderResolverResponse;
 }

package/dist/LambderResponseBuilder.js

@@ -29,7 +29,6 @@ export default class LambderResponseBuilder {
         }
         const publicPath = path.resolve(this.publicPath);
         const absolutePath = path.resolve(publicPath, filePath);
-        console.log("readPublicFileSync", { filePath, publicPath, absolutePath });
         if (!absolutePath.startsWith(publicPath)) {
             return "forbidden-public-path";
         }
@@ -44,7 +43,6 @@ export default class LambderResponseBuilder {
         }
         const publicPath = path.resolve(this.publicPath);
         const absolutePath = path.resolve(publicPath, filePath);
-        console.log("checkPublicFileExist", { filePath, publicPath, absolutePath });
         if (!absolutePath.startsWith(publicPath)) {
             return false;
         }
@@ -166,7 +164,7 @@ export default class LambderResponseBuilder {
         const mimeType = mimeTypeResolver.lookup(filePath);
         const body = await this.readPublicFileSync(filePath);
         if (body === "forbidden-public-path") {
-            throw { error: "Forbidden public path: " + filePath };
+            throw new Error("Forbidden public path: " + filePath);
         }
         const bodyBuffer = Buffer.isBuffer(body) ? body : Buffer.from(body);
         const bodyBase64 = bodyBuffer.toString("base64");

package/dist/LambderUtils.js

@@ -17,11 +17,10 @@ export default class LambderUtils {
         }
         const ejsPath = path.resolve(this.ejsPath);
         const absolutePath = path.resolve(ejsPath, filePath);
-        console.log("readEjsFileSync", { filePath, ejsPath, absolutePath });
         if (!absolutePath.startsWith(ejsPath)) {
             return "forbidden-ejs-path";
         }
-        return String(await fs.promises.readFile(absolutePath));
+        return await fs.promises.readFile(absolutePath, 'utf-8');
     }
     ;
     async checkEjsFileExist(filePath) {
@@ -35,7 +34,6 @@ export default class LambderUtils {
         }
         const ejsPath = path.resolve(this.ejsPath);
         const absolutePath = path.resolve(ejsPath, filePath);
-        console.log("checkEjsFileExist", { filePath, ejsPath, absolutePath });
         if (!absolutePath.startsWith(ejsPath)) {
             return false;
         }

package/dist/index.d.ts

@@ -5,4 +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 { type ApiContractShape, type ApiContract, type ApiInput, type ApiOutput, } from "./LambderApiContract.js";
+export { type ApiContractShape, } from "./LambderApiContract.js";

package/docs/LAMBDER_MSW.md

@@ -248,14 +248,14 @@ afterEach(() => server.resetHandlers());
 afterAll(() => server.close());
 
 // Setup LambderCaller
-const caller = new LambderCaller<MyApiContract>({
+const lambderCaller = new LambderCaller<MyApiContract>({
     apiPath: '/secure',
     isCorsEnabled: false
 });
 
 describe('User APIs', () => {
     it('should fetch user by id', async () => {
-        const result = await caller.api('getUserById', { userId: '123' });
+        const result = await lambderCaller.api('getUserById', { userId: '123' });
         
         expect(result).toEqual({
             id: '123',
@@ -265,7 +265,7 @@ describe('User APIs', () => {
     });
     
     it('should create a new user', async () => {
-        const result = await caller.api('createUser', {
+        const result = await lambderCaller.api('createUser', {
             name: 'Jane Smith',
             email: 'jane@example.com'
         });
@@ -277,7 +277,7 @@ describe('User APIs', () => {
     
     it('should handle session expired', async () => {
         try {
-            await caller.api('getProtectedData', {});
+            await lambderCaller.api('getProtectedData', {});
             // Should not reach here
             expect(true).toBe(false);
         } catch (error: any) {
@@ -287,7 +287,7 @@ describe('User APIs', () => {
     
     it('should handle errors', async () => {
         try {
-            await caller.api('failingApi', {});
+            await lambderCaller.api('failingApi', {});
             // Should not reach here
             expect(true).toBe(false);
         } catch (error: any) {
@@ -386,7 +386,7 @@ it('should handle specific user', async () => {
         })
     );
     
-    const result = await caller.api('getUserById', { userId: '999' });
+    const result = await lambderCaller.api('getUserById', { userId: '999' });
     expect(result?.name).toBe('Special User');
 });
 ```