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

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

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

package/dist/src/assert.d.ts

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

package/dist/src/assert.js

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,14 @@
+import { CloudFormationSetupConfig } from './cloudformation';
+import { DevServerConfig } from './config';
+import { HttpSettings } from './http-server';
+import { Authorizer, Route } from './lambda-http-proxy';
+import { Callback, Service, Startable } from './services';
+import { LambdaPayloadVersion } from './mappers';
+export declare const newLambdaProxyFromCloudFormationTemplate: <Context, AuthorizerContext, Event_1, HandlerResponse>(name: string, settings: HttpSettings, payloadVersion: LambdaPayloadVersion<AuthorizerContext, Event_1, HandlerResponse>, config: CloudFormationLambdaProxyConfig<Context, AuthorizerContext, Event_1, HandlerResponse>, callback: Callback<string>) => Startable<Service<string>>;
+type CloudFormationLambdaProxyConfig<Context, AuthorizerContext, Event, HandlerResponse> = {
+    authorizer?: (config: DevServerConfig) => Authorizer<AuthorizerContext> | undefined;
+    extraRoutes: Route<Context, AuthorizerContext, Event, HandlerResponse>[];
+    prepare?: (config: DevServerConfig) => Promise<void>;
+    context?: () => Context;
+} & CloudFormationSetupConfig;
+export {};

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newLambdaProxyFromCloudFormationTemplate = void 0;
+const cloudformation_1 = require("./cloudformation");
+const lambda_http_proxy_1 = require("./lambda-http-proxy");
+const PATH_VARIABLE_CAPTURE = /{(.*?)}/g;
+const QUERY_STRING_OR_LOCATION_REG_EXP = '(?:([?#].*))?';
+const PROXY_PATH_PARAM = 'proxy';
+const newLambdaProxyFromCloudFormationTemplate = (name, settings, payloadVersion, config, callback) => new CloudFormationLambdaProxy(name, settings, config.extraRoutes, payloadVersion, config, callback);
+exports.newLambdaProxyFromCloudFormationTemplate = newLambdaProxyFromCloudFormationTemplate;
+class CloudFormationLambdaProxy extends cloudformation_1.CloudFormationSetup {
+    constructor(name, settings, extraRoutes, payloadVersion, config, callback) {
+        super(name, (event) => event.Type === 'HttpApi', async (event, handler) => Promise.resolve(this.pathWithCapturingGroups(event.Properties.Path)).then((pathWithCapturingGroups) => ({
+            method: new RegExp(this.method(event.Properties.Method)),
+            path: new RegExp(`^${pathWithCapturingGroups}${QUERY_STRING_OR_LOCATION_REG_EXP}?$`),
+            weight: this.computeWeight(pathWithCapturingGroups),
+            handler: this.pathParameterCapture(new RegExp(pathWithCapturingGroups), handler, config.context),
+        })), config.prepare, config);
+        this.settings = settings;
+        this.extraRoutes = extraRoutes;
+        this.callback = callback;
+        this.afterStart = (name, cfg, routes) => (0, lambda_http_proxy_1.newLambdaHttpProxy)(`${name}:apigw`, {
+            settings: this.settings,
+            routes: this.extraRoutes.concat(routes),
+            authorizer: (this.authorizer || (() => undefined))(cfg),
+            mapper: this.mapper,
+        }, this.callback);
+        this.computeWeight = (path) => this.segments(path) - this.variables(path);
+        this.segments = (path) => path.split('/').length;
+        this.variables = (path) => path.split('(?<').length;
+        this.pathWithCapturingGroups = (source) => [...source.matchAll(PATH_VARIABLE_CAPTURE)].reduce((prev, curr) => prev.replaceAll(curr[0], `(?<${this.normalizeCaptureGroupName(curr[1]).replaceAll("+", "")}>.*)`), source);
+        this.normalizeCaptureGroupName = (original) => (original === 'proxy+' ? PROXY_PATH_PARAM : original);
+        this.pathParameterCapture = (pathWithCapturingGroups, handler, context) => async (event) => {
+            const pathParameters = pathWithCapturingGroups.exec(this.pathParameterResolver.locate(event))?.groups;
+            this.pathParameterResolver.store(event, Object.fromEntries((Object.entries(pathParameters ?? {}))
+                .map(([k, v]) => [k, decodeURIComponent(v)])));
+            return handler(event, context?.());
+        };
+        this.method = (cloudFormationValue) => {
+            switch (cloudFormationValue) {
+                case 'ANY':
+                    return '.*';
+                case 'HEAD':
+                case 'OPTIONS':
+                case 'GET':
+                case 'POST':
+                case 'PUT':
+                case 'DELETE':
+                case 'PATCH':
+                    return cloudFormationValue;
+                default:
+                    throw new Error(`unsupported method ${cloudFormationValue}`);
+            }
+        };
+        this.mapper = payloadVersion.mapper;
+        this.authorizer = config?.authorizer;
+        this.pathParameterResolver = payloadVersion.resolver;
+    }
+    logHandler(handler) {
+        return `detected handler for ${handler.method} on ${handler.path} with weight ${handler.weight}`;
+    }
+}

package/dist/src/cloudformation.d.ts

@@ -0,0 +1,28 @@
+import { DevServerConfig } from './config';
+import { Startable } from './services';
+export declare abstract class CloudFormationSetup<P, H, R, F> implements Startable<F> {
+    readonly name: string;
+    private readonly eventFilter;
+    private readonly handlerResolver;
+    private readonly beforeStart;
+    private readonly template;
+    private readonly handlers;
+    private readonly handlerNameResolver;
+    private readonly LOGGER;
+    constructor(name: string, eventFilter: (event: Event<P>) => boolean, handlerResolver: (event: Event<P>, handler: H) => Promise<R>, beforeStart: ((config: DevServerConfig) => Promise<void>) | undefined, config: CloudFormationSetupConfig);
+    start: (config: DevServerConfig) => Promise<F>;
+    protected abstract afterStart: (name: string, config: DevServerConfig, routes: R[]) => F;
+    private resolvedHandlers;
+    abstract logHandler(handler: R): string;
+    private parseApiEvents;
+}
+export type CloudFormationSetupConfig = {
+    template: (name: string) => string;
+    handlers: (name: string) => string;
+    handlerNameResolver: (name: string) => string;
+};
+type Event<P> = {
+    Type: string;
+    Properties: P;
+};
+export {};

package/dist/src/cloudformation.js

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

package/dist/src/config.d.ts

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

package/dist/src/config.js

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

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: 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 ?? ((port) => `http://localhost:${port}`);
+    }
+}
+;

package/dist/src/deferred.d.ts

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

package/dist/src/deferred.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promised = exports.lazy = void 0;
+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;
+const promised = (lifecycle) => new services_1.Service(new Promised(lifecycle));
+exports.promised = promised;
+class Lazy {
+    constructor(configurable) {
+        this.configurable = configurable;
+        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[${this.name}]`);
+    }
+    async start(config) {
+        const local = this.configurable(config);
+        this.started = local;
+        this.LOGGER.info('DISCOVERY:%s', local.name);
+        return local.start(config);
+    }
+    withStartedOr(task, fallback) {
+        const local = this.started;
+        if (local !== undefined)
+            task(local);
+        else
+            fallback();
+    }
+}
+class Promised {
+    constructor(configurable) {
+        this.name = (0, crypto_1.randomUUID)();
+        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();
+    }
+}

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

@@ -0,0 +1,19 @@
+import { Config } from "./config";
+import { Service } from "./services";
+export declare class DevServer {
+    readonly name: string;
+    private readonly service;
+    private readonly config?;
+    private readonly eventProxyTopic;
+    private LOGGER;
+    private localStack;
+    private network;
+    constructor(name: string, service: Service<any>, config?: Config);
+    start: () => Promise<StartedDevServer>;
+    private shutdown;
+}
+type StartedDevServer = {
+    name: string;
+    stop: () => Promise<void>;
+};
+export {};

package/dist/src/dev-server.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevServer = void 0;
+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 = async () => Promise.resolve(new testcontainers_1.Network(new testcontainers_1.RandomUuid()).start())
+            .tap((network) => this.network = network)
+            .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(() => ({
+            name: this.name,
+            stop: async () => this.shutdown().then(() => this.LOGGER.info('stopped')),
+        }));
+        this.shutdown = async () => this.service.stop()
+            .finally(tunnel_1.terminate)
+            .then(() => this.localStack?.stop())
+            .then(() => this.network?.stop().catch((e) => this.LOGGER.warn(e, 'failed to stop network')));
+        this.LOGGER = logging_1.LoggerFactory.create(`DEVSERVER[${name}]`);
+        const encodedName = Buffer.from(name).toString('hex').substring(0, 64);
+        this.eventProxyTopic = `EventProxyTopic${encodedName}`;
+    }
+}
+exports.DevServer = DevServer;

package/dist/src/dynamodb.d.ts

@@ -0,0 +1,16 @@
+import { CreateTableCommand, DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { AwsConfig } from "./config";
+import { Service, Callback } from "./services";
+export declare const newDynamoDbTable: (name: string, config: {
+    command: CreateTableCommand;
+    ttlAttribute?: string;
+}, callback?: Callback<string>) => Service<string>;
+export declare class DynamoDb {
+    readonly client: DynamoDBClient;
+    constructor(config: AwsConfig);
+    createTable: (factory: CreateTableCommand) => Promise<import("@aws-sdk/client-dynamodb").CreateTableCommandOutput | {
+        TableDescription: {
+            TableName: string;
+        };
+    }>;
+}