fix: Revert: require explicit query context specification (#219)

This reverts commit 8b0b31f.
expo · Apr 11, 2024 · 1bdfbd6 · 1bdfbd6
1 parent 0fa6f55
commit 1bdfbd6
Show file tree

Hide file tree

Showing 46 changed files with 755 additions and 1,598 deletions.
diff --git a/...ges/entity-cache-adapter-local-memory/src/__tests__/GenericLocalMemoryCacher-full-test.ts b/...ges/entity-cache-adapter-local-memory/src/__tests__/GenericLocalMemoryCacher-full-test.ts
@@ -25,19 +25,13 @@ describe(GenericLocalMemoryCacher, () => {
     const cacheKeyMaker = genericCacher['makeCacheKey'].bind(genericCacher);
 
     const date = new Date();
-    const entity1Created = await LocalMemoryTestEntity.creator(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    )
+    const entity1Created = await LocalMemoryTestEntity.creator(viewerContext)
       .setField('name', 'blah')
       .setField('dateField', date)
       .enforceCreateAsync();
 
     // loading an entity should put it in cache
-    const entity1 = await LocalMemoryTestEntity.loader(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    )
+    const entity1 = await LocalMemoryTestEntity.loader(viewerContext)
       .enforcing()
       .loadByIDAsync(entity1Created.getID());
 
@@ -69,10 +63,9 @@ describe(GenericLocalMemoryCacher, () => {
     // simulate non existent db fetch, should write negative result ('') to cache
     const nonExistentId = uuidv4();
 
-    const entityNonExistentResult = await LocalMemoryTestEntity.loader(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    ).loadByIDAsync(nonExistentId);
+    const entityNonExistentResult = await LocalMemoryTestEntity.loader(viewerContext).loadByIDAsync(
+      nonExistentId
+    );
     expect(entityNonExistentResult.ok).toBe(false);
 
     const nonExistentCachedResult = await entitySpecificGenericCacher.loadManyAsync([
@@ -84,16 +77,12 @@ describe(GenericLocalMemoryCacher, () => {
 
     // load again through entities framework to ensure it reads negative result
     const entityNonExistentResult2 = await LocalMemoryTestEntity.loader(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
+      viewerContext
     ).loadByIDAsync(nonExistentId);
     expect(entityNonExistentResult2.ok).toBe(false);
 
     // invalidate from cache to ensure it invalidates correctly
-    await LocalMemoryTestEntity.loader(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    ).invalidateFieldsAsync(entity1.getAllFields());
+    await LocalMemoryTestEntity.loader(viewerContext).invalidateFieldsAsync(entity1.getAllFields());
     const cachedResultMiss = await entitySpecificGenericCacher.loadManyAsync([
       cacheKeyMaker('id', entity1.getID()),
     ]);
@@ -111,19 +100,13 @@ describe(GenericLocalMemoryCacher, () => {
     const cacheKeyMaker = genericCacher['makeCacheKey'].bind(genericCacher);
 
     const date = new Date();
-    const entity1Created = await LocalMemoryTestEntity.creator(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    )
+    const entity1Created = await LocalMemoryTestEntity.creator(viewerContext)
       .setField('name', 'blah')
       .setField('dateField', date)
       .enforceCreateAsync();
 
     // loading an entity will try to put it in cache but it's a noop cache, so it should be a miss
-    const entity1 = await LocalMemoryTestEntity.loader(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    )
+    const entity1 = await LocalMemoryTestEntity.loader(viewerContext)
       .enforcing()
       .loadByIDAsync(entity1Created.getID());
 
@@ -150,10 +133,9 @@ describe(GenericLocalMemoryCacher, () => {
     // a non existent db fetch should try to write negative result ('') but it's a noop cache, so it should be a miss
     const nonExistentId = uuidv4();
 
-    const entityNonExistentResult = await LocalMemoryTestEntity.loader(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    ).loadByIDAsync(nonExistentId);
+    const entityNonExistentResult = await LocalMemoryTestEntity.loader(viewerContext).loadByIDAsync(
+      nonExistentId
+    );
     expect(entityNonExistentResult.ok).toBe(false);
 
     const nonExistentCachedResult = await entitySpecificGenericCacher.loadManyAsync([

diff --git a/...ache-adapter-redis/src/__integration-tests__/BatchedRedisCacheAdapter-integration-test.ts b/...ache-adapter-redis/src/__integration-tests__/BatchedRedisCacheAdapter-integration-test.ts
@@ -101,10 +101,7 @@ describe(GenericRedisCacher, () => {
       ]['cacheAdapter']['genericCacher'];
     const cacheKeyMaker = genericCacher['makeCacheKey'].bind(genericCacher);
 
-    const entity1Created = await RedisTestEntity.creator(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    )
+    const entity1Created = await RedisTestEntity.creator(viewerContext)
       .setField('name', 'blah')
       .enforceCreateAsync();
 
@@ -120,22 +117,9 @@ describe(GenericRedisCacher, () => {
       createRedisIntegrationTestEntityCompanionProvider(genericRedisCacheContext)
     );
     const [entity1, entity2, entity3] = await Promise.all([
-      RedisTestEntity.loader(
-        viewerContext1,
-        viewerContext1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
-        .enforcing()
-        .loadByIDAsync(entity1Created.getID()),
-      RedisTestEntity.loader(
-        viewerContext2,
-        viewerContext2.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
-        .enforcing()
-        .loadByIDAsync(entity1Created.getID()),
-      RedisTestEntity.loader(
-        viewerContext3,
-        viewerContext3.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
+      RedisTestEntity.loader(viewerContext1).enforcing().loadByIDAsync(entity1Created.getID()),
+      RedisTestEntity.loader(viewerContext2).enforcing().loadByIDAsync(entity1Created.getID()),
+      RedisTestEntity.loader(viewerContext3)
         .enforcing()
         .loadByFieldEqualingAsync('name', entity1Created.getField('name')),
     ]);
@@ -154,36 +138,28 @@ describe(GenericRedisCacher, () => {
     });
 
     const cacheKeyEntity1NameField = cacheKeyMaker('name', entity1Created.getField('name'));
-    await RedisTestEntity.loader(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    )
+    await RedisTestEntity.loader(viewerContext)
       .enforcing()
       .loadByFieldEqualingAsync('name', entity1Created.getField('name'));
     await expect(redis.get(cacheKeyEntity1NameField)).resolves.toEqual(cachedJSON);
 
     // simulate non existent db fetch, should write negative result ('') to cache
     const nonExistentId = uuidv4();
-    const entityNonExistentResult = await RedisTestEntity.loader(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    ).loadByIDAsync(nonExistentId);
+    const entityNonExistentResult = await RedisTestEntity.loader(viewerContext).loadByIDAsync(
+      nonExistentId
+    );
     expect(entityNonExistentResult.ok).toBe(false);
     const cacheKeyNonExistent = cacheKeyMaker('id', nonExistentId);
     const nonExistentCachedValue = await redis.get(cacheKeyNonExistent);
     expect(nonExistentCachedValue).toEqual('');
     // load again through entities framework to ensure it reads negative result
-    const entityNonExistentResult2 = await RedisTestEntity.loader(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    ).loadByIDAsync(nonExistentId);
+    const entityNonExistentResult2 = await RedisTestEntity.loader(viewerContext).loadByIDAsync(
+      nonExistentId
+    );
     expect(entityNonExistentResult2.ok).toBe(false);
 
     // invalidate from cache to ensure it invalidates correctly in both caches
-    await RedisTestEntity.loader(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    ).invalidateFieldsAsync(entity1.getAllFields());
+    await RedisTestEntity.loader(viewerContext).invalidateFieldsAsync(entity1.getAllFields());
     await expect(redis.get(cacheKeyEntity1)).resolves.toBeNull();
     await expect(redis.get(cacheKeyEntity1NameField)).resolves.toBeNull();
   });

diff --git a/...cache-adapter-redis/src/__integration-tests__/GenericRedisCacher-full-integration-test.ts b/...cache-adapter-redis/src/__integration-tests__/GenericRedisCacher-full-integration-test.ts
@@ -46,18 +46,12 @@ describe(GenericRedisCacher, () => {
       ]['cacheAdapter']['genericCacher'];
     const cacheKeyMaker = genericCacher['makeCacheKey'].bind(genericCacher);
 
-    const entity1Created = await RedisTestEntity.creator(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    )
+    const entity1Created = await RedisTestEntity.creator(viewerContext)
       .setField('name', 'blah')
       .enforceCreateAsync();
 
     // loading an entity should put it in cache
-    const entity1 = await RedisTestEntity.loader(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    )
+    const entity1 = await RedisTestEntity.loader(viewerContext)
       .enforcing()
       .loadByIDAsync(entity1Created.getID());
 
@@ -73,10 +67,9 @@ describe(GenericRedisCacher, () => {
     // simulate non existent db fetch, should write negative result ('') to cache
     const nonExistentId = uuidv4();
 
-    const entityNonExistentResult = await RedisTestEntity.loader(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    ).loadByIDAsync(nonExistentId);
+    const entityNonExistentResult = await RedisTestEntity.loader(viewerContext).loadByIDAsync(
+      nonExistentId
+    );
     expect(entityNonExistentResult.ok).toBe(false);
 
     const nonExistentCachedValue = await (genericRedisCacheContext.redisClient as Redis).get(
@@ -85,17 +78,13 @@ describe(GenericRedisCacher, () => {
     expect(nonExistentCachedValue).toEqual('');
 
     // load again through entities framework to ensure it reads negative result
-    const entityNonExistentResult2 = await RedisTestEntity.loader(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    ).loadByIDAsync(nonExistentId);
+    const entityNonExistentResult2 = await RedisTestEntity.loader(viewerContext).loadByIDAsync(
+      nonExistentId
+    );
     expect(entityNonExistentResult2.ok).toBe(false);
 
     // invalidate from cache to ensure it invalidates correctly
-    await RedisTestEntity.loader(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    ).invalidateFieldsAsync(entity1.getAllFields());
+    await RedisTestEntity.loader(viewerContext).invalidateFieldsAsync(entity1.getAllFields());
     const cachedValueNull = await (genericRedisCacheContext.redisClient as Redis).get(
       cacheKeyMaker('id', entity1.getID())
     );
@@ -108,19 +97,11 @@ describe(GenericRedisCacher, () => {
     );
     const date = new Date();
     const entity1 = await enforceAsyncResult(
-      RedisTestEntity.creator(
-        viewerContext,
-        viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
-        .setField('dateField', date)
-        .createAsync()
+      RedisTestEntity.creator(viewerContext).setField('dateField', date).createAsync()
     );
     expect(entity1.getField('dateField')).toEqual(date);
 
-    const entity2 = await RedisTestEntity.loader(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    )
+    const entity2 = await RedisTestEntity.loader(viewerContext)
       .enforcing()
       .loadByIDAsync(entity1.getID());
     expect(entity2.getField('dateField')).toEqual(date);
@@ -129,12 +110,7 @@ describe(GenericRedisCacher, () => {
     const vc2 = new TestViewerContext(
       createRedisIntegrationTestEntityCompanionProvider(genericRedisCacheContext)
     );
-    const entity3 = await RedisTestEntity.loader(
-      vc2,
-      vc2.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    )
-      .enforcing()
-      .loadByIDAsync(entity1.getID());
+    const entity3 = await RedisTestEntity.loader(vc2).enforcing().loadByIDAsync(entity1.getID());
     expect(entity3.getField('dateField')).toEqual(date);
   });
 
@@ -143,17 +119,9 @@ describe(GenericRedisCacher, () => {
       createRedisIntegrationTestEntityCompanionProvider(genericRedisCacheContext)
     );
     const entity1 = await enforceAsyncResult(
-      RedisTestEntity.creator(
-        viewerContext,
-        viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
-        .setField('name', '')
-        .createAsync()
+      RedisTestEntity.creator(viewerContext).setField('name', '').createAsync()
     );
-    const entity2 = await RedisTestEntity.loader(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    )
+    const entity2 = await RedisTestEntity.loader(viewerContext)
       .enforcing()
       .loadByFieldEqualingAsync('name', '');
     expect(entity2?.getID()).toEqual(entity1.getID());
@@ -162,10 +130,7 @@ describe(GenericRedisCacher, () => {
     const vc2 = new TestViewerContext(
       createRedisIntegrationTestEntityCompanionProvider(genericRedisCacheContext)
     );
-    const entity3 = await RedisTestEntity.loader(
-      vc2,
-      vc2.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    )
+    const entity3 = await RedisTestEntity.loader(vc2)
       .enforcing()
       .loadByFieldEqualingAsync('name', '');
     expect(entity3?.getID()).toEqual(entity1.getID());

diff --git a/...tity-cache-adapter-redis/src/__integration-tests__/GenericRedisCacher-integration-test.ts b/...tity-cache-adapter-redis/src/__integration-tests__/GenericRedisCacher-integration-test.ts
@@ -46,10 +46,7 @@ describe(GenericRedisCacher, () => {
       redisTestEntityConfiguration
     );
     const date = new Date();
-    const entity1Created = await RedisTestEntity.creator(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    )
+    const entity1Created = await RedisTestEntity.creator(viewerContext)
       .setField('name', 'blah')
       .setField('dateField', date)
       .enforceCreateAsync();
@@ -95,10 +92,7 @@ describe(GenericRedisCacher, () => {
       redisTestEntityConfiguration
     );
     const date = new Date();
-    const entity1Created = await RedisTestEntity.creator(
-      viewerContext,
-      viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    )
+    const entity1Created = await RedisTestEntity.creator(viewerContext)
       .setField('name', 'blah')
       .setField('dateField', date)
       .enforceCreateAsync();

diff --git a/packages/entity-cache-adapter-redis/src/__integration-tests__/errors-test.ts b/packages/entity-cache-adapter-redis/src/__integration-tests__/errors-test.ts
@@ -40,12 +40,7 @@ describe(GenericRedisCacher, () => {
     );
 
     await expect(
-      RedisTestEntity.creator(
-        vc1,
-        vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
-        .setField('name', 'blah')
-        .enforceCreateAsync()
+      RedisTestEntity.creator(vc1).setField('name', 'blah').enforceCreateAsync()
     ).rejects.toThrow(EntityCacheAdapterTransientError);
   });
 });