lambder 1.0.103 → 1.0.104

package/dist/Lambder.d.ts

@@ -1,6 +1,7 @@
 import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
 import LambderResolver from "./LambderResolver.js";
 import LambderResponseBuilder, { LambderResolverResponse } from "./LambderResponseBuilder.js";
+import LambderUtils from "./LambderUtils.js";
 type Path = `/${string}`;
 type LambderSession = {
     userId: string;
@@ -37,18 +38,21 @@ type RouteFallbackHandlerFunction = (ctx: LambderRenderContext, resolver: Lambde
 type ApiFallbackHandlerFunction = (ctx: LambderRenderContext, resolver: LambderResolver) => LambderResolverResponse;
 export declare const createContext: (event: APIGatewayProxyEvent, lambdaContext: Context, apiPath: string) => LambderRenderContext;
 export default class Lambder {
-    private apiPath;
-    private apiVersion;
-    private isCorsEnabled;
-    private publicPath;
+    apiPath: string;
+    apiVersion: null | string;
+    isCorsEnabled: boolean;
+    publicPath: string;
+    ejsPath: string;
     private actionList;
     private hookList;
     private globalErrorHandler;
     private routeFallbackHandler;
     private apiFallbackHandler;
-    constructor({ publicPath, apiPath, apiVersion, isCorsEnabled, }: {
+    utils: LambderUtils;
+    constructor({ publicPath, apiPath, ejsPath, apiVersion, isCorsEnabled }: {
         publicPath: string;
         apiPath?: string;
+        ejsPath?: string;
         apiVersion?: string;
         isCorsEnabled?: boolean;
     });

package/dist/Lambder.js

@@ -3,6 +3,7 @@ import cookieParser from "cookie";
 import { match } from "path-to-regexp";
 import LambderResolver from "./LambderResolver.js";
 import LambderResponseBuilder from "./LambderResponseBuilder.js";
+import LambderUtils from "./LambderUtils.js";
 export const createContext = (event, lambdaContext, apiPath) => {
     const host = event.headers.Host || event.headers.host || "";
     const path = event.path;
@@ -35,13 +36,16 @@ export default class Lambder {
     apiVersion;
     isCorsEnabled;
     publicPath;
+    ejsPath;
     actionList;
     hookList;
     globalErrorHandler = null;
     routeFallbackHandler = null;
     apiFallbackHandler = null;
-    constructor({ publicPath, apiPath, apiVersion, isCorsEnabled, }) {
+    utils;
+    constructor({ publicPath, apiPath, ejsPath, apiVersion, isCorsEnabled }) {
         this.publicPath = publicPath || "/incorrect-path-not-found";
+        this.ejsPath = ejsPath || "/incorrect-ejs-path-not-found";
         this.apiPath = apiPath ?? "/api";
         this.apiVersion = apiVersion ?? null;
         this.isCorsEnabled = isCorsEnabled ?? false;
@@ -51,6 +55,7 @@ export default class Lambder {
             "afterRender": [],
             "fallback": [],
         };
+        this.utils = new LambderUtils({ ejsPath });
     }
     setRouteFallbackHandler(routeFallbackHandler) {
         this.routeFallbackHandler = routeFallbackHandler;
@@ -192,6 +197,7 @@ export default class Lambder {
             isCorsEnabled: this.isCorsEnabled,
             publicPath: this.publicPath,
             apiVersion: this.apiVersion,
+            lambderUtils: this.utils,
         });
     }
     ;
@@ -200,6 +206,7 @@ export default class Lambder {
             isCorsEnabled: this.isCorsEnabled,
             publicPath: this.publicPath,
             apiVersion: this.apiVersion,
+            lambderUtils: this.utils,
             resolve, reject
         });
     }

package/dist/LambderResolver.d.ts

@@ -1,4 +1,5 @@
 import LambderResponseBuilder, { LambderResolverResponse } from "./LambderResponseBuilder.js";
+import LambderUtils from "./LambderUtils.js";
 type MethodType<T, M extends keyof T> = T[M] extends (...args: any[]) => any ? T[M] : never;
 interface DieResolverMethods {
     raw: MethodType<LambderResponseBuilder, 'raw'>;
@@ -18,10 +19,11 @@ export default class LambderResolver extends LambderResponseBuilder {
     resolve: (response: LambderResolverResponse) => void;
     reject: (err: Error) => void;
     die: DieResolverMethods;
-    constructor({ isCorsEnabled, publicPath, apiVersion, resolve, reject }: {
+    constructor({ isCorsEnabled, publicPath, apiVersion, lambderUtils, resolve, reject }: {
         isCorsEnabled: boolean;
         publicPath: string;
         apiVersion?: string | null;
+        lambderUtils: LambderUtils;
         resolve: (response: LambderResolverResponse) => void;
         reject: (err: Error) => void;
     });

package/dist/LambderResolver.js

@@ -3,8 +3,8 @@ export default class LambderResolver extends LambderResponseBuilder {
     resolve;
     reject;
     die;
-    constructor({ isCorsEnabled, publicPath, apiVersion, resolve, reject }) {
-        super({ isCorsEnabled, publicPath, apiVersion });
+    constructor({ isCorsEnabled, publicPath, apiVersion, lambderUtils, resolve, reject }) {
+        super({ isCorsEnabled, publicPath, apiVersion, lambderUtils });
         this.resolve = resolve;
         this.reject = reject;
         this.die = {

package/dist/LambderResponseBuilder.d.ts

@@ -1,3 +1,4 @@
+import LambderUtils from "./LambderUtils.js";
 export type LambderResolverResponse = {
     statusCode: number;
     multiValueHeaders?: Record<string, string[]>;
@@ -17,18 +18,16 @@ export type LambderApiResponse<T> = LambderApiResponseConfig & {
 export default class LambderResponseBuilder {
     private isCorsEnabled;
     private publicPath;
-    private ejsPath;
     private apiVersion;
-    constructor({ isCorsEnabled, publicPath, apiVersion, ejsPath }: {
+    private lambderUtils;
+    constructor({ isCorsEnabled, publicPath, apiVersion, lambderUtils }: {
         isCorsEnabled: boolean;
         publicPath: string;
-        ejsPath?: string | null;
         apiVersion?: string | null;
+        lambderUtils: LambderUtils;
     });
     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;

package/dist/LambderResponseBuilder.js

@@ -1,6 +1,5 @@
 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({
@@ -12,13 +11,13 @@ const CORS_HEADERS = convertToMultiHeader({
 export default class LambderResponseBuilder {
     isCorsEnabled;
     publicPath;
-    ejsPath;
     apiVersion;
-    constructor({ isCorsEnabled, publicPath, apiVersion, ejsPath }) {
+    lambderUtils;
+    constructor({ isCorsEnabled, publicPath, apiVersion, lambderUtils }) {
         this.isCorsEnabled = isCorsEnabled;
         this.publicPath = publicPath;
-        this.ejsPath = ejsPath ?? null;
         this.apiVersion = apiVersion ?? null;
+        this.lambderUtils = lambderUtils;
     }
     ;
     readPublicFileSync(filePath) {
@@ -41,32 +40,6 @@ export default class LambderResponseBuilder {
         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;
     }
@@ -149,11 +122,7 @@ export default class LambderResponseBuilder {
     }
     ;
     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 });
+        const renderedResult = await this.lambderUtils.renderEjs(template, pageData);
         return this.raw({
             statusCode: 200,
             isBase64Encoded: true,
@@ -163,11 +132,13 @@ export default class LambderResponseBuilder {
     }
     ;
     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);
+        const renderedResult = await this.lambderUtils.renderEjsFile(filePath, pageData);
+        return this.raw({
+            statusCode: 200,
+            isBase64Encoded: true,
+            multiValueHeaders: { "Content-Type": ["text/html; charset=utf-8"], ...convertToMultiHeader(headers) },
+            body: Buffer.from(renderedResult).toString("base64"),
+        });
     }
     ;
     api(payload, { versionExpired, sessionExpired, notAuthorized, message = null, errorMessage = null, } = {

package/dist/LambderUtils.d.ts

@@ -0,0 +1,10 @@
+export default class LambderUtils {
+    private ejsPath?;
+    constructor({ ejsPath }?: {
+        ejsPath?: string;
+    });
+    private readEjsFileSync;
+    private checkEjsFileExist;
+    renderEjs(template: string, pageData: Record<string, any>): Promise<string>;
+    renderEjsFile(filePath: string, pageData: Record<string, any>): Promise<string>;
+}

package/dist/LambderUtils.js

@@ -0,0 +1,54 @@
+import fs from "fs";
+import * as path from "path";
+import ejs from "ejs";
+export default class LambderUtils {
+    ejsPath;
+    constructor({ ejsPath } = {}) {
+        this.ejsPath = ejsPath;
+    }
+    ;
+    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();
+    }
+    ;
+    async renderEjs(template, pageData) {
+        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 renderedResult;
+    }
+    ;
+    async renderEjsFile(filePath, pageData) {
+        if (!this.checkEjsFileExist(filePath)) {
+            return "File not found: " + filePath;
+        }
+        const template = this.readEjsFileSync(filePath);
+        return this.renderEjs(template, pageData);
+    }
+    ;
+}
+;

package/package.json

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

package/src/Lambder.ts

@@ -5,6 +5,7 @@ import { match } from "path-to-regexp";
 import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
 import LambderResolver from "./LambderResolver.js";
 import LambderResponseBuilder, { LambderResolverResponse } from "./LambderResponseBuilder.js";
+import LambderUtils from "./LambderUtils.js";
 
 type Path = `/${string}`;
 
@@ -35,7 +36,6 @@ type LambderRenderContext = {
 
 type LambderModuleFunction = (lambderInstance: Lambder) => void | Promise<void>;
 
-
 type ConditionFunction = (ctx: LambderRenderContext) => boolean;
 type ActionFunction = (ctx: LambderRenderContext, resolver: LambderResolver) => LambderResolverResponse|Promise<LambderResolverResponse>;
 type ActionObject = { conditionFn: ConditionFunction, actionFn: ActionFunction };
@@ -81,10 +81,11 @@ export const createContext = (
 
 
 export default class Lambder {
-    private apiPath: string;
-    private apiVersion: null|string;
-    private isCorsEnabled: boolean;
-    private publicPath: string;
+    public apiPath: string;
+    public apiVersion: null|string;
+    public isCorsEnabled: boolean;
+    public publicPath: string;
+    public ejsPath: string;
     
     private actionList: ActionObject[];
     private hookList: { 
@@ -96,11 +97,15 @@ export default class Lambder {
     private routeFallbackHandler: RouteFallbackHandlerFunction|null = null;
     private apiFallbackHandler: ApiFallbackHandlerFunction|null = null;
 
+    public utils: LambderUtils;
+
+    
     constructor(
-        { publicPath, apiPath, apiVersion, isCorsEnabled, }: 
-        { publicPath: string, apiPath?: string, apiVersion?: string, isCorsEnabled?: boolean, }
+        { publicPath, apiPath, ejsPath, apiVersion, isCorsEnabled }: 
+        { publicPath: string, apiPath?: string, ejsPath?: string, apiVersion?: string, isCorsEnabled?: boolean, }
     ){
         this.publicPath = publicPath || "/incorrect-path-not-found";
+        this.ejsPath = ejsPath || "/incorrect-ejs-path-not-found";
         this.apiPath = apiPath ?? "/api";
         this.apiVersion = apiVersion ?? null;
         this.isCorsEnabled = isCorsEnabled ?? false;
@@ -111,6 +116,8 @@ export default class Lambder {
             "afterRender": [],
             "fallback": [],
         };
+
+        this.utils = new LambderUtils({ ejsPath });
     }
 
     setRouteFallbackHandler(routeFallbackHandler: RouteFallbackHandlerFunction){
@@ -267,6 +274,7 @@ export default class Lambder {
             isCorsEnabled: this.isCorsEnabled, 
             publicPath: this.publicPath,
             apiVersion: this.apiVersion,
+            lambderUtils: this.utils,
         });
     };
 
@@ -275,6 +283,7 @@ export default class Lambder {
             isCorsEnabled: this.isCorsEnabled, 
             publicPath: this.publicPath,
             apiVersion: this.apiVersion,
+            lambderUtils: this.utils,
             resolve, reject
         });
     };

package/src/LambderResolver.ts

@@ -1,4 +1,5 @@
 import LambderResponseBuilder, { LambderResolverResponse } from "./LambderResponseBuilder.js";
+import LambderUtils from "./LambderUtils.js";
 
 type MethodType<T, M extends keyof T> = T[M] extends (...args: any[]) => any ? T[M] : never;
 
@@ -23,16 +24,17 @@ export default class LambderResolver extends LambderResponseBuilder {
     public die: DieResolverMethods;
 
     constructor(
-        { isCorsEnabled, publicPath, apiVersion, resolve, reject }: 
+        { isCorsEnabled, publicPath, apiVersion, lambderUtils, resolve, reject }: 
         { 
             isCorsEnabled: boolean, 
             publicPath: string,
             apiVersion?: string|null,
+            lambderUtils: LambderUtils
             resolve: (response: LambderResolverResponse) => void,
             reject: (err: Error) => void,
         }
     ){
-        super({ isCorsEnabled, publicPath, apiVersion });
+        super({ isCorsEnabled, publicPath, apiVersion, lambderUtils });
         this.resolve = resolve;
         this.reject = reject;
 

package/src/LambderResponseBuilder.ts

@@ -2,6 +2,7 @@ import fs from "fs";
 import * as path from "path";
 import ejs from "ejs";
 import mimeTypeResolver from "mime-types";
+import LambderUtils from "./LambderUtils.js";
 
 const convertToMultiHeader = (
     headers: Record<string, string|string[]> | undefined
@@ -38,22 +39,22 @@ export type LambderApiResponse<T> = LambderApiResponseConfig & {
 export default class LambderResponseBuilder {
     private isCorsEnabled: boolean;
     private publicPath: string;
-    private ejsPath: string|null;
     private apiVersion: string|null;
+    private lambderUtils: LambderUtils;
 
     constructor(
-        { isCorsEnabled, publicPath, apiVersion, ejsPath }: 
+        { isCorsEnabled, publicPath, apiVersion, lambderUtils }: 
         { 
             isCorsEnabled: boolean, 
             publicPath: string,
-            ejsPath?: string|null,
             apiVersion?: string|null,
+            lambderUtils: LambderUtils
         }
     ){
         this.isCorsEnabled = isCorsEnabled;
         this.publicPath = publicPath;
-        this.ejsPath = ejsPath ?? null;
         this.apiVersion = apiVersion ?? null;
+        this.lambderUtils = lambderUtils;
     };
 
     private readPublicFileSync(filePath: string){
@@ -72,23 +73,6 @@ export default class LambderResponseBuilder {
         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;
@@ -197,11 +181,7 @@ export default class LambderResponseBuilder {
         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 });
+        const renderedResult = await this.lambderUtils.renderEjs(template, pageData);
 
         return this.raw({
             statusCode: 200,
@@ -216,11 +196,14 @@ export default class LambderResponseBuilder {
         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);
+        const renderedResult = await this.lambderUtils.renderEjsFile(filePath, pageData);
+
+        return this.raw({
+            statusCode: 200,
+            isBase64Encoded: true,
+            multiValueHeaders: {"Content-Type": ["text/html; charset=utf-8"], ...convertToMultiHeader(headers)},
+            body: Buffer.from(renderedResult).toString("base64"),
+        });
     };
 
     api<T=any>(

package/src/LambderUtils.ts

@@ -0,0 +1,58 @@
+import fs from "fs";
+import * as path from "path";
+import ejs from "ejs";
+
+export default class LambderUtils {
+    private ejsPath?: string;
+
+    constructor(
+        { ejsPath }: {
+            ejsPath?: string
+        } = {}
+    ){
+        this.ejsPath = ejsPath;
+    };
+
+    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();
+    };
+
+	async renderEjs(
+        template: string, 
+        pageData: Record<string, any>,
+    ):Promise<string>{
+        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 renderedResult;
+    };
+
+	async renderEjsFile(
+        filePath: string, 
+        pageData: Record<string, any>,
+    ):Promise<string>{
+        if(!this.checkEjsFileExist(filePath)){
+            return "File not found: " + filePath;
+        }
+        const template = this.readEjsFileSync(filePath);
+        return this.renderEjs(template, pageData);
+    };
+
+};