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

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()),
+        },
+    );

package/src/http-server.ts

@@ -0,0 +1,59 @@
+import { IncomingMessage, Server, ServerResponse, createServer } from "http";
+import { once } from "events";
+import { Logger, LoggerFactory } from "@yopdev/logging";
+import { AddressInfo } from "net";
+import { assertNotUndefined } from "./assert";
+import { Lifecycle, Service, Callback } from "./services";
+
+export const newHttpServer = (
+    name: string,
+    config: {
+        settings: HttpSettings,
+        handler: (request: IncomingMessage, requestBody: string, response: ServerResponse) => void,
+    },
+    callback?: Callback<string>,
+) => new Service(new HttpServer(name, config.settings, config.handler), callback)
+
+export class HttpServer implements Lifecycle<string> {
+    private LOGGER: Logger
+    private readonly protocol: string
+    private address: AddressInfo | undefined
+    private readonly server: Promise<Server>
+
+    constructor(
+        readonly name: string,
+        readonly settings: HttpSettings,
+        readonly handler: (request: IncomingMessage, requestBody: string, response: ServerResponse) => void,
+    ) {
+        const server = createServer((req, res) => {
+            req.setEncoding('utf-8')
+
+            let body = ''
+
+            req.on('data', (chunks) => body = body.concat(chunks));
+            req.on('end', () => handler(req, body, res));
+        })
+            .listen(settings.port, settings.host, () => this.address = server.address() as AddressInfo)
+        this.server = once(server, 'listening')
+            .then(() => server)
+        this.protocol = settings.protocol
+        this.LOGGER = LoggerFactory.create(`HTTPSERVER[${name}]`);
+    }
+
+    start = () => this.server
+        .then(() => this.LOGGER.debug('listening [%s]', assertNotUndefined(this.address).port))
+        .then(() => this.endpointUrl())
+
+    private endpointUrl = () => {
+        const address = assertNotUndefined(this.address, 'server not started')
+        return `${this.protocol}//${address.address}:${address.port}/`
+    }
+
+    stop = () => this.server.then((server) => server.close()).then(() => undefined)
+}
+
+export type HttpSettings = {
+    protocol: string
+    host: string
+    port: number | undefined
+}

package/src/index.ts

@@ -0,0 +1,32 @@
+export { DevServer } from './dev-server' 
+export { newHttpServer as httpServer, HttpSettings } from './http-server' 
+export { newLambdaHttpProxy as lambdaHttpProxy, UNAUTHORIZED } from './lambda-http-proxy'
+export { v1 as v1LambdaProxyPayload, v2 as v2LambdaProxyPayload } from './mappers'
+export { newLambdaProxyFromCloudFormationTemplate as cloudFormationLambdaProxy } from './cloudformation-lambda-http-proxy'
+export { newDynamoDbTableFromCloudFormationTemplate as cloudFormationDynamoDbTable } from './cloudformation-dynamodb-table'
+export { newSnsHttpProxy as snsHttpProxy } from './sns-http-proxy'
+export { newInternalQueue as internalQueue } from './internal-queue'
+export { newEventsProxy as eventsProxy } from './event-proxy'
+export { snsEventsFromCloudFormationTemplate as cloudFormationSnsEventHandlers } from './cloudformation-event-proxy'
+export { newScheduledTasks as scheduledTasks } from './scheduled-tasks'
+export { newPreTrafficHooks as preTrafficHooks } from './pre-traffic-hooks'
+export { newDynamoDbTable as dynamoDbTable } from './dynamodb'
+export { newContainer as container } from './container' 
+export { newTunnel as tunnel } from './tunnel'
+export { all as allOf, oneThenOther } from './factories' 
+export { lazy, promised } from './deferred'
+export { Lifecycle, Service, Startable } from './services'
+export { DevServerConfig } from './config'
+
+declare global {
+    interface Promise<T> {
+        tap(onfulfilled?: (value: T) => void, onrejected?: (reason: unknown) => void): Promise<T>;
+    }
+}
+
+Promise.prototype.tap = async function <T>(
+    onfulfilled?: (value: T) => void,
+    onrejected?: (reason: unknown) => void,
+): Promise<any> {
+    return this.then(onfulfilled, onrejected).then(async () => this);
+};

package/src/internal-queue.ts

@@ -0,0 +1,89 @@
+import { Logger, LoggerFactory } from "@yopdev/logging";
+import { Queue, Sqs } from "./sqs";
+import { SQSEvent, SQSRecord } from "aws-lambda";
+import { Consumer } from "sqs-consumer";
+import { stopConsumer } from "./stoppable";
+import { mapToLambdaSqsRecord } from "./mappers";
+import { Lifecycle, Service, Callback } from "./services";
+import { DevServerConfig } from "./config";
+import { Message, SQSClient } from "@aws-sdk/client-sqs";
+
+export const newInternalQueue = (
+    name: string,
+    config: {
+        name: string,
+        visibility: number,
+        handler: (queue: Queue) => (e: SQSEvent) => Promise<void>,
+        fifo: boolean,
+        mapper?: (message: Message) => SQSRecord,
+    },
+    callback?: Callback<string>
+) => new Service(new InternalQueue(
+    name,
+    config.visibility,
+    config.handler,
+    (sqs: Sqs) => config.fifo ? sqs.createFifoQueue : sqs.createStandardQueue,
+    config.mapper ?? mapToLambdaSqsRecord,
+), callback)
+
+class InternalQueue implements Lifecycle<string> {
+    private LOGGER: Logger
+
+    private consumer: Consumer | undefined;
+
+    constructor(
+        readonly name: string,
+        private readonly visibility: number,
+        private readonly handler: (queue: Queue) => ((e: SQSEvent) => Promise<void>),
+        private readonly creator: (sqs: Sqs) => (name: string) => Promise<Queue>,
+        private readonly mapper: (message: Message) => SQSRecord,
+    ) {
+        this.LOGGER = LoggerFactory.create(`INTERNALQUEUE[${name}]`);
+    }
+
+    start = (config: DevServerConfig) => this.create(config.sqs)
+
+    private create = async (sqs: Sqs) => this.createQueue(sqs, this.name)
+        .then((queue) => this
+            .createConsumer(sqs.client, this.name, queue.url, this.handler(queue), this.visibility)
+            .then(() => queue.url)
+        )
+
+    private async createQueue(sqs: Sqs, name: string) {
+        return this.creator(sqs)(name) //
+            .then((queue) => {
+                this.LOGGER.info('created: %s', queue.url);
+                return queue;
+            });
+    }
+
+    private createConsumer = async (
+        sqs: SQSClient,
+        name: string,
+        url: string,
+        handler: (e: SQSEvent) => Promise<void>,
+        visibility: number,
+    ): Promise<InternalQueue> => Promise.resolve(() =>
+        this.consumer = Consumer.create({
+            queueUrl: url,
+            waitTimeSeconds: visibility,
+            sqs: sqs,
+            handleMessage: async (message) => handler({ Records: [this.mapper(message)] }),
+        }))
+        .then((factory) => factory())
+        .then((consumer) => {
+            consumer.on('error', (err) => {
+                this.LOGGER.error(err, 'failed to handle message');
+            });
+            consumer.on('processing_error', (err) => {
+                this.LOGGER.error(err, 'failed to process message');
+            });
+            this.LOGGER.info('consumer for %s initialized', name);
+            return consumer;
+        })
+        .then(async (consumer) => consumer.start())
+        .then(() => this.LOGGER.info('started'))
+        .then(() => this)
+
+    stop = async () => this.consumer !== undefined ? stopConsumer(this.visibility, this.consumer) : this.LOGGER.warn('no consumer')
+}

package/src/lambda-http-proxy.ts

@@ -0,0 +1,111 @@
+import { Logger, LoggerFactory } from "@yopdev/logging";
+import { HttpServer, HttpSettings } from "./http-server";
+import { IncomingMessage, ServerResponse } from "http";
+import { LambdaMapperFactory } from "./mappers";
+import { internalServerError, writeResponse } from "./responses";
+import { Lifecycle, Service, Callback } from "./services";
+
+export const UNAUTHORIZED = new Error('UNAUTHORIZED');
+export const newLambdaHttpProxy = <Context, AuthorizerContext, Event, HandlerResponse>(
+    name: string,
+    config: {
+        settings: HttpSettings,
+        routes: Route<Context, AuthorizerContext, Event, HandlerResponse>[],
+        mapper: LambdaMapperFactory<AuthorizerContext, Event, HandlerResponse>,
+        authorizer?: Authorizer<AuthorizerContext>
+        context?: () => Context
+    },
+    callback?: Callback<string>,
+) => new Service(new LambdaHttpProxy<Context, AuthorizerContext, Event, HandlerResponse>(
+    name,
+    config.settings,
+    config.routes,
+    config.mapper,
+    config.authorizer ?? (() => Promise.resolve(undefined)),
+    config.context,
+), callback)
+
+class LambdaHttpProxy<Context, AuthorizerContext, Event, HandlerResponse> implements Lifecycle<string> {
+    private LOGGER: Logger
+    private readonly server: HttpServer
+
+    constructor(
+        readonly name: string,
+        settings: HttpSettings,
+        private readonly routes: Route<Context, AuthorizerContext, Event, HandlerResponse>[],
+        private readonly mapper: LambdaMapperFactory<AuthorizerContext, Event, HandlerResponse>,
+        private readonly defaultAuthorizer: Authorizer<AuthorizerContext>,
+        private readonly context: () => Context = () => undefined,
+    ) {
+        this.server = new HttpServer(name, settings, this.resolveRoute)
+        this.LOGGER = LoggerFactory.create(`HTTP->LAMBDA[${this.name}]`);
+        this.LOGGER.info('registered %i routes', routes.length)
+    }
+
+    start = () => this.server.start()
+
+    stop = () => this.server.stop()
+
+    private handler = (
+        authorizer: Authorizer<AuthorizerContext>,
+        lambdaHandler: (event: Event, context: Context) => Promise<HandlerResponse>
+    ) =>
+        (request: IncomingMessage, body: string, response: ServerResponse) =>
+            this.mapper.newInstance(request, body)
+                .then(async (mapper) =>
+                    authorizer(mapper.authorization())
+                        .then(async (context) =>
+                            lambdaHandler(mapper.event(context), this.context())
+                                .then((lambda) => {
+                                    const result = mapper.toResponse(lambda)
+                                    return writeResponse(
+                                        response,
+                                        result.statusCode,
+                                        result.body(),
+                                        result.contentType,
+                                        result.location,
+                                        result.cookies,
+                                    )
+                                })
+                                .catch((e) => {
+                                    this.LOGGER.error(e, 'request failed to execute');
+                                    internalServerError(response, e.body);
+                                }),
+                            (e) => e === UNAUTHORIZED ? writeResponse(response, 401, '') : internalServerError(response, e))
+                )
+
+    private fallback = async (request: IncomingMessage, _: string, response: ServerResponse) =>
+        Promise.resolve(this.LOGGER.warn(`FALLBACK: ${request.method} to ${request.url}`)).then(() =>
+            writeResponse(
+                response,
+                404,
+                `no route found to handle ${request.method} to ${request.url}`
+            ))
+
+    private resolveRoute = (request: IncomingMessage, body: string, response: ServerResponse) =>
+        (this.routes.filter((r) => r.method.test(request.method))
+            .filter((r) => r.path.test(request.url))
+            .sort((r1, r2) => r2.weight - r1.weight)
+            .map((r) => this.handler(r.authorizer ?? this.defaultAuthorizer, r.handler))
+            .find(() => true) ?? this.fallback)(request, body, response)
+}
+
+export abstract class Response {
+    constructor(
+        readonly statusCode: number,
+        readonly contentType: string | undefined,
+        readonly location: string | undefined,
+        readonly cookies: string[] | undefined,
+    ) { }
+    body: () => string | Buffer | undefined
+}
+
+export type Route<Context, AuthorizerContext, Event, HandlerResponse> = {
+    method: RegExp;
+    path: RegExp;
+    weight: number;
+    authorizer?: Authorizer<AuthorizerContext>;
+    handler: (event: Event, context: Context) => Promise<HandlerResponse>;
+};
+
+export type Authorizer<Context> = (authorization: string) => Promise<Context | undefined>;

package/src/localstack.ts

@@ -0,0 +1,74 @@
+import { LoggerFactory } from "@yopdev/logging";
+import { GenericContainer, StartedNetwork, StartedTestContainer } from "testcontainers";
+import { AwsConfig, Config } from "./config";
+import { Stoppable } from "./services";
+
+const LOGGER = LoggerFactory.create('LOCALSTACK');
+const SERVICES_PORT = 4566;
+const NETWORK_ALIAS = 'localstack';
+const PROTOCOL = 'http';
+const DEFAULT_DOCKER_IMAGE = 'localstack/localstack:stable'
+export class LocalStack implements Stoppable {
+    private readonly _start: () => Promise<string>
+    private started: StartedTestContainer | undefined
+
+    constructor(network: StartedNetwork, config?: Config) {
+        const concreteConfig = this.configOrDefaults(config)
+        const container = new GenericContainer(concreteConfig.localStackDockerImage)
+        const localStatePath = concreteConfig.localStateBindMount
+        const withLocalState = localStatePath !== undefined ?
+            container
+                .withEnvironment({
+                    PERSISTENCE: '1',
+                    DYNAMODB_REMOVE_EXPIRED_ITEMS: '1',
+                })
+                .withBindMounts([{
+                    source: localStatePath,
+                    target: '/var/lib/localstack',
+                    mode: 'rw',
+                }])
+            : container
+        const ready = withLocalState
+            .withExposedPorts(concreteConfig.exposedPort)
+            .withNetwork(network)
+            .withNetworkAliases(NETWORK_ALIAS)
+
+        this._start = () => ready
+            .start()
+            .then((container) => this.started = container)
+            .then((container) => `${PROTOCOL}://${container.getHost()}:${container.getMappedPort(SERVICES_PORT)}`)
+    }
+
+    private configOrDefaults(config?: Config): LocalStackConfig {
+        const selectedServicesPort = config?.boundServicesPort
+        const exposedPort = selectedServicesPort !== undefined ?
+            { container: SERVICES_PORT, host: selectedServicesPort } :
+            SERVICES_PORT
+        return {
+            localStackDockerImage: config?.localStackDockerImage || DEFAULT_DOCKER_IMAGE,
+            exposedPort: exposedPort,
+            localStateBindMount: config?.localStateBindMount,
+        }
+    }
+
+    start = async (): Promise<AwsConfig> => this._start()
+        .then((endpoint) => ({
+            region: 'us-east-1',
+            endpoint: endpoint,
+            credentials: {
+                accessKeyId: 'dummy',
+                secretAccessKey: 'dummy'
+            }
+        }))
+        .tap(() => LOGGER.debug('started'))
+
+    stop = () => Promise.resolve(this.started)
+        .then((container) => container ? container.stop().then(() => 'stopped') : 'not started')
+        .then((status) => LOGGER.debug(status))
+}
+
+type LocalStackConfig = {
+    localStackDockerImage: string
+    exposedPort: { container: number, host: number } | number
+    localStateBindMount: string | undefined
+}