lambder 1.0.2 → 1.0.4

package/Readme.md

@@ -0,0 +1,58 @@
+# Lambder
+
+Lambder provides a simplified way to handle AWS Lambda functions with HTTP triggers, offering a clear structure for managing API endpoints, static file serving, hooks, and error handling.
+
+## Features
+
+- Easy setup of API paths with conditions and actions.
+- Support for hooks at different stages of the request lifecycle.
+- Integrated cookie and query string parsing.
+- Customizable error handling and fallback mechanisms.
+- CORS support and easy configuration for public paths.
+- Response helpers for JSON, HTML, XML, files, and more.
+
+## Installation
+
+```bash
+npm install lambder
+```
+
+## Quick Start
+
+```typescript
+import Lambder from 'lambder';
+import { APIGatewayProxyEvent, Context } from 'aws-lambda';
+
+const app = new Lambder({
+    apiPath: '/api',
+    publicPath: '/public',
+    isCorsEnabled: true,
+});
+
+// Define a simple API endpoint
+app.addApi('/hello', async (ctx) => {
+    return ctx.resolver.json({ message: 'Hello, World!' });
+});
+
+// Handle 404 Not Found
+app.setGlobalErrorHandler((err: Error) => {
+    return { statusCode: 404, body: 'Not Found' };
+});
+
+// Lambda handler
+exports.handler = async (event: APIGatewayProxyEvent, context: Context) => {
+    return app.render(event, context);
+};
+```
+
+## Documentation
+
+For more details on how to use Lambder, including the full API reference, visit [Lambder Documentation](#).
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request for any improvements or bug fixes.
+
+## License
+
+MIT License

package/dist/Resolver.d.ts

@@ -61,6 +61,7 @@ export default class Resolver {
         reject: (err: Error) => void;
     });
     private readFileSync;
+    private checkFileExist;
     raw(param: ResolverResponse): ResolverResponse;
     json(data: {
         [key: string]: any;
@@ -83,7 +84,7 @@ export default class Resolver {
     }): ResolverResponse;
     file(filePath: string, headers?: {
         [key: string]: string | string[];
-    }): ResolverResponse;
+    }, fallbackFilePath?: string): ResolverResponse;
     api({ payload, error, ...other }: {
         payload?: any;
         error?: any;

package/dist/Resolver.js

@@ -34,13 +34,21 @@ export default class Resolver {
         });
     }
     readFileSync(filePath) {
-        const __dirname = pathLibrary.resolve(pathLibrary.dirname(""));
-        const absolutePath = pathLibrary.resolve(filePath);
         const publicPath = pathLibrary.resolve(this.publicPath);
+        const absolutePath = pathLibrary.resolve(publicPath, filePath);
         if (!absolutePath.includes(publicPath)) {
             return "forbiddenpath";
         }
-        return fs.readFileSync(filePath);
+        return fs.readFileSync(absolutePath);
+    }
+    ;
+    checkFileExist(filePath) {
+        const absolutePath = pathLibrary.resolve(filePath);
+        const publicPath = pathLibrary.resolve(this.publicPath);
+        if (!absolutePath.includes(publicPath)) {
+            return false;
+        }
+        return fs.existsSync(absolutePath);
     }
     ;
     raw(param) {
@@ -110,9 +118,13 @@ export default class Resolver {
         });
     }
     ;
-    file(filePath, headers) {
-        if (!fs.existsSync(filePath))
+    file(filePath, headers, fallbackFilePath) {
+        if (!this.checkFileExist(filePath)) {
+            if (fallbackFilePath && this.checkFileExist(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 bodyBase64 = Buffer.from(body).toString("base64");

package/dist/index.d.ts

@@ -22,7 +22,7 @@ type RenderContext = RawResolvedContext & {
 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 HookBeforeRenderFunction = (renderContext: RenderContext) => RenderContext | Promise<RenderContext>;
 type HookAfterRenderFunction = (renderContext: RenderContext, renderResult: ResolverResponse) => ResolverResponse | Promise<ResolverResponse>;
 type HookFallbackFunction = (renderContext: RenderContext) => ResolverResponse | Promise<ResolverResponse>;
 type HookCompletedFunction = (renderResult: ResolverResponse) => ResolverResponse | Promise<ResolverResponse>;
@@ -35,15 +35,16 @@ export default class Lambder {
     private _actionList;
     private _hookList;
     private globalErrorHandler;
-    constructor({ apiPath, apiVersion, isCorsEnabled, publicPath }: {
+    private fallbackHandler;
+    constructor({ publicPath, apiPath, apiVersion, isCorsEnabled, }: {
+        publicPath: string;
         apiPath?: string;
         apiVersion?: string;
         isCorsEnabled?: boolean;
-        publicPath: string;
     });
     private apiHandler;
     private pathHandler;
-    private fallbackHandler;
+    setFallbackHandler(fallbackHandler: (renderContext: RenderContext) => ResolverResponse): void;
     setGlobalErrorHandler(globalErrorHandler: (err: Error) => ResolverResponse): void;
     addApi(condition: string | ConditionFunction | RegExp, actionFn: ActionFunction): void;
     addPath(condition: string | ConditionFunction | RegExp, actionFn: ActionFunction): void;

package/dist/index.js

@@ -32,11 +32,12 @@ export default class Lambder {
     _actionList;
     _hookList;
     globalErrorHandler = null;
-    constructor({ apiPath, apiVersion, isCorsEnabled, publicPath }) {
+    fallbackHandler = null;
+    constructor({ publicPath, apiPath, apiVersion, isCorsEnabled, }) {
+        this.publicPath = publicPath || "/incorrect-path-not-found";
         this.apiPath = apiPath ?? "/api";
         this.apiVersion = apiVersion ?? null;
         this.isCorsEnabled = isCorsEnabled ?? false;
-        this.publicPath = publicPath || "/incorrect-path-not-found";
         this._actionList = [];
         this._hookList = {
             "beforeRender": [],
@@ -53,8 +54,8 @@ export default class Lambder {
         // Do context stuff;
         return await actionFn(renderContext);
     }
-    async fallbackHandler(renderContext) {
-        return renderContext.resolver.file("index.html");
+    setFallbackHandler(fallbackHandler) {
+        this.fallbackHandler = fallbackHandler;
     }
     setGlobalErrorHandler(globalErrorHandler) {
         this.globalErrorHandler = globalErrorHandler;
@@ -118,7 +119,7 @@ export default class Lambder {
                 resolve, reject,
             });
             const eventContext = resolveEvent(event, resolve, reject);
-            const renderContext = { ...eventContext, runContext, resolver };
+            let renderContext = { ...eventContext, runContext, resolver };
             if (renderContext.method === "OPTIONS")
                 return resolver.cors();
             let firstMatchedAction = null;
@@ -130,8 +131,9 @@ export default class Lambder {
                 }
             }
             if (firstMatchedAction) {
-                for (const hook of this._hookList["beforeRender"])
-                    await hook.hookFn(renderContext);
+                for (const hook of this._hookList["beforeRender"]) {
+                    renderContext = await hook.hookFn(renderContext);
+                }
                 let renderResult = await firstMatchedAction.actionFn(renderContext);
                 for (const hook of this._hookList["afterRender"]) {
                     renderResult = await hook.hookFn(renderContext, renderResult);
@@ -141,8 +143,13 @@ export default class Lambder {
             else {
                 for (const hook of this._hookList["fallback"])
                     await hook.hookFn(renderContext);
-                const renderResult = await this.fallbackHandler(renderContext);
-                resolve(renderResult);
+                if (this.fallbackHandler) {
+                    const renderResult = await this.fallbackHandler(renderContext);
+                    resolve(renderResult);
+                }
+                else {
+                    resolve({ statusCode: 204, body: "Fallback handler not set.", });
+                }
             }
         }).then(async (renderResult) => {
             for (const hook of this._hookList["completed"]) {
@@ -153,7 +160,7 @@ export default class Lambder {
             if (this.globalErrorHandler) {
                 return this.globalErrorHandler(err);
             }
-            return { statusCode: 501, body: "Unknown Server Error", };
+            return { statusCode: 500, body: "Internal Server Error.", };
         });
     }
 }

package/package.json

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

package/src/Resolver.ts

@@ -80,11 +80,16 @@ export default class Resolver {
     }
 
     private readFileSync(filePath: string){
-        const __dirname = pathLibrary.resolve(pathLibrary.dirname(""));
-        const absolutePath = pathLibrary.resolve(filePath);
         const publicPath = pathLibrary.resolve(this.publicPath);
+        const absolutePath = pathLibrary.resolve(publicPath, filePath);
         if(!absolutePath.includes(publicPath)){ return "forbiddenpath"; }
-        return fs.readFileSync(filePath);
+        return fs.readFileSync(absolutePath);
+    };
+    private checkFileExist(filePath: string){
+        const absolutePath = pathLibrary.resolve(filePath);
+        const publicPath = pathLibrary.resolve(this.publicPath);
+        if(!absolutePath.includes(publicPath)){ return false; }
+        return fs.existsSync(absolutePath);
     };
 
     raw(param: ResolverResponse){
@@ -174,8 +179,14 @@ export default class Resolver {
 	file(
         filePath: string, 
         headers?: { [key:string]: string|string[] },
+        fallbackFilePath?: string,
     ):ResolverResponse{
-        if(!fs.existsSync(filePath)) return this.json({ error: "File not found: " + filePath });
+        if(!this.checkFileExist(filePath)){
+            if(fallbackFilePath && this.checkFileExist(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 bodyBase64 = Buffer.from(body).toString("base64");

package/src/index.ts

@@ -24,7 +24,7 @@ type ActionFunction = (renderContext: RenderContext) => ResolverResponse|Promise
 type ActionType = { conditionFn: ConditionFunction, actionFn: ActionFunction };
 
 type HookCreatedFunction = (lambderInstance: Lambder) => Promise<void>;
-type HookBeforeRenderFunction = (renderContext: RenderContext) => Promise<void>;
+type HookBeforeRenderFunction = (renderContext: RenderContext) => RenderContext|Promise<RenderContext>;
 type HookAfterRenderFunction = (renderContext: RenderContext, renderResult: ResolverResponse) => ResolverResponse|Promise<ResolverResponse>;
 type HookFallbackFunction = (renderContext: RenderContext) => ResolverResponse|Promise<ResolverResponse>;
 type HookCompletedFunction = (renderResult: ResolverResponse) => ResolverResponse|Promise<ResolverResponse>;
@@ -71,15 +71,16 @@ export default class Lambder {
         "completed": { priority: number, hookFn: HookCompletedFunction }[]
     };
     private globalErrorHandler: Function|null = null;
+    private fallbackHandler: Function|null = null;
 
     constructor(
-        { apiPath, apiVersion, isCorsEnabled, publicPath }: 
-        { apiPath?: string, apiVersion?: string, isCorsEnabled?: boolean, publicPath: string }
+        { publicPath, apiPath, apiVersion, isCorsEnabled, }: 
+        { publicPath: string, apiPath?: string, apiVersion?: string, isCorsEnabled?: boolean, }
     ){
+        this.publicPath = publicPath || "/incorrect-path-not-found";
         this.apiPath = apiPath ?? "/api";
         this.apiVersion = apiVersion ?? null;
         this.isCorsEnabled = isCorsEnabled ?? false;
-        this.publicPath = publicPath || "/incorrect-path-not-found";
         
         this._actionList = [];
         this._hookList = {
@@ -98,8 +99,8 @@ export default class Lambder {
         // Do context stuff;
         return await actionFn(renderContext);
     }
-    private async fallbackHandler(renderContext:RenderContext){
-        return renderContext.resolver.file("index.html");
+    setFallbackHandler(fallbackHandler: (renderContext:RenderContext)=>ResolverResponse){
+        this.fallbackHandler = fallbackHandler;
     }
     setGlobalErrorHandler(globalErrorHandler: (err: Error)=>ResolverResponse){
         this.globalErrorHandler = globalErrorHandler;
@@ -175,7 +176,7 @@ export default class Lambder {
                 resolve, reject,
             });
             const eventContext:RawResolvedContext = resolveEvent(event, resolve, reject);
-            const renderContext:RenderContext = { ...eventContext, runContext, resolver };
+            let renderContext:RenderContext = { ...eventContext, runContext, resolver };
             
             if(renderContext.method === "OPTIONS") return resolver.cors();
 
@@ -189,7 +190,9 @@ export default class Lambder {
             }
 
             if(firstMatchedAction){
-                for(const hook of this._hookList["beforeRender"]) await hook.hookFn(renderContext);
+                for(const hook of this._hookList["beforeRender"]){
+                    renderContext = await hook.hookFn(renderContext);
+                }
                 let renderResult = await firstMatchedAction.actionFn(renderContext);
                 for(const hook of this._hookList["afterRender"]){
                     renderResult = await hook.hookFn(renderContext, renderResult);
@@ -197,8 +200,12 @@ export default class Lambder {
                 resolve(renderResult);
             }else{
                 for(const hook of this._hookList["fallback"]) await hook.hookFn(renderContext);
-                const renderResult = await this.fallbackHandler(renderContext);
-                resolve(renderResult);
+                if(this.fallbackHandler){
+                    const renderResult = await this.fallbackHandler(renderContext);
+                    resolve(renderResult);
+                }else{
+                    resolve({ statusCode: 204, body: "Fallback handler not set.", })
+                }
             }
         }).then(async (renderResult: ResolverResponse):Promise<ResolverResponse> => {
             for(const hook of this._hookList["completed"]){
@@ -209,7 +216,7 @@ export default class Lambder {
             if(this.globalErrorHandler){
                 return this.globalErrorHandler(err);
             }
-            return { statusCode: 501, body: "Unknown Server Error", }
+            return { statusCode: 500, body: "Internal Server Error.", }
         })
     }