lambder 1.0.60 → 1.0.62

package/dist/Lambder.d.ts

@@ -1,6 +1,6 @@
 import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
 import Resolver from "./Resolver.js";
-import ResponseBuilder, { ResolverResponse } from "./ResponseBuilder.js";
+import LambderResponseBuilder, { LambderResolverResponse } from "./LambderResponseBuilder.js";
 type Path = `/${string}`;
 type Session = {
     userId: string;
@@ -25,14 +25,14 @@ type RenderContext = {
     lambdaContext: Context;
 };
 type ConditionFunction = (ctx: RenderContext) => boolean;
-type ActionFunction = (ctx: RenderContext, resolver: Resolver) => ResolverResponse | Promise<ResolverResponse>;
+type ActionFunction = (ctx: RenderContext, resolver: Resolver) => LambderResolverResponse | Promise<LambderResolverResponse>;
 type HookCreatedFunction = (lambderInstance: Lambder) => Promise<void>;
 type HookBeforeRenderFunction = (ctx: RenderContext, resolver: Resolver) => RenderContext | Error | Promise<RenderContext | Error>;
-type HookAfterRenderFunction = (ctx: RenderContext, resolver: Resolver, response: ResolverResponse) => ResolverResponse | Error | Promise<ResolverResponse | Error>;
+type HookAfterRenderFunction = (ctx: RenderContext, resolver: Resolver, response: LambderResolverResponse) => LambderResolverResponse | Error | Promise<LambderResolverResponse | Error>;
 type HookFallbackFunction = (ctx: RenderContext, resolver: Resolver) => void | Promise<void>;
-type GlobalErrorHandlerFunction = (err: Error, ctx: RenderContext | null, response: ResponseBuilder) => ResolverResponse | Promise<ResolverResponse>;
-type RouteFallbackHandlerFunction = (ctx: RenderContext, resolver: Resolver) => ResolverResponse;
-type ApiFallbackHandlerFunction = (ctx: RenderContext, resolver: Resolver) => ResolverResponse;
+type GlobalErrorHandlerFunction = (err: Error, ctx: RenderContext | null, response: LambderResponseBuilder) => LambderResolverResponse | Promise<LambderResolverResponse>;
+type RouteFallbackHandlerFunction = (ctx: RenderContext, resolver: Resolver) => LambderResolverResponse;
+type ApiFallbackHandlerFunction = (ctx: RenderContext, resolver: Resolver) => LambderResolverResponse;
 export declare const createContext: (event: APIGatewayProxyEvent, lambdaContext: Context, apiPath?: string | null) => RenderContext;
 export default class Lambder {
     private apiPath;
@@ -66,8 +66,8 @@ export default class Lambder {
     addHook(hookEvent: 'beforeRender', hookFn: HookBeforeRenderFunction, priority?: number): Promise<void>;
     addHook(hookEvent: 'afterRender', hookFn: HookAfterRenderFunction, priority?: number): Promise<void>;
     addHook(hookEvent: 'fallback', hookFn: HookFallbackFunction, priority?: number): Promise<void>;
-    getResponseBuilder(): ResponseBuilder;
+    getResponseBuilder(): LambderResponseBuilder;
     private getResolver;
-    render(event: APIGatewayProxyEvent, lambdaContext: Context): Promise<ResolverResponse>;
+    render(event: APIGatewayProxyEvent, lambdaContext: Context): Promise<LambderResolverResponse>;
 }
 export {};

package/dist/Lambder.js

@@ -2,7 +2,7 @@ import querystring from "querystring";
 import cookieParser from "cookie";
 import { match } from "path-to-regexp";
 import Resolver from "./Resolver.js";
-import ResponseBuilder from "./ResponseBuilder.js";
+import LambderResponseBuilder from "./LambderResponseBuilder.js";
 export const createContext = (event, lambdaContext, apiPath = null) => {
     const host = event.headers.Host || event.headers.host || "";
     const path = event.path;
@@ -175,7 +175,7 @@ export default class Lambder {
         }
     }
     getResponseBuilder() {
-        return new ResponseBuilder({
+        return new LambderResponseBuilder({
             isCorsEnabled: this.isCorsEnabled,
             publicPath: this.publicPath,
             apiVersion: this.apiVersion,

package/dist/LambderCaller.d.ts

@@ -47,7 +47,7 @@ export default class LambderCaller {
         fetchStartedHandler?: FetchStartEventHandler;
         fetchEndedHandler?: FetchEndEventHandler;
     });
-    api(apiName: string, payload?: any, headers?: Record<string, any>, options?: {
+    api<T>(apiName: string, payload?: any, headers?: Record<string, any>, options?: {
         versionExpiredHandler?: VoidFunction;
         sessionExpiredHandler?: VoidFunction;
         messageHandler?: MessageHandler;
@@ -56,6 +56,6 @@ export default class LambderCaller {
         errorHandler?: ErrorHandler;
         fetchStartedHandler?: FetchStartEventHandler;
         fetchEndedHandler?: FetchEndEventHandler;
-    }): Promise<any>;
+    }): Promise<T | null>;
 }
 export {};

package/dist/LambderCaller.js

@@ -108,6 +108,7 @@ export default class LambderCaller {
             if (this.errorHandler) {
                 this.errorHandler(wrappedError);
             }
+            return null;
         }
     }
     ;

package/dist/LambderResponseBuilder.d.ts

@@ -0,0 +1,36 @@
+export type LambderResolverResponse = {
+    statusCode: number;
+    multiValueHeaders?: Record<string, string[]>;
+    body: string | null;
+    isBase64Encoded?: boolean;
+};
+export type LambderApiResponse<T> = {
+    payload?: T | null;
+    versionExpired?: boolean;
+    sessionExpired?: boolean;
+    notAuthorized?: boolean;
+    message?: any;
+    errorMessage?: any;
+};
+export default class LambderResponseBuilder {
+    private isCorsEnabled;
+    private publicPath;
+    private apiVersion;
+    constructor({ isCorsEnabled, publicPath, apiVersion }: {
+        isCorsEnabled: boolean;
+        publicPath: string;
+        apiVersion?: string | null;
+    });
+    private readFileSync;
+    private checkFileExist;
+    raw(param: LambderResolverResponse): LambderResolverResponse;
+    json(data: Record<string, any>, headers?: Record<string, string | string[]>): LambderResolverResponse;
+    xml(data: string): LambderResolverResponse;
+    html(data: string, headers?: Record<string, string | string[]>): LambderResolverResponse;
+    status301(url: string, headers?: Record<string, string | string[]>): LambderResolverResponse;
+    status404(data: string, headers?: Record<string, string | string[]>): LambderResolverResponse;
+    cors(): LambderResolverResponse;
+    fileBase64(fileBase64: string, mimeType: string, headers?: Record<string, string | string[]>): LambderResolverResponse;
+    file(filePath: string, headers?: Record<string, string | string[]>, fallbackFilePath?: string): LambderResolverResponse;
+    api<T>({ payload, versionExpired, sessionExpired, notAuthorized, message, errorMessage, }: LambderApiResponse<T>, headers?: Record<string, string | string[]>): LambderResolverResponse;
+}

package/dist/{ResponseBuilder.js → LambderResponseBuilder.js}

@@ -8,7 +8,7 @@ const CORS_HEADERS = convertToMultiHeader({
     "Access-Control-Allow-Origin": "*",
     "Access-Control-Allow-Methods": "OPTIONS,POST",
 });
-export default class ResponseBuilder {
+export default class LambderResponseBuilder {
     isCorsEnabled;
     publicPath;
     apiVersion;
@@ -119,9 +119,7 @@ export default class ResponseBuilder {
         return this.fileBase64(bodyBase64, mimeType || "", headers);
     }
     ;
-    api({ payload, versionExpired, sessionExpired, notAuthorized, message = null, errorMessage = null, ...other }, headers) {
-        if (Object.keys(other).length)
-            console.log("ERROR: Unexpected key in result: " + Object.keys(other).join(", "));
+    api({ payload, versionExpired, sessionExpired, notAuthorized, message = null, errorMessage = null, }, headers) {
         return this.json({
             apiVersion: this.apiVersion,
             payload,

package/dist/Resolver.d.ts

@@ -1,26 +1,26 @@
-import ResponseBuilder, { ResolverResponse } from "./ResponseBuilder.js";
+import LambderResponseBuilder, { LambderResolverResponse } from "./LambderResponseBuilder.js";
 type MethodType<T, M extends keyof T> = T[M] extends (...args: any[]) => any ? T[M] : never;
 interface DieResolverMethods {
-    raw: MethodType<ResponseBuilder, 'raw'>;
-    json: MethodType<ResponseBuilder, 'json'>;
-    xml: MethodType<ResponseBuilder, 'xml'>;
-    html: MethodType<ResponseBuilder, 'html'>;
-    status301: MethodType<ResponseBuilder, 'status301'>;
-    status404: MethodType<ResponseBuilder, 'status404'>;
-    cors: MethodType<ResponseBuilder, 'cors'>;
-    fileBase64: MethodType<ResponseBuilder, 'fileBase64'>;
-    file: MethodType<ResponseBuilder, 'file'>;
-    api: MethodType<ResponseBuilder, 'api'>;
+    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'>;
+    api: MethodType<LambderResponseBuilder, 'api'>;
 }
-export default class Resolver extends ResponseBuilder {
-    resolve: (response: ResolverResponse) => void;
+export default class Resolver extends LambderResponseBuilder {
+    resolve: (response: LambderResolverResponse) => void;
     reject: (err: Error) => void;
     die: DieResolverMethods;
     constructor({ isCorsEnabled, publicPath, apiVersion, resolve, reject }: {
         isCorsEnabled: boolean;
         publicPath: string;
         apiVersion?: string | null;
-        resolve: (response: ResolverResponse) => void;
+        resolve: (response: LambderResolverResponse) => void;
         reject: (err: Error) => void;
     });
     private autoResolve;

package/dist/Resolver.js

@@ -1,5 +1,5 @@
-import ResponseBuilder from "./ResponseBuilder.js";
-export default class Resolver extends ResponseBuilder {
+import LambderResponseBuilder from "./LambderResponseBuilder.js";
+export default class Resolver extends LambderResponseBuilder {
     resolve;
     reject;
     die;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import Lambder from './Lambder.js';
 export default Lambder;
 export { default as LambderCaller } from "./LambderCaller.js";
-export { default as ResponseBuilder } from "./ResponseBuilder.js";
+export { default as LambderResponseBuilder } from "./LambderResponseBuilder.js";
 export { default as Resolver } from "./Resolver.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 import Lambder from './Lambder.js';
 export default Lambder;
 export { default as LambderCaller } from "./LambderCaller.js";
-export { default as ResponseBuilder } from "./ResponseBuilder.js";
+export { default as LambderResponseBuilder } from "./LambderResponseBuilder.js";
 export { default as Resolver } from "./Resolver.js";

package/package.json

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

package/src/Lambder.ts

@@ -4,7 +4,7 @@ import { match } from "path-to-regexp";
 
 import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
 import Resolver from "./Resolver.js";
-import ResponseBuilder, { ResolverResponse } from "./ResponseBuilder.js";
+import LambderResponseBuilder, { LambderResolverResponse } from "./LambderResponseBuilder.js";
 
 type Path = `/${string}`;
 
@@ -33,23 +33,19 @@ type RenderContext = {
 };
 
 type ConditionFunction = (ctx: RenderContext) => boolean;
-type ActionFunction = (ctx: RenderContext, resolver: Resolver) => ResolverResponse|Promise<ResolverResponse>;
+type ActionFunction = (ctx: RenderContext, resolver: Resolver) => LambderResolverResponse|Promise<LambderResolverResponse>;
 type ActionObject = { conditionFn: ConditionFunction, actionFn: ActionFunction };
 
 type HookCreatedFunction = (lambderInstance: Lambder) => Promise<void>;
 type HookBeforeRenderFunction = (ctx: RenderContext, resolver: Resolver) => RenderContext|Error|Promise<RenderContext|Error>;
-type HookAfterRenderFunction = (ctx: RenderContext, resolver: Resolver, response: ResolverResponse) => ResolverResponse|Error|Promise<ResolverResponse|Error>;
+type HookAfterRenderFunction = (ctx: RenderContext, resolver: Resolver, response: LambderResolverResponse) => LambderResolverResponse|Error|Promise<LambderResolverResponse|Error>;
 type HookFallbackFunction = (ctx: RenderContext, resolver: Resolver) => void|Promise<void>;
 
-type GlobalErrorHandlerFunction = (err: Error, ctx: RenderContext|null, response: ResponseBuilder) => ResolverResponse|Promise<ResolverResponse>;
-type RouteFallbackHandlerFunction = (ctx:RenderContext, resolver: Resolver) => ResolverResponse;
-type ApiFallbackHandlerFunction = (ctx:RenderContext, resolver: Resolver) => ResolverResponse;
+type GlobalErrorHandlerFunction = (err: Error, ctx: RenderContext|null, response: LambderResponseBuilder) => LambderResolverResponse|Promise<LambderResolverResponse>;
+type RouteFallbackHandlerFunction = (ctx:RenderContext, resolver: Resolver) => LambderResolverResponse;
+type ApiFallbackHandlerFunction = (ctx:RenderContext, resolver: Resolver) => LambderResolverResponse;
 
 type HookEventType = "created"|"beforeRender"|"afterRender"|"fallback";
-type HookListType = { 
-    priority: number, 
-    hookFn: HookCreatedFunction|HookBeforeRenderFunction|HookAfterRenderFunction|HookFallbackFunction,
-}[];
 
 export const createContext = (
     event: APIGatewayProxyEvent, 
@@ -243,14 +239,14 @@ export default class Lambder {
     }
 
     public getResponseBuilder(){
-        return new ResponseBuilder({
+        return new LambderResponseBuilder({
             isCorsEnabled: this.isCorsEnabled, 
             publicPath: this.publicPath,
             apiVersion: this.apiVersion,
         });
     };
 
-    private getResolver(resolve: (response: ResolverResponse) => void, reject: (err: Error) => void){
+    private getResolver(resolve: (response: LambderResolverResponse) => void, reject: (err: Error) => void){
         return new Resolver({
             isCorsEnabled: this.isCorsEnabled, 
             publicPath: this.publicPath,
@@ -262,7 +258,7 @@ export default class Lambder {
     async render(
         event: APIGatewayProxyEvent,
         lambdaContext: Context
-    ): Promise<ResolverResponse>{
+    ): Promise<LambderResolverResponse>{
         let eventRenderContext:RenderContext|null = null;
         
         try {
@@ -270,7 +266,7 @@ export default class Lambder {
             eventRenderContext = ctx;
 
             return await new Promise(async (
-                resolve:(response: ResolverResponse)=>void,
+                resolve:(response: LambderResolverResponse)=>void,
                 reject:(err: Error)=>void
             )=> {
                 try{

package/src/LambderCaller.ts

@@ -1,4 +1,5 @@
 import Cookies from 'js-cookie';
+import { LambderApiResponse } from './LambderResponseBuilder';
 
 type VoidFunction = ()=>void|Promise<void>;
 type FetchTracker = { apiName: string, done: boolean, fetchEndCalled: boolean };
@@ -80,7 +81,7 @@ export default class LambderCaller {
 
     };
 
-    async api(apiName: string, payload?: any, headers?: Record<string, any>, options?: {
+    async api<T>(apiName: string, payload?: any, headers?: Record<string, any>, options?: {
         versionExpiredHandler?: VoidFunction, 
         sessionExpiredHandler?: VoidFunction, 
         messageHandler?: MessageHandler,
@@ -89,7 +90,7 @@ export default class LambderCaller {
         errorHandler?: ErrorHandler, 
         fetchStartedHandler?: FetchStartEventHandler, 
         fetchEndedHandler?: FetchEndEventHandler,
-    }){
+    }): Promise<T|null>{
         const fetchTracker: FetchTracker = { apiName, done: false, fetchEndCalled: false };
         try {
             this.fetchTrackerList.push(fetchTracker);
@@ -108,7 +109,7 @@ export default class LambderCaller {
             }).then(res=>{
                 if(res.status >= 500) throw new Error("Request failed: " + res.status + " - " + res.statusText);
                 return res.json();
-            });
+            }) as LambderApiResponse<T>;
             fetchTracker.done = true;
             if(this.fetchEndedHandler){
                 fetchTracker.fetchEndCalled = true;
@@ -162,6 +163,7 @@ export default class LambderCaller {
                 });
             }
             if(this.errorHandler){ this.errorHandler(wrappedError); }
+            return null;
         }
     };
 }

package/src/{ResponseBuilder.ts → LambderResponseBuilder.ts}

@@ -14,15 +14,23 @@ const CORS_HEADERS = convertToMultiHeader({
     "Access-Control-Allow-Methods": "OPTIONS,POST",
 });
 
-export type ResolverResponse = { 
+export type LambderResolverResponse = { 
     statusCode: number, 
     multiValueHeaders?: Record<string, string[]>, 
     body: string | null,
     isBase64Encoded?: boolean,
 };
 
+export type LambderApiResponse<T> = {
+    payload?: T | null; 
+    versionExpired?: boolean; 
+    sessionExpired?: boolean; 
+    notAuthorized?: boolean; 
+    message?: any; 
+    errorMessage?: any;
+}
 
-export default class ResponseBuilder {
+export default class LambderResponseBuilder {
     private isCorsEnabled: boolean;
     private publicPath: string;
     private apiVersion: string|null;
@@ -56,14 +64,14 @@ export default class ResponseBuilder {
         return fs.existsSync(absolutePath) && fs.statSync(absolutePath).isFile();
     };
 
-    raw(param: ResolverResponse){
+    raw(param: LambderResolverResponse){
         return param;
     };
 
 	json(
         data: Record<string, any>, 
         headers?: Record<string, string|string[]>
-    ):ResolverResponse{
+    ):LambderResolverResponse{
         return this.raw({
             statusCode: 200,
             multiValueHeaders: { 
@@ -75,7 +83,7 @@ export default class ResponseBuilder {
         });
     }
 
-	xml(data: string):ResolverResponse{
+	xml(data: string):LambderResolverResponse{
         return this.raw({
             statusCode: 200,
             isBase64Encoded: true,
@@ -87,7 +95,7 @@ export default class ResponseBuilder {
 	html(
         data: string, 
         headers?: Record<string, string|string[]>,
-    ):ResolverResponse{
+    ):LambderResolverResponse{
         return this.raw({
             statusCode: 200,
             isBase64Encoded: true,
@@ -99,7 +107,7 @@ export default class ResponseBuilder {
 	status301(
         url: string, 
         headers?: Record<string, string|string[]>,
-    ):ResolverResponse{
+    ):LambderResolverResponse{
         return this.raw({
             statusCode: 301, 
             multiValueHeaders: { "Location" : [url], ...convertToMultiHeader(headers) },
@@ -110,7 +118,7 @@ export default class ResponseBuilder {
 	status404(
         data: string,
         headers?: Record<string, string|string[]>,
-    ):ResolverResponse{
+    ):LambderResolverResponse{
         return this.raw({
             statusCode: 404,
             isBase64Encoded: true,
@@ -119,7 +127,7 @@ export default class ResponseBuilder {
         });
     };
 
-	cors():ResolverResponse{
+	cors():LambderResolverResponse{
         return this.raw({ 
             statusCode: 200,
             multiValueHeaders: this.isCorsEnabled ? CORS_HEADERS: {},
@@ -131,7 +139,7 @@ export default class ResponseBuilder {
         fileBase64: string, 
         mimeType: string, 
         headers?: Record<string, string|string[]>,
-    ):ResolverResponse{
+    ):LambderResolverResponse{
         return this.raw({ 
             statusCode: 200, 
             isBase64Encoded: true, 
@@ -144,7 +152,7 @@ export default class ResponseBuilder {
         filePath: string, 
         headers?: Record<string, string|string[]>,
         fallbackFilePath?: string,
-    ):ResolverResponse{
+    ):LambderResolverResponse{
         if(!this.checkFileExist(filePath)){
             if(fallbackFilePath && this.checkFileExist(fallbackFilePath)){
                 return this.file(fallbackFilePath, headers);
@@ -158,23 +166,14 @@ export default class ResponseBuilder {
         return this.fileBase64(bodyBase64, mimeType || "", headers);
     };
 
-    api(
+    api<T>(
         { 
             payload, 
             versionExpired, sessionExpired, notAuthorized, 
             message = null, errorMessage = null, 
-            ...other 
-        }: { 
-            payload?: any; 
-            versionExpired?: boolean; 
-            sessionExpired?: boolean; 
-            notAuthorized?: boolean; 
-            message?: any; 
-            errorMessage?: any;
-        }, 
+        }: LambderApiResponse<T>, 
         headers?: Record<string, string|string[]>,
-    ): ResolverResponse {
-        if(Object.keys(other).length) console.log("ERROR: Unexpected key in result: " + Object.keys(other).join(", "));
+    ): LambderResolverResponse {
         return this.json({ 
             apiVersion: this.apiVersion,
             payload,

package/src/Resolver.ts

@@ -1,22 +1,22 @@
-import ResponseBuilder, { ResolverResponse } from "./ResponseBuilder.js";
+import LambderResponseBuilder, { LambderResolverResponse } from "./LambderResponseBuilder.js";
 
 type MethodType<T, M extends keyof T> = T[M] extends (...args: any[]) => any ? T[M] : never;
 
 interface DieResolverMethods {
-    raw: MethodType<ResponseBuilder, 'raw'>;
-    json: MethodType<ResponseBuilder, 'json'>;
-    xml: MethodType<ResponseBuilder, 'xml'>;
-    html: MethodType<ResponseBuilder, 'html'>;
-    status301: MethodType<ResponseBuilder, 'status301'>;
-    status404: MethodType<ResponseBuilder, 'status404'>;
-    cors: MethodType<ResponseBuilder, 'cors'>;
-    fileBase64: MethodType<ResponseBuilder, 'fileBase64'>;
-    file: MethodType<ResponseBuilder, 'file'>;
-    api: MethodType<ResponseBuilder, 'api'>;
+    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'>;
+    api: MethodType<LambderResponseBuilder, 'api'>;
 }
 
-export default class Resolver extends ResponseBuilder {
-    public resolve: (response: ResolverResponse) => void;
+export default class Resolver extends LambderResponseBuilder {
+    public resolve: (response: LambderResolverResponse) => void;
     public reject: (err: Error) => void;
     public die: DieResolverMethods;
 
@@ -26,7 +26,7 @@ export default class Resolver extends ResponseBuilder {
             isCorsEnabled: boolean, 
             publicPath: string,
             apiVersion?: string|null,
-            resolve: (response: ResolverResponse) => void,
+            resolve: (response: LambderResolverResponse) => void,
             reject: (err: Error) => void,
         }
     ){
@@ -49,10 +49,10 @@ export default class Resolver extends ResponseBuilder {
     }
 
     private autoResolve<
-        T extends (...args: any[]) => ResolverResponse
-    >(method: T): (...funcArgs: Parameters<T>) => ResolverResponse {
-        return (...args: Parameters<T>): ResolverResponse => {
-            const result: ResolverResponse = method.apply(this, args);
+        T extends (...args: any[]) => LambderResolverResponse
+    >(method: T): (...funcArgs: Parameters<T>) => LambderResolverResponse {
+        return (...args: Parameters<T>): LambderResolverResponse => {
+            const result: LambderResolverResponse = method.apply(this, args);
             this.resolve(result);
             return result;
         };

package/src/index.ts

@@ -2,5 +2,5 @@ import Lambder from './Lambder.js';
 
 export default Lambder;
 export { default as LambderCaller } from "./LambderCaller.js";
-export { default as ResponseBuilder } from "./ResponseBuilder.js";
+export { default as LambderResponseBuilder } from "./LambderResponseBuilder.js";
 export { default as Resolver } from "./Resolver.js";

package/dist/ResponseBuilder.d.ts

@@ -1,35 +0,0 @@
-export type ResolverResponse = {
-    statusCode: number;
-    multiValueHeaders?: Record<string, string[]>;
-    body: string | null;
-    isBase64Encoded?: boolean;
-};
-export default class ResponseBuilder {
-    private isCorsEnabled;
-    private publicPath;
-    private apiVersion;
-    constructor({ isCorsEnabled, publicPath, apiVersion }: {
-        isCorsEnabled: boolean;
-        publicPath: string;
-        apiVersion?: string | null;
-    });
-    private readFileSync;
-    private checkFileExist;
-    raw(param: ResolverResponse): ResolverResponse;
-    json(data: Record<string, any>, headers?: Record<string, string | string[]>): ResolverResponse;
-    xml(data: string): ResolverResponse;
-    html(data: string, headers?: Record<string, string | string[]>): ResolverResponse;
-    status301(url: string, headers?: Record<string, string | string[]>): ResolverResponse;
-    status404(data: string, headers?: Record<string, string | string[]>): ResolverResponse;
-    cors(): ResolverResponse;
-    fileBase64(fileBase64: string, mimeType: string, headers?: Record<string, string | string[]>): ResolverResponse;
-    file(filePath: string, headers?: Record<string, string | string[]>, fallbackFilePath?: string): ResolverResponse;
-    api({ payload, versionExpired, sessionExpired, notAuthorized, message, errorMessage, ...other }: {
-        payload?: any;
-        versionExpired?: boolean;
-        sessionExpired?: boolean;
-        notAuthorized?: boolean;
-        message?: any;
-        errorMessage?: any;
-    }, headers?: Record<string, string | string[]>): ResolverResponse;
-}