@yopdev/dev-server 1.5.0 → 1.5.7

package/dist/src/cloudformation-event-proxy.js

@@ -16,7 +16,8 @@ class CloudFormationEventsProxy extends cloudformation_1.CloudFormationSetup {
                 const actual = Object.entries(attributes).flatMap((entry) => entry[1].Value + entry[0]);
                 return required.filter((e) => actual.includes(e)).length > 0;
             },
-        }), config.prepare, (_name, _config, routes) => routes, config);
+        }), config.prepare, config);
+        this.afterStart = (_name, _config, routes) => routes;
     }
     logHandler(handler) {
         return `detected sns handler ${handler.name}`;

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,27 +14,28 @@ 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),
-        })), config.prepare, (name, cfg, routes) => {
-            return (0, lambda_http_proxy_1.newLambdaHttpProxy)(`${name}:apigw`, {
-                settings: this.settings,
-                routes: this.extraRoutes.concat(routes),
-                authorizer: (config?.authorizer || (() => undefined))(cfg),
-            }, callback);
-        }, config);
+            handler: this.pathParameterCapture(new RegExp(pathWithCapturingGroups), handler, config.context),
+        })), config.prepare, config);
         this.settings = settings;
         this.extraRoutes = extraRoutes;
+        this.callback = callback;
+        this.afterStart = (name, cfg, routes) => (0, lambda_http_proxy_1.newLambdaHttpProxy)(`${name}:apigw`, {
+            settings: this.settings,
+            routes: this.extraRoutes.concat(routes),
+            authorizer: (this.authorizer || (() => undefined))(cfg),
+        }, this.callback);
         this.computeWeight = (path) => this.segments(path) - this.variables(path);
         this.segments = (path) => path.split('/').length;
         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?.());
         };
+        this.authorizer = config?.authorizer;
     }
     logHandler(handler) {
         return `detected handler for ${handler.method} on ${handler.path} with weight ${handler.weight}`;

package/dist/src/cloudformation.d.ts

@@ -5,13 +5,13 @@ export declare abstract class CloudFormationSetup<P, H, R, F> implements Startab
     private readonly eventFilter;
     private readonly handlerResolver;
     private readonly beforeStart;
-    private readonly afterStart;
     private readonly template;
     private readonly handlers;
     private readonly handlerNameResolver;
     private readonly LOGGER;
-    constructor(name: string, eventFilter: (event: Event<P>) => boolean, handlerResolver: (event: Event<P>, handler: H) => Promise<R>, beforeStart: ((config: DevServerConfig) => Promise<void>) | undefined, afterStart: (name: string, config: DevServerConfig, routes: R[]) => F, config: CloudFormationSetupConfig);
+    constructor(name: string, eventFilter: (event: Event<P>) => boolean, handlerResolver: (event: Event<P>, handler: H) => Promise<R>, beforeStart: ((config: DevServerConfig) => Promise<void>) | undefined, config: CloudFormationSetupConfig);
     start: (config: DevServerConfig) => Promise<F>;
+    protected abstract afterStart: (name: string, config: DevServerConfig, routes: R[]) => F;
     private resolvedHandlers;
     abstract logHandler(handler: R): string;
     private parseApiEvents;

package/dist/src/cloudformation.js

@@ -6,12 +6,11 @@ const fs_1 = require("fs");
 const js_yaml_1 = require("js-yaml");
 const logging_1 = require("@yopdev/logging");
 class CloudFormationSetup {
-    constructor(name, eventFilter, handlerResolver, beforeStart, afterStart, config) {
+    constructor(name, eventFilter, handlerResolver, beforeStart, config) {
         this.name = name;
         this.eventFilter = eventFilter;
         this.handlerResolver = handlerResolver;
         this.beforeStart = beforeStart;
-        this.afterStart = afterStart;
         this.start = async (config) => (this.beforeStart || Promise.resolve)(config)
             .then(this.resolvedHandlers)
             .then(async (routes) => this.afterStart(this.name, config, routes));

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/dist/src/sqs.js

@@ -14,7 +14,7 @@ class Sqs {
             .send(new client_sqs_1.CreateQueueCommand({
             QueueName: fifo ? `${name}.fifo` : name,
             Attributes: {
-                FifoQueue: fifo ? 'true' : 'false',
+                FifoQueue: fifo ? 'true' : undefined,
             }
         }))
             .then((create) => this.client

package/package.json

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