@yopdev/dev-server 1.5.0 → 1.5.6

package/dist/src/cloudformation-lambda-http-proxy.d.ts

@@ -3,10 +3,11 @@ import { DevServerConfig } from './config';
 import { HttpSettings } from './http-server';
 import { Authorizer, Route } from './lambda-http-proxy';
 import { Callback, Service, Startable } from './services';
-export declare const newLambdaProxyFromCloudFormationTemplate: (name: string, settings: HttpSettings, config: CloudFormationLambdaProxyConfig, callback: Callback<string>) => Startable<Service<string>>;
-type CloudFormationLambdaProxyConfig = {
+export declare const newLambdaProxyFromCloudFormationTemplate: <C>(name: string, settings: HttpSettings, config: CloudFormationLambdaProxyConfig<C>, callback: Callback<string>) => Startable<Service<string>>;
+type CloudFormationLambdaProxyConfig<C> = {
     authorizer?: (config: DevServerConfig) => Authorizer | undefined;
-    extraRoutes: Route[];
+    extraRoutes: Route<C>[];
     prepare?: (config: DevServerConfig) => Promise<void>;
+    context?: () => C;
 } & CloudFormationSetupConfig;
 export {};

package/dist/src/cloudformation-lambda-http-proxy.js

@@ -14,7 +14,7 @@ class CloudFormationLambdaProxy extends cloudformation_1.CloudFormationSetup {
             method: new RegExp(event.Properties.Method),
             path: new RegExp(`^${pathWithCapturingGroups}${QUERY_STRING_OR_LOCATION_REG_EXP}?$`),
             weight: this.computeWeight(pathWithCapturingGroups),
-            handler: this.pathParameterCapture(new RegExp(pathWithCapturingGroups), handler),
+            handler: this.pathParameterCapture(new RegExp(pathWithCapturingGroups), handler, config.context),
         })), config.prepare, (name, cfg, routes) => {
             return (0, lambda_http_proxy_1.newLambdaHttpProxy)(`${name}:apigw`, {
                 settings: this.settings,
@@ -29,11 +29,11 @@ class CloudFormationLambdaProxy extends cloudformation_1.CloudFormationSetup {
         this.variables = (path) => path.split('(?<').length;
         this.pathWithCapturingGroups = (source) => [...source.matchAll(PATH_VARIABLE_CAPTURE)].reduce((prev, curr) => prev.replaceAll(curr[0], `(?<${this.normalizeCaptureGroupName(curr[1])}>.*)`), source);
         this.normalizeCaptureGroupName = (original) => (original === 'proxy+' ? PROXY_PATH_PARAM : original);
-        this.pathParameterCapture = (pathWithCapturingGroups, handler) => async (event) => {
+        this.pathParameterCapture = (pathWithCapturingGroups, handler, context) => async (event) => {
             const pathParameters = pathWithCapturingGroups.exec(event.path)?.groups;
             event.pathParameters = Object.fromEntries((Object.entries(pathParameters ?? {}))
                 .map(([k, v]) => [k, decodeURIComponent(v)]));
-            return handler(event);
+            return handler(event, context?.());
         };
     }
     logHandler(handler) {

package/dist/src/lambda-http-proxy.d.ts

@@ -3,17 +3,18 @@ import { APIGatewayEventDefaultAuthorizerContext, APIGatewayProxyEvent, APIGatew
 import { IncomingMessage } from "http";
 import { Service, Callback } from "./services";
 export declare const UNAUTHORIZED: Error;
-export declare const newLambdaHttpProxy: (name: string, config: {
+export declare const newLambdaHttpProxy: <C>(name: string, config: {
     settings: HttpSettings;
-    routes: Route[];
+    routes: Route<C>[];
     mapper?: (request: IncomingMessage, body: string) => Promise<APIGatewayProxyEvent>;
     authorizer?: Authorizer;
+    context?: () => C;
 }, callback?: Callback<string>) => Service<string>;
-export type Route = {
+export type Route<C> = {
     method: RegExp;
     path: RegExp;
     weight: number;
     authorizer?: Authorizer;
-    handler: (event: APIGatewayProxyEvent) => Promise<APIGatewayProxyResult>;
+    handler: (event: APIGatewayProxyEvent, context: C) => Promise<APIGatewayProxyResult>;
 };
 export type Authorizer = (authorization: string) => Promise<APIGatewayEventDefaultAuthorizerContext | undefined>;

package/dist/src/lambda-http-proxy.js

@@ -7,22 +7,23 @@ const mappers_1 = require("./mappers");
 const responses_1 = require("./responses");
 const services_1 = require("./services");
 exports.UNAUTHORIZED = new Error('UNAUTHORIZED');
-const newLambdaHttpProxy = (name, config, callback) => new services_1.Service(new LambdaHttpProxy(name, config.settings, config.routes, config.mapper ?? mappers_1.mapToLambdaEvent, config.authorizer ?? (() => Promise.resolve(undefined))), callback);
+const newLambdaHttpProxy = (name, config, callback) => new services_1.Service(new LambdaHttpProxy(name, config.settings, config.routes, config.mapper ?? mappers_1.mapToLambdaEvent, config.authorizer ?? (() => Promise.resolve(undefined)), config.context), callback);
 exports.newLambdaHttpProxy = newLambdaHttpProxy;
 class LambdaHttpProxy {
-    constructor(name, settings, routes, mapper, defaultAuthorizer) {
+    constructor(name, settings, routes, mapper, defaultAuthorizer, context = () => undefined) {
         this.name = name;
         this.routes = routes;
         this.mapper = mapper;
         this.defaultAuthorizer = defaultAuthorizer;
+        this.context = context;
         this.start = () => this.server.start();
         this.stop = () => this.server.stop();
         this.handler = (authorizer, lambdaHandler) => (request, body, response) => this.mapper(request, body)
             .then(async (proxyEvent) => authorizer(proxyEvent.headers['authorization'])
             .then(async (context) => {
             proxyEvent.requestContext.authorizer = context;
-            return lambdaHandler(proxyEvent)
-                .then((lambda) => (0, responses_1.writeResponse)(response, lambda.statusCode, lambda.body, lambda.headers?.['content-type']?.toString() ?? undefined, lambda.headers?.['location']?.toString() ?? undefined))
+            return lambdaHandler(proxyEvent, this.context())
+                .then((lambda) => (0, responses_1.writeResponse)(response, lambda.statusCode, lambda.isBase64Encoded ? Buffer.from(lambda.body, 'base64') : lambda.body, lambda.headers?.['content-type']?.toString() ?? undefined, lambda.headers?.['location']?.toString() ?? undefined))
                 .catch((e) => {
                 this.LOGGER.error(e, 'request failed to execute');
                 (0, responses_1.internalServerError)(response, e.body);

package/dist/src/responses.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { ServerResponse } from 'http';
 export declare function internalServerError(res: ServerResponse, body: any): void;
-export declare function writeResponse(res: ServerResponse, statusCode: number, body: string, contentType?: string, location?: string): void;
+export declare function writeResponse(res: ServerResponse, statusCode: number, body: string | Buffer, contentType?: string, location?: string): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yopdev/dev-server",
-  "version": "1.5.0",
+  "version": "1.5.6",
   "scripts": {
     "compile": "tsc",
     "pretest": "npm run compile",