@expo/entity 0.60.0 → 0.61.0

package/build/src/internal/EntityDataManager.d.ts

@@ -1,9 +1,9 @@
-import { EntityDatabaseAdapter } from '../EntityDatabaseAdapter';
-import { EntityQueryContext, EntityTransactionalQueryContext } from '../EntityQueryContext';
-import { EntityQueryContextProvider } from '../EntityQueryContextProvider';
-import { IEntityLoadKey, IEntityLoadValue, LoadPair } from './EntityLoadInterfaces';
-import { ReadThroughEntityCache } from './ReadThroughEntityCache';
-import { IEntityMetricsAdapter } from '../metrics/IEntityMetricsAdapter';
+import type { EntityDatabaseAdapter } from '../EntityDatabaseAdapter.ts';
+import type { EntityQueryContext, EntityTransactionalQueryContext } from '../EntityQueryContext.ts';
+import type { EntityQueryContextProvider } from '../EntityQueryContextProvider.ts';
+import type { IEntityLoadKey, IEntityLoadValue, LoadPair } from './EntityLoadInterfaces.ts';
+import type { ReadThroughEntityCache } from './ReadThroughEntityCache.ts';
+import type { IEntityMetricsAdapter } from '../metrics/IEntityMetricsAdapter.ts';
 /**
  * A data manager is responsible for orchestrating multiple sources of entity
  * data including local caches, EntityCacheAdapter, and EntityDatabaseAdapter.

package/build/src/internal/EntityDataManager.js

@@ -1,16 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityDataManager = void 0;
-const dataloader_1 = __importDefault(require("dataloader"));
-const invariant_1 = __importDefault(require("invariant"));
-const EntityQueryContext_1 = require("../EntityQueryContext");
-const entityUtils_1 = require("../entityUtils");
-const EntityMetricsUtils_1 = require("../metrics/EntityMetricsUtils");
-const IEntityMetricsAdapter_1 = require("../metrics/IEntityMetricsAdapter");
-const maps_1 = require("../utils/collections/maps");
+import DataLoader from 'dataloader';
+import invariant from 'invariant';
+import { TransactionalDataLoaderMode } from "../EntityQueryContext.js";
+import { partitionErrors } from "../entityUtils.js";
+import { timeAndLogLoadMapEventAsync, timeAndLogLoadOneEventAsync, } from "../metrics/EntityMetricsUtils.js";
+import { EntityMetricsLoadType, IncrementLoadCountEventType, } from "../metrics/IEntityMetricsAdapter.js";
+import { computeIfAbsent } from "../utils/collections/maps.js";
 /**
  * A data manager is responsible for orchestrating multiple sources of entity
  * data including local caches, EntityCacheAdapter, and EntityDatabaseAdapter.
@@ -19,7 +13,7 @@ const maps_1 = require("../utils/collections/maps");
  *
  * @internal
  */
-class EntityDataManager {
+export class EntityDataManager {
     databaseAdapter;
     entityCache;
     queryContextProvider;
@@ -37,8 +31,8 @@ class EntityDataManager {
         this.entityClassName = entityClassName;
     }
     getDataLoaderForLoadKey(key) {
-        return (0, maps_1.computeIfAbsent)(this.dataLoaders, key.getLoadMethodType() + key.getDataManagerDataLoaderKey(), () => {
-            return new dataloader_1.default(async (serializedLoadValues) => {
+        return computeIfAbsent(this.dataLoaders, key.getLoadMethodType() + key.getDataManagerDataLoaderKey(), () => {
+            return new DataLoader(async (serializedLoadValues) => {
                 const values = serializedLoadValues.map((serializedLoadValue) => key.deserializeLoadValue(serializedLoadValue));
                 const objectMap = await this.loadManyForNonTransactionalDataLoaderAsync(key, values);
                 return values.map((value) => objectMap.get(value) ?? []);
@@ -47,7 +41,7 @@ class EntityDataManager {
     }
     async loadManyForNonTransactionalDataLoaderAsync(key, values) {
         this.metricsAdapter.incrementDataManagerLoadCount({
-            type: IEntityMetricsAdapter_1.IncrementLoadCountEventType.CACHE,
+            type: IncrementLoadCountEventType.CACHE,
             isInTransaction: false,
             fieldValueCount: values.length,
             entityClassName: this.entityClassName,
@@ -55,7 +49,7 @@ class EntityDataManager {
         });
         return await this.entityCache.readManyThroughAsync(key, values, async (fetcherValues) => {
             this.metricsAdapter.incrementDataManagerLoadCount({
-                type: IEntityMetricsAdapter_1.IncrementLoadCountEventType.DATABASE,
+                type: IncrementLoadCountEventType.DATABASE,
                 isInTransaction: false,
                 fieldValueCount: fetcherValues.length,
                 entityClassName: this.entityClassName,
@@ -65,21 +59,21 @@ class EntityDataManager {
         });
     }
     getTransactionalDataLoaderForLoadKey(queryContext, key) {
-        const dataLoaderMapForTransaction = (0, maps_1.computeIfAbsent)(this.transactionalDataLoaders, queryContext.transactionId, () => new Map());
-        return (0, maps_1.computeIfAbsent)(dataLoaderMapForTransaction, key.getLoadMethodType() + key.getDataManagerDataLoaderKey(), () => {
-            return new dataloader_1.default(async (serializedLoadValues) => {
+        const dataLoaderMapForTransaction = computeIfAbsent(this.transactionalDataLoaders, queryContext.transactionId, () => new Map());
+        return computeIfAbsent(dataLoaderMapForTransaction, key.getLoadMethodType() + key.getDataManagerDataLoaderKey(), () => {
+            return new DataLoader(async (serializedLoadValues) => {
                 const values = serializedLoadValues.map((serializedLoadValue) => key.deserializeLoadValue(serializedLoadValue));
                 const objectMap = await this.loadManyForTransactionalDataLoaderAsync(queryContext, key, values);
                 return values.map((value) => objectMap.get(value) ?? []);
             }, {
                 // only cache if transactional dataloader caching is enabled for the transactional query context
-                cache: queryContext.transactionalDataLoaderMode === EntityQueryContext_1.TransactionalDataLoaderMode.ENABLED,
+                cache: queryContext.transactionalDataLoaderMode === TransactionalDataLoaderMode.ENABLED,
             });
         });
     }
     async loadManyForTransactionalDataLoaderAsync(queryContext, key, values) {
         this.metricsAdapter.incrementDataManagerLoadCount({
-            type: IEntityMetricsAdapter_1.IncrementLoadCountEventType.DATABASE,
+            type: IncrementLoadCountEventType.DATABASE,
             isInTransaction: true,
             fieldValueCount: values.length,
             entityClassName: this.entityClassName,
@@ -96,14 +90,14 @@ class EntityDataManager {
      * @returns map from load value to objects that match the query for that load value
      */
     async loadManyEqualingAsync(queryContext, key, values) {
-        return await (0, EntityMetricsUtils_1.timeAndLogLoadMapEventAsync)(this.metricsAdapter, IEntityMetricsAdapter_1.EntityMetricsLoadType.LOAD_MANY, this.entityClassName, queryContext)(this.loadManyEqualingInternalAsync(queryContext, key, values));
+        return await timeAndLogLoadMapEventAsync(this.metricsAdapter, EntityMetricsLoadType.LOAD_MANY, this.entityClassName, queryContext)(this.loadManyEqualingInternalAsync(queryContext, key, values));
     }
     async loadManyEqualingInternalAsync(queryContext, key, values) {
         key.validateRuntimeLoadValuesForDataManagerDataLoader(values, this.entityClassName);
         if (queryContext.isInTransaction() &&
-            queryContext.transactionalDataLoaderMode === EntityQueryContext_1.TransactionalDataLoaderMode.DISABLED) {
+            queryContext.transactionalDataLoaderMode === TransactionalDataLoaderMode.DISABLED) {
             this.metricsAdapter.incrementDataManagerLoadCount({
-                type: IEntityMetricsAdapter_1.IncrementLoadCountEventType.DATABASE,
+                type: IncrementLoadCountEventType.DATABASE,
                 isInTransaction: true,
                 fieldValueCount: values.length,
                 entityClassName: this.entityClassName,
@@ -112,7 +106,7 @@ class EntityDataManager {
             return await this.databaseAdapter.fetchManyWhereAsync(queryContext, key, values);
         }
         this.metricsAdapter.incrementDataManagerLoadCount({
-            type: IEntityMetricsAdapter_1.IncrementLoadCountEventType.DATALOADER,
+            type: IncrementLoadCountEventType.DATALOADER,
             isInTransaction: queryContext.isInTransaction(),
             fieldValueCount: values.length,
             entityClassName: this.entityClassName,
@@ -122,12 +116,12 @@ class EntityDataManager {
             ? this.getTransactionalDataLoaderForLoadKey(queryContext, key)
             : this.getDataLoaderForLoadKey(key);
         const results = await dataLoader.loadMany(values.map((v) => key.serializeLoadValue(v)));
-        const [successfulValues, errors] = (0, entityUtils_1.partitionErrors)(results);
+        const [successfulValues, errors] = partitionErrors(results);
         if (errors.length > 0) {
             const error = errors[0];
             throw error;
         }
-        (0, invariant_1.default)(values.length === successfulValues.length, `length mismatch between values (${values.length}) and successful values (${successfulValues.length})`);
+        invariant(values.length === successfulValues.length, `length mismatch between values (${values.length}) and successful values (${successfulValues.length})`);
         const mapToReturn = key.vendNewLoadValueMap();
         for (let i = 0; i < successfulValues.length; i++) {
             mapToReturn.set(values[i], successfulValues[i]);
@@ -146,7 +140,7 @@ class EntityDataManager {
      * @returns at most one that match the query for that load value
      */
     async loadOneEqualingAsync(queryContext, key, value) {
-        return await (0, EntityMetricsUtils_1.timeAndLogLoadOneEventAsync)(this.metricsAdapter, IEntityMetricsAdapter_1.EntityMetricsLoadType.LOAD_ONE, this.entityClassName, queryContext)(this.databaseAdapter.fetchOneWhereAsync(queryContext, key, value));
+        return await timeAndLogLoadOneEventAsync(this.metricsAdapter, EntityMetricsLoadType.LOAD_ONE, this.entityClassName, queryContext)(this.databaseAdapter.fetchOneWhereAsync(queryContext, key, value));
     }
     async invalidateOneAsync(key, value) {
         await this.entityCache.invalidateManyAsync(key, [value]);
@@ -167,7 +161,7 @@ class EntityDataManager {
      * @param pairs - key-value pairs to invalidate
      */
     invalidateKeyValuePairsForTransaction(queryContext, pairs) {
-        if (queryContext.transactionalDataLoaderMode === EntityQueryContext_1.TransactionalDataLoaderMode.DISABLED) {
+        if (queryContext.transactionalDataLoaderMode === TransactionalDataLoaderMode.DISABLED) {
             return;
         }
         // invalidate all query contexts in transaction tree
@@ -208,5 +202,3 @@ class EntityDataManager {
         });
     }
 }
-exports.EntityDataManager = EntityDataManager;
-//# sourceMappingURL=EntityDataManager.js.map

package/build/src/internal/EntityFieldTransformationUtils.d.ts

@@ -1,4 +1,4 @@
-import { EntityConfiguration } from '../EntityConfiguration';
+import type { EntityConfiguration } from '../EntityConfiguration.ts';
 /**
  * @internal
  */

package/build/src/internal/EntityFieldTransformationUtils.js

@@ -1,24 +1,17 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformFieldsToCacheObject = exports.transformCacheObjectToFields = exports.transformFieldsToDatabaseObject = exports.transformDatabaseObjectToFields = exports.getDatabaseFieldForEntityField = void 0;
-const invariant_1 = __importDefault(require("invariant"));
-const nullthrows_1 = __importDefault(require("nullthrows"));
+import nullthrows from '@expo/nullthrows';
+import invariant from 'invariant';
 /**
  * @internal
  */
-const getDatabaseFieldForEntityField = (entityConfiguration, entityField) => {
+export const getDatabaseFieldForEntityField = (entityConfiguration, entityField) => {
     const databaseField = entityConfiguration.entityToDBFieldsKeyMapping.get(entityField);
-    (0, invariant_1.default)(databaseField, `database field mapping missing for ${String(entityField)}`);
+    invariant(databaseField, `database field mapping missing for ${String(entityField)}`);
     return databaseField;
 };
-exports.getDatabaseFieldForEntityField = getDatabaseFieldForEntityField;
 /**
  * @internal
  */
-const transformDatabaseObjectToFields = (entityConfiguration, fieldTransformerMap, databaseObject) => {
+export const transformDatabaseObjectToFields = (entityConfiguration, fieldTransformerMap, databaseObject) => {
     const fields = {};
     for (const k in databaseObject) {
         const val = databaseObject[k];
@@ -29,25 +22,23 @@ const transformDatabaseObjectToFields = (entityConfiguration, fieldTransformerMa
     }
     return fields;
 };
-exports.transformDatabaseObjectToFields = transformDatabaseObjectToFields;
 /**
  * @internal
  */
-const transformFieldsToDatabaseObject = (entityConfiguration, fieldTransformerMap, fields) => {
+export const transformFieldsToDatabaseObject = (entityConfiguration, fieldTransformerMap, fields) => {
     const databaseObject = {};
     for (const k in fields) {
         const val = fields[k];
         const databaseKey = entityConfiguration.entityToDBFieldsKeyMapping.get(k);
-        (0, invariant_1.default)(databaseKey, `must be database key for field: ${k}`);
+        invariant(databaseKey, `must be database key for field: ${k}`);
         databaseObject[databaseKey] = maybeTransformFieldValueToDatabaseValue(entityConfiguration, fieldTransformerMap, k, val);
     }
     return databaseObject;
 };
-exports.transformFieldsToDatabaseObject = transformFieldsToDatabaseObject;
 /**
  * @internal
  */
-const transformCacheObjectToFields = (entityConfiguration, fieldTransformerMap, cacheObject) => {
+export const transformCacheObjectToFields = (entityConfiguration, fieldTransformerMap, cacheObject) => {
     const fields = {};
     for (const fieldsKey in cacheObject) {
         const val = cacheObject[fieldsKey];
@@ -55,11 +46,10 @@ const transformCacheObjectToFields = (entityConfiguration, fieldTransformerMap,
     }
     return fields;
 };
-exports.transformCacheObjectToFields = transformCacheObjectToFields;
 /**
  * @internal
  */
-const transformFieldsToCacheObject = (entityConfiguration, fieldTransformerMap, fields) => {
+export const transformFieldsToCacheObject = (entityConfiguration, fieldTransformerMap, fields) => {
     const cacheObject = {};
     for (const fieldsKey in fields) {
         const val = fields[fieldsKey];
@@ -67,17 +57,16 @@ const transformFieldsToCacheObject = (entityConfiguration, fieldTransformerMap,
     }
     return cacheObject;
 };
-exports.transformFieldsToCacheObject = transformFieldsToCacheObject;
 const maybeTransformDatabaseValueToFieldValue = (entityConfiguration, fieldTransformerMap, fieldName, value) => {
     // this will always be non-null due to the way the dbToEntityFieldsKeyMapping is computed and this
     // function is called conditionally
-    const fieldDefinition = (0, nullthrows_1.default)(entityConfiguration.schema.get(fieldName));
+    const fieldDefinition = nullthrows(entityConfiguration.schema.get(fieldName));
     const transformer = fieldTransformerMap.get(fieldDefinition.constructor.name);
     const readTransformer = transformer?.read;
     return readTransformer ? readTransformer(value) : value;
 };
 const maybeTransformFieldValueToDatabaseValue = (entityConfiguration, fieldTransformerMap, fieldName, value) => {
-    const fieldDefinition = (0, nullthrows_1.default)(entityConfiguration.schema.get(fieldName));
+    const fieldDefinition = nullthrows(entityConfiguration.schema.get(fieldName));
     const transformer = fieldTransformerMap.get(fieldDefinition.constructor.name);
     const writeTransformer = transformer?.write;
     return writeTransformer ? writeTransformer(value) : value;
@@ -100,4 +89,3 @@ const maybeTransformFieldValueToCacheValue = (entityConfiguration, fieldTransfor
     const writeTransformer = transformer?.write;
     return writeTransformer ? writeTransformer(value) : value;
 };
-//# sourceMappingURL=EntityFieldTransformationUtils.js.map

package/build/src/internal/EntityLoadInterfaces.d.ts

@@ -1,5 +1,6 @@
-import { EntityConfiguration } from '../EntityConfiguration';
-import { ISerializable, SerializableKeyMap } from '../utils/collections/SerializableKeyMap';
+import type { EntityConfiguration } from '../EntityConfiguration.ts';
+import type { ISerializable } from '../utils/collections/SerializableKeyMap.ts';
+import { SerializableKeyMap } from '../utils/collections/SerializableKeyMap.ts';
 /**
  * Load method type identifier of a load key. Used for keying data loaders and identification in metrics.
  *

package/build/src/internal/EntityLoadInterfaces.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoadValueMap = exports.EntityLoadMethodType = void 0;
-const SerializableKeyMap_1 = require("../utils/collections/SerializableKeyMap");
+import { SerializableKeyMap } from "../utils/collections/SerializableKeyMap.js";
 /**
  * Load method type identifier of a load key. Used for keying data loaders and identification in metrics.
  *
  * @internal
  */
-var EntityLoadMethodType;
+export var EntityLoadMethodType;
 (function (EntityLoadMethodType) {
     /**
      * Load method type for loading entities by single fieldName and fieldValue(s).
@@ -17,13 +14,11 @@ var EntityLoadMethodType;
      * Load method type for loading entities by composite field.
      */
     EntityLoadMethodType["COMPOSITE"] = "composite";
-})(EntityLoadMethodType || (exports.EntityLoadMethodType = EntityLoadMethodType = {}));
+})(EntityLoadMethodType || (EntityLoadMethodType = {}));
 /**
  * Map from load value interface to value.
  *
  * @internal
  */
-class LoadValueMap extends SerializableKeyMap_1.SerializableKeyMap {
+export class LoadValueMap extends SerializableKeyMap {
 }
-exports.LoadValueMap = LoadValueMap;
-//# sourceMappingURL=EntityLoadInterfaces.js.map

package/build/src/internal/EntityTableDataCoordinator.d.ts

@@ -1,11 +1,11 @@
-import { EntityConfiguration } from '../EntityConfiguration';
-import { EntityDatabaseAdapter } from '../EntityDatabaseAdapter';
-import { EntityQueryContextProvider } from '../EntityQueryContextProvider';
-import { IEntityCacheAdapter } from '../IEntityCacheAdapter';
-import { IEntityCacheAdapterProvider } from '../IEntityCacheAdapterProvider';
-import { IEntityDatabaseAdapterProvider } from '../IEntityDatabaseAdapterProvider';
-import { EntityDataManager } from './EntityDataManager';
-import { IEntityMetricsAdapter } from '../metrics/IEntityMetricsAdapter';
+import type { EntityConfiguration } from '../EntityConfiguration.ts';
+import type { EntityDatabaseAdapter } from '../EntityDatabaseAdapter.ts';
+import type { EntityQueryContextProvider } from '../EntityQueryContextProvider.ts';
+import type { IEntityCacheAdapter } from '../IEntityCacheAdapter.ts';
+import type { IEntityCacheAdapterProvider } from '../IEntityCacheAdapterProvider.ts';
+import type { IEntityDatabaseAdapterProvider } from '../IEntityDatabaseAdapterProvider.ts';
+import { EntityDataManager } from './EntityDataManager.ts';
+import type { IEntityMetricsAdapter } from '../metrics/IEntityMetricsAdapter.ts';
 /**
  * Responsible for orchestrating fetching and caching of entity data from a
  * table. Note that one instance is shared amongst all entities that read from

package/build/src/internal/EntityTableDataCoordinator.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityTableDataCoordinator = void 0;
-const EntityDataManager_1 = require("./EntityDataManager");
-const ReadThroughEntityCache_1 = require("./ReadThroughEntityCache");
+import { EntityDataManager } from "./EntityDataManager.js";
+import { ReadThroughEntityCache } from "./ReadThroughEntityCache.js";
 /**
  * Responsible for orchestrating fetching and caching of entity data from a
  * table. Note that one instance is shared amongst all entities that read from
@@ -10,7 +7,7 @@ const ReadThroughEntityCache_1 = require("./ReadThroughEntityCache");
  *
  * @internal
  */
-class EntityTableDataCoordinator {
+export class EntityTableDataCoordinator {
     entityConfiguration;
     queryContextProvider;
     metricsAdapter;
@@ -25,11 +22,9 @@ class EntityTableDataCoordinator {
         this.entityClassName = entityClassName;
         this.databaseAdapter = databaseAdapterProvider.getDatabaseAdapter(entityConfiguration);
         this.cacheAdapter = cacheAdapterProvider.getCacheAdapter(entityConfiguration);
-        this.dataManager = new EntityDataManager_1.EntityDataManager(this.databaseAdapter, new ReadThroughEntityCache_1.ReadThroughEntityCache(entityConfiguration, this.cacheAdapter), queryContextProvider, metricsAdapter, entityClassName);
+        this.dataManager = new EntityDataManager(this.databaseAdapter, new ReadThroughEntityCache(entityConfiguration, this.cacheAdapter), queryContextProvider, metricsAdapter, entityClassName);
     }
     getQueryContextProvider() {
         return this.queryContextProvider;
     }
 }
-exports.EntityTableDataCoordinator = EntityTableDataCoordinator;
-//# sourceMappingURL=EntityTableDataCoordinator.js.map

package/build/src/internal/ReadThroughEntityCache.d.ts

@@ -1,6 +1,6 @@
-import { EntityConfiguration } from '../EntityConfiguration';
-import { IEntityCacheAdapter } from '../IEntityCacheAdapter';
-import { IEntityLoadKey, IEntityLoadValue } from './EntityLoadInterfaces';
+import type { EntityConfiguration } from '../EntityConfiguration.ts';
+import type { IEntityCacheAdapter } from '../IEntityCacheAdapter.ts';
+import type { IEntityLoadKey, IEntityLoadValue } from './EntityLoadInterfaces.ts';
 /**
  * @internal
  */

package/build/src/internal/ReadThroughEntityCache.js

@@ -1,27 +1,21 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReadThroughEntityCache = exports.CacheStatus = void 0;
-const invariant_1 = __importDefault(require("invariant"));
-const maps_1 = require("../utils/collections/maps");
+import invariant from 'invariant';
+import { filterMap } from "../utils/collections/maps.js";
 /**
  * @internal
  */
-var CacheStatus;
+export var CacheStatus;
 (function (CacheStatus) {
     CacheStatus[CacheStatus["HIT"] = 0] = "HIT";
     CacheStatus[CacheStatus["MISS"] = 1] = "MISS";
     CacheStatus[CacheStatus["NEGATIVE"] = 2] = "NEGATIVE";
-})(CacheStatus || (exports.CacheStatus = CacheStatus = {}));
+})(CacheStatus || (CacheStatus = {}));
 /**
  * A read-through entity cache is responsible for coordinating EntityDatabaseAdapter and
  * EntityCacheAdapter within the EntityDataManager.
  *
  * @internal
  */
-class ReadThroughEntityCache {
+export class ReadThroughEntityCache {
     entityConfiguration;
     entityCacheAdapter;
     constructor(entityConfiguration, entityCacheAdapter) {
@@ -53,8 +47,8 @@ class ReadThroughEntityCache {
             return await fetcher(values);
         }
         const cacheLoadResults = await this.entityCacheAdapter.loadManyAsync(key, values);
-        (0, invariant_1.default)(cacheLoadResults.size === values.length, `${this.constructor.name} loadMany should return a result for each value`);
-        const valuesToFetchFromDB = Array.from((0, maps_1.filterMap)(cacheLoadResults, (cacheLoadResult) => cacheLoadResult.status === CacheStatus.MISS).keys());
+        invariant(cacheLoadResults.size === values.length, `${this.constructor.name} loadMany should return a result for each value`);
+        const valuesToFetchFromDB = Array.from(filterMap(cacheLoadResults, (cacheLoadResult) => cacheLoadResult.status === CacheStatus.MISS).keys());
         // put transformed cache hits in result map
         const results = key.vendNewLoadValueMap();
         cacheLoadResults.forEach((cacheLoadResult, value) => {
@@ -105,5 +99,3 @@ class ReadThroughEntityCache {
         await this.entityCacheAdapter.invalidateManyAsync(key, values);
     }
 }
-exports.ReadThroughEntityCache = ReadThroughEntityCache;
-//# sourceMappingURL=ReadThroughEntityCache.js.map

package/build/src/internal/SingleFieldHolder.d.ts

@@ -1,5 +1,6 @@
-import { EntityConfiguration } from '../EntityConfiguration';
-import { EntityLoadMethodType, IEntityLoadKey, IEntityLoadValue, LoadValueMap } from './EntityLoadInterfaces';
+import type { EntityConfiguration } from '../EntityConfiguration.ts';
+import type { IEntityLoadKey, IEntityLoadValue } from './EntityLoadInterfaces.ts';
+import { EntityLoadMethodType, LoadValueMap } from './EntityLoadInterfaces.ts';
 /**
  * A load key that represents a single field (fieldName) on an entity.
  *

package/build/src/internal/SingleFieldHolder.js

@@ -1,18 +1,12 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SingleFieldValueHolderMap = exports.SingleFieldValueHolder = exports.SingleFieldHolder = void 0;
-const invariant_1 = __importDefault(require("invariant"));
-const EntityFieldTransformationUtils_1 = require("./EntityFieldTransformationUtils");
-const EntityLoadInterfaces_1 = require("./EntityLoadInterfaces");
+import invariant from 'invariant';
+import { getDatabaseFieldForEntityField } from "./EntityFieldTransformationUtils.js";
+import { EntityLoadMethodType, LoadValueMap } from "./EntityLoadInterfaces.js";
 /**
  * A load key that represents a single field (fieldName) on an entity.
  *
  * @internal
  */
-class SingleFieldHolder {
+export class SingleFieldHolder {
     fieldName;
     constructor(fieldName) {
         this.fieldName = fieldName;
@@ -24,7 +18,7 @@ class SingleFieldHolder {
         return entityConfiguration.cacheableKeys.has(this.fieldName);
     }
     getDatabaseColumns(entityConfiguration) {
-        return [(0, EntityFieldTransformationUtils_1.getDatabaseFieldForEntityField)(entityConfiguration, this.fieldName)];
+        return [getDatabaseFieldForEntityField(entityConfiguration, this.fieldName)];
     }
     getDatabaseValues(value) {
         return [value.fieldValue];
@@ -38,11 +32,11 @@ class SingleFieldHolder {
     }
     createCacheKeyPartsForLoadValue(entityConfiguration, value) {
         const columnName = entityConfiguration.entityToDBFieldsKeyMapping.get(this.fieldName);
-        (0, invariant_1.default)(columnName, `database field mapping missing for ${String(this.fieldName)}`);
+        invariant(columnName, `database field mapping missing for ${String(this.fieldName)}`);
         return [columnName, String(value.fieldValue)];
     }
     getLoadMethodType() {
-        return EntityLoadInterfaces_1.EntityLoadMethodType.SINGLE;
+        return EntityLoadMethodType.SINGLE;
     }
     getDataManagerDataLoaderKey() {
         return this.fieldName;
@@ -63,13 +57,12 @@ class SingleFieldHolder {
         return new SingleFieldValueHolderMap();
     }
 }
-exports.SingleFieldHolder = SingleFieldHolder;
 /**
  * A load value for a SingleFieldHolder.
  *
  * @internal
  */
-class SingleFieldValueHolder {
+export class SingleFieldValueHolder {
     fieldValue;
     constructor(fieldValue) {
         this.fieldValue = fieldValue;
@@ -84,14 +77,11 @@ class SingleFieldValueHolder {
         return new SingleFieldValueHolder(fieldValue);
     }
 }
-exports.SingleFieldValueHolder = SingleFieldValueHolder;
 /**
  * @internal
  */
-class SingleFieldValueHolderMap extends EntityLoadInterfaces_1.LoadValueMap {
+export class SingleFieldValueHolderMap extends LoadValueMap {
     deserializeKey(serializedKey) {
         return SingleFieldValueHolder.deserialize(serializedKey);
     }
 }
-exports.SingleFieldValueHolderMap = SingleFieldValueHolderMap;
-//# sourceMappingURL=SingleFieldHolder.js.map

package/build/src/metrics/EntityMetricsUtils.d.ts

@@ -1,6 +1,6 @@
-import { EntityQueryContext } from '../EntityQueryContext';
-import { EntityMetricsLoadType, EntityMetricsMutationType, IEntityMetricsAdapter } from './IEntityMetricsAdapter';
-import { IEntityLoadValue } from '../internal/EntityLoadInterfaces';
+import type { EntityQueryContext } from '../EntityQueryContext.ts';
+import type { EntityMetricsLoadType, EntityMetricsMutationType, IEntityMetricsAdapter } from './IEntityMetricsAdapter.ts';
+import type { IEntityLoadValue } from '../internal/EntityLoadInterfaces.ts';
 export declare const timeAndLogLoadEventAsync: (metricsAdapter: IEntityMetricsAdapter, loadType: EntityMetricsLoadType, entityClassName: string, queryContext: EntityQueryContext) => <TFields>(promise: Promise<readonly Readonly<TFields>[]>) => Promise<readonly Readonly<TFields>[]>;
 export declare const timeAndLogLoadOneEventAsync: (metricsAdapter: IEntityMetricsAdapter, loadType: EntityMetricsLoadType, entityClassName: string, queryContext: EntityQueryContext) => <TFields>(promise: Promise<Readonly<TFields> | null>) => Promise<Readonly<TFields> | null>;
 export declare const timeAndLogLoadMapEventAsync: (metricsAdapter: IEntityMetricsAdapter, loadType: EntityMetricsLoadType, entityClassName: string, queryContext: EntityQueryContext) => <TFields extends Record<string, any>, TSerializedLoadValue, TLoadValue extends IEntityLoadValue<TSerializedLoadValue>>(promise: Promise<ReadonlyMap<TLoadValue, readonly Readonly<TFields>[]>>) => Promise<ReadonlyMap<TLoadValue, readonly Readonly<TFields>[]>>;

package/build/src/metrics/EntityMetricsUtils.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.timeAndLogMutationEventAsync = exports.timeAndLogLoadMapEventAsync = exports.timeAndLogLoadOneEventAsync = exports.timeAndLogLoadEventAsync = void 0;
-const maps_1 = require("../utils/collections/maps");
-const timeAndLogLoadEventAsync = (metricsAdapter, loadType, entityClassName, queryContext) => async (promise) => {
+import { reduceMap } from "../utils/collections/maps.js";
+export const timeAndLogLoadEventAsync = (metricsAdapter, loadType, entityClassName, queryContext) => async (promise) => {
     const startTime = Date.now();
     const result = await promise;
     const endTime = Date.now();
@@ -15,8 +12,7 @@ const timeAndLogLoadEventAsync = (metricsAdapter, loadType, entityClassName, que
     });
     return result;
 };
-exports.timeAndLogLoadEventAsync = timeAndLogLoadEventAsync;
-const timeAndLogLoadOneEventAsync = (metricsAdapter, loadType, entityClassName, queryContext) => async (promise) => {
+export const timeAndLogLoadOneEventAsync = (metricsAdapter, loadType, entityClassName, queryContext) => async (promise) => {
     const startTime = Date.now();
     const result = await promise;
     const endTime = Date.now();
@@ -29,12 +25,11 @@ const timeAndLogLoadOneEventAsync = (metricsAdapter, loadType, entityClassName,
     });
     return result;
 };
-exports.timeAndLogLoadOneEventAsync = timeAndLogLoadOneEventAsync;
-const timeAndLogLoadMapEventAsync = (metricsAdapter, loadType, entityClassName, queryContext) => async (promise) => {
+export const timeAndLogLoadMapEventAsync = (metricsAdapter, loadType, entityClassName, queryContext) => async (promise) => {
     const startTime = Date.now();
     const result = await promise;
     const endTime = Date.now();
-    const count = (0, maps_1.reduceMap)(result, (acc, v) => acc + v.length, 0);
+    const count = reduceMap(result, (acc, v) => acc + v.length, 0);
     metricsAdapter.logDataManagerLoadEvent({
         type: loadType,
         isInTransaction: queryContext.isInTransaction(),
@@ -44,8 +39,7 @@ const timeAndLogLoadMapEventAsync = (metricsAdapter, loadType, entityClassName,
     });
     return result;
 };
-exports.timeAndLogLoadMapEventAsync = timeAndLogLoadMapEventAsync;
-const timeAndLogMutationEventAsync = (metricsAdapter, mutationType, entityClassName, queryContext) => async (promise) => {
+export const timeAndLogMutationEventAsync = (metricsAdapter, mutationType, entityClassName, queryContext) => async (promise) => {
     const startTime = Date.now();
     const result = await promise;
     const endTime = Date.now();
@@ -57,5 +51,3 @@ const timeAndLogMutationEventAsync = (metricsAdapter, mutationType, entityClassN
     });
     return result;
 };
-exports.timeAndLogMutationEventAsync = timeAndLogMutationEventAsync;
-//# sourceMappingURL=EntityMetricsUtils.js.map

package/build/src/metrics/IEntityMetricsAdapter.d.ts

@@ -1,5 +1,5 @@
-import { EntityAuthorizationAction, EntityPrivacyPolicyEvaluationMode } from '../EntityPrivacyPolicy';
-import { EntityLoadMethodType } from '../internal/EntityLoadInterfaces';
+import type { EntityAuthorizationAction, EntityPrivacyPolicyEvaluationMode } from '../EntityPrivacyPolicy.ts';
+import type { EntityLoadMethodType } from '../internal/EntityLoadInterfaces.ts';
 export declare enum EntityMetricsLoadType {
     LOAD_MANY = 0,
     LOAD_MANY_EQUALITY_CONJUNCTION = 1,

package/build/src/metrics/IEntityMetricsAdapter.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityMetricsAuthorizationResult = exports.IncrementLoadCountEventType = exports.EntityMetricsMutationType = exports.EntityMetricsLoadType = void 0;
-var EntityMetricsLoadType;
+export var EntityMetricsLoadType;
 (function (EntityMetricsLoadType) {
     EntityMetricsLoadType[EntityMetricsLoadType["LOAD_MANY"] = 0] = "LOAD_MANY";
     EntityMetricsLoadType[EntityMetricsLoadType["LOAD_MANY_EQUALITY_CONJUNCTION"] = 1] = "LOAD_MANY_EQUALITY_CONJUNCTION";
@@ -9,14 +6,14 @@ var EntityMetricsLoadType;
     EntityMetricsLoadType[EntityMetricsLoadType["LOAD_MANY_SQL"] = 3] = "LOAD_MANY_SQL";
     EntityMetricsLoadType[EntityMetricsLoadType["LOAD_ONE"] = 4] = "LOAD_ONE";
     EntityMetricsLoadType[EntityMetricsLoadType["LOAD_PAGE"] = 5] = "LOAD_PAGE";
-})(EntityMetricsLoadType || (exports.EntityMetricsLoadType = EntityMetricsLoadType = {}));
-var EntityMetricsMutationType;
+})(EntityMetricsLoadType || (EntityMetricsLoadType = {}));
+export var EntityMetricsMutationType;
 (function (EntityMetricsMutationType) {
     EntityMetricsMutationType[EntityMetricsMutationType["CREATE"] = 0] = "CREATE";
     EntityMetricsMutationType[EntityMetricsMutationType["UPDATE"] = 1] = "UPDATE";
     EntityMetricsMutationType[EntityMetricsMutationType["DELETE"] = 2] = "DELETE";
-})(EntityMetricsMutationType || (exports.EntityMetricsMutationType = EntityMetricsMutationType = {}));
-var IncrementLoadCountEventType;
+})(EntityMetricsMutationType || (EntityMetricsMutationType = {}));
+export var IncrementLoadCountEventType;
 (function (IncrementLoadCountEventType) {
     /**
      * Type for when a dataloader load is initiated via the standard load methods
@@ -31,10 +28,9 @@ var IncrementLoadCountEventType;
      * Type for when a database load is initiated due to a dataloader and cache miss, when an entity query doesn't support caching, or during a transaction.
      */
     IncrementLoadCountEventType[IncrementLoadCountEventType["DATABASE"] = 2] = "DATABASE";
-})(IncrementLoadCountEventType || (exports.IncrementLoadCountEventType = IncrementLoadCountEventType = {}));
-var EntityMetricsAuthorizationResult;
+})(IncrementLoadCountEventType || (IncrementLoadCountEventType = {}));
+export var EntityMetricsAuthorizationResult;
 (function (EntityMetricsAuthorizationResult) {
     EntityMetricsAuthorizationResult[EntityMetricsAuthorizationResult["DENY"] = 0] = "DENY";
     EntityMetricsAuthorizationResult[EntityMetricsAuthorizationResult["ALLOW"] = 1] = "ALLOW";
-})(EntityMetricsAuthorizationResult || (exports.EntityMetricsAuthorizationResult = EntityMetricsAuthorizationResult = {}));
-//# sourceMappingURL=IEntityMetricsAdapter.js.map
+})(EntityMetricsAuthorizationResult || (EntityMetricsAuthorizationResult = {}));