@yopdev/dev-server 2.0.0-alpha.2 → 2.0.0-beta.2

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

@@ -1,16 +1,14 @@
-/// <reference types="node" />
 import { CloudFormationSetupConfig } from './cloudformation';
 import { DevServerConfig } from './config';
 import { HttpSettings } from './http-server';
-import { APIGatewayEventRequestContextV2WithGenericAuthorizer, Route } from './lambda-http-proxy';
+import { Authorizer, Route } from './lambda-http-proxy';
 import { Callback, Service, Startable } from './services';
-import { IncomingMessage } from 'http';
-export declare const newLambdaProxyFromCloudFormationTemplate: <C, A>(name: string, settings: HttpSettings, config: CloudFormationLambdaProxyConfig<C, A>, callback: Callback<string>) => Startable<Service<string>>;
-type CloudFormationLambdaProxyConfig<C, A> = {
-    authorizer?: (config: DevServerConfig) => A | undefined;
-    extraRoutes: Route<C, A>[];
+import { LambdaPayloadVersion } from './mappers';
+export declare const newLambdaProxyFromCloudFormationTemplate: <Context, AuthorizerContext, Event_1, HandlerResponse>(name: string, settings: HttpSettings, lambdaPayloadVersion: () => LambdaPayloadVersion<AuthorizerContext, Event_1, HandlerResponse>, config: CloudFormationLambdaProxyConfig<Context, AuthorizerContext, Event_1, HandlerResponse>, callback: Callback<string>) => Startable<Service<string>>;
+type CloudFormationLambdaProxyConfig<Context, AuthorizerContext, Event, HandlerResponse> = {
+    authorizer?: (config: DevServerConfig) => Authorizer<AuthorizerContext> | undefined;
+    extraRoutes: Route<Context, AuthorizerContext, Event, HandlerResponse>[];
     prepare?: (config: DevServerConfig) => Promise<void>;
-    context?: () => C;
-    mapper?: (request: IncomingMessage, body: string) => Promise<APIGatewayEventRequestContextV2WithGenericAuthorizer<A>>;
+    context?: () => Context;
 } & CloudFormationSetupConfig;
 export {};

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

@@ -6,10 +6,10 @@ const lambda_http_proxy_1 = require("./lambda-http-proxy");
 const PATH_VARIABLE_CAPTURE = /{(.*?)}/g;
 const QUERY_STRING_OR_LOCATION_REG_EXP = '(?:([?#].*))?';
 const PROXY_PATH_PARAM = 'proxy';
-const newLambdaProxyFromCloudFormationTemplate = (name, settings, config, callback) => new CloudFormationLambdaProxy(name, settings, config.extraRoutes, config, callback);
+const newLambdaProxyFromCloudFormationTemplate = (name, settings, lambdaPayloadVersion, config, callback) => new CloudFormationLambdaProxy(name, settings, config.extraRoutes, lambdaPayloadVersion, config, callback);
 exports.newLambdaProxyFromCloudFormationTemplate = newLambdaProxyFromCloudFormationTemplate;
 class CloudFormationLambdaProxy extends cloudformation_1.CloudFormationSetup {
-    constructor(name, settings, extraRoutes, config, callback) {
+    constructor(name, settings, extraRoutes, lambdaPayloadVersion, config, callback) {
         super(name, (event) => event.Type === 'HttpApi', async (event, handler) => Promise.resolve(this.pathWithCapturingGroups(event.Properties.Path)).then((pathWithCapturingGroups) => ({
             method: new RegExp(event.Properties.Method),
             path: new RegExp(`^${pathWithCapturingGroups}${QUERY_STRING_OR_LOCATION_REG_EXP}?$`),
@@ -31,13 +31,15 @@ class CloudFormationLambdaProxy extends cloudformation_1.CloudFormationSetup {
         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, context) => async (event) => {
-            const pathParameters = pathWithCapturingGroups.exec(event.rawPath)?.groups;
-            event.pathParameters = Object.fromEntries((Object.entries(pathParameters ?? {}))
-                .map(([k, v]) => [k, decodeURIComponent(v)]));
+            const pathParameters = pathWithCapturingGroups.exec(this.pathParameterResolver.locate(event))?.groups;
+            this.pathParameterResolver.store(event, Object.fromEntries((Object.entries(pathParameters ?? {}))
+                .map(([k, v]) => [k, decodeURIComponent(v)])));
             return handler(event, context?.());
         };
-        this.mapper = config?.mapper;
+        const payloadVersion = lambdaPayloadVersion();
+        this.mapper = payloadVersion.mapper;
         this.authorizer = config?.authorizer;
+        this.pathParameterResolver = payloadVersion.resolver;
     }
     logHandler(handler) {
         return `detected handler for ${handler.method} on ${handler.path} with weight ${handler.weight}`;

package/dist/src/index.d.ts

@@ -1,6 +1,7 @@
 export { DevServer } from './dev-server';
 export { newHttpServer as httpServer, HttpSettings } from './http-server';
 export { newLambdaHttpProxy as lambdaHttpProxy, UNAUTHORIZED } from './lambda-http-proxy';
+export { v1 as v1LambdaProxyPayload, v2 as v2LambdaProxyPayload } from './mappers';
 export { newLambdaProxyFromCloudFormationTemplate as cloudFormationLambdaProxy } from './cloudformation-lambda-http-proxy';
 export { newSnsHttpProxy as snsHttpProxy } from './sns-http-proxy';
 export { newInternalQueue as internalQueue } from './internal-queue';

package/dist/src/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Service = exports.promised = exports.lazy = exports.oneThenOther = exports.allOf = exports.tunnel = exports.container = exports.dynamoDbTable = exports.preTrafficHooks = exports.scheduledTasks = exports.cloudFormationSnsEventHandlers = exports.eventsProxy = exports.internalQueue = exports.snsHttpProxy = exports.cloudFormationLambdaProxy = exports.UNAUTHORIZED = exports.lambdaHttpProxy = exports.httpServer = exports.DevServer = void 0;
+exports.Service = exports.promised = exports.lazy = exports.oneThenOther = exports.allOf = exports.tunnel = exports.container = exports.dynamoDbTable = exports.preTrafficHooks = exports.scheduledTasks = exports.cloudFormationSnsEventHandlers = exports.eventsProxy = exports.internalQueue = exports.snsHttpProxy = exports.cloudFormationLambdaProxy = exports.v2LambdaProxyPayload = exports.v1LambdaProxyPayload = exports.UNAUTHORIZED = exports.lambdaHttpProxy = exports.httpServer = exports.DevServer = void 0;
 var dev_server_1 = require("./dev-server");
 Object.defineProperty(exports, "DevServer", { enumerable: true, get: function () { return dev_server_1.DevServer; } });
 var http_server_1 = require("./http-server");
@@ -8,6 +8,9 @@ Object.defineProperty(exports, "httpServer", { enumerable: true, get: function (
 var lambda_http_proxy_1 = require("./lambda-http-proxy");
 Object.defineProperty(exports, "lambdaHttpProxy", { enumerable: true, get: function () { return lambda_http_proxy_1.newLambdaHttpProxy; } });
 Object.defineProperty(exports, "UNAUTHORIZED", { enumerable: true, get: function () { return lambda_http_proxy_1.UNAUTHORIZED; } });
+var mappers_1 = require("./mappers");
+Object.defineProperty(exports, "v1LambdaProxyPayload", { enumerable: true, get: function () { return mappers_1.v1; } });
+Object.defineProperty(exports, "v2LambdaProxyPayload", { enumerable: true, get: function () { return mappers_1.v2; } });
 var cloudformation_lambda_http_proxy_1 = require("./cloudformation-lambda-http-proxy");
 Object.defineProperty(exports, "cloudFormationLambdaProxy", { enumerable: true, get: function () { return cloudformation_lambda_http_proxy_1.newLambdaProxyFromCloudFormationTemplate; } });
 var sns_http_proxy_1 = require("./sns-http-proxy");

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

@@ -1,21 +1,27 @@
+/// <reference types="node" />
 import { HttpSettings } from "./http-server";
-import { APIGatewayEventRequestContextV2WithAuthorizer, APIGatewayProxyEventV2WithRequestContext, APIGatewayProxyStructuredResultV2 } from "aws-lambda";
-import { IncomingMessage } from "http";
+import { LambdaMapperFactory } from "./mappers";
 import { Service, Callback } from "./services";
 export declare const UNAUTHORIZED: Error;
-export declare const newLambdaHttpProxy: <C, A>(name: string, config: {
+export declare const newLambdaHttpProxy: <Context, AuthorizerContext, Event_1, HandlerResponse>(name: string, config: {
     settings: HttpSettings;
-    routes: Route<C, A>[];
-    mapper?: (request: IncomingMessage, body: string) => Promise<APIGatewayEventRequestContextV2WithGenericAuthorizer<A>>;
-    authorizer?: Authorizer<A>;
-    context?: () => C;
+    routes: Route<Context, AuthorizerContext, Event_1, HandlerResponse>[];
+    mapper: LambdaMapperFactory<AuthorizerContext, Event_1, HandlerResponse>;
+    authorizer?: Authorizer<AuthorizerContext>;
+    context?: () => Context;
 }, callback?: Callback<string>) => Service<string>;
-export type APIGatewayEventRequestContextV2WithGenericAuthorizer<A> = APIGatewayProxyEventV2WithRequestContext<APIGatewayEventRequestContextV2WithAuthorizer<A>>;
-export type Route<C, A> = {
+export declare abstract class Response {
+    readonly statusCode: number;
+    readonly contentType: string | undefined;
+    readonly location: string | undefined;
+    constructor(statusCode: number, contentType: string | undefined, location: string | undefined);
+    body: () => string | Buffer | undefined;
+}
+export type Route<Context, AuthorizerContext, Event, HandlerResponse> = {
     method: RegExp;
     path: RegExp;
     weight: number;
-    authorizer?: Authorizer<A>;
-    handler: (event: APIGatewayEventRequestContextV2WithGenericAuthorizer<A>, context: C) => Promise<APIGatewayProxyStructuredResultV2>;
+    authorizer?: Authorizer<AuthorizerContext>;
+    handler: (event: Event, context: Context) => Promise<HandlerResponse>;
 };
-export type Authorizer<A> = (authorization: string) => Promise<A | undefined>;
+export type Authorizer<Context> = (authorization: string) => Promise<Context | undefined>;

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

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.newLambdaHttpProxy = exports.UNAUTHORIZED = void 0;
+exports.Response = exports.newLambdaHttpProxy = exports.UNAUTHORIZED = void 0;
 const logging_1 = require("@yopdev/logging");
 const http_server_1 = require("./http-server");
-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)), config.context), callback);
+const newLambdaHttpProxy = (name, config, callback) => new services_1.Service(new LambdaHttpProxy(name, config.settings, config.routes, config.mapper, config.authorizer ?? (() => Promise.resolve(undefined)), config.context), callback);
 exports.newLambdaHttpProxy = newLambdaHttpProxy;
 class LambdaHttpProxy {
     constructor(name, settings, routes, mapper, defaultAuthorizer, context = () => undefined) {
@@ -18,12 +17,14 @@ class LambdaHttpProxy {
         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'])
+        this.handler = (authorizer, lambdaHandler) => (request, body, response) => this.mapper.newInstance(request, body)
+            .then(async (mapper) => authorizer(mapper.authorization())
             .then(async (context) => {
-            proxyEvent.requestContext.authorizer = context;
-            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))
+            return lambdaHandler(mapper.event(context), this.context())
+                .then((lambda) => {
+                const result = mapper.toResponse(lambda);
+                return (0, responses_1.writeResponse)(response, result.statusCode, result.body(), result.contentType, result.location);
+            })
                 .catch((e) => {
                 this.LOGGER.error(e, 'request failed to execute');
                 (0, responses_1.internalServerError)(response, e.body);
@@ -40,3 +41,11 @@ class LambdaHttpProxy {
         this.LOGGER.info('registered %i routes', routes.length);
     }
 }
+class Response {
+    constructor(statusCode, contentType, location) {
+        this.statusCode = statusCode;
+        this.contentType = contentType;
+        this.location = location;
+    }
+}
+exports.Response = Response;

package/dist/src/mappers.d.ts

@@ -1,7 +1,25 @@
 /// <reference types="node" />
 import { Message } from "@aws-sdk/client-sqs";
-import { SQSRecord } from "aws-lambda";
+import { APIGatewayProxyEvent, APIGatewayProxyEventPathParameters, APIGatewayProxyEventV2, APIGatewayProxyResult, APIGatewayProxyStructuredResultV2, SQSRecord } from "aws-lambda";
 import { IncomingMessage } from "http";
-import { APIGatewayEventRequestContextV2WithGenericAuthorizer } from "./lambda-http-proxy";
+import { Response } from "./lambda-http-proxy";
 export declare const mapToLambdaSqsRecord: (message: Message) => SQSRecord;
-export declare function mapToLambdaEvent<A>(req: IncomingMessage, requestBody: string): Promise<APIGatewayEventRequestContextV2WithGenericAuthorizer<A>>;
+export type LambdaPayloadVersion<AuthorizerContext, Event, HandlerResponse> = {
+    mapper: LambdaMapperFactory<AuthorizerContext, Event, HandlerResponse>;
+    resolver: PathParameterResolver<Event>;
+};
+export declare const v1: <AuthorizerContext>() => LambdaPayloadVersion<AuthorizerContext, APIGatewayProxyEvent, APIGatewayProxyResult>;
+export declare const v2: <AuthorizerContext>() => LambdaPayloadVersion<AuthorizerContext, APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2>;
+interface LambdaMapper<AuthorizerContext, Event, HandlerResponse> {
+    event(context: AuthorizerContext): Event;
+    authorization(): string;
+    toResponse: (response: HandlerResponse) => Response;
+}
+export interface LambdaMapperFactory<AuthorizerContext, Event, LambdaResponse> {
+    newInstance(request: IncomingMessage, body: string): Promise<LambdaMapper<AuthorizerContext, Event, LambdaResponse>>;
+}
+export type PathParameterResolver<Event> = {
+    locate: (event: Event) => string;
+    store: (event: Event, params: APIGatewayProxyEventPathParameters) => void;
+};
+export {};

package/dist/src/mappers.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapToLambdaEvent = exports.mapToLambdaSqsRecord = void 0;
+exports.v2 = exports.v1 = exports.mapToLambdaSqsRecord = void 0;
 const url_1 = require("url");
+const lambda_http_proxy_1 = require("./lambda-http-proxy");
 const mapToLambdaSqsRecord = (message) => {
     if (!message.Body)
         throw new Error('message Body must be present');
@@ -23,84 +24,129 @@ const mapToLambdaSqsRecord = (message) => {
     };
 };
 exports.mapToLambdaSqsRecord = mapToLambdaSqsRecord;
-function mapToLambdaEvent(req, requestBody) {
-    if (!req.url || !req.method)
-        throw new Error('url and method are required');
-    const url = new url_1.URL(req.url, `http://${req.headers.host}`);
-    const qsp = {};
-    url.searchParams.forEach((v, k) => (qsp[k] = decodeURIComponent(v)));
-    const headers = {};
-    if (req.headers['content-type'])
-        headers['content-type'] = req.headers['content-type'];
-    if (req.headers['accept'])
-        headers['accept'] = req.headers['accept'];
-    if (req.headers['authorization'])
-        headers['authorization'] = req.headers['authorization'];
-    const time = 1428582896000;
-    return Promise.resolve({
-        version: '2.0',
-        rawPath: url.pathname,
-        rawQueryString: url.search,
-        routeKey: '',
-        httpMethod: req.method,
-        body: requestBody,
-        headers: headers,
-        path: url.pathname,
-        pathParameters: null,
-        queryStringParameters: qsp,
-        resource: '',
-        multiValueHeaders: {},
-        isBase64Encoded: false,
-        multiValueQueryStringParameters: null,
-        stageVariables: null,
-        requestContext: {
-            domainName: req.headers.host,
-            domainPrefix: '',
-            http: {
-                method: req.method,
-                path: url.pathname,
-                protocol: 'http',
-                sourceIp: '127.0.0.1',
-                userAgent: req.headers['user-agent'],
-            },
+const payloadV1JwtAuthorizerLambdaMapper = () => ({
+    newInstance: (request, body) => Promise.resolve(new DefaultLambdaMapper(request, body))
+});
+const payloadV2LambdaAuthorizerLambdaMapper = () => ({
+    newInstance: (request, body) => Promise.resolve(new DefaultLambdaMapper(request, body))
+});
+const payloadV1PathParameterResolver = {
+    locate: (event) => event.path,
+    store: (event, params) => event.pathParameters = params
+};
+const payloadV2PathParameterResolver = {
+    locate: (event) => event.rawPath,
+    store: (event, params) => event.pathParameters = params
+};
+const v1 = () => ({
+    mapper: payloadV1JwtAuthorizerLambdaMapper(),
+    resolver: payloadV1PathParameterResolver,
+});
+exports.v1 = v1;
+const v2 = () => ({
+    mapper: payloadV2LambdaAuthorizerLambdaMapper(),
+    resolver: payloadV2PathParameterResolver,
+});
+exports.v2 = v2;
+class DefaultLambdaMapper {
+    constructor(request, body) {
+        this.body = body;
+        this.toResponse = (response) => response.isBase64Encoded ?
+            new Base64EncodedResponse(response.statusCode, response.headers?.['content-type']?.toString(), response.headers?.['location']?.toString(), response.body) :
+            new StringResponse(response.statusCode, response.headers?.['content-type']?.toString(), response.headers?.['location']?.toString(), response.body);
+        this.event = (context) => ({
+            version: '2.0',
+            rawPath: this.url.pathname,
+            rawQueryString: this.url.search,
             routeKey: '',
-            time: new Date(time).toString(),
-            timeEpoch: time,
-            accountId: '',
-            apiId: '',
-            authorizer: undefined,
-            httpMethod: '',
-            identity: {
-                accessKey: '',
+            httpMethod: this.method,
+            body: this.body,
+            headers: this.headers,
+            path: this.url.pathname,
+            pathParameters: null,
+            queryStringParameters: this.queryStringParameters,
+            resource: '',
+            multiValueHeaders: {},
+            isBase64Encoded: false,
+            multiValueQueryStringParameters: null,
+            stageVariables: null,
+            requestContext: {
+                domainName: this.headers.host,
+                domainPrefix: '',
+                http: {
+                    method: this.method,
+                    path: this.url.pathname,
+                    protocol: 'http',
+                    sourceIp: '127.0.0.1',
+                    userAgent: this.headers['user-agent'],
+                },
+                routeKey: '',
+                time: new Date(this.time).toString(),
+                timeEpoch: this.time,
                 accountId: '',
-                apiKey: '',
-                apiKeyId: '',
-                caller: '',
-                clientCert: {
-                    clientCertPem: '',
-                    issuerDN: '',
-                    serialNumber: '',
-                    subjectDN: '',
-                    validity: { notAfter: '', notBefore: '' },
+                apiId: '',
+                authorizer: context,
+                httpMethod: '',
+                identity: {
+                    accessKey: '',
+                    accountId: '',
+                    apiKey: '',
+                    apiKeyId: '',
+                    caller: '',
+                    clientCert: {
+                        clientCertPem: '',
+                        issuerDN: '',
+                        serialNumber: '',
+                        subjectDN: '',
+                        validity: { notAfter: '', notBefore: '' },
+                    },
+                    cognitoAuthenticationProvider: '',
+                    cognitoAuthenticationType: '',
+                    cognitoIdentityId: '',
+                    cognitoIdentityPoolId: '',
+                    principalOrgId: '',
+                    sourceIp: '',
+                    user: '',
+                    userAgent: '',
+                    userArn: '',
                 },
-                cognitoAuthenticationProvider: '',
-                cognitoAuthenticationType: '',
-                cognitoIdentityId: '',
-                cognitoIdentityPoolId: '',
-                principalOrgId: '',
-                sourceIp: '',
-                user: '',
-                userAgent: '',
-                userArn: '',
-            },
-            path: '',
-            protocol: '',
-            requestId: '',
-            requestTimeEpoch: time,
-            resourceId: '',
-            resourcePath: '',
-            stage: '',
-        },
-    });
+                path: '',
+                protocol: '',
+                requestId: '',
+                requestTimeEpoch: this.time,
+                resourceId: '',
+                resourcePath: '',
+                stage: '',
+            }
+        });
+        this.authorization = () => this.authorizationHeaderValue;
+        if (!request.url || !request.method)
+            throw new Error('url and method are required');
+        const url = new url_1.URL(request.url, `http://${request.headers.host}`);
+        const qsp = {};
+        url.searchParams.forEach((v, k) => (qsp[k] = decodeURIComponent(v)));
+        this.queryStringParameters = qsp;
+        const headers = {};
+        if (request.headers['content-type'])
+            headers['content-type'] = request.headers['content-type'];
+        if (request.headers['accept'])
+            headers['accept'] = request.headers['accept'];
+        if (request.headers['authorization'])
+            headers['authorization'] = request.headers['authorization'];
+        this.headers = headers;
+        this.url = url;
+        this.time = 1428582896000;
+    }
+}
+class StringResponse extends lambda_http_proxy_1.Response {
+    constructor(statusCode, contentType, location, body) {
+        super(statusCode, contentType, location);
+        this.body = () => body;
+    }
+}
+class Base64EncodedResponse extends lambda_http_proxy_1.Response {
+    constructor(statusCode, contentType, location, body) {
+        super(statusCode, contentType, location);
+        this.body = () => Buffer.from(body, 'base64');
+    }
 }
-exports.mapToLambdaEvent = mapToLambdaEvent;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yopdev/dev-server",
-  "version": "2.0.0-alpha.2",
+  "version": "2.0.0-beta.2",
   "scripts": {
     "compile": "tsc",
     "pretest": "npm run compile",