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

package/src/scheduled-tasks.ts

@@ -0,0 +1,31 @@
+import { Logger, LoggerFactory } from '@yopdev/logging';
+import { clearInterval } from 'timers';
+import { Lifecycle, Service } from './services';
+
+export const newScheduledTasks = (
+    name: string,
+    schedules: Rate[],
+) => new Service(new ScheduledTasks(name, schedules))
+
+class ScheduledTasks implements Lifecycle<void> {
+    private LOGGER: Logger
+    
+    constructor(readonly name: string, private readonly schedules: Rate[]) {
+        this.LOGGER = LoggerFactory.create(`SCHEDULER[${name}]`)
+        this.LOGGER.info('registered %i scheduled tasks', schedules.length);
+    }
+
+    intervals: NodeJS.Timeout[] = [];
+
+    start = async () => Promise.resolve(
+        this.schedules.forEach((schedule) => this.intervals.push(setInterval(schedule.task, schedule.frequency * 1000)))
+    )
+        .then(() => undefined)
+
+    stop = async () => Promise.resolve(this.intervals.forEach((interval) => clearInterval(interval)))
+}
+
+export type Rate = {
+    frequency: number;
+    task: () => Promise<unknown>;
+}

package/src/services.ts

@@ -0,0 +1,46 @@
+import { Logger, LoggerFactory } from "@yopdev/logging";
+import { DevServerConfig } from "./config";
+
+export interface Lifecycle<I> extends Startable<I>, Stoppable {
+    name: string
+}
+
+export interface Startable<T> {
+    start(config: DevServerConfig): Promise<T>
+}
+export interface Stoppable {
+    stop(): Promise<void>;
+}
+
+export type Callback<I> = (instance: I) => Promise<void>
+
+export class Service<I> implements Lifecycle<I> {
+    private readonly DEFAULT_CALLBACK: Callback<unknown> = () => Promise.resolve(this.LOGGER.debug('no callback'));
+
+    readonly name: string
+    readonly start: (config: DevServerConfig) => Promise<I>
+    readonly stop: () => Promise<void>
+    private doStop: () => Promise<void>
+    private readonly LOGGER: Logger
+
+    constructor(service: Lifecycle<I>, private readonly callback?: Callback<I>) {
+        this.name = service.name
+        this.LOGGER = LoggerFactory.create(`SERVICE[${this.name}]`)
+        const stop = async () => service.stop()
+        this.start = (config: DevServerConfig) => service.start(config)
+            .catch((error) => stop()
+                .then(() => this.doStop = () => Promise.resolve(this.LOGGER.error(error, 'failed')))
+                .then(() => Promise.reject(error))
+            )
+            .then((started) => this
+                .callbackOrDefault(started)
+                .then(() => this.LOGGER.info('started'))
+                .then(() => started)
+            )
+        this.doStop = () => stop()
+            .then(() => this.LOGGER.info('stopped'))
+        this.stop = () => this.doStop();
+    }
+
+    private callbackOrDefault = async (instance: I) => (this.callback ?? this.DEFAULT_CALLBACK)(instance)
+}

package/src/sns-http-proxy.ts

@@ -0,0 +1,109 @@
+import { Logger, LoggerFactory } from "@yopdev/logging";
+import { HttpServer, HttpSettings } from "./http-server";
+import { Sns } from "./sns";
+import { IncomingMessage, ServerResponse } from "http";
+import { MessageAttributeValue } from "@aws-sdk/client-sns";
+import { internalServerError, writeResponse } from "./responses";
+import { Lifecycle, Service, Callback } from "./services";
+import { DevServerConfig } from "./config";
+import { assertNotUndefined } from "./assert";
+
+export const newSnsHttpProxy = (
+    name: string,
+    config: {
+        settings: HttpSettings,
+        method: string,
+        subject?: string,
+        topic?: string,
+    },
+    callback?: Callback<string>,
+) => new Service(new SnsHttpProxy(name, config.settings, config.method, config.subject, config.topic), callback)
+
+export class SnsHttpProxy implements Lifecycle<string> {
+    private LOGGER: Logger
+    private server: HttpServer
+    private config: {
+        topic: string
+        sns: Sns
+    } | undefined
+
+    constructor(
+        readonly name: string,
+        private readonly settings: HttpSettings,
+        private readonly method: string,
+        private readonly subject?: string,
+        private readonly topic?: string,
+    ) {
+        this.server = new HttpServer(
+            this.name,
+            this.settings,
+            this.handler(this.method, this.subject)
+        )
+        this.LOGGER = LoggerFactory.create(`HTTP->SNS[${name}]`)
+        this.LOGGER.info(
+            'forwarding %s %s events to %s',
+            subject ? `events with ${subject} subject` : 'all',
+            method,
+            topic ?? 'the event bus',
+        );
+    }
+
+    start = (config: DevServerConfig) => Promise.resolve(this.server)
+        .then(server => server.start())
+        .tap(() => {
+            this.config = {
+                topic: this.topic ?? config.eventsProxy.topic.arn,
+                sns: config.sns
+            }
+        })
+        .then((endpoint) => endpoint)
+
+    stop = () => this.onlyWhenStarted(this.server).stop()
+        .then(() => this.LOGGER.debug('stopped'))
+
+    handler = (method: string, subject?: string) =>
+        (request: IncomingMessage, body: string, response: ServerResponse) =>
+            Promise.resolve((assertNotUndefined(this.config)))
+                .then((config) =>
+                    config.sns
+                        .publish(
+                            { arn: config.topic },
+                            this.extractMessage(method, request, body),
+                            subject,
+                            this.extractMessageAttributes(request)
+                        )
+                        .then(() => writeResponse(response, 200, ''))
+                        .catch((e) => {
+                            this.LOGGER.error(e, 'request failed to execute');
+                            internalServerError(response, e.body);
+                        })
+                )
+
+    extractMessage = (method: string, request: IncomingMessage, body: string) => {
+        switch (method) {
+            case 'GET':
+                return this.extractQueryString(request) || '';
+            case 'POST':
+                return body;
+            default:
+                throw new Error();
+        }
+    }
+
+    private onlyWhenStarted = (server: HttpServer | undefined) => assertNotUndefined(server, 'not started')
+
+    private extractQueryString = (request: IncomingMessage) => request.url?.substring(request.url?.indexOf('?') + 1)
+
+    private extractMessageAttributes = (request: IncomingMessage): Record<string, MessageAttributeValue> => {
+        const initialValue = {};
+        return Object.keys(request.headers).reduce((obj, item) => {
+            return {
+                ...obj,
+                [item]: {
+                    DataType: 'String',
+                    StringValue: request.headers[item],
+                },
+            };
+        }, initialValue);
+    }
+}

package/src/sns.ts

@@ -0,0 +1,49 @@
+import { CreateTopicCommand, MessageAttributeValue, PublishCommand, SNSClient, SubscribeCommand } from "@aws-sdk/client-sns";
+import { AwsConfig } from "./config";
+import { assertNotUndefined } from "./assert";
+import { LoggerFactory } from "@yopdev/logging";
+
+const LOGGER = LoggerFactory.create('SNS')
+export class Sns {
+    readonly client: SNSClient;
+
+    constructor(aws: AwsConfig) {
+        this.client = new SNSClient(aws);
+    }
+
+    createTopic = async (topic: string) => this.client
+        .send(
+            new CreateTopicCommand({
+                Name: topic,
+            }),
+        )
+        .then((o) => assertNotUndefined(o.TopicArn, 'TopicArn is not present'))
+        .tap((arn) => LOGGER.debug('topic %o created', arn))
+
+    createSubscription = async (topic: { arn: string }, queue: { arn: string }) => this.client
+        .send(
+            new SubscribeCommand({
+                TopicArn: topic.arn,
+                Protocol: 'sqs',
+                Endpoint: queue.arn,
+            }),
+        )
+        .then(() => LOGGER.debug('subscription %s->%s created', topic.arn, queue.arn))
+
+    publish = async (
+        topic: { arn: string },
+        body: string,
+        subject?: string,
+        attributes?: Record<string, MessageAttributeValue>,
+    ) => this.client
+        .send(
+            new PublishCommand({
+                TopicArn: topic.arn,
+                Message: body,
+                MessageAttributes: attributes,
+                Subject: subject,
+            }),
+        )
+        .then(() => LOGGER.trace('published %s[%s]', topic.arn, subject))
+        .then()
+}

package/src/sqs.ts

@@ -0,0 +1,46 @@
+import { CreateQueueCommand, GetQueueAttributesCommand, SQSClient } from "@aws-sdk/client-sqs";
+import { assertNotUndefined } from "./assert";
+import { AwsConfig } from "./config";
+import { LoggerFactory } from "@yopdev/logging";
+
+const QUEUE_NAME_ATTRIBUTE_NAME = 'QueueArn'
+const LOGGER = LoggerFactory.create('SQS')
+export class Sqs {
+    readonly client: SQSClient;
+
+    constructor(config: AwsConfig) {
+        this.client = new SQSClient(config)
+    }
+
+    createStandardQueue = async (name: string) => this.createNamedQueue(name, false);
+    createFifoQueue = async (name: string) => this.createNamedQueue(name, true);
+
+    private createNamedQueue = async (name: string, fifo: boolean): Promise<Queue> => this.client
+        .send(
+            new CreateQueueCommand({
+                QueueName: fifo ? `${name}.fifo` : name,
+                Attributes: {
+                    FifoQueue: fifo ? 'true' : undefined,
+                }
+            }),
+        )
+        .then(
+            (create) => this.client
+                .send(
+                    new GetQueueAttributesCommand({
+                        QueueUrl: create.QueueUrl,
+                        AttributeNames: [QUEUE_NAME_ATTRIBUTE_NAME],
+                    }),
+                )
+                .then((attributes) => ({
+                    url: assertNotUndefined(create.QueueUrl),
+                    arn: assertNotUndefined(attributes.Attributes)[QUEUE_NAME_ATTRIBUTE_NAME]!,
+                }))
+        )
+        .tap((queue) => LOGGER.debug('created %s', queue.arn))
+}
+
+export type Queue = {
+    arn: string;
+    url: string;
+};

package/src/stoppable.ts

@@ -0,0 +1,10 @@
+import { Consumer } from "sqs-consumer";
+
+export const stopConsumer = async (queueWaitTimeSecs: number, target?: Consumer): Promise<void> => {
+    if (target) {
+        target.stop();
+        return new Promise((resolve) => {
+            setTimeout(resolve, queueWaitTimeSecs * 1000 + 1);
+        });
+    } else { return Promise.resolve() }
+}

package/src/tunnel.ts

@@ -0,0 +1,32 @@
+import { Lifecycle, Service } from './services';
+import { Logger, LoggerFactory } from '@yopdev/logging';
+import * as ngrok from '@ngrok/ngrok';
+import { assertNotUndefined } from './assert';
+
+export const terminate = async () => ngrok.kill();
+export const newTunnel = (config: { name: string; port: number; fixed?: { name: string; token: string } }) =>
+    new Service(new Tunnel(config.name, config.port, config.fixed));
+class Tunnel implements Lifecycle<string> {
+    private logger: Logger;
+    constructor(
+        readonly name: string,
+        private readonly port: number,
+        private readonly domain?: {
+            name: string,
+            token: string,
+        },
+    ) {
+        this.logger = LoggerFactory.create(`TUNNEL[${name}]`);
+    }
+    start = async () =>
+        ngrok
+            .forward({
+                proto: 'http',
+                domain: this.domain?.name,
+                addr: this.port,
+                authtoken: this.domain?.token,
+            })
+            .then((listener) => assertNotUndefined(listener.url()))
+            .tap((url) => this.logger.debug(url))
+    stop = async () => ngrok.disconnect();
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "target": "ES2021",
+    "moduleResolution": "NodeNext",
+    "declaration": true,
+    "outDir": "./dist"
+  }
+}