@expo/entity 0.41.0 → 0.43.0

package/src/__tests__/Entity-test.ts

@@ -8,8 +8,8 @@ import EnforcingEntityDeleter from '../EnforcingEntityDeleter';
 import EnforcingEntityUpdater from '../EnforcingEntityUpdater';
 import Entity from '../Entity';
 import ViewerContext from '../ViewerContext';
-import SimpleTestEntity from '../testfixtures/SimpleTestEntity';
-import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
+import SimpleTestEntity from '../utils/__testfixtures__/SimpleTestEntity';
+import { createUnitTestEntityCompanionProvider } from '../utils/__testfixtures__/createUnitTestEntityCompanionProvider';
 
 describe(Entity, () => {
   describe('creator', () => {

package/src/__tests__/EntityAssociationLoader-test.ts

@@ -2,8 +2,8 @@ import AuthorizationResultBasedEntityAssociationLoader from '../AuthorizationRes
 import EnforcingEntityAssociationLoader from '../EnforcingEntityAssociationLoader';
 import EntityAssociationLoader from '../EntityAssociationLoader';
 import ViewerContext from '../ViewerContext';
-import SimpleTestEntity from '../testfixtures/SimpleTestEntity';
-import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
+import SimpleTestEntity from '../utils/__testfixtures__/SimpleTestEntity';
+import { createUnitTestEntityCompanionProvider } from '../utils/__testfixtures__/createUnitTestEntityCompanionProvider';
 
 describe(EntityAssociationLoader, () => {
   describe('enforcing', () => {

package/src/__tests__/EntityCommonUseCases-test.ts

@@ -13,7 +13,7 @@ import EntityNotAuthorizedError from '../errors/EntityNotAuthorizedError';
 import AlwaysAllowPrivacyPolicyRule from '../rules/AlwaysAllowPrivacyPolicyRule';
 import AlwaysDenyPrivacyPolicyRule from '../rules/AlwaysDenyPrivacyPolicyRule';
 import PrivacyPolicyRule, { RuleEvaluationResult } from '../rules/PrivacyPolicyRule';
-import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
+import { createUnitTestEntityCompanionProvider } from '../utils/__testfixtures__/createUnitTestEntityCompanionProvider';
 
 class TestUserViewerContext extends ViewerContext {
   constructor(
@@ -33,17 +33,17 @@ type BlahFields = {
   ownerID: string;
 };
 
-class BlahEntity extends Entity<BlahFields, string, TestUserViewerContext> {
+class BlahEntity extends Entity<BlahFields, 'id', TestUserViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     BlahFields,
-    string,
+    'id',
     TestUserViewerContext,
     BlahEntity,
     BlahEntityPrivacyPolicy
   > {
     return {
       entityClass: BlahEntity,
-      entityConfiguration: new EntityConfiguration<BlahFields>({
+      entityConfiguration: new EntityConfiguration<BlahFields, 'id'>({
         idField: 'id',
         tableName: 'blah_table',
         schema: {
@@ -65,7 +65,7 @@ class BlahEntity extends Entity<BlahFields, string, TestUserViewerContext> {
 
 class DenyIfNotOwnerPrivacyPolicyRule extends PrivacyPolicyRule<
   BlahFields,
-  string,
+  'id',
   TestUserViewerContext,
   BlahEntity
 > {
@@ -74,7 +74,7 @@ class DenyIfNotOwnerPrivacyPolicyRule extends PrivacyPolicyRule<
     _queryContext: EntityQueryContext,
     _evaluationContext: EntityPrivacyPolicyEvaluationContext<
       BlahFields,
-      string,
+      'id',
       TestUserViewerContext,
       BlahEntity
     >,
@@ -89,24 +89,24 @@ class DenyIfNotOwnerPrivacyPolicyRule extends PrivacyPolicyRule<
 
 class BlahEntityPrivacyPolicy extends EntityPrivacyPolicy<
   BlahFields,
-  string,
+  'id',
   ViewerContext,
   BlahEntity
 > {
   protected override readonly createRules = [
     new DenyIfNotOwnerPrivacyPolicyRule(),
-    new AlwaysAllowPrivacyPolicyRule<BlahFields, string, ViewerContext, BlahEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<BlahFields, 'id', ViewerContext, BlahEntity>(),
   ];
   protected override readonly readRules = [
     new DenyIfNotOwnerPrivacyPolicyRule(),
-    new AlwaysAllowPrivacyPolicyRule<BlahFields, string, ViewerContext, BlahEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<BlahFields, 'id', ViewerContext, BlahEntity>(),
   ];
   protected override readonly updateRules = [
     new DenyIfNotOwnerPrivacyPolicyRule(),
-    new AlwaysAllowPrivacyPolicyRule<BlahFields, string, ViewerContext, BlahEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<BlahFields, 'id', ViewerContext, BlahEntity>(),
   ];
   protected override readonly deleteRules = [
-    new AlwaysDenyPrivacyPolicyRule<BlahFields, string, ViewerContext, BlahEntity>(),
+    new AlwaysDenyPrivacyPolicyRule<BlahFields, 'id', ViewerContext, BlahEntity>(),
   ];
 }
 

package/src/__tests__/EntityCompanion-test.ts

@@ -13,13 +13,13 @@ import TestEntityWithMutationTriggers, {
   TestMTFields,
   testEntityMTConfiguration,
   TestMutationTrigger,
-} from '../testfixtures/TestEntityWithMutationTriggers';
+} from '../utils/__testfixtures__/TestEntityWithMutationTriggers';
 
 describe(EntityCompanion, () => {
   it('correctly instantiates mutator and loader factories', () => {
     const entityCompanionProvider = instance(mock<EntityCompanionProvider>());
 
-    const tableDataCoordinatorMock = mock<EntityTableDataCoordinator<TestMTFields>>();
+    const tableDataCoordinatorMock = mock<EntityTableDataCoordinator<TestMTFields, 'id'>>();
     when(tableDataCoordinatorMock.entityConfiguration).thenReturn(testEntityMTConfiguration);
 
     const companion = new EntityCompanion(
@@ -35,7 +35,7 @@ describe(EntityCompanion, () => {
   it('correctly merges local and global mutation triggers', () => {
     const globalMutationTriggers: EntityMutationTriggerConfiguration<
       TestMTFields,
-      string,
+      'id',
       ViewerContext,
       TestEntityWithMutationTriggers,
       keyof TestMTFields
@@ -53,7 +53,7 @@ describe(EntityCompanion, () => {
       globalMutationTriggers,
     );
 
-    const tableDataCoordinatorMock = mock<EntityTableDataCoordinator<TestMTFields>>();
+    const tableDataCoordinatorMock = mock<EntityTableDataCoordinator<TestMTFields, 'id'>>();
     when(tableDataCoordinatorMock.entityConfiguration).thenReturn(testEntityMTConfiguration);
 
     const companion = new EntityCompanion(

package/src/__tests__/EntityCompanionProvider-test.ts

@@ -4,28 +4,29 @@ import EntityConfiguration from '../EntityConfiguration';
 import { StringField } from '../EntityFields';
 import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
 import ViewerContext from '../ViewerContext';
-import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
+import { createUnitTestEntityCompanionProvider } from '../utils/__testfixtures__/createUnitTestEntityCompanionProvider';
 
 type BlahFields = {
   hello: string;
 };
 
-const blahConfiguration = new EntityConfiguration<BlahFields>({
+const blahConfiguration = new EntityConfiguration<BlahFields, 'hello'>({
   idField: 'hello',
   tableName: 'wat',
   schema: {
     hello: new StringField({
       columnName: 'hello',
+      cache: false,
     }),
   },
   databaseAdapterFlavor: 'postgres',
   cacheAdapterFlavor: 'redis',
 });
 
-class Blah1Entity extends Entity<BlahFields, string, ViewerContext> {
+class Blah1Entity extends Entity<BlahFields, 'hello', ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     BlahFields,
-    string,
+    'hello',
     ViewerContext,
     Blah1Entity,
     NoOpTest1PrivacyPolicy
@@ -38,10 +39,10 @@ class Blah1Entity extends Entity<BlahFields, string, ViewerContext> {
   }
 }
 
-class Blah2Entity extends Entity<BlahFields, string, ViewerContext> {
+class Blah2Entity extends Entity<BlahFields, 'hello', ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     BlahFields,
-    string,
+    'hello',
     ViewerContext,
     Blah2Entity,
     NoOpTest2PrivacyPolicy
@@ -56,13 +57,13 @@ class Blah2Entity extends Entity<BlahFields, string, ViewerContext> {
 
 class NoOpTest1PrivacyPolicy extends EntityPrivacyPolicy<
   BlahFields,
-  string,
+  'hello',
   ViewerContext,
   Blah1Entity
 > {}
 class NoOpTest2PrivacyPolicy extends EntityPrivacyPolicy<
   BlahFields,
-  string,
+  'hello',
   ViewerContext,
   Blah2Entity
 > {}

package/src/__tests__/EntityConfiguration-test.ts

@@ -1,5 +1,6 @@
 import EntityConfiguration from '../EntityConfiguration';
-import { UUIDField, StringField } from '../EntityFields';
+import { StringField, UUIDField } from '../EntityFields';
+import { CompositeFieldHolder } from '../internal/CompositeFieldHolder';
 
 describe(EntityConfiguration, () => {
   describe('when valid', () => {
@@ -13,12 +14,13 @@ describe(EntityConfiguration, () => {
       id: string;
     };
 
-    const blahEntityConfiguration = new EntityConfiguration<BlahT>({
+    const blahEntityConfiguration = new EntityConfiguration<BlahT, 'id'>({
       idField: 'id',
       tableName: 'blah_table',
       schema: {
         id: new UUIDField({
           columnName: 'id',
+          cache: false,
         }),
         cacheable: new StringField({
           columnName: 'cacheable',
@@ -30,6 +32,10 @@ describe(EntityConfiguration, () => {
       },
       databaseAdapterFlavor: 'postgres',
       cacheAdapterFlavor: 'redis',
+      compositeFieldDefinitions: [
+        { compositeField: ['id', 'cacheable'], cache: true },
+        { compositeField: ['id', 'uniqueButNotCacheable'], cache: false },
+      ],
     });
 
     it('returns correct fields', () => {
@@ -37,20 +43,91 @@ describe(EntityConfiguration, () => {
       expect(blahEntityConfiguration.tableName).toEqual('blah_table');
       expect(blahEntityConfiguration.databaseAdapterFlavor).toEqual('postgres');
       expect(blahEntityConfiguration.cacheAdapterFlavor).toEqual('redis');
+      expect(blahEntityConfiguration.compositeFieldInfo.getAllCompositeFieldHolders()).toEqual([
+        new CompositeFieldHolder(['id', 'cacheable']),
+        new CompositeFieldHolder(['id', 'uniqueButNotCacheable']),
+      ]);
     });
 
     it('filters cacheable fields', () => {
       expect(blahEntityConfiguration.cacheableKeys).toEqual(new Set(['cacheable']));
     });
 
+    it('correctly returns cacheable composite fields', () => {
+      expect(
+        blahEntityConfiguration.compositeFieldInfo.canCacheCompositeField(['id', 'cacheable']),
+      ).toBe(true);
+      expect(
+        blahEntityConfiguration.compositeFieldInfo.canCacheCompositeField([
+          'id',
+          'uniqueButNotCacheable',
+        ]),
+      ).toBe(false);
+
+      expect(() =>
+        blahEntityConfiguration.compositeFieldInfo.canCacheCompositeField(['id']),
+      ).toThrow('Composite field (id) not found in entity configuration');
+    });
+
+    it('validates composite fields', () => {
+      expect(
+        () =>
+          new EntityConfiguration<BlahT, 'id'>({
+            idField: 'id',
+            tableName: 'blah_table',
+            schema: {
+              id: new UUIDField({
+                columnName: 'id',
+                cache: false,
+              }),
+              cacheable: new StringField({
+                columnName: 'cacheable',
+                cache: true,
+              }),
+              uniqueButNotCacheable: new StringField({
+                columnName: 'unique_but_not_cacheable',
+              }),
+            },
+            databaseAdapterFlavor: 'postgres',
+            cacheAdapterFlavor: 'redis',
+            compositeFieldDefinitions: [{ compositeField: ['id', 'id'], cache: true }],
+          }),
+      ).toThrow('Composite field must have unique sub-fields');
+
+      expect(
+        () =>
+          new EntityConfiguration<BlahT, 'id'>({
+            idField: 'id',
+            tableName: 'blah_table',
+            schema: {
+              id: new UUIDField({
+                columnName: 'id',
+                cache: false,
+              }),
+              cacheable: new StringField({
+                columnName: 'cacheable',
+                cache: true,
+              }),
+              uniqueButNotCacheable: new StringField({
+                columnName: 'unique_but_not_cacheable',
+              }),
+            },
+            databaseAdapterFlavor: 'postgres',
+            cacheAdapterFlavor: 'redis',
+            compositeFieldDefinitions: [{ compositeField: ['id'], cache: true }],
+          }),
+      ).toThrow('Composite field must have at least two sub-fields');
+    });
+
     describe('cache key version', () => {
       it('defaults to 0', () => {
-        const entityConfiguration = new EntityConfiguration<Blah2T>({
+        const entityConfiguration = new EntityConfiguration<Blah2T, 'id'>({
           idField: 'id',
           tableName: 'blah',
           schema: {
             id: new UUIDField({
               columnName: 'id',
+              cache: false,
             }),
           },
           databaseAdapterFlavor: 'postgres',
@@ -60,12 +137,13 @@ describe(EntityConfiguration, () => {
       });
 
       it('sets to custom version', () => {
-        const entityConfiguration = new EntityConfiguration<Blah2T>({
+        const entityConfiguration = new EntityConfiguration<Blah2T, 'id'>({
           idField: 'id',
           tableName: 'blah',
           schema: {
             id: new UUIDField({
               columnName: 'id',
+              cache: false,
             }),
           },
           databaseAdapterFlavor: 'postgres',
@@ -95,17 +173,18 @@ describe(EntityConfiguration, () => {
       ])('disallows %p as field key', (keyName) => {
         expect(
           () =>
-            new EntityConfiguration<any>({
+            new EntityConfiguration<any, 'id'>({
               idField: 'id',
               tableName: 'blah_table',
               schema: {
                 id: new UUIDField({
                   columnName: 'id',
+                  cache: false,
                 }),
                 [keyName]: new StringField({
                   columnName: 'any',
                 }),
-              },
+              } as any,
               databaseAdapterFlavor: 'postgres',
               cacheAdapterFlavor: 'redis',
             }),

package/src/__tests__/EntityDatabaseAdapter-test.ts

@@ -5,10 +5,12 @@ import EntityDatabaseAdapter, {
   TableFieldMultiValueEqualityCondition,
 } from '../EntityDatabaseAdapter';
 import { EntityQueryContext } from '../EntityQueryContext';
+import { CompositeFieldHolder, CompositeFieldValueHolder } from '../internal/CompositeFieldHolder';
 import { FieldTransformerMap } from '../internal/EntityFieldTransformationUtils';
-import { TestFields, testEntityConfiguration } from '../testfixtures/TestEntity';
+import { SingleFieldHolder, SingleFieldValueHolder } from '../internal/SingleFieldHolder';
+import { TestFields, testEntityConfiguration } from '../utils/__testfixtures__/TestEntity';
 
-class TestEntityDatabaseAdapter extends EntityDatabaseAdapter<TestFields> {
+class TestEntityDatabaseAdapter extends EntityDatabaseAdapter<TestFields, 'customIdField'> {
   private readonly fetchResults: object[];
   private readonly insertResults: object[];
   private readonly updateResults: object[];
@@ -47,8 +49,8 @@ class TestEntityDatabaseAdapter extends EntityDatabaseAdapter<TestFields> {
   protected async fetchManyWhereInternalAsync(
     _queryInterface: any,
     _tableName: string,
-    _tableField: string,
-    _tableValues: readonly any[],
+    _tableColumns: readonly string[],
+    _tableTuples: (readonly any[])[],
   ): Promise<object[]> {
     return this.fetchResults;
   }
@@ -104,8 +106,12 @@ describe(EntityDatabaseAdapter, () => {
     it('transforms object', async () => {
       const queryContext = instance(mock(EntityQueryContext));
       const adapter = new TestEntityDatabaseAdapter({ fetchResults: [{ string_field: 'hello' }] });
-      const result = await adapter.fetchManyWhereAsync(queryContext, 'stringField', ['hello']);
-      expect(result.get('hello')).toEqual([{ stringField: 'hello' }]);
+      const result = await adapter.fetchManyWhereAsync(
+        queryContext,
+        new SingleFieldHolder('stringField'),
+        [new SingleFieldValueHolder('hello')],
+      );
+      expect(result.get(new SingleFieldValueHolder('hello'))).toEqual([{ stringField: 'hello' }]);
     });
 
     it('returns objects keyed by queried values', async () => {
@@ -113,22 +119,112 @@ describe(EntityDatabaseAdapter, () => {
       const adapter = new TestEntityDatabaseAdapter({
         fetchResults: [{ string_field: 'hello' }, { string_field: 'wat' }],
       });
-      const result = await adapter.fetchManyWhereAsync(queryContext, 'stringField', [
-        'hello',
-        'wat',
-      ]);
-      expect(result.get('hello')).toEqual([{ stringField: 'hello' }]);
-      expect(result.get('wat')).toEqual([{ stringField: 'wat' }]);
+      const result = await adapter.fetchManyWhereAsync(
+        queryContext,
+        new SingleFieldHolder('stringField'),
+        [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('wat')],
+      );
+      expect(result.get(new SingleFieldValueHolder('hello'))).toEqual([{ stringField: 'hello' }]);
+      expect(result.get(new SingleFieldValueHolder('wat'))).toEqual([{ stringField: 'wat' }]);
+    });
+
+    it('returns objects keyed by composite queried values', async () => {
+      const queryContext = instance(mock(EntityQueryContext));
+      const adapter = new TestEntityDatabaseAdapter({
+        fetchResults: [
+          { string_field: 'hello', number_field: 1 },
+          { string_field: 'wat', number_field: 2 },
+        ],
+      });
+      const result = await adapter.fetchManyWhereAsync(
+        queryContext,
+        new CompositeFieldHolder<TestFields, 'customIdField'>(['intField', 'stringField']),
+        [
+          new CompositeFieldValueHolder({ intField: 1, stringField: 'hello' }),
+          new CompositeFieldValueHolder({ intField: 2, stringField: 'wat' }),
+          new CompositeFieldValueHolder({ intField: 4, stringField: 'no' }),
+        ],
+      );
+      expect(
+        result.get(new CompositeFieldValueHolder({ intField: 1, stringField: 'hello' })),
+      ).toEqual([{ stringField: 'hello', intField: 1 }]);
+      expect(
+        result.get(new CompositeFieldValueHolder({ intField: 2, stringField: 'wat' })),
+      ).toEqual([{ stringField: 'wat', intField: 2 }]);
+      expect(result.get(new CompositeFieldValueHolder({ intField: 4, stringField: 'no' }))).toEqual(
+        [],
+      );
     });
 
     it('returns map with all keys even when no results are returned', async () => {
       const queryContext = instance(mock(EntityQueryContext));
       const adapter = new TestEntityDatabaseAdapter({});
-      const result = await adapter.fetchManyWhereAsync(queryContext, 'stringField', [
-        'what',
-        'who',
-      ]);
-      expect(Array.from(result.keys())).toEqual(['what', 'who']);
+      const result = await adapter.fetchManyWhereAsync(
+        queryContext,
+        new SingleFieldHolder('stringField'),
+        [new SingleFieldValueHolder('what'), new SingleFieldValueHolder('who')],
+      );
+      expect(Array.from(result.keys()).map((v) => v.fieldValue)).toEqual(['what', 'who']);
+    });
+
+    it('throws when result contains invalid (null) value for key', async () => {
+      const queryContext = instance(mock(EntityQueryContext));
+      const adapter = new TestEntityDatabaseAdapter({
+        fetchResults: [{ string_field: null }],
+      });
+      await expect(
+        adapter.fetchManyWhereAsync(queryContext, new SingleFieldHolder('stringField'), [
+          new SingleFieldValueHolder('hello'),
+        ]),
+      ).rejects.toThrow(
+        'One or more fields from the object is invalid for key SingleField(stringField); {"stringField":null}. This may indicate a faulty database adapter implementation.',
+      );
+    });
+
+    it('throws when result contains invalid (undefined) value for key', async () => {
+      const queryContext = instance(mock(EntityQueryContext));
+      const adapter = new TestEntityDatabaseAdapter({
+        fetchResults: [{ string_field: undefined }],
+      });
+      await expect(
+        adapter.fetchManyWhereAsync(queryContext, new SingleFieldHolder('stringField'), [
+          new SingleFieldValueHolder('hello'),
+        ]),
+      ).rejects.toThrow(
+        'One or more fields from the object is invalid for key SingleField(stringField); {}. This may indicate a faulty database adapter implementation.',
+      );
+    });
+
+    it('throws when result contains invalid (null) value for composite key', async () => {
+      const queryContext = instance(mock(EntityQueryContext));
+      const adapter = new TestEntityDatabaseAdapter({
+        fetchResults: [{ string_field: 'hello', number_field: null }],
+      });
+      await expect(
+        adapter.fetchManyWhereAsync(
+          queryContext,
+          new CompositeFieldHolder<TestFields, 'customIdField'>(['intField', 'stringField']),
+          [new CompositeFieldValueHolder({ intField: 1, stringField: 'hello' })],
+        ),
+      ).rejects.toThrow(
+        'One or more fields from the object is invalid for key CompositeField(intField,stringField); {"stringField":"hello","intField":null}. This may indicate a faulty database adapter implementation.',
+      );
+    });
+
+    it('throws when result contains invalid (undefined) value for composite key', async () => {
+      const queryContext = instance(mock(EntityQueryContext));
+      const adapter = new TestEntityDatabaseAdapter({
+        fetchResults: [{ string_field: 'hello', number_field: undefined }],
+      });
+      await expect(
+        adapter.fetchManyWhereAsync(
+          queryContext,
+          new CompositeFieldHolder<TestFields, 'customIdField'>(['intField', 'stringField']),
+          [new CompositeFieldValueHolder({ intField: 1, stringField: 'hello' })],
+        ),
+      ).rejects.toThrow(
+        'One or more fields from the object is invalid for key CompositeField(intField,stringField); {"stringField":"hello"}. This may indicate a faulty database adapter implementation.',
+      );
     });
   });