fastify-rabbitmq 0.0.1-alpha.0 → 0.0.1-alpha.2

package/README.md

@@ -1,93 +1,178 @@
-# fastify-rabbitmq
-A Fastify RabbitMQ Plugin Developed in Pure TypeScript. Providing a lot more expandability on the ```amqplib``` package and RabbitMQ functionally.
+# Fastify RabbitMq
+
+A Fastify RabbitMQ Plugin Developed in Pure TypeScript.
+It uses the [node-amqp-connection-manager](https://github.com/jwalton/node-amqp-connection-manager) plugin as a wrapper.
+
+This comes right from the README on ```node-amqp-connection-manager```:
+
+> Features
+> * Automatically reconnect when your amqplib broker dies in a fire.
+> * Round-robin connections between multiple brokers in a cluster.
+> * If messages are sent while the broker is unavailable, queues messages in memory until we reconnect.
+> * Supports both promises and callbacks (using promise-breaker)
+> * Very un-opinionated library—a thin wrapper around amqplib.
+
+## Notice
+
+This NPM package is still going **active development** so things will break. Review the issues list for on going development work and if you want to help out, submit a PR.
+
+Help Wanted:
+* Documentation
+* GitHub Workflows
+* Unit Testing using Jest
+
+## Table of Contents
+
+1. [Notice](#notice)
+2. [Install](#install)
+2. [Basic Usage](#basic-usage)
+3. [Full Documentation](#full-documentation)
+   1. [Options](#options)
+4. [Acknowledgements](#acknowledgements)
+5. [License](#license)
 
 ## Install
 ```
-npm i fastify-rabbitmq
+npm i fastify-rabbitmq amqplib
+npm i --save-dev @types/amqplib
 ```
 
-## Usage
-Register as a plugin. This will decorate your `fastify` instance with the following methods:
+## Basic Usage
+Register this as a plugin.
+Make sure it is loaded before any ***routes*** are loaded.
+
+### Quick Setup on the Server Side
+
+```typescript
+export default fp<any>(async (fastify: FastifyInstance, options: FastifyPluginOptions) => {
+  
+   fastify.register(fastifyRabbit, {
+      urLs: ['amqp://localhost']
+   })
+
+   fastify.ready().then(async () => {
+      fastify.log.debug('[rabbitmq] Started RabbitMQ')
+      fastify.rabbitmq.channel = fastify.rabbitmq.createChannel({
+         json: true,
+         setup: function (channel: ConfirmChannel) {
+            return Promise.all([
+               channel.assertQueue('server', {durable: true}),
+               channel.prefetch(1),
+               channel.consume('server', async (message) => {
+                  fastify.log.debug(JSON.stringify(data))
+                  fastify.rabbitmq.channel?.ack(message);
+               })
+            ]);
+         },
+      })
+   })
+   
+});
+```
+
+Within server instance can also call the same queue as long as it has access to the ``fastify.rabbitmq`` decorator.
+Traditionally, a separate app is running and is the client sending messages to the client.
+
+### Quick Setup on the Client Side
 
-* fastify.rabbitmq.publishMessage
-* fastify.rabbitmq.directMessage
+First set up your plugin to register the plugin.
 
-```js
+```typescript
+import {ConfirmChannel} from "amqplib";
+import {
+   FastifyInstance,
+   FastifyPluginOptions,
+} from 'fastify';
+import fp from "fastify-plugin";
 import fastifyRabbit from "fastify-rabbitmq"
 
-fastify.register(fastifyRabbit, {
-  queue: 'rabbitqueue',
-  consumeMessageFn: async (message, channel: Channel) => {
-    console.log(message.content.toString())
-  }
+export default fp<any>(async (fastify: FastifyInstance, options: FastifyPluginOptions) => {
+
+  fastify.register(fastifyRabbit, {
+    urLs: ['amqp://localhost']
+  })
+
+  fastify.ready().then(async () => {
+
+    fastify.rabbitmq.channel = fastify.rabbitmq.createChannel({
+      json: true,
+      setup: function (channel: ConfirmChannel) {
+        return channel.assertQueue('client', { durable: true });
+      }
+    });
+
+  })
+
 })
 ```
 
-## Options
+Now in your routes or anywhere the fastify.rabbitmq can be accessed:
 
 ```typescript
-export interface FastifyRabbitMQOptions {
-  namespace?: string
-  queue: string
-  host?: string
-  port?: string
-  username?: string
-  password?: string
-  preProcessMessageFn?: (message: any) => string;
-  consumeMessageFn: (message: ConsumeMessage, channel: Channel) => void;
-  confirmChannel?: boolean
-}
+fastify.get('/rabbitmq', {}, async (request, reply) => {
+   try {
+      fastify.rabbitmq.channel?.sendToQueue('server', { foo: 'bar'})
+      return reply.code(200).send({ result: true});
+   } catch (error) {
+      return reply.send(404);
+   }
+});
 ```
-### `queue` (required)
-
-The RabbitMQ queue to create.
 
-### `consumeMessageFn` (required)
+## Full Documentation
 
-How this particular queue will process messages. Rememer that plugins in fastify can not access the request/reply scope. You will need to send your data that you get to a REST API endpoint for it to be processed.
+### Options
 
 ```typescript
-consumeMessageFn: async (message, channel: Channel) => {
-  const data = message.content.toString()
-  const options: any = {
-    json: {
-      ...data
-    },
-  };
-  const {body} = await got.post(`http://localhost:3000/foo`, options)
+export interface FastifyRabbitMQOptions extends AmqpConnectionManagerOptions {
+   logLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error'
+   namespace?: string
+   urLs: ConnectionUrl | ConnectionUrl[] | undefined | null
 }
 ```
-One example using the ```got``` NPM package to then pass the results from theis RabbitMQ data.
+#### FastifyRabbitMQOptions
 
-### `name`
+##### `logLevel`
 
-If you register more than one RabbitMQ queue within the same application, you must give it a namespace.
-The name can be the same as the queue.
+Set the log level for Fastify RabbitMQ plugin. This is usefull for development work. The default value is ```silent```
 
-### `host`
+##### `namespace`
 
-By default, it's ```localhost``` but pass your RabbitMQ server hostname or IP address. 
+If you need more than one "connection" to a different set and/or array of RabbitMQ servers,
+either on network or cloud, each registration of the plugin needs it to be in its own namespace.
+If not provided, your application will fail to load.
 
-### `port`
+##### `urLs`
 
-By default it's ```5672``` but pass your RabbitMQ port.
+This needs to be an array of the RabbitMQ host:
+
+```typescript
+fastify.register(fastifyRabbit, {
+  urLs: ['amqp://localhost']
+})
+```
 
-### `username`
+This is not needed
+if you use AmqpConnectionManagerOptions [findServers](https://github.com/jwalton/node-amqp-connection-manager#connecturls-options)
+which overrides the urls value if it's set.
+If you need
+to pass in credentials to the RabbitMQ or vHost for the connection review the [connection options](#amqpconnectionmanageroptions).
 
-By default, it's ```guest``` but pass your RabbitMQ username.
+Please review the options [here](https://github.com/jwalton/node-amqp-connection-manager/blob/master/src/AmqpConnectionManager.ts#L26C13-L26C34).
+(Note:
+This URL might bring you to the wrong line
+if the file has been changed on the ```node-amqp-connection-manager``` package.)
 
-### `password`
+#### ```AmqpConnectionManagerOptions```
 
-By default, it's ```guest``` but pass your RabbitMQ password.
+See [Connection Options](https://github.com/jwalton/node-amqp-connection-manager#connecturls-options) for 'node-amqp-connection-manager' for detailed options that can be passed in.
 
-### `preProcessMessageFn`
+## Acknowledgements
 
-Before your message goes out, do something to your message.
-This is good so all your message go out correctly.
-If not, just make sure you are only sending strings out.
+- [node-amqp-connection-manager](https://github.com/jwalton/node-amqp-connection-manager)
+- [fastify](https://fastify.dev/)
+- ...and of course my Wife and Baby Girl.
 
-### `confirmChannel`
+## License
 
-By default,
-it's ```false``` but mark this ture in order for you to mark your queue
-always confirm that it received data from a remote RabbitMQ.
+Licensed under [MIT](./LICENSE).

package/dist/index.d.ts

@@ -1,33 +1,27 @@
-import { FastifyInstance, FastifyPluginCallback } from 'fastify';
-import { Channel, ConsumeMessage } from 'amqplib';
+import { Channel, ConfirmChannel } from 'amqplib';
+import { ChannelWrapper } from 'amqp-connection-manager';
+import type { AmqpConnectionManager, AmqpConnectionManagerOptions, ConnectionUrl } from 'amqp-connection-manager';
+import { FastifyInstance } from 'fastify';
 import FastifyRabbitMQOptions = fastifyRabbitMQ.FastifyRabbitMQOptions;
+import FastifyRabbitMQObject = fastifyRabbitMQ.FastifyRabbitMQObject;
 declare module 'fastify' {
     interface FastifyInstance {
-        rabbitmq: fastifyRabbitMQ.FastifyRabbitMQObject & fastifyRabbitMQ.FastifyRabbitMQNestedObject;
+        rabbitmq: FastifyRabbitMQObject & fastifyRabbitMQ.FastifyRabbitMQNestedObject;
     }
 }
-type fastifyRabbitMQPlugin = FastifyPluginCallback<NonNullable<fastifyRabbitMQ.FastifyRabbitMQOptions>>;
 declare namespace fastifyRabbitMQ {
-    export interface FastifyRabbitMQObject {
-        publishMessage(sendQueue: string, message: any): void;
-        directMessage(sendQueue: string, message: any): void;
+    interface FastifyRabbitMQObject extends AmqpConnectionManager {
+        channel?: ChannelWrapper;
     }
-    export interface FastifyRabbitMQNestedObject {
+    interface FastifyRabbitMQNestedObject {
         [namespace: string]: FastifyRabbitMQObject;
     }
-    export interface FastifyRabbitMQOptions {
+    interface FastifyRabbitMQOptions extends AmqpConnectionManagerOptions {
+        logLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error';
         namespace?: string;
-        queue: string;
-        host?: string;
-        port?: string;
-        username?: string;
-        password?: string;
-        preProcessMessageFn?: (message: any) => string;
-        consumeMessageFn: (message: ConsumeMessage, channel: Channel) => void;
-        confirmChannel?: boolean;
+        urLs: ConnectionUrl | ConnectionUrl[] | undefined | null;
     }
-    export const fastifyRabbitMQPlugin: fastifyRabbitMQPlugin;
-    export { fastifyRabbitMQPlugin as default };
 }
 declare const fastifyRabbit: (fastify: FastifyInstance, options: FastifyRabbitMQOptions) => Promise<void>;
+export { Channel, ConfirmChannel };
 export default fastifyRabbit;

package/dist/index.js

@@ -7,107 +7,61 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import amqp from 'amqp-connection-manager';
 import fp from 'fastify-plugin';
-import amqp from 'amqplib';
 /**
  * decorateFastifyInstance
  * @since 0.0.1
  * @param fastify
  * @param options
- * @param functions
+ * @param connection
  */
-const decorateFastifyInstance = (fastify, options, functions) => {
-    const { namespace } = options;
-    if (namespace) {
+const decorateFastifyInstance = (fastify, options, connection) => {
+    const { logLevel = 'silent', namespace = '' } = options;
+    // override log level
+    const logger = fastify.log.child({}, { level: logLevel });
+    if (namespace !== '') {
+        logger.debug('[fastify-rabbitmq] Namespace: %s', namespace);
+    }
+    if (namespace !== '') {
         if (typeof fastify.rabbitmq === 'undefined') {
-            fastify.decorate('rabbitmq', Object.assign({}, functions));
+            fastify.decorate('rabbitmq', connection);
         }
-        if (typeof fastify.rabbitmq[namespace] !== 'undefined') {
-            throw Error('Connection name already registered: ' + namespace);
+        if (fastify.rabbitmq[namespace] != null) {
+            throw Error('[fastify-rabbitmq] Connection name already registered: ' + namespace);
         }
+        logger.trace('[fastify-rabbitmq] Decorate Fastify with Namespace: %', namespace);
+        fastify.rabbitmq[namespace] = connection;
     }
     else {
         if (typeof fastify.rabbitmq !== 'undefined') {
-            throw Error('fastify-rabbitmq has already registered');
+            throw Error('[fastify-rabbitmq] Already registered');
         }
     }
     if (typeof fastify.rabbitmq === 'undefined') {
-        fastify.decorate('rabbitmq', Object.assign({}, functions));
+        logger.trace('[fastify-rabbitmq] Decorate Fastify');
+        fastify.decorate('rabbitmq', connection);
     }
 };
 const fastifyRabbit = fp((fastify, options) => __awaiter(void 0, void 0, void 0, function* () {
-    const { queue, host = 'localhost', port = '5672', username = 'guest', password = 'guest', confirmChannel = false, consumeMessageFn, preProcessMessageFn } = options;
-    const RABBITMQ_FULL_URL = `amqp://${username}:${password}@${host}:${port}`;
-    /**
-     * getRabbitChannel
-     * @since 0.0.1
-     * @param confirmChannel {boolean} Set this to true if you want the channel to always ask for a confirmation that it was sent and received by the other side.
-     */
-    function getRabbitChannel(confirmChannel) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const conn = yield amqp.connect(RABBITMQ_FULL_URL);
-            return confirmChannel ? yield conn.createConfirmChannel() : yield conn.createChannel();
-        });
-    }
-    /**
-     * consumeRabbitMessage
-     * Process the incoming message from another queue. This is required.
-     * @since 0.0.1
-     * @param msg {ConsumeMessage} Data from RabbitMQ. It's in a string format; however, you need to interpret the data.
-     * @param channel {Channel} What channel did it comes from and the properties of that channel.
-     */
-    function consumeRabbitMessage(msg, channel) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (typeof consumeMessageFn === 'function') {
-                consumeMessageFn(msg, channel);
-            }
-        });
-    }
-    /**
-     * preProcessMessage
-     * If the parameter preProcessMessageFn is passed, it will use that function to process the data.
-     * @since 0.0.1
-     * @param message {any} The data you want to send, however it must be a string.
-     */
-    function preProcessMessage(message) {
-        if (typeof preProcessMessageFn === 'function') {
-            return preProcessMessageFn(message);
-        }
-        else {
-            return message;
-        }
-    }
-    const channel = yield getRabbitChannel(confirmChannel);
-    yield (channel === null || channel === void 0 ? void 0 : channel.assertQueue(queue, { durable: false }).then(() => __awaiter(void 0, void 0, void 0, function* () {
-        return yield channel.consume(queue, (msg) => __awaiter(void 0, void 0, void 0, function* () {
-            yield consumeRabbitMessage(msg, channel);
-        }), {
-            noAck: true
-        });
-    })));
-    /**
-     * publishMessage
-     * @since 0.0.1
-     * @param sendQueue {string} The target queue.
-     * @param message {any} You can publish anything as long as it goes out over as a string.
-     */
-    function publishMessage(sendQueue, message) {
-        channel === null || channel === void 0 ? void 0 : channel.publish('', sendQueue, Buffer.from(preProcessMessage(message)));
-    }
-    /**
-     * directMessage
-     * @since 0.0.1
-     * @param sendQueue {string} The target queue and directed to that queue. No one else can take it.
-     * @param message {any} You can publish anything as long as it goes out over as a string.
-     */
-    function directMessage(sendQueue, message) {
-        channel === null || channel === void 0 ? void 0 : channel.sendToQueue(sendQueue, Buffer.from(preProcessMessage(message)), {
-            replyTo: queue
-        });
-    }
+    const { logLevel = 'silent', urLs, heartbeatIntervalInSeconds, reconnectTimeInSeconds, findServers, connectionOptions } = options;
+    // override log level
+    const logger = fastify.log.child({}, { level: logLevel });
+    const connection = amqp.connect(urLs, {
+        heartbeatIntervalInSeconds,
+        reconnectTimeInSeconds,
+        findServers,
+        connectionOptions
+    });
+    connection.on('connect', function () {
+        logger.debug('[fastify-rabbitmq] Connection to RabbitMQ Successful');
+    });
+    connection.on('disconnect', function () {
+        logger.debug('[fastify-rabbitmq] Connection to RabbitMQ Disconnected');
+    });
     /**
      * Decorate Fastify
      */
-    decorateFastifyInstance(fastify, options, { publishMessage, directMessage });
+    decorateFastifyInstance(fastify, options, connection);
 }));
 export default fastifyRabbit;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify-rabbitmq",
-  "version": "0.0.1-alpha.0",
+  "version": "0.0.1-alpha.2",
   "description": "A Fastify RabbitMQ Plugin Developed in Pure TypeScript using the AMQPLIB",
   "type": "module",
   "types": "dist/index.d.ts",
@@ -10,7 +10,7 @@
     "build:watch": "tsc -w",
     "lint": "ts-standard",
     "lint:fix": "ts-standard --fix",
-    "test": "npm run unit && npm run typescript",
+    "test": "jest",
     "update": "npx npm-check-updates -u && npm install"
   },
   "repository": {
@@ -18,6 +18,8 @@
     "url": "git+https://github.com/Bugs5382/fastify-rabbitmq.git"
   },
   "keywords": [
+    "amqp-connection-manager",
+    "amqplib",
     "typescript",
     "rabbitmq",
     "fastify",
@@ -30,17 +32,21 @@
   },
   "homepage": "https://github.com/Bugs5382/fastify-rabbitmq#readme",
   "dependencies": {
-    "amqplib": "^0.10.3",
+    "amqp-connection-manager": "^4.1.14",
     "fastify-plugin": "^4.5.1"
   },
   "devDependencies": {
     "@types/amqplib": "^0.10.1",
-    "@types/node": "^20.4.6",
+    "@types/jest": "^29.5.3",
+    "@types/node": "^20.4.10",
     "fastify": "^4.21.0",
-    "npm-check-updates": "^16.10.17",
+    "jest": "^29.6.2",
+    "npm-check-updates": "^16.11.1",
     "pre-commit": "^1.2.2",
-    "tap": "^16.3.8",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
     "ts-standard": "^12.0.2",
+    "tsd": "^0.28.1",
     "typescript": "^5.1.6"
   },
   "pre-commit": []

package/index.ts

@@ -1,165 +0,0 @@
-import {FastifyInstance, FastifyPluginCallback} from 'fastify'
-import fp from 'fastify-plugin'
-import amqp, {Channel, ConsumeMessage} from 'amqplib'
-
-import FastifyRabbitMQOptions = fastifyRabbitMQ.FastifyRabbitMQOptions;
-
-declare module 'fastify' {
-  interface FastifyInstance {
-    rabbitmq: fastifyRabbitMQ.FastifyRabbitMQObject & fastifyRabbitMQ.FastifyRabbitMQNestedObject;
-  }
-
-}
-
-type fastifyRabbitMQPlugin = FastifyPluginCallback<
-  NonNullable<fastifyRabbitMQ.FastifyRabbitMQOptions>
->;
-
-declare namespace fastifyRabbitMQ {
-
-  export interface FastifyRabbitMQObject {
-    publishMessage (sendQueue: string, message: any): void
-    directMessage (sendQueue: string, message: any): void
-  }
-
-  export interface FastifyRabbitMQNestedObject {
-    [namespace: string]: FastifyRabbitMQObject;
-  }
-
-  export interface FastifyRabbitMQOptions {
-    namespace?: string
-    queue: string
-    host?: string
-    port?: string
-    username?: string
-    password?: string
-    preProcessMessageFn?: (message: any) => string;
-    consumeMessageFn: (message: ConsumeMessage, channel: Channel) => void;
-    confirmChannel?: boolean
-  }
-
-  export const fastifyRabbitMQPlugin: fastifyRabbitMQPlugin
-  export { fastifyRabbitMQPlugin as default }
-
-}
-
-/**
- * decorateFastifyInstance
- * @since 0.0.1
- * @param fastify
- * @param options
- * @param functions
- */
-const decorateFastifyInstance = (fastify: FastifyInstance, options: FastifyRabbitMQOptions, functions: any): void => {
-  const { namespace } = options
-
-  if (namespace) {
-    if (typeof fastify.rabbitmq === 'undefined') {
-      fastify.decorate('rabbitmq', {...functions})
-    }
-    if (typeof fastify.rabbitmq[namespace] !== 'undefined') {
-      throw Error('Connection name already registered: ' + namespace)
-    }
-
-  } else {
-    if (typeof fastify.rabbitmq !== 'undefined') {
-      throw Error('fastify-rabbitmq has already registered')
-    }
-  }
-
-  if (typeof fastify.rabbitmq === 'undefined') {
-    fastify.decorate('rabbitmq', {...functions})
-  }
-
-}
-
-const fastifyRabbit = fp(async (fastify: FastifyInstance, options: FastifyRabbitMQOptions): Promise<void> => {
-  const {
-    queue,
-    host = 'localhost',
-    port = '5672',
-    username = 'guest',
-    password = 'guest',
-    confirmChannel = false,
-    consumeMessageFn,
-    preProcessMessageFn
-  } = options
-
-  const RABBITMQ_FULL_URL = `amqp://${username}:${password}@${host}:${port}`
-
-  /**
-   * getRabbitChannel
-   * @since 0.0.1
-   * @param confirmChannel {boolean} Set this to true if you want the channel to always ask for a confirmation that it was sent and received by the other side.
-   */
-  async function getRabbitChannel (confirmChannel: boolean): Promise<Channel> {
-    const conn = await amqp.connect(RABBITMQ_FULL_URL)
-    return confirmChannel ? await conn.createConfirmChannel() : await conn.createChannel()
-  }
-
-  /**
-   * consumeRabbitMessage
-   * Process the incoming message from another queue. This is required.
-   * @since 0.0.1
-   * @param msg {ConsumeMessage} Data from RabbitMQ. It's in a string format; however, you need to interpret the data.
-   * @param channel {Channel} What channel did it comes from and the properties of that channel.
-   */
-  async function consumeRabbitMessage (msg: ConsumeMessage, channel: Channel): Promise<void> {
-    if (typeof consumeMessageFn === 'function') {
-      consumeMessageFn(msg, channel)
-    }
-  }
-
-  /**
-   * preProcessMessage
-   * If the parameter preProcessMessageFn is passed, it will use that function to process the data.
-   * @since 0.0.1
-   * @param message {any} The data you want to send, however it must be a string.
-   */
-  function preProcessMessage(message: any): string {
-    if (typeof preProcessMessageFn === 'function') {
-      return preProcessMessageFn(message)
-    } else {
-      return message
-    }
-  }
-
-  const channel = await getRabbitChannel(confirmChannel)
-
-  await channel?.assertQueue(queue, { durable: false }).then(async () => {
-    return await channel.consume(queue, async (msg:amqp.ConsumeMessage | null): Promise<void> => {
-      await consumeRabbitMessage(<ConsumeMessage>msg, channel)
-    }, {
-      noAck: true
-    })
-  })
-
-  /**
-   * publishMessage
-   * @since 0.0.1
-   * @param sendQueue {string} The target queue.
-   * @param message {any} You can publish anything as long as it goes out over as a string.
-   */
-  function publishMessage (sendQueue: string, message: any): void {
-    channel?.publish('', sendQueue, Buffer.from(preProcessMessage(message)))
-  }
-
-  /**
-   * directMessage
-   * @since 0.0.1
-   * @param sendQueue {string} The target queue and directed to that queue. No one else can take it.
-   * @param message {any} You can publish anything as long as it goes out over as a string.
-   */
-  function directMessage (sendQueue: string, message: any): void {
-    channel?.sendToQueue(sendQueue, Buffer.from(preProcessMessage(message)), {
-      replyTo: queue
-    })
-  }
-
-  /**
-   * Decorate Fastify
-   */
-  decorateFastifyInstance(fastify, options, {publishMessage, directMessage})
-})
-
-export default fastifyRabbit

package/tsconfig.json

@@ -1,29 +0,0 @@
-{
-  "files": ["index.ts"],
-  "compilerOptions": {
-    "target": "es2015",
-    "module": "es2015",
-    "moduleResolution": "node",
-    "declaration": true,
-    "outDir": "./dist",
-    "noEmit": false,
-    "strict": true,
-    "noImplicitAny": true,
-    "strictNullChecks": true,
-    "strictFunctionTypes": true,
-    "strictBindCallApply": true,
-    "strictPropertyInitialization": true,
-    "noImplicitThis": true,
-    "alwaysStrict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-    "noPropertyAccessFromIndexSignature": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "skipLibCheck": true
-  }
-}