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

package/src/AuthorizationResultBasedKnexEntityLoader.ts

@@ -400,6 +400,42 @@ export class AuthorizationResultBasedKnexEntityLoader<
     return await this.constructionUtils.constructAndAuthorizeEntitiesArrayAsync(fieldObjects);
   }
 
+  /**
+   * Count entities matching the conjunction of field equality operands.
+   * This does not perform authorization since count does not load full entities.
+   * Note that this should be used with the same caution as loadManyByFieldEqualityConjunctionAsync
+   * regarding indexing since counts can be expensive on large datasets without appropriate indexes.
+   *
+   * @returns count of entities matching the filters
+   */
+  async countByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(
+    fieldEqualityOperands: readonly FieldEqualityCondition<TFields, N>[],
+  ): Promise<number> {
+    for (const fieldEqualityOperand of fieldEqualityOperands) {
+      const fieldValues = isSingleValueFieldEqualityCondition(fieldEqualityOperand)
+        ? [fieldEqualityOperand.fieldValue]
+        : fieldEqualityOperand.fieldValues;
+      this.constructionUtils.validateFieldAndValues(fieldEqualityOperand.fieldName, fieldValues);
+    }
+
+    return await this.knexDataManager.countByFieldEqualityConjunctionAsync(
+      this.queryContext,
+      fieldEqualityOperands,
+    );
+  }
+
+  /**
+   * Count entities matching a SQL fragment.
+   * This does not perform authorization since count does not load full entities.
+   * Note that this should be used with the same caution as loadManyBySQL regarding indexing
+   * since counts can be expensive on large datasets without appropriate indexes.
+   *
+   * @returns count of entities matching the query
+   */
+  async countBySQLAsync(fragment: SQLFragment<Pick<TFields, TSelectedFields>>): Promise<number> {
+    return await this.knexDataManager.countBySQLFragmentAsync(this.queryContext, fragment);
+  }
+
   /**
    * Authorization-result-based version of the EnforcingKnexEntityLoader method by the same name.
    * @returns SQL query builder for building and executing SQL queries that when executed returns entity results where result error can be UnauthorizedError.

package/src/BasePostgresEntityDatabaseAdapter.ts

@@ -248,6 +248,73 @@ export abstract class BasePostgresEntityDatabaseAdapter<
     querySelectionModifiers: TableQuerySelectionModifiers<TFields>,
   ): Promise<object[]>;
 
+  /**
+   * Count objects matching the conjunction of where clauses constructed from
+   * specified field equality operands.
+   *
+   * @param queryContext - query context with which to perform the count
+   * @param fieldEqualityOperands - list of field equality where clause operand specifications
+   * @returns count of objects matching the query
+   */
+  async countByFieldEqualityConjunctionAsync<N extends keyof TFields>(
+    queryContext: EntityQueryContext,
+    fieldEqualityOperands: readonly FieldEqualityCondition<TFields, N>[],
+  ): Promise<number> {
+    const tableFieldSingleValueOperands: TableFieldSingleValueEqualityCondition[] = [];
+    const tableFieldMultipleValueOperands: TableFieldMultiValueEqualityCondition[] = [];
+    for (const operand of fieldEqualityOperands) {
+      if (isSingleValueFieldEqualityCondition(operand)) {
+        tableFieldSingleValueOperands.push({
+          tableField: getDatabaseFieldForEntityField(this.entityConfiguration, operand.fieldName),
+          tableValue: operand.fieldValue,
+        });
+      } else {
+        tableFieldMultipleValueOperands.push({
+          tableField: getDatabaseFieldForEntityField(this.entityConfiguration, operand.fieldName),
+          tableValues: operand.fieldValues,
+        });
+      }
+    }
+
+    return await this.countByFieldEqualityConjunctionInternalAsync(
+      queryContext.getQueryInterface(),
+      this.entityConfiguration.tableName,
+      tableFieldSingleValueOperands,
+      tableFieldMultipleValueOperands,
+    );
+  }
+
+  protected abstract countByFieldEqualityConjunctionInternalAsync(
+    queryInterface: Knex,
+    tableName: string,
+    tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[],
+    tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[],
+  ): Promise<number>;
+
+  /**
+   * Count objects matching the SQL fragment.
+   *
+   * @param queryContext - query context with which to perform the count
+   * @param sqlFragment - SQLFragment for the WHERE clause of the query
+   * @returns count of objects matching the query
+   */
+  async countBySQLFragmentAsync(
+    queryContext: EntityQueryContext,
+    sqlFragment: SQLFragment<TFields>,
+  ): Promise<number> {
+    return await this.countBySQLFragmentInternalAsync(
+      queryContext.getQueryInterface(),
+      this.entityConfiguration.tableName,
+      sqlFragment,
+    );
+  }
+
+  protected abstract countBySQLFragmentInternalAsync(
+    queryInterface: Knex,
+    tableName: string,
+    sqlFragment: SQLFragment<TFields>,
+  ): Promise<number>;
+
   private convertToTableQueryModifiers(
     querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>,
   ): TableQuerySelectionModifiers<TFields> {

package/src/BaseSQLQueryBuilder.ts

@@ -47,7 +47,7 @@ export abstract class BaseSQLQueryBuilder<
   orderBy(
     fieldName: TSelectedFields,
     order: OrderByOrdering = OrderByOrdering.ASCENDING,
-    nulls: NullsOrdering | undefined = undefined,
+    nulls?: NullsOrdering,
   ): this {
     this.modifiers.orderBy = [...(this.modifiers.orderBy ?? []), { fieldName, order, nulls }];
     return this;
@@ -74,7 +74,7 @@ export abstract class BaseSQLQueryBuilder<
   orderBySQL(
     fragment: SQLFragment<Pick<TFields, TSelectedFields>>,
     order: OrderByOrdering = OrderByOrdering.ASCENDING,
-    nulls: NullsOrdering | undefined = undefined,
+    nulls?: NullsOrdering,
   ): this {
     this.modifiers.orderBy = [
       ...(this.modifiers.orderBy ?? []),

package/src/EnforcingKnexEntityLoader.ts

@@ -104,6 +104,32 @@ export class EnforcingKnexEntityLoader<
     return entityResults.map((result) => result.enforceValue());
   }
 
+  /**
+   * Count entities matching the conjunction of field equality operands.
+   * This does not perform authorization since count does not load full entities.
+   * Note that this should be used with the same caution as loadManyByFieldEqualityConjunctionAsync
+   * regarding indexing since counts can be expensive on large datasets without appropriate indexes.
+   *
+   * @returns count of entities matching the filters
+   */
+  async countByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(
+    fieldEqualityOperands: FieldEqualityCondition<TFields, N>[],
+  ): Promise<number> {
+    return await this.knexEntityLoader.countByFieldEqualityConjunctionAsync(fieldEqualityOperands);
+  }
+
+  /**
+   * Count entities matching a SQL fragment.
+   * This does not perform authorization since count does not load full entity rows.
+   * Note that this should be used with the same caution as loadManyBySQL regarding indexing
+   * since counts can be expensive on large datasets without appropriate indexes.
+   *
+   * @returns count of entities matching the query
+   */
+  async countBySQLAsync(fragment: SQLFragment<Pick<TFields, TSelectedFields>>): Promise<number> {
+    return await this.knexEntityLoader.countBySQLAsync(fragment);
+  }
+
   /**
    * Load entities using a SQL query builder. When executed, all queries will enforce authorization and throw if not authorized.
    *

package/src/PostgresEntityDatabaseAdapter.ts

@@ -1,5 +1,5 @@
 import type { EntityConfiguration, FieldTransformer, FieldTransformerMap } from '@expo/entity';
-import { getDatabaseFieldForEntityField } from '@expo/entity';
+import { getDatabaseFieldForEntityField, RESERVED_ENTITY_COUNT_QUERY_ALIAS } from '@expo/entity';
 import type { Knex } from 'knex';
 
 import type {
@@ -91,7 +91,7 @@ export class PostgresEntityDatabaseAdapter<
           .select()
           .from(tableName)
           .whereRaw(`(??) = ANY(?)`, [
-            tableColumns[0],
+            tableColumns[0]!,
             tableTuples.map((tableTuple) => tableTuple[0]),
           ]),
       );
@@ -164,14 +164,12 @@ export class PostgresEntityDatabaseAdapter<
     return ret;
   }
 
-  protected async fetchManyByFieldEqualityConjunctionInternalAsync(
-    queryInterface: Knex,
-    tableName: string,
+  private applyFieldEqualityConjunctionWhereClause(
+    query: Knex.QueryBuilder,
     tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[],
     tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[],
-    querySelectionModifiers: TableQuerySelectionModifiers<TFields>,
-  ): Promise<object[]> {
-    let query = queryInterface.select().from(tableName);
+  ): Knex.QueryBuilder {
+    let result = query;
 
     if (tableFieldSingleValueEqualityOperands.length > 0) {
       const whereObject: { [key: string]: any } = {};
@@ -184,11 +182,11 @@ export class PostgresEntityDatabaseAdapter<
         for (const { tableField, tableValue } of nonNullTableFieldSingleValueEqualityOperands) {
           whereObject[tableField] = tableValue;
         }
-        query = query.where(whereObject);
+        result = result.where(whereObject);
       }
       if (nullTableFieldSingleValueEqualityOperands.length > 0) {
         for (const { tableField } of nullTableFieldSingleValueEqualityOperands) {
-          query = query.whereNull(tableField);
+          result = result.whereNull(tableField);
         }
       }
     }
@@ -196,7 +194,7 @@ export class PostgresEntityDatabaseAdapter<
     if (tableFieldMultiValueEqualityOperands.length > 0) {
       for (const { tableField, tableValues } of tableFieldMultiValueEqualityOperands) {
         const nonNullTableValues = tableValues.filter((tableValue) => tableValue !== null);
-        query = query.where((builder) => {
+        result = result.where((builder) => {
           builder.whereRaw('?? = ANY(?)', [tableField, [...nonNullTableValues]]);
           // there was at least one null, allow null in this equality clause
           if (nonNullTableValues.length !== tableValues.length) {
@@ -206,29 +204,79 @@ export class PostgresEntityDatabaseAdapter<
       }
     }
 
+    return result;
+  }
+
+  protected async fetchManyByFieldEqualityConjunctionInternalAsync(
+    queryInterface: Knex,
+    tableName: string,
+    tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[],
+    tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[],
+    querySelectionModifiers: TableQuerySelectionModifiers<TFields>,
+  ): Promise<object[]> {
+    let query = this.applyFieldEqualityConjunctionWhereClause(
+      queryInterface.select().from(tableName),
+      tableFieldSingleValueEqualityOperands,
+      tableFieldMultiValueEqualityOperands,
+    );
     query = this.applyQueryModifiersToQuery(query, querySelectionModifiers);
     return await wrapNativePostgresCallAsync(() => query);
   }
 
+  private applySQLFragmentWhereClause(
+    query: Knex.QueryBuilder,
+    sqlFragment: SQLFragment<TFields>,
+  ): Knex.QueryBuilder {
+    return query.whereRaw(
+      sqlFragment.sql,
+      sqlFragment.getKnexBindings((fieldName) =>
+        getDatabaseFieldForEntityField(this.entityConfiguration, fieldName),
+      ),
+    );
+  }
+
   protected async fetchManyBySQLFragmentInternalAsync(
     queryInterface: Knex,
     tableName: string,
     sqlFragment: SQLFragment<TFields>,
     querySelectionModifiers: TableQuerySelectionModifiers<TFields>,
   ): Promise<object[]> {
-    let query = queryInterface
-      .select()
-      .from(tableName)
-      .whereRaw(
-        sqlFragment.sql,
-        sqlFragment.getKnexBindings((fieldName) =>
-          getDatabaseFieldForEntityField(this.entityConfiguration, fieldName),
-        ),
-      );
+    let query = this.applySQLFragmentWhereClause(
+      queryInterface.select().from(tableName),
+      sqlFragment,
+    );
     query = this.applyQueryModifiersToQuery(query, querySelectionModifiers);
     return await wrapNativePostgresCallAsync(() => query);
   }
 
+  protected async countByFieldEqualityConjunctionInternalAsync(
+    queryInterface: Knex,
+    tableName: string,
+    tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[],
+    tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[],
+  ): Promise<number> {
+    const query = this.applyFieldEqualityConjunctionWhereClause(
+      queryInterface.count('*', { as: RESERVED_ENTITY_COUNT_QUERY_ALIAS }).from(tableName),
+      tableFieldSingleValueEqualityOperands,
+      tableFieldMultiValueEqualityOperands,
+    );
+    const result = await wrapNativePostgresCallAsync(() => query);
+    return parseInt(String(result[0][RESERVED_ENTITY_COUNT_QUERY_ALIAS]), 10);
+  }
+
+  protected async countBySQLFragmentInternalAsync(
+    queryInterface: Knex,
+    tableName: string,
+    sqlFragment: SQLFragment<TFields>,
+  ): Promise<number> {
+    const query = this.applySQLFragmentWhereClause(
+      queryInterface.count('*', { as: RESERVED_ENTITY_COUNT_QUERY_ALIAS }).from(tableName),
+      sqlFragment,
+    );
+    const result = await wrapNativePostgresCallAsync(() => query);
+    return parseInt(String(result[0][RESERVED_ENTITY_COUNT_QUERY_ALIAS]), 10);
+  }
+
   protected async insertInternalAsync(
     queryInterface: Knex,
     tableName: string,

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));

package/src/__tests__/BasePostgresEntityDatabaseAdapter-test.ts

@@ -89,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,

package/src/__tests__/SQLOperator-test.ts

@@ -258,12 +258,11 @@ describe('SQLOperator', () => {
       });
 
       it('handles all SupportedSQLValue types in getDebugString', () => {
-        const fragment = new SQLFragment('INSERT INTO test VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)', [
+        const fragment = new SQLFragment('INSERT INTO test VALUES (?, ?, ?, ?, ?, ?, ?, ?)', [
           { type: 'value', value: 'string' },
           { type: 'value', value: 123 },
           { type: 'value', value: true },
           { type: 'value', value: null },
-          { type: 'value', value: undefined },
           { type: 'value', value: new Date('2024-01-01T00:00:00.000Z') },
           { type: 'value', value: Buffer.from('hello') },
           { type: 'value', value: BigInt(999) },
@@ -272,7 +271,7 @@ describe('SQLOperator', () => {
 
         const text = fragment.getDebugString();
         expect(text).toBe(
-          "INSERT INTO test VALUES ('string', 123, TRUE, NULL, NULL, '2024-01-01T00:00:00.000Z', '\\x68656c6c6f', 999, ARRAY[1, 2, 3])",
+          "INSERT INTO test VALUES ('string', 123, TRUE, NULL, '2024-01-01T00:00:00.000Z', '\\x68656c6c6f', 999, ARRAY[1, 2, 3])",
         );
       });
 
@@ -763,13 +762,6 @@ describe('SQLOperator', () => {
         expect(fragment.getKnexBindings(getColumnForField)).toEqual(['nullable_field']);
       });
 
-      it('handles undefined in equality check', () => {
-        const fragment = SQLExpression.eq('nullableField', undefined);
-
-        expect(fragment.sql).toBe('?? IS NULL');
-        expect(fragment.getKnexBindings(getColumnForField)).toEqual(['nullable_field']);
-      });
-
       it('accepts a SQLFragment expression', () => {
         const fragment = SQLExpression.eq(sql<TestFields>`${entityField('stringField')}`, 'active');
         expect(fragment.sql).toBe('?? = ?');
@@ -801,13 +793,6 @@ describe('SQLOperator', () => {
         expect(fragment.getKnexBindings(getColumnForField)).toEqual(['nullable_field']);
       });
 
-      it('handles undefined in inequality check', () => {
-        const fragment = SQLExpression.neq('nullableField', undefined);
-
-        expect(fragment.sql).toBe('?? IS NOT NULL');
-        expect(fragment.getKnexBindings(getColumnForField)).toEqual(['nullable_field']);
-      });
-
       it('accepts a SQLFragment expression', () => {
         const fragment = SQLExpression.neq(
           sql<TestFields>`${entityField('stringField')}`,
@@ -1131,12 +1116,6 @@ describe('SQLOperator', () => {
         expect(fragment.getKnexBindings(getColumnForField)).toEqual(['string_field']);
       });
 
-      it('eq(undefined) uses IS NULL', () => {
-        const fragment = makeExpr<string>(stringFieldFragment()).eq(undefined);
-        expect(fragment.sql).toBe('?? IS NULL');
-        expect(fragment.getKnexBindings(getColumnForField)).toEqual(['string_field']);
-      });
-
       it('neq(value)', () => {
         const fragment = makeExpr<string>(stringFieldFragment()).neq('deleted');
         expect(fragment.sql).toBe('?? != ?');
@@ -1149,12 +1128,6 @@ describe('SQLOperator', () => {
         expect(fragment.getKnexBindings(getColumnForField)).toEqual(['string_field']);
       });
 
-      it('neq(undefined) uses IS NOT NULL', () => {
-        const fragment = makeExpr<string>(stringFieldFragment()).neq(undefined);
-        expect(fragment.sql).toBe('?? IS NOT NULL');
-        expect(fragment.getKnexBindings(getColumnForField)).toEqual(['string_field']);
-      });
-
       it('gt(value)', () => {
         const fragment = makeExpr<number>(intFieldFragment()).gt(10);
         expect(fragment.sql).toBe('?? > ?');