@yopdev/dev-server 1.1.0 → 1.1.6

package/dist/{config.d.ts → src/config.d.ts}

@@ -3,13 +3,12 @@ import { Sns } from "./sns";
 import { DynamoDb } from "./dynamodb";
 import { StartedNetwork } from "testcontainers";
 export type Config = {
-    servicesPort: number;
-    localStackDockerImage: string | undefined;
-    useRandomPorts: boolean;
-    localStateBindMount: string | undefined;
-    queueName: string;
-    topicName: string;
-    table: string;
+    boundServicesPort?: number;
+    localStackDockerImage?: string;
+    localStateBindMount?: string;
+    queueName?: string;
+    topicName?: string;
+    tableName?: string;
 };
 export type AwsConfig = {
     region: string;

package/dist/{dev-server.d.ts → src/dev-server.d.ts}

@@ -2,11 +2,14 @@ import { Config } from "./config";
 import { Lifecycle, Service } from "./services";
 export declare class DevServer implements Lifecycle<DevServer> {
     readonly name: string;
-    private readonly config;
     private readonly service;
+    private readonly config?;
+    private readonly topicName;
+    private readonly queueName;
+    private readonly tableName;
     private LOGGER;
     private localStack;
-    constructor(name: string, config: Config, service: Service<any>);
+    constructor(name: string, service: Service<any>, config?: Config);
     start: () => Promise<this>;
     stop: () => Promise<void>;
 }

package/dist/{dev-server.js → src/dev-server.js}

@@ -8,15 +8,16 @@ var dynamodb_1 = require("./dynamodb");
 var logging_1 = require("@yopdev/logging");
 var sns_1 = require("./sns");
 var DevServer = /** @class */ (function () {
-    function DevServer(name, config, service) {
+    function DevServer(name, service, config) {
         var _this = this;
+        var _a, _b, _c;
         this.name = name;
-        this.config = config;
         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(_this.config, network),
+                localStack: _this.localStack = new localstack_1.LocalStack(network, _this.config),
                 network: network
             }); })
                 .then(function (infra) { return infra.localStack.start().then(function (config) { return ({
@@ -29,12 +30,12 @@ var DevServer = /** @class */ (function () {
                 sqs: new sqs_1.Sqs(infra.aws),
                 sns: new sns_1.Sns(infra.aws),
                 dynamo: new dynamodb_1.DynamoDb(infra.aws),
-                table: _this.config.table,
+                table: _this.tableName,
                 topic: {
-                    arn: "arn:aws:sns:us-east-1:000000000000:".concat(_this.config.topicName),
-                    name: _this.config.topicName,
+                    arn: "arn:aws:sns:us-east-1:000000000000:".concat(_this.topicName),
+                    name: _this.topicName,
                 },
-                queue: _this.config.queueName,
+                queue: _this.queueName,
             }); })
                 .then(function (config) { _this.LOGGER.debug('starting. config is %o', config); return config; })
                 .then(function (aws) { return _this.service.start(aws); })
@@ -45,6 +46,10 @@ var DevServer = /** @class */ (function () {
             .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, 16);
+        this.topicName = (_a = config === null || config === void 0 ? void 0 : config.topicName) !== null && _a !== void 0 ? _a : "Topic".concat(encodedName);
+        this.queueName = (_b = config === null || config === void 0 ? void 0 : config.queueName) !== null && _b !== void 0 ? _b : "Queue".concat(encodedName);
+        this.tableName = (_c = config === null || config === void 0 ? void 0 : config.tableName) !== null && _c !== void 0 ? _c : "Table".concat(encodedName);
     }
     return DevServer;
 }());

package/dist/{dynamodb.d.ts → src/dynamodb.d.ts}

@@ -1,9 +1,9 @@
 import { CreateTableCommand } from "@aws-sdk/client-dynamodb";
 import { AwsConfig } from "./config";
-import { Service, ServiceConfig } from "./services";
+import { Service, Callback } from "./services";
 export declare const newDynamoDbTable: (name: string, config: {
     command: CreateTableCommand;
-}, service: ServiceConfig<string>) => Service<string>;
+}, callback?: Callback<string>) => Service<string>;
 export declare class DynamoDb {
     private readonly dynamo;
     constructor(config: AwsConfig);

package/dist/{dynamodb.js → src/dynamodb.js}

@@ -40,7 +40,7 @@ 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, service) { return new services_1.Service(new DynamoDbTableCreator(name, config.command), service); };
+var newDynamoDbTable = function (name, config, callback) { return new services_1.Service(new DynamoDbTableCreator(name, config.command), callback); };
 exports.newDynamoDbTable = newDynamoDbTable;
 var DynamoDbTableCreator = /** @class */ (function () {
     function DynamoDbTableCreator(name, command) {

package/dist/{event-proxy.d.ts → src/event-proxy.d.ts}

@@ -1,9 +1,9 @@
 import { SQSEvent } from 'aws-lambda';
-import { Lifecycle, Service, ServiceConfig } from './services';
+import { Lifecycle, Service, Callback } from './services';
 import { DevServerConfig } from './config';
 export declare const newEventsProxy: (name: string, config: {
     handlers: EventHandler[];
-}, service: ServiceConfig<EventsProxy>) => Service<EventsProxy>;
+}, callback?: Callback<EventsProxy>) => Service<EventsProxy>;
 declare class EventsProxy implements Lifecycle<EventsProxy> {
     readonly name: string;
     private readonly handlers;

package/dist/{event-proxy.js → src/event-proxy.js}

@@ -43,7 +43,7 @@ var logging_1 = require("@yopdev/logging");
 var stoppable_1 = require("./stoppable");
 var assert_1 = require("./assert");
 var services_1 = require("./services");
-var newEventsProxy = function (name, config, service) { return new services_1.Service(new EventsProxy(name, config.handlers), service); };
+var newEventsProxy = function (name, config, callback) { return new services_1.Service(new EventsProxy(name, config.handlers), callback); };
 exports.newEventsProxy = newEventsProxy;
 var EventsProxy = /** @class */ (function () {
     function EventsProxy(name, handlers) {

package/dist/{factories.d.ts → src/factories.d.ts}

@@ -1,2 +1,3 @@
 import { Service } from "./services";
 export declare const all: (services: Service<any>[]) => Service<any>;
+export declare const oneThenOther: (one: Service<unknown>, other: Service<unknown>) => Service<unknown>;

package/dist/src/factories.js

@@ -0,0 +1,69 @@
+"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.oneThenOther = exports.all = void 0;
+var services_1 = require("./services");
+var all = function (services) { return new services_1.Service({
+    name: "ALLOF[".concat(services.map(function (each) { return each.name; }).join(','), "]"),
+    start: function (config) { return __awaiter(void 0, void 0, void 0, function () {
+        var _this = this;
+        return __generator(this, function (_a) {
+            return [2 /*return*/, Promise.all(services.map(function (each) { return each.start(config); })).then(function () { return _this; })];
+        });
+    }); },
+    stop: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        return [2 /*return*/, Promise.all(services.map(function (each) { return each.stop(); })).then()];
+    }); }); }
+}); };
+exports.all = all;
+var oneThenOther = function (one, other) {
+    return new services_1.Service({
+        name: "[".concat(one.name, "]->[").concat(other.name, "]"),
+        start: function (config) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/, one.start(config).then(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                    return [2 /*return*/, other.start(config)];
+                }); }); })];
+        }); }); },
+        stop: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/, other.stop().then(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                    return [2 /*return*/, one.stop()];
+                }); }); })];
+        }); }); },
+    });
+};
+exports.oneThenOther = oneThenOther;

package/dist/{http-server.d.ts → src/http-server.d.ts}

@@ -1,10 +1,10 @@
 /// <reference types="node" />
 import { IncomingMessage, ServerResponse } from "http";
-import { Lifecycle, Service, ServiceConfig } from "./services";
+import { Lifecycle, Service, Callback } from "./services";
 export declare const newHttpServer: (name: string, config: {
     settings: HttpSettings;
     handler: (request: IncomingMessage, requestBody: string, response: ServerResponse) => void;
-}, service: ServiceConfig<string>) => Service<string>;
+}, callback?: Callback<string>) => Service<string>;
 export declare class HttpServer implements Lifecycle<string> {
     readonly name: string;
     readonly settings: HttpSettings;

package/dist/{http-server.js → src/http-server.js}

@@ -6,7 +6,7 @@ var events_1 = require("events");
 var logging_1 = require("@yopdev/logging");
 var assert_1 = require("./assert");
 var services_1 = require("./services");
-var newHttpServer = function (name, config, service) { return new services_1.Service(new HttpServer(name, config.settings, config.handler), service); };
+var newHttpServer = function (name, config, callback) { return new services_1.Service(new HttpServer(name, config.settings, config.handler), callback); };
 exports.newHttpServer = newHttpServer;
 var HttpServer = /** @class */ (function () {
     function HttpServer(name, settings, handler) {

package/dist/{index.d.ts → src/index.d.ts}

@@ -7,4 +7,5 @@ export { newEventsProxy as eventsProxy } from './event-proxy';
 export { newScheduledTasks as scheduledTasks } from './scheduled-tasks';
 export { newPreTrafficHooks as preTrafficHooks } from './pre-traffic-hooks';
 export { newDynamoDbTable as dynamoDbTable } from './dynamodb';
-export { all as allOf } from './factories';
+export { all as allOf, oneThenOther } from './factories';
+export { lazy } from './lazy';

package/dist/{index.js → src/index.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.allOf = exports.dynamoDbTable = exports.preTrafficHooks = exports.scheduledTasks = exports.eventsProxy = exports.internalQueue = exports.snsHttpProxy = exports.lambdaHttpProxy = exports.httpServer = exports.DevServer = void 0;
+exports.lazy = exports.oneThenOther = exports.allOf = exports.dynamoDbTable = exports.preTrafficHooks = exports.scheduledTasks = exports.eventsProxy = exports.internalQueue = exports.snsHttpProxy = exports.lambdaHttpProxy = exports.httpServer = exports.DevServer = void 0;
 var dev_server_1 = require("./dev-server");
 Object.defineProperty(exports, "DevServer", { enumerable: true, get: function () { return dev_server_1.DevServer; } });
 var http_server_1 = require("./http-server");
@@ -21,3 +21,6 @@ var dynamodb_1 = require("./dynamodb");
 Object.defineProperty(exports, "dynamoDbTable", { enumerable: true, get: function () { return dynamodb_1.newDynamoDbTable; } });
 var factories_1 = require("./factories");
 Object.defineProperty(exports, "allOf", { enumerable: true, get: function () { return factories_1.all; } });
+Object.defineProperty(exports, "oneThenOther", { enumerable: true, get: function () { return factories_1.oneThenOther; } });
+var lazy_1 = require("./lazy");
+Object.defineProperty(exports, "lazy", { enumerable: true, get: function () { return lazy_1.lazy; } });

package/dist/{internal-queue.d.ts → src/internal-queue.d.ts}

@@ -1,7 +1,7 @@
 import { SQSEvent } from "aws-lambda";
-import { Service, ServiceConfig } from "./services";
+import { Service, Callback } from "./services";
 export declare const newInternalQueue: (name: string, config: {
     index: number;
     visibility: number;
     handler: (e: SQSEvent) => Promise<void>;
-}, service: ServiceConfig<string>) => Service<string>;
+}, callback?: Callback<string>) => Service<string>;

package/dist/{internal-queue.js → src/internal-queue.js}

@@ -42,7 +42,7 @@ var sqs_consumer_1 = require("sqs-consumer");
 var stoppable_1 = require("./stoppable");
 var mappers_1 = require("./mappers");
 var services_1 = require("./services");
-var newInternalQueue = function (name, config, service) { return new services_1.Service(new InternalQueue(name, config.visibility, config.handler, config.index), service); };
+var newInternalQueue = function (name, config, callback) { return new services_1.Service(new InternalQueue(name, config.visibility, config.handler, config.index), callback); };
 exports.newInternalQueue = newInternalQueue;
 var InternalQueue = /** @class */ (function () {
     function InternalQueue(name, visibility, handler, index) {

package/dist/{lambda-http-proxy.d.ts → src/lambda-http-proxy.d.ts}

@@ -1,7 +1,7 @@
 import { HttpSettings } from "./http-server";
 import { APIGatewayProxyEvent, APIGatewayProxyResult } from "aws-lambda";
-import { Service, ServiceConfig } from "./services";
+import { Service, Callback } from "./services";
 export declare const newLambdaHttpProxy: (name: string, config: {
     settings: HttpSettings;
     handler: (event: APIGatewayProxyEvent) => Promise<APIGatewayProxyResult>;
-}, service: ServiceConfig<string>) => Service<string>;
+}, callback?: Callback<string>) => Service<string>;

package/dist/{lambda-http-proxy.js → src/lambda-http-proxy.js}

@@ -6,7 +6,7 @@ var http_server_1 = require("./http-server");
 var mappers_1 = require("./mappers");
 var responses_1 = require("./responses");
 var services_1 = require("./services");
-var newLambdaHttpProxy = function (name, config, service) { return new services_1.Service(new LambdaHttpProxy(name, config.settings, config.handler), service); };
+var newLambdaHttpProxy = function (name, config, callback) { return new services_1.Service(new LambdaHttpProxy(name, config.settings, config.handler), callback); };
 exports.newLambdaHttpProxy = newLambdaHttpProxy;
 var LambdaHttpProxy = /** @class */ (function () {
     function LambdaHttpProxy(name, settings, handler) {

package/dist/src/lazy.d.ts

@@ -0,0 +1,3 @@
+import { DevServerConfig } from "./config";
+import { Service } from "./services";
+export declare const lazy: <I>(lifecycle: (config: DevServerConfig) => Service<I>) => Service<I>;

package/dist/src/lazy.js

@@ -0,0 +1,82 @@
+"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.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)); };
+exports.lazy = lazy;
+var Lazy = /** @class */ (function () {
+    function Lazy(configurable) {
+        var _this = this;
+        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.started = undefined;
+        this.name = (0, crypto_1.randomUUID)();
+        this.LOGGER = logging_1.LoggerFactory.create("LAZY[".concat(this.name, "]"));
+    }
+    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;
+        if (local !== undefined)
+            task(local);
+        else
+            fallback();
+    };
+    return Lazy;
+}());

package/dist/{localstack.d.ts → src/localstack.d.ts}

@@ -4,7 +4,8 @@ import { Stoppable } from "./services";
 export declare class LocalStack implements Stoppable {
     private readonly _start;
     private started;
-    constructor(config: Config, network: StartedNetwork);
+    constructor(network: StartedNetwork, config?: Config);
+    private configOrDefaults;
     start: () => Promise<AwsConfig>;
     stop: () => Promise<void>;
 }

package/dist/{localstack.js → src/localstack.js}

@@ -40,11 +40,12 @@ exports.LocalStack = void 0;
 var logging_1 = require("@yopdev/logging");
 var testcontainers_1 = require("testcontainers");
 var LOGGER = logging_1.LoggerFactory.create('LOCALSTACK');
+var SERVICES_PORT = 4566;
 var NETWORK_ALIAS = 'localstack';
 var PROTOCOL = 'http';
 var DEFAULT_DOCKER_IMAGE = 'localstack/localstack:stable';
 var LocalStack = /** @class */ (function () {
-    function LocalStack(config, network) {
+    function LocalStack(network, config) {
         var _this = this;
         this.start = function () { return __awaiter(_this, void 0, void 0, function () {
             return __generator(this, function (_a) {
@@ -62,8 +63,9 @@ var LocalStack = /** @class */ (function () {
         this.stop = function () { return Promise.resolve(_this.started)
             .then(function (container) { return container ? container.stop().then(function () { return 'stopped'; }) : 'not started'; })
             .then(function (status) { return LOGGER.info(status); }); };
-        var container = new testcontainers_1.GenericContainer(config.localStackDockerImage || DEFAULT_DOCKER_IMAGE);
-        var localStatePath = config.localStateBindMount;
+        var concreteConfig = this.configOrDefaults(config);
+        var container = new testcontainers_1.GenericContainer(concreteConfig.localStackDockerImage);
+        var localStatePath = concreteConfig.localStateBindMount;
         var withLocalState = localStatePath !== undefined ?
             container
                 .withEnvironment({ PERSISTENCE: '1' })
@@ -74,20 +76,26 @@ var LocalStack = /** @class */ (function () {
                 }])
             : container;
         var ready = withLocalState
-            .withExposedPorts(config.useRandomPorts ?
-            config.servicesPort :
-            {
-                container: config.servicesPort,
-                host: config.servicesPort
-            })
+            .withExposedPorts(concreteConfig.exposedPort)
             .withNetwork(network)
             .withNetworkAliases(NETWORK_ALIAS);
         this._start = function () { return ready
             .start()
             .then(function (container) { return _this.started = container; })
-            .then(function (container) { return "".concat(PROTOCOL, "://").concat(container.getHost(), ":").concat(container.getMappedPort(config.servicesPort)); }); };
+            .then(function (container) { return "".concat(PROTOCOL, "://").concat(container.getHost(), ":").concat(container.getMappedPort(SERVICES_PORT)); }); };
         LOGGER.debug('initialized');
     }
+    LocalStack.prototype.configOrDefaults = function (config) {
+        var selectedServicesPort = config === null || config === void 0 ? void 0 : config.boundServicesPort;
+        var exposedPort = selectedServicesPort !== undefined ?
+            { container: SERVICES_PORT, host: selectedServicesPort } :
+            SERVICES_PORT;
+        return {
+            localStackDockerImage: (config === null || config === void 0 ? void 0 : config.localStackDockerImage) || DEFAULT_DOCKER_IMAGE,
+            exposedPort: exposedPort,
+            localStateBindMount: config === null || config === void 0 ? void 0 : config.localStateBindMount,
+        };
+    };
     return LocalStack;
 }());
 exports.LocalStack = LocalStack;

package/dist/{pre-traffic-hooks.d.ts → src/pre-traffic-hooks.d.ts}

@@ -1,5 +1,5 @@
-import { Lifecycle, Service, ServiceConfig } from './services';
-export declare const newPreTrafficHooks: (name: string, hooks: () => Promise<void>[], service: ServiceConfig<PreTrafficHooks>) => Service<PreTrafficHooks>;
+import { Lifecycle, Service, Callback } from './services';
+export declare const newPreTrafficHooks: (name: string, hooks: () => Promise<void>[], callback?: Callback<PreTrafficHooks>) => Service<PreTrafficHooks>;
 declare class PreTrafficHooks implements Lifecycle<PreTrafficHooks> {
     readonly name: string;
     private readonly hooks;

package/dist/{pre-traffic-hooks.js → src/pre-traffic-hooks.js}

@@ -39,7 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.newPreTrafficHooks = void 0;
 var logging_1 = require("@yopdev/logging");
 var services_1 = require("./services");
-var newPreTrafficHooks = function (name, hooks, service) { return new services_1.Service(new PreTrafficHooks(name, hooks), service); };
+var newPreTrafficHooks = function (name, hooks, callback) { return new services_1.Service(new PreTrafficHooks(name, hooks), callback); };
 exports.newPreTrafficHooks = newPreTrafficHooks;
 var PreTrafficHooks = /** @class */ (function () {
     function PreTrafficHooks(name, hooks) {

package/dist/{scheduled-tasks.d.ts → src/scheduled-tasks.d.ts}

@@ -1,6 +1,6 @@
 /// <reference types="node" />
-import { Lifecycle, Service, ServiceConfig } from './services';
-export declare const newScheduledTasks: (name: string, schedules: Rate[], service: ServiceConfig<ScheduledTasks>) => Service<ScheduledTasks>;
+import { Lifecycle, Service, Callback } from './services';
+export declare const newScheduledTasks: (name: string, schedules: Rate[], callback?: Callback<ScheduledTasks>) => Service<ScheduledTasks>;
 declare class ScheduledTasks implements Lifecycle<ScheduledTasks> {
     readonly name: string;
     private readonly schedules;

package/dist/{scheduled-tasks.js → src/scheduled-tasks.js}

@@ -40,7 +40,7 @@ exports.newScheduledTasks = void 0;
 var logging_1 = require("@yopdev/logging");
 var timers_1 = require("timers");
 var services_1 = require("./services");
-var newScheduledTasks = function (name, schedules, service) { return new services_1.Service(new ScheduledTasks(name, schedules), service); };
+var newScheduledTasks = function (name, schedules, callback) { return new services_1.Service(new ScheduledTasks(name, schedules), callback); };
 exports.newScheduledTasks = newScheduledTasks;
 var ScheduledTasks = /** @class */ (function () {
     function ScheduledTasks(name, schedules) {

package/dist/{services.d.ts → src/services.d.ts}

@@ -6,19 +6,14 @@ export interface Lifecycle<I> extends Stoppable {
 export interface Stoppable {
     stop(): Promise<void>;
 }
-export interface Callbackable<I> {
-    callback?: ((instance: I) => Promise<void>);
-}
+export type Callback<I> = (instance: I) => Promise<void>;
 export declare class Service<I> implements Lifecycle<I> {
-    private readonly config;
+    private readonly callback?;
+    private readonly DEFAULT_CALLBACK;
     readonly name: string;
     readonly start: (config: DevServerConfig) => Promise<I>;
     readonly stop: () => Promise<void>;
-    private LOGGER;
-    constructor(service: Lifecycle<I>, config: ServiceConfig<I>);
-    private callback;
-    private dependsOnOrNothing;
+    private readonly LOGGER;
+    constructor(service: Lifecycle<I>, callback?: Callback<I>);
+    private callbackOrDefault;
 }
-export type ServiceConfig<I> = {
-    dependsOn?: Lifecycle<any>;
-} & Callbackable<I>;

package/dist/{services.js → src/services.js}

@@ -39,35 +39,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Service = void 0;
 var logging_1 = require("@yopdev/logging");
 var Service = /** @class */ (function () {
-    function Service(service, config) {
+    function Service(service, callback) {
         var _this = this;
-        this.config = config;
-        this.callback = function (instance) { return __awaiter(_this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, (this.config.callback || (function () { return _this.LOGGER.debug('no callback', _this.name); }))(instance)];
-            });
-        }); };
-        this.dependsOnOrNothing = function () {
-            var _a;
-            return (_a = _this.config.dependsOn) !== null && _a !== void 0 ? _a : {
-                name: _this.name,
-                start: function () { return Promise.resolve(_this.LOGGER.trace('no start dependency for %s', _this.name)); },
-                stop: function () { return Promise.resolve(_this.LOGGER.trace('no stop dependency for %s', _this.name)); }
-            };
-        };
+        this.callback = callback;
+        this.DEFAULT_CALLBACK = function () { return Promise.resolve(_this.LOGGER.debug('no callback')); };
+        this.callbackOrDefault = function (instance) { return __awaiter(_this, void 0, void 0, function () { var _a; return __generator(this, function (_b) {
+            return [2 /*return*/, ((_a = this.callback) !== null && _a !== void 0 ? _a : this.DEFAULT_CALLBACK)(instance)];
+        }); }); };
         this.name = service.name;
         this.LOGGER = logging_1.LoggerFactory.create("SERVICE[".concat(this.name, "]"));
-        this.start = function (config) { return _this.dependsOnOrNothing()
-            .start(config)
-            .then(function () { return service.start(config); })
+        this.start = function (config) { return service.start(config)
             .then(function (started) { return _this
-            .callback(started)
+            .callbackOrDefault(started)
             .then(function () { return _this.LOGGER.info('started'); })
             .then(function () { return started; }); }); };
         this.stop = function () { return service
             .stop()
-            .then(function () { return _this.dependsOnOrNothing().stop(); })
             .then(function () { return _this.LOGGER.info('stopped'); }); };
     }
     return Service;

package/dist/{sns-http-proxy.d.ts → src/sns-http-proxy.d.ts}

@@ -1,12 +1,12 @@
 import { HttpSettings } from "./http-server";
 import { IncomingMessage, ServerResponse } from "http";
-import { Lifecycle, Service, ServiceConfig } from "./services";
+import { Lifecycle, Service, Callback } from "./services";
 import { DevServerConfig } from "./config";
 export declare const newSnsHttpProxy: (name: string, config: {
     settings: HttpSettings;
     method: string;
     subject: string | undefined;
-}, service: ServiceConfig<string>) => Service<string>;
+}, callback?: Callback<string>) => Service<string>;
 export declare class SnsHttpProxy implements Lifecycle<string> {
     readonly name: string;
     private readonly settings;

package/dist/{sns-http-proxy.js → src/sns-http-proxy.js}

@@ -17,7 +17,7 @@ var http_server_1 = require("./http-server");
 var responses_1 = require("./responses");
 var services_1 = require("./services");
 var assert_1 = require("./assert");
-var newSnsHttpProxy = function (name, config, service) { return new services_1.Service(new SnsHttpProxy(name, config.settings, config.method, config.subject), service); };
+var newSnsHttpProxy = function (name, config, callback) { return new services_1.Service(new SnsHttpProxy(name, config.settings, config.method, config.subject), callback); };
 exports.newSnsHttpProxy = newSnsHttpProxy;
 var SnsHttpProxy = /** @class */ (function () {
     function SnsHttpProxy(name, settings, method, subject) {

package/package.json

@@ -1,28 +1,34 @@
 {
   "name": "@yopdev/dev-server",
-  "version": "1.1.0",
+  "version": "1.1.6",
   "scripts": {
     "compile": "tsc",
+    "test": "jest",
     "clean": "rm -rf dist",
     "predistclean": "npm run clean",
     "distclean": "rm -rf node_modules"
   },
   "devDependencies": {
-    "typescript": "^5.2.2"
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.2.2",
+    "@types/aws-lambda": "8.10.114",
+    "@types/node": "^20.9.0"
   },
   "dependencies": {
     "@aws-sdk/client-dynamodb": "^3.451.0",
     "@aws-sdk/client-sns": "^3.451.0",
     "@aws-sdk/client-sqs": "^3.451.0",
-    "@types/aws-lambda": "8.10.114",
-    "@types/node": "^20.9.0",
     "@yopdev/logging": "^0.0.1",
     "sqs-consumer": "^7.4.0",
     "testcontainers": "^10.2.2"
   },
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "github:blockademy/devserver"
+  },
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
   "files": [
-    "dist"
+    "dist/src"
   ]
 }

package/dist/factories.js

@@ -1,11 +0,0 @@
-"use strict";
-var _this = this;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.all = void 0;
-var services_1 = require("./services");
-var all = function (services) { return new services_1.Service({
-    name: "ALLOF[".concat(services.map(function (each) { return each.name; }).join(','), "]"),
-    start: function (config) { return Promise.all(services.map(function (each) { return each.start(config); })).then(function () { return _this; }); },
-    stop: function () { return Promise.all(services.map(function (each) { return each.stop(); })).then(); }
-}, {}); };
-exports.all = all;