@yopdev/dev-server 3.0.1 → 3.0.2-RC1

package/src/scheduled-tasks.ts

@@ -0,0 +1,31 @@
+import { Logger, LoggerFactory } from '@yopdev/logging';
+import { clearInterval } from 'timers';
+import { Lifecycle, Service } from './services';
+
+export const newScheduledTasks = (
+    name: string,
+    schedules: Rate[],
+) => new Service(new ScheduledTasks(name, schedules))
+
+class ScheduledTasks implements Lifecycle<void> {
+    private LOGGER: Logger
+    
+    constructor(readonly name: string, private readonly schedules: Rate[]) {
+        this.LOGGER = LoggerFactory.create(`SCHEDULER[${name}]`)
+        this.LOGGER.info('registered %i scheduled tasks', schedules.length);
+    }
+
+    intervals: NodeJS.Timeout[] = [];
+
+    start = async () => Promise.resolve(
+        this.schedules.forEach((schedule) => this.intervals.push(setInterval(schedule.task, schedule.frequency * 1000)))
+    )
+        .then(() => undefined)
+
+    stop = async () => Promise.resolve(this.intervals.forEach((interval) => clearInterval(interval)))
+}
+
+export type Rate = {
+    frequency: number;
+    task: () => Promise<unknown>;
+}

package/src/services.ts

@@ -0,0 +1,46 @@
+import { Logger, LoggerFactory } from "@yopdev/logging";
+import { DevServerConfig } from "./config";
+
+export interface Lifecycle<I> extends Startable<I>, Stoppable {
+    name: string
+}
+
+export interface Startable<T> {
+    start(config: DevServerConfig): Promise<T>
+}
+export interface Stoppable {
+    stop(): Promise<void>;
+}
+
+export type Callback<I> = (instance: I) => Promise<void>
+
+export class Service<I> implements Lifecycle<I> {
+    private readonly DEFAULT_CALLBACK: Callback<unknown> = () => Promise.resolve(this.LOGGER.debug('no callback'));
+
+    readonly name: string
+    readonly start: (config: DevServerConfig) => Promise<I>
+    readonly stop: () => Promise<void>
+    private doStop: () => Promise<void>
+    private readonly LOGGER: Logger
+
+    constructor(service: Lifecycle<I>, private readonly callback?: Callback<I>) {
+        this.name = service.name
+        this.LOGGER = LoggerFactory.create(`SERVICE[${this.name}]`)
+        const stop = async () => service.stop()
+        this.start = (config: DevServerConfig) => service.start(config)
+            .catch((error) => stop()
+                .then(() => this.doStop = () => Promise.resolve(this.LOGGER.error(error, 'failed')))
+                .then(() => Promise.reject(error))
+            )
+            .then((started) => this
+                .callbackOrDefault(started)
+                .then(() => this.LOGGER.info('started'))
+                .then(() => started)
+            )
+        this.doStop = () => stop()
+            .then(() => this.LOGGER.info('stopped'))
+        this.stop = () => this.doStop();
+    }
+
+    private callbackOrDefault = async (instance: I) => (this.callback ?? this.DEFAULT_CALLBACK)(instance)
+}

package/src/sns-http-proxy.ts

@@ -0,0 +1,109 @@
+import { Logger, LoggerFactory } from "@yopdev/logging";
+import { HttpServer, HttpSettings } from "./http-server";
+import { Sns } from "./sns";
+import { IncomingMessage, ServerResponse } from "http";
+import { MessageAttributeValue } from "@aws-sdk/client-sns";
+import { internalServerError, writeResponse } from "./responses";
+import { Lifecycle, Service, Callback } from "./services";
+import { DevServerConfig } from "./config";
+import { assertNotUndefined } from "./assert";
+
+export const newSnsHttpProxy = (
+    name: string,
+    config: {
+        settings: HttpSettings,
+        method: string,
+        subject?: string,
+        topic?: string,
+    },
+    callback?: Callback<string>,
+) => new Service(new SnsHttpProxy(name, config.settings, config.method, config.subject, config.topic), callback)
+
+export class SnsHttpProxy implements Lifecycle<string> {
+    private LOGGER: Logger
+    private server: HttpServer
+    private config: {
+        topic: string
+        sns: Sns
+    } | undefined
+
+    constructor(
+        readonly name: string,
+        private readonly settings: HttpSettings,
+        private readonly method: string,
+        private readonly subject?: string,
+        private readonly topic?: string,
+    ) {
+        this.server = new HttpServer(
+            this.name,
+            this.settings,
+            this.handler(this.method, this.subject)
+        )
+        this.LOGGER = LoggerFactory.create(`HTTP->SNS[${name}]`)
+        this.LOGGER.info(
+            'forwarding %s %s events to %s',
+            subject ? `events with ${subject} subject` : 'all',
+            method,
+            topic ?? 'the event bus',
+        );
+    }
+
+    start = (config: DevServerConfig) => Promise.resolve(this.server)
+        .then(server => server.start())
+        .tap(() => {
+            this.config = {
+                topic: this.topic ?? config.eventsProxy.topic.arn,
+                sns: config.sns
+            }
+        })
+        .then((endpoint) => endpoint)
+
+    stop = () => this.onlyWhenStarted(this.server).stop()
+        .then(() => this.LOGGER.debug('stopped'))
+
+    handler = (method: string, subject?: string) =>
+        (request: IncomingMessage, body: string, response: ServerResponse) =>
+            Promise.resolve((assertNotUndefined(this.config)))
+                .then((config) =>
+                    config.sns
+                        .publish(
+                            { arn: config.topic },
+                            this.extractMessage(method, request, body),
+                            subject,
+                            this.extractMessageAttributes(request)
+                        )
+                        .then(() => writeResponse(response, 200, ''))
+                        .catch((e) => {
+                            this.LOGGER.error(e, 'request failed to execute');
+                            internalServerError(response, e.body);
+                        })
+                )
+
+    extractMessage = (method: string, request: IncomingMessage, body: string) => {
+        switch (method) {
+            case 'GET':
+                return this.extractQueryString(request) || '';
+            case 'POST':
+                return body;
+            default:
+                throw new Error();
+        }
+    }
+
+    private onlyWhenStarted = (server: HttpServer | undefined) => assertNotUndefined(server, 'not started')
+
+    private extractQueryString = (request: IncomingMessage) => request.url?.substring(request.url?.indexOf('?') + 1)
+
+    private extractMessageAttributes = (request: IncomingMessage): Record<string, MessageAttributeValue> => {
+        const initialValue = {};
+        return Object.keys(request.headers).reduce((obj, item) => {
+            return {
+                ...obj,
+                [item]: {
+                    DataType: 'String',
+                    StringValue: request.headers[item],
+                },
+            };
+        }, initialValue);
+    }
+}

package/src/sns.ts

@@ -0,0 +1,49 @@
+import { CreateTopicCommand, MessageAttributeValue, PublishCommand, SNSClient, SubscribeCommand } from "@aws-sdk/client-sns";
+import { AwsConfig } from "./config";
+import { assertNotUndefined } from "./assert";
+import { LoggerFactory } from "@yopdev/logging";
+
+const LOGGER = LoggerFactory.create('SNS')
+export class Sns {
+    readonly client: SNSClient;
+
+    constructor(aws: AwsConfig) {
+        this.client = new SNSClient(aws);
+    }
+
+    createTopic = async (topic: string) => this.client
+        .send(
+            new CreateTopicCommand({
+                Name: topic,
+            }),
+        )
+        .then((o) => assertNotUndefined(o.TopicArn, 'TopicArn is not present'))
+        .tap((arn) => LOGGER.debug('topic %o created', arn))
+
+    createSubscription = async (topic: { arn: string }, queue: { arn: string }) => this.client
+        .send(
+            new SubscribeCommand({
+                TopicArn: topic.arn,
+                Protocol: 'sqs',
+                Endpoint: queue.arn,
+            }),
+        )
+        .then(() => LOGGER.debug('subscription %s->%s created', topic.arn, queue.arn))
+
+    publish = async (
+        topic: { arn: string },
+        body: string,
+        subject?: string,
+        attributes?: Record<string, MessageAttributeValue>,
+    ) => this.client
+        .send(
+            new PublishCommand({
+                TopicArn: topic.arn,
+                Message: body,
+                MessageAttributes: attributes,
+                Subject: subject,
+            }),
+        )
+        .then(() => LOGGER.trace('published %s[%s]', topic.arn, subject))
+        .then()
+}

package/src/sqs.ts

@@ -0,0 +1,46 @@
+import { CreateQueueCommand, GetQueueAttributesCommand, SQSClient } from "@aws-sdk/client-sqs";
+import { assertNotUndefined } from "./assert";
+import { AwsConfig } from "./config";
+import { LoggerFactory } from "@yopdev/logging";
+
+const QUEUE_NAME_ATTRIBUTE_NAME = 'QueueArn'
+const LOGGER = LoggerFactory.create('SQS')
+export class Sqs {
+    readonly client: SQSClient;
+
+    constructor(config: AwsConfig) {
+        this.client = new SQSClient(config)
+    }
+
+    createStandardQueue = async (name: string) => this.createNamedQueue(name, false);
+    createFifoQueue = async (name: string) => this.createNamedQueue(name, true);
+
+    private createNamedQueue = async (name: string, fifo: boolean): Promise<Queue> => this.client
+        .send(
+            new CreateQueueCommand({
+                QueueName: fifo ? `${name}.fifo` : name,
+                Attributes: {
+                    FifoQueue: fifo ? 'true' : undefined,
+                }
+            }),
+        )
+        .then(
+            (create) => this.client
+                .send(
+                    new GetQueueAttributesCommand({
+                        QueueUrl: create.QueueUrl,
+                        AttributeNames: [QUEUE_NAME_ATTRIBUTE_NAME],
+                    }),
+                )
+                .then((attributes) => ({
+                    url: assertNotUndefined(create.QueueUrl),
+                    arn: assertNotUndefined(attributes.Attributes)[QUEUE_NAME_ATTRIBUTE_NAME]!,
+                }))
+        )
+        .tap((queue) => LOGGER.debug('created %s', queue.arn))
+}
+
+export type Queue = {
+    arn: string;
+    url: string;
+};

package/src/stoppable.ts

@@ -0,0 +1,10 @@
+import { Consumer } from "sqs-consumer";
+
+export const stopConsumer = async (queueWaitTimeSecs: number, target?: Consumer): Promise<void> => {
+    if (target) {
+        target.stop();
+        return new Promise((resolve) => {
+            setTimeout(resolve, queueWaitTimeSecs * 1000 + 1);
+        });
+    } else { return Promise.resolve() }
+}

package/src/tunnel.ts

@@ -0,0 +1,32 @@
+import { Lifecycle, Service } from './services';
+import { Logger, LoggerFactory } from '@yopdev/logging';
+import * as ngrok from '@ngrok/ngrok';
+import { assertNotUndefined } from './assert';
+
+export const terminate = async () => ngrok.kill();
+export const newTunnel = (config: { name: string; port: number; fixed?: { name: string; token: string } }) =>
+    new Service(new Tunnel(config.name, config.port, config.fixed));
+class Tunnel implements Lifecycle<string> {
+    private logger: Logger;
+    constructor(
+        readonly name: string,
+        private readonly port: number,
+        private readonly domain?: {
+            name: string,
+            token: string,
+        },
+    ) {
+        this.logger = LoggerFactory.create(`TUNNEL[${name}]`);
+    }
+    start = async () =>
+        ngrok
+            .forward({
+                proto: 'http',
+                domain: this.domain?.name,
+                addr: this.port,
+                authtoken: this.domain?.token,
+            })
+            .then((listener) => assertNotUndefined(listener.url()))
+            .tap((url) => this.logger.debug(url))
+    stop = async () => ngrok.disconnect();
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "target": "ES2021",
+    "moduleResolution": "NodeNext",
+    "declaration": true,
+    "outDir": "./dist"
+  }
+}

package/dist/src/assert.d.ts

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

package/dist/src/assert.js

@@ -1,9 +0,0 @@
-"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

@@ -1,13 +0,0 @@
-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

@@ -1,45 +0,0 @@
-"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

@@ -1,13 +0,0 @@
-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

@@ -1,25 +0,0 @@
-"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

@@ -1,14 +0,0 @@
-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

@@ -1,62 +0,0 @@
-"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

@@ -1,28 +0,0 @@
-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

@@ -1,50 +0,0 @@
-"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;

package/dist/src/config.d.ts

@@ -1,31 +0,0 @@
-import { Sqs } from "./sqs";
-import { Sns } from "./sns";
-import { DynamoDb } from "./dynamodb";
-import { StartedNetwork } from "testcontainers";
-import { S3 } from "./s3";
-export type Config = {
-    boundServicesPort?: number;
-    localStackDockerImage?: string;
-    localStateBindMount?: string;
-};
-export type AwsConfig = {
-    region: string;
-    endpoint: string;
-    credentials: {
-        accessKeyId: string;
-        secretAccessKey: string;
-    };
-};
-export type DevServerConfig = {
-    raw: AwsConfig;
-    network: StartedNetwork;
-    sqs: Sqs;
-    sns: Sns;
-    s3: S3;
-    dynamo: DynamoDb;
-    eventsProxy: {
-        topic: {
-            arn: string;
-        };
-    };
-};

package/dist/src/config.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });