lambder 1.0.29 → 1.0.36

package/dist/Lambder.d.ts

@@ -1,5 +1,6 @@
 import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
-import Resolver, { ResolverResponse } from "./Resolver.js";
+import Resolver from "./Resolver.js";
+import ResolverLight, { ResolverResponse } from "./ResolverLight.js";
 type DDBSession = {
     userId: string;
     userIdHash: string;
@@ -35,6 +36,9 @@ type HookBeforeRenderFunction = (renderContext: RenderContext, resolver: Resolve
 type HookAfterRenderFunction = (renderContext: RenderContext, resolver: Resolver, renderResult: ResolverResponse) => ResolverResponse | Promise<ResolverResponse>;
 type HookFallbackFunction = (renderContext: RenderContext, resolver: Resolver) => ResolverResponse | Promise<ResolverResponse>;
 type HookCompletedFunction = (renderResult: ResolverResponse) => ResolverResponse | Promise<ResolverResponse>;
+type GlobalErrorHandlerFunction = (err: Error, renderContext: RenderContext | null, resolver: ResolverLight) => ResolverResponse | Promise<ResolverResponse>;
+type RouteFallbackHandlerFunction = (renderContext: RenderContext, resolver: Resolver) => ResolverResponse;
+type ApiFallbackHandlerFunction = (renderContext: RenderContext, resolver: Resolver) => ResolverResponse;
 export declare const createContext: (event: APIGatewayProxyEvent, lambdaContext: Context) => RenderContext;
 export default class Lambder {
     private apiPath;
@@ -52,9 +56,9 @@ export default class Lambder {
         apiVersion?: string;
         isCorsEnabled?: boolean;
     });
-    setRouteFallbackHandler(routeFallbackHandler: (renderContext: RenderContext, resolver: Resolver) => ResolverResponse): void;
-    setApiFallbackHandler(apiFallbackHandler: (renderContext: RenderContext, resolver: Resolver) => ResolverResponse): void;
-    setGlobalErrorHandler(globalErrorHandler: (err: Error) => ResolverResponse): void;
+    setRouteFallbackHandler(routeFallbackHandler: RouteFallbackHandlerFunction): void;
+    setApiFallbackHandler(apiFallbackHandler: ApiFallbackHandlerFunction): void;
+    setGlobalErrorHandler(globalErrorHandler: GlobalErrorHandlerFunction): void;
     private validateSession;
     private handleNoMatchedAction;
     addModule(moduleFn: Function): Promise<void>;

package/dist/Lambder.js

@@ -1,6 +1,7 @@
 import querystring from "querystring";
 import cookieParser from "cookie";
 import Resolver from "./Resolver.js";
+import ResolverLight from "./ResolverLight.js";
 export const createContext = (event, lambdaContext) => {
     const host = event.headers.Host || event.headers.host || "";
     const url = event.path;
@@ -147,14 +148,21 @@ export default class Lambder {
         }
     }
     async render(event, lambdaContext) {
+        let eventRenderContext = null;
+        const resolverLight = new ResolverLight({
+            isCorsEnabled: this.isCorsEnabled,
+            publicPath: this.publicPath,
+            apiVersion: this.apiVersion,
+        });
         try {
             let renderContext = createContext(event, lambdaContext);
+            eventRenderContext = renderContext;
             return await new Promise(async (resolve, reject) => {
                 const resolver = new Resolver({
                     isCorsEnabled: this.isCorsEnabled,
                     publicPath: this.publicPath,
                     apiVersion: this.apiVersion,
-                    resolve, reject,
+                    resolve, reject
                 });
                 if (renderContext.method === "OPTIONS")
                     return resolver.cors();
@@ -187,7 +195,7 @@ export default class Lambder {
         catch (err) {
             const wrappedError = err instanceof Error ? err : new Error("Error: " + String(err));
             if (this.globalErrorHandler) {
-                return this.globalErrorHandler(wrappedError);
+                return this.globalErrorHandler(wrappedError, eventRenderContext, resolverLight);
             }
             return { statusCode: 500, body: "Internal Server Error.", };
         }

package/dist/Resolver.d.ts

@@ -1,12 +1,4 @@
-export type ResolverResponse = {
-    statusCode: number;
-    multiValueHeaders?: {
-        [key: string]: string[];
-    };
-    body: string | null;
-    isBase64Encoded?: boolean;
-    [key: string]: any;
-};
+import ResolverLight, { ResolverResponse } from "./ResolverLight";
 interface IResolverMethods {
     raw(param: {
         statusCode: number;
@@ -15,29 +7,29 @@ interface IResolverMethods {
         multiValueHeaders: {
             [key: string]: string[];
         };
-    }): any;
+    }): ResolverResponse;
     json(data: {
         [key: string]: any;
     }, headers?: {
         [key: string]: string | string[];
-    }): any;
-    xml(data: string): any;
+    }): ResolverResponse;
+    xml(data: string): ResolverResponse;
     html(data: string, headers?: {
         [key: string]: string | string[];
-    }): any;
+    }): ResolverResponse;
     status301(url: string, headers?: {
         [key: string]: string | string[];
-    }): any;
+    }): ResolverResponse;
     status404(data: string, headers?: {
         [key: string]: string | string[];
-    }): any;
-    cors(): any;
+    }): ResolverResponse;
+    cors(): ResolverResponse;
     fileBase64(fileBase64: string, mimeType: string, headers?: {
         [key: string]: string | string[];
-    }): any;
+    }): ResolverResponse;
     file(filePath: string, headers?: {
         [key: string]: string | string[];
-    }): any;
+    }): ResolverResponse;
     api({ payload, versionExpired, sessionExpired, notAuthorized, message, errorMessage, ...other }: {
         payload?: any;
         versionExpired?: boolean;
@@ -47,14 +39,11 @@ interface IResolverMethods {
         errorMessage?: any;
     }, headers?: {
         [key: string]: string | string[];
-    }): any;
+    }): ResolverResponse;
 }
-export default class Resolver {
-    private isCorsEnabled;
-    private publicPath;
-    private apiVersion;
-    resolve: Function;
-    reject: Function;
+export default class Resolver extends ResolverLight {
+    resolve: (renderResult: ResolverResponse) => void;
+    reject: (err: Error) => void;
     die: IResolverMethods;
     constructor({ isCorsEnabled, publicPath, apiVersion, resolve, reject }: {
         isCorsEnabled: boolean;
@@ -63,40 +52,6 @@ export default class Resolver {
         resolve: (renderResult: ResolverResponse) => void;
         reject: (err: Error) => void;
     });
-    private readFileSync;
-    private checkFileExist;
-    raw(param: ResolverResponse): ResolverResponse;
-    json(data: {
-        [key: string]: any;
-    }, headers?: {
-        [key: string]: string | string[];
-    }): ResolverResponse;
-    xml(data: string): ResolverResponse;
-    html(data: string, headers?: {
-        [key: string]: string | string[];
-    }): ResolverResponse;
-    status301(url: string, headers?: {
-        [key: string]: string | string[];
-    }): ResolverResponse;
-    status404(data: string, headers?: {
-        [key: string]: string | string[];
-    }): ResolverResponse;
-    cors(): ResolverResponse;
-    fileBase64(fileBase64: string, mimeType: string, headers?: {
-        [key: string]: string | string[];
-    }): ResolverResponse;
-    file(filePath: string, headers?: {
-        [key: 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?: {
-        [key: string]: string | string[];
-    }): ResolverResponse;
+    private autoResolve;
 }
 export {};

package/dist/Resolver.js

@@ -1,153 +1,32 @@
-import fs from "fs";
-import * as path from "path";
-import mimeTypeResolver from "mime-types";
-const convertToMultiHeader = (headers) => Object.fromEntries(Object.entries(headers || {}).map(([k, v]) => [k, Array.isArray(v) ? v : [v]]));
-const CORS_HEADERS = convertToMultiHeader({
-    "Access-Control-Allow-Credentials": "true",
-    "Access-Control-Allow-Headers": "Origin, X-Requested-With, Content-Type, Accept",
-    "Access-Control-Allow-Origin": "*",
-    "Access-Control-Allow-Methods": "OPTIONS,POST",
-});
-export default class Resolver {
-    isCorsEnabled;
-    publicPath;
-    apiVersion;
+import ResolverLight from "./ResolverLight";
+export default class Resolver extends ResolverLight {
     resolve;
     reject;
     die;
     constructor({ isCorsEnabled, publicPath, apiVersion, resolve, reject }) {
-        this.isCorsEnabled = isCorsEnabled;
-        this.publicPath = publicPath;
-        this.apiVersion = apiVersion ?? null;
+        super({ isCorsEnabled, publicPath, apiVersion });
         this.resolve = resolve;
         this.reject = reject;
+        // Bind ResolverLight methods to `this` for `die` and automatically resolve
         this.die = {
-            raw: this.raw,
-            json: this.json,
-            xml: this.xml,
-            html: this.html,
-            status301: this.status301,
-            status404: this.status404,
-            cors: this.cors,
-            fileBase64: this.fileBase64,
-            file: this.file,
-            api: this.api,
+            raw: this.autoResolve(this.raw),
+            json: this.autoResolve(this.json),
+            xml: this.autoResolve(this.xml),
+            html: this.autoResolve(this.html),
+            status301: this.autoResolve(this.status301),
+            status404: this.autoResolve(this.status404),
+            cors: this.autoResolve(this.cors),
+            fileBase64: this.autoResolve(this.fileBase64),
+            file: this.autoResolve(this.file),
+            api: this.autoResolve(this.api),
         };
     }
-    ;
-    readFileSync(filePath) {
-        const publicPath = path.resolve(this.publicPath);
-        const absolutePath = path.join(publicPath, filePath);
-        console.log("readFileSync", { filePath, publicPath, absolutePath });
-        if (!absolutePath.includes(publicPath)) {
-            return "forbiddenpath";
-        }
-        return fs.readFileSync(absolutePath);
-    }
-    ;
-    checkFileExist(filePath) {
-        const publicPath = path.resolve(this.publicPath);
-        const absolutePath = path.join(this.publicPath, filePath);
-        console.log("checkFileExist", { filePath, publicPath, absolutePath });
-        if (!absolutePath.includes(publicPath)) {
-            return false;
-        }
-        return fs.existsSync(absolutePath) && fs.statSync(absolutePath).isFile();
-    }
-    ;
-    raw(param) {
-        return param;
-    }
-    ;
-    json(data, headers) {
-        return this.raw({
-            statusCode: 200,
-            multiValueHeaders: {
-                "Content-Type": ["application/json; charset=utf-8"],
-                ...(this.isCorsEnabled ? CORS_HEADERS : {}),
-                ...convertToMultiHeader(headers)
-            },
-            body: JSON.stringify(data),
-        });
-    }
-    xml(data) {
-        return this.raw({
-            statusCode: 200,
-            isBase64Encoded: true,
-            multiValueHeaders: { "Content-Type": ["application/xml; charset=utf-8"] },
-            body: Buffer.from(data).toString("base64"),
-        });
-    }
-    ;
-    html(data, headers) {
-        return this.raw({
-            statusCode: 200,
-            isBase64Encoded: true,
-            multiValueHeaders: { "Content-Type": ["text/html; charset=utf-8"], ...convertToMultiHeader(headers) },
-            body: Buffer.from(data).toString("base64"),
-        });
-    }
-    ;
-    status301(url, headers) {
-        return this.raw({
-            statusCode: 301,
-            multiValueHeaders: { "Location": [url], ...convertToMultiHeader(headers) },
-            body: null
-        });
-    }
-    ;
-    status404(data, headers) {
-        return this.raw({
-            statusCode: 404,
-            isBase64Encoded: true,
-            multiValueHeaders: { "Content-Type": ["text/html; charset=utf-8"], ...convertToMultiHeader(headers) },
-            body: Buffer.from(data).toString("base64"),
-        });
-    }
-    ;
-    cors() {
-        return this.raw({
-            statusCode: 200,
-            multiValueHeaders: this.isCorsEnabled ? CORS_HEADERS : {},
-            body: JSON.stringify(""),
-        });
-    }
-    ;
-    fileBase64(fileBase64, mimeType, headers) {
-        return this.raw({
-            statusCode: 200,
-            isBase64Encoded: true,
-            multiValueHeaders: { "Content-Type": [mimeType || "text/html"], ...convertToMultiHeader(headers) },
-            body: fileBase64,
-        });
-    }
-    ;
-    file(filePath, headers, fallbackFilePath) {
-        if (!this.checkFileExist(filePath)) {
-            if (fallbackFilePath && this.checkFileExist(fallbackFilePath)) {
-                return this.file(fallbackFilePath, headers);
-            }
-            return this.json({ error: "File not found: " + filePath });
-        }
-        const mimeType = mimeTypeResolver.lookup(filePath);
-        const body = this.readFileSync(filePath);
-        const bodyBase64 = Buffer.from(body).toString("base64");
-        console.log("bodyBase64.length", bodyBase64.length);
-        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(", "));
-        return this.json({
-            apiVersion: this.apiVersion,
-            payload,
-            ...(versionExpired ? { versionExpired } : {}),
-            ...(sessionExpired ? { sessionExpired } : {}),
-            ...(notAuthorized ? { notAuthorized } : {}),
-            ...(message ? { message } : {}),
-            ...(errorMessage ? { errorMessage } : {}),
-        }, headers);
+    autoResolve(method) {
+        return (...args) => {
+            const result = method.apply(this, args);
+            this.resolve(result);
+            return result;
+        };
     }
-    ;
 }
+;

package/dist/ResolverLight.d.ts

@@ -0,0 +1,54 @@
+export type ResolverResponse = {
+    statusCode: number;
+    multiValueHeaders?: {
+        [key: string]: string[];
+    };
+    body: string | null;
+    isBase64Encoded?: boolean;
+    [key: string]: any;
+};
+export default class ResolverLight {
+    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: {
+        [key: string]: any;
+    }, headers?: {
+        [key: string]: string | string[];
+    }): ResolverResponse;
+    xml(data: string): ResolverResponse;
+    html(data: string, headers?: {
+        [key: string]: string | string[];
+    }): ResolverResponse;
+    status301(url: string, headers?: {
+        [key: string]: string | string[];
+    }): ResolverResponse;
+    status404(data: string, headers?: {
+        [key: string]: string | string[];
+    }): ResolverResponse;
+    cors(): ResolverResponse;
+    fileBase64(fileBase64: string, mimeType: string, headers?: {
+        [key: string]: string | string[];
+    }): ResolverResponse;
+    file(filePath: string, headers?: {
+        [key: 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?: {
+        [key: string]: string | string[];
+    }): ResolverResponse;
+}

package/dist/ResolverLight.js

@@ -0,0 +1,137 @@
+import fs from "fs";
+import * as path from "path";
+import mimeTypeResolver from "mime-types";
+const convertToMultiHeader = (headers) => Object.fromEntries(Object.entries(headers || {}).map(([k, v]) => [k, Array.isArray(v) ? v : [v]]));
+const CORS_HEADERS = convertToMultiHeader({
+    "Access-Control-Allow-Credentials": "true",
+    "Access-Control-Allow-Headers": "Origin, X-Requested-With, Content-Type, Accept",
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "OPTIONS,POST",
+});
+export default class ResolverLight {
+    isCorsEnabled;
+    publicPath;
+    apiVersion;
+    constructor({ isCorsEnabled, publicPath, apiVersion }) {
+        this.isCorsEnabled = isCorsEnabled;
+        this.publicPath = publicPath;
+        this.apiVersion = apiVersion ?? null;
+    }
+    ;
+    readFileSync(filePath) {
+        const publicPath = path.resolve(this.publicPath);
+        const absolutePath = path.join(publicPath, filePath);
+        console.log("readFileSync", { filePath, publicPath, absolutePath });
+        if (!absolutePath.includes(publicPath)) {
+            return "forbiddenpath";
+        }
+        return fs.readFileSync(absolutePath);
+    }
+    ;
+    checkFileExist(filePath) {
+        const publicPath = path.resolve(this.publicPath);
+        const absolutePath = path.join(this.publicPath, filePath);
+        console.log("checkFileExist", { filePath, publicPath, absolutePath });
+        if (!absolutePath.includes(publicPath)) {
+            return false;
+        }
+        return fs.existsSync(absolutePath) && fs.statSync(absolutePath).isFile();
+    }
+    ;
+    raw(param) {
+        return param;
+    }
+    ;
+    json(data, headers) {
+        return this.raw({
+            statusCode: 200,
+            multiValueHeaders: {
+                "Content-Type": ["application/json; charset=utf-8"],
+                ...(this.isCorsEnabled ? CORS_HEADERS : {}),
+                ...convertToMultiHeader(headers)
+            },
+            body: JSON.stringify(data),
+        });
+    }
+    xml(data) {
+        return this.raw({
+            statusCode: 200,
+            isBase64Encoded: true,
+            multiValueHeaders: { "Content-Type": ["application/xml; charset=utf-8"] },
+            body: Buffer.from(data).toString("base64"),
+        });
+    }
+    ;
+    html(data, headers) {
+        return this.raw({
+            statusCode: 200,
+            isBase64Encoded: true,
+            multiValueHeaders: { "Content-Type": ["text/html; charset=utf-8"], ...convertToMultiHeader(headers) },
+            body: Buffer.from(data).toString("base64"),
+        });
+    }
+    ;
+    status301(url, headers) {
+        return this.raw({
+            statusCode: 301,
+            multiValueHeaders: { "Location": [url], ...convertToMultiHeader(headers) },
+            body: null
+        });
+    }
+    ;
+    status404(data, headers) {
+        return this.raw({
+            statusCode: 404,
+            isBase64Encoded: true,
+            multiValueHeaders: { "Content-Type": ["text/html; charset=utf-8"], ...convertToMultiHeader(headers) },
+            body: Buffer.from(data).toString("base64"),
+        });
+    }
+    ;
+    cors() {
+        return this.raw({
+            statusCode: 200,
+            multiValueHeaders: this.isCorsEnabled ? CORS_HEADERS : {},
+            body: JSON.stringify(""),
+        });
+    }
+    ;
+    fileBase64(fileBase64, mimeType, headers) {
+        return this.raw({
+            statusCode: 200,
+            isBase64Encoded: true,
+            multiValueHeaders: { "Content-Type": [mimeType || "text/html"], ...convertToMultiHeader(headers) },
+            body: fileBase64,
+        });
+    }
+    ;
+    file(filePath, headers, fallbackFilePath) {
+        if (!this.checkFileExist(filePath)) {
+            if (fallbackFilePath && this.checkFileExist(fallbackFilePath)) {
+                return this.file(fallbackFilePath, headers);
+            }
+            return this.json({ error: "File not found: " + filePath });
+        }
+        const mimeType = mimeTypeResolver.lookup(filePath);
+        const body = this.readFileSync(filePath);
+        const bodyBase64 = Buffer.from(body).toString("base64");
+        console.log("bodyBase64.length", bodyBase64.length);
+        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(", "));
+        return this.json({
+            apiVersion: this.apiVersion,
+            payload,
+            ...(versionExpired ? { versionExpired } : {}),
+            ...(sessionExpired ? { sessionExpired } : {}),
+            ...(notAuthorized ? { notAuthorized } : {}),
+            ...(message ? { message } : {}),
+            ...(errorMessage ? { errorMessage } : {}),
+        }, headers);
+    }
+    ;
+}
+;

package/dist/index.d.ts

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

package/dist/index.js

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

package/package.json

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

package/src/Lambder.ts

@@ -2,7 +2,8 @@ import querystring from "querystring";
 import cookieParser from "cookie";
 
 import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
-import Resolver, { ResolverResponse } from "./Resolver.js";
+import Resolver from "./Resolver.js";
+import ResolverLight, { ResolverResponse } from "./ResolverLight.js";
 
 type DDBSession = {
     userId: string,
@@ -36,6 +37,10 @@ type HookAfterRenderFunction = (renderContext: RenderContext, resolver: Resolver
 type HookFallbackFunction = (renderContext: RenderContext, resolver: Resolver) => ResolverResponse|Promise<ResolverResponse>;
 type HookCompletedFunction = (renderResult: ResolverResponse) => ResolverResponse|Promise<ResolverResponse>;
 
+type GlobalErrorHandlerFunction = (err: Error, renderContext: RenderContext|null, resolver: ResolverLight) => ResolverResponse|Promise<ResolverResponse>;
+type RouteFallbackHandlerFunction = (renderContext:RenderContext, resolver: Resolver) => ResolverResponse;
+type ApiFallbackHandlerFunction = (renderContext:RenderContext, resolver: Resolver) => ResolverResponse;
+
 type HookEventType = "created"|"beforeRender"|"afterRender"|"fallback"|"completed";
 type HookListType = { 
     priority: number, 
@@ -77,9 +82,9 @@ export default class Lambder {
         "fallback": { priority: number, hookFn: HookFallbackFunction }[],
         "completed": { priority: number, hookFn: HookCompletedFunction }[]
     };
-    private globalErrorHandler: Function|null = null;
-    private routeFallbackHandler: Function|null = null;
-    private apiFallbackHandler: Function|null = null;
+    private globalErrorHandler: GlobalErrorHandlerFunction|null = null;
+    private routeFallbackHandler: RouteFallbackHandlerFunction|null = null;
+    private apiFallbackHandler: ApiFallbackHandlerFunction|null = null;
 
     constructor(
         { publicPath, apiPath, apiVersion, isCorsEnabled, }: 
@@ -99,13 +104,13 @@ export default class Lambder {
         };
     }
 
-    setRouteFallbackHandler(routeFallbackHandler: (renderContext:RenderContext, resolver: Resolver)=>ResolverResponse){
+    setRouteFallbackHandler(routeFallbackHandler: RouteFallbackHandlerFunction){
         this.routeFallbackHandler = routeFallbackHandler;
     }
-    setApiFallbackHandler(apiFallbackHandler: (renderContext:RenderContext, resolver: Resolver)=>ResolverResponse){
+    setApiFallbackHandler(apiFallbackHandler: ApiFallbackHandlerFunction){
         this.apiFallbackHandler = apiFallbackHandler;
     }
-    setGlobalErrorHandler(globalErrorHandler: (err: Error)=>ResolverResponse){
+    setGlobalErrorHandler(globalErrorHandler: GlobalErrorHandlerFunction){
         this.globalErrorHandler = globalErrorHandler;
     }
 
@@ -222,18 +227,26 @@ export default class Lambder {
         event: APIGatewayProxyEvent,
         lambdaContext: Context
     ): Promise<ResolverResponse>{
+        let eventRenderContext:RenderContext|null = null;
+        const resolverLight = new ResolverLight({
+            isCorsEnabled: this.isCorsEnabled, 
+            publicPath: this.publicPath,
+            apiVersion: this.apiVersion,
+        })
+
         try {
-            let renderContext:RenderContext = createContext(event, lambdaContext)
+            let renderContext = createContext(event, lambdaContext);
+            eventRenderContext = renderContext;
 
             return await new Promise(async (
                 resolve:(renderResult: ResolverResponse)=>void,
                 reject:(err: Error)=>void
             )=> {
-                const resolver = new Resolver({ 
+                const resolver = new Resolver({
                     isCorsEnabled: this.isCorsEnabled, 
                     publicPath: this.publicPath,
                     apiVersion: this.apiVersion,
-                    resolve, reject,
+                    resolve, reject
                 });
                 if(renderContext.method === "OPTIONS") return resolver.cors();
     
@@ -263,9 +276,8 @@ export default class Lambder {
             });
         }catch(err){
             const wrappedError = err instanceof Error ? err : new Error("Error: " + String(err));
-
             if(this.globalErrorHandler){
-                return this.globalErrorHandler(wrappedError);
+                return this.globalErrorHandler(wrappedError, eventRenderContext, resolverLight);
             }
             return { statusCode: 500, body: "Internal Server Error.", }
 

package/src/Resolver.ts

@@ -1,27 +1,4 @@
-import fs from "fs";
-import * as path from "path";
-import mimeTypeResolver from "mime-types";
-
-const convertToMultiHeader = (
-    headers: { [key:string]: string|string[] } | undefined
-):{ [key:string]: string[] }  =>
-    Object.fromEntries(Object.entries(headers||{}).map(([k,v])=>[ k, Array.isArray(v) ? v : [v] ]));
-
-const CORS_HEADERS = convertToMultiHeader({
-    "Access-Control-Allow-Credentials": "true",
-    "Access-Control-Allow-Headers" : "Origin, X-Requested-With, Content-Type, Accept",
-    "Access-Control-Allow-Origin": "*",
-    "Access-Control-Allow-Methods": "OPTIONS,POST",
-});
-
-
-export type ResolverResponse = { 
-    statusCode: number, 
-    multiValueHeaders?: { [key:string]: string[] }, 
-    body: string | null,
-    isBase64Encoded?: boolean,
-    [key:string]: any,
-};
+import ResolverLight, { ResolverResponse } from "./ResolverLight";
 
 
 interface IResolverMethods {
@@ -30,15 +7,15 @@ interface IResolverMethods {
         isBase64Encoded?: boolean,
         body: null | string, 
         multiValueHeaders: { [key: string]: string[] },
-    }): any;
-    json(data: { [key: string]: any }, headers?: { [key: string]: string | string[] }): any;
-    xml(data: string): any;
-    html(data: string, headers?: { [key: string]: string | string[] }): any;
-    status301(url: string, headers?: { [key: string]: string | string[] }): any;
-    status404(data: string, headers?: { [key: string]: string | string[] }): any;
-    cors(): any;
-    fileBase64(fileBase64: string, mimeType: string, headers?: { [key: string]: string | string[] }): any;
-    file(filePath: string, headers?: { [key: string]: string | string[] }): any;
+    }): ResolverResponse;
+    json(data: { [key: string]: any }, headers?: { [key: string]: string | string[] }): ResolverResponse;
+    xml(data: string): ResolverResponse;
+    html(data: string, headers?: { [key: string]: string | string[] }): ResolverResponse;
+    status301(url: string, headers?: { [key: string]: string | string[] }): ResolverResponse;
+    status404(data: string, headers?: { [key: string]: string | string[] }): ResolverResponse;
+    cors(): ResolverResponse;
+    fileBase64(fileBase64: string, mimeType: string, headers?: { [key: string]: string | string[] }): ResolverResponse;
+    file(filePath: string, headers?: { [key: string]: string | string[] }): ResolverResponse;
     api({ 
             payload, 
             versionExpired, sessionExpired, notAuthorized, 
@@ -53,17 +30,14 @@ interface IResolverMethods {
             errorMessage?: any;
         }, 
         headers?: { [key:string]: string|string[] }
-    ): any;
+    ): ResolverResponse;
 }
 
 
-export default class Resolver {
-    private isCorsEnabled: boolean;
-    private publicPath: string;
-    private apiVersion: string|null;
-    resolve: Function;
-    reject: Function;
-    die: IResolverMethods;
+export default class Resolver extends ResolverLight {
+    public resolve: (renderResult: ResolverResponse) => void;
+    public reject: (err: Error) => void;
+    public die: IResolverMethods;
 
     constructor(
         { isCorsEnabled, publicPath, apiVersion, resolve, reject }: 
@@ -71,173 +45,37 @@ export default class Resolver {
             isCorsEnabled: boolean, 
             publicPath: string,
             apiVersion?: string|null,
-            resolve:(renderResult: ResolverResponse)=>void,
-            reject:(err: Error)=>void
+            resolve: (renderResult: ResolverResponse) => void,
+            reject: (err: Error) => void,
         }
     ){
-        this.isCorsEnabled = isCorsEnabled;
-        this.publicPath = publicPath;
-        this.apiVersion = apiVersion ?? null;
+        super({ isCorsEnabled, publicPath, apiVersion });
         this.resolve = resolve;
         this.reject = reject;
-        this.die = {
-            raw: this.raw,
-            json: this.json,
-            xml: this.xml,
-            html: this.html,
-            status301: this.status301,
-            status404: this.status404,
-            cors: this.cors,
-            fileBase64: this.fileBase64,
-            file: this.file,
-            api: this.api,
-        }
-    };
-
-    private readFileSync(filePath: string){
-        const publicPath = path.resolve(this.publicPath);
-        const absolutePath = path.join(publicPath, filePath);
-        console.log("readFileSync", { filePath, publicPath, absolutePath });
-        if(!absolutePath.includes(publicPath)){ return "forbiddenpath"; }
-        return fs.readFileSync(absolutePath);
-    };
-
-    private checkFileExist(filePath: string){
-        const publicPath = path.resolve(this.publicPath);
-        const absolutePath = path.join(this.publicPath, filePath);
-        console.log("checkFileExist", { filePath, publicPath, absolutePath });
-        if(!absolutePath.includes(publicPath)){ return false; }
-        return fs.existsSync(absolutePath) && fs.statSync(absolutePath).isFile();
-    };
 
-    raw(param: ResolverResponse){
-        return param;
-    };
-
-	json(
-        data: { [key:string]: any }, 
-        headers?: { [key:string]: string|string[] }
-    ):ResolverResponse{
-        return this.raw({
-            statusCode: 200,
-            multiValueHeaders: { 
-                "Content-Type": ["application/json; charset=utf-8"],
-                 ...(this.isCorsEnabled ? CORS_HEADERS : {}), 
-                 ...convertToMultiHeader(headers)
-            },
-            body: JSON.stringify(data),
-        });
+        // Bind ResolverLight methods to `this` for `die` and automatically resolve
+        this.die = {
+            raw: this.autoResolve(this.raw),
+            json: this.autoResolve(this.json),
+            xml: this.autoResolve(this.xml),
+            html: this.autoResolve(this.html),
+            status301: this.autoResolve(this.status301),
+            status404: this.autoResolve(this.status404),
+            cors: this.autoResolve(this.cors),
+            fileBase64: this.autoResolve(this.fileBase64),
+            file: this.autoResolve(this.file),
+            api: this.autoResolve(this.api),
+        };
     }
 
-	xml(data: string):ResolverResponse{
-        return this.raw({
-            statusCode: 200,
-            isBase64Encoded: true,
-            multiValueHeaders: { "Content-Type": ["application/xml; charset=utf-8"]}, 
-            body: Buffer.from(data).toString("base64"),
-        });
-    };
-
-	html(
-        data: string, 
-        headers?: { [key:string]: string|string[] },
-    ):ResolverResponse{
-        return this.raw({
-            statusCode: 200,
-            isBase64Encoded: true,
-            multiValueHeaders: {"Content-Type": ["text/html; charset=utf-8"], ...convertToMultiHeader(headers)},
-            body: Buffer.from(data).toString("base64"),
-        });
-    };
-
-	status301(
-        url: string, 
-        headers?: { [key:string]: string|string[] },
-    ):ResolverResponse{
-        return this.raw({
-            statusCode: 301, 
-            multiValueHeaders: { "Location" : [url], ...convertToMultiHeader(headers) },
-            body:null
-        });
-    };
-
-	status404(
-        data: string,
-        headers?: { [key:string]: string|string[] },
-    ):ResolverResponse{
-        return this.raw({
-            statusCode: 404,
-            isBase64Encoded: true,
-            multiValueHeaders: {"Content-Type": ["text/html; charset=utf-8"], ...convertToMultiHeader(headers)},
-            body: Buffer.from(data).toString("base64"),
-        });
-    };
-
-	cors():ResolverResponse{
-        return this.raw({ 
-            statusCode: 200,
-            multiValueHeaders: this.isCorsEnabled ? CORS_HEADERS: {},
-            body: JSON.stringify(""),
-        });
-    };
-
-	fileBase64 (
-        fileBase64: string, 
-        mimeType: string, 
-        headers?: { [key:string]: string|string[] },
-    ):ResolverResponse{
-        return this.raw({ 
-            statusCode: 200, 
-            isBase64Encoded: true, 
-            multiValueHeaders: { "Content-Type": [mimeType || "text/html"], ...convertToMultiHeader(headers) }, 
-            body: fileBase64, 
-        });
-    };
-
-	file(
-        filePath: string, 
-        headers?: { [key:string]: string|string[] },
-        fallbackFilePath?: string,
-    ):ResolverResponse{
-        if(!this.checkFileExist(filePath)){
-            if(fallbackFilePath && this.checkFileExist(fallbackFilePath)){
-                return this.file(fallbackFilePath, headers);
-            }
-            return this.json({ error: "File not found: " + filePath })
-        }
-        const mimeType = mimeTypeResolver.lookup(filePath);
-        const body = this.readFileSync(filePath);
-        const bodyBase64 = Buffer.from(body).toString("base64");
-        console.log("bodyBase64.length",bodyBase64.length);
-        return this.fileBase64(bodyBase64, mimeType || "", headers);
-    };
+    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);
+            this.resolve(result);
+            return result;
+        };
+    }
 
-    api(
-        { 
-            payload, 
-            versionExpired, sessionExpired, notAuthorized, 
-            message = null, errorMessage = null, 
-            ...other 
-        }: { 
-            payload?: any; 
-            versionExpired?: boolean; 
-            sessionExpired?: boolean; 
-            notAuthorized?: boolean; 
-            message?: any; 
-            errorMessage?: any;
-        }, 
-        headers?: { [key:string]: string|string[] },
-    ): ResolverResponse {
-        if(Object.keys(other).length) console.log("ERROR: Unexpected key in result: " + Object.keys(other).join(", "));
-        return this.json({ 
-            apiVersion: this.apiVersion,
-            payload,
-            ...(versionExpired ? {versionExpired} : {}),
-            ...(sessionExpired ? {sessionExpired} : {}),
-            ...(notAuthorized ? {notAuthorized} : {}),
-            ...(message ? {message} : {}),
-            ...(errorMessage ? {errorMessage} : {}),
-        }, headers);
-    };
-    
-}
+};

package/src/ResolverLight.ts

@@ -0,0 +1,224 @@
+import fs from "fs";
+import * as path from "path";
+import mimeTypeResolver from "mime-types";
+
+const convertToMultiHeader = (
+    headers: { [key:string]: string|string[] } | undefined
+):{ [key:string]: string[] }  =>
+    Object.fromEntries(Object.entries(headers||{}).map(([k,v])=>[ k, Array.isArray(v) ? v : [v] ]));
+
+const CORS_HEADERS = convertToMultiHeader({
+    "Access-Control-Allow-Credentials": "true",
+    "Access-Control-Allow-Headers" : "Origin, X-Requested-With, Content-Type, Accept",
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "OPTIONS,POST",
+});
+
+export type ResolverResponse = { 
+    statusCode: number, 
+    multiValueHeaders?: { [key:string]: string[] }, 
+    body: string | null,
+    isBase64Encoded?: boolean,
+    [key:string]: any,
+};
+
+
+export default class ResolverLight {
+    private isCorsEnabled: boolean;
+    private publicPath: string;
+    private apiVersion: string|null;
+
+    constructor(
+        { isCorsEnabled, publicPath, apiVersion }: 
+        { 
+            isCorsEnabled: boolean, 
+            publicPath: string,
+            apiVersion?: string|null,
+        }
+    ){
+        this.isCorsEnabled = isCorsEnabled;
+        this.publicPath = publicPath;
+        this.apiVersion = apiVersion ?? null;
+    };
+
+    private readFileSync(filePath: string){
+        const publicPath = path.resolve(this.publicPath);
+        const absolutePath = path.join(publicPath, filePath);
+        console.log("readFileSync", { filePath, publicPath, absolutePath });
+        if(!absolutePath.includes(publicPath)){ return "forbiddenpath"; }
+        return fs.readFileSync(absolutePath);
+    };
+
+    private checkFileExist(filePath: string){
+        const publicPath = path.resolve(this.publicPath);
+        const absolutePath = path.join(this.publicPath, filePath);
+        console.log("checkFileExist", { filePath, publicPath, absolutePath });
+        if(!absolutePath.includes(publicPath)){ return false; }
+        return fs.existsSync(absolutePath) && fs.statSync(absolutePath).isFile();
+    };
+
+    raw(param: ResolverResponse){
+        return param;
+    };
+
+	json(
+        data: { [key:string]: any }, 
+        headers?: { [key:string]: string|string[] }
+    ):ResolverResponse{
+        return this.raw({
+            statusCode: 200,
+            multiValueHeaders: { 
+                "Content-Type": ["application/json; charset=utf-8"],
+                 ...(this.isCorsEnabled ? CORS_HEADERS : {}), 
+                 ...convertToMultiHeader(headers)
+            },
+            body: JSON.stringify(data),
+        });
+    }
+
+	xml(data: string):ResolverResponse{
+        return this.raw({
+            statusCode: 200,
+            isBase64Encoded: true,
+            multiValueHeaders: { "Content-Type": ["application/xml; charset=utf-8"]}, 
+            body: Buffer.from(data).toString("base64"),
+        });
+    };
+
+	html(
+        data: string, 
+        headers?: { [key:string]: string|string[] },
+    ):ResolverResponse{
+        return this.raw({
+            statusCode: 200,
+            isBase64Encoded: true,
+            multiValueHeaders: {"Content-Type": ["text/html; charset=utf-8"], ...convertToMultiHeader(headers)},
+            body: Buffer.from(data).toString("base64"),
+        });
+    };
+
+	status301(
+        url: string, 
+        headers?: { [key:string]: string|string[] },
+    ):ResolverResponse{
+        return this.raw({
+            statusCode: 301, 
+            multiValueHeaders: { "Location" : [url], ...convertToMultiHeader(headers) },
+            body:null
+        });
+    };
+
+	status404(
+        data: string,
+        headers?: { [key:string]: string|string[] },
+    ):ResolverResponse{
+        return this.raw({
+            statusCode: 404,
+            isBase64Encoded: true,
+            multiValueHeaders: {"Content-Type": ["text/html; charset=utf-8"], ...convertToMultiHeader(headers)},
+            body: Buffer.from(data).toString("base64"),
+        });
+    };
+
+	cors():ResolverResponse{
+        return this.raw({ 
+            statusCode: 200,
+            multiValueHeaders: this.isCorsEnabled ? CORS_HEADERS: {},
+            body: JSON.stringify(""),
+        });
+    };
+
+	fileBase64 (
+        fileBase64: string, 
+        mimeType: string, 
+        headers?: { [key:string]: string|string[] },
+    ):ResolverResponse{
+        return this.raw({ 
+            statusCode: 200, 
+            isBase64Encoded: true, 
+            multiValueHeaders: { "Content-Type": [mimeType || "text/html"], ...convertToMultiHeader(headers) }, 
+            body: fileBase64, 
+        });
+    };
+
+	file(
+        filePath: string, 
+        headers?: { [key:string]: string|string[] },
+        fallbackFilePath?: string,
+    ):ResolverResponse{
+        if(!this.checkFileExist(filePath)){
+            if(fallbackFilePath && this.checkFileExist(fallbackFilePath)){
+                return this.file(fallbackFilePath, headers);
+            }
+            return this.json({ error: "File not found: " + filePath })
+        }
+        const mimeType = mimeTypeResolver.lookup(filePath);
+        const body = this.readFileSync(filePath);
+        const bodyBase64 = Buffer.from(body).toString("base64");
+        console.log("bodyBase64.length",bodyBase64.length);
+        return this.fileBase64(bodyBase64, mimeType || "", headers);
+    };
+
+    api(
+        { 
+            payload, 
+            versionExpired, sessionExpired, notAuthorized, 
+            message = null, errorMessage = null, 
+            ...other 
+        }: { 
+            payload?: any; 
+            versionExpired?: boolean; 
+            sessionExpired?: boolean; 
+            notAuthorized?: boolean; 
+            message?: any; 
+            errorMessage?: any;
+        }, 
+        headers?: { [key:string]: string|string[] },
+    ): ResolverResponse {
+        if(Object.keys(other).length) console.log("ERROR: Unexpected key in result: " + Object.keys(other).join(", "));
+        return this.json({ 
+            apiVersion: this.apiVersion,
+            payload,
+            ...(versionExpired ? {versionExpired} : {}),
+            ...(sessionExpired ? {sessionExpired} : {}),
+            ...(notAuthorized ? {notAuthorized} : {}),
+            ...(message ? {message} : {}),
+            ...(errorMessage ? {errorMessage} : {}),
+        }, headers);
+    };
+
+};
+
+
+
+interface IResolverMethods {
+    raw(param: { 
+        statusCode: number, 
+        isBase64Encoded?: boolean,
+        body: null | string, 
+        multiValueHeaders: { [key: string]: string[] },
+    }): ResolverResponse;
+    json(data: { [key: string]: any }, headers?: { [key: string]: string | string[] }): ResolverResponse;
+    xml(data: string): ResolverResponse;
+    html(data: string, headers?: { [key: string]: string | string[] }): ResolverResponse;
+    status301(url: string, headers?: { [key: string]: string | string[] }): ResolverResponse;
+    status404(data: string, headers?: { [key: string]: string | string[] }): ResolverResponse;
+    cors(): ResolverResponse;
+    fileBase64(fileBase64: string, mimeType: string, headers?: { [key: string]: string | string[] }): ResolverResponse;
+    file(filePath: string, headers?: { [key: string]: string | string[] }): ResolverResponse;
+    api({ 
+            payload, 
+            versionExpired, sessionExpired, notAuthorized, 
+            message, errorMessage, 
+            ...other 
+        }: { 
+            payload?: any; 
+            versionExpired?: boolean; 
+            sessionExpired?: boolean; 
+            notAuthorized?: boolean; 
+            message?: any; 
+            errorMessage?: any;
+        }, 
+        headers?: { [key:string]: string|string[] }
+    ): ResolverResponse;
+}

package/src/index.ts

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