@yopdev/dev-server 1.4.1-alpha.0 → 1.4.5

package/dist/src/assert.js

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

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,24 @@
+"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, (_name, _config, routes) => routes, config);
+    }
+    logHandler(handler) {
+        return `detected sns handler ${handler.name}`;
+    }
+}

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

@@ -0,0 +1,12 @@
+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';
+export declare const newLambdaProxyFromCloudFormationTemplate: (name: string, settings: HttpSettings, config: CloudFormationLambdaProxyConfig, callback: Callback<string>) => Startable<Service<string>>;
+type CloudFormationLambdaProxyConfig = {
+    authorizer?: (config: DevServerConfig) => Authorizer | undefined;
+    extraRoutes: Route[];
+    prepare?: (config: DevServerConfig) => Promise<void>;
+} & CloudFormationSetupConfig;
+export {};

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

@@ -0,0 +1,42 @@
+"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, config, callback) => new CloudFormationLambdaProxy(name, settings, config.extraRoutes, config, callback);
+exports.newLambdaProxyFromCloudFormationTemplate = newLambdaProxyFromCloudFormationTemplate;
+class CloudFormationLambdaProxy extends cloudformation_1.CloudFormationSetup {
+    constructor(name, settings, extraRoutes, 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}?$`),
+            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);
+        this.settings = settings;
+        this.extraRoutes = extraRoutes;
+        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) => {
+            const pathParameters = pathWithCapturingGroups.exec(event.path)?.groups;
+            event.pathParameters = Object.fromEntries((Object.entries(pathParameters ?? {}))
+                .map(([k, v]) => [k, decodeURIComponent(v)]));
+            return handler(event);
+        };
+    }
+    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 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);
+    start: (config: DevServerConfig) => Promise<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,47 @@
+"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 js_yaml_1 = require("js-yaml");
+const logging_1 = require("@yopdev/logging");
+class CloudFormationSetup {
+    constructor(name, eventFilter, handlerResolver, beforeStart, afterStart, 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));
+        this.resolvedHandlers = async () => {
+            const template = this.template(this.name);
+            this.LOGGER.info('parsing %s', template);
+            const definition = this.parseApiEvents(template);
+            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(this.handlers(this.name)).then(async (handlers) => Promise.resolve(handlers[this.handlerNameResolver(event.Handler)])
+                .then(async (handler) => this.handlerResolver(event, handler))
+                .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

@@ -2,6 +2,7 @@ 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;
@@ -20,6 +21,7 @@ export type DevServerConfig = {
     network: StartedNetwork;
     sqs: Sqs;
     sns: Sns;
+    s3: S3;
     dynamo: DynamoDb;
     eventsProxy: {
         topic: {

package/dist/src/container.d.ts

@@ -0,0 +1,18 @@
+import { BindMount, Environment } from 'testcontainers/build/types';
+import { Callback, Service } from './services';
+import { PortWithOptionalBinding } from 'testcontainers/build/utils/port';
+import { Readable } from 'stream';
+import { WaitStrategy } from 'testcontainers/build/wait-strategies/wait-strategy';
+export declare const newContainer: (name: string, config: {
+    image: string;
+    networkAlias: string;
+    environment?: Environment;
+    bindMounts?: BindMount[];
+    exposedPorts?: PortWithOptionalBinding[];
+    logConsumer?: (stream: Readable) => unknown;
+    startup?: {
+        waitStrategy: WaitStrategy;
+        timeout: number;
+    };
+    endpointBuilder?: (port: number) => string;
+}, callback?: Callback<string>) => Service<string>;

package/dist/src/container.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newContainer = void 0;
+const logging_1 = require("@yopdev/logging");
+const testcontainers_1 = require("testcontainers");
+const services_1 = require("./services");
+const newContainer = (name, config, callback) => new services_1.Service(new Container(name, config.image, config.networkAlias, config.environment, config.bindMounts, config.exposedPorts, config.logConsumer, config.startup, config.endpointBuilder), callback);
+exports.newContainer = newContainer;
+class Container {
+    constructor(name, image, networkAlias, environment, bindMounts, exposedPorts, logConsumer, startup, endpointBuilder) {
+        this.name = name;
+        this.networkAlias = networkAlias;
+        this.start = async (config) => Promise.resolve(this.LOGGER.info('start'))
+            .then(() => this.container
+            .withNetwork(config.network)
+            .withNetworkAliases(this.networkAlias)
+            .start())
+            .then((started) => this.started = started)
+            .then(() => this.endpointBuilder(this.started.getFirstMappedPort()))
+            .tap((url) => this.LOGGER.debug(url));
+        this.stop = async () => this.started.stop().then(() => undefined);
+        this.LOGGER = logging_1.LoggerFactory.create(`CONTAINER[${name}]`);
+        const generic = new testcontainers_1.GenericContainer(image);
+        const withEnvironment = environment ? generic.withEnvironment(environment) : generic;
+        const withBindMounts = bindMounts ? withEnvironment.withBindMounts(bindMounts) : withEnvironment;
+        const withExposedPorts = exposedPorts ? withBindMounts.withExposedPorts(...exposedPorts) : withBindMounts;
+        const withLogConsumer = logConsumer ? withExposedPorts.withLogConsumer(logConsumer) : withExposedPorts;
+        this.container = startup ? withLogConsumer.withWaitStrategy(startup.waitStrategy).withStartupTimeout(startup.timeout) : withLogConsumer;
+        this.networkAlias = networkAlias;
+        this.endpointBuilder = endpointBuilder ?? ((port) => `http://localhost:${port}`);
+    }
+}
+;

package/dist/src/deferred.js

@@ -1,109 +1,44 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.promised = exports.lazy = void 0;
-var crypto_1 = require("crypto");
-var services_1 = require("./services");
-var logging_1 = require("@yopdev/logging");
-var lazy = function (lifecycle) { return new services_1.Service(new Lazy(lifecycle)); };
+const crypto_1 = require("crypto");
+const services_1 = require("./services");
+const logging_1 = require("@yopdev/logging");
+const lazy = (lifecycle) => new services_1.Service(new Lazy(lifecycle));
 exports.lazy = lazy;
-var promised = function (lifecycle) { return new services_1.Service(new Promised(lifecycle)); };
+const promised = (lifecycle) => new services_1.Service(new Promised(lifecycle));
 exports.promised = promised;
-var Lazy = /** @class */ (function () {
-    function Lazy(configurable) {
-        var _this = this;
+class Lazy {
+    constructor(configurable) {
         this.configurable = configurable;
-        this.stop = function () { return __awaiter(_this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.withStartedOr(function (s) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
-                        return [2 /*return*/, s.stop()];
-                    }); }); }, function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
-                        return [2 /*return*/, Promise.reject(new Error('not started'))];
-                    }); }); })];
-            });
-        }); };
+        this.stop = async () => this.withStartedOr(async (s) => s.stop(), async () => Promise.reject(new Error('not started')));
         this.started = undefined;
         this.name = (0, crypto_1.randomUUID)();
-        this.LOGGER = logging_1.LoggerFactory.create("LAZY[".concat(this.name, "]"));
+        this.LOGGER = logging_1.LoggerFactory.create(`LAZY[${this.name}]`);
+    }
+    async start(config) {
+        const local = this.configurable(config);
+        this.started = local;
+        this.LOGGER.info('DISCOVERY:%s', local.name);
+        return local.start(config);
     }
-    Lazy.prototype.start = function (config) {
-        return __awaiter(this, void 0, void 0, function () {
-            var local;
-            return __generator(this, function (_a) {
-                local = this.configurable(config);
-                this.started = local;
-                this.LOGGER.info('DISCOVERY:%s', local.name);
-                return [2 /*return*/, local.start(config)];
-            });
-        });
-    };
-    Lazy.prototype.withStartedOr = function (task, fallback) {
-        var local = this.started;
+    withStartedOr(task, fallback) {
+        const local = this.started;
         if (local !== undefined)
             task(local);
         else
             fallback();
-    };
-    return Lazy;
-}());
-var Promised = /** @class */ (function () {
-    function Promised(configurable) {
-        var _this = this;
+    }
+}
+class Promised {
+    constructor(configurable) {
         this.configurable = configurable;
-        this.start = function (config) { return __awaiter(_this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.configurable(config)
-                        .then(function (service) { return _this.service = service; })
-                        .then(function (service) { return _this.LOGGER.info('DISCOVERY:%s', service.name); })
-                        .then(function () { return _this.service.start(config); })];
-            });
-        }); };
-        this.stop = function () { return __awaiter(_this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, Promise.resolve(this.LOGGER.info('stopped'))
-                        .then(function () { return _this.service.stop(); })];
-            });
-        }); };
+        this.start = async (config) => this.configurable(config)
+            .then((service) => this.service = service)
+            .then((service) => this.LOGGER.info('DISCOVERY:%s', service.name))
+            .then(() => this.service.start(config));
+        this.stop = async () => this.service.stop();
         this.name = (0, crypto_1.randomUUID)();
-        this.LOGGER = logging_1.LoggerFactory.create("PROMISED[".concat(this.name, "]"));
+        this.LOGGER = logging_1.LoggerFactory.create(`PROMISED[${this.name}]`);
     }
-    return Promised;
-}());
+}

package/dist/src/dev-server.js

@@ -1,56 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DevServer = void 0;
-var testcontainers_1 = require("testcontainers");
-var localstack_1 = require("./localstack");
-var sqs_1 = require("./sqs");
-var dynamodb_1 = require("./dynamodb");
-var logging_1 = require("@yopdev/logging");
-var sns_1 = require("./sns");
-var DevServer = /** @class */ (function () {
-    function DevServer(name, service, config) {
-        var _this = this;
+const testcontainers_1 = require("testcontainers");
+const localstack_1 = require("./localstack");
+const sqs_1 = require("./sqs");
+const dynamodb_1 = require("./dynamodb");
+const logging_1 = require("@yopdev/logging");
+const sns_1 = require("./sns");
+const tunnel_1 = require("./tunnel");
+const s3_1 = require("./s3");
+class DevServer {
+    constructor(name, service, config) {
         this.name = name;
         this.service = service;
         this.config = config;
-        this.start = function () {
-            return Promise.resolve(new testcontainers_1.Network(new testcontainers_1.RandomUuid()).start())
-                .then(function (network) { return ({
-                localStack: _this.localStack = new localstack_1.LocalStack(network, _this.config),
-                network: network
-            }); })
-                .then(function (infra) { return infra.localStack.start().then(function (config) { return ({
-                aws: config,
-                network: infra.network
-            }); }); })
-                .then(function (infra) { return Promise
-                .resolve(new sns_1.Sns(infra.aws))
-                .then(function (sns) { return sns
-                .createTopic(_this.eventProxyTopic)
-                .then(function (eventProxyTopicArn) { return ({
-                raw: infra.aws,
-                network: infra.network,
-                sqs: new sqs_1.Sqs(infra.aws),
-                sns: new sns_1.Sns(infra.aws),
-                dynamo: new dynamodb_1.DynamoDb(infra.aws),
-                eventsProxy: {
-                    topic: {
-                        arn: eventProxyTopicArn
-                    }
-                },
-            }); }); }); })
-                .then(function (config) { _this.LOGGER.debug('starting. config is %o', config); return config; })
-                .then(function (aws) { return _this.service.start(aws); })
-                .then(function () { return _this.LOGGER.info('started'); })
-                .then(function () { return _this; });
-        };
-        this.stop = function () { return _this.service.stop()
-            .then(function () { var _a; return (_a = _this.localStack) === null || _a === void 0 ? void 0 : _a.stop(); })
-            .then(function () { return _this.LOGGER.info('stopped'); }); };
-        this.LOGGER = logging_1.LoggerFactory.create("DEVSERVER[".concat(name, "]"));
-        var encodedName = Buffer.from(name).toString('hex').substring(0, 64);
-        this.eventProxyTopic = "EventProxyTopic".concat(encodedName);
+        this.start = () => Promise.resolve(new testcontainers_1.Network(new testcontainers_1.RandomUuid()).start())
+            .then((network) => ({
+            localStack: this.localStack = new localstack_1.LocalStack(network, this.config),
+            network: network
+        }))
+            .then((infra) => infra.localStack.start().then((config) => ({
+            aws: config,
+            network: infra.network
+        })))
+            .then((infra) => Promise
+            .resolve(new sns_1.Sns(infra.aws))
+            .then((sns) => sns
+            .createTopic(this.eventProxyTopic)
+            .then((eventProxyTopicArn) => ({
+            raw: infra.aws,
+            network: infra.network,
+            sqs: new sqs_1.Sqs(infra.aws),
+            sns: new sns_1.Sns(infra.aws),
+            s3: new s3_1.S3(infra.aws),
+            dynamo: new dynamodb_1.DynamoDb(infra.aws),
+            eventsProxy: {
+                topic: {
+                    arn: eventProxyTopicArn
+                }
+            },
+        }))))
+            .tap((config) => this.LOGGER.debug('config is %o', config))
+            .then((aws) => this.service.start(aws))
+            .then(() => this.LOGGER.info('started'))
+            .then(() => this);
+        this.stop = () => this.service.stop()
+            .then(tunnel_1.terminate)
+            .then(() => this.localStack?.stop())
+            .then(() => this.LOGGER.info('stopped'));
+        this.LOGGER = logging_1.LoggerFactory.create(`DEVSERVER[${name}]`);
+        const encodedName = Buffer.from(name).toString('hex').substring(0, 64);
+        this.eventProxyTopic = `EventProxyTopic${encodedName}`;
     }
-    return DevServer;
-}());
+}
 exports.DevServer = DevServer;

package/dist/src/dynamodb.js

@@ -1,85 +1,35 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DynamoDb = exports.newDynamoDbTable = void 0;
-var client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
-var logging_1 = require("@yopdev/logging");
-var services_1 = require("./services");
-var newDynamoDbTable = function (name, config, callback) { return new services_1.Service(new DynamoDbTableCreator(name, config.command), callback); };
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const logging_1 = require("@yopdev/logging");
+const services_1 = require("./services");
+const assert_1 = require("./assert");
+const newDynamoDbTable = (name, config, callback) => new services_1.Service(new DynamoDbTableCreator(name, config.command), callback);
 exports.newDynamoDbTable = newDynamoDbTable;
-var DynamoDbTableCreator = /** @class */ (function () {
-    function DynamoDbTableCreator(name, command) {
-        var _this = this;
+class DynamoDbTableCreator {
+    constructor(name, command) {
         this.name = name;
         this.command = command;
-        this.start = function (config) { return __awaiter(_this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, config.dynamo.createTable(this.command)
-                        .then(function () { return _this.LOGGER.info('created'); })
-                        .then(function () { return _this.name; })];
-            });
-        }); };
-        this.stop = function () { return Promise.resolve()
-            .then(function () { return _this.LOGGER.info('stopped'); }); };
-        this.LOGGER = logging_1.LoggerFactory.create("TABLE[".concat(name, "]"));
+        this.start = async (config) => config.dynamo.createTable(this.command)
+            .tap((output) => this.LOGGER.debug(output))
+            .then(() => this.name);
+        this.stop = () => Promise.resolve();
+        this.LOGGER = logging_1.LoggerFactory.create(`TABLE[${name}]`);
     }
-    return DynamoDbTableCreator;
-}());
-var LOGGER = logging_1.LoggerFactory.create('DYNAMODB');
-var DynamoDb = /** @class */ (function () {
-    function DynamoDb(config) {
-        var _this = this;
-        this.createTable = function (factory) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.client
-                        .send(factory) //
-                        .then(function (table) { var _a; LOGGER.info('table created %s', (_a = table.TableDescription) === null || _a === void 0 ? void 0 : _a.TableName); return table; })
-                        .catch(function (reason) {
-                        LOGGER.error('failed to create table');
-                        if (reason.name !== 'ResourceInUseException')
-                            return Promise.reject(reason);
-                    })];
-            });
-        }); };
+}
+const LOGGER = logging_1.LoggerFactory.create('DYNAMODB');
+class DynamoDb {
+    constructor(config) {
+        this.createTable = async (factory) => this.client
+            .send(factory) //
+            .tap((table) => LOGGER.debug('created %s', (0, assert_1.assertNotUndefined)(table.TableDescription).TableName))
+            .catch((reason) => {
+            LOGGER.error('failed to create table');
+            if (reason.name !== 'ResourceInUseException')
+                return Promise.reject(reason);
+        });
         this.client = new client_dynamodb_1.DynamoDBClient(config);
-        LOGGER.debug('initialized');
     }
-    return DynamoDb;
-}());
+}
 exports.DynamoDb = DynamoDb;

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

@@ -1,12 +1,13 @@
-import { SQSEvent } from 'aws-lambda';
-import { MessageAttributeValue } from '@aws-sdk/client-sqs';
+import { SNSMessageAttributes, SQSEvent, SQSRecord } from 'aws-lambda';
+import { Message } from '@aws-sdk/client-sqs';
 import { Service } from './services';
 export declare const newEventsProxy: (name: string, config: {
     handlers: EventHandler[];
     topic?: string;
-}) => Service<any>;
+    mapper?: (message: Message) => SQSRecord;
+}) => Service<void>;
 export type EventHandler = {
     name: string;
     handler: (event: SQSEvent) => Promise<unknown>;
-    matcher: (subject: string, attributes: Record<string, MessageAttributeValue>) => boolean;
+    matcher: (subject: string, attributes: SNSMessageAttributes) => boolean;
 };