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

package/src/cloudformation-dynamodb-table.ts

@@ -0,0 +1,97 @@
+import { Callback, Lifecycle, Service } from './services';
+import { AttributeDefinition, CreateTableCommand, GlobalSecondaryIndex, KeySchemaElement, UpdateTimeToLiveCommand } from '@aws-sdk/client-dynamodb';
+import { CLOUDFORMATION_SCHEMA } from 'js-yaml-cloudformation-schema';
+import { load } from 'js-yaml';
+import { readFileSync } from 'fs';
+import { DevServerConfig } from './config';
+import { Logger, LoggerFactory } from '@yopdev/logging';
+import { newDynamoDbTable } from './dynamodb';
+
+export const newDynamoDbTableFromCloudFormationTemplate = (
+    name: string,
+    config: DynamoDbTableCloudFormationConfig,
+    callback?: Callback<string>,
+): Service<string> => new Service(new DynamoDbTableCloudFormation(
+    name,
+    config.template,
+    config.resource,
+    config.tableName,
+    config.throughput
+), callback)
+
+class DynamoDbTableCloudFormation implements Lifecycle<string> {
+    private readonly LOGGER: Logger
+    private readonly tableName: (name: string) => string;
+
+    constructor(
+        readonly name: string,
+        private readonly template: (name: string) => string,
+        private readonly resource: string,
+        tableName: (name: string) => string,
+        private readonly throughput: Throughput,
+    ) {
+        this.LOGGER = LoggerFactory.create(`CFN:DYNAMO[${name}]`)
+        this.tableName = tableName ? tableName : (name: string) => { throw new Error(`table name not specified on ${name}`) }
+    }
+
+    start = (config: DevServerConfig) => Promise.resolve(
+        this.parseTableDefinition(this.template(this.name))
+            .then((definition) => definition[this.resource].Properties)
+            .then((resource) => this.createTableCommand(resource, this.throughput)
+                .then((command) => newDynamoDbTable(this.name, {
+                    command: command,
+                    ttlAttribute: resource.TimeToLiveSpecification?.AttributeName,
+                }))))
+                .tap(() => this.LOGGER.info('configured'))
+                .then((service) => service.start(config))
+
+    stop = () => Promise.resolve()
+
+    private createTableCommand = async (definition: DynamoDbTableCloudformationDefinitionProperties, throughput: Throughput) =>
+        new CreateTableCommand({
+            TableName: definition.TableName ?? this.tableName(this.name),
+            KeySchema: definition.KeySchema,
+            AttributeDefinitions: definition.AttributeDefinitions,
+            GlobalSecondaryIndexes: definition.GlobalSecondaryIndexes?.map((gsi: GlobalSecondaryIndex) => ({
+                ...gsi,
+                ProvisionedThroughput: throughput,
+            })),
+            ProvisionedThroughput: throughput,
+        });
+
+    private parseTableDefinition = async (path: string) => (
+        load(readFileSync(path).toString(), {
+            schema: CLOUDFORMATION_SCHEMA,
+        }) as ResourcesCloudformationDefinition
+    ).Resources;
+}
+
+type DynamoDbTableCloudFormationConfig = {
+    template: (name: string) => string;
+    resource: string,
+    tableName: (name: string) => string;
+    throughput: Throughput;
+}
+
+type ResourcesCloudformationDefinition = {
+    Resources: {
+        [name: string]: {
+            Properties: DynamoDbTableCloudformationDefinitionProperties
+        }
+    };
+}
+
+type DynamoDbTableCloudformationDefinitionProperties = {
+    TableName?: string;
+    KeySchema: KeySchemaElement[];
+    AttributeDefinitions: AttributeDefinition[];
+    GlobalSecondaryIndexes?: GlobalSecondaryIndex[];
+    TimeToLiveSpecification?: TimeToLiveSpecification;
+}
+
+type TimeToLiveSpecification = {
+    AttributeName: string;
+    Enabled: boolean;
+};
+
+type Throughput = { ReadCapacityUnits: number; WriteCapacityUnits: number }

package/src/cloudformation-event-proxy.ts

@@ -0,0 +1,61 @@
+import { SQSEvent, SQSRecord } from 'aws-lambda';
+import { CloudFormationSetup, CloudFormationSetupConfig } from './cloudformation';
+import { EventHandler } from './event-proxy';
+import { DevServerConfig } from './config';
+import { Startable } from './services';
+import { Message } from '@aws-sdk/client-sqs';
+
+export const snsEventsFromCloudFormationTemplate = (
+    name: string,
+    config: CloudFormationEventsProxyConfig,
+): Startable<EventHandler[]> =>
+    new CloudFormationEventsProxy(name, config);
+class CloudFormationEventsProxy extends CloudFormationSetup<
+    {
+        SqsSubscription: {
+            BatchSize: string;
+            QueueArn: string;
+            QueueUrl: string;
+        };
+        Topic: string;
+        FilterPolicy: {
+            [name: string]: string[];
+        };
+    },
+    (event: SQSEvent) => Promise<unknown>,
+    EventHandler,
+    EventHandler[]
+> {
+    constructor(name: string, config: CloudFormationEventsProxyConfig) {
+        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
+        );
+    }
+
+    protected afterStart = (_name: string, _config: DevServerConfig, routes: EventHandler[]) => routes;
+
+    logHandler(handler: EventHandler): string {
+        return `detected sns handler ${handler.name}`;
+    }
+}
+
+type CloudFormationEventsProxyConfig = {
+    topic?: string,
+    mapper?: (message: Message) => SQSRecord,
+    prepare?: (config: DevServerConfig) => Promise<void>,
+} & CloudFormationSetupConfig;

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

@@ -0,0 +1,125 @@
+import { CloudFormationSetup, CloudFormationSetupConfig } from './cloudformation';
+import { DevServerConfig } from './config';
+import { HttpSettings } from './http-server';
+import { Authorizer, Route, newLambdaHttpProxy } from './lambda-http-proxy';
+import { Callback, Service, Startable } from './services';
+import { LambdaMapperFactory, LambdaPayloadVersion, PathParameterResolver } from './mappers';
+
+const PATH_VARIABLE_CAPTURE = /{(.*?)}/g;
+const QUERY_STRING_OR_LOCATION_REG_EXP = '(?:([?#].*))?';
+const PROXY_PATH_PARAM = 'proxy';
+export const newLambdaProxyFromCloudFormationTemplate = <Context, AuthorizerContext, Event, HandlerResponse>(
+    name: string,
+    settings: HttpSettings,
+    payloadVersion: LambdaPayloadVersion<AuthorizerContext, Event, HandlerResponse>,
+    config: CloudFormationLambdaProxyConfig<Context, AuthorizerContext, Event, HandlerResponse>,
+    callback: Callback<string>,
+): Startable<Service<string>> => new CloudFormationLambdaProxy(name, settings, config.extraRoutes, payloadVersion, config, callback);
+
+class CloudFormationLambdaProxy<Context, AuthorizerContext, Event, HandlerResponse> extends CloudFormationSetup<
+    {
+        Path: string;
+        Method: string;
+    },
+    (event: Event) => Promise<HandlerResponse>,
+    Route<Context, AuthorizerContext, Event, HandlerResponse>,
+    Service<string>
+> {
+    private mapper: LambdaMapperFactory<AuthorizerContext, Event, HandlerResponse>;
+    private authorizer: (cfg: DevServerConfig) => Authorizer<AuthorizerContext>;
+    private pathParameterResolver: PathParameterResolver<Event>
+
+    constructor(
+        name: string,
+        private readonly settings: HttpSettings,
+        private readonly extraRoutes: Route<Context, AuthorizerContext, Event, HandlerResponse>[],
+        payloadVersion: LambdaPayloadVersion<AuthorizerContext, Event, HandlerResponse>,
+        config: CloudFormationLambdaProxyConfig<Context, AuthorizerContext, Event, HandlerResponse>,
+        private readonly callback?: Callback<string>,
+    ) {
+        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.mapper = payloadVersion.mapper;
+        this.authorizer = config?.authorizer;
+        this.pathParameterResolver = payloadVersion.resolver;
+    }
+
+    protected afterStart = (name: string, cfg: DevServerConfig, routes: Route<Context, AuthorizerContext, Event, HandlerResponse>[]) =>
+        newLambdaHttpProxy(
+            `${name}:apigw`,
+            {
+                settings: this.settings,
+                routes: this.extraRoutes.concat(routes),
+                authorizer: (this.authorizer || (() => undefined))(cfg),
+                mapper: this.mapper,
+            },
+            this.callback,
+        );
+
+    private computeWeight = (path: string) => this.segments(path) - this.variables(path);
+
+    private segments = (path: string) => path.split('/').length;
+    private variables = (path: string) => path.split('(?<').length;
+
+    logHandler(handler: Route<Context, AuthorizerContext, Event, HandlerResponse>): string {
+        return `detected handler for ${handler.method} on ${handler.path} with weight ${handler.weight}`;
+    }
+
+    private pathWithCapturingGroups = (source: string) =>
+        [...source.matchAll(PATH_VARIABLE_CAPTURE)].reduce(
+            (prev, curr) => prev.replaceAll(curr[0], `(?<${this.normalizeCaptureGroupName(curr[1]).replaceAll("+","")}>.*)`),
+            source,
+        );
+
+    private normalizeCaptureGroupName = (original: string) => (original === 'proxy+' ? PROXY_PATH_PARAM : original);
+
+    private pathParameterCapture =
+        (pathWithCapturingGroups: RegExp, handler: (event: Event, context?: Context) => Promise<HandlerResponse>, context?: () => Context) =>
+            async (event: 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?.());
+            };
+
+    private method = (cloudFormationValue: string) => {
+        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}`);
+        }
+    }
+}
+
+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;

package/src/cloudformation.ts

@@ -0,0 +1,95 @@
+import { CLOUDFORMATION_SCHEMA } from 'js-yaml-cloudformation-schema';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import { load } from 'js-yaml';
+import { Logger, LoggerFactory } from '@yopdev/logging';
+import { DevServerConfig } from './config';
+import { Startable } from './services';
+
+export abstract class CloudFormationSetup<P, H, R, F> implements Startable<F> {
+    private readonly template: (name: string) => string;
+    private readonly handlers: (name: string) => string;
+    private readonly handlerNameResolver: (name: string) => string;
+    private readonly LOGGER: Logger;
+    constructor(
+        readonly name: string,
+        private readonly eventFilter: (event: Event<P>) => boolean,
+        private readonly handlerResolver: (event: Event<P>, handler: H) => Promise<R>,
+        private readonly beforeStart: ((config: DevServerConfig) => Promise<void>) | undefined,
+        config: CloudFormationSetupConfig,
+    ) {
+        this.LOGGER = LoggerFactory.create(`CFN:FUNCTION[${name}]`);
+        this.template = config.template;
+        this.handlers = config.handlers;
+        this.handlerNameResolver = config.handlerNameResolver;
+    }
+    start = async (config: DevServerConfig) =>
+        (this.beforeStart || Promise.resolve)(config)
+            .then(this.resolvedHandlers)
+            .then(async (routes) => this.afterStart(this.name, config, routes));
+
+    protected abstract afterStart: (name: string, config: DevServerConfig, routes: R[]) => F;
+
+    private resolvedHandlers = async (): Promise<R[]> => {
+        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: H) =>
+                            (handler !== undefined) ?
+                                this.handlerResolver(event, handler) :
+                                Promise.reject(new Error(`function ${event.Handler} defined in ${resolve(template)} not found in ${resolve(functions)}`)))
+                        .then((handler) => {
+                            this.LOGGER.info(this.logHandler(handler));
+                            return handler;
+                        }),
+                ),
+            );
+        return Promise.all(routes);
+    };
+
+    abstract logHandler(handler: R): string;
+
+    private parseApiEvents = (path: string) =>
+        (
+            load(readFileSync(path).toString(), {
+                schema: CLOUDFORMATION_SCHEMA,
+            }) as {
+                Resources: {
+                    [name: string]: {
+                        Type: string;
+                        Properties: {
+                            Handler: string;
+                            Events: {
+                                [name: string]: Event<P>;
+                            };
+                        };
+                    };
+                };
+            }
+        ).Resources;
+}
+
+export type CloudFormationSetupConfig = {
+    template: (name: string) => string;
+    handlers: (name: string) => string;
+    handlerNameResolver: (name: string) => string;
+};
+
+type Event<P> = {
+    Type: string;
+    Properties: P;
+};

package/src/config.ts

@@ -0,0 +1,34 @@
+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/src/container.ts

@@ -0,0 +1,82 @@
+import { Logger, LoggerFactory } from '@yopdev/logging';
+import { GenericContainer, StartedTestContainer } from 'testcontainers';
+import { BindMount, Environment } from 'testcontainers/build/types';
+import { Callback, Lifecycle, Service } from './services';
+import { PortWithOptionalBinding } from 'testcontainers/build/utils/port';
+import { Readable } from 'stream';
+import { WaitStrategy } from 'testcontainers/build/wait-strategies/wait-strategy';
+import { DevServerConfig } from './config';
+
+export 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>,
+) =>
+    new Service(new Container(
+        name,
+        config.image,
+        config.networkAlias,
+        config.environment,
+        config.bindMounts,
+        config.exposedPorts,
+        config.logConsumer,
+        config.startup,
+        config.endpointBuilder,
+    ), callback);
+
+class Container implements Lifecycle<string> {
+    private readonly LOGGER: Logger;
+    private readonly container: GenericContainer;
+    private readonly endpointBuilder: (port: number) => string;
+    private started: StartedTestContainer | undefined;
+
+    constructor(
+        readonly name: string,
+        image: string,
+        private readonly networkAlias: string,
+        environment?: Environment,
+        bindMounts?: BindMount[],
+        exposedPorts?: PortWithOptionalBinding[],
+        logConsumer?: (stream: Readable) => unknown,
+        startup?: {
+            waitStrategy: WaitStrategy,
+            timeout: number
+        },
+        endpointBuilder?: (port: number) => string,
+    ) {
+        this.LOGGER = LoggerFactory.create(`CONTAINER[${name}]`);
+        const generic = new 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: number) => `http://localhost:${port}`);
+    }
+
+    start = async (config: DevServerConfig) =>
+        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));
+
+    stop = async () => (this.started ?? { stop: async () => { this.LOGGER.warn('no container') } }).stop().then(() => undefined);
+};

package/src/deferred.ts

@@ -0,0 +1,60 @@
+import { randomUUID } from "crypto";
+import { DevServerConfig } from "./config";
+import { Lifecycle, Service } from "./services";
+import { Logger, LoggerFactory } from "@yopdev/logging";
+
+export const lazy = <I>(lifecycle: (config: DevServerConfig) => Service<I>) => new Service(new Lazy(lifecycle));
+export const promised = <I>(lifecycle: (config: DevServerConfig) => Promise<Service<I>>) => new Service(new Promised(lifecycle));
+
+class Lazy<I> implements Lifecycle<I> {
+    private started: Lifecycle<I> | undefined;
+    private readonly LOGGER: Logger
+    readonly name: string;
+
+    constructor(private readonly configurable: (config: DevServerConfig) => Service<I>) {
+        this.started = undefined;
+        this.name = randomUUID();
+        this.LOGGER = LoggerFactory.create(`LAZY[${this.name}]`)
+    }
+
+    async start(config: DevServerConfig) {
+        const local = this.configurable(config);
+        this.started = local;
+        this.LOGGER.info('DISCOVERY:%s', local.name)
+        return local.start(config);
+    }
+
+    stop: () => Promise<void> = async () =>
+        this.withStartedOr(
+            async (s) => s.stop(),
+            async () => Promise.reject(new Error('not started')),
+        );
+
+    private withStartedOr<T>(task: (i: Lifecycle<I>) => T, fallback: () => T) {
+        const local = this.started;
+        if (local !== undefined) task(local);
+        else fallback();
+    }
+}
+
+class Promised<I> implements Lifecycle<I> {
+    private readonly LOGGER: Logger;
+    readonly name: string;
+    readonly start: (config: DevServerConfig) => Promise<I>
+    readonly stop: () => Promise<void>
+
+    constructor(configurable: (config: DevServerConfig) => Promise<Service<I>>) {
+        this.name = randomUUID();
+        this.LOGGER = LoggerFactory.create(`PROMISED[${this.name}]`)
+
+        let initialized: Service<I>
+        this.start = async (config: DevServerConfig) =>
+            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/src/dev-server.ts

@@ -0,0 +1,78 @@
+import { Network, RandomUuid, StartedNetwork } from "testcontainers";
+import { Config } from "./config";
+import { Service } from "./services";
+import { LocalStack } from "./localstack";
+import { Sqs } from "./sqs";
+import { DynamoDb } from "./dynamodb";
+import { Logger, LoggerFactory } from "@yopdev/logging";
+import { Sns } from "./sns";
+import { terminate } from "./tunnel";
+import { S3 } from "./s3";
+
+export class DevServer {
+    private readonly eventProxyTopic: string
+    private LOGGER: Logger
+    private localStack: LocalStack | undefined;
+    private network: StartedNetwork | undefined;
+
+    constructor(
+        readonly name: string,
+        private readonly service: Service<any>,
+        private readonly config?: Config,
+    ) {
+        this.LOGGER = LoggerFactory.create(`DEVSERVER[${name}]`)
+        const encodedName = Buffer.from(name).toString('hex').substring(0, 64)
+        this.eventProxyTopic = `EventProxyTopic${encodedName}`
+    }
+
+    start: () => Promise<StartedDevServer> = async () =>
+        Promise.resolve(new Network(new RandomUuid()).start())
+            .tap((network) => this.network = network)
+            .then((network) => ({
+                localStack: this.localStack = new LocalStack(network, this.config),
+                network: network
+            }))
+            .then((infra) => infra.localStack.start().then((config) => ({
+                aws: config,
+                network: infra.network
+            })))
+            .then((infra) => Promise
+                .resolve(new Sns(infra.aws))
+                .then((sns) => sns
+                    .createTopic(this.eventProxyTopic)
+                    .then((eventProxyTopicArn) => ({
+                        raw: infra.aws,
+                        network: infra.network,
+                        sqs: new Sqs(infra.aws),
+                        sns: new Sns(infra.aws),
+                        s3: new S3(infra.aws),
+                        dynamo: new 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')),
+            }))
+
+    private shutdown = async () => this.service.stop()
+        .finally(terminate)
+        .then(() => this.localStack?.stop())
+        .then(() => this.network?.stop().catch((e) => this.LOGGER.warn(e, 'failed to stop network')))
+}
+
+type StartedDevServer = {
+    name: string
+    stop: () => Promise<void>
+}