lambder 1.0.54 → 1.0.56

package/dist/Lambder.d.ts

@@ -26,10 +26,9 @@ type RenderContext = {
 type ConditionFunction = (ctx: RenderContext) => boolean;
 type ActionFunction = (ctx: RenderContext, resolver: Resolver) => ResolverResponse | Promise<ResolverResponse>;
 type HookCreatedFunction = (lambderInstance: Lambder) => Promise<void>;
-type HookBeforeRenderFunction = (ctx: RenderContext, resolver: Resolver) => RenderContext | Promise<RenderContext>;
-type HookAfterRenderFunction = (ctx: RenderContext, resolver: Resolver, response: ResolverResponse) => ResolverResponse | Promise<ResolverResponse>;
-type HookFallbackFunction = (ctx: RenderContext, resolver: Resolver) => ResolverResponse | Promise<ResolverResponse>;
-type HookCompletedFunction = (response: ResolverResponse) => ResolverResponse | Promise<ResolverResponse>;
+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 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;
@@ -66,7 +65,6 @@ 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>;
-    addHook(hookEvent: 'completed', hookFn: HookCompletedFunction, priority?: number): Promise<void>;
     getResponseBuilder(): ResponseBuilder;
     private getResolver;
     render(event: APIGatewayProxyEvent, lambdaContext: Context): Promise<ResolverResponse>;

package/dist/Lambder.js

@@ -48,7 +48,6 @@ export default class Lambder {
             "beforeRender": [],
             "afterRender": [],
             "fallback": [],
-            "completed": []
         };
     }
     setRouteFallbackHandler(routeFallbackHandler) {
@@ -199,30 +198,37 @@ export default class Lambder {
             let ctx = createContext(event, lambdaContext);
             eventRenderContext = ctx;
             return await new Promise(async (resolve, reject) => {
-                const resolver = this.getResolver(resolve, reject);
-                if (ctx.method === "OPTIONS")
-                    return resolver.cors();
-                const firstMatchedAction = this.actionList.find(action => action.conditionFn(ctx));
-                if (firstMatchedAction) {
-                    for (const hook of this.hookList["beforeRender"]) {
-                        ctx = await hook.hookFn(ctx, resolver);
+                try {
+                    const resolver = this.getResolver(resolve, reject);
+                    if (ctx.method === "OPTIONS")
+                        return resolver.cors();
+                    const firstMatchedAction = this.actionList.find(action => action.conditionFn(ctx));
+                    if (firstMatchedAction) {
+                        for (const hook of this.hookList["beforeRender"]) {
+                            const hookCtx = await hook.hookFn(ctx, resolver);
+                            if (hookCtx instanceof Error) {
+                                throw hookCtx;
+                            }
+                            ctx = hookCtx;
+                        }
+                        let response = await firstMatchedAction.actionFn(ctx, resolver);
+                        for (const hook of this.hookList["afterRender"]) {
+                            const hookResponse = await hook.hookFn(ctx, resolver, response);
+                            if (hookResponse instanceof Error) {
+                                throw hookResponse;
+                            }
+                            response = hookResponse;
+                        }
+                        resolve(response);
                     }
-                    let response = await firstMatchedAction.actionFn(ctx, resolver);
-                    for (const hook of this.hookList["afterRender"]) {
-                        response = await hook.hookFn(ctx, resolver, response);
+                    else {
+                        return this.handleNoMatchedAction(ctx, resolver);
                     }
-                    resolve(response);
                 }
-                else {
-                    return this.handleNoMatchedAction(ctx, resolver);
+                catch (err) {
+                    const wrappedError = err instanceof Error ? err : new Error("Error: " + String(err));
+                    reject(wrappedError);
                 }
-            }).then(async (response) => {
-                for (const hook of this.hookList["completed"]) {
-                    response = await hook.hookFn(response);
-                }
-                return response;
-            }).catch((reason) => {
-                throw reason;
             });
         }
         catch (err) {

package/package.json

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

package/src/Lambder.ts

@@ -36,19 +36,18 @@ type ActionFunction = (ctx: RenderContext, resolver: Resolver) => ResolverRespon
 type ActionObject = { conditionFn: ConditionFunction, actionFn: ActionFunction };
 
 type HookCreatedFunction = (lambderInstance: Lambder) => Promise<void>;
-type HookBeforeRenderFunction = (ctx: RenderContext, resolver: Resolver) => RenderContext|Promise<RenderContext>;
-type HookAfterRenderFunction = (ctx: RenderContext, resolver: Resolver, response: ResolverResponse) => ResolverResponse|Promise<ResolverResponse>;
-type HookFallbackFunction = (ctx: RenderContext, resolver: Resolver) => ResolverResponse|Promise<ResolverResponse>;
-type HookCompletedFunction = (response: ResolverResponse) => ResolverResponse|Promise<ResolverResponse>;
+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 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 HookEventType = "created"|"beforeRender"|"afterRender"|"fallback"|"completed";
+type HookEventType = "created"|"beforeRender"|"afterRender"|"fallback";
 type HookListType = { 
     priority: number, 
-    hookFn: HookCreatedFunction|HookBeforeRenderFunction|HookAfterRenderFunction|HookFallbackFunction|HookCompletedFunction,
+    hookFn: HookCreatedFunction|HookBeforeRenderFunction|HookAfterRenderFunction|HookFallbackFunction,
 }[];
 
 export const createContext = (
@@ -85,7 +84,6 @@ export default class Lambder {
         "beforeRender": { priority: number, hookFn: HookBeforeRenderFunction }[],
         "afterRender": { priority: number, hookFn: HookAfterRenderFunction }[],
         "fallback": { priority: number, hookFn: HookFallbackFunction }[],
-        "completed": { priority: number, hookFn: HookCompletedFunction }[]
     };
     private globalErrorHandler: GlobalErrorHandlerFunction|null = null;
     private routeFallbackHandler: RouteFallbackHandlerFunction|null = null;
@@ -105,7 +103,6 @@ export default class Lambder {
             "beforeRender": [],
             "afterRender": [],
             "fallback": [],
-            "completed": []
         };
     }
 
@@ -137,7 +134,7 @@ export default class Lambder {
     };
 
     private async handleNoMatchedAction(ctx: RenderContext, resolver: Resolver){
-        for(const hook of this.hookList["fallback"]){ await hook.hookFn(ctx, resolver); }
+        for(const hook of this.hookList["fallback"]){  await hook.hookFn(ctx, resolver); }
 
         const isAPI = ctx.path === this.apiPath;
         if(isAPI && this.apiFallbackHandler){
@@ -170,6 +167,7 @@ export default class Lambder {
                 }else if(condition?.constructor == RegExp){
                     ctx.pathParams = ctx.path.match(condition);
                 }
+                
                 return await actionFn(ctx, resolver);
             }
         });
@@ -230,15 +228,13 @@ export default class Lambder {
         });
     };
 
-
     async addHook(hookEvent: 'created', hookFn: HookCreatedFunction, priority?: number): Promise<void>;
     async addHook(hookEvent: 'beforeRender', hookFn: HookBeforeRenderFunction, priority?: number): Promise<void>;
     async addHook(hookEvent: 'afterRender', hookFn: HookAfterRenderFunction, priority?: number): Promise<void>;
     async addHook(hookEvent: 'fallback', hookFn: HookFallbackFunction, priority?: number): Promise<void>;
-    async addHook(hookEvent: 'completed', hookFn: HookCompletedFunction, priority?: number): Promise<void>;
     async addHook(
         hookEvent:HookEventType, 
-        hookFn: HookCreatedFunction & HookBeforeRenderFunction & HookAfterRenderFunction & HookFallbackFunction & HookCompletedFunction,
+        hookFn: HookCreatedFunction & HookBeforeRenderFunction & HookAfterRenderFunction & HookFallbackFunction,
         priority = 0
     ): Promise<void> {
         if(hookEvent === "created"){
@@ -280,23 +276,31 @@ export default class Lambder {
                 resolve:(response: ResolverResponse)=>void,
                 reject:(err: Error)=>void
             )=> {
-                const resolver = this.getResolver(resolve, reject);
-                if(ctx.method === "OPTIONS") return resolver.cors();
-    
-                const firstMatchedAction = this.actionList.find(action => action.conditionFn(ctx));
-                if(firstMatchedAction){
-                    for(const hook of this.hookList["beforeRender"]){ ctx = await hook.hookFn(ctx, resolver); }
-                    let response = await firstMatchedAction.actionFn(ctx, resolver);
-                    for(const hook of this.hookList["afterRender"]){ response = await hook.hookFn(ctx, resolver, response); }
-                    resolve(response);
-                }else{
-                    return this.handleNoMatchedAction(ctx, resolver);
+                try{
+                    const resolver = this.getResolver(resolve, reject);
+                    if(ctx.method === "OPTIONS") return resolver.cors();
+        
+                    const firstMatchedAction = this.actionList.find(action => action.conditionFn(ctx));
+                    if(firstMatchedAction){
+                        for(const hook of this.hookList["beforeRender"]){ 
+                            const hookCtx = await hook.hookFn(ctx, resolver);
+                            if(hookCtx instanceof Error){ throw hookCtx; }
+                            ctx = hookCtx;
+                        }
+                        let response = await firstMatchedAction.actionFn(ctx, resolver);
+                        for(const hook of this.hookList["afterRender"]){ 
+                            const hookResponse = await hook.hookFn(ctx, resolver, response);
+                            if(hookResponse instanceof Error){ throw hookResponse; }
+                            response = hookResponse;
+                        }
+                        resolve(response);
+                    }else{
+                        return this.handleNoMatchedAction(ctx, resolver);
+                    }
+                } catch(err){ 
+                    const wrappedError = err instanceof Error ? err : new Error("Error: " + String(err));
+                    reject(wrappedError);
                 }
-            }).then(async (response: ResolverResponse):Promise<ResolverResponse> => {
-                for(const hook of this.hookList["completed"]){ response = await hook.hookFn(response); }
-                return response;
-            }).catch((reason: Error)=>{
-                throw reason;
             })
         }catch(err){
             if(this.globalErrorHandler){