@expo/entity 0.38.0 → 0.39.0

package/build/utils/testing/describeFieldTestCase.js.map

@@ -1 +1 @@
-{"version":3,"file":"describeFieldTestCase.js","sourceRoot":"","sources":["../../../src/utils/testing/describeFieldTestCase.ts"],"names":[],"mappings":";;AAEA,SAAwB,qBAAqB,CAC3C,eAAyC,EACzC,WAAgB,EAChB,aAAoB;IAEpB,QAAQ,CAAC,eAAe,CAAC,WAAW,CAAC,IAAI,EAAE,GAAG,EAAE;QAC9C,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC3B,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,GAAG,eAAe,CAAC,WAAW,CAAC,IAAI,WAAW,EAAE,CAAC,KAAK,EAAE,EAAE;gBAC/E,MAAM,CAAC,eAAe,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC/D,CAAC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC7B,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,GAAG,eAAe,CAAC,WAAW,CAAC,IAAI,aAAa,EAAE,CAAC,KAAK,EAAE,EAAE;gBACnF,MAAM,CAAC,eAAe,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAChE,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC;AAlBD,wCAkBC"}
+{"version":3,"file":"describeFieldTestCase.js","sourceRoot":"","sources":["../../../src/utils/testing/describeFieldTestCase.ts"],"names":[],"mappings":";;AAEA,wCAkBC;AAlBD,SAAwB,qBAAqB,CAC3C,eAAyC,EACzC,WAAgB,EAChB,aAAoB;IAEpB,QAAQ,CAAC,eAAe,CAAC,WAAW,CAAC,IAAI,EAAE,GAAG,EAAE;QAC9C,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC3B,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,GAAG,eAAe,CAAC,WAAW,CAAC,IAAI,WAAW,EAAE,CAAC,KAAK,EAAE,EAAE;gBAC/E,MAAM,CAAC,eAAe,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC/D,CAAC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC7B,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,GAAG,eAAe,CAAC,WAAW,CAAC,IAAI,aAAa,EAAE,CAAC,KAAK,EAAE,EAAE;gBACnF,MAAM,CAAC,eAAe,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAChE,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/entity",
-  "version": "0.38.0",
+  "version": "0.39.0",
   "description": "A privacy-first data model",
   "files": [
     "build",
@@ -34,5 +34,5 @@
     "uuid": "^8.3.0",
     "uuidv7": "^1.0.0"
   },
-  "gitHead": "d7cc0c23b983eccca9ca4e7ca620a5aaef6846c4"
+  "gitHead": "9426a08a3226d907bf43378b9ea57fd04284c4ea"
 }

package/src/AuthorizationResultBasedEntityLoader.ts

@@ -102,7 +102,7 @@ export default class AuthorizationResultBasedEntityLoader<
       entityResultsForFieldValue !== undefined,
       `${fieldValue} should be guaranteed to be present in returned map of entities`,
     );
-    return entityResultsForFieldValue!;
+    return entityResultsForFieldValue;
   }
 
   /**

package/src/EntityCompanionProvider.ts

@@ -143,11 +143,14 @@ export default class EntityCompanionProvider {
    */
   constructor(
     public readonly metricsAdapter: IEntityMetricsAdapter,
-    private databaseAdapterFlavors: ReadonlyMap<
+    private readonly databaseAdapterFlavors: ReadonlyMap<
       DatabaseAdapterFlavor,
       DatabaseAdapterFlavorDefinition
     >,
-    private cacheAdapterFlavors: ReadonlyMap<CacheAdapterFlavor, CacheAdapterFlavorDefinition>,
+    private readonly cacheAdapterFlavors: ReadonlyMap<
+      CacheAdapterFlavor,
+      CacheAdapterFlavorDefinition
+    >,
     readonly globalMutationTriggers: EntityMutationTriggerConfiguration<
       any,
       any,

package/src/EntityMutator.ts

@@ -611,7 +611,7 @@ export class DeleteMutator<
    * Convenience method that throws upon delete failure.
    */
   async enforceDeleteAsync(): Promise<void> {
-    return await enforceAsyncResult(this.deleteAsync());
+    await enforceAsyncResult(this.deleteAsync());
   }
 
   private async deleteInTransactionAsync(

package/src/__tests__/EntityCommonUseCases-test.ts

@@ -118,15 +118,15 @@ it('runs through a common workflow', async () => {
   const vc2 = new TestUserViewerContext(entityCompanionProvider, uuidv4());
 
   const blahOwner1 = await enforceAsyncResult(
-    BlahEntity.creator(vc1).setField('ownerID', vc1.getUserID()!).createAsync(),
+    BlahEntity.creator(vc1).setField('ownerID', vc1.getUserID()).createAsync(),
   );
 
   await enforceAsyncResult(
-    BlahEntity.creator(vc1).setField('ownerID', vc1.getUserID()!).createAsync(),
+    BlahEntity.creator(vc1).setField('ownerID', vc1.getUserID()).createAsync(),
   );
 
   const blahOwner2 = await enforceAsyncResult(
-    BlahEntity.creator(vc2).setField('ownerID', vc2.getUserID()!).createAsync(),
+    BlahEntity.creator(vc2).setField('ownerID', vc2.getUserID()).createAsync(),
   );
 
   // sanity check created objects
@@ -149,7 +149,7 @@ it('runs through a common workflow', async () => {
   const results = await enforceResultsAsync(
     BlahEntity.loader(vc1)
       .withAuthorizationResults()
-      .loadManyByFieldEqualingAsync('ownerID', vc1.getUserID()!),
+      .loadManyByFieldEqualingAsync('ownerID', vc1.getUserID()),
   );
   expect(results).toHaveLength(2);
 

package/src/__tests__/EntityCompanion-test.ts

@@ -72,7 +72,7 @@ describe(EntityCompanion, () => {
 
     expect(mergedTriggers).toStrictEqual({
       afterCreate: [localTriggers!.afterCreate![0], globalMutationTriggers.afterCreate![0]],
-      afterAll: [localTriggers!.afterAll![0], globalMutationTriggers!.afterAll![0]],
+      afterAll: [localTriggers!.afterAll![0], globalMutationTriggers.afterAll![0]],
       afterCommit: [localTriggers!.afterCommit![0]],
     });
   });

package/src/__tests__/EntityDatabaseAdapter-test.ts

@@ -9,12 +9,12 @@ import { FieldTransformerMap } from '../internal/EntityFieldTransformationUtils'
 import { TestFields, testEntityConfiguration } from '../testfixtures/TestEntity';
 
 class TestEntityDatabaseAdapter extends EntityDatabaseAdapter<TestFields> {
-  private fetchResults: object[];
-  private insertResults: object[];
-  private updateResults: object[];
-  private fetchEqualityConditionResults: object[];
-  private fetchRawWhereResults: object[];
-  private deleteCount: number;
+  private readonly fetchResults: object[];
+  private readonly insertResults: object[];
+  private readonly updateResults: object[];
+  private readonly fetchEqualityConditionResults: object[];
+  private readonly fetchRawWhereResults: object[];
+  private readonly deleteCount: number;
 
   constructor({
     fetchResults = [],

package/src/__tests__/EntityLoader-constructor-test.ts

@@ -94,7 +94,7 @@ export default class TestEntity extends Entity<
     selectedFields: Readonly<TestFields>;
   }) {
     if (constructorParams.selectedFields.id === ID_SENTINEL_THROW_LITERAL) {
-      // eslint-disable-next-line no-throw-literal,@typescript-eslint/no-throw-literal
+      // eslint-disable-next-line no-throw-literal,@typescript-eslint/only-throw-error
       throw 'hello';
     } else if (constructorParams.selectedFields.id === ID_SENTINEL_THROW_ERROR) {
       throw new Error('world');

package/src/__tests__/entityUtils-test.ts

@@ -7,6 +7,7 @@ import {
   successfulResultsFilterMap,
   failedResultsFilterMap,
   pick,
+  partitionArray,
 } from '../entityUtils';
 
 describe(enforceResultsAsync, () => {
@@ -97,3 +98,14 @@ describe(pick, () => {
     });
   });
 });
+
+describe(partitionArray, () => {
+  it('partitions array', () => {
+    type A = true;
+    type B = false;
+    const arr: (A | B)[] = [true, false, true, true, false];
+    const [as, bs] = partitionArray<A, B>(arr, (val: A | B): val is A => val === true);
+    expect(as).toMatchObject([true, true, true]);
+    expect(bs).toMatchObject([false, false]);
+  });
+});

package/src/entityUtils.ts

@@ -71,22 +71,37 @@ export const failedResultsFilterMap = <K, T>(
   return ret;
 };
 
+export type PartitionArrayPredicate<T, U> = (val: T | U) => val is T;
+
 /**
- * Partition array of values and errors into an array of values and an array of errors.
- * @param valuesAndErrors - array of values and errors
+ * Partition an array of values into two arrays based on evaluation of a binary predicate.
+ * @param values - array of values to partition
+ * @param predicate - binary predicate to evaluate partition group of each value
  */
-export const partitionErrors = <T>(valuesAndErrors: (T | Error)[]): [T[], Error[]] => {
-  const values: T[] = [];
-  const errors: Error[] = [];
+export const partitionArray = <T, U>(
+  values: (T | U)[],
+  predicate: PartitionArrayPredicate<T, U>,
+): [T[], U[]] => {
+  const ts: T[] = [];
+  const us: U[] = [];
 
-  for (const valueOrError of valuesAndErrors) {
-    if (isError(valueOrError)) {
-      errors.push(valueOrError);
+  for (const value of values) {
+    if (predicate(value)) {
+      ts.push(value);
     } else {
-      values.push(valueOrError);
+      us.push(value);
     }
   }
 
+  return [ts, us];
+};
+
+/**
+ * Partition array of values and errors into an array of values and an array of errors.
+ * @param valuesAndErrors - array of values and errors
+ */
+export const partitionErrors = <T>(valuesAndErrors: (T | Error)[]): [T[], Error[]] => {
+  const [errors, values] = partitionArray<Error, T>(valuesAndErrors, isError);
   return [values, errors];
 };
 

package/src/internal/EntityFieldTransformationUtils.ts

@@ -26,7 +26,7 @@ export const getDatabaseFieldForEntityField = <TFields extends Record<string, an
 ): string => {
   const databaseField = entityConfiguration.entityToDBFieldsKeyMapping.get(entityField);
   invariant(databaseField, `database field mapping missing for ${String(entityField)}`);
-  return databaseField!;
+  return databaseField;
 };
 
 export const transformDatabaseObjectToFields = <TFields extends Record<string, any>>(
@@ -60,7 +60,7 @@ export const transformFieldsToDatabaseObject = <TFields extends Record<string, a
     const val = fields[k]!;
     const databaseKey = entityConfiguration.entityToDBFieldsKeyMapping.get(k as any);
     invariant(databaseKey, `must be database key for field: ${k}`);
-    databaseObject[databaseKey!] = maybeTransformFieldValueToDatabaseValue(
+    databaseObject[databaseKey] = maybeTransformFieldValueToDatabaseValue(
       entityConfiguration,
       fieldTransformerMap,
       k,

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

@@ -306,11 +306,11 @@ describe(EntityDataManager, () => {
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
 
     await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'testIndexedField', [
-      objectInQuestion['testIndexedField']!,
+      objectInQuestion['testIndexedField'],
     ]);
     await entityDataManager.invalidateObjectFieldsAsync(objectInQuestion);
     await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'testIndexedField', [
-      objectInQuestion['testIndexedField']!,
+      objectInQuestion['testIndexedField'],
     ]);
 
     expect(dbSpy).toHaveBeenCalledTimes(2);
@@ -345,11 +345,11 @@ describe(EntityDataManager, () => {
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
 
     await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'testIndexedField', [
-      objectInQuestion['testIndexedField']!,
+      objectInQuestion['testIndexedField'],
     ]);
     await entityDataManager.invalidateObjectFieldsAsync(objectInQuestion);
     await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'customIdField', [
-      objectInQuestion['customIdField']!,
+      objectInQuestion['customIdField'],
     ]);
 
     expect(dbSpy).toHaveBeenCalledTimes(2);

package/src/utils/EntityPrivacyUtils.ts

@@ -9,9 +9,22 @@ import { EntityCascadingDeletionInfo } from '../EntityMutationInfo';
 import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../EntityQueryContext';
 import ViewerContext from '../ViewerContext';
-import { failedResults } from '../entityUtils';
+import { failedResults, partitionArray } from '../entityUtils';
 import EntityNotAuthorizedError from '../errors/EntityNotAuthorizedError';
 
+export type EntityPrivacyEvaluationResultSuccess = {
+  allowed: true;
+};
+
+export type EntityPrivacyEvaluationResultFailure = {
+  allowed: false;
+  authorizationErrors: EntityNotAuthorizedError<any, any, any, any, any>[];
+};
+
+export type EntityPrivacyEvaluationResult =
+  | EntityPrivacyEvaluationResultSuccess
+  | EntityPrivacyEvaluationResultFailure;
+
 /**
  * Check whether an entity loaded by a viewer can be updated by that same viewer.
  *
@@ -30,34 +43,67 @@ import EntityNotAuthorizedError from '../errors/EntityNotAuthorizedError';
  * @param queryContext - query context in which to perform the check
  */
 export async function canViewerUpdateAsync<
-  TMFields extends object,
-  TMID extends NonNullable<TMFields[TMSelectedFields]>,
-  TMViewerContext extends ViewerContext,
-  TMEntity extends Entity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
-  TMPrivacyPolicy extends EntityPrivacyPolicy<
-    TMFields,
-    TMID,
-    TMViewerContext,
-    TMEntity,
-    TMSelectedFields
+  TFields extends object,
+  TID extends NonNullable<TFields[TSelectedFields]>,
+  TViewerContext extends ViewerContext,
+  TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
+  TPrivacyPolicy extends EntityPrivacyPolicy<
+    TFields,
+    TID,
+    TViewerContext,
+    TEntity,
+    TSelectedFields
   >,
-  TMSelectedFields extends keyof TMFields = keyof TMFields,
+  TSelectedFields extends keyof TFields = keyof TFields,
 >(
-  entityClass: IEntityClass<
-    TMFields,
-    TMID,
-    TMViewerContext,
-    TMEntity,
-    TMPrivacyPolicy,
-    TMSelectedFields
-  >,
-  sourceEntity: TMEntity,
+  entityClass: IEntityClass<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>,
+  sourceEntity: TEntity,
   queryContext: EntityQueryContext = sourceEntity
     .getViewerContext()
     .getViewerScopedEntityCompanionForClass(entityClass)
     .getQueryContextProvider()
     .getQueryContext(),
 ): Promise<boolean> {
+  const result = await canViewerUpdateInternalAsync(
+    entityClass,
+    sourceEntity,
+    /* cascadingDeleteCause */ null,
+    queryContext,
+  );
+  return result.allowed;
+}
+
+/**
+ * Check whether an entity loaded by a viewer can be updated by that same viewer and return the evaluation result.
+ *
+ * @see canViewerUpdateAsync
+ *
+ * @param entityClass - class of entity
+ * @param sourceEntity - entity loaded by viewer
+ * @param queryContext - query context in which to perform the check
+ */
+export async function getCanViewerUpdateResultAsync<
+  TFields extends object,
+  TID extends NonNullable<TFields[TSelectedFields]>,
+  TViewerContext extends ViewerContext,
+  TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
+  TPrivacyPolicy extends EntityPrivacyPolicy<
+    TFields,
+    TID,
+    TViewerContext,
+    TEntity,
+    TSelectedFields
+  >,
+  TSelectedFields extends keyof TFields = keyof TFields,
+>(
+  entityClass: IEntityClass<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>,
+  sourceEntity: TEntity,
+  queryContext: EntityQueryContext = sourceEntity
+    .getViewerContext()
+    .getViewerScopedEntityCompanionForClass(entityClass)
+    .getQueryContextProvider()
+    .getQueryContext(),
+): Promise<EntityPrivacyEvaluationResult> {
   return await canViewerUpdateInternalAsync(
     entityClass,
     sourceEntity,
@@ -67,31 +113,24 @@ export async function canViewerUpdateAsync<
 }
 
 async function canViewerUpdateInternalAsync<
-  TMFields extends object,
-  TMID extends NonNullable<TMFields[TMSelectedFields]>,
-  TMViewerContext extends ViewerContext,
-  TMEntity extends Entity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
-  TMPrivacyPolicy extends EntityPrivacyPolicy<
-    TMFields,
-    TMID,
-    TMViewerContext,
-    TMEntity,
-    TMSelectedFields
+  TFields extends object,
+  TID extends NonNullable<TFields[TSelectedFields]>,
+  TViewerContext extends ViewerContext,
+  TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
+  TPrivacyPolicy extends EntityPrivacyPolicy<
+    TFields,
+    TID,
+    TViewerContext,
+    TEntity,
+    TSelectedFields
   >,
-  TMSelectedFields extends keyof TMFields = keyof TMFields,
+  TSelectedFields extends keyof TFields = keyof TFields,
 >(
-  entityClass: IEntityClass<
-    TMFields,
-    TMID,
-    TMViewerContext,
-    TMEntity,
-    TMPrivacyPolicy,
-    TMSelectedFields
-  >,
-  sourceEntity: TMEntity,
+  entityClass: IEntityClass<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>,
+  sourceEntity: TEntity,
   cascadingDeleteCause: EntityCascadingDeletionInfo | null,
   queryContext: EntityQueryContext,
-): Promise<boolean> {
+): Promise<EntityPrivacyEvaluationResult> {
   const companion = sourceEntity
     .getViewerContext()
     .getViewerScopedEntityCompanionForClass(entityClass);
@@ -107,20 +146,19 @@ async function canViewerUpdateInternalAsync<
   );
   if (!evaluationResult.ok) {
     if (evaluationResult.reason instanceof EntityNotAuthorizedError) {
-      return false;
+      return { allowed: false, authorizationErrors: [evaluationResult.reason] };
     } else {
       throw evaluationResult.reason;
     }
   }
-  return evaluationResult.ok;
+  return { allowed: true };
 }
 
 /**
  * Check whether a single entity loaded by a viewer can be deleted by that same viewer.
  * This recursively checks edge cascade permissions (EntityEdgeDeletionBehavior) as well.
  *
- * @remarks
- * See remarks for canViewerUpdate.
+ * @see canViewerUpdateAsync
  *
  * @param entityClass - class of entity
  * @param sourceEntity - entity loaded by viewer
@@ -129,32 +167,65 @@ async function canViewerUpdateInternalAsync<
 export async function canViewerDeleteAsync<
   TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
-  TMViewerContext extends ViewerContext,
-  TEntity extends Entity<TFields, TID, TMViewerContext, TSelectedFields>,
+  TViewerContext extends ViewerContext,
+  TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
   TPrivacyPolicy extends EntityPrivacyPolicy<
     TFields,
     TID,
-    TMViewerContext,
+    TViewerContext,
     TEntity,
     TSelectedFields
   >,
   TSelectedFields extends keyof TFields = keyof TFields,
 >(
-  entityClass: IEntityClass<
+  entityClass: IEntityClass<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>,
+  sourceEntity: TEntity,
+  queryContext: EntityQueryContext = sourceEntity
+    .getViewerContext()
+    .getViewerScopedEntityCompanionForClass(entityClass)
+    .getQueryContextProvider()
+    .getQueryContext(),
+): Promise<boolean> {
+  const result = await canViewerDeleteInternalAsync(
+    entityClass,
+    sourceEntity,
+    /* cascadingDeleteCause */ null,
+    queryContext,
+  );
+  return result.allowed;
+}
+
+/**
+ * Check whether a single entity loaded by a viewer can be deleted by that same viewer and return the evaluation result.
+ *
+ * @see canViewerDeleteAsync
+ *
+ * @param entityClass - class of entity
+ * @param sourceEntity - entity loaded by viewer
+ * @param queryContext - query context in which to perform the check
+ */
+export async function getCanViewerDeleteResultAsync<
+  TFields extends object,
+  TID extends NonNullable<TFields[TSelectedFields]>,
+  TViewerContext extends ViewerContext,
+  TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
+  TPrivacyPolicy extends EntityPrivacyPolicy<
     TFields,
     TID,
-    TMViewerContext,
+    TViewerContext,
     TEntity,
-    TPrivacyPolicy,
     TSelectedFields
   >,
+  TSelectedFields extends keyof TFields = keyof TFields,
+>(
+  entityClass: IEntityClass<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>,
   sourceEntity: TEntity,
   queryContext: EntityQueryContext = sourceEntity
     .getViewerContext()
     .getViewerScopedEntityCompanionForClass(entityClass)
     .getQueryContextProvider()
     .getQueryContext(),
-): Promise<boolean> {
+): Promise<EntityPrivacyEvaluationResult> {
   return await canViewerDeleteInternalAsync(
     entityClass,
     sourceEntity,
@@ -166,29 +237,22 @@ export async function canViewerDeleteAsync<
 async function canViewerDeleteInternalAsync<
   TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
-  TMViewerContext extends ViewerContext,
-  TEntity extends Entity<TFields, TID, TMViewerContext, TSelectedFields>,
+  TViewerContext extends ViewerContext,
+  TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
   TPrivacyPolicy extends EntityPrivacyPolicy<
     TFields,
     TID,
-    TMViewerContext,
+    TViewerContext,
     TEntity,
     TSelectedFields
   >,
   TSelectedFields extends keyof TFields = keyof TFields,
 >(
-  entityClass: IEntityClass<
-    TFields,
-    TID,
-    TMViewerContext,
-    TEntity,
-    TPrivacyPolicy,
-    TSelectedFields
-  >,
+  entityClass: IEntityClass<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>,
   sourceEntity: TEntity,
   cascadingDeleteCause: EntityCascadingDeletionInfo | null,
   queryContext: EntityQueryContext,
-): Promise<boolean> {
+): Promise<EntityPrivacyEvaluationResult> {
   const viewerContext = sourceEntity.getViewerContext();
   const entityCompanionProvider = viewerContext.entityCompanionProvider;
   const viewerScopedCompanion = sourceEntity
@@ -207,7 +271,7 @@ async function canViewerDeleteInternalAsync<
   );
   if (!evaluationResult.ok) {
     if (evaluationResult.reason instanceof EntityNotAuthorizedError) {
-      return false;
+      return { allowed: false, authorizationErrors: [evaluationResult.reason] };
     } else {
       throw evaluationResult.reason;
     }
@@ -297,7 +361,7 @@ async function canViewerDeleteInternalAsync<
       const failedEntityLoadResults = failedResults(entityResultsToCheckForInboundEdge);
       for (const failedResult of failedEntityLoadResults) {
         if (failedResult.reason instanceof EntityNotAuthorizedError) {
-          return false;
+          return { allowed: false, authorizationErrors: [failedResult.reason] };
         } else {
           throw failedResult.reason;
         }
@@ -311,48 +375,68 @@ async function canViewerDeleteInternalAsync<
       switch (association.edgeDeletionBehavior) {
         case EntityEdgeDeletionBehavior.CASCADE_DELETE:
         case EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE_ONLY: {
-          const canDeleteAll = (
-            await Promise.all(
-              entitiesForInboundEdge.map((entity) =>
-                canViewerDeleteInternalAsync(
-                  inboundEdge,
-                  entity,
-                  newCascadingDeleteCause,
-                  queryContext,
-                ),
+          const canDeleteEvaluationResults = await Promise.all(
+            entitiesForInboundEdge.map((entity) =>
+              canViewerDeleteInternalAsync(
+                inboundEdge,
+                entity,
+                newCascadingDeleteCause,
+                queryContext,
               ),
-            )
-          ).every((b) => b);
+            ),
+          );
 
-          if (!canDeleteAll) {
-            return false;
+          const reducedEvaluationResult = reduceEvaluationResults(canDeleteEvaluationResults);
+          if (!reducedEvaluationResult.allowed) {
+            return reducedEvaluationResult;
           }
+
           break;
         }
 
         case EntityEdgeDeletionBehavior.SET_NULL:
         case EntityEdgeDeletionBehavior.SET_NULL_INVALIDATE_CACHE_ONLY: {
-          const canUpdateAll = (
-            await Promise.all(
-              entitiesForInboundEdge.map((entity) =>
-                canViewerUpdateInternalAsync(
-                  inboundEdge,
-                  entity,
-                  newCascadingDeleteCause,
-                  queryContext,
-                ),
+          const canUpdateEvaluationResults = await Promise.all(
+            entitiesForInboundEdge.map((entity) =>
+              canViewerUpdateInternalAsync(
+                inboundEdge,
+                entity,
+                newCascadingDeleteCause,
+                queryContext,
               ),
-            )
-          ).every((b) => b);
+            ),
+          );
 
-          if (!canUpdateAll) {
-            return false;
+          const reducedEvaluationResult = reduceEvaluationResults(canUpdateEvaluationResults);
+          if (!reducedEvaluationResult.allowed) {
+            return reducedEvaluationResult;
           }
+
           break;
         }
       }
     }
   }
 
-  return true;
+  return { allowed: true };
+}
+
+function reduceEvaluationResults(
+  evaluationResults: EntityPrivacyEvaluationResult[],
+): EntityPrivacyEvaluationResult {
+  const [successResults, failureResults] = partitionArray<
+    EntityPrivacyEvaluationResultSuccess,
+    EntityPrivacyEvaluationResultFailure
+  >(evaluationResults, (evaluationResult) => evaluationResult.allowed);
+
+  if (successResults.length === evaluationResults.length) {
+    return { allowed: true };
+  }
+
+  return {
+    allowed: false,
+    authorizationErrors: failureResults.flatMap(
+      (failureResult) => failureResult.authorizationErrors,
+    ),
+  };
 }