@karmaniverous/entity-manager 5.0.8 → 5.0.10

package/dist/cjs/EntityManager/query.js

@@ -0,0 +1,130 @@
+'use strict';
+
+var entityTools = require('@karmaniverous/entity-tools');
+var lzString = require('lz-string');
+var radash = require('radash');
+var dehydratePageKeyMap = require('./dehydratePageKeyMap.js');
+var rehydratePageKeyMap = require('./rehydratePageKeyMap.js');
+
+const { compressToEncodedURIComponent, decompressFromEncodedURIComponent } = lzString;
+/**
+ * Query a database entity across shards in a provider-generic fashion.
+ *
+ * @remarks
+ * The provided {@link ShardQueryFunction | `ShardQueryFunction`} performs the actual query of individual data pages on individual shards. This function is presumed to express provider-specific query logic, including any necessary indexing or search constraints.
+ *
+ * Individual shard query results will be combined, deduped by {@link Config.uniqueProperty} property value, and sorted by {@link QueryOptions.sortOrder | `sortOrder`}.
+ *
+ * In queries on sharded data, expect the leading and trailing edges of returned data pages to interleave somewhat with preceding & following pages.
+ *
+ * Unsharded query results should sort & page as expected.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param options - {@link QueryOptions | `QueryOptions`} object.
+ *
+ * @returns {@link QueryResult} object.
+ *
+ * @throws Error if {@link QueryOptions.pageKeyMap | `pageKeyMap`} keys do not match {@link QueryOptions.shardQueryMap | `shardQueryMap`} keys.
+ */
+async function query(entityManager, options) {
+    try {
+        // Get defaults (avoid unsafe destructuring on generic access).
+        const entityDefaults = entityManager.config.entities[options.entityToken];
+        const defaultLimit = entityDefaults.defaultLimit;
+        const defaultPageSize = entityDefaults.defaultPageSize;
+        // Extract params.
+        const { entityToken, limit = defaultLimit, item, pageKeyMap, pageSize = defaultPageSize, shardQueryMap, sortOrder = [], timestampFrom = 0, timestampTo = Date.now(), throttle = entityManager.config.throttle, } = options;
+        // Validate params.
+        if (!(limit === Infinity || (radash.isInt(limit) && limit >= 1)))
+            throw new Error('limit must be a positive integer or Infinity.');
+        if (!(radash.isInt(pageSize) && pageSize >= 1))
+            throw new Error('pageSize must be a positive integer');
+        // Rehydrate pageKeyMap.
+        const [hashKeyToken, rehydratedPageKeyMap] = rehydratePageKeyMap.rehydratePageKeyMap(entityManager, entityToken, Object.keys(shardQueryMap).sort(), item, pageKeyMap
+            ? JSON.parse(decompressFromEncodedURIComponent(pageKeyMap))
+            : undefined, timestampFrom, timestampTo);
+        // Shortcut if pageKeyMap is empty.
+        if (!Object.keys(rehydratedPageKeyMap).length)
+            return {
+                count: 0,
+                items: [],
+                pageKeyMap: compressToEncodedURIComponent(JSON.stringify([])),
+            };
+        // Iterate search over pages.
+        let workingResult = {
+            items: [],
+            pageKeyMap: rehydratedPageKeyMap,
+        };
+        do {
+            // TODO: This loop will blow up as shards scale, since at a minimum it will return shardCount * pageSize
+            // items, which may be >> limit. Probably the way to fix entityManager is to limit the number of shards queried per
+            // iteration in order to keep shardsQueried * pageSize > (limit - items.length) but only just.
+            // TODO: Test for invalid characters (path delimiters) in index keys & shard key values.
+            // Build typed tasks (indexToken, hashKey, pageKey).
+            const tasks = [];
+            for (const [indexToken, indexPageKeys] of Object.entries(rehydratedPageKeyMap)) {
+                for (const [hashKey, pk] of Object.entries(indexPageKeys)) {
+                    tasks.push([indexToken, hashKey, pk]);
+                }
+            }
+            // Query every shard on every index in pageKeyMap.
+            const shardQueryResults = await radash.parallel(throttle, tasks, async ([indexToken, hashKey, pageKey]) => ({
+                indexToken,
+                queryResult: await shardQueryMap[indexToken](hashKey, pageKey, pageSize),
+                hashKey,
+            }));
+            // Reduce shardQueryResults & update working result.
+            workingResult = shardQueryResults.reduce(({ items, pageKeyMap }, { indexToken, queryResult, hashKey }) => {
+                Object.assign(rehydratedPageKeyMap[indexToken], {
+                    [hashKey]: queryResult.pageKey,
+                });
+                return {
+                    items: [...items, ...queryResult.items],
+                    pageKeyMap,
+                };
+            }, workingResult);
+            // Repeat while pages remain & limit is not reached.
+            let pagesRemain = false;
+            for (const idx of Object.keys(workingResult.pageKeyMap)) {
+                const inner = workingResult.pageKeyMap[idx];
+                for (const h of Object.keys(inner)) {
+                    if (inner[h] !== undefined) {
+                        pagesRemain = true;
+                        break;
+                    }
+                }
+                if (pagesRemain)
+                    break;
+            }
+            if (!pagesRemain)
+                break;
+        } while (workingResult.items.length < limit);
+        // Dedupe & sort working result.
+        // Note: when projecting, callers may omit uniqueProperty/sort keys.
+        // We perform operations on the full item shape and then cast back.
+        const itemsForOps = workingResult.items;
+        const dedupedSorted = entityTools.sort(radash.unique(itemsForOps, (i) => i[entityManager.config.entities[entityToken]
+            .uniqueProperty].toString()), sortOrder);
+        workingResult.items = dedupedSorted;
+        const result = {
+            count: workingResult.items.length,
+            items: workingResult.items,
+            pageKeyMap: compressToEncodedURIComponent(JSON.stringify(dehydratePageKeyMap.dehydratePageKeyMap(entityManager, entityToken, workingResult.pageKeyMap))),
+        };
+        entityManager.logger.debug('queried entityToken across shards', {
+            options,
+            hashKeyToken,
+            rehydratedPageKeyMap,
+            workingResult,
+            result,
+        });
+        return result;
+    }
+    catch (error) {
+        if (error instanceof Error)
+            entityManager.logger.error(error.message, options);
+        throw error;
+    }
+}
+
+exports.query = query;

package/dist/cjs/EntityManager/rehydrateIndexItem.js

@@ -0,0 +1,65 @@
+'use strict';
+
+var radash = require('radash');
+var decodeElement = require('./decodeElement.js');
+var unwrapIndex = require('./unwrapIndex.js');
+var validateEntityToken = require('./validateEntityToken.js');
+var validateIndexToken = require('./validateIndexToken.js');
+
+/**
+ * Convert a delimited string into an {@link EntityItem | `EntityItem`} object representing the ungenerated component elements of a Config entity index, minus its hash key.
+ *
+ * @remarks
+ * Reverses {@link EntityManager.dehydrateIndexItem | `dehydrateIndexItem`}.
+ *
+ * {@link EntityManager.dehydrateIndexItem | `dehydrateIndexItem`} alphebetically sorts unwrapped index elements during the dehydration process. This method assumes delimited element values are presented in the same order.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param entityToken - {@link Config.entities | `entityManager.config.entities`} key.
+ * @param indexToken - {@link Config.indexes | `entityManager.config.indexes`} key.
+ * @param dehydrated - Dehydrated index value.
+ *
+ * @returns {@link EntityItem | `EntityItem`} object containing rehydrated index component elements.
+ *
+ * @throws `Error` if `entityToken` is invalid.
+ * @throws `Error` if `indexToken` is invalid.
+ */
+function rehydrateIndexItem(entityManager, entityToken, indexToken, dehydrated) {
+    try {
+        // Validate params.
+        validateEntityToken.validateEntityToken(entityManager, entityToken);
+        validateIndexToken.validateIndexToken(entityManager, indexToken);
+        // Unwrap index elements.
+        const { hashKey } = entityManager.config.indexes[indexToken];
+        const elements = unwrapIndex.unwrapIndex(entityManager, entityToken, indexToken, [
+            hashKey,
+        ]);
+        // Split dehydrated value & validate.
+        const { generatedKeyDelimiter } = entityManager.config;
+        const values = dehydrated.split(generatedKeyDelimiter);
+        if (elements.length !== values.length)
+            throw new Error('index rehydration key-value mismatch');
+        // Assign values to elements.
+        const rehydrated = radash.shake(radash.zipToObject(elements, values.map((value, i) => decodeElement.decodeElement(entityManager, elements[i], value))));
+        entityManager.logger.debug('rehydrated index', {
+            entityToken,
+            indexToken,
+            dehydrated,
+            elements,
+            values,
+            rehydrated,
+        });
+        return rehydrated;
+    }
+    catch (error) {
+        if (error instanceof Error)
+            entityManager.logger.error(error.message, {
+                entityToken,
+                indexToken,
+                dehydrated,
+            });
+        throw error;
+    }
+}
+
+exports.rehydrateIndexItem = rehydrateIndexItem;

package/dist/cjs/EntityManager/rehydratePageKeyMap.js

@@ -0,0 +1,103 @@
+'use strict';
+
+var radash = require('radash');
+var decodeGeneratedProperty = require('./decodeGeneratedProperty.js');
+var encodeGeneratedProperty = require('./encodeGeneratedProperty.js');
+var getHashKeySpace = require('./getHashKeySpace.js');
+var getIndexComponents = require('./getIndexComponents.js');
+var rehydrateIndexItem = require('./rehydrateIndexItem.js');
+var updateItemRangeKey = require('./updateItemRangeKey.js');
+var validateEntityToken = require('./validateEntityToken.js');
+var validateIndexToken = require('./validateIndexToken.js');
+
+/**
+ * Rehydrate an array of dehydrated page keys into a {@link PageKeyMap | `PageKeyMap`} object.
+ *
+ * Reverses the {@link EntityManager.dehydratePageKeyMap | `dehydratePageKeyMap`} method.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param entityToken - {@link Config.entities | `entityManager.config.entities`} key.
+ * @param indexTokens - Array of {@link Config.indexes | `entityManager.config.indexes`} keys used as keys of the original {@link PageKeyMap | `PageKeyMap`}.
+ * @param item - Partial item object sufficiently populated to generate index hash keys.
+ * @param dehydrated - Array of dehydrated page keys or undefined if new query.
+ * @param timestampFrom - Lower timestanp limit used to generate the original {@link PageKeyMap | `PageKeyMap`}. Defaults to `0`.
+ * @param timestampTo - Upper timestamp limit used to generate the original {@link PageKeyMap | `PageKeyMap`}. Defaults to `Date.now()`.
+ *
+ * @returns A tuple of `hashKeyToken` and rehydrated {@link PageKeyMap | `PageKeyMap`} object.
+ *
+ * @throws `Error` if `entityToken` is invalid.
+ * @throws `Error` if `indexTokens` is empty.
+ * @throws `Error` if any `indexTokens` are invalid.
+ * @throws `Error` if `indexTokens` represent indexes with inconsistent hashKeys.
+ * @throws `Error` if `dehydrated` has invalid length.
+ */
+function rehydratePageKeyMap(entityManager, entityToken, indexTokens, item, dehydrated, timestampFrom = 0, timestampTo = Date.now()) {
+    try {
+        // Validate params.
+        validateEntityToken.validateEntityToken(entityManager, entityToken);
+        // Validate indexTokens populated.
+        if (!indexTokens.length)
+            throw new Error('indexTokens empty');
+        // Validate indexTokens exist and capture hashKeys.
+        const hashKeys = radash.unique(indexTokens.map((indexToken) => {
+            validateIndexToken.validateIndexToken(entityManager, indexToken);
+            return entityManager.config.indexes[indexToken].hashKey;
+        }));
+        // Validate hashKeys consistent.
+        if (hashKeys.length > 1)
+            throw new Error('inconsistent hashKeys');
+        const [hashKeyToken] = hashKeys;
+        indexTokens.map((index) => {
+            validateIndexToken.validateIndexToken(entityManager, index);
+        });
+        // Shortcut empty dehydrated.
+        if (dehydrated && !dehydrated.length)
+            return [
+                hashKeyToken,
+                {},
+            ];
+        // Get hash key space.
+        const hashKeySpace = getHashKeySpace.getHashKeySpace(entityManager, entityToken, hashKeyToken, item, timestampFrom, timestampTo);
+        // Default dehydrated.
+        dehydrated ?? (dehydrated = [...radash.range(1, hashKeySpace.length * indexTokens.length, '')]);
+        // Validate dehydrated length
+        if (dehydrated.length !== hashKeySpace.length * indexTokens.length)
+            throw new Error('dehydrated length mismatch');
+        // Rehydrate pageKeys.
+        const uniqueProperty = entityManager.config.entities[entityToken]
+            .uniqueProperty;
+        const { sharded, unsharded } = entityManager.config.generatedProperties;
+        const rehydrated = radash.mapValues(radash.zipToObject(indexTokens, radash.cluster(dehydrated, hashKeySpace.length)), (dehydratedIndexPageKeyMaps, index) => radash.zipToObject(hashKeySpace, (hashKey, i) => {
+            if (!dehydratedIndexPageKeyMaps[i])
+                return;
+            let pageKeyItem = {
+                ...decodeGeneratedProperty.decodeGeneratedProperty(entityManager, entityToken, hashKey),
+                ...rehydrateIndexItem.rehydrateIndexItem(entityManager, entityToken, index, dehydratedIndexPageKeyMaps[i]),
+            };
+            pageKeyItem = updateItemRangeKey.updateItemRangeKey(entityManager, entityToken, pageKeyItem);
+            return radash.zipToObject(getIndexComponents.getIndexComponents(entityManager, index), (component) => component === entityManager.config.rangeKey
+                ? [uniqueProperty, pageKeyItem[uniqueProperty]].join(entityManager.config.generatedValueDelimiter)
+                : component in sharded || component in unsharded
+                    ? encodeGeneratedProperty.encodeGeneratedProperty(entityManager, component, pageKeyItem)
+                    : pageKeyItem[component]);
+        }));
+        entityManager.logger.debug('rehydrated page key map', {
+            entityToken,
+            indexTokens,
+            dehydrated,
+            rehydrated,
+        });
+        return [hashKeyToken, rehydrated];
+    }
+    catch (error) {
+        if (error instanceof Error)
+            entityManager.logger.error(error.message, {
+                entityToken,
+                indexTokens,
+                dehydrated,
+            });
+        throw error;
+    }
+}
+
+exports.rehydratePageKeyMap = rehydratePageKeyMap;

package/dist/cjs/EntityManager/removeKeys.js

@@ -0,0 +1,51 @@
+'use strict';
+
+var validateEntityToken = require('./validateEntityToken.js');
+
+/**
+ * Strips generated properties, hash key, and range key from an {@link EntityRecord | `EntityRecord`} object.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param entityToken - {@link Config.entities | `entityManager.config.entities`} key.
+ * @param item - {@link EntityRecord | `EntityRecord`} object.
+ *
+ * @returns {@link EntityItem | `EntityItem`} with generated properties, hash key & range key removed.
+ *
+ * @throws `Error` if `entityToken` is invalid.
+ */
+function removeKeys(entityManager, entityToken, item) {
+    try {
+        // Validate params.
+        validateEntityToken.validateEntityToken(entityManager, entityToken);
+        // Build a set of keys to strip (hash, range, and all generated properties).
+        const { hashKey, rangeKey, generatedProperties: { sharded, unsharded }, } = entityManager.config;
+        const keysToStrip = new Set([
+            hashKey,
+            rangeKey,
+            ...Object.keys(sharded),
+            ...Object.keys(unsharded),
+        ]);
+        // Create a shallow copy of item omitting the keys above (no delete operator),
+        // avoiding any-typed assignments.
+        const source = item;
+        const newItemObj = {};
+        for (const [key, value] of Object.entries(source)) {
+            if (!keysToStrip.has(key)) {
+                newItemObj[key] = value;
+            }
+        }
+        entityManager.logger.debug('stripped entity item generated properties', {
+            entityToken,
+            item,
+            newItem: newItemObj,
+        });
+        return newItemObj;
+    }
+    catch (error) {
+        if (error instanceof Error)
+            entityManager.logger.error(error.message, { entityToken, item });
+        throw error;
+    }
+}
+
+exports.removeKeys = removeKeys;

package/dist/cjs/EntityManager/unwrapIndex.js

@@ -0,0 +1,59 @@
+'use strict';
+
+var radash = require('radash');
+var getIndexComponents = require('./getIndexComponents.js');
+var validateEntityToken = require('./validateEntityToken.js');
+var validateIndexToken = require('./validateIndexToken.js');
+
+/**
+ * Unwraps an {@link Config.indexes | index} into deduped, sorted, ungenerated index component elements.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param entityToken - {@link Config.entities | `entityManager.config.entities`} key.
+ * @param indexToken - {@link ConfigEntity.indexes | `entityManager.config.entities.<entityToken>.indexes`} key.
+ * @param omit - Array of index components or elements to omit from the output value.
+ *
+ * @returns Deduped, sorted array of ungenerated index component elements.
+ *
+ * @throws `Error` if `entityToken` is invalid.
+ * @throws `Error` if `indexToken` is invalid.
+ */
+function unwrapIndex(entityManager, entityToken, indexToken, omit = []) {
+    try {
+        // Validate params.
+        validateEntityToken.validateEntityToken(entityManager, entityToken);
+        validateIndexToken.validateIndexToken(entityManager, indexToken);
+        const { sharded, unsharded } = entityManager.config.generatedProperties;
+        const unwrapped = radash.unique(getIndexComponents.getIndexComponents(entityManager, indexToken)
+            .filter((component) => !omit.includes(component))
+            .map((component) => component === entityManager.config.hashKey
+            ? entityManager.config.entities[entityToken].timestampProperty
+            : component === entityManager.config.rangeKey
+                ? entityManager.config.entities[entityToken].uniqueProperty
+                : component in sharded
+                    ? sharded[component]
+                    : component in unsharded
+                        ? unsharded[component]
+                        : component)
+            .flat()
+            .filter((element) => !omit.includes(element))).sort();
+        entityManager.logger.debug('unwrapped index', {
+            entityToken,
+            indexToken,
+            omit,
+            unwrapped,
+        });
+        return unwrapped;
+    }
+    catch (error) {
+        if (error instanceof Error)
+            entityManager.logger.error(error.message, {
+                entityToken,
+                indexToken,
+                omit,
+            });
+        throw error;
+    }
+}
+
+exports.unwrapIndex = unwrapIndex;

package/dist/cjs/EntityManager/updateItemHashKey.js

@@ -0,0 +1,79 @@
+'use strict';
+
+var entityTools = require('@karmaniverous/entity-tools');
+var stringHash = require('string-hash');
+var getShardBump = require('./getShardBump.js');
+var validateEntityToken = require('./validateEntityToken.js');
+
+/**
+ * Update the hash key on an {@link EntityItemPartial | `EntityItemPartial`} object.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param entityToken - {@link Config.entities | `this.config.entities`} key.
+ * @param item - {@link StorageItem | `StorageItem`} object.
+ * @param overwrite - Overwrite existing {@link ConfigKeys.hashKey | `this.config.hashKey`} property value (default `false`).
+ *
+ * @returns Shallow clone of `item` with updated hash key.
+ *
+ * @throws `Error` if `entityToken` is invalid.
+ */
+function updateItemHashKey(entityManager, entityToken, item, overwrite = false) {
+    try {
+        // Validate params.
+        validateEntityToken.validateEntityToken(entityManager, entityToken);
+        // Return current item if hashKey exists and overwrite is false.
+        if (item[entityManager.config.hashKey] &&
+            !overwrite) {
+            entityManager.logger.debug('did not overwrite existing entity item hash key', {
+                item,
+                entityToken,
+                overwrite,
+            });
+            return { ...item };
+        }
+        // Get item timestamp property & validate.
+        const tsProp = entityManager.config.entities[entityToken]
+            .timestampProperty;
+        const timestamp = item[tsProp];
+        if (entityTools.isNil(timestamp))
+            throw new Error(`missing item timestamp property`);
+        // Find first entity sharding bump before timestamp.
+        const { charBits, chars } = getShardBump.getShardBump(entityManager, entityToken, timestamp);
+        let hashKey = `${String(entityToken)}${entityManager.config.shardKeyDelimiter}`;
+        if (chars) {
+            // Radix is the numerical base of the shardKey.
+            const radix = 2 ** charBits;
+            // Compute the full shard space for this bump. Use radix ** chars to ensure
+            // all placeholders are utilized (e.g., chars=2, charBits=2 => 16 combos).
+            const space = radix ** chars;
+            // Get item unique property & validate.
+            const upProp = entityManager.config.entities[entityToken]
+                .uniqueProperty;
+            const uniqueId = item[upProp];
+            if (entityTools.isNil(uniqueId))
+                throw new Error(`missing item unique property`);
+            hashKey += (stringHash(uniqueId) % space)
+                .toString(radix)
+                .padStart(chars, '0');
+        }
+        const newItem = Object.assign({ ...item }, { [entityManager.config.hashKey]: hashKey });
+        entityManager.logger.debug('updated entity item hash key', {
+            entityToken,
+            overwrite,
+            item,
+            newItem,
+        });
+        return newItem;
+    }
+    catch (error) {
+        if (error instanceof Error)
+            entityManager.logger.error(error.message, {
+                entityToken,
+                item,
+                overwrite,
+            });
+        throw error;
+    }
+}
+
+exports.updateItemHashKey = updateItemHashKey;

package/dist/cjs/EntityManager/updateItemRangeKey.js

@@ -0,0 +1,65 @@
+'use strict';
+
+var entityTools = require('@karmaniverous/entity-tools');
+var validateEntityToken = require('./validateEntityToken.js');
+
+/**
+ * Update the range key on an {@link EntityItemPartial | `EntityItemPartial`} object.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param entityToken - {@link Config.entities | `this.config.entities`} key.
+ * @param item - {@link StorageItem | `StorageItem`} object.
+ * @param overwrite - Overwrite existing {@link ConfigKeys.rangeKey | `this.config.rangeKey`} property value (default `false`).
+ *
+ * @returns Shallow clone of `item` with updated range key.
+ *
+ * @throws `Error` if `entityToken` is invalid.
+ * @throws `Error` if `item` {@link Config.uniqueProperty | `this.config.entities<entityToken>.uniqueProperty`} property value is missing.
+ */
+function updateItemRangeKey(entityManager, entityToken, item, overwrite = false) {
+    try {
+        // Validate params.
+        validateEntityToken.validateEntityToken(entityManager, entityToken);
+        // Return current item if rangeKey exists and overwrite is false.
+        const rkProp = entityManager.config.rangeKey;
+        if (item[rkProp] && !overwrite) {
+            entityManager.logger.debug('did not overwrite existing entity item range key', {
+                entityToken,
+                item,
+                overwrite,
+            });
+            return { ...item };
+        }
+        // Get item unique property & validate.
+        const upProp = entityManager.config.entities[entityToken]
+            .uniqueProperty;
+        const uniqueValue = item[upProp];
+        if (entityTools.isNil(uniqueValue))
+            throw new Error(`missing item unique property`);
+        // Update range key.
+        const newItem = Object.assign({ ...item }, {
+            [entityManager.config.rangeKey]: [
+                entityManager.config.entities[entityToken].uniqueProperty,
+                uniqueValue,
+            ].join(entityManager.config.generatedValueDelimiter),
+        });
+        entityManager.logger.debug('updated entity item range key', {
+            entityToken,
+            overwrite,
+            item,
+            newItem,
+        });
+        return newItem;
+    }
+    catch (error) {
+        if (error instanceof Error)
+            entityManager.logger.error(error.message, {
+                entityToken,
+                item,
+                overwrite,
+            });
+        throw error;
+    }
+}
+
+exports.updateItemRangeKey = updateItemRangeKey;

package/dist/cjs/EntityManager/validateEntityToken.js

@@ -0,0 +1,17 @@
+'use strict';
+
+/**
+ * Validate that an entity is defined in the EntityManager config.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param entityToken - `entityManager.config.entities` key.
+ *
+ * @throws `Error` if `entityToken` is invalid.
+ */
+function validateEntityToken(entityManager, entityToken) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!entityManager.config.entities[entityToken])
+        throw new Error('invalid entity token');
+}
+
+exports.validateEntityToken = validateEntityToken;

package/dist/cjs/EntityManager/validateGeneratedProperty.js

@@ -0,0 +1,23 @@
+'use strict';
+
+/**
+ * Validate that a property is defined as an {@link EntityManager | `EntityManager`} {@link Config.generatedProperties | generated property}.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param property - {@link Config.generatedProperties | Generated property} key.
+ * @param isSharded - Whether the generated property is sharded. `undefined` indicates no constraint.
+ *
+ * @throws `Error` if `property` is not a {@link Config.generatedProperties | generated property}.
+ * @throws `Error` if `sharded` is specified & does not match {@link Config.generatedProperties | generated property} type.
+ */
+function validateGeneratedProperty(entityManager, property, isSharded) {
+    const { sharded, unsharded } = entityManager.config.generatedProperties;
+    if (!(property in sharded) && !(property in unsharded))
+        throw new Error('invalid generated property');
+    if (isSharded !== undefined &&
+        ((isSharded && !(property in sharded)) ||
+            (!isSharded && !(property in unsharded))))
+        throw new Error(`generated property ${isSharded ? 'not ' : ''}sharded`);
+}
+
+exports.validateGeneratedProperty = validateGeneratedProperty;

package/dist/cjs/EntityManager/validateIndexToken.js

@@ -0,0 +1,16 @@
+'use strict';
+
+/**
+ * Validate that an entity index is defined in EntityManager config.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param indexToken - {@link Config.indexes | `entityManager.config.indexes`} key.
+ *
+ * @throws `Error` if `indexToken` is invalid.
+ */
+function validateIndexToken(entityManager, indexToken) {
+    if (!(indexToken in entityManager.config.indexes))
+        throw new Error('invalid index token');
+}
+
+exports.validateIndexToken = validateIndexToken;

package/dist/cjs/EntityManager/validateTranscodedProperty.js

@@ -0,0 +1,16 @@
+'use strict';
+
+/**
+ * Validate that a property is defined as an {@link EntityManager | `EntityManager`} {@link Config.propertyTranscodes | transcoded property}.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param property - {@link Config.propertyTranscodes | Transcoded property} key.
+ *
+ * @throws `Error` if `property` is not a {@link Config.propertyTranscodes | transcoded property}.
+ */
+function validateTranscodedProperty(entityManager, property) {
+    if (!(property in entityManager.config.propertyTranscodes))
+        throw new Error('invalid transcoded property');
+}
+
+exports.validateTranscodedProperty = validateTranscodedProperty;

package/dist/cjs/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var BaseEntityClient = require('./BaseEntityClient/BaseEntityClient.js');
+var BaseQueryBuilder = require('./BaseQueryBuilder/BaseQueryBuilder.js');
+var createEntityManager = require('./EntityManager/createEntityManager.js');
+var EntityManager = require('./EntityManager/EntityManager.js');
+var ParsedConfig = require('./EntityManager/ParsedConfig.js');
+
+
+
+exports.BaseEntityClient = BaseEntityClient.BaseEntityClient;
+exports.BaseQueryBuilder = BaseQueryBuilder.BaseQueryBuilder;
+exports.createEntityManager = createEntityManager.createEntityManager;
+exports.EntityManager = EntityManager.EntityManager;
+exports.configSchema = ParsedConfig.configSchema;