@expo/entity 0.41.0 → 0.43.0

package/src/utils/__tests__/EntityPrivacyUtils-test.ts

@@ -23,7 +23,7 @@ import {
   getCanViewerDeleteResultAsync,
   getCanViewerUpdateResultAsync,
 } from '../EntityPrivacyUtils';
-import { createUnitTestEntityCompanionProvider } from '../testing/createUnitTestEntityCompanionProvider';
+import { createUnitTestEntityCompanionProvider } from '../__testfixtures__/createUnitTestEntityCompanionProvider';
 
 function assertEntityPrivacyEvaluationResultFailure(
   evaluationResult: EntityPrivacyEvaluationResult,
@@ -296,54 +296,54 @@ type TestEntityThrowOtherErrorFields = {
 };
 
 class DenyUpdateEntityPrivacyPolicy<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<'id', any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TSelectedFields extends keyof TFields = keyof TFields,
-> extends EntityPrivacyPolicy<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
+> extends EntityPrivacyPolicy<TFields, TIDField, TViewerContext, TEntity, TSelectedFields> {
   protected override readonly readRules = [
-    new AlwaysAllowPrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>(),
+    new AlwaysAllowPrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>(),
   ];
   protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>(),
+    new AlwaysAllowPrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>(),
   ];
   protected override readonly updateRules = [
-    new AlwaysDenyPrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>(),
+    new AlwaysDenyPrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>(),
   ];
   protected override readonly deleteRules = [
-    new AlwaysAllowPrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>(),
+    new AlwaysAllowPrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>(),
   ];
 }
 
 class DenyDeleteEntityPrivacyPolicy<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<'id', any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TSelectedFields extends keyof TFields = keyof TFields,
-> extends EntityPrivacyPolicy<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
+> extends EntityPrivacyPolicy<TFields, TIDField, TViewerContext, TEntity, TSelectedFields> {
   protected override readonly readRules = [
-    new AlwaysAllowPrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>(),
+    new AlwaysAllowPrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>(),
   ];
   protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>(),
+    new AlwaysAllowPrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>(),
   ];
   protected override readonly updateRules = [
-    new AlwaysAllowPrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>(),
+    new AlwaysAllowPrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>(),
   ];
   protected override readonly deleteRules = [
-    new AlwaysDenyPrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>(),
+    new AlwaysDenyPrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>(),
   ];
 }
 
 class ThrowOtherErrorEntityPrivacyPolicy<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<'id', any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TSelectedFields extends keyof TFields = keyof TFields,
-> extends EntityPrivacyPolicy<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
+> extends EntityPrivacyPolicy<TFields, TIDField, TViewerContext, TEntity, TSelectedFields> {
   protected override readonly readRules = [
     {
       async evaluateAsync(
@@ -351,7 +351,7 @@ class ThrowOtherErrorEntityPrivacyPolicy<
         _queryContext: EntityQueryContext,
         evaluationContext: EntityPrivacyPolicyEvaluationContext<
           TFields,
-          TID,
+          TIDField,
           TViewerContext,
           TEntity,
           TSelectedFields
@@ -364,10 +364,10 @@ class ThrowOtherErrorEntityPrivacyPolicy<
         return RuleEvaluationResult.SKIP;
       },
     },
-    new AlwaysAllowPrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>(),
+    new AlwaysAllowPrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>(),
   ];
   protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>(),
+    new AlwaysAllowPrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>(),
   ];
   protected override readonly updateRules = [
     {
@@ -386,12 +386,12 @@ class ThrowOtherErrorEntityPrivacyPolicy<
 }
 
 class DenyReadEntityPrivacyPolicy<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<'id', any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TSelectedFields extends keyof TFields = keyof TFields,
-> extends EntityPrivacyPolicy<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
+> extends EntityPrivacyPolicy<TFields, TIDField, TViewerContext, TEntity, TSelectedFields> {
   protected override readonly readRules = [
     {
       async evaluateAsync(
@@ -399,7 +399,7 @@ class DenyReadEntityPrivacyPolicy<
         queryContext: EntityQueryContext,
         evaluationContext: EntityPrivacyPolicyEvaluationContext<
           TFields,
-          TID,
+          TIDField,
           TViewerContext,
           TEntity,
           TSelectedFields
@@ -416,37 +416,38 @@ class DenyReadEntityPrivacyPolicy<
     },
   ];
   protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>(),
+    new AlwaysAllowPrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>(),
   ];
   protected override readonly updateRules = [
-    new AlwaysAllowPrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>(),
+    new AlwaysAllowPrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>(),
   ];
   protected override readonly deleteRules = [
-    new AlwaysAllowPrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>(),
+    new AlwaysAllowPrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>(),
   ];
 }
 
-class LeafDenyUpdateEntity extends Entity<TestLeafDenyUpdateFields, string, ViewerContext> {
+class LeafDenyUpdateEntity extends Entity<TestLeafDenyUpdateFields, 'id', ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestLeafDenyUpdateFields,
-    string,
+    'id',
     ViewerContext,
     LeafDenyUpdateEntity,
     DenyUpdateEntityPrivacyPolicy<
       TestLeafDenyUpdateFields,
-      string,
+      'id',
       ViewerContext,
       LeafDenyUpdateEntity
     >
   > {
     return {
       entityClass: LeafDenyUpdateEntity,
-      entityConfiguration: new EntityConfiguration<TestLeafDenyUpdateFields>({
+      entityConfiguration: new EntityConfiguration<TestLeafDenyUpdateFields, 'id'>({
         idField: 'id',
         tableName: 'leaf_1',
         schema: {
           id: new UUIDField({
             columnName: 'custom_id',
+            cache: false,
           }),
           // to ensure edge traversal doesn't process other edges
           unused_other_association: new UUIDField({
@@ -481,27 +482,28 @@ class LeafDenyUpdateEntity extends Entity<TestLeafDenyUpdateFields, string, View
   }
 }
 
-class LeafDenyDeleteEntity extends Entity<TestLeafDenyDeleteFields, string, ViewerContext> {
+class LeafDenyDeleteEntity extends Entity<TestLeafDenyDeleteFields, 'id', ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestLeafDenyDeleteFields,
-    string,
+    'id',
     ViewerContext,
     LeafDenyDeleteEntity,
     DenyDeleteEntityPrivacyPolicy<
       TestLeafDenyDeleteFields,
-      string,
+      'id',
       ViewerContext,
       LeafDenyDeleteEntity
     >
   > {
     return {
       entityClass: LeafDenyDeleteEntity,
-      entityConfiguration: new EntityConfiguration<TestLeafDenyDeleteFields>({
+      entityConfiguration: new EntityConfiguration<TestLeafDenyDeleteFields, 'id'>({
         idField: 'id',
         tableName: 'leaf_2',
         schema: {
           id: new UUIDField({
             columnName: 'custom_id',
+            cache: false,
           }),
           // deletion behavior should fail since this entity can't be deleted
           simple_test_deny_update_cascade_delete_id: new UUIDField({
@@ -528,23 +530,24 @@ class LeafDenyDeleteEntity extends Entity<TestLeafDenyDeleteFields, string, View
   }
 }
 
-class LeafDenyReadEntity extends Entity<TestLeafDenyReadFields, string, ViewerContext> {
+class LeafDenyReadEntity extends Entity<TestLeafDenyReadFields, 'id', ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestLeafDenyReadFields,
-    string,
+    'id',
     ViewerContext,
     LeafDenyReadEntity,
-    DenyReadEntityPrivacyPolicy<TestLeafDenyReadFields, string, ViewerContext, LeafDenyReadEntity>
+    DenyReadEntityPrivacyPolicy<TestLeafDenyReadFields, 'id', ViewerContext, LeafDenyReadEntity>
   > {
     return {
       entityClass: LeafDenyReadEntity,
-      entityConfiguration: new EntityConfiguration<TestLeafDenyReadFields>({
+      entityConfiguration: new EntityConfiguration<TestLeafDenyReadFields, 'id'>({
         idField: 'id',
         tableName: 'leaf_4',
         inboundEdges: [],
         schema: {
           id: new UUIDField({
             columnName: 'custom_id',
+            cache: false,
           }),
           simple_test_id: new UUIDField({
             columnName: 'simple_test_id',
@@ -563,22 +566,17 @@ class LeafDenyReadEntity extends Entity<TestLeafDenyReadFields, string, ViewerCo
   }
 }
 
-class SimpleTestDenyUpdateEntity extends Entity<TestEntityFields, string, ViewerContext> {
+class SimpleTestDenyUpdateEntity extends Entity<TestEntityFields, 'id', ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestEntityFields,
-    string,
+    'id',
     ViewerContext,
     SimpleTestDenyUpdateEntity,
-    DenyUpdateEntityPrivacyPolicy<
-      TestEntityFields,
-      string,
-      ViewerContext,
-      SimpleTestDenyUpdateEntity
-    >
+    DenyUpdateEntityPrivacyPolicy<TestEntityFields, 'id', ViewerContext, SimpleTestDenyUpdateEntity>
   > {
     return {
       entityClass: SimpleTestDenyUpdateEntity,
-      entityConfiguration: new EntityConfiguration<TestEntityFields>({
+      entityConfiguration: new EntityConfiguration<TestEntityFields, 'id'>({
         idField: 'id',
         tableName: 'blah',
         inboundEdges: [
@@ -590,6 +588,7 @@ class SimpleTestDenyUpdateEntity extends Entity<TestEntityFields, string, Viewer
         schema: {
           id: new UUIDField({
             columnName: 'custom_id',
+            cache: false,
           }),
         },
         databaseAdapterFlavor: 'postgres',
@@ -600,22 +599,17 @@ class SimpleTestDenyUpdateEntity extends Entity<TestEntityFields, string, Viewer
   }
 }
 
-class SimpleTestDenyDeleteEntity extends Entity<TestEntityFields, string, ViewerContext> {
+class SimpleTestDenyDeleteEntity extends Entity<TestEntityFields, 'id', ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestEntityFields,
-    string,
+    'id',
     ViewerContext,
     SimpleTestDenyDeleteEntity,
-    DenyDeleteEntityPrivacyPolicy<
-      TestEntityFields,
-      string,
-      ViewerContext,
-      SimpleTestDenyDeleteEntity
-    >
+    DenyDeleteEntityPrivacyPolicy<TestEntityFields, 'id', ViewerContext, SimpleTestDenyDeleteEntity>
   > {
     return {
       entityClass: SimpleTestDenyDeleteEntity,
-      entityConfiguration: new EntityConfiguration<TestEntityFields>({
+      entityConfiguration: new EntityConfiguration<TestEntityFields, 'id'>({
         idField: 'id',
         tableName: 'blah_2',
         inboundEdges: [
@@ -627,6 +621,7 @@ class SimpleTestDenyDeleteEntity extends Entity<TestEntityFields, string, Viewer
         schema: {
           id: new UUIDField({
             columnName: 'custom_id',
+            cache: false,
           }),
         },
         databaseAdapterFlavor: 'postgres',
@@ -639,30 +634,31 @@ class SimpleTestDenyDeleteEntity extends Entity<TestEntityFields, string, Viewer
 
 class SimpleTestThrowOtherErrorEntity extends Entity<
   TestEntityThrowOtherErrorFields,
-  string,
+  'id',
   ViewerContext
 > {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestEntityThrowOtherErrorFields,
-    string,
+    'id',
     ViewerContext,
     SimpleTestThrowOtherErrorEntity,
     ThrowOtherErrorEntityPrivacyPolicy<
       TestEntityThrowOtherErrorFields,
-      string,
+      'id',
       ViewerContext,
       SimpleTestThrowOtherErrorEntity
     >
   > {
     return {
       entityClass: SimpleTestThrowOtherErrorEntity,
-      entityConfiguration: new EntityConfiguration<TestEntityThrowOtherErrorFields>({
+      entityConfiguration: new EntityConfiguration<TestEntityThrowOtherErrorFields, 'id'>({
         idField: 'id',
         tableName: 'blah_3',
         inboundEdges: [],
         schema: {
           id: new UUIDField({
             columnName: 'custom_id',
+            cache: false,
           }),
           simple_test_id: new UUIDField({
             columnName: 'simple_test_id',

package/src/utils/__tests__/canViewerDeleteAsync-edgeDeletionPermissionInferenceBehavior-test.ts

@@ -12,7 +12,7 @@ import ViewerContext from '../../ViewerContext';
 import AlwaysAllowPrivacyPolicyRule from '../../rules/AlwaysAllowPrivacyPolicyRule';
 import AlwaysDenyPrivacyPolicyRule from '../../rules/AlwaysDenyPrivacyPolicyRule';
 import { canViewerDeleteAsync } from '../EntityPrivacyUtils';
-import { createUnitTestEntityCompanionProvider } from '../testing/createUnitTestEntityCompanionProvider';
+import { createUnitTestEntityCompanionProvider } from '../__testfixtures__/createUnitTestEntityCompanionProvider';
 
 describe(canViewerDeleteAsync, () => {
   describe('edgeDeletionPermissionInferenceBehavior', () => {
@@ -97,43 +97,44 @@ type TestLeafEntityFields = {
 };
 
 class AlwaysAllowEntityPrivacyPolicy<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TSelectedFields extends keyof TFields = keyof TFields,
-> extends EntityPrivacyPolicy<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
+> extends EntityPrivacyPolicy<TFields, TIDField, TViewerContext, TEntity, TSelectedFields> {
   protected override readonly readRules = [
-    new AlwaysAllowPrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>(),
+    new AlwaysAllowPrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>(),
   ];
   protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>(),
+    new AlwaysAllowPrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>(),
   ];
   protected override readonly updateRules = [
-    new AlwaysDenyPrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>(),
+    new AlwaysDenyPrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>(),
   ];
   protected override readonly deleteRules = [
-    new AlwaysAllowPrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>(),
+    new AlwaysAllowPrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>(),
   ];
 }
 
-class TestEntity extends Entity<TestEntityFields, string, ViewerContext> {
+class TestEntity extends Entity<TestEntityFields, 'id', ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestEntityFields,
-    string,
+    'id',
     ViewerContext,
     TestEntity,
-    AlwaysAllowEntityPrivacyPolicy<TestEntityFields, string, ViewerContext, TestEntity>
+    AlwaysAllowEntityPrivacyPolicy<TestEntityFields, 'id', ViewerContext, TestEntity>
   > {
     return {
       entityClass: TestEntity,
-      entityConfiguration: new EntityConfiguration<TestEntityFields>({
+      entityConfiguration: new EntityConfiguration<TestEntityFields, 'id'>({
         idField: 'id',
         tableName: 'blah',
         inboundEdges: [TestLeafEntity, TestLeafLookupByFieldEntity, TestLeafNoInferenceEntity],
         schema: {
           id: new UUIDField({
             columnName: 'custom_id',
+            cache: false,
           }),
         },
         databaseAdapterFlavor: 'postgres',
@@ -144,22 +145,23 @@ class TestEntity extends Entity<TestEntityFields, string, ViewerContext> {
   }
 }
 
-class TestLeafEntity extends Entity<TestLeafEntityFields, string, ViewerContext> {
+class TestLeafEntity extends Entity<TestLeafEntityFields, 'id', ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestLeafEntityFields,
-    string,
+    'id',
     ViewerContext,
     TestLeafEntity,
-    AlwaysAllowEntityPrivacyPolicy<TestLeafEntityFields, string, ViewerContext, TestLeafEntity>
+    AlwaysAllowEntityPrivacyPolicy<TestLeafEntityFields, 'id', ViewerContext, TestLeafEntity>
   > {
     return {
       entityClass: TestLeafEntity,
-      entityConfiguration: new EntityConfiguration<TestLeafEntityFields>({
+      entityConfiguration: new EntityConfiguration<TestLeafEntityFields, 'id'>({
         idField: 'id',
         tableName: 'blah_2',
         schema: {
           id: new UUIDField({
             columnName: 'custom_id',
+            cache: false,
           }),
           test_entity_id: new UUIDField({
             columnName: 'test_entity_id',
@@ -179,22 +181,23 @@ class TestLeafEntity extends Entity<TestLeafEntityFields, string, ViewerContext>
   }
 }
 
-class TestLeafLookupByFieldEntity extends Entity<TestLeafEntityFields, string, ViewerContext> {
+class TestLeafLookupByFieldEntity extends Entity<TestLeafEntityFields, 'id', ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestLeafEntityFields,
-    string,
+    'id',
     ViewerContext,
     TestLeafEntity,
-    AlwaysAllowEntityPrivacyPolicy<TestLeafEntityFields, string, ViewerContext, TestLeafEntity>
+    AlwaysAllowEntityPrivacyPolicy<TestLeafEntityFields, 'id', ViewerContext, TestLeafEntity>
   > {
     return {
       entityClass: TestLeafEntity,
-      entityConfiguration: new EntityConfiguration<TestLeafEntityFields>({
+      entityConfiguration: new EntityConfiguration<TestLeafEntityFields, 'id'>({
         idField: 'id',
         tableName: 'blah_4',
         schema: {
           id: new UUIDField({
             columnName: 'custom_id',
+            cache: false,
           }),
           test_entity_id: new UUIDField({
             columnName: 'test_entity_id',
@@ -215,27 +218,28 @@ class TestLeafLookupByFieldEntity extends Entity<TestLeafEntityFields, string, V
   }
 }
 
-class TestLeafNoInferenceEntity extends Entity<TestLeafEntityFields, string, ViewerContext> {
+class TestLeafNoInferenceEntity extends Entity<TestLeafEntityFields, 'id', ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestLeafEntityFields,
-    string,
+    'id',
     ViewerContext,
     TestLeafNoInferenceEntity,
     AlwaysAllowEntityPrivacyPolicy<
       TestLeafEntityFields,
-      string,
+      'id',
       ViewerContext,
       TestLeafNoInferenceEntity
     >
   > {
     return {
       entityClass: TestLeafNoInferenceEntity,
-      entityConfiguration: new EntityConfiguration<TestLeafEntityFields>({
+      entityConfiguration: new EntityConfiguration<TestLeafEntityFields, 'id'>({
         idField: 'id',
         tableName: 'blah_3',
         schema: {
           id: new UUIDField({
             columnName: 'custom_id',
+            cache: false,
           }),
           test_entity_id: new UUIDField({
             columnName: 'test_entity_id',

package/src/utils/__tests__/mergeEntityMutationTriggerConfigurations-test.ts

@@ -1,4 +1,4 @@
-import { TestMutationTrigger } from '../../testfixtures/TestEntityWithMutationTriggers';
+import { TestMutationTrigger } from '../__testfixtures__/TestEntityWithMutationTriggers';
 import { mergeEntityMutationTriggerConfigurations } from '../mergeEntityMutationTriggerConfigurations';
 
 describe(mergeEntityMutationTriggerConfigurations, () => {

package/src/utils/collections/SerializableKeyMap.ts

@@ -0,0 +1,84 @@
+/**
+ * A serializable object. The serialized value is used to determine equality.
+ */
+export interface ISerializable<TSerialized> {
+  serialize(): TSerialized;
+}
+
+/**
+ * A map with keys that are serializable. Serialized keys are considered equal if their serialized values are equal.
+ * Otherwise, the map behaves like a regular Map.
+ */
+export abstract class SerializableKeyMap<TSerialized, K extends ISerializable<TSerialized>, V>
+  implements ReadonlyMap<K, V>, Map<K, V>
+{
+  protected readonly underlyingMap: Map<TSerialized, V>;
+
+  constructor(iterable?: Iterable<readonly [K, V]> | null) {
+    this.underlyingMap = new Map(
+      Array.from(iterable ?? []).map(([key, value]) => [key.serialize(), value]),
+    );
+  }
+
+  protected abstract deserializeKey(serializedKey: TSerialized): K;
+
+  forEach(
+    callbackfn: (value: V, key: K, map: SerializableKeyMap<TSerialized, K, V>) => void,
+    thisArg?: any,
+  ): void {
+    this.underlyingMap.forEach((value, key) => {
+      callbackfn.call(thisArg, value, this.deserializeKey(key), this);
+    });
+  }
+
+  get(key: K): V | undefined {
+    return this.underlyingMap.get(key.serialize());
+  }
+
+  has(key: K): boolean {
+    return this.underlyingMap.has(key.serialize());
+  }
+
+  clear(): void {
+    this.underlyingMap.clear();
+  }
+
+  delete(key: K): boolean {
+    return this.underlyingMap.delete(key.serialize());
+  }
+
+  set(key: K, value: V): this {
+    this.underlyingMap.set(key.serialize(), value);
+    return this;
+  }
+
+  get size(): number {
+    return this.underlyingMap.size;
+  }
+
+  *entries(): MapIterator<[K, V]> {
+    for (const [key, value] of this.underlyingMap.entries()) {
+      yield [this.deserializeKey(key), value];
+    }
+  }
+
+  *keys(): MapIterator<K> {
+    for (const key of this.underlyingMap.keys()) {
+      yield this.deserializeKey(key);
+    }
+  }
+
+  *values(): MapIterator<V> {
+    for (const value of this.underlyingMap.values()) {
+      yield value;
+    }
+  }
+
+  [Symbol.iterator](): MapIterator<[K, V]> {
+    return this.entries();
+  }
+
+  get [Symbol.toStringTag](): string {
+    return 'SerializableKeyMap';
+  }
+}