Consistently use assert

Author: albe

src/EventStore.js

@@ -397,11 +397,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);
     }
 
     /**
@@ -470,9 +466,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;
@@ -550,14 +547,12 @@ class EventStore extends events.EventEmitter {
         const queryTypes = [];
         for (const type of types) {
             if (!(type in this.streams)) {
-                if (this.typeAccessor) {
-                    // typeAccessor is configured: type streams are created on commit, so a missing
-                    // stream simply means no event of this type has been committed yet — treat as empty.
-                    continue;
-                }
                 // No typeAccessor: the stream was never created; we cannot know whether events of
                 // this type exist in the store, so throw to avoid an unintentional full-store scan.
-                throw new Error(`Type stream "${type}" does not exist. Create it with createEventStream() first, or configure typeAccessor to have type streams created automatically on commit.`);
+                assert(!!this.typeAccessor, `Type stream "${type}" does not exist. Create it with createEventStream() first, or configure typeAccessor to have type streams created automatically on commit.`);
+                // typeAccessor is configured: type streams are created on commit, so a missing
+                // stream simply means no event of this type has been committed yet — treat as empty.
+                continue;
             }
             queryTypes.push(type);
         }
@@ -675,9 +670,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

@@ -214,8 +214,8 @@ class ReadableIndex 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.');
-        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 '../util.js';
+import { assert, assertEqual } from '../util.js';
 import { buildMetadataHeader } from '../metadataUtil.js';
 import { ensureDirectory } from '../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 './util.js';
+import {assert, kWayMerge} from './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);
@@ -253,9 +251,7 @@ class ReadablePartition extends events.EventEmitter {
         }
 
         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

@@ -184,9 +184,8 @@ class WritablePartition extends ReadablePartition {
             time64 = this.clock.time();
         }
         /* 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);
@@ -210,7 +209,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);
@@ -237,7 +236,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');
@@ -390,9 +389,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/metadataUtil.js

@@ -1,5 +1,5 @@
 import crypto from 'crypto';
-import { assertEqual } from './util.js';
+import {assert, assertEqual} from './util.js';
 
 /**
  * Build a buffer containing the file magic header and a JSON stringified metadata block, padded to be a multiple of 16 bytes long.
@@ -90,9 +90,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;
@@ -125,9 +124,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) {
@@ -179,9 +176,8 @@ function buildMatcherTree(matcher) {
         const child = { objectPattern: null, valuePatterns: null, node: null, objMatch: null, valueMatches: [] };
 
         if (Array.isArray(value)) {
-            if (value.some(item => item && typeof item === 'object')) {
-                throw new TypeError('Array matcher values must be scalars.');
-            }
+            assert(!value.some(item => item && typeof item === 'object'), 'Array matcher values must be scalars.', TypeError);
+
             child.valuePatterns = value.map(item => Buffer.concat([keyPrefix, Buffer.from(JSON.stringify(item), 'utf8')]));
         } else if (value && typeof value === 'object') {
             child.objectPattern = Buffer.concat([keyPrefix, Buffer.from('{', 'utf8')]);