@expo/entity 0.34.0 → 0.35.0

package/src/__tests__/cases/TwoEntitySameTableOverlappingRows-test.ts

@@ -3,26 +3,26 @@ import { EntityCompanionDefinition } from '../../EntityCompanionProvider';
 import EntityConfiguration from '../../EntityConfiguration';
 import { UUIDField, StringField } from '../../EntityFields';
 import EntityPrivacyPolicy from '../../EntityPrivacyPolicy';
+import ViewerContext from '../../ViewerContext';
 import AlwaysAllowPrivacyPolicyRule from '../../rules/AlwaysAllowPrivacyPolicyRule';
-import TestViewerContext from '../../testfixtures/TestViewerContext';
 import { createUnitTestEntityCompanionProvider } from '../../utils/testing/createUnitTestEntityCompanionProvider';
 
 describe('Two entities backed by the same table', () => {
   test('mutate through different types and keep consistent cache and dataloader', async () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
-    const viewerContext = new TestViewerContext(companionProvider);
+    const viewerContext = new ViewerContext(companionProvider);
 
-    const entity1 = await OneTestEntity.creator(viewerContext, viewerContext.getQueryContext())
+    const entity1 = await OneTestEntity.creator(viewerContext)
       .setField('fake_field', 'hello')
       .enforceCreateAsync();
     expect(entity1).toBeInstanceOf(OneTestEntity);
 
-    const entity2 = await TwoTestEntity.loader(viewerContext, viewerContext.getQueryContext())
+    const entity2 = await TwoTestEntity.loader(viewerContext)
       .enforcing()
       .loadByIDAsync(entity1.getID());
     expect(entity2).toBeInstanceOf(TwoTestEntity);
 
-    const updated2 = await TwoTestEntity.updater(entity2, viewerContext.getQueryContext())
+    const updated2 = await TwoTestEntity.updater(entity2)
       .setField('fake_field', 'world')
       .setField('other_field', 'wat')
       .enforceUpdateAsync();
@@ -32,7 +32,7 @@ describe('Two entities backed by the same table', () => {
       fake_field: 'world',
     });
 
-    const loaded1 = await OneTestEntity.loader(viewerContext, viewerContext.getQueryContext())
+    const loaded1 = await OneTestEntity.loader(viewerContext)
       .enforcing()
       .loadByIDAsync(entity1.getID());
     expect(loaded1.getAllFields()).toMatchObject({
@@ -43,14 +43,14 @@ describe('Two entities backed by the same table', () => {
 
   test('cached field that differs between the two to test invalidation', async () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
-    const viewerContext = new TestViewerContext(companionProvider);
+    const viewerContext = new ViewerContext(companionProvider);
 
-    const entity = await TwoTestEntity.creator(viewerContext, viewerContext.getQueryContext())
+    const entity = await TwoTestEntity.creator(viewerContext)
       .setField('fake_field', 'hello')
       .setField('other_field', 'huh')
       .enforceCreateAsync();
 
-    const loadedEntity = await TwoTestEntity.loader(viewerContext, viewerContext.getQueryContext())
+    const loadedEntity = await TwoTestEntity.loader(viewerContext)
       .enforcing()
       .loadByFieldEqualingAsync('other_field', 'huh');
     expect(loadedEntity?.getAllFields()).toMatchObject({
@@ -59,14 +59,12 @@ describe('Two entities backed by the same table', () => {
       other_field: 'huh',
     });
 
-    const loaded1 = await OneTestEntity.loader(viewerContext, viewerContext.getQueryContext())
+    const loaded1 = await OneTestEntity.loader(viewerContext)
       .enforcing()
       .loadByIDAsync(entity.getID());
-    await OneTestEntity.updater(loaded1, viewerContext.getQueryContext())
-      .setField('fake_field', 'world')
-      .enforceUpdateAsync();
+    await OneTestEntity.updater(loaded1).setField('fake_field', 'world').enforceUpdateAsync();
 
-    const loaded2 = await TwoTestEntity.loader(viewerContext, viewerContext.getQueryContext())
+    const loaded2 = await TwoTestEntity.loader(viewerContext)
       .enforcing()
       .loadByFieldEqualingAsync('other_field', 'huh');
     expect(loaded2?.getAllFields()).toMatchObject({
@@ -75,7 +73,7 @@ describe('Two entities backed by the same table', () => {
       other_field: 'huh',
     });
 
-    const loaded22 = await TwoTestEntity.loader(viewerContext, viewerContext.getQueryContext())
+    const loaded22 = await TwoTestEntity.loader(viewerContext)
       .enforcing()
       .loadByFieldEqualingAsync('fake_field', 'world');
     expect(loaded22?.getAllFields()).toMatchObject({
@@ -116,32 +114,26 @@ const testEntityConfiguration = new EntityConfiguration<TestFields>({
   cacheAdapterFlavor: 'redis',
 });
 
-class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<
-  any,
-  string,
-  TestViewerContext,
-  any,
-  any
-> {
+class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<any, string, ViewerContext, any, any> {
   protected override readonly readRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, TestViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
   protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, TestViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
   protected override readonly updateRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, TestViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
   protected override readonly deleteRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, TestViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
 }
 
-class OneTestEntity extends Entity<TestFields, string, TestViewerContext, OneTestFields> {
+class OneTestEntity extends Entity<TestFields, string, ViewerContext, OneTestFields> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     OneTestEntity,
     TestEntityPrivacyPolicy,
     OneTestFields
@@ -155,11 +147,11 @@ class OneTestEntity extends Entity<TestFields, string, TestViewerContext, OneTes
   }
 }
 
-class TwoTestEntity extends Entity<TestFields, string, TestViewerContext, TwoTestFields> {
+class TwoTestEntity extends Entity<TestFields, string, ViewerContext, TwoTestFields> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     TwoTestEntity,
     TestEntityPrivacyPolicy,
     TwoTestFields

package/src/internal/EntityDataManager.ts

@@ -76,7 +76,7 @@ export default class EntityDataManager<TFields> {
           entityClassName: this.entityClassName,
         });
         return await this.databaseAdapter.fetchManyWhereAsync(
-          this.queryContextProvider.getNonTransactionalQueryContext(),
+          this.queryContextProvider.getQueryContext(),
           fieldName,
           fetcherValues
         );

package/src/internal/__tests__/EntityDataManager-test.ts

@@ -78,7 +78,7 @@ describe(EntityDataManager, () => {
       new NoOpEntityMetricsAdapter(),
       TestEntity.name
     );
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
 
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
@@ -126,7 +126,7 @@ describe(EntityDataManager, () => {
       new NoOpEntityMetricsAdapter(),
       TestEntity.name
     );
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
 
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
@@ -174,7 +174,7 @@ describe(EntityDataManager, () => {
       new NoOpEntityMetricsAdapter(),
       TestEntity.name
     );
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
     // use second data manager to ensure that cache is hit instead of data loader
     const entityDataManager2 = new EntityDataManager(
       databaseAdapter,
@@ -218,7 +218,7 @@ describe(EntityDataManager, () => {
       new NoOpEntityMetricsAdapter(),
       TestEntity.name
     );
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
 
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
@@ -254,7 +254,7 @@ describe(EntityDataManager, () => {
       new NoOpEntityMetricsAdapter(),
       TestEntity.name
     );
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
 
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
@@ -298,7 +298,7 @@ describe(EntityDataManager, () => {
       new NoOpEntityMetricsAdapter(),
       TestEntity.name
     );
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
 
     const objectInQuestion = objects.get(testEntityConfiguration.tableName)![1]!;
 
@@ -337,7 +337,7 @@ describe(EntityDataManager, () => {
       new NoOpEntityMetricsAdapter(),
       TestEntity.name
     );
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
 
     const objectInQuestion = objects.get(testEntityConfiguration.tableName)![1]!;
 
@@ -415,7 +415,7 @@ describe(EntityDataManager, () => {
       new NoOpEntityMetricsAdapter(),
       TestEntity.name
     );
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
 
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyByFieldEqualityConjunctionAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
@@ -461,7 +461,7 @@ describe(EntityDataManager, () => {
       new NoOpEntityMetricsAdapter(),
       TestEntity.name
     );
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
 
     await expect(
       entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'customIdField', ['2'])
@@ -488,7 +488,7 @@ describe(EntityDataManager, () => {
       metricsAdapter,
       TestEntity.name
     );
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
 
     await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'customIdField', ['1']);
     verify(
@@ -591,7 +591,7 @@ describe(EntityDataManager, () => {
       new NoOpEntityMetricsAdapter(),
       TestEntity.name
     );
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
 
     await expect(
       entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'nullableField', [null as any])

package/src/testfixtures/SimpleTestEntity.ts

@@ -1,9 +1,9 @@
-import TestViewerContext from './TestViewerContext';
 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 SimpleTestFields = {
@@ -27,7 +27,7 @@ export const simpleTestEntityConfiguration = new EntityConfiguration<SimpleTestF
 export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
   SimpleTestFields,
   string,
-  TestViewerContext,
+  ViewerContext,
   SimpleTestEntity,
   SimpleTestFieldSelection
 > {
@@ -35,7 +35,7 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
     new AlwaysAllowPrivacyPolicyRule<
       SimpleTestFields,
       string,
-      TestViewerContext,
+      ViewerContext,
       SimpleTestEntity,
       SimpleTestFieldSelection
     >(),
@@ -44,7 +44,7 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
     new AlwaysAllowPrivacyPolicyRule<
       SimpleTestFields,
       string,
-      TestViewerContext,
+      ViewerContext,
       SimpleTestEntity,
       SimpleTestFieldSelection
     >(),
@@ -53,7 +53,7 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
     new AlwaysAllowPrivacyPolicyRule<
       SimpleTestFields,
       string,
-      TestViewerContext,
+      ViewerContext,
       SimpleTestEntity,
       SimpleTestFieldSelection
     >(),
@@ -62,7 +62,7 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
     new AlwaysAllowPrivacyPolicyRule<
       SimpleTestFields,
       string,
-      TestViewerContext,
+      ViewerContext,
       SimpleTestEntity,
       SimpleTestFieldSelection
     >(),
@@ -72,13 +72,13 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
 export default class SimpleTestEntity extends Entity<
   SimpleTestFields,
   string,
-  TestViewerContext,
+  ViewerContext,
   SimpleTestFieldSelection
 > {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     SimpleTestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     SimpleTestEntity,
     SimpleTestEntityPrivacyPolicy,
     SimpleTestFieldSelection

package/src/testfixtures/TestEntity.ts

@@ -1,11 +1,11 @@
 import { result, Result } from '@expo/results';
 
-import TestViewerContext from './TestViewerContext';
 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';
 
 export type TestFields = {
@@ -48,28 +48,28 @@ export const testEntityConfiguration = new EntityConfiguration<TestFields>({
 export class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<
   TestFields,
   string,
-  TestViewerContext,
+  ViewerContext,
   TestEntity
 > {
   protected override readonly readRules = [
-    new AlwaysAllowPrivacyPolicyRule<TestFields, string, TestViewerContext, TestEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
   ];
   protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<TestFields, string, TestViewerContext, TestEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
   ];
   protected override readonly updateRules = [
-    new AlwaysAllowPrivacyPolicyRule<TestFields, string, TestViewerContext, TestEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
   ];
   protected override readonly deleteRules = [
-    new AlwaysAllowPrivacyPolicyRule<TestFields, string, TestViewerContext, TestEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
   ];
 }
 
-export default class TestEntity extends Entity<TestFields, string, TestViewerContext> {
+export default class TestEntity extends Entity<TestFields, string, ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     TestEntity,
     TestEntityPrivacyPolicy
   > {
@@ -84,10 +84,7 @@ export default class TestEntity extends Entity<TestFields, string, TestViewerCon
     return 'Hello World!';
   }
 
-  static async hello(
-    viewerContext: TestViewerContext,
-    testValue: string
-  ): Promise<Result<TestEntity>> {
+  static async hello(viewerContext: ViewerContext, testValue: string): Promise<Result<TestEntity>> {
     const fields = {
       customIdField: testValue,
       testIndexedField: 'hello',
@@ -106,15 +103,15 @@ export default class TestEntity extends Entity<TestFields, string, TestViewerCon
     );
   }
 
-  static async returnError(_viewerContext: TestViewerContext): Promise<Result<TestEntity>> {
+  static async returnError(_viewerContext: ViewerContext): Promise<Result<TestEntity>> {
     return result(new Error('return entity'));
   }
 
-  static async throwError(_viewerContext: TestViewerContext): Promise<Result<TestEntity>> {
+  static async throwError(_viewerContext: ViewerContext): Promise<Result<TestEntity>> {
     throw new Error('threw entity');
   }
 
-  static async nonResult(_viewerContext: TestViewerContext, testValue: string): Promise<string> {
+  static async nonResult(_viewerContext: ViewerContext, testValue: string): Promise<string> {
     return testValue;
   }
 }

package/src/testfixtures/TestEntity2.ts

@@ -1,9 +1,9 @@
-import TestViewerContext from './TestViewerContext';
 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 = {
@@ -29,28 +29,28 @@ export const testEntity2Configuration = new EntityConfiguration<Test2Fields>({
 export class TestEntity2PrivacyPolicy extends EntityPrivacyPolicy<
   Test2Fields,
   string,
-  TestViewerContext,
+  ViewerContext,
   TestEntity2
 > {
   protected override readonly readRules = [
-    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, TestViewerContext, TestEntity2>(),
+    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, ViewerContext, TestEntity2>(),
   ];
   protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, TestViewerContext, TestEntity2>(),
+    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, ViewerContext, TestEntity2>(),
   ];
   protected override readonly updateRules = [
-    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, TestViewerContext, TestEntity2>(),
+    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, ViewerContext, TestEntity2>(),
   ];
   protected override readonly deleteRules = [
-    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, TestViewerContext, TestEntity2>(),
+    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, ViewerContext, TestEntity2>(),
   ];
 }
 
-export default class TestEntity2 extends Entity<Test2Fields, string, TestViewerContext> {
+export default class TestEntity2 extends Entity<Test2Fields, string, ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     Test2Fields,
     string,
-    TestViewerContext,
+    ViewerContext,
     TestEntity2,
     TestEntity2PrivacyPolicy
   > {

package/src/testfixtures/TestViewerContext.ts

@@ -1,14 +1,3 @@
-import { EntityQueryContext, EntityTransactionalQueryContext } from '../EntityQueryContext';
 import ViewerContext from '../ViewerContext';
 
-export default class TestViewerContext extends ViewerContext {
-  public getQueryContext(): EntityQueryContext {
-    return super.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres');
-  }
-
-  public async runInTransactionAsync<TResult>(
-    transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<TResult>
-  ): Promise<TResult> {
-    return await super.runInTransactionForDatabaseAdaptorFlavorAsync('postgres', transactionScope);
-  }
-}
+export default class TestViewerContext extends ViewerContext {}