@expo/entity 0.41.0 → 0.43.0

package/src/utils/{testing → __testfixtures__}/StubDatabaseAdapter.ts

@@ -17,18 +17,22 @@ import {
 import { computeIfAbsent, mapMap } from '../collections/maps';
 
 export default class StubDatabaseAdapter<
-  T extends Record<string, any>,
-> extends EntityDatabaseAdapter<T> {
+  TFields extends Record<string, any>,
+  TIDField extends keyof TFields,
+> extends EntityDatabaseAdapter<TFields, TIDField> {
   constructor(
-    private readonly entityConfiguration2: EntityConfiguration<T>,
+    private readonly entityConfiguration2: EntityConfiguration<TFields, TIDField>,
     private readonly dataStore: Map<string, Readonly<{ [key: string]: any }>[]>,
   ) {
     super(entityConfiguration2);
   }
 
-  public static convertFieldObjectsToDataStore<T extends Record<string, any>>(
-    entityConfiguration: EntityConfiguration<T>,
-    dataStore: Map<string, Readonly<T>[]>,
+  public static convertFieldObjectsToDataStore<
+    TFields extends Record<string, any>,
+    TIDField extends keyof TFields,
+  >(
+    entityConfiguration: EntityConfiguration<TFields, TIDField>,
+    dataStore: Map<string, Readonly<TFields>[]>,
   ): Map<string, Readonly<{ [key: string]: any }>[]> {
     return mapMap(dataStore, (objectsForTable) =>
       objectsForTable.map((objectForTable) =>
@@ -48,20 +52,23 @@ export default class StubDatabaseAdapter<
   protected async fetchManyWhereInternalAsync(
     _queryInterface: any,
     tableName: string,
-    tableField: string,
-    tableValues: readonly any[],
+    tableColumns: readonly string[],
+    tableTuples: (readonly any[])[],
   ): Promise<object[]> {
     const objectCollection = this.getObjectCollectionForTable(tableName);
-    return tableValues.reduce(
-      (acc, fieldValue) => {
+    const results = tableTuples.reduce(
+      (acc, tableTuple) => {
         return acc.concat(
           objectCollection.filter((obj) => {
-            return obj[tableField] === fieldValue;
+            return tableColumns.every((tableColumn, index) => {
+              return obj[tableColumn] === tableTuple[index];
+            });
           }),
         );
       },
-      [] as { [key: string]: any },
+      [] as { [key: string]: any }[],
     );
+    return [...results];
   }
 
   private static compareByOrderBys(

package/src/utils/{testing → __testfixtures__}/StubDatabaseAdapterProvider.ts

@@ -1,14 +1,14 @@
-import StubDatabaseAdapter from './StubDatabaseAdapter';
 import EntityConfiguration from '../../EntityConfiguration';
 import EntityDatabaseAdapter from '../../EntityDatabaseAdapter';
 import IEntityDatabaseAdapterProvider from '../../IEntityDatabaseAdapterProvider';
+import StubDatabaseAdapter from '../__testfixtures__/StubDatabaseAdapter';
 
 export default class StubDatabaseAdapterProvider implements IEntityDatabaseAdapterProvider {
   private readonly objectCollection = new Map();
 
-  getDatabaseAdapter<TFields extends Record<string, any>>(
-    entityConfiguration: EntityConfiguration<TFields>,
-  ): EntityDatabaseAdapter<TFields> {
+  getDatabaseAdapter<TFields extends Record<string, any>, TIDField extends keyof TFields>(
+    entityConfiguration: EntityConfiguration<TFields, TIDField>,
+  ): EntityDatabaseAdapter<TFields, TIDField> {
     return new StubDatabaseAdapter(entityConfiguration, this.objectCollection);
   }
 }

package/src/utils/__testfixtures__/TSMockitoExtensions.ts

@@ -0,0 +1,69 @@
+import isEqualWith from 'lodash/isEqualWith';
+import { Matcher } from 'ts-mockito/lib/matcher/type/Matcher';
+
+import {
+  CompositeFieldHolder,
+  CompositeFieldValueHolder,
+} from '../../internal/CompositeFieldHolder';
+import { SingleFieldHolder, SingleFieldValueHolder } from '../../internal/SingleFieldHolder';
+import { SerializableKeyMap } from '../collections/SerializableKeyMap';
+
+export function isEqualWithEntityAware(expected: any, actual: any): boolean {
+  return isEqualWith(expected, actual, (expected: any, actual: any): boolean | undefined => {
+    if (expected instanceof Matcher) {
+      return expected.match(actual);
+    }
+
+    if (expected instanceof SingleFieldHolder && actual instanceof SingleFieldHolder) {
+      return expected.fieldName === actual.fieldName;
+    }
+
+    if (expected instanceof SingleFieldValueHolder && actual instanceof SingleFieldValueHolder) {
+      return expected.fieldValue === actual.fieldValue;
+    }
+
+    if (expected instanceof CompositeFieldHolder && actual instanceof CompositeFieldHolder) {
+      return expected.serialize() === actual.serialize();
+    }
+
+    if (
+      expected instanceof CompositeFieldValueHolder &&
+      actual instanceof CompositeFieldValueHolder
+    ) {
+      return expected.serialize() === actual.serialize();
+    }
+
+    if (expected instanceof SerializableKeyMap && actual instanceof SerializableKeyMap) {
+      for (const [key, value] of expected.entries()) {
+        if (!actual.has(key) || !isEqualWith(value, actual.get(key))) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    return undefined;
+  });
+}
+
+export class DeepEqualEntityAwareMatcher<T> extends Matcher {
+  constructor(private readonly expectedValue: T) {
+    super();
+  }
+
+  public override match(value: any): boolean {
+    return isEqualWithEntityAware(this.expectedValue, value);
+  }
+
+  public override toString(): string {
+    if (this.expectedValue instanceof Array) {
+      return `deepEqualEntityAware([${this.expectedValue}])`;
+    } else {
+      return `deepEqualEntityAware(${this.expectedValue})`;
+    }
+  }
+}
+
+export function deepEqualEntityAware<T>(expectedValue: T): T {
+  return new DeepEqualEntityAwareMatcher(expectedValue) as any;
+}

package/src/{testfixtures → utils/__testfixtures__}/TestEntity.ts

@@ -1,12 +1,12 @@
 import { result, Result } from '@expo/results';
 
-import Entity from '../Entity';
-import { EntityCompanionDefinition } from '../EntityCompanionProvider';
-import EntityConfiguration from '../EntityConfiguration';
-import { UUIDField, StringField, DateField, IntField } from '../EntityFields';
-import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
-import ViewerContext from '../ViewerContext';
-import AlwaysAllowPrivacyPolicyRule from '../rules/AlwaysAllowPrivacyPolicyRule';
+import Entity from '../../Entity';
+import { EntityCompanionDefinition } from '../../EntityCompanionProvider';
+import EntityConfiguration from '../../EntityConfiguration';
+import { StringField, DateField, IntField, UUIDField } from '../../EntityFields';
+import EntityPrivacyPolicy from '../../EntityPrivacyPolicy';
+import ViewerContext from '../../ViewerContext';
+import AlwaysAllowPrivacyPolicyRule from '../../rules/AlwaysAllowPrivacyPolicyRule';
 
 export type TestFields = {
   customIdField: string;
@@ -17,12 +17,13 @@ export type TestFields = {
   nullableField: string | null;
 };
 
-export const testEntityConfiguration = new EntityConfiguration<TestFields>({
+export const testEntityConfiguration = new EntityConfiguration<TestFields, 'customIdField'>({
   idField: 'customIdField',
   tableName: 'test_entity_should_not_write_to_db',
   schema: {
     customIdField: new UUIDField({
       columnName: 'custom_id',
+      cache: true,
     }),
     testIndexedField: new StringField({
       columnName: 'test_index',
@@ -43,32 +44,37 @@ export const testEntityConfiguration = new EntityConfiguration<TestFields>({
   },
   databaseAdapterFlavor: 'postgres',
   cacheAdapterFlavor: 'redis',
+  compositeFieldDefinitions: [
+    { compositeField: ['stringField', 'intField'], cache: false },
+    { compositeField: ['stringField', 'testIndexedField'], cache: true },
+    { compositeField: ['nullableField', 'testIndexedField'], cache: true },
+  ],
 });
 
 export class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<
   TestFields,
-  string,
+  'customIdField',
   ViewerContext,
   TestEntity
 > {
   protected override readonly readRules = [
-    new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<TestFields, 'customIdField', ViewerContext, TestEntity>(),
   ];
   protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<TestFields, 'customIdField', ViewerContext, TestEntity>(),
   ];
   protected override readonly updateRules = [
-    new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<TestFields, 'customIdField', ViewerContext, TestEntity>(),
   ];
   protected override readonly deleteRules = [
-    new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<TestFields, 'customIdField', ViewerContext, TestEntity>(),
   ];
 }
 
-export default class TestEntity extends Entity<TestFields, string, ViewerContext> {
+export default class TestEntity extends Entity<TestFields, 'customIdField', ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
-    string,
+    'customIdField',
     ViewerContext,
     TestEntity,
     TestEntityPrivacyPolicy

package/src/{testfixtures → utils/__testfixtures__}/TestEntity2.ts

@@ -1,22 +1,23 @@
-import Entity from '../Entity';
-import { EntityCompanionDefinition } from '../EntityCompanionProvider';
-import EntityConfiguration from '../EntityConfiguration';
-import { UUIDField } from '../EntityFields';
-import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
-import ViewerContext from '../ViewerContext';
-import AlwaysAllowPrivacyPolicyRule from '../rules/AlwaysAllowPrivacyPolicyRule';
+import Entity from '../../Entity';
+import { EntityCompanionDefinition } from '../../EntityCompanionProvider';
+import EntityConfiguration from '../../EntityConfiguration';
+import { UUIDField } from '../../EntityFields';
+import EntityPrivacyPolicy from '../../EntityPrivacyPolicy';
+import ViewerContext from '../../ViewerContext';
+import AlwaysAllowPrivacyPolicyRule from '../../rules/AlwaysAllowPrivacyPolicyRule';
 
 export type Test2Fields = {
   id: string;
   foreignKey: string;
 };
 
-export const testEntity2Configuration = new EntityConfiguration<Test2Fields>({
+export const testEntity2Configuration = new EntityConfiguration<Test2Fields, 'id'>({
   idField: 'id',
   tableName: 'test_entity_should_not_write_to_db_2',
   schema: {
     id: new UUIDField({
       columnName: 'id',
+      cache: false,
     }),
     foreignKey: new UUIDField({
       columnName: 'foreign_key',
@@ -28,28 +29,28 @@ export const testEntity2Configuration = new EntityConfiguration<Test2Fields>({
 
 export class TestEntity2PrivacyPolicy extends EntityPrivacyPolicy<
   Test2Fields,
-  string,
+  'id',
   ViewerContext,
   TestEntity2
 > {
   protected override readonly readRules = [
-    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, ViewerContext, TestEntity2>(),
+    new AlwaysAllowPrivacyPolicyRule<Test2Fields, 'id', ViewerContext, TestEntity2>(),
   ];
   protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, ViewerContext, TestEntity2>(),
+    new AlwaysAllowPrivacyPolicyRule<Test2Fields, 'id', ViewerContext, TestEntity2>(),
   ];
   protected override readonly updateRules = [
-    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, ViewerContext, TestEntity2>(),
+    new AlwaysAllowPrivacyPolicyRule<Test2Fields, 'id', ViewerContext, TestEntity2>(),
   ];
   protected override readonly deleteRules = [
-    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, ViewerContext, TestEntity2>(),
+    new AlwaysAllowPrivacyPolicyRule<Test2Fields, 'id', ViewerContext, TestEntity2>(),
   ];
 }
 
-export default class TestEntity2 extends Entity<Test2Fields, string, ViewerContext> {
+export default class TestEntity2 extends Entity<Test2Fields, 'id', ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     Test2Fields,
-    string,
+    'id',
     ViewerContext,
     TestEntity2,
     TestEntity2PrivacyPolicy

package/src/{testfixtures → utils/__testfixtures__}/TestEntityWithMutationTriggers.ts

@@ -1,28 +1,29 @@
-import Entity from '../Entity';
-import { EntityCompanionDefinition } from '../EntityCompanionProvider';
-import EntityConfiguration from '../EntityConfiguration';
-import { StringField, UUIDField } from '../EntityFields';
-import { EntityTriggerMutationInfo } from '../EntityMutationInfo';
+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';
+} 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>({
+export const testEntityMTConfiguration = new EntityConfiguration<TestMTFields, 'id'>({
   idField: 'id',
   tableName: 'test_entity_should_not_write_to_db_3',
   schema: {
     id: new UUIDField({
       columnName: 'id',
+      cache: false,
     }),
     stringField: new StringField({
       columnName: 'string_field',
@@ -34,14 +35,14 @@ export const testEntityMTConfiguration = new EntityConfiguration<TestMTFields>({
 
 export class TestEntityMTPrivacyPolicy extends EntityPrivacyPolicy<
   TestMTFields,
-  string,
+  'id',
   ViewerContext,
   TestEntityWithMutationTriggers
 > {
   protected override readonly readRules = [
     new AlwaysAllowPrivacyPolicyRule<
       TestMTFields,
-      string,
+      'id',
       ViewerContext,
       TestEntityWithMutationTriggers
     >(),
@@ -49,7 +50,7 @@ export class TestEntityMTPrivacyPolicy extends EntityPrivacyPolicy<
   protected override readonly createRules = [
     new AlwaysAllowPrivacyPolicyRule<
       TestMTFields,
-      string,
+      'id',
       ViewerContext,
       TestEntityWithMutationTriggers
     >(),
@@ -57,7 +58,7 @@ export class TestEntityMTPrivacyPolicy extends EntityPrivacyPolicy<
   protected override readonly updateRules = [
     new AlwaysAllowPrivacyPolicyRule<
       TestMTFields,
-      string,
+      'id',
       ViewerContext,
       TestEntityWithMutationTriggers
     >(),
@@ -65,7 +66,7 @@ export class TestEntityMTPrivacyPolicy extends EntityPrivacyPolicy<
   protected override readonly deleteRules = [
     new AlwaysAllowPrivacyPolicyRule<
       TestMTFields,
-      string,
+      'id',
       ViewerContext,
       TestEntityWithMutationTriggers
     >(),
@@ -74,7 +75,7 @@ export class TestEntityMTPrivacyPolicy extends EntityPrivacyPolicy<
 
 export class TestMutationTrigger extends EntityMutationTrigger<
   TestMTFields,
-  string,
+  'id',
   ViewerContext,
   TestEntityWithMutationTriggers,
   keyof TestMTFields
@@ -92,7 +93,7 @@ export class TestMutationTrigger extends EntityMutationTrigger<
     _entity: TestEntityWithMutationTriggers,
     _mutationInfo: EntityTriggerMutationInfo<
       TestMTFields,
-      string,
+      'id',
       ViewerContext,
       TestEntityWithMutationTriggers,
       keyof TestMTFields
@@ -102,7 +103,7 @@ export class TestMutationTrigger extends EntityMutationTrigger<
 
 export class NonTransactionalTestMutationTrigger extends EntityNonTransactionalMutationTrigger<
   TestMTFields,
-  string,
+  'id',
   ViewerContext,
   TestEntityWithMutationTriggers,
   keyof TestMTFields
@@ -119,7 +120,7 @@ export class NonTransactionalTestMutationTrigger extends EntityNonTransactionalM
     _entity: TestEntityWithMutationTriggers,
     _mutationInfo: EntityTriggerMutationInfo<
       TestMTFields,
-      string,
+      'id',
       ViewerContext,
       TestEntityWithMutationTriggers,
       keyof TestMTFields
@@ -132,12 +133,12 @@ export class NonTransactionalTestMutationTrigger extends EntityNonTransactionalM
  */
 export default class TestEntityWithMutationTriggers extends Entity<
   TestMTFields,
-  string,
+  'id',
   ViewerContext
 > {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestMTFields,
-    string,
+    'id',
     ViewerContext,
     TestEntityWithMutationTriggers,
     TestEntityMTPrivacyPolicy

package/src/{testfixtures → utils/__testfixtures__}/TestViewerContext.ts

@@ -1,3 +1,3 @@
-import ViewerContext from '../ViewerContext';
+import ViewerContext from '../../ViewerContext';
 
 export default class TestViewerContext extends ViewerContext {}

package/src/utils/{testing → __testfixtures__}/describeFieldTestCase.ts

@@ -1,7 +1,7 @@
 import { EntityFieldDefinition } from '../../EntityFieldDefinition';
 
 export default function describeFieldTestCase<T>(
-  fieldDefinition: EntityFieldDefinition<T>,
+  fieldDefinition: EntityFieldDefinition<T, any>,
   validValues: T[],
   invalidValues: any[],
 ): void {