lambder 1.0.27 → 1.0.29

package/deploy.sh

@@ -4,6 +4,7 @@
 set -e
 
 # Update the version, build the project, and publish
+rm -rf ./dist/*
 npm version patch
 npm run build
 npm publish

package/dist/Lambder.d.ts

@@ -35,7 +35,7 @@ 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;
+export declare const createContext: (event: APIGatewayProxyEvent, lambdaContext: Context) => RenderContext;
 export default class Lambder {
     private apiPath;
     private apiVersion;

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,49 @@ 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;
+        try {
+            let renderContext = createContext(event, lambdaContext);
+            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);
             }
             return { statusCode: 500, body: "Internal Server Error.", };
-        });
+        }
     }
 }

package/package.json

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

package/src/Lambder.ts

@@ -45,8 +45,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 +59,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 };
 }
 
@@ -224,48 +222,54 @@ 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();
-
-            const firstMatchedAction = await (async () => {
-                for(const action of this._actionList){
-                    if(await action.conditionFn(renderContext)) return action;
-                }
-            })();
+        try {
+            let renderContext:RenderContext = createContext(event, lambdaContext)
 
-            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);
             }
             return { statusCode: 500, body: "Internal Server Error.", }
-        })
+
+        }
     }
 
 }