event-storage 0.7.2 → 0.9.1

package/src/Storage/ReadOnlyStorage.js

@@ -13,6 +13,8 @@ class ReadOnlyStorage extends ReadableStorage {
      */
     constructor(storageName = 'storage', config = {}) {
         super(storageName, config);
+        this.storageFilesFilter = this.storageFilesFilter.bind(this);
+        this.onStorageFileChanged = this.onStorageFileChanged.bind(this);
     }
 
     /**
@@ -33,8 +35,8 @@ class ReadOnlyStorage extends ReadableStorage {
      */
     open() {
         if (!this.watcher) {
-            this.watcher = new Watcher(this.dataDirectory, this.storageFilesFilter.bind(this));
-            this.watcher.on('rename', this.onStorageFileChanged.bind(this));
+            this.watcher = new Watcher([this.dataDirectory, this.indexDirectory], this.storageFilesFilter);
+            this.watcher.on('rename', this.onStorageFileChanged);
         }
         return super.open();
     }
@@ -45,8 +47,9 @@ class ReadOnlyStorage extends ReadableStorage {
      */
     onStorageFileChanged(filename) {
         if (filename.substr(-6) === '.index') {
+            const indexName = filename.substr(this.storageFile.length + 1, filename.length - this.storageFile.length - 7);
             // New indexes are not automatically opened in the reader
-            this.emit('index-created', filename);
+            this.emit('index-created', indexName);
             return;
         }
 

package/src/Storage/ReadableStorage.js

@@ -1,9 +1,10 @@
 const fs = require('fs');
 const path = require('path');
-const EventEmitter = require('events');
+const events = require('events');
 const Partition = require('../Partition');
 const Index = require('../Index');
-const { assert, createHmac, matches, wrapAndCheck, buildMetadataForMatcher } = require('../util');
+const { assert, wrapAndCheck, kWayMerge } = require('../util');
+const { createHmac, matches, buildMetadataForMatcher } = require('../metadataUtil');
 
 const DEFAULT_READ_BUFFER_SIZE = 4 * 1024;
 
@@ -19,11 +20,15 @@ function *reverse(iterator) {
     }
 }
 
+/**
+ * @typedef {object|function(object):boolean} Matcher
+ */
+
 /**
  * An append-only storage with highly performant positional range scans.
  * It's highly optimized for an event-store and hence does not support compaction or data-rewrite, nor any querying
  */
-class ReadableStorage extends EventEmitter {
+class ReadableStorage extends events.EventEmitter {
 
     /**
      * @param {string} [storageName] The name of the storage.
@@ -62,15 +67,15 @@ class ReadableStorage extends EventEmitter {
 
         this.dataDirectory = path.resolve(config.dataDirectory);
 
-        this.initializeIndexes(config);
         this.scanPartitions(config);
+        this.initializeIndexes(config);
     }
 
     /**
      * @protected
      * @param {string} name
      * @param {object} [options]
-     * @returns {{ index: ReadableIndex, matcher?: object|function }}
+     * @returns {{ index: ReadableIndex, matcher?: Matcher }}
      */
     createIndex(name, options = {}) {
         /** @type ReadableIndex */
@@ -105,6 +110,7 @@ class ReadableStorage extends EventEmitter {
         const { index } = this.createIndex(config.indexFile, this.indexOptions);
         this.index = index;
         this.secondaryIndexes = {};
+        this.readonlyIndexes = {};
     }
 
     /**
@@ -128,12 +134,13 @@ class ReadableStorage extends EventEmitter {
             readBufferSize: DEFAULT_READ_BUFFER_SIZE
         };
         this.partitionConfig = Object.assign(defaults, config);
-        this.partitions = {};
+        this.partitions = Object.create(null);
 
         const files = fs.readdirSync(this.dataDirectory);
         for (let file of files) {
             if (file.substr(-6) === '.index') continue;
             if (file.substr(-7) === '.branch') continue;
+            if (file.substr(-5) === '.lock') continue;
             if (file.substr(0, this.storageFile.length) !== this.storageFile) continue;
 
             const partition = this.createPartition(file, this.partitionConfig);
@@ -167,6 +174,9 @@ class ReadableStorage extends EventEmitter {
     close() {
         this.index.close();
         this.forEachSecondaryIndex(index => index.close());
+        for (let index of Object.values(this.readonlyIndexes)) {
+            index.close();
+        }
         this.forEachPartition(partition => partition.close());
         this.emit('closed');
     }
@@ -188,6 +198,19 @@ class ReadableStorage extends EventEmitter {
         return this.partitions[partitionIdentifier];
     }
 
+    /**
+     * Register a handler that is called before a document is read from a partition.
+     * The handler receives the position and the partition metadata and may throw to abort the read.
+     * Multiple handlers can be registered; all run on every read in registration order.
+     * Equivalent to `storage.on('preRead', hook)`.
+     *
+     * @api
+     * @param {function(number, object): void} hook A function receiving (position, partitionMetadata).
+     */
+    preRead(hook) {
+        this.on('preRead', hook);
+    }
+
     /**
      * @protected
      * @param {number} partitionId The partition to read from.
@@ -198,6 +221,9 @@ class ReadableStorage extends EventEmitter {
      */
     readFrom(partitionId, position, size) {
         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);
     }
@@ -232,21 +258,25 @@ class ReadableStorage extends EventEmitter {
      * @api
      * @param {number} from The 1-based document number (inclusive) to start reading from.
      * @param {number} [until] The 1-based document number (inclusive) to read until. Defaults to index.length.
-     * @param {ReadableIndex} [index] The index to use for finding the documents in the range.
+     * @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).
      * @returns {Generator<object>} A generator that will read each document in the range one by one.
      */
     *readRange(from, until = -1, index = null) {
-        index = index || this.index;
-        index.open();
+        const lengthSource = index || this.index;
+        if (!lengthSource.isOpen()) {
+            lengthSource.open();
+        }
 
-        const readFrom = wrapAndCheck(from, index.length);
-        const readUntil = wrapAndCheck(until, index.length);
-        assert(readFrom !== false && readUntil !== false, `Range scan error for range ${from} - ${until}.`);
+        const readFrom = wrapAndCheck(from, lengthSource.length);
+        const readUntil = wrapAndCheck(until, lengthSource.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) {
+            while (batchUntil >= readUntil) {
                 const batchFrom = Math.max(readUntil, batchUntil - batchSize);
                 yield* reverse(this.iterateRange(batchFrom, batchUntil, index));
                 batchUntil = batchFrom - 1;
@@ -259,31 +289,66 @@ class ReadableStorage extends EventEmitter {
 
     /**
      * Iterate all documents in this storage in range from to until inside the index.
+     * If index is false, iterates all partitions directly in sequenceNumber order.
      * @private
      * @param {number} from
      * @param {number} until
-     * @param {ReadableIndex} index
+     * @param {ReadableIndex|false|null} index
      * @returns {Generator<object>}
      */
     *iterateRange(from, until, index) {
-        const entries = index.range(from, until);
+        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;
+            }
+            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;
         }
     }
 
+    /**
+     * Open an existing readonly index for reading, without registering it in the secondary indexes write path.
+     * Use this for indexes whose files carry a status marker (e.g. `stream-foo.closed.index`).
+     *
+     * @api
+     * @param {string} name The readonly index name (e.g. 'stream-foo.closed').
+     * @returns {ReadableIndex}
+     * @throws {Error} if the readonly index does not exist.
+     */
+    openReadonlyIndex(name) {
+        if (name in this.readonlyIndexes) {
+            return this.readonlyIndexes[name];
+        }
+        const indexName = this.storageFile + '.' + name + '.index';
+        assert(fs.existsSync(path.join(this.indexDirectory, indexName)), `Index "${name}" does not exist.`);
+        const { index } = this.createIndex(indexName, Object.assign({}, this.indexOptions));
+        index.open();
+        this.readonlyIndexes[name] = index;
+        return index;
+    }
+
     /**
      * Open an existing index.
      *
      * @api
      * @param {string} name The index name.
-     * @param {object|function} [matcher] The matcher object or function that the index needs to have been defined with. If not given it will not be validated.
+     * @param {Matcher} [matcher] The matcher object or function that the index needs to have been defined with. If not given it will not be validated.
      * @returns {ReadableIndex}
      * @throws {Error} if the index with that name does not exist.
      * @throws {Error} if the HMAC for the matcher does not match.
      */
     openIndex(name, matcher) {
+        if (name === '_all') {
+            return this.index;
+        }
         if (name in this.secondaryIndexes) {
             return this.secondaryIndexes[name].index;
         }
@@ -299,17 +364,79 @@ class ReadableStorage extends EventEmitter {
     }
 
     /**
-     * Helper method to iterate over all documents.
+     * Iterate documents across all partitions in sequenceNumber order using a k-way merge.
+     * Opens any closed partition automatically.
      *
      * @protected
-     * @param {function(object, EntryInterface)} iterationHandler
+     * @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}>}
      */
-    forEachDocument(iterationHandler) {
+    *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;
+    }
+
+    /**
+     * 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 }`.
+     *
+     * @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  */
         if (typeof iterationHandler !== 'function') {
             return;
         }
 
+        if (noIndex) {
+            for (const { document, ...entryInfo } of this.iterateDocumentsNoIndex()) {
+                iterationHandler(document, entryInfo);
+            }
+            return;
+        }
+
         const entries = this.index.all();
 
         for (let entry of entries) {
@@ -359,3 +486,4 @@ class ReadableStorage extends EventEmitter {
 
 module.exports = ReadableStorage;
 module.exports.matches = matches;
+module.exports.CorruptFileError = Partition.CorruptFileError;

package/src/Storage/WritableStorage.js

@@ -1,15 +1,22 @@
 const fs = require('fs');
-const mkdirpSync = require('mkdirp').sync;
 const path = require('path');
 const WritablePartition = require('../Partition/WritablePartition');
 const WritableIndex = require('../Index/WritableIndex');
 const ReadableStorage = require('./ReadableStorage');
-const { assert, matches, buildMetadataForMatcher, buildMatcherFromMetadata } = require('../util');
+const { assert, ensureDirectory } = require('../util');
+const { matches, buildMetadataForMatcher, buildMatcherFromMetadata } = require('../metadataUtil');
 
 const DEFAULT_WRITE_BUFFER_SIZE = 16 * 1024;
 
+const LOCK_RECLAIM = 0x1;
+const LOCK_THROW = 0x2;
+
 class StorageLockedError extends Error {}
 
+/**
+ * @typedef {object|function(object):boolean} Matcher
+ */
+
 /**
  * An append-only storage with highly performant positional range scans.
  * It's highly optimized for an event-store and hence does not support compaction or data-rewrite, nor any querying
@@ -33,6 +40,7 @@ class WritableStorage extends ReadableStorage {
      * @param {function(object, number): string} [config.partitioner] A function that takes a document and sequence number and returns a partition name that the document should be stored in. Defaults to write all documents to the primary partition.
      * @param {object} [config.indexOptions] An options object that should be passed to all indexes on construction.
      * @param {string} [config.hmacSecret] A private key that is used to verify matchers retrieved from indexes.
+     * @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') {
@@ -49,13 +57,13 @@ class WritableStorage extends ReadableStorage {
         };
         config = Object.assign(defaults, config);
         config.indexOptions = Object.assign({ syncOnFlush: config.syncOnFlush }, config.indexOptions);
-        if (!fs.existsSync(config.dataDirectory)) {
-            try {
-                mkdirpSync(config.dataDirectory);
-            } catch (e) {
-            }
-        }
+        ensureDirectory(config.dataDirectory);
         super(storageName, config);
+
+        this.lockFile = path.resolve(this.dataDirectory, this.storageFile + '.lock');
+        if (config.lock === LOCK_RECLAIM) {
+            this.unlock();
+        }
         this.partitioner = config.partitioner;
     }
 
@@ -68,7 +76,135 @@ class WritableStorage extends ReadableStorage {
         if (!this.lock()) {
             return true;
         }
-        return super.open();
+        const result = super.open();
+        this.emit('ready');
+        return result;
+    }
+
+    /**
+     * Helper method to iterate over all writable secondary indexes.
+     * Opens each index before calling the callback (passing the previous open status),
+     * and closes it afterwards if it was not already open.
+     *
+     * @protected
+     * @param {function(WritableIndex, string, boolean)} iterationHandler Called with (index, name, wasOpen).
+     * @param {object} [matchDocument] If supplied, only indexes the document matches on will be iterated.
+     */
+    forEachWritableSecondaryIndex(iterationHandler, matchDocument) {
+        this.forEachSecondaryIndex((index, name) => {
+            /* istanbul ignore if */
+            if (!(index instanceof WritableIndex)) return;
+            const wasOpen = index.isOpen();
+            if (!wasOpen) index.open();
+            iterationHandler(index, name, wasOpen);
+            if (!wasOpen) index.close();
+        }, matchDocument);
+    }
+
+    /**
+     * Scan every partition's last document to detect torn writes inline.
+     * A document is torn when its expected end exceeds the actual file size:
+     *   position + documentWriteSize(dataSize) > partition.size
+     *
+     * @private
+     * @returns {{ lastValidSequenceNumber: number, maxPartitionSequenceNumber: number }}
+     */
+    findTornWriteBoundary() {
+        let lastValidSequenceNumber = Number.MAX_SAFE_INTEGER;
+        let maxPartitionSequenceNumber = -1;
+        this.forEachPartition(partition => {
+            partition.open();
+            const last = partition.readLast();
+            /* istanbul ignore if */
+            if (!last) return;
+            const { header: { sequenceNumber, dataSize }, position } = last;
+            if (position + partition.documentWriteSize(dataSize) > partition.size) {
+                // Torn write: the document extends beyond the end of the file.
+                lastValidSequenceNumber = Math.min(lastValidSequenceNumber, sequenceNumber);
+            } else {
+                maxPartitionSequenceNumber = Math.max(maxPartitionSequenceNumber, sequenceNumber);
+            }
+        });
+        return { lastValidSequenceNumber, maxPartitionSequenceNumber };
+    }
+
+    /**
+     * Check all partitions for torn writes, physically repair each partition, truncate all indexes
+     * to the torn-write boundary, and then reindex to rebuild any missing index entries.
+     *
+     * A document is torn when the partition file ends before the document's expected end position
+     * (i.e. position + documentWriteSize(dataSize) > partition.size).  Detected inline in
+     * findTornWriteBoundary(), without any checkTornWrite() call.
+     *
+     * Repair flow:
+     * 1. findTornWriteBoundary() reads the last document of every partition and finds the global
+     *    torn-write boundary (minimum torn sequence number across all partitions).
+     * 2. If torn writes were found, truncateAfterSequence() removes all documents at or beyond
+     *    the boundary from each partition.
+     * 3. Truncate all indexes to the torn-write boundary, then reindex to fill any lagging entries.
+     * 4. If no torn writes were found but the index is lagging, reindex directly.
+     */
+    checkTornWrites() {
+        const { lastValidSequenceNumber, maxPartitionSequenceNumber } = this.findTornWriteBoundary();
+
+        if (lastValidSequenceNumber < Number.MAX_SAFE_INTEGER) {
+            // Phase 2: remove all documents at or beyond the torn-write boundary from each partition.
+            this.forEachPartition(partition => {
+                partition.open();
+                partition.truncateAfterSequence(lastValidSequenceNumber - 1);
+            });
+
+            // Truncate all indexes to the torn-write boundary.
+            this.index.open();
+            this.index.truncate(lastValidSequenceNumber);
+            /* istanbul ignore next */
+            this.forEachWritableSecondaryIndex(index => {
+                index.truncate(index.find(lastValidSequenceNumber));
+            });
+
+            // Reindex to fill in any missing complete-document entries.
+            this.reindex(this.index.length);
+        } else if (maxPartitionSequenceNumber >= 0 && maxPartitionSequenceNumber + 1 > this.index.length) {
+            // No torn writes, but the index is lagging — repair it.
+            this.reindex(this.index.length);
+        }
+
+        this.forEachPartition(partition => partition.close());
+    }
+
+    /**
+     * Rebuild the primary index and all loaded secondary indexes starting from the given sequence
+     * number by scanning the partition data directly.
+     * This is the building block for both auto-repair (invoked automatically when the primary
+     * index is found to be lagging in checkTornWrites()) and for user-driven re-indexing after
+     * index corruption.
+     *
+     * @api
+     * @param {number} [fromSequenceNumber=0] The number of primary index entries to keep intact.
+     *   All index entries beyond this position will be removed and rebuilt from partition data.
+     *   Defaults to 0, which rebuilds all indexes from scratch.
+     */
+    reindex(fromSequenceNumber = 0) {
+        this.index.truncate(fromSequenceNumber);
+
+        // Truncate all loaded secondary indexes to match the new primary length.
+        this.forEachWritableSecondaryIndex(index => {
+            // find(0) returns 0, so truncate(0) will remove all entries when fromSequenceNumber===0
+            index.truncate(fromSequenceNumber === 0 ? 0 : index.find(fromSequenceNumber));
+        });
+
+        // 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 WritableIndex.Entry(this.index.length + 1, position, size, partition);
+            this.index.add(newEntry);
+
+            this.forEachWritableSecondaryIndex((secIndex) => {
+                secIndex.add(newEntry);
+            }, document);
+        }
+
+        this.flush();
     }
 
     /**
@@ -81,7 +217,6 @@ class WritableStorage extends ReadableStorage {
         if (this.locked) {
             return false;
         }
-        this.lockFile = path.resolve(this.dataDirectory, this.storageFile + '.lock');
         try {
             fs.mkdirSync(this.lockFile);
             this.locked = true;
@@ -101,7 +236,12 @@ class WritableStorage extends ReadableStorage {
      * Current implementation just deletes a lock file that is named like the storage.
      */
     unlock() {
-        fs.rmdirSync(this.lockFile);
+        if (fs.existsSync(this.lockFile)) {
+            if (!this.locked) {
+                this.checkTornWrites();
+            }
+            fs.rmdirSync(this.lockFile);
+        }
         this.locked = false;
     }
 
@@ -147,6 +287,19 @@ class WritableStorage extends ReadableStorage {
         return entry;
     }
 
+    /**
+     * Register a handler that is called before a document is written to storage.
+     * The handler receives the document and the partition metadata and may throw to abort the write.
+     * Multiple handlers can be registered; all run on every write in registration order.
+     * Equivalent to `storage.on('preCommit', hook)`.
+     *
+     * @api
+     * @param {function(object, object): void} hook A function receiving (document, partitionMetadata).
+     */
+    preCommit(hook) {
+        this.on('preCommit', hook);
+    }
+
     /**
      * 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.
@@ -159,10 +312,14 @@ class WritableStorage extends ReadableStorage {
      */
     getPartition(partitionIdentifier) {
         if (typeof partitionIdentifier === 'string') {
+            const partitionShortName = partitionIdentifier;
             const partitionName = this.storageFile + (partitionIdentifier.length ? '.' + partitionIdentifier : '');
             partitionIdentifier = WritablePartition.idFor(partitionName);
             if (!this.partitions[partitionIdentifier]) {
-                this.partitions[partitionIdentifier] = this.createPartition(partitionName, this.partitionConfig);
+                const partitionConfig = typeof this.partitionConfig.metadata === 'function'
+                    ? { ...this.partitionConfig, metadata: this.partitionConfig.metadata(partitionShortName) }
+                    : this.partitionConfig;
+                this.partitions[partitionIdentifier] = this.createPartition(partitionName, partitionConfig);
                 this.emit('partition-created', partitionIdentifier);
             }
             this.partitions[partitionIdentifier].open();
@@ -183,6 +340,9 @@ 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);
+        }
         const position = partition.write(data, this.length, callback);
 
         assert(position !== false, 'Error writing document.');
@@ -205,11 +365,14 @@ class WritableStorage extends ReadableStorage {
      *
      * @api
      * @param {string} name The index name.
-     * @param {object|function} [matcher] An object that describes the document properties that need to match to add it this index or a function that receives a document and returns true if the document should be indexed.
+     * @param {Matcher} [matcher] An object that describes the document properties that need to match to add it this index or a function that receives a document and returns true if the document should be indexed.
      * @returns {ReadableIndex} The index containing all documents that match the query.
      * @throws {Error} if the index doesn't exist yet and no matcher was specified.
      */
     ensureIndex(name, matcher) {
+        if (name === '_all') {
+            return this.index;
+        }
         if (name in this.secondaryIndexes) {
             return this.secondaryIndexes[name].index;
         }
@@ -276,6 +439,10 @@ class WritableStorage extends ReadableStorage {
     /**
      * Truncate all partitions after the given (global) sequence number.
      *
+     * Assumes the primary index is fully consistent with the partition data. Looks up the first
+     * index entry after `after` for each affected partition and truncates the partition file
+     * at that entry's byte position.
+     *
      * @private
      * @param {number} after The document sequence number to truncate after.
      */
@@ -309,31 +476,39 @@ class WritableStorage extends ReadableStorage {
         if (!this.index.isOpen()) {
             this.index.open();
         }
+        if (after < 0) {
+            after += this.index.length;
+        }
 
         this.truncatePartitions(after);
 
         this.index.truncate(after);
-        this.forEachSecondaryIndex(index => {
-            if (!(index instanceof WritableIndex)) {
-                return;
-            }
-            let closeIndex = false;
-            if (!index.isOpen()) {
-                index.open();
-                closeIndex = true;
-            }
+        this.forEachWritableSecondaryIndex(index => {
             index.truncate(index.find(after));
-            if (closeIndex) {
-                index.close();
-            }
         });
     }
 
+    /**
+     * @inheritDoc
+     * Open an existing secondary index and repair any stale entries beyond the current primary
+     * index length. Stale entries can be present when checkTornWrites() truncated the primary
+     * index before this secondary index was loaded into memory.
+     */
+    openIndex(name, matcher) {
+        const index = super.openIndex(name, matcher);
+        const lastEntry = index.lastEntry;
+        if (lastEntry !== false && lastEntry.number > this.index.length) {
+            // Secondary index is ahead of primary: truncate stale entries.
+            index.truncate(index.find(this.index.length));
+        }
+        return index;
+    }
+
     /**
      * @protected
      * @param {string} name
      * @param {object} [options]
-     * @returns {{ index: WritableIndex, matcher: object|function }}
+     * @returns {{ index: WritableIndex, matcher: Matcher }}
      */
     createIndex(name, options = {}) {
         const index = new WritableIndex(name, options);
@@ -366,4 +541,7 @@ class WritableStorage extends ReadableStorage {
 }
 
 module.exports = WritableStorage;
-module.exports.StorageLockedError = StorageLockedError;
+module.exports.StorageLockedError = StorageLockedError;
+module.exports.CorruptFileError = ReadableStorage.CorruptFileError;
+module.exports.LOCK_THROW = LOCK_THROW;
+module.exports.LOCK_RECLAIM = LOCK_RECLAIM;