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

package/build/src/internal/EntityKnexDataManager.d.ts

@@ -88,17 +88,9 @@ export declare class EntityKnexDataManager<TFields extends Record<string, any>,
      * @returns array of objects matching the query
      */
     loadManyByFieldEqualityConjunctionAsync<N extends keyof TFields>(queryContext: EntityQueryContext, fieldEqualityOperands: readonly FieldEqualityCondition<TFields, N>[], querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>): Promise<readonly Readonly<TFields>[]>;
-    /**
-     * Loads many objects matching the raw WHERE clause.
-     *
-     * @param queryContext - query context in which to perform the load
-     * @param rawWhereClause - parameterized SQL WHERE clause with positional binding placeholders or named binding placeholders
-     * @param bindings - array of positional bindings or object of named bindings
-     * @param querySelectionModifiers - limit, offset, orderBy, and orderByRaw for the query
-     * @returns array of objects matching the query
-     */
-    loadManyByRawWhereClauseAsync(queryContext: EntityQueryContext, rawWhereClause: string, bindings: readonly any[] | object, querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>): Promise<readonly Readonly<TFields>[]>;
+    countByFieldEqualityConjunctionAsync<N extends keyof TFields>(queryContext: EntityQueryContext, fieldEqualityOperands: readonly FieldEqualityCondition<TFields, N>[]): Promise<number>;
     loadManyBySQLFragmentAsync(queryContext: EntityQueryContext, sqlFragment: SQLFragment<TFields>, querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>): Promise<readonly Readonly<TFields>[]>;
+    countBySQLFragmentAsync(queryContext: EntityQueryContext, sqlFragment: SQLFragment<TFields>): Promise<number>;
     /**
      * Load a page of objects using cursor-based pagination with unified pagination specification.
      *

package/build/src/internal/EntityKnexDataManager.js

@@ -1,4 +1,4 @@
-import { EntityDatabaseAdapterPaginationCursorInvalidError, EntityMetricsLoadType, getDatabaseFieldForEntityField, timeAndLogLoadEventAsync, } from '@expo/entity';
+import { EntityDatabaseAdapterPaginationCursorInvalidError, EntityMetricsLoadType, getDatabaseFieldForEntityField, timeAndLogCountEventAsync, timeAndLogLoadEventAsync, } from '@expo/entity';
 import assert from 'assert';
 import { NullsOrdering, OrderByOrdering } from "../BasePostgresEntityDatabaseAdapter.js";
 import { PaginationStrategy } from "../PaginationStrategy.js";
@@ -42,23 +42,16 @@ export class EntityKnexDataManager {
         EntityKnexDataManager.validateOrderByClauses(querySelectionModifiers.orderBy);
         return await timeAndLogLoadEventAsync(this.metricsAdapter, EntityMetricsLoadType.LOAD_MANY_EQUALITY_CONJUNCTION, this.entityClassName, queryContext)(this.databaseAdapter.fetchManyByFieldEqualityConjunctionAsync(queryContext, fieldEqualityOperands, querySelectionModifiers));
     }
-    /**
-     * Loads many objects matching the raw WHERE clause.
-     *
-     * @param queryContext - query context in which to perform the load
-     * @param rawWhereClause - parameterized SQL WHERE clause with positional binding placeholders or named binding placeholders
-     * @param bindings - array of positional bindings or object of named bindings
-     * @param querySelectionModifiers - limit, offset, orderBy, and orderByRaw for the query
-     * @returns array of objects matching the query
-     */
-    async loadManyByRawWhereClauseAsync(queryContext, rawWhereClause, bindings, querySelectionModifiers) {
-        EntityKnexDataManager.validateOrderByClauses(querySelectionModifiers.orderBy);
-        return await timeAndLogLoadEventAsync(this.metricsAdapter, EntityMetricsLoadType.LOAD_MANY_RAW, this.entityClassName, queryContext)(this.databaseAdapter.fetchManyByRawWhereClauseAsync(queryContext, rawWhereClause, bindings, querySelectionModifiers));
+    async countByFieldEqualityConjunctionAsync(queryContext, fieldEqualityOperands) {
+        return await timeAndLogCountEventAsync(this.metricsAdapter, EntityMetricsLoadType.COUNT_EQUALITY_CONJUNCTION, this.entityClassName, queryContext)(this.databaseAdapter.countByFieldEqualityConjunctionAsync(queryContext, fieldEqualityOperands));
     }
     async loadManyBySQLFragmentAsync(queryContext, sqlFragment, querySelectionModifiers) {
         EntityKnexDataManager.validateOrderByClauses(querySelectionModifiers.orderBy);
         return await timeAndLogLoadEventAsync(this.metricsAdapter, EntityMetricsLoadType.LOAD_MANY_SQL, this.entityClassName, queryContext)(this.databaseAdapter.fetchManyBySQLFragmentAsync(queryContext, sqlFragment, querySelectionModifiers));
     }
+    async countBySQLFragmentAsync(queryContext, sqlFragment) {
+        return await timeAndLogCountEventAsync(this.metricsAdapter, EntityMetricsLoadType.COUNT_SQL, this.entityClassName, queryContext)(this.databaseAdapter.countBySQLFragmentAsync(queryContext, sqlFragment));
+    }
     /**
      * Load a page of objects using cursor-based pagination with unified pagination specification.
      *
@@ -223,17 +216,14 @@ export class EntityKnexDataManager {
         };
     }
     combineWhereConditions(baseWhere, cursorCondition) {
-        const conditions = [baseWhere, cursorCondition].filter((it) => !!it);
-        if (conditions.length === 0) {
-            return sql `TRUE`;
+        if (!baseWhere) {
+            return cursorCondition ?? sql `TRUE`;
         }
-        if (conditions.length === 1) {
-            return conditions[0];
+        if (!cursorCondition) {
+            return baseWhere;
         }
-        // Wrap baseWhere in parens if combining with cursor condition
-        // We know we have exactly 2 conditions at this point
-        const [first, second] = conditions;
-        return sql `(${first}) AND ${second}`;
+        // Wrap baseWhere in parens when combining with cursor condition
+        return sql `(${baseWhere}) AND ${cursorCondition}`;
     }
     augmentOrderByIfNecessary(orderBy, idField) {
         const clauses = orderBy ?? [];

package/package.json

@@ -1,43 +1,43 @@
 {
   "name": "@expo/entity-database-adapter-knex",
-  "version": "0.62.0",
+  "version": "0.64.0",
   "description": "Knex database adapter for @expo/entity",
+  "keywords": [
+    "entity"
+  ],
+  "license": "MIT",
+  "author": "Expo",
   "files": [
     "build",
     "!*.tsbuildinfo",
     "!__*",
     "src"
   ],
+  "type": "module",
   "main": "build/src/index.js",
   "types": "build/src/index.d.ts",
   "scripts": {
     "build": "tsc --build",
     "prepack": "rm -rf build && yarn build",
     "clean": "yarn build --clean",
-    "lint": "yarn run --top-level eslint src",
+    "lint": "yarn run --top-level oxlint --type-aware src",
     "lint-fix": "yarn lint --fix",
     "test": "yarn test:all --rootDir $(pwd)",
     "integration": "yarn integration:all --rootDir $(pwd)"
   },
-  "engines": {
-    "node": ">=18"
-  },
-  "keywords": [
-    "entity"
-  ],
-  "author": "Expo",
-  "license": "MIT",
-  "type": "module",
   "dependencies": {
-    "@expo/entity": "^0.62.0",
-    "knex": "^3.1.0"
+    "@expo/entity": "^0.64.0",
+    "knex": "^3.2.9"
   },
   "devDependencies": {
-    "@expo/entity-testing-utils": "^0.62.0",
+    "@expo/entity-testing-utils": "^0.64.0",
     "@jest/globals": "30.3.0",
     "pg": "8.20.0",
     "ts-mockito": "2.6.1",
-    "typescript": "5.9.3"
+    "typescript": "6.0.3"
+  },
+  "engines": {
+    "node": ">=18"
   },
-  "gitHead": "4965cc238882982e6315beca48a68679ed45456b"
+  "gitHead": "3f10a9e70eab45ae95acdae133055d8a3ec04ce8"
 }

package/src/AuthorizationResultBasedKnexEntityLoader.ts

@@ -401,24 +401,39 @@ export class AuthorizationResultBasedKnexEntityLoader<
   }
 
   /**
-   * Authorization-result-based version of the EnforcingKnexEntityLoader method by the same name.
-   * @returns array of entity results that match the query, where result error can be UnauthorizedError
-   * @throws Error when rawWhereClause or bindings are invalid
+   * 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.
    *
-   * @deprecated Use loadManyBySQL instead for safer value bindings and more flexible query building.
+   * @returns count of entities matching the filters
    */
-  async loadManyByRawWhereClauseAsync(
-    rawWhereClause: string,
-    bindings: any[] | object,
-    querySelectionModifiers: EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields> = {},
-  ): Promise<readonly Result<TEntity>[]> {
-    const fieldObjects = await this.knexDataManager.loadManyByRawWhereClauseAsync(
+  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,
-      rawWhereClause,
-      bindings,
-      querySelectionModifiers,
+      fieldEqualityOperands,
     );
-    return await this.constructionUtils.constructAndAuthorizeEntitiesArrayAsync(fieldObjects);
+  }
+
+  /**
+   * 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);
   }
 
   /**

package/src/BasePostgresEntityDatabaseAdapter.ts

@@ -217,25 +217,22 @@ export abstract class BasePostgresEntityDatabaseAdapter<
   ): Promise<object[]>;
 
   /**
-   * Fetch many objects matching the raw WHERE clause.
+   * Fetch many objects matching the SQL fragment.
    *
    * @param queryContext - query context with which to perform the fetch
-   * @param rawWhereClause - parameterized SQL WHERE clause with positional binding placeholders or named binding placeholders
-   * @param bindings - array of positional bindings or object of named bindings
-   * @param querySelectionModifiers - limit, offset, and orderBy for the query
+   * @param sqlFragment - SQLFragment for the WHERE clause of the query
+   * @param querySelectionModifiers - limit, offset, and orderByFragment for the query
    * @returns array of objects matching the query
    */
-  async fetchManyByRawWhereClauseAsync(
+  async fetchManyBySQLFragmentAsync(
     queryContext: EntityQueryContext,
-    rawWhereClause: string,
-    bindings: any[] | object,
+    sqlFragment: SQLFragment<TFields>,
     querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>,
   ): Promise<readonly Readonly<TFields>[]> {
-    const results = await this.fetchManyByRawWhereClauseInternalAsync(
+    const results = await this.fetchManyBySQLFragmentInternalAsync(
       queryContext.getQueryInterface(),
       this.entityConfiguration.tableName,
-      rawWhereClause,
-      bindings,
+      sqlFragment,
       this.convertToTableQueryModifiers(querySelectionModifiers),
     );
 
@@ -244,45 +241,79 @@ export abstract class BasePostgresEntityDatabaseAdapter<
     );
   }
 
-  protected abstract fetchManyByRawWhereClauseInternalAsync(
+  protected abstract fetchManyBySQLFragmentInternalAsync(
     queryInterface: Knex,
     tableName: string,
-    rawWhereClause: string,
-    bindings: object | any[],
+    sqlFragment: SQLFragment<TFields>,
     querySelectionModifiers: TableQuerySelectionModifiers<TFields>,
   ): Promise<object[]>;
 
   /**
-   * Fetch many objects matching the SQL fragment.
+   * Count objects matching the conjunction of where clauses constructed from
+   * specified field equality operands.
    *
-   * @param queryContext - query context with which to perform the fetch
+   * @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
-   * @param querySelectionModifiers - limit, offset, and orderByFragment for the query
-   * @returns array of objects matching the query
+   * @returns count of objects matching the query
    */
-  async fetchManyBySQLFragmentAsync(
+  async countBySQLFragmentAsync(
     queryContext: EntityQueryContext,
     sqlFragment: SQLFragment<TFields>,
-    querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>,
-  ): Promise<readonly Readonly<TFields>[]> {
-    const results = await this.fetchManyBySQLFragmentInternalAsync(
+  ): Promise<number> {
+    return await this.countBySQLFragmentInternalAsync(
       queryContext.getQueryInterface(),
       this.entityConfiguration.tableName,
       sqlFragment,
-      this.convertToTableQueryModifiers(querySelectionModifiers),
-    );
-
-    return results.map((result) =>
-      transformDatabaseObjectToFields(this.entityConfiguration, this.fieldTransformerMap, result),
     );
   }
 
-  protected abstract fetchManyBySQLFragmentInternalAsync(
+  protected abstract countBySQLFragmentInternalAsync(
     queryInterface: Knex,
     tableName: string,
     sqlFragment: SQLFragment<TFields>,
-    querySelectionModifiers: TableQuerySelectionModifiers<TFields>,
-  ): Promise<object[]>;
+  ): Promise<number>;
 
   private convertToTableQueryModifiers(
     querySelectionModifiers: PostgresQuerySelectionModifiers<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

@@ -105,47 +105,29 @@ export class EnforcingKnexEntityLoader<
   }
 
   /**
-   * Load entities with a raw SQL WHERE clause.
+   * 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.
    *
-   * @example
-   * Load entities with SQL function
-   * ```typescript
-   * const entitiesWithJsonKey = await ExampleEntity.loader(vc)
-   *   .loadManyByRawWhereClauseAsync(
-   *     "json_column->>'key_name' = ?",
-   *     ['value'],
-   *   );
-   * ```
-   *
-   * @example
-   * Load entities with tuple matching
-   * ```typescript
-   * const entities = await ExampleEntity.loader(vc)
-   *   .loadManyByRawWhereClauseAsync(
-   *     '(column_1, column_2) IN ((?, ?), (?, ?))',
-   *     [value1, value2, value3, value4],
-   *   );
-   * ```
-   * @param rawWhereClause - SQL WHERE clause. Interpolated values should be specified as ?-placeholders or :key_name
-   * @param bindings - values to bind to the placeholders in the WHERE clause
-   * @param querySelectionModifiers - limit, offset, and orderBy for the query.
-   * @returns entities matching the WHERE clause
-   * @throws EntityNotAuthorizedError when viewer is not authorized to view one or more of the returned entities
-   * @throws Error when rawWhereClause or bindings are invalid
+   * @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.
    *
-   * @deprecated Use loadManyBySQL instead for safer value bindings and more flexible query building.
+   * @returns count of entities matching the query
    */
-  async loadManyByRawWhereClauseAsync(
-    rawWhereClause: string,
-    bindings: any[] | object,
-    querySelectionModifiers: EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields> = {},
-  ): Promise<readonly TEntity[]> {
-    const entityResults = await this.knexEntityLoader.loadManyByRawWhereClauseAsync(
-      rawWhereClause,
-      bindings,
-      querySelectionModifiers,
-    );
-    return entityResults.map((result) => result.enforceValue());
+  async countBySQLAsync(fragment: SQLFragment<Pick<TFields, TSelectedFields>>): Promise<number> {
+    return await this.knexEntityLoader.countBySQLAsync(fragment);
   }
 
   /**

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,41 +204,79 @@ export class PostgresEntityDatabaseAdapter<
       }
     }
 
-    query = this.applyQueryModifiersToQuery(query, querySelectionModifiers);
-    return await wrapNativePostgresCallAsync(() => query);
+    return result;
   }
 
-  protected async fetchManyByRawWhereClauseInternalAsync(
+  protected async fetchManyByFieldEqualityConjunctionInternalAsync(
     queryInterface: Knex,
     tableName: string,
-    rawWhereClause: string,
-    bindings: object | any[],
+    tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[],
+    tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[],
     querySelectionModifiers: TableQuerySelectionModifiers<TFields>,
   ): Promise<object[]> {
-    let query = queryInterface.select().from(tableName).whereRaw(rawWhereClause, bindings);
+    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,
@@ -257,10 +293,11 @@ export class PostgresEntityDatabaseAdapter<
     tableIdField: string,
     id: any,
     object: object,
-  ): Promise<object[]> {
-    return await wrapNativePostgresCallAsync(() =>
-      queryInterface.update(object).into(tableName).where(tableIdField, id).returning('*'),
+  ): Promise<{ updatedRowCount: number }> {
+    const updatedRowCount = await wrapNativePostgresCallAsync(() =>
+      queryInterface.update(object).into(tableName).where(tableIdField, id),
     );
+    return { updatedRowCount };
   }
 
   protected async deleteInternalAsync(