feat!: move knex loaders into entity-database-adapter-knex package

.ctirc

@@ -7,44 +7,42 @@
     {
       "project": "packages/entity/tsconfig.json",
       "output": "packages/entity/src",
-      "exclude": [
-        "**/__testfixtures__/**",
-        "**/__tests__/**"
-      ]
+      "exclude": [ "**/__testfixtures__/**", "**/__tests__/**" ]
     },
     {
       "project": "packages/entity-cache-adapter-local-memory/tsconfig.json",
       "output": "packages/entity-cache-adapter-local-memory/src",
-      "exclude": [ "**/__testfixtures__/**" ]
+      "exclude": [ "**/__testfixtures__/**", "**/__tests__/**" ]
     },
     {
       "project": "packages/entity-cache-adapter-redis/tsconfig.json",
       "output": "packages/entity-cache-adapter-redis/src",
-      "exclude": [ "**/__testfixtures__/**" ]
+      "exclude": [ "**/__testfixtures__/**", "**/__tests__/**" ]
     },
     {
       "project": "packages/entity-database-adapter-knex/tsconfig.json",
       "output": "packages/entity-database-adapter-knex/src",
-      "exclude": [ "**/__testfixtures__/**" ]
+      "exclude": [ "**/__testfixtures__/**", "**/__tests__/**" ]
     },
     {
       "project": "packages/entity-ip-address-field/tsconfig.json",
       "output": "packages/entity-ip-address-field/src",
+      "exclude": [ "**/__testfixtures__/**", "**/__tests__/**" ]
     },
     {
       "project": "packages/entity-secondary-cache-local-memory/tsconfig.json",
       "output": "packages/entity-secondary-cache-local-memory/src",
-      "exclude": [ "**/__tests__/**" ]
+      "exclude": [ "**/__testfixtures__/**", "**/__tests__/**" ]
     },
     {
       "project": "packages/entity-secondary-cache-redis/tsconfig.json",
       "output": "packages/entity-secondary-cache-redis/src",
-      "exclude": [ "**/__testfixtures__/**" ]
+      "exclude": [ "**/__testfixtures__/**", "**/__tests__/**" ]
     },
     {
       "project": "packages/entity-testing-utils/tsconfig.json",
       "output": "packages/entity-testing-utils/src",
-      "exclude": [ "**/__testfixtures__/**" ]
+      "exclude": [ "**/__testfixtures__/**", "**/__tests__/**" ]
     }
   ]
 }

packages/entity-cache-adapter-local-memory/src/__tests__/GenericLocalMemoryCacher-full-test.ts

@@ -1,5 +1,6 @@
 import {
   CacheStatus,
+  GenericEntityCacheAdapter,
   IEntityGenericCacher,
   SingleFieldHolder,
   SingleFieldValueHolder,
@@ -23,12 +24,11 @@ describe(GenericLocalMemoryCacher, () => {
   it('has correct caching behavior', async () => {
     const entityCompanionProvider = createLocalMemoryTestEntityCompanionProvider();
     const viewerContext = new ViewerContext(entityCompanionProvider);
-    const genericCacher = viewerContext.entityCompanionProvider.getCompanionForEntity(
-      LocalMemoryTestEntity,
-    )['tableDataCoordinator']['cacheAdapter']['genericCacher'] as IEntityGenericCacher<
-      LocalMemoryTestEntityFields,
-      'id'
-    >;
+    const genericCacher = (
+      viewerContext.entityCompanionProvider.getCompanionForEntity(LocalMemoryTestEntity)[
+        'tableDataCoordinator'
+      ]['cacheAdapter'] as GenericEntityCacheAdapter<LocalMemoryTestEntityFields, 'id'>
+    )['genericCacher'];
 
     const date = new Date();
     const entity1Created = await LocalMemoryTestEntity.creator(viewerContext)
@@ -105,7 +105,7 @@ describe(GenericLocalMemoryCacher, () => {
     expect(entityNonExistentResult2.ok).toBe(false);
 
     // invalidate from cache to ensure it invalidates correctly
-    await LocalMemoryTestEntity.loaderUtils(viewerContext).invalidateFieldsAsync(
+    await LocalMemoryTestEntity.invalidationUtils(viewerContext).invalidateFieldsAsync(
       entity1.getAllFields(),
     );
     const keys = genericCacher.makeCacheKeysForInvalidation(
@@ -121,12 +121,11 @@ describe(GenericLocalMemoryCacher, () => {
   it('respects the parameters of a noop cache', async () => {
     const entityCompanionProvider = createNoOpLocalMemoryIntegrationTestEntityCompanionProvider();
     const viewerContext = new ViewerContext(entityCompanionProvider);
-    const genericCacher = viewerContext.entityCompanionProvider.getCompanionForEntity(
-      LocalMemoryTestEntity,
-    )['tableDataCoordinator']['cacheAdapter']['genericCacher'] as IEntityGenericCacher<
-      LocalMemoryTestEntityFields,
-      'id'
-    >;
+    const genericCacher = (
+      viewerContext.entityCompanionProvider.getCompanionForEntity(LocalMemoryTestEntity)[
+        'tableDataCoordinator'
+      ]['cacheAdapter'] as GenericEntityCacheAdapter<LocalMemoryTestEntityFields, 'id'>
+    )['genericCacher'];
     const cacheKeyMaker = genericCacher['makeCacheKeyForStorage'].bind(genericCacher);
 
     const date = new Date();

packages/entity-cache-adapter-redis/src/__integration-tests__/BatchedRedisCacheAdapter-integration-test.ts

@@ -1,6 +1,6 @@
 import { Batcher } from '@expo/batcher';
 import {
-  IEntityGenericCacher,
+  GenericEntityCacheAdapter,
   SingleFieldHolder,
   SingleFieldValueHolder,
   ViewerContext,
@@ -109,12 +109,11 @@ describe(GenericRedisCacher, () => {
 
     const mgetSpy = jest.spyOn(redis, 'mget');
 
-    const genericCacher = viewerContext.entityCompanionProvider.getCompanionForEntity(
-      RedisTestEntity,
-    )['tableDataCoordinator']['cacheAdapter']['genericCacher'] as IEntityGenericCacher<
-      RedisTestEntityFields,
-      'id'
-    >;
+    const genericCacher = (
+      viewerContext.entityCompanionProvider.getCompanionForEntity(RedisTestEntity)[
+        'tableDataCoordinator'
+      ]['cacheAdapter'] as GenericEntityCacheAdapter<RedisTestEntityFields, 'id'>
+    )['genericCacher'];
 
     const entity1Created = await RedisTestEntity.creator(viewerContext)
       .setField('name', 'blah')
@@ -187,7 +186,9 @@ describe(GenericRedisCacher, () => {
     expect(entityNonExistentResult2.ok).toBe(false);
 
     // invalidate from cache to ensure it invalidates correctly in both caches
-    await RedisTestEntity.loaderUtils(viewerContext).invalidateFieldsAsync(entity1.getAllFields());
+    await RedisTestEntity.invalidationUtils(viewerContext).invalidateFieldsAsync(
+      entity1.getAllFields(),
+    );
     await expect(redis.get(cacheKeyEntity1)).resolves.toBeNull();
     await expect(redis.get(cacheKeyEntity1NameField)).resolves.toBeNull();
   });

packages/entity-cache-adapter-redis/src/__integration-tests__/GenericRedisCacher-full-integration-test.ts

@@ -1,7 +1,7 @@
 import {
   CompositeFieldHolder,
   CompositeFieldValueHolder,
-  IEntityGenericCacher,
+  GenericEntityCacheAdapter,
   SingleFieldHolder,
   SingleFieldValueHolder,
   ViewerContext,
@@ -55,12 +55,11 @@ describe(GenericRedisCacher, () => {
     const viewerContext = new TestViewerContext(
       createRedisIntegrationTestEntityCompanionProvider(genericRedisCacheContext),
     );
-    const genericCacher = viewerContext.entityCompanionProvider.getCompanionForEntity(
-      RedisTestEntity,
-    )['tableDataCoordinator']['cacheAdapter']['genericCacher'] as IEntityGenericCacher<
-      RedisTestEntityFields,
-      'id'
-    >;
+    const genericCacher = (
+      viewerContext.entityCompanionProvider.getCompanionForEntity(RedisTestEntity)[
+        'tableDataCoordinator'
+      ]['cacheAdapter'] as GenericEntityCacheAdapter<RedisTestEntityFields, 'id'>
+    )['genericCacher'];
 
     const entity1Created = await RedisTestEntity.creator(viewerContext)
       .setField('name', 'blah')
@@ -144,7 +143,9 @@ describe(GenericRedisCacher, () => {
     expect(entityNonExistentCompositeResult2).toBe(null);
 
     // invalidate from cache to ensure it invalidates correctly
-    await RedisTestEntity.loaderUtils(viewerContext).invalidateFieldsAsync(entity1.getAllFields());
+    await RedisTestEntity.invalidationUtils(viewerContext).invalidateFieldsAsync(
+      entity1.getAllFields(),
+    );
     const cachedValueNullKeys = genericCacher.makeCacheKeysForInvalidation(
       new SingleFieldHolder('id'),
       new SingleFieldValueHolder(entity1.getID()),

packages/entity-database-adapter-knex/package.json

@@ -35,6 +35,7 @@
     "@expo/entity-testing-utils": "workspace:^",
     "@jest/globals": "30.2.0",
     "pg": "8.18.0",
+    "ts-mockito": "2.6.1",
     "typescript": "5.9.3"
   }
 }

packages/entity/src/AuthorizationResultBasedKnexEntityLoader.ts → packages/entity-database-adapter-knex/src/AuthorizationResultBasedKnexEntityLoader.ts

@@ -1,18 +1,20 @@
+import {
+  EntityConstructionUtils,
+  EntityPrivacyPolicy,
+  EntityQueryContext,
+  ReadonlyEntity,
+  ViewerContext,
+  IEntityMetricsAdapter,
+} from '@expo/entity';
 import { Result } from '@expo/results';
 
 import {
   FieldEqualityCondition,
   isSingleValueFieldEqualityCondition,
   QuerySelectionModifiers,
   QuerySelectionModifiersWithOrderByRaw,
-} from './EntityDatabaseAdapter';
-import { EntityLoaderUtils } from './EntityLoaderUtils';
-import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
-import { EntityQueryContext } from './EntityQueryContext';
-import { ReadonlyEntity } from './ReadonlyEntity';
-import { ViewerContext } from './ViewerContext';
+} from './BasePostgresEntityDatabaseAdapter';
 import { EntityKnexDataManager } from './internal/EntityKnexDataManager';
-import { IEntityMetricsAdapter } from './metrics/IEntityMetricsAdapter';
 
 /**
  * Authorization-result-based knex entity loader for non-data-loader-based load methods.
@@ -38,7 +40,7 @@ export class AuthorizationResultBasedKnexEntityLoader<
     private readonly queryContext: EntityQueryContext,
     private readonly knexDataManager: EntityKnexDataManager<TFields, TIDField>,
     protected readonly metricsAdapter: IEntityMetricsAdapter,
-    public readonly utils: EntityLoaderUtils<
+    public readonly constructionUtils: EntityConstructionUtils<
       TFields,
       TIDField,
       TViewerContext,
@@ -77,15 +79,15 @@ export class AuthorizationResultBasedKnexEntityLoader<
       const fieldValues = isSingleValueFieldEqualityCondition(fieldEqualityOperand)
         ? [fieldEqualityOperand.fieldValue]
         : fieldEqualityOperand.fieldValues;
-      this.utils.validateFieldAndValues(fieldEqualityOperand.fieldName, fieldValues);
+      this.constructionUtils.validateFieldAndValues(fieldEqualityOperand.fieldName, fieldValues);
     }
 
     const fieldObjects = await this.knexDataManager.loadManyByFieldEqualityConjunctionAsync(
       this.queryContext,
       fieldEqualityOperands,
       querySelectionModifiers,
     );
-    return await this.utils.constructAndAuthorizeEntitiesArrayAsync(fieldObjects);
+    return await this.constructionUtils.constructAndAuthorizeEntitiesArrayAsync(fieldObjects);
   }
 
   /**
@@ -104,6 +106,6 @@ export class AuthorizationResultBasedKnexEntityLoader<
       bindings,
       querySelectionModifiers,
     );
-    return await this.utils.constructAndAuthorizeEntitiesArrayAsync(fieldObjects);
+    return await this.constructionUtils.constructAndAuthorizeEntitiesArrayAsync(fieldObjects);
   }
 }