event-storage 0.8.0 → 1.0.0

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "event-storage",
-  "version": "0.8.0",
+  "version": "1.0.0",
+  "type": "module",
   "description": "An optimized embedded event store for node.js",
   "keywords": [
     "event-storage",
@@ -15,31 +16,35 @@
   "homepage": "https://github.com/albe/node-event-storage",
   "repository": {
     "type": "git",
-    "url": "https://github.com/albe/node-event-storage"
+    "url": "git+https://github.com/albe/node-event-storage.git"
   },
   "bugs": {
     "url": "https://github.com/albe/node-event-storage/issues"
   },
+  "exports": {
+    ".": "./index.js"
+  },
   "scripts": {
-    "test": "nyc --reporter=lcov mocha test/*.spec.js",
-    "coverage": "nyc report --reporter=text-lcov | coveralls"
+    "test": "c8 --reporter=lcov --reporter=text mocha test/*.spec.js",
+    "coverage": "c8 report --reporter=text-lcov | coveralls"
   },
   "files": [
-    "*/Consumer*.js",
-    "*/EventStore*.js",
-    "*/EventStream*.js",
-    "*/Index*.js",
-    "*/IndexEntry*.js",
-    "*/JoinEventStream*.js",
-    "*/Partition*.js",
-    "*/Storage*.js",
-    "*/Watcher*.js",
-    "*/Clock*.js",
-    "*/Index/*.js",
-    "*/Partition/*.js",
-    "*/Storage/*.js",
+    "src/Consumer*.js",
+    "src/EventStore*.js",
+    "src/EventStream*.js",
+    "src/Index*.js",
+    "src/IndexEntry*.js",
+    "src/JoinEventStream*.js",
+    "src/Partition*.js",
+    "src/Storage*.js",
+    "src/Watcher*.js",
+    "src/Clock*.js",
+    "src/Index/*.js",
+    "src/Partition/*.js",
+    "src/Storage/*.js",
     "src/WatchesFile.js",
     "src/util.js",
+    "src/metadataUtil.js",
     "index.js"
   ],
   "license": "MIT",
@@ -50,24 +55,16 @@
     }
   ],
   "engines": {
-    "node": ">=10.0"
+    "node": ">=18.0"
   },
   "dependencies": {
-    "mkdirp": "^1.0.3"
-  },
-  "nyc": {
-    "include": [
-      "src/**/*.js"
-    ],
-    "exclude": [
-      "bench/**/*.js"
-    ]
+    "mkdirp": "^3.0.1"
   },
   "devDependencies": {
-    "coveralls": "^3.0.2",
+    "c8": "^11.0.0",
+    "coveralls-next": "^6.0.1",
     "expect.js": "^0.3.1",
-    "fs-extra": "^9.0.1",
-    "mocha": "^8.0.1",
-    "nyc": "^15.0.0"
+    "fs-extra": "^11.3.4",
+    "mocha": "^11.7.5"
   }
 }

package/src/Clock.js

@@ -1,6 +1,6 @@
-const TIME_BASE = process.hrtime();
-const DATE_BASE_US = Date.now() * 1000.0 + 999.0; // DATE_BASE_US should match the TIME_BASE with lower resolution, but never be less
-const US_PER_SEC = 1.0e6;
+const TIME_BASE = process.hrtime.bigint();
+const DATE_FACTOR = 1000000n;
+const DATE_BASE_NS = BigInt(Date.now() + 1) * DATE_FACTOR - 1n;
 const CLOCK_ACCURACY_US = 1; // two process.hrtime() calls take roughly this long, so this is the accuracy we can measure time
 
 /**
@@ -14,18 +14,30 @@ class Clock {
      * @param {Date|number} epoch The epoch to base this clock on, either as a Date or a number of the amount of milliseconds since the unix epoch
      */
     constructor(epoch) {
-        this.epoch = Math.floor((epoch instanceof Date ? epoch.getTime() : Number(epoch)) * 1000.0);
+        this.epoch = BigInt(epoch instanceof Date ? epoch.getTime() : Number(epoch)) * DATE_FACTOR;
+        this.lastTime = 0;
     }
 
     /**
-     * @returns {number} The number of microseconds since the epoch given in the constructor. The decimal part denotes the accuracy of the clock in milliseconds.
-     * @note Needs to allow at least tens of ms accuracy, better hundreds of ms
+     * @returns {number} The number of microseconds since the epoch given in the constructor.
+     * @note Needs to allow at least tenths of ms accuracy, better hundredths of ms
      */
     time() {
-        const delta = process.hrtime(TIME_BASE);
-        return DATE_BASE_US - this.epoch + (delta[0] * US_PER_SEC + Math.floor(delta[1] / 1000)) + (CLOCK_ACCURACY_US / 1000.0);
+        const delta = process.hrtime.bigint() - TIME_BASE;
+        const timeSinceEpoch = Number((DATE_BASE_NS - this.epoch + delta) / 1000n);
+        return this.lastTime = Math.max(this.lastTime + 1, timeSinceEpoch);
+    }
+
+    /**
+     * Return the clock accuracy of the given timestamp. This is only useful for calculating a consistent ordering
+     * ala TrueTime for multi-writer scenarios.
+     * @param {number} time A timestamp measured by this clock.
+     * @returns {number} The amount of µs accuracy this timestamp has.
+     */
+    accuracy(time) {
+        return CLOCK_ACCURACY_US;
     }
 
 }
 
-module.exports = Clock;
+export default Clock;

package/src/Consumer.js

@@ -1,9 +1,8 @@
-const stream = require('stream');
-const fs = require('fs');
-const path = require('path');
-const { assert, ensureDirectory } = require('./util');
-
-const Storage = require('./Storage/ReadableStorage');
+import stream from 'stream';
+import fs from 'fs';
+import path from 'path';
+import { assert, ensureDirectory } from './util.js';
+import Storage from './Storage/ReadableStorage.js';
 const MAX_CATCHUP_BATCH = 10;
 
 /**
@@ -299,4 +298,4 @@ class Consumer extends stream.Readable {
     }
 }
 
-module.exports = Consumer;
+export default Consumer;

package/src/EventStore.js

@@ -1,12 +1,12 @@
-const EventStream = require('./EventStream');
-const JoinEventStream = require('./JoinEventStream');
-const fs = require('fs');
-const path = require('path');
-const events = require('events');
-const Storage = require('./Storage');
-const Consumer = require('./Consumer');
-const stream = require('stream');
-const { assert } = require('./util');
+import EventStream from './EventStream.js';
+import JoinEventStream from './JoinEventStream.js';
+import fs from 'fs';
+import path from 'path';
+import events from 'events';
+import Storage, { ReadOnly as ReadOnlyStorage, LOCK_THROW, LOCK_RECLAIM } from './Storage.js';
+import Index from './Index.js';
+import Consumer from './Consumer.js';
+import { assert, scanForFiles } from './util.js';
 
 const ExpectedVersion = {
     Any: -1,
@@ -15,24 +15,6 @@ const ExpectedVersion = {
 
 class OptimisticConcurrencyError extends Error {}
 
-class EventUnwrapper extends stream.Transform {
-
-    constructor() {
-        super({ objectMode: true });
-    }
-
-    _transform(data, encoding, callback) {
-        /* istanbul ignore else */
-        if (data.stream && data.payload) {
-            this.push(data.payload);
-        } else {
-            this.push(data);
-        }
-        callback();
-    }
-
-}
-
 /**
  * An event store optimized for working with many streams.
  * An event stream is implemented as an iterator over an index on the storage, therefore indexes need to be lightweight
@@ -47,6 +29,10 @@ class EventStore extends events.EventEmitter {
      * @param {string} [config.streamsDirectory] The directory where the streams should be stored. Default '{storageDirectory}/streams'.
      * @param {object} [config.storageConfig] Additional config options given to the storage backend. See `Storage`.
      * @param {boolean} [config.readOnly] If the storage should be mounted in read-only mode.
+     * @param {object|function(string): object} [config.streamMetadata] A metadata object or a function `(streamName) => object`
+     *   that is called whenever a new stream partition is created. The returned object is stored once in the partition
+     *   file header and surfaced to `preCommit` / `preRead` hooks. Takes precedence only when
+     *   `config.storageConfig.metadata` is not also set.
      */
     constructor(storeName = 'eventstore', config = {}) {
         super();
@@ -63,6 +49,17 @@ class EventStore extends events.EventEmitter {
             readOnly: config.readOnly || false
         };
         const storageConfig = Object.assign(defaults, config.storageConfig);
+
+        // Translate the high-level streamMetadata option into the storage-level metadata function,
+        // but only when the caller has not already provided a lower-level storageConfig.metadata.
+        if (config.streamMetadata !== undefined && storageConfig.metadata === undefined) {
+            if (typeof config.streamMetadata === 'function') {
+                storageConfig.metadata = config.streamMetadata;
+            } else {
+                storageConfig.metadata = (streamName) => config.streamMetadata[streamName] || {};
+            }
+        }
+
         this.initialize(storeName, storageConfig);
     }
 
@@ -76,7 +73,7 @@ class EventStore extends events.EventEmitter {
 
         this.storeName = storeName;
         this.storage = (storageConfig.readOnly === true) ?
-                        new Storage.ReadOnly(storeName, storageConfig)
+                        new ReadOnlyStorage(storeName, storageConfig)
                         : new Storage(storeName, storageConfig);
         this.storage.open();
         this.streams = Object.create(null);
@@ -87,10 +84,43 @@ class EventStore extends events.EventEmitter {
                 this.storage.close();
                 throw err;
             }
+            this.checkUnfinishedCommits();
             this.emit('ready');
         });
     }
 
+    /**
+     * Check if the last commit in the store was unfinished, which is the case if not all events of the commit have been written.
+     * Torn writes are handled at the storage level, so this method only deals with unfinished commits.
+     * @private
+     */
+    checkUnfinishedCommits() {
+        let position = this.storage.length;
+        let lastEvent;
+        let truncateIndex = false;
+        while (position > 0) {
+            try {
+                lastEvent = this.storage.read(position);
+            } catch (e) {
+                // A preRead hook may throw (e.g. access control). Stop repair check.
+                return;
+            }
+            if (lastEvent !== false) break;
+            truncateIndex = true;
+            position--;
+        }
+
+        if (lastEvent && lastEvent.metadata.commitSize && lastEvent.metadata.commitVersion !== lastEvent.metadata.commitSize - 1) {
+            this.emit('unfinished-commit', lastEvent);
+            // commitId = global sequence number at which the commit started
+            this.storage.truncate(lastEvent.metadata.commitId);
+        } else if (truncateIndex) {
+            // The index contained items that are not in the storage file; truncate everything
+            // after `position`, the last sequence number that was successfully read.
+            this.storage.truncate(position);
+        }
+    }
+
     /**
      * Scan the streams directory for existing streams so they are ready for `getEventStream()`.
      *
@@ -103,38 +133,44 @@ class EventStore extends events.EventEmitter {
             callback = () => {};
         }
         // Find existing streams by scanning dir for filenames starting with 'stream-'
-        fs.readdir(this.streamsDirectory, (err, files) => {
-            if (err) {
-                return callback(err);
-            }
-            let matches;
-            for (let file of files) {
-                if ((matches = file.match(/(stream-.*)\.index$/)) !== null) {
-                    this.registerStream(matches[1]);
-                }
-            }
-            callback();
-        });
+        scanForFiles(this.streamsDirectory, /(stream-.*)\.index$/, this.registerStream.bind(this), callback);
         this.storage.on('index-created', this.registerStream.bind(this));
     }
 
     /**
      * @private
-     * @param {string} name The full stream name, including the `stream-` prefix.
+     * @param {string} name The full stream name, including the `stream-` prefix (and optional `.closed` suffix).
      */
     registerStream(name) {
         /* istanbul ignore if */
         if (!name.startsWith('stream-')) {
             return;
         }
-        const streamName = name.substr(7, name.length - 7);
-        /* istanbul ignore if */
+        let streamName = name.slice(7);
+        // Detect the `.closed` suffix — present both in the initial scan and when the directory
+        // watcher emits 'index-created' after a writer renames the file (e.g. 'stream-foo-bar.closed').
+        let isClosed = false;
+        if (streamName.endsWith('.closed')) {
+            streamName = streamName.slice(0, -7);
+            isClosed = true;
+        }
         if (streamName in this.streams) {
+            if (isClosed && !this.streams[streamName].closed) {
+                // The stream was renamed to .closed while this instance had it open.
+                // The old ReadOnlyIndex was already closed via onRename, so we open the new one.
+                const closedIndexName = 'stream-' + streamName + '.closed';
+                const closedIndex = this.storage.openReadonlyIndex(closedIndexName);
+                // deepcode ignore PrototypePollutionFunctionParams: streams is a Map
+                this.streams[streamName] = { index: closedIndex, closed: true };
+                this.emit('stream-closed', streamName);
+            }
             return;
         }
-        const index = this.storage.openIndex('stream-'+streamName);
+        const index = isClosed
+            ? this.storage.openReadonlyIndex(name)
+            : this.storage.openIndex(name);
         // deepcode ignore PrototypePollutionFunctionParams: streams is a Map
-        this.streams[streamName] = { index };
+        this.streams[streamName] = { index, closed: isClosed };
         this.emit('stream-available', streamName);
     }
 
@@ -147,6 +183,103 @@ class EventStore extends events.EventEmitter {
         this.storage.close();
     }
 
+    /**
+     * Override EventEmitter.on() to delegate 'preCommit' and 'preRead' event registrations
+     * to the underlying storage, so that `eventstore.on('preCommit', handler)` works naturally.
+     * All other events are handled by the default EventEmitter.
+     *
+     * @param {string} event
+     * @param {function} listener
+     * @returns {this}
+     */
+    on(event, listener) {
+        if (event === 'preCommit' || event === 'preRead') {
+            if (event === 'preCommit') {
+                assert(!(this.storage instanceof ReadOnlyStorage), 'The storage was opened in read-only mode. Can not register a preCommit handler on it.');
+            }
+            this.storage.on(event, listener);
+            return this;
+        }
+        return super.on(event, listener);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    addListener(event, listener) {
+        return this.on(event, listener);
+    }
+
+    /**
+     * Override EventEmitter.once() to delegate 'preCommit' and 'preRead' to the underlying storage.
+     *
+     * @param {string} event
+     * @param {function} listener
+     * @returns {this}
+     */
+    once(event, listener) {
+        if (event === 'preCommit' || event === 'preRead') {
+            if (event === 'preCommit') {
+                assert(!(this.storage instanceof ReadOnlyStorage), 'The storage was opened in read-only mode. Can not register a preCommit handler on it.');
+            }
+            this.storage.once(event, listener);
+            return this;
+        }
+        return super.once(event, listener);
+    }
+
+    /**
+     * Override EventEmitter.off() / removeListener() to delegate 'preCommit' and 'preRead'
+     * to the underlying storage.
+     *
+     * @param {string} event
+     * @param {function} listener
+     * @returns {this}
+     */
+    off(event, listener) {
+        if (event === 'preCommit' || event === 'preRead') {
+            this.storage.off(event, listener);
+            return this;
+        }
+        return super.off(event, listener);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    removeListener(event, listener) {
+        return this.off(event, listener);
+    }
+
+    /**
+     * Convenience method to register a handler called before an event is committed to storage.
+     * Equivalent to `eventstore.on('preCommit', hook)`.
+     * The handler receives `(event, partitionMetadata)` and may throw to abort the write.
+     * Multiple handlers can be registered; all run on every write in registration order.
+     * The handler is invoked on every write, so its logic should be cheap, fast, and synchronous.
+     *
+     * @api
+     * @param {function(object, object): void} hook A function receiving (event, partitionMetadata).
+     * @throws {Error} If the storage was opened in read-only mode.
+     */
+    preCommit(hook) {
+        this.on('preCommit', hook);
+    }
+
+    /**
+     * Convenience method to register a handler called before an event is read from storage.
+     * Equivalent to `eventstore.on('preRead', hook)`.
+     * The handler receives `(position, partitionMetadata)` and may throw to abort the read.
+     * Multiple handlers can be registered; all run on every read in registration order.
+     * The handler is invoked on every read, so its logic should be cheap, fast, and synchronous.
+     *
+     * @api
+     * @param {function(number, object): void} hook A function receiving (position, partitionMetadata).
+     */
+    preRead(hook) {
+        this.on('preRead', hook);
+    }
+
     /**
      * Get the number of events stored.
      *
@@ -204,7 +337,7 @@ class EventStore extends events.EventEmitter {
      * @throws {OptimisticConcurrencyError} if the stream is not at the expected version.
      */
     commit(streamName, events, expectedVersion = ExpectedVersion.Any, metadata = {}, callback = null) {
-        assert(!(this.storage instanceof Storage.ReadOnly), 'The storage was opened in read-only mode. Can not commit to it.');
+        assert(!(this.storage instanceof ReadOnlyStorage), 'The storage was opened in read-only mode. Can not commit to it.');
         assert(typeof streamName === 'string' && streamName !== '', 'Must specify a stream name for commit.');
         assert(typeof events !== 'undefined' && events !== null, 'No events specified for commit.');
 
@@ -213,6 +346,7 @@ class EventStore extends events.EventEmitter {
         if (!(streamName in this.streams)) {
             this.createEventStream(streamName, { stream: streamName });
         }
+        assert(!this.streams[streamName].closed, `Stream "${streamName}" is closed and cannot be written to.`);
         let streamVersion = this.streams[streamName].index.length;
         if (expectedVersion !== ExpectedVersion.Any && streamVersion !== expectedVersion) {
             throw new OptimisticConcurrencyError(`Optimistic Concurrency error. Expected stream "${streamName}" at version ${expectedVersion} but is at version ${streamVersion}.`);
@@ -265,11 +399,11 @@ class EventStore extends events.EventEmitter {
      *
      * @api
      * @param {string} streamName The name of the stream to get.
-     * @param {number} [minRevision] The minimum revision to include in the events (inclusive).
-     * @param {number} [maxRevision] The maximum revision to include in the events (inclusive).
+     * @param {number} [minRevision] The 1-based minimum revision to include in the events (inclusive).
+     * @param {number} [maxRevision] The 1-based maximum revision to include in the events (inclusive).
      * @returns {EventStream|boolean} The event stream or false if a stream with the name doesn't exist.
      */
-    getEventStream(streamName, minRevision = 0, maxRevision = -1) {
+    getEventStream(streamName, minRevision = 1, maxRevision = -1) {
         if (!(streamName in this.streams)) {
             return false;
         }
@@ -281,11 +415,11 @@ class EventStore extends events.EventEmitter {
      * This is the same as `getEventStream('_all', ...)`.
      *
      * @api
-     * @param {number} [minRevision] The minimum revision to include in the events (inclusive).
-     * @param {number} [maxRevision] The maximum revision to include in the events (inclusive).
+     * @param {number} [minRevision] The 1-based minimum revision to include in the events (inclusive).
+     * @param {number} [maxRevision] The 1-based maximum revision to include in the events (inclusive).
      * @returns {EventStream} The event stream.
      */
-    getAllEvents(minRevision = 0, maxRevision = -1) {
+    getAllEvents(minRevision = 1, maxRevision = -1) {
         return this.getEventStream('_all', minRevision, maxRevision);
     }
 
@@ -294,12 +428,12 @@ class EventStore extends events.EventEmitter {
      *
      * @param {string} streamName The (transient) name of the joined stream.
      * @param {Array<string>} streamNames An array of the stream names to join.
-     * @param {number} [minRevision] The minimum revision to include in the events (inclusive).
-     * @param {number} [maxRevision] The maximum revision to include in the events (inclusive).
+     * @param {number} [minRevision] The 1-based minimum revision to include in the events (inclusive).
+     * @param {number} [maxRevision] The 1-based maximum revision to include in the events (inclusive).
      * @returns {EventStream} The joined event stream.
      * @throws {Error} if any of the streams doesn't exist.
      */
-    fromStreams(streamName, streamNames, minRevision = 0, maxRevision = -1) {
+    fromStreams(streamName, streamNames, minRevision = 1, maxRevision = -1) {
         assert(streamNames instanceof Array, 'Must specify an array of stream names.');
 
         for (let stream of streamNames) {
@@ -318,12 +452,12 @@ class EventStore extends events.EventEmitter {
      *
      * @api
      * @param {string} categoryName The name of the category to get a stream for. A category is a stream name prefix.
-     * @param {number} [minRevision] The minimum revision to include in the events (inclusive).
-     * @param {number} [maxRevision] The maximum revision to include in the events (inclusive).
+     * @param {number} [minRevision] The 1-based minimum revision to include in the events (inclusive).
+     * @param {number} [maxRevision] The 1-based maximum revision to include in the events (inclusive).
      * @returns {EventStream} The joined event stream for all streams of the given category.
      * @throws {Error} If no stream for this category exists.
      */
-    getEventStreamForCategory(categoryName, minRevision = 0, maxRevision = -1) {
+    getEventStreamForCategory(categoryName, minRevision = 1, maxRevision = -1) {
         if (categoryName in this.streams) {
             return this.getEventStream(categoryName, minRevision, maxRevision);
         }
@@ -346,7 +480,7 @@ class EventStore extends events.EventEmitter {
      * @throws {Error} If the stream could not be created.
      */
     createEventStream(streamName, matcher) {
-        assert(!(this.storage instanceof Storage.ReadOnly), 'The storage was opened in read-only mode. Can not create new stream on it.');
+        assert(!(this.storage instanceof ReadOnlyStorage), 'The storage was opened in read-only mode. Can not create new stream on it.');
         assert(!(streamName in this.streams), 'Can not recreate stream!');
 
         const streamIndexName = 'stream-' + streamName;
@@ -370,7 +504,7 @@ class EventStore extends events.EventEmitter {
      * @returns void
      */
     deleteEventStream(streamName) {
-        assert(!(this.storage instanceof Storage.ReadOnly), 'The storage was opened in read-only mode. Can not delete a stream on it.');
+        assert(!(this.storage instanceof ReadOnlyStorage), 'The storage was opened in read-only mode. Can not delete a stream on it.');
 
         if (!(streamName in this.streams)) {
             return;
@@ -380,6 +514,46 @@ class EventStore extends events.EventEmitter {
         this.emit('stream-deleted', streamName);
     }
 
+    /**
+     * Close a stream so that no new events are indexed into it.
+     * The stream will still be readable, but any attempt to write to it will throw an error.
+     * A closed stream is persisted by renaming its index file to include a `.closed` marker
+     * (e.g. `stream-X.closed.index`), so it will be recognized as closed when the store is reopened.
+     *
+     * @api
+     * @param {string} streamName The name of the stream to close.
+     * @returns void
+     * @throws {Error} If the storage is read-only.
+     * @throws {Error} If the stream does not exist.
+     * @throws {Error} If the stream is already closed.
+     */
+    closeEventStream(streamName) {
+        assert(!(this.storage instanceof ReadOnlyStorage), 'The storage was opened in read-only mode. Can not close a stream on it.');
+        assert(streamName in this.streams, `Stream "${streamName}" does not exist.`);
+        assert(!this.streams[streamName].closed, `Stream "${streamName}" is already closed.`);
+
+        const indexName = 'stream-' + streamName;
+        const { index } = this.streams[streamName];
+
+        // Flush and close the index before renaming the file
+        index.close();
+
+        // Rename the index file to mark it as closed (e.g. stream-foo.index -> stream-foo.closed.index)
+        const closedFileName = index.fileName.replace(/\.index$/, '.closed.index');
+        fs.renameSync(index.fileName, closedFileName);
+
+        // Remove from secondary indexes so that new writes are no longer indexed into this stream
+        delete this.storage.secondaryIndexes[indexName];
+
+        // Reopen the renamed index for read access, outside the secondary indexes write path
+        const closedIndexName = indexName + '.closed';
+        const closedIndex = this.storage.openReadonlyIndex(closedIndexName);
+
+        // deepcode ignore PrototypePollutionFunctionParams: streams is a Map
+        this.streams[streamName] = { index: closedIndex, closed: true };
+        this.emit('stream-closed', streamName);
+    }
+
     /**
      * Get a durable consumer for the given stream that will keep receiving events from the last position.
      *
@@ -390,14 +564,34 @@ class EventStore extends events.EventEmitter {
      * @returns {Consumer} A durable consumer for the given stream.
      */
     getConsumer(streamName, identifier, initialState = {}, since = 0) {
-        const consumer = new Consumer(this.storage, 'stream-' + streamName, identifier, initialState, since);
+        const consumer = new Consumer(this.storage, streamName === '_all' ? '_all' : 'stream-' + streamName, identifier, initialState, since);
         consumer.streamName = streamName;
-        return consumer.pipe(new EventUnwrapper());
+        return consumer;
+    }
+
+    /**
+     * Scan the existing consumers on this EventStore and asynchronously return a list of their names.
+     * @param {function(error: Error, consumers: array)} callback A callback that will receive an error as first and the list of consumers as second argument.
+     */
+    scanConsumers(callback) {
+        const consumersPath = path.join(this.storage.indexDirectory, 'consumers');
+        if (!fs.existsSync(consumersPath)) {
+            callback(null, []);
+            return;
+        }
+        const regex = new RegExp(`^${this.storage.storageFile}\\.([^.]*\\..*)$`);
+        const consumers = [];
+        scanForFiles(consumersPath, regex, consumers.push.bind(consumers), /* istanbul ignore next */ (err) => {
+            if (err) {
+                return callback(err, []);
+            }
+            callback(null, consumers);
+        });
     }
 }
 
-module.exports = EventStore;
-module.exports.ExpectedVersion = ExpectedVersion;
-module.exports.OptimisticConcurrencyError = OptimisticConcurrencyError;
-module.exports.LOCK_THROW = Storage.LOCK_THROW;
-module.exports.LOCK_RECLAIM = Storage.LOCK_RECLAIM;
+EventStore.Storage = Storage;
+EventStore.Index = Index;
+
+export default EventStore;
+export { ExpectedVersion, OptimisticConcurrencyError, LOCK_THROW, LOCK_RECLAIM };