@expo/entity 0.49.0 → 0.51.0

package/src/__tests__/EntityMutator-test.ts

@@ -30,7 +30,10 @@ import {
   EntityMutationTriggerConfiguration,
   EntityNonTransactionalMutationTrigger,
 } from '../EntityMutationTriggerConfiguration';
-import { EntityMutationValidator } from '../EntityMutationValidator';
+import {
+  EntityMutationValidator,
+  EntityMutationValidatorConfiguration,
+} from '../EntityMutationValidatorConfiguration';
 import { EntityMutatorFactory } from '../EntityMutatorFactory';
 import { EntityPrivacyPolicyEvaluationContext } from '../EntityPrivacyPolicy';
 import { EntityQueryContext, EntityTransactionalQueryContext } from '../EntityQueryContext';
@@ -57,6 +60,27 @@ import {
   TestFields,
 } from '../utils/__testfixtures__/TestEntity';
 
+class TestMutationValidator extends EntityMutationValidator<
+  TestFields,
+  'customIdField',
+  ViewerContext,
+  TestEntity,
+  keyof TestFields
+> {
+  async executeAsync(
+    _viewerContext: ViewerContext,
+    _queryContext: EntityQueryContext,
+    _entity: TestEntity,
+    _mutationInfo: EntityValidatorMutationInfo<
+      TestFields,
+      'customIdField',
+      ViewerContext,
+      TestEntity,
+      keyof TestFields
+    >,
+  ): Promise<void> {}
+}
+
 class TestMutationTrigger extends EntityMutationTrigger<
   TestFields,
   'customIdField',
@@ -89,33 +113,48 @@ class TestNonTransactionalMutationTrigger extends EntityNonTransactionalMutation
 }
 
 const setUpMutationValidatorSpies = (
-  mutationValidators: EntityMutationValidator<
+  mutationValidators: EntityMutationValidatorConfiguration<
     TestFields,
     'customIdField',
     ViewerContext,
     TestEntity,
     keyof TestFields
-  >[],
-): EntityMutationValidator<
+  >,
+): EntityMutationValidatorConfiguration<
   TestFields,
   'customIdField',
   ViewerContext,
   TestEntity,
   keyof TestFields
->[] => {
-  return mutationValidators.map((validator) => spy(validator));
+> => {
+  return {
+    beforeCreateAndUpdate: [spy(mutationValidators.beforeCreateAndUpdate![0]!)],
+    beforeDelete: [spy(mutationValidators.beforeDelete![0]!)],
+  };
 };
 
 const verifyValidatorCounts = (
   viewerContext: ViewerContext,
-  mutationValidatorSpies: EntityMutationValidator<
+  mutationValidatorSpies: EntityMutationValidatorConfiguration<
     TestFields,
     'customIdField',
     ViewerContext,
     TestEntity,
     keyof TestFields
-  >[],
-  expectedCalls: number,
+  >,
+  executed: Record<
+    keyof Pick<
+      EntityMutationValidatorConfiguration<
+        TestFields,
+        'customIdField',
+        ViewerContext,
+        TestEntity,
+        keyof TestFields
+      >,
+      'beforeCreateAndUpdate' | 'beforeDelete'
+    >,
+    boolean
+  >,
   mutationInfo: EntityValidatorMutationInfo<
     TestFields,
     'customIdField',
@@ -124,16 +163,28 @@ const verifyValidatorCounts = (
     keyof TestFields
   >,
 ): void => {
-  for (const validator of mutationValidatorSpies) {
-    verify(
-      validator.executeAsync(
-        viewerContext,
-        anyOfClass(EntityTransactionalQueryContext),
-        anyOfClass(TestEntity),
-        deepEqual(mutationInfo),
-      ),
-    ).times(expectedCalls);
-  }
+  Object.keys(executed).forEach((s) => {
+    const sk = s as keyof typeof executed;
+    if (executed[sk]) {
+      verify(
+        mutationValidatorSpies[sk]![0]!.executeAsync(
+          viewerContext,
+          anyOfClass(EntityTransactionalQueryContext),
+          anyOfClass(TestEntity),
+          deepEqual(mutationInfo),
+        ),
+      ).once();
+    } else {
+      verify(
+        mutationValidatorSpies[sk]![0]!.executeAsync(
+          viewerContext,
+          anyOfClass(EntityTransactionalQueryContext),
+          anyOfClass(TestEntity),
+          deepEqual(mutationInfo),
+        ),
+      ).never();
+    }
+  });
 };
 
 const setUpMutationTriggerSpies = (
@@ -200,9 +251,10 @@ const verifyTriggerCounts = (
   >,
 ): void => {
   Object.keys(executed).forEach((s) => {
-    if ((executed as any)[s]) {
+    const sk = s as keyof typeof executed;
+    if (executed[sk]) {
       verify(
-        (mutationTriggerSpies as any)[s]![0].executeAsync(
+        mutationTriggerSpies[sk]![0]!.executeAsync(
           viewerContext,
           anyOfClass(EntityTransactionalQueryContext),
           anyOfClass(TestEntity),
@@ -211,7 +263,7 @@ const verifyTriggerCounts = (
       ).once();
     } else {
       verify(
-        (mutationTriggerSpies as any)[s]![0].executeAsync(
+        mutationTriggerSpies[sk]![0]!.executeAsync(
           viewerContext,
           anyOfClass(EntityTransactionalQueryContext),
           anyOfClass(TestEntity),
@@ -268,13 +320,13 @@ const createEntityMutatorFactory = (
     TestEntityPrivacyPolicy
   >;
   metricsAdapter: IEntityMetricsAdapter;
-  mutationValidators: EntityMutationValidator<
+  mutationValidators: EntityMutationValidatorConfiguration<
     TestFields,
     'customIdField',
     ViewerContext,
     TestEntity,
     keyof TestFields
-  >[];
+  >;
   mutationTriggers: EntityMutationTriggerConfiguration<
     TestFields,
     'customIdField',
@@ -283,13 +335,16 @@ const createEntityMutatorFactory = (
     keyof TestFields
   >;
 } => {
-  const mutationValidators: EntityMutationValidator<
+  const mutationValidators: EntityMutationValidatorConfiguration<
     TestFields,
     'customIdField',
     ViewerContext,
     TestEntity,
     keyof TestFields
-  >[] = [new TestMutationTrigger()];
+  > = {
+    beforeCreateAndUpdate: [new TestMutationValidator()],
+    beforeDelete: [new TestMutationValidator()],
+  };
   const mutationTriggers: EntityMutationTriggerConfiguration<
     TestFields,
     'customIdField',
@@ -547,7 +602,15 @@ describe(EntityMutatorFactory, () => {
           .createAsync(),
       );
 
-      verifyValidatorCounts(viewerContext, validatorSpies, 1, { type: EntityMutationType.CREATE });
+      verifyValidatorCounts(
+        viewerContext,
+        validatorSpies,
+        {
+          beforeCreateAndUpdate: true,
+          beforeDelete: false,
+        },
+        { type: EntityMutationType.CREATE },
+      );
     });
   });
 
@@ -801,11 +864,19 @@ describe(EntityMutatorFactory, () => {
           .updateAsync(),
       );
 
-      verifyValidatorCounts(viewerContext, validatorSpies, 1, {
-        type: EntityMutationType.UPDATE,
-        previousValue: existingEntity,
-        cascadingDeleteCause: null,
-      });
+      verifyValidatorCounts(
+        viewerContext,
+        validatorSpies,
+        {
+          beforeCreateAndUpdate: true,
+          beforeDelete: false,
+        },
+        {
+          type: EntityMutationType.UPDATE,
+          previousValue: existingEntity,
+          cascadingDeleteCause: null,
+        },
+      );
     });
 
     it('passes manaully-specified cascading delete cause to privacy policy and validators and triggers', async () => {
@@ -893,11 +964,19 @@ describe(EntityMutatorFactory, () => {
         ),
       ).once();
 
-      verifyValidatorCounts(viewerContext, validatorSpies, 1, {
-        type: EntityMutationType.UPDATE,
-        previousValue: existingEntity,
-        cascadingDeleteCause,
-      });
+      verifyValidatorCounts(
+        viewerContext,
+        validatorSpies,
+        {
+          beforeCreateAndUpdate: true,
+          beforeDelete: false,
+        },
+        {
+          type: EntityMutationType.UPDATE,
+          previousValue: existingEntity,
+          cascadingDeleteCause,
+        },
+      );
 
       verifyTriggerCounts(
         viewerContext,
@@ -1133,7 +1212,7 @@ describe(EntityMutatorFactory, () => {
       );
     });
 
-    it('does not execute validators', async () => {
+    it('executes validators', async () => {
       const viewerContext = mock<ViewerContext>();
       const privacyPolicyEvaluationContext =
         instance(
@@ -1176,9 +1255,18 @@ describe(EntityMutatorFactory, () => {
           .deleteAsync(),
       );
 
-      verifyValidatorCounts(viewerContext, validatorSpies, 0, {
-        type: EntityMutationType.DELETE as any,
-      });
+      verifyValidatorCounts(
+        viewerContext,
+        validatorSpies,
+        {
+          beforeCreateAndUpdate: false,
+          beforeDelete: true,
+        },
+        {
+          type: EntityMutationType.DELETE,
+          cascadingDeleteCause: null,
+        },
+      );
     });
 
     it('passes manaully-specified cascading delete cause to privacy policy and triggers', async () => {
@@ -1198,20 +1286,26 @@ describe(EntityMutatorFactory, () => {
       const queryContext = new StubQueryContextProvider().getQueryContext();
 
       const id1 = uuidv4();
-      const { mutationTriggers, privacyPolicy, entityMutatorFactory, entityLoaderFactory } =
-        createEntityMutatorFactory([
-          {
-            customIdField: id1,
-            stringField: 'huh',
-            testIndexedField: '3',
-            intField: 3,
-            dateField: new Date(),
-            nullableField: null,
-          },
-        ]);
+      const {
+        mutationTriggers,
+        mutationValidators,
+        privacyPolicy,
+        entityMutatorFactory,
+        entityLoaderFactory,
+      } = createEntityMutatorFactory([
+        {
+          customIdField: id1,
+          stringField: 'huh',
+          testIndexedField: '3',
+          intField: 3,
+          dateField: new Date(),
+          nullableField: null,
+        },
+      ]);
 
       const spiedPrivacyPolicy = spy(privacyPolicy);
       const triggerSpies = setUpMutationTriggerSpies(mutationTriggers);
+      const validatorSpies = setUpMutationValidatorSpies(mutationValidators);
 
       const existingEntity = await enforceAsyncResult(
         entityLoaderFactory
@@ -1240,6 +1334,19 @@ describe(EntityMutatorFactory, () => {
         ),
       ).once();
 
+      verifyValidatorCounts(
+        viewerContext,
+        validatorSpies,
+        {
+          beforeCreateAndUpdate: false,
+          beforeDelete: true,
+        },
+        {
+          type: EntityMutationType.DELETE,
+          cascadingDeleteCause,
+        },
+      );
+
       verifyTriggerCounts(
         viewerContext,
         triggerSpies,
@@ -1462,7 +1569,7 @@ describe(EntityMutatorFactory, () => {
       simpleTestEntityConfiguration,
       SimpleTestEntity,
       instance(privacyPolicyMock),
-      [],
+      {},
       {},
       entityLoaderFactory,
       databaseAdapter,
@@ -1588,7 +1695,7 @@ describe(EntityMutatorFactory, () => {
       simpleTestEntityConfiguration,
       SimpleTestEntity,
       privacyPolicy,
-      [],
+      {},
       {},
       entityLoaderFactory,
       instance(databaseAdapterMock),

package/src/__tests__/GenericEntityCacheAdapter-test.ts

@@ -3,6 +3,7 @@ import { anything, deepEqual, instance, mock, verify, when } from 'ts-mockito';
 
 import { GenericEntityCacheAdapter } from '../GenericEntityCacheAdapter';
 import { IEntityGenericCacher } from '../IEntityGenericCacher';
+import { EntityCacheAdapterTransientError } from '../errors/EntityCacheAdapterError';
 import { CacheStatus } from '../internal/ReadThroughEntityCache';
 import {
   SingleFieldHolder,
@@ -68,6 +69,29 @@ describe(GenericEntityCacheAdapter, () => {
       );
       expect(results).toEqual(new SingleFieldValueHolderMap(new Map()));
     });
+
+    it('rethrows EntityCacheAdapterTransientError from underlying cacher', async () => {
+      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
+      when(
+        mockGenericCacher.makeCacheKeyForStorage(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          anything(),
+        ),
+      ).thenCall((fieldHolder, fieldValueHolder) => {
+        return `${fieldHolder.fieldName}.${fieldValueHolder.fieldValue}`;
+      });
+      const expectedError = new EntityCacheAdapterTransientError('Transient error');
+      when(mockGenericCacher.loadManyAsync(deepEqual(['id.wat']))).thenReject(expectedError);
+
+      const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
+      await expect(
+        cacheAdapter.loadManyAsync(new SingleFieldHolder('id'), [
+          new SingleFieldValueHolder('wat'),
+        ]),
+      ).rejects.toThrow(expectedError);
+
+      verify(mockGenericCacher.loadManyAsync(anything())).once();
+    });
   });
 
   describe('cacheManyAsync', () => {

package/src/__tests__/GenericSecondaryEntityCache-test.ts

@@ -0,0 +1,180 @@
+import { describe, it, expect } from '@jest/globals';
+import nullthrows from 'nullthrows';
+
+import { EntitySecondaryCacheLoader } from '../EntitySecondaryCacheLoader';
+import { GenericSecondaryEntityCache } from '../GenericSecondaryEntityCache';
+import { IEntityGenericCacher } from '../IEntityGenericCacher';
+import { ViewerContext } from '../ViewerContext';
+import { IEntityLoadKey, IEntityLoadValue } from '../internal/EntityLoadInterfaces';
+import { CacheLoadResult, CacheStatus } from '../internal/ReadThroughEntityCache';
+import {
+  TestEntity,
+  TestEntityPrivacyPolicy,
+  TestFields,
+} from '../utils/__testfixtures__/TestEntity';
+import { createUnitTestEntityCompanionProvider } from '../utils/__testfixtures__/createUnitTestEntityCompanionProvider';
+import { mapMapAsync } from '../utils/collections/maps';
+
+type TestLoadParams = { intValue: number };
+
+const DOES_NOT_EXIST = Symbol('doesNotExist');
+
+class TestGenericCacher implements IEntityGenericCacher<TestFields, 'customIdField'> {
+  private readonly localMemoryCache = new Map<
+    string,
+    Readonly<TestFields> | typeof DOES_NOT_EXIST
+  >();
+
+  public async loadManyAsync(
+    keys: readonly string[],
+  ): Promise<ReadonlyMap<string, CacheLoadResult<TestFields>>> {
+    const cacheResults = new Map<string, CacheLoadResult<TestFields>>();
+    for (const key of keys) {
+      const cacheResult = this.localMemoryCache.get(key);
+      if (cacheResult === DOES_NOT_EXIST) {
+        cacheResults.set(key, {
+          status: CacheStatus.NEGATIVE,
+        });
+      } else if (cacheResult) {
+        cacheResults.set(key, {
+          status: CacheStatus.HIT,
+          item: cacheResult as unknown as TestFields,
+        });
+      } else {
+        cacheResults.set(key, {
+          status: CacheStatus.MISS,
+        });
+      }
+    }
+    return cacheResults;
+  }
+
+  public async cacheManyAsync(objectMap: ReadonlyMap<string, Readonly<TestFields>>): Promise<void> {
+    for (const [key, item] of objectMap) {
+      this.localMemoryCache.set(key, item);
+    }
+  }
+
+  public async cacheDBMissesAsync(keys: readonly string[]): Promise<void> {
+    for (const key of keys) {
+      this.localMemoryCache.set(key, DOES_NOT_EXIST);
+    }
+  }
+
+  public async invalidateManyAsync(keys: readonly string[]): Promise<void> {
+    for (const key of keys) {
+      this.localMemoryCache.delete(key);
+    }
+  }
+
+  makeCacheKeyForStorage<
+    TLoadKey extends IEntityLoadKey<TestFields, 'customIdField', TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(_key: TLoadKey, _value: TLoadValue): string {
+    throw new Error('Method not used by this test.');
+  }
+
+  makeCacheKeysForInvalidation<
+    TLoadKey extends IEntityLoadKey<TestFields, 'customIdField', TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(_key: TLoadKey, _value: TLoadValue): readonly string[] {
+    throw new Error('Method not used by this test.');
+  }
+}
+
+class TestSecondaryEntityCache<
+  TFields extends Record<string, any>,
+  TIDField extends keyof TFields,
+  TLoadParams,
+> extends GenericSecondaryEntityCache<TFields, TIDField, TLoadParams> {}
+
+class TestSecondaryCacheLoader extends EntitySecondaryCacheLoader<
+  TestLoadParams,
+  TestFields,
+  'customIdField',
+  ViewerContext,
+  TestEntity,
+  TestEntityPrivacyPolicy
+> {
+  public databaseLoadCount = 0;
+
+  protected override async fetchObjectsFromDatabaseAsync(
+    loadParamsArray: readonly Readonly<TestLoadParams>[],
+  ): Promise<ReadonlyMap<Readonly<Readonly<TestLoadParams>>, Readonly<TestFields> | null>> {
+    this.databaseLoadCount += loadParamsArray.length;
+
+    const emptyMap = new Map(loadParamsArray.map((p) => [p, null]));
+    return await mapMapAsync(emptyMap, async (_value, loadParams) => {
+      return (
+        (
+          await this.entityLoader.loadManyByFieldEqualityConjunctionAsync([
+            { fieldName: 'intField', fieldValue: loadParams.intValue },
+          ])
+        )[0]
+          ?.enforceValue()
+          ?.getAllFields() ?? null
+      );
+    });
+  }
+}
+
+describe(GenericSecondaryEntityCache, () => {
+  it('Loads through secondary loader, caches, and invalidates', async () => {
+    const viewerContext = new ViewerContext(createUnitTestEntityCompanionProvider());
+
+    const createdEntity = await TestEntity.creator(viewerContext)
+      .setField('intField', 1)
+      .createAsync();
+
+    const secondaryCacheLoader = new TestSecondaryCacheLoader(
+      new TestSecondaryEntityCache(
+        new TestGenericCacher(),
+        (params) => `intValue.${params.intValue}`,
+      ),
+      TestEntity.loaderWithAuthorizationResults(viewerContext),
+    );
+
+    const loadParams = { intValue: 1 };
+    const results = await secondaryCacheLoader.loadManyAsync([loadParams]);
+    expect(nullthrows(results.get(loadParams)).enforceValue().getID()).toEqual(
+      createdEntity.getID(),
+    );
+
+    expect(secondaryCacheLoader.databaseLoadCount).toEqual(1);
+
+    const results2 = await secondaryCacheLoader.loadManyAsync([loadParams]);
+    expect(nullthrows(results2.get(loadParams)).enforceValue().getID()).toEqual(
+      createdEntity.getID(),
+    );
+
+    expect(secondaryCacheLoader.databaseLoadCount).toEqual(1);
+
+    await secondaryCacheLoader.invalidateManyAsync([loadParams]);
+
+    const results3 = await secondaryCacheLoader.loadManyAsync([loadParams]);
+    expect(nullthrows(results3.get(loadParams)).enforceValue().getID()).toEqual(
+      createdEntity.getID(),
+    );
+
+    expect(secondaryCacheLoader.databaseLoadCount).toEqual(2);
+  });
+
+  it('correctly handles uncached and unfetchable load params', async () => {
+    const viewerContext = new ViewerContext(createUnitTestEntityCompanionProvider());
+
+    const secondaryCacheLoader = new TestSecondaryCacheLoader(
+      new TestSecondaryEntityCache(
+        new TestGenericCacher(),
+        (params) => `intValue.${params.intValue}`,
+      ),
+      TestEntity.loaderWithAuthorizationResults(viewerContext),
+    );
+
+    const loadParams = { intValue: 2 };
+    const results = await secondaryCacheLoader.loadManyAsync([loadParams]);
+    expect(results.size).toBe(1);
+    expect(results.get(loadParams)).toBe(null);
+  });
+});

package/src/index.ts

@@ -29,7 +29,7 @@ export * from './EntityLoaderFactory';
 export * from './EntityLoaderUtils';
 export * from './EntityMutationInfo';
 export * from './EntityMutationTriggerConfiguration';
-export * from './EntityMutationValidator';
+export * from './EntityMutationValidatorConfiguration';
 export * from './EntityMutatorFactory';
 export * from './EntityPrivacyPolicy';
 export * from './EntityQueryContext';

package/src/utils/__testfixtures__/PrivacyPolicyRuleTestUtils.ts

@@ -11,7 +11,7 @@ export interface Case<
   TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
-  TSelectedFields extends keyof TFields,
+  TSelectedFields extends keyof TFields = keyof TFields,
 > {
   viewerContext: TViewerContext;
   queryContext: EntityQueryContext;
@@ -30,7 +30,7 @@ export type CaseMap<
   TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
-  TSelectedFields extends keyof TFields,
+  TSelectedFields extends keyof TFields = keyof TFields,
 > = Map<string, () => Promise<Case<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>>>;
 
 /**

package/src/utils/__testfixtures__/StubDatabaseAdapter.ts

@@ -234,7 +234,13 @@ export class StubDatabaseAdapter<
     const objectIndex = objectCollection.findIndex((obj) => {
       return obj[tableIdField] === id;
     });
-    invariant(objectIndex >= 0, 'should exist');
+
+    // SQL updates to a nonexistent row succeed but affect 0 rows,
+    // mirror that behavior here for better test simulation
+    if (objectIndex < 0) {
+      return [];
+    }
+
     objectCollection[objectIndex] = {
       ...objectCollection[objectIndex],
       ...object,
@@ -253,9 +259,13 @@ export class StubDatabaseAdapter<
     const objectIndex = objectCollection.findIndex((obj) => {
       return obj[tableIdField] === id;
     });
+
+    // SQL deletes to a nonexistent row succeed and affect 0 rows,
+    // mirror that behavior here for better test simulation
     if (objectIndex < 0) {
       return 0;
     }
+
     objectCollection.splice(objectIndex, 1);
     return 1;
   }

package/build/src/EntityMutationValidator.d.ts

@@ -1,11 +0,0 @@
-import { EntityValidatorMutationInfo } from './EntityMutationInfo';
-import { EntityTransactionalQueryContext } from './EntityQueryContext';
-import { ReadonlyEntity } from './ReadonlyEntity';
-import { ViewerContext } from './ViewerContext';
-/**
- * A validator is a way to specify entity mutation validation that runs within the
- * same transaction as the mutation itself before creating or updating an entity.
- */
-export declare abstract class EntityMutationValidator<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 = keyof TFields> {
-    abstract executeAsync(viewerContext: TViewerContext, queryContext: EntityTransactionalQueryContext, entity: TEntity, mutationInfo: EntityValidatorMutationInfo<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>): Promise<void>;
-}

package/build/src/EntityMutationValidator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"EntityMutationValidator.js","sourceRoot":"","sources":["../../src/EntityMutationValidator.ts"],"names":[],"mappings":";;;AAKA;;;GAGG;AACH,MAAsB,uBAAuB;CAmB5C;AAnBD,0DAmBC"}

package/src/EntityMutationValidator.ts

@@ -1,29 +0,0 @@
-import { EntityValidatorMutationInfo } from './EntityMutationInfo';
-import { EntityTransactionalQueryContext } from './EntityQueryContext';
-import { ReadonlyEntity } from './ReadonlyEntity';
-import { ViewerContext } from './ViewerContext';
-
-/**
- * A validator is a way to specify entity mutation validation that runs within the
- * same transaction as the mutation itself before creating or updating an entity.
- */
-export abstract class EntityMutationValidator<
-  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 = keyof TFields,
-> {
-  abstract executeAsync(
-    viewerContext: TViewerContext,
-    queryContext: EntityTransactionalQueryContext,
-    entity: TEntity,
-    mutationInfo: EntityValidatorMutationInfo<
-      TFields,
-      TIDField,
-      TViewerContext,
-      TEntity,
-      TSelectedFields
-    >,
-  ): Promise<void>;
-}