Merge origin/main and resolve conflicts

Author: Copilot

src/EventStore.js

@@ -403,11 +403,7 @@ class EventStore extends events.EventEmitter {
             condition.raw
         );
 
-        if (stream.next() !== false) {
-            throw new OptimisticConcurrencyError(
-                `Optimistic Concurrency error. A conflicting event was committed since the condition was obtained.`
-            );
-        }
+        assert(stream.next() === false, `Optimistic Concurrency error. A conflicting event was committed since the condition was obtained.`, OptimisticConcurrencyError);
     }
 
     /**
@@ -490,9 +486,10 @@ class EventStore extends events.EventEmitter {
         }
         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}.`);
-        }
+        assert(expectedVersion === ExpectedVersion.Any || streamVersion === expectedVersion,
+            `Optimistic Concurrency error. Expected stream "${streamName}" at version ${expectedVersion} but is at version ${streamVersion}.`,
+            OptimisticConcurrencyError
+        );
 
         if (events.length > 1) {
             delete metadata.commitVersion;
@@ -668,9 +665,8 @@ class EventStore extends events.EventEmitter {
             streamName.startsWith(categoryName + '/')
         );
 
-        if (categoryStreams.length === 0) {
-            throw new Error(`No streams for category '${categoryName}' exist.`);
-        }
+        assert(categoryStreams.length > 0, `No streams for category '${categoryName}' exist.`);
+
         return this.fromStreams(categoryName, categoryStreams, minRevision, maxRevision, predicate, raw);
     }
 

src/Index/ReadableIndex.js

@@ -77,6 +77,7 @@ class ReadableIndex extends events.EventEmitter {
         if (options.metadata) {
             this.metadata = Object.assign({entryClass: options.EntryClass.name, entrySize: options.EntryClass.size}, options.metadata);
         }
+        this.headerSize = 0;
     }
 
     /**
@@ -208,12 +209,13 @@ class ReadableIndex extends events.EventEmitter {
      * @throws {Error} if the metadata size in the header is invalid.
      */
     readMetadata() {
+        if (this.headerSize > 0) return this.headerSize;
         const headerBuffer = Buffer.allocUnsafe(8 + 4);
         fs.readSync(this.fd, headerBuffer, 0, 8 + 4, 0);
         const headerMagic = headerBuffer.toString('utf8', 0, 8);
 
-        assert(headerMagic.substr(0, 6) === HEADER_MAGIC.substr(0, 6), 'Invalid file header.');
-        assert(headerMagic === HEADER_MAGIC, `Invalid file version. The index ${this.fileName} was created with a different library version (${headerMagic.substr(6)}).`);
+        assert(headerMagic.substring(0, 6) === HEADER_MAGIC.substring(0, 6), 'Invalid file header.');
+        assert(headerMagic === HEADER_MAGIC, `Invalid file version. The index ${this.fileName} was created with a different library version (${headerMagic.substring(6)}).`);
 
         const metadataSize = headerBuffer.readUInt32BE(8);
         assert(metadataSize >= 3, 'Invalid metadata size.');

src/Index/WritableIndex.js

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import ReadableIndex, { Entry, CorruptedIndexError, HEADER_MAGIC } from './ReadableIndex.js';
-import { assertEqual } from '../utils/util.js';
+import { assert, assertEqual } from '../utils/util.js';
 import { buildMetadataHeader } from '../utils/metadataUtil.js';
 import { ensureDirectory } from '../utils/fsUtil.js';
 
@@ -191,9 +191,7 @@ class WritableIndex extends ReadableIndex {
         assertEqual(entry.constructor.size, this.EntryClass.size, `Invalid entry size.`);
 
         const dataLen = this.data.length;
-        if (dataLen > 0 && this.data[dataLen - 1].number >= entry.number) {
-            throw new Error('Consistency error. Tried to add an index that should come before existing last entry.');
-        }
+        assert(dataLen === 0 || this.data.at(-1).number < entry.number, 'Consistency error. Tried to add an index that should come before existing last entry.');
 
         if (this.readUntil === dataLen - 1) {
             this.readUntil++;

src/JoinEventStream.js

@@ -1,5 +1,5 @@
 import EventStream from './EventStream.js';
-import { kWayMerge } from './utils/util.js';
+import { assert, kWayMerge } from './utils/util.js';
 
 /** Reusable sentinel used for missing or empty per-stream iterators. */
 const emptyIterator = Object.freeze({ next() { return { done: true }; } });
@@ -32,9 +32,7 @@ class JoinEventStream extends EventStream {
      */
     constructor(name, streams, eventStore, minRevision = 1, maxRevision = -1, predicate = null, raw = false) {
         super(name, eventStore, minRevision, maxRevision, predicate, raw);
-        if (!(streams instanceof Array) || streams.length === 0) {
-            throw new Error(`Invalid list of streams supplied to JoinStream ${name}.`);
-        }
+        assert(streams instanceof Array && streams.length > 0, `Invalid list of streams supplied to JoinStream ${name}.`);
 
         this.streamIndex = eventStore.storage.index;
         // Translate revisions to index numbers (1-based) and wrap around negatives

src/Partition/ReadablePartition.js

@@ -116,10 +116,10 @@ class ReadablePartition extends events.EventEmitter {
         fs.readSync(this.fd, headerBuffer, 0, 8 + 4, 0);
         const headerMagic = headerBuffer.toString('utf8', 0, 8);
 
-        assert(headerMagic.substr(0, 6) === HEADER_MAGIC.substr(0, 6), `Invalid file header in partition ${this.name}.`);
+        assert(headerMagic.substring(0, 6) === HEADER_MAGIC.substring(0, 6), `Invalid file header in partition ${this.name}.`);
 
         this.header = headerMagic;
-        assert(headerMagic === HEADER_MAGIC, `Invalid file version. The partition ${this.name} was created with a different library version (${headerMagic.substr(6)}).`);
+        assert(headerMagic === HEADER_MAGIC, `Invalid file version. The partition ${this.name} was created with a different library version (${headerMagic.substring(6)}).`);
 
         const metadataSize = headerBuffer.readUInt32BE(8);
         assert(metadataSize > 2 && metadataSize <= 4096, 'Invalid metadata size.');
@@ -202,9 +202,7 @@ class ReadablePartition extends events.EventEmitter {
         const dataSize = buffer.readUInt32BE(offset + 0);
         assert(dataSize > 0 && dataSize <= 64 * 1024 * 1024, `Error reading document size from ${position}, got ${dataSize}.`);
 
-        if (size && dataSize !== size) {
-            throw new InvalidDataSizeError(`Invalid document size ${dataSize} at position ${position}, expected ${size}.`);
-        }
+        assert(!size || dataSize === size, `Invalid document size ${dataSize} at position ${position}, expected ${size}.`, InvalidDataSizeError);
 
         const sequenceNumber = buffer.readUInt32BE(offset + 4);
         const time64 = buffer.readDoubleBE(offset + 8);
@@ -268,9 +266,7 @@ class ReadablePartition extends events.EventEmitter {
         this.assignHeaderOutput(headerOut, header);
 
         const writeSize = this.documentWriteSize(dataSize);
-        if (position + writeSize > this.size) {
-            throw new CorruptFileError(`Invalid document at position ${position}. This may be caused by an unfinished write.`);
-        }
+        assert(position + writeSize <= this.size, `Invalid document at position ${position}. This may be caused by an unfinished write.`, CorruptFileError);
 
         if (dataSize + DOCUMENT_HEADER_SIZE > reader.buffer.byteLength) {
             const tempReadBuffer = Buffer.allocUnsafe(dataSize);

src/Partition/WritablePartition.js

@@ -179,9 +179,8 @@ class WritablePartition extends ReadablePartition {
     writeDocumentHeader(buffer, offset, dataSize, sequenceNumber = null, time64 = null) {
         ({ sequenceNumber, time64 } = this.normalizeWriteMetadata(sequenceNumber, time64));
         /* istanbul ignore if */
-        if (time64 < 0) {
-            throw new Error('Time may not be negative!');
-        }
+        assert(time64 >= 0, 'Time may not be negative!');
+
         buffer.writeUInt32BE(dataSize, offset);
         buffer.writeUInt32BE(sequenceNumber, offset + 4);
         buffer.writeDoubleBE(time64, offset + 8);
@@ -223,7 +222,7 @@ class WritablePartition extends ReadablePartition {
         bytesWritten += fs.writeSync(this.fd, this.writeMetaBuffer, 0, DOCUMENT_HEADER_SIZE);
         bytesWritten += fs.writeSync(this.fd, data);
         const padSize = alignTo(dataSize + DOCUMENT_FOOTER_SIZE, DOCUMENT_ALIGNMENT);
-        bytesWritten += fs.writeSync(this.fd, DOCUMENT_PAD.substr(0, padSize));
+        bytesWritten += fs.writeSync(this.fd, DOCUMENT_PAD.substring(0, padSize));
         this.writeMetaBuffer.writeUInt32BE(dataSize, 0);
         bytesWritten += fs.writeSync(this.fd, this.writeMetaBuffer, 0, 4);
         bytesWritten += fs.writeSync(this.fd, DOCUMENT_SEPARATOR);
@@ -250,7 +249,7 @@ class WritablePartition extends ReadablePartition {
         bytesWritten += this.writeDocumentHeader(this.writeBuffer, this.writeBufferCursor, dataSize, sequenceNumber);
         bytesWritten += this.writeBuffer.write(data, this.writeBufferCursor + bytesWritten, 'utf8');
         const padSize = alignTo(dataSize + DOCUMENT_FOOTER_SIZE, DOCUMENT_ALIGNMENT);
-        bytesWritten += this.writeBuffer.write(DOCUMENT_PAD.substr(0, padSize), this.writeBufferCursor + bytesWritten, 'utf8');
+        bytesWritten += this.writeBuffer.write(DOCUMENT_PAD.substring(0, padSize), this.writeBufferCursor + bytesWritten, 'utf8');
         this.writeBuffer.writeUInt32BE(dataSize, this.writeBufferCursor + bytesWritten);
         bytesWritten += 4;
         bytesWritten += this.writeBuffer.write(DOCUMENT_SEPARATOR, this.writeBufferCursor + bytesWritten, 'utf8');
@@ -400,9 +399,7 @@ class WritablePartition extends ReadablePartition {
         try {
             this.readFrom(after);
         } catch (e) {
-            if (!(e instanceof CorruptFileError)) {
-                throw new Error('Can only truncate on valid document boundaries.');
-            }
+            assert(e instanceof CorruptFileError, 'Can only truncate on valid document boundaries.');
         }
 
         fs.truncateSync(this.fileName, this.headerSize + after);

src/Storage/ReadOnlyStorage.js

@@ -23,7 +23,7 @@ class ReadOnlyStorage extends ReadableStorage {
      * @returns {boolean}
      */
     storageFilesFilter(filename) {
-        return filename.substr(-7) !== '.branch' && filename.substr(0, this.storageFile.length) === this.storageFile;
+        return !filename.endsWith('.branch') && filename.substring(0, this.storageFile.length) === this.storageFile;
     }
 
     /**
@@ -46,8 +46,8 @@ class ReadOnlyStorage extends ReadableStorage {
      * @param {string} filename
      */
     onStorageFileChanged(filename) {
-        if (filename.substr(-6) === '.index') {
-            const indexName = filename.substr(this.storageFile.length + 1, filename.length - this.storageFile.length - 7);
+        if (filename.endsWith('.index')) {
+            const indexName = filename.substring(this.storageFile.length + 1, filename.length - 6);
             // New indexes are not automatically opened in the reader
             this.emit('index-created', indexName);
             return;

src/Storage/WritableStorage.js

@@ -232,9 +232,8 @@ class WritableStorage extends ReadableStorage {
             this.locked = true;
         } catch (e) {
             /* istanbul ignore if */
-            if (e.code !== 'EEXIST') {
-                throw new Error(`Error creating lock for storage ${this.storageFile}: ` + e.message);
-            }
+            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;

src/utils/metadataUtil.js

@@ -1,5 +1,5 @@
 import crypto from 'crypto';
-import { assertEqual } from './util.js';
+import { assert, assertEqual } from './util.js';
 import { BYTE_OPEN_OBJECT, indexOfSameLevel } from './jsonUtil.js';
 
 function isPlainObject(value) {
@@ -97,9 +97,8 @@ function buildMatcherFromMetadata(matcherMetadata, hmac) {
     if (typeof matcherMetadata.matcher === 'object') {
         matcher = matcherMetadata.matcher;
     } else {
-        if (matcherMetadata.hmac !== hmac(matcherMetadata.matcher)) {
-            throw new Error('Invalid HMAC for matcher.');
-        }
+        assert(matcherMetadata.hmac === hmac(matcherMetadata.matcher), 'Invalid HMAC for matcher.');
+
         matcher = eval('(' + matcherMetadata.matcher + ')').bind({}); // jshint ignore:line
     }
     return matcher;
@@ -132,9 +131,7 @@ function buildTypeMatcherFn(payloadPath) {
  * @returns {function(Buffer): boolean}
  */
 function buildRawBufferMatcher(matcher = {}) {
-    if (!matcher || typeof matcher !== 'object' || Array.isArray(matcher)) {
-        throw new TypeError('Matcher must be an object.');
-    }
+    assert(matcher && typeof matcher ==='object' && !Array.isArray(matcher), 'Matcher must be an object.', TypeError);
 
     const root = buildMatcherTree(matcher);
     if (root.children.length === 0) {