event-storage 1.1.0 → 1.3.0

package/src/Storage/ReadableStorage.js

@@ -1,11 +1,12 @@
 import fs from 'fs';
 import path from 'path';
 import events from 'events';
-import Partition, { ReadOnly as ReadOnlyPartition } from '../Partition.js';
-import Index, { ReadOnly as ReadOnlyIndex } from '../Index.js';
-import { assert, wrapAndCheck, kWayMerge } from '../util.js';
-import { scanForFiles } from '../fsUtil.js';
-import { createHmac, matches, buildMetadataForMatcher } from '../metadataUtil.js';
+import { ReadOnly as ReadOnlyPartition } from '../Partition.js';
+import { ReadOnly as ReadOnlyIndex } from '../Index.js';
+import { assert, wrapAndCheck, iterate, kWayMerge } from '../utils/util.js';
+import { scanForFiles } from '../utils/fsUtil.js';
+import { createHmac, matches, buildMetadataForMatcher } from '../utils/metadataUtil.js';
+import { normalizeNamedCtorArgs } from '../utils/apiHelpers.js';
 import IndexMatcher from '../IndexMatcher.js';
 import PartitionPool from '../PartitionPool.js';
 
@@ -26,18 +27,6 @@ const DEFAULT_MATCHER_PROPERTIES = ['stream', 'payload.type'];
  */
 const DEFAULT_MAX_OPEN_PARTITIONS = 1024;
 
-/**
- * Reverses the items of an iterable
- * @param {Generator|Iterable} iterator
- * @returns {Generator<*>}
- */
-function *reverse(iterator) {
-    const items = Array.from(iterator);
-    for (let i = items.length - 1; i >= 0; i--) {
-        yield items[i];
-    }
-}
-
 /**
  * @typedef {object|function(object):boolean} Matcher
  */
@@ -71,10 +60,7 @@ class ReadableStorage extends events.EventEmitter {
      */
     constructor(storageName = 'storage', config = {}) {
         super();
-        if (typeof storageName !== 'string') {
-            config = storageName;
-            storageName = undefined;
-        }
+        ({ name: storageName, options: config } = normalizeNamedCtorArgs(storageName, config));
 
         this.storageFile = storageName || 'storage';
         const defaults = {
@@ -169,7 +155,7 @@ class ReadableStorage extends events.EventEmitter {
             const partition = this.createPartition(file, this.partitionConfig);
             this.partitions.add(partition.id, partition);
         }, (partErr) => {
-            /* istanbul ignore if */
+            /* c8 ignore next */
             if (partErr) throw partErr;
 
             // Scan was cancelled by close() between the two scan phases.
@@ -184,7 +170,7 @@ class ReadableStorage extends events.EventEmitter {
                 this.emit('index-created', name);
             }, (indexErr) => {
                 // The directory could disappear between existsSync and readdir (e.g. test cleanup).
-                /* istanbul ignore if */
+                /* c8 ignore next */
                 if (indexErr && indexErr.code !== 'ENOENT') throw indexErr;
                 done();
             });
@@ -284,16 +270,19 @@ class ReadableStorage extends events.EventEmitter {
      * @param {number} partitionId The partition to read from.
      * @param {number} position The file position to read from.
      * @param {number} [size] The expected byte size of the document at the given position.
-     * @returns {object} The document stored at the given position.
+     * @param {boolean} [raw] Whether to return raw buffers instead of deserialized objects. Default false.
+     * @param {boolean} [backwardsHint] If set to true, will optimize buffering for backwards reading.
+     * @returns {object|{ buffer: Buffer, time64: number, sequenceNumber: number }} The document stored at the given position.
      * @throws {Error} if the document at the given position can not be deserialized.
      */
-    readFrom(partitionId, position, size) {
+    readFrom(partitionId, position, size, raw = false, backwardsHint = false) {
         const partition = this.getPartition(partitionId);
         if (this.listenerCount('preRead') > 0) {
             this.emit('preRead', position, partition.metadata);
         }
-        const data = partition.readFrom(position, size);
-        return this.serializer.deserialize(data);
+        const headerOut = {};
+        const buffer = partition.readFrom(position, size, headerOut, backwardsHint);
+        return raw ? { buffer, time64: headerOut.time64, sequenceNumber: headerOut.sequenceNumber } : this.serializer.deserialize(buffer.toString('utf8'));
     }
 
     /**
@@ -306,10 +295,7 @@ class ReadableStorage extends events.EventEmitter {
      */
     read(number, index) {
         index = index || this.index;
-
-        if (!index.isOpen()) {
-            index.open();
-        }
+        index.open();
 
         const entry = index.get(number);
         if (entry === false) {
@@ -329,30 +315,22 @@ class ReadableStorage extends events.EventEmitter {
      * @param {ReadableIndex|false} [index] The index to use for finding the documents in the range.
      *   Pass `false` to skip the global index and iterate all partitions directly in sequenceNumber order
      *   (useful when the global index is unavailable or corrupted).
+     * @param {boolean} [raw] Whether to return raw buffers instead of deserialized objects. Default false.
      * @returns {Generator<object>} A generator that will read each document in the range one by one.
      */
-    *readRange(from, until = -1, index = null) {
-        const lengthSource = index || this.index;
-        if (!lengthSource.isOpen()) {
-            lengthSource.open();
+    *readRange(from, until = -1, index = null, raw = false) {
+        let length = Number.MAX_SAFE_INTEGER;
+        if (index !== false) {
+            index = index || this.index;
+            index.open();
+            length = index.length;
         }
 
-        const readFrom = wrapAndCheck(from, lengthSource.length);
-        const readUntil = wrapAndCheck(until, lengthSource.length);
+        const readFrom = wrapAndCheck(from, length);
+        const readUntil = wrapAndCheck(until, length);
         assert(readFrom > 0 && readUntil > 0, `Range scan error for range ${from} - ${until}.`);
 
-        if (readFrom > readUntil) {
-            const batchSize = 10;
-            let batchUntil = readFrom;
-            while (batchUntil >= readUntil) {
-                const batchFrom = Math.max(readUntil, batchUntil - batchSize);
-                yield* reverse(this.iterateRange(batchFrom, batchUntil, index));
-                batchUntil = batchFrom - 1;
-            }
-            return undefined;
-        }
-
-        yield* this.iterateRange(readFrom, readUntil, index);
+        yield* this.iterateRange(readFrom, readUntil, index, raw);
     }
 
     /**
@@ -362,23 +340,25 @@ class ReadableStorage extends events.EventEmitter {
      * @param {number} from
      * @param {number} until
      * @param {ReadableIndex|false|null} index
+     * @param {boolean} [raw] Whether to return raw buffers instead of deserialized objects. Default false.
      * @returns {Generator<object>}
      */
-    *iterateRange(from, until, index) {
+    *iterateRange(from, until, index, raw = false) {
         if (index === false) {
-            // Explicitly disabled index: iterate all partitions and merge by sequenceNumber.
-            // Document header sequenceNumber is 0-based; from/until are 1-based index positions.
-            for (const entry of this.iterateDocumentsNoIndex(from - 1, until - 1)) {
-                yield entry.document;
+            for (const { document } of this.iterateDocumentsNoIndex(from - 1, until - 1)) {
+                yield document;
             }
             return;
         }
 
         const idx = index || this.index;
-        const entries = idx.range(from, until);
-        for (let entry of entries) {
-            const document = this.readFrom(entry.partition, entry.position, entry.size);
-            yield document;
+        const forwards = from <= until;
+        const lo = Math.min(from, until);
+        const hi = Math.max(from, until);
+        const entries = idx.range(lo, hi);
+        if (!entries) return;
+        for (const entry of iterate(entries, forwards)) {
+            yield this.readFrom(entry.partition, entry.position, entry.size, raw, !forwards);
         }
     }
 
@@ -448,76 +428,64 @@ class ReadableStorage extends events.EventEmitter {
         }
     }
 
-    /**
-     * Iterate documents across all partitions in sequenceNumber order using a k-way merge.
-     * Opens any closed partition automatically.
-     *
-     * @protected
-     * @param {number} [from=0] The 0-based sequenceNumber to start from (inclusive).
-     * @param {number} [until=Number.MAX_SAFE_INTEGER] The 0-based sequenceNumber to read until (inclusive).
-     * @returns {Generator<{document: object, sequenceNumber: number, partitionName: string, position: number, size: number, partition: number}>}
-     */
-    *iterateDocumentsNoIndex(from = 0, until = Number.MAX_SAFE_INTEGER) {
-        const streams = [];
-
-        this.forEachPartition(partition => {
-            if (!partition.isOpen()) {
-                partition.open();
-            }
-
-            const found = partition.findDocument(from);
-            if (found && found.headerOut.sequenceNumber <= until) {
-                const nextPosition = found.headerOut.position + partition.documentWriteSize(found.headerOut.dataSize);
-                const reader = partition.readAll(nextPosition, found.headerOut);
-                streams.push({ ...found, reader, partition: partition.id, partitionName: partition.name });
-            }
-        });
-
-        const items = [];
-        kWayMerge(
-            streams,
-            stream => stream.headerOut.sequenceNumber,
-            stream => {
-                const next = stream.reader.next();
-                if (!next.done && stream.headerOut.sequenceNumber <= until) {
-                    stream.data = next.value;
-                    return true;
-                }
-                return false;
-            },
-            stream => items.push({
-                document: this.serializer.deserialize(stream.data),
-                sequenceNumber: stream.headerOut.sequenceNumber,
-                partitionName: stream.partitionName,
-                position: stream.headerOut.position,
-                size: stream.headerOut.dataSize,
-                partition: stream.partition,
-            })
-        );
-
-        yield* items;
-    }
+     /**
+      * Build the standard document result entry from a readRange yield.
+      * @private
+      * @param {{ data: Buffer, entry: { number: number, position: number, size: number, partition: number } }} [readItem]
+      */
+     buildDocumentEntry(readItem) {
+         return {
+             document: this.serializer.deserialize(readItem.data.toString('utf8')),
+             // Replicate the index entry structure here, so iteration can be used easily to reindex
+             entry: readItem.entry
+         };
+     }
+
+     /**
+      * Iterate documents across all partitions in sequenceNumber order using a k-way merge.
+      * Opens any closed partition automatically.
+      *
+      * @protected
+      * @param {number} [from=0] The 0-based sequenceNumber to start from (inclusive).
+      * @param {number} [until=Number.MAX_SAFE_INTEGER] The 0-based sequenceNumber to read until (inclusive).
+      * @returns {Generator<{document: object, entry: { sequenceNumber: number, position: number, size: number, partition: number }}>}
+      */
+     *iterateDocumentsNoIndex(from = 0, until = Number.MAX_SAFE_INTEGER) {
+         const forwards = from <= until;
+         const partitions = [];
+         this.forEachPartition(partition => {
+             partition.open();
+             partitions.push(partition.readRange(from, until));
+         });
+
+         yield* kWayMerge(
+             partitions,
+             item => item.entry.number,
+             forwards,
+             item => this.buildDocumentEntry(item)
+         );
+     }
 
     /**
      * Helper method to iterate over all documents, invoking a callback for each one.
      * Pass `noIndex = true` to iterate all partitions directly in sequenceNumber order
      * (useful when the global index is unavailable or corrupted).
      * When `noIndex` is false the second callback argument is the raw index `EntryInterface`.
-     * When `noIndex` is true the second callback argument has `{ partition, position, size, sequenceNumber, partitionName }`.
+     * When `noIndex` is true the second callback argument has `{ partition, position, size, sequenceNumber }`.
      *
      * @protected
      * @param {function(object, object): void} iterationHandler
      * @param {boolean} [noIndex=false] When true, bypasses the index and iterates partitions directly.
      */
     forEachDocument(iterationHandler, noIndex = false) {
-        /* istanbul ignore if  */
+        /* c8 ignore next 3  */
         if (typeof iterationHandler !== 'function') {
             return;
         }
 
         if (noIndex) {
-            for (const { document, ...entryInfo } of this.iterateDocumentsNoIndex()) {
-                iterationHandler(document, entryInfo);
+            for (const { document, entry } of this.iterateDocumentsNoIndex()) {
+                iterationHandler(document, entry);
             }
             return;
         }
@@ -541,7 +509,7 @@ class ReadableStorage extends events.EventEmitter {
      * @param {object} [matchDocument] If supplied, only indexes the document matches on will be iterated.
      */
     forEachSecondaryIndex(iterationHandler, matchDocument) {
-        /* istanbul ignore if  */
+        /* c8 ignore next 3  */
         if (typeof iterationHandler !== 'function') {
             return;
         }
@@ -566,7 +534,7 @@ class ReadableStorage extends events.EventEmitter {
      * @param {function(ReadablePartition)} iterationHandler
      */
     forEachPartition(iterationHandler) {
-        /* istanbul ignore if  */
+        /* c8 ignore next 3  */
         if (typeof iterationHandler !== 'function') {
             return;
         }

package/src/Storage/WritableStorage.js

@@ -3,9 +3,10 @@ import path from 'path';
 import WritablePartition from '../Partition/WritablePartition.js';
 import WritableIndex, { Entry as WritableIndexEntry } from '../Index/WritableIndex.js';
 import ReadableStorage from './ReadableStorage.js';
-import { assert } from '../util.js';
-import { ensureDirectory } from '../fsUtil.js';
-import { matches, buildMetadataForMatcher, buildMatcherFromMetadata } from '../metadataUtil.js';
+import { assert } from '../utils/util.js';
+import { ensureDirectory } from '../utils/fsUtil.js';
+import { matches, buildMetadataForMatcher, buildMatcherFromMetadata } from '../utils/metadataUtil.js';
+import { normalizeNamedCtorArgs } from '../utils/apiHelpers.js';
 
 const DEFAULT_WRITE_BUFFER_SIZE = 16 * 1024;
 
@@ -44,10 +45,7 @@ class WritableStorage extends ReadableStorage {
      * @param {number} [config.lock] One of LOCK_* constants that defines how an existing lock should be handled.
      */
     constructor(storageName = 'storage', config = {}) {
-        if (typeof storageName !== 'string') {
-            config = storageName;
-            storageName = undefined;
-        }
+        ({ name: storageName, options: config } = normalizeNamedCtorArgs(storageName, config));
         const defaults = {
             partitioner: (document, number) => '',
             writeBufferSize: DEFAULT_WRITE_BUFFER_SIZE,
@@ -64,6 +62,7 @@ class WritableStorage extends ReadableStorage {
         this.lockFile = path.resolve(this.dataDirectory, this.storageFile + '.lock');
         this._lockMode = config.lock;
         this.partitioner = config.partitioner;
+        this.partitionIds = {};
     }
 
     /**
@@ -99,7 +98,7 @@ class WritableStorage extends ReadableStorage {
      */
     forEachWritableSecondaryIndex(iterationHandler, matchDocument) {
         this.forEachSecondaryIndex((index, name) => {
-            /* istanbul ignore if */
+            /* c8 ignore next */
             if (!(index instanceof WritableIndex)) return;
             const wasOpen = index.isOpen();
             if (!wasOpen) index.open();
@@ -122,7 +121,7 @@ class WritableStorage extends ReadableStorage {
         this.forEachPartition(partition => {
             partition.open();
             const last = partition.readLast();
-            /* istanbul ignore if */
+            /* c8 ignore next */
             if (!last) return;
             const { header: { sequenceNumber, dataSize }, position } = last;
             if (position + partition.documentWriteSize(dataSize) > partition.size) {
@@ -164,7 +163,7 @@ class WritableStorage extends ReadableStorage {
             // Truncate all indexes to the torn-write boundary.
             this.index.open();
             this.index.truncate(lastValidSequenceNumber);
-            /* istanbul ignore next */
+            /* c8 ignore next */
             this.forEachWritableSecondaryIndex(index => {
                 index.truncate(index.find(lastValidSequenceNumber));
             });
@@ -204,8 +203,8 @@ class WritableStorage extends ReadableStorage {
 
         // Scan partitions in sequence-number order and rebuild index entries.
         // iterateDocumentsNoIndex opens any closed partitions automatically.
-        for (const { document, partition, position, size } of this.iterateDocumentsNoIndex(fromSequenceNumber, Number.MAX_SAFE_INTEGER)) {
-            const newEntry = new WritableIndexEntry(this.index.length + 1, position, size, partition);
+        for (const { document, entry } of this.iterateDocumentsNoIndex(fromSequenceNumber)) {
+            const newEntry = new WritableIndexEntry(this.index.length + 1, entry.position, entry.size, entry.partition);
             this.index.add(newEntry);
 
             this.forEachWritableSecondaryIndex((secIndex) => {
@@ -230,10 +229,9 @@ class WritableStorage extends ReadableStorage {
             fs.mkdirSync(this.lockFile);
             this.locked = true;
         } catch (e) {
-            /* istanbul ignore if */
-            if (e.code !== 'EEXIST') {
-                throw new Error(`Error creating lock for storage ${this.storageFile}: ` + e.message);
-            }
+            /* c8 ignore next */
+            assert(e.code === 'EEXIST', `Error creating lock for storage ${this.storageFile}: ` + e.message)
+
             throw new StorageLockedError(`Storage ${this.storageFile} is locked by another process`);
         }
         return true;
@@ -290,7 +288,7 @@ class WritableStorage extends ReadableStorage {
         const entry = new WritableIndexEntry(this.index.length + 1, position, size, partitionId);
         this.index.add(entry, (indexPosition) => {
             this.emit('wrote', document, entry, indexPosition);
-            /* istanbul ignore if  */
+            /* c8 ignore next 3  */
             if (typeof callback === 'function') {
                 return callback(indexPosition);
             }
@@ -311,6 +309,36 @@ class WritableStorage extends ReadableStorage {
         this.on('preCommit', hook);
     }
 
+    getPartitionIdForName(partitionShortName, partitionName) {
+        const partitionId = this.partitionIds[partitionShortName] ?? WritablePartition.idFor(partitionName);
+        this.partitionIds[partitionShortName] = partitionId;
+        return partitionId;
+    }
+
+    buildPartitionConfig(partitionShortName) {
+        if (typeof this.partitionConfig.metadata !== 'function') {
+            return this.partitionConfig;
+        }
+        return { ...this.partitionConfig, metadata: this.partitionConfig.metadata(partitionShortName) };
+    }
+
+    ensurePartitionDirectory(partitionName) {
+        if (!partitionName.includes('/')) {
+            return;
+        }
+        ensureDirectory(path.join(this.dataDirectory, path.dirname(partitionName)));
+    }
+
+    createNamedPartition(partitionId, partitionName, partitionShortName) {
+        if (this.partitions.has(partitionId)) {
+            return;
+        }
+        const partitionConfig = this.buildPartitionConfig(partitionShortName);
+        this.ensurePartitionDirectory(partitionName);
+        this.partitions.add(partitionId, this.createPartition(partitionName, partitionConfig));
+        this.emit('partition-created', partitionId);
+    }
+
     /**
      * Get a partition either by name or by id.
      * If a partition with the given name does not exist, a new one will be created.
@@ -327,17 +355,8 @@ class WritableStorage extends ReadableStorage {
         if (typeof partitionIdentifier === 'string') {
             const partitionShortName = partitionIdentifier;
             const partitionName = this.storageFile + (partitionIdentifier.length ? '.' + partitionIdentifier : '');
-            partitionIdentifier = WritablePartition.idFor(partitionName);
-            if (!this.partitions.has(partitionIdentifier)) {
-                const partitionConfig = typeof this.partitionConfig.metadata === 'function'
-                    ? { ...this.partitionConfig, metadata: this.partitionConfig.metadata(partitionShortName) }
-                    : this.partitionConfig;
-                if (partitionName.includes('/')) {
-                    ensureDirectory(path.join(this.dataDirectory, path.dirname(partitionName)));
-                }
-                this.partitions.add(partitionIdentifier, this.createPartition(partitionName, partitionConfig));
-                this.emit('partition-created', partitionIdentifier);
-            }
+            partitionIdentifier = this.getPartitionIdForName(partitionShortName, partitionName);
+            this.createNamedPartition(partitionIdentifier, partitionName, partitionShortName);
         }
         return super.getPartition(partitionIdentifier);
     }
@@ -354,18 +373,15 @@ class WritableStorage extends ReadableStorage {
 
         const partitionName = this.partitioner(document, this.index.length + 1);
         const partition = this.getPartition(partitionName);
-        if (this.listenerCount('preCommit') > 0) {
-            this.emit('preCommit', document, partition.metadata);
-        }
+        this.emit('preCommit', document, partition.metadata);
+
         const position = partition.write(data, this.length, callback);
 
         assert(position !== false, 'Error writing document.');
 
         const indexEntry = this.addIndex(partition.id, position, dataSize, document);
         this.forEachSecondaryIndex((index, name) => {
-            if (!index.isOpen()) {
-                index.open();
-            }
+            index.open();
             index.add(indexEntry);
             this.emit('index-add', name, index.length, document);
         }, document);
@@ -491,9 +507,8 @@ class WritableStorage extends ReadableStorage {
          2) truncate all partitions accordingly
          3) truncate/rewrite all indexes
          */
-        if (!this.index.isOpen()) {
-            this.index.open();
-        }
+        this.index.open();
+
         if (after < 0) {
             after += this.index.length;
         }

package/src/Watcher.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import events from 'events';
-import { assert } from './util.js';
+import { assert } from './utils/util.js';
 
 /** @type {Map<string, DirectoryWatcher>} */
 const directoryWatchers = new Map();

package/src/utils/apiHelpers.js

@@ -0,0 +1,123 @@
+/**
+ * Normalize commit overloads into a single argument object.
+ *
+ * @param {object|object[]} events Event or event list.
+ * @param {number|object|function} expectedVersion Expected version, CommitCondition, or already metadata/callback.
+ * @param {object|function} metadata Commit metadata or callback.
+ * @param {function} callback Completion callback.
+ * @param {number} ExpectedVersionAny Fallback value for "any" expectedVersion.
+ * @param {Function} CommitConditionClass Class used for CommitCondition checks.
+ * @returns {{events: object[], expectedVersion: number|object, metadata: object, callback: function}} Normalized commit arguments.
+ */
+function fixCommitArgumentTypes(events, expectedVersion, metadata, callback, ExpectedVersionAny, CommitConditionClass) {
+    if (!(events instanceof Array)) {
+        events = [events];
+    }
+    if (typeof expectedVersion !== 'number' && !(expectedVersion instanceof CommitConditionClass)) {
+        callback = metadata;
+        metadata = expectedVersion;
+        expectedVersion = ExpectedVersionAny;
+    }
+    if (typeof metadata !== 'object') {
+        callback = metadata;
+        metadata = {};
+    }
+    if (typeof callback !== 'function') {
+        callback = () => {};
+    }
+    return { events, expectedVersion, metadata, callback };
+}
+
+/**
+ * Derive the stream name from an index name.
+ *
+ * @param {string} indexName Index file/index name.
+ * @returns {string} Corresponding stream name.
+ */
+function parseStreamFromIndexName(indexName) {
+    if (indexName === '_all') {
+        return '_all';
+    }
+    if (indexName.startsWith('stream-')) {
+        return indexName.slice(7);
+    }
+    return indexName;
+}
+
+/**
+ * Support predicate/raw shorthand (`predicate=true`).
+ *
+ * @param {object|function|boolean|null} predicate Filter predicate or raw shorthand.
+ * @param {boolean} raw Raw flag from the call signature.
+ * @returns {{predicate: object|function|null, raw: boolean}} Normalized predicate/raw pair.
+ */
+function normalizePredicateRaw(predicate, raw) {
+    if (typeof predicate === 'boolean' && raw === false) {
+        return { predicate: null, raw: predicate };
+    }
+    return { predicate, raw };
+}
+
+/**
+ * Support constructor overloads with optional `name`.
+ *
+ * @param {string|object} name Name or already the options object.
+ * @param {object} options Options object when `name` is provided.
+ * @param {string|undefined} [fallbackName=undefined] Fallback name when no explicit `name` is passed.
+ * @returns {{name: string|undefined, options: object}} Normalized name/options pair.
+ */
+function normalizeNamedCtorArgs(name, options, fallbackName = undefined) {
+    if (typeof name !== 'string') {
+        return { name: fallbackName, options: name };
+    }
+    return { name, options };
+}
+
+/**
+ * Normalize negative revisions relative to stream length.
+ *
+ * @param {number} version Requested revision.
+ * @param {number} length Current stream length.
+ * @returns {number} Resolved revision.
+ */
+function normalizeRevision(version, length) {
+    return version < 0 ? version + length + 1 : version;
+}
+
+/**
+ * Clamp and normalize maxRevision, including negative values.
+ *
+ * @param {number} length Current stream length.
+ * @param {number} maxRevision Requested max revision.
+ * @returns {number} Effective max revision in valid range.
+ */
+function normalizeMaxRevision(length, maxRevision) {
+    return Math.min(length, maxRevision < 0 ? length + maxRevision + 1 : maxRevision);
+}
+
+/**
+ * Support the consumer overload where the first argument is a numeric start offset.
+ *
+ * @param {object|number} initialState Initial state or numeric start offset.
+ * @param {number} startFrom Start offset from the call signature.
+ * @returns {{initialState: object, startFrom: number}} Normalized consumer initialization values.
+ */
+function normalizeConsumerStateArgs(initialState, startFrom) {
+    if (typeof initialState === 'number') {
+        return { initialState: {}, startFrom: initialState };
+    }
+    return { initialState, startFrom };
+}
+
+export {
+    fixCommitArgumentTypes,
+    parseStreamFromIndexName,
+    normalizePredicateRaw,
+    normalizeNamedCtorArgs,
+    normalizeRevision,
+    normalizeMaxRevision,
+    normalizeConsumerStateArgs
+};
+
+
+