@expo/entity 0.54.0 → 0.57.0

package/src/internal/__tests__/ReadThroughEntityCache-test.ts

@@ -76,7 +76,7 @@ describe(ReadThroughEntityCache, () => {
 
       when(
         cacheAdapterMock.loadManyAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware([
             new SingleFieldValueHolder('wat'),
             new SingleFieldValueHolder('who'),
@@ -102,7 +102,7 @@ describe(ReadThroughEntityCache, () => {
 
       verify(
         cacheAdapterMock.loadManyAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware([
             new SingleFieldValueHolder('wat'),
             new SingleFieldValueHolder('who'),
@@ -111,7 +111,7 @@ describe(ReadThroughEntityCache, () => {
       ).once();
       verify(
         cacheAdapterMock.cacheManyAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware(
             new SingleFieldValueHolderMap(
               new Map([
@@ -146,7 +146,7 @@ describe(ReadThroughEntityCache, () => {
 
       when(
         cacheAdapterMock.loadManyAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware([
             new SingleFieldValueHolder('wat'),
             new SingleFieldValueHolder('who'),
@@ -170,7 +170,7 @@ describe(ReadThroughEntityCache, () => {
 
       verify(
         cacheAdapterMock.loadManyAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware([
             new SingleFieldValueHolder('wat'),
             new SingleFieldValueHolder('who'),
@@ -179,7 +179,7 @@ describe(ReadThroughEntityCache, () => {
       ).once();
       verify(
         cacheAdapterMock.cacheManyAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware(
             new SingleFieldValueHolderMap(
               new Map([
@@ -216,7 +216,7 @@ describe(ReadThroughEntityCache, () => {
 
       when(
         cacheAdapterMock.loadManyAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware([new SingleFieldValueHolder('why')]),
         ),
       ).thenResolve(
@@ -233,19 +233,19 @@ describe(ReadThroughEntityCache, () => {
 
       verify(
         cacheAdapterMock.loadManyAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware([new SingleFieldValueHolder('why')]),
         ),
       ).once();
       verify(
         cacheAdapterMock.cacheManyAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware(new SingleFieldValueHolderMap(new Map())),
         ),
       ).once();
       verify(
         cacheAdapterMock.cacheDBMissesAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware([new SingleFieldValueHolder('why')]),
         ),
       ).once();
@@ -260,7 +260,7 @@ describe(ReadThroughEntityCache, () => {
 
       when(
         cacheAdapterMock.loadManyAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware([new SingleFieldValueHolder('why')]),
         ),
       ).thenResolve(
@@ -276,12 +276,22 @@ describe(ReadThroughEntityCache, () => {
       );
       verify(
         cacheAdapterMock.loadManyAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware([new SingleFieldValueHolder('why')]),
         ),
       ).once();
-      verify(cacheAdapterMock.cacheManyAsync(new SingleFieldHolder('id'), anything())).never();
-      verify(cacheAdapterMock.cacheDBMissesAsync(new SingleFieldHolder('id'), anything())).never();
+      verify(
+        cacheAdapterMock.cacheManyAsync(
+          new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+          anything(),
+        ),
+      ).never();
+      verify(
+        cacheAdapterMock.cacheDBMissesAsync(
+          new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+          anything(),
+        ),
+      ).never();
       expect(result).toEqual(new SingleFieldValueHolderMap(new Map()));
     });
 
@@ -293,7 +303,7 @@ describe(ReadThroughEntityCache, () => {
 
       when(
         cacheAdapterMock.loadManyAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware([
             new SingleFieldValueHolder('wat'),
             new SingleFieldValueHolder('who'),
@@ -324,7 +334,7 @@ describe(ReadThroughEntityCache, () => {
       );
       verify(
         cacheAdapterMock.loadManyAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware([
             new SingleFieldValueHolder('wat'),
             new SingleFieldValueHolder('who'),
@@ -335,7 +345,7 @@ describe(ReadThroughEntityCache, () => {
       ).once();
       verify(
         cacheAdapterMock.cacheManyAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware(
             new SingleFieldValueHolderMap(
               new Map([[new SingleFieldValueHolder('wat'), { id: 'wat' }]]),
@@ -345,7 +355,7 @@ describe(ReadThroughEntityCache, () => {
       ).once();
       verify(
         cacheAdapterMock.cacheDBMissesAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware([new SingleFieldValueHolder('how')]),
         ),
       ).once();
@@ -372,7 +382,12 @@ describe(ReadThroughEntityCache, () => {
         [new SingleFieldValueHolder<BlahFields, 'id'>('wat')],
         fetcher,
       );
-      verify(cacheAdapterMock.loadManyAsync(new SingleFieldHolder('id'), anything())).never();
+      verify(
+        cacheAdapterMock.loadManyAsync(
+          new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+          anything(),
+        ),
+      ).never();
       expect(result).toEqual(
         new SingleFieldValueHolderMap(
           new Map([[new SingleFieldValueHolder('wat'), [{ id: 'wat' }]]]),
@@ -390,7 +405,7 @@ describe(ReadThroughEntityCache, () => {
 
       when(
         cacheAdapterMock.loadManyAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware([
             new SingleFieldValueHolder('wat'),
             new SingleFieldValueHolder('who'),
@@ -416,7 +431,7 @@ describe(ReadThroughEntityCache, () => {
 
       verify(
         cacheAdapterMock.loadManyAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware([
             new SingleFieldValueHolder('wat'),
             new SingleFieldValueHolder('who'),
@@ -425,7 +440,7 @@ describe(ReadThroughEntityCache, () => {
       ).once();
       verify(
         cacheAdapterMock.cacheManyAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware(
             new Map([
               [new SingleFieldValueHolder('wat'), { id: 'wat' }],
@@ -456,12 +471,12 @@ describe(ReadThroughEntityCache, () => {
       const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields, 'id'>>();
       const cacheAdapter = instance(cacheAdapterMock);
       const entityCache = new ReadThroughEntityCache(makeEntityConfiguration(true), cacheAdapter);
-      await entityCache.invalidateManyAsync(new SingleFieldHolder('id'), [
+      await entityCache.invalidateManyAsync(new SingleFieldHolder<BlahFields, 'id', 'id'>('id'), [
         new SingleFieldValueHolder('wat'),
       ]);
       verify(
         cacheAdapterMock.invalidateManyAsync(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           deepEqualEntityAware([new SingleFieldValueHolder('wat')]),
         ),
       ).once();

package/src/metrics/EntityMetricsUtils.ts

@@ -30,6 +30,29 @@ export const timeAndLogLoadEventAsync =
     return result;
   };
 
+export const timeAndLogLoadOneEventAsync =
+  (
+    metricsAdapter: IEntityMetricsAdapter,
+    loadType: EntityMetricsLoadType,
+    entityClassName: string,
+    queryContext: EntityQueryContext,
+  ) =>
+  async <TFields>(promise: Promise<Readonly<TFields> | null>) => {
+    const startTime = Date.now();
+    const result = await promise;
+    const endTime = Date.now();
+
+    metricsAdapter.logDataManagerLoadEvent({
+      type: loadType,
+      isInTransaction: queryContext.isInTransaction(),
+      entityClassName,
+      duration: endTime - startTime,
+      count: result ? 1 : 0,
+    });
+
+    return result;
+  };
+
 export const timeAndLogLoadMapEventAsync =
   (
     metricsAdapter: IEntityMetricsAdapter,

package/src/metrics/IEntityMetricsAdapter.ts

@@ -8,6 +8,9 @@ export enum EntityMetricsLoadType {
   LOAD_MANY,
   LOAD_MANY_EQUALITY_CONJUNCTION,
   LOAD_MANY_RAW,
+  LOAD_MANY_SQL,
+  LOAD_ONE,
+  LOAD_PAGE,
 }
 
 /**

package/src/metrics/__tests__/EntityMetricsUtils-test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from '@jest/globals';
+import { anyNumber, deepEqual, instance, mock, verify, when } from 'ts-mockito';
+
+import { EntityQueryContext } from '../../EntityQueryContext';
+import {
+  timeAndLogLoadEventAsync,
+  timeAndLogLoadMapEventAsync,
+  timeAndLogMutationEventAsync,
+} from '../EntityMetricsUtils';
+import {
+  EntityMetricsLoadType,
+  EntityMetricsMutationType,
+  IEntityMetricsAdapter,
+} from '../IEntityMetricsAdapter';
+
+describe(timeAndLogLoadEventAsync, () => {
+  it('returns the result from the wrapped promise and logs', async () => {
+    const metricsAdapterMock = mock<IEntityMetricsAdapter>();
+    const metricsAdapter = instance(metricsAdapterMock);
+
+    const queryContextMock = mock<EntityQueryContext>();
+    when(queryContextMock.isInTransaction()).thenReturn(false);
+    const queryContext = instance(queryContextMock);
+
+    const expectedResult = [{ id: 1 }, { id: 2 }];
+
+    const result = await timeAndLogLoadEventAsync(
+      metricsAdapter,
+      EntityMetricsLoadType.LOAD_MANY,
+      'TestEntity',
+      queryContext,
+    )(Promise.resolve(expectedResult));
+
+    expect(result).toBe(expectedResult);
+
+    verify(
+      metricsAdapterMock.logDataManagerLoadEvent(
+        deepEqual({
+          type: EntityMetricsLoadType.LOAD_MANY,
+          isInTransaction: false,
+          entityClassName: 'TestEntity',
+          duration: anyNumber(),
+          count: expectedResult.length,
+        }),
+      ),
+    ).once();
+  });
+});
+
+describe(timeAndLogLoadMapEventAsync, () => {
+  it('returns the result from the wrapped promise and logs with count summed across map values', async () => {
+    const metricsAdapterMock = mock<IEntityMetricsAdapter>();
+    const metricsAdapter = instance(metricsAdapterMock);
+
+    const queryContextMock = mock<EntityQueryContext>();
+    when(queryContextMock.isInTransaction()).thenReturn(false);
+    const queryContext = instance(queryContextMock);
+
+    const key1 = { serialize: () => 'key1' };
+    const key2 = { serialize: () => 'key2' };
+    const expectedResult = new Map([
+      [key1, [{ id: 1 }, { id: 2 }]],
+      [key2, [{ id: 3 }]],
+    ]);
+
+    const result = await timeAndLogLoadMapEventAsync(
+      metricsAdapter,
+      EntityMetricsLoadType.LOAD_MANY,
+      'TestEntity',
+      queryContext,
+    )(Promise.resolve(expectedResult));
+
+    expect(result).toBe(expectedResult);
+
+    verify(
+      metricsAdapterMock.logDataManagerLoadEvent(
+        deepEqual({
+          type: EntityMetricsLoadType.LOAD_MANY,
+          isInTransaction: false,
+          entityClassName: 'TestEntity',
+          duration: anyNumber(),
+          count: 3,
+        }),
+      ),
+    ).once();
+  });
+});
+
+describe(timeAndLogMutationEventAsync, () => {
+  it('returns the result from the wrapped promise and logs', async () => {
+    const metricsAdapterMock = mock<IEntityMetricsAdapter>();
+    const metricsAdapter = instance(metricsAdapterMock);
+
+    const queryContextMock = mock<EntityQueryContext>();
+    when(queryContextMock.isInTransaction()).thenReturn(true);
+    const queryContext = instance(queryContextMock);
+
+    const expectedResult = { id: 1, name: 'created' };
+
+    const result = await timeAndLogMutationEventAsync(
+      metricsAdapter,
+      EntityMetricsMutationType.CREATE,
+      'TestEntity',
+      queryContext,
+    )(Promise.resolve(expectedResult));
+
+    expect(result).toBe(expectedResult);
+
+    verify(
+      metricsAdapterMock.logMutatorMutationEvent(
+        deepEqual({
+          type: EntityMetricsMutationType.CREATE,
+          isInTransaction: true,
+          entityClassName: 'TestEntity',
+          duration: anyNumber(),
+        }),
+      ),
+    ).once();
+  });
+});

package/src/rules/AllowIfAllSubRulesAllowPrivacyPolicyRule.ts

@@ -0,0 +1,47 @@
+import { EntityPrivacyPolicyRuleEvaluationContext } from '../EntityPrivacyPolicy';
+import { EntityQueryContext } from '../EntityQueryContext';
+import { ReadonlyEntity } from '../ReadonlyEntity';
+import { ViewerContext } from '../ViewerContext';
+import { PrivacyPolicyRule, RuleEvaluationResult } from './PrivacyPolicyRule';
+
+export class AllowIfAllSubRulesAllowPrivacyPolicyRule<
+  TFields extends object,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
+  TViewerContext extends ViewerContext,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
+  TSelectedFields extends keyof TFields = keyof TFields,
+> extends PrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields> {
+  constructor(
+    private readonly subRules: PrivacyPolicyRule<
+      TFields,
+      TIDField,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >[],
+  ) {
+    super();
+  }
+
+  async evaluateAsync(
+    viewerContext: TViewerContext,
+    queryContext: EntityQueryContext,
+    evaluationContext: EntityPrivacyPolicyRuleEvaluationContext<
+      TFields,
+      TIDField,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+    entity: TEntity,
+  ): Promise<RuleEvaluationResult> {
+    const results = await Promise.all(
+      this.subRules.map((subRule) =>
+        subRule.evaluateAsync(viewerContext, queryContext, evaluationContext, entity),
+      ),
+    );
+    return results.every((result) => result === RuleEvaluationResult.ALLOW)
+      ? RuleEvaluationResult.ALLOW
+      : RuleEvaluationResult.SKIP;
+  }
+}

package/src/rules/AllowIfAnySubRuleAllowsPrivacyPolicyRule.ts

@@ -0,0 +1,47 @@
+import { EntityPrivacyPolicyRuleEvaluationContext } from '../EntityPrivacyPolicy';
+import { EntityQueryContext } from '../EntityQueryContext';
+import { ReadonlyEntity } from '../ReadonlyEntity';
+import { ViewerContext } from '../ViewerContext';
+import { PrivacyPolicyRule, RuleEvaluationResult } from './PrivacyPolicyRule';
+
+export class AllowIfAnySubRuleAllowsPrivacyPolicyRule<
+  TFields extends object,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
+  TViewerContext extends ViewerContext,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
+  TSelectedFields extends keyof TFields = keyof TFields,
+> extends PrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields> {
+  constructor(
+    private readonly subRules: PrivacyPolicyRule<
+      TFields,
+      TIDField,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >[],
+  ) {
+    super();
+  }
+
+  async evaluateAsync(
+    viewerContext: TViewerContext,
+    queryContext: EntityQueryContext,
+    evaluationContext: EntityPrivacyPolicyRuleEvaluationContext<
+      TFields,
+      TIDField,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+    entity: TEntity,
+  ): Promise<RuleEvaluationResult> {
+    const results = await Promise.all(
+      this.subRules.map((subRule) =>
+        subRule.evaluateAsync(viewerContext, queryContext, evaluationContext, entity),
+      ),
+    );
+    return results.includes(RuleEvaluationResult.ALLOW)
+      ? RuleEvaluationResult.ALLOW
+      : RuleEvaluationResult.SKIP;
+  }
+}

package/src/rules/AllowIfInParentCascadeDeletionPrivacyPolicyRule.ts

@@ -0,0 +1,177 @@
+import { IEntityClass } from '../Entity';
+import { EntityPrivacyPolicy, EntityPrivacyPolicyEvaluationContext } from '../EntityPrivacyPolicy';
+import { EntityQueryContext } from '../EntityQueryContext';
+import { ReadonlyEntity } from '../ReadonlyEntity';
+import { ViewerContext } from '../ViewerContext';
+import { PrivacyPolicyRule, RuleEvaluationResult } from './PrivacyPolicyRule';
+
+/**
+ * Directive for specifying the parent relationship in AllowIfInParentCascadeDeletionPrivacyPolicyRule.
+ */
+export interface AllowIfInParentCascadeDeletionDirective<
+  TViewerContext extends ViewerContext,
+  TFields,
+  TParentFields extends object,
+  TParentIDField extends keyof NonNullable<Pick<TParentFields, TParentSelectedFields>>,
+  TParentEntity extends ReadonlyEntity<
+    TParentFields,
+    TParentIDField,
+    TViewerContext,
+    TParentSelectedFields
+  >,
+  TParentPrivacyPolicy extends EntityPrivacyPolicy<
+    TParentFields,
+    TParentIDField,
+    TViewerContext,
+    TParentEntity,
+    TParentSelectedFields
+  >,
+  TSelectedFields extends keyof TFields = keyof TFields,
+  TParentSelectedFields extends keyof TParentFields = keyof TParentFields,
+> {
+  /**
+   * Class of parent entity that should trigger a cascade set null update to a field within
+   * the entity being authorized.
+   */
+  parentEntityClass: IEntityClass<
+    TParentFields,
+    TParentIDField,
+    TViewerContext,
+    TParentEntity,
+    TParentPrivacyPolicy,
+    TParentSelectedFields
+  >;
+
+  /**
+   * Field of the current entity with references the deleting instace of parentEntityClass.
+   */
+  fieldIdentifyingParentEntity: keyof Pick<TFields, TSelectedFields>;
+
+  /**
+   * Field in parentEntityClass referenced by the value of fieldIdentifyingParentEntity.
+   * If not provided, ID is assumed.
+   */
+  parentEntityLookupByField?: keyof Pick<TParentFields, TParentSelectedFields>;
+}
+
+/**
+ * A generic privacy policy rule that allows when an entity is being authorized
+ * as part of a cascading delete from a parent entity. Handles two cases:
+ * - When the field has not yet been null'ed out due to a cascading set null. This is often
+ *   required for read rules to authorize the initial re-read of the entity being update set null'ed.
+ * - When the field has been null'ed out due to a cascading set null. This is often required
+ *   the update rules for the field nullification.
+ *
+ * These two cases could theoretically be handled by two separate (stricter) rules, but are combined
+ * to simplify configuration since practically there are few cases where having them be combined would
+ * preset an issue.
+ *
+ * @example
+ * Billing info owned by an account, but records who created the billing info in creating_user_id. User is a member of that account.
+ * User can delete themselves, and the billing info's creating_user_id field is cascade set null'ed when the user is deleted.
+ *
+ * ```ts
+ *  class BillingInfoEntityPrivacyPolicy extends EntityPrivacyPolicy<...> {
+ *    protected override readonly readRules = [
+ *      ...,
+ *      new AllowIfInParentCascadeDeletionPrivacyPolicyRule<...>({
+ *        fieldIdentifyingParentEntity: 'creating_user_id',
+ *        parentEntityClass: UserEntity,
+ *      }),
+ *    ];
+ *
+ *    protected override readonly updateRules = [
+ *      ...,
+ *      new AllowIfInParentCascadeDeletionPrivacyPolicyRule<...>({
+ *        fieldIdentifyingParentEntity: 'creating_user_id',
+ *        parentEntityClass: UserEntity,
+ *      }),
+ *    ];
+ *  }
+ * ```
+ */
+export class AllowIfInParentCascadeDeletionPrivacyPolicyRule<
+  TFields extends object,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
+  TViewerContext extends ViewerContext,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
+  TFields2 extends object,
+  TIDField2 extends keyof NonNullable<Pick<TFields2, TSelectedFields2>>,
+  TEntity2 extends ReadonlyEntity<TFields2, TIDField2, TViewerContext, TSelectedFields2>,
+  TPrivacyPolicy2 extends EntityPrivacyPolicy<
+    TFields2,
+    TIDField2,
+    TViewerContext,
+    TEntity2,
+    TSelectedFields2
+  >,
+  TSelectedFields extends keyof TFields = keyof TFields,
+  TSelectedFields2 extends keyof TFields2 = keyof TFields2,
+> extends PrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields> {
+  constructor(
+    private readonly directive: AllowIfInParentCascadeDeletionDirective<
+      TViewerContext,
+      TFields,
+      TFields2,
+      TIDField2,
+      TEntity2,
+      TPrivacyPolicy2,
+      TSelectedFields,
+      TSelectedFields2
+    >,
+  ) {
+    super();
+  }
+
+  async evaluateAsync(
+    _viewerContext: TViewerContext,
+    _queryContext: EntityQueryContext,
+    evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TIDField,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+    entity: TEntity,
+  ): Promise<RuleEvaluationResult> {
+    const parentEntityClass = this.directive.parentEntityClass;
+
+    const deleteCause = evaluationContext.cascadingDeleteCause;
+    if (!deleteCause || !(deleteCause.entity instanceof parentEntityClass)) {
+      return RuleEvaluationResult.SKIP;
+    }
+
+    const entityBeingDeleted = deleteCause.entity;
+
+    // allow if parent foreign key field matches specified field in the entity being authorized
+    const valueInThisEntityReferencingParent = entity.getField(
+      this.directive.fieldIdentifyingParentEntity,
+    );
+    const valueInParent = this.directive.parentEntityLookupByField
+      ? entityBeingDeleted.getField(this.directive.parentEntityLookupByField)
+      : entityBeingDeleted.getID();
+
+    if (
+      valueInThisEntityReferencingParent &&
+      valueInThisEntityReferencingParent === valueInParent
+    ) {
+      return RuleEvaluationResult.ALLOW;
+    }
+
+    // allow if parent foreign key field matches specified field in the entity being authorized, and the
+    // field in the entity being authorized has been null'ed out  due to cascading set null
+    const valueInPreviousValueOfThisEntityReferencingParent =
+      evaluationContext.previousValue?.getField(this.directive.fieldIdentifyingParentEntity);
+
+    if (
+      valueInPreviousValueOfThisEntityReferencingParent &&
+      valueInPreviousValueOfThisEntityReferencingParent === valueInParent &&
+      valueInThisEntityReferencingParent === null
+    ) {
+      return RuleEvaluationResult.ALLOW;
+    }
+
+    return RuleEvaluationResult.SKIP;
+  }
+}

package/src/rules/EvaluateIfEntityFieldPredicatePrivacyPolicyRule.ts

@@ -0,0 +1,46 @@
+import { EntityPrivacyPolicyRuleEvaluationContext } from '../EntityPrivacyPolicy';
+import { EntityQueryContext } from '../EntityQueryContext';
+import { ReadonlyEntity } from '../ReadonlyEntity';
+import { ViewerContext } from '../ViewerContext';
+import { PrivacyPolicyRule, RuleEvaluationResult } from './PrivacyPolicyRule';
+
+export class EvaluateIfEntityFieldPredicatePrivacyPolicyRule<
+  TFields extends object,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
+  TViewerContext extends ViewerContext,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
+  N extends TSelectedFields,
+  TSelectedFields extends keyof TFields = keyof TFields,
+> extends PrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields> {
+  constructor(
+    private readonly fieldName: N,
+    private readonly shouldEvaluatePredicate: (fieldValue: TFields[N]) => boolean,
+    private readonly rule: PrivacyPolicyRule<
+      TFields,
+      TIDField,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+  ) {
+    super();
+  }
+
+  async evaluateAsync(
+    viewerContext: TViewerContext,
+    queryContext: EntityQueryContext,
+    evaluationContext: EntityPrivacyPolicyRuleEvaluationContext<
+      TFields,
+      TIDField,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+    entity: TEntity,
+  ): Promise<RuleEvaluationResult> {
+    const fieldValue = entity.getField(this.fieldName);
+    return this.shouldEvaluatePredicate(fieldValue)
+      ? await this.rule.evaluateAsync(viewerContext, queryContext, evaluationContext, entity)
+      : RuleEvaluationResult.SKIP;
+  }
+}