feat!: make using non-enforcing entity loader explicit

expo · Jun 5, 2024 · 1c7d887 · 1c7d887
1 parent 778d9e3
commit 1c7d887
Show file tree

Hide file tree

Showing 18 changed files with 762 additions and 543 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
@@ -63,8 +63,9 @@ describe(GenericLocalMemoryCacher, () => {
     // simulate non existent db fetch, should write negative result ('') to cache
     const nonExistentId = uuidv4();
 
-    const entityNonExistentResult =
-      await LocalMemoryTestEntity.loader(viewerContext).loadByIDAsync(nonExistentId);
+    const entityNonExistentResult = await LocalMemoryTestEntity.loader(viewerContext)
+      .nonEnforcing()
+      .loadByIDAsync(nonExistentId);
     expect(entityNonExistentResult.ok).toBe(false);
 
     const nonExistentCachedResult = await entitySpecificGenericCacher.loadManyAsync([
@@ -75,12 +76,15 @@ describe(GenericLocalMemoryCacher, () => {
     });
 
     // load again through entities framework to ensure it reads negative result
-    const entityNonExistentResult2 =
-      await LocalMemoryTestEntity.loader(viewerContext).loadByIDAsync(nonExistentId);
+    const entityNonExistentResult2 = await LocalMemoryTestEntity.loader(viewerContext)
+      .nonEnforcing()
+      .loadByIDAsync(nonExistentId);
     expect(entityNonExistentResult2.ok).toBe(false);
 
     // invalidate from cache to ensure it invalidates correctly
-    await LocalMemoryTestEntity.loader(viewerContext).invalidateFieldsAsync(entity1.getAllFields());
+    await LocalMemoryTestEntity.loader(viewerContext)
+      .nonEnforcing()
+      .invalidateFieldsAsync(entity1.getAllFields());
     const cachedResultMiss = await entitySpecificGenericCacher.loadManyAsync([
       cacheKeyMaker('id', entity1.getID()),
     ]);
@@ -131,8 +135,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).loadByIDAsync(nonExistentId);
+    const entityNonExistentResult = await LocalMemoryTestEntity.loader(viewerContext)
+      .nonEnforcing()
+      .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
@@ -145,19 +145,23 @@ describe(GenericRedisCacher, () => {
 
     // simulate non existent db fetch, should write negative result ('') to cache
     const nonExistentId = uuidv4();
-    const entityNonExistentResult =
-      await RedisTestEntity.loader(viewerContext).loadByIDAsync(nonExistentId);
+    const entityNonExistentResult = await RedisTestEntity.loader(viewerContext)
+      .nonEnforcing()
+      .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).loadByIDAsync(nonExistentId);
+    const entityNonExistentResult2 = await RedisTestEntity.loader(viewerContext)
+      .nonEnforcing()
+      .loadByIDAsync(nonExistentId);
     expect(entityNonExistentResult2.ok).toBe(false);
 
     // invalidate from cache to ensure it invalidates correctly in both caches
-    await RedisTestEntity.loader(viewerContext).invalidateFieldsAsync(entity1.getAllFields());
+    await RedisTestEntity.loader(viewerContext)
+      .nonEnforcing()
+      .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
@@ -67,8 +67,9 @@ describe(GenericRedisCacher, () => {
     // simulate non existent db fetch, should write negative result ('') to cache
     const nonExistentId = uuidv4();
 
-    const entityNonExistentResult =
-      await RedisTestEntity.loader(viewerContext).loadByIDAsync(nonExistentId);
+    const entityNonExistentResult = await RedisTestEntity.loader(viewerContext)
+      .nonEnforcing()
+      .loadByIDAsync(nonExistentId);
     expect(entityNonExistentResult.ok).toBe(false);
 
     const nonExistentCachedValue = await (genericRedisCacheContext.redisClient as Redis).get(
@@ -77,12 +78,15 @@ describe(GenericRedisCacher, () => {
     expect(nonExistentCachedValue).toEqual('');
 
     // load again through entities framework to ensure it reads negative result
-    const entityNonExistentResult2 =
-      await RedisTestEntity.loader(viewerContext).loadByIDAsync(nonExistentId);
+    const entityNonExistentResult2 = await RedisTestEntity.loader(viewerContext)
+      .nonEnforcing()
+      .loadByIDAsync(nonExistentId);
     expect(entityNonExistentResult2.ok).toBe(false);
 
     // invalidate from cache to ensure it invalidates correctly
-    await RedisTestEntity.loader(viewerContext).invalidateFieldsAsync(entity1.getAllFields());
+    await RedisTestEntity.loader(viewerContext)
+      .nonEnforcing()
+      .invalidateFieldsAsync(entity1.getAllFields());
     const cachedValueNull = await (genericRedisCacheContext.redisClient as Redis).get(
       cacheKeyMaker('id', entity1.getID()),
     );

diff --git a/.../entity-database-adapter-knex/src/__integration-tests__/PostgresEntityIntegration-test.ts b/.../entity-database-adapter-knex/src/__integration-tests__/PostgresEntityIntegration-test.ts
@@ -1,7 +1,6 @@
 import {
   OrderByOrdering,
   createUnitTestEntityCompanionProvider,
-  enforceResultsAsync,
   ViewerContext,
   TransactionIsolationLevel,
 } from '@expo/entity';
@@ -92,7 +91,7 @@ describe('postgres entity integration', () => {
       PostgresTestEntity.creator(vc1).setField('name', 'hello').createAsync(),
     );
 
-    await enforceAsyncResult(PostgresTestEntity.loader(vc1).loadByIDAsync(firstEntity.getID()));
+    await PostgresTestEntity.loader(vc1).enforcing().loadByIDAsync(firstEntity.getID());
 
     const errorToThrow = new Error('Intentional error');
 
@@ -111,9 +110,9 @@ describe('postgres entity integration', () => {
       ),
     ).rejects.toEqual(errorToThrow);
 
-    const entities = await enforceResultsAsync(
-      PostgresTestEntity.loader(vc1).loadManyByFieldEqualingAsync('name', 'hello'),
-    );
+    const entities = await PostgresTestEntity.loader(vc1)
+      .enforcing()
+      .loadManyByFieldEqualingAsync('name', 'hello');
     expect(entities).toHaveLength(1);
   });
 

diff --git a/packages/entity-example/src/routers/notesRouter.ts b/packages/entity-example/src/routers/notesRouter.ts
@@ -30,7 +30,9 @@ router.get('/', async (ctx) => {
 
 router.get('/:id', async (ctx) => {
   const viewerContext = ctx.state.viewerContext;
-  const noteResult = await NoteEntity.loader(viewerContext).loadByIDAsync(ctx.params['id']!);
+  const noteResult = await NoteEntity.loader(viewerContext)
+    .nonEnforcing()
+    .loadByIDAsync(ctx.params['id']!);
   if (!noteResult.ok) {
     ctx.throw(403, noteResult.reason);
     return;
@@ -72,7 +74,9 @@ router.put('/:id', async (ctx) => {
   const viewerContext = ctx.state.viewerContext;
   const { title, body } = ctx.request.body as any;
 
-  const noteLoadResult = await NoteEntity.loader(viewerContext).loadByIDAsync(ctx.params['id']!);
+  const noteLoadResult = await NoteEntity.loader(viewerContext)
+    .nonEnforcing()
+    .loadByIDAsync(ctx.params['id']!);
   if (!noteLoadResult.ok) {
     ctx.throw(403, noteLoadResult.reason);
     return;
@@ -95,7 +99,9 @@ router.put('/:id', async (ctx) => {
 router.delete('/:id', async (ctx) => {
   const viewerContext = ctx.state.viewerContext;
 
-  const noteLoadResult = await NoteEntity.loader(viewerContext).loadByIDAsync(ctx.params['id']!);
+  const noteLoadResult = await NoteEntity.loader(viewerContext)
+    .nonEnforcing()
+    .loadByIDAsync(ctx.params['id']!);
   if (!noteLoadResult.ok) {
     ctx.throw(403, noteLoadResult.reason);
     return;

diff --git a/packages/entity/src/EnforcingEntityLoader.ts b/packages/entity/src/EnforcingEntityLoader.ts
@@ -3,15 +3,16 @@ import {
   QuerySelectionModifiers,
   QuerySelectionModifiersWithOrderByRaw,
 } from './EntityDatabaseAdapter';
-import EntityLoader from './EntityLoader';
 import EntityPrivacyPolicy from './EntityPrivacyPolicy';
+import NonEnforcingEntityLoader from './NonEnforcingEntityLoader';
 import ReadonlyEntity from './ReadonlyEntity';
 import ViewerContext from './ViewerContext';
 import { mapMap } from './utils/collections/maps';
 
 /**
- * Enforcing view on an entity loader. All loads through this loader will throw
- * if the loads are not successful.
+ * Enforcing entity loader. All normal loads are batched,
+ * cached, and authorized against the entity's EntityPrivacyPolicy. All loads
+ * through this loader will throw if the load is not successful.
  */
 export default class EnforcingEntityLoader<
   TFields extends object,
@@ -28,7 +29,7 @@ export default class EnforcingEntityLoader<
   TSelectedFields extends keyof TFields,
 > {
   constructor(
-    private readonly entityLoader: EntityLoader<
+    private readonly entityLoader: NonEnforcingEntityLoader<
       TFields,
       TID,
       TViewerContext,

diff --git a/packages/entity/src/EntityAssociationLoader.ts b/packages/entity/src/EntityAssociationLoader.ts
@@ -76,7 +76,9 @@ export default class EntityAssociationLoader<
       .getLoaderFactory()
       .forLoad(queryContext, { previousValue: null, cascadingDeleteCause: null });
 
-    return (await loader.loadByIDAsync(associatedEntityID as unknown as TAssociatedID)) as Result<
+    return (await loader
+      .nonEnforcing()
+      .loadByIDAsync(associatedEntityID as unknown as TAssociatedID)) as Result<
       null extends TFields[TIdentifyingField] ? TAssociatedEntity | null : TAssociatedEntity
     >;
   }
@@ -129,10 +131,9 @@ export default class EntityAssociationLoader<
       .getViewerScopedEntityCompanionForClass(associatedEntityClass)
       .getLoaderFactory()
       .forLoad(queryContext, { previousValue: null, cascadingDeleteCause: null });
-    return await loader.loadManyByFieldEqualingAsync(
-      associatedEntityFieldContainingThisID,
-      thisID as any,
-    );
+    return await loader
+      .nonEnforcing()
+      .loadManyByFieldEqualingAsync(associatedEntityFieldContainingThisID, thisID as any);
   }
 
   /**
@@ -186,10 +187,9 @@ export default class EntityAssociationLoader<
       .getViewerScopedEntityCompanionForClass(associatedEntityClass)
       .getLoaderFactory()
       .forLoad(queryContext, { previousValue: null, cascadingDeleteCause: null });
-    return await loader.loadByFieldEqualingAsync(
-      associatedEntityLookupByField,
-      associatedFieldValue as any,
-    );
+    return await loader
+      .nonEnforcing()
+      .loadByFieldEqualingAsync(associatedEntityLookupByField, associatedFieldValue as any);
   }
 
   /**
@@ -244,10 +244,9 @@ export default class EntityAssociationLoader<
       .getViewerScopedEntityCompanionForClass(associatedEntityClass)
       .getLoaderFactory()
       .forLoad(queryContext, { previousValue: null, cascadingDeleteCause: null });
-    return await loader.loadManyByFieldEqualingAsync(
-      associatedEntityLookupByField,
-      associatedFieldValue as any,
-    );
+    return await loader
+      .nonEnforcing()
+      .loadManyByFieldEqualingAsync(associatedEntityLookupByField, associatedFieldValue as any);
   }
 
   /**