@expo/entity-database-adapter-knex 0.62.0 → 0.64.0

package/src/SQLOperator.ts

@@ -1,4 +1,5 @@
 import assert from 'assert';
+import type { Knex } from 'knex';
 
 /**
  * Supported SQL value types that can be safely parameterized.
@@ -12,7 +13,6 @@ export type SupportedSQLValue =
   | Date
   | Buffer
   | bigint
-  | undefined // Will be treated as NULL
   | readonly SupportedSQLValue[] // For IN clauses and array types
   | Readonly<{ [key: string]: unknown }>; // For JSON/JSONB columns
 
@@ -41,7 +41,7 @@ export class SQLFragment<TFields extends Record<string, any>> {
    */
   getKnexBindings(
     getColumnForField: (fieldName: keyof TFields) => string,
-  ): readonly SupportedSQLValue[] {
+  ): readonly Knex.RawBinding[] {
     return this.bindings.map((b) => {
       switch (b.type) {
         case 'entityField':
@@ -49,7 +49,10 @@ export class SQLFragment<TFields extends Record<string, any>> {
         case 'identifier':
           return b.name;
         case 'value':
-          return b.value;
+          // Needs a cast since bigint is supported by knex postgres dialect but not all dialects, and thus isn't included
+          // in the type. Because we only use the postgres dialect in this adapter, it's safe to allow it here.
+          // https://github.com/knex/knex/issues/5013#issuecomment-3368744254
+          return b.value as Knex.RawBinding;
       }
     });
   }
@@ -133,8 +136,8 @@ export class SQLFragment<TFields extends Record<string, any>> {
    * Handles all SupportedSQLValue types.
    */
   private static formatDebugValue(value: SupportedSQLValue): string {
-    // Handle null and undefined
-    if (value === null || value === undefined) {
+    // Handle null
+    if (value === null) {
       return 'NULL';
     }
 
@@ -303,7 +306,7 @@ export function sql<TFields extends Record<string, any>>(
   strings.forEach((string, i) => {
     sqlString += string;
     if (i < values.length) {
-      const value = values[i];
+      const value = values[i]!;
 
       if (value instanceof SQLFragment) {
         // Handle nested SQL fragments
@@ -344,7 +347,7 @@ type PickSupportedSQLValueKeys<T> = {
 }[keyof T];
 
 type PickStringValueKeys<T> = {
-  [K in keyof T]: T[K] extends string | null | undefined ? K : never;
+  [K in keyof T]: T[K] extends string | null ? K : never;
 }[keyof T];
 
 type JsonSerializable =
@@ -368,13 +371,13 @@ export class SQLChainableFragment<
 > extends SQLFragment<TFields> {
   /**
    * Generates an equality condition (`= value`).
-   * Automatically converts `null`/`undefined` to `IS NULL`.
+   * Automatically converts `null` to `IS NULL`.
    *
    * @param value - The value to compare against
    * @returns A {@link SQLFragment} representing the equality condition
    */
-  eq(value: TValue | null | undefined): SQLFragment<TFields> {
-    if (value === null || value === undefined) {
+  eq(value: TValue | null): SQLFragment<TFields> {
+    if (value === null) {
       return this.isNull();
     }
     return sql`${this} = ${value}`;
@@ -382,13 +385,13 @@ export class SQLChainableFragment<
 
   /**
    * Generates an inequality condition (`!= value`).
-   * Automatically converts `null`/`undefined` to `IS NOT NULL`.
+   * Automatically converts `null` to `IS NOT NULL`.
    *
    * @param value - The value to compare against
    * @returns A {@link SQLFragment} representing the inequality condition
    */
-  neq(value: TValue | null | undefined): SQLFragment<TFields> {
-    if (value === null || value === undefined) {
+  neq(value: TValue | null): SQLFragment<TFields> {
+    if (value === null) {
       return this.isNotNull();
     }
     return sql`${this} != ${value}`;
@@ -635,9 +638,7 @@ type ExtractFragmentFields<T> = T extends SQLFragment<infer F> ? F : never;
 // Conditional value types for expression overloads.
 // Uses SQLChainableFragment<any, ...> so that TExpr alone drives inference (single type param).
 type FragmentValueNullable<TFragment> =
-  TFragment extends SQLChainableFragment<any, infer TValue>
-    ? TValue | null | undefined
-    : SupportedSQLValue;
+  TFragment extends SQLChainableFragment<any, infer TValue> ? TValue | null : SupportedSQLValue;
 
 type FragmentValue<TFragment> =
   TFragment extends SQLChainableFragment<any, infer TValue> ? TValue : SupportedSQLValue;
@@ -950,7 +951,7 @@ function isNotNullHelper<TFields extends Record<string, any>>(
 
 /**
  * Generates an equality condition (`= value`) from a fragment.
- * Automatically converts `null`/`undefined` to `IS NULL`.
+ * Automatically converts `null` to `IS NULL`.
  *
  * @param fragment - A SQLFragment or SQLChainableFragment to compare
  * @param value - The value to compare against
@@ -961,7 +962,7 @@ function eqHelper<TFragment extends SQLFragment<any>>(
 ): SQLFragment<ExtractFragmentFields<TFragment>>;
 /**
  * Generates an equality condition (`= value`) from a field name.
- * Automatically converts `null`/`undefined` to `IS NULL`.
+ * Automatically converts `null` to `IS NULL`.
  *
  * @param fieldName - The entity field name to compare
  * @param value - The value to compare against
@@ -979,7 +980,7 @@ function eqHelper<TFields extends Record<string, any>>(
 
 /**
  * Generates an inequality condition (`!= value`) from a fragment.
- * Automatically converts `null`/`undefined` to `IS NOT NULL`.
+ * Automatically converts `null` to `IS NOT NULL`.
  *
  * @param fragment - A SQLFragment or SQLChainableFragment to compare
  * @param value - The value to compare against
@@ -990,7 +991,7 @@ function neqHelper<TFragment extends SQLFragment<any>>(
 ): SQLFragment<ExtractFragmentFields<TFragment>>;
 /**
  * Generates an inequality condition (`!= value`) from a field name.
- * Automatically converts `null`/`undefined` to `IS NOT NULL`.
+ * Automatically converts `null` to `IS NOT NULL`.
  *
  * @param fieldName - The entity field name to compare
  * @param value - The value to compare against
@@ -1521,12 +1522,12 @@ export const SQLExpression = {
   isNotNull: isNotNullHelper,
 
   /**
-   * Equality operator. Automatically converts null/undefined to IS NULL.
+   * Equality operator. Automatically converts null to IS NULL.
    */
   eq: eqHelper,
 
   /**
-   * Inequality operator. Automatically converts null/undefined to IS NOT NULL.
+   * Inequality operator. Automatically converts null to IS NOT NULL.
    */
   neq: neqHelper,
 

package/src/__integration-tests__/PostgresEntityIntegration-test.ts

@@ -959,6 +959,103 @@ describe('postgres entity integration', () => {
     });
   });
 
+  describe('counting with countBySQLAsync', () => {
+    it('counts entities matching a SQL fragment', async () => {
+      const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+
+      await enforceAsyncResult(
+        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
+          .setField('name', 'Alice')
+          .setField('hasACat', true)
+          .setField('hasADog', false)
+          .createAsync(),
+      );
+
+      await enforceAsyncResult(
+        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
+          .setField('name', 'Bob')
+          .setField('hasACat', false)
+          .setField('hasADog', true)
+          .createAsync(),
+      );
+
+      await enforceAsyncResult(
+        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
+          .setField('name', 'Charlie')
+          .setField('hasACat', true)
+          .setField('hasADog', true)
+          .createAsync(),
+      );
+
+      const catOwnerCount = await PostgresTestEntity.knexLoader(vc1).countBySQLAsync(
+        sql`has_a_cat = ${true}`,
+      );
+      expect(catOwnerCount).toBe(2);
+
+      const dogOwnerCount = await PostgresTestEntity.knexLoader(vc1).countBySQLAsync(
+        sql`has_a_dog = ${true}`,
+      );
+      expect(dogOwnerCount).toBe(2);
+
+      const allCount = await PostgresTestEntity.knexLoader(vc1).countBySQLAsync(sql`TRUE`);
+      expect(allCount).toBe(3);
+
+      const noneCount = await PostgresTestEntity.knexLoader(vc1).countBySQLAsync(sql`FALSE`);
+      expect(noneCount).toBe(0);
+    });
+  });
+
+  describe('counting with countByFieldEqualityConjunctionAsync', () => {
+    it('counts entities matching field equality conditions', async () => {
+      const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+
+      await enforceAsyncResult(
+        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
+          .setField('name', 'hello')
+          .setField('hasACat', false)
+          .setField('hasADog', true)
+          .createAsync(),
+      );
+
+      await enforceAsyncResult(
+        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
+          .setField('name', 'world')
+          .setField('hasACat', false)
+          .setField('hasADog', true)
+          .createAsync(),
+      );
+
+      await enforceAsyncResult(
+        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
+          .setField('name', 'wat')
+          .setField('hasACat', false)
+          .setField('hasADog', false)
+          .createAsync(),
+      );
+
+      const count1 = await PostgresTestEntity.knexLoader(vc1).countByFieldEqualityConjunctionAsync([
+        { fieldName: 'hasACat', fieldValue: false },
+        { fieldName: 'hasADog', fieldValue: true },
+      ]);
+      expect(count1).toBe(2);
+
+      const count2 = await PostgresTestEntity.knexLoader(vc1).countByFieldEqualityConjunctionAsync([
+        { fieldName: 'hasADog', fieldValues: [true, false] },
+      ]);
+      expect(count2).toBe(3);
+
+      const count3 = await PostgresTestEntity.knexLoader(vc1).countByFieldEqualityConjunctionAsync([
+        { fieldName: 'name', fieldValue: 'hello' },
+      ]);
+      expect(count3).toBe(1);
+
+      const count4 = await PostgresTestEntity.knexLoader(vc1).countByFieldEqualityConjunctionAsync(
+        [],
+      );
+      expect(count4).toBe(3);
+    });
+  });
+
   describe('conjunction field equality loading', () => {
     it('supports single fieldValue and multiple fieldValues', async () => {
       const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
@@ -1085,6 +1182,49 @@ describe('postgres entity integration', () => {
       expect(results.map((e) => e.getField('name'))).toEqual(['alpha', 'gamma', 'beta']);
     });
 
+    it('supports fieldFragment orderBy with entityField', async () => {
+      const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+
+      await enforceAsyncResult(
+        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
+          .setField('name', 'alpha')
+          .setField('hasACat', true)
+          .createAsync(),
+      );
+
+      await enforceAsyncResult(
+        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
+          .setField('name', 'beta')
+          .setField('hasACat', false)
+          .createAsync(),
+      );
+
+      await enforceAsyncResult(
+        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
+          .setField('name', 'gamma')
+          .setField('hasACat', true)
+          .createAsync(),
+      );
+
+      // Order by entityField references, which translate entity field names to DB column names
+      const results = await PostgresTestEntity.knexLoader(
+        vc1,
+      ).loadManyByFieldEqualityConjunctionAsync([], {
+        orderBy: [
+          {
+            fieldFragment: sql`${entityField('hasACat')}`,
+            order: OrderByOrdering.DESCENDING,
+          },
+          {
+            fieldFragment: sql`${entityField('name')}`,
+            order: OrderByOrdering.ASCENDING,
+          },
+        ],
+      });
+      expect(results).toHaveLength(3);
+      expect(results.map((e) => e.getField('name'))).toEqual(['alpha', 'gamma', 'beta']);
+    });
+
     it('rejects fieldFragment containing trailing ASC or DESC', async () => {
       const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
 
@@ -1165,122 +1305,6 @@ describe('postgres entity integration', () => {
     });
   });
 
-  describe('raw where clause loading', () => {
-    it('loads by raw where clause', async () => {
-      const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
-      await enforceAsyncResult(
-        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
-          .setField('name', 'hello')
-          .setField('hasACat', false)
-          .setField('hasADog', true)
-          .createAsync(),
-      );
-
-      const results = await PostgresTestEntity.knexLoader(vc1).loadManyByRawWhereClauseAsync(
-        'name = ?',
-        ['hello'],
-      );
-
-      expect(results).toHaveLength(1);
-    });
-
-    it('throws with invalid where clause', async () => {
-      const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
-      await enforceAsyncResult(
-        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
-          .setField('name', 'hello')
-          .setField('hasACat', false)
-          .setField('hasADog', true)
-          .createAsync(),
-      );
-
-      await expect(
-        PostgresTestEntity.knexLoader(vc1).loadManyByRawWhereClauseAsync('invalid_column = ?', [
-          'hello',
-        ]),
-      ).rejects.toThrow();
-    });
-
-    it('supports query modifiers', async () => {
-      const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
-
-      await enforceAsyncResult(
-        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
-          .setField('name', 'a')
-          .setField('hasADog', true)
-          .createAsync(),
-      );
-
-      await enforceAsyncResult(
-        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
-          .setField('name', 'b')
-          .setField('hasADog', true)
-          .createAsync(),
-      );
-
-      await enforceAsyncResult(
-        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
-          .setField('name', 'c')
-          .setField('hasADog', true)
-          .createAsync(),
-      );
-
-      const results = await PostgresTestEntity.knexLoader(vc1).loadManyByRawWhereClauseAsync(
-        'has_a_dog = ?',
-        [true],
-        {
-          limit: 2,
-          offset: 1,
-          orderBy: [
-            {
-              fieldName: 'name',
-              order: OrderByOrdering.ASCENDING,
-            },
-          ],
-        },
-      );
-
-      expect(results).toHaveLength(2);
-      expect(results.map((e) => e.getField('name'))).toEqual(['b', 'c']);
-
-      const resultsMultipleOrderBy = await PostgresTestEntity.knexLoader(
-        vc1,
-      ).loadManyByRawWhereClauseAsync('has_a_dog = ?', [true], {
-        orderBy: [
-          {
-            fieldName: 'hasADog',
-            order: OrderByOrdering.ASCENDING,
-          },
-          {
-            fieldName: 'name',
-            order: OrderByOrdering.DESCENDING,
-          },
-        ],
-      });
-
-      expect(resultsMultipleOrderBy).toHaveLength(3);
-      expect(resultsMultipleOrderBy.map((e) => e.getField('name'))).toEqual(['c', 'b', 'a']);
-
-      const resultsOrderByRaw = await PostgresTestEntity.knexLoader(
-        vc1,
-      ).loadManyByRawWhereClauseAsync('has_a_dog = ?', [true], {
-        orderBy: [
-          {
-            fieldFragment: sql`${entityField('hasADog')}`,
-            order: OrderByOrdering.ASCENDING,
-          },
-          {
-            fieldFragment: sql`${entityField('name')}`,
-            order: OrderByOrdering.DESCENDING,
-          },
-        ],
-      });
-
-      expect(resultsOrderByRaw).toHaveLength(3);
-      expect(resultsOrderByRaw.map((e) => e.getField('name'))).toEqual(['c', 'b', 'a']);
-    });
-  });
-
   describe('trigger transaction behavior', () => {
     describe('create', () => {
       it('rolls back transaction when trigger throws except afterCommit', async () => {

package/src/__tests__/AuthorizationResultBasedKnexEntityLoader-test.ts

@@ -205,81 +205,6 @@ describe(AuthorizationResultBasedKnexEntityLoader, () => {
     ).once();
   });
 
-  it('loads entities with loadManyByRawWhereClauseAsync', async () => {
-    const privacyPolicy = new TestEntityPrivacyPolicy();
-    const spiedPrivacyPolicy = spy(privacyPolicy);
-    const viewerContext = instance(mock(ViewerContext));
-    const privacyPolicyEvaluationContext =
-      instance(
-        mock<
-          EntityPrivacyPolicyEvaluationContext<
-            TestFields,
-            'customIdField',
-            ViewerContext,
-            TestEntity
-          >
-        >(),
-      );
-    const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
-    const queryContext = instance(mock<EntityQueryContext>());
-
-    const knexDataManagerMock =
-      mock<EntityKnexDataManager<TestFields, 'customIdField'>>(EntityKnexDataManager);
-    when(
-      knexDataManagerMock.loadManyByRawWhereClauseAsync(
-        queryContext,
-        anything(),
-        anything(),
-        anything(),
-      ),
-    ).thenResolve([
-      {
-        customIdField: 'id',
-        stringField: 'huh',
-        intField: 4,
-        testIndexedField: '4',
-        dateField: new Date(),
-        nullableField: null,
-      },
-    ]);
-    const knexDataManager = instance(knexDataManagerMock);
-
-    const constructionUtils = new EntityConstructionUtils(
-      viewerContext,
-      queryContext,
-      privacyPolicyEvaluationContext,
-      testEntityConfiguration,
-      TestEntity,
-      /* entitySelectedFields */ undefined,
-      privacyPolicy,
-      metricsAdapter,
-    );
-    const knexEntityLoader = new AuthorizationResultBasedKnexEntityLoader(
-      queryContext,
-      knexDataManager,
-      metricsAdapter,
-      constructionUtils,
-    );
-
-    const result = await knexEntityLoader.loadManyByRawWhereClauseAsync('id = ?', [1], {
-      orderBy: [{ fieldName: 'testIndexedField', order: OrderByOrdering.DESCENDING }],
-    });
-    expect(result).toHaveLength(1);
-    expect(result[0]).not.toBeNull();
-    expect(result[0]!.ok).toBe(true);
-    expect(result[0]!.enforceValue().getField('testIndexedField')).toEqual('4');
-
-    verify(
-      spiedPrivacyPolicy.authorizeReadAsync(
-        viewerContext,
-        queryContext,
-        privacyPolicyEvaluationContext,
-        anyOfClass(TestEntity),
-        anything(),
-      ),
-    ).once();
-  });
-
   describe('loads entities with loadManyBySQL', () => {
     it('returns entities with authorization results', async () => {
       const privacyPolicy = new TestEntityPrivacyPolicy();

package/src/__tests__/BasePostgresEntityDatabaseAdapter-test.ts

@@ -18,9 +18,8 @@ class TestEntityDatabaseAdapter extends BasePostgresEntityDatabaseAdapter<
   private readonly fetchResults: object[];
   private readonly fetchOneResult: object | null;
   private readonly insertResults: object[];
-  private readonly updateResults: object[];
+  private readonly updateResults: { updatedRowCount: number };
   private readonly fetchEqualityConditionResults: object[];
-  private readonly fetchRawWhereResults: object[];
   private readonly fetchSQLFragmentResults: object[];
   private readonly deleteCount: number;
 
@@ -28,18 +27,16 @@ class TestEntityDatabaseAdapter extends BasePostgresEntityDatabaseAdapter<
     fetchResults = [],
     fetchOneResult = null,
     insertResults = [],
-    updateResults = [],
+    updateResults = { updatedRowCount: 0 },
     fetchEqualityConditionResults = [],
-    fetchRawWhereResults = [],
     fetchSQLFragmentResults = [],
     deleteCount = 0,
   }: {
     fetchResults?: object[];
     fetchOneResult?: object | null;
     insertResults?: object[];
-    updateResults?: object[];
+    updateResults?: { updatedRowCount: number };
     fetchEqualityConditionResults?: object[];
-    fetchRawWhereResults?: object[];
     fetchSQLFragmentResults?: object[];
     deleteCount?: number;
   }) {
@@ -49,7 +46,6 @@ class TestEntityDatabaseAdapter extends BasePostgresEntityDatabaseAdapter<
     this.insertResults = insertResults;
     this.updateResults = updateResults;
     this.fetchEqualityConditionResults = fetchEqualityConditionResults;
-    this.fetchRawWhereResults = fetchRawWhereResults;
     this.fetchSQLFragmentResults = fetchSQLFragmentResults;
     this.deleteCount = deleteCount;
   }
@@ -76,15 +72,6 @@ class TestEntityDatabaseAdapter extends BasePostgresEntityDatabaseAdapter<
     return this.fetchOneResult;
   }
 
-  protected async fetchManyByRawWhereClauseInternalAsync(
-    _queryInterface: any,
-    _tableName: string,
-    _rawWhereClause: string,
-    _bindings: object | any[],
-  ): Promise<object[]> {
-    return this.fetchRawWhereResults;
-  }
-
   protected async fetchManyBySQLFragmentInternalAsync(
     _queryInterface: any,
     _tableName: string,
@@ -102,6 +89,23 @@ class TestEntityDatabaseAdapter extends BasePostgresEntityDatabaseAdapter<
     return this.fetchEqualityConditionResults;
   }
 
+  protected async countByFieldEqualityConjunctionInternalAsync(
+    _queryInterface: any,
+    _tableName: string,
+    _tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[],
+    _tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[],
+  ): Promise<number> {
+    return 0;
+  }
+
+  protected async countBySQLFragmentInternalAsync(
+    _queryInterface: any,
+    _tableName: string,
+    _sqlFragment: any,
+  ): Promise<number> {
+    return 0;
+  }
+
   protected async insertInternalAsync(
     _queryInterface: any,
     _tableName: string,
@@ -116,7 +120,7 @@ class TestEntityDatabaseAdapter extends BasePostgresEntityDatabaseAdapter<
     _tableIdField: string,
     _id: any,
     _object: object,
-  ): Promise<object[]> {
+  ): Promise<{ updatedRowCount: number }> {
     return this.updateResults;
   }
 
@@ -148,15 +152,4 @@ describe(BasePostgresEntityDatabaseAdapter, () => {
       expect(results).toEqual([{ stringField: 'hello' }]);
     });
   });
-
-  describe('fetchManyWithRawWhereClause', () => {
-    it('transforms object', async () => {
-      const queryContext = instance(mock(EntityQueryContext));
-      const adapter = new TestEntityDatabaseAdapter({
-        fetchRawWhereResults: [{ string_field: 'hello' }],
-      });
-      const results = await adapter.fetchManyByRawWhereClauseAsync(queryContext, 'hello', [], {});
-      expect(results).toEqual([{ stringField: 'hello' }]);
-    });
-  });
 });

package/src/__tests__/EnforcingKnexEntityLoader-test.ts

@@ -137,58 +137,6 @@ describe(EnforcingKnexEntityLoader, () => {
     });
   });
 
-  describe('loadManyByRawWhereClause', () => {
-    it('throws when result is unsuccessful', async () => {
-      const nonEnforcingKnexEntityLoaderMock = mock(
-        AuthorizationResultBasedKnexEntityLoader<any, any, any, any, any, any>,
-      );
-      const rejection = new Error();
-      when(
-        nonEnforcingKnexEntityLoaderMock.loadManyByRawWhereClauseAsync(
-          anything(),
-          anything(),
-          anything(),
-        ),
-      ).thenResolve([result(rejection)]);
-      const nonEnforcingKnexEntityLoader = instance(nonEnforcingKnexEntityLoaderMock);
-      const enforcingKnexEntityLoader = new EnforcingKnexEntityLoader(
-        nonEnforcingKnexEntityLoader,
-        instance(mock(EntityQueryContext)),
-        instance(mock(EntityKnexDataManager)),
-        instance(mock<IEntityMetricsAdapter>()),
-        instance(mock(EntityConstructionUtils)),
-      );
-      await expect(
-        enforcingKnexEntityLoader.loadManyByRawWhereClauseAsync(anything(), anything(), anything()),
-      ).rejects.toThrow(rejection);
-    });
-
-    it('returns value when result is successful', async () => {
-      const nonEnforcingKnexEntityLoaderMock = mock(
-        AuthorizationResultBasedKnexEntityLoader<any, any, any, any, any, any>,
-      );
-      const resolved = {};
-      when(
-        nonEnforcingKnexEntityLoaderMock.loadManyByRawWhereClauseAsync(
-          anything(),
-          anything(),
-          anything(),
-        ),
-      ).thenResolve([result(resolved)]);
-      const nonEnforcingKnexEntityLoader = instance(nonEnforcingKnexEntityLoaderMock);
-      const enforcingKnexEntityLoader = new EnforcingKnexEntityLoader(
-        nonEnforcingKnexEntityLoader,
-        instance(mock(EntityQueryContext)),
-        instance(mock(EntityKnexDataManager)),
-        instance(mock<IEntityMetricsAdapter>()),
-        instance(mock(EntityConstructionUtils)),
-      );
-      await expect(
-        enforcingKnexEntityLoader.loadManyByRawWhereClauseAsync(anything(), anything(), anything()),
-      ).resolves.toEqual([resolved]);
-    });
-  });
-
   describe('loadManyBySQL', () => {
     it('throws when result is unsuccessful', async () => {
       const nonEnforcingKnexEntityLoaderMock = mock(