@karmaniverous/entity-manager 5.0.8 → 6.0.0

package/dist/mjs/src/getHashKeySpace.js

@@ -0,0 +1,39 @@
+import { validateEntityToken } from './validateEntityToken.js';
+import { range } from '../node_modules/radash/dist/esm/array.js';
+
+/**
+ * Return an array of {@link ConfigKeys.hashKey | `entityManager.config.hashKey`} property values covering the shard space bounded by `timestampFrom` & `timestampTo`.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param entityToken - {@link ConfigKeys.entities | `entityManager.config.entities`} key.
+ * @param timestampFrom - Lower timestanp limit. Defaults to `0`.
+ * @param timestampTo - Upper timestamp limit. Defaults to `Date.now()`.
+ *
+ * @returns Array of {@link ConfigKeys.hashKey | `entityManager.config.hashKey`} property values covering the indicated shard space.
+ *
+ * @throws `Error` if `entityToken` is invalid.
+ */
+function getHashKeySpace(entityManager, entityToken, timestampFrom = 0, timestampTo = Date.now()) {
+    try {
+        // Validate params.
+        validateEntityToken(entityManager, entityToken);
+        const { shardBumps } = entityManager.config.entities[entityToken];
+        const hashKeySpace = shardBumps
+            .filter((bump, i) => (i === shardBumps.length - 1 ||
+            shardBumps[i + 1].timestamp > timestampFrom) &&
+            bump.timestamp <= timestampTo)
+            .flatMap(({ charBits, chars }) => {
+            const radix = 2 ** charBits;
+            return chars
+                ? [...range(0, radix ** chars - 1)].map((char) => char.toString(radix).padStart(chars, '0'))
+                : '';
+        })
+            .map((shardKey) => `${entityToken}${entityManager.config.shardKeyDelimiter}${shardKey}`);
+        return hashKeySpace;
+    }
+    catch (error) {
+        throw error;
+    }
+}
+
+export { getHashKeySpace };

package/dist/mjs/src/getShardBump.js

@@ -0,0 +1,22 @@
+import { validateEntityToken } from './validateEntityToken.js';
+
+/**
+ * Get first entity shard bump before timestamp.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param entityToken - {@link ConfigKeys.entities | `this.config.entities`} key.
+ * @param timestamp - Timestamp in milliseconds.
+ *
+ * @returns {@link ShardBump | `ShardBump`} object.
+ *
+ * @throws `Error` if `entityToken` is invalid.
+ */
+function getShardBump(entityManager, entityToken, timestamp) {
+    // Validate params.
+    validateEntityToken(entityManager, entityToken);
+    return [...entityManager.config.entities[entityToken].shardBumps]
+        .reverse()
+        .find((bump) => bump.timestamp <= timestamp);
+}
+
+export { getShardBump };

package/dist/mjs/src/index.js

@@ -0,0 +1 @@
+export { EntityManager } from './EntityManager.js';

package/dist/mjs/src/query.js

@@ -0,0 +1,102 @@
+import { sort } from '../node_modules/@karmaniverous/entity-tools/dist/mjs/sort.js';
+import lzString from '../node_modules/lz-string/libs/lz-string.js';
+import { dehydratePageKeyMap } from './dehydratePageKeyMap.js';
+import { rehydratePageKeyMap } from './rehydratePageKeyMap.js';
+import { validateEntityGeneratedProperty } from './validateEntityGeneratedProperty.js';
+import { isInt } from '../node_modules/radash/dist/esm/typed.js';
+import { parallel } from '../node_modules/radash/dist/esm/async.js';
+import { unique } from '../node_modules/radash/dist/esm/array.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 ConfigEntity.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.queryMap | `queryMap`} keys.
+ */
+async function query(entityManager, { entityToken, hashKey, item, limit, pageKeyMap, pageSize, queryMap, sortOrder = [], timestampFrom = 0, timestampTo = Date.now(), throttle = entityManager.config.throttle, }) {
+    try {
+        // Get defaults.
+        const { defaultLimit, defaultPageSize } = entityManager.config.entities[entityToken];
+        limit ?? (limit = defaultLimit);
+        pageSize ?? (pageSize = defaultPageSize);
+        // Validate params.
+        validateEntityGeneratedProperty(entityManager, entityToken, hashKey, true);
+        if (!(limit === Infinity || (isInt(limit) && limit >= 1)))
+            throw new Error('limit must be a positive integer or Infinity.');
+        if (!(isInt(pageSize) && pageSize >= 1))
+            throw new Error('pageSize must be a positive integer');
+        // Rehydrate pageKeyMap.
+        const rehydratedPageKeyMap = rehydratePageKeyMap(entityManager, pageKeyMap
+            ? JSON.parse(decompressFromEncodedURIComponent(pageKeyMap))
+            : undefined, entityToken, Object.keys(queryMap), 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.
+            // Query every shard on every index in pageKeyMap.
+            const shardQueryResults = await parallel(throttle, Object.entries(rehydratedPageKeyMap).flatMap(([index, indexPageKeys]) => Object.entries(indexPageKeys).map(([hashKey, pageKey]) => [
+                index,
+                hashKey,
+                pageKey,
+            ])), async ([index, hashKey, pageKey]) => ({
+                index,
+                queryResult: await queryMap[index](hashKey, pageKey, pageSize),
+                hashKey,
+            }));
+            // Reduce shardQueryResults & updateworkingRresult.
+            workingResult = shardQueryResults.reduce(({ items, pageKeyMap }, { index, queryResult, hashKey }) => {
+                Object.assign(rehydratedPageKeyMap[index], {
+                    [hashKey]: queryResult.pageKey,
+                });
+                return {
+                    items: [...items, ...queryResult.items],
+                    pageKeyMap,
+                };
+            }, workingResult);
+        } while (
+        // Repeat while pages remain & limit is not reached.
+        Object.values(workingResult.pageKeyMap).some((indexPageKeys) => Object.values(indexPageKeys).some((pageKey) => pageKey !== undefined)) &&
+            workingResult.items.length < limit);
+        // Dedupe & sort working result.
+        workingResult.items = sort(unique(workingResult.items, (item) => item[entityManager.config.entities[entityToken]
+            .uniqueProperty].toString()), sortOrder);
+        const result = {
+            count: workingResult.items.length,
+            items: workingResult.items,
+            pageKeyMap: compressToEncodedURIComponent(JSON.stringify(dehydratePageKeyMap(entityManager, workingResult.pageKeyMap, entityToken))),
+        };
+        return result;
+    }
+    catch (error) {
+        throw error;
+    }
+}
+
+export { query };

package/dist/mjs/src/rehydrateIndexItem.js

@@ -0,0 +1,46 @@
+import { decodeEntityElement } from './decodeEntityElement.js';
+import { unwrapIndex } from './unwrapIndex.js';
+import { validateEntityIndexToken } from './validateEntityIndexToken.js';
+import { shake } from '../node_modules/radash/dist/esm/object.js';
+import { zipToObject } from '../node_modules/radash/dist/esm/array.js';
+
+/**
+ * Convert a delimited string into a partial {@link ItemMap | `ItemMap`} object representing the ungenerated component elements of a Config entity index.
+ *
+ * @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 dehydrated - Dehydrated index value.
+ * @param entityToken - {@link ConfigKeys.entities | `entityManager.config.entities`} key.
+ * @param indexToken - {@link ConfigEntity.indexes | `entityManager.config.entities.<entityToken>.indexes`} key.
+ * @param omit - Array of index components omitted from `dehydrated`.
+ *
+ * @returns Partial {@link ItemMap | `ItemMap`} object containing rehydrated index component elements.
+ *
+ * @throws `Error` if `entityToken` is invalid.
+ * @throws `Error` if `indexToken` is invalid.
+ */
+function rehydrateIndexItem(entityManager, dehydrated, entityToken, indexToken, omit = []) {
+    try {
+        const { generatedKeyDelimiter } = entityManager.config;
+        // Validate params.
+        validateEntityIndexToken(entityManager, entityToken, indexToken);
+        // Unwrap index elements.
+        const elements = unwrapIndex(entityManager, entityToken, indexToken).filter((element) => !omit.includes(element));
+        // Split dehydrated value & validate.
+        const values = dehydrated.split(generatedKeyDelimiter);
+        if (elements.length !== values.length)
+            throw new Error('index rehydration key-value mismatch');
+        // Assign values to elements.
+        const rehydrated = shake(zipToObject(elements, values.map((value, i) => decodeEntityElement(entityManager, value, entityToken, elements[i]))));
+        return rehydrated;
+    }
+    catch (error) {
+        throw error;
+    }
+}
+
+export { rehydrateIndexItem };

package/dist/mjs/src/rehydratePageKeyMap.js

@@ -0,0 +1,64 @@
+import { encodeGeneratedProperty } from './encodeGeneratedProperty.js';
+import { getHashKeySpace } from './getHashKeySpace.js';
+import { rehydrateIndexItem } from './rehydrateIndexItem.js';
+import { updateItemRangeKey } from './updateItemRangeKey.js';
+import { validateEntityIndexToken } from './validateEntityIndexToken.js';
+import { range, zipToObject, cluster } from '../node_modules/radash/dist/esm/array.js';
+import { mapValues } from '../node_modules/radash/dist/esm/object.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 dehydrated - Array of dehydrated page keys or undefined if new query.
+ * @param entityToken - {@link ConfigKeys.entities | `entityManager.config.entities`} key.
+ * @param indexTokens - Array of {@link ConfigEntity.indexes | `entityManager.config.entities.<entityToken>.indexes`} keys used as keys of the original {@link PageKeyMap | `PageKeyMap`}.
+ * @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 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 `dehydrated` has invalid length.
+ */
+function rehydratePageKeyMap(entityManager, dehydrated, entityToken, indexTokens, timestampFrom = 0, timestampTo = Date.now()) {
+    try {
+        // Validate params.
+        if (!indexTokens.length)
+            throw new Error('indexTokens empty');
+        indexTokens.map((index) => validateEntityIndexToken(entityManager, entityToken, index));
+        // Shortcut empty dehydrated.
+        if (dehydrated && !dehydrated.length)
+            return {};
+        // Get hash key space.
+        const hashKeySpace = getHashKeySpace(entityManager, entityToken, timestampFrom, timestampTo);
+        // Default dehydrated.
+        dehydrated ?? (dehydrated = [...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 rehydrated = mapValues(zipToObject(indexTokens, cluster(dehydrated, hashKeySpace.length)), (dehydratedIndexPageKeyMaps, index) => zipToObject(hashKeySpace, (hashKey, i) => {
+            if (!dehydratedIndexPageKeyMaps[i])
+                return;
+            const item = {
+                [entityManager.config.hashKey]: hashKey,
+                ...rehydrateIndexItem(entityManager, dehydratedIndexPageKeyMaps[i], entityToken, index, [entityManager.config.hashKey]),
+            };
+            updateItemRangeKey(entityManager, item, entityToken);
+            return zipToObject(entityManager.config.entities[entityToken].indexes[index], (component) => entityManager.config.entities[entityToken].generated[component]
+                ? encodeGeneratedProperty(entityManager, item, entityToken, component)
+                : item[component]);
+        }));
+        return rehydrated;
+    }
+    catch (error) {
+        throw error;
+    }
+}
+
+export { rehydratePageKeyMap };

package/dist/mjs/src/removeKeys.js

@@ -0,0 +1,31 @@
+import { validateEntityToken } from './validateEntityToken.js';
+
+/**
+ * Strips generated properties, hash key, and range key from an {@link ItemMap | `ItemMap`} object. Mutates `item`.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param item - {@link ItemMap | `ItemMap`} object.
+ * @param entityToken - {@link ConfigKeys.entities | `entityManager.config.entities`} key.
+ *
+ * @returns Mutated `item` without generated properties, hash key or range key.
+ *
+ * @throws `Error` if `entityToken` is invalid.
+ */
+function removeKeys(entityManager, item, entityToken) {
+    try {
+        // Validate params.
+        validateEntityToken(entityManager, entityToken);
+        // Delete hash & range keys.
+        delete item[entityManager.config.hashKey];
+        delete item[entityManager.config.rangeKey];
+        // Delete generated properties.
+        for (const property in entityManager.config.entities[entityToken].generated)
+            delete item[property];
+        return item;
+    }
+    catch (error) {
+        throw error;
+    }
+}
+
+export { removeKeys };

package/dist/mjs/src/unwrapIndex.js

@@ -0,0 +1,38 @@
+import { validateEntityIndexToken } from './validateEntityIndexToken.js';
+import { shake } from '../node_modules/radash/dist/esm/object.js';
+
+/**
+ * Unwraps an {@link ConfigEntity.indexes | Entity index} into deduped, sorted, ungenerated index component elements.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param entityToken - {@link ConfigKeys.entities | `entityManager.config.entities`} key.
+ * @param indexToken - {@link ConfigEntity.indexes | `entityManager.config.entities.<entityToken>.indexes`} key.
+ *
+ * @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) {
+    try {
+        // Validate params.
+        validateEntityIndexToken(entityManager, entityToken, indexToken);
+        const generated = entityManager.config.entities[entityToken].generated;
+        const generatedKeys = Object.keys(shake(generated));
+        return entityManager.config.entities[entityToken].indexes[indexToken]
+            .map((component) => component === entityManager.config.hashKey
+            ? entityManager.config.hashKey
+            : component === entityManager.config.rangeKey
+                ? entityManager.config.entities[entityToken].uniqueProperty
+                : generatedKeys.includes(component)
+                    ? generated[component].elements
+                    : component)
+            .flat()
+            .sort();
+    }
+    catch (error) {
+        throw error;
+    }
+}
+
+export { unwrapIndex };

package/dist/mjs/src/updateItemHashKey.js

@@ -0,0 +1,53 @@
+import { isNil } from '../node_modules/@karmaniverous/entity-tools/dist/mjs/Nil.js';
+import stringHash from '../node_modules/string-hash/index.js';
+import { getShardBump } from './getShardBump.js';
+import { validateEntityToken } from './validateEntityToken.js';
+
+/**
+ * Update the hash key on a partial {@link ItemMap | `ItemMap`} object. Mutates `item`.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param item - Partial {@link ItemMap | `ItemMap`} object.
+ * @param entityToken - {@link ConfigKeys.entities | `this.config.entities`} key.
+ * @param overwrite - Overwrite existing {@link ConfigKeys.hashKey | `this.config.hashKey`} property value (default `false`).
+ *
+ * @returns Mutated `item` with updated hash key.
+ *
+ * @throws `Error` if `entityToken` is invalid.
+ */
+function updateItemHashKey(entityManager, item, entityToken, overwrite = false) {
+    try {
+        // Validate params.
+        validateEntityToken(entityManager, entityToken);
+        // Return current item if hashKey exists and overwrite is false.
+        if (item[entityManager.config.hashKey] && !overwrite) {
+            return item;
+        }
+        // Get item timestamp property & validate.
+        const timestamp = item[entityManager.config.entities[entityToken].timestampProperty];
+        if (isNil(timestamp))
+            throw new Error(`missing item timestamp property`);
+        // Find first entity sharding bump before timestamp.
+        const { charBits, chars } = getShardBump(entityManager, entityToken, timestamp);
+        let hashKey = `${entityToken}${entityManager.config.shardKeyDelimiter}`;
+        if (chars) {
+            // Radix is the numerical base of the shardKey.
+            const radix = 2 ** charBits;
+            // Get item unique property & validate.
+            const uniqueId = item[entityManager.config.entities[entityToken]
+                .uniqueProperty];
+            if (isNil(uniqueId))
+                throw new Error(`missing item unique property`);
+            hashKey += (stringHash(uniqueId.toString()) % (chars * radix))
+                .toString(radix)
+                .padStart(chars, '0');
+        }
+        Object.assign(item, { [entityManager.config.hashKey]: hashKey });
+        return item;
+    }
+    catch (error) {
+        throw error;
+    }
+}
+
+export { updateItemHashKey };

package/dist/mjs/src/updateItemRangeKey.js

@@ -0,0 +1,43 @@
+import { isNil } from '../node_modules/@karmaniverous/entity-tools/dist/mjs/Nil.js';
+import { validateEntityToken } from './validateEntityToken.js';
+
+/**
+ * Update the range key on a partial {@link ItemMap | `ItemMap`} object. Mutates `item`.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param item - Partial {@link ItemMap | `ItemMap`} object.
+ * @param entityToken - {@link ConfigKeys.entities | `this.config.entities`} key.
+ * @param overwrite - Overwrite existing {@link ConfigKeys.rangeKey | `this.config.rangeKey`} property value (default `false`).
+ *
+ * @returns Mutated `item` with updated range key.
+ *
+ * @throws `Error` if `entityToken` is invalid.
+ * @throws `Error` if `item` {@link ConfigEntity.uniqueProperty | `this.config.entities<entityToken>.uniqueProperty`} property value is missing.
+ */
+function updateItemRangeKey(entityManager, item, entityToken, overwrite = false) {
+    try {
+        // Validate params.
+        validateEntityToken(entityManager, entityToken);
+        // Return current item if rangeKey exists and overwrite is false.
+        if (item[entityManager.config.rangeKey] && !overwrite) {
+            return item;
+        }
+        // Get item unique property & validate.
+        const uniqueProperty = item[entityManager.config.entities[entityToken].uniqueProperty];
+        if (isNil(uniqueProperty))
+            throw new Error(`missing item unique property`);
+        // Update range key.
+        Object.assign(item, {
+            [entityManager.config.rangeKey]: [
+                entityManager.config.entities[entityToken].uniqueProperty,
+                uniqueProperty,
+            ].join(entityManager.config.generatedValueDelimiter),
+        });
+        return item;
+    }
+    catch (error) {
+        throw error;
+    }
+}
+
+export { updateItemRangeKey };

package/dist/mjs/src/validateEntityGeneratedProperty.js

@@ -0,0 +1,27 @@
+import { validateEntityToken } from './validateEntityToken.js';
+
+/**
+ * Validate that an entity generated property is defined in EntityManager
+ * config.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param entityToken - {@link ConfigKeys.entities | `this.config.entities`} key.
+ * @param property - {@link ConfigEntityGenerated | `this.config.entities.<entityToken>.generated`} key.
+ * @param sharded - Whether the generated property is sharded. `undefined` indicates no constraint.
+ *
+ * @throws `Error` if `entityToken` is invalid.
+ * @throws `Error` if `property` is invalid.
+ * @throws `Error` if `sharded` is specified & does not match `this.config.entities.<entityToken>.generated.<property>.sharded`.
+ */
+function validateEntityGeneratedProperty(entityManager, entityToken, property, sharded) {
+    validateEntityToken(entityManager, entityToken);
+    const generated = entityManager.config.entities[entityToken].generated[property];
+    if (!generated && property !== entityManager.config.hashKey)
+        throw new Error('invalid entity generated property');
+    if (sharded !== undefined &&
+        ((generated && sharded !== generated.sharded) ||
+            (!sharded && property === entityManager.config.hashKey)))
+        throw new Error(`entity generated property ${sharded ? 'not ' : ''}sharded`);
+}
+
+export { validateEntityGeneratedProperty };

package/dist/mjs/src/validateEntityIndexToken.js

@@ -0,0 +1,20 @@
+import { validateEntityToken } from './validateEntityToken.js';
+
+/**
+ * Validate that an entity index is defined in EntityManager config.
+ *
+ * @param entityManager - {@link EntityManager | `EntityManager`} instance.
+ * @param entityToken - {@link ConfigKeys.entities | `this.config.entities`} key.
+ * @param indexToken - {@link ConfigEntity.indexes | `this.config.entities.<entityToken>.indexes`} key.
+ *
+ * @throws `Error` if `entityToken` is invalid.
+ * @throws `Error` if `indexToken` is invalid.
+ */
+function validateEntityIndexToken(entityManager, entityToken, indexToken) {
+    validateEntityToken(entityManager, entityToken);
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!entityManager.config.entities[entityToken].indexes[indexToken])
+        throw new Error('invalid entity index token');
+}
+
+export { validateEntityIndexToken };

package/dist/mjs/src/validateEntityToken.js

@@ -0,0 +1,15 @@
+/**
+ * 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');
+}
+
+export { validateEntityToken };