@expo/entity 0.35.0 → 0.36.0

package/src/utils/collections/maps.ts

@@ -11,7 +11,7 @@ import invariant from 'invariant';
 export const computeIfAbsent = <K, V>(
   map: Map<K, V>,
   key: K,
-  mappingFunction: (key: K) => V
+  mappingFunction: (key: K) => V,
 ): V => {
   if (!map.has(key)) {
     const value = mappingFunction(key);
@@ -28,7 +28,7 @@ export const computeIfAbsent = <K, V>(
  */
 export const mapMap = <K, V, M>(
   map: ReadonlyMap<K, V>,
-  mapper: (value: V, key: K) => M
+  mapper: (value: V, key: K) => M,
 ): Map<K, M> => {
   const resultingMap = new Map();
   for (const [k, v] of map) {
@@ -45,7 +45,7 @@ export const mapMap = <K, V, M>(
  */
 export const mapMapAsync = async function <K, V, M>(
   map: ReadonlyMap<K, V>,
-  mapper: (value: V, key: K) => Promise<M>
+  mapper: (value: V, key: K) => Promise<M>,
 ): Promise<Map<K, M>> {
   const resultingMap: Map<K, M> = new Map();
   await Promise.all(
@@ -53,7 +53,7 @@ export const mapMapAsync = async function <K, V, M>(
       const initialValue = map.get(k) as V;
       const result = await mapper(initialValue, k);
       resultingMap.set(k, result);
-    })
+    }),
   );
   return resultingMap;
 };
@@ -69,7 +69,7 @@ export const mapMapAsync = async function <K, V, M>(
  */
 export const mapKeys = <K, V, K2>(
   map: ReadonlyMap<K, V>,
-  mapper: (key: K, value: V) => K2
+  mapper: (key: K, value: V) => K2,
 ): Map<K2, V> => {
   const resultingMap = new Map();
   for (const [k, v] of map) {
@@ -92,7 +92,7 @@ export const mapKeys = <K, V, K2>(
 export const zipToMap = <K, V>(keys: readonly K[], values: readonly V[]): Map<K, V> => {
   invariant(
     keys.length === values.length,
-    `zipToMap input length mismatch: keys[${keys.length}], values[${values.length}]`
+    `zipToMap input length mismatch: keys[${keys.length}], values[${values.length}]`,
   );
   const resultingMap = new Map();
   for (let i = 0; i < keys.length; i++) {
@@ -126,7 +126,7 @@ export const invertMap = <K, V>(map: ReadonlyMap<K, V>): Map<V, K> => {
 export const reduceMap = <K, V, A>(
   map: ReadonlyMap<K, V>,
   reducer: (accumulator: A, value: V, key: K) => A,
-  initialValue: A
+  initialValue: A,
 ): A => {
   let newAccumulator = initialValue;
   for (const [k, v] of map) {
@@ -147,7 +147,7 @@ export const reduceMap = <K, V, A>(
 export const reduceMapAsync = async <K, V, A>(
   map: ReadonlyMap<K, V>,
   reducer: (accumulator: A, value: V, key: K) => Promise<A>,
-  initialValue: A
+  initialValue: A,
 ): Promise<A> => {
   let newAccumulator = initialValue;
   for (const [k, v] of map) {
@@ -163,7 +163,7 @@ export const reduceMapAsync = async <K, V, A>(
  */
 export function filterMap<K, V, S extends V>(
   map: ReadonlyMap<K, V>,
-  predicate: (value: V, key: K) => value is S
+  predicate: (value: V, key: K) => value is S,
 ): Map<K, S>;
 
 /**
@@ -173,7 +173,7 @@ export function filterMap<K, V, S extends V>(
  */
 export function filterMap<K, V>(
   map: ReadonlyMap<K, V>,
-  predicate: (value: V, key: K) => boolean
+  predicate: (value: V, key: K) => boolean,
 ): Map<K, V>;
 
 /**
@@ -183,7 +183,7 @@ export function filterMap<K, V>(
  */
 export function filterMap<K, V>(
   map: ReadonlyMap<K, V>,
-  predicate: (value: V, key: K) => unknown
+  predicate: (value: V, key: K) => unknown,
 ): Map<K, V> {
   const resultingMap = new Map();
   map.forEach((v, k) => {

package/src/utils/mergeEntityMutationTriggerConfigurations.ts

@@ -0,0 +1,44 @@
+import EntityMutationTriggerConfiguration from '../EntityMutationTriggerConfiguration';
+import ReadonlyEntity from '../ReadonlyEntity';
+import ViewerContext from '../ViewerContext';
+
+function nonNullish<TValue>(value: TValue | null | undefined): value is NonNullable<TValue> {
+  return value !== null && value !== undefined;
+}
+
+export function mergeEntityMutationTriggerConfigurations<
+  TFields extends object,
+  TID extends NonNullable<TFields[TSelectedFields]>,
+  TViewerContext extends ViewerContext,
+  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TSelectedFields extends keyof TFields,
+>(
+  ...mutationTriggerConfigurations: EntityMutationTriggerConfiguration<
+    TFields,
+    TID,
+    TViewerContext,
+    TEntity,
+    TSelectedFields
+  >[]
+): EntityMutationTriggerConfiguration<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
+  const merged = {
+    beforeCreate: mutationTriggerConfigurations.flatMap((c) => c.beforeCreate).filter(nonNullish),
+    afterCreate: mutationTriggerConfigurations.flatMap((c) => c.afterCreate).filter(nonNullish),
+    beforeUpdate: mutationTriggerConfigurations.flatMap((c) => c.beforeUpdate).filter(nonNullish),
+    afterUpdate: mutationTriggerConfigurations.flatMap((c) => c.afterUpdate).filter(nonNullish),
+    beforeDelete: mutationTriggerConfigurations.flatMap((c) => c.beforeDelete).filter(nonNullish),
+    afterDelete: mutationTriggerConfigurations.flatMap((c) => c.afterDelete).filter(nonNullish),
+    beforeAll: mutationTriggerConfigurations.flatMap((c) => c.beforeAll).filter(nonNullish),
+    afterAll: mutationTriggerConfigurations.flatMap((c) => c.afterAll).filter(nonNullish),
+    afterCommit: mutationTriggerConfigurations.flatMap((c) => c.afterCommit).filter(nonNullish),
+  };
+
+  /** Remove any trigger that is an empty array */
+  for (const key of Object.keys(merged) as (keyof typeof merged)[]) {
+    if (merged[key].length === 0) {
+      delete merged[key];
+    }
+  }
+
+  return merged;
+}

package/src/utils/testing/PrivacyPolicyRuleTestUtils.ts

@@ -9,11 +9,17 @@ export interface Case<
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
-  TSelectedFields extends keyof TFields
+  TSelectedFields extends keyof TFields,
 > {
   viewerContext: TViewerContext;
   queryContext: EntityQueryContext;
-  evaluationContext: EntityPrivacyPolicyEvaluationContext;
+  evaluationContext: EntityPrivacyPolicyEvaluationContext<
+    TFields,
+    TID,
+    TViewerContext,
+    TEntity,
+    TSelectedFields
+  >;
   entity: TEntity;
 }
 
@@ -22,7 +28,7 @@ export type CaseMap<
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
-  TSelectedFields extends keyof TFields
+  TSelectedFields extends keyof TFields,
 > = Map<string, () => Promise<Case<TFields, TID, TViewerContext, TEntity, TSelectedFields>>>;
 
 /**
@@ -33,7 +39,7 @@ export const describePrivacyPolicyRuleWithAsyncTestCase = <
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
-  TSelectedFields extends keyof TFields = keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields,
 >(
   privacyPolicyRule: PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>,
   {
@@ -44,17 +50,16 @@ export const describePrivacyPolicyRuleWithAsyncTestCase = <
     allowCases?: CaseMap<TFields, TID, TViewerContext, TEntity, TSelectedFields>;
     skipCases?: CaseMap<TFields, TID, TViewerContext, TEntity, TSelectedFields>;
     denyCases?: CaseMap<TFields, TID, TViewerContext, TEntity, TSelectedFields>;
-  }
+  },
 ): void => {
   describe(privacyPolicyRule.constructor.name, () => {
     if (allowCases && allowCases.size > 0) {
       describe('allow cases', () => {
         test.each(Array.from(allowCases.keys()))('%p', async (caseKey) => {
-          const { viewerContext, queryContext, evaluationContext, entity } = await allowCases.get(
-            caseKey
-          )!();
+          const { viewerContext, queryContext, evaluationContext, entity } =
+            await allowCases.get(caseKey)!();
           await expect(
-            privacyPolicyRule.evaluateAsync(viewerContext, queryContext, evaluationContext, entity)
+            privacyPolicyRule.evaluateAsync(viewerContext, queryContext, evaluationContext, entity),
           ).resolves.toEqual(RuleEvaluationResult.ALLOW);
         });
       });
@@ -63,11 +68,10 @@ export const describePrivacyPolicyRuleWithAsyncTestCase = <
     if (skipCases && skipCases.size > 0) {
       describe('skip cases', () => {
         test.each(Array.from(skipCases.keys()))('%p', async (caseKey) => {
-          const { viewerContext, queryContext, evaluationContext, entity } = await skipCases.get(
-            caseKey
-          )!();
+          const { viewerContext, queryContext, evaluationContext, entity } =
+            await skipCases.get(caseKey)!();
           await expect(
-            privacyPolicyRule.evaluateAsync(viewerContext, queryContext, evaluationContext, entity)
+            privacyPolicyRule.evaluateAsync(viewerContext, queryContext, evaluationContext, entity),
           ).resolves.toEqual(RuleEvaluationResult.SKIP);
         });
       });
@@ -76,11 +80,10 @@ export const describePrivacyPolicyRuleWithAsyncTestCase = <
     if (denyCases && denyCases.size > 0) {
       describe('deny cases', () => {
         test.each(Array.from(denyCases.keys()))('%p', async (caseKey) => {
-          const { viewerContext, queryContext, evaluationContext, entity } = await denyCases.get(
-            caseKey
-          )!();
+          const { viewerContext, queryContext, evaluationContext, entity } =
+            await denyCases.get(caseKey)!();
           await expect(
-            privacyPolicyRule.evaluateAsync(viewerContext, queryContext, evaluationContext, entity)
+            privacyPolicyRule.evaluateAsync(viewerContext, queryContext, evaluationContext, entity),
           ).resolves.toEqual(RuleEvaluationResult.DENY);
         });
       });
@@ -96,7 +99,7 @@ export const describePrivacyPolicyRule = <
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
-  TSelectedFields extends keyof TFields = keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields,
 >(
   privacyPolicyRule: PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>,
   {
@@ -107,21 +110,21 @@ export const describePrivacyPolicyRule = <
     allowCases?: Case<TFields, TID, TViewerContext, TEntity, TSelectedFields>[];
     skipCases?: Case<TFields, TID, TViewerContext, TEntity, TSelectedFields>[];
     denyCases?: Case<TFields, TID, TViewerContext, TEntity, TSelectedFields>[];
-  }
+  },
 ): void => {
   const makeCasesMap = (
-    cases: Case<TFields, TID, TViewerContext, TEntity, TSelectedFields>[]
+    cases: Case<TFields, TID, TViewerContext, TEntity, TSelectedFields>[],
   ): CaseMap<TFields, TID, TViewerContext, TEntity, TSelectedFields> =>
     cases.reduce(
       (
         acc: CaseMap<TFields, TID, TViewerContext, TEntity, TSelectedFields>,
         testCase: Case<TFields, TID, TViewerContext, TEntity, TSelectedFields>,
-        index
+        index,
       ) => {
         acc.set(`case ${index}`, async () => testCase);
         return acc;
       },
-      new Map()
+      new Map(),
     );
 
   return describePrivacyPolicyRuleWithAsyncTestCase(privacyPolicyRule, {

package/src/utils/testing/StubCacheAdapter.ts

@@ -6,8 +6,8 @@ import IEntityCacheAdapterProvider from '../../IEntityCacheAdapterProvider';
 import { CacheStatus, CacheLoadResult } from '../../internal/ReadThroughEntityCache';
 
 export class NoCacheStubCacheAdapterProvider implements IEntityCacheAdapterProvider {
-  getCacheAdapter<TFields>(
-    _entityConfiguration: EntityConfiguration<TFields>
+  getCacheAdapter<TFields extends Record<string, any>>(
+    _entityConfiguration: EntityConfiguration<TFields>,
   ): IEntityCacheAdapter<TFields> {
     return new NoCacheStubCacheAdapter();
   }
@@ -16,7 +16,7 @@ export class NoCacheStubCacheAdapterProvider implements IEntityCacheAdapterProvi
 export class NoCacheStubCacheAdapter<TFields> implements IEntityCacheAdapter<TFields> {
   public async loadManyAsync<N extends keyof TFields>(
     _fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult<TFields>>> {
     return fieldValues.reduce((acc: Map<NonNullable<TFields[N]>, CacheLoadResult<TFields>>, v) => {
       acc.set(v, {
@@ -28,42 +28,44 @@ export class NoCacheStubCacheAdapter<TFields> implements IEntityCacheAdapter<TFi
 
   public async cacheManyAsync<N extends keyof TFields>(
     _fieldName: N,
-    _objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>
+    _objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>,
   ): Promise<void> {}
 
   public async cacheDBMissesAsync<N extends keyof TFields>(
     _fieldName: N,
-    _fieldValues: readonly NonNullable<TFields[N]>[]
+    _fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<void> {}
 
   async invalidateManyAsync<N extends keyof TFields>(
     _fieldName: N,
-    _fieldValues: readonly TFields[N][]
+    _fieldValues: readonly TFields[N][],
   ): Promise<void> {}
 }
 
 export class InMemoryFullCacheStubCacheAdapterProvider implements IEntityCacheAdapterProvider {
   cache: Map<string, Readonly<object>> = new Map();
 
-  getCacheAdapter<TFields>(
-    entityConfiguration: EntityConfiguration<TFields>
+  getCacheAdapter<TFields extends Record<string, any>>(
+    entityConfiguration: EntityConfiguration<TFields>,
   ): IEntityCacheAdapter<TFields> {
     return new InMemoryFullCacheStubCacheAdapter(
       entityConfiguration,
-      this.cache as Map<string, Readonly<TFields>>
+      this.cache as Map<string, Readonly<TFields>>,
     );
   }
 }
 
-export class InMemoryFullCacheStubCacheAdapter<TFields> implements IEntityCacheAdapter<TFields> {
+export class InMemoryFullCacheStubCacheAdapter<TFields extends Record<string, any>>
+  implements IEntityCacheAdapter<TFields>
+{
   constructor(
     private readonly entityConfiguration: EntityConfiguration<TFields>,
-    readonly cache: Map<string, Readonly<TFields>>
+    readonly cache: Map<string, Readonly<TFields>>,
   ) {}
 
   public async loadManyAsync<N extends keyof TFields>(
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult<TFields>>> {
     const results = new Map<NonNullable<TFields[N]>, CacheLoadResult<TFields>>();
     fieldValues.forEach((fieldValue) => {
@@ -86,7 +88,7 @@ export class InMemoryFullCacheStubCacheAdapter<TFields> implements IEntityCacheA
 
   public async cacheManyAsync<N extends keyof TFields>(
     fieldName: N,
-    objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>
+    objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>,
   ): Promise<void> {
     objectMap.forEach((obj, fieldValue) => {
       const cacheKey = this.createCacheKey(fieldName, fieldValue);
@@ -96,12 +98,12 @@ export class InMemoryFullCacheStubCacheAdapter<TFields> implements IEntityCacheA
 
   public async cacheDBMissesAsync<N extends keyof TFields>(
     _fieldName: N,
-    _fieldValues: readonly NonNullable<TFields[N]>[]
+    _fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<void> {}
 
   public async invalidateManyAsync<N extends keyof TFields>(
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<void> {
     fieldValues.forEach((fieldValue) => {
       const cacheKey = this.createCacheKey(fieldName, fieldValue);

package/src/utils/testing/StubDatabaseAdapter.ts

@@ -1,5 +1,5 @@
 import invariant from 'invariant';
-import { v4 as uuidv4 } from 'uuid';
+import { uuidv7 } from 'uuidv7';
 
 import EntityConfiguration from '../../EntityConfiguration';
 import EntityDatabaseAdapter, {
@@ -16,22 +16,24 @@ import {
 } from '../../internal/EntityFieldTransformationUtils';
 import { computeIfAbsent, mapMap } from '../collections/maps';
 
-export default class StubDatabaseAdapter<T> extends EntityDatabaseAdapter<T> {
+export default class StubDatabaseAdapter<
+  T extends Record<string, any>,
+> extends EntityDatabaseAdapter<T> {
   constructor(
     private readonly entityConfiguration2: EntityConfiguration<T>,
-    private readonly dataStore: Map<string, Readonly<{ [key: string]: any }>[]>
+    private readonly dataStore: Map<string, Readonly<{ [key: string]: any }>[]>,
   ) {
     super(entityConfiguration2);
   }
 
-  public static convertFieldObjectsToDataStore<T>(
+  public static convertFieldObjectsToDataStore<T extends Record<string, any>>(
     entityConfiguration: EntityConfiguration<T>,
-    dataStore: Map<string, Readonly<T>[]>
+    dataStore: Map<string, Readonly<T>[]>,
   ): Map<string, Readonly<{ [key: string]: any }>[]> {
     return mapMap(dataStore, (objectsForTable) =>
       objectsForTable.map((objectForTable) =>
-        transformFieldsToDatabaseObject(entityConfiguration, new Map(), objectForTable)
-      )
+        transformFieldsToDatabaseObject(entityConfiguration, new Map(), objectForTable),
+      ),
     );
   }
 
@@ -47,16 +49,19 @@ export default class StubDatabaseAdapter<T> extends EntityDatabaseAdapter<T> {
     _queryInterface: any,
     tableName: string,
     tableField: string,
-    tableValues: readonly any[]
+    tableValues: readonly any[],
   ): Promise<object[]> {
     const objectCollection = this.getObjectCollectionForTable(tableName);
-    return tableValues.reduce((acc, fieldValue) => {
-      return acc.concat(
-        objectCollection.filter((obj) => {
-          return obj[tableField] === fieldValue;
-        })
-      );
-    }, [] as { [key: string]: any });
+    return tableValues.reduce(
+      (acc, fieldValue) => {
+        return acc.concat(
+          objectCollection.filter((obj) => {
+            return obj[tableField] === fieldValue;
+          }),
+        );
+      },
+      [] as { [key: string]: any },
+    );
   }
 
   private static compareByOrderBys(
@@ -65,7 +70,7 @@ export default class StubDatabaseAdapter<T> extends EntityDatabaseAdapter<T> {
       order: OrderByOrdering;
     }[],
     objectA: { [key: string]: any },
-    objectB: { [key: string]: any }
+    objectB: { [key: string]: any },
   ): 0 | 1 | -1 {
     if (orderBys.length === 0) {
       return 0;
@@ -88,8 +93,8 @@ export default class StubDatabaseAdapter<T> extends EntityDatabaseAdapter<T> {
         return aField > bField
           ? -1
           : aField < bField
-          ? 1
-          : this.compareByOrderBys(orderBys.slice(1), objectA, objectB);
+            ? 1
+            : this.compareByOrderBys(orderBys.slice(1), objectA, objectB);
       }
       case OrderByOrdering.ASCENDING: {
         // simulate NULLS LAST for ASC
@@ -104,8 +109,8 @@ export default class StubDatabaseAdapter<T> extends EntityDatabaseAdapter<T> {
         return bField > aField
           ? -1
           : bField < aField
-          ? 1
-          : this.compareByOrderBys(orderBys.slice(1), objectA, objectB);
+            ? 1
+            : this.compareByOrderBys(orderBys.slice(1), objectA, objectB);
       }
     }
   }
@@ -115,7 +120,7 @@ export default class StubDatabaseAdapter<T> extends EntityDatabaseAdapter<T> {
     tableName: string,
     tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[],
     tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[],
-    querySelectionModifiers: TableQuerySelectionModifiers
+    querySelectionModifiers: TableQuerySelectionModifiers,
   ): Promise<object[]> {
     let filteredObjects = this.getObjectCollectionForTable(tableName);
     for (const { tableField, tableValue } of tableFieldSingleValueEqualityOperands) {
@@ -129,7 +134,7 @@ export default class StubDatabaseAdapter<T> extends EntityDatabaseAdapter<T> {
     const orderBy = querySelectionModifiers.orderBy;
     if (orderBy !== undefined) {
       filteredObjects = filteredObjects.sort((a, b) =>
-        StubDatabaseAdapter.compareByOrderBys(orderBy, a, b)
+        StubDatabaseAdapter.compareByOrderBys(orderBy, a, b),
       );
     }
 
@@ -151,7 +156,7 @@ export default class StubDatabaseAdapter<T> extends EntityDatabaseAdapter<T> {
     _tableName: string,
     _rawWhereClause: string,
     _bindings: object | any[],
-    _querySelectionModifiers: TableQuerySelectionModifiers
+    _querySelectionModifiers: TableQuerySelectionModifiers,
   ): Promise<object[]> {
     throw new Error('Raw WHERE clauses not supported for StubDatabaseAdapter');
   }
@@ -160,15 +165,15 @@ export default class StubDatabaseAdapter<T> extends EntityDatabaseAdapter<T> {
     const idSchemaField = this.entityConfiguration2.schema.get(this.entityConfiguration2.idField);
     invariant(
       idSchemaField,
-      `No schema field found for ${String(this.entityConfiguration2.idField)}`
+      `No schema field found for ${String(this.entityConfiguration2.idField)}`,
     );
     if (idSchemaField instanceof StringField) {
-      return uuidv4();
+      return uuidv7();
     } else if (idSchemaField instanceof IntField) {
       return Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
     } else {
       throw new Error(
-        `Unsupported ID type for StubDatabaseAdapter: ${idSchemaField.constructor.name}`
+        `Unsupported ID type for StubDatabaseAdapter: ${idSchemaField.constructor.name}`,
       );
     }
   }
@@ -176,13 +181,13 @@ export default class StubDatabaseAdapter<T> extends EntityDatabaseAdapter<T> {
   protected async insertInternalAsync(
     _queryInterface: any,
     tableName: string,
-    object: object
+    object: object,
   ): Promise<object[]> {
     const objectCollection = this.getObjectCollectionForTable(tableName);
 
     const idField = getDatabaseFieldForEntityField(
       this.entityConfiguration2,
-      this.entityConfiguration2.idField
+      this.entityConfiguration2.idField,
     );
     const objectToInsert = {
       [idField]: this.generateRandomID(),
@@ -197,7 +202,7 @@ export default class StubDatabaseAdapter<T> extends EntityDatabaseAdapter<T> {
     tableName: string,
     tableIdField: string,
     id: any,
-    object: object
+    object: object,
   ): Promise<object[]> {
     // SQL does not support empty updates, mirror behavior here for better test simulation
     if (Object.keys(object).length === 0) {
@@ -221,7 +226,7 @@ export default class StubDatabaseAdapter<T> extends EntityDatabaseAdapter<T> {
     _queryInterface: any,
     tableName: string,
     tableIdField: string,
-    id: any
+    id: any,
   ): Promise<number> {
     const objectCollection = this.getObjectCollectionForTable(tableName);
 

package/src/utils/testing/StubDatabaseAdapterProvider.ts

@@ -6,8 +6,8 @@ import IEntityDatabaseAdapterProvider from '../../IEntityDatabaseAdapterProvider
 export default class StubDatabaseAdapterProvider implements IEntityDatabaseAdapterProvider {
   private readonly objectCollection = new Map();
 
-  getDatabaseAdapter<TFields>(
-    entityConfiguration: EntityConfiguration<TFields>
+  getDatabaseAdapter<TFields extends Record<string, any>>(
+    entityConfiguration: EntityConfiguration<TFields>,
   ): EntityDatabaseAdapter<TFields> {
     return new StubDatabaseAdapter(entityConfiguration, this.objectCollection);
   }

package/src/utils/testing/StubQueryContextProvider.ts

@@ -7,13 +7,13 @@ export class StubQueryContextProvider extends EntityQueryContextProvider {
   }
 
   protected createTransactionRunner<T>(
-    _transactionConfig?: TransactionConfig
+    _transactionConfig?: TransactionConfig,
   ): (transactionScope: (queryInterface: any) => Promise<T>) => Promise<T> {
     return (transactionScope) => Promise.resolve(transactionScope({}));
   }
 
   protected createNestedTransactionRunner<T>(
-    _outerQueryInterface: any
+    _outerQueryInterface: any,
   ): (transactionScope: (queryInterface: any) => Promise<T>) => Promise<T> {
     return (transactionScope) => Promise.resolve(transactionScope({}));
   }

package/src/utils/testing/__tests__/PrivacyPolicyRuleTestUtils-test.ts

@@ -0,0 +1,42 @@
+import { anything, instance, mock } from 'ts-mockito';
+
+import { EntityPrivacyPolicyEvaluationContext } from '../../../EntityPrivacyPolicy';
+import { EntityQueryContext } from '../../../EntityQueryContext';
+import ViewerContext from '../../../ViewerContext';
+import AlwaysAllowPrivacyPolicyRule from '../../../rules/AlwaysAllowPrivacyPolicyRule';
+import AlwaysDenyPrivacyPolicyRule from '../../../rules/AlwaysDenyPrivacyPolicyRule';
+import { describePrivacyPolicyRuleWithAsyncTestCase } from '../PrivacyPolicyRuleTestUtils';
+
+describe(describePrivacyPolicyRuleWithAsyncTestCase, () => {
+  describe('default args do not execute', () => {
+    describePrivacyPolicyRuleWithAsyncTestCase(new AlwaysAllowPrivacyPolicyRule(), {
+      allowCases: new Map([
+        [
+          'case',
+          async () => ({
+            viewerContext: instance(mock(ViewerContext)),
+            queryContext: instance(mock(EntityQueryContext)),
+            evaluationContext:
+              instance(mock<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>()),
+            entity: anything(),
+          }),
+        ],
+      ]),
+    });
+
+    describePrivacyPolicyRuleWithAsyncTestCase(new AlwaysDenyPrivacyPolicyRule(), {
+      denyCases: new Map([
+        [
+          'case',
+          async () => ({
+            viewerContext: instance(mock(ViewerContext)),
+            queryContext: instance(mock(EntityQueryContext)),
+            evaluationContext:
+              instance(mock<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>()),
+            entity: anything(),
+          }),
+        ],
+      ]),
+    });
+  });
+});