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

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

package/src/mappers.ts

@@ -0,0 +1,231 @@
+import { Message } from "@aws-sdk/client-sqs";
+import { APIGatewayEventRequestContextV2WithAuthorizer, APIGatewayProxyEvent, APIGatewayProxyEventHeaders, APIGatewayProxyEventPathParameters, APIGatewayProxyEventQueryStringParameters, APIGatewayProxyEventV2, APIGatewayProxyEventV2WithRequestContext, APIGatewayProxyResult, APIGatewayProxyStructuredResultV2, SQSRecord } from "aws-lambda";
+import { IncomingMessage } from "http";
+import { URL } from "url";
+import { Response } from "./lambda-http-proxy";
+
+export const mapToLambdaSqsRecord = (message: Message): SQSRecord => {
+    if (!message.Body) throw new Error('message Body must be present');
+
+    return {
+        messageId: 'N/A',
+        receiptHandle: 'N/A',
+        body: message.Body,
+        attributes: {
+            ApproximateReceiveCount: 'N/A',
+            SentTimestamp: 'N/A',
+            SenderId: 'N/A',
+            ApproximateFirstReceiveTimestamp: 'N/A',
+        },
+        messageAttributes: {},
+        md5OfBody: 'N/A',
+        eventSource: 'N/A',
+        eventSourceARN: 'N/A',
+        awsRegion: 'N/A',
+    };
+}
+
+const payloadV1JwtAuthorizerLambdaMapper = <AuthorizerContext>(): LambdaMapperFactory<AuthorizerContext, APIGatewayProxyEvent, APIGatewayProxyResult> => ({
+    newInstance: (request, body) => Promise.resolve(new DefaultLambdaMapper<AuthorizerContext>(request, body))
+})
+
+const payloadV2LambdaAuthorizerLambdaMapper = <AuthorizerContext>(): LambdaMapperFactory<AuthorizerContext, APIGatewayEventRequestContextV2WithGenericAuthorizer<AuthorizerContext>, APIGatewayProxyStructuredResultV2> => ({
+    newInstance: (request, body) => Promise.resolve(new DefaultLambdaMapper<AuthorizerContext>(request, body))
+})
+
+const payloadV1PathParameterResolver: PathParameterResolver<APIGatewayProxyEvent> = {
+    locate: (event: APIGatewayProxyEvent) => event.path,
+    store: (event: APIGatewayProxyEvent, params: APIGatewayProxyEventPathParameters) => event.pathParameters = params
+}
+
+const payloadV2PathParameterResolver: PathParameterResolver<APIGatewayProxyEventV2> = {
+    locate: (event: APIGatewayProxyEventV2) => event.rawPath,
+    store: (event: APIGatewayProxyEventV2, params: APIGatewayProxyEventPathParameters) => event.pathParameters = params
+}
+
+export type LambdaPayloadVersion<AuthorizerContext, Event, HandlerResponse> = {
+    mapper: LambdaMapperFactory<AuthorizerContext, Event, HandlerResponse>,
+    resolver: PathParameterResolver<Event>,
+}
+
+export const v1 = <AuthorizerContext>(): LambdaPayloadVersion<AuthorizerContext, APIGatewayProxyEvent, APIGatewayProxyResult> => ({
+    mapper: payloadV1JwtAuthorizerLambdaMapper<AuthorizerContext>(),
+    resolver: payloadV1PathParameterResolver,
+})
+
+export const v2 = <AuthorizerContext>(): LambdaPayloadVersion<AuthorizerContext, APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2> => ({
+    mapper: payloadV2LambdaAuthorizerLambdaMapper<AuthorizerContext>(),
+    resolver: payloadV2PathParameterResolver,
+})
+
+class DefaultLambdaMapper<AuthorizerContext> implements LambdaMapper<AuthorizerContext, APIGatewayProxyEvent & APIGatewayEventRequestContextV2WithGenericAuthorizer<AuthorizerContext>, APIGatewayProxyResult & APIGatewayProxyStructuredResultV2> {
+    private readonly url: URL
+    private readonly authorizationHeaderValue: string
+    private readonly time: number
+    private readonly method: string
+    private readonly queryStringParameters: APIGatewayProxyEventQueryStringParameters
+    private readonly headers: APIGatewayProxyEventHeaders
+
+    constructor(request: IncomingMessage, private readonly body: string) {
+        if (!request.url || !request.method) throw new Error('url and method are required');
+
+        const url = new URL(request.url, `http://${request.headers.host}`);
+
+        const qsp: APIGatewayProxyEventQueryStringParameters = {};
+        url.searchParams.forEach((v, k) => (qsp[k] = decodeURIComponent(v)));
+        this.queryStringParameters = qsp;
+
+        const headers: APIGatewayProxyEventHeaders = {};
+        if (request.headers['content-type']) headers['content-type'] = request.headers['content-type'];
+        if (request.headers['accept']) headers['accept'] = request.headers['accept'];
+        if (request.headers['origin']) headers['origin'] = request.headers['origin'];
+        if (request.headers['cookie']) headers['cookie'] = request.headers['cookie'];
+        const authorizationHeaderValue = request.headers['authorization']
+        if (authorizationHeaderValue) {
+            headers['authorization'] = authorizationHeaderValue;
+            this.authorizationHeaderValue = authorizationHeaderValue;
+        }
+        this.headers = headers
+        this.url = url
+        this.time = 1428582896000;
+        this.method = request.method
+    }
+
+    toResponse = (response: APIGatewayProxyResult | APIGatewayProxyStructuredResultV2) => response.isBase64Encoded ?
+        new Base64EncodedResponse(response.statusCode, response.headers?.['content-type']?.toString(), response.headers?.['location']?.toString(), response.body, this.readSetCookies(response)) :
+        new StringResponse(response.statusCode, response.headers?.['content-type']?.toString(), response.headers?.['location']?.toString(), response.body, this.readSetCookies(response))
+
+    private readSetCookies = (response: APIGatewayProxyResult | APIGatewayProxyStructuredResultV2): string[] => {
+        // V2: structured response with cookies array
+        if ('cookies' in response && Array.isArray(response.cookies)) {
+            return response.cookies;
+        }
+
+        // V1: check multiValueHeaders first
+        if ('multiValueHeaders' in response && response.multiValueHeaders?.['Set-Cookie']) {
+            return response.multiValueHeaders['Set-Cookie'].map(c => c.toString());
+        }
+
+        // V1: fallback to single header
+        if ('headers' in response && response.headers?.['Set-Cookie']) {
+            const cookieHeader = response.headers['Set-Cookie'];
+            return Array.isArray(cookieHeader) ? cookieHeader.map(c => c.toString()) : [cookieHeader];
+        }
+
+        return [];
+    };
+
+    event = (context: AuthorizerContext): APIGatewayProxyEvent & APIGatewayEventRequestContextV2WithGenericAuthorizer<AuthorizerContext> => ({
+        version: '2.0',
+        rawPath: this.url.pathname,
+        rawQueryString: this.url.search,
+        routeKey: '',
+        httpMethod: this.method,
+        body: this.body,
+        headers: this.headers,
+        path: this.url.pathname,
+        pathParameters: null,
+        queryStringParameters: this.queryStringParameters,
+        resource: '',
+        multiValueHeaders: {},
+        isBase64Encoded: false,
+        multiValueQueryStringParameters: null,
+        stageVariables: null,
+        requestContext: {
+            domainName: this.headers.host,
+            domainPrefix: '',
+            http: {
+                method: this.method,
+                path: this.url.pathname,
+                protocol: 'http',
+                sourceIp: '127.0.0.1',
+                userAgent: this.headers['user-agent'],
+            },
+            routeKey: '',
+            time: new Date(this.time).toString(),
+            timeEpoch: this.time,
+            accountId: '',
+            apiId: '',
+            authorizer: context,
+            httpMethod: '',
+            identity: {
+                accessKey: '',
+                accountId: '',
+                apiKey: '',
+                apiKeyId: '',
+                caller: '',
+                clientCert: {
+                    clientCertPem: '',
+                    issuerDN: '',
+                    serialNumber: '',
+                    subjectDN: '',
+                    validity: { notAfter: '', notBefore: '' },
+                },
+                cognitoAuthenticationProvider: '',
+                cognitoAuthenticationType: '',
+                cognitoIdentityId: '',
+                cognitoIdentityPoolId: '',
+                principalOrgId: '',
+                sourceIp: '',
+                user: '',
+                userAgent: '',
+                userArn: '',
+            },
+            path: '',
+            protocol: '',
+            requestId: '',
+            requestTimeEpoch: this.time,
+            resourceId: '',
+            resourcePath: '',
+            stage: '',
+        }
+    })
+
+    authorization = () => this.authorizationHeaderValue
+}
+interface LambdaMapper<AuthorizerContext, Event, HandlerResponse> {
+    event(context: AuthorizerContext): Event
+    authorization(): string
+    toResponse: (response: HandlerResponse) => Response
+}
+
+export interface LambdaMapperFactory<AuthorizerContext, Event, LambdaResponse> {
+    newInstance(request: IncomingMessage, body: string): Promise<LambdaMapper<AuthorizerContext, Event, LambdaResponse>>;
+}
+
+class StringResponse extends Response {
+    readonly body: () => string
+
+    constructor(
+        statusCode: number,
+        contentType: string | undefined,
+        location: string | undefined,
+        body: string | undefined,
+        cookies: string[] | undefined
+    ) {
+        super(statusCode, contentType, location, cookies)
+        this.body = () => body;
+    }
+}
+
+class Base64EncodedResponse extends Response {
+    readonly body: () => Buffer
+
+    constructor(
+        statusCode: number,
+        contentType: string | undefined,
+        location: string | undefined,
+        body: string,
+        cookies: string[] | undefined,
+    ) {
+        super(statusCode, contentType, location, cookies)
+        this.body = () => Buffer.from(body, 'base64')
+    }
+}
+
+type APIGatewayEventRequestContextV2WithGenericAuthorizer<AuthorizerContext> = APIGatewayProxyEventV2WithRequestContext<APIGatewayEventRequestContextV2WithAuthorizer<AuthorizerContext>>;
+
+export type PathParameterResolver<Event> = {
+    locate: (event: Event) => string
+    store: (event: Event, params: APIGatewayProxyEventPathParameters) => void
+}

package/src/pre-traffic-hooks.ts

@@ -0,0 +1,24 @@
+import { Logger, LoggerFactory } from '@yopdev/logging';
+import { Lifecycle, Service } from './services';
+
+export const newPreTrafficHooks = (
+    name: string,
+    hooks: () => Promise<void>[],
+) => new Service(new PreTrafficHooks(name, hooks))
+
+class PreTrafficHooks implements Lifecycle<void> {
+    private LOGGER: Logger
+    constructor(
+        readonly name: string,
+        private readonly hooks: () => Promise<void>[]
+    ) {
+        this.LOGGER = LoggerFactory.create(`PRETRAFFIC[${name}]`);
+        this.LOGGER.info('%i hooks registered', hooks.length);
+    }
+
+    start = async () => Promise
+        .all(this.hooks())
+        .then(() => undefined)
+
+    stop = async () => Promise.resolve()
+}

package/src/responses.ts

@@ -0,0 +1,28 @@
+import { LoggerFactory } from '@yopdev/logging';
+import { ServerResponse } from 'http';
+
+const LOG = LoggerFactory.create('RESPONSES');
+export function internalServerError(res: ServerResponse, body: any) {
+    LOG.error(body, 'internal server error handled');
+    return writeResponse(res, 500, 'internal server error. check system logs');
+}
+
+export function writeResponse(
+    res: ServerResponse,
+    statusCode: number,
+    body: string | Buffer,
+    contentType?: string,
+    location?: string,
+    cookies?: string[],
+) {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', '*');
+    res.setHeader('Access-Control-Allow-Headers', '*');
+    if (cookies) {
+        res.setHeader('Set-Cookie', cookies);
+    }
+    if (contentType) res.setHeader('Content-Type', contentType);
+    if (location) res.setHeader('Location', location);
+    res.statusCode = statusCode;
+    res.end(body);
+}

package/src/s3.ts

@@ -0,0 +1,24 @@
+import { CORSConfiguration, CORSRule, CreateBucketCommand, PutBucketCorsCommand, S3Client } from '@aws-sdk/client-s3';
+import { AwsConfig } from './config';
+import { LoggerFactory } from '@yopdev/logging';
+
+const LOGGER = LoggerFactory.create('S3')
+export class S3 {
+    readonly client: S3Client;
+
+    constructor(aws: AwsConfig) {
+        this.client = new S3Client({ forcePathStyle: true, ...aws });
+    }
+
+    createBucket = async (name: string, cors?: CORSConfiguration) =>
+        this.client.send(
+            new CreateBucketCommand({
+                Bucket: name,
+            }),
+        )
+            .then(() => cors && this.client.send(new PutBucketCorsCommand({
+                Bucket: name,
+                CORSConfiguration: cors
+            })))
+            .tap(() => LOGGER.debug('bucket %s created', name))
+}