lambder 1.0.17 → 1.0.19

package/.vscode/settings.json

@@ -18,7 +18,7 @@
 			"**/.git/": true,
     },
     "cSpell.words": [
-      "lambder"
+      "lambder", 
     ],
   }
   

package/dist/LambderCaller.d.ts

@@ -0,0 +1,39 @@
+type VoidFunction = () => void | Promise<void>;
+type StartEndEventHandler = (activeFetchList: {
+    apiName: string;
+    done: boolean;
+}[]) => void | Promise<void>;
+type ErrorHandler = (err: Error) => void | Promise<void>;
+type MessageHandler = (message: any) => void | Promise<void>;
+export default class LambderCaller {
+    isCorsEnabled: boolean;
+    apiPath: string;
+    apiVersion?: string;
+    fetchTrackerList: {
+        apiName: string;
+        done: boolean;
+    }[];
+    versionExpiredHandler?: VoidFunction;
+    sessionExpiredHandler?: VoidFunction;
+    messageHandler?: MessageHandler;
+    errorMessageHandler?: MessageHandler;
+    notAuthorizedHandler?: VoidFunction;
+    errorHandler?: ErrorHandler;
+    fetchStartedHandler?: StartEndEventHandler;
+    fetchEndedHandler?: StartEndEventHandler;
+    constructor({ isCorsEnabled, apiPath, apiVersion, versionExpiredHandler, sessionExpiredHandler, messageHandler, errorMessageHandler, notAuthorizedHandler, errorHandler, fetchStartedHandler, fetchEndedHandler, }: {
+        isCorsEnabled: boolean;
+        apiPath: string;
+        apiVersion?: string;
+        versionExpiredHandler?: VoidFunction;
+        sessionExpiredHandler?: VoidFunction;
+        messageHandler?: MessageHandler;
+        errorMessageHandler?: MessageHandler;
+        notAuthorizedHandler?: VoidFunction;
+        errorHandler?: ErrorHandler;
+        fetchStartedHandler?: StartEndEventHandler;
+        fetchEndedHandler?: StartEndEventHandler;
+    });
+    private api;
+}
+export {};

package/dist/LambderCaller.js

@@ -0,0 +1,93 @@
+import Cookies from 'js-cookie';
+export default class LambderCaller {
+    isCorsEnabled;
+    apiPath;
+    apiVersion;
+    fetchTrackerList = [];
+    versionExpiredHandler;
+    sessionExpiredHandler;
+    messageHandler;
+    errorMessageHandler;
+    notAuthorizedHandler;
+    errorHandler;
+    fetchStartedHandler;
+    fetchEndedHandler;
+    constructor({ isCorsEnabled, apiPath, apiVersion, versionExpiredHandler, sessionExpiredHandler, messageHandler, errorMessageHandler, notAuthorizedHandler, errorHandler, fetchStartedHandler, fetchEndedHandler, }) {
+        this.isCorsEnabled = isCorsEnabled;
+        this.apiPath = apiPath;
+        this.apiVersion = apiVersion;
+        this.versionExpiredHandler = versionExpiredHandler;
+        this.sessionExpiredHandler = sessionExpiredHandler;
+        this.messageHandler = messageHandler;
+        this.errorMessageHandler = errorMessageHandler;
+        this.notAuthorizedHandler = notAuthorizedHandler;
+        this.errorHandler = errorHandler;
+        this.fetchStartedHandler = fetchStartedHandler;
+        this.fetchEndedHandler = fetchEndedHandler;
+    }
+    ;
+    async api(apiName, payload, headers) {
+        const fetchTracker = { apiName, done: false };
+        try {
+            this.fetchTrackerList.push(fetchTracker);
+            if (this.fetchStartedHandler)
+                await this.fetchStartedHandler(this.fetchTrackerList.filter(v => !v.done));
+            const version = this.apiVersion;
+            const token = Cookies.get("LMBRTOKEN") || "";
+            const siteHost = window.location.hostname;
+            let data = await fetch(this.apiPath, {
+                method: 'POST', mode: 'same-origin', cache: 'no-cache',
+                credentials: 'same-origin', redirect: 'follow', referrerPolicy: 'origin',
+                headers: { 'Content-Type': 'application/json', ...(headers || {}) },
+                body: JSON.stringify({ api: apiName, version, token, siteHost, payload, }),
+            }).then(res => {
+                if (res.status >= 500)
+                    throw new Error("Request failed: " + res.status + " - " + res.statusText);
+                return res.json();
+            });
+            if (data && data.versionExpired) {
+                if (this.versionExpiredHandler) {
+                    await this.versionExpiredHandler();
+                }
+                else if (this.errorHandler) {
+                    await this.errorHandler(new Error("Version Expired; Please refresh;"));
+                }
+                return null;
+            }
+            if (data && data.sessionExpired) {
+                Cookies.set('LMBRAUTHID', '', { expires: -1 });
+                Cookies.set('LMBRTOKEN', '', { expires: -1 });
+                if (this.sessionExpiredHandler) {
+                    await this.sessionExpiredHandler();
+                }
+                else if (this.errorHandler) {
+                    await this.errorHandler(new Error("Version Expired; Please refresh;"));
+                }
+                return null;
+            }
+            if (data && data.notAuthorized) {
+                if (this.notAuthorizedHandler) {
+                    await this.notAuthorizedHandler();
+                }
+                else if (this.errorHandler) {
+                    await this.errorHandler(new Error("Version Expired; Please refresh;"));
+                }
+                return null;
+            }
+            if (data && data.message && this.messageHandler) {
+                await this.messageHandler(data.message);
+            }
+            if (data && data.errorMessage && this.errorMessageHandler) {
+                await this.errorMessageHandler(data.errorMessage);
+            }
+            return data.payload ?? null;
+        }
+        catch (err) {
+            fetchTracker.done = true;
+            if (this.errorHandler) {
+                this.errorHandler(err instanceof Error ? err : new Error("Error: " + String(err)));
+            }
+        }
+    }
+    ;
+}

package/dist/Resolver.d.ts

@@ -85,9 +85,13 @@ export default class Resolver {
     file(filePath: string, headers?: {
         [key: string]: string | string[];
     }, fallbackFilePath?: string): ResolverResponse;
-    api({ payload, error, ...other }: {
+    api({ payload, versionExpired, sessionExpired, notAuthorized, message, errorMessage, ...other }: {
         payload?: any;
-        error?: any;
+        versionExpired?: boolean;
+        sessionExpired?: boolean;
+        notAuthorized?: boolean;
+        message?: any;
+        errorMessage?: any;
     }, headers?: {
         [key: string]: string | string[];
     }): ResolverResponse;

package/dist/Resolver.js

@@ -136,15 +136,17 @@ export default class Resolver {
         return this.fileBase64(bodyBase64, mimeType || "", headers);
     }
     ;
-    api({ payload, error = null, ...other }, headers) {
-        if (error)
-            console.log("ERROR: ", error);
+    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,
-            ...(error ? { error } : {}),
+            ...(versionExpired ? { versionExpired } : {}),
+            ...(sessionExpired ? { sessionExpired } : {}),
+            ...(notAuthorized ? { notAuthorized } : {}),
+            ...(message ? { message } : {}),
+            ...(errorMessage ? { errorMessage } : {}),
         }, headers);
     }
     ;

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
 import Resolver, { ResolverResponse } from "./Resolver.js";
+export { default as LambderCaller } from "./LambderCaller.js";
 type DDBSession = {
     userId: string;
     userIdHash: string;
@@ -44,17 +45,20 @@ export default class Lambder {
     private _actionList;
     private _hookList;
     private globalErrorHandler;
-    private fallbackHandler;
+    private routeFallbackHandler;
+    private apiFallbackHandler;
     constructor({ publicPath, apiPath, apiVersion, isCorsEnabled, }: {
         publicPath: string;
         apiPath?: string;
         apiVersion?: string;
         isCorsEnabled?: boolean;
     });
-    setFallbackHandler(fallbackHandler: (renderContext: RenderContext, resolver: Resolver) => ResolverResponse): void;
+    setRouteFallbackHandler(routeFallbackHandler: (renderContext: RenderContext, resolver: Resolver) => ResolverResponse): void;
+    setApiFallbackHandler(apiFallbackHandler: (renderContext: RenderContext, resolver: Resolver) => ResolverResponse): void;
     setGlobalErrorHandler(globalErrorHandler: (err: Error) => ResolverResponse): void;
-    addModule(moduleFn: Function): Promise<void>;
     private validateSession;
+    private handleNoMatchedAction;
+    addModule(moduleFn: Function): Promise<void>;
     addRoute(condition: string | ConditionFunction | RegExp, actionFn: ActionFunction): void;
     addSessionRoute(condition: string | ConditionFunction | RegExp, actionFn: ActionFunction): void;
     addApi(condition: string | ConditionFunction | RegExp, actionFn: ActionFunction): void;
@@ -66,4 +70,3 @@ export default class Lambder {
     addHook(hookEvent: 'completed', hookFn: HookCompletedFunction, priority?: number): Promise<void>;
     render(event: APIGatewayProxyEvent, lambdaContext: Context): Promise<ResolverResponse>;
 }
-export {};

package/dist/index.js

@@ -1,6 +1,7 @@
 import querystring from "querystring";
 import cookieParser from "cookie";
 import Resolver from "./Resolver.js";
+export { default as LambderCaller } from "./LambderCaller.js";
 export const createContext = (event, lambdaContext, resolve, reject) => {
     const host = event.headers.Host || event.headers.host || "";
     const url = event.path;
@@ -33,7 +34,8 @@ export default class Lambder {
     _actionList;
     _hookList;
     globalErrorHandler = null;
-    fallbackHandler = null;
+    routeFallbackHandler = null;
+    apiFallbackHandler = null;
     constructor({ publicPath, apiPath, apiVersion, isCorsEnabled, }) {
         this.publicPath = publicPath || "/incorrect-path-not-found";
         this.apiPath = apiPath ?? "/api";
@@ -47,15 +49,15 @@ export default class Lambder {
             "completed": []
         };
     }
-    setFallbackHandler(fallbackHandler) {
-        this.fallbackHandler = fallbackHandler;
+    setRouteFallbackHandler(routeFallbackHandler) {
+        this.routeFallbackHandler = routeFallbackHandler;
+    }
+    setApiFallbackHandler(apiFallbackHandler) {
+        this.apiFallbackHandler = apiFallbackHandler;
     }
     setGlobalErrorHandler(globalErrorHandler) {
         this.globalErrorHandler = globalErrorHandler;
     }
-    async addModule(moduleFn) {
-        await moduleFn(this);
-    }
     async validateSession(session) {
         if (!session)
             return false;
@@ -68,6 +70,29 @@ export default class Lambder {
         // Check DDB;
         return false;
     }
+    ;
+    async handleNoMatchedAction(renderContext, resolver) {
+        for (const hook of this._hookList["fallback"]) {
+            await hook.hookFn(renderContext, resolver);
+        }
+        if (renderContext.url === this.apiPath) {
+            if (this.apiFallbackHandler) {
+                resolver.resolve(await this.apiFallbackHandler(renderContext, resolver));
+            }
+            else {
+                resolver.resolve({ statusCode: 204, body: "API handler not set.", });
+            }
+        }
+        else if (this.routeFallbackHandler) {
+            resolver.resolve(await this.routeFallbackHandler(renderContext, resolver));
+        }
+        else {
+            resolver.resolve({ statusCode: 204, body: "Handler not set.", });
+        }
+    }
+    async addModule(moduleFn) {
+        await moduleFn(this);
+    }
     addRoute(condition, actionFn) {
         this._actionList.push({
             conditionFn: async (renderContext) => (renderContext.method === "GET" &&
@@ -77,6 +102,7 @@ export default class Lambder {
             actionFn: async (renderContext, resolver) => await actionFn(renderContext, resolver)
         });
     }
+    ;
     addSessionRoute(condition, actionFn) {
         this._actionList.push({
             conditionFn: async (renderContext) => (renderContext.method === "GET" &&
@@ -86,6 +112,7 @@ export default class Lambder {
             actionFn: async (renderContext, resolver) => await actionFn(renderContext, resolver)
         });
     }
+    ;
     addApi(condition, actionFn) {
         this._actionList.push({
             conditionFn: async (renderContext) => (renderContext.method === "POST" && renderContext.url === this.apiPath &&
@@ -95,6 +122,7 @@ export default class Lambder {
             actionFn: async (renderContext, resolver) => await actionFn(renderContext, resolver)
         });
     }
+    ;
     addSessionApi(condition, actionFn) {
         this._actionList.push({
             conditionFn: async (renderContext) => (renderContext.method === "POST" && renderContext.url === this.apiPath &&
@@ -109,6 +137,7 @@ export default class Lambder {
             }
         });
     }
+    ;
     async addHook(hookEvent, hookFn, priority = 0) {
         if (hookEvent === "created") {
             await hookFn(this);
@@ -146,16 +175,7 @@ export default class Lambder {
                 resolve(renderResult);
             }
             else {
-                for (const hook of this._hookList["fallback"]) {
-                    await hook.hookFn(renderContext, resolver);
-                }
-                if (this.fallbackHandler) {
-                    const renderResult = await this.fallbackHandler(renderContext, resolver);
-                    resolve(renderResult);
-                }
-                else {
-                    resolve({ statusCode: 204, body: "Fallback handler not set.", });
-                }
+                return this.handleNoMatchedAction(renderContext, resolver);
             }
         }).then(async (renderResult) => {
             for (const hook of this._hookList["completed"]) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lambder",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,12 +14,14 @@
   "license": "ISC",
   "dependencies": {
     "cookie": "^0.6.0",
+    "js-cookie": "^3.0.5",
     "mime-types": "^2.1.35",
     "querystring": "^0.2.1"
   },
   "devDependencies": {
     "@types/aws-lambda": "^8.10.136",
     "@types/cookie": "^0.6.0",
+    "@types/js-cookie": "^3.0.6",
     "@types/mime-types": "^2.1.4",
     "@types/node": "^20.11.27",
     "@typescript-eslint/eslint-plugin": "^7.2.0",

package/src/LambderCaller.ts

@@ -0,0 +1,121 @@
+import Cookies from 'js-cookie';
+
+type VoidFunction = ()=>void|Promise<void>;
+type StartEndEventHandler = (activeFetchList:{ apiName: string, done: boolean}[])=>void|Promise<void>;
+type ErrorHandler = (err: Error) => void|Promise<void>;
+type MessageHandler = (message:any) => void|Promise<void>;
+
+export default class LambderCaller {
+    isCorsEnabled: boolean;
+    apiPath: string;
+    apiVersion?: string; 
+
+    fetchTrackerList: { apiName: string, done: boolean}[] = [];
+    versionExpiredHandler?: VoidFunction;
+    sessionExpiredHandler?: VoidFunction;
+
+    messageHandler?: MessageHandler;
+    errorMessageHandler?: MessageHandler;
+    notAuthorizedHandler?: VoidFunction;
+    errorHandler?: ErrorHandler;
+    
+    fetchStartedHandler?: StartEndEventHandler;
+    fetchEndedHandler?: StartEndEventHandler;
+
+    constructor(
+        { 
+            isCorsEnabled, apiPath, apiVersion, 
+            versionExpiredHandler, sessionExpiredHandler, 
+            messageHandler, errorMessageHandler,
+            notAuthorizedHandler, errorHandler,
+            fetchStartedHandler, fetchEndedHandler,
+        }: 
+        { 
+            isCorsEnabled: boolean, 
+            apiPath: string,
+            apiVersion?: string,
+            versionExpiredHandler?: VoidFunction, 
+            sessionExpiredHandler?: VoidFunction, 
+            messageHandler?: MessageHandler,
+            errorMessageHandler?: MessageHandler,
+            notAuthorizedHandler?: VoidFunction, 
+            errorHandler?: ErrorHandler, 
+            fetchStartedHandler?: StartEndEventHandler, 
+            fetchEndedHandler?: StartEndEventHandler,
+        }
+    ){
+        this.isCorsEnabled = isCorsEnabled;
+        this.apiPath = apiPath;
+        this.apiVersion = apiVersion;
+
+        this.versionExpiredHandler = versionExpiredHandler;
+        this.sessionExpiredHandler = sessionExpiredHandler;
+
+        this.messageHandler = messageHandler;
+        this.errorMessageHandler = errorMessageHandler;
+        this.notAuthorizedHandler = notAuthorizedHandler;
+        this.errorHandler = errorHandler;
+        
+        this.fetchStartedHandler = fetchStartedHandler; 
+        this.fetchEndedHandler = fetchEndedHandler;
+
+    };
+
+    private async api(apiName: string, payload: any, headers?: { [key:string]: any }){
+        const fetchTracker = { apiName, done: false };
+        try {
+            this.fetchTrackerList.push(fetchTracker);
+            if(this.fetchStartedHandler) await this.fetchStartedHandler(this.fetchTrackerList.filter(v=>!v.done));
+            const version = this.apiVersion;
+            const token = Cookies.get("LMBRTOKEN") || "";
+            const siteHost = window.location.hostname;
+            let data = await fetch(this.apiPath, {
+                method: 'POST', mode: 'same-origin', cache: 'no-cache',
+                credentials: 'same-origin', redirect: 'follow', referrerPolicy: 'origin',
+                headers: { 'Content-Type': 'application/json', ...(headers || {}) },
+                body: JSON.stringify({ api: apiName, version, token, siteHost, payload, }),
+            }).then(res=>{
+                if(res.status >= 500) throw new Error("Request failed: " + res.status + " - " + res.statusText);
+                return res.json();
+            });
+            if(data && data.versionExpired){
+                if(this.versionExpiredHandler){
+                    await this.versionExpiredHandler();
+                }else if(this.errorHandler){
+                    await this.errorHandler(new Error("Version Expired; Please refresh;"));
+                }
+                return null;
+            }
+            if(data && data.sessionExpired){ 
+                Cookies.set('LMBRAUTHID', '', { expires: -1 });
+                Cookies.set('LMBRTOKEN', '', { expires: -1 });
+                if(this.sessionExpiredHandler){
+                    await this.sessionExpiredHandler();
+                }else if(this.errorHandler){
+                    await this.errorHandler(new Error("Version Expired; Please refresh;"));
+                }
+                return null;
+            }
+            if(data && data.notAuthorized){
+                if(this.notAuthorizedHandler){
+                    await this.notAuthorizedHandler();
+                }else if(this.errorHandler){
+                    await this.errorHandler(new Error("Version Expired; Please refresh;"));
+                }
+                return null;
+            }
+            if(data && data.message && this.messageHandler){
+                await this.messageHandler(data.message);
+            }
+            if(data && data.errorMessage && this.errorMessageHandler){
+                await this.errorMessageHandler(data.errorMessage);
+            }
+            return data.payload ?? null;
+        }catch(err){
+            fetchTracker.done = true
+            if(this.errorHandler){
+                this.errorHandler(err instanceof Error ? err : new Error("Error: " + String(err)));
+            }
+        }
+    };
+}

package/src/Resolver.ts

@@ -198,16 +198,32 @@ export default class Resolver {
         return this.fileBase64(bodyBase64, mimeType || "", headers);
     };
 
-	api(
-        { payload, error=null, ...other }: { payload?: any; error?: any; }, 
+    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(error) console.log("ERROR: ", error);
+    ): ResolverResponse {
         if(Object.keys(other).length) console.log("ERROR: Unexpected key in result: " + Object.keys(other).join(", "));
         return this.json({ 
             apiVersion: this.apiVersion,
-            payload, 
-            ...(error ? {error} : {}),
+            payload,
+            ...(versionExpired ? {versionExpired} : {}),
+            ...(sessionExpired ? {sessionExpired} : {}),
+            ...(notAuthorized ? {notAuthorized} : {}),
+            ...(message ? {message} : {}),
+            ...(errorMessage ? {errorMessage} : {}),
         }, headers);
     };
+    
 }

package/src/index.ts

@@ -4,6 +4,8 @@ import cookieParser from "cookie";
 import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
 import Resolver, { ResolverResponse } from "./Resolver.js";
 
+export { default as LambderCaller } from "./LambderCaller.js";
+
 type DDBSession = {
     userId: string,
     userIdHash: string;
@@ -80,7 +82,8 @@ export default class Lambder {
         "completed": { priority: number, hookFn: HookCompletedFunction }[]
     };
     private globalErrorHandler: Function|null = null;
-    private fallbackHandler: Function|null = null;
+    private routeFallbackHandler: Function|null = null;
+    private apiFallbackHandler: Function|null = null;
 
     constructor(
         { publicPath, apiPath, apiVersion, isCorsEnabled, }: 
@@ -100,17 +103,16 @@ export default class Lambder {
         };
     }
 
-    setFallbackHandler(fallbackHandler: (renderContext:RenderContext, resolver: Resolver)=>ResolverResponse){
-        this.fallbackHandler = fallbackHandler;
+    setRouteFallbackHandler(routeFallbackHandler: (renderContext:RenderContext, resolver: Resolver)=>ResolverResponse){
+        this.routeFallbackHandler = routeFallbackHandler;
+    }
+    setApiFallbackHandler(apiFallbackHandler: (renderContext:RenderContext, resolver: Resolver)=>ResolverResponse){
+        this.apiFallbackHandler = apiFallbackHandler;
     }
     setGlobalErrorHandler(globalErrorHandler: (err: Error)=>ResolverResponse){
         this.globalErrorHandler = globalErrorHandler;
     }
 
-    async addModule(moduleFn: Function): Promise<void>{
-        await moduleFn(this);
-    }
-    
     private async validateSession (session: DDBSession): Promise<boolean>{
         if(!session) return false;
         if(!session.userId || !session.userIdHash || !session.sessionHash || !session.csrfToken) return false;
@@ -118,8 +120,28 @@ export default class Lambder {
         if(session.expiresTimeStamp > Date.now()) return false;
         // Check DDB;
         return false;
+    };
+
+    private async handleNoMatchedAction(renderContext: RenderContext, resolver: Resolver){
+        for(const hook of this._hookList["fallback"]){
+            await hook.hookFn(renderContext, resolver);
+        }
+        if(renderContext.url === this.apiPath){
+            if(this.apiFallbackHandler){
+                resolver.resolve(await this.apiFallbackHandler(renderContext, resolver));
+            }else{
+                resolver.resolve({ statusCode: 204, body: "API handler not set.", })
+            }
+        }else if(this.routeFallbackHandler){
+            resolver.resolve(await this.routeFallbackHandler(renderContext, resolver));
+        }else{
+            resolver.resolve({ statusCode: 204, body: "Handler not set.", })
+        }
     }
 
+    async addModule(moduleFn: Function): Promise<void>{
+        await moduleFn(this);
+    }
     addRoute(condition: string|ConditionFunction|RegExp, actionFn: ActionFunction):void{
         this._actionList.push({ 
             conditionFn: async (renderContext:RenderContext) => (
@@ -132,7 +154,7 @@ export default class Lambder {
             ), 
             actionFn: async (renderContext:RenderContext, resolver: Resolver) => await actionFn(renderContext, resolver) 
         });
-    }
+    };
 
     addSessionRoute(condition: string|ConditionFunction|RegExp, actionFn: ActionFunction):void{
         this._actionList.push({ 
@@ -146,7 +168,7 @@ export default class Lambder {
             ), 
             actionFn: async (renderContext:RenderContext, resolver: Resolver) => await actionFn(renderContext, resolver) 
         });
-    }
+    };
     
     addApi(condition: string|ConditionFunction|RegExp, actionFn: ActionFunction):void{
         this._actionList.push({ 
@@ -160,7 +182,7 @@ export default class Lambder {
             ), 
             actionFn: async (renderContext:RenderContext, resolver: Resolver) => await actionFn(renderContext, resolver) 
         });
-    }
+    };
 
     addSessionApi(condition: string|ConditionFunction|RegExp, actionFn: ActionFunction):void{
         this._actionList.push({ 
@@ -178,7 +200,7 @@ export default class Lambder {
                 return await actionFn(renderContext, resolver);
             }
         });
-    }
+    };
 
 
     async addHook(hookEvent: 'created', hookFn: HookCreatedFunction, priority?: number): Promise<void>;
@@ -199,6 +221,7 @@ export default class Lambder {
         }
     }
 
+
     async render(
         event: APIGatewayProxyEvent,
         lambdaContext: Context
@@ -217,8 +240,8 @@ export default class Lambder {
             if(renderContext.method === "OPTIONS") return resolver.cors();
 
             const firstMatchedAction = await (async () => {
-                for (const action of this._actionList) {
-                    if (await action.conditionFn(renderContext)) return action;
+                for(const action of this._actionList){
+                    if(await action.conditionFn(renderContext)) return action;
                 }
             })();
 
@@ -232,15 +255,7 @@ export default class Lambder {
                 }
                 resolve(renderResult);
             }else{
-                for(const hook of this._hookList["fallback"]){
-                    await hook.hookFn(renderContext, resolver);
-                }
-                if(this.fallbackHandler){
-                    const renderResult = await this.fallbackHandler(renderContext, resolver);
-                    resolve(renderResult);
-                }else{
-                    resolve({ statusCode: 204, body: "Fallback handler not set.", })
-                }
+                return this.handleNoMatchedAction(renderContext, resolver);
             }
         }).then(async (renderResult: ResolverResponse):Promise<ResolverResponse> => {
             for(const hook of this._hookList["completed"]){