@expo/entity 0.53.0 → 0.55.0

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

@@ -0,0 +1,64 @@
+import { anything, instance, mock } from 'ts-mockito';
+
+import { EntityPrivacyPolicyEvaluationContext } 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<EntityPrivacyPolicyEvaluationContext<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<EntityPrivacyPolicyEvaluationContext<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<EntityPrivacyPolicyEvaluationContext<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 { EntityPrivacyPolicyEvaluationContext } 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<EntityPrivacyPolicyEvaluationContext<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<EntityPrivacyPolicyEvaluationContext<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<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>()),
+        entity: anything(),
+      },
+    ],
+  },
+);

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

@@ -0,0 +1,258 @@
+import { 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: {
+          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: {
+          previousValue: instance(childEntityMock),
+          cascadingDeleteCause: {
+            entity: parentEntity,
+            cascadingDeleteCause: null,
+          },
+        },
+        entity: instance(childEntityMockWithNullifiedField),
+      },
+    ],
+    skipCases: [
+      // no cascading delete
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext: {
+          previousValue: null,
+          cascadingDeleteCause: null,
+        },
+        entity: instance(childEntityMock),
+      },
+      // cascading delete not from parent entity class
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext: {
+          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: {
+          previousValue: null,
+          cascadingDeleteCause: {
+            entity: otherParentEntity,
+            cascadingDeleteCause: null,
+          },
+        },
+        entity: instance(childEntityMock),
+      },
+      // entity belongs to different parent
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext: {
+          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: {
+          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: {
+          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: {
+          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: {
+          previousValue: instance(childEntityWithNameRefMock),
+          cascadingDeleteCause: {
+            entity: parentEntityWithName,
+            cascadingDeleteCause: null,
+          },
+        },
+        entity: instance(childEntityWithNameRefMockWithNullifiedField),
+      },
+    ],
+  },
+);

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

@@ -0,0 +1,47 @@
+import { mock, instance, when } from 'ts-mockito';
+
+import { EntityPrivacyPolicyEvaluationContext } 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<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>()),
+        entity: entityBlah,
+      },
+    ],
+    skipCases: [
+      {
+        viewerContext: instance(mock(ViewerContext)),
+        queryContext: instance(mock(EntityQueryContext)),
+        evaluationContext:
+          instance(mock<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>()),
+        entity: entityFoo,
+      },
+    ],
+  },
+);

package/src/utils/EntityPrivacyUtils.ts

@@ -5,9 +5,9 @@ import {
   EntityEdgeDeletionAuthorizationInferenceBehavior,
   EntityEdgeDeletionBehavior,
 } from '../EntityFieldDefinition';
-import { EntityCascadingDeletionInfo } from '../EntityMutationInfo';
-import { EntityPrivacyPolicy } from '../EntityPrivacyPolicy';
+import { EntityPrivacyPolicy, EntityPrivacyPolicyEvaluationContext } from '../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../EntityQueryContext';
+import { ReadonlyEntity } from '../ReadonlyEntity';
 import { ViewerContext } from '../ViewerContext';
 import { failedResults, partitionArray } from '../entityUtils';
 import { EntityNotAuthorizedError } from '../errors/EntityNotAuthorizedError';
@@ -74,7 +74,7 @@ export async function canViewerUpdateAsync<
   const result = await canViewerUpdateInternalAsync(
     entityClass,
     sourceEntity,
-    /* cascadingDeleteCause */ null,
+    { previousValue: sourceEntity, cascadingDeleteCause: null },
     queryContext,
   );
   return result.allowed;
@@ -121,7 +121,7 @@ export async function getCanViewerUpdateResultAsync<
   return await canViewerUpdateInternalAsync(
     entityClass,
     sourceEntity,
-    /* cascadingDeleteCause */ null,
+    { previousValue: sourceEntity, cascadingDeleteCause: null },
     queryContext,
   );
 }
@@ -149,7 +149,13 @@ async function canViewerUpdateInternalAsync<
     TSelectedFields
   >,
   sourceEntity: TEntity,
-  cascadingDeleteCause: EntityCascadingDeletionInfo | null,
+  evaluationContext: EntityPrivacyPolicyEvaluationContext<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TSelectedFields
+  >,
   queryContext: EntityQueryContext,
 ): Promise<EntityPrivacyEvaluationResult> {
   const companion = sourceEntity
@@ -160,7 +166,7 @@ async function canViewerUpdateInternalAsync<
     privacyPolicy.authorizeUpdateAsync(
       sourceEntity.getViewerContext(),
       queryContext,
-      { previousValue: null, cascadingDeleteCause },
+      evaluationContext,
       sourceEntity,
       companion.getMetricsAdapter(),
     ),
@@ -217,7 +223,7 @@ export async function canViewerDeleteAsync<
   const result = await canViewerDeleteInternalAsync(
     entityClass,
     sourceEntity,
-    /* cascadingDeleteCause */ null,
+    { previousValue: null, cascadingDeleteCause: null },
     queryContext,
   );
   return result.allowed;
@@ -264,7 +270,7 @@ export async function getCanViewerDeleteResultAsync<
   return await canViewerDeleteInternalAsync(
     entityClass,
     sourceEntity,
-    /* cascadingDeleteCause */ null,
+    { previousValue: null, cascadingDeleteCause: null },
     queryContext,
   );
 }
@@ -292,7 +298,13 @@ async function canViewerDeleteInternalAsync<
     TSelectedFields
   >,
   sourceEntity: TEntity,
-  cascadingDeleteCause: EntityCascadingDeletionInfo | null,
+  evaluationContext: EntityPrivacyPolicyEvaluationContext<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TSelectedFields
+  >,
   queryContext: EntityQueryContext,
 ): Promise<EntityPrivacyEvaluationResult> {
   const viewerContext = sourceEntity.getViewerContext();
@@ -306,7 +318,7 @@ async function canViewerDeleteInternalAsync<
     privacyPolicy.authorizeDeleteAsync(
       sourceEntity.getViewerContext(),
       queryContext,
-      { previousValue: null, cascadingDeleteCause },
+      evaluationContext,
       sourceEntity,
       viewerScopedCompanion.getMetricsAdapter(),
     ),
@@ -321,7 +333,7 @@ async function canViewerDeleteInternalAsync<
 
   const newCascadingDeleteCause = {
     entity: sourceEntity,
-    cascadingDeleteCause,
+    cascadingDeleteCause: evaluationContext.cascadingDeleteCause,
   };
 
   // Take entity X which is proposed to be deleted, look at inbound edges (entities that reference X).
@@ -366,7 +378,7 @@ async function canViewerDeleteInternalAsync<
       const edgeDeletionPermissionInferenceBehavior =
         association.edgeDeletionAuthorizationInferenceBehavior;
 
-      let entityResultsToCheckForInboundEdge: readonly Result<any>[];
+      let entityResultsToCheckForInboundEdge: readonly Result<ReadonlyEntity<any, any, any, any>>[];
 
       if (
         edgeDeletionPermissionInferenceBehavior ===
@@ -419,7 +431,7 @@ async function canViewerDeleteInternalAsync<
               canViewerDeleteInternalAsync(
                 inboundEdge,
                 entity,
-                newCascadingDeleteCause,
+                { previousValue: null, cascadingDeleteCause: newCascadingDeleteCause },
                 queryContext,
               ),
             ),
@@ -435,14 +447,43 @@ async function canViewerDeleteInternalAsync<
 
         case EntityEdgeDeletionBehavior.SET_NULL:
         case EntityEdgeDeletionBehavior.SET_NULL_INVALIDATE_CACHE_ONLY: {
+          // create synthetic entities with the reference field set to null to properly evaluate
+          // 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,
+                [fieldName]: null,
+              };
+
+              return {
+                previousValue: entity,
+                syntheticallyUpdatedValue: entityLoader.utils.constructEntity(syntheticFields),
+              };
+            },
+          );
+
           const canUpdateEvaluationResults = await Promise.all(
-            entitiesForInboundEdge.map((entity) =>
-              canViewerUpdateInternalAsync(
-                inboundEdge,
-                entity,
-                newCascadingDeleteCause,
-                queryContext,
-              ),
+            previousAndSyntheticEntitiesForInboundEdge.map(
+              ({ previousValue, syntheticallyUpdatedValue }) =>
+                canViewerUpdateInternalAsync(
+                  inboundEdge,
+                  syntheticallyUpdatedValue,
+                  {
+                    previousValue,
+                    cascadingDeleteCause: newCascadingDeleteCause,
+                  },
+                  queryContext,
+                ),
             ),
           );
 

package/src/utils/__testfixtures__/StubCacheAdapter.ts

@@ -17,8 +17,7 @@ export class NoCacheStubCacheAdapterProvider implements IEntityCacheAdapterProvi
 export class NoCacheStubCacheAdapter<
   TFields extends Record<string, any>,
   TIDField extends keyof TFields,
-> implements IEntityCacheAdapter<TFields, TIDField>
-{
+> implements IEntityCacheAdapter<TFields, TIDField> {
   public async loadManyAsync<
     TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
     TSerializedLoadValue,
@@ -74,8 +73,7 @@ export class InMemoryFullCacheStubCacheAdapterProvider implements IEntityCacheAd
 export class InMemoryFullCacheStubCacheAdapter<
   TFields extends Record<string, any>,
   TIDField extends keyof TFields,
-> implements IEntityCacheAdapter<TFields, TIDField>
-{
+> implements IEntityCacheAdapter<TFields, TIDField> {
   constructor(
     private readonly entityConfiguration: EntityConfiguration<TFields, TIDField>,
     private readonly cache: Map<string, Readonly<TFields> | typeof DOES_NOT_EXIST>,

package/src/utils/__testfixtures__/StubDatabaseAdapter.ts

@@ -1,5 +1,5 @@
 import invariant from 'invariant';
-import { uuidv7 } from 'uuidv7';
+import { v7 as uuidv7 } from 'uuid';
 
 import { EntityConfiguration } from '../../EntityConfiguration';
 import {