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

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

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