event-storage 1.0.0 → 1.1.0

package/src/Storage/ReadableStorage.js

@@ -4,10 +4,28 @@ 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 IndexMatcher from '../IndexMatcher.js';
+import PartitionPool from '../PartitionPool.js';
 
 const DEFAULT_READ_BUFFER_SIZE = 4 * 1024;
 
+/**
+ * Default ordered list of document property paths used as discriminant keys when
+ * classifying object matchers into the fast-lookup table.  Each path may use
+ * dot-notation for nested access (e.g. `'payload.type'`).  The first path that
+ * resolves to a scalar value in a given matcher wins; remaining paths are not
+ * examined for that matcher.
+ */
+const DEFAULT_MATCHER_PROPERTIES = ['stream', 'payload.type'];
+
+/**
+ * Default maximum number of partition file descriptors kept open simultaneously.
+ * Partitions beyond this limit are evicted using LRU order. 0 disables the limit.
+ */
+const DEFAULT_MAX_OPEN_PARTITIONS = 1024;
+
 /**
  * Reverses the items of an iterable
  * @param {Generator|Iterable} iterator
@@ -43,6 +61,13 @@ class ReadableStorage extends events.EventEmitter {
      * @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 {object} [config.metadata] A metadata object to be stored in all partitions belonging to this storage.
+     * @param {string[]} [config.matcherProperties] Ordered list of document property paths (dot-notation) used as
+     *   discriminant keys for the fast secondary-index lookup table. Only the first property that resolves to a scalar
+     *   value inside a given object matcher is used; the rest are checked via the full `matches()` fallback.
+     *   Default: `['stream', 'payload.type']`.
+     * @param {number} [config.maxOpenPartitions] Maximum number of partition file descriptors kept open at one time.
+     *   When the limit is reached the least-recently-used partition is closed to make room. 0 disables the limit.
+     *   Default: 1024.
      */
     constructor(storageName = 'storage', config = {}) {
         super();
@@ -58,7 +83,9 @@ class ReadableStorage extends events.EventEmitter {
             indexFile: this.storageFile + '.index',
             indexOptions: {},
             hmacSecret: '',
-            metadata: {}
+            metadata: {},
+            matcherProperties: DEFAULT_MATCHER_PROPERTIES,
+            maxOpenPartitions: DEFAULT_MAX_OPEN_PARTITIONS
         };
         config = Object.assign(defaults, config);
         this.serializer = config.serializer;
@@ -67,7 +94,13 @@ class ReadableStorage extends events.EventEmitter {
 
         this.dataDirectory = path.resolve(config.dataDirectory);
 
-        this.scanPartitions(config);
+        const partitionDefaults = { readBufferSize: DEFAULT_READ_BUFFER_SIZE };
+        this.partitionConfig = Object.assign(partitionDefaults, config);
+        this.partitions = new PartitionPool(config.maxOpenPartitions);
+
+        // initialized: null = not started (or scan cancelled), false = in progress, true = done
+        this.initialized = null;
+
         this.initializeIndexes(config);
     }
 
@@ -111,6 +144,9 @@ class ReadableStorage extends events.EventEmitter {
         this.index = index;
         this.secondaryIndexes = {};
         this.readonlyIndexes = {};
+
+        /** Fast secondary-index lookup — classifies matchers for O(1) candidate resolution on write. */
+        this.indexMatcher = new IndexMatcher(config.matcherProperties);
     }
 
     /**
@@ -122,56 +158,91 @@ class ReadableStorage extends events.EventEmitter {
     }
 
     /**
-     * Scan the data directory for all existing partitions.
-     * Every file beginning with the storageFile name is considered a partition.
-     *
-     * @private
-     * @param {object} config The configuration object containing options for the partitions.
-     * @returns void
+     * Scan partitions and secondary index files; emit 'index-created' for each found index.
+     * @param {function} done Called when both scans finish.
      */
-    scanPartitions(config) {
-        const defaults = {
-            readBufferSize: DEFAULT_READ_BUFFER_SIZE
-        };
-        this.partitionConfig = Object.assign(defaults, config);
-        this.partitions = Object.create(null);
+    scanFiles(done) {
+        const escaped = this.storageFile.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const partitionPattern = new RegExp(`^(${escaped}.*)$`);
+        scanForFiles(this.dataDirectory, partitionPattern, (file) => {
+            if (file.endsWith('.index') || file.endsWith('.branch') || file.endsWith('.lock')) return;
+            const partition = this.createPartition(file, this.partitionConfig);
+            this.partitions.add(partition.id, partition);
+        }, (partErr) => {
+            /* istanbul ignore if */
+            if (partErr) throw partErr;
 
-        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;
+            // Scan was cancelled by close() between the two scan phases.
+            if (this.initialized === null) return;
 
-            const partition = this.createPartition(file, this.partitionConfig);
-            this.partitions[partition.id] = partition;
-        }
+            // No secondary indexes exist yet — nothing to scan.
+            if (!fs.existsSync(this.indexDirectory)) {
+                return done();
+            }
+            const indexPattern = new RegExp(`^${escaped}\\.(.+)\\.index$`);
+            scanForFiles(this.indexDirectory, indexPattern, (name) => {
+                this.emit('index-created', name);
+            }, (indexErr) => {
+                // The directory could disappear between existsSync and readdir (e.g. test cleanup).
+                /* istanbul ignore if */
+                if (indexErr && indexErr.code !== 'ENOENT') throw indexErr;
+                done();
+            });
+        });
     }
 
     /**
-     * Open the storage and indexes and create read and write buffers eagerly.
-     * Will emit an 'opened' event if finished.
+     * Only the primary index is opened eagerly; secondary indexes open on demand.
      *
-     * @api
-     * @returns {boolean}
+     * @protected
      */
-    open() {
+    openIndexes() {
         this.index.open();
+    }
 
-        this.forEachSecondaryIndex(index => index.open());
-
-        this.emit('opened');
+    /**
+     * Open the storage; scans existing partitions and indexes asynchronously on first open.
+     * Re-opens after `close()` are synchronous.
+     * Will emit an `'opened'` event when finished.
+     *
+     * @api
+     * @param {function(): void} [callback] Called after indexes open, before `'opened'` is emitted.
+     *   Can be used as a synchronous alternative to listening to the `'opened'` event.
+     * @returns {boolean}
+     */
+    open(callback) {
+        if (this.initialized === true) {
+            this.openIndexes();
+            callback?.();
+            this.emit('opened');
+            return true;
+        }
+        if (this.initialized === false) {
+            return true;
+        }
+        this.initialized = false;
+        this.scanFiles(() => {
+            // Guard: close() while scanning resets initialized to null.
+            if (this.initialized === null) return;
+            this.initialized = true;
+            this.openIndexes();
+            callback?.();
+            this.emit('opened');
+        });
         return true;
     }
 
     /**
-     * Close the storage and frees up all resources.
+     * Close the storage and free up all resources.
      * Will emit a 'closed' event when finished.
      *
      * @api
-     * @returns void
      */
     close() {
+        // Cancel in-progress scan so the callback does not re-open after an explicit close.
+        if (this.initialized === false) {
+            this.initialized = null;
+        }
         this.index.close();
         this.forEachSecondaryIndex(index => index.close());
         for (let index of Object.values(this.readonlyIndexes)) {
@@ -182,20 +253,17 @@ class ReadableStorage extends events.EventEmitter {
     }
 
     /**
-     * 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.
+     * Get a partition by its id.
      * If a partition with the given id does not exist, an error is thrown.
      *
      * @protected
-     * @param {string|number} partitionIdentifier The partition name or the partition Id
+     * @param {number|string} partitionIdentifier The partition Id
      * @returns {ReadablePartition}
-     * @throws {Error} If an id is given and no such partition exists.
+     * @throws {Error} If no such partition exists.
      */
     getPartition(partitionIdentifier) {
-        assert(partitionIdentifier in this.partitions, `Partition #${partitionIdentifier} does not exist.`);
-
-        this.partitions[partitionIdentifier].open();
-        return this.partitions[partitionIdentifier];
+        assert(this.partitions.has(partitionIdentifier), `Partition #${partitionIdentifier} does not exist.`);
+        return this.partitions.open(partitionIdentifier);
     }
 
     /**
@@ -359,10 +427,27 @@ class ReadableStorage extends events.EventEmitter {
         const metadata = buildMetadataForMatcher(matcher, this.hmac);
         let { index } = this.secondaryIndexes[name] = this.createIndex(indexName, Object.assign({}, this.indexOptions, { metadata }));
 
+        // Register the actual stored matcher (may have been reconstructed from metadata by WritableStorage.createIndex).
+        this.indexMatcher.add(name, this.secondaryIndexes[name].matcher);
+
         index.open();
         return index;
     }
 
+    /**
+     * Remove a secondary index from the write path and the matcher lookup table.
+     *
+     * @api
+     * @param {string} name The secondary index name to remove.
+     */
+    removeSecondaryIndex(name) {
+        const entry = this.secondaryIndexes[name];
+        if (entry) {
+            this.indexMatcher.remove(name);
+            delete this.secondaryIndexes[name];
+        }
+    }
+
     /**
      * Iterate documents across all partitions in sequenceNumber order using a k-way merge.
      * Opens any closed partition automatically.
@@ -448,6 +533,9 @@ class ReadableStorage extends events.EventEmitter {
     /**
      * Helper method to iterate over all secondary indexes.
      *
+     * When `matchDocument` is provided, `this.indexMatcher.forEachMatch()` is used to
+     * efficiently find only the matching indexes via the discriminant lookup table.
+     *
      * @protected
      * @param {function(ReadableIndex, string)} iterationHandler
      * @param {object} [matchDocument] If supplied, only indexes the document matches on will be iterated.
@@ -458,11 +546,17 @@ class ReadableStorage extends events.EventEmitter {
             return;
         }
 
-        for (let indexName of Object.keys(this.secondaryIndexes)) {
-            if (!matchDocument || matches(matchDocument, this.secondaryIndexes[indexName].matcher)) {
+        if (!matchDocument) {
+            // No document filter: iterate all secondary indexes unconditionally.
+            for (const indexName of Object.keys(this.secondaryIndexes)) {
                 iterationHandler(this.secondaryIndexes[indexName].index, indexName);
             }
+            return;
         }
+
+        this.indexMatcher.forEachMatch(matchDocument, indexName => {
+            iterationHandler(this.secondaryIndexes[indexName].index, indexName);
+        });
     }
 
     /**
@@ -477,9 +571,7 @@ class ReadableStorage extends events.EventEmitter {
             return;
         }
 
-        for (let partition of Object.keys(this.partitions)) {
-            iterationHandler(this.partitions[partition]);
-        }
+        this.partitions.forEach(iterationHandler);
     }
 
 }

package/src/Storage/WritableStorage.js

@@ -3,7 +3,8 @@ 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, ensureDirectory } from '../util.js';
+import { assert } from '../util.js';
+import { ensureDirectory } from '../fsUtil.js';
 import { matches, buildMetadataForMatcher, buildMatcherFromMetadata } from '../metadataUtil.js';
 
 const DEFAULT_WRITE_BUFFER_SIZE = 16 * 1024;
@@ -61,24 +62,30 @@ class WritableStorage extends ReadableStorage {
         super(storageName, config);
 
         this.lockFile = path.resolve(this.dataDirectory, this.storageFile + '.lock');
-        if (config.lock === LOCK_RECLAIM) {
-            this.unlock();
-        }
+        this._lockMode = config.lock;
         this.partitioner = config.partitioner;
     }
 
     /**
      * @inheritDoc
+     * Acquires the write lock synchronously.
+     * For LOCK_RECLAIM, removes any orphaned lock before trying to acquire our own; torn-write
+     * repair runs after the primary index is open, before `'opened'` is emitted.
+     *
      * @returns {boolean}
      * @throws {StorageLockedError} If this storage is locked by another process.
      */
-    open() {
+    open(callback) {
+        const needsRepair = this._lockMode === LOCK_RECLAIM && this.unlock();
+
         if (!this.lock()) {
             return true;
         }
-        const result = super.open();
-        this.emit('ready');
-        return result;
+
+        const onOpen = needsRepair
+            ? () => { this.checkTornWrites(); callback?.(); }
+            : callback;
+        return super.open(onOpen);
     }
 
     /**
@@ -170,6 +177,8 @@ class WritableStorage extends ReadableStorage {
         }
 
         this.forEachPartition(partition => partition.close());
+        // Partitions were closed directly (bypassing the pool), so reset the open-handle tracking.
+        this.partitions.clearOpenHandles();
     }
 
     /**
@@ -234,19 +243,21 @@ class WritableStorage extends ReadableStorage {
      * Unlock this storage, no matter if it was previously locked by this writer.
      * Only use this if you are sure there is no other process still having a writer open.
      * Current implementation just deletes a lock file that is named like the storage.
+     * @returns {boolean} True if an orphaned lock from another process was removed.
      */
     unlock() {
-        if (fs.existsSync(this.lockFile)) {
-            if (!this.locked) {
-                this.checkTornWrites();
-            }
+        const lockExists = fs.existsSync(this.lockFile);
+        const orphaned = lockExists && !this.locked;
+        if (lockExists) {
             fs.rmdirSync(this.lockFile);
         }
         this.locked = false;
+        return orphaned;
     }
 
     /**
      * @inheritDoc
+     * Unlocks the storage, then delegates to the parent close().
      */
     close() {
         if (this.locked) {
@@ -305,6 +316,8 @@ class WritableStorage extends ReadableStorage {
      * If a partition with the given name does not exist, a new one will be created.
      * If a partition with the given id does not exist, an error is thrown.
      *
+     * Partition opening and LRU tracking are delegated to `super.getPartition()`.
+     *
      * @protected
      * @param {string|number} partitionIdentifier The partition name or the partition Id
      * @returns {ReadablePartition}
@@ -315,15 +328,16 @@ class WritableStorage extends ReadableStorage {
             const partitionShortName = partitionIdentifier;
             const partitionName = this.storageFile + (partitionIdentifier.length ? '.' + partitionIdentifier : '');
             partitionIdentifier = WritablePartition.idFor(partitionName);
-            if (!this.partitions[partitionIdentifier]) {
+            if (!this.partitions.has(partitionIdentifier)) {
                 const partitionConfig = typeof this.partitionConfig.metadata === 'function'
                     ? { ...this.partitionConfig, metadata: this.partitionConfig.metadata(partitionShortName) }
                     : this.partitionConfig;
-                this.partitions[partitionIdentifier] = this.createPartition(partitionName, 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);
             }
-            this.partitions[partitionIdentifier].open();
-            return this.partitions[partitionIdentifier];
         }
         return super.getPartition(partitionIdentifier);
     }
@@ -366,10 +380,11 @@ class WritableStorage extends ReadableStorage {
      * @api
      * @param {string} name The index name.
      * @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.
+     * @param {boolean} [reindex=true] Whether to scan existing documents and populate the new index. Set to false when it is known that no existing documents can match the matcher.
      * @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) {
+    ensureIndex(name, matcher, reindex = true) {
         if (name === '_all') {
             return this.index;
         }
@@ -386,18 +401,21 @@ class WritableStorage extends ReadableStorage {
 
         const metadata = buildMetadataForMatcher(matcher, this.hmac);
         const { index } = this.createIndex(indexName, Object.assign({}, this.indexOptions, { metadata }));
-        try {
-            this.forEachDocument((document, indexEntry) => {
-                if (matches(document, matcher)) {
-                    index.add(indexEntry);
-                }
-            });
-        } catch (e) {
-            index.destroy();
-            throw e;
+        if (reindex) {
+            try {
+                this.forEachDocument((document, indexEntry) => {
+                    if (matches(document, matcher)) {
+                        index.add(indexEntry);
+                    }
+                });
+            } catch (e) {
+                index.destroy();
+                throw e;
+            }
         }
 
         this.secondaryIndexes[name] = { index, matcher };
+        this.indexMatcher.add(name, matcher);
         this.emit('index-created', name);
         return index;
     }
@@ -423,7 +441,7 @@ class WritableStorage extends ReadableStorage {
      */
     forEachDistinctPartitionOf(entries, iterationHandler) {
         const partitions = [];
-        const numPartitions = Object.keys(this.partitions).length;
+        const numPartitions = this.partitions.count;
         for (let entry of entries) {
             if (partitions.indexOf(entry.partition) >= 0) {
                 continue;

package/src/fsUtil.js

@@ -0,0 +1,123 @@
+import fs from 'fs';
+import path from 'path';
+import { mkdirpSync } from 'mkdirp';
+
+/**
+ * Ensure that the given directory exists.
+ * @param {string} dirName
+ * @return {boolean} true if the directory existed already
+ */
+function ensureDirectory(dirName) {
+    if (!fs.existsSync(dirName)) {
+        try {
+            mkdirpSync(dirName);
+        } catch (e) {
+        }
+        return false;
+    }
+    return true;
+}
+
+/**
+ * Invoke `onEach` if `relativePath` matches `regexPattern`, passing the first capture group or the full match.
+ *
+ * @param {string} relativePath
+ * @param {RegExp} regexPattern
+ * @param {function(string)} onEach
+ */
+function visitMatchingPath(relativePath, regexPattern, onEach) {
+    const match = relativePath.match(regexPattern);
+    if (match !== null) {
+        onEach(match[1] !== undefined ? match[1] : match[0]);
+    }
+}
+
+/**
+ * Classify `entries` into matching files (visited via `onEach`) and subdirectory names (returned).
+ *
+ * @param {fs.Dirent[]} entries
+ * @param {string} relativePrefix
+ * @param {RegExp} regexPattern
+ * @param {function(string)} onEach
+ * @returns {string[]} names of subdirectory entries
+ */
+function classifyEntries(entries, relativePrefix, regexPattern, onEach) {
+    const subdirs = [];
+    for (let entry of entries) {
+        if (entry.isDirectory()) {
+            subdirs.push(entry.name);
+        } else {
+            visitMatchingPath(relativePrefix + entry.name, regexPattern, onEach);
+        }
+    }
+    return subdirs;
+}
+
+/**
+ * Sequentially scan each name in `subdirs`, calling `done` when all are complete or on first error.
+ *
+ * @param {string[]} subdirs
+ * @param {string} dir
+ * @param {string} relativePrefix
+ * @param {RegExp} regexPattern
+ * @param {function(string)} onEach
+ * @param {function(Error?)} done
+ */
+function scanSubdirs(subdirs, dir, relativePrefix, regexPattern, onEach, done) {
+    let i = 0;
+    function next() {
+        if (i >= subdirs.length) return done(null);
+        const name = subdirs[i++];
+        scanDir(path.join(dir, name), relativePrefix + name + '/', false, regexPattern, onEach, (err) => {
+            if (err) return done(err);
+            next();
+        });
+    }
+    next();
+}
+
+/**
+ * Asynchronously scan one directory level, then recurse into subdirectories sequentially.
+ *
+ * @param {string} dir
+ * @param {string} relativePrefix
+ * @param {boolean} isRoot
+ * @param {RegExp} regexPattern
+ * @param {function(string)} onEach
+ * @param {function(Error?)} done
+ */
+function scanDir(dir, relativePrefix, isRoot, regexPattern, onEach, done) {
+    fs.readdir(dir, { withFileTypes: true }, (err, entries) => {
+        if (err) {
+            /* istanbul ignore next */
+            if (!isRoot && err.code === 'ENOENT') return done(null);
+            return done(err);
+        }
+        const subdirs = classifyEntries(entries, relativePrefix, regexPattern, onEach);
+        scanSubdirs(subdirs, dir, relativePrefix, regexPattern, onEach, done);
+    });
+}
+
+/**
+ * Scan a directory (and its subdirectories) for files whose relative paths match a regex pattern,
+ * calling a callback for each match.
+ *
+ * The regex is matched against the **relative path from `directory`** (e.g. `eventstore.stream-x/foo.index`),
+ * so patterns that capture a path prefix work transparently for both flat and nested layouts.
+ *
+ * The `onEach` callback receives the first capturing group of the match (`match[1]`), or the full
+ * match (`match[0]`) when no capturing group is defined in the pattern.
+ *
+ * @param {string} directory The root directory to scan.
+ * @param {RegExp} regexPattern The pattern to match relative file paths against.
+ * @param {function(string)} onEach Called with the first capturing group (or full match) for each matching path.
+ * @param {function(Error?)} onDone Called when the scan is complete, or with an error if one occurred.
+ */
+function scanForFiles(directory, regexPattern, onEach, onDone) {
+    scanDir(directory, '', true, regexPattern, onEach, onDone);
+}
+
+export {
+    ensureDirectory,
+    scanForFiles,
+};

package/src/metadataUtil.js

@@ -1,4 +1,27 @@
 import crypto from 'crypto';
+import { 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.
+ *
+ * @param {string} magic
+ * @param {object} metadata
+ * @returns {Buffer} A buffer containing the header data
+ */
+function buildMetadataHeader(magic, metadata) {
+    assertEqual(magic.length, 8, 'The header magic bytes length is wrong.');
+    let metadataString = JSON.stringify(metadata);
+    let metadataSize = Buffer.byteLength(metadataString, 'utf8');
+    // 8 byte MAGIC, 4 byte metadata size, 1 byte line break
+    const pad = (16 - ((8 + 4 + metadataSize + 1) % 16)) % 16;
+    metadataString += ' '.repeat(pad) + "\n";
+    metadataSize += pad + 1;
+    const metadataBuffer = Buffer.allocUnsafe(8 + 4 + metadataSize);
+    metadataBuffer.write(magic, 0, 8, 'utf8');
+    metadataBuffer.writeUInt32BE(metadataSize, 8);
+    metadataBuffer.write(metadataString, 8 + 4, metadataSize, 'utf8');
+    return metadataBuffer;
+}
 
 /**
  * @param {string} secret The secret to use for calculating further HMACs
@@ -26,7 +49,11 @@ function matches(document, matcher) {
     if (typeof matcher === 'function') return matcher(document);
 
     for (let prop of Object.getOwnPropertyNames(matcher)) {
-        if (typeof matcher[prop] === 'object') {
+        if (Array.isArray(matcher[prop])) {
+            if (!matcher[prop].includes(document[prop])) {
+                return false;
+            }
+        } else if (typeof matcher[prop] === 'object') {
             if (!matches(document[prop], matcher[prop])) {
                 return false;
             }
@@ -71,9 +98,29 @@ function buildMatcherFromMetadata(matcherMetadata, hmac) {
     return matcher;
 }
 
+/**
+ * Builds a factory function that, given a type string, returns an object matcher for
+ * documents whose payload contains that type at the given dot-notation path.
+ *
+ * @param {string} payloadPath Dot-notation path relative to the event payload (e.g. `'type'`, `'meta.kind'`).
+ * @returns {function(string): object} A function `(typeValue) => objectMatcher`.
+ */
+function buildTypeMatcherFn(payloadPath) {
+    const parts = payloadPath.split('.');
+    return function(typeValue) {
+        let obj = typeValue;
+        for (let i = parts.length - 1; i >= 0; i--) {
+            obj = { [parts[i]]: obj };
+        }
+        return { payload: obj };
+    };
+}
+
 export {
     createHmac,
     matches,
+    buildMetadataHeader,
     buildMetadataForMatcher,
-    buildMatcherFromMetadata
+    buildMatcherFromMetadata,
+    buildTypeMatcherFn
 };