lambder 1.0.28 → 1.0.31

package/dist/Lambder.d.ts

@@ -35,7 +35,10 @@ 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>;
-export declare const createContext: (event: APIGatewayProxyEvent, lambdaContext: Context, resolve: Function, reject: Function) => RenderContext;
+type GlobalErrorHandlerFunction = (err: Error, renderContext: RenderContext | null) => 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;
     private apiVersion;
@@ -52,9 +55,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,7 +1,7 @@
 import querystring from "querystring";
 import cookieParser from "cookie";
 import Resolver from "./Resolver.js";
-export const createContext = (event, lambdaContext, resolve, reject) => {
+export const createContext = (event, lambdaContext) => {
     const host = event.headers.Host || event.headers.host || "";
     const url = event.path;
     const get = event.queryStringParameters || {};
@@ -21,7 +21,7 @@ export const createContext = (event, lambdaContext, resolve, reject) => {
     }
     catch (e) { }
     if (/^(((\d+\.)+\d+)|(([a-f\d]+:)+[a-f\d]+))$/.test(host)) {
-        reject(new Error("[404] Host cannot be an ip address: " + host));
+        throw new Error("[404] Host cannot be an ip address: " + host);
     }
     return { host, url, method, get, post, cookie, headers, session, lambdaContext };
 };
@@ -147,45 +147,51 @@ export default class Lambder {
         }
     }
     async render(event, lambdaContext) {
-        return await new Promise(async (resolve, reject) => {
-            const resolver = new Resolver({
-                isCorsEnabled: this.isCorsEnabled,
-                publicPath: this.publicPath,
-                apiVersion: this.apiVersion,
-                resolve, reject,
-            });
-            let renderContext = createContext(event, lambdaContext, resolve, reject);
-            if (renderContext.method === "OPTIONS")
-                return resolver.cors();
-            const firstMatchedAction = await (async () => {
-                for (const action of this._actionList) {
-                    if (await action.conditionFn(renderContext))
-                        return action;
+        let eventRenderContext = null;
+        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,
+                });
+                if (renderContext.method === "OPTIONS")
+                    return resolver.cors();
+                const firstMatchedAction = await (async () => {
+                    for (const action of this._actionList) {
+                        if (await action.conditionFn(renderContext))
+                            return action;
+                    }
+                })();
+                if (firstMatchedAction) {
+                    for (const hook of this._hookList["beforeRender"]) {
+                        renderContext = await hook.hookFn(renderContext, resolver);
+                    }
+                    let renderResult = await firstMatchedAction.actionFn(renderContext, resolver);
+                    for (const hook of this._hookList["afterRender"]) {
+                        renderResult = await hook.hookFn(renderContext, resolver, renderResult);
+                    }
+                    resolve(renderResult);
                 }
-            })();
-            if (firstMatchedAction) {
-                for (const hook of this._hookList["beforeRender"]) {
-                    renderContext = await hook.hookFn(renderContext, resolver);
+                else {
+                    return this.handleNoMatchedAction(renderContext, resolver);
                 }
-                let renderResult = await firstMatchedAction.actionFn(renderContext, resolver);
-                for (const hook of this._hookList["afterRender"]) {
-                    renderResult = await hook.hookFn(renderContext, resolver, renderResult);
+            }).then(async (renderResult) => {
+                for (const hook of this._hookList["completed"]) {
+                    renderResult = await hook.hookFn(renderResult);
                 }
-                resolve(renderResult);
-            }
-            else {
-                return this.handleNoMatchedAction(renderContext, resolver);
-            }
-        }).then(async (renderResult) => {
-            for (const hook of this._hookList["completed"]) {
-                renderResult = await hook.hookFn(renderResult);
-            }
-            return renderResult;
-        }).catch(async (err) => {
+                return renderResult;
+            });
+        }
+        catch (err) {
+            const wrappedError = err instanceof Error ? err : new Error("Error: " + String(err));
             if (this.globalErrorHandler) {
-                return this.globalErrorHandler(err);
+                return this.globalErrorHandler(wrappedError, eventRenderContext);
             }
             return { statusCode: 500, body: "Internal Server Error.", };
-        });
+        }
     }
 }

package/package.json

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

package/src/Lambder.ts

@@ -36,6 +36,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) => 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, 
@@ -45,8 +49,6 @@ type HookListType = {
 export const createContext = (
     event: APIGatewayProxyEvent, 
     lambdaContext: Context,
-    resolve: Function, 
-    reject: Function
 ):RenderContext => {
     const host = event.headers.Host || event.headers.host || "";
     const url = event.path;
@@ -61,7 +63,7 @@ export const createContext = (
         try { post = JSON.parse(decodedBody) || {}; }
         catch(e){ post = querystring.parse(decodedBody) || {}; }
     }catch(e){}
-    if(/^(((\d+\.)+\d+)|(([a-f\d]+:)+[a-f\d]+))$/.test(host)){ reject(new Error("[404] Host cannot be an ip address: " + host)); }
+    if(/^(((\d+\.)+\d+)|(([a-f\d]+:)+[a-f\d]+))$/.test(host)){ throw new Error("[404] Host cannot be an ip address: " + host); }
     return { host, url, method, get, post, cookie, headers, session, lambdaContext };
 }
 
@@ -79,9 +81,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, }: 
@@ -101,13 +103,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;
     }
 
@@ -224,48 +226,56 @@ export default class Lambder {
         event: APIGatewayProxyEvent,
         lambdaContext: Context
     ): Promise<ResolverResponse>{
-        return await new Promise(async (
-            resolve:(renderResult: ResolverResponse)=>void,
-            reject:(err: Error)=>void
-        )=> {
-            const resolver = new Resolver({ 
-                isCorsEnabled: this.isCorsEnabled, 
-                publicPath: this.publicPath,
-                apiVersion: this.apiVersion,
-                resolve, reject,
-            });
-            let renderContext:RenderContext = createContext(event, lambdaContext, resolve, reject)
-            if(renderContext.method === "OPTIONS") return resolver.cors();
+        let eventRenderContext:RenderContext|null = null;
 
-            const firstMatchedAction = await (async () => {
-                for(const action of this._actionList){
-                    if(await action.conditionFn(renderContext)) return action;
-                }
-            })();
+        try {
+            let renderContext = createContext(event, lambdaContext);
+            eventRenderContext = renderContext;
 
-            if(firstMatchedAction){
-                for(const hook of this._hookList["beforeRender"]){
-                    renderContext = await hook.hookFn(renderContext, resolver);
+            return await new Promise(async (
+                resolve:(renderResult: ResolverResponse)=>void,
+                reject:(err: Error)=>void
+            )=> {
+                const resolver = new Resolver({ 
+                    isCorsEnabled: this.isCorsEnabled, 
+                    publicPath: this.publicPath,
+                    apiVersion: this.apiVersion,
+                    resolve, reject,
+                });
+                if(renderContext.method === "OPTIONS") return resolver.cors();
+    
+                const firstMatchedAction = await (async () => {
+                    for(const action of this._actionList){
+                        if(await action.conditionFn(renderContext)) return action;
+                    }
+                })();
+    
+                if(firstMatchedAction){
+                    for(const hook of this._hookList["beforeRender"]){
+                        renderContext = await hook.hookFn(renderContext, resolver);
+                    }
+                    let renderResult = await firstMatchedAction.actionFn(renderContext, resolver);
+                    for(const hook of this._hookList["afterRender"]){
+                        renderResult = await hook.hookFn(renderContext, resolver, renderResult);
+                    }
+                    resolve(renderResult);
+                }else{
+                    return this.handleNoMatchedAction(renderContext, resolver);
                 }
-                let renderResult = await firstMatchedAction.actionFn(renderContext, resolver);
-                for(const hook of this._hookList["afterRender"]){
-                    renderResult = await hook.hookFn(renderContext, resolver, renderResult);
+            }).then(async (renderResult: ResolverResponse):Promise<ResolverResponse> => {
+                for(const hook of this._hookList["completed"]){
+                    renderResult = await hook.hookFn(renderResult);
                 }
-                resolve(renderResult);
-            }else{
-                return this.handleNoMatchedAction(renderContext, resolver);
-            }
-        }).then(async (renderResult: ResolverResponse):Promise<ResolverResponse> => {
-            for(const hook of this._hookList["completed"]){
-                renderResult = await hook.hookFn(renderResult);
-            }
-            return renderResult;
-        }).catch(async (err: Error):Promise<ResolverResponse> => {
+                return renderResult;
+            });
+        }catch(err){
+            const wrappedError = err instanceof Error ? err : new Error("Error: " + String(err));
             if(this.globalErrorHandler){
-                return this.globalErrorHandler(err);
+                return this.globalErrorHandler(wrappedError, eventRenderContext);
             }
             return { statusCode: 500, body: "Internal Server Error.", }
-        })
+
+        }
     }
 
 }