@expo/entity 0.54.0 → 0.57.0

package/src/rules/PrivacyPolicyRule.ts

@@ -1,4 +1,4 @@
-import { EntityPrivacyPolicyEvaluationContext } from '../EntityPrivacyPolicy';
+import { EntityPrivacyPolicyRuleEvaluationContext } from '../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../EntityQueryContext';
 import { ReadonlyEntity } from '../ReadonlyEntity';
 import { ViewerContext } from '../ViewerContext';
@@ -46,7 +46,7 @@ export abstract class PrivacyPolicyRule<
   abstract evaluateAsync(
     viewerContext: TViewerContext,
     queryContext: EntityQueryContext,
-    evaluationContext: EntityPrivacyPolicyEvaluationContext<
+    evaluationContext: EntityPrivacyPolicyRuleEvaluationContext<
       TFields,
       TIDField,
       TViewerContext,

package/src/rules/__tests__/AllowIfAllSubRulesAllowPrivacyPolicyRule-test.ts

@@ -0,0 +1,64 @@
+import { anything, instance, mock } from 'ts-mockito';
+
+import { EntityPrivacyPolicyRuleEvaluationContext } from '../../EntityPrivacyPolicy';
+import { EntityQueryContext } from '../../EntityQueryContext';
+import { ViewerContext } from '../../ViewerContext';
+import { describePrivacyPolicyRule } from '../../utils/__testfixtures__/PrivacyPolicyRuleTestUtils';
+import { AllowIfAllSubRulesAllowPrivacyPolicyRule } from '../AllowIfAllSubRulesAllowPrivacyPolicyRule';
+import { AlwaysAllowPrivacyPolicyRule } from '../AlwaysAllowPrivacyPolicyRule';
+import { AlwaysDenyPrivacyPolicyRule } from '../AlwaysDenyPrivacyPolicyRule';
+import { AlwaysSkipPrivacyPolicyRule } from '../AlwaysSkipPrivacyPolicyRule';
+
+describePrivacyPolicyRule(
+  new AllowIfAllSubRulesAllowPrivacyPolicyRule([
+    new AlwaysAllowPrivacyPolicyRule(),
+    new AlwaysSkipPrivacyPolicyRule(),
+  ]),
+  {
+    skipCases: [
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext:
+          instance(mock<EntityPrivacyPolicyRuleEvaluationContext<any, any, any, any, any>>()),
+        entity: anything(),
+      },
+    ],
+  },
+);
+
+describePrivacyPolicyRule(
+  new AllowIfAllSubRulesAllowPrivacyPolicyRule([
+    new AlwaysAllowPrivacyPolicyRule(),
+    new AlwaysDenyPrivacyPolicyRule(),
+  ]),
+  {
+    skipCases: [
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext:
+          instance(mock<EntityPrivacyPolicyRuleEvaluationContext<any, any, any, any, any>>()),
+        entity: anything(),
+      },
+    ],
+  },
+);
+
+describePrivacyPolicyRule(
+  new AllowIfAllSubRulesAllowPrivacyPolicyRule([
+    new AlwaysAllowPrivacyPolicyRule(),
+    new AlwaysAllowPrivacyPolicyRule(),
+  ]),
+  {
+    allowCases: [
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext:
+          instance(mock<EntityPrivacyPolicyRuleEvaluationContext<any, any, any, any, any>>()),
+        entity: anything(),
+      },
+    ],
+  },
+);

package/src/rules/__tests__/AllowIfAnySubRuleAllowsPrivacyPolicyRule-test.ts

@@ -0,0 +1,64 @@
+import { anything, instance, mock } from 'ts-mockito';
+
+import { EntityPrivacyPolicyRuleEvaluationContext } from '../../EntityPrivacyPolicy';
+import { EntityQueryContext } from '../../EntityQueryContext';
+import { ViewerContext } from '../../ViewerContext';
+import { describePrivacyPolicyRule } from '../../utils/__testfixtures__/PrivacyPolicyRuleTestUtils';
+import { AllowIfAnySubRuleAllowsPrivacyPolicyRule } from '../AllowIfAnySubRuleAllowsPrivacyPolicyRule';
+import { AlwaysAllowPrivacyPolicyRule } from '../AlwaysAllowPrivacyPolicyRule';
+import { AlwaysDenyPrivacyPolicyRule } from '../AlwaysDenyPrivacyPolicyRule';
+import { AlwaysSkipPrivacyPolicyRule } from '../AlwaysSkipPrivacyPolicyRule';
+
+describePrivacyPolicyRule(
+  new AllowIfAnySubRuleAllowsPrivacyPolicyRule([
+    new AlwaysAllowPrivacyPolicyRule(),
+    new AlwaysSkipPrivacyPolicyRule(),
+  ]),
+  {
+    allowCases: [
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext:
+          instance(mock<EntityPrivacyPolicyRuleEvaluationContext<any, any, any, any, any>>()),
+        entity: anything(),
+      },
+    ],
+  },
+);
+
+describePrivacyPolicyRule(
+  new AllowIfAnySubRuleAllowsPrivacyPolicyRule([
+    new AlwaysAllowPrivacyPolicyRule(),
+    new AlwaysDenyPrivacyPolicyRule(),
+  ]),
+  {
+    allowCases: [
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext:
+          instance(mock<EntityPrivacyPolicyRuleEvaluationContext<any, any, any, any, any>>()),
+        entity: anything(),
+      },
+    ],
+  },
+);
+
+describePrivacyPolicyRule(
+  new AllowIfAnySubRuleAllowsPrivacyPolicyRule([
+    new AlwaysSkipPrivacyPolicyRule(),
+    new AlwaysSkipPrivacyPolicyRule(),
+  ]),
+  {
+    skipCases: [
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext:
+          instance(mock<EntityPrivacyPolicyRuleEvaluationContext<any, any, any, any, any>>()),
+        entity: anything(),
+      },
+    ],
+  },
+);

package/src/rules/__tests__/AllowIfInParentCascadeDeletionPrivacyPolicyRule-test.ts

@@ -0,0 +1,268 @@
+import { anything, instance, mock, when } from 'ts-mockito';
+
+import { EntityCompanionDefinition } from '../../EntityCompanionProvider';
+import { EntityPrivacyPolicy } from '../../EntityPrivacyPolicy';
+import { EntityQueryContext } from '../../EntityQueryContext';
+import { ReadonlyEntity } from '../../ReadonlyEntity';
+import { ViewerContext } from '../../ViewerContext';
+import { describePrivacyPolicyRule } from '../../utils/__testfixtures__/PrivacyPolicyRuleTestUtils';
+import { AllowIfInParentCascadeDeletionPrivacyPolicyRule } from '../AllowIfInParentCascadeDeletionPrivacyPolicyRule';
+
+// Define test field types
+type ParentFields = {
+  id: string;
+  name: string;
+};
+
+type ChildFields = {
+  id: string;
+  parent_id: string | null;
+  parent_name: string | null;
+};
+
+// Create a mock privacy policy for the parent entity
+class TestParentPrivacyPolicy extends EntityPrivacyPolicy<
+  ParentFields,
+  'id',
+  ViewerContext,
+  TestParentEntity
+> {
+  protected override readonly readRules = [];
+  protected override readonly createRules = [];
+  protected override readonly updateRules = [];
+  protected override readonly deleteRules = [];
+}
+
+// Create a mock parent entity class with required static method
+class TestParentEntity extends ReadonlyEntity<ParentFields, 'id', ViewerContext> {
+  static defineCompanionDefinition(): EntityCompanionDefinition<
+    ParentFields,
+    'id',
+    ViewerContext,
+    TestParentEntity,
+    TestParentPrivacyPolicy
+  > {
+    throw new Error('Not implemented for test');
+  }
+}
+
+// Create a mock child entity class
+class TestChildEntity extends ReadonlyEntity<ChildFields, 'id', ViewerContext> {}
+
+// Mock parent entities
+const parentEntityMock = mock(TestParentEntity);
+when(parentEntityMock.getID()).thenReturn('5');
+const parentEntity = instance(parentEntityMock);
+Object.setPrototypeOf(parentEntity, TestParentEntity.prototype);
+
+const otherParentEntityMock = mock(TestParentEntity);
+when(otherParentEntityMock.getID()).thenReturn('6');
+const otherParentEntity = instance(otherParentEntityMock);
+Object.setPrototypeOf(otherParentEntity, TestParentEntity.prototype);
+
+// Mock a non-parent entity (different class)
+class UnrelatedOtherEntity extends ReadonlyEntity<{ id: string }, 'id', ViewerContext> {}
+const unrelatedOtherEntityMock = mock(UnrelatedOtherEntity);
+Object.setPrototypeOf(unrelatedOtherEntityMock, UnrelatedOtherEntity.prototype);
+
+// Mock child entities
+const childEntityMock = mock(TestChildEntity);
+when(childEntityMock.getField('parent_id')).thenReturn('5');
+
+const childEntityMockWithNullifiedField = mock(TestChildEntity);
+when(childEntityMockWithNullifiedField.getField('parent_id')).thenReturn(null);
+
+const childEntityDifferentParentMock = mock(TestChildEntity);
+when(childEntityDifferentParentMock.getField('parent_id')).thenReturn('6');
+
+describePrivacyPolicyRule(
+  new AllowIfInParentCascadeDeletionPrivacyPolicyRule<
+    ChildFields,
+    'id',
+    ViewerContext,
+    TestChildEntity,
+    ParentFields,
+    'id',
+    TestParentEntity,
+    TestParentPrivacyPolicy
+  >({
+    fieldIdentifyingParentEntity: 'parent_id',
+    parentEntityClass: TestParentEntity,
+  }),
+  {
+    allowCases: [
+      // parent id matches parent being deleted, field not yet nullified
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext: {
+          action: anything(),
+          previousValue: instance(childEntityMock),
+          cascadingDeleteCause: {
+            entity: parentEntity,
+            cascadingDeleteCause: null,
+          },
+        },
+        entity: instance(childEntityMock),
+      },
+      // parent id matches parent being deleted, field null in current version but filled in previous version
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext: {
+          action: anything(),
+          previousValue: instance(childEntityMock),
+          cascadingDeleteCause: {
+            entity: parentEntity,
+            cascadingDeleteCause: null,
+          },
+        },
+        entity: instance(childEntityMockWithNullifiedField),
+      },
+    ],
+    skipCases: [
+      // no cascading delete
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext: {
+          action: anything(),
+          previousValue: null,
+          cascadingDeleteCause: null,
+        },
+        entity: instance(childEntityMock),
+      },
+      // cascading delete not from parent entity class
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext: {
+          action: anything(),
+          previousValue: null,
+          cascadingDeleteCause: {
+            entity: instance(unrelatedOtherEntityMock),
+            cascadingDeleteCause: null,
+          },
+        },
+        entity: instance(childEntityMock),
+      },
+      // cascading delete from different parent, field not nullified
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext: {
+          action: anything(),
+          previousValue: null,
+          cascadingDeleteCause: {
+            entity: otherParentEntity,
+            cascadingDeleteCause: null,
+          },
+        },
+        entity: instance(childEntityMock),
+      },
+      // entity belongs to different parent
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext: {
+          action: anything(),
+          previousValue: null,
+          cascadingDeleteCause: {
+            entity: parentEntity,
+            cascadingDeleteCause: null,
+          },
+        },
+        entity: instance(childEntityDifferentParentMock),
+      },
+      // parent id field undefined (null) and no previous value
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext: {
+          action: anything(),
+          previousValue: null,
+          cascadingDeleteCause: {
+            entity: parentEntity,
+            cascadingDeleteCause: null,
+          },
+        },
+        entity: instance(childEntityMockWithNullifiedField),
+      },
+      // parent id now null but previous value different parent
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext: {
+          action: anything(),
+          previousValue: instance(childEntityDifferentParentMock),
+          cascadingDeleteCause: {
+            entity: parentEntity,
+            cascadingDeleteCause: null,
+          },
+        },
+        entity: instance(childEntityMockWithNullifiedField),
+      },
+    ],
+  },
+);
+
+// Test with custom lookup field (parentEntityLookupByField)
+const parentEntityWithNameMock = mock(TestParentEntity);
+when(parentEntityWithNameMock.getField('name')).thenReturn('test-name');
+const parentEntityWithName = instance(parentEntityWithNameMock);
+Object.setPrototypeOf(parentEntityWithName, TestParentEntity.prototype);
+
+const childEntityWithNameRefMock = mock(TestChildEntity);
+when(childEntityWithNameRefMock.getField('parent_name')).thenReturn('test-name');
+
+const childEntityWithNameRefMockWithNullifiedField = mock(TestChildEntity);
+when(childEntityWithNameRefMockWithNullifiedField.getField('parent_name')).thenReturn(null);
+
+describePrivacyPolicyRule(
+  new AllowIfInParentCascadeDeletionPrivacyPolicyRule<
+    ChildFields,
+    'id',
+    ViewerContext,
+    TestChildEntity,
+    ParentFields,
+    'id',
+    TestParentEntity,
+    TestParentPrivacyPolicy
+  >({
+    fieldIdentifyingParentEntity: 'parent_name',
+    parentEntityClass: TestParentEntity,
+    parentEntityLookupByField: 'name',
+  }),
+  {
+    allowCases: [
+      // parent name matches parent being deleted, field not yet nullified
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext: {
+          action: anything(),
+          previousValue: instance(childEntityWithNameRefMock),
+          cascadingDeleteCause: {
+            entity: parentEntityWithName,
+            cascadingDeleteCause: null,
+          },
+        },
+        entity: instance(childEntityWithNameRefMock),
+      },
+      // parent name matches parent being deleted, field null in current version but filled in previous version
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext: {
+          action: anything(),
+          previousValue: instance(childEntityWithNameRefMock),
+          cascadingDeleteCause: {
+            entity: parentEntityWithName,
+            cascadingDeleteCause: null,
+          },
+        },
+        entity: instance(childEntityWithNameRefMockWithNullifiedField),
+      },
+    ],
+  },
+);

package/src/rules/__tests__/AlwaysAllowPrivacyPolicyRule-test.ts

@@ -1,6 +1,6 @@
 import { anything, instance, mock } from 'ts-mockito';
 
-import { EntityPrivacyPolicyEvaluationContext } from '../../EntityPrivacyPolicy';
+import { EntityPrivacyPolicyRuleEvaluationContext } from '../../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../../EntityQueryContext';
 import { ViewerContext } from '../../ViewerContext';
 import { describePrivacyPolicyRule } from '../../utils/__testfixtures__/PrivacyPolicyRuleTestUtils';
@@ -12,7 +12,7 @@ describePrivacyPolicyRule(new AlwaysAllowPrivacyPolicyRule(), {
       viewerContext: instance(mock(ViewerContext)),
       queryContext: instance(mock(EntityQueryContext)),
       evaluationContext:
-        instance(mock<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>()),
+        instance(mock<EntityPrivacyPolicyRuleEvaluationContext<any, any, any, any, any>>()),
       entity: anything(),
     },
   ],

package/src/rules/__tests__/AlwaysDenyPrivacyPolicyRule-test.ts

@@ -1,6 +1,6 @@
 import { anything, instance, mock } from 'ts-mockito';
 
-import { EntityPrivacyPolicyEvaluationContext } from '../../EntityPrivacyPolicy';
+import { EntityPrivacyPolicyRuleEvaluationContext } from '../../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../../EntityQueryContext';
 import { ViewerContext } from '../../ViewerContext';
 import { describePrivacyPolicyRule } from '../../utils/__testfixtures__/PrivacyPolicyRuleTestUtils';
@@ -12,7 +12,7 @@ describePrivacyPolicyRule(new AlwaysDenyPrivacyPolicyRule(), {
       viewerContext: instance(mock(ViewerContext)),
       queryContext: instance(mock(EntityQueryContext)),
       evaluationContext:
-        instance(mock<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>()),
+        instance(mock<EntityPrivacyPolicyRuleEvaluationContext<any, any, any, any, any>>()),
       entity: anything(),
     },
   ],

package/src/rules/__tests__/AlwaysSkipPrivacyPolicyRule-test.ts

@@ -1,6 +1,6 @@
 import { anything, instance, mock } from 'ts-mockito';
 
-import { EntityPrivacyPolicyEvaluationContext } from '../../EntityPrivacyPolicy';
+import { EntityPrivacyPolicyRuleEvaluationContext } from '../../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../../EntityQueryContext';
 import { ViewerContext } from '../../ViewerContext';
 import { describePrivacyPolicyRule } from '../../utils/__testfixtures__/PrivacyPolicyRuleTestUtils';
@@ -12,7 +12,7 @@ describePrivacyPolicyRule(new AlwaysSkipPrivacyPolicyRule(), {
       viewerContext: instance(mock(ViewerContext)),
       queryContext: instance(mock(EntityQueryContext)),
       evaluationContext:
-        instance(mock<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>()),
+        instance(mock<EntityPrivacyPolicyRuleEvaluationContext<any, any, any, any, any>>()),
       entity: anything(),
     },
   ],

package/src/rules/__tests__/EvaluateIfEntityFieldPredicatePrivacyPolicyRule-test.ts

@@ -0,0 +1,47 @@
+import { mock, instance, when } from 'ts-mockito';
+
+import { EntityPrivacyPolicyRuleEvaluationContext } from '../../EntityPrivacyPolicy';
+import { EntityQueryContext } from '../../EntityQueryContext';
+import { ViewerContext } from '../../ViewerContext';
+import { describePrivacyPolicyRule } from '../../utils/__testfixtures__/PrivacyPolicyRuleTestUtils';
+import { TestEntity, TestFields } from '../../utils/__testfixtures__/TestEntity';
+import { AlwaysAllowPrivacyPolicyRule } from '../AlwaysAllowPrivacyPolicyRule';
+import { EvaluateIfEntityFieldPredicatePrivacyPolicyRule } from '../EvaluateIfEntityFieldPredicatePrivacyPolicyRule';
+
+const entityBlahMock = mock(TestEntity);
+when(entityBlahMock.getField('testIndexedField')).thenReturn('1');
+const entityBlah = instance(entityBlahMock);
+
+const entityFooMock = mock(TestEntity);
+when(entityFooMock.getField('testIndexedField')).thenReturn('2');
+const entityFoo = instance(entityFooMock);
+
+describePrivacyPolicyRule<TestFields, 'customIdField', ViewerContext, TestEntity>(
+  new EvaluateIfEntityFieldPredicatePrivacyPolicyRule<
+    TestFields,
+    'customIdField',
+    ViewerContext,
+    TestEntity,
+    'testIndexedField'
+  >('testIndexedField', (val) => val === '1', new AlwaysAllowPrivacyPolicyRule()),
+  {
+    allowCases: [
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext:
+          instance(mock<EntityPrivacyPolicyRuleEvaluationContext<any, any, any, any, any>>()),
+        entity: entityBlah,
+      },
+    ],
+    skipCases: [
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext:
+          instance(mock<EntityPrivacyPolicyRuleEvaluationContext<any, any, any, any, any>>()),
+        entity: entityFoo,
+      },
+    ],
+  },
+);

package/src/utils/EntityPrivacyUtils.ts

@@ -354,13 +354,16 @@ async function canViewerDeleteInternalAsync<
       entityCompanionProvider.getCompanionForEntity(inboundEdge).entityCompanionDefinition
         .entityConfiguration;
 
-    const loader = viewerContext
-      .getViewerScopedEntityCompanionForClass(inboundEdge)
-      .getLoaderFactory()
-      .forLoad(queryContext, {
-        previousValue: null,
-        cascadingDeleteCause: newCascadingDeleteCause,
-      });
+    const entityCompanion = viewerContext.getViewerScopedEntityCompanionForClass(inboundEdge);
+    const loaderFactory = entityCompanion.getLoaderFactory();
+    const loader = loaderFactory.forLoad(queryContext, {
+      previousValue: null,
+      cascadingDeleteCause: newCascadingDeleteCause,
+    });
+    const constructionUtils = loaderFactory.constructionUtils(queryContext, {
+      previousValue: null,
+      cascadingDeleteCause: newCascadingDeleteCause,
+    });
 
     for (const [fieldName, fieldDefinition] of configurationForInboundEdge.schema) {
       const association = fieldDefinition.association;
@@ -384,18 +387,12 @@ async function canViewerDeleteInternalAsync<
         edgeDeletionPermissionInferenceBehavior ===
         EntityEdgeDeletionAuthorizationInferenceBehavior.ONE_IMPLIES_ALL
       ) {
-        const singleEntityResultToTestForInboundEdge =
-          await loader.loadFirstByFieldEqualityConjunctionAsync(
-            [
-              {
-                fieldName,
-                fieldValue: association.associatedEntityLookupByField
-                  ? sourceEntity.getField(association.associatedEntityLookupByField as any)
-                  : sourceEntity.getID(),
-              },
-            ],
-            { orderBy: [] },
-          );
+        const singleEntityResultToTestForInboundEdge = await loader['loadOneByFieldEqualingAsync'](
+          fieldName,
+          association.associatedEntityLookupByField
+            ? sourceEntity.getField(association.associatedEntityLookupByField)
+            : sourceEntity.getID(),
+        );
         entityResultsToCheckForInboundEdge = singleEntityResultToTestForInboundEdge
           ? [singleEntityResultToTestForInboundEdge]
           : [];
@@ -403,7 +400,7 @@ async function canViewerDeleteInternalAsync<
         const entityResultsForInboundEdge = await loader.loadManyByFieldEqualingAsync(
           fieldName,
           association.associatedEntityLookupByField
-            ? sourceEntity.getField(association.associatedEntityLookupByField as any)
+            ? sourceEntity.getField(association.associatedEntityLookupByField)
             : sourceEntity.getID(),
         );
         entityResultsToCheckForInboundEdge = entityResultsForInboundEdge;
@@ -451,14 +448,6 @@ async function canViewerDeleteInternalAsync<
           // privacy policy as it would be after the cascading SET NULL operation
           const previousAndSyntheticEntitiesForInboundEdge = entitiesForInboundEdge.map(
             (entity) => {
-              const entityLoader = viewerContext
-                .getViewerScopedEntityCompanionForClass(inboundEdge)
-                .getLoaderFactory()
-                .forLoad(queryContext, {
-                  previousValue: entity,
-                  cascadingDeleteCause: newCascadingDeleteCause,
-                });
-
               const allFields = entity.getAllDatabaseFields();
               const syntheticFields = {
                 ...allFields,
@@ -467,7 +456,7 @@ async function canViewerDeleteInternalAsync<
 
               return {
                 previousValue: entity,
-                syntheticallyUpdatedValue: entityLoader.utils.constructEntity(syntheticFields),
+                syntheticallyUpdatedValue: constructionUtils.constructEntity(syntheticFields),
               };
             },
           );

package/src/utils/__testfixtures__/PrivacyPolicyRuleTestUtils.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from '@jest/globals';
 
-import { EntityPrivacyPolicyEvaluationContext } from '../../EntityPrivacyPolicy';
+import { EntityPrivacyPolicyRuleEvaluationContext } from '../../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../../EntityQueryContext';
 import { ReadonlyEntity } from '../../ReadonlyEntity';
 import { ViewerContext } from '../../ViewerContext';
@@ -15,7 +15,7 @@ export interface Case<
 > {
   viewerContext: TViewerContext;
   queryContext: EntityQueryContext;
-  evaluationContext: EntityPrivacyPolicyEvaluationContext<
+  evaluationContext: EntityPrivacyPolicyRuleEvaluationContext<
     TFields,
     TIDField,
     TViewerContext,