node-es-transformer 1.0.0-beta3 → 1.0.0-beta5

package/dist/node-es-transformer.esm.js

@@ -1,44 +1,44 @@
+import elasticsearch from '@elastic/elasticsearch';
 import fs from 'fs';
 import es from 'event-stream';
 import glob from 'glob';
 import split from 'split2';
 import { Readable } from 'stream';
 import cliProgress from 'cli-progress';
-import elasticsearch from '@elastic/elasticsearch';
 
 // In earlier versions this was used to set the number of docs to index in a
 // single bulk request. Since we switched to use the helpers.bulk() method from
 // the ES client, this now translates to the `flushBytes` option of the helper.
 // However, for kind of a backwards compability with the old values, this uses
 // KBytes instead of Bytes. It will be multiplied by 1024 in the index queue.
-var DEFAULT_BUFFER_SIZE = 5120;
+const DEFAULT_BUFFER_SIZE = 5120;
 
 // The default number of docs to fetch in a single search request when reindexing.
-var DEFAULT_SEARCH_SIZE = 1000;
-
-function createMappingFactory(ref) {
-  var sourceClient = ref.sourceClient;
-  var sourceIndexName = ref.sourceIndexName;
-  var targetClient = ref.targetClient;
-  var targetIndexName = ref.targetIndexName;
-  var mappings = ref.mappings;
-  var mappingsOverride = ref.mappingsOverride;
-  var indexMappingTotalFieldsLimit = ref.indexMappingTotalFieldsLimit;
-  var verbose = ref.verbose;
-  var deleteIndex = ref.deleteIndex;
-
-  return async function () {
-    var targetMappings = mappingsOverride ? undefined : mappings;
+const DEFAULT_SEARCH_SIZE = 1000;
 
+function createMappingFactory({
+  sourceClient,
+  sourceIndexName,
+  targetClient,
+  targetIndexName,
+  mappings,
+  mappingsOverride,
+  indexMappingTotalFieldsLimit,
+  verbose,
+  deleteIndex,
+  pipeline
+}) {
+  return async () => {
+    let targetMappings = mappingsOverride ? undefined : mappings;
     if (sourceClient && sourceIndexName && typeof targetMappings === 'undefined') {
       try {
-        var mapping = await sourceClient.indices.getMapping({
-          index: sourceIndexName,
+        const mapping = await sourceClient.indices.getMapping({
+          index: sourceIndexName
         });
         if (mapping[sourceIndexName]) {
           targetMappings = mapping[sourceIndexName].mappings;
         } else {
-          var allMappings = Object.values(mapping);
+          const allMappings = Object.values(mapping);
           if (allMappings.length > 0) {
             targetMappings = Object.values(mapping)[0].mappings;
           }
@@ -48,36 +48,47 @@ function createMappingFactory(ref) {
         return;
       }
     }
-
     if (typeof targetMappings === 'object' && targetMappings !== null) {
       if (mappingsOverride) {
-        targetMappings = Object.assign({}, targetMappings,
-          {properties: Object.assign({}, targetMappings.properties,
-            mappings)});
+        targetMappings = {
+          ...targetMappings,
+          properties: {
+            ...targetMappings.properties,
+            ...mappings
+          }
+        };
       }
-
       try {
-        var indexExists = await targetClient.indices.exists({ index: targetIndexName });
-
+        const indexExists = await targetClient.indices.exists({
+          index: targetIndexName
+        });
         if (indexExists === true && deleteIndex === true) {
-          await targetClient.indices.delete({ index: targetIndexName });
+          await targetClient.indices.delete({
+            index: targetIndexName
+          });
         }
-
         if (indexExists === false || deleteIndex === true) {
-          var resp = await targetClient.indices.create({
+          const resp = await targetClient.indices.create({
             index: targetIndexName,
-            body: Object.assign({}, {mappings: targetMappings},
-              (indexMappingTotalFieldsLimit !== undefined
-                ? {
-                    settings: {
-                      'index.mapping.total_fields.limit': indexMappingTotalFieldsLimit,
-                      'index.number_of_shards': 1,
-                      'index.number_of_replicas': 0,
-                    },
+            body: {
+              mappings: targetMappings,
+              ...(pipeline !== undefined ? {
+                settings: {
+                  index: {
+                    default_pipeline: pipeline
                   }
-                : {})),
+                }
+              } : {}),
+              ...(indexMappingTotalFieldsLimit !== undefined ? {
+                settings: {
+                  'index.mapping.total_fields.limit': indexMappingTotalFieldsLimit,
+                  'index.number_of_shards': 1,
+                  'index.number_of_replicas': 0
+                }
+              } : {})
+            }
           });
-          if (verbose) { console.log('Created target mapping', resp); }
+          if (verbose) console.log('Created target mapping', resp);
         }
       } catch (err) {
         console.log('Error creating target mapping', err);
@@ -88,119 +99,99 @@ function createMappingFactory(ref) {
 
 function fileReaderFactory(indexer, fileName, transform, splitRegex, verbose) {
   function startIndex(files) {
-    var finished = false;
-
-    var file = files.shift();
-    var s = fs
-      .createReadStream(file)
-      .pipe(split(splitRegex))
-      .pipe(
-        es
-          .mapSync(function (line) {
-            try {
-              // skip empty lines
-              if (line === '') {
-                return;
-              }
-
-              var doc =
-                typeof transform === 'function'
-                  ? JSON.stringify(transform(JSON.parse(line)))
-                  : line;
-
-              // if doc is undefined we'll skip indexing it
-              if (typeof doc === 'undefined') {
-                s.resume();
-                return;
-              }
-
-              // the transform callback may return an array of docs so we can emit
-              // multiple docs from a single line
-              if (Array.isArray(doc)) {
-                doc.forEach(function (d) { return indexer.add(d); });
-                return;
-              }
-
-              indexer.add(doc);
-            } catch (e) {
-              console.log('error', e);
-            }
-          })
-          .on('error', function (err) {
-            console.log('Error while reading file.', err);
-          })
-          .on('end', function () {
-            if (verbose) { console.log('Read entire file: ', file); }
-            if (files.length > 0) {
-              startIndex(files);
-              return;
-            }
+    let finished = false;
+    const file = files.shift();
+    const s = fs.createReadStream(file).pipe(split(splitRegex)).pipe(es.mapSync(line => {
+      try {
+        // skip empty lines
+        if (line === '') {
+          return;
+        }
+        const doc = typeof transform === 'function' ? JSON.stringify(transform(JSON.parse(line))) : line;
 
-            indexer.finish();
-            finished = true;
-          })
-      );
+        // if doc is undefined we'll skip indexing it
+        if (typeof doc === 'undefined') {
+          s.resume();
+          return;
+        }
 
-    indexer.queueEmitter.on('pause', function () {
-      if (finished) { return; }
+        // the transform callback may return an array of docs so we can emit
+        // multiple docs from a single line
+        if (Array.isArray(doc)) {
+          doc.forEach(d => indexer.add(d));
+          return;
+        }
+        indexer.add(doc);
+      } catch (e) {
+        console.log('error', e);
+      }
+    }).on('error', err => {
+      console.log('Error while reading file.', err);
+    }).on('end', () => {
+      if (verbose) console.log('Read entire file: ', file);
+      if (files.length > 0) {
+        startIndex(files);
+        return;
+      }
+      indexer.finish();
+      finished = true;
+    }));
+    indexer.queueEmitter.on('pause', () => {
+      if (finished) return;
       s.pause();
     });
-
-    indexer.queueEmitter.on('resume', function () {
-      if (finished) { return; }
+    indexer.queueEmitter.on('resume', () => {
+      if (finished) return;
       s.resume();
     });
   }
-
-  return function () {
-    glob(fileName, function (er, files) {
+  return () => {
+    glob(fileName, (er, files) => {
       startIndex(files);
     });
   };
 }
 
-var EventEmitter = require('events');
-
-var queueEmitter = new EventEmitter();
-
-var parallelCalls = 5;
+const EventEmitter = require('events');
+const queueEmitter = new EventEmitter();
+const parallelCalls = 5;
 
 // a simple helper queue to bulk index documents
-function indexQueueFactory(ref) {
-  var client = ref.targetClient;
-  var targetIndexName = ref.targetIndexName;
-  var bufferSize = ref.bufferSize; if ( bufferSize === void 0 ) bufferSize = DEFAULT_BUFFER_SIZE;
-  var skipHeader = ref.skipHeader; if ( skipHeader === void 0 ) skipHeader = false;
-  var verbose = ref.verbose; if ( verbose === void 0 ) verbose = true;
-
-  var flushBytes = bufferSize * 1024; // Convert KB to Bytes
-  var highWaterMark = flushBytes * parallelCalls;
+function indexQueueFactory({
+  targetClient: client,
+  targetIndexName,
+  bufferSize = DEFAULT_BUFFER_SIZE,
+  skipHeader = false
+}) {
+  let docsPerSecond = 0;
+  const flushBytes = bufferSize * 1024; // Convert KB to Bytes
+  const highWaterMark = flushBytes * parallelCalls;
 
   // Create a Readable stream
-  var stream = new Readable({
-    read: function read() {}, // Implement read but we manage pushing manually
-    highWaterMark: highWaterMark, // Buffer size for backpressure management
+  const stream = new Readable({
+    read() {},
+    // Implement read but we manage pushing manually
+    highWaterMark // Buffer size for backpressure management
   });
-
   async function* ndjsonStreamIterator(readableStream) {
-    var buffer = ''; // To hold the incomplete data
-    var skippedHeader = false;
+    let buffer = ''; // To hold the incomplete data
+    let skippedHeader = false;
 
     // Iterate over the stream using async iteration
-    for await (var chunk of readableStream) {
+    for await (const chunk of readableStream) {
       buffer += chunk.toString(); // Accumulate the chunk data in the buffer
 
       // Split the buffer into lines (NDJSON items)
-      var lines = buffer.split('\n');
+      const lines = buffer.split('\n');
 
       // The last line might be incomplete, so hold it back in the buffer
       buffer = lines.pop();
 
       // Yield each complete JSON object
-      for (var line of lines) {
+      for (const line of lines) {
         if (line.trim()) {
           try {
-            if (!skipHeader || (skipHeader && !skippedHeader)) {
+            if (!skipHeader || skipHeader && !skippedHeader) {
               yield JSON.parse(line); // Parse and yield the JSON object
               skippedHeader = true;
             }
@@ -221,122 +212,106 @@ function indexQueueFactory(ref) {
       }
     }
   }
-
-  var finished = false;
+  let finished = false;
 
   // Async IIFE to start bulk indexing
-  (async function () {
-    console.log('START BULK INDEXING');
+  (async () => {
+    const interval = setInterval(() => {
+      queueEmitter.emit('docsPerSecond', docsPerSecond);
+      docsPerSecond = 0;
+    }, 1000);
     await client.helpers.bulk({
       concurrency: parallelCalls,
-      flushBytes: flushBytes,
+      flushBytes,
       flushInterval: 1000,
       refreshOnCompletion: true,
       datasource: ndjsonStreamIterator(stream),
-      onDocument: function onDocument(doc) {
+      onDocument(doc) {
+        docsPerSecond++;
         return {
-          index: { _index: targetIndexName },
+          index: {
+            _index: targetIndexName
+          }
         };
-      },
+      }
     });
-    console.log('FINISHED BULK INDEXING');
-
+    clearInterval(interval);
     queueEmitter.emit('finish');
   })();
-
   return {
-    add: function (doc) {
+    add: doc => {
       if (finished) {
         throw new Error('Unexpected doc added after indexer should finish.');
       }
-
-      var canContinue = stream.push(((JSON.stringify(doc)) + "\n"));
+      const canContinue = stream.push(`${JSON.stringify(doc)}\n`);
       if (!canContinue) {
         queueEmitter.emit('pause');
-        stream.once('drain', function () {
+        stream.once('drain', () => {
           queueEmitter.emit('resume');
         });
       }
     },
-    finish: function () {
+    finish: () => {
       finished = true;
       stream.push(null);
     },
-    queueEmitter: queueEmitter,
+    queueEmitter
   };
 }
 
 // create a new progress bar instance and use shades_classic theme
-var progressBar = new cliProgress.SingleBar({}, cliProgress.Presets.shades_classic);
-
-function indexReaderFactory(
-  indexer,
-  sourceIndexName,
-  transform,
-  client,
-  query,
-  searchSize,
-  populatedFields
-) {
-  if ( searchSize === void 0 ) searchSize = DEFAULT_SEARCH_SIZE;
-  if ( populatedFields === void 0 ) populatedFields = false;
-
+const progressBar = new cliProgress.SingleBar({}, cliProgress.Presets.shades_classic);
+function indexReaderFactory(indexer, sourceIndexName, transform, client, query, searchSize = DEFAULT_SEARCH_SIZE, populatedFields = false) {
   return async function indexReader() {
-    var docsNum = 0;
-    var scrollId;
-    var finished = false;
-    var readActive = false;
-    var backPressurePause = false;
-
+    let docsNum = 0;
+    let scrollId;
+    let finished = false;
+    let readActive = false;
+    let backPressurePause = false;
     async function fetchPopulatedFields() {
       try {
-        var response = await client.search({
+        // Get all populated fields from the index
+        const response = await client.fieldCaps({
           index: sourceIndexName,
-          size: searchSize,
-          query: {
-            function_score: {
-              query: query,
-              random_score: {},
-            },
-          },
+          fields: '*',
+          include_empty_fields: false,
+          filters: '-metadata'
+        }, {
+          maxRetries: 0
         });
-
-        // Get all field names for each returned doc and flatten it
-        // to a list of unique field names used across all docs.
-        return Array.from(new Set(response.hits.hits.map(function (d) { return Object.keys(d._source); }).flat(1)));
+        return Object.keys(response.fields);
       } catch (e) {
         console.log('error', e);
       }
     }
-
     function search(fields) {
-      return client.search(Object.assign({}, {index: sourceIndexName,
+      return client.search({
+        index: sourceIndexName,
         scroll: '600s',
         size: searchSize,
-        query: query},
-        (fields ? { _source: fields } : {})));
+        query,
+        ...(fields ? {
+          _source: fields
+        } : {})
+      });
     }
-
     function scroll(id) {
       return client.scroll({
         scroll_id: id,
-        scroll: '600s',
+        scroll: '600s'
       });
     }
-
-    var fieldsWithData;
+    let fieldsWithData;
 
     // identify populated fields
     if (populatedFields) {
       fieldsWithData = await fetchPopulatedFields();
     }
-
     await fetchNextResponse();
-
     function processHit(hit) {
       docsNum += 1;
       try {
-        var doc = typeof transform === 'function' ? transform(hit._source) : hit._source; // eslint-disable-line no-underscore-dangle
+        const doc = typeof transform === 'function' ? transform(hit._source) : hit._source; // eslint-disable-line no-underscore-dangle
 
         // if doc is undefined we'll skip indexing it
         if (typeof doc === 'undefined') {
@@ -346,35 +321,27 @@ function indexReaderFactory(
         // the transform callback may return an array of docs so we can emit
         // multiple docs from a single line
         if (Array.isArray(doc)) {
-          doc.forEach(function (d) { return indexer.add(d); });
+          doc.forEach(d => indexer.add(d));
           return;
         }
-
         indexer.add(doc);
       } catch (e) {
         console.log('error', e);
       }
     }
-
     async function fetchNextResponse() {
       readActive = true;
-
-      var sc = scrollId ? await scroll(scrollId) : await search(fieldsWithData);
-
+      const sc = scrollId ? await scroll(scrollId) : await search(fieldsWithData);
       if (!scrollId) {
         progressBar.start(sc.hits.total.value, 0);
       }
-
       scrollId = sc._scroll_id;
       readActive = false;
-
       processResponse(sc);
     }
-
     async function processResponse(response) {
       // collect the docs from this response
       response.hits.hits.forEach(processHit);
-
       progressBar.update(docsNum);
 
       // check to see if we have collected all of the docs
@@ -382,27 +349,21 @@ function indexReaderFactory(
         indexer.finish();
         return;
       }
-
       if (!backPressurePause) {
         await fetchNextResponse();
       }
     }
-
-    indexer.queueEmitter.on('pause', async function () {
+    indexer.queueEmitter.on('pause', async () => {
       backPressurePause = true;
     });
-
-    indexer.queueEmitter.on('resume', async function () {
+    indexer.queueEmitter.on('resume', async () => {
       backPressurePause = false;
-
       if (readActive || finished) {
         return;
       }
-
       await fetchNextResponse();
     });
-
-    indexer.queueEmitter.on('finish', function () {
+    indexer.queueEmitter.on('finish', () => {
       finished = true;
       progressBar.stop();
     });
@@ -411,167 +372,130 @@ function indexReaderFactory(
 
 function streamReaderFactory(indexer, stream, transform, splitRegex, verbose) {
   function startIndex() {
-    console.log('START INDEX', splitRegex);
-    var finished = false;
-
-    var s = stream.pipe(split(splitRegex)).pipe(
-      es
-        .mapSync(function (line) {
-          try {
-            // skip empty lines
-            if (line === '') {
-              return;
-            }
-
-            var doc =
-              typeof transform === 'function' ? JSON.stringify(transform(JSON.parse(line))) : line;
-
-            // if doc is undefined we'll skip indexing it
-            if (typeof doc === 'undefined') {
-              s.resume();
-              return;
-            }
-
-            // the transform callback may return an array of docs so we can emit
-            // multiple docs from a single line
-            if (Array.isArray(doc)) {
-              doc.forEach(function (d) { return indexer.add(d); });
-              return;
-            }
+    let finished = false;
+    const s = stream.pipe(split(splitRegex)).pipe(es.mapSync(line => {
+      try {
+        // skip empty lines
+        if (line === '') {
+          return;
+        }
+        const doc = typeof transform === 'function' ? JSON.stringify(transform(JSON.parse(line))) : line;
 
-            indexer.add(doc);
-          } catch (e) {
-            console.log('error', e);
-          }
-        })
-        .on('error', function (err) {
-          console.log('Error while reading file.', err);
-        })
-        .on('end', function () {
-          if (verbose) { console.log('Read entire stream.'); }
-          indexer.finish();
-          finished = true;
-        })
-    );
+        // if doc is undefined we'll skip indexing it
+        if (typeof doc === 'undefined') {
+          s.resume();
+          return;
+        }
 
-    indexer.queueEmitter.on('pause', function () {
-      if (finished) { return; }
+        // the transform callback may return an array of docs so we can emit
+        // multiple docs from a single line
+        if (Array.isArray(doc)) {
+          doc.forEach(d => indexer.add(d));
+          return;
+        }
+        indexer.add(doc);
+      } catch (e) {
+        console.log('error', e);
+      }
+    }).on('error', err => {
+      console.log('Error while reading stream.', err);
+    }).on('end', () => {
+      if (verbose) console.log('Read entire stream.');
+      indexer.finish();
+      finished = true;
+    }));
+    indexer.queueEmitter.on('pause', () => {
+      if (finished) return;
       s.pause();
     });
-
-    indexer.queueEmitter.on('resume', function () {
-      if (finished) { return; }
+    indexer.queueEmitter.on('resume', () => {
+      if (finished) return;
       s.resume();
     });
   }
-
-  return function () {
+  return () => {
     startIndex();
   };
 }
 
-async function transformer(ref) {
-  var deleteIndex = ref.deleteIndex; if ( deleteIndex === void 0 ) deleteIndex = false;
-  var sourceClientConfig = ref.sourceClientConfig;
-  var targetClientConfig = ref.targetClientConfig;
-  var bufferSize = ref.bufferSize; if ( bufferSize === void 0 ) bufferSize = DEFAULT_BUFFER_SIZE;
-  var searchSize = ref.searchSize; if ( searchSize === void 0 ) searchSize = DEFAULT_SEARCH_SIZE;
-  var stream = ref.stream;
-  var fileName = ref.fileName;
-  var splitRegex = ref.splitRegex; if ( splitRegex === void 0 ) splitRegex = /\n/;
-  var sourceIndexName = ref.sourceIndexName;
-  var targetIndexName = ref.targetIndexName;
-  var mappings = ref.mappings;
-  var mappingsOverride = ref.mappingsOverride; if ( mappingsOverride === void 0 ) mappingsOverride = false;
-  var indexMappingTotalFieldsLimit = ref.indexMappingTotalFieldsLimit;
-  var populatedFields = ref.populatedFields; if ( populatedFields === void 0 ) populatedFields = false;
-  var query = ref.query;
-  var skipHeader = ref.skipHeader; if ( skipHeader === void 0 ) skipHeader = false;
-  var transform = ref.transform;
-  var verbose = ref.verbose; if ( verbose === void 0 ) verbose = true;
-
-  console.log('TRANSFORMER');
+async function transformer({
+  deleteIndex = false,
+  sourceClientConfig,
+  targetClientConfig,
+  bufferSize = DEFAULT_BUFFER_SIZE,
+  searchSize = DEFAULT_SEARCH_SIZE,
+  stream,
+  fileName,
+  splitRegex = /\n/,
+  sourceIndexName,
+  targetIndexName,
+  mappings,
+  mappingsOverride = false,
+  indexMappingTotalFieldsLimit,
+  pipeline,
+  populatedFields = false,
+  query,
+  skipHeader = false,
+  transform,
+  verbose = true
+}) {
   if (typeof targetIndexName === 'undefined') {
     throw Error('targetIndexName must be specified.');
   }
-
-  var defaultClientConfig = {
-    node: 'http://localhost:9200',
+  const defaultClientConfig = {
+    node: 'http://localhost:9200'
   };
-
-  var sourceClient = new elasticsearch.Client(sourceClientConfig || defaultClientConfig);
-  var targetClient = new elasticsearch.Client(
-    targetClientConfig || sourceClientConfig || defaultClientConfig
-  );
-
-  var createMapping = createMappingFactory({
-    sourceClient: sourceClient,
-    sourceIndexName: sourceIndexName,
-    targetClient: targetClient,
-    targetIndexName: targetIndexName,
-    mappings: mappings,
-    mappingsOverride: mappingsOverride,
-    indexMappingTotalFieldsLimit: indexMappingTotalFieldsLimit,
-    verbose: verbose,
-    deleteIndex: deleteIndex,
+  const sourceClient = new elasticsearch.Client(sourceClientConfig || defaultClientConfig);
+  const targetClient = new elasticsearch.Client(targetClientConfig || sourceClientConfig || defaultClientConfig);
+  const createMapping = createMappingFactory({
+    sourceClient,
+    sourceIndexName,
+    targetClient,
+    targetIndexName,
+    mappings,
+    mappingsOverride,
+    indexMappingTotalFieldsLimit,
+    verbose,
+    deleteIndex,
+    pipeline
   });
-  var indexer = indexQueueFactory({
-    targetClient: targetClient,
-    targetIndexName: targetIndexName,
-    bufferSize: bufferSize,
-    skipHeader: skipHeader,
-    verbose: verbose,
+  const indexer = indexQueueFactory({
+    targetClient,
+    targetIndexName,
+    bufferSize,
+    skipHeader,
+    verbose
   });
-
   function getReader() {
     if (typeof fileName !== 'undefined' && typeof sourceIndexName !== 'undefined') {
       throw Error('Only either one of fileName or sourceIndexName can be specified.');
     }
-
-    if (
-      (typeof fileName !== 'undefined' && typeof sourceIndexName !== 'undefined') ||
-      (typeof fileName !== 'undefined' && typeof stream !== 'undefined') ||
-      (typeof sourceIndexName !== 'undefined' && typeof stream !== 'undefined')
-    ) {
+    if (typeof fileName !== 'undefined' && typeof sourceIndexName !== 'undefined' || typeof fileName !== 'undefined' && typeof stream !== 'undefined' || typeof sourceIndexName !== 'undefined' && typeof stream !== 'undefined') {
       throw Error('Only one of fileName, sourceIndexName, or stream can be specified.');
     }
-
     if (typeof fileName !== 'undefined') {
       return fileReaderFactory(indexer, fileName, transform, splitRegex, verbose);
     }
-
     if (typeof sourceIndexName !== 'undefined') {
-      return indexReaderFactory(
-        indexer,
-        sourceIndexName,
-        transform,
-        sourceClient,
-        query,
-        searchSize,
-        populatedFields
-      );
+      return indexReaderFactory(indexer, sourceIndexName, transform, sourceClient, query, searchSize, populatedFields);
     }
-
     if (typeof stream !== 'undefined') {
-      console.log('STREAM READER');
       return streamReaderFactory(indexer, stream, transform, splitRegex, verbose);
     }
-
     return null;
   }
-
-  var reader = getReader();
-  console.log('READER INITIALIZED');
-
+  const reader = getReader();
   try {
-    var indexExists = await targetClient.indices.exists({ index: targetIndexName });
-    console.log('INDEX EXISTS', indexExists);
-
+    const indexExists = await targetClient.indices.exists({
+      index: targetIndexName
+    });
     if (indexExists === false) {
       await createMapping();
       reader();
     } else if (deleteIndex === true) {
-      await targetClient.indices.delete({ index: targetIndexName });
+      await targetClient.indices.delete({
+        index: targetIndexName
+      });
       await createMapping();
       reader();
     } else {
@@ -582,8 +506,10 @@ async function transformer(ref) {
   } finally {
     // targetClient.close();
   }
-
-  return { events: indexer.queueEmitter };
+  return {
+    events: indexer.queueEmitter
+  };
 }
 
-export default transformer;
+export { transformer as default };
+//# sourceMappingURL=node-es-transformer.esm.js.map