@yopdev/dev-server 1.8.0-alpha.1 → 2.0.0-alpha.2

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,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,16 @@
+/// <reference types="node" />
+import { CloudFormationSetupConfig } from './cloudformation';
+import { DevServerConfig } from './config';
+import { HttpSettings } from './http-server';
+import { APIGatewayEventRequestContextV2WithGenericAuthorizer, 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>[];
+    prepare?: (config: DevServerConfig) => Promise<void>;
+    context?: () => C;
+    mapper?: (request: IncomingMessage, body: string) => Promise<APIGatewayEventRequestContextV2WithGenericAuthorizer<A>>;
+} & CloudFormationSetupConfig;
+export {};

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

@@ -0,0 +1,45 @@
+"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.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])}>.*)`), 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)]));
+            return handler(event, context?.());
+        };
+        this.mapper = config?.mapper;
+        this.authorizer = config?.authorizer;
+    }
+    logHandler(handler) {
+        return `detected handler for ${handler.method} on ${handler.path} with weight ${handler.weight}`;
+    }
+}

package/dist/src/cloudformation.d.ts

@@ -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,46 @@
+"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, 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 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/container.js

@@ -1,80 +1,33 @@
 "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.newContainer = void 0;
-var logging_1 = require("@yopdev/logging");
-var testcontainers_1 = require("testcontainers");
-var services_1 = require("./services");
-var newContainer = function (name, config, callback) {
-    return new services_1.Service(new Container(name, config.image, config.networkAlias, config.environment, config.bindMounts, config.exposedPorts, config.logConsumer, config.startup, config.endpointBuilder), callback);
-};
+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;
-var Container = /** @class */ (function () {
-    function Container(name, image, networkAlias, environment, bindMounts, exposedPorts, logConsumer, startup, endpointBuilder) {
-        var _this = this;
+class Container {
+    constructor(name, image, networkAlias, environment, bindMounts, exposedPorts, logConsumer, startup, endpointBuilder) {
         this.name = name;
         this.networkAlias = networkAlias;
-        this.start = function (config) { return __awaiter(_this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, Promise.resolve(this.LOGGER.info('start'))
-                        .then(function () { return _this.container
-                        .withNetwork(config.network)
-                        .withNetworkAliases(_this.networkAlias)
-                        .start(); })
-                        .then(function (started) { return _this.started = started; })
-                        .then(function () { return _this.endpointBuilder(_this.started.getFirstMappedPort()); })
-                        .tap(function (url) { return _this.LOGGER.debug(url); })];
-            });
-        }); };
-        this.stop = function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
-            return [2 /*return*/, this.started.stop().then(function () { return undefined; })];
-        }); }); };
-        this.LOGGER = logging_1.LoggerFactory.create("CONTAINER[".concat(name, "]"));
-        var generic = new testcontainers_1.GenericContainer(image);
-        var withEnvironment = environment ? generic.withEnvironment(environment) : generic;
-        var withBindMounts = bindMounts ? withEnvironment.withBindMounts(bindMounts) : withEnvironment;
-        var withExposedPorts = exposedPorts ? withBindMounts.withExposedPorts.apply(withBindMounts, exposedPorts) : withBindMounts;
-        var withLogConsumer = logConsumer ? withExposedPorts.withLogConsumer(logConsumer) : withExposedPorts;
+        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: async () => { this.LOGGER.warn('no container'); } }).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 !== null && endpointBuilder !== void 0 ? endpointBuilder : (function (port) { return "http://localhost:".concat(port); });
+        this.endpointBuilder = endpointBuilder ?? ((port) => `http://localhost:${port}`);
     }
-    return Container;
-}());
+}
 ;

package/dist/src/deferred.js

@@ -1,105 +1,45 @@
 "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;
-        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 () { return __generator(this, function (_a) {
-            return [2 /*return*/, this.service.stop()];
-        }); }); };
+    }
+}
+class Promised {
+    constructor(configurable) {
         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}]`);
+        let initialized;
+        this.start = async (config) => configurable(config)
+            .catch((e) => e?.cleanup?.() ?? Promise.reject(e))
+            .then((service) => initialized = service)
+            .tap((service) => this.LOGGER.info('DISCOVERY:%s', service.name))
+            .then((service) => service.start(config));
+        this.stop = async () => (initialized ?? { stop: async () => this.LOGGER.info('not started') }).stop();
     }
-    return Promised;
-}());
+}

package/dist/src/dev-server.d.ts

@@ -10,4 +10,5 @@ export declare class DevServer implements Lifecycle<DevServer> {
     constructor(name: string, service: Service<any>, config?: Config);
     start: () => Promise<this>;
     stop: () => Promise<void>;
+    private shutdown;
 }

package/dist/src/dev-server.js

@@ -1,60 +1,60 @@
 "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 tunnel_1 = require("./tunnel");
-var s3_1 = require("./s3");
-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),
-                s3: new s3_1.S3(infra.aws),
-                dynamo: new dynamodb_1.DynamoDb(infra.aws),
-                eventsProxy: {
-                    topic: {
-                        arn: eventProxyTopicArn
-                    }
-                },
-            }); }); }); })
-                .tap(function (config) { return _this.LOGGER.debug('config is %o', 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()
+        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))
+            .catch((e) => this.shutdown()
+            .then(() => this.LOGGER.error('error starting service'))
+            .then(() => Promise.reject(e)))
+            .then(() => this.LOGGER.info('started'))
+            .then(() => this);
+        this.stop = () => this.shutdown()
+            .then(() => this.LOGGER.info('stopped'));
+        this.shutdown = async () => this.service.stop()
             .then(tunnel_1.terminate)
-            .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);
+            .then(() => this.localStack?.stop());
+        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;