lambder 1.0.13 → 1.0.15

package/.vscode/settings.json

@@ -1,6 +1,6 @@
 {
     "editor.codeActionsOnSave": {
-      "source.fixAll.eslint": true
+      "source.fixAll.eslint": "explicit"
     },
     "eslint.validate": [
       "javascript",
@@ -16,6 +16,9 @@
 			"**/dist/": true,
 			"**/package-lock.json": true,
 			"**/.git/": true,
-		},
+    },
+    "cSpell.words": [
+      "lambder"
+    ],
   }
   

package/dist/Resolver.d.ts

@@ -52,7 +52,7 @@ export default class Resolver {
     private apiVersion;
     resolve: Function;
     reject: Function;
-    die: Partial<IResolverMethods>;
+    die: IResolverMethods;
     constructor({ isCorsEnabled, publicPath, apiVersion, resolve, reject }: {
         isCorsEnabled: boolean;
         publicPath: string;

package/dist/Resolver.js

@@ -1,5 +1,5 @@
 import fs from "fs";
-import * as pathLibrary from "path";
+import * as path 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({
@@ -21,22 +21,23 @@ export default class Resolver {
         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;
-            }
-        });
+        this.die = {
+            raw: this.raw,
+            json: this.json,
+            xml: this.xml,
+            html: this.html,
+            status301: this.status301,
+            status404: this.status404,
+            cors: this.cors,
+            fileBase64: this.fileBase64,
+            file: this.file,
+            api: this.api,
+        };
     }
     ;
     readFileSync(filePath) {
-        const publicPath = pathLibrary.resolve(this.publicPath);
-        const absolutePath = pathLibrary.join(publicPath, filePath);
+        const publicPath = path.resolve(this.publicPath);
+        const absolutePath = path.join(publicPath, filePath);
         console.log("readFileSync", { filePath, publicPath, absolutePath });
         if (!absolutePath.includes(publicPath)) {
             return "forbiddenpath";
@@ -45,8 +46,8 @@ export default class Resolver {
     }
     ;
     checkFileExist(filePath) {
-        const publicPath = pathLibrary.resolve(this.publicPath);
-        const absolutePath = pathLibrary.join(this.publicPath, filePath);
+        const publicPath = path.resolve(this.publicPath);
+        const absolutePath = path.join(this.publicPath, filePath);
         console.log("checkFileExist", { filePath, publicPath, absolutePath });
         if (!absolutePath.includes(publicPath)) {
             return false;

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
 import Resolver, { ResolverResponse } from "./Resolver.js";
-type RawResolvedContext = {
+type RenderContext = {
     host: string;
     url: string;
     method: string;
@@ -14,9 +14,7 @@ type RawResolvedContext = {
         [key: string]: any;
     };
     headers: APIGatewayProxyEventHeaders;
-};
-type RenderContext = RawResolvedContext & {
-    runContext: Context;
+    lambdaContext: Context;
 };
 type ConditionFunction = (renderContext: RenderContext) => boolean | Promise<boolean>;
 type ActionFunction = (renderContext: RenderContext, resolver: Resolver) => ResolverResponse | Promise<ResolverResponse>;
@@ -25,7 +23,7 @@ type HookBeforeRenderFunction = (renderContext: RenderContext, resolver: Resolve
 type HookAfterRenderFunction = (renderContext: RenderContext, resolver: Resolver, renderResult: ResolverResponse) => ResolverResponse | Promise<ResolverResponse>;
 type HookFallbackFunction = (renderContext: RenderContext, resolver: Resolver) => ResolverResponse | Promise<ResolverResponse>;
 type HookCompletedFunction = (renderResult: ResolverResponse) => ResolverResponse | Promise<ResolverResponse>;
-export declare const resolveEvent: (event: APIGatewayProxyEvent, resolve: Function, reject: Function) => RawResolvedContext;
+export declare const createContext: (event: APIGatewayProxyEvent, lambdaContext: Context, resolve: Function, reject: Function) => RenderContext;
 export default class Lambder {
     private apiPath;
     private apiVersion;
@@ -53,6 +51,6 @@ export default class Lambder {
     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>;
+    render(event: APIGatewayProxyEvent, lambdaContext: Context): Promise<ResolverResponse>;
 }
 export {};

package/dist/index.js

@@ -1,7 +1,7 @@
 import querystring from "querystring";
 import cookieParser from "cookie";
 import Resolver from "./Resolver.js";
-export const resolveEvent = (event, resolve, reject) => {
+export const createContext = (event, lambdaContext, resolve, reject) => {
     const host = event.headers.Host || event.headers.host || "";
     const url = event.path;
     const get = event.queryStringParameters || {};
@@ -22,7 +22,7 @@ export const resolveEvent = (event, resolve, reject) => {
     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 };
+    return { host, url, method, get, post, cookie, headers, lambdaContext };
 };
 export default class Lambder {
     apiPath;
@@ -110,7 +110,7 @@ export default class Lambder {
     async addModule(moduleFn) {
         await moduleFn(this);
     }
-    async render(event, runContext) {
+    async render(event, lambdaContext) {
         return await new Promise(async (resolve, reject) => {
             const resolver = new Resolver({
                 isCorsEnabled: this.isCorsEnabled,
@@ -118,8 +118,7 @@ export default class Lambder {
                 apiVersion: this.apiVersion,
                 resolve, reject,
             });
-            const eventContext = resolveEvent(event, resolve, reject);
-            let renderContext = { ...eventContext, runContext };
+            let renderContext = createContext(event, lambdaContext, resolve, reject);
             if (renderContext.method === "OPTIONS")
                 return resolver.cors();
             let firstMatchedAction = null;

package/package.json

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

package/src/Resolver.ts

@@ -1,5 +1,5 @@
 import fs from "fs";
-import * as pathLibrary from "path";
+import * as path from "path";
 import mimeTypeResolver from "mime-types";
 
 const convertToMultiHeader = (
@@ -49,7 +49,7 @@ export default class Resolver {
     private apiVersion: string|null;
     resolve: Function;
     reject: Function;
-    die: Partial<IResolverMethods>;
+    die: IResolverMethods;
 
     constructor(
         { isCorsEnabled, publicPath, apiVersion, resolve, reject }: 
@@ -66,30 +66,31 @@ export default class Resolver {
         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;
-            }
-        });
+        this.die = {
+            raw: this.raw,
+            json: this.json,
+            xml: this.xml,
+            html: this.html,
+            status301: this.status301,
+            status404: this.status404,
+            cors: this.cors,
+            fileBase64: this.fileBase64,
+            file: this.file,
+            api: this.api,
+        }
     };
 
     private readFileSync(filePath: string){
-        const publicPath = pathLibrary.resolve(this.publicPath);
-        const absolutePath = pathLibrary.join(publicPath, filePath);
+        const publicPath = path.resolve(this.publicPath);
+        const absolutePath = path.join(publicPath, filePath);
         console.log("readFileSync", { filePath, publicPath, absolutePath });
         if(!absolutePath.includes(publicPath)){ return "forbiddenpath"; }
         return fs.readFileSync(absolutePath);
     };
 
     private checkFileExist(filePath: string){
-        const publicPath = pathLibrary.resolve(this.publicPath);
-        const absolutePath = pathLibrary.join(this.publicPath, filePath);
+        const publicPath = path.resolve(this.publicPath);
+        const absolutePath = path.join(this.publicPath, filePath);
         console.log("checkFileExist", { filePath, publicPath, absolutePath });
         if(!absolutePath.includes(publicPath)){ return false; }
         return fs.existsSync(absolutePath) && fs.statSync(absolutePath).isFile();

package/src/index.ts

@@ -4,7 +4,7 @@ import cookieParser from "cookie";
 import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
 import Resolver, { ResolverResponse } from "./Resolver.js";
 
-type RawResolvedContext = {
+type RenderContext = {
     host: string;
     url: string;
     method: string;
@@ -12,12 +12,9 @@ type RawResolvedContext = {
     post: { [key: string]: any };
     cookie: { [key: string]: any };
     headers: APIGatewayProxyEventHeaders;
+    lambdaContext: Context;
 };
 
-type RenderContext = RawResolvedContext & {
-    runContext: Context, 
-}
-
 type ConditionFunction = (renderContext: RenderContext) => boolean|Promise<boolean>;
 type ActionFunction = (renderContext: RenderContext, resolver: Resolver) => ResolverResponse|Promise<ResolverResponse>;
 type ActionType = { conditionFn: ConditionFunction, actionFn: ActionFunction };
@@ -34,11 +31,12 @@ type HookListType = {
     hookFn: HookCreatedFunction|HookBeforeRenderFunction|HookAfterRenderFunction|HookFallbackFunction|HookCompletedFunction,
 }[];
 
-export const resolveEvent = (
+export const createContext = (
     event: APIGatewayProxyEvent, 
+    lambdaContext: Context,
     resolve: Function, 
     reject: Function
-):RawResolvedContext => {
+):RenderContext => {
     const host = event.headers.Host || event.headers.host || "";
     const url = event.path;
     const get: { [key:string]: any } = event.queryStringParameters || {};
@@ -52,7 +50,7 @@ export const resolveEvent = (
         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 };
+    return { host, url, method, get, post, cookie, headers, lambdaContext };
 }
 
 
@@ -167,7 +165,7 @@ export default class Lambder {
 
     async render(
         event: APIGatewayProxyEvent,
-        runContext: Context
+        lambdaContext: Context
     ): Promise<ResolverResponse>{
         return await new Promise(async (
             resolve:(renderResult: ResolverResponse)=>void,
@@ -180,8 +178,7 @@ export default class Lambder {
                 apiVersion: this.apiVersion,
                 resolve, reject,
             });
-            const eventContext:RawResolvedContext = resolveEvent(event, resolve, reject);
-            let renderContext:RenderContext = { ...eventContext, runContext };
+            let renderContext:RenderContext = createContext(event, lambdaContext, resolve, reject)
             
             if(renderContext.method === "OPTIONS") return resolver.cors();