@expo/entity 0.60.0 → 0.61.0

package/build/src/AuthorizationResultBasedEntityAssociationLoader.d.ts

@@ -1,9 +1,9 @@
-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 { Result } from '@expo/results';
+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
  * associated with an entity. In relational databases, these entities are often referenced

package/build/src/AuthorizationResultBasedEntityAssociationLoader.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthorizationResultBasedEntityAssociationLoader = void 0;
-const results_1 = require("@expo/results");
+import { result } from '@expo/results';
 /**
  * An association loader is a set of convenience methods for loading entities
  * associated with an entity. In relational databases, these entities are often referenced
  * by foreign keys.
  */
-class AuthorizationResultBasedEntityAssociationLoader {
+export class AuthorizationResultBasedEntityAssociationLoader {
     entity;
     queryContext;
     constructor(entity, queryContext) {
@@ -23,7 +20,7 @@ class AuthorizationResultBasedEntityAssociationLoader {
     async loadAssociatedEntityAsync(fieldIdentifyingAssociatedEntity, associatedEntityClass) {
         const associatedEntityID = this.entity.getField(fieldIdentifyingAssociatedEntity);
         if (!associatedEntityID) {
-            return (0, results_1.result)(null);
+            return result(null);
         }
         const loader = this.entity
             .getViewerContext()
@@ -112,12 +109,10 @@ class AuthorizationResultBasedEntityAssociationLoader {
                 return null;
             }
             if (!associatedEntityResult.ok) {
-                return (0, results_1.result)(associatedEntityResult.reason);
+                return result(associatedEntityResult.reason);
             }
             currentEntity = associatedEntityResult.value;
         }
-        return (0, results_1.result)(currentEntity);
+        return result(currentEntity);
     }
 }
-exports.AuthorizationResultBasedEntityAssociationLoader = AuthorizationResultBasedEntityAssociationLoader;
-//# sourceMappingURL=AuthorizationResultBasedEntityAssociationLoader.js.map

package/build/src/AuthorizationResultBasedEntityLoader.d.ts

@@ -1,12 +1,12 @@
-import { Result } from '@expo/results';
-import { IEntityClass } from './Entity';
-import { 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 { EntityDataManager } from './internal/EntityDataManager';
+import type { Result } from '@expo/results';
+import type { IEntityClass } from './Entity.ts';
+import type { EntityCompositeField, EntityCompositeFieldValue, EntityConfiguration } 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 type { EntityDataManager } from './internal/EntityDataManager.ts';
 /**
  * Authorization-result-based entity loader. All normal loads are batched,
  * cached, and authorized against the entity's EntityPrivacyPolicy. All loads through this

package/build/src/AuthorizationResultBasedEntityLoader.js

@@ -1,25 +1,19 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthorizationResultBasedEntityLoader = void 0;
-const results_1 = require("@expo/results");
-const invariant_1 = __importDefault(require("invariant"));
-const nullthrows_1 = __importDefault(require("nullthrows"));
-const EntityNotFoundError_1 = require("./errors/EntityNotFoundError");
-const CompositeFieldHolder_1 = require("./internal/CompositeFieldHolder");
-const CompositeFieldValueMap_1 = require("./internal/CompositeFieldValueMap");
-const SingleFieldHolder_1 = require("./internal/SingleFieldHolder");
-const maps_1 = require("./utils/collections/maps");
-const sets_1 = require("./utils/collections/sets");
+import nullthrows from '@expo/nullthrows';
+import { result } from '@expo/results';
+import invariant from 'invariant';
+import { EntityNotFoundError } from "./errors/EntityNotFoundError.js";
+import { CompositeFieldValueHolder } from "./internal/CompositeFieldHolder.js";
+import { CompositeFieldValueMap } from "./internal/CompositeFieldValueMap.js";
+import { SingleFieldHolder, SingleFieldValueHolder } from "./internal/SingleFieldHolder.js";
+import { mapKeys, mapMap } from "./utils/collections/maps.js";
+import { areSetsEqual } from "./utils/collections/sets.js";
 /**
  * Authorization-result-based entity loader. All normal loads are batched,
  * cached, and authorized against the entity's EntityPrivacyPolicy. All loads through this
  * loader are are results (or null for some loader methods), where an unsuccessful result
  * means an authorization error or entity construction error occurred. Other errors are thrown.
  */
-class AuthorizationResultBasedEntityLoader {
+export class AuthorizationResultBasedEntityLoader {
     queryContext;
     entityConfiguration;
     entityClass;
@@ -40,7 +34,7 @@ class AuthorizationResultBasedEntityLoader {
     async loadManyByFieldEqualingManyAsync(fieldName, fieldValues) {
         const { loadKey, loadValues } = this.validateFieldAndValuesAndConvertToHolders(fieldName, fieldValues);
         const loadValuesToFieldObjects = await this.dataManager.loadManyEqualingAsync(this.queryContext, loadKey, loadValues);
-        const fieldValuesToFieldObjects = (0, maps_1.mapKeys)(loadValuesToFieldObjects, (loadValue) => loadValue.fieldValue);
+        const fieldValuesToFieldObjects = mapKeys(loadValuesToFieldObjects, (loadValue) => loadValue.fieldValue);
         return await this.constructionUtils.constructAndAuthorizeEntitiesAsync(fieldValuesToFieldObjects);
     }
     /**
@@ -60,7 +54,7 @@ class AuthorizationResultBasedEntityLoader {
     async loadManyByFieldEqualingAsync(fieldName, fieldValue) {
         const entityResults = await this.loadManyByFieldEqualingManyAsync(fieldName, [fieldValue]);
         const entityResultsForFieldValue = entityResults.get(fieldValue);
-        (0, invariant_1.default)(entityResultsForFieldValue !== undefined, `${fieldValue} should be guaranteed to be present in returned map of entities`);
+        invariant(entityResultsForFieldValue !== undefined, `${fieldValue} should be guaranteed to be present in returned map of entities`);
         return entityResultsForFieldValue;
     }
     /**
@@ -95,7 +89,7 @@ class AuthorizationResultBasedEntityLoader {
             compositeFieldValue,
         ]);
         const entityResultForCompositeFieldValue = entityResults.get(compositeFieldValue);
-        (0, invariant_1.default)(entityResultForCompositeFieldValue !== undefined, `${compositeFieldValue} should be guaranteed to be present in returned map of entities`);
+        invariant(entityResultForCompositeFieldValue !== undefined, `${compositeFieldValue} should be guaranteed to be present in returned map of entities`);
         return entityResultForCompositeFieldValue;
     }
     /**
@@ -105,7 +99,7 @@ class AuthorizationResultBasedEntityLoader {
      */
     async loadByFieldEqualingAsync(uniqueFieldName, fieldValue) {
         const entityResults = await this.loadManyByFieldEqualingAsync(uniqueFieldName, fieldValue);
-        (0, invariant_1.default)(entityResults.length <= 1, `loadByFieldEqualing: Multiple entities of type ${this.entityClass.name} found for ${String(uniqueFieldName)}=${fieldValue}`);
+        invariant(entityResults.length <= 1, `loadByFieldEqualing: Multiple entities of type ${this.entityClass.name} found for ${String(uniqueFieldName)}=${fieldValue}`);
         return entityResults[0] ?? null;
     }
     /**
@@ -114,7 +108,7 @@ class AuthorizationResultBasedEntityLoader {
      */
     async loadByCompositeFieldEqualingAsync(compositeField, compositeFieldValue) {
         const entityResults = await this.loadManyByCompositeFieldEqualingAsync(compositeField, compositeFieldValue);
-        (0, invariant_1.default)(entityResults.length <= 1, `loadByCompositeFieldEqualing: Multiple entities of type ${this.entityClass.name} found for composite field (${compositeField.join(',')})=${JSON.stringify(compositeFieldValue)}`);
+        invariant(entityResults.length <= 1, `loadByCompositeFieldEqualing: Multiple entities of type ${this.entityClass.name} found for composite field (${compositeField.join(',')})=${JSON.stringify(compositeFieldValue)}`);
         return entityResults[0] ?? null;
     }
     /**
@@ -124,7 +118,7 @@ class AuthorizationResultBasedEntityLoader {
     async loadByIDAsync(id) {
         const entityResults = await this.loadManyByIDsAsync([id]);
         // loadManyByIDsAsync is always populated for each id supplied
-        return (0, nullthrows_1.default)(entityResults.get(id));
+        return nullthrows(entityResults.get(id));
     }
     /**
      * Authorization-result-based version of the EnforcingEntityLoader method by the same name.
@@ -139,10 +133,10 @@ class AuthorizationResultBasedEntityLoader {
      */
     async loadManyByIDsAsync(ids) {
         const entityResults = (await this.loadManyByFieldEqualingManyAsync(this.entityConfiguration.idField, ids));
-        return (0, maps_1.mapMap)(entityResults, (entityResultsForId, id) => {
+        return mapMap(entityResults, (entityResultsForId, id) => {
             const entityResult = entityResultsForId[0];
             return (entityResult ??
-                (0, results_1.result)(new EntityNotFoundError_1.EntityNotFoundError({
+                result(new EntityNotFoundError({
                     entityClass: this.entityClass,
                     fieldName: this.entityConfiguration.idField,
                     fieldValue: id,
@@ -155,33 +149,33 @@ class AuthorizationResultBasedEntityLoader {
      */
     async loadManyByIDsNullableAsync(ids) {
         const entityResults = (await this.loadManyByFieldEqualingManyAsync(this.entityConfiguration.idField, ids));
-        return (0, maps_1.mapMap)(entityResults, (entityResultsForId) => {
+        return mapMap(entityResults, (entityResultsForId) => {
             return entityResultsForId[0] ?? null;
         });
     }
     validateFieldAndValuesAndConvertToHolders(fieldName, fieldValues) {
         this.constructionUtils.validateFieldAndValues(fieldName, fieldValues);
         return {
-            loadKey: new SingleFieldHolder_1.SingleFieldHolder(fieldName),
-            loadValues: fieldValues.map((fieldValue) => new SingleFieldHolder_1.SingleFieldValueHolder(fieldValue)),
+            loadKey: new SingleFieldHolder(fieldName),
+            loadValues: fieldValues.map((fieldValue) => new SingleFieldValueHolder(fieldValue)),
         };
     }
     validateFieldAndValueAndConvertToHolders(fieldName, fieldValue) {
         this.constructionUtils.validateFieldAndValues(fieldName, [fieldValue]);
         return {
-            loadKey: new SingleFieldHolder_1.SingleFieldHolder(fieldName),
-            loadValue: new SingleFieldHolder_1.SingleFieldValueHolder(fieldValue),
+            loadKey: new SingleFieldHolder(fieldName),
+            loadValue: new SingleFieldValueHolder(fieldValue),
         };
     }
     validateCompositeFieldAndValuesAndConvertToHolders(compositeField, compositeFieldValues) {
         // validate that the composite field input is defined in the entity configuration
         const compositeFieldHolder = this.entityConfiguration.compositeFieldInfo.getCompositeFieldHolderForCompositeField(compositeField);
-        (0, invariant_1.default)(compositeFieldHolder, `must have composite field definition for composite field = ${String(compositeField)}`);
+        invariant(compositeFieldHolder, `must have composite field definition for composite field = ${String(compositeField)}`);
         const cacheableCompositeFieldFieldsSet = compositeFieldHolder.getFieldSet();
-        const compositeFieldValueHolders = compositeFieldValues.map((compositeFieldValue) => new CompositeFieldHolder_1.CompositeFieldValueHolder(compositeFieldValue));
+        const compositeFieldValueHolders = compositeFieldValues.map((compositeFieldValue) => new CompositeFieldValueHolder(compositeFieldValue));
         // validate that the composite field values are valid
         for (const compositeFieldValueHolder of compositeFieldValueHolders) {
-            (0, invariant_1.default)((0, sets_1.areSetsEqual)(cacheableCompositeFieldFieldsSet, compositeFieldValueHolder.getFieldSet()), `composite field values must contain exactly the fields defined in the composite field definition: ${compositeField}`);
+            invariant(areSetsEqual(cacheableCompositeFieldFieldsSet, compositeFieldValueHolder.getFieldSet()), `composite field values must contain exactly the fields defined in the composite field definition: ${compositeField}`);
             for (const field of compositeField) {
                 const fieldValue = compositeFieldValueHolder.compositeFieldValue[field];
                 this.constructionUtils.validateFieldAndValues(field, [fieldValue]);
@@ -193,7 +187,7 @@ class AuthorizationResultBasedEntityLoader {
         };
     }
     async constructAndAuthorizeEntitiesFromCompositeFieldValueHolderMapAsync(map) {
-        return new CompositeFieldValueMap_1.CompositeFieldValueMap(await Promise.all(Array.from(map.entries()).map(async ([compositeFieldValueHolder, fieldObjects]) => {
+        return new CompositeFieldValueMap(await Promise.all(Array.from(map.entries()).map(async ([compositeFieldValueHolder, fieldObjects]) => {
             return [
                 compositeFieldValueHolder,
                 await this.constructionUtils.constructAndAuthorizeEntitiesArrayAsync(fieldObjects),
@@ -201,5 +195,3 @@ class AuthorizationResultBasedEntityLoader {
         })));
     }
 }
-exports.AuthorizationResultBasedEntityLoader = AuthorizationResultBasedEntityLoader;
-//# sourceMappingURL=AuthorizationResultBasedEntityLoader.js.map

package/build/src/AuthorizationResultBasedEntityMutator.d.ts

@@ -1,16 +1,16 @@
-import { Result } from '@expo/results';
-import { Entity, IEntityClass } from './Entity';
-import { EntityCompanionProvider } from './EntityCompanionProvider';
-import { EntityConfiguration } from './EntityConfiguration';
-import { EntityDatabaseAdapter } from './EntityDatabaseAdapter';
-import { EntityLoaderFactory } from './EntityLoaderFactory';
-import { EntityCascadingDeletionInfo, EntityTriggerMutationInfo, EntityValidatorMutationInfo } from './EntityMutationInfo';
-import { EntityMutationTrigger, EntityMutationTriggerConfiguration, EntityNonTransactionalMutationTrigger } from './EntityMutationTriggerConfiguration';
-import { EntityMutationValidator, EntityMutationValidatorConfiguration } from './EntityMutationValidatorConfiguration';
-import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
-import { EntityQueryContext, EntityTransactionalQueryContext } from './EntityQueryContext';
-import { ViewerContext } from './ViewerContext';
-import { IEntityMetricsAdapter } from './metrics/IEntityMetricsAdapter';
+import type { Result } from '@expo/results';
+import type { Entity, IEntityClass } from './Entity.ts';
+import type { EntityCompanionProvider } from './EntityCompanionProvider.ts';
+import type { EntityConfiguration } from './EntityConfiguration.ts';
+import type { EntityDatabaseAdapter } from './EntityDatabaseAdapter.ts';
+import type { EntityLoaderFactory } from './EntityLoaderFactory.ts';
+import type { EntityCascadingDeletionInfo, EntityTriggerMutationInfo, EntityValidatorMutationInfo } from './EntityMutationInfo.ts';
+import type { EntityMutationTrigger, EntityMutationTriggerConfiguration, EntityNonTransactionalMutationTrigger } from './EntityMutationTriggerConfiguration.ts';
+import type { EntityMutationValidator, EntityMutationValidatorConfiguration } from './EntityMutationValidatorConfiguration.ts';
+import type { EntityPrivacyPolicy } from './EntityPrivacyPolicy.ts';
+import type { EntityQueryContext, EntityTransactionalQueryContext } from './EntityQueryContext.ts';
+import type { ViewerContext } from './ViewerContext.ts';
+import type { IEntityMetricsAdapter } from './metrics/IEntityMetricsAdapter.ts';
 /**
  * Base class for entity mutators. Mutators are builder-like class instances that are
  * responsible for creating, updating, and deleting entities, and for calling out to

package/build/src/AuthorizationResultBasedEntityMutator.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.AuthorizationResultBasedDeleteMutator = exports.AuthorizationResultBasedUpdateMutator = exports.AuthorizationResultBasedCreateMutator = exports.AuthorizationResultBasedBaseMutator = void 0;
-const results_1 = require("@expo/results");
-const invariant_1 = __importDefault(require("invariant"));
-const EntityFieldDefinition_1 = require("./EntityFieldDefinition");
-const EntityMutationInfo_1 = require("./EntityMutationInfo");
-const entityUtils_1 = require("./entityUtils");
-const EntityInvalidFieldValueError_1 = require("./errors/EntityInvalidFieldValueError");
-const EntityMetricsUtils_1 = require("./metrics/EntityMetricsUtils");
-const IEntityMetricsAdapter_1 = require("./metrics/IEntityMetricsAdapter");
-const maps_1 = require("./utils/collections/maps");
+import { asyncResult, enforceAsyncResult, result } from '@expo/results';
+import invariant from 'invariant';
+import { EntityEdgeDeletionBehavior } from "./EntityFieldDefinition.js";
+import { EntityMutationType } from "./EntityMutationInfo.js";
+import { enforceResultsAsync } from "./entityUtils.js";
+import { EntityInvalidFieldValueError } from "./errors/EntityInvalidFieldValueError.js";
+import { timeAndLogMutationEventAsync } from "./metrics/EntityMetricsUtils.js";
+import { EntityMetricsMutationType } from "./metrics/IEntityMetricsAdapter.js";
+import { mapMapAsync } from "./utils/collections/maps.js";
 /**
  * Base class for entity mutators. Mutators are builder-like class instances that are
  * responsible for creating, updating, and deleting entities, and for calling out to
@@ -99,7 +93,7 @@ const maps_1 = require("./utils/collections/maps");
  * - https://engineering.fb.com/2013/06/25/core-infra/tao-the-power-of-the-graph/
  * - https://hazelcast.com/blog/a-hitchhikers-guide-to-caching-patterns/
  */
-class AuthorizationResultBasedBaseMutator {
+export class AuthorizationResultBasedBaseMutator {
     companionProvider;
     viewerContext;
     queryContext;
@@ -128,10 +122,10 @@ class AuthorizationResultBasedBaseMutator {
         for (const fieldName in fields) {
             const fieldValue = fields[fieldName];
             const fieldDefinition = this.entityConfiguration.schema.get(fieldName);
-            (0, invariant_1.default)(fieldDefinition, `must have field definition for field = ${fieldName}`);
+            invariant(fieldDefinition, `must have field definition for field = ${fieldName}`);
             const isInputValid = fieldDefinition.validateInputValue(fieldValue);
             if (!isInputValid) {
-                throw new EntityInvalidFieldValueError_1.EntityInvalidFieldValueError(this.entityClass, fieldName, fieldValue);
+                throw new EntityInvalidFieldValueError(this.entityClass, fieldName, fieldValue);
             }
         }
     }
@@ -154,11 +148,10 @@ class AuthorizationResultBasedBaseMutator {
         await Promise.all(triggers.map((trigger) => trigger.executeAsync(this.viewerContext, entity, mutationInfo)));
     }
 }
-exports.AuthorizationResultBasedBaseMutator = AuthorizationResultBasedBaseMutator;
 /**
  * Mutator for creating a new entity.
  */
-class AuthorizationResultBasedCreateMutator extends AuthorizationResultBasedBaseMutator {
+export class AuthorizationResultBasedCreateMutator extends AuthorizationResultBasedBaseMutator {
     fieldsForEntity = {};
     /**
      * Set the value for entity field.
@@ -175,7 +168,7 @@ class AuthorizationResultBasedCreateMutator extends AuthorizationResultBasedBase
      * @returns authorized, cached, newly-created entity result, where result error can be UnauthorizedError
      */
     async createAsync() {
-        return await (0, EntityMetricsUtils_1.timeAndLogMutationEventAsync)(this.metricsAdapter, IEntityMetricsAdapter_1.EntityMetricsMutationType.CREATE, this.entityClass.name, this.queryContext)(this.createInTransactionAsync());
+        return await timeAndLogMutationEventAsync(this.metricsAdapter, EntityMetricsMutationType.CREATE, this.entityClass.name, this.queryContext)(this.createInTransactionAsync());
     }
     async createInTransactionAsync() {
         return await this.queryContext.runInTransactionIfNotInTransactionAsync((innerQueryContext) => this.createInternalAsync(innerQueryContext));
@@ -195,13 +188,13 @@ class AuthorizationResultBasedCreateMutator extends AuthorizationResultBasedBase
             [this.entityConfiguration.idField]: '00000000-0000-0000-0000-000000000000', // zero UUID
             ...this.fieldsForEntity,
         });
-        const authorizeCreateResult = await (0, results_1.asyncResult)(this.privacyPolicy.authorizeCreateAsync(this.viewerContext, queryContext, { previousValue: null, cascadingDeleteCause: null }, temporaryEntityForPrivacyCheck, this.metricsAdapter));
+        const authorizeCreateResult = await asyncResult(this.privacyPolicy.authorizeCreateAsync(this.viewerContext, queryContext, { previousValue: null, cascadingDeleteCause: null }, temporaryEntityForPrivacyCheck, this.metricsAdapter));
         if (!authorizeCreateResult.ok) {
             return authorizeCreateResult;
         }
-        await this.executeMutationValidatorsAsync(this.mutationValidators.beforeCreateAndUpdate, queryContext, temporaryEntityForPrivacyCheck, { type: EntityMutationInfo_1.EntityMutationType.CREATE });
-        await this.executeMutationTriggersAsync(this.mutationTriggers.beforeAll, queryContext, temporaryEntityForPrivacyCheck, { type: EntityMutationInfo_1.EntityMutationType.CREATE });
-        await this.executeMutationTriggersAsync(this.mutationTriggers.beforeCreate, queryContext, temporaryEntityForPrivacyCheck, { type: EntityMutationInfo_1.EntityMutationType.CREATE });
+        await this.executeMutationValidatorsAsync(this.mutationValidators.beforeCreateAndUpdate, queryContext, temporaryEntityForPrivacyCheck, { type: EntityMutationType.CREATE });
+        await this.executeMutationTriggersAsync(this.mutationTriggers.beforeAll, queryContext, temporaryEntityForPrivacyCheck, { type: EntityMutationType.CREATE });
+        await this.executeMutationTriggersAsync(this.mutationTriggers.beforeCreate, queryContext, temporaryEntityForPrivacyCheck, { type: EntityMutationType.CREATE });
         const insertResult = await this.databaseAdapter.insertAsync(queryContext, this.fieldsForEntity);
         // Invalidate all caches for the new entity so that any previously-negatively-cached loads
         // are removed from the caches.
@@ -211,18 +204,17 @@ class AuthorizationResultBasedCreateMutator extends AuthorizationResultBasedBase
         });
         invalidationUtils.invalidateFieldsForTransaction(queryContext, insertResult);
         const unauthorizedEntityAfterInsert = constructionUtils.constructEntity(insertResult);
-        const newEntity = await (0, results_1.enforceAsyncResult)(entityLoader.loadByIDAsync(unauthorizedEntityAfterInsert.getID()));
-        await this.executeMutationTriggersAsync(this.mutationTriggers.afterCreate, queryContext, newEntity, { type: EntityMutationInfo_1.EntityMutationType.CREATE });
-        await this.executeMutationTriggersAsync(this.mutationTriggers.afterAll, queryContext, newEntity, { type: EntityMutationInfo_1.EntityMutationType.CREATE });
-        queryContext.appendPostCommitCallback(this.executeNonTransactionalMutationTriggersAsync.bind(this, this.mutationTriggers.afterCommit, newEntity, { type: EntityMutationInfo_1.EntityMutationType.CREATE }));
-        return (0, results_1.result)(newEntity);
+        const newEntity = await enforceAsyncResult(entityLoader.loadByIDAsync(unauthorizedEntityAfterInsert.getID()));
+        await this.executeMutationTriggersAsync(this.mutationTriggers.afterCreate, queryContext, newEntity, { type: EntityMutationType.CREATE });
+        await this.executeMutationTriggersAsync(this.mutationTriggers.afterAll, queryContext, newEntity, { type: EntityMutationType.CREATE });
+        queryContext.appendPostCommitCallback(this.executeNonTransactionalMutationTriggersAsync.bind(this, this.mutationTriggers.afterCommit, newEntity, { type: EntityMutationType.CREATE }));
+        return result(newEntity);
     }
 }
-exports.AuthorizationResultBasedCreateMutator = AuthorizationResultBasedCreateMutator;
 /**
  * Mutator for updating an existing entity.
  */
-class AuthorizationResultBasedUpdateMutator extends AuthorizationResultBasedBaseMutator {
+export class AuthorizationResultBasedUpdateMutator extends AuthorizationResultBasedBaseMutator {
     cascadingDeleteCause;
     originalEntity;
     fieldsForEntity;
@@ -249,7 +241,7 @@ class AuthorizationResultBasedUpdateMutator extends AuthorizationResultBasedBase
      * @returns authorized updated entity result, where result error can be UnauthorizedError
      */
     async updateAsync() {
-        return await (0, EntityMetricsUtils_1.timeAndLogMutationEventAsync)(this.metricsAdapter, IEntityMetricsAdapter_1.EntityMetricsMutationType.UPDATE, this.entityClass.name, this.queryContext)(this.updateInTransactionAsync(false));
+        return await timeAndLogMutationEventAsync(this.metricsAdapter, EntityMetricsMutationType.UPDATE, this.entityClass.name, this.queryContext)(this.updateInTransactionAsync(false));
     }
     async updateInTransactionAsync(skipDatabaseUpdate) {
         return await this.queryContext.runInTransactionIfNotInTransactionAsync((innerQueryContext) => this.updateInternalAsync(innerQueryContext, skipDatabaseUpdate));
@@ -267,22 +259,22 @@ class AuthorizationResultBasedUpdateMutator extends AuthorizationResultBasedBase
             cascadingDeleteCause: this.cascadingDeleteCause,
         });
         const entityAboutToBeUpdated = constructionUtils.constructEntity(this.fieldsForEntity);
-        const authorizeUpdateResult = await (0, results_1.asyncResult)(this.privacyPolicy.authorizeUpdateAsync(this.viewerContext, queryContext, { previousValue: this.originalEntity, cascadingDeleteCause: this.cascadingDeleteCause }, entityAboutToBeUpdated, this.metricsAdapter));
+        const authorizeUpdateResult = await asyncResult(this.privacyPolicy.authorizeUpdateAsync(this.viewerContext, queryContext, { previousValue: this.originalEntity, cascadingDeleteCause: this.cascadingDeleteCause }, entityAboutToBeUpdated, this.metricsAdapter));
         if (!authorizeUpdateResult.ok) {
             return authorizeUpdateResult;
         }
         await this.executeMutationValidatorsAsync(this.mutationValidators.beforeCreateAndUpdate, queryContext, entityAboutToBeUpdated, {
-            type: EntityMutationInfo_1.EntityMutationType.UPDATE,
+            type: EntityMutationType.UPDATE,
             previousValue: this.originalEntity,
             cascadingDeleteCause: this.cascadingDeleteCause,
         });
         await this.executeMutationTriggersAsync(this.mutationTriggers.beforeAll, queryContext, entityAboutToBeUpdated, {
-            type: EntityMutationInfo_1.EntityMutationType.UPDATE,
+            type: EntityMutationType.UPDATE,
             previousValue: this.originalEntity,
             cascadingDeleteCause: this.cascadingDeleteCause,
         });
         await this.executeMutationTriggersAsync(this.mutationTriggers.beforeUpdate, queryContext, entityAboutToBeUpdated, {
-            type: EntityMutationInfo_1.EntityMutationType.UPDATE,
+            type: EntityMutationType.UPDATE,
             previousValue: this.originalEntity,
             cascadingDeleteCause: this.cascadingDeleteCause,
         });
@@ -307,23 +299,23 @@ class AuthorizationResultBasedUpdateMutator extends AuthorizationResultBasedBase
         });
         invalidationUtils.invalidateFieldsForTransaction(queryContext, this.originalEntity.getAllDatabaseFields());
         invalidationUtils.invalidateFieldsForTransaction(queryContext, this.fieldsForEntity);
-        const updatedEntity = await (0, results_1.enforceAsyncResult)(entityLoader.loadByIDAsync(entityAboutToBeUpdated.getID())); // ID is guaranteed to be stable by ensureStableIDField
+        const updatedEntity = await enforceAsyncResult(entityLoader.loadByIDAsync(entityAboutToBeUpdated.getID())); // ID is guaranteed to be stable by ensureStableIDField
         await this.executeMutationTriggersAsync(this.mutationTriggers.afterUpdate, queryContext, updatedEntity, {
-            type: EntityMutationInfo_1.EntityMutationType.UPDATE,
+            type: EntityMutationType.UPDATE,
             previousValue: this.originalEntity,
             cascadingDeleteCause: this.cascadingDeleteCause,
         });
         await this.executeMutationTriggersAsync(this.mutationTriggers.afterAll, queryContext, updatedEntity, {
-            type: EntityMutationInfo_1.EntityMutationType.UPDATE,
+            type: EntityMutationType.UPDATE,
             previousValue: this.originalEntity,
             cascadingDeleteCause: this.cascadingDeleteCause,
         });
         queryContext.appendPostCommitCallback(this.executeNonTransactionalMutationTriggersAsync.bind(this, this.mutationTriggers.afterCommit, updatedEntity, {
-            type: EntityMutationInfo_1.EntityMutationType.UPDATE,
+            type: EntityMutationType.UPDATE,
             previousValue: this.originalEntity,
             cascadingDeleteCause: this.cascadingDeleteCause,
         }));
-        return (0, results_1.result)(updatedEntity);
+        return result(updatedEntity);
     }
     ensureStableIDField(updatedFields) {
         const originalId = this.originalEntity.getID();
@@ -333,11 +325,10 @@ class AuthorizationResultBasedUpdateMutator extends AuthorizationResultBasedBase
         }
     }
 }
-exports.AuthorizationResultBasedUpdateMutator = AuthorizationResultBasedUpdateMutator;
 /**
  * Mutator for deleting an existing entity.
  */
-class AuthorizationResultBasedDeleteMutator extends AuthorizationResultBasedBaseMutator {
+export class AuthorizationResultBasedDeleteMutator extends AuthorizationResultBasedBaseMutator {
     entity;
     cascadingDeleteCause;
     constructor(companionProvider, viewerContext, queryContext, entityConfiguration, entityClass, privacyPolicy, mutationValidators, mutationTriggers, entityLoaderFactory, databaseAdapter, metricsAdapter, entity, cascadingDeleteCause) {
@@ -350,27 +341,27 @@ class AuthorizationResultBasedDeleteMutator extends AuthorizationResultBasedBase
      * @returns void result, where result error can be UnauthorizedError
      */
     async deleteAsync() {
-        return await (0, EntityMetricsUtils_1.timeAndLogMutationEventAsync)(this.metricsAdapter, IEntityMetricsAdapter_1.EntityMetricsMutationType.DELETE, this.entityClass.name, this.queryContext)(this.deleteInTransactionAsync(new Set(), false));
+        return await timeAndLogMutationEventAsync(this.metricsAdapter, EntityMetricsMutationType.DELETE, this.entityClass.name, this.queryContext)(this.deleteInTransactionAsync(new Set(), false));
     }
     async deleteInTransactionAsync(processedEntityIdentifiersFromTransitiveDeletions, skipDatabaseDeletion) {
         return await this.queryContext.runInTransactionIfNotInTransactionAsync((innerQueryContext) => this.deleteInternalAsync(innerQueryContext, processedEntityIdentifiersFromTransitiveDeletions, skipDatabaseDeletion));
     }
     async deleteInternalAsync(queryContext, processedEntityIdentifiersFromTransitiveDeletions, skipDatabaseDeletion) {
-        const authorizeDeleteResult = await (0, results_1.asyncResult)(this.privacyPolicy.authorizeDeleteAsync(this.viewerContext, queryContext, { previousValue: null, cascadingDeleteCause: this.cascadingDeleteCause }, this.entity, this.metricsAdapter));
+        const authorizeDeleteResult = await asyncResult(this.privacyPolicy.authorizeDeleteAsync(this.viewerContext, queryContext, { previousValue: null, cascadingDeleteCause: this.cascadingDeleteCause }, this.entity, this.metricsAdapter));
         if (!authorizeDeleteResult.ok) {
             return authorizeDeleteResult;
         }
         await this.processEntityDeletionForInboundEdgesAsync(this.entity, queryContext, processedEntityIdentifiersFromTransitiveDeletions);
         await this.executeMutationValidatorsAsync(this.mutationValidators.beforeDelete, queryContext, this.entity, {
-            type: EntityMutationInfo_1.EntityMutationType.DELETE,
+            type: EntityMutationType.DELETE,
             cascadingDeleteCause: this.cascadingDeleteCause,
         });
         await this.executeMutationTriggersAsync(this.mutationTriggers.beforeAll, queryContext, this.entity, {
-            type: EntityMutationInfo_1.EntityMutationType.DELETE,
+            type: EntityMutationType.DELETE,
             cascadingDeleteCause: this.cascadingDeleteCause,
         });
         await this.executeMutationTriggersAsync(this.mutationTriggers.beforeDelete, queryContext, this.entity, {
-            type: EntityMutationInfo_1.EntityMutationType.DELETE,
+            type: EntityMutationType.DELETE,
             cascadingDeleteCause: this.cascadingDeleteCause,
         });
         if (!skipDatabaseDeletion) {
@@ -385,18 +376,18 @@ class AuthorizationResultBasedDeleteMutator extends AuthorizationResultBasedBase
         });
         invalidationUtils.invalidateFieldsForTransaction(queryContext, this.entity.getAllDatabaseFields());
         await this.executeMutationTriggersAsync(this.mutationTriggers.afterDelete, queryContext, this.entity, {
-            type: EntityMutationInfo_1.EntityMutationType.DELETE,
+            type: EntityMutationType.DELETE,
             cascadingDeleteCause: this.cascadingDeleteCause,
         });
         await this.executeMutationTriggersAsync(this.mutationTriggers.afterAll, queryContext, this.entity, {
-            type: EntityMutationInfo_1.EntityMutationType.DELETE,
+            type: EntityMutationType.DELETE,
             cascadingDeleteCause: this.cascadingDeleteCause,
         });
         queryContext.appendPostCommitCallback(this.executeNonTransactionalMutationTriggersAsync.bind(this, this.mutationTriggers.afterCommit, this.entity, {
-            type: EntityMutationInfo_1.EntityMutationType.DELETE,
+            type: EntityMutationType.DELETE,
             cascadingDeleteCause: this.cascadingDeleteCause,
         }));
-        return (0, results_1.result)();
+        return result();
     }
     /**
      * Finds all entities referencing the specified entity and either deletes them, nullifies
@@ -434,7 +425,7 @@ class AuthorizationResultBasedDeleteMutator extends AuthorizationResultBasedBase
                 .getViewerContext()
                 .getViewerScopedEntityCompanionForClass(entityClass)
                 .getMutatorFactory();
-            return await (0, maps_1.mapMapAsync)(this.companionProvider.getCompanionForEntity(entityClass).entityCompanionDefinition
+            return await mapMapAsync(this.companionProvider.getCompanionForEntity(entityClass).entityCompanionDefinition
                 .entityConfiguration.schema, async (fieldDefinition, fieldName) => {
                 const association = fieldDefinition.association;
                 if (!association) {
@@ -444,7 +435,7 @@ class AuthorizationResultBasedDeleteMutator extends AuthorizationResultBasedBase
                 if (associatedConfiguration !== entityConfiguration) {
                     return;
                 }
-                const inboundReferenceEntities = await (0, entityUtils_1.enforceResultsAsync)(loaderFactory
+                const inboundReferenceEntities = await enforceResultsAsync(loaderFactory
                     .forLoad(queryContext, {
                     previousValue: null,
                     cascadingDeleteCause: newCascadingDeleteCause,
@@ -453,27 +444,27 @@ class AuthorizationResultBasedDeleteMutator extends AuthorizationResultBasedBase
                     ? entity.getField(association.associatedEntityLookupByField)
                     : entity.getID()));
                 switch (association.edgeDeletionBehavior) {
-                    case EntityFieldDefinition_1.EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE_ONLY: {
-                        await Promise.all(inboundReferenceEntities.map((inboundReferenceEntity) => (0, results_1.enforceAsyncResult)(mutatorFactory
+                    case EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE_ONLY: {
+                        await Promise.all(inboundReferenceEntities.map((inboundReferenceEntity) => enforceAsyncResult(mutatorFactory
                             .forDelete(inboundReferenceEntity, queryContext, newCascadingDeleteCause)
                             .deleteInTransactionAsync(processedEntityIdentifiers, 
                         /* skipDatabaseDeletion */ true))));
                         break;
                     }
-                    case EntityFieldDefinition_1.EntityEdgeDeletionBehavior.SET_NULL_INVALIDATE_CACHE_ONLY: {
-                        await Promise.all(inboundReferenceEntities.map((inboundReferenceEntity) => (0, results_1.enforceAsyncResult)(mutatorFactory
+                    case EntityEdgeDeletionBehavior.SET_NULL_INVALIDATE_CACHE_ONLY: {
+                        await Promise.all(inboundReferenceEntities.map((inboundReferenceEntity) => enforceAsyncResult(mutatorFactory
                             .forUpdate(inboundReferenceEntity, queryContext, newCascadingDeleteCause)
                             .setField(fieldName, null)['updateInTransactionAsync'](/* skipDatabaseUpdate */ true))));
                         break;
                     }
-                    case EntityFieldDefinition_1.EntityEdgeDeletionBehavior.SET_NULL: {
-                        await Promise.all(inboundReferenceEntities.map((inboundReferenceEntity) => (0, results_1.enforceAsyncResult)(mutatorFactory
+                    case EntityEdgeDeletionBehavior.SET_NULL: {
+                        await Promise.all(inboundReferenceEntities.map((inboundReferenceEntity) => enforceAsyncResult(mutatorFactory
                             .forUpdate(inboundReferenceEntity, queryContext, newCascadingDeleteCause)
                             .setField(fieldName, null)['updateInTransactionAsync'](/* skipDatabaseUpdate */ false))));
                         break;
                     }
-                    case EntityFieldDefinition_1.EntityEdgeDeletionBehavior.CASCADE_DELETE: {
-                        await Promise.all(inboundReferenceEntities.map((inboundReferenceEntity) => (0, results_1.enforceAsyncResult)(mutatorFactory
+                    case EntityEdgeDeletionBehavior.CASCADE_DELETE: {
+                        await Promise.all(inboundReferenceEntities.map((inboundReferenceEntity) => enforceAsyncResult(mutatorFactory
                             .forDelete(inboundReferenceEntity, queryContext, newCascadingDeleteCause)
                             .deleteInTransactionAsync(processedEntityIdentifiers, 
                         /* skipDatabaseDeletion */ false))));
@@ -483,5 +474,3 @@ class AuthorizationResultBasedDeleteMutator extends AuthorizationResultBasedBase
         }));
     }
 }
-exports.AuthorizationResultBasedDeleteMutator = AuthorizationResultBasedDeleteMutator;
-//# sourceMappingURL=AuthorizationResultBasedEntityMutator.js.map

package/build/src/ComposedEntityCacheAdapter.d.ts

@@ -1,6 +1,6 @@
-import { IEntityCacheAdapter } from './IEntityCacheAdapter';
-import { IEntityLoadKey, IEntityLoadValue } from './internal/EntityLoadInterfaces';
-import { CacheLoadResult } from './internal/ReadThroughEntityCache';
+import type { IEntityCacheAdapter } from './IEntityCacheAdapter.ts';
+import type { IEntityLoadKey, IEntityLoadValue } from './internal/EntityLoadInterfaces.ts';
+import type { CacheLoadResult } from './internal/ReadThroughEntityCache.ts';
 /**
  * A IEntityCacheAdapter that composes other IEntityCacheAdapter instances.
  */