lambder 1.0.39 → 1.0.40

package/dist/Lambder.d.ts

@@ -1,6 +1,6 @@
 import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
 import Resolver from "./Resolver.js";
-import ResolverLight, { ResolverResponse } from "./ResolverLight.js";
+import ResponseBuilder, { ResolverResponse } from "./ResponseBuilder.js";
 type DDBSession = {
     userId: string;
     userIdHash: string;
@@ -36,7 +36,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>;
-type GlobalErrorHandlerFunction = (err: Error, renderContext: RenderContext | null, resolver: ResolverLight) => ResolverResponse | Promise<ResolverResponse>;
+type GlobalErrorHandlerFunction = (err: Error, renderContext: RenderContext | null, response: ResponseBuilder) => ResolverResponse | Promise<ResolverResponse>;
 type RouteFallbackHandlerFunction = (renderContext: RenderContext, resolver: Resolver) => ResolverResponse;
 type ApiFallbackHandlerFunction = (renderContext: RenderContext, resolver: Resolver) => ResolverResponse;
 export declare const createContext: (event: APIGatewayProxyEvent, lambdaContext: Context) => RenderContext;
@@ -71,6 +71,8 @@ export default class Lambder {
     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>;
+    getResponseBuilder(): ResponseBuilder;
+    getResolver(resolve: (renderResult: ResolverResponse) => void, reject: (err: Error) => void): Resolver;
     render(event: APIGatewayProxyEvent, lambdaContext: Context): Promise<ResolverResponse>;
 }
 export {};

package/dist/Lambder.js

@@ -1,7 +1,7 @@
 import querystring from "querystring";
 import cookieParser from "cookie";
 import Resolver from "./Resolver.js";
-import ResolverLight from "./ResolverLight.js";
+import ResponseBuilder from "./ResponseBuilder.js";
 export const createContext = (event, lambdaContext) => {
     const host = event.headers.Host || event.headers.host || "";
     const url = event.path;
@@ -147,18 +147,30 @@ export default class Lambder {
             this._hookList[hookEvent].sort((a, b) => a.priority - b.priority);
         }
     }
+    getResponseBuilder() {
+        return new ResponseBuilder({
+            isCorsEnabled: this.isCorsEnabled,
+            publicPath: this.publicPath,
+            apiVersion: this.apiVersion,
+        });
+    }
+    ;
+    getResolver(resolve, reject) {
+        return new Resolver({
+            isCorsEnabled: this.isCorsEnabled,
+            publicPath: this.publicPath,
+            apiVersion: this.apiVersion,
+            resolve, reject
+        });
+    }
+    ;
     async render(event, lambdaContext) {
         let eventRenderContext = null;
         try {
             let renderContext = createContext(event, lambdaContext);
             eventRenderContext = renderContext;
             return await new Promise(async (resolve, reject) => {
-                const resolver = new Resolver({
-                    isCorsEnabled: this.isCorsEnabled,
-                    publicPath: this.publicPath,
-                    apiVersion: this.apiVersion,
-                    resolve, reject
-                });
+                const resolver = this.getResolver(resolve, reject);
                 if (renderContext.method === "OPTIONS")
                     return resolver.cors();
                 const firstMatchedAction = await (async () => {
@@ -188,14 +200,10 @@ export default class Lambder {
             });
         }
         catch (err) {
-            const resolverLight = new ResolverLight({
-                isCorsEnabled: this.isCorsEnabled,
-                publicPath: this.publicPath,
-                apiVersion: this.apiVersion,
-            });
+            const responseBuilder = this.getResponseBuilder();
             const wrappedError = err instanceof Error ? err : new Error("Error: " + String(err));
             if (this.globalErrorHandler) {
-                return this.globalErrorHandler(wrappedError, eventRenderContext, resolverLight);
+                return this.globalErrorHandler(wrappedError, eventRenderContext, responseBuilder);
             }
             return { statusCode: 500, body: "Internal Server Error.", };
         }

package/dist/Resolver.d.ts

@@ -1,18 +1,18 @@
-import ResolverLight, { ResolverResponse } from "./ResolverLight.js";
+import ResponseBuilder, { ResolverResponse } from "./ResponseBuilder.js";
 type MethodType<T, M extends keyof T> = T[M] extends (...args: any[]) => any ? T[M] : never;
 interface DieResolverMethods {
-    raw: MethodType<ResolverLight, 'raw'>;
-    json: MethodType<ResolverLight, 'json'>;
-    xml: MethodType<ResolverLight, 'xml'>;
-    html: MethodType<ResolverLight, 'html'>;
-    status301: MethodType<ResolverLight, 'status301'>;
-    status404: MethodType<ResolverLight, 'status404'>;
-    cors: MethodType<ResolverLight, 'cors'>;
-    fileBase64: MethodType<ResolverLight, 'fileBase64'>;
-    file: MethodType<ResolverLight, 'file'>;
-    api: MethodType<ResolverLight, 'api'>;
+    raw: MethodType<ResponseBuilder, 'raw'>;
+    json: MethodType<ResponseBuilder, 'json'>;
+    xml: MethodType<ResponseBuilder, 'xml'>;
+    html: MethodType<ResponseBuilder, 'html'>;
+    status301: MethodType<ResponseBuilder, 'status301'>;
+    status404: MethodType<ResponseBuilder, 'status404'>;
+    cors: MethodType<ResponseBuilder, 'cors'>;
+    fileBase64: MethodType<ResponseBuilder, 'fileBase64'>;
+    file: MethodType<ResponseBuilder, 'file'>;
+    api: MethodType<ResponseBuilder, 'api'>;
 }
-export default class Resolver extends ResolverLight {
+export default class Resolver extends ResponseBuilder {
     resolve: (renderResult: ResolverResponse) => void;
     reject: (err: Error) => void;
     die: DieResolverMethods;

package/dist/Resolver.js

@@ -1,5 +1,5 @@
-import ResolverLight from "./ResolverLight.js";
-export default class Resolver extends ResolverLight {
+import ResponseBuilder from "./ResponseBuilder.js";
+export default class Resolver extends ResponseBuilder {
     resolve;
     reject;
     die;
@@ -7,7 +7,6 @@ export default class Resolver extends ResolverLight {
         super({ isCorsEnabled, publicPath, apiVersion });
         this.resolve = resolve;
         this.reject = reject;
-        // Bind ResolverLight methods to `this` for `die` and automatically resolve
         this.die = {
             raw: this.autoResolve(this.raw),
             json: this.autoResolve(this.json),

package/dist/{ResolverLight.d.ts → ResponseBuilder.d.ts}

@@ -7,7 +7,7 @@ export type ResolverResponse = {
     isBase64Encoded?: boolean;
     [key: string]: any;
 };
-export default class ResolverLight {
+export default class ResponseBuilder {
     private isCorsEnabled;
     private publicPath;
     private apiVersion;

package/dist/{ResolverLight.js → ResponseBuilder.js}

@@ -8,7 +8,7 @@ const CORS_HEADERS = convertToMultiHeader({
     "Access-Control-Allow-Origin": "*",
     "Access-Control-Allow-Methods": "OPTIONS,POST",
 });
-export default class ResolverLight {
+export default class ResponseBuilder {
     isCorsEnabled;
     publicPath;
     apiVersion;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import Lambder from './Lambder.js';
 export default Lambder;
 export { default as LambderCaller } from "./LambderCaller.js";
-export { default as ResolverLight } from "./ResolverLight.js";
+export { default as ResponseBuilder } from "./ResponseBuilder.js";
 export { default as Resolver } from "./Resolver.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 import Lambder from './Lambder.js';
 export default Lambder;
 export { default as LambderCaller } from "./LambderCaller.js";
-export { default as ResolverLight } from "./ResolverLight.js";
+export { default as ResponseBuilder } from "./ResponseBuilder.js";
 export { default as Resolver } from "./Resolver.js";

package/package.json

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

package/src/Lambder.ts

@@ -3,7 +3,7 @@ import cookieParser from "cookie";
 
 import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
 import Resolver from "./Resolver.js";
-import ResolverLight, { ResolverResponse } from "./ResolverLight.js";
+import ResponseBuilder, { ResolverResponse } from "./ResponseBuilder.js";
 
 type DDBSession = {
     userId: string,
@@ -37,7 +37,7 @@ type HookAfterRenderFunction = (renderContext: RenderContext, resolver: Resolver
 type HookFallbackFunction = (renderContext: RenderContext, resolver: Resolver) => ResolverResponse|Promise<ResolverResponse>;
 type HookCompletedFunction = (renderResult: ResolverResponse) => ResolverResponse|Promise<ResolverResponse>;
 
-type GlobalErrorHandlerFunction = (err: Error, renderContext: RenderContext|null, resolver: ResolverLight) => ResolverResponse|Promise<ResolverResponse>;
+type GlobalErrorHandlerFunction = (err: Error, renderContext: RenderContext|null, response: ResponseBuilder) => ResolverResponse|Promise<ResolverResponse>;
 type RouteFallbackHandlerFunction = (renderContext:RenderContext, resolver: Resolver) => ResolverResponse;
 type ApiFallbackHandlerFunction = (renderContext:RenderContext, resolver: Resolver) => ResolverResponse;
 
@@ -222,6 +222,22 @@ export default class Lambder {
         }
     }
 
+    public getResponseBuilder(){
+        return new ResponseBuilder({
+            isCorsEnabled: this.isCorsEnabled, 
+            publicPath: this.publicPath,
+            apiVersion: this.apiVersion,
+        });
+    };
+
+    public getResolver(resolve: (renderResult: ResolverResponse) => void, reject: (err: Error) => void){
+        return new Resolver({
+            isCorsEnabled: this.isCorsEnabled, 
+            publicPath: this.publicPath,
+            apiVersion: this.apiVersion,
+            resolve, reject
+        });
+    };
 
     async render(
         event: APIGatewayProxyEvent,
@@ -236,12 +252,7 @@ export default class Lambder {
                 resolve:(renderResult: ResolverResponse)=>void,
                 reject:(err: Error)=>void
             )=> {
-                const resolver = new Resolver({
-                    isCorsEnabled: this.isCorsEnabled, 
-                    publicPath: this.publicPath,
-                    apiVersion: this.apiVersion,
-                    resolve, reject
-                });
+                const resolver = this.getResolver(resolve, reject);
                 if(renderContext.method === "OPTIONS") return resolver.cors();
     
                 const firstMatchedAction = await (async () => {
@@ -269,14 +280,10 @@ export default class Lambder {
                 return renderResult;
             });
         }catch(err){
-            const resolverLight = new ResolverLight({
-                isCorsEnabled: this.isCorsEnabled, 
-                publicPath: this.publicPath,
-                apiVersion: this.apiVersion,
-            })
+            const responseBuilder = this.getResponseBuilder();
             const wrappedError = err instanceof Error ? err : new Error("Error: " + String(err));
             if(this.globalErrorHandler){
-                return this.globalErrorHandler(wrappedError, eventRenderContext, resolverLight);
+                return this.globalErrorHandler(wrappedError, eventRenderContext, responseBuilder);
             }
             return { statusCode: 500, body: "Internal Server Error.", }
 

package/src/Resolver.ts

@@ -1,21 +1,21 @@
-import ResolverLight, { ResolverResponse } from "./ResolverLight.js";
+import ResponseBuilder, { ResolverResponse } from "./ResponseBuilder.js";
 
 type MethodType<T, M extends keyof T> = T[M] extends (...args: any[]) => any ? T[M] : never;
 
 interface DieResolverMethods {
-    raw: MethodType<ResolverLight, 'raw'>;
-    json: MethodType<ResolverLight, 'json'>;
-    xml: MethodType<ResolverLight, 'xml'>;
-    html: MethodType<ResolverLight, 'html'>;
-    status301: MethodType<ResolverLight, 'status301'>;
-    status404: MethodType<ResolverLight, 'status404'>;
-    cors: MethodType<ResolverLight, 'cors'>;
-    fileBase64: MethodType<ResolverLight, 'fileBase64'>;
-    file: MethodType<ResolverLight, 'file'>;
-    api: MethodType<ResolverLight, 'api'>;
+    raw: MethodType<ResponseBuilder, 'raw'>;
+    json: MethodType<ResponseBuilder, 'json'>;
+    xml: MethodType<ResponseBuilder, 'xml'>;
+    html: MethodType<ResponseBuilder, 'html'>;
+    status301: MethodType<ResponseBuilder, 'status301'>;
+    status404: MethodType<ResponseBuilder, 'status404'>;
+    cors: MethodType<ResponseBuilder, 'cors'>;
+    fileBase64: MethodType<ResponseBuilder, 'fileBase64'>;
+    file: MethodType<ResponseBuilder, 'file'>;
+    api: MethodType<ResponseBuilder, 'api'>;
 }
 
-export default class Resolver extends ResolverLight {
+export default class Resolver extends ResponseBuilder {
     public resolve: (renderResult: ResolverResponse) => void;
     public reject: (err: Error) => void;
     public die: DieResolverMethods;
@@ -34,7 +34,6 @@ export default class Resolver extends ResolverLight {
         this.resolve = resolve;
         this.reject = reject;
 
-        // Bind ResolverLight methods to `this` for `die` and automatically resolve
         this.die = {
             raw: this.autoResolve(this.raw),
             json: this.autoResolve(this.json),

package/src/{ResolverLight.ts → ResponseBuilder.ts}

@@ -23,7 +23,7 @@ export type ResolverResponse = {
 };
 
 
-export default class ResolverLight {
+export default class ResponseBuilder {
     private isCorsEnabled: boolean;
     private publicPath: string;
     private apiVersion: string|null;
@@ -187,38 +187,4 @@ export default class ResolverLight {
         }, headers);
     };
 
-};
-
-
-
-interface IResolverMethods {
-    raw(param: { 
-        statusCode: number, 
-        isBase64Encoded?: boolean,
-        body: null | string, 
-        multiValueHeaders: { [key: string]: string[] },
-    }): 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, 
-            versionExpired, sessionExpired, notAuthorized, 
-            message, errorMessage, 
-            ...other 
-        }: { 
-            payload?: any; 
-            versionExpired?: boolean; 
-            sessionExpired?: boolean; 
-            notAuthorized?: boolean; 
-            message?: any; 
-            errorMessage?: any;
-        }, 
-        headers?: { [key:string]: string|string[] }
-    ): ResolverResponse;
-}
+};

package/src/index.ts

@@ -2,5 +2,5 @@ import Lambder from './Lambder.js';
 
 export default Lambder;
 export { default as LambderCaller } from "./LambderCaller.js";
-export { default as ResolverLight } from "./ResolverLight.js";
+export { default as ResponseBuilder } from "./ResponseBuilder.js";
 export { default as Resolver } from "./Resolver.js";