lambder 1.0.147 → 2.0.2

package/src/Lambder.ts

@@ -1,5 +1,6 @@
 import cookieParser from "cookie";
 import { match } from "path-to-regexp";
+import { z } from "zod";
 
 import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
 import LambderResolver from "./LambderResolver.js";
@@ -7,7 +8,7 @@ import LambderResponseBuilder, { LambderResolverResponse } from "./LambderRespon
 import LambderUtils from "./LambderUtils.js";
 import LambderSessionManager, { 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}`;
 
@@ -38,8 +39,6 @@ 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>;
@@ -105,14 +104,40 @@ export const createContext = (
     };
 }
 
-
-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> = {}> {
     public apiPath: string;
     public apiVersion: null|string;
     public isCorsEnabled: boolean = false;
     public publicPath: string;
     public 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;
+     * ```
+     */
+    public readonly ApiContractType!: _TContract;
+    
     private actionList: ActionObject[];
     private hookList: { 
         "beforeRender": { priority: number, hookFn: HookBeforeRenderFunction }[],
@@ -148,32 +173,38 @@ export default class Lambder<TContract extends ApiContractShape = any, TSessionD
         this.utils = new LambderUtils({ ejsPath });
     }
 
-    enableCors(isCorsEnabled: boolean){
+    enableCors(isCorsEnabled: boolean): this {
         this.isCorsEnabled = isCorsEnabled;
+        return this;
     }
 
     enableDdbSession(
         { tableName, tableRegion, sessionSalt, enableSlidingExpiration }: { tableName: string; tableRegion: string; sessionSalt: string; enableSlidingExpiration?: boolean; }, 
         { partitionKey, sortKey }: { partitionKey: string, sortKey: string } = { partitionKey: "pk", sortKey: "sk" }
-    ){
+    ): this {
         this.lambderSessionManager = new LambderSessionManager({
             tableName, tableRegion, partitionKey, sortKey, sessionSalt, enableSlidingExpiration
         });
+        return this;
     }
 
-    setSessionCookieKey(sessionTokenCookieKey: string, sessionCsrfCookieKey: string){
+    setSessionCookieKey(sessionTokenCookieKey: string, sessionCsrfCookieKey: string): this {
         this.sessionTokenCookieKey = sessionTokenCookieKey;
         this.sessionCsrfCookieKey = sessionCsrfCookieKey;
+        return this;
     }
 
-    setRouteFallbackHandler(routeFallbackHandler: RouteFallbackHandlerFunction){
+    setRouteFallbackHandler(routeFallbackHandler: RouteFallbackHandlerFunction): this {
         this.routeFallbackHandler = routeFallbackHandler;
+        return this;
     }
-    setApiFallbackHandler(apiFallbackHandler: ApiFallbackHandlerFunction){
+    setApiFallbackHandler(apiFallbackHandler: ApiFallbackHandlerFunction): this {
         this.apiFallbackHandler = apiFallbackHandler;
+        return this;
     }
-    setGlobalErrorHandler(globalErrorHandler: GlobalErrorHandlerFunction){
+    setGlobalErrorHandler(globalErrorHandler: GlobalErrorHandlerFunction): this {
         this.globalErrorHandler = globalErrorHandler;
+        return this;
     }
     private getPatternMatch(pattern: string, path: string): Record<string, any> {
         const result = (match(pattern, { decode: decodeURIComponent }))(path);
@@ -199,15 +230,7 @@ export default class Lambder<TContract extends ApiContractShape = any, TSessionD
         }
     }
 
-    async addModule(moduleFn: LambderModuleFunction): Promise<void>{
-        await moduleFn(this);
-    }
-
-    async importModule(moduleImport: Promise<{ default: LambderModuleFunction }>): Promise<void>{
-        await this.addModule((await moduleImport).default);
-    }
-
-    addRoute(condition: Path|ConditionFunction|RegExp, actionFn: ActionFunction):void{
+    addRoute(condition: Path|ConditionFunction|RegExp, actionFn: ActionFunction): this {
         this.actionList.push({ 
             conditionFn: (ctx:LambderRenderContext<any>) => (
                 ctx.method === "GET" && 
@@ -221,15 +244,17 @@ export default class Lambder<TContract extends ApiContractShape = any, TSessionD
                 if(typeof condition === "string"){
                     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 as unknown as Record<string, any>)) : {};
                 }
                 
                 return await actionFn(ctx, resolver);
             }
         });
-    };
+        return this;
+    }
 
-    addSessionRoute(condition: Path|ConditionFunction|RegExp, actionFn: SessionActionFunction<TSessionData>):void{
+    addSessionRoute(condition: Path|ConditionFunction|RegExp, actionFn: SessionActionFunction<TSessionData>): this {
         this.actionList.push({ 
             conditionFn: (ctx:LambderRenderContext<any>) => (
                 ctx.method === "GET" &&
@@ -243,7 +268,8 @@ export default class Lambder<TContract extends ApiContractShape = any, TSessionD
                 if(typeof condition === "string"){
                     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 as unknown as Record<string, any>)) : {};
                 }
 
                 const sessionCtx = ctx as unknown as LambderSessionRenderContext<any, TSessionData>;
@@ -253,76 +279,87 @@ export default class Lambder<TContract extends ApiContractShape = any, TSessionD
                 return await actionFn(sessionCtx, resolver);
             }
         });
-    };
+        return this;
+    }
     
-    // Overload for untyped API with RegExp or function
-    addApi(
-        apiName: ConditionFunction|RegExp,
-        actionFn: ActionFunction
-    ):void;
-    // Overload for typed API with string name (must come before untyped string overload)
-    addApi<TApiName extends keyof TContract & string>(
-        apiName: TApiName,
-        actionFn: (
-            ctx: LambderRenderContext<TContract[TApiName]['input']>,
-            resolver: LambderResolver<TContract, TApiName>
-        ) => LambderResolverResponse|Promise<LambderResolverResponse>
-    ):void;
-    // Overload for untyped API with string (backward compatibility, must be last)
-    addApi(
-        apiName: string,
-        actionFn: ActionFunction
-    ):void;
-    // Implementation
-    addApi(apiName: string|ConditionFunction|RegExp, actionFn: ActionFunction):void{
+    // Plugin system
+    public use<_TNewContract extends Record<string, any>>(
+        plugin: (lambder: Lambder<TSessionData, _TContract>) => Lambder<TSessionData, _TNewContract>
+    ): Lambder<TSessionData, _TNewContract> {
+        return plugin(this);
+    }
+
+    // Typed API with Zod
+    public 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>>> {
         this.actionList.push({ 
-            conditionFn: (ctx:LambderRenderContext<any>) =>  (
-                !!ctx.apiName && (
-                    (typeof apiName === "string" && ctx.apiName === apiName) ||
-                    (typeof apiName === "function" && apiName(ctx)) ||
-                    (apiName?.constructor == RegExp && apiName.test(ctx.apiName))
-                )
-            ), 
-            actionFn: async (ctx:LambderRenderContext<any>, resolver: LambderResolver) => await actionFn(ctx, resolver),
+            conditionFn: (ctx:LambderRenderContext<any>) => ctx.apiName === name,
+            actionFn: async (ctx:LambderRenderContext<any>, resolver: LambderResolver) => {
+                // 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 as any;
+    }
 
-    // Overload for untyped session API with RegExp or function
-    addSessionApi(
-        apiName: ConditionFunction|RegExp,
-        actionFn: SessionActionFunction<TSessionData>
-    ):void;
-    // Overload for typed session API with string name (must come before untyped string overload)
-    addSessionApi<TApiName extends keyof TContract & string>(
-        apiName: TApiName,
-        actionFn: (
-            ctx: LambderSessionRenderContext<TContract[TApiName]['input'], TSessionData>,
-            resolver: LambderResolver<TContract, TApiName>
-        ) => LambderResolverResponse|Promise<LambderResolverResponse>
-    ):void;
-    // Overload for untyped session API with string (backward compatibility, must be last)
-    addSessionApi(
-        apiName: string,
-        actionFn: SessionActionFunction<TSessionData>
-    ):void;
-    // Implementation
-    addSessionApi(apiName: string|ConditionFunction|RegExp, actionFn: SessionActionFunction<TSessionData>):void{
+    // Typed Session API with Zod
+    public 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>>> {
         this.actionList.push({ 
-            conditionFn: (ctx:LambderRenderContext<any>) =>  (
-                !!ctx.apiName && (
-                    (typeof apiName === "string" && ctx.apiName === apiName) ||
-                    (typeof apiName === "function" && apiName(ctx)) ||
-                    (apiName?.constructor == RegExp && apiName.test(ctx.apiName))
-                )
-            ), 
+            conditionFn: (ctx:LambderRenderContext<any>) => ctx.apiName === name,
             actionFn: async (ctx:LambderRenderContext<any>, resolver: LambderResolver) => {
                 const sessionCtx = ctx as unknown as LambderSessionRenderContext<any, TSessionData>;
                 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 as any;
+    }
 
     async addHook(hookEvent: 'created', hookFn: HookCreatedFunction, priority?: number): Promise<void>;
     async addHook(hookEvent: 'beforeRender', hookFn: HookBeforeRenderFunction, priority?: number): Promise<void>;
@@ -375,6 +412,10 @@ export default class Lambder<TContract extends ApiContractShape = any, TSessionD
         });
     };
 
+    getHandler() {
+        return (event: APIGatewayProxyEvent, context: Context) => this.render(event, context);
+    }
+
     async render(
         event: APIGatewayProxyEvent,
         lambdaContext: Context

package/src/LambderApiContract.ts

@@ -1,63 +1,20 @@
 /**
- * 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
+ * Helper type for merging new API into existing contract during chaining
  */
-export type ApiInput<
-    TContract extends ApiContractShape,
-    TApiName extends keyof TContract
-> = TContract[TApiName]['input'];
+export type MergeContract<Old, Name extends string, In, Out> = 
+    Old & { [K in Name]: { input: In, output: Out } };
 
-/**
- * Extract output type from contract for a specific API
- */
-export type ApiOutput<
-    TContract extends ApiContractShape,
-    TApiName extends keyof TContract
-> = TContract[TApiName]['output'];

package/src/LambderCaller.ts

@@ -143,9 +143,9 @@ export default class LambderCaller<TContract extends ApiContractShape = any> {
                     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/src/LambderMSW.ts

@@ -1,9 +1,6 @@
-import { createRequire } from 'module';
 import type { ApiContractShape } from './LambderApiContract';
 import type { LambderApiResponse } from './LambderResponseBuilder';
 
-const require = createRequire(import.meta.url);
-
 // MSW types - these will be resolved at runtime when msw is installed
 type RequestHandler = any;
 
@@ -80,8 +77,6 @@ export default class LambderMSW<TContract extends ApiContractShape = any> {
             if (!body || typeof body.apiName !== 'string') { return; }
             if (body.apiName !== apiName) { return; }
             
-            console.log("LambderMSW called for:", body.apiName);
-            
             try {
                 // Add artificial delay if specified
                 if (options?.delay) {
@@ -91,8 +86,6 @@ export default class LambderMSW<TContract extends ApiContractShape = any> {
                 // Call the handler with the payload from the request
                 const payload = await handler(body.payload as TContract[TApiName]['input']);
                 
-                console.log("Matched! Returning payload for:", apiName);
-
                 const response: MockApiResponse<TContract[TApiName]['output']> = {
                     apiVersion: this.apiVersion,
                     payload,

package/src/LambderResolver.ts

@@ -1,36 +1,32 @@
 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'>;
+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: ApiOutput<TContract, TApiName> | null,
-        config?: Parameters<LambderResponseBuilder<TContract>['api']>[1],
-        headers?: Parameters<LambderResponseBuilder<TContract>['api']>[2]
+        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> {
     public resolve: (response: LambderResolverResponse) => void;
     public reject: (err: Error) => void;
-    public die: DieResolverMethods<TContract, TApiName>;
+    public die: DieResolverMethods<TOutput>;
 
     constructor(
         { isCorsEnabled, publicPath, apiVersion, lambderUtils, ctx, resolve, reject }: 
@@ -66,13 +62,14 @@ export default class LambderResolver<
 
     // Override api method with proper typing
     api(
-        payload: ApiOutput<TContract, TApiName> | null,
-        config?: Parameters<LambderResponseBuilder<TContract>['api']>[1],
-        headers?: Parameters<LambderResponseBuilder<TContract>['api']>[2]
+        payload: TOutput | null,
+        config?: Parameters<LambderResponseBuilder['api']>[1],
+        headers?: Parameters<LambderResponseBuilder['api']>[2]
     ): LambderResolverResponse {
         return super.api(payload, config, headers);
     }
 
+
     private autoResolve<
         T extends (...args: any[]) => LambderResolverResponse
     >(method: T): (...funcArgs: Parameters<T>) => LambderResolverResponse {

package/src/LambderResponseBuilder.ts

@@ -1,7 +1,6 @@
 import mimeTypeResolver from "mime-types";
 import LambderUtils from "./LambderUtils.js";
 import { LambderRenderContext } from "./Lambder.js";
-import type { ApiContractShape } from "./LambderApiContract.js";
 import { getFS, getPath } from "./node-polyfills.js";
 
 const convertToMultiHeader = (
@@ -37,7 +36,7 @@ export type LambderApiResponse<T> = LambderApiResponseConfig & {
     payload?: T | null; 
 }
 
-export default class LambderResponseBuilder<TContract extends ApiContractShape = any> {
+export default class LambderResponseBuilder<TResponse = any> {
     private isCorsEnabled: boolean;
     private publicPath: string;
     private apiVersion: string|null;
@@ -71,7 +70,6 @@ export default class LambderResponseBuilder<TContract extends ApiContractShape =
         
         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"; }
         return await fs.promises.readFile(absolutePath);
     };
@@ -84,7 +82,6 @@ export default class LambderResponseBuilder<TContract extends ApiContractShape =
         
         const publicPath = path.resolve(this.publicPath);
         const absolutePath = path.resolve(publicPath, filePath);
-        console.log("checkPublicFileExist", { filePath, publicPath, absolutePath });
         if(!absolutePath.startsWith(publicPath)){ return false; }
         try {
             const stat = await fs.promises.stat(absolutePath);
@@ -224,7 +221,7 @@ export default class LambderResponseBuilder<TContract extends ApiContractShape =
         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 =  Buffer.isBuffer(body) ? body : Buffer.from(body);
         const bodyBase64 = bodyBuffer.toString("base64");
@@ -262,8 +259,8 @@ export default class LambderResponseBuilder<TContract extends ApiContractShape =
         });
     };
 
-    api<T=any>(
-        payload: T | null, 
+    api(
+        payload: TResponse | null, 
         {
             versionExpired, sessionExpired, notAuthorized, 
             message, errorMessage, logList,

package/src/LambderUtils.ts

@@ -22,9 +22,8 @@ export default class LambderUtils {
         if(!this.ejsPath){ return "EJS PATH NOT SET!"; }
         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');
     };
 
     private async checkEjsFileExist(filePath: string){
@@ -37,7 +36,6 @@ export default class LambderUtils {
         if(!this.ejsPath){ return "EJS PATH NOT SET!"; }
         const ejsPath = path.resolve(this.ejsPath);
         const absolutePath = path.resolve(ejsPath, filePath);
-        console.log("checkEjsFileExist", { filePath, ejsPath, absolutePath });
         if(!absolutePath.startsWith(ejsPath)){ return false; }
         try {
             const stat = await fs.promises.stat(absolutePath);

package/src/index.ts

@@ -10,7 +10,4 @@ export { default as LambderMSW } from "./LambderMSW.js";
 // Type-safe API contract utilities
 export { 
     type ApiContractShape,
-    type ApiContract,
-    type ApiInput,
-    type ApiOutput,
 } from "./LambderApiContract.js";