@expo/entity 0.60.0 → 0.62.0

package/build/src/index.js

@@ -1,99 +1,82 @@
-"use strict";
 /* eslint-disable tsdoc/syntax */
 /**
  * @packageDocumentation
  * @module @expo/entity
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./AuthorizationResultBasedEntityAssociationLoader"), exports);
-__exportStar(require("./AuthorizationResultBasedEntityLoader"), exports);
-__exportStar(require("./AuthorizationResultBasedEntityMutator"), exports);
-__exportStar(require("./ComposedEntityCacheAdapter"), exports);
-__exportStar(require("./ComposedSecondaryEntityCache"), exports);
-__exportStar(require("./EnforcingEntityAssociationLoader"), exports);
-__exportStar(require("./EnforcingEntityCreator"), exports);
-__exportStar(require("./EnforcingEntityDeleter"), exports);
-__exportStar(require("./EnforcingEntityLoader"), exports);
-__exportStar(require("./EnforcingEntityUpdater"), exports);
-__exportStar(require("./Entity"), exports);
-__exportStar(require("./EntityAssociationLoader"), exports);
-__exportStar(require("./EntityCompanion"), exports);
-__exportStar(require("./EntityCompanionProvider"), exports);
-__exportStar(require("./EntityConfiguration"), exports);
-__exportStar(require("./EntityConstructionUtils"), exports);
-__exportStar(require("./EntityCreator"), exports);
-__exportStar(require("./EntityDatabaseAdapter"), exports);
-__exportStar(require("./EntityDeleter"), exports);
-__exportStar(require("./EntityFieldDefinition"), exports);
-__exportStar(require("./EntityFields"), exports);
-__exportStar(require("./EntityInvalidationUtils"), exports);
-__exportStar(require("./EntityLoader"), exports);
-__exportStar(require("./EntityLoaderFactory"), exports);
-__exportStar(require("./EntityMutationInfo"), exports);
-__exportStar(require("./EntityMutationTriggerConfiguration"), exports);
-__exportStar(require("./EntityMutationValidatorConfiguration"), exports);
-__exportStar(require("./EntityMutatorFactory"), exports);
-__exportStar(require("./EntityPrivacyPolicy"), exports);
-__exportStar(require("./EntityQueryContext"), exports);
-__exportStar(require("./EntityQueryContextProvider"), exports);
-__exportStar(require("./EntitySecondaryCacheLoader"), exports);
-__exportStar(require("./EntityUpdater"), exports);
-__exportStar(require("./entityUtils"), exports);
-__exportStar(require("./GenericEntityCacheAdapter"), exports);
-__exportStar(require("./GenericSecondaryEntityCache"), exports);
-__exportStar(require("./IEntityCacheAdapter"), exports);
-__exportStar(require("./IEntityCacheAdapterProvider"), exports);
-__exportStar(require("./IEntityDatabaseAdapterProvider"), exports);
-__exportStar(require("./IEntityGenericCacher"), exports);
-__exportStar(require("./ReadonlyEntity"), exports);
-__exportStar(require("./ViewerContext"), exports);
-__exportStar(require("./ViewerScopedEntityCompanion"), exports);
-__exportStar(require("./ViewerScopedEntityCompanionProvider"), exports);
-__exportStar(require("./ViewerScopedEntityLoaderFactory"), exports);
-__exportStar(require("./ViewerScopedEntityMutatorFactory"), exports);
-__exportStar(require("./errors/EntityCacheAdapterError"), exports);
-__exportStar(require("./errors/EntityDatabaseAdapterError"), exports);
-__exportStar(require("./errors/EntityError"), exports);
-__exportStar(require("./errors/EntityInvalidFieldValueError"), exports);
-__exportStar(require("./errors/EntityNotAuthorizedError"), exports);
-__exportStar(require("./errors/EntityNotFoundError"), exports);
-__exportStar(require("./internal/CompositeFieldHolder"), exports);
-__exportStar(require("./internal/CompositeFieldValueMap"), exports);
-__exportStar(require("./internal/EntityDataManager"), exports);
-__exportStar(require("./internal/EntityFieldTransformationUtils"), exports);
-__exportStar(require("./internal/EntityLoadInterfaces"), exports);
-__exportStar(require("./internal/EntityTableDataCoordinator"), exports);
-__exportStar(require("./internal/ReadThroughEntityCache"), exports);
-__exportStar(require("./internal/SingleFieldHolder"), exports);
-__exportStar(require("./metrics/EntityMetricsUtils"), exports);
-__exportStar(require("./metrics/IEntityMetricsAdapter"), exports);
-__exportStar(require("./metrics/NoOpEntityMetricsAdapter"), exports);
-__exportStar(require("./rules/AllowIfAllSubRulesAllowPrivacyPolicyRule"), exports);
-__exportStar(require("./rules/AllowIfAnySubRuleAllowsPrivacyPolicyRule"), exports);
-__exportStar(require("./rules/AllowIfInParentCascadeDeletionPrivacyPolicyRule"), exports);
-__exportStar(require("./rules/AlwaysAllowPrivacyPolicyRule"), exports);
-__exportStar(require("./rules/AlwaysDenyPrivacyPolicyRule"), exports);
-__exportStar(require("./rules/AlwaysSkipPrivacyPolicyRule"), exports);
-__exportStar(require("./rules/EvaluateIfEntityFieldPredicatePrivacyPolicyRule"), exports);
-__exportStar(require("./rules/PrivacyPolicyRule"), exports);
-__exportStar(require("./utils/EntityCreationUtils"), exports);
-__exportStar(require("./utils/EntityPrivacyUtils"), exports);
-__exportStar(require("./utils/mergeEntityMutationTriggerConfigurations"), exports);
-__exportStar(require("./utils/collections/maps"), exports);
-__exportStar(require("./utils/collections/SerializableKeyMap"), exports);
-__exportStar(require("./utils/collections/sets"), exports);
-//# sourceMappingURL=index.js.map
+export * from "./AuthorizationResultBasedEntityAssociationLoader.js";
+export * from "./AuthorizationResultBasedEntityLoader.js";
+export * from "./AuthorizationResultBasedEntityMutator.js";
+export * from "./ComposedEntityCacheAdapter.js";
+export * from "./ComposedSecondaryEntityCache.js";
+export * from "./EnforcingEntityAssociationLoader.js";
+export * from "./EnforcingEntityCreator.js";
+export * from "./EnforcingEntityDeleter.js";
+export * from "./EnforcingEntityLoader.js";
+export * from "./EnforcingEntityUpdater.js";
+export * from "./Entity.js";
+export * from "./EntityAssociationLoader.js";
+export * from "./EntityCompanion.js";
+export * from "./EntityCompanionProvider.js";
+export * from "./EntityConfiguration.js";
+export * from "./EntityConstructionUtils.js";
+export * from "./EntityCreator.js";
+export * from "./EntityDatabaseAdapter.js";
+export * from "./EntityDeleter.js";
+export * from "./EntityFieldDefinition.js";
+export * from "./EntityFields.js";
+export * from "./EntityInvalidationUtils.js";
+export * from "./EntityLoader.js";
+export * from "./EntityLoaderFactory.js";
+export * from "./EntityMutationInfo.js";
+export * from "./EntityMutationTriggerConfiguration.js";
+export * from "./EntityMutationValidatorConfiguration.js";
+export * from "./EntityMutatorFactory.js";
+export * from "./EntityPrivacyPolicy.js";
+export * from "./EntityQueryContext.js";
+export * from "./EntityQueryContextProvider.js";
+export * from "./EntitySecondaryCacheLoader.js";
+export * from "./EntityUpdater.js";
+export * from "./entityUtils.js";
+export * from "./GenericEntityCacheAdapter.js";
+export * from "./GenericSecondaryEntityCache.js";
+export * from "./IEntityCacheAdapter.js";
+export * from "./IEntityCacheAdapterProvider.js";
+export * from "./IEntityDatabaseAdapterProvider.js";
+export * from "./IEntityGenericCacher.js";
+export * from "./ReadonlyEntity.js";
+export * from "./ViewerContext.js";
+export * from "./ViewerScopedEntityCompanion.js";
+export * from "./ViewerScopedEntityCompanionProvider.js";
+export * from "./ViewerScopedEntityLoaderFactory.js";
+export * from "./ViewerScopedEntityMutatorFactory.js";
+export * from "./errors/EntityCacheAdapterError.js";
+export * from "./errors/EntityDatabaseAdapterError.js";
+export * from "./errors/EntityError.js";
+export * from "./errors/EntityInvalidFieldValueError.js";
+export * from "./errors/EntityNotAuthorizedError.js";
+export * from "./errors/EntityNotFoundError.js";
+export * from "./internal/CompositeFieldHolder.js";
+export * from "./internal/CompositeFieldValueMap.js";
+export * from "./internal/EntityDataManager.js";
+export * from "./internal/EntityFieldTransformationUtils.js";
+export * from "./internal/EntityLoadInterfaces.js";
+export * from "./internal/EntityTableDataCoordinator.js";
+export * from "./internal/ReadThroughEntityCache.js";
+export * from "./internal/SingleFieldHolder.js";
+export * from "./metrics/EntityMetricsUtils.js";
+export * from "./metrics/IEntityMetricsAdapter.js";
+export * from "./metrics/NoOpEntityMetricsAdapter.js";
+export * from "./rules/AllowIfAllSubRulesAllowPrivacyPolicyRule.js";
+export * from "./rules/AllowIfAnySubRuleAllowsPrivacyPolicyRule.js";
+export * from "./rules/AllowIfInParentCascadeDeletionPrivacyPolicyRule.js";
+export * from "./rules/AlwaysAllowPrivacyPolicyRule.js";
+export * from "./rules/AlwaysDenyPrivacyPolicyRule.js";
+export * from "./rules/AlwaysSkipPrivacyPolicyRule.js";
+export * from "./rules/EvaluateIfEntityFieldPredicatePrivacyPolicyRule.js";
+export * from "./rules/PrivacyPolicyRule.js";
+export * from "./utils/EntityCreationUtils.js";
+export * from "./utils/EntityPrivacyUtils.js";
+export * from "./utils/mergeEntityMutationTriggerConfigurations.js";
+export * from "./utils/collections/maps.js";
+export * from "./utils/collections/SerializableKeyMap.js";
+export * from "./utils/collections/sets.js";

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

@@ -1,5 +1,6 @@
-import { EntityCompositeField, EntityCompositeFieldValue, EntityConfiguration } from '../EntityConfiguration';
-import { EntityLoadMethodType, IEntityLoadKey, IEntityLoadValue, LoadValueMap } from '../internal/EntityLoadInterfaces';
+import type { EntityCompositeField, EntityCompositeFieldValue, EntityConfiguration } from '../EntityConfiguration.ts';
+import type { IEntityLoadKey, IEntityLoadValue } from '../internal/EntityLoadInterfaces.ts';
+import { EntityLoadMethodType, LoadValueMap } from '../internal/EntityLoadInterfaces.ts';
 declare const CompositeFieldHolderSerializedBrand: unique symbol;
 /**
  * @internal

package/build/src/internal/CompositeFieldHolder.js

@@ -1,20 +1,14 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompositeFieldValueHolderMap = exports.CompositeFieldValueHolder = exports.CompositeFieldHolder = void 0;
-const invariant_1 = __importDefault(require("invariant"));
-const entityUtils_1 = require("../entityUtils");
-const EntityFieldTransformationUtils_1 = require("./EntityFieldTransformationUtils");
-const EntityLoadInterfaces_1 = require("../internal/EntityLoadInterfaces");
+import invariant from 'invariant';
+import { pick } from "../entityUtils.js";
+import { getDatabaseFieldForEntityField } from "./EntityFieldTransformationUtils.js";
+import { EntityLoadMethodType, LoadValueMap } from "../internal/EntityLoadInterfaces.js";
 /**
  * A load key that represents a composite field (set of fieldName) on an entity.
  * Must be defined in the entity configuration composite field definition.
  *
  * @internal
  */
-class CompositeFieldHolder {
+export class CompositeFieldHolder {
     compositeField;
     constructor(compositeFieldInput) {
         this.compositeField = [...compositeFieldInput].sort();
@@ -26,7 +20,7 @@ class CompositeFieldHolder {
         return new Set(this.compositeField);
     }
     extractCompositeFieldValueHolderFromObjectFields(objectFields) {
-        const selection = (0, entityUtils_1.pick)(objectFields, this.compositeField);
+        const selection = pick(objectFields, this.compositeField);
         if (Object.values(selection).some((value) => value === undefined || value === null)) {
             return null;
         }
@@ -39,7 +33,7 @@ class CompositeFieldHolder {
         return entityConfiguration.compositeFieldInfo.canCacheCompositeField(this.compositeField);
     }
     getDatabaseColumns(entityConfiguration) {
-        return this.compositeField.map((fieldName) => (0, EntityFieldTransformationUtils_1.getDatabaseFieldForEntityField)(entityConfiguration, fieldName));
+        return this.compositeField.map((fieldName) => getDatabaseFieldForEntityField(entityConfiguration, fieldName));
     }
     getDatabaseValues(value) {
         return this.compositeField.map((fieldName) => value.compositeFieldValue[fieldName]);
@@ -50,14 +44,14 @@ class CompositeFieldHolder {
     createCacheKeyPartsForLoadValue(entityConfiguration, value) {
         const columnNames = this.compositeField.map((fieldName) => {
             const columnName = entityConfiguration.entityToDBFieldsKeyMapping.get(fieldName);
-            (0, invariant_1.default)(columnName, `database field mapping missing for ${String(fieldName)}`);
+            invariant(columnName, `database field mapping missing for ${String(fieldName)}`);
             return columnName;
         });
         const compositeFieldValues = this.compositeField.map((fieldName) => value.compositeFieldValue[fieldName]);
         return [...columnNames, ...compositeFieldValues.map((value) => String(value))];
     }
     getLoadMethodType() {
-        return EntityLoadInterfaces_1.EntityLoadMethodType.COMPOSITE;
+        return EntityLoadMethodType.COMPOSITE;
     }
     getDataManagerDataLoaderKey() {
         return this.serialize();
@@ -79,13 +73,12 @@ class CompositeFieldHolder {
         return new CompositeFieldValueHolderMap();
     }
 }
-exports.CompositeFieldHolder = CompositeFieldHolder;
 /**
  * A load value for a CompositeFieldHolder.
  *
  * @internal
  */
-class CompositeFieldValueHolder {
+export class CompositeFieldValueHolder {
     compositeFieldValue;
     constructor(compositeFieldValue) {
         this.compositeFieldValue = compositeFieldValue;
@@ -110,14 +103,11 @@ class CompositeFieldValueHolder {
         return JSON.stringify(this.compositeFieldValue, Object.keys(this.compositeFieldValue).sort());
     }
 }
-exports.CompositeFieldValueHolder = CompositeFieldValueHolder;
 /**
  * @internal
  */
-class CompositeFieldValueHolderMap extends EntityLoadInterfaces_1.LoadValueMap {
+export class CompositeFieldValueHolderMap extends LoadValueMap {
     deserializeKey(serializedKey) {
         return CompositeFieldValueHolder.deserialize(serializedKey);
     }
 }
-exports.CompositeFieldValueHolderMap = CompositeFieldValueHolderMap;
-//# sourceMappingURL=CompositeFieldHolder.js.map

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

@@ -1,5 +1,5 @@
-import { EntityCompositeField, EntityCompositeFieldValue } from '../EntityConfiguration';
-import { CompositeFieldValueHolder } from './CompositeFieldHolder';
+import type { EntityCompositeField, EntityCompositeFieldValue } from '../EntityConfiguration.ts';
+import { CompositeFieldValueHolder } from './CompositeFieldHolder.ts';
 /**
  * @internal
  */

package/build/src/internal/CompositeFieldValueMap.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompositeFieldValueMap = void 0;
-const CompositeFieldHolder_1 = require("./CompositeFieldHolder");
+import { CompositeFieldValueHolder } from "./CompositeFieldHolder.js";
 /**
  * @internal
  */
-class CompositeFieldValueMap {
+export class CompositeFieldValueMap {
     map;
     constructor(entries) {
         const map = new Map();
@@ -15,14 +12,14 @@ class CompositeFieldValueMap {
         this.map = map;
     }
     get(compositeFieldValue) {
-        return this.map.get(new CompositeFieldHolder_1.CompositeFieldValueHolder(compositeFieldValue).serialize());
+        return this.map.get(new CompositeFieldValueHolder(compositeFieldValue).serialize());
     }
     has(compositeFieldValue) {
-        return this.map.has(new CompositeFieldHolder_1.CompositeFieldValueHolder(compositeFieldValue).serialize());
+        return this.map.has(new CompositeFieldValueHolder(compositeFieldValue).serialize());
     }
     forEach(callbackfn, thisArg) {
         this.map.forEach((value, key) => {
-            callbackfn.call(thisArg, value, CompositeFieldHolder_1.CompositeFieldValueHolder.deserialize(key).compositeFieldValue, this);
+            callbackfn.call(thisArg, value, CompositeFieldValueHolder.deserialize(key).compositeFieldValue, this);
         });
     }
     get size() {
@@ -30,12 +27,12 @@ class CompositeFieldValueMap {
     }
     *entries() {
         for (const [key, value] of this.map.entries()) {
-            yield [CompositeFieldHolder_1.CompositeFieldValueHolder.deserialize(key).compositeFieldValue, value];
+            yield [CompositeFieldValueHolder.deserialize(key).compositeFieldValue, value];
         }
     }
     *keys() {
         for (const key of this.map.keys()) {
-            yield CompositeFieldHolder_1.CompositeFieldValueHolder.deserialize(key).compositeFieldValue;
+            yield CompositeFieldValueHolder.deserialize(key).compositeFieldValue;
         }
     }
     *values() {
@@ -50,5 +47,3 @@ class CompositeFieldValueMap {
         return 'CompositeFieldValueMap';
     }
 }
-exports.CompositeFieldValueMap = CompositeFieldValueMap;
-//# sourceMappingURL=CompositeFieldValueMap.js.map

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.
  *