lambder 1.0.0

package/.eslintrc.cjs

@@ -0,0 +1,26 @@
+module.exports = {
+    "env": {
+        "browser": true,
+        "es2021": true
+    },
+    "extends": "standard-with-typescript",
+    "overrides": [
+        {
+            "env": {
+                "node": true
+            },
+            "files": [
+                ".eslintrc.{js,cjs}"
+            ],
+            "parserOptions": {
+                "sourceType": "script"
+            }
+        }
+    ],
+    "parserOptions": {
+        "ecmaVersion": "latest",
+        "sourceType": "module"
+    },
+    "rules": {
+    }
+}

package/.vscode/settings.json

@@ -0,0 +1,15 @@
+{
+    "editor.codeActionsOnSave": {
+      "source.fixAll.eslint": true
+    },
+    "eslint.validate": [
+      "javascript",
+      "javascriptreact",
+      "typescript",
+      "typescriptreact"
+    ],
+    "eslint.workingDirectories": [
+      "./src"
+    ]
+  }
+  

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+import type { APIGatewayProxyEvent, Context } from "aws-lambda";
+export declare const resolveEvent: (event: APIGatewayProxyEvent, resolve: any, reject: any) => {
+    host: string;
+    realHost: string;
+    url: string;
+    method: string;
+    get: {
+        [key: string]: any;
+    };
+    post: {
+        [key: string]: any;
+    };
+    cookie: any;
+    headers: import("aws-lambda").APIGatewayProxyEventHeaders;
+};
+declare const hookTypeList: readonly ["beforeRender", "afterRender", "created", "completed", "fallback"];
+type HookType = typeof hookTypeList[number];
+export default class Lambder {
+    apiPath: string;
+    corsEnabled: boolean;
+    private _actionList;
+    private _hookList;
+    constructor({ apiPath, corsEnabled }: {
+        apiPath?: string;
+        corsEnabled?: boolean;
+    });
+    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>;
+}
+export {};

package/dist/index.js

@@ -0,0 +1,196 @@
+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));
+// };
+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 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;
+    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) {
+        post = {};
+    }
+    if (/^(((\d+\.)+\d+)|(([a-f\d]+:)+[a-f\d]+))$/.test(host)) {
+        reject("[404] Host cannot be an ip address: " + host);
+    }
+    return { host, realHost, 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;
+    _actionList;
+    _hookList;
+    constructor({ apiPath, corsEnabled }) {
+        this.apiPath = apiPath ?? "/api";
+        this.corsEnabled = corsEnabled ?? true;
+        this._actionList = [];
+        this._hookList = {
+            "beforeRender": [],
+            "afterRender": [],
+            "fallback": [],
+            "completed": []
+        };
+    }
+    async apiHandler(context, actionFn) {
+        // Do context stuff;
+        return await actionFn(context);
+    }
+    async pathHandler(context, actionFn) {
+        // Do context stuff;
+        return await actionFn(context);
+    }
+    async fallbackHandler(context) {
+        return die404("Not Found");
+    }
+    addApi(condition, actionFn) {
+        let conditionFn = (renderContext) => false;
+        if (typeof condition === "string") {
+            conditionFn = (renderContext) => renderContext.url === this.apiPath && (renderContext.post?.api) === condition;
+        }
+        else if (typeof condition === "function") {
+            conditionFn = (renderContext) => renderContext.url === this.apiPath && condition(renderContext);
+        }
+        else if (condition?.constructor == RegExp) {
+            conditionFn = (renderContext) => renderContext.url === this.apiPath && condition.test(renderContext.post?.api);
+        }
+        else {
+            throw "Unsupported API Condition";
+        }
+        return this._actionList.push({
+            conditionFn,
+            actionFn: async (renderContext) => await this.apiHandler(renderContext, actionFn)
+        });
+    }
+    addPath(condition, actionFn) {
+        let conditionFn = (renderContext) => false;
+        if (typeof condition === "string") {
+            conditionFn = (renderContext) => renderContext.url === condition;
+        }
+        else if (typeof condition === "function") {
+            conditionFn = (renderContext) => condition(renderContext);
+        }
+        else if (condition?.constructor == RegExp) {
+            conditionFn = (renderContext) => condition.test(renderContext.url);
+        }
+        else {
+            throw "Unsupported Path Condition";
+        }
+        return this._actionList.push({
+            conditionFn,
+            actionFn: async (renderContext) => await this.pathHandler(renderContext, actionFn)
+        });
+    }
+    async addHook(when, hookFn, priority = 0) {
+        if (when === "created") {
+            await hookFn(this);
+        }
+        else {
+            this._hookList[when].push({ priority, hookFn });
+            this._hookList[when].sort((a, b) => a.priority - b.priority);
+        }
+    }
+    async addModule(moduleFn) {
+        await moduleFn(this);
+    }
+    async render(event, runContext) {
+        return await new Promise(async (resolve, reject) => {
+            const eventContext = resolveEvent(event, resolve, reject);
+            const renderContext = { ...eventContext, runContext, resolve, reject };
+            if (renderContext.method === "OPTIONS")
+                return dieCors();
+            let firstMatchedAction = null;
+            for (const action of this._actionList) {
+                const isConditionMet = await action.conditionFn(renderContext);
+                if (isConditionMet) {
+                    firstMatchedAction = action;
+                    break;
+                }
+            }
+            if (firstMatchedAction) {
+                for (const hook of this._hookList["beforeRender"])
+                    await hook.hookFn(renderContext);
+                let renderResult = await firstMatchedAction.actionFn(renderContext);
+                for (const hook of this._hookList["afterRender"]) {
+                    renderResult = await hook.hookFn(renderContext, renderResult);
+                }
+                resolve(renderResult);
+            }
+            else {
+                for (const hook of this._hookList["fallback"])
+                    await hook.hookFn(renderContext);
+                const renderResult = await this.fallbackHandler(renderContext);
+                resolve(renderResult);
+            }
+        });
+        for (const hook of this._hookList["completed"])
+            await hook.hookFn(promiseResult);
+    }
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "lambder",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "test": "exit 1",
+    "build": "tsc",
+    "lint": "eslint . --ext .ts,.tsx --fix"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "cookie": "^0.6.0",
+    "mime-types": "^2.1.35",
+    "querystring": "^0.2.1"
+  },
+  "devDependencies": {
+    "@types/aws-lambda": "^8.10.136",
+    "@types/cookie": "^0.6.0",
+    "@types/mime-types": "^2.1.4",
+    "@types/node": "^20.11.27",
+    "@typescript-eslint/eslint-plugin": "^7.2.0",
+    "@typescript-eslint/parser": "^7.2.0",
+    "eslint": "^8.57.0",
+    "typescript": "^5.4.2"
+  }
+}

package/src/Resolver.ts

@@ -0,0 +1,198 @@
+import fs from "fs";
+import * as pathLibrary from "path";
+import mimeTypeResolver from "mime-types";
+
+const convertToMultiHeader = (
+    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 = 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 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: boolean;
+    private publicPath: string;
+    private apiVersion: string|null;
+    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
+        }
+    ){
+        this.isCorsEnabled = isCorsEnabled;
+        this.publicPath = publicPath;
+        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;
+            }
+        });
+    }
+
+    private readFileSync(filePath: string){
+        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: ResolverResponse){
+        return param;
+    };
+
+	json(
+        data: { [key:string]: any }, 
+        headers?: { [key:string]: string|string[] }
+    ):ResolverResponse{
+        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: string):ResolverResponse{
+        return this.raw({
+            statusCode: 200,
+            isBase64Encoded: true,
+            multiValueHeaders: { "Content-Type": ["application/xml; charset=utf-8"]}, 
+            body: Buffer.from(data).toString("base64"),
+        });
+    };
+
+	html(
+        data: string, 
+        headers?: { [key:string]: string|string[] },
+    ):ResolverResponse{
+        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: string, 
+        headers?: { [key:string]: string|string[] },
+    ):ResolverResponse{
+        return this.raw({
+            statusCode: 301, 
+            multiValueHeaders: { "Location" : [url], ...convertToMultiHeader(headers) },
+            body:null
+        });
+    };
+
+	status404(
+        data: string,
+        headers?: { [key:string]: string|string[] },
+    ):ResolverResponse{
+        return this.raw({
+            statusCode: 404,
+            isBase64Encoded: true,
+            multiValueHeaders: {"Content-Type": ["text/html; charset=utf-8"], ...convertToMultiHeader(headers)},
+            body: Buffer.from(data).toString("base64"),
+        });
+    };
+
+	cors():ResolverResponse{
+        return this.raw({ 
+            statusCode: 200,
+            multiValueHeaders: this.isCorsEnabled ? CORS_HEADERS: {},
+            body: JSON.stringify(""),
+        });
+    };
+
+	fileBase64 (
+        fileBase64: string, 
+        mimeType: string, 
+        headers?: { [key:string]: string|string[] },
+    ):ResolverResponse{
+        return this.raw({ 
+            statusCode: 200, 
+            isBase64Encoded: true, 
+            multiValueHeaders: { "Content-Type": [mimeType || "text/html"], ...convertToMultiHeader(headers) }, 
+            body: fileBase64, 
+        });
+    };
+
+	file(
+        filePath: string, 
+        headers?: { [key:string]: string|string[] },
+    ):ResolverResponse{
+        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 }: { payload?: any; error?: any; }, 
+        headers?: { [key:string]: string|string[] },
+    ):ResolverResponse{
+        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/src/index.ts

@@ -0,0 +1,216 @@
+import querystring from "querystring";
+import cookieParser from "cookie";
+
+import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
+import Resolver, { ResolverResponse } from "./Resolver";
+
+type RawResolvedContext = {
+    host: string;
+    url: string;
+    method: string;
+    get: { [key: string]: any };
+    post: { [key: string]: any };
+    cookie: { [key: string]: any };
+    headers: APIGatewayProxyEventHeaders;
+};
+
+type RenderContext = RawResolvedContext & {
+    runContext: Context, 
+    resolver: Resolver,
+}
+
+type ConditionFunction = (renderContext: RenderContext) => boolean|Promise<boolean>;
+type ActionFunction = (renderContext: RenderContext) => ResolverResponse|Promise<ResolverResponse>;
+type ActionType = { conditionFn: ConditionFunction, actionFn: ActionFunction };
+
+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>;
+
+type HookEventType = "created"|"beforeRender"|"afterRender"|"fallback"|"completed";
+type HookListType = { 
+    priority: number, 
+    hookFn: HookCreatedFunction|HookBeforeRenderFunction|HookAfterRenderFunction|HookFallbackFunction|HookCompletedFunction,
+}[];
+
+export const resolveEvent = (
+    event: APIGatewayProxyEvent, 
+    resolve: Function, 
+    reject: Function
+):RawResolvedContext => {
+    const host = event.headers.Host || event.headers.host || "";
+    const url = event.path;
+    const get: { [key:string]: any } = event.queryStringParameters || {};
+    const method = event.httpMethod;
+    const cookie = cookieParser.parse(event.headers.Cookie || event.headers.cookie || "");
+    const headers = event.headers;
+    let post:{ [key: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){}
+    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 };
+}
+
+
+export default class Lambder {
+    private apiPath: string;
+    private apiVersion: null|string;
+    private isCorsEnabled: boolean;
+    private publicPath: string;
+    
+    private _actionList: ActionType[];
+    private _hookList: { 
+        "beforeRender": { priority: number, hookFn: HookBeforeRenderFunction }[],
+        "afterRender": { priority: number, hookFn: HookAfterRenderFunction }[],
+        "fallback": { priority: number, hookFn: HookFallbackFunction }[],
+        "completed": { priority: number, hookFn: HookCompletedFunction }[]
+    };
+    private globalErrorHandler: Function|null = null;
+
+    constructor(
+        { apiPath, apiVersion, isCorsEnabled, publicPath }: 
+        { apiPath?: string, apiVersion?: string, isCorsEnabled?: boolean, publicPath: string }
+    ){
+        this.apiPath = apiPath ?? "/api";
+        this.apiVersion = apiVersion ?? null;
+        this.isCorsEnabled = isCorsEnabled ?? false;
+        this.publicPath = publicPath || "/incorrect-path-not-found";
+        
+        this._actionList = [];
+        this._hookList = {
+            "beforeRender": [],
+            "afterRender": [],
+            "fallback": [],
+            "completed": []
+        };
+    }
+
+    private async apiHandler (renderContext:RenderContext, actionFn: ActionFunction){
+        // Do context stuff;
+        return await actionFn(renderContext);
+    }
+    private async pathHandler (renderContext:RenderContext, actionFn: ActionFunction){
+        // Do context stuff;
+        return await actionFn(renderContext);
+    }
+    private async fallbackHandler(renderContext:RenderContext){
+        return renderContext.resolver.file("index.html");
+    }
+    setGlobalErrorHandler(globalErrorHandler: (err: Error)=>ResolverResponse){
+        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.url === this.apiPath && (renderContext.post?.api) === condition;
+        }else if(typeof condition === "function"){
+            conditionFn = async (renderContext:RenderContext) => renderContext.url === this.apiPath && (await condition(renderContext));
+        }else if(condition?.constructor == RegExp){
+            conditionFn = (renderContext:RenderContext) => renderContext.url === this.apiPath && condition.test(renderContext.post?.api);
+        }else { throw "Unsupported API Condition"; }
+        this._actionList.push({ 
+            conditionFn, 
+            actionFn: async (renderContext:RenderContext) => await this.apiHandler(renderContext, actionFn) 
+        });
+    }
+
+    addPath(condition: string|ConditionFunction|RegExp, actionFn: ActionFunction):void{
+        let conditionFn: ConditionFunction = (renderContext:RenderContext) => false;
+        if(typeof condition === "string"){
+            conditionFn = (renderContext:RenderContext) => renderContext.url === condition;
+        }else if(typeof condition === "function"){
+            conditionFn = async (renderContext:RenderContext) => (await condition(renderContext));
+        }else if(condition?.constructor == RegExp){
+            conditionFn = (renderContext:RenderContext) => condition.test(renderContext.url);
+        }else { throw "Unsupported Path Condition"; }
+        this._actionList.push({ 
+            conditionFn, 
+            actionFn: async (renderContext:RenderContext) => await this.pathHandler(renderContext, actionFn) 
+        });
+    }
+
+
+
+    async addHook(hookEvent: 'created', hookFn: HookCreatedFunction, priority?: number): Promise<void>;
+    async addHook(hookEvent: 'beforeRender', hookFn: HookBeforeRenderFunction, priority?: number): Promise<void>;
+    async addHook(hookEvent: 'afterRender', hookFn: HookAfterRenderFunction, priority?: number): Promise<void>;
+    async addHook(hookEvent: 'fallback', hookFn: HookFallbackFunction, priority?: number): Promise<void>;
+    async addHook(hookEvent: 'completed', hookFn: HookCompletedFunction, priority?: number): Promise<void>;
+    async addHook(
+        hookEvent:HookEventType, 
+        hookFn: HookCreatedFunction & HookBeforeRenderFunction & HookAfterRenderFunction & HookFallbackFunction & HookCompletedFunction,
+        priority = 0
+    ): Promise<void> {
+        if(hookEvent === "created"){
+            await hookFn(this);
+        }else{
+            this._hookList[hookEvent].push({ priority, hookFn });
+            this._hookList[hookEvent].sort((a, b) => a.priority - b.priority);
+        }
+    }
+
+    async addModule(moduleFn: Function): Promise<void>{
+        await moduleFn(this);
+    }
+
+    async render(
+        event: APIGatewayProxyEvent,
+        runContext: Context
+    ): Promise<ResolverResponse>{
+        return await new Promise(async (
+            resolve:(renderResult: ResolverResponse)=>void,
+            reject:(err: Error)=>void
+        )=> {
+
+            const resolver = new Resolver({ 
+                isCorsEnabled: this.isCorsEnabled, 
+                publicPath: this.publicPath,
+                apiVersion: this.apiVersion,
+                resolve, reject,
+            });
+            const eventContext:RawResolvedContext = resolveEvent(event, resolve, reject);
+            const renderContext:RenderContext = { ...eventContext, runContext, resolver };
+            
+            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;
+                }
+            }
+
+            if(firstMatchedAction){
+                for(const hook of this._hookList["beforeRender"]) await hook.hookFn(renderContext);
+                let renderResult = await firstMatchedAction.actionFn(renderContext);
+                for(const hook of this._hookList["afterRender"]){
+                    renderResult = await hook.hookFn(renderContext, renderResult);
+                }
+                resolve(renderResult);
+            }else{
+                for(const hook of this._hookList["fallback"]) await hook.hookFn(renderContext);
+                const renderResult = await this.fallbackHandler(renderContext);
+                resolve(renderResult);
+            }
+        }).then(async (renderResult: ResolverResponse):Promise<ResolverResponse> => {
+            for(const hook of this._hookList["completed"]){
+                renderResult = await hook.hookFn(renderResult);
+            }
+            return renderResult;
+        }).catch(async (err: Error):Promise<ResolverResponse> => {
+            if(this.globalErrorHandler){
+                return this.globalErrorHandler(err);
+            }
+            return { statusCode: 501, body: "Unknown Server Error", }
+        })
+    }
+
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+      "target": "ESNext",             // Compile to a modern ECMAScript version that supports modules
+      "module": "ESNext",             // Use ESNext as module code generation to support ESM
+      "declaration": true,            // Generate corresponding '.d.ts' file.
+      "outDir": "./dist",             // Redirect output structure to the 'dist' directory
+      "strict": true,                 // Enable all strict type-checking options
+      "esModuleInterop": true,        // Enables compatibility with Babel imports
+      "skipLibCheck": true,           // Skip type checking of all declaration files (*.d.ts)
+      "forceConsistentCasingInFileNames": true,
+      "moduleResolution": "node",     // Module resolution strategy to use
+      "resolveJsonModule": true,      // Allow importing of '.json' files
+      "isolatedModules": true,        // Ensure each file can be safely transpiled without relying on other imports
+      "baseUrl": ".",                 // Base directory to resolve non-relative module names
+      "paths": {                      // Specify paths for imports
+        "*": ["node_modules/*"]
+      },
+      "lib": ["ESNext", "DOM"],       // Specify library files to be included in the compilation
+      "types": ["node"]               // Type definitions to be included
+    },
+    "include": ["src/**/*"],          // Include all files in the src directory
+    "exclude": ["node_modules", "dist"]  // Exclude 'node_modules' directory and 'dist' directory
+  }
+