@yopdev/dev-server 3.0.2-RC1 → 3.0.2-RC2

package/.github/workflows/npm-publish.yml

@@ -28,6 +28,7 @@ jobs:
           node-version: 20
           registry-url: https://registry.npmjs.org/
       - run: npm ci
+      - run: npm run compile
       - run: npm publish
         env:
           NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/dist/__tests__/bootstrap.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/bootstrap.test.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const src_1 = require("../src");
+const services_1 = require("../src/services");
+const assert_1 = require("assert");
+(0, globals_1.describe)("dev server", () => {
+    (0, globals_1.it)("bootstraps with defaults and an empty service", async () => {
+        const name = 'bootstrap';
+        const tested = await new src_1.DevServer(name, new services_1.Service({
+            name: 'service',
+            start: async () => Promise.resolve(),
+            stop: async () => Promise.resolve(),
+        })).start();
+        return (0, globals_1.expect)(tested.name).toEqual(name);
+    });
+    (0, globals_1.it)("calls service cleanup when init fails", async () => {
+        let called = false;
+        try {
+            await new src_1.DevServer('bootstrap', new services_1.Service({
+                name: 'failing-root',
+                start: async () => Promise.reject(new Error('fail!')),
+                stop: async () => Promise.resolve(called = true).then(),
+            })).start();
+            (0, assert_1.fail)('should have failed');
+        }
+        catch (e) {
+            return (0, globals_1.expect)(called)
+                .toStrictEqual(true);
+        }
+    });
+    (0, globals_1.it)("calls service cleanups on all components", async () => {
+        let calledOnParent = false;
+        let calledOnSibling = false;
+        let calledOnFailing = false;
+        try {
+            await new src_1.DevServer('bootstrap', (0, src_1.allOf)([
+                new services_1.Service({
+                    name: 'parent',
+                    start: async () => Promise.resolve(),
+                    stop: async () => Promise.resolve(calledOnParent = true).then(),
+                }), (0, src_1.allOf)([
+                    new services_1.Service({
+                        name: 'failing-nested',
+                        start: async () => Promise.reject(new Error('fail!')),
+                        stop: async () => Promise.resolve(calledOnFailing = true).then(),
+                    }),
+                    new services_1.Service({
+                        name: 'sibling',
+                        start: async () => Promise.resolve(),
+                        stop: async () => Promise.resolve(calledOnSibling = true).then(),
+                    }),
+                ])
+            ])).start();
+            (0, assert_1.fail)('should have failed');
+        }
+        catch (e) {
+            return (0, globals_1.expect)([calledOnParent, calledOnFailing, calledOnSibling])
+                .toStrictEqual([true, true, true]);
+        }
+    });
+    (0, globals_1.it)("propagates the exception from the failing service", async () => {
+        const error = new Error('fail!');
+        try {
+            await new src_1.DevServer('bootstrap', (0, src_1.allOf)([
+                new services_1.Service({
+                    name: 'parent',
+                    start: async () => Promise.resolve(),
+                    stop: async () => Promise.resolve(),
+                }), (0, src_1.allOf)([
+                    new services_1.Service({
+                        name: 'failing-nested',
+                        start: async () => Promise.reject(error),
+                        stop: async () => Promise.resolve(),
+                    }),
+                    new services_1.Service({
+                        name: 'sibling',
+                        start: async () => Promise.resolve(),
+                        stop: async () => Promise.resolve(),
+                    }),
+                ])
+            ])).start();
+            (0, assert_1.fail)('should have failed');
+        }
+        catch (e) {
+            return (0, globals_1.expect)(e)
+                .toStrictEqual(error);
+        }
+    });
+});

package/dist/__tests__/deferred.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/deferred.test.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const src_1 = require("../src");
+const testcontainers_1 = require("testcontainers");
+const sqs_1 = require("../src/sqs");
+const sns_1 = require("../src/sns");
+const s3_1 = require("../src/s3");
+const dynamodb_1 = require("../src/dynamodb");
+const assert_1 = require("assert");
+(0, globals_1.describe)("a promised service", () => {
+    (0, globals_1.test)("calls start with devserver config", () => {
+        const aws = {
+            region: 'region',
+            endpoint: 'http://localhost',
+            credentials: {
+                accessKeyId: 'aki',
+                secretAccessKey: 'sak',
+            },
+        };
+        const c = {
+            raw: aws,
+            network: new testcontainers_1.StartedNetwork(undefined, 'network', undefined),
+            sqs: new sqs_1.Sqs(aws),
+            sns: new sns_1.Sns(aws),
+            s3: new s3_1.S3(aws),
+            dynamo: new dynamodb_1.DynamoDb(aws),
+            eventsProxy: {
+                topic: {
+                    arn: 'arn:...',
+                },
+            },
+        };
+        return (0, globals_1.expect)((0, src_1.promised)(async (cfg) => Promise.resolve(new src_1.Service({
+            name: 'resolved',
+            start: (config) => Promise.resolve(cfg === config),
+            stop: () => Promise.resolve(),
+        }))).start(c))
+            .resolves.toStrictEqual(true);
+    });
+    (0, globals_1.test)("calls the stop routine on failure starting promised service", async () => {
+        const error = new Error('failed starting service');
+        let stopped = false;
+        try {
+            await new src_1.DevServer('fail-on-start', (0, src_1.promised)(() => Promise.resolve(new src_1.Service({
+                name: 'fail-on-start',
+                start: async () => Promise.reject(error),
+                stop: async () => { stopped = true; },
+            })))).start();
+            (0, assert_1.fail)('should have thrown exception');
+        }
+        catch (e) {
+            return (0, globals_1.expect)(stopped)
+                .toStrictEqual(true);
+        }
+    });
+    (0, globals_1.test)("calls the cleanup routine on failure constructing promised service", async () => {
+        const error = {
+            cleanup: async () => stopped = true
+        };
+        let stopped = false;
+        try {
+            await new src_1.DevServer('fail-on-construct', (0, src_1.promised)(() => Promise.resolve(new src_1.Service({
+                name: 'fail-on-construct',
+                start: async () => Promise.resolve(),
+                stop: async () => Promise.resolve(),
+            }))
+                .then(() => Promise.reject(error)))).start();
+            (0, assert_1.fail)('should have thrown exception');
+        }
+        catch (e) {
+            return (0, globals_1.expect)(stopped)
+                .toStrictEqual(true);
+        }
+    });
+});

package/dist/__tests__/event-proxy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/event-proxy.test.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const src_1 = require("../src");
+(0, globals_1.describe)("the event proxy", () => {
+    (0, globals_1.test)("handles an implementation error gracefully", async () => {
+        let sns;
+        let topic;
+        let invoked = false;
+        const handler = {
+            name: 'fail',
+            handler: async () => {
+                invoked = true;
+                return Promise.reject();
+            },
+            matcher: () => true,
+        };
+        const devServer = await new src_1.DevServer('events-proxy', (0, src_1.allOf)([
+            new src_1.Service({
+                name: 'config-capture',
+                start: (config) => {
+                    sns = config.sns;
+                    topic = config.eventsProxy.topic;
+                    return Promise.resolve();
+                },
+                stop: () => Promise.resolve(),
+            }),
+            (0, src_1.eventsProxy)('test', {
+                handlers: [handler]
+            }),
+        ])).start();
+        return (0, globals_1.expect)(sns.publish(topic, '{}')
+            .then(() => new Promise(resolve => setTimeout(resolve, 200)))
+            .then(() => invoked)
+            .finally(() => devServer.stop())).resolves.toStrictEqual(true);
+    });
+});

package/dist/__tests__/lambda-http-proxy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/lambda-http-proxy.test.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const src_1 = require("../src");
+const lambda_http_proxy_1 = require("../src/lambda-http-proxy");
+const axios_1 = __importDefault(require("axios"));
+const mappers_1 = require("../src/mappers");
+(0, globals_1.describe)("the lambda http proxy", () => {
+    const payloadVersionV2Mapper = (0, mappers_1.v2)().mapper;
+    (0, globals_1.it)("invokes the handler with the heaviest route", async () => {
+        let endpoint;
+        const tested = await new src_1.DevServer('lambda-http-proxy', (0, lambda_http_proxy_1.newLambdaHttpProxy)('service', {
+            settings: { protocol: 'http:', host: '127.0.0.1', port: undefined },
+            routes: [
+                { method: /GET/, path: /\/a\/.*\/b\/.*\/c/, weight: 3, handler: () => Promise.resolve({ statusCode: 200, body: '' }) },
+                { method: /GET/, path: /\/a\/.*\/b\/.*/, weight: 2, handler: () => Promise.resolve({ statusCode: 400, body: '' }) },
+                { method: /GET/, path: /\/a\/.*/, weight: 2, handler: () => Promise.resolve({ statusCode: 400, body: '' }) },
+            ],
+            mapper: payloadVersionV2Mapper,
+        }, async (url) => { endpoint = url; })).start();
+        return (0, globals_1.expect)(axios_1.default.get(`${endpoint}a/1/b/2/c`)
+            .then(r => r.status)
+            .finally(async () => tested.stop()))
+            .resolves
+            .toEqual(200);
+    });
+    (0, globals_1.it)("supports a single 'catch all' route", async () => {
+        let endpoint;
+        const tested = await new src_1.DevServer('lambda-http-proxy', (0, lambda_http_proxy_1.newLambdaHttpProxy)('service', {
+            settings: { protocol: 'http:', host: '127.0.0.1', port: undefined },
+            routes: [
+                { method: /.*/, path: /.*/, weight: 0, handler: () => Promise.resolve({ statusCode: 200, body: 'handled!' }) },
+            ],
+            mapper: payloadVersionV2Mapper,
+        }, async (url) => { endpoint = url; })).start();
+        return (0, globals_1.expect)(axios_1.default.post(`${endpoint}find-me`)
+            .then(r => ({ status: r.status, body: r.data }))
+            .finally(async () => tested.stop()))
+            .resolves
+            .toStrictEqual({ status: 200, body: 'handled!' });
+    });
+    (0, globals_1.it)("returns unauthorized when the authorizer rejects", async () => {
+        let endpoint;
+        const tested = await new src_1.DevServer('lambda-http-proxy', (0, lambda_http_proxy_1.newLambdaHttpProxy)('service', {
+            settings: { protocol: 'http:', host: '127.0.0.1', port: undefined },
+            routes: [
+                { method: /.*/, path: /.*/, weight: 0, handler: () => Promise.resolve({ statusCode: 200, body: 'handled!' }), authorizer: () => Promise.reject(lambda_http_proxy_1.UNAUTHORIZED) },
+            ],
+            mapper: payloadVersionV2Mapper,
+        }, async (url) => { endpoint = url; })).start();
+        return (0, globals_1.expect)(axios_1.default.get(endpoint, { validateStatus: () => true })
+            .then(r => r.status)
+            .finally(async () => tested.stop()))
+            .resolves
+            .toEqual(401);
+    });
+    (0, globals_1.it)("triggers the fallback handler when no route matches a request", async () => {
+        let endpoint;
+        const tested = await new src_1.DevServer('lambda-http-proxy', (0, lambda_http_proxy_1.newLambdaHttpProxy)('service', {
+            settings: { protocol: 'http:', host: '127.0.0.1', port: undefined },
+            routes: [
+                { method: /.*/, path: /\a/, weight: 0, handler: () => Promise.resolve({ statusCode: 200, body: 'handled!' }) },
+            ],
+            mapper: payloadVersionV2Mapper,
+        }, async (url) => { endpoint = url; })).start();
+        return (0, globals_1.expect)(axios_1.default.get(`${endpoint}b`, { validateStatus: () => true })
+            .then(r => ({ status: r.status, body: r.data }))
+            .finally(async () => tested.stop()))
+            .resolves
+            .toStrictEqual({ status: 404, body: 'no route found to handle GET to /b' });
+    });
+    (0, globals_1.it)("handler has access to the context", async () => {
+        const expectedContext = 'hello world!';
+        let endpoint;
+        const tested = await new src_1.DevServer('lambda-http-proxy', (0, lambda_http_proxy_1.newLambdaHttpProxy)('service', {
+            settings: { protocol: 'http:', host: '127.0.0.1', port: undefined },
+            routes: [
+                {
+                    method: /.*/,
+                    path: /\a/,
+                    weight: 0,
+                    handler: (_, context) => Promise.resolve({ statusCode: 200, body: context })
+                },
+            ],
+            context: () => expectedContext,
+            mapper: payloadVersionV2Mapper,
+        }, async (url) => { endpoint = url; })).start();
+        return (0, globals_1.expect)(axios_1.default.get(`${endpoint}a`)
+            .then(r => r.data)
+            .finally(async () => tested.stop()))
+            .resolves
+            .toStrictEqual(expectedContext);
+    });
+    (0, globals_1.it)("can set cookies", async () => {
+        let endpoint;
+        const handler = async (event, context) => {
+            return {
+                statusCode: 200,
+                cookies: ['galletita=criollita'],
+            };
+        };
+        const tested = await new src_1.DevServer('lambda-http-proxy', (0, lambda_http_proxy_1.newLambdaHttpProxy)('service', {
+            settings: { protocol: 'http:', host: '127.0.0.1', port: undefined },
+            routes: [
+                { method: /GET/, path: /\/a/, weight: 0, handler: handler },
+            ],
+            mapper: payloadVersionV2Mapper,
+        }, async (url) => { endpoint = url; })).start();
+        return (0, globals_1.expect)(axios_1.default.get(`${endpoint}a`)
+            .then(r => r.headers["set-cookie"])
+            .finally(async () => tested.stop())).resolves.toContain('galletita=criollita');
+    });
+    (0, globals_1.it)("can read cookies", async () => {
+        let endpoint;
+        const handler = async (event, context) => {
+            return {
+                statusCode: 200,
+                body: event["headers"].cookie,
+            };
+        };
+        const tested = await new src_1.DevServer('lambda-http-proxy', (0, lambda_http_proxy_1.newLambdaHttpProxy)('service', {
+            settings: { protocol: 'http:', host: '127.0.0.1', port: undefined },
+            routes: [
+                { method: /GET/, path: /\/a/, weight: 0, handler: handler },
+            ],
+            mapper: payloadVersionV2Mapper,
+        }, async (url) => { endpoint = url; })).start();
+        return (0, globals_1.expect)(axios_1.default.get(`${endpoint}a`, { headers: { cookie: ['galletita=criollita'] } })
+            .then(r => r.data)
+            .finally(async () => tested.stop())).resolves.toContain('galletita=criollita');
+    });
+});

package/dist/src/assert.d.ts

@@ -0,0 +1 @@
+export declare function assertNotUndefined<T>(value: T | undefined, message?: string): T;

package/dist/src/assert.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNotUndefined = void 0;
+function assertNotUndefined(value, message = 'value is undefined') {
+    if (value === undefined)
+        throw new Error(message);
+    return value;
+}
+exports.assertNotUndefined = assertNotUndefined;

package/dist/src/cloudformation-dynamodb-table.d.ts

@@ -0,0 +1,13 @@
+import { Callback, Service } from './services';
+export declare const newDynamoDbTableFromCloudFormationTemplate: (name: string, config: DynamoDbTableCloudFormationConfig, callback?: Callback<string>) => Service<string>;
+type DynamoDbTableCloudFormationConfig = {
+    template: (name: string) => string;
+    resource: string;
+    tableName: (name: string) => string;
+    throughput: Throughput;
+};
+type Throughput = {
+    ReadCapacityUnits: number;
+    WriteCapacityUnits: number;
+};
+export {};

package/dist/src/cloudformation-dynamodb-table.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newDynamoDbTableFromCloudFormationTemplate = void 0;
+const services_1 = require("./services");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const js_yaml_cloudformation_schema_1 = require("js-yaml-cloudformation-schema");
+const js_yaml_1 = require("js-yaml");
+const fs_1 = require("fs");
+const logging_1 = require("@yopdev/logging");
+const dynamodb_1 = require("./dynamodb");
+const newDynamoDbTableFromCloudFormationTemplate = (name, config, callback) => new services_1.Service(new DynamoDbTableCloudFormation(name, config.template, config.resource, config.tableName, config.throughput), callback);
+exports.newDynamoDbTableFromCloudFormationTemplate = newDynamoDbTableFromCloudFormationTemplate;
+class DynamoDbTableCloudFormation {
+    constructor(name, template, resource, tableName, throughput) {
+        this.name = name;
+        this.template = template;
+        this.resource = resource;
+        this.throughput = throughput;
+        this.start = (config) => Promise.resolve(this.parseTableDefinition(this.template(this.name))
+            .then((definition) => definition[this.resource].Properties)
+            .then((resource) => this.createTableCommand(resource, this.throughput)
+            .then((command) => (0, dynamodb_1.newDynamoDbTable)(this.name, {
+            command: command,
+            ttlAttribute: resource.TimeToLiveSpecification?.AttributeName,
+        }))))
+            .tap(() => this.LOGGER.info('configured'))
+            .then((service) => service.start(config));
+        this.stop = () => Promise.resolve();
+        this.createTableCommand = async (definition, throughput) => new client_dynamodb_1.CreateTableCommand({
+            TableName: definition.TableName ?? this.tableName(this.name),
+            KeySchema: definition.KeySchema,
+            AttributeDefinitions: definition.AttributeDefinitions,
+            GlobalSecondaryIndexes: definition.GlobalSecondaryIndexes?.map((gsi) => ({
+                ...gsi,
+                ProvisionedThroughput: throughput,
+            })),
+            ProvisionedThroughput: throughput,
+        });
+        this.parseTableDefinition = async (path) => (0, js_yaml_1.load)((0, fs_1.readFileSync)(path).toString(), {
+            schema: js_yaml_cloudformation_schema_1.CLOUDFORMATION_SCHEMA,
+        }).Resources;
+        this.LOGGER = logging_1.LoggerFactory.create(`CFN:DYNAMO[${name}]`);
+        this.tableName = tableName ? tableName : (name) => { throw new Error(`table name not specified on ${name}`); };
+    }
+}

package/dist/src/cloudformation-event-proxy.d.ts

@@ -0,0 +1,13 @@
+import { SQSRecord } from 'aws-lambda';
+import { CloudFormationSetupConfig } from './cloudformation';
+import { EventHandler } from './event-proxy';
+import { DevServerConfig } from './config';
+import { Startable } from './services';
+import { Message } from '@aws-sdk/client-sqs';
+export declare const snsEventsFromCloudFormationTemplate: (name: string, config: CloudFormationEventsProxyConfig) => Startable<EventHandler[]>;
+type CloudFormationEventsProxyConfig = {
+    topic?: string;
+    mapper?: (message: Message) => SQSRecord;
+    prepare?: (config: DevServerConfig) => Promise<void>;
+} & CloudFormationSetupConfig;
+export {};

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snsEventsFromCloudFormationTemplate = void 0;
+const cloudformation_1 = require("./cloudformation");
+const snsEventsFromCloudFormationTemplate = (name, config) => new CloudFormationEventsProxy(name, config);
+exports.snsEventsFromCloudFormationTemplate = snsEventsFromCloudFormationTemplate;
+class CloudFormationEventsProxy extends cloudformation_1.CloudFormationSetup {
+    constructor(name, config) {
+        super(name, (event) => event.Type === 'SNS', async (event, handler) => ({
+            name: handler.name,
+            handler: handler,
+            matcher: (_, attributes) => {
+                const required = Object.entries(event.Properties.FilterPolicy ?? []).flatMap((entry) => entry[1].map((value) => value + entry[0]));
+                if (required.length == 0)
+                    return true;
+                const actual = Object.entries(attributes).flatMap((entry) => entry[1].Value + entry[0]);
+                return required.filter((e) => actual.includes(e)).length > 0;
+            },
+        }), 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

@@ -0,0 +1,14 @@
+import { CloudFormationSetupConfig } from './cloudformation';
+import { DevServerConfig } from './config';
+import { HttpSettings } from './http-server';
+import { Authorizer, Route } from './lambda-http-proxy';
+import { Callback, Service, Startable } from './services';
+import { LambdaPayloadVersion } from './mappers';
+export declare const newLambdaProxyFromCloudFormationTemplate: <Context, AuthorizerContext, Event_1, HandlerResponse>(name: string, settings: HttpSettings, payloadVersion: 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?: () => Context;
+} & CloudFormationSetupConfig;
+export {};

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newLambdaProxyFromCloudFormationTemplate = void 0;
+const cloudformation_1 = require("./cloudformation");
+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, payloadVersion, config, callback) => new CloudFormationLambdaProxy(name, settings, config.extraRoutes, payloadVersion, config, callback);
+exports.newLambdaProxyFromCloudFormationTemplate = newLambdaProxyFromCloudFormationTemplate;
+class CloudFormationLambdaProxy extends cloudformation_1.CloudFormationSetup {
+    constructor(name, settings, extraRoutes, payloadVersion, config, callback) {
+        super(name, (event) => event.Type === 'HttpApi', async (event, handler) => Promise.resolve(this.pathWithCapturingGroups(event.Properties.Path)).then((pathWithCapturingGroups) => ({
+            method: new RegExp(this.method(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.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),
+            mapper: this.mapper,
+        }, 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]).replaceAll("+", "")}>.*)`), source);
+        this.normalizeCaptureGroupName = (original) => (original === 'proxy+' ? PROXY_PATH_PARAM : original);
+        this.pathParameterCapture = (pathWithCapturingGroups, handler, context) => async (event) => {
+            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.method = (cloudFormationValue) => {
+            switch (cloudFormationValue) {
+                case 'ANY':
+                    return '.*';
+                case 'HEAD':
+                case 'OPTIONS':
+                case 'GET':
+                case 'POST':
+                case 'PUT':
+                case 'DELETE':
+                case 'PATCH':
+                    return cloudFormationValue;
+                default:
+                    throw new Error(`unsupported method ${cloudFormationValue}`);
+            }
+        };
+        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/cloudformation.d.ts

@@ -0,0 +1,28 @@
+import { DevServerConfig } from './config';
+import { Startable } from './services';
+export declare abstract class CloudFormationSetup<P, H, R, F> implements Startable<F> {
+    readonly name: string;
+    private readonly eventFilter;
+    private readonly handlerResolver;
+    private readonly beforeStart;
+    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, 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;
+}
+export type CloudFormationSetupConfig = {
+    template: (name: string) => string;
+    handlers: (name: string) => string;
+    handlerNameResolver: (name: string) => string;
+};
+type Event<P> = {
+    Type: string;
+    Properties: P;
+};
+export {};

package/dist/src/cloudformation.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudFormationSetup = void 0;
+const js_yaml_cloudformation_schema_1 = require("js-yaml-cloudformation-schema");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const js_yaml_1 = require("js-yaml");
+const logging_1 = require("@yopdev/logging");
+class CloudFormationSetup {
+    constructor(name, eventFilter, handlerResolver, beforeStart, config) {
+        this.name = name;
+        this.eventFilter = eventFilter;
+        this.handlerResolver = handlerResolver;
+        this.beforeStart = beforeStart;
+        this.start = async (config) => (this.beforeStart || Promise.resolve)(config)
+            .then(this.resolvedHandlers)
+            .then(async (routes) => this.afterStart(this.name, config, routes));
+        this.resolvedHandlers = async () => {
+            const template = this.template(this.name);
+            this.LOGGER.info('parsing %s', template);
+            const definition = this.parseApiEvents(template);
+            const functions = this.handlers(this.name);
+            const routes = Object.values(definition)
+                .filter((resource) => resource.Type === 'AWS::Serverless::Function')
+                .filter((resource) => resource.Properties.Events)
+                .flatMap((resource) => Object.values(resource.Properties.Events).map((event) => ({
+                ...event,
+                Handler: resource.Properties.Handler,
+            })))
+                .filter(this.eventFilter)
+                .map(async (event) => import(functions).then(async (handlers) => Promise.resolve(handlers[this.handlerNameResolver(event.Handler)])
+                .then(async (handler) => (handler !== undefined) ?
+                this.handlerResolver(event, handler) :
+                Promise.reject(new Error(`function ${event.Handler} defined in ${(0, path_1.resolve)(template)} not found in ${(0, path_1.resolve)(functions)}`)))
+                .then((handler) => {
+                this.LOGGER.info(this.logHandler(handler));
+                return handler;
+            })));
+            return Promise.all(routes);
+        };
+        this.parseApiEvents = (path) => (0, js_yaml_1.load)((0, fs_1.readFileSync)(path).toString(), {
+            schema: js_yaml_cloudformation_schema_1.CLOUDFORMATION_SCHEMA,
+        }).Resources;
+        this.LOGGER = logging_1.LoggerFactory.create(`CFN:FUNCTION[${name}]`);
+        this.template = config.template;
+        this.handlers = config.handlers;
+        this.handlerNameResolver = config.handlerNameResolver;
+    }
+}
+exports.CloudFormationSetup = CloudFormationSetup;