@xnestjs/elasticsearch 1.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Panates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,86 @@
+# @xnestjs/elasticsearch
+
+NestJS extension library for ElasticSearch
+
+## Install
+
+```sh
+npm install @xnestjs/elasticsearch
+# or using yarn
+yarn add @xnestjs/elasticsearch
+```
+
+## Usage
+
+### Register sync
+
+An example of nestjs module that import the @xnestjs/elasticsearch
+
+```ts
+// module.ts
+import { Module } from '@nestjs/common';
+import { ElasticsearchModule } from '@xnestjs/elasticsearch';
+
+@Module({
+    imports: [
+        ElasticsearchModule.forRoot({
+            useValue: {
+                node: 'http://localhost:9201',
+            },
+        }),
+    ],
+})
+export class MyModule {
+}
+```
+
+### Register async
+
+An example of nestjs module that import the @xnestjs/elasticsearch async
+
+```ts
+// module.ts
+import { Module } from '@nestjs/common';
+import { ElasticsearchModule } from '@xnestjs/elasticsearch';
+
+@Module({
+    imports: [
+        ElasticsearchModule.forRootAsync({
+            inject: [ConfigModule],
+            useFactory: (config: ConfigService) => ({
+                node: config.get('ELASTIC_NODE'),
+            }),
+        }),
+    ]
+})
+export class MyModule {
+}
+```
+
+## Environment Variables
+
+The library supports configuration through environment variables. Environment variables below is accepted.
+All environment variables starts with prefix (MONGODB_). This can be configured while registering the module.
+
+| Environment Variable                 | Type    | Default               | Description                                                                                                                                                                                            |
+|--------------------------------------|---------|-----------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| ELASTIC_NODE                         | String  | http://localhost:9200 | Elasticsearch node settings, if there is only one node. Required if `NODES` or `CLOUD_ID` is not set.                                                                                                  |
+| ELASTIC_NODES                        | String  |                       | Elasticsearch node settings, if there is only one node. Required if `NODE` or `CLOUD_ID` is not set.                                                                                                   |
+| ELASTIC_NAME                         | String  | elasticsearch-js      | A name for client                                                                                                                                                                                      |
+| ELASTIC_MAX_RESPONSE_SIZE            | Number  |                       | When configured, verifies that the uncompressed response size is lower than the configured number. If it's higher, it will abort the request.                                                          |
+| ELASTIC_MAX_COMPRESSED_RESPONSE_SIZE | Number  |                       | When configured, verifies that the compressed response size is lower than the configured number. If it's higher, it will abort the request.                                                            |
+| ELASTIC_MAX_RETRIES                  | Number  | 3                     | Max number of retries for each request                                                                                                                                                                 |
+| ELASTIC_REQUEST_TIMEOUT              | Number  | 30000                 | Max request timeout in milliseconds for each request                                                                                                                                                   |
+| ELASTIC_PING_TIMEOUT                 | Number  | 3000                  | Max number of milliseconds a `ClusterConnectionPool` will wait when pinging nodes before marking them dead                                                                                             |
+| ELASTIC_AUTH_USERNAME                | String  |                       | BasicAuth username                                                                                                                                                                                     |
+| ELASTIC_AUTH_PASSWORD                | String  |                       | BasicAuth password                                                                                                                                                                                     |
+| ELASTIC_AUTH_BEARER                  | String  |                       | BearerAuth bearer header value                                                                                                                                                                         |
+| ELASTIC_AUTH_API_KEY                 | String  |                       | ApiKeyAuth api key                                                                                                                                                                                     |
+| ELASTIC_API_KEY_ID                   | String  |                       | ApiKeyAuth api key id                                                                                                                                                                                  |
+| ELASTIC_TLS                          | Boolean | False                 | Enabled the TLS connection                                                                                                                                                                             |
+| ELASTIC_TLS_CA_CERT                  | String  |                       | Optionally override the trusted CA certificates. Default is to trust the well-known CAs curated by Mozilla. Mozilla's CAs are completely replaced when CAs are explicitly specified using this option. |
+| ELASTIC_TLS_CERT_FILE                | String  |                       | The File that contains Cert chains in PEM format.                                                                                                                                                      |
+| ELASTIC_TLS_KEY_FILE                 | String  |                       | The File that contains private keys in PEM format.                                                                                                                                                     |
+| ELASTIC_TLS_KEY_PASSPHRASE           | String  |                       | PFX or PKCS12 encoded private key and certificate chain.                                                                                                                                               |
+| ELASTIC_TLS_REJECT_UNAUTHORIZED      | Boolean | False                 | If true the server will reject any connection which is notauthorized with the list of supplied CAs. This option only has an effect if requestCert is true.                                             |
+| ELASTIC_CA_FINGERPRINT               | String  |                       | If configured, verifies that the fingerprint of the CA certificate that has signed the certificate of the server matches the supplied fingerprint; only accepts SHA256 digest fingerprints             |

package/cjs/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ELASTICSEARCH_MODULE_ID = exports.ELASTICSEARCH_CONNECTION_OPTIONS = void 0;
+exports.ELASTICSEARCH_CONNECTION_OPTIONS = Symbol('ELASTICSEARCH_CONNECTION_OPTIONS');
+exports.ELASTICSEARCH_MODULE_ID = Symbol('ELASTICSEARCH_MODULE_ID');

package/cjs/elasticsearch-core.module.js

@@ -0,0 +1,198 @@
+"use strict";
+var ElasticsearchCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElasticsearchCoreModule = void 0;
+const tslib_1 = require("tslib");
+const node_assert_1 = tslib_1.__importDefault(require("node:assert"));
+const crypto = tslib_1.__importStar(require("node:crypto"));
+const node_process_1 = tslib_1.__importDefault(require("node:process"));
+const objects_1 = require("@jsopen/objects");
+const common_1 = require("@nestjs/common");
+const elasticsearch_1 = require("@nestjs/elasticsearch");
+const colors = tslib_1.__importStar(require("ansi-colors"));
+const putil_varhelpers_1 = require("putil-varhelpers");
+const constants_js_1 = require("./constants.js");
+const CLIENT_TOKEN = Symbol('CLIENT_TOKEN');
+let ElasticsearchCoreModule = ElasticsearchCoreModule_1 = class ElasticsearchCoreModule {
+    /**
+     *
+     */
+    static forRoot(moduleOptions) {
+        const connectionOptions = this._readConnectionOptions(moduleOptions.useValue || {}, moduleOptions.envPrefix);
+        return this._createDynamicModule(moduleOptions, {
+            global: moduleOptions.global,
+            providers: [
+                {
+                    provide: constants_js_1.ELASTICSEARCH_CONNECTION_OPTIONS,
+                    useValue: connectionOptions,
+                },
+            ],
+        });
+    }
+    /**
+     *
+     */
+    static forRootAsync(asyncOptions) {
+        node_assert_1.default.ok(asyncOptions.useFactory, 'useFactory is required');
+        return this._createDynamicModule(asyncOptions, {
+            global: asyncOptions.global,
+            providers: [
+                {
+                    provide: constants_js_1.ELASTICSEARCH_CONNECTION_OPTIONS,
+                    inject: asyncOptions.inject,
+                    useFactory: async (...args) => {
+                        const opts = await asyncOptions.useFactory(...args);
+                        return this._readConnectionOptions(opts, asyncOptions.envPrefix);
+                    },
+                },
+            ],
+        });
+    }
+    static _createDynamicModule(opts, metadata) {
+        const token = opts.token ?? elasticsearch_1.ElasticsearchService;
+        const logger = typeof opts.logger === 'string' ? new common_1.Logger(opts.logger) : opts.logger;
+        const exports = [constants_js_1.ELASTICSEARCH_CONNECTION_OPTIONS, ...(metadata.exports ?? [])];
+        const providers = [
+            ...(metadata.providers ?? []),
+            {
+                provide: common_1.Logger,
+                useValue: logger,
+            },
+            {
+                provide: CLIENT_TOKEN,
+                useExisting: elasticsearch_1.ElasticsearchService,
+            },
+            {
+                provide: constants_js_1.ELASTICSEARCH_MODULE_ID,
+                useValue: crypto.randomUUID(),
+            },
+        ];
+        if (token !== elasticsearch_1.ElasticsearchService) {
+            exports.push(token);
+            providers.push({
+                provide: token,
+                useExisting: elasticsearch_1.ElasticsearchService,
+            });
+        }
+        class InnerProvidersModule {
+        }
+        return {
+            module: ElasticsearchCoreModule_1,
+            providers,
+            // global: true,
+            imports: [
+                elasticsearch_1.ElasticsearchModule.registerAsync({
+                    imports: [
+                        {
+                            module: InnerProvidersModule,
+                            providers: metadata.providers,
+                            exports: metadata.providers,
+                        },
+                    ],
+                    inject: [constants_js_1.ELASTICSEARCH_CONNECTION_OPTIONS],
+                    useFactory: async (connectionOptions) => {
+                        return connectionOptions;
+                    },
+                }),
+            ],
+            exports,
+        };
+    }
+    static _readConnectionOptions(moduleOptions, prefix = 'ELASTIC_') {
+        const options = (0, objects_1.clone)(moduleOptions);
+        const env = node_process_1.default.env;
+        options.node = options.node || env[prefix + 'NODE'];
+        if (options.node) {
+            if (typeof options.node === 'string' && options.node.includes(','))
+                options.node.split(/\s*,\s*/);
+        }
+        else {
+            options.nodes = options.nodes || env[prefix + 'NODES'];
+            if (options.nodes) {
+                if (typeof options.nodes === 'string' && options.nodes.includes(','))
+                    options.nodes.split(/\s*,\s*/);
+            }
+        }
+        if (!(options.node || options.nodes))
+            options.node = 'http://localhost:9200';
+        options.maxRetries = options.maxRetries ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'MAX_RETRIES']);
+        options.requestTimeout = options.requestTimeout ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'REQUEST_TIMEOUT']);
+        options.pingTimeout = options.pingTimeout ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'PING_TIMEOUT']);
+        if (options.tls == null && (0, putil_varhelpers_1.toBoolean)(env[prefix + 'TLS'])) {
+            options.tls = {
+                ca: [env[prefix + 'TLS_CA_CERT'] || ''],
+                cert: env[prefix + 'TLS_CERT_FILE'],
+                key: env[prefix + 'TLS_KEY_FILE'],
+                passphrase: env[prefix + 'TLS_KEY_PASSPHRASE'],
+                rejectUnauthorized: (0, putil_varhelpers_1.toBoolean)(env[prefix + 'TLS_REJECT_UNAUTHORIZED']),
+                checkServerIdentity: (host, cert) => {
+                    if (cert.subject.CN !== host) {
+                        return new Error(`Certificate CN (${cert.subject.CN}) does not match host (${host})`);
+                    }
+                },
+            };
+        }
+        options.name = options.name ?? env[prefix + 'NAME'];
+        if (!options.auth) {
+            if (env[prefix + 'AUTH_USERNAME']) {
+                options.auth = {
+                    username: env[prefix + 'AUTH_USERNAME'],
+                    password: env[prefix + 'AUTH_PASSWORD'] || '',
+                };
+            }
+            else if (env[prefix + 'AUTH_BEARER']) {
+                options.auth = {
+                    bearer: env[prefix + 'AUTH_BEARER'],
+                };
+            }
+            else if (env[prefix + 'AUTH_API_KEY']) {
+                if (env[prefix + 'API_KEY_ID'])
+                    options.auth = {
+                        apiKey: {
+                            id: env[prefix + 'API_KEY_ID'],
+                            api_key: env[prefix + 'API_KEY'],
+                        },
+                    };
+                options.auth = {
+                    apiKey: env[prefix + 'API_KEY'],
+                };
+            }
+        }
+        options.caFingerprint = options.caFingerprint ?? env[prefix + 'CA_FINGERPRINT'];
+        options.maxResponseSize = options.maxResponseSize ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'MAX_RESPONSE_SIZE']);
+        options.maxCompressedResponseSize =
+            options.maxCompressedResponseSize ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'MAX_COMPRESSED_RESPONSE_SIZE']);
+        return options;
+    }
+    /**
+     *
+     * @constructor
+     */
+    constructor(client, logger, connectionOptions) {
+        this.client = client;
+        this.logger = logger;
+        this.connectionOptions = connectionOptions;
+    }
+    async onApplicationBootstrap() {
+        if (this.logger) {
+            const options = this.connectionOptions;
+            const nodes = options.node || options.nodes;
+            this.logger.log(`Connecting to ElasticSearch at ${colors.blue(String(nodes))}`);
+            common_1.Logger.flush();
+            await this.client.ping({}).catch(e => {
+                this.logger.error('ElasticSearch connection failed: ' + e.message);
+                throw e;
+            });
+        }
+    }
+    onApplicationShutdown() {
+        return this.client.close();
+    }
+};
+exports.ElasticsearchCoreModule = ElasticsearchCoreModule;
+exports.ElasticsearchCoreModule = ElasticsearchCoreModule = ElasticsearchCoreModule_1 = tslib_1.__decorate([
+    tslib_1.__param(0, (0, common_1.Inject)(CLIENT_TOKEN)),
+    tslib_1.__param(2, (0, common_1.Inject)(constants_js_1.ELASTICSEARCH_CONNECTION_OPTIONS)),
+    tslib_1.__metadata("design:paramtypes", [elasticsearch_1.ElasticsearchService,
+        common_1.Logger, Object])
+], ElasticsearchCoreModule);

package/cjs/elasticsearch.module.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElasticsearchModule = void 0;
+const elasticsearch_core_module_js_1 = require("./elasticsearch-core.module.js");
+/**
+ * The ElasticsearchModule class is responsible for providing integration with Elasticsearch
+ * through dynamic module configurations. It allows synchronous and asynchronous setup of
+ * Elasticsearch configurations for use in a Node.js application.
+ */
+class ElasticsearchModule {
+    /**
+     * Configures and returns the dynamic module for the Elasticsearch integration.
+     *
+     */
+    static forRoot(options) {
+        return {
+            module: ElasticsearchModule,
+            imports: [elasticsearch_core_module_js_1.ElasticsearchCoreModule.forRoot(options || {})],
+        };
+    }
+    /**
+     * Configures and returns the async dynamic module for the Elasticsearch integration.
+     *
+     */
+    static forRootAsync(options) {
+        return {
+            module: ElasticsearchModule,
+            imports: [elasticsearch_core_module_js_1.ElasticsearchCoreModule.forRootAsync(options)],
+        };
+    }
+}
+exports.ElasticsearchModule = ElasticsearchModule;

package/cjs/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElasticsearchService = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./constants.js"), exports);
+tslib_1.__exportStar(require("./elasticsearch.module.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);
+var elasticsearch_1 = require("@nestjs/elasticsearch");
+Object.defineProperty(exports, "ElasticsearchService", { enumerable: true, get: function () { return elasticsearch_1.ElasticsearchService; } });

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/constants.js

@@ -0,0 +1,2 @@
+export const ELASTICSEARCH_CONNECTION_OPTIONS = Symbol('ELASTICSEARCH_CONNECTION_OPTIONS');
+export const ELASTICSEARCH_MODULE_ID = Symbol('ELASTICSEARCH_MODULE_ID');

package/esm/elasticsearch-core.module.js

@@ -0,0 +1,195 @@
+var ElasticsearchCoreModule_1;
+import { __decorate, __metadata, __param } from "tslib";
+import assert from 'node:assert';
+import * as crypto from 'node:crypto';
+import process from 'node:process';
+import { clone } from '@jsopen/objects';
+import { Inject, Logger } from '@nestjs/common';
+import { ElasticsearchModule, ElasticsearchService } from '@nestjs/elasticsearch';
+import * as colors from 'ansi-colors';
+import { toBoolean, toInt } from 'putil-varhelpers';
+import { ELASTICSEARCH_CONNECTION_OPTIONS, ELASTICSEARCH_MODULE_ID } from './constants.js';
+const CLIENT_TOKEN = Symbol('CLIENT_TOKEN');
+let ElasticsearchCoreModule = ElasticsearchCoreModule_1 = class ElasticsearchCoreModule {
+    /**
+     *
+     */
+    static forRoot(moduleOptions) {
+        const connectionOptions = this._readConnectionOptions(moduleOptions.useValue || {}, moduleOptions.envPrefix);
+        return this._createDynamicModule(moduleOptions, {
+            global: moduleOptions.global,
+            providers: [
+                {
+                    provide: ELASTICSEARCH_CONNECTION_OPTIONS,
+                    useValue: connectionOptions,
+                },
+            ],
+        });
+    }
+    /**
+     *
+     */
+    static forRootAsync(asyncOptions) {
+        assert.ok(asyncOptions.useFactory, 'useFactory is required');
+        return this._createDynamicModule(asyncOptions, {
+            global: asyncOptions.global,
+            providers: [
+                {
+                    provide: ELASTICSEARCH_CONNECTION_OPTIONS,
+                    inject: asyncOptions.inject,
+                    useFactory: async (...args) => {
+                        const opts = await asyncOptions.useFactory(...args);
+                        return this._readConnectionOptions(opts, asyncOptions.envPrefix);
+                    },
+                },
+            ],
+        });
+    }
+    static _createDynamicModule(opts, metadata) {
+        const token = opts.token ?? ElasticsearchService;
+        const logger = typeof opts.logger === 'string' ? new Logger(opts.logger) : opts.logger;
+        const exports = [ELASTICSEARCH_CONNECTION_OPTIONS, ...(metadata.exports ?? [])];
+        const providers = [
+            ...(metadata.providers ?? []),
+            {
+                provide: Logger,
+                useValue: logger,
+            },
+            {
+                provide: CLIENT_TOKEN,
+                useExisting: ElasticsearchService,
+            },
+            {
+                provide: ELASTICSEARCH_MODULE_ID,
+                useValue: crypto.randomUUID(),
+            },
+        ];
+        if (token !== ElasticsearchService) {
+            exports.push(token);
+            providers.push({
+                provide: token,
+                useExisting: ElasticsearchService,
+            });
+        }
+        class InnerProvidersModule {
+        }
+        return {
+            module: ElasticsearchCoreModule_1,
+            providers,
+            // global: true,
+            imports: [
+                ElasticsearchModule.registerAsync({
+                    imports: [
+                        {
+                            module: InnerProvidersModule,
+                            providers: metadata.providers,
+                            exports: metadata.providers,
+                        },
+                    ],
+                    inject: [ELASTICSEARCH_CONNECTION_OPTIONS],
+                    useFactory: async (connectionOptions) => {
+                        return connectionOptions;
+                    },
+                }),
+            ],
+            exports,
+        };
+    }
+    static _readConnectionOptions(moduleOptions, prefix = 'ELASTIC_') {
+        const options = clone(moduleOptions);
+        const env = process.env;
+        options.node = options.node || env[prefix + 'NODE'];
+        if (options.node) {
+            if (typeof options.node === 'string' && options.node.includes(','))
+                options.node.split(/\s*,\s*/);
+        }
+        else {
+            options.nodes = options.nodes || env[prefix + 'NODES'];
+            if (options.nodes) {
+                if (typeof options.nodes === 'string' && options.nodes.includes(','))
+                    options.nodes.split(/\s*,\s*/);
+            }
+        }
+        if (!(options.node || options.nodes))
+            options.node = 'http://localhost:9200';
+        options.maxRetries = options.maxRetries ?? toInt(env[prefix + 'MAX_RETRIES']);
+        options.requestTimeout = options.requestTimeout ?? toInt(env[prefix + 'REQUEST_TIMEOUT']);
+        options.pingTimeout = options.pingTimeout ?? toInt(env[prefix + 'PING_TIMEOUT']);
+        if (options.tls == null && toBoolean(env[prefix + 'TLS'])) {
+            options.tls = {
+                ca: [env[prefix + 'TLS_CA_CERT'] || ''],
+                cert: env[prefix + 'TLS_CERT_FILE'],
+                key: env[prefix + 'TLS_KEY_FILE'],
+                passphrase: env[prefix + 'TLS_KEY_PASSPHRASE'],
+                rejectUnauthorized: toBoolean(env[prefix + 'TLS_REJECT_UNAUTHORIZED']),
+                checkServerIdentity: (host, cert) => {
+                    if (cert.subject.CN !== host) {
+                        return new Error(`Certificate CN (${cert.subject.CN}) does not match host (${host})`);
+                    }
+                },
+            };
+        }
+        options.name = options.name ?? env[prefix + 'NAME'];
+        if (!options.auth) {
+            if (env[prefix + 'AUTH_USERNAME']) {
+                options.auth = {
+                    username: env[prefix + 'AUTH_USERNAME'],
+                    password: env[prefix + 'AUTH_PASSWORD'] || '',
+                };
+            }
+            else if (env[prefix + 'AUTH_BEARER']) {
+                options.auth = {
+                    bearer: env[prefix + 'AUTH_BEARER'],
+                };
+            }
+            else if (env[prefix + 'AUTH_API_KEY']) {
+                if (env[prefix + 'API_KEY_ID'])
+                    options.auth = {
+                        apiKey: {
+                            id: env[prefix + 'API_KEY_ID'],
+                            api_key: env[prefix + 'API_KEY'],
+                        },
+                    };
+                options.auth = {
+                    apiKey: env[prefix + 'API_KEY'],
+                };
+            }
+        }
+        options.caFingerprint = options.caFingerprint ?? env[prefix + 'CA_FINGERPRINT'];
+        options.maxResponseSize = options.maxResponseSize ?? toInt(env[prefix + 'MAX_RESPONSE_SIZE']);
+        options.maxCompressedResponseSize =
+            options.maxCompressedResponseSize ?? toInt(env[prefix + 'MAX_COMPRESSED_RESPONSE_SIZE']);
+        return options;
+    }
+    /**
+     *
+     * @constructor
+     */
+    constructor(client, logger, connectionOptions) {
+        this.client = client;
+        this.logger = logger;
+        this.connectionOptions = connectionOptions;
+    }
+    async onApplicationBootstrap() {
+        if (this.logger) {
+            const options = this.connectionOptions;
+            const nodes = options.node || options.nodes;
+            this.logger.log(`Connecting to ElasticSearch at ${colors.blue(String(nodes))}`);
+            Logger.flush();
+            await this.client.ping({}).catch(e => {
+                this.logger.error('ElasticSearch connection failed: ' + e.message);
+                throw e;
+            });
+        }
+    }
+    onApplicationShutdown() {
+        return this.client.close();
+    }
+};
+ElasticsearchCoreModule = ElasticsearchCoreModule_1 = __decorate([
+    __param(0, Inject(CLIENT_TOKEN)),
+    __param(2, Inject(ELASTICSEARCH_CONNECTION_OPTIONS)),
+    __metadata("design:paramtypes", [ElasticsearchService,
+        Logger, Object])
+], ElasticsearchCoreModule);
+export { ElasticsearchCoreModule };

package/esm/elasticsearch.module.js

@@ -0,0 +1,28 @@
+import { ElasticsearchCoreModule } from './elasticsearch-core.module.js';
+/**
+ * The ElasticsearchModule class is responsible for providing integration with Elasticsearch
+ * through dynamic module configurations. It allows synchronous and asynchronous setup of
+ * Elasticsearch configurations for use in a Node.js application.
+ */
+export class ElasticsearchModule {
+    /**
+     * Configures and returns the dynamic module for the Elasticsearch integration.
+     *
+     */
+    static forRoot(options) {
+        return {
+            module: ElasticsearchModule,
+            imports: [ElasticsearchCoreModule.forRoot(options || {})],
+        };
+    }
+    /**
+     * Configures and returns the async dynamic module for the Elasticsearch integration.
+     *
+     */
+    static forRootAsync(options) {
+        return {
+            module: ElasticsearchModule,
+            imports: [ElasticsearchCoreModule.forRootAsync(options)],
+        };
+    }
+}

package/esm/index.js

@@ -0,0 +1,4 @@
+export * from './constants.js';
+export * from './elasticsearch.module.js';
+export * from './types.js';
+export { ElasticsearchService } from '@nestjs/elasticsearch';

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@xnestjs/elasticsearch",
+  "version": "1.3.0",
+  "description": "NestJS extension library for ElasticSearch",
+  "author": "Panates",
+  "license": "MIT",
+  "dependencies": {
+    "@jsopen/objects": "^1.5.2",
+    "ansi-colors": "^4.1.3",
+    "putil-varhelpers": "^1.6.5",
+    "tslib": "^2.8.1"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "@nestjs/core": "^10.0.0 || ^11.0.0",
+    "@nestjs/elasticsearch": "^10.0.0 || ^11.0.0",
+    "@elastic/elasticsearch": "^7.4.0 || ^8.0.0"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./types/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "require": {
+        "types": "./types/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "default": "./esm/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./cjs/index.js",
+  "module": "./esm/index.js",
+  "types": "./types/index.d.ts",
+  "repository": {
+    "registry": "https://github.com/panates/xnestjs.git",
+    "directory": "packages/elasticsearch"
+  },
+  "engines": {
+    "node": ">=16.0",
+    "npm": ">=7.0.0"
+  },
+  "files": [
+    "cjs/",
+    "esm/",
+    "types/",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "nestjs",
+    "elasticsearch"
+  ]
+}

package/types/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const ELASTICSEARCH_CONNECTION_OPTIONS: unique symbol;
+export declare const ELASTICSEARCH_MODULE_ID: unique symbol;

package/types/elasticsearch-core.module.d.ts

@@ -0,0 +1,25 @@
+import { DynamicModule, Logger, OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common';
+import { ElasticsearchService } from '@nestjs/elasticsearch';
+import type { ElasticsearchConnectionOptions, ElasticsearchModuleAsyncOptions, ElasticsearchModuleOptions } from './types.js';
+export declare class ElasticsearchCoreModule implements OnApplicationShutdown, OnApplicationBootstrap {
+    protected client: ElasticsearchService;
+    private logger;
+    private connectionOptions;
+    /**
+     *
+     */
+    static forRoot(moduleOptions: ElasticsearchModuleOptions): DynamicModule;
+    /**
+     *
+     */
+    static forRootAsync(asyncOptions: ElasticsearchModuleAsyncOptions): DynamicModule;
+    private static _createDynamicModule;
+    private static _readConnectionOptions;
+    /**
+     *
+     * @constructor
+     */
+    constructor(client: ElasticsearchService, logger: Logger, connectionOptions: ElasticsearchConnectionOptions);
+    onApplicationBootstrap(): Promise<void>;
+    onApplicationShutdown(): Promise<void>;
+}

package/types/elasticsearch.module.d.ts

@@ -0,0 +1,19 @@
+import type { DynamicModule } from '@nestjs/common';
+import type { ElasticsearchModuleAsyncOptions, ElasticsearchModuleOptions } from './types';
+/**
+ * The ElasticsearchModule class is responsible for providing integration with Elasticsearch
+ * through dynamic module configurations. It allows synchronous and asynchronous setup of
+ * Elasticsearch configurations for use in a Node.js application.
+ */
+export declare class ElasticsearchModule {
+    /**
+     * Configures and returns the dynamic module for the Elasticsearch integration.
+     *
+     */
+    static forRoot(options?: ElasticsearchModuleOptions): DynamicModule;
+    /**
+     * Configures and returns the async dynamic module for the Elasticsearch integration.
+     *
+     */
+    static forRootAsync(options: ElasticsearchModuleAsyncOptions): DynamicModule;
+}

package/types/index.d.cts

@@ -0,0 +1,4 @@
+export * from './constants.js';
+export * from './elasticsearch.module.js';
+export * from './types.js';
+export { ElasticsearchService } from '@nestjs/elasticsearch';

package/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './constants.js';
+export * from './elasticsearch.module.js';
+export * from './types.js';
+export { ElasticsearchService } from '@nestjs/elasticsearch';

package/types/types.d.ts

@@ -0,0 +1,20 @@
+import type { ClientOptions } from '@elastic/elasticsearch';
+import type { Logger } from '@nestjs/common';
+import type { ModuleMetadata } from '@nestjs/common/interfaces';
+import type { InjectionToken } from '@nestjs/common/interfaces/modules/injection-token.interface';
+export interface ElasticsearchConnectionOptions extends ClientOptions {
+}
+interface BaseModuleOptions {
+    token?: InjectionToken;
+    envPrefix?: string;
+    logger?: Logger | string;
+    global?: boolean;
+}
+export interface ElasticsearchModuleOptions extends BaseModuleOptions {
+    useValue?: ElasticsearchConnectionOptions;
+}
+export interface ElasticsearchModuleAsyncOptions extends BaseModuleOptions, Pick<ModuleMetadata, 'imports'> {
+    inject?: InjectionToken[];
+    useFactory: (...args: any[]) => Promise<ElasticsearchConnectionOptions> | ElasticsearchConnectionOptions;
+}
+export {};