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

package/dist/src/mappers.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v2 = exports.v1 = exports.mapToLambdaSqsRecord = void 0;
+const url_1 = require("url");
+const lambda_http_proxy_1 = require("./lambda-http-proxy");
+const mapToLambdaSqsRecord = (message) => {
+    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',
+    };
+};
+exports.mapToLambdaSqsRecord = mapToLambdaSqsRecord;
+const payloadV1JwtAuthorizerLambdaMapper = () => ({
+    newInstance: (request, body) => Promise.resolve(new DefaultLambdaMapper(request, body))
+});
+const payloadV2LambdaAuthorizerLambdaMapper = () => ({
+    newInstance: (request, body) => Promise.resolve(new DefaultLambdaMapper(request, body))
+});
+const payloadV1PathParameterResolver = {
+    locate: (event) => event.path,
+    store: (event, params) => event.pathParameters = params
+};
+const payloadV2PathParameterResolver = {
+    locate: (event) => event.rawPath,
+    store: (event, params) => event.pathParameters = params
+};
+const v1 = () => ({
+    mapper: payloadV1JwtAuthorizerLambdaMapper(),
+    resolver: payloadV1PathParameterResolver,
+});
+exports.v1 = v1;
+const v2 = () => ({
+    mapper: payloadV2LambdaAuthorizerLambdaMapper(),
+    resolver: payloadV2PathParameterResolver,
+});
+exports.v2 = v2;
+class DefaultLambdaMapper {
+    constructor(request, body) {
+        this.body = body;
+        this.toResponse = (response) => 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));
+        this.readSetCookies = (response) => {
+            // 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 [];
+        };
+        this.event = (context) => ({
+            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: '',
+            }
+        });
+        this.authorization = () => this.authorizationHeaderValue;
+        if (!request.url || !request.method)
+            throw new Error('url and method are required');
+        const url = new url_1.URL(request.url, `http://${request.headers.host}`);
+        const qsp = {};
+        url.searchParams.forEach((v, k) => (qsp[k] = decodeURIComponent(v)));
+        this.queryStringParameters = qsp;
+        const headers = {};
+        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;
+    }
+}
+class StringResponse extends lambda_http_proxy_1.Response {
+    constructor(statusCode, contentType, location, body, cookies) {
+        super(statusCode, contentType, location, cookies);
+        this.body = () => body;
+    }
+}
+class Base64EncodedResponse extends lambda_http_proxy_1.Response {
+    constructor(statusCode, contentType, location, body, cookies) {
+        super(statusCode, contentType, location, cookies);
+        this.body = () => Buffer.from(body, 'base64');
+    }
+}

package/dist/src/pre-traffic-hooks.d.ts

@@ -0,0 +1,2 @@
+import { Service } from './services';
+export declare const newPreTrafficHooks: (name: string, hooks: () => Promise<void>[]) => Service<any>;

package/dist/src/pre-traffic-hooks.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newPreTrafficHooks = void 0;
+const logging_1 = require("@yopdev/logging");
+const services_1 = require("./services");
+const newPreTrafficHooks = (name, hooks) => new services_1.Service(new PreTrafficHooks(name, hooks));
+exports.newPreTrafficHooks = newPreTrafficHooks;
+class PreTrafficHooks {
+    constructor(name, hooks) {
+        this.name = name;
+        this.hooks = hooks;
+        this.start = async () => Promise
+            .all(this.hooks())
+            .then(() => undefined);
+        this.stop = async () => Promise.resolve();
+        this.LOGGER = logging_1.LoggerFactory.create(`PRETRAFFIC[${name}]`);
+        this.LOGGER.info('%i hooks registered', hooks.length);
+    }
+}

package/dist/src/responses.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ServerResponse } from 'http';
+export declare function internalServerError(res: ServerResponse, body: any): void;
+export declare function writeResponse(res: ServerResponse, statusCode: number, body: string | Buffer, contentType?: string, location?: string, cookies?: string[]): void;

package/dist/src/responses.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeResponse = exports.internalServerError = void 0;
+const logging_1 = require("@yopdev/logging");
+const LOG = logging_1.LoggerFactory.create('RESPONSES');
+function internalServerError(res, body) {
+    LOG.error(body, 'internal server error handled');
+    return writeResponse(res, 500, 'internal server error. check system logs');
+}
+exports.internalServerError = internalServerError;
+function writeResponse(res, statusCode, body, contentType, location, cookies) {
+    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);
+}
+exports.writeResponse = writeResponse;

package/dist/src/s3.d.ts

@@ -0,0 +1,7 @@
+import { CORSConfiguration, S3Client } from '@aws-sdk/client-s3';
+import { AwsConfig } from './config';
+export declare class S3 {
+    readonly client: S3Client;
+    constructor(aws: AwsConfig);
+    createBucket: (name: string, cors?: CORSConfiguration) => Promise<import("@aws-sdk/client-s3").PutBucketCorsCommandOutput>;
+}

package/dist/src/s3.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3 = void 0;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const logging_1 = require("@yopdev/logging");
+const LOGGER = logging_1.LoggerFactory.create('S3');
+class S3 {
+    constructor(aws) {
+        this.createBucket = async (name, cors) => this.client.send(new client_s3_1.CreateBucketCommand({
+            Bucket: name,
+        }))
+            .then(() => cors && this.client.send(new client_s3_1.PutBucketCorsCommand({
+            Bucket: name,
+            CORSConfiguration: cors
+        })))
+            .tap(() => LOGGER.debug('bucket %s created', name));
+        this.client = new client_s3_1.S3Client({ forcePathStyle: true, ...aws });
+    }
+}
+exports.S3 = S3;

package/dist/src/scheduled-tasks.d.ts

@@ -0,0 +1,6 @@
+import { Service } from './services';
+export declare const newScheduledTasks: (name: string, schedules: Rate[]) => Service<any>;
+export type Rate = {
+    frequency: number;
+    task: () => Promise<unknown>;
+};

package/dist/src/scheduled-tasks.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newScheduledTasks = void 0;
+const logging_1 = require("@yopdev/logging");
+const timers_1 = require("timers");
+const services_1 = require("./services");
+const newScheduledTasks = (name, schedules) => new services_1.Service(new ScheduledTasks(name, schedules));
+exports.newScheduledTasks = newScheduledTasks;
+class ScheduledTasks {
+    constructor(name, schedules) {
+        this.name = name;
+        this.schedules = schedules;
+        this.intervals = [];
+        this.start = async () => Promise.resolve(this.schedules.forEach((schedule) => this.intervals.push(setInterval(schedule.task, schedule.frequency * 1000))))
+            .then(() => undefined);
+        this.stop = async () => Promise.resolve(this.intervals.forEach((interval) => (0, timers_1.clearInterval)(interval)));
+        this.LOGGER = logging_1.LoggerFactory.create(`SCHEDULER[${name}]`);
+        this.LOGGER.info('registered %i scheduled tasks', schedules.length);
+    }
+}

package/dist/src/services.d.ts

@@ -0,0 +1,22 @@
+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 declare class Service<I> implements Lifecycle<I> {
+    private readonly callback?;
+    private readonly DEFAULT_CALLBACK;
+    readonly name: string;
+    readonly start: (config: DevServerConfig) => Promise<I>;
+    readonly stop: () => Promise<void>;
+    private doStop;
+    private readonly LOGGER;
+    constructor(service: Lifecycle<I>, callback?: Callback<I>);
+    private callbackOrDefault;
+}

package/dist/src/services.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = void 0;
+const logging_1 = require("@yopdev/logging");
+class Service {
+    constructor(service, callback) {
+        this.callback = callback;
+        this.DEFAULT_CALLBACK = () => Promise.resolve(this.LOGGER.debug('no callback'));
+        this.callbackOrDefault = async (instance) => (this.callback ?? this.DEFAULT_CALLBACK)(instance);
+        this.name = service.name;
+        this.LOGGER = logging_1.LoggerFactory.create(`SERVICE[${this.name}]`);
+        const stop = async () => service.stop();
+        this.start = (config) => 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();
+    }
+}
+exports.Service = Service;

package/dist/src/sns-http-proxy.d.ts

@@ -0,0 +1,28 @@
+import { HttpSettings } from "./http-server";
+import { IncomingMessage, ServerResponse } from "http";
+import { Lifecycle, Service, Callback } from "./services";
+import { DevServerConfig } from "./config";
+export declare const newSnsHttpProxy: (name: string, config: {
+    settings: HttpSettings;
+    method: string;
+    subject?: string;
+    topic?: string;
+}, callback?: Callback<string>) => Service<string>;
+export declare class SnsHttpProxy implements Lifecycle<string> {
+    readonly name: string;
+    private readonly settings;
+    private readonly method;
+    private readonly subject?;
+    private readonly topic?;
+    private LOGGER;
+    private server;
+    private config;
+    constructor(name: string, settings: HttpSettings, method: string, subject?: string, topic?: string);
+    start: (config: DevServerConfig) => Promise<string>;
+    stop: () => Promise<void>;
+    handler: (method: string, subject?: string) => (request: IncomingMessage, body: string, response: ServerResponse) => Promise<void>;
+    extractMessage: (method: string, request: IncomingMessage, body: string) => string;
+    private onlyWhenStarted;
+    private extractQueryString;
+    private extractMessageAttributes;
+}

package/dist/src/sns-http-proxy.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnsHttpProxy = exports.newSnsHttpProxy = void 0;
+const logging_1 = require("@yopdev/logging");
+const http_server_1 = require("./http-server");
+const responses_1 = require("./responses");
+const services_1 = require("./services");
+const assert_1 = require("./assert");
+const newSnsHttpProxy = (name, config, callback) => new services_1.Service(new SnsHttpProxy(name, config.settings, config.method, config.subject, config.topic), callback);
+exports.newSnsHttpProxy = newSnsHttpProxy;
+class SnsHttpProxy {
+    constructor(name, settings, method, subject, topic) {
+        this.name = name;
+        this.settings = settings;
+        this.method = method;
+        this.subject = subject;
+        this.topic = topic;
+        this.start = (config) => Promise.resolve(this.server)
+            .then(server => server.start())
+            .tap(() => {
+            this.config = {
+                topic: this.topic ?? config.eventsProxy.topic.arn,
+                sns: config.sns
+            };
+        })
+            .then((endpoint) => endpoint);
+        this.stop = () => this.onlyWhenStarted(this.server).stop()
+            .then(() => this.LOGGER.debug('stopped'));
+        this.handler = (method, subject) => (request, body, response) => Promise.resolve(((0, assert_1.assertNotUndefined)(this.config)))
+            .then((config) => config.sns
+            .publish({ arn: config.topic }, this.extractMessage(method, request, body), subject, this.extractMessageAttributes(request))
+            .then(() => (0, responses_1.writeResponse)(response, 200, ''))
+            .catch((e) => {
+            this.LOGGER.error(e, 'request failed to execute');
+            (0, responses_1.internalServerError)(response, e.body);
+        }));
+        this.extractMessage = (method, request, body) => {
+            switch (method) {
+                case 'GET':
+                    return this.extractQueryString(request) || '';
+                case 'POST':
+                    return body;
+                default:
+                    throw new Error();
+            }
+        };
+        this.onlyWhenStarted = (server) => (0, assert_1.assertNotUndefined)(server, 'not started');
+        this.extractQueryString = (request) => request.url?.substring(request.url?.indexOf('?') + 1);
+        this.extractMessageAttributes = (request) => {
+            const initialValue = {};
+            return Object.keys(request.headers).reduce((obj, item) => {
+                return {
+                    ...obj,
+                    [item]: {
+                        DataType: 'String',
+                        StringValue: request.headers[item],
+                    },
+                };
+            }, initialValue);
+        };
+        this.server = new http_server_1.HttpServer(this.name, this.settings, this.handler(this.method, this.subject));
+        this.LOGGER = logging_1.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');
+    }
+}
+exports.SnsHttpProxy = SnsHttpProxy;

package/dist/src/sns.d.ts

@@ -0,0 +1,15 @@
+import { MessageAttributeValue, SNSClient } from "@aws-sdk/client-sns";
+import { AwsConfig } from "./config";
+export declare class Sns {
+    readonly client: SNSClient;
+    constructor(aws: AwsConfig);
+    createTopic: (topic: string) => Promise<string>;
+    createSubscription: (topic: {
+        arn: string;
+    }, queue: {
+        arn: string;
+    }) => Promise<void>;
+    publish: (topic: {
+        arn: string;
+    }, body: string, subject?: string, attributes?: Record<string, MessageAttributeValue>) => Promise<void>;
+}

package/dist/src/sns.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sns = void 0;
+const client_sns_1 = require("@aws-sdk/client-sns");
+const assert_1 = require("./assert");
+const logging_1 = require("@yopdev/logging");
+const LOGGER = logging_1.LoggerFactory.create('SNS');
+class Sns {
+    constructor(aws) {
+        this.createTopic = async (topic) => this.client
+            .send(new client_sns_1.CreateTopicCommand({
+            Name: topic,
+        }))
+            .then((o) => (0, assert_1.assertNotUndefined)(o.TopicArn, 'TopicArn is not present'))
+            .tap((arn) => LOGGER.debug('topic %o created', arn));
+        this.createSubscription = async (topic, queue) => this.client
+            .send(new client_sns_1.SubscribeCommand({
+            TopicArn: topic.arn,
+            Protocol: 'sqs',
+            Endpoint: queue.arn,
+        }))
+            .then(() => LOGGER.debug('subscription %s->%s created', topic.arn, queue.arn));
+        this.publish = async (topic, body, subject, attributes) => this.client
+            .send(new client_sns_1.PublishCommand({
+            TopicArn: topic.arn,
+            Message: body,
+            MessageAttributes: attributes,
+            Subject: subject,
+        }))
+            .then(() => LOGGER.trace('published %s[%s]', topic.arn, subject))
+            .then();
+        this.client = new client_sns_1.SNSClient(aws);
+    }
+}
+exports.Sns = Sns;

package/dist/src/sqs.d.ts

@@ -0,0 +1,13 @@
+import { SQSClient } from "@aws-sdk/client-sqs";
+import { AwsConfig } from "./config";
+export declare class Sqs {
+    readonly client: SQSClient;
+    constructor(config: AwsConfig);
+    createStandardQueue: (name: string) => Promise<Queue>;
+    createFifoQueue: (name: string) => Promise<Queue>;
+    private createNamedQueue;
+}
+export type Queue = {
+    arn: string;
+    url: string;
+};

package/dist/src/sqs.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sqs = void 0;
+const client_sqs_1 = require("@aws-sdk/client-sqs");
+const assert_1 = require("./assert");
+const logging_1 = require("@yopdev/logging");
+const QUEUE_NAME_ATTRIBUTE_NAME = 'QueueArn';
+const LOGGER = logging_1.LoggerFactory.create('SQS');
+class Sqs {
+    constructor(config) {
+        this.createStandardQueue = async (name) => this.createNamedQueue(name, false);
+        this.createFifoQueue = async (name) => this.createNamedQueue(name, true);
+        this.createNamedQueue = async (name, fifo) => this.client
+            .send(new client_sqs_1.CreateQueueCommand({
+            QueueName: fifo ? `${name}.fifo` : name,
+            Attributes: {
+                FifoQueue: fifo ? 'true' : undefined,
+            }
+        }))
+            .then((create) => this.client
+            .send(new client_sqs_1.GetQueueAttributesCommand({
+            QueueUrl: create.QueueUrl,
+            AttributeNames: [QUEUE_NAME_ATTRIBUTE_NAME],
+        }))
+            .then((attributes) => ({
+            url: (0, assert_1.assertNotUndefined)(create.QueueUrl),
+            arn: (0, assert_1.assertNotUndefined)(attributes.Attributes)[QUEUE_NAME_ATTRIBUTE_NAME],
+        })))
+            .tap((queue) => LOGGER.debug('created %s', queue.arn));
+        this.client = new client_sqs_1.SQSClient(config);
+    }
+}
+exports.Sqs = Sqs;

package/dist/src/stoppable.d.ts

@@ -0,0 +1,2 @@
+import { Consumer } from "sqs-consumer";
+export declare const stopConsumer: (queueWaitTimeSecs: number, target?: Consumer) => Promise<void>;

package/dist/src/stoppable.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopConsumer = void 0;
+const stopConsumer = async (queueWaitTimeSecs, target) => {
+    if (target) {
+        target.stop();
+        return new Promise((resolve) => {
+            setTimeout(resolve, queueWaitTimeSecs * 1000 + 1);
+        });
+    }
+    else {
+        return Promise.resolve();
+    }
+};
+exports.stopConsumer = stopConsumer;

package/dist/src/tunnel.d.ts

@@ -0,0 +1,10 @@
+import { Service } from './services';
+export declare const terminate: () => Promise<void>;
+export declare const newTunnel: (config: {
+    name: string;
+    port: number;
+    fixed?: {
+        name: string;
+        token: string;
+    };
+}) => Service<string>;

package/dist/src/tunnel.js

@@ -0,0 +1,52 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newTunnel = exports.terminate = void 0;
+const services_1 = require("./services");
+const logging_1 = require("@yopdev/logging");
+const ngrok = __importStar(require("@ngrok/ngrok"));
+const assert_1 = require("./assert");
+const terminate = async () => ngrok.kill();
+exports.terminate = terminate;
+const newTunnel = (config) => new services_1.Service(new Tunnel(config.name, config.port, config.fixed));
+exports.newTunnel = newTunnel;
+class Tunnel {
+    constructor(name, port, domain) {
+        this.name = name;
+        this.port = port;
+        this.domain = domain;
+        this.start = async () => ngrok
+            .forward({
+            proto: 'http',
+            domain: this.domain?.name,
+            addr: this.port,
+            authtoken: this.domain?.token,
+        })
+            .then((listener) => (0, assert_1.assertNotUndefined)(listener.url()))
+            .tap((url) => this.logger.debug(url));
+        this.stop = async () => ngrok.disconnect();
+        this.logger = logging_1.LoggerFactory.create(`TUNNEL[${name}]`);
+    }
+}

package/jest.config.js

@@ -0,0 +1,7 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: "ts-jest",
+  testPathIgnorePatterns: ["/dist/"],
+  testRegex: "/__tests__/.*$",
+  testTimeout: 60000,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yopdev/dev-server",
-  "version": "3.0.2-RC",
+  "version": "3.0.2-RC2",
   "scripts": {
     "compile": "tsc",
     "pretest": "npm run compile",
@@ -35,8 +35,5 @@
   },
   "main": "dist/src/index.js",
   "exports": "./dist/src/index.js",
-  "types": "dist/src/index.d.ts",
-  "files": [
-    "dist/src"
-  ]
+  "types": "dist/src/index.d.ts"
 }

package/src/assert.ts

@@ -0,0 +1,4 @@
+export function assertNotUndefined<T>(value: T | undefined, message = 'value is undefined'): T {
+    if (value === undefined) throw new Error(message);
+    return value;
+}