@expo/entity 0.45.0 → 0.46.0

package/build/src/__tests__/EntityMutator-test.js

@@ -0,0 +1,721 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const results_1 = require("@expo/results");
+const globals_1 = require("@jest/globals");
+const ts_mockito_1 = require("ts-mockito");
+const uuid_1 = require("uuid");
+const AuthorizationResultBasedEntityLoader_1 = require("../AuthorizationResultBasedEntityLoader");
+const EntityCompanionProvider_1 = require("../EntityCompanionProvider");
+const EntityLoaderFactory_1 = require("../EntityLoaderFactory");
+const EntityLoaderUtils_1 = require("../EntityLoaderUtils");
+const EntityMutationInfo_1 = require("../EntityMutationInfo");
+const EntityMutationTriggerConfiguration_1 = require("../EntityMutationTriggerConfiguration");
+const EntityMutatorFactory_1 = require("../EntityMutatorFactory");
+const EntityQueryContext_1 = require("../EntityQueryContext");
+const ViewerContext_1 = require("../ViewerContext");
+const entityUtils_1 = require("../entityUtils");
+const EntityDataManager_1 = require("../internal/EntityDataManager");
+const ReadThroughEntityCache_1 = require("../internal/ReadThroughEntityCache");
+const IEntityMetricsAdapter_1 = require("../metrics/IEntityMetricsAdapter");
+const NoOpEntityMetricsAdapter_1 = require("../metrics/NoOpEntityMetricsAdapter");
+const SimpleTestEntity_1 = require("../utils/__testfixtures__/SimpleTestEntity");
+const StubCacheAdapter_1 = require("../utils/__testfixtures__/StubCacheAdapter");
+const StubDatabaseAdapter_1 = require("../utils/__testfixtures__/StubDatabaseAdapter");
+const StubQueryContextProvider_1 = require("../utils/__testfixtures__/StubQueryContextProvider");
+const TestEntity_1 = require("../utils/__testfixtures__/TestEntity");
+class TestMutationTrigger extends EntityMutationTriggerConfiguration_1.EntityMutationTrigger {
+    async executeAsync(_viewerContext, _queryContext, _entity, _mutationInfo) { }
+}
+class TestNonTransactionalMutationTrigger extends EntityMutationTriggerConfiguration_1.EntityNonTransactionalMutationTrigger {
+    async executeAsync(_viewerContext, _entity) { }
+}
+const setUpMutationValidatorSpies = (mutationValidators) => {
+    return mutationValidators.map((validator) => (0, ts_mockito_1.spy)(validator));
+};
+const verifyValidatorCounts = (viewerContext, mutationValidatorSpies, expectedCalls, mutationInfo) => {
+    for (const validator of mutationValidatorSpies) {
+        (0, ts_mockito_1.verify)(validator.executeAsync(viewerContext, (0, ts_mockito_1.anyOfClass)(EntityQueryContext_1.EntityTransactionalQueryContext), (0, ts_mockito_1.anyOfClass)(TestEntity_1.TestEntity), (0, ts_mockito_1.deepEqual)(mutationInfo))).times(expectedCalls);
+    }
+};
+const setUpMutationTriggerSpies = (mutationTriggers) => {
+    return {
+        beforeCreate: [(0, ts_mockito_1.spy)(mutationTriggers.beforeCreate[0])],
+        afterCreate: [(0, ts_mockito_1.spy)(mutationTriggers.afterCreate[0])],
+        beforeUpdate: [(0, ts_mockito_1.spy)(mutationTriggers.beforeUpdate[0])],
+        afterUpdate: [(0, ts_mockito_1.spy)(mutationTriggers.afterUpdate[0])],
+        beforeDelete: [(0, ts_mockito_1.spy)(mutationTriggers.beforeDelete[0])],
+        afterDelete: [(0, ts_mockito_1.spy)(mutationTriggers.afterDelete[0])],
+        beforeAll: [(0, ts_mockito_1.spy)(mutationTriggers.beforeAll[0])],
+        afterAll: [(0, ts_mockito_1.spy)(mutationTriggers.afterAll[0])],
+        afterCommit: [(0, ts_mockito_1.spy)(mutationTriggers.afterCommit[0])],
+    };
+};
+const verifyTriggerCounts = (viewerContext, mutationTriggerSpies, executed, mutationInfo) => {
+    Object.keys(executed).forEach((s) => {
+        if (executed[s]) {
+            (0, ts_mockito_1.verify)(mutationTriggerSpies[s][0].executeAsync(viewerContext, (0, ts_mockito_1.anyOfClass)(EntityQueryContext_1.EntityTransactionalQueryContext), (0, ts_mockito_1.anyOfClass)(TestEntity_1.TestEntity), (0, ts_mockito_1.deepEqual)(mutationInfo))).once();
+        }
+        else {
+            (0, ts_mockito_1.verify)(mutationTriggerSpies[s][0].executeAsync(viewerContext, (0, ts_mockito_1.anyOfClass)(EntityQueryContext_1.EntityTransactionalQueryContext), (0, ts_mockito_1.anyOfClass)(TestEntity_1.TestEntity), (0, ts_mockito_1.deepEqual)(mutationInfo))).never();
+        }
+    });
+    (0, ts_mockito_1.verify)(mutationTriggerSpies.beforeAll[0].executeAsync(viewerContext, (0, ts_mockito_1.anyOfClass)(EntityQueryContext_1.EntityTransactionalQueryContext), (0, ts_mockito_1.anyOfClass)(TestEntity_1.TestEntity), (0, ts_mockito_1.deepEqual)(mutationInfo))).once();
+    (0, ts_mockito_1.verify)(mutationTriggerSpies.afterAll[0].executeAsync(viewerContext, (0, ts_mockito_1.anyOfClass)(EntityQueryContext_1.EntityTransactionalQueryContext), (0, ts_mockito_1.anyOfClass)(TestEntity_1.TestEntity), (0, ts_mockito_1.deepEqual)(mutationInfo))).once();
+    (0, ts_mockito_1.verify)(mutationTriggerSpies.afterCommit[0].executeAsync(viewerContext, (0, ts_mockito_1.anyOfClass)(TestEntity_1.TestEntity), (0, ts_mockito_1.deepEqual)(mutationInfo))).once();
+};
+const createEntityMutatorFactory = (existingObjects) => {
+    const mutationValidators = [new TestMutationTrigger()];
+    const mutationTriggers = {
+        beforeCreate: [new TestMutationTrigger()],
+        afterCreate: [new TestMutationTrigger()],
+        beforeUpdate: [new TestMutationTrigger()],
+        afterUpdate: [new TestMutationTrigger()],
+        beforeDelete: [new TestMutationTrigger()],
+        afterDelete: [new TestMutationTrigger()],
+        beforeAll: [new TestMutationTrigger()],
+        afterAll: [new TestMutationTrigger()],
+        afterCommit: [new TestNonTransactionalMutationTrigger()],
+    };
+    const databaseAdapter = new StubDatabaseAdapter_1.StubDatabaseAdapter(TestEntity_1.testEntityConfiguration, StubDatabaseAdapter_1.StubDatabaseAdapter.convertFieldObjectsToDataStore(TestEntity_1.testEntityConfiguration, new Map([[TestEntity_1.testEntityConfiguration.tableName, existingObjects]])));
+    const customStubDatabaseAdapterProvider = {
+        getDatabaseAdapter(_entityConfiguration) {
+            return databaseAdapter;
+        },
+    };
+    const metricsAdapter = new NoOpEntityMetricsAdapter_1.NoOpEntityMetricsAdapter();
+    const cacheAdapterProvider = new StubCacheAdapter_1.NoCacheStubCacheAdapterProvider();
+    const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+    const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+    const queryContextProvider = new StubQueryContextProvider_1.StubQueryContextProvider();
+    const companionProvider = new EntityCompanionProvider_1.EntityCompanionProvider(metricsAdapter, new Map([
+        [
+            'postgres',
+            {
+                adapterProvider: customStubDatabaseAdapterProvider,
+                queryContextProvider,
+            },
+        ],
+    ]), new Map([
+        [
+            'redis',
+            {
+                cacheAdapterProvider,
+            },
+        ],
+    ]));
+    const dataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, queryContextProvider, metricsAdapter, TestEntity_1.TestEntity.name);
+    const entityLoaderFactory = new EntityLoaderFactory_1.EntityLoaderFactory(companionProvider.getCompanionForEntity(TestEntity_1.TestEntity), dataManager, metricsAdapter);
+    const entityMutatorFactory = new EntityMutatorFactory_1.EntityMutatorFactory(companionProvider, TestEntity_1.testEntityConfiguration, TestEntity_1.TestEntity, companionProvider.getCompanionForEntity(TestEntity_1.TestEntity).privacyPolicy, mutationValidators, mutationTriggers, entityLoaderFactory, databaseAdapter, metricsAdapter);
+    return {
+        privacyPolicy: companionProvider.getCompanionForEntity(TestEntity_1.TestEntity).privacyPolicy,
+        entityLoaderFactory,
+        entityMutatorFactory,
+        metricsAdapter,
+        mutationValidators,
+        mutationTriggers,
+    };
+};
+(0, globals_1.describe)(EntityMutatorFactory_1.EntityMutatorFactory, () => {
+    (0, globals_1.describe)('forCreate', () => {
+        (0, globals_1.it)('creates entities', async () => {
+            const viewerContext = (0, ts_mockito_1.mock)();
+            const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+            const id1 = (0, uuid_1.v4)();
+            const id2 = (0, uuid_1.v4)();
+            const { entityMutatorFactory } = createEntityMutatorFactory([
+                {
+                    customIdField: id1,
+                    stringField: 'huh',
+                    testIndexedField: '4',
+                    intField: 1,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+                {
+                    customIdField: id2,
+                    stringField: 'huh',
+                    testIndexedField: '5',
+                    intField: 1,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+            ]);
+            const newEntity = await (0, results_1.enforceAsyncResult)(entityMutatorFactory
+                .forCreate(viewerContext, queryContext)
+                .setField('stringField', 'huh')
+                .createAsync());
+            (0, globals_1.expect)(newEntity).toBeTruthy();
+        });
+        (0, globals_1.it)('checks privacy', async () => {
+            const viewerContext = (0, ts_mockito_1.mock)();
+            const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+            const id1 = (0, uuid_1.v4)();
+            const id2 = (0, uuid_1.v4)();
+            const { privacyPolicy, entityMutatorFactory } = createEntityMutatorFactory([
+                {
+                    customIdField: id1,
+                    stringField: 'huh',
+                    testIndexedField: '4',
+                    intField: 1,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+                {
+                    customIdField: id2,
+                    stringField: 'huh',
+                    testIndexedField: '5',
+                    intField: 1,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+            ]);
+            const spiedPrivacyPolicy = (0, ts_mockito_1.spy)(privacyPolicy);
+            await (0, results_1.enforceAsyncResult)(entityMutatorFactory
+                .forCreate(viewerContext, queryContext)
+                .setField('stringField', 'huh')
+                .createAsync());
+            (0, ts_mockito_1.verify)(spiedPrivacyPolicy.authorizeCreateAsync(viewerContext, (0, ts_mockito_1.anyOfClass)(EntityQueryContext_1.EntityTransactionalQueryContext), (0, ts_mockito_1.deepEqual)({ previousValue: null, cascadingDeleteCause: null }), (0, ts_mockito_1.anyOfClass)(TestEntity_1.TestEntity), (0, ts_mockito_1.anything)())).once();
+        });
+        (0, globals_1.it)('executes triggers', async () => {
+            const viewerContext = (0, ts_mockito_1.mock)();
+            const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+            const id1 = (0, uuid_1.v4)();
+            const id2 = (0, uuid_1.v4)();
+            const { mutationTriggers, entityMutatorFactory } = createEntityMutatorFactory([
+                {
+                    customIdField: id1,
+                    stringField: 'huh',
+                    testIndexedField: '4',
+                    intField: 1,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+                {
+                    customIdField: id2,
+                    stringField: 'huh',
+                    testIndexedField: '5',
+                    intField: 1,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+            ]);
+            const triggerSpies = setUpMutationTriggerSpies(mutationTriggers);
+            await (0, results_1.enforceAsyncResult)(entityMutatorFactory
+                .forCreate(viewerContext, queryContext)
+                .setField('stringField', 'huh')
+                .createAsync());
+            verifyTriggerCounts(viewerContext, triggerSpies, {
+                beforeCreate: true,
+                afterCreate: true,
+                beforeUpdate: false,
+                afterUpdate: false,
+                beforeDelete: false,
+                afterDelete: false,
+            }, { type: EntityMutationInfo_1.EntityMutationType.CREATE });
+        });
+        (0, globals_1.it)('executes validators', async () => {
+            const viewerContext = (0, ts_mockito_1.mock)();
+            const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+            const id1 = (0, uuid_1.v4)();
+            const id2 = (0, uuid_1.v4)();
+            const { mutationValidators, entityMutatorFactory } = createEntityMutatorFactory([
+                {
+                    customIdField: id1,
+                    stringField: 'huh',
+                    testIndexedField: '4',
+                    intField: 1,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+                {
+                    customIdField: id2,
+                    stringField: 'huh',
+                    testIndexedField: '5',
+                    intField: 1,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+            ]);
+            const validatorSpies = setUpMutationValidatorSpies(mutationValidators);
+            await (0, results_1.enforceAsyncResult)(entityMutatorFactory
+                .forCreate(viewerContext, queryContext)
+                .setField('stringField', 'huh')
+                .createAsync());
+            verifyValidatorCounts(viewerContext, validatorSpies, 1, { type: EntityMutationInfo_1.EntityMutationType.CREATE });
+        });
+    });
+    (0, globals_1.describe)('forUpdate', () => {
+        (0, globals_1.it)('updates entities', async () => {
+            const viewerContext = (0, ts_mockito_1.mock)();
+            const privacyPolicyEvaluationContext = (0, ts_mockito_1.instance)((0, ts_mockito_1.mock)());
+            const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+            const id1 = (0, uuid_1.v4)();
+            const id2 = (0, uuid_1.v4)();
+            const { entityMutatorFactory, entityLoaderFactory } = createEntityMutatorFactory([
+                {
+                    customIdField: id1,
+                    stringField: 'huh',
+                    testIndexedField: '3',
+                    intField: 3,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+                {
+                    customIdField: id2,
+                    stringField: 'huh',
+                    testIndexedField: '4',
+                    intField: 3,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+            ]);
+            const existingEntity = await (0, results_1.enforceAsyncResult)(entityLoaderFactory
+                .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
+                .loadByIDAsync(id2));
+            const updatedEntity = await (0, results_1.enforceAsyncResult)(entityMutatorFactory
+                .forUpdate(existingEntity, queryContext)
+                .setField('stringField', 'huh2')
+                .updateAsync());
+            (0, globals_1.expect)(updatedEntity).toBeTruthy();
+            (0, globals_1.expect)(updatedEntity.getAllFields()).not.toMatchObject(existingEntity.getAllFields());
+            (0, globals_1.expect)(updatedEntity.getField('stringField')).toEqual('huh2');
+            const reloadedEntity = await (0, results_1.enforceAsyncResult)(entityLoaderFactory
+                .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
+                .loadByIDAsync(id2));
+            (0, globals_1.expect)(reloadedEntity.getAllFields()).toMatchObject(updatedEntity.getAllFields());
+        });
+        (0, globals_1.it)('checks privacy', async () => {
+            const viewerContext = (0, ts_mockito_1.mock)();
+            const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+            const id1 = (0, uuid_1.v4)();
+            const id2 = (0, uuid_1.v4)();
+            const { privacyPolicy, entityMutatorFactory, entityLoaderFactory } = createEntityMutatorFactory([
+                {
+                    customIdField: id1,
+                    stringField: 'huh',
+                    testIndexedField: '3',
+                    intField: 3,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+                {
+                    customIdField: id2,
+                    stringField: 'huh',
+                    testIndexedField: '4',
+                    intField: 3,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+            ]);
+            const spiedPrivacyPolicy = (0, ts_mockito_1.spy)(privacyPolicy);
+            const existingEntity = await (0, results_1.enforceAsyncResult)(entityLoaderFactory
+                .forLoad(viewerContext, queryContext, { previousValue: null, cascadingDeleteCause: null })
+                .loadByIDAsync(id2));
+            await (0, results_1.enforceAsyncResult)(entityMutatorFactory
+                .forUpdate(existingEntity, queryContext)
+                .setField('stringField', 'huh2')
+                .updateAsync());
+            (0, ts_mockito_1.verify)(spiedPrivacyPolicy.authorizeUpdateAsync(viewerContext, (0, ts_mockito_1.anyOfClass)(EntityQueryContext_1.EntityTransactionalQueryContext), (0, ts_mockito_1.deepEqual)({ previousValue: existingEntity, cascadingDeleteCause: null }), (0, ts_mockito_1.anyOfClass)(TestEntity_1.TestEntity), (0, ts_mockito_1.anything)())).once();
+            (0, ts_mockito_1.verify)(spiedPrivacyPolicy.authorizeReadAsync(viewerContext, (0, ts_mockito_1.anyOfClass)(EntityQueryContext_1.EntityTransactionalQueryContext), (0, ts_mockito_1.deepEqual)({ previousValue: existingEntity, cascadingDeleteCause: null }), (0, ts_mockito_1.anyOfClass)(TestEntity_1.TestEntity), (0, ts_mockito_1.anything)())).once();
+        });
+        (0, globals_1.it)('executes triggers', async () => {
+            const viewerContext = (0, ts_mockito_1.mock)();
+            const privacyPolicyEvaluationContext = (0, ts_mockito_1.instance)((0, ts_mockito_1.mock)());
+            const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+            const id1 = (0, uuid_1.v4)();
+            const id2 = (0, uuid_1.v4)();
+            const { mutationTriggers, entityMutatorFactory, entityLoaderFactory } = createEntityMutatorFactory([
+                {
+                    customIdField: id1,
+                    stringField: 'huh',
+                    testIndexedField: '3',
+                    intField: 3,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+                {
+                    customIdField: id2,
+                    stringField: 'huh',
+                    testIndexedField: '4',
+                    intField: 3,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+            ]);
+            const triggerSpies = setUpMutationTriggerSpies(mutationTriggers);
+            const existingEntity = await (0, results_1.enforceAsyncResult)(entityLoaderFactory
+                .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
+                .loadByIDAsync(id2));
+            await (0, results_1.enforceAsyncResult)(entityMutatorFactory
+                .forUpdate(existingEntity, queryContext)
+                .setField('stringField', 'huh2')
+                .updateAsync());
+            verifyTriggerCounts(viewerContext, triggerSpies, {
+                beforeCreate: false,
+                afterCreate: false,
+                beforeUpdate: true,
+                afterUpdate: true,
+                beforeDelete: false,
+                afterDelete: false,
+            }, {
+                type: EntityMutationInfo_1.EntityMutationType.UPDATE,
+                previousValue: existingEntity,
+                cascadingDeleteCause: null,
+            });
+        });
+        (0, globals_1.it)('executes validators', async () => {
+            const viewerContext = (0, ts_mockito_1.mock)();
+            const privacyPolicyEvaluationContext = (0, ts_mockito_1.instance)((0, ts_mockito_1.mock)());
+            const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+            const id1 = (0, uuid_1.v4)();
+            const id2 = (0, uuid_1.v4)();
+            const { mutationValidators, entityMutatorFactory, entityLoaderFactory } = createEntityMutatorFactory([
+                {
+                    customIdField: id1,
+                    stringField: 'huh',
+                    testIndexedField: '3',
+                    intField: 3,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+                {
+                    customIdField: id2,
+                    stringField: 'huh',
+                    testIndexedField: '4',
+                    intField: 3,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+            ]);
+            const validatorSpies = setUpMutationValidatorSpies(mutationValidators);
+            const existingEntity = await (0, results_1.enforceAsyncResult)(entityLoaderFactory
+                .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
+                .loadByIDAsync(id2));
+            await (0, results_1.enforceAsyncResult)(entityMutatorFactory
+                .forUpdate(existingEntity, queryContext)
+                .setField('stringField', 'huh2')
+                .updateAsync());
+            verifyValidatorCounts(viewerContext, validatorSpies, 1, {
+                type: EntityMutationInfo_1.EntityMutationType.UPDATE,
+                previousValue: existingEntity,
+                cascadingDeleteCause: null,
+            });
+        });
+        (0, globals_1.it)('throws when id field is updated', async () => {
+            const viewerContext = (0, ts_mockito_1.mock)();
+            const privacyPolicyEvaluationContext = (0, ts_mockito_1.instance)((0, ts_mockito_1.mock)());
+            const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+            const id1 = (0, uuid_1.v4)();
+            const { entityMutatorFactory, entityLoaderFactory } = createEntityMutatorFactory([
+                {
+                    customIdField: id1,
+                    stringField: 'huh',
+                    testIndexedField: '4',
+                    intField: 3,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+            ]);
+            const existingEntity = await (0, results_1.enforceAsyncResult)(entityLoaderFactory
+                .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
+                .loadByIDAsync(id1));
+            await (0, globals_1.expect)((0, results_1.enforceAsyncResult)(entityMutatorFactory
+                .forUpdate(existingEntity, queryContext)
+                .setField('customIdField', (0, uuid_1.v4)())
+                .updateAsync())).rejects.toThrow('id field updates not supported: (entityClass = TestEntity)');
+            const reloadedEntity = await (0, results_1.enforceAsyncResult)(entityLoaderFactory
+                .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
+                .loadByIDAsync(id1));
+            (0, globals_1.expect)(reloadedEntity.getAllFields()).toMatchObject(existingEntity.getAllFields());
+        });
+    });
+    (0, globals_1.describe)('forDelete', () => {
+        (0, globals_1.it)('deletes entities', async () => {
+            const viewerContext = (0, ts_mockito_1.mock)();
+            const privacyPolicyEvaluationContext = (0, ts_mockito_1.instance)((0, ts_mockito_1.mock)());
+            const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+            const id1 = (0, uuid_1.v4)();
+            const { entityMutatorFactory, entityLoaderFactory } = createEntityMutatorFactory([
+                {
+                    customIdField: id1,
+                    stringField: 'huh',
+                    testIndexedField: '3',
+                    intField: 3,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+            ]);
+            const existingEntity = await (0, results_1.enforceAsyncResult)(entityLoaderFactory
+                .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
+                .loadByIDAsync(id1));
+            (0, globals_1.expect)(existingEntity).toBeTruthy();
+            await (0, results_1.enforceAsyncResult)(entityMutatorFactory.forDelete(existingEntity, queryContext).deleteAsync());
+            await (0, globals_1.expect)((0, results_1.enforceAsyncResult)(entityLoaderFactory
+                .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
+                .loadByIDAsync(id1))).rejects.toBeInstanceOf(Error);
+        });
+        (0, globals_1.it)('checks privacy', async () => {
+            const viewerContext = (0, ts_mockito_1.mock)();
+            const privacyPolicyEvaluationContext = (0, ts_mockito_1.instance)((0, ts_mockito_1.mock)());
+            const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+            const id1 = (0, uuid_1.v4)();
+            const { privacyPolicy, entityMutatorFactory, entityLoaderFactory } = createEntityMutatorFactory([
+                {
+                    customIdField: id1,
+                    stringField: 'huh',
+                    testIndexedField: '3',
+                    intField: 3,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+            ]);
+            const spiedPrivacyPolicy = (0, ts_mockito_1.spy)(privacyPolicy);
+            const existingEntity = await (0, results_1.enforceAsyncResult)(entityLoaderFactory
+                .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
+                .loadByIDAsync(id1));
+            await (0, results_1.enforceAsyncResult)(entityMutatorFactory.forDelete(existingEntity, queryContext).deleteAsync());
+            (0, ts_mockito_1.verify)(spiedPrivacyPolicy.authorizeDeleteAsync(viewerContext, (0, ts_mockito_1.anyOfClass)(EntityQueryContext_1.EntityTransactionalQueryContext), (0, ts_mockito_1.anything)(), (0, ts_mockito_1.anyOfClass)(TestEntity_1.TestEntity), (0, ts_mockito_1.anything)())).once();
+        });
+        (0, globals_1.it)('executes triggers', async () => {
+            const viewerContext = (0, ts_mockito_1.mock)();
+            const privacyPolicyEvaluationContext = (0, ts_mockito_1.instance)((0, ts_mockito_1.mock)());
+            const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+            const id1 = (0, uuid_1.v4)();
+            const { mutationTriggers, entityMutatorFactory, entityLoaderFactory } = createEntityMutatorFactory([
+                {
+                    customIdField: id1,
+                    stringField: 'huh',
+                    testIndexedField: '3',
+                    intField: 3,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+            ]);
+            const triggerSpies = setUpMutationTriggerSpies(mutationTriggers);
+            const existingEntity = await (0, results_1.enforceAsyncResult)(entityLoaderFactory
+                .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
+                .loadByIDAsync(id1));
+            await (0, results_1.enforceAsyncResult)(entityMutatorFactory.forDelete(existingEntity, queryContext).deleteAsync());
+            verifyTriggerCounts(viewerContext, triggerSpies, {
+                beforeCreate: false,
+                afterCreate: false,
+                beforeUpdate: false,
+                afterUpdate: false,
+                beforeDelete: true,
+                afterDelete: true,
+            }, { type: EntityMutationInfo_1.EntityMutationType.DELETE, cascadingDeleteCause: null });
+        });
+        (0, globals_1.it)('does not execute validators', async () => {
+            const viewerContext = (0, ts_mockito_1.mock)();
+            const privacyPolicyEvaluationContext = (0, ts_mockito_1.instance)((0, ts_mockito_1.mock)());
+            const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+            const id1 = (0, uuid_1.v4)();
+            const { mutationValidators, entityMutatorFactory, entityLoaderFactory } = createEntityMutatorFactory([
+                {
+                    customIdField: id1,
+                    stringField: 'huh',
+                    testIndexedField: '3',
+                    intField: 3,
+                    dateField: new Date(),
+                    nullableField: null,
+                },
+            ]);
+            const validatorSpies = setUpMutationValidatorSpies(mutationValidators);
+            const existingEntity = await (0, results_1.enforceAsyncResult)(entityLoaderFactory
+                .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
+                .loadByIDAsync(id1));
+            await (0, results_1.enforceAsyncResult)(entityMutatorFactory.forDelete(existingEntity, queryContext).deleteAsync());
+            verifyValidatorCounts(viewerContext, validatorSpies, 0, {
+                type: EntityMutationInfo_1.EntityMutationType.DELETE,
+            });
+        });
+    });
+    (0, globals_1.it)('invalidates cache for fields upon create', async () => {
+        const viewerContext = (0, ts_mockito_1.mock)();
+        const privacyPolicyEvaluationContext = (0, ts_mockito_1.instance)((0, ts_mockito_1.mock)());
+        const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+        const id1 = (0, uuid_1.v4)();
+        const { entityMutatorFactory, entityLoaderFactory } = createEntityMutatorFactory([
+            {
+                customIdField: id1,
+                stringField: 'huh',
+                testIndexedField: '3',
+                intField: 3,
+                dateField: new Date(),
+                nullableField: null,
+            },
+        ]);
+        const entites1 = await (0, entityUtils_1.enforceResultsAsync)(entityLoaderFactory
+            .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
+            .loadManyByFieldEqualingAsync('stringField', 'huh'));
+        (0, globals_1.expect)(entites1).toHaveLength(1);
+        const entitiesLoadedByComposite1 = await (0, entityUtils_1.enforceResultsAsync)(entityLoaderFactory
+            .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
+            .loadManyByCompositeFieldEqualingAsync(['stringField', 'intField'], {
+            stringField: 'huh',
+            intField: 3,
+        }));
+        (0, globals_1.expect)(entitiesLoadedByComposite1).toHaveLength(1);
+        await (0, results_1.enforceAsyncResult)(entityMutatorFactory
+            .forCreate(viewerContext, queryContext)
+            .setField('stringField', 'huh')
+            .setField('intField', 3)
+            .createAsync());
+        const entities2 = await (0, entityUtils_1.enforceResultsAsync)(entityLoaderFactory
+            .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
+            .loadManyByFieldEqualingAsync('stringField', 'huh'));
+        (0, globals_1.expect)(entities2).toHaveLength(2);
+        const entitiesLoadedByComposite2 = await (0, entityUtils_1.enforceResultsAsync)(entityLoaderFactory
+            .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
+            .loadManyByCompositeFieldEqualingAsync(['stringField', 'intField'], {
+            stringField: 'huh',
+            intField: 3,
+        }));
+        (0, globals_1.expect)(entitiesLoadedByComposite2).toHaveLength(2);
+    });
+    (0, globals_1.it)('throws error when field not valid', async () => {
+        const viewerContext = (0, ts_mockito_1.mock)();
+        const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+        const id1 = (0, uuid_1.v4)();
+        const { entityMutatorFactory } = createEntityMutatorFactory([
+            {
+                customIdField: id1,
+                stringField: 'huh',
+                testIndexedField: '3',
+                intField: 3,
+                dateField: new Date(),
+                nullableField: null,
+            },
+        ]);
+        await (0, globals_1.expect)(entityMutatorFactory
+            .forCreate(viewerContext, queryContext)
+            .setField('stringField', 10)
+            .createAsync()).rejects.toThrow('Entity field not valid: TestEntity (stringField = 10)');
+        const createdEntity = await (0, results_1.enforceAsyncResult)(entityMutatorFactory
+            .forCreate(viewerContext, queryContext)
+            .setField('stringField', 'hello')
+            .createAsync());
+        await (0, globals_1.expect)(entityMutatorFactory
+            .forUpdate(createdEntity, queryContext)
+            .setField('stringField', 10)
+            .updateAsync()).rejects.toThrow('Entity field not valid: TestEntity (stringField = 10)');
+    });
+    (0, globals_1.it)('returns error result when not authorized to create', async () => {
+        const entityCompanionProvider = (0, ts_mockito_1.instance)((0, ts_mockito_1.mock)(EntityCompanionProvider_1.EntityCompanionProvider));
+        const viewerContext = (0, ts_mockito_1.instance)((0, ts_mockito_1.mock)(ViewerContext_1.ViewerContext));
+        const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+        const privacyPolicyMock = (0, ts_mockito_1.mock)(SimpleTestEntity_1.SimpleTestEntityPrivacyPolicy);
+        const databaseAdapter = (0, ts_mockito_1.instance)((0, ts_mockito_1.mock)());
+        const metricsAdapter = (0, ts_mockito_1.instance)((0, ts_mockito_1.mock)());
+        const id1 = (0, uuid_1.v4)();
+        const fakeEntity = new SimpleTestEntity_1.SimpleTestEntity({
+            viewerContext,
+            id: id1,
+            selectedFields: {
+                id: id1,
+            },
+            databaseFields: {
+                id: id1,
+            },
+        });
+        const entityLoaderMock = (0, ts_mockito_1.mock)(AuthorizationResultBasedEntityLoader_1.AuthorizationResultBasedEntityLoader);
+        const entityLoaderUtilsMock = (0, ts_mockito_1.mock)(EntityLoaderUtils_1.EntityLoaderUtils);
+        (0, ts_mockito_1.when)(entityLoaderUtilsMock.constructEntity((0, ts_mockito_1.anything)())).thenReturn(fakeEntity);
+        (0, ts_mockito_1.when)(entityLoaderMock.utils).thenReturn((0, ts_mockito_1.instance)(entityLoaderUtilsMock));
+        const entityLoader = (0, ts_mockito_1.instance)(entityLoaderMock);
+        const entityLoaderFactoryMock = (0, ts_mockito_1.mock)(EntityLoaderFactory_1.EntityLoaderFactory);
+        (0, ts_mockito_1.when)(entityLoaderFactoryMock.forLoad(viewerContext, (0, ts_mockito_1.anyOfClass)(EntityQueryContext_1.EntityTransactionalQueryContext), (0, ts_mockito_1.anything)())).thenReturn(entityLoader);
+        const entityLoaderFactory = (0, ts_mockito_1.instance)(entityLoaderFactoryMock);
+        const rejectionError = new Error();
+        (0, ts_mockito_1.when)(privacyPolicyMock.authorizeCreateAsync(viewerContext, (0, ts_mockito_1.anyOfClass)(EntityQueryContext_1.EntityTransactionalQueryContext), (0, ts_mockito_1.anything)(), (0, ts_mockito_1.anyOfClass)(SimpleTestEntity_1.SimpleTestEntity), (0, ts_mockito_1.anything)())).thenReject(rejectionError);
+        (0, ts_mockito_1.when)(privacyPolicyMock.authorizeUpdateAsync(viewerContext, (0, ts_mockito_1.anyOfClass)(EntityQueryContext_1.EntityTransactionalQueryContext), (0, ts_mockito_1.anything)(), (0, ts_mockito_1.anyOfClass)(SimpleTestEntity_1.SimpleTestEntity), (0, ts_mockito_1.anything)())).thenReject(rejectionError);
+        (0, ts_mockito_1.when)(privacyPolicyMock.authorizeDeleteAsync(viewerContext, (0, ts_mockito_1.anyOfClass)(EntityQueryContext_1.EntityTransactionalQueryContext), (0, ts_mockito_1.anything)(), (0, ts_mockito_1.anyOfClass)(SimpleTestEntity_1.SimpleTestEntity), (0, ts_mockito_1.anything)())).thenReject(rejectionError);
+        const entityMutatorFactory = new EntityMutatorFactory_1.EntityMutatorFactory(entityCompanionProvider, SimpleTestEntity_1.simpleTestEntityConfiguration, SimpleTestEntity_1.SimpleTestEntity, (0, ts_mockito_1.instance)(privacyPolicyMock), [], {}, entityLoaderFactory, databaseAdapter, metricsAdapter);
+        const entityCreateResult = await entityMutatorFactory
+            .forCreate(viewerContext, queryContext)
+            .createAsync();
+        (0, globals_1.expect)(entityCreateResult.ok).toBe(false);
+        (0, globals_1.expect)(entityCreateResult.reason).toEqual(rejectionError);
+        (0, globals_1.expect)(entityCreateResult.value).toBe(undefined);
+        const entityUpdateResult = await entityMutatorFactory
+            .forUpdate(fakeEntity, queryContext)
+            .updateAsync();
+        (0, globals_1.expect)(entityUpdateResult.ok).toBe(false);
+        (0, globals_1.expect)(entityUpdateResult.reason).toEqual(rejectionError);
+        (0, globals_1.expect)(entityUpdateResult.value).toBe(undefined);
+        const entityDeleteResult = await entityMutatorFactory
+            .forDelete(fakeEntity, queryContext)
+            .deleteAsync();
+        (0, globals_1.expect)(entityDeleteResult.ok).toBe(false);
+        (0, globals_1.expect)(entityDeleteResult.reason).toEqual(rejectionError);
+        (0, globals_1.expect)(entityDeleteResult.value).toBe(undefined);
+    });
+    (0, globals_1.it)('throws error when db adapter throws', async () => {
+        const entityCompanionProviderMock = (0, ts_mockito_1.mock)(EntityCompanionProvider_1.EntityCompanionProvider);
+        (0, ts_mockito_1.when)(entityCompanionProviderMock.getCompanionForEntity(SimpleTestEntity_1.SimpleTestEntity)).thenReturn({
+            entityCompanionDefinition: SimpleTestEntity_1.SimpleTestEntity.defineCompanionDefinition(),
+        });
+        const entityCompanionProvider = (0, ts_mockito_1.instance)(entityCompanionProviderMock);
+        const viewerContext = (0, ts_mockito_1.instance)((0, ts_mockito_1.mock)(ViewerContext_1.ViewerContext));
+        const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+        const privacyPolicy = (0, ts_mockito_1.instance)((0, ts_mockito_1.mock)(SimpleTestEntity_1.SimpleTestEntityPrivacyPolicy));
+        const databaseAdapterMock = (0, ts_mockito_1.mock)();
+        const metricsAdapter = (0, ts_mockito_1.instance)((0, ts_mockito_1.mock)());
+        const id1 = (0, uuid_1.v4)();
+        const fakeEntity = new SimpleTestEntity_1.SimpleTestEntity({
+            viewerContext,
+            id: id1,
+            selectedFields: {
+                id: id1,
+            },
+            databaseFields: {
+                id: id1,
+            },
+        });
+        const entityLoaderMock = (0, ts_mockito_1.mock)(AuthorizationResultBasedEntityLoader_1.AuthorizationResultBasedEntityLoader);
+        const entityLoaderUtilsMock = (0, ts_mockito_1.mock)(EntityLoaderUtils_1.EntityLoaderUtils);
+        (0, ts_mockito_1.when)(entityLoaderUtilsMock.constructEntity((0, ts_mockito_1.anything)())).thenReturn(fakeEntity);
+        (0, ts_mockito_1.when)(entityLoaderMock.utils).thenReturn((0, ts_mockito_1.instance)(entityLoaderUtilsMock));
+        const entityLoader = (0, ts_mockito_1.instance)(entityLoaderMock);
+        const entityLoaderFactoryMock = (0, ts_mockito_1.mock)(EntityLoaderFactory_1.EntityLoaderFactory);
+        (0, ts_mockito_1.when)(entityLoaderFactoryMock.forLoad(viewerContext, (0, ts_mockito_1.anyOfClass)(EntityQueryContext_1.EntityTransactionalQueryContext), (0, ts_mockito_1.anything)())).thenReturn(entityLoader);
+        const entityLoaderFactory = (0, ts_mockito_1.instance)(entityLoaderFactoryMock);
+        const rejectionError = new Error();
+        (0, ts_mockito_1.when)(databaseAdapterMock.insertAsync((0, ts_mockito_1.anyOfClass)(EntityQueryContext_1.EntityTransactionalQueryContext), (0, ts_mockito_1.anything)())).thenReject(rejectionError);
+        (0, ts_mockito_1.when)(databaseAdapterMock.updateAsync((0, ts_mockito_1.anyOfClass)(EntityQueryContext_1.EntityTransactionalQueryContext), (0, ts_mockito_1.anything)(), (0, ts_mockito_1.anything)(), (0, ts_mockito_1.anything)())).thenReject(rejectionError);
+        (0, ts_mockito_1.when)(databaseAdapterMock.deleteAsync((0, ts_mockito_1.anyOfClass)(EntityQueryContext_1.EntityTransactionalQueryContext), (0, ts_mockito_1.anything)(), (0, ts_mockito_1.anything)())).thenReject(rejectionError);
+        const entityMutatorFactory = new EntityMutatorFactory_1.EntityMutatorFactory(entityCompanionProvider, SimpleTestEntity_1.simpleTestEntityConfiguration, SimpleTestEntity_1.SimpleTestEntity, privacyPolicy, [], {}, entityLoaderFactory, (0, ts_mockito_1.instance)(databaseAdapterMock), metricsAdapter);
+        await (0, globals_1.expect)(entityMutatorFactory.forCreate(viewerContext, queryContext).createAsync()).rejects.toEqual(rejectionError);
+        await (0, globals_1.expect)(entityMutatorFactory.forUpdate(fakeEntity, queryContext).updateAsync()).rejects.toEqual(rejectionError);
+        await (0, globals_1.expect)(entityMutatorFactory.forDelete(fakeEntity, queryContext).deleteAsync()).rejects.toEqual(rejectionError);
+    });
+    (0, globals_1.it)('records metrics appropriately', async () => {
+        const viewerContext = (0, ts_mockito_1.mock)();
+        const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+        const { entityMutatorFactory, metricsAdapter } = createEntityMutatorFactory([]);
+        const spiedMetricsAdapter = (0, ts_mockito_1.spy)(metricsAdapter);
+        const newEntity = await (0, results_1.enforceAsyncResult)(entityMutatorFactory
+            .forCreate(viewerContext, queryContext)
+            .setField('stringField', 'huh')
+            .createAsync());
+        await (0, results_1.enforceAsyncResult)(entityMutatorFactory
+            .forUpdate(newEntity, queryContext)
+            .setField('stringField', 'wat')
+            .updateAsync());
+        await (0, results_1.enforceAsyncResult)(entityMutatorFactory.forDelete(newEntity, queryContext).deleteAsync());
+        (0, ts_mockito_1.verify)(spiedMetricsAdapter.logMutatorMutationEvent((0, ts_mockito_1.objectContaining)({
+            type: IEntityMetricsAdapter_1.EntityMetricsMutationType.CREATE,
+            entityClassName: TestEntity_1.TestEntity.name,
+        }))).once();
+        (0, ts_mockito_1.verify)(spiedMetricsAdapter.logMutatorMutationEvent((0, ts_mockito_1.objectContaining)({
+            type: IEntityMetricsAdapter_1.EntityMetricsMutationType.UPDATE,
+            entityClassName: TestEntity_1.TestEntity.name,
+        }))).once();
+        (0, ts_mockito_1.verify)(spiedMetricsAdapter.logMutatorMutationEvent((0, ts_mockito_1.objectContaining)({
+            type: IEntityMetricsAdapter_1.EntityMetricsMutationType.DELETE,
+            entityClassName: TestEntity_1.TestEntity.name,
+        }))).once();
+        (0, ts_mockito_1.verify)(spiedMetricsAdapter.logMutatorMutationEvent((0, ts_mockito_1.anything)())).thrice();
+    });
+});
+//# sourceMappingURL=EntityMutator-test.js.map