@cumulus/es-client 18.2.2 → 18.3.1

package/bootstrap.js

@@ -15,7 +15,7 @@ const Logger = require('@cumulus/logger');
 const { inTestMode } = require('@cumulus/common/test-utils');
 const { IndexExistsError } = require('@cumulus/errors');
 
-const { Search, defaultIndexAlias } = require('./search');
+const { EsClient, defaultIndexAlias } = require('./search');
 const { createIndex } = require('./indexer');
 const mappings = require('./config/mappings.json');
 
@@ -31,7 +31,7 @@ const logger = new Logger({ sender: '@cumulus/es-client/bootstrap' });
  * @returns {Array<string>} - list of missing indices
  */
 async function findMissingMappings(esClient, index, newMappings) {
-  const typesResponse = await esClient.indices.getMapping({
+  const typesResponse = await esClient.client.indices.getMapping({
     index,
   }).then((response) => response.body);
 
@@ -61,7 +61,7 @@ async function removeIndexAsAlias(esClient, alias, removeAliasConflict) {
   // We can't do a simple exists check here, because it'll return true if the alias
   // is actually an alias assigned to an index. We do a get and check that the alias
   // name is not the key, which would indicate it's an index
-  const { body: existingIndex } = await esClient.indices.get(
+  const { body: existingIndex } = await esClient.client.indices.get(
     { index: alias },
     { ignore: [404] }
   );
@@ -72,7 +72,7 @@ async function removeIndexAsAlias(esClient, alias, removeAliasConflict) {
       throw new Error('Aborting ES recreation as configuration does not allow removal of index');
     }
     logger.warn(`Deleting alias as index: ${alias}`);
-    await esClient.indices.delete({ index: alias });
+    await esClient.client.indices.delete({ index: alias });
   }
 }
 
@@ -97,10 +97,11 @@ async function bootstrapElasticSearch({
 }) {
   if (!host) return;
 
-  const esClient = await Search.es(host);
+  const esClient = new EsClient(host);
+  await esClient.initializeEsClient();
 
   // Make sure that indexes are not automatically created
-  await esClient.cluster.putSettings({
+  await esClient.client.cluster.putSettings({
     body: {
       persistent: { 'action.auto_create_index': false },
     },
@@ -110,7 +111,7 @@ async function bootstrapElasticSearch({
 
   let aliasedIndex = index;
 
-  const indices = await esClient.indices.getAlias({ name: alias }, { ignore: [404] })
+  const indices = await esClient.client.indices.getAlias({ name: alias }, { ignore: [404] })
     .then((response) => response.body);
 
   const aliasExists = !isNil(indices) && !indices.error;
@@ -130,7 +131,7 @@ async function bootstrapElasticSearch({
       }
     }
 
-    await esClient.indices.putAlias({
+    await esClient.client.indices.putAlias({
       index: index,
       name: alias,
     });
@@ -145,7 +146,7 @@ async function bootstrapElasticSearch({
     const concurrencyLimit = inTestMode() ? 1 : 3;
     const limit = pLimit(concurrencyLimit);
     const addMissingTypesPromises = missingTypes.map((type) =>
-      limit(() => esClient.indices.putMapping({
+      limit(() => esClient.client.indices.putMapping({
         index: aliasedIndex,
         type,
         body: get(mappings, type),

package/collections.js

@@ -18,8 +18,8 @@ class Collection extends BaseSearch {
   }
 
   async getStats(records, ids) {
-    if (!this.client) {
-      this.client = await this.constructor.es();
+    if (!this._esClient) {
+      await this.initializeEsClient();
     }
 
     const aggs = await this.client.search({
@@ -126,9 +126,10 @@ class Collection extends BaseSearch {
    * @returns {Promise<Array<string>>} - list of collection ids with active granules
    */
   async aggregateGranuleCollections() {
-    if (!this.client) {
-      this.client = await this.constructor.es();
+    if (!this._esClient) {
+      await this.initializeEsClient();
     }
+
     // granules
     const searchParams = this._buildSearch();
     delete searchParams.from;

package/esAmazonConnection.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const { Connection } = require('@elastic/elasticsearch');
+const aws4 = require('aws4');
+
+/**
+ * Builds and returns a custom subclass of Connection that is configured to sign requests
+ * for AWS Elasticsearch service. Request signing is provided by the aws4 library and requires
+ * valid AWS credentials.
+ *
+ * @param {object} awsConfig - AWS configuration values to be used to build the Connection.
+ * @param {string} [awsConfig.region] - Optionally specify the AWS region in the request.
+ * @param {object} awsConfig.credentials - Valid AWS credentials object.
+ * @returns {AmazonConnection} - Connection configured and signed to work with AWS Elasticsearch
+ * service.
+ */
+const createAmazonConnection = (awsConfig) => {
+  class AmazonConnection extends Connection {
+    constructor(opts = {}) {
+      super(opts);
+      if (awsConfig.credentials) {
+        this.accessKeyId = awsConfig.credentials.accessKeyId;
+        this.secretAccessKey = awsConfig.credentials.secretAccessKey;
+      }
+    }
+
+    buildRequestObject(params) {
+      const req = super.buildRequestObject(params);
+
+      req.service = 'es';
+
+      if (awsConfig.region) {
+        req.region = awsConfig.region;
+      }
+
+      if (!req.headers) {
+        req.headers = {};
+      }
+
+      // Fix the Host header, since HttpConnector.makeReqParams() appends
+      // the port number which will cause signature verification to fail
+      req.headers.host = req.hostname;
+
+      // This fix allows the connector to work with the older 6.x elastic branch.
+      // The problem with that version, is that the Transport object would add a
+      // `Content-Length` header (yes with Pascal Case), thus duplicating headers
+      // (`Content-Length` and `content-length`), which makes the signature fail.
+      let contentLength = 0;
+      if (params.body) {
+        contentLength = Buffer.byteLength(params.body, 'utf8');
+        req.body = params.body;
+      }
+
+      const lengthHeader = 'content-length';
+      const headerFound = Object.keys(req.headers).find(
+        (header) => header.toLowerCase() === lengthHeader
+      );
+
+      if (headerFound === undefined) {
+        req.headers[lengthHeader] = contentLength;
+      }
+
+      return aws4.sign(req, awsConfig.credentials);
+    }
+  }
+
+  return AmazonConnection;
+};
+
+module.exports = (awsConfig) => ({
+  Connection: createAmazonConnection(awsConfig),
+});

package/esScrollSearch.js

@@ -36,8 +36,8 @@ const {
  */
 class ESScrollSearch extends Search {
   async query() {
-    if (!this.client) {
-      this.client = await super.constructor.es();
+    if (!this._esClient) {
+      await this.initializeEsClient(undefined, this.metrics);
     }
     let response;
     if (!this.scrollId) {

package/esSearchAfter.js

@@ -33,9 +33,10 @@ class ESSearchAfter extends Search {
    * @returns {Promise<Object>} Object containing query meta and results
    */
   async query() {
-    if (!this.client) {
-      this.client = await super.constructor.es();
+    if (!this._esClient) {
+      await this.initializeEsClient();
     }
+
     const searchParams = this._buildSearch();
     const response = await this.client.search(searchParams);
 

package/indexer.js

@@ -21,20 +21,20 @@ const { IndexExistsError, ValidationError } = require('@cumulus/errors');
 const { constructCollectionId } = require('@cumulus/message/Collections');
 const { removeNilProperties } = require('@cumulus/common/util');
 
-const { Search, defaultIndexAlias } = require('./search');
+const { EsClient, Search, defaultIndexAlias } = require('./search');
 const mappings = require('./config/mappings.json');
 
 const logger = new Logger({ sender: '@cumulus/es-client/indexer' });
 
 async function createIndex(esClient, indexName) {
-  const indexExists = await esClient.indices.exists({ index: indexName })
+  const indexExists = await esClient.client.indices.exists({ index: indexName })
     .then((response) => response.body);
 
   if (indexExists) {
     throw new IndexExistsError(`Index ${indexName} exists and cannot be created.`);
   }
 
-  await esClient.indices.create({
+  await esClient.client.indices.create({
     index: indexName,
     body: {
       mappings,
@@ -57,7 +57,7 @@ async function createIndex(esClient, indexName) {
  * @param  {Object} doc      - the record
  * @param  {string} index    - Elasticsearch index alias
  * @param  {string} type     - Elasticsearch type
- * @param  {string} parent   - the optional parent id
+ * @param  {string} [parent]   - the optional parent id
  * @returns {Promise} Elasticsearch response
  */
 async function genericRecordUpdate(esClient, id, doc, index, type, parent) {
@@ -76,11 +76,28 @@ async function genericRecordUpdate(esClient, id, doc, index, type, parent) {
 
   if (parent) params.parent = parent;
 
-  // adding or replacing record to ES
-  const actualEsClient = esClient || (await Search.es());
+  let actualEsClient;
+  if (esClient) {
+    actualEsClient = esClient;
+  } else {
+    const defaultEsClient = new EsClient();
+    await defaultEsClient.initializeEsClient();
+    actualEsClient = defaultEsClient;
+  }
+
   let indexResponse;
   try {
-    indexResponse = await actualEsClient.index(params);
+    try {
+      indexResponse = await actualEsClient.client.index(params);
+    } catch (error) {
+      if (error.name === 'ResponseError' && error.meta.body.message.includes('The security token included in the request is expired')) {
+        logger.warn(`genericRecordUpdate encountered a ResponseError ${JSON.stringify(error)}, updating credentials and retrying`);
+        await actualEsClient.refreshClient();
+        indexResponse = await actualEsClient.client.index(params);
+      } else {
+        throw error;
+      }
+    }
   } catch (error) {
     logger.error(`Error thrown on index ${JSON.stringify(error)}`);
     throw error;
@@ -99,7 +116,7 @@ async function genericRecordUpdate(esClient, id, doc, index, type, parent) {
  * @returns {Promise} Elasticsearch response
  */
 async function updateExistingRecord(esClient, id, doc, index, type) {
-  return await esClient.update({
+  return await esClient.client.update({
     index,
     type,
     id,
@@ -155,6 +172,7 @@ async function upsertExecution({
   type = 'execution',
   refresh,
 }, writeConstraints = true) {
+  const cumulusEsClient = await esClient.client;
   Object.keys(updates).forEach((key) => {
     if (updates[key] === null && executionInvalidNullFields.includes(key)) {
       throw new ValidationError(`Attempted Elasticsearch write with invalid key ${key} set to null.  Please remove or change this field and retry`);
@@ -190,7 +208,7 @@ async function upsertExecution({
           }
         `;
   }
-  return await esClient.update({
+  return await cumulusEsClient.update({
     index,
     type,
     id: upsertDoc.arn,
@@ -309,8 +327,7 @@ async function indexGranule(esClient, payload, index = defaultIndexAlias, type =
     parent: payload.collectionId,
     refresh: inTestMode(),
   };
-  await esClient.delete(delGranParams, { ignore: [404] });
-
+  await esClient.client.delete(delGranParams, { ignore: [404] });
   return genericRecordUpdate(
     esClient,
     payload.granuleId,
@@ -356,6 +373,8 @@ async function upsertGranule({
       throw new ValidationError(`Attempted Elasticsearch write with invalid key ${key} set to null.  Please remove or change this field and retry`);
     }
   });
+
+  const cumulusEsClient = await esClient.client;
   // If the granule exists in 'deletedgranule', delete it first before inserting the granule
   // into ES.  Ignore 404 error, so the deletion still succeeds if the record doesn't exist.
   const delGranParams = {
@@ -365,7 +384,7 @@ async function upsertGranule({
     parent: updates.collectionId,
     refresh: inTestMode(),
   };
-  await esClient.delete(delGranParams, { ignore: [404] });
+  await cumulusEsClient.delete(delGranParams, { ignore: [404] });
 
   // Remove nils in case there isn't a collision
   const upsertDoc = removeNilProperties(updates);
@@ -412,7 +431,7 @@ async function upsertGranule({
     }
   }
 
-  return await esClient.update({
+  return await cumulusEsClient.update({
     index,
     type,
     id: updates.granuleId,
@@ -473,7 +492,7 @@ async function upsertPdr({
     ...updates,
     timestamp: Date.now(),
   };
-  return await esClient.update({
+  return await esClient.client.update({
     index,
     type,
     id: upsertDoc.pdrName,
@@ -506,13 +525,13 @@ async function upsertPdr({
  * @param  {Object} params.esClient - Elasticsearch Connection object
  * @param  {string} params.id       - id of the Elasticsearch record
  * @param  {string} params.type     - Elasticsearch type (default: execution)
- * @param  {strint} params.parent   - id of the parent (optional)
+ * @param  {string} params.parent   - id of the parent (optional)
  * @param  {string} params.index    - Elasticsearch index (default: cumulus)
  * @param  {Array}  params.ignore   - Response codes to ignore (optional)
  * @returns {Promise} elasticsearch delete response
  */
 async function deleteRecord({
-  esClient,
+  esClient = new EsClient(),
   id,
   type,
   parent,
@@ -531,8 +550,8 @@ async function deleteRecord({
   if (parent) params.parent = parent;
   if (ignore) options = { ignore };
 
-  const actualEsClient = esClient || (await Search.es());
-  const deleteResponse = await actualEsClient.delete(params, options);
+  await esClient.initializeEsClient();
+  const deleteResponse = await esClient.client.delete(params, options);
   return deleteResponse.body;
 }
 
@@ -778,27 +797,28 @@ async function deleteGranule({
 
 module.exports = {
   createIndex,
-  indexCollection,
-  indexProvider,
-  indexReconciliationReport,
-  indexRule,
-  indexGranule,
-  upsertGranule,
-  indexPdr,
-  upsertPdr,
-  indexExecution,
-  indexAsyncOperation,
-  deleteRecord,
   deleteAsyncOperation,
-  updateAsyncOperation,
-  upsertExecution,
   deleteCollection,
-  deleteProvider,
-  deleteRule,
-  deletePdr,
-  deleteGranule,
   deleteExecution,
+  deleteGranule,
+  deletePdr,
+  deleteProvider,
   deleteReconciliationReport,
+  deleteRecord,
+  deleteRule,
   executionInvalidNullFields,
   granuleInvalidNullFields,
+  genericRecordUpdate,
+  indexAsyncOperation,
+  indexCollection,
+  indexExecution,
+  indexGranule,
+  indexPdr,
+  indexProvider,
+  indexReconciliationReport,
+  indexRule,
+  updateAsyncOperation,
+  upsertExecution,
+  upsertGranule,
+  upsertPdr,
 };

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@cumulus/es-client",
-  "version": "18.2.2",
+  "version": "18.3.1",
   "description": "Utilities for working with Elasticsearch",
   "keywords": [
     "CUMULUS",
     "NASA"
   ],
   "engines": {
-    "node": ">=16.19.0"
+    "node": ">=20.12.2"
   },
   "publishConfig": {
     "access": "public"
@@ -19,6 +19,7 @@
   },
   "scripts": {
     "test": "../../node_modules/.bin/ava",
+    "test:ci": "../../scripts/run_package_ci_unit.sh",
     "test:coverage": "../../node_modules/.bin/nyc npm test",
     "coverage": "python ../../scripts/coverage_handler/coverage.py"
   },
@@ -26,26 +27,27 @@
     "files": [
       "tests/*.js"
     ],
-    "verbose": true
+    "verbose": true,
+    "failFast": true
   },
   "author": "Cumulus Authors",
   "license": "Apache-2.0",
   "dependencies": {
-    "@cumulus/common": "18.2.2",
-    "@cumulus/errors": "18.2.2",
-    "@cumulus/logger": "18.2.2",
-    "@cumulus/message": "18.2.2",
+    "@aws-sdk/credential-providers": "^3.535.0",
+    "@cumulus/common": "18.3.1",
+    "@cumulus/errors": "18.3.1",
+    "@cumulus/logger": "18.3.1",
+    "@cumulus/message": "18.3.1",
     "@elastic/elasticsearch": "^5.6.20",
-    "aws-elasticsearch-connector": "8.2.0",
-    "aws-sdk": "^2.1492.0",
+    "aws4": "^1.12.0",
     "lodash": "~4.17.21",
     "moment": "2.29.4",
     "p-limit": "^1.2.0"
   },
   "devDependencies": {
-    "@cumulus/aws-client": "18.2.2",
-    "@cumulus/test-data": "18.2.2",
+    "@cumulus/aws-client": "18.3.1",
+    "@cumulus/test-data": "18.3.1",
     "p-each-series": "^2.1.0"
   },
-  "gitHead": "d2f030f1d77b6d3072cb20f84261b10a7b160620"
+  "gitHead": "0393f90c6401ef0c524068e4636c1dcc389020b8"
 }

package/search.js

@@ -1,3 +1,4 @@
+//@ts-check
 /* This code is copied from sat-api-lib library
  * with some alterations.
  * source: https://raw.githubusercontent.com/sat-utils/sat-api-lib/master/libs/search.js
@@ -8,12 +9,13 @@
 
 const has = require('lodash/has');
 const omit = require('lodash/omit');
-const aws = require('aws-sdk');
-const { AmazonConnection } = require('aws-elasticsearch-connector');
+const { fromNodeProviderChain } = require('@aws-sdk/credential-providers');
 const elasticsearch = require('@elastic/elasticsearch');
 
 const { inTestMode } = require('@cumulus/common/test-utils');
+const Logger = require('@cumulus/logger');
 
+const createEsAmazonConnection = require('./esAmazonConnection');
 const queries = require('./queries');
 const aggs = require('./aggregations');
 
@@ -25,16 +27,11 @@ const logDetails = {
 const defaultIndexAlias = 'cumulus-alias';
 const multipleRecordFoundString = 'More than one record was found!';
 const recordNotFoundString = 'Record not found';
-
-const getCredentials = () =>
-  new Promise((resolve, reject) => aws.config.getCredentials((err) => {
-    if (err) return reject(err);
-    return resolve();
-  }));
+const logger = new Logger({ sender: '@cumulus/es-client/search' });
 
 /**
- * returns the local address of elasticsearch based on
- * the environment variables set
+ * Returns the local address of elasticsearch based on
+ * environment variables
  *
  * @returns {string} elasticsearch local address
  */
@@ -46,6 +43,19 @@ const getLocalEsHost = () => {
   return `${protocol}://localhost:9200`;
 };
 
+/**
+ * Retrieves AWS credentials using the `fromNodeProviderChain` function.
+ */
+const getAwsCredentials = async () => {
+  const credentialsProvider = fromNodeProviderChain({
+    clientConfig: {
+      region: process.env.AWS_REGION,
+    },
+  });
+  const creds = await credentialsProvider();
+  return creds;
+};
+
 const esTestConfig = () => ({
   node: getLocalEsHost(),
   requestTimeout: 5000,
@@ -54,9 +64,18 @@ const esTestConfig = () => ({
   },
 });
 
-const esProdConfig = async (host) => {
-  if (!aws.config.credentials) await getCredentials();
-
+/**
+ * Generates a configuration for Elasticsearch in a production environment.
+ *
+ * @param {string | undefined} host - The host URL for the Elasticsearch instance.
+ *  If not provided, the function will use the `ES_HOST` environment variable.
+ * @param {import('@aws-sdk/types').AwsCredentialIdentity | undefined} credentials - The
+ *  AWS credentials for accessing the Elasticsearch instance.
+ * @returns
+ * -  The configuration object for Elasticsearch, including the node address,
+ * AWS connection details, and request timeout.
+ */
+const esProdConfig = (host, credentials) => {
   let node = 'http://localhost:9200';
 
   if (process.env.ES_HOST) {
@@ -64,13 +83,12 @@ const esProdConfig = async (host) => {
   } else if (host) {
     node = `https://${host}`;
   }
-
   return {
     node,
-    Connection: AmazonConnection,
-    awsConfig: {
-      credentials: aws.config.credentials,
-    },
+    ...createEsAmazonConnection({
+      credentials,
+      region: process.env.AWS_REGION,
+    }),
 
     // Note that this doesn't abort the query.
     requestTimeout: 50000, // milliseconds
@@ -93,29 +111,147 @@ const esMetricsConfig = () => {
   };
 };
 
+/**
+ * Generates a configuration for Elasticsearch based on the environment
+ * and provided parameters.
+ *
+ * @param {string} [host] - The host URL for the Elasticsearch instance.
+ * @param {boolean} [metrics=false] - A flag indicating whether metrics are enabled.
+ * @returns {Promise<[Object, import('@aws-sdk/types').Credentials | undefined]>} A
+ * promise that resolves to a tuple containing the configuration object and
+ * AWS credentials (if applicable).
+ */
 const esConfig = async (host, metrics = false) => {
   let config;
+  let credentials;
   if (inTestMode() || 'LOCAL_ES_HOST' in process.env) {
     config = esTestConfig();
   } else if (metrics) {
     config = esMetricsConfig();
   } else {
-    config = await esProdConfig(host);
+    credentials = await getAwsCredentials();
+    config = esProdConfig(host, credentials);
   }
-  return config;
+  return [config, credentials];
 };
 
+/**
+ * `EsClient` is a class for managing an Elasticsearch client.
+ *
+ * @property {string} host - The host URL for the Elasticsearch instance.
+ * @property {boolean} metrics - A flag indicating whether metrics are enabled.
+ * @property {elasticsearch.Client} _client - The Elasticsearch client instance.
+ *
+ * @method constructor - Initializes a new instance of the `EsClient` class.
+ * @method initializeEsClient - Initializes the Elasticsearch client (this._client/client)
+ * if it hasn't been initialized yet.
+ * @method refreshClient - Refreshes the Elasticsearch client if the AWS credentials have changed,
+ * by creating a new Elasticsearch `Client` instance.
+ * @method client - Getter that returns the current Elasticsearch Client
+ */
+class EsClient {
+  /**
+   *  Initializes the Elasticsearch client if it hasn't been initialized yet,
+   * fetching AWS credentials if necessary.
+   *
+   * @returns {Promise<elasticsearch.Client>} A promise that resolves to an instance of
+   * `elasticsearch.Client`.
+   */
+  async initializeEsClient() {
+    /** @type {elasticsearch.Client | undefined} */
+    let client = this._client;
+    if (!client) {
+      const [config, credentials] = await esConfig(this.host, this.metrics);
+      if (credentials) {
+        this._awsKeyId = credentials.accessKeyId;
+      }
+      client = new elasticsearch.Client(config);
+      this._client = client;
+    }
+    return client;
+  }
+
+  /**
+   * Asynchronously refreshes the Elasticsearch client if the AWS credentials have changed,
+   * by creating a new Elasticsearch `Client` instance.
+   *
+   * @returns {Promise<void>} A promise that resolves when the credentials have been refreshed.
+   */
+  async refreshClient() {
+    const { host, metrics } = this;
+    if (this.metrics || inTestMode() || process.env.LOCAL_ES_HOST) {
+      return;
+    }
+    const oldKey = this._awsKeyId;
+    const newCreds = await getAwsCredentials();
+    if (oldKey !== newCreds.accessKeyId) {
+      logger.info('AWS Credentials updated, updating to new ESClient');
+      const [config] = await esConfig(host, metrics); // Removed unused variable _creds
+      this._client = new elasticsearch.Client(config);
+      this._awsKeyId = newCreds.accessKeyId;
+    }
+  }
+
+  /**
+   * Getter that returns the Elasticsearch client instance if it's been initialized
+   *
+   * @returns {elasticsearch.Client | undefined} The Elasticsearch client instance.
+   */
+  get client() {
+    return this._client;
+  }
+
+  /**
+   * Initializes a new instance of the `EsClient` class.
+   *
+   * @param {string} host - The host URL for the Elasticsearch instance.
+   * @param {boolean} [metrics=false] - A flag indicating whether metrics are enabled.
+   */
+  constructor(host, metrics = false) {
+    this.host = host;
+    this.metrics = metrics;
+    if (metrics) {
+      this.host = process.env.METRICS_ES_HOST;
+    }
+  }
+}
+
+/**
+ * `BaseSearch` is a class for managing certain Cumulus Elasticsearch queries.
+ *
+ * @property {string | undefined} host - The host URL for the Elasticsearch instance.
+ * @property {boolean} metrics - A flag indicating whether metrics are enabled.
+ * @property {EsClient} _esClient - The Elasticsearch client instance.
+ * @property {string | null} type - The type of the Elasticsearch index.
+ * @property {Object} params - The query parameters.
+ * @property {number} size - The number of results to return per page.
+ * @property {number} frm - The starting index for the results.
+ * @property {number} page - The current page number.
+ * @property {string} index - The Elasticsearch index to query.
+ *
+ * @method initializeEsClient - Initializes the EsClient associated with the instance of this class
+ * @method client - Returns the Elasticsearch client instance.
+ * @method constructor - Initializes the `BaseSearch` instance, including the EsClient instance.
+ * @method get - Retrieves a single document by id and/or parentId.
+ * @method exists - Checks if a document exists by id and/or parentId.
+ * @method query - Performs a search query.
+ * @method count - Counts the number of documents in the index
+ */
 class BaseSearch {
-  static async es(host, metrics) {
-    return new elasticsearch.Client(await esConfig(host, metrics));
+  async initializeEsClient(host, metrics) {
+    this._esClient = new EsClient(host, metrics);
+    await this._esClient.initializeEsClient();
+  }
+
+  get client() {
+    return this._esClient ? this._esClient.client : undefined;
   }
 
-  constructor(event, type = null, index, metrics = false) {
+  constructor(event = {}, type = null, index, metrics = false) {
     let params = {};
     const logLimit = 10;
 
     this.type = type;
-    this.client = null;
     this.metrics = metrics;
 
     // this will allow us to receive payload
@@ -125,17 +261,16 @@ class BaseSearch {
     }
 
     // get page number
-    const page = Number.parseInt((params.page) ? params.page : 1, 10);
+    const page = Number.parseInt(params.page ? params.page : 1, 10);
     this.params = params;
-    //log.debug('Generated params:', params, logDetails);
 
-    this.size = Number.parseInt((params.limit) ? params.limit : logLimit, 10);
+    this.size = Number.parseInt(params.limit ? params.limit : logLimit, 10);
 
     // max size is 100 for performance reasons
     this.size = this.size > 100 ? 100 : this.size;
 
     this.frm = (page - 1) * this.size;
-    this.page = Number.parseInt((params.skip) ? params.skip : page, 10);
+    this.page = Number.parseInt(params.skip ? params.skip : page, 10);
     this.index = index || defaultIndexAlias;
   }
 
@@ -197,37 +332,38 @@ class BaseSearch {
     const body = {
       query: {
         bool: {
-          must: [{
-            term: {
-              _id: id,
+          must: [
+            {
+              term: {
+                _id: id,
+              },
             },
-          }],
+          ],
         },
       },
     };
 
     if (parentId) {
-      body.query.bool.must.push(
-        {
-          parent_id: {
-            id: parentId,
-            type: this.type,
-          },
-        }
-      );
+      body.query.bool.must.push({
+        parent_id: {
+          id: parentId,
+          type: this.type,
+        },
+      });
     }
 
     logDetails.granuleId = id;
 
-    if (!this.client) {
-      this.client = await this.constructor.es();
+    if (!this._esClient) {
+      await this.initializeEsClient();
     }
 
     const result = await this.client.search({
       index: this.index,
       type: this.type,
       body,
-    }).then((response) => response.body);
+    })
+      .then((response) => response.body);
 
     if (result.hits.total > 1) {
       return { detail: multipleRecordFoundString };
@@ -251,8 +387,8 @@ class BaseSearch {
 
     try {
       // search ES with the generated parameters
-      if (!this.client) {
-        this.client = await this.constructor.es(null, this.metrics);
+      if (!this._esClient) {
+        await this.initializeEsClient(null, this.metrics);
       }
       const response = await this.client.search(searchParams);
       const hits = response.body.hits.hits;
@@ -262,7 +398,9 @@ class BaseSearch {
       meta.page = this.page;
       meta.count = response.body.hits.total;
       if (hits.length > 0) {
-        meta.searchContext = encodeURIComponent(JSON.stringify(hits[hits.length - 1].sort));
+        meta.searchContext = encodeURIComponent(
+          JSON.stringify(hits[hits.length - 1].sort)
+        );
       }
 
       return {
@@ -278,11 +416,11 @@ class BaseSearch {
     const searchParams = this._buildAggregation();
 
     try {
-      if (!this.client) {
-        this.client = await this.constructor.es();
+      if (!this.esClient) {
+        this.esClient = await this.initializeEsClient();
       }
 
-      const result = await this.client.search(searchParams);
+      const result = await this.esClient.search(searchParams);
       const count = result.body.hits.total;
 
       return {
@@ -293,7 +431,6 @@ class BaseSearch {
         counts: result.body.aggregations,
       };
     } catch (error) {
-      //log.error(e, logDetails);
       return error;
     }
   }
@@ -301,9 +438,24 @@ class BaseSearch {
 
 class Search extends BaseSearch {}
 
+/**
+ * Initializes and returns an instance of an `EsClient` Class
+ *
+ * @param {string} host - The host URL for the Elasticsearch instance.
+ * @param {boolean} metrics - A flag indicating whether metrics are enabled.
+ * @returns {Promise<EsClient>} A promise that resolves to an instance of `EsClient`.
+ */
+const getEsClient = async (host, metrics) => {
+  const esClient = new EsClient(host, metrics);
+  await esClient.initializeEsClient();
+  return esClient;
+};
+
 module.exports = {
   BaseSearch,
   Search,
+  EsClient,
+  getEsClient,
   defaultIndexAlias,
   multipleRecordFoundString,
   recordNotFoundString,

package/stats.js

@@ -28,8 +28,8 @@ class Stats extends BaseSearch {
   }
 
   async query() {
-    if (!this.client) {
-      this.client = await this.constructor.es();
+    if (!this._esClient) {
+      await this.initializeEsClient(undefined, this.metrics);
     }
 
     // granules
@@ -105,8 +105,8 @@ class Stats extends BaseSearch {
   }
 
   async count() {
-    if (!this.client) {
-      this.client = await this.constructor.es();
+    if (!this._esClient) {
+      await this.initializeEsClient(undefined, this.metrics);
     }
 
     const originalField = this.params.field || 'status';

package/testUtils.js

@@ -2,7 +2,7 @@ const { randomString } = require('@cumulus/common/test-utils');
 
 const bootstrap = require('./bootstrap');
 
-const { Search } = require('./search');
+const { EsClient, Search } = require('./search');
 
 const createTestIndex = async () => {
   const esIndex = randomString();
@@ -13,12 +13,19 @@ const createTestIndex = async () => {
     index: esIndex,
     alias: esAlias,
   });
-  const esClient = await Search.es('fakehost');
-  return { esIndex, esClient };
+  const esClient = await new EsClient('fakehost');
+  await esClient.initializeEsClient();
+  const searchClient = await new Search();
+  await searchClient.initializeEsClient('fakehost');
+  return {
+    esClient,
+    esIndex,
+    searchClient,
+  };
 };
 
 const cleanupTestIndex = async ({ esClient, esIndex }) => {
-  await esClient.indices.delete({ index: esIndex });
+  await esClient.client.indices.delete({ index: esIndex });
 };
 
 module.exports = {