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

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>
+}

package/src/dynamodb.ts

@@ -0,0 +1,62 @@
+import { CreateTableCommand, DynamoDBClient, UpdateTimeToLiveCommand } from "@aws-sdk/client-dynamodb";
+import { AwsConfig, DevServerConfig } from "./config";
+import { Logger, LoggerFactory } from "@yopdev/logging";
+import { Lifecycle, Service, Callback } from "./services";
+import { assertNotUndefined } from "./assert";
+
+export const newDynamoDbTable = (
+    name: string,
+    config: {
+        command: CreateTableCommand,
+        ttlAttribute?: string,
+    },
+    callback?: Callback<string>,
+) => new Service(new DynamoDbTableCreator(name, config.command, config.ttlAttribute), callback)
+
+class DynamoDbTableCreator implements Lifecycle<string> {
+    private LOGGER: Logger;
+    constructor(
+        readonly name: string,
+        private readonly command: CreateTableCommand,
+        private readonly ttlAttribute: string | undefined,
+    ) {
+        this.LOGGER = LoggerFactory.create(`TABLE[${name}]`)
+    }
+
+    start = async (config: DevServerConfig) => config.dynamo.createTable(this.command)
+        .tap((output) => this.LOGGER.debug(output))
+        .then(() => this.ttlAttribute)
+        .then((ttl) => ttl !== undefined ? this.setupTimeToLive(config.dynamo, ttl) : Promise.resolve())
+        .then(() => this.name)
+
+    private setupTimeToLive = async (dynamodb: DynamoDb, attributeName: string) =>
+        dynamodb.client.send(new UpdateTimeToLiveCommand({
+            TableName: this.command.input.TableName,
+            TimeToLiveSpecification: {
+                Enabled: true,
+                AttributeName: attributeName,
+            }
+        }))
+            .tap((out) => this.LOGGER.info('set ttl attribute %s? %s', attributeName, out.$metadata.httpStatusCode === 200))
+            .then(() => undefined)
+
+    stop = () => Promise.resolve()
+}
+
+const LOGGER = LoggerFactory.create('DYNAMODB');
+export class DynamoDb {
+    readonly client: DynamoDBClient
+
+    constructor(config: AwsConfig) {
+        this.client = new DynamoDBClient(config)
+    }
+
+    createTable = async (factory: CreateTableCommand) => this.client
+        .send(factory) //
+        .tap((table) => LOGGER.debug('created %s', assertNotUndefined(table.TableDescription).TableName))
+        .catch((reason) => {
+            LOGGER.error('failed to create table')
+            if (reason.name !== 'ResourceInUseException') return Promise.reject(reason);
+            return { TableDescription: { TableName: factory.input.TableName } }
+        })
+}

package/src/event-proxy.ts

@@ -0,0 +1,101 @@
+import { Consumer } from 'sqs-consumer';
+import { SNSMessage, SNSMessageAttributes, SQSEvent, SQSRecord } from 'aws-lambda';
+import { mapToLambdaSqsRecord } from './mappers';
+import { Sns } from './sns';
+import { Sqs } from './sqs';
+import { Message, SQSClient } from '@aws-sdk/client-sqs';
+import { Logger, LoggerFactory } from '@yopdev/logging';
+import { stopConsumer } from './stoppable';
+import { assertNotUndefined } from './assert';
+import { Lifecycle, Service } from './services';
+import { DevServerConfig } from './config';
+
+export const newEventsProxy = (
+    name: string,
+    config: {
+        handlers: EventHandler[],
+        topic?: string,
+        mapper?: (message: Message) => SQSRecord,
+    },
+) => new Service(new EventsProxy(name, config.handlers, config.mapper ?? mapToLambdaSqsRecord, config.topic))
+class EventsProxy implements Lifecycle<void> {
+    private LOGGER: Logger
+    private consumer: Consumer | undefined;
+    private readonly pollingFrequency = 1;
+    private stopped = true;
+
+    constructor(
+        readonly name: string,
+        private readonly handlers: EventHandler[],
+        private readonly mapper: (message: Message) => SQSRecord,
+        private readonly topic?: string,
+    ) {
+        this.LOGGER = LoggerFactory.create(`SNS->SQS[${name}]`);
+        this.LOGGER.debug(
+            'handling events from %s',
+            topic ?? 'the event bus',
+        );
+    }
+    
+    private queueName = () => `EventProxyQueue${Buffer.from(this.name).toString('hex').substring(0, 64)}`
+
+    start = async (config: DevServerConfig) => this.queueConnectedToTopic(config.sns, this.topic ?? config.eventsProxy.topic.arn, config.sqs, this.queueName())
+        .then((url) => this.startEventsConsumer(config.sqs.client, url))
+        .tap(() => this.stopped = false)
+        .then((consumer) => this.LOGGER.debug(consumer))
+
+    private queueConnectedToTopic = async (sns: Sns, topic: string, sqs: Sqs, queue: string) => sqs.createStandardQueue(queue)
+        .then((queue) => sns
+            .createSubscription({ arn: topic }, { arn: queue.arn })
+            .then(() => queue.url)
+        )
+
+    private startEventsConsumer = async (sqs: SQSClient, url: string): Promise<string> => {
+        this.consumer = Consumer.create({
+            waitTimeSeconds: this.pollingFrequency,
+            queueUrl: url,
+            sqs: sqs,
+            handleMessage: async (message) => this.onEachMessage(message),
+        });
+        this.consumer.start();
+        return url;
+    }
+
+    private extractErrorMessage = (e: any) => typeof e === 'string' ? e : e.message !== undefined && typeof e.message === 'string' ? e.message : ''
+
+    private onEachMessage = async (message: Message) => {
+        if (this.stopped) {
+            this.LOGGER.warn('stopped events proxy received message %o', message);
+            return;
+        }
+        const body = assertNotUndefined(message.Body, 'body is not present');
+        const json = JSON.parse(body) as SNSMessage
+        const attributes = json.MessageAttributes
+        const subject = json.Subject;
+
+        const handlers = this.handlers.filter((handler) => handler.matcher(subject, attributes));
+        if (handlers.length === 0) {
+            this.LOGGER.warn('no handlers found for message %o', message);
+        }
+        const record = this.mapper(message);
+        return Promise.all(handlers.map((handler) =>
+            handler
+                .handler({ Records: [record] })
+                .then(() => {
+                    this.LOGGER.debug('handler %s accepted message', handler.name);
+                })
+                .catch((e) => {
+                    const error = this.extractErrorMessage(e);
+                    this.LOGGER.error(e, 'handler %s failed with %s', handler.name, error);
+                })
+        )).then(() => undefined)
+    }
+
+    stop = async () => stopConsumer(this.pollingFrequency, this.consumer)
+}
+
+export type EventHandler = {
+    name: string;
+    handler: (event: SQSEvent) => Promise<unknown>;
+    matcher: (subject: string, attributes: SNSMessageAttributes) => boolean;
+};

package/src/factories.ts

@@ -0,0 +1,19 @@
+import { DevServerConfig } from "./config";
+import { Service } from "./services";
+
+export const all = (services: Service<any>[]): Service<any> => new Service(
+    {
+        name: `ALLOF[${services.map((each) => each.name).join(',')}]`,
+        start: async (config: DevServerConfig) => Promise.all(services.map((each) => each.start(config))).then(() => this),
+        stop: async () => Promise.all(services.map((each) => each.stop())).then()
+    },
+)
+
+export const oneThenOther = (one: Service<unknown>, other: Service<unknown>): Service<unknown> =>
+    new Service(
+        {
+            name: `[${one.name}]->[${other.name}]`,
+            start: async (config: DevServerConfig) => one.start(config).then(async () => other.start(config)),
+            stop: async () => other.stop().then(async () => one.stop()),
+        },
+    );