lambder 1.0.0 → 1.0.2

package/deploy.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+# Exit immediately if a command exits with a non-zero status.
+set -e
+
+# Update the version, build the project, and publish
+npm version patch
+npm run build
+npm publish
+
+echo "All operations completed successfully"

package/dist/Resolver.d.ts

@@ -0,0 +1,94 @@
+export type ResolverResponse = {
+    statusCode: number;
+    multiValueHeaders?: {
+        [key: string]: string[];
+    };
+    body: string | null;
+    isBase64Encoded?: boolean;
+    [key: string]: any;
+};
+interface IResolverMethods {
+    raw(param: {
+        statusCode: number;
+        isBase64Encoded?: boolean;
+        body: null | string;
+        multiValueHeaders: {
+            [key: string]: string[];
+        };
+    }): any;
+    json(data: {
+        [key: string]: any;
+    }, headers?: {
+        [key: string]: string | string[];
+    }): any;
+    xml(data: string): any;
+    html(data: string, headers?: {
+        [key: string]: string | string[];
+    }): any;
+    status301(url: string, headers?: {
+        [key: string]: string | string[];
+    }): any;
+    status404(data: string, headers?: {
+        [key: string]: string | string[];
+    }): any;
+    cors(): any;
+    fileBase64(fileBase64: string, mimeType: string, headers?: {
+        [key: string]: string | string[];
+    }): any;
+    file(filePath: string, headers?: {
+        [key: string]: string | string[];
+    }): any;
+    api({ payload, error, ...other }: {
+        payload?: any;
+        error?: any;
+        [key: string]: any;
+    }, headers?: {
+        [key: string]: string | string[];
+    }): any;
+}
+export default class Resolver {
+    private isCorsEnabled;
+    private publicPath;
+    private apiVersion;
+    resolve: Function;
+    reject: Function;
+    die: Partial<IResolverMethods>;
+    constructor({ isCorsEnabled, publicPath, apiVersion, resolve, reject }: {
+        isCorsEnabled: boolean;
+        publicPath: string;
+        apiVersion?: string | null;
+        resolve: (renderResult: ResolverResponse) => void;
+        reject: (err: Error) => void;
+    });
+    private readFileSync;
+    raw(param: ResolverResponse): ResolverResponse;
+    json(data: {
+        [key: string]: any;
+    }, headers?: {
+        [key: string]: string | string[];
+    }): ResolverResponse;
+    xml(data: string): ResolverResponse;
+    html(data: string, headers?: {
+        [key: string]: string | string[];
+    }): ResolverResponse;
+    status301(url: string, headers?: {
+        [key: string]: string | string[];
+    }): ResolverResponse;
+    status404(data: string, headers?: {
+        [key: string]: string | string[];
+    }): ResolverResponse;
+    cors(): ResolverResponse;
+    fileBase64(fileBase64: string, mimeType: string, headers?: {
+        [key: string]: string | string[];
+    }): ResolverResponse;
+    file(filePath: string, headers?: {
+        [key: string]: string | string[];
+    }): ResolverResponse;
+    api({ payload, error, ...other }: {
+        payload?: any;
+        error?: any;
+    }, headers?: {
+        [key: string]: string | string[];
+    }): ResolverResponse;
+}
+export {};

package/dist/Resolver.js

@@ -0,0 +1,135 @@
+import fs from "fs";
+import * as pathLibrary 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({
+    "Access-Control-Allow-Credentials": "true",
+    "Access-Control-Allow-Headers": "Origin, X-Requested-With, Content-Type, Accept",
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "OPTIONS,POST",
+});
+export default class Resolver {
+    isCorsEnabled;
+    publicPath;
+    apiVersion;
+    resolve;
+    reject;
+    die;
+    constructor({ isCorsEnabled, publicPath, apiVersion, resolve, reject }) {
+        this.isCorsEnabled = isCorsEnabled;
+        this.publicPath = publicPath;
+        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;
+            }
+        });
+    }
+    readFileSync(filePath) {
+        const __dirname = pathLibrary.resolve(pathLibrary.dirname(""));
+        const absolutePath = pathLibrary.resolve(filePath);
+        const publicPath = pathLibrary.resolve(this.publicPath);
+        if (!absolutePath.includes(publicPath)) {
+            return "forbiddenpath";
+        }
+        return fs.readFileSync(filePath);
+    }
+    ;
+    raw(param) {
+        return param;
+    }
+    ;
+    json(data, headers) {
+        return this.raw({
+            statusCode: 200,
+            multiValueHeaders: {
+                "Content-Type": ["application/json; charset=utf-8"],
+                ...(this.isCorsEnabled ? CORS_HEADERS : {}),
+                ...convertToMultiHeader(headers)
+            },
+            body: JSON.stringify(data),
+        });
+    }
+    xml(data) {
+        return this.raw({
+            statusCode: 200,
+            isBase64Encoded: true,
+            multiValueHeaders: { "Content-Type": ["application/xml; charset=utf-8"] },
+            body: Buffer.from(data).toString("base64"),
+        });
+    }
+    ;
+    html(data, headers) {
+        return this.raw({
+            statusCode: 200,
+            isBase64Encoded: true,
+            multiValueHeaders: { "Content-Type": ["text/html; charset=utf-8"], ...convertToMultiHeader(headers) },
+            body: Buffer.from(data).toString("base64"),
+        });
+    }
+    ;
+    status301(url, headers) {
+        return this.raw({
+            statusCode: 301,
+            multiValueHeaders: { "Location": [url], ...convertToMultiHeader(headers) },
+            body: null
+        });
+    }
+    ;
+    status404(data, headers) {
+        return this.raw({
+            statusCode: 404,
+            isBase64Encoded: true,
+            multiValueHeaders: { "Content-Type": ["text/html; charset=utf-8"], ...convertToMultiHeader(headers) },
+            body: Buffer.from(data).toString("base64"),
+        });
+    }
+    ;
+    cors() {
+        return this.raw({
+            statusCode: 200,
+            multiValueHeaders: this.isCorsEnabled ? CORS_HEADERS : {},
+            body: JSON.stringify(""),
+        });
+    }
+    ;
+    fileBase64(fileBase64, mimeType, headers) {
+        return this.raw({
+            statusCode: 200,
+            isBase64Encoded: true,
+            multiValueHeaders: { "Content-Type": [mimeType || "text/html"], ...convertToMultiHeader(headers) },
+            body: fileBase64,
+        });
+    }
+    ;
+    file(filePath, headers) {
+        if (!fs.existsSync(filePath))
+            return this.json({ error: "File not found: " + filePath });
+        const mimeType = mimeTypeResolver.lookup(filePath);
+        const body = this.readFileSync(filePath);
+        const bodyBase64 = Buffer.from(body).toString("base64");
+        console.log("bodyBase64.length", bodyBase64.length);
+        return this.fileBase64(bodyBase64, mimeType || "", headers);
+    }
+    ;
+    api({ payload, error = null, ...other }, headers) {
+        if (error)
+            console.log("ERROR: ", error);
+        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 } : {}),
+        }, headers);
+    }
+    ;
+}

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import type { APIGatewayProxyEvent, Context } from "aws-lambda";
-export declare const resolveEvent: (event: APIGatewayProxyEvent, resolve: any, reject: any) => {
+import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
+import Resolver, { ResolverResponse } from "./Resolver";
+type RawResolvedContext = {
     host: string;
-    realHost: string;
     url: string;
     method: string;
     get: {
@@ -10,27 +10,49 @@ export declare const resolveEvent: (event: APIGatewayProxyEvent, resolve: any, r
     post: {
         [key: string]: any;
     };
-    cookie: any;
-    headers: import("aws-lambda").APIGatewayProxyEventHeaders;
+    cookie: {
+        [key: string]: any;
+    };
+    headers: APIGatewayProxyEventHeaders;
+};
+type RenderContext = RawResolvedContext & {
+    runContext: Context;
+    resolver: Resolver;
 };
-declare const hookTypeList: readonly ["beforeRender", "afterRender", "created", "completed", "fallback"];
-type HookType = typeof hookTypeList[number];
+type ConditionFunction = (renderContext: RenderContext) => boolean | Promise<boolean>;
+type ActionFunction = (renderContext: RenderContext) => ResolverResponse | Promise<ResolverResponse>;
+type HookCreatedFunction = (lambderInstance: Lambder) => Promise<void>;
+type HookBeforeRenderFunction = (renderContext: RenderContext) => Promise<void>;
+type HookAfterRenderFunction = (renderContext: RenderContext, renderResult: ResolverResponse) => ResolverResponse | Promise<ResolverResponse>;
+type HookFallbackFunction = (renderContext: RenderContext) => ResolverResponse | Promise<ResolverResponse>;
+type HookCompletedFunction = (renderResult: ResolverResponse) => ResolverResponse | Promise<ResolverResponse>;
+export declare const resolveEvent: (event: APIGatewayProxyEvent, resolve: Function, reject: Function) => RawResolvedContext;
 export default class Lambder {
-    apiPath: string;
-    corsEnabled: boolean;
+    private apiPath;
+    private apiVersion;
+    private isCorsEnabled;
+    private publicPath;
     private _actionList;
     private _hookList;
-    constructor({ apiPath, corsEnabled }: {
+    private globalErrorHandler;
+    constructor({ apiPath, apiVersion, isCorsEnabled, publicPath }: {
         apiPath?: string;
-        corsEnabled?: boolean;
+        apiVersion?: string;
+        isCorsEnabled?: boolean;
+        publicPath: string;
     });
     private apiHandler;
     private pathHandler;
     private fallbackHandler;
-    addApi(condition: string | Function | RegExp, actionFn: Function): number;
-    addPath(condition: string | Function | RegExp, actionFn: Function): number;
-    addHook(when: HookType, hookFn: Function, priority?: number): Promise<void>;
-    addModule(moduleFn: any): Promise<void>;
-    render(event: APIGatewayProxyEvent, runContext: Context): Promise<unknown>;
+    setGlobalErrorHandler(globalErrorHandler: (err: Error) => ResolverResponse): void;
+    addApi(condition: string | ConditionFunction | RegExp, actionFn: ActionFunction): void;
+    addPath(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, runContext: Context): Promise<ResolverResponse>;
 }
 export {};

package/dist/index.js

@@ -1,29 +1,14 @@
-import fs from "fs";
-import * as pathLibrary from "path";
 import querystring from "querystring";
 import cookieParser from "cookie";
-const readFileSync = (filePath) => {
-    const __dirname = pathLibrary.resolve(pathLibrary.dirname(""));
-    const absolutePath = pathLibrary.resolve(filePath);
-    const publicPath = pathLibrary.resolve(`${__dirname}/www/`);
-    if (!absolutePath.includes(publicPath)) {
-        return "forbiddenpath";
-    }
-    return fs.readFileSync(filePath);
-};
-// export const millisecondCounter = (startTime = 0) => {
-//     const time = process.hrtime();
-//     return Number((time[0] + (time[1] / 1e9) - startTime).toFixed(3));
-// };
+import Resolver from "./Resolver";
 export const resolveEvent = (event, resolve, reject) => {
-    const realHost = event.headers.Host || event.headers.host || "";
-    const host = realHost.replace(/^(\S+)--([a-z]+)\.beta00\.com$/, "$1.$2.com").replace(".beta00.com", ".com");
+    const host = event.headers.Host || event.headers.host || "";
     const url = event.path;
     const get = event.queryStringParameters || {};
     const method = event.httpMethod;
     const cookie = cookieParser.parse(event.headers.Cookie || event.headers.cookie || "");
     const headers = event.headers;
-    let post;
+    let post = {};
     try {
         const decodedBody = event.isBase64Encoded ? (event.body ? Buffer.from(event.body, "base64").toString() : "{}") : (event.body || "{}");
         try {
@@ -33,64 +18,25 @@ export const resolveEvent = (event, resolve, reject) => {
             post = querystring.parse(decodedBody) || {};
         }
     }
-    catch (e) {
-        post = {};
-    }
+    catch (e) { }
     if (/^(((\d+\.)+\d+)|(([a-f\d]+:)+[a-f\d]+))$/.test(host)) {
-        reject("[404] Host cannot be an ip address: " + host);
+        reject(new Error("[404] Host cannot be an ip address: " + host));
     }
-    return { host, realHost, url, method, get, post, cookie, headers };
+    return { host, url, method, get, post, cookie, headers };
 };
-// const parseHeader = (
-//     headers: { [key:string]: string|string[] } | undefined
-// ):{ [key:string]: string[] }  =>
-//     Object.fromEntries(Object.entries(headers||{}).map(([k,v])=>[ k, Array.isArray(v) ? v : [v] ]));
-// const CORS_HEADERS = parseHeader({
-//     "Access-Control-Allow-Credentials": "true",
-//     "Access-Control-Allow-Headers" : "Origin, X-Requested-With, Content-Type, Accept",
-//     "Access-Control-Allow-Origin": "*",
-//     "Access-Control-Allow-Methods": "OPTIONS,POST",
-// });
-// export const dieRaw = (param: { body: null|string, statusCode: number, multiValueHeaders: {[key:string]: string[] }, isBase64Encoded?: boolean }) => { console.log("HandlerEnd: " + millisecondCounter() + " Size: " + (param.body || {}).length ); return param; };
-// export const dieJson = (data: { [key:string]: any }|string, headers?: { [key:string]: string|string[] }) => dieRaw({statusCode: 200,multiValueHeaders: { "Content-Type": ["application/json; charset=utf-8"], ...CORS_HEADERS, ...parseHeader(headers)},body: JSON.stringify(data),});
-// export const dieXml = (data: string) => dieRaw({statusCode: 200,isBase64Encoded: true,multiValueHeaders: { "Content-Type": ["application/xml; charset=utf-8"]}, body: Buffer.from(data).toString("base64"),});
-// export const dieHtml = (data: string, headers?: { [key:string]: string|string[] }) => dieRaw({statusCode: 200,isBase64Encoded: true,multiValueHeaders: {"Content-Type": ["text/html; charset=utf-8"], ...parseHeader(headers)},body: Buffer.from(data).toString("base64"),});
-// export const die301 = (url: string, headers?: { [key:string]: string|string[] }) => dieRaw({statusCode: 301, multiValueHeaders: { "Location" : [url], ...parseHeader(headers) },body:null});
-// export const die404 = (data: string,headers?: { [key:string]: string|string[] }) => dieRaw({statusCode: 404,isBase64Encoded: true,multiValueHeaders: {"Content-Type": ["text/html; charset=utf-8"], ...parseHeader(headers)},body: Buffer.from(data).toString("base64"),});
-// export const dieCors = () => dieRaw({ statusCode: 200,multiValueHeaders: CORS_HEADERS,body: JSON.stringify(""),});
-// export const dieFileBase64 = async (fileBase64: string, mimeType: string, headers?: { [key:string]: string|string[] }) => dieRaw({ statusCode: 200, isBase64Encoded: true, multiValueHeaders: { "Content-Type": [mimeType || "text/html"], ...parseHeader(headers) }, body: fileBase64, });
-// export const dieFile = async (file: string, headers?: { [key:string]: string|string[] }) => {
-//     if(!fs.existsSync(file)) return dieJson("File not found: " + file );
-//     const mimeType = mimeTypeResolver.lookup(file);
-//     const body = readFileSync(file);
-//     const bodyBase64 = Buffer.from(body).toString("base64");
-//     console.log("bodyBase64.length",bodyBase64.length);
-//     return dieFileBase64(bodyBase64, mimeType || "", headers);
-// };
-// export const dieApi = ({
-//     payload, error=null,
-//     ...other
-// }: {
-//     payload?: any;
-//     error?: any;
-// }, headers?: { [key:string]: string|string[] })=>{
-//     if(error) console.log("ERROR: ", error);
-//     if(Object.keys(other).length) console.log("ERROR: Unexpected key in result: " + Object.keys(other).join(", "));
-//     return dieJson({
-//         version: lambdaConfig.version,
-//         payload,
-//         ...(error ? {error} : {}),
-//     },headers);
-// }
-const hookTypeList = ["beforeRender", "afterRender", "created", "completed", "fallback"];
 export default class Lambder {
     apiPath;
-    corsEnabled;
+    apiVersion;
+    isCorsEnabled;
+    publicPath;
     _actionList;
     _hookList;
-    constructor({ apiPath, corsEnabled }) {
+    globalErrorHandler = null;
+    constructor({ apiPath, apiVersion, isCorsEnabled, publicPath }) {
         this.apiPath = apiPath ?? "/api";
-        this.corsEnabled = corsEnabled ?? true;
+        this.apiVersion = apiVersion ?? null;
+        this.isCorsEnabled = isCorsEnabled ?? false;
+        this.publicPath = publicPath || "/incorrect-path-not-found";
         this._actionList = [];
         this._hookList = {
             "beforeRender": [],
@@ -99,16 +45,19 @@ export default class Lambder {
             "completed": []
         };
     }
-    async apiHandler(context, actionFn) {
+    async apiHandler(renderContext, actionFn) {
         // Do context stuff;
-        return await actionFn(context);
+        return await actionFn(renderContext);
     }
-    async pathHandler(context, actionFn) {
+    async pathHandler(renderContext, actionFn) {
         // Do context stuff;
-        return await actionFn(context);
+        return await actionFn(renderContext);
     }
-    async fallbackHandler(context) {
-        return die404("Not Found");
+    async fallbackHandler(renderContext) {
+        return renderContext.resolver.file("index.html");
+    }
+    setGlobalErrorHandler(globalErrorHandler) {
+        this.globalErrorHandler = globalErrorHandler;
     }
     addApi(condition, actionFn) {
         let conditionFn = (renderContext) => false;
@@ -116,7 +65,7 @@ export default class Lambder {
             conditionFn = (renderContext) => renderContext.url === this.apiPath && (renderContext.post?.api) === condition;
         }
         else if (typeof condition === "function") {
-            conditionFn = (renderContext) => renderContext.url === this.apiPath && condition(renderContext);
+            conditionFn = async (renderContext) => renderContext.url === this.apiPath && (await condition(renderContext));
         }
         else if (condition?.constructor == RegExp) {
             conditionFn = (renderContext) => renderContext.url === this.apiPath && condition.test(renderContext.post?.api);
@@ -124,7 +73,7 @@ export default class Lambder {
         else {
             throw "Unsupported API Condition";
         }
-        return this._actionList.push({
+        this._actionList.push({
             conditionFn,
             actionFn: async (renderContext) => await this.apiHandler(renderContext, actionFn)
         });
@@ -135,7 +84,7 @@ export default class Lambder {
             conditionFn = (renderContext) => renderContext.url === condition;
         }
         else if (typeof condition === "function") {
-            conditionFn = (renderContext) => condition(renderContext);
+            conditionFn = async (renderContext) => (await condition(renderContext));
         }
         else if (condition?.constructor == RegExp) {
             conditionFn = (renderContext) => condition.test(renderContext.url);
@@ -143,18 +92,18 @@ export default class Lambder {
         else {
             throw "Unsupported Path Condition";
         }
-        return this._actionList.push({
+        this._actionList.push({
             conditionFn,
             actionFn: async (renderContext) => await this.pathHandler(renderContext, actionFn)
         });
     }
-    async addHook(when, hookFn, priority = 0) {
-        if (when === "created") {
+    async addHook(hookEvent, hookFn, priority = 0) {
+        if (hookEvent === "created") {
             await hookFn(this);
         }
         else {
-            this._hookList[when].push({ priority, hookFn });
-            this._hookList[when].sort((a, b) => a.priority - b.priority);
+            this._hookList[hookEvent].push({ priority, hookFn });
+            this._hookList[hookEvent].sort((a, b) => a.priority - b.priority);
         }
     }
     async addModule(moduleFn) {
@@ -162,10 +111,16 @@ export default class Lambder {
     }
     async render(event, runContext) {
         return await new Promise(async (resolve, reject) => {
+            const resolver = new Resolver({
+                isCorsEnabled: this.isCorsEnabled,
+                publicPath: this.publicPath,
+                apiVersion: this.apiVersion,
+                resolve, reject,
+            });
             const eventContext = resolveEvent(event, resolve, reject);
-            const renderContext = { ...eventContext, runContext, resolve, reject };
+            const renderContext = { ...eventContext, runContext, resolver };
             if (renderContext.method === "OPTIONS")
-                return dieCors();
+                return resolver.cors();
             let firstMatchedAction = null;
             for (const action of this._actionList) {
                 const isConditionMet = await action.conditionFn(renderContext);
@@ -189,8 +144,16 @@ export default class Lambder {
                 const renderResult = await this.fallbackHandler(renderContext);
                 resolve(renderResult);
             }
+        }).then(async (renderResult) => {
+            for (const hook of this._hookList["completed"]) {
+                renderResult = await hook.hookFn(renderResult);
+            }
+            return renderResult;
+        }).catch(async (err) => {
+            if (this.globalErrorHandler) {
+                return this.globalErrorHandler(err);
+            }
+            return { statusCode: 501, body: "Unknown Server Error", };
         });
-        for (const hook of this._hookList["completed"])
-            await hook.hookFn(promiseResult);
     }
 }

package/package.json

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