@expo/entity 0.40.0 → 0.42.0

package/src/__tests__/Entity-test.ts

@@ -1,22 +1,37 @@
+import {
+  AuthorizationResultBasedCreateMutator,
+  AuthorizationResultBasedDeleteMutator,
+  AuthorizationResultBasedUpdateMutator,
+} from '../AuthorizationResultBasedEntityMutator';
+import EnforcingEntityCreator from '../EnforcingEntityCreator';
+import EnforcingEntityDeleter from '../EnforcingEntityDeleter';
+import EnforcingEntityUpdater from '../EnforcingEntityUpdater';
 import Entity from '../Entity';
-import EntityCreator from '../EntityCreator';
-import EntityDeleter from '../EntityDeleter';
-import EntityUpdater from '../EntityUpdater';
 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', () => {
-    it('creates a new EntityCreator', () => {
+    it('creates a new EnforcingEntityCreator', () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
-      expect(SimpleTestEntity.creator(viewerContext)).toBeInstanceOf(EntityCreator);
+      expect(SimpleTestEntity.creator(viewerContext)).toBeInstanceOf(EnforcingEntityCreator);
+    });
+  });
+
+  describe('creatorWithAuthorizationResults', () => {
+    it('creates a new AuthorizationResultBasedCreateMutator', () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      expect(SimpleTestEntity.creatorWithAuthorizationResults(viewerContext)).toBeInstanceOf(
+        AuthorizationResultBasedCreateMutator,
+      );
     });
   });
 
   describe('updater', () => {
-    it('creates a new EntityUpdater', () => {
+    it('creates a new EnforcingEntityUpdater', () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
       const data = {
@@ -28,12 +43,48 @@ describe(Entity, () => {
         databaseFields: data,
         selectedFields: data,
       });
-      expect(SimpleTestEntity.updater(testEntity)).toBeInstanceOf(EntityUpdater);
+      expect(SimpleTestEntity.updater(testEntity)).toBeInstanceOf(EnforcingEntityUpdater);
+    });
+  });
+
+  describe('updaterWithAuthorizationResults', () => {
+    it('creates a new AuthorizationResultBasedUpdateMutator', () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      const data = {
+        id: 'what',
+      };
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
+      expect(SimpleTestEntity.updaterWithAuthorizationResults(testEntity)).toBeInstanceOf(
+        AuthorizationResultBasedUpdateMutator,
+      );
     });
   });
 
   describe('deleter', () => {
-    it('creates a new EntityDeleter', () => {
+    it('creates a new EnforcingEntityDeleter', () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      const data = {
+        id: 'what',
+      };
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
+      expect(SimpleTestEntity.deleter(testEntity)).toBeInstanceOf(EnforcingEntityDeleter);
+    });
+  });
+
+  describe('deleterWithAuthorizationResults', () => {
+    it('creates a new AuthorizationResultBasedDeleteMutator', () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
       const data = {
@@ -45,7 +96,9 @@ describe(Entity, () => {
         databaseFields: data,
         selectedFields: data,
       });
-      expect(SimpleTestEntity.deleter(testEntity)).toBeInstanceOf(EntityDeleter);
+      expect(SimpleTestEntity.deleterWithAuthorizationResults(testEntity)).toBeInstanceOf(
+        AuthorizationResultBasedDeleteMutator,
+      );
     });
   });
 });

package/src/__tests__/EntityAssociationLoader-test.ts

@@ -2,18 +2,16 @@ 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', () => {
     it('creates a new EnforcingEntityLoader', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
-      const testEntity = await SimpleTestEntity.creator(viewerContext).enforcing().createAsync();
-      expect(testEntity.associationLoader().enforcing()).toBeInstanceOf(
-        EnforcingEntityAssociationLoader,
-      );
+      const testEntity = await SimpleTestEntity.creator(viewerContext).createAsync();
+      expect(testEntity.associationLoader()).toBeInstanceOf(EnforcingEntityAssociationLoader);
     });
   });
 
@@ -21,8 +19,8 @@ describe(EntityAssociationLoader, () => {
     it('creates a new AuthorizationResultBasedEntityAssociationLoader', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
-      const testEntity = await SimpleTestEntity.creator(viewerContext).enforcing().createAsync();
-      expect(testEntity.associationLoader().withAuthorizationResults()).toBeInstanceOf(
+      const testEntity = await SimpleTestEntity.creator(viewerContext).createAsync();
+      expect(testEntity.associationLoaderWithAuthorizationResults()).toBeInstanceOf(
         AuthorizationResultBasedEntityAssociationLoader,
       );
     });

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>(),
   ];
 }
 
@@ -118,22 +118,19 @@ it('runs through a common workflow', async () => {
   const vc2 = new TestUserViewerContext(entityCompanionProvider, uuidv4());
 
   const blahOwner1 = await enforceAsyncResult(
-    BlahEntity.creator(vc1)
-      .withAuthorizationResults()
+    BlahEntity.creatorWithAuthorizationResults(vc1)
       .setField('ownerID', vc1.getUserID())
       .createAsync(),
   );
 
   await enforceAsyncResult(
-    BlahEntity.creator(vc1)
-      .withAuthorizationResults()
+    BlahEntity.creatorWithAuthorizationResults(vc1)
       .setField('ownerID', vc1.getUserID())
       .createAsync(),
   );
 
   const blahOwner2 = await enforceAsyncResult(
-    BlahEntity.creator(vc2)
-      .withAuthorizationResults()
+    BlahEntity.creatorWithAuthorizationResults(vc2)
       .setField('ownerID', vc2.getUserID())
       .createAsync(),
   );
@@ -145,43 +142,43 @@ it('runs through a common workflow', async () => {
   // check that two people can't read each others data
   await expect(
     enforceAsyncResult(
-      BlahEntity.loader(vc1).withAuthorizationResults().loadByIDAsync(blahOwner2.getID()),
+      BlahEntity.loaderWithAuthorizationResults(vc1).loadByIDAsync(blahOwner2.getID()),
     ),
   ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
   await expect(
     enforceAsyncResult(
-      BlahEntity.loader(vc2).withAuthorizationResults().loadByIDAsync(blahOwner1.getID()),
+      BlahEntity.loaderWithAuthorizationResults(vc2).loadByIDAsync(blahOwner1.getID()),
     ),
   ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
 
   // check that all of owner 1's objects can be loaded
   const results = await enforceResultsAsync(
-    BlahEntity.loader(vc1)
-      .withAuthorizationResults()
-      .loadManyByFieldEqualingAsync('ownerID', vc1.getUserID()),
+    BlahEntity.loaderWithAuthorizationResults(vc1).loadManyByFieldEqualingAsync(
+      'ownerID',
+      vc1.getUserID(),
+    ),
   );
   expect(results).toHaveLength(2);
 
   // check that two people can't create objects owned by others
   await expect(
     enforceAsyncResult(
-      BlahEntity.creator(vc2)
-        .withAuthorizationResults()
+      BlahEntity.creatorWithAuthorizationResults(vc2)
         .setField('ownerID', blahOwner1.getID())
         .createAsync(),
     ),
   ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
 
   // check that empty load many returns nothing
-  const results2 = await BlahEntity.loader(vc1)
-    .withAuthorizationResults()
-    .loadManyByFieldEqualingManyAsync('ownerID', []);
+  const results2 = await BlahEntity.loaderWithAuthorizationResults(
+    vc1,
+  ).loadManyByFieldEqualingManyAsync('ownerID', []);
   for (const value in results2.values) {
     expect(value).toHaveLength(0);
   }
 
   // check that the user can't delete their own data (as specified by privacy rules)
   await expect(
-    enforceAsyncResult(BlahEntity.deleter(blahOwner2).withAuthorizationResults().deleteAsync()),
+    enforceAsyncResult(BlahEntity.deleterWithAuthorizationResults(blahOwner2).deleteAsync()),
   ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
 });

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',
             }),