@expo/entity 0.60.0 → 0.62.0

package/build/src/rules/EvaluateIfEntityFieldPredicatePrivacyPolicyRule.d.ts

@@ -1,8 +1,8 @@
-import { EntityPrivacyPolicyRuleEvaluationContext } from '../EntityPrivacyPolicy';
-import { EntityQueryContext } from '../EntityQueryContext';
-import { ReadonlyEntity } from '../ReadonlyEntity';
-import { ViewerContext } from '../ViewerContext';
-import { PrivacyPolicyRule, RuleEvaluationResult } from './PrivacyPolicyRule';
+import type { EntityPrivacyPolicyRuleEvaluationContext } from '../EntityPrivacyPolicy.ts';
+import type { EntityQueryContext } from '../EntityQueryContext.ts';
+import type { ReadonlyEntity } from '../ReadonlyEntity.ts';
+import type { ViewerContext } from '../ViewerContext.ts';
+import { PrivacyPolicyRule, RuleEvaluationResult } from './PrivacyPolicyRule.ts';
 export declare class EvaluateIfEntityFieldPredicatePrivacyPolicyRule<TFields extends object, TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>, TViewerContext extends ViewerContext, TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>, N extends TSelectedFields, TSelectedFields extends keyof TFields = keyof TFields> extends PrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields> {
     private readonly fieldName;
     private readonly shouldEvaluatePredicate;

package/build/src/rules/EvaluateIfEntityFieldPredicatePrivacyPolicyRule.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EvaluateIfEntityFieldPredicatePrivacyPolicyRule = void 0;
-const PrivacyPolicyRule_1 = require("./PrivacyPolicyRule");
-class EvaluateIfEntityFieldPredicatePrivacyPolicyRule extends PrivacyPolicyRule_1.PrivacyPolicyRule {
+import { PrivacyPolicyRule, RuleEvaluationResult } from "./PrivacyPolicyRule.js";
+export class EvaluateIfEntityFieldPredicatePrivacyPolicyRule extends PrivacyPolicyRule {
     fieldName;
     shouldEvaluatePredicate;
     rule;
@@ -16,8 +13,6 @@ class EvaluateIfEntityFieldPredicatePrivacyPolicyRule extends PrivacyPolicyRule_
         const fieldValue = entity.getField(this.fieldName);
         return this.shouldEvaluatePredicate(fieldValue)
             ? await this.rule.evaluateAsync(viewerContext, queryContext, evaluationContext, entity)
-            : PrivacyPolicyRule_1.RuleEvaluationResult.SKIP;
+            : RuleEvaluationResult.SKIP;
     }
 }
-exports.EvaluateIfEntityFieldPredicatePrivacyPolicyRule = EvaluateIfEntityFieldPredicatePrivacyPolicyRule;
-//# sourceMappingURL=EvaluateIfEntityFieldPredicatePrivacyPolicyRule.js.map

package/build/src/rules/PrivacyPolicyRule.d.ts

@@ -1,7 +1,7 @@
-import { EntityPrivacyPolicyRuleEvaluationContext } from '../EntityPrivacyPolicy';
-import { EntityQueryContext } from '../EntityQueryContext';
-import { ReadonlyEntity } from '../ReadonlyEntity';
-import { ViewerContext } from '../ViewerContext';
+import type { EntityPrivacyPolicyRuleEvaluationContext } from '../EntityPrivacyPolicy.ts';
+import type { EntityQueryContext } from '../EntityQueryContext.ts';
+import type { ReadonlyEntity } from '../ReadonlyEntity.ts';
+import type { ViewerContext } from '../ViewerContext.ts';
 export declare enum RuleEvaluationResult {
     /**
      * Deny viewer access to the entity.

package/build/src/rules/PrivacyPolicyRule.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrivacyPolicyRule = exports.RuleEvaluationResult = void 0;
-var RuleEvaluationResult;
+export var RuleEvaluationResult;
 (function (RuleEvaluationResult) {
     /**
      * Deny viewer access to the entity.
@@ -15,7 +12,7 @@ var RuleEvaluationResult;
      * Allow viewer access to the entity.
      */
     RuleEvaluationResult[RuleEvaluationResult["ALLOW"] = 1] = "ALLOW";
-})(RuleEvaluationResult || (exports.RuleEvaluationResult = RuleEvaluationResult = {}));
+})(RuleEvaluationResult || (RuleEvaluationResult = {}));
 /**
  * A single unit of which declarative privacy policies are composed, allowing for simple
  * expression and testing of authorization logic.
@@ -32,7 +29,5 @@ var RuleEvaluationResult;
  * - Blocking. For example, a user blocks another user from seeing their posts, and the rule
  *   would be named something like `DenyIfViewerHasBeenBlockedPrivacyPolicyRule`.
  */
-class PrivacyPolicyRule {
+export class PrivacyPolicyRule {
 }
-exports.PrivacyPolicyRule = PrivacyPolicyRule;
-//# sourceMappingURL=PrivacyPolicyRule.js.map

package/build/src/utils/EntityCreationUtils.d.ts

@@ -1,8 +1,8 @@
-import { IEntityClass } from '../Entity';
-import { EntityPrivacyPolicy } from '../EntityPrivacyPolicy';
-import { EntityTransactionalQueryContext } from '../EntityQueryContext';
-import { ReadonlyEntity } from '../ReadonlyEntity';
-import { ViewerContext } from '../ViewerContext';
+import type { IEntityClass } from '../Entity.ts';
+import type { EntityPrivacyPolicy } from '../EntityPrivacyPolicy.ts';
+import type { EntityTransactionalQueryContext } from '../EntityQueryContext.ts';
+import type { ReadonlyEntity } from '../ReadonlyEntity.ts';
+import type { ViewerContext } from '../ViewerContext.ts';
 /**
  * Create an entity if it doesn't exist, or get the existing entity if it does.
  */

package/build/src/utils/EntityCreationUtils.js

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createOrGetExistingAsync = createOrGetExistingAsync;
-exports.createWithUniqueConstraintRecoveryAsync = createWithUniqueConstraintRecoveryAsync;
-const EntityDatabaseAdapterError_1 = require("../errors/EntityDatabaseAdapterError");
-const EntityNotFoundError_1 = require("../errors/EntityNotFoundError");
+import { EntityDatabaseAdapterUniqueConstraintError } from "../errors/EntityDatabaseAdapterError.js";
+import { EntityNotFoundError } from "../errors/EntityNotFoundError.js";
 /**
  * Create an entity if it doesn't exist, or get the existing entity if it does.
  */
-async function createOrGetExistingAsync(viewerContext, entityClass, getAsync, getArgs, createAsync, createArgs, queryContext) {
+export async function createOrGetExistingAsync(viewerContext, entityClass, getAsync, getArgs, createAsync, createArgs, queryContext) {
     if (!queryContext) {
         const maybeEntity = await getAsync(viewerContext, getArgs);
         if (maybeEntity) {
@@ -31,7 +27,7 @@ async function createOrGetExistingAsync(viewerContext, entityClass, getAsync, ge
  * Account for concurrent requests that may try to create the same entity.
  * Return the existing entity if we get a Unique Constraint error.
  */
-async function createWithUniqueConstraintRecoveryAsync(viewerContext, entityClass, getAsync, getArgs, createAsync, createArgs, queryContext) {
+export async function createWithUniqueConstraintRecoveryAsync(viewerContext, entityClass, getAsync, getArgs, createAsync, createArgs, queryContext) {
     try {
         if (!queryContext) {
             return await createAsync(viewerContext, createArgs);
@@ -39,10 +35,10 @@ async function createWithUniqueConstraintRecoveryAsync(viewerContext, entityClas
         return await queryContext.runInNestedTransactionAsync((nestedQueryContext) => createAsync(viewerContext, createArgs, nestedQueryContext));
     }
     catch (e) {
-        if (e instanceof EntityDatabaseAdapterError_1.EntityDatabaseAdapterUniqueConstraintError) {
+        if (e instanceof EntityDatabaseAdapterUniqueConstraintError) {
             const entity = await getAsync(viewerContext, getArgs, queryContext);
             if (!entity) {
-                throw new EntityNotFoundError_1.EntityNotFoundError(`Expected entity to exist after unique constraint error: ${entityClass.name}`);
+                throw new EntityNotFoundError(`Expected entity to exist after unique constraint error: ${entityClass.name}`);
             }
             return entity;
         }
@@ -51,4 +47,3 @@ async function createWithUniqueConstraintRecoveryAsync(viewerContext, entityClas
         }
     }
 }
-//# sourceMappingURL=EntityCreationUtils.js.map

package/build/src/utils/EntityPrivacyUtils.d.ts

@@ -1,8 +1,8 @@
-import { Entity, IEntityClass } from '../Entity';
-import { EntityPrivacyPolicy } from '../EntityPrivacyPolicy';
-import { EntityQueryContext } from '../EntityQueryContext';
-import { ViewerContext } from '../ViewerContext';
-import { EntityNotAuthorizedError } from '../errors/EntityNotAuthorizedError';
+import type { Entity, IEntityClass } from '../Entity.ts';
+import type { EntityPrivacyPolicy } from '../EntityPrivacyPolicy.ts';
+import type { EntityQueryContext } from '../EntityQueryContext.ts';
+import type { ViewerContext } from '../ViewerContext.ts';
+import { EntityNotAuthorizedError } from '../errors/EntityNotAuthorizedError.ts';
 export type EntityPrivacyEvaluationResultSuccess = {
     allowed: true;
 };

package/build/src/utils/EntityPrivacyUtils.js

@@ -1,13 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.canViewerUpdateAsync = canViewerUpdateAsync;
-exports.getCanViewerUpdateResultAsync = getCanViewerUpdateResultAsync;
-exports.canViewerDeleteAsync = canViewerDeleteAsync;
-exports.getCanViewerDeleteResultAsync = getCanViewerDeleteResultAsync;
-const results_1 = require("@expo/results");
-const EntityFieldDefinition_1 = require("../EntityFieldDefinition");
-const entityUtils_1 = require("../entityUtils");
-const EntityNotAuthorizedError_1 = require("../errors/EntityNotAuthorizedError");
+import { asyncResult } from '@expo/results';
+import { EntityEdgeDeletionAuthorizationInferenceBehavior, EntityEdgeDeletionBehavior, } from "../EntityFieldDefinition.js";
+import { failedResults, partitionArray } from "../entityUtils.js";
+import { EntityNotAuthorizedError } from "../errors/EntityNotAuthorizedError.js";
 /**
  * Check whether an entity loaded by a viewer can be updated by that same viewer.
  *
@@ -25,7 +19,7 @@ const EntityNotAuthorizedError_1 = require("../errors/EntityNotAuthorizedError")
  * @param sourceEntity - entity loaded by viewer
  * @param queryContext - query context in which to perform the check
  */
-async function canViewerUpdateAsync(entityClass, sourceEntity, queryContext = sourceEntity
+export async function canViewerUpdateAsync(entityClass, sourceEntity, queryContext = sourceEntity
     .getViewerContext()
     .getViewerScopedEntityCompanionForClass(entityClass)
     .getQueryContextProvider()
@@ -42,7 +36,7 @@ async function canViewerUpdateAsync(entityClass, sourceEntity, queryContext = so
  * @param sourceEntity - entity loaded by viewer
  * @param queryContext - query context in which to perform the check
  */
-async function getCanViewerUpdateResultAsync(entityClass, sourceEntity, queryContext = sourceEntity
+export async function getCanViewerUpdateResultAsync(entityClass, sourceEntity, queryContext = sourceEntity
     .getViewerContext()
     .getViewerScopedEntityCompanionForClass(entityClass)
     .getQueryContextProvider()
@@ -54,9 +48,9 @@ async function canViewerUpdateInternalAsync(entityClass, sourceEntity, evaluatio
         .getViewerContext()
         .getViewerScopedEntityCompanionForClass(entityClass);
     const privacyPolicy = companion.entityCompanion.privacyPolicy;
-    const evaluationResult = await (0, results_1.asyncResult)(privacyPolicy.authorizeUpdateAsync(sourceEntity.getViewerContext(), queryContext, evaluationContext, sourceEntity, companion.getMetricsAdapter()));
+    const evaluationResult = await asyncResult(privacyPolicy.authorizeUpdateAsync(sourceEntity.getViewerContext(), queryContext, evaluationContext, sourceEntity, companion.getMetricsAdapter()));
     if (!evaluationResult.ok) {
-        if (evaluationResult.reason instanceof EntityNotAuthorizedError_1.EntityNotAuthorizedError) {
+        if (evaluationResult.reason instanceof EntityNotAuthorizedError) {
             return { allowed: false, authorizationErrors: [evaluationResult.reason] };
         }
         else {
@@ -75,7 +69,7 @@ async function canViewerUpdateInternalAsync(entityClass, sourceEntity, evaluatio
  * @param sourceEntity - entity loaded by viewer
  * @param queryContext - query context in which to perform the check
  */
-async function canViewerDeleteAsync(entityClass, sourceEntity, queryContext = sourceEntity
+export async function canViewerDeleteAsync(entityClass, sourceEntity, queryContext = sourceEntity
     .getViewerContext()
     .getViewerScopedEntityCompanionForClass(entityClass)
     .getQueryContextProvider()
@@ -92,7 +86,7 @@ async function canViewerDeleteAsync(entityClass, sourceEntity, queryContext = so
  * @param sourceEntity - entity loaded by viewer
  * @param queryContext - query context in which to perform the check
  */
-async function getCanViewerDeleteResultAsync(entityClass, sourceEntity, queryContext = sourceEntity
+export async function getCanViewerDeleteResultAsync(entityClass, sourceEntity, queryContext = sourceEntity
     .getViewerContext()
     .getViewerScopedEntityCompanionForClass(entityClass)
     .getQueryContextProvider()
@@ -106,9 +100,9 @@ async function canViewerDeleteInternalAsync(entityClass, sourceEntity, evaluatio
         .getViewerContext()
         .getViewerScopedEntityCompanionForClass(entityClass);
     const privacyPolicy = viewerScopedCompanion.entityCompanion.privacyPolicy;
-    const evaluationResult = await (0, results_1.asyncResult)(privacyPolicy.authorizeDeleteAsync(sourceEntity.getViewerContext(), queryContext, evaluationContext, sourceEntity, viewerScopedCompanion.getMetricsAdapter()));
+    const evaluationResult = await asyncResult(privacyPolicy.authorizeDeleteAsync(sourceEntity.getViewerContext(), queryContext, evaluationContext, sourceEntity, viewerScopedCompanion.getMetricsAdapter()));
     if (!evaluationResult.ok) {
-        if (evaluationResult.reason instanceof EntityNotAuthorizedError_1.EntityNotAuthorizedError) {
+        if (evaluationResult.reason instanceof EntityNotAuthorizedError) {
             return { allowed: false, authorizationErrors: [evaluationResult.reason] };
         }
         else {
@@ -154,7 +148,7 @@ async function canViewerDeleteInternalAsync(entityClass, sourceEntity, evaluatio
             const edgeDeletionPermissionInferenceBehavior = association.edgeDeletionAuthorizationInferenceBehavior;
             let entityResultsToCheckForInboundEdge;
             if (edgeDeletionPermissionInferenceBehavior ===
-                EntityFieldDefinition_1.EntityEdgeDeletionAuthorizationInferenceBehavior.ONE_IMPLIES_ALL) {
+                EntityEdgeDeletionAuthorizationInferenceBehavior.ONE_IMPLIES_ALL) {
                 const singleEntityResultToTestForInboundEdge = await loader['loadOneByFieldEqualingAsync'](fieldName, association.associatedEntityLookupByField
                     ? sourceEntity.getField(association.associatedEntityLookupByField)
                     : sourceEntity.getID());
@@ -168,9 +162,9 @@ async function canViewerDeleteInternalAsync(entityClass, sourceEntity, evaluatio
                     : sourceEntity.getID());
                 entityResultsToCheckForInboundEdge = entityResultsForInboundEdge;
             }
-            const failedEntityLoadResults = (0, entityUtils_1.failedResults)(entityResultsToCheckForInboundEdge);
+            const failedEntityLoadResults = failedResults(entityResultsToCheckForInboundEdge);
             for (const failedResult of failedEntityLoadResults) {
-                if (failedResult.reason instanceof EntityNotAuthorizedError_1.EntityNotAuthorizedError) {
+                if (failedResult.reason instanceof EntityNotAuthorizedError) {
                     return { allowed: false, authorizationErrors: [failedResult.reason] };
                 }
                 else {
@@ -180,8 +174,8 @@ async function canViewerDeleteInternalAsync(entityClass, sourceEntity, evaluatio
             // all results should be success at this point due to check above
             const entitiesForInboundEdge = entityResultsToCheckForInboundEdge.map((r) => r.enforceValue());
             switch (association.edgeDeletionBehavior) {
-                case EntityFieldDefinition_1.EntityEdgeDeletionBehavior.CASCADE_DELETE:
-                case EntityFieldDefinition_1.EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE_ONLY: {
+                case EntityEdgeDeletionBehavior.CASCADE_DELETE:
+                case EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE_ONLY: {
                     const canDeleteEvaluationResults = await Promise.all(entitiesForInboundEdge.map((entity) => canViewerDeleteInternalAsync(inboundEdge, entity, { previousValue: null, cascadingDeleteCause: newCascadingDeleteCause }, queryContext)));
                     const reducedEvaluationResult = reduceEvaluationResults(canDeleteEvaluationResults);
                     if (!reducedEvaluationResult.allowed) {
@@ -189,8 +183,8 @@ async function canViewerDeleteInternalAsync(entityClass, sourceEntity, evaluatio
                     }
                     break;
                 }
-                case EntityFieldDefinition_1.EntityEdgeDeletionBehavior.SET_NULL:
-                case EntityFieldDefinition_1.EntityEdgeDeletionBehavior.SET_NULL_INVALIDATE_CACHE_ONLY: {
+                case EntityEdgeDeletionBehavior.SET_NULL:
+                case EntityEdgeDeletionBehavior.SET_NULL_INVALIDATE_CACHE_ONLY: {
                     // create synthetic entities with the reference field set to null to properly evaluate
                     // privacy policy as it would be after the cascading SET NULL operation
                     const previousAndSyntheticEntitiesForInboundEdge = entitiesForInboundEdge.map((entity) => {
@@ -220,7 +214,7 @@ async function canViewerDeleteInternalAsync(entityClass, sourceEntity, evaluatio
     return { allowed: true };
 }
 function reduceEvaluationResults(evaluationResults) {
-    const [successResults, failureResults] = (0, entityUtils_1.partitionArray)(evaluationResults, (evaluationResult) => evaluationResult.allowed);
+    const [successResults, failureResults] = partitionArray(evaluationResults, (evaluationResult) => evaluationResult.allowed);
     if (successResults.length === evaluationResults.length) {
         return { allowed: true };
     }
@@ -229,4 +223,3 @@ function reduceEvaluationResults(evaluationResults) {
         authorizationErrors: failureResults.flatMap((failureResult) => failureResult.authorizationErrors),
     };
 }
-//# sourceMappingURL=EntityPrivacyUtils.js.map

package/build/src/utils/collections/SerializableKeyMap.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SerializableKeyMap = void 0;
 /**
  * A map with keys that are serializable. Serialized keys are considered equal if their serialized values are equal.
  * Otherwise, the map behaves like a regular Map.
  */
-class SerializableKeyMap {
+export class SerializableKeyMap {
     underlyingMap;
     constructor(iterable) {
         this.underlyingMap = new Map(Array.from(iterable ?? []).map(([key, value]) => [key.serialize(), value]));
@@ -56,5 +53,3 @@ class SerializableKeyMap {
         return 'SerializableKeyMap';
     }
 }
-exports.SerializableKeyMap = SerializableKeyMap;
-//# sourceMappingURL=SerializableKeyMap.js.map

package/build/src/utils/collections/maps.js

@@ -1,11 +1,4 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.reduceMapAsync = exports.reduceMap = exports.invertMap = exports.zipToMap = exports.mapKeys = exports.mapMapAsync = exports.mapMap = exports.computeIfAbsent = void 0;
-exports.filterMap = filterMap;
-const invariant_1 = __importDefault(require("invariant"));
+import invariant from 'invariant';
 /**
  * If the specified key is not already associated with a value in this map, computes
  * its value using the given mapping function and enters it into this map.
@@ -14,35 +7,33 @@ const invariant_1 = __importDefault(require("invariant"));
  * @param key - key for which to get the value or with which the computed value is to be associated
  * @param mappingFunction - function to compute a value for key
  */
-const computeIfAbsent = (map, key, mappingFunction) => {
+export const computeIfAbsent = (map, key, mappingFunction) => {
     if (!map.has(key)) {
         const value = mappingFunction(key);
         map.set(key, value);
     }
     return map.get(key);
 };
-exports.computeIfAbsent = computeIfAbsent;
 /**
  * Create a new Map by associating the value of mapper executed for each key in the source map.
  *
  * @param map - source map
  * @param mapper - function to compute a value in the resulting map for the source key and value
  */
-const mapMap = (map, mapper) => {
+export const mapMap = (map, mapper) => {
     const resultingMap = new Map();
     for (const [k, v] of map) {
         resultingMap.set(k, mapper(v, k));
     }
     return resultingMap;
 };
-exports.mapMap = mapMap;
 /**
  * Create a new Map by associating the value of mapper executed for each key in the source map.
  *
  * @param map - source map
  * @param mapper - asynchronous function to compute a value in the resulting map for the source key and value
  */
-const mapMapAsync = async function (map, mapper) {
+export const mapMapAsync = async function (map, mapper) {
     const resultingMap = new Map();
     await Promise.all(Array.from(map.keys()).map(async (k) => {
         const initialValue = map.get(k);
@@ -51,7 +42,6 @@ const mapMapAsync = async function (map, mapper) {
     }));
     return resultingMap;
 };
-exports.mapMapAsync = mapMapAsync;
 /**
  * Create a new Map by associating the value of each key with mapper executed for each key in the source map.
  * The opposite of mapMap. In the event two source keys map to the same result key, the second source key's
@@ -61,14 +51,13 @@ exports.mapMapAsync = mapMapAsync;
  * @param map - source map
  * @param mapper - function to compute a key in the resulting map for the source key and value
  */
-const mapKeys = (map, mapper) => {
+export const mapKeys = (map, mapper) => {
     const resultingMap = new Map();
     for (const [k, v] of map) {
         resultingMap.set(mapper(k, v), v);
     }
     return resultingMap;
 };
-exports.mapKeys = mapKeys;
 /**
  * Create a new Map from each member of keys to the corresponding member of values.
  *
@@ -80,28 +69,26 @@ exports.mapKeys = mapKeys;
  * @param keys - keys
  * @param values - corresponding ordered values for keys
  */
-const zipToMap = (keys, values) => {
-    (0, invariant_1.default)(keys.length === values.length, `zipToMap input length mismatch: keys[${keys.length}], values[${values.length}]`);
+export const zipToMap = (keys, values) => {
+    invariant(keys.length === values.length, `zipToMap input length mismatch: keys[${keys.length}], values[${values.length}]`);
     const resultingMap = new Map();
     for (let i = 0; i < keys.length; i++) {
         resultingMap.set(keys[i], values[i]);
     }
     return resultingMap;
 };
-exports.zipToMap = zipToMap;
 /**
  * Create a new Map by inverting keys and values of specified map.
  *
  * @param map - map to invert
  */
-const invertMap = (map) => {
+export const invertMap = (map) => {
     const resultingMap = new Map();
     for (const [k, v] of map) {
         resultingMap.set(v, k);
     }
     return resultingMap;
 };
-exports.invertMap = invertMap;
 /**
  * Execute a reducer function on each element of the source map, resulting in a single output value.
  *
@@ -110,14 +97,13 @@ exports.invertMap = invertMap;
  *                  iteration key and returns a new accumulated value
  * @param initialValue - initial accumulated value
  */
-const reduceMap = (map, reducer, initialValue) => {
+export const reduceMap = (map, reducer, initialValue) => {
     let newAccumulator = initialValue;
     for (const [k, v] of map) {
         newAccumulator = reducer(newAccumulator, v, k);
     }
     return newAccumulator;
 };
-exports.reduceMap = reduceMap;
 /**
  * Execute an asynchronous reducer function on each element of the source map, resulting in a single output value.
  * Note that this does not parallelize asynchronous reduce steps so it should be used with caution.
@@ -127,20 +113,19 @@ exports.reduceMap = reduceMap;
  *                  current iteration key and returns a new accumulated value
  * @param initialValue - initial accumulated value
  */
-const reduceMapAsync = async (map, reducer, initialValue) => {
+export const reduceMapAsync = async (map, reducer, initialValue) => {
     let newAccumulator = initialValue;
     for (const [k, v] of map) {
         newAccumulator = await reducer(newAccumulator, v, k);
     }
     return newAccumulator;
 };
-exports.reduceMapAsync = reduceMapAsync;
 /**
  * Create a new Map containing all elements from the source map that pass the provided test predicate.
  * @param map - source map
  * @param predicate - function to test each element of source map
  */
-function filterMap(map, predicate) {
+export function filterMap(map, predicate) {
     const resultingMap = new Map();
     map.forEach((v, k) => {
         if (predicate(v, k)) {
@@ -149,4 +134,3 @@ function filterMap(map, predicate) {
     });
     return resultingMap;
 }
-//# sourceMappingURL=maps.js.map

package/build/src/utils/collections/sets.js

@@ -1,7 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.areSetsEqual = areSetsEqual;
-function areSetsEqual(a, b) {
+export function areSetsEqual(a, b) {
     return a.size === b.size && [...a].every((value) => b.has(value));
 }
-//# sourceMappingURL=sets.js.map

package/build/src/utils/mergeEntityMutationTriggerConfigurations.d.ts

@@ -1,4 +1,4 @@
-import { EntityMutationTriggerConfiguration } from '../EntityMutationTriggerConfiguration';
-import { ReadonlyEntity } from '../ReadonlyEntity';
-import { ViewerContext } from '../ViewerContext';
+import type { EntityMutationTriggerConfiguration } from '../EntityMutationTriggerConfiguration.ts';
+import type { ReadonlyEntity } from '../ReadonlyEntity.ts';
+import type { ViewerContext } from '../ViewerContext.ts';
 export declare function mergeEntityMutationTriggerConfigurations<TFields extends Record<string, any>, TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>, TViewerContext extends ViewerContext, TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>, TSelectedFields extends keyof TFields>(...mutationTriggerConfigurations: EntityMutationTriggerConfiguration<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>[]): EntityMutationTriggerConfiguration<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>;

package/build/src/utils/mergeEntityMutationTriggerConfigurations.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeEntityMutationTriggerConfigurations = mergeEntityMutationTriggerConfigurations;
 function nonNullish(value) {
     return value !== null && value !== undefined;
 }
-function mergeEntityMutationTriggerConfigurations(...mutationTriggerConfigurations) {
+export function mergeEntityMutationTriggerConfigurations(...mutationTriggerConfigurations) {
     const merged = {
         beforeCreate: mutationTriggerConfigurations.flatMap((c) => c.beforeCreate).filter(nonNullish),
         afterCreate: mutationTriggerConfigurations.flatMap((c) => c.afterCreate).filter(nonNullish),
@@ -24,4 +21,3 @@ function mergeEntityMutationTriggerConfigurations(...mutationTriggerConfiguratio
     }
     return merged;
 }
-//# sourceMappingURL=mergeEntityMutationTriggerConfigurations.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/entity",
-  "version": "0.60.0",
+  "version": "0.62.0",
   "description": "A privacy-first data model",
   "files": [
     "build",
@@ -19,27 +19,28 @@
     "test": "yarn test:all --rootDir $(pwd)"
   },
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "keywords": [
     "entity"
   ],
   "author": "Expo",
   "license": "MIT",
+  "type": "module",
   "dependencies": {
     "@expo/results": "^1.0.0",
     "dataloader": "^2.2.3",
     "invariant": "^2.2.4"
   },
   "devDependencies": {
-    "@jest/globals": "30.2.0",
+    "@jest/globals": "30.3.0",
     "@types/invariant": "2.2.37",
-    "@types/lodash": "4.17.24",
-    "@types/node": "24.11.0",
-    "lodash": "4.17.23",
+    "@types/lodash-es": "4.17.12",
+    "@types/node": "24.12.0",
+    "lodash-es": "4.17.23",
     "ts-mockito": "2.6.1",
     "typescript": "5.9.3",
     "uuid": "13.0.0"
   },
-  "gitHead": "e36dc81bd22ce92a7a11ccd1976173b464da5e76"
+  "gitHead": "4965cc238882982e6315beca48a68679ed45456b"
 }

package/src/AuthorizationResultBasedEntityAssociationLoader.ts

@@ -1,10 +1,11 @@
-import { Result, result } from '@expo/results';
+import type { Result } from '@expo/results';
+import { result } from '@expo/results';
 
-import { IEntityClass } from './Entity';
-import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
-import { EntityQueryContext } from './EntityQueryContext';
-import { ReadonlyEntity } from './ReadonlyEntity';
-import { ViewerContext } from './ViewerContext';
+import type { IEntityClass } from './Entity.ts';
+import type { EntityPrivacyPolicy } from './EntityPrivacyPolicy.ts';
+import type { EntityQueryContext } from './EntityQueryContext.ts';
+import type { ReadonlyEntity } from './ReadonlyEntity.ts';
+import type { ViewerContext } from './ViewerContext.ts';
 
 /**
  * An association loader is a set of convenience methods for loading entities

package/src/AuthorizationResultBasedEntityLoader.ts

@@ -1,25 +1,27 @@
-import { Result, result } from '@expo/results';
+import nullthrows from '@expo/nullthrows';
+import type { Result } from '@expo/results';
+import { result } from '@expo/results';
 import invariant from 'invariant';
-import nullthrows from 'nullthrows';
 
-import { IEntityClass } from './Entity';
-import {
+import type { IEntityClass } from './Entity.ts';
+import type {
   EntityCompositeField,
   EntityCompositeFieldValue,
   EntityConfiguration,
-} from './EntityConfiguration';
-import { EntityConstructionUtils } from './EntityConstructionUtils';
-import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
-import { EntityQueryContext } from './EntityQueryContext';
-import { ReadonlyEntity } from './ReadonlyEntity';
-import { ViewerContext } from './ViewerContext';
-import { EntityNotFoundError } from './errors/EntityNotFoundError';
-import { CompositeFieldHolder, CompositeFieldValueHolder } from './internal/CompositeFieldHolder';
-import { CompositeFieldValueMap } from './internal/CompositeFieldValueMap';
-import { EntityDataManager } from './internal/EntityDataManager';
-import { SingleFieldHolder, SingleFieldValueHolder } from './internal/SingleFieldHolder';
-import { mapKeys, mapMap } from './utils/collections/maps';
-import { areSetsEqual } from './utils/collections/sets';
+} from './EntityConfiguration.ts';
+import type { EntityConstructionUtils } from './EntityConstructionUtils.ts';
+import type { EntityPrivacyPolicy } from './EntityPrivacyPolicy.ts';
+import type { EntityQueryContext } from './EntityQueryContext.ts';
+import type { ReadonlyEntity } from './ReadonlyEntity.ts';
+import type { ViewerContext } from './ViewerContext.ts';
+import { EntityNotFoundError } from './errors/EntityNotFoundError.ts';
+import type { CompositeFieldHolder } from './internal/CompositeFieldHolder.ts';
+import { CompositeFieldValueHolder } from './internal/CompositeFieldHolder.ts';
+import { CompositeFieldValueMap } from './internal/CompositeFieldValueMap.ts';
+import type { EntityDataManager } from './internal/EntityDataManager.ts';
+import { SingleFieldHolder, SingleFieldValueHolder } from './internal/SingleFieldHolder.ts';
+import { mapKeys, mapMap } from './utils/collections/maps.ts';
+import { areSetsEqual } from './utils/collections/sets.ts';
 
 /**
  * Authorization-result-based entity loader. All normal loads are batched,