lambder 1.0.98 → 1.0.102

package/Readme.md

@@ -32,6 +32,7 @@ const lambder = new Lambder({
     apiPath: "/secure",
     isCorsEnabled: true,
     publicPath: path.resolve(`./public`),
+    // ejsPath: path.resolve(`./ejs-templates`),
 });
 
 // Define a simple api
@@ -64,6 +65,27 @@ lambder.addRoute((ctx)=>ctx.path === '/hello-fn-route', (ctx, res) => {
     return res.html("Hello from a function route");
 });
 
+// Define a simple route that serves an EJS template file
+lambder.addRoute("/product/:productId", (ctx, res) => {
+    const product = await getProduct(ctx.pathParams.productId);
+    // Serve the file from ejsPath defined above.
+    return await res.ejsFile("productPage.html.ejs", { product });
+});
+
+// Serve sitemap using an ejs template.
+lambder.addRoute("/sitemap", (ctx, res) => {
+    const templateString = `
+        <?xml version="1.0" encoding="UTF-8"?>
+        <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+        <%~
+            page.urlList.map(url => `<url><loc>${url}</loc></url>`).join("")
+        %>
+        </urlset>
+    `.trim();
+    const urlList = [];
+    return await  res.ejsTemplate(templateString, { urlList }, { "Content-Type": ["application/xml; charset=utf-8"]});
+});
+
 
 // Match all other paths and serve static files from publicPath, if not found, serve index.html
 lambder.addRoute("/(.*)", (ctx, res)=>{
@@ -139,6 +161,29 @@ lambder.addModule(async (lambder: Lambder): Promise<void> => {
 });
 ```
 
+### EJS Templates: 
+
+EJS templates have the variables `page` and `partial` available:
+
+A template is the main file that you call with `await res.ejsFile('template-file')`. Templates will have `page` variable available.
+A partial is included from a template, like `<%- await include('partial/header.html.ejs', partialData) -%>` will have `page` and `partial` variables available.
+
+An example template:
+```html
+<div>
+    <%- await include('partial/header.html.ejs', partialData) -%>
+    <div>Page Variable: <pre><%~ JSON.stringify(page, null, 2) %></pre></div>
+    <%- await include('partial/footer.html.ejs', partialData) -%>
+</div>
+```
+An example partial:
+```html
+<div>
+    <div>Page Variable: <pre><%~ JSON.stringify(page, null, 2) %></pre></div>
+    <div>Partial Variable: <pre><%~ JSON.stringify(partial, null, 2) %></pre></div>
+</div>
+```
+
 ### Project Structure: 
 
 Add your imports to index.ts:
@@ -217,6 +262,13 @@ lambder.addApi("getCompanyName", async (ctx, res) => {
     //   attempts to serve the fallback file. 
     //   Returns a JSON error if neither file is found.
 
+    return await res.ejsFile(filePath, pageData, headers); 
+    // Renders and serves an ejs file from the server's ejs directory, with optional headers.
+    //   Returns a JSON error if file is not found.
+
+    return await res.ejsTemplate(template, pageData, headers); 
+    // Renders and serves an ejs template string, with optional headers.
+
     return res.api(payload, { notAuthorized, message, errorMessage }, headers); 
     // This function works together with the LambderCaller from the frontend.
     // Sends a standardized API response including the payload and status 
@@ -237,6 +289,8 @@ lambder.addApi("getCompanyName", async (ctx, res) => {
     res.die.cors(); 
     res.die.fileBase64(fileBase64, mimeType, headers); 
     res.die.file(filePath, headers, fallbackFilePath); 
+    await res.die.ejsFile(filePath, pageData, headers); 
+    await res.die.ejsTemplate(template, pageData, headers); 
     res.die.api(payload, { versionExpired, sessionExpired, notAuthorized, message, errorMessage }, headers); 
 });
 ```

package/dist/Lambder.js

@@ -11,8 +11,9 @@ export const createContext = (event, lambdaContext, apiPath) => {
     const method = event.httpMethod;
     const cookie = cookieParser.parse(event.headers.Cookie || event.headers.cookie || "");
     const headers = event.headers;
-    let post = {};
     const session = null;
+    // Decode body for the post
+    let post = {};
     try {
         const decodedBody = event.isBase64Encoded ? (event.body ? Buffer.from(event.body, "base64").toString() : "{}") : (event.body || "{}");
         try {
@@ -23,12 +24,10 @@ export const createContext = (event, lambdaContext, apiPath) => {
         }
     }
     catch (e) { }
+    // Parse api variables
     const isAPICall = method === "POST" && apiPath && path === apiPath && post.apiName;
     const apiName = isAPICall ? post.apiName : null;
     const apiPayload = isAPICall ? post.payload : null;
-    if (/^(((\d+\.)+\d+)|(([a-f\d]+:)+[a-f\d]+))$/.test(host)) {
-        throw new Error("[404] Host cannot be an ip address: " + host);
-    }
     return { host, path, pathParams, method, get, post, cookie, apiName, apiPayload, headers, session, lambdaContext };
 };
 export default class Lambder {

package/dist/LambderResolver.d.ts

@@ -10,6 +10,8 @@ interface DieResolverMethods {
     cors: MethodType<LambderResponseBuilder, 'cors'>;
     fileBase64: MethodType<LambderResponseBuilder, 'fileBase64'>;
     file: MethodType<LambderResponseBuilder, 'file'>;
+    ejsFile: MethodType<LambderResponseBuilder, 'ejsFile'>;
+    ejsTemplate: MethodType<LambderResponseBuilder, 'ejsTemplate'>;
     api: MethodType<LambderResponseBuilder, 'api'>;
 }
 export default class LambderResolver extends LambderResponseBuilder {
@@ -24,5 +26,6 @@ export default class LambderResolver extends LambderResponseBuilder {
         reject: (err: Error) => void;
     });
     private autoResolve;
+    private autoResolvePromise;
 }
 export {};

package/dist/LambderResolver.js

@@ -17,6 +17,8 @@ export default class LambderResolver extends LambderResponseBuilder {
             cors: this.autoResolve(this.cors),
             fileBase64: this.autoResolve(this.fileBase64),
             file: this.autoResolve(this.file),
+            ejsFile: this.autoResolvePromise(this.ejsFile),
+            ejsTemplate: this.autoResolvePromise(this.ejsTemplate),
             api: this.autoResolve(this.api),
         };
     }
@@ -27,5 +29,20 @@ export default class LambderResolver extends LambderResponseBuilder {
             return result;
         };
     }
+    autoResolvePromise(method) {
+        return (...args) => {
+            return new Promise((resolve, reject) => {
+                method.apply(this, args)
+                    .then(result => {
+                    this.resolve(result);
+                    resolve(result);
+                })
+                    .catch(err => {
+                    this.reject(err);
+                    reject(err);
+                });
+            });
+        };
+    }
 }
 ;

package/dist/LambderResponseBuilder.d.ts

@@ -17,14 +17,18 @@ export type LambderApiResponse<T> = LambderApiResponseConfig & {
 export default class LambderResponseBuilder {
     private isCorsEnabled;
     private publicPath;
+    private ejsPath;
     private apiVersion;
-    constructor({ isCorsEnabled, publicPath, apiVersion }: {
+    constructor({ isCorsEnabled, publicPath, apiVersion, ejsPath }: {
         isCorsEnabled: boolean;
         publicPath: string;
+        ejsPath?: string | null;
         apiVersion?: string | null;
     });
-    private readFileSync;
-    private checkFileExist;
+    private readPublicFileSync;
+    private checkPublicFileExist;
+    private readEjsFileSync;
+    private checkEjsFileExist;
     raw(param: LambderResolverResponse): LambderResolverResponse;
     json(data: Record<string, any>, headers?: Record<string, string | string[]>): LambderResolverResponse;
     xml(data: string): LambderResolverResponse;
@@ -34,5 +38,7 @@ export default class LambderResponseBuilder {
     cors(): LambderResolverResponse;
     fileBase64(fileBase64: string, mimeType: string, headers?: Record<string, string | string[]>): LambderResolverResponse;
     file(filePath: string, headers?: Record<string, string | string[]>, fallbackFilePath?: string): LambderResolverResponse;
+    ejsTemplate(template: string, pageData: Record<string, any>, headers?: Record<string, string | string[]>): Promise<LambderResolverResponse>;
+    ejsFile(filePath: string, pageData: Record<string, any>, headers?: Record<string, string | string[]>): Promise<LambderResolverResponse>;
     api<T = any>(payload: T | null, { versionExpired, sessionExpired, notAuthorized, message, errorMessage, }?: LambderApiResponseConfig, headers?: Record<string, string | string[]>): LambderResolverResponse;
 }

package/dist/LambderResponseBuilder.js

@@ -1,5 +1,6 @@
 import fs from "fs";
 import * as path from "path";
+import ejs from "ejs";
 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({
@@ -11,33 +12,61 @@ const CORS_HEADERS = convertToMultiHeader({
 export default class LambderResponseBuilder {
     isCorsEnabled;
     publicPath;
+    ejsPath;
     apiVersion;
-    constructor({ isCorsEnabled, publicPath, apiVersion }) {
+    constructor({ isCorsEnabled, publicPath, apiVersion, ejsPath }) {
         this.isCorsEnabled = isCorsEnabled;
         this.publicPath = publicPath;
+        this.ejsPath = ejsPath ?? null;
         this.apiVersion = apiVersion ?? null;
     }
     ;
-    readFileSync(filePath) {
+    readPublicFileSync(filePath) {
         const publicPath = path.resolve(this.publicPath);
         const absolutePath = path.join(publicPath, filePath);
-        console.log("readFileSync", { filePath, publicPath, absolutePath });
+        console.log("readPublicFileSync", { filePath, publicPath, absolutePath });
         if (!absolutePath.includes(publicPath)) {
-            return "forbiddenpath";
+            return "forbidden-public-path";
         }
         return fs.readFileSync(absolutePath);
     }
     ;
-    checkFileExist(filePath) {
+    checkPublicFileExist(filePath) {
         const publicPath = path.resolve(this.publicPath);
         const absolutePath = path.join(this.publicPath, filePath);
-        console.log("checkFileExist", { filePath, publicPath, absolutePath });
+        console.log("checkPublicFileExist", { filePath, publicPath, absolutePath });
         if (!absolutePath.includes(publicPath)) {
             return false;
         }
         return fs.existsSync(absolutePath) && fs.statSync(absolutePath).isFile();
     }
     ;
+    readEjsFileSync(filePath) {
+        if (!this.ejsPath) {
+            return "EJS PATH NOT SET!";
+        }
+        const ejsPath = path.resolve(this.ejsPath);
+        const absolutePath = path.join(ejsPath, filePath);
+        console.log("readEjsFileSync", { filePath, ejsPath, absolutePath });
+        if (!absolutePath.includes(ejsPath)) {
+            return "forbidden-ejs-path";
+        }
+        return String(fs.readFileSync(absolutePath));
+    }
+    ;
+    checkEjsFileExist(filePath) {
+        if (!this.ejsPath) {
+            return "EJS PATH NOT SET!";
+        }
+        const ejsPath = path.resolve(this.ejsPath);
+        const absolutePath = path.join(this.ejsPath, filePath);
+        console.log("checkEjsFileExist", { filePath, ejsPath, absolutePath });
+        if (!absolutePath.includes(ejsPath)) {
+            return false;
+        }
+        return fs.existsSync(absolutePath) && fs.statSync(absolutePath).isFile();
+    }
+    ;
     raw(param) {
         return param;
     }
@@ -106,19 +135,41 @@ export default class LambderResponseBuilder {
     }
     ;
     file(filePath, headers, fallbackFilePath) {
-        if (!this.checkFileExist(filePath)) {
-            if (fallbackFilePath && this.checkFileExist(fallbackFilePath)) {
+        if (!this.checkPublicFileExist(filePath)) {
+            if (fallbackFilePath && this.checkPublicFileExist(fallbackFilePath)) {
                 return this.file(fallbackFilePath, headers);
             }
             return this.json({ error: "File not found: " + filePath });
         }
         const mimeType = mimeTypeResolver.lookup(filePath);
-        const body = this.readFileSync(filePath);
+        const body = this.readPublicFileSync(filePath);
         const bodyBase64 = Buffer.from(body).toString("base64");
         console.log("bodyBase64.length", bodyBase64.length);
         return this.fileBase64(bodyBase64, mimeType || "", headers);
     }
     ;
+    async ejsTemplate(template, pageData, headers) {
+        const includeRenderedFile = async (filePath, partialData) => {
+            const template = await this.readEjsFileSync(filePath);
+            return await ejs.render(template, { page: pageData, partial: partialData, include: includeRenderedFile }, { async: true });
+        };
+        const renderedResult = await ejs.render(template, { page: pageData, include: includeRenderedFile }, { async: true });
+        return this.raw({
+            statusCode: 200,
+            isBase64Encoded: true,
+            multiValueHeaders: { "Content-Type": ["text/html; charset=utf-8"], ...convertToMultiHeader(headers) },
+            body: Buffer.from(renderedResult).toString("base64"),
+        });
+    }
+    ;
+    async ejsFile(filePath, pageData, headers) {
+        if (!this.checkEjsFileExist(filePath)) {
+            return this.json({ error: "File not found: " + filePath });
+        }
+        const template = this.readEjsFileSync(filePath);
+        return this.ejsTemplate(template, pageData, headers);
+    }
+    ;
     api(payload, { versionExpired, sessionExpired, notAuthorized, message = null, errorMessage = null, } = {
         versionExpired: undefined, sessionExpired: undefined, notAuthorized: undefined,
         message: null, errorMessage: null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lambder",
-  "version": "1.0.98",
+  "version": "1.0.102",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,6 +14,7 @@
   "license": "ISC",
   "dependencies": {
     "cookie": "^0.6.0",
+    "ejs": "^3.1.9",
     "js-cookie": "^3.0.5",
     "mime-types": "^2.1.35",
     "path-to-regexp": "^6.2.1",
@@ -22,6 +23,7 @@
   "devDependencies": {
     "@types/aws-lambda": "^8.10.136",
     "@types/cookie": "^0.6.0",
+    "@types/ejs": "^3.1.5",
     "@types/js-cookie": "^3.0.6",
     "@types/mime-types": "^2.1.4",
     "@types/node": "^20.11.27",

package/src/Lambder.ts

@@ -63,18 +63,19 @@ export const createContext = (
     const method = event.httpMethod;
     const cookie = cookieParser.parse(event.headers.Cookie || event.headers.cookie || "");
     const headers = event.headers;
-    let post: Record<string, any> = {};
     const session = null;
+    // Decode body for the post
+    let post: Record<string, any> = {};
     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){}
+    // Parse api variables
     const isAPICall = method === "POST" && apiPath && path === apiPath && post.apiName;
     const apiName:string = isAPICall ? post.apiName : null;
     const apiPayload:string = isAPICall ? post.payload : null;
 
-    if(/^(((\d+\.)+\d+)|(([a-f\d]+:)+[a-f\d]+))$/.test(host)){ throw new Error("[404] Host cannot be an ip address: " + host); }
     return { host, path, pathParams, method, get, post, cookie, apiName, apiPayload, headers, session, lambdaContext };
 }
 

package/src/LambderResolver.ts

@@ -12,6 +12,8 @@ interface DieResolverMethods {
     cors: MethodType<LambderResponseBuilder, 'cors'>;
     fileBase64: MethodType<LambderResponseBuilder, 'fileBase64'>;
     file: MethodType<LambderResponseBuilder, 'file'>;
+    ejsFile: MethodType<LambderResponseBuilder, 'ejsFile'>;
+    ejsTemplate: MethodType<LambderResponseBuilder, 'ejsTemplate'>;
     api: MethodType<LambderResponseBuilder, 'api'>;
 }
 
@@ -44,6 +46,8 @@ export default class LambderResolver extends LambderResponseBuilder {
             cors: this.autoResolve(this.cors),
             fileBase64: this.autoResolve(this.fileBase64),
             file: this.autoResolve(this.file),
+            ejsFile: this.autoResolvePromise(this.ejsFile),
+            ejsTemplate: this.autoResolvePromise(this.ejsTemplate),
             api: this.autoResolve(this.api),
         };
     }
@@ -58,4 +62,22 @@ export default class LambderResolver extends LambderResponseBuilder {
         };
     }
 
+    private autoResolvePromise<
+        T extends (...args: any[]) => Promise<LambderResolverResponse>
+    >(method: T): (...funcArgs: Parameters<T>) => Promise<LambderResolverResponse> {
+        return (...args: Parameters<T>): Promise<LambderResolverResponse> => {
+            return new Promise<LambderResolverResponse>((resolve, reject) => {
+                method.apply(this, args)
+                    .then(result => {
+                        this.resolve(result);
+                        resolve(result);
+                    })
+                    .catch(err => {
+                        this.reject(err);
+                        reject(err);
+                    });
+            });
+        };
+    }
+
 };

package/src/LambderResponseBuilder.ts

@@ -1,5 +1,6 @@
 import fs from "fs";
 import * as path from "path";
+import ejs from "ejs";
 import mimeTypeResolver from "mime-types";
 
 const convertToMultiHeader = (
@@ -37,37 +38,58 @@ export type LambderApiResponse<T> = LambderApiResponseConfig & {
 export default class LambderResponseBuilder {
     private isCorsEnabled: boolean;
     private publicPath: string;
+    private ejsPath: string|null;
     private apiVersion: string|null;
 
     constructor(
-        { isCorsEnabled, publicPath, apiVersion }: 
+        { isCorsEnabled, publicPath, apiVersion, ejsPath }: 
         { 
             isCorsEnabled: boolean, 
             publicPath: string,
+            ejsPath?: string|null,
             apiVersion?: string|null,
         }
     ){
         this.isCorsEnabled = isCorsEnabled;
         this.publicPath = publicPath;
+        this.ejsPath = ejsPath ?? null;
         this.apiVersion = apiVersion ?? null;
     };
 
-    private readFileSync(filePath: string){
+    private readPublicFileSync(filePath: string){
         const publicPath = path.resolve(this.publicPath);
         const absolutePath = path.join(publicPath, filePath);
-        console.log("readFileSync", { filePath, publicPath, absolutePath });
-        if(!absolutePath.includes(publicPath)){ return "forbiddenpath"; }
+        console.log("readPublicFileSync", { filePath, publicPath, absolutePath });
+        if(!absolutePath.includes(publicPath)){ return "forbidden-public-path"; }
         return fs.readFileSync(absolutePath);
     };
 
-    private checkFileExist(filePath: string){
+    private checkPublicFileExist(filePath: string){
         const publicPath = path.resolve(this.publicPath);
         const absolutePath = path.join(this.publicPath, filePath);
-        console.log("checkFileExist", { filePath, publicPath, absolutePath });
+        console.log("checkPublicFileExist", { filePath, publicPath, absolutePath });
         if(!absolutePath.includes(publicPath)){ return false; }
         return fs.existsSync(absolutePath) && fs.statSync(absolutePath).isFile();
     };
 
+    private readEjsFileSync(filePath: string){
+        if(!this.ejsPath){ return "EJS PATH NOT SET!"; }
+        const ejsPath = path.resolve(this.ejsPath);
+        const absolutePath = path.join(ejsPath, filePath);
+        console.log("readEjsFileSync", { filePath, ejsPath, absolutePath });
+        if(!absolutePath.includes(ejsPath)){ return "forbidden-ejs-path"; }
+        return String(fs.readFileSync(absolutePath));
+    };
+
+    private checkEjsFileExist(filePath: string){
+        if(!this.ejsPath){ return "EJS PATH NOT SET!"; }
+        const ejsPath = path.resolve(this.ejsPath);
+        const absolutePath = path.join(this.ejsPath, filePath);
+        console.log("checkEjsFileExist", { filePath, ejsPath, absolutePath });
+        if(!absolutePath.includes(ejsPath)){ return false; }
+        return fs.existsSync(absolutePath) && fs.statSync(absolutePath).isFile();
+    };
+
     raw(param: LambderResolverResponse){
         return param;
     };
@@ -157,19 +179,50 @@ export default class LambderResponseBuilder {
         headers?: Record<string, string|string[]>,
         fallbackFilePath?: string,
     ):LambderResolverResponse{
-        if(!this.checkFileExist(filePath)){
-            if(fallbackFilePath && this.checkFileExist(fallbackFilePath)){
+        if(!this.checkPublicFileExist(filePath)){
+            if(fallbackFilePath && this.checkPublicFileExist(fallbackFilePath)){
                 return this.file(fallbackFilePath, headers);
             }
             return this.json({ error: "File not found: " + filePath })
         }
         const mimeType = mimeTypeResolver.lookup(filePath);
-        const body = this.readFileSync(filePath);
+        const body = this.readPublicFileSync(filePath);
         const bodyBase64 = Buffer.from(body).toString("base64");
         console.log("bodyBase64.length",bodyBase64.length);
         return this.fileBase64(bodyBase64, mimeType || "", headers);
     };
 
+	async ejsTemplate(
+        template: string, 
+        pageData: Record<string, any>,
+        headers?: Record<string, string|string[]>,
+    ):Promise<LambderResolverResponse>{
+        const includeRenderedFile = async (filePath: string, partialData: Record<string, any>) => {
+            const template = await this.readEjsFileSync(filePath);
+            return await ejs.render(template, { page: pageData, partial: partialData, include: includeRenderedFile }, { async: true });
+        }
+        const renderedResult = await ejs.render(template, { page: pageData, include: includeRenderedFile }, { async: true });
+
+        return this.raw({
+            statusCode: 200,
+            isBase64Encoded: true,
+            multiValueHeaders: {"Content-Type": ["text/html; charset=utf-8"], ...convertToMultiHeader(headers)},
+            body: Buffer.from(renderedResult).toString("base64"),
+        });
+    };
+
+	async ejsFile(
+        filePath: string, 
+        pageData: Record<string, any>,
+        headers?: Record<string, string|string[]>,
+    ):Promise<LambderResolverResponse>{
+        if(!this.checkEjsFileExist(filePath)){
+            return this.json({ error: "File not found: " + filePath })
+        }
+        const template = this.readEjsFileSync(filePath);
+        return this.ejsTemplate(template, pageData, headers);
+    };
+
     api<T=any>(
         payload: T | null, 
         {