lambder 1.0.14 → 1.0.16

package/.vscode/settings.json

@@ -1,6 +1,6 @@
 {
     "editor.codeActionsOnSave": {
-      "source.fixAll.eslint": true
+      "source.fixAll.eslint": "explicit"
     },
     "eslint.validate": [
       "javascript",
@@ -16,6 +16,9 @@
 			"**/dist/": true,
 			"**/package-lock.json": true,
 			"**/.git/": true,
-		},
+    },
+    "cSpell.words": [
+      "lambder"
+    ],
   }
   

package/dist/Resolver.d.ts

@@ -52,7 +52,7 @@ export default class Resolver {
     private apiVersion;
     resolve: Function;
     reject: Function;
-    die: Partial<IResolverMethods>;
+    die: IResolverMethods;
     constructor({ isCorsEnabled, publicPath, apiVersion, resolve, reject }: {
         isCorsEnabled: boolean;
         publicPath: string;

package/dist/Resolver.js

@@ -1,5 +1,5 @@
 import fs from "fs";
-import * as pathLibrary from "path";
+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({
@@ -21,22 +21,23 @@ export default class Resolver {
         this.apiVersion = apiVersion ?? null;
         this.resolve = resolve;
         this.reject = reject;
-        this.die = new Proxy(this, {
-            get: (target, prop) => {
-                const origProp = target[prop];
-                if (typeof origProp === 'function') {
-                    return (...args) => {
-                        this.resolve(origProp.apply(this, args));
-                    };
-                }
-                return origProp;
-            }
-        });
+        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,
+        };
     }
     ;
     readFileSync(filePath) {
-        const publicPath = pathLibrary.resolve(this.publicPath);
-        const absolutePath = pathLibrary.join(publicPath, 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";
@@ -45,8 +46,8 @@ export default class Resolver {
     }
     ;
     checkFileExist(filePath) {
-        const publicPath = pathLibrary.resolve(this.publicPath);
-        const absolutePath = pathLibrary.join(this.publicPath, 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;

package/dist/index.d.ts

@@ -1,5 +1,16 @@
 import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
 import Resolver, { ResolverResponse } from "./Resolver.js";
+type DDBSession = {
+    userId: string;
+    userIdHash: string;
+    sessionHash: string;
+    csrfToken: string;
+    createdTimeStamp: number;
+    expiresTimeStamp: number;
+    data: {
+        [key: string]: any;
+    };
+} | null;
 type RenderContext = {
     host: string;
     url: string;
@@ -14,6 +25,7 @@ type RenderContext = {
         [key: string]: any;
     };
     headers: APIGatewayProxyEventHeaders;
+    session: DDBSession;
     lambdaContext: Context;
 };
 type ConditionFunction = (renderContext: RenderContext) => boolean | Promise<boolean>;
@@ -39,18 +51,18 @@ export default class Lambder {
         apiVersion?: string;
         isCorsEnabled?: boolean;
     });
-    private apiHandler;
-    private pathHandler;
     setFallbackHandler(fallbackHandler: (renderContext: RenderContext, resolver: Resolver) => ResolverResponse): void;
     setGlobalErrorHandler(globalErrorHandler: (err: Error) => ResolverResponse): void;
-    addApi(condition: string | ConditionFunction | RegExp, actionFn: ActionFunction): void;
+    addModule(moduleFn: Function): Promise<void>;
+    private validateSession;
     addPath(condition: string | ConditionFunction | RegExp, actionFn: ActionFunction): void;
+    addPublicApi(condition: string | ConditionFunction | RegExp, actionFn: ActionFunction): void;
+    addSessionApi(condition: string | ConditionFunction | RegExp, actionFn: ActionFunction): void;
     addHook(hookEvent: 'created', hookFn: HookCreatedFunction, priority?: number): Promise<void>;
     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>;
-    addModule(moduleFn: Function): Promise<void>;
     render(event: APIGatewayProxyEvent, lambdaContext: Context): Promise<ResolverResponse>;
 }
 export {};

package/dist/index.js

@@ -9,6 +9,7 @@ export const createContext = (event, lambdaContext, resolve, reject) => {
     const cookie = cookieParser.parse(event.headers.Cookie || event.headers.cookie || "");
     const headers = event.headers;
     let post = {};
+    const session = null;
     try {
         const decodedBody = event.isBase64Encoded ? (event.body ? Buffer.from(event.body, "base64").toString() : "{}") : (event.body || "{}");
         try {
@@ -22,7 +23,7 @@ export const createContext = (event, lambdaContext, resolve, reject) => {
     if (/^(((\d+\.)+\d+)|(([a-f\d]+:)+[a-f\d]+))$/.test(host)) {
         reject(new Error("[404] Host cannot be an ip address: " + host));
     }
-    return { host, url, method, get, post, cookie, headers, lambdaContext };
+    return { host, url, method, get, post, cookie, headers, session, lambdaContext };
 };
 export default class Lambder {
     apiPath;
@@ -46,56 +47,57 @@ export default class Lambder {
             "completed": []
         };
     }
-    async apiHandler(renderContext, resolver, actionFn) {
-        // Do context stuff;
-        return await actionFn(renderContext, resolver);
-    }
-    async pathHandler(renderContext, resolver, actionFn) {
-        // Do context stuff;
-        return await actionFn(renderContext, resolver);
-    }
     setFallbackHandler(fallbackHandler) {
         this.fallbackHandler = fallbackHandler;
     }
     setGlobalErrorHandler(globalErrorHandler) {
         this.globalErrorHandler = globalErrorHandler;
     }
-    addApi(condition, actionFn) {
-        let conditionFn = (renderContext) => false;
-        if (typeof condition === "string") {
-            conditionFn = (renderContext) => renderContext.method === "POST" && renderContext.url === this.apiPath && (renderContext.post?.api) === condition;
-        }
-        else if (typeof condition === "function") {
-            conditionFn = async (renderContext) => renderContext.method === "POST" && renderContext.url === this.apiPath && (await condition(renderContext));
-        }
-        else if (condition?.constructor == RegExp) {
-            conditionFn = (renderContext) => renderContext.method === "POST" && renderContext.url === this.apiPath && condition.test(renderContext.post?.api);
-        }
-        else {
-            throw "Unsupported API Condition";
-        }
+    async addModule(moduleFn) {
+        await moduleFn(this);
+    }
+    async validateSession(session) {
+        if (!session)
+            return false;
+        if (!session.userId || !session.userIdHash || !session.sessionHash || !session.csrfToken)
+            return false;
+        if (!session.createdTimeStamp || !session.expiresTimeStamp)
+            return false;
+        if (session.expiresTimeStamp > Date.now())
+            return false;
+        // Check DDB;
+        return false;
+    }
+    addPath(condition, actionFn) {
         this._actionList.push({
-            conditionFn,
-            actionFn: async (renderContext, resolver) => await this.apiHandler(renderContext, resolver, actionFn)
+            conditionFn: async (renderContext) => (renderContext.method === "GET" &&
+                ((typeof condition === "string" && renderContext.url === condition) ||
+                    (typeof condition === "function" && (await condition(renderContext))) ||
+                    (condition?.constructor == RegExp && condition.test(renderContext.url)))),
+            actionFn: async (renderContext, resolver) => await actionFn(renderContext, resolver)
         });
     }
-    addPath(condition, actionFn) {
-        let conditionFn = (renderContext) => false;
-        if (typeof condition === "string") {
-            conditionFn = (renderContext) => renderContext.method === "GET" && renderContext.url === condition;
-        }
-        else if (typeof condition === "function") {
-            conditionFn = async (renderContext) => renderContext.method === "GET" && (await condition(renderContext));
-        }
-        else if (condition?.constructor == RegExp) {
-            conditionFn = (renderContext) => renderContext.method === "GET" && condition.test(renderContext.url);
-        }
-        else {
-            throw "Unsupported Path Condition";
-        }
+    addPublicApi(condition, actionFn) {
         this._actionList.push({
-            conditionFn,
-            actionFn: async (renderContext, resolver) => await this.pathHandler(renderContext, resolver, actionFn)
+            conditionFn: async (renderContext) => (renderContext.method === "POST" && renderContext.url === this.apiPath &&
+                ((typeof condition === "string" && renderContext.post?.api === condition) ||
+                    (typeof condition === "function" && (await condition(renderContext))) ||
+                    (condition?.constructor == RegExp && condition.test(renderContext.post?.api)))),
+            actionFn: async (renderContext, resolver) => await actionFn(renderContext, resolver)
+        });
+    }
+    addSessionApi(condition, actionFn) {
+        this._actionList.push({
+            conditionFn: async (renderContext) => (renderContext.method === "POST" && renderContext.url === this.apiPath &&
+                ((typeof condition === "string" && renderContext.post?.api === condition) ||
+                    (typeof condition === "function" && (await condition(renderContext))) ||
+                    (condition?.constructor == RegExp && condition.test(renderContext.post?.api)))),
+            actionFn: async (renderContext, resolver) => {
+                const isSessionValid = this.validateSession(renderContext.session);
+                if (!isSessionValid)
+                    throw new Error("Session not found");
+                return await actionFn(renderContext, resolver);
+            }
         });
     }
     async addHook(hookEvent, hookFn, priority = 0) {
@@ -107,9 +109,6 @@ export default class Lambder {
             this._hookList[hookEvent].sort((a, b) => a.priority - b.priority);
         }
     }
-    async addModule(moduleFn) {
-        await moduleFn(this);
-    }
     async render(event, lambdaContext) {
         return await new Promise(async (resolve, reject) => {
             const resolver = new Resolver({
@@ -121,14 +120,12 @@ export default class Lambder {
             let renderContext = createContext(event, lambdaContext, resolve, reject);
             if (renderContext.method === "OPTIONS")
                 return resolver.cors();
-            let firstMatchedAction = null;
-            for (const action of this._actionList) {
-                const isConditionMet = await action.conditionFn(renderContext);
-                if (isConditionMet) {
-                    firstMatchedAction = action;
-                    break;
+            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);
@@ -140,8 +137,9 @@ export default class Lambder {
                 resolve(renderResult);
             }
             else {
-                for (const hook of this._hookList["fallback"])
+                for (const hook of this._hookList["fallback"]) {
                     await hook.hookFn(renderContext, resolver);
+                }
                 if (this.fallbackHandler) {
                     const renderResult = await this.fallbackHandler(renderContext, resolver);
                     resolve(renderResult);

package/package.json

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

package/src/Resolver.ts

@@ -1,5 +1,5 @@
 import fs from "fs";
-import * as pathLibrary from "path";
+import * as path from "path";
 import mimeTypeResolver from "mime-types";
 
 const convertToMultiHeader = (
@@ -49,7 +49,7 @@ export default class Resolver {
     private apiVersion: string|null;
     resolve: Function;
     reject: Function;
-    die: Partial<IResolverMethods>;
+    die: IResolverMethods;
 
     constructor(
         { isCorsEnabled, publicPath, apiVersion, resolve, reject }: 
@@ -66,30 +66,31 @@ export default class Resolver {
         this.apiVersion = apiVersion ?? null;
         this.resolve = resolve;
         this.reject = reject;
-        this.die = new Proxy(this, {
-            get: (target, prop: keyof IResolverMethods) => {
-                const origProp = target[prop];
-                if (typeof origProp === 'function') {
-                    return (...args: any[]) => {
-                        this.resolve((origProp as Function).apply(this, args));
-                    };
-                }
-                return origProp;
-            }
-        });
+        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 = pathLibrary.resolve(this.publicPath);
-        const absolutePath = pathLibrary.join(publicPath, 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);
     };
 
     private checkFileExist(filePath: string){
-        const publicPath = pathLibrary.resolve(this.publicPath);
-        const absolutePath = pathLibrary.join(this.publicPath, 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();

package/src/index.ts

@@ -4,6 +4,16 @@ import cookieParser from "cookie";
 import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
 import Resolver, { ResolverResponse } from "./Resolver.js";
 
+type DDBSession = {
+    userId: string,
+    userIdHash: string;
+    sessionHash: string;
+    csrfToken: string;
+    createdTimeStamp: number;
+    expiresTimeStamp: number;
+    data: { [key:string]: any };
+} | null;
+
 type RenderContext = {
     host: string;
     url: string;
@@ -12,6 +22,7 @@ type RenderContext = {
     post: { [key: string]: any };
     cookie: { [key: string]: any };
     headers: APIGatewayProxyEventHeaders;
+    session: DDBSession;
     lambdaContext: Context;
 };
 
@@ -44,13 +55,14 @@ export const createContext = (
     const cookie = cookieParser.parse(event.headers.Cookie || event.headers.cookie || "");
     const headers = event.headers;
     let post:{ [key:string]: any } = {};
+    const session = null;
     try {
         const decodedBody = event.isBase64Encoded ? ( event.body ? Buffer.from(event.body,"base64").toString() : "{}" ) : ( event.body || "{}" );
         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)); }
-    return { host, url, method, get, post, cookie, headers, lambdaContext };
+    return { host, url, method, get, post, cookie, headers, session, lambdaContext };
 }
 
 
@@ -88,14 +100,6 @@ export default class Lambder {
         };
     }
 
-    private async apiHandler (renderContext:RenderContext, resolver: Resolver, actionFn: ActionFunction){
-        // Do context stuff;
-        return await actionFn(renderContext, resolver);
-    }
-    private async pathHandler (renderContext:RenderContext, resolver: Resolver, actionFn: ActionFunction){
-        // Do context stuff;
-        return await actionFn(renderContext, resolver);
-    }
     setFallbackHandler(fallbackHandler: (renderContext:RenderContext, resolver: Resolver)=>ResolverResponse){
         this.fallbackHandler = fallbackHandler;
     }
@@ -103,42 +107,64 @@ export default class Lambder {
         this.globalErrorHandler = globalErrorHandler;
     }
 
-    addApi(condition: string|ConditionFunction|RegExp, actionFn: ActionFunction):void{
-        let conditionFn: ConditionFunction = (renderContext:RenderContext) => false;
-        if(typeof condition === "string"){
-            conditionFn = (renderContext:RenderContext) => 
-                renderContext.method === "POST" && renderContext.url === this.apiPath && (renderContext.post?.api) === condition;
-        }else if(typeof condition === "function"){
-            conditionFn = async (renderContext:RenderContext) => 
-                renderContext.method === "POST" && renderContext.url === this.apiPath && (await condition(renderContext));
-        }else if(condition?.constructor == RegExp){
-            conditionFn = (renderContext:RenderContext) => 
-                renderContext.method === "POST" && renderContext.url === this.apiPath && condition.test(renderContext.post?.api);
-        }else { throw "Unsupported API Condition"; }
-        this._actionList.push({ 
-            conditionFn, 
-            actionFn: async (renderContext:RenderContext, resolver: Resolver) => await this.apiHandler(renderContext, resolver, actionFn) 
-        });
+    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;
+        if(!session.createdTimeStamp || !session.expiresTimeStamp) return false;
+        if(session.expiresTimeStamp > Date.now()) return false;
+        // Check DDB;
+        return false;
     }
 
     addPath(condition: string|ConditionFunction|RegExp, actionFn: ActionFunction):void{
-        let conditionFn: ConditionFunction = (renderContext:RenderContext) => false;
-        if(typeof condition === "string"){
-            conditionFn = (renderContext:RenderContext) => 
-                renderContext.method === "GET" && renderContext.url === condition;
-        }else if(typeof condition === "function"){
-            conditionFn = async (renderContext:RenderContext) => 
-                renderContext.method === "GET" && (await condition(renderContext));
-        }else if(condition?.constructor == RegExp){
-            conditionFn = (renderContext:RenderContext) => 
-                renderContext.method === "GET" && condition.test(renderContext.url);
-        }else { throw "Unsupported Path Condition"; }
         this._actionList.push({ 
-            conditionFn, 
-            actionFn: async (renderContext:RenderContext, resolver: Resolver) => await this.pathHandler(renderContext, resolver, actionFn) 
+            conditionFn: async (renderContext:RenderContext) => (
+                renderContext.method === "GET" && 
+                (
+                    (typeof condition === "string" && renderContext.url === condition) ||
+                    (typeof condition === "function" && (await condition(renderContext))) ||
+                    (condition?.constructor == RegExp && condition.test(renderContext.url))
+                )
+            ), 
+            actionFn: async (renderContext:RenderContext, resolver: Resolver) => await actionFn(renderContext, resolver) 
+        });
+    }
+    
+    addPublicApi(condition: string|ConditionFunction|RegExp, actionFn: ActionFunction):void{
+        this._actionList.push({ 
+            conditionFn: async (renderContext:RenderContext) =>  (
+                renderContext.method === "POST" && renderContext.url === this.apiPath &&
+                (
+                    (typeof condition === "string" && renderContext.post?.api === condition) ||
+                    (typeof condition === "function" && (await condition(renderContext))) ||
+                    (condition?.constructor == RegExp && condition.test(renderContext.post?.api))
+                )
+            ), 
+            actionFn: async (renderContext:RenderContext, resolver: Resolver) => await actionFn(renderContext, resolver) 
         });
     }
 
+    addSessionApi(condition: string|ConditionFunction|RegExp, actionFn: ActionFunction):void{
+        this._actionList.push({ 
+            conditionFn: async (renderContext:RenderContext) =>  (
+                renderContext.method === "POST" && renderContext.url === this.apiPath &&
+                (
+                    (typeof condition === "string" && renderContext.post?.api === condition) ||
+                    (typeof condition === "function" && (await condition(renderContext))) ||
+                    (condition?.constructor == RegExp && condition.test(renderContext.post?.api))
+                )
+            ), 
+            actionFn: async (renderContext:RenderContext, resolver: Resolver) => {
+                const isSessionValid = this.validateSession(renderContext.session);
+                if(!isSessionValid) throw new Error("Session not found");
+                return await actionFn(renderContext, resolver);
+            }
+        });
+    }
 
 
     async addHook(hookEvent: 'created', hookFn: HookCreatedFunction, priority?: number): Promise<void>;
@@ -159,10 +185,6 @@ export default class Lambder {
         }
     }
 
-    async addModule(moduleFn: Function): Promise<void>{
-        await moduleFn(this);
-    }
-
     async render(
         event: APIGatewayProxyEvent,
         lambdaContext: Context
@@ -171,7 +193,6 @@ export default class Lambder {
             resolve:(renderResult: ResolverResponse)=>void,
             reject:(err: Error)=>void
         )=> {
-
             const resolver = new Resolver({ 
                 isCorsEnabled: this.isCorsEnabled, 
                 publicPath: this.publicPath,
@@ -179,17 +200,13 @@ export default class Lambder {
                 resolve, reject,
             });
             let renderContext:RenderContext = createContext(event, lambdaContext, resolve, reject)
-            
             if(renderContext.method === "OPTIONS") return resolver.cors();
 
-            let firstMatchedAction: null|ActionType = null;
-            for(const action of this._actionList){
-                const isConditionMet = await action.conditionFn(renderContext);
-                if(isConditionMet){
-                    firstMatchedAction = action;
-                    break;
+            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"]){
@@ -201,7 +218,9 @@ export default class Lambder {
                 }
                 resolve(renderResult);
             }else{
-                for(const hook of this._hookList["fallback"]) await hook.hookFn(renderContext, resolver);
+                for(const hook of this._hookList["fallback"]){
+                    await hook.hookFn(renderContext, resolver);
+                }
                 if(this.fallbackHandler){
                     const renderResult = await this.fallbackHandler(renderContext, resolver);
                     resolve(renderResult);