@expo/entity 0.35.0 → 0.37.0

package/src/metrics/EntityMetricsUtils.ts

@@ -8,7 +8,7 @@ export const timeAndLogLoadEventAsync =
   (
     metricsAdapter: IEntityMetricsAdapter,
     loadType: EntityMetricsLoadType,
-    entityClassName: string
+    entityClassName: string,
   ) =>
   async <TFields>(promise: Promise<readonly Readonly<TFields>[]>) => {
     const startTime = Date.now();
@@ -29,10 +29,10 @@ export const timeAndLogLoadMapEventAsync =
   (
     metricsAdapter: IEntityMetricsAdapter,
     loadType: EntityMetricsLoadType,
-    entityClassName: string
+    entityClassName: string,
   ) =>
   async <TFields, N extends keyof TFields>(
-    promise: Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>>
+    promise: Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>>,
   ) => {
     const startTime = Date.now();
     const result = await promise;
@@ -54,7 +54,7 @@ export const timeAndLogMutationEventAsync =
   (
     metricsAdapter: IEntityMetricsAdapter,
     mutationType: EntityMetricsMutationType,
-    entityClassName: string
+    entityClassName: string,
   ) =>
   async <T>(promise: Promise<T>) => {
     const startTime = Date.now();

package/src/metrics/IEntityMetricsAdapter.ts

@@ -140,7 +140,7 @@ export default interface IEntityMetricsAdapter {
    * Called when a dataloader, cache, or database load is initiated via the standard
    * load methods (not equality conjunction or raw). Most commonly used for logging
    * a waterfall to determine dataloader and cache hit rates and ratios.
-   * @param fieldValueCount - count of field values being loaded for a field
+   * @param incrementLoadCountEvent - count of field values being loaded for a field
    */
   incrementDataManagerLoadCount(incrementLoadCountEvent: IncrementLoadCountEvent): void;
 }

package/src/rules/AlwaysAllowPrivacyPolicyRule.ts

@@ -12,13 +12,19 @@ export default class AlwaysAllowPrivacyPolicyRule<
   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,
 > extends PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
   async evaluateAsync(
     _viewerContext: TViewerContext,
     _queryContext: EntityQueryContext,
-    _evaluationContext: EntityPrivacyPolicyEvaluationContext,
-    _entity: TEntity
+    _evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+    _entity: TEntity,
   ): Promise<RuleEvaluationResult> {
     return RuleEvaluationResult.ALLOW;
   }

package/src/rules/AlwaysDenyPrivacyPolicyRule.ts

@@ -12,13 +12,19 @@ export default class AlwaysDenyPrivacyPolicyRule<
   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,
 > extends PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
   async evaluateAsync(
     _viewerContext: TViewerContext,
     _queryContext: EntityQueryContext,
-    _evaluationContext: EntityPrivacyPolicyEvaluationContext,
-    _entity: TEntity
+    _evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+    _entity: TEntity,
   ): Promise<RuleEvaluationResult> {
     return RuleEvaluationResult.DENY;
   }

package/src/rules/AlwaysSkipPrivacyPolicyRule.ts

@@ -12,13 +12,19 @@ export default class AlwaysSkipPrivacyPolicyRule<
   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,
 > extends PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
   async evaluateAsync(
     _viewerContext: TViewerContext,
     _queryContext: EntityQueryContext,
-    _evaluationContext: EntityPrivacyPolicyEvaluationContext,
-    _entity: TEntity
+    _evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+    _entity: TEntity,
   ): Promise<RuleEvaluationResult> {
     return RuleEvaluationResult.SKIP;
   }

package/src/rules/PrivacyPolicyRule.ts

@@ -41,12 +41,18 @@ export default abstract class PrivacyPolicyRule<
   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,
 > {
   abstract evaluateAsync(
     viewerContext: TViewerContext,
     queryContext: EntityQueryContext,
-    evaluationContext: EntityPrivacyPolicyEvaluationContext,
-    entity: TEntity
+    evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+    entity: TEntity,
   ): Promise<RuleEvaluationResult>;
 }

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

@@ -11,7 +11,8 @@ describePrivacyPolicyRule(new AlwaysAllowPrivacyPolicyRule(), {
     {
       viewerContext: instance(mock(ViewerContext)),
       queryContext: instance(mock(EntityQueryContext)),
-      evaluationContext: instance(mock<EntityPrivacyPolicyEvaluationContext>()),
+      evaluationContext:
+        instance(mock<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>()),
       entity: anything(),
     },
   ],

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

@@ -11,7 +11,8 @@ describePrivacyPolicyRule(new AlwaysDenyPrivacyPolicyRule(), {
     {
       viewerContext: instance(mock(ViewerContext)),
       queryContext: instance(mock(EntityQueryContext)),
-      evaluationContext: instance(mock<EntityPrivacyPolicyEvaluationContext>()),
+      evaluationContext:
+        instance(mock<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>()),
       entity: anything(),
     },
   ],

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

@@ -11,7 +11,8 @@ describePrivacyPolicyRule(new AlwaysSkipPrivacyPolicyRule(), {
     {
       viewerContext: instance(mock(ViewerContext)),
       queryContext: instance(mock(EntityQueryContext)),
-      evaluationContext: instance(mock<EntityPrivacyPolicyEvaluationContext>()),
+      evaluationContext:
+        instance(mock<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>()),
       entity: anything(),
     },
   ],

package/src/testfixtures/TestEntity.ts

@@ -99,7 +99,7 @@ export default class TestEntity extends Entity<TestFields, string, ViewerContext
         id: testValue,
         databaseFields: fields,
         selectedFields: fields,
-      })
+      }),
     );
   }
 

package/src/testfixtures/TestEntityWithMutationTriggers.ts

@@ -0,0 +1,156 @@
+import Entity from '../Entity';
+import { EntityCompanionDefinition } from '../EntityCompanionProvider';
+import EntityConfiguration from '../EntityConfiguration';
+import { StringField, UUIDField } from '../EntityFields';
+import { EntityTriggerMutationInfo } from '../EntityMutationInfo';
+import {
+  EntityMutationTrigger,
+  EntityNonTransactionalMutationTrigger,
+} from '../EntityMutationTriggerConfiguration';
+import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
+import { EntityQueryContext } from '../EntityQueryContext';
+import ViewerContext from '../ViewerContext';
+import AlwaysAllowPrivacyPolicyRule from '../rules/AlwaysAllowPrivacyPolicyRule';
+
+export type TestMTFields = {
+  id: string;
+  stringField: string;
+};
+
+export const testEntityMTConfiguration = new EntityConfiguration<TestMTFields>({
+  idField: 'id',
+  tableName: 'test_entity_should_not_write_to_db_3',
+  schema: {
+    id: new UUIDField({
+      columnName: 'id',
+    }),
+    stringField: new StringField({
+      columnName: 'string_field',
+    }),
+  },
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
+});
+
+export class TestEntityMTPrivacyPolicy extends EntityPrivacyPolicy<
+  TestMTFields,
+  string,
+  ViewerContext,
+  TestEntityWithMutationTriggers
+> {
+  protected override readonly readRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      TestMTFields,
+      string,
+      ViewerContext,
+      TestEntityWithMutationTriggers
+    >(),
+  ];
+  protected override readonly createRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      TestMTFields,
+      string,
+      ViewerContext,
+      TestEntityWithMutationTriggers
+    >(),
+  ];
+  protected override readonly updateRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      TestMTFields,
+      string,
+      ViewerContext,
+      TestEntityWithMutationTriggers
+    >(),
+  ];
+  protected override readonly deleteRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      TestMTFields,
+      string,
+      ViewerContext,
+      TestEntityWithMutationTriggers
+    >(),
+  ];
+}
+
+export class TestMutationTrigger extends EntityMutationTrigger<
+  TestMTFields,
+  string,
+  ViewerContext,
+  TestEntityWithMutationTriggers,
+  keyof TestMTFields
+> {
+  constructor(
+    // @ts-expect-error key is never used but is helpful for debugging
+    private readonly key: string,
+  ) {
+    super();
+  }
+
+  async executeAsync(
+    _viewerContext: ViewerContext,
+    _queryContext: EntityQueryContext,
+    _entity: TestEntityWithMutationTriggers,
+    _mutationInfo: EntityTriggerMutationInfo<
+      TestMTFields,
+      string,
+      ViewerContext,
+      TestEntityWithMutationTriggers,
+      keyof TestMTFields
+    >,
+  ): Promise<void> {}
+}
+
+export class NonTransactionalTestMutationTrigger extends EntityNonTransactionalMutationTrigger<
+  TestMTFields,
+  string,
+  ViewerContext,
+  TestEntityWithMutationTriggers,
+  keyof TestMTFields
+> {
+  constructor(
+    // @ts-expect-error key is never used but is helpful for debugging
+    private readonly key: string,
+  ) {
+    super();
+  }
+
+  async executeAsync(
+    _viewerContext: ViewerContext,
+    _entity: TestEntityWithMutationTriggers,
+    _mutationInfo: EntityTriggerMutationInfo<
+      TestMTFields,
+      string,
+      ViewerContext,
+      TestEntityWithMutationTriggers,
+      keyof TestMTFields
+    >,
+  ): Promise<void> {}
+}
+
+/**
+ * A test Entity that has one afterCreate and one afterAll trigger
+ */
+export default class TestEntityWithMutationTriggers extends Entity<
+  TestMTFields,
+  string,
+  ViewerContext
+> {
+  static defineCompanionDefinition(): EntityCompanionDefinition<
+    TestMTFields,
+    string,
+    ViewerContext,
+    TestEntityWithMutationTriggers,
+    TestEntityMTPrivacyPolicy
+  > {
+    return {
+      entityClass: TestEntityWithMutationTriggers,
+      entityConfiguration: testEntityMTConfiguration,
+      privacyPolicyClass: TestEntityMTPrivacyPolicy,
+      mutationTriggers: {
+        afterCreate: [new TestMutationTrigger('localAfterCreate')],
+        afterAll: [new TestMutationTrigger('localAfterAll')],
+        afterCommit: [new NonTransactionalTestMutationTrigger('localAfterCommit')],
+      },
+    };
+  }
+}

package/src/utils/EntityPrivacyUtils.ts

@@ -0,0 +1,325 @@
+import { asyncResult } from '@expo/results';
+
+import Entity, { IEntityClass } from '../Entity';
+import { EntityEdgeDeletionBehavior } from '../EntityFieldDefinition';
+import { EntityCascadingDeletionInfo } from '../EntityMutationInfo';
+import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
+import { EntityQueryContext } from '../EntityQueryContext';
+import ViewerContext from '../ViewerContext';
+import { failedResults } from '../entityUtils';
+import EntityNotAuthorizedError from '../errors/EntityNotAuthorizedError';
+
+/**
+ * Check whether an entity loaded by a viewer can be updated by that same viewer.
+ *
+ * @remarks
+ *
+ * This may be useful in situations relying upon the thrown privacy policy thrown authorization error
+ * is insufficient for the task at hand. When dealing with purely a sequence of mutations it is easy
+ * to roll back all mutations given a single authorization error by wrapping them in a single transaction.
+ * When certain portions of a mutation cannot be rolled back transactionally (third pary calls,
+ * legacy code, etc), using this method can help decide whether the sequence of mutations will fail before
+ * attempting them. Note that if any privacy policy rules use a piece of data being updated in the mutations
+ * the result of this method and the update mutation itself may differ.
+ *
+ * @param entityClass - class of entity
+ * @param sourceEntity - entity loaded by viewer
+ * @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
+  >,
+  TMSelectedFields extends keyof TMFields = keyof TMFields,
+>(
+  entityClass: IEntityClass<
+    TMFields,
+    TMID,
+    TMViewerContext,
+    TMEntity,
+    TMPrivacyPolicy,
+    TMSelectedFields
+  >,
+  sourceEntity: TMEntity,
+  queryContext: EntityQueryContext = sourceEntity
+    .getViewerContext()
+    .getViewerScopedEntityCompanionForClass(entityClass)
+    .getQueryContextProvider()
+    .getQueryContext(),
+): Promise<boolean> {
+  return await canViewerUpdateInternalAsync(
+    entityClass,
+    sourceEntity,
+    /* cascadingDeleteCause */ null,
+    queryContext,
+  );
+}
+
+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
+  >,
+  TMSelectedFields extends keyof TMFields = keyof TMFields,
+>(
+  entityClass: IEntityClass<
+    TMFields,
+    TMID,
+    TMViewerContext,
+    TMEntity,
+    TMPrivacyPolicy,
+    TMSelectedFields
+  >,
+  sourceEntity: TMEntity,
+  cascadingDeleteCause: EntityCascadingDeletionInfo | null,
+  queryContext: EntityQueryContext,
+): Promise<boolean> {
+  const companion = sourceEntity
+    .getViewerContext()
+    .getViewerScopedEntityCompanionForClass(entityClass);
+  const privacyPolicy = companion.entityCompanion.privacyPolicy;
+  const evaluationResult = await asyncResult(
+    privacyPolicy.authorizeUpdateAsync(
+      sourceEntity.getViewerContext(),
+      queryContext,
+      { previousValue: null, cascadingDeleteCause },
+      sourceEntity,
+      companion.getMetricsAdapter(),
+    ),
+  );
+  if (!evaluationResult.ok) {
+    if (evaluationResult.reason instanceof EntityNotAuthorizedError) {
+      return false;
+    } else {
+      throw evaluationResult.reason;
+    }
+  }
+  return evaluationResult.ok;
+}
+
+/**
+ * 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.
+ *
+ * @param entityClass - class of entity
+ * @param sourceEntity - entity loaded by viewer
+ * @param queryContext - query context in which to perform the check
+ */
+export async function canViewerDeleteAsync<
+  TFields extends object,
+  TID extends NonNullable<TFields[TSelectedFields]>,
+  TMViewerContext extends ViewerContext,
+  TEntity extends Entity<TFields, TID, TMViewerContext, TSelectedFields>,
+  TPrivacyPolicy extends EntityPrivacyPolicy<
+    TFields,
+    TID,
+    TMViewerContext,
+    TEntity,
+    TSelectedFields
+  >,
+  TSelectedFields extends keyof TFields = keyof TFields,
+>(
+  entityClass: IEntityClass<
+    TFields,
+    TID,
+    TMViewerContext,
+    TEntity,
+    TPrivacyPolicy,
+    TSelectedFields
+  >,
+  sourceEntity: TEntity,
+  queryContext: EntityQueryContext = sourceEntity
+    .getViewerContext()
+    .getViewerScopedEntityCompanionForClass(entityClass)
+    .getQueryContextProvider()
+    .getQueryContext(),
+): Promise<boolean> {
+  return await canViewerDeleteInternalAsync(
+    entityClass,
+    sourceEntity,
+    /* cascadingDeleteCause */ null,
+    queryContext,
+  );
+}
+
+async function canViewerDeleteInternalAsync<
+  TFields extends object,
+  TID extends NonNullable<TFields[TSelectedFields]>,
+  TMViewerContext extends ViewerContext,
+  TEntity extends Entity<TFields, TID, TMViewerContext, TSelectedFields>,
+  TPrivacyPolicy extends EntityPrivacyPolicy<
+    TFields,
+    TID,
+    TMViewerContext,
+    TEntity,
+    TSelectedFields
+  >,
+  TSelectedFields extends keyof TFields = keyof TFields,
+>(
+  entityClass: IEntityClass<
+    TFields,
+    TID,
+    TMViewerContext,
+    TEntity,
+    TPrivacyPolicy,
+    TSelectedFields
+  >,
+  sourceEntity: TEntity,
+  cascadingDeleteCause: EntityCascadingDeletionInfo | null,
+  queryContext: EntityQueryContext,
+): Promise<boolean> {
+  const viewerContext = sourceEntity.getViewerContext();
+  const entityCompanionProvider = viewerContext.entityCompanionProvider;
+  const viewerScopedCompanion = sourceEntity
+    .getViewerContext()
+    .getViewerScopedEntityCompanionForClass(entityClass);
+
+  const privacyPolicy = viewerScopedCompanion.entityCompanion.privacyPolicy;
+  const evaluationResult = await asyncResult(
+    privacyPolicy.authorizeDeleteAsync(
+      sourceEntity.getViewerContext(),
+      queryContext,
+      { previousValue: null, cascadingDeleteCause },
+      sourceEntity,
+      viewerScopedCompanion.getMetricsAdapter(),
+    ),
+  );
+  if (!evaluationResult.ok) {
+    if (evaluationResult.reason instanceof EntityNotAuthorizedError) {
+      return false;
+    } else {
+      throw evaluationResult.reason;
+    }
+  }
+
+  const newCascadingDeleteCause = {
+    entity: sourceEntity,
+    cascadingDeleteCause,
+  };
+
+  // Take entity X which is proposed to be deleted, look at inbound edges (entities that reference X).
+  // These inbound edges are the entities that will either get deleted or have their references
+  // to X nullified based on the EntityEdgeDeletionBehavior when entity X is deleted.
+  // For each of these inboundEdge entities Y, look at the field(s) on Y that reference X.
+  // For each of the field(s) on Y that reference X,
+  // - if EntityEdgeDeletionBehavior is cascade set null, check if user can update Y
+  // - if EntityEdgeDeletionBehavior is cascade delete, recursively run canViewerDeleteAsync on Y
+  // Return the conjunction (returning eagerly when false) of all checks recursively.
+
+  const entityConfiguration =
+    viewerScopedCompanion.entityCompanion.entityCompanionDefinition.entityConfiguration;
+  const inboundEdges = entityConfiguration.inboundEdges;
+
+  for (const inboundEdge of inboundEdges) {
+    const configurationForInboundEdge =
+      entityCompanionProvider.getCompanionForEntity(inboundEdge).entityCompanionDefinition
+        .entityConfiguration;
+
+    const loader = viewerContext
+      .getViewerScopedEntityCompanionForClass(inboundEdge)
+      .getLoaderFactory()
+      .forLoad(queryContext, {
+        previousValue: null,
+        cascadingDeleteCause: newCascadingDeleteCause,
+      });
+
+    for (const [fieldName, fieldDefinition] of configurationForInboundEdge.schema) {
+      const association = fieldDefinition.association;
+      if (!association) {
+        continue;
+      }
+
+      const associatedConfiguration = entityCompanionProvider.getCompanionForEntity(
+        association.associatedEntityClass,
+      ).entityCompanionDefinition.entityConfiguration;
+      if (associatedConfiguration !== entityConfiguration) {
+        continue;
+      }
+
+      const entityResultsForInboundEdge = await loader
+        .withAuthorizationResults()
+        .loadManyByFieldEqualingAsync(
+          fieldName,
+          association.associatedEntityLookupByField
+            ? sourceEntity.getField(association.associatedEntityLookupByField as any)
+            : sourceEntity.getID(),
+        );
+
+      const failedEntityLoadResults = failedResults(entityResultsForInboundEdge);
+      for (const failedResult of failedEntityLoadResults) {
+        if (failedResult.reason instanceof EntityNotAuthorizedError) {
+          return false;
+        } else {
+          throw failedResult.reason;
+        }
+      }
+
+      // all results should be success at this point due to check above
+      const entitiesForInboundEdge = entityResultsForInboundEdge.map((r) => r.enforceValue());
+
+      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,
+                ),
+              ),
+            )
+          ).every((b) => b);
+
+          if (!canDeleteAll) {
+            return false;
+          }
+          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,
+                ),
+              ),
+            )
+          ).every((b) => b);
+
+          if (!canUpdateAll) {
+            return false;
+          }
+          break;
+        }
+      }
+    }
+  }
+
+  return true;
+}