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

package/README.md

@@ -39,4 +39,4 @@ export const createDefaultEntityCompanionProvider = (
     }
   );
 };
-```
+```

package/build/src/AuthorizationResultBasedKnexEntityLoader.d.ts

@@ -236,13 +236,23 @@ export declare class AuthorizationResultBasedKnexEntityLoader<TFields extends Re
      */
     loadManyByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(fieldEqualityOperands: readonly FieldEqualityCondition<TFields, N>[], querySelectionModifiers?: EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>): Promise<readonly Result<TEntity>[]>;
     /**
-     * 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.
+     *
+     * @returns count of entities matching the filters
+     */
+    countByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(fieldEqualityOperands: readonly FieldEqualityCondition<TFields, N>[]): Promise<number>;
+    /**
+     * 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.
      *
-     * @deprecated Use loadManyBySQL instead for safer value bindings and more flexible query building.
+     * @returns count of entities matching the query
      */
-    loadManyByRawWhereClauseAsync(rawWhereClause: string, bindings: any[] | object, querySelectionModifiers?: EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>): Promise<readonly Result<TEntity>[]>;
+    countBySQLAsync(fragment: SQLFragment<Pick<TFields, TSelectedFields>>): Promise<number>;
     /**
      * 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/build/src/AuthorizationResultBasedKnexEntityLoader.js

@@ -44,15 +44,32 @@ export class AuthorizationResultBasedKnexEntityLoader {
         return await this.constructionUtils.constructAndAuthorizeEntitiesArrayAsync(fieldObjects);
     }
     /**
-     * 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, bindings, querySelectionModifiers = {}) {
-        const fieldObjects = await this.knexDataManager.loadManyByRawWhereClauseAsync(this.queryContext, rawWhereClause, bindings, querySelectionModifiers);
-        return await this.constructionUtils.constructAndAuthorizeEntitiesArrayAsync(fieldObjects);
+    async countByFieldEqualityConjunctionAsync(fieldEqualityOperands) {
+        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) {
+        return await this.knexDataManager.countBySQLFragmentAsync(this.queryContext, fragment);
     }
     /**
      * Authorization-result-based version of the EnforcingKnexEntityLoader method by the same name.

package/build/src/BasePostgresEntityDatabaseAdapter.d.ts

@@ -126,17 +126,6 @@ export declare abstract class BasePostgresEntityDatabaseAdapter<TFields extends
      */
     fetchManyByFieldEqualityConjunctionAsync<N extends keyof TFields>(queryContext: EntityQueryContext, fieldEqualityOperands: readonly FieldEqualityCondition<TFields, N>[], querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>): Promise<readonly Readonly<TFields>[]>;
     protected abstract fetchManyByFieldEqualityConjunctionInternalAsync(queryInterface: Knex, tableName: string, tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[], tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[], querySelectionModifiers: TableQuerySelectionModifiers<TFields>): Promise<object[]>;
-    /**
-     * Fetch many objects matching the raw WHERE clause.
-     *
-     * @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
-     * @returns array of objects matching the query
-     */
-    fetchManyByRawWhereClauseAsync(queryContext: EntityQueryContext, rawWhereClause: string, bindings: any[] | object, querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>): Promise<readonly Readonly<TFields>[]>;
-    protected abstract fetchManyByRawWhereClauseInternalAsync(queryInterface: Knex, tableName: string, rawWhereClause: string, bindings: object | any[], querySelectionModifiers: TableQuerySelectionModifiers<TFields>): Promise<object[]>;
     /**
      * Fetch many objects matching the SQL fragment.
      *
@@ -147,5 +136,24 @@ export declare abstract class BasePostgresEntityDatabaseAdapter<TFields extends
      */
     fetchManyBySQLFragmentAsync(queryContext: EntityQueryContext, sqlFragment: SQLFragment<TFields>, querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>): Promise<readonly Readonly<TFields>[]>;
     protected abstract fetchManyBySQLFragmentInternalAsync(queryInterface: Knex, tableName: string, sqlFragment: SQLFragment<TFields>, 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
+     */
+    countByFieldEqualityConjunctionAsync<N extends keyof TFields>(queryContext: EntityQueryContext, fieldEqualityOperands: readonly FieldEqualityCondition<TFields, N>[]): Promise<number>;
+    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
+     */
+    countBySQLFragmentAsync(queryContext: EntityQueryContext, sqlFragment: SQLFragment<TFields>): Promise<number>;
+    protected abstract countBySQLFragmentInternalAsync(queryInterface: Knex, tableName: string, sqlFragment: SQLFragment<TFields>): Promise<number>;
     private convertToTableQueryModifiers;
 }

package/build/src/BasePostgresEntityDatabaseAdapter.js

@@ -60,19 +60,6 @@ export class BasePostgresEntityDatabaseAdapter extends EntityDatabaseAdapter {
         const results = await this.fetchManyByFieldEqualityConjunctionInternalAsync(queryContext.getQueryInterface(), this.entityConfiguration.tableName, tableFieldSingleValueOperands, tableFieldMultipleValueOperands, this.convertToTableQueryModifiers(querySelectionModifiers));
         return results.map((result) => transformDatabaseObjectToFields(this.entityConfiguration, this.fieldTransformerMap, result));
     }
-    /**
-     * Fetch many objects matching the raw WHERE clause.
-     *
-     * @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
-     * @returns array of objects matching the query
-     */
-    async fetchManyByRawWhereClauseAsync(queryContext, rawWhereClause, bindings, querySelectionModifiers) {
-        const results = await this.fetchManyByRawWhereClauseInternalAsync(queryContext.getQueryInterface(), this.entityConfiguration.tableName, rawWhereClause, bindings, this.convertToTableQueryModifiers(querySelectionModifiers));
-        return results.map((result) => transformDatabaseObjectToFields(this.entityConfiguration, this.fieldTransformerMap, result));
-    }
     /**
      * Fetch many objects matching the SQL fragment.
      *
@@ -85,6 +72,43 @@ export class BasePostgresEntityDatabaseAdapter extends EntityDatabaseAdapter {
         const results = await this.fetchManyBySQLFragmentInternalAsync(queryContext.getQueryInterface(), this.entityConfiguration.tableName, sqlFragment, this.convertToTableQueryModifiers(querySelectionModifiers));
         return results.map((result) => transformDatabaseObjectToFields(this.entityConfiguration, this.fieldTransformerMap, result));
     }
+    /**
+     * 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(queryContext, fieldEqualityOperands) {
+        const tableFieldSingleValueOperands = [];
+        const tableFieldMultipleValueOperands = [];
+        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);
+    }
+    /**
+     * 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, sqlFragment) {
+        return await this.countBySQLFragmentInternalAsync(queryContext.getQueryInterface(), this.entityConfiguration.tableName, sqlFragment);
+    }
     convertToTableQueryModifiers(querySelectionModifiers) {
         const orderBy = querySelectionModifiers.orderBy;
         return {

package/build/src/BaseSQLQueryBuilder.d.ts

@@ -25,7 +25,7 @@ export declare abstract class BaseSQLQueryBuilder<TFields extends Record<string,
     /**
      * Order by a field. Can be called multiple times to add multiple order bys.
      */
-    orderBy(fieldName: TSelectedFields, order?: OrderByOrdering, nulls?: NullsOrdering | undefined): this;
+    orderBy(fieldName: TSelectedFields, order?: OrderByOrdering, nulls?: NullsOrdering): this;
     /**
      * Order by a SQL fragment expression.
      * Provides type-safe, parameterized ORDER BY clauses
@@ -44,7 +44,7 @@ export declare abstract class BaseSQLQueryBuilder<TFields extends Record<string,
      * @param fragment - The SQL fragment to order by. Must not include the ASC/DESC keyword, as ordering direction is determined by the `order` parameter.
      * @param order - The ordering direction (ascending or descending). Defaults to ascending.
      */
-    orderBySQL(fragment: SQLFragment<Pick<TFields, TSelectedFields>>, order?: OrderByOrdering, nulls?: NullsOrdering | undefined): this;
+    orderBySQL(fragment: SQLFragment<Pick<TFields, TSelectedFields>>, order?: OrderByOrdering, nulls?: NullsOrdering): this;
     /**
      * Get the current modifiers as QuerySelectionModifiersWithOrderByFragment<TFields>
      */

package/build/src/BaseSQLQueryBuilder.js

@@ -27,7 +27,7 @@ export class BaseSQLQueryBuilder {
     /**
      * Order by a field. Can be called multiple times to add multiple order bys.
      */
-    orderBy(fieldName, order = OrderByOrdering.ASCENDING, nulls = undefined) {
+    orderBy(fieldName, order = OrderByOrdering.ASCENDING, nulls) {
         this.modifiers.orderBy = [...(this.modifiers.orderBy ?? []), { fieldName, order, nulls }];
         return this;
     }
@@ -49,7 +49,7 @@ export class BaseSQLQueryBuilder {
      * @param fragment - The SQL fragment to order by. Must not include the ASC/DESC keyword, as ordering direction is determined by the `order` parameter.
      * @param order - The ordering direction (ascending or descending). Defaults to ascending.
      */
-    orderBySQL(fragment, order = OrderByOrdering.ASCENDING, nulls = undefined) {
+    orderBySQL(fragment, order = OrderByOrdering.ASCENDING, nulls) {
         this.modifiers.orderBy = [
             ...(this.modifiers.orderBy ?? []),
             { fieldFragment: fragment, order, nulls },

package/build/src/EnforcingKnexEntityLoader.d.ts

@@ -39,37 +39,23 @@ export declare class EnforcingKnexEntityLoader<TFields extends Record<string, an
      */
     loadManyByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(fieldEqualityOperands: FieldEqualityCondition<TFields, N>[], querySelectionModifiers?: EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>): Promise<readonly TEntity[]>;
     /**
-     * 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
+     */
+    countByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(fieldEqualityOperands: FieldEqualityCondition<TFields, N>[]): Promise<number>;
+    /**
+     * 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
      */
-    loadManyByRawWhereClauseAsync(rawWhereClause: string, bindings: any[] | object, querySelectionModifiers?: EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>): Promise<readonly TEntity[]>;
+    countBySQLAsync(fragment: SQLFragment<Pick<TFields, TSelectedFields>>): Promise<number>;
     /**
      * Load entities using a SQL query builder. When executed, all queries will enforce authorization and throw if not authorized.
      *

package/build/src/EnforcingKnexEntityLoader.js

@@ -46,39 +46,26 @@ export class EnforcingKnexEntityLoader {
         return entityResults.map((result) => result.enforceValue());
     }
     /**
-     * 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(fieldEqualityOperands) {
+        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, bindings, querySelectionModifiers = {}) {
-        const entityResults = await this.knexEntityLoader.loadManyByRawWhereClauseAsync(rawWhereClause, bindings, querySelectionModifiers);
-        return entityResults.map((result) => result.enforceValue());
+    async countBySQLAsync(fragment) {
+        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/build/src/PostgresEntityDatabaseAdapter.d.ts

@@ -12,10 +12,15 @@ export declare class PostgresEntityDatabaseAdapter<TFields extends Record<string
     protected fetchManyWhereInternalAsync(queryInterface: Knex, tableName: string, tableColumns: readonly string[], tableTuples: any[][]): Promise<object[]>;
     protected fetchOneWhereInternalAsync(queryInterface: Knex, tableName: string, tableColumns: readonly string[], tableTuple: readonly any[]): Promise<object | null>;
     private applyQueryModifiersToQuery;
+    private applyFieldEqualityConjunctionWhereClause;
     protected fetchManyByFieldEqualityConjunctionInternalAsync(queryInterface: Knex, tableName: string, tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[], tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[], querySelectionModifiers: TableQuerySelectionModifiers<TFields>): Promise<object[]>;
-    protected fetchManyByRawWhereClauseInternalAsync(queryInterface: Knex, tableName: string, rawWhereClause: string, bindings: object | any[], querySelectionModifiers: TableQuerySelectionModifiers<TFields>): Promise<object[]>;
+    private applySQLFragmentWhereClause;
     protected fetchManyBySQLFragmentInternalAsync(queryInterface: Knex, tableName: string, sqlFragment: SQLFragment<TFields>, querySelectionModifiers: TableQuerySelectionModifiers<TFields>): Promise<object[]>;
+    protected countByFieldEqualityConjunctionInternalAsync(queryInterface: Knex, tableName: string, tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[], tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[]): Promise<number>;
+    protected countBySQLFragmentInternalAsync(queryInterface: Knex, tableName: string, sqlFragment: SQLFragment<TFields>): Promise<number>;
     protected insertInternalAsync(queryInterface: Knex, tableName: string, object: object): Promise<object[]>;
-    protected updateInternalAsync(queryInterface: Knex, tableName: string, tableIdField: string, id: any, object: object): Promise<object[]>;
+    protected updateInternalAsync(queryInterface: Knex, tableName: string, tableIdField: string, id: any, object: object): Promise<{
+        updatedRowCount: number;
+    }>;
     protected deleteInternalAsync(queryInterface: Knex, tableName: string, tableIdField: string, id: any): Promise<number>;
 }

package/build/src/PostgresEntityDatabaseAdapter.js

@@ -1,4 +1,4 @@
-import { getDatabaseFieldForEntityField } from '@expo/entity';
+import { getDatabaseFieldForEntityField, RESERVED_ENTITY_COUNT_QUERY_ALIAS } from '@expo/entity';
 import { BasePostgresEntityDatabaseAdapter, NullsOrdering, OrderByOrdering, } from "./BasePostgresEntityDatabaseAdapter.js";
 import { JSONArrayField, MaybeJSONArrayField } from "./EntityFields.js";
 import { wrapNativePostgresCallAsync } from "./errors/wrapNativePostgresCallAsync.js";
@@ -100,8 +100,8 @@ export class PostgresEntityDatabaseAdapter extends BasePostgresEntityDatabaseAda
         }
         return ret;
     }
-    async fetchManyByFieldEqualityConjunctionInternalAsync(queryInterface, tableName, tableFieldSingleValueEqualityOperands, tableFieldMultiValueEqualityOperands, querySelectionModifiers) {
-        let query = queryInterface.select().from(tableName);
+    applyFieldEqualityConjunctionWhereClause(query, tableFieldSingleValueEqualityOperands, tableFieldMultiValueEqualityOperands) {
+        let result = query;
         if (tableFieldSingleValueEqualityOperands.length > 0) {
             const whereObject = {};
             const nonNullTableFieldSingleValueEqualityOperands = tableFieldSingleValueEqualityOperands.filter(({ tableValue }) => tableValue !== null);
@@ -110,18 +110,18 @@ export class PostgresEntityDatabaseAdapter extends BasePostgresEntityDatabaseAda
                 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);
                 }
             }
         }
         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) {
@@ -130,27 +130,37 @@ export class PostgresEntityDatabaseAdapter extends BasePostgresEntityDatabaseAda
                 });
             }
         }
-        query = this.applyQueryModifiersToQuery(query, querySelectionModifiers);
-        return await wrapNativePostgresCallAsync(() => query);
+        return result;
     }
-    async fetchManyByRawWhereClauseInternalAsync(queryInterface, tableName, rawWhereClause, bindings, querySelectionModifiers) {
-        let query = queryInterface.select().from(tableName).whereRaw(rawWhereClause, bindings);
+    async fetchManyByFieldEqualityConjunctionInternalAsync(queryInterface, tableName, tableFieldSingleValueEqualityOperands, tableFieldMultiValueEqualityOperands, querySelectionModifiers) {
+        let query = this.applyFieldEqualityConjunctionWhereClause(queryInterface.select().from(tableName), tableFieldSingleValueEqualityOperands, tableFieldMultiValueEqualityOperands);
         query = this.applyQueryModifiersToQuery(query, querySelectionModifiers);
         return await wrapNativePostgresCallAsync(() => query);
     }
+    applySQLFragmentWhereClause(query, sqlFragment) {
+        return query.whereRaw(sqlFragment.sql, sqlFragment.getKnexBindings((fieldName) => getDatabaseFieldForEntityField(this.entityConfiguration, fieldName)));
+    }
     async fetchManyBySQLFragmentInternalAsync(queryInterface, tableName, sqlFragment, querySelectionModifiers) {
-        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);
     }
+    async countByFieldEqualityConjunctionInternalAsync(queryInterface, tableName, tableFieldSingleValueEqualityOperands, tableFieldMultiValueEqualityOperands) {
+        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);
+    }
+    async countBySQLFragmentInternalAsync(queryInterface, tableName, sqlFragment) {
+        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);
+    }
     async insertInternalAsync(queryInterface, tableName, object) {
         return await wrapNativePostgresCallAsync(() => queryInterface.insert(object).into(tableName).returning('*'));
     }
     async updateInternalAsync(queryInterface, tableName, tableIdField, id, object) {
-        return await wrapNativePostgresCallAsync(() => queryInterface.update(object).into(tableName).where(tableIdField, id).returning('*'));
+        const updatedRowCount = await wrapNativePostgresCallAsync(() => queryInterface.update(object).into(tableName).where(tableIdField, id));
+        return { updatedRowCount };
     }
     async deleteInternalAsync(queryInterface, tableName, tableIdField, id) {
         return await wrapNativePostgresCallAsync(() => queryInterface.into(tableName).where(tableIdField, id).del());

package/build/src/SQLOperator.d.ts

@@ -1,8 +1,9 @@
+import type { Knex } from 'knex';
 /**
  * Supported SQL value types that can be safely parameterized.
  * This ensures type safety and prevents passing unsupported types to SQL queries.
  */
-export type SupportedSQLValue = string | number | boolean | null | Date | Buffer | bigint | undefined | readonly SupportedSQLValue[] | Readonly<{
+export type SupportedSQLValue = string | number | boolean | null | Date | Buffer | bigint | readonly SupportedSQLValue[] | Readonly<{
     [key: string]: unknown;
 }>;
 /**
@@ -31,7 +32,7 @@ export declare class SQLFragment<TFields extends Record<string, any>> {
      *
      * @param getColumnForField - function that resolves an entity field name to its database column name
      */
-    getKnexBindings(getColumnForField: (fieldName: keyof TFields) => string): readonly SupportedSQLValue[];
+    getKnexBindings(getColumnForField: (fieldName: keyof TFields) => string): readonly Knex.RawBinding[];
     /**
      * Combine SQL fragments
      */
@@ -161,7 +162,7 @@ type PickSupportedSQLValueKeys<T> = {
     [K in keyof T]: T[K] extends SupportedSQLValue ? K : never;
 }[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 = string | number | boolean | null | undefined | readonly JsonSerializable[] | {
     readonly [key: string]: JsonSerializable;
@@ -175,20 +176,20 @@ type JsonSerializable = string | number | boolean | null | undefined | readonly
 export declare class SQLChainableFragment<TFields extends Record<string, any>, TValue extends SupportedSQLValue> 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>;
+    eq(value: TValue | null): SQLFragment<TFields>;
     /**
      * 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>;
+    neq(value: TValue | null): SQLFragment<TFields>;
     /**
      * Generates a greater-than condition (`> value`).
      *
@@ -312,7 +313,7 @@ declare const ALLOWED_CAST_TYPES: readonly ["int", "integer", "int2", "int4", "i
  */
 export type PostgresCastType = (typeof ALLOWED_CAST_TYPES)[number];
 type ExtractFragmentFields<T> = T extends SQLFragment<infer F> ? F : never;
-type FragmentValueNullable<TFragment> = TFragment extends SQLChainableFragment<any, infer TValue> ? TValue | null | undefined : SupportedSQLValue;
+type FragmentValueNullable<TFragment> = TFragment extends SQLChainableFragment<any, infer TValue> ? TValue | null : SupportedSQLValue;
 type FragmentValue<TFragment> = TFragment extends SQLChainableFragment<any, infer TValue> ? TValue : SupportedSQLValue;
 type FragmentValueArray<TFragment> = TFragment extends SQLChainableFragment<any, infer TValue> ? readonly TValue[] : readonly SupportedSQLValue[];
 /**
@@ -477,7 +478,7 @@ declare function isNotNullHelper<TFragment extends SQLFragment<any>>(fragment: T
 declare function isNotNullHelper<TFields extends Record<string, any>, N extends keyof TFields>(fieldName: N): SQLFragment<TFields>;
 /**
  * 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
@@ -485,7 +486,7 @@ declare function isNotNullHelper<TFields extends Record<string, any>, N extends
 declare function eqHelper<TFragment extends SQLFragment<any>>(fragment: TFragment, value: FragmentValueNullable<TFragment>): 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
@@ -493,7 +494,7 @@ declare function eqHelper<TFragment extends SQLFragment<any>>(fragment: TFragmen
 declare function eqHelper<TFields extends Record<string, any>, N extends PickSupportedSQLValueKeys<TFields>>(fieldName: N, value: TFields[N]): SQLFragment<TFields>;
 /**
  * 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
@@ -501,7 +502,7 @@ declare function eqHelper<TFields extends Record<string, any>, N extends PickSup
 declare function neqHelper<TFragment extends SQLFragment<any>>(fragment: TFragment, value: FragmentValueNullable<TFragment>): 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
@@ -804,11 +805,11 @@ export declare const SQLExpression: {
      */
     isNotNull: typeof isNotNullHelper;
     /**
-     * Equality operator. Automatically converts null/undefined to IS NULL.
+     * Equality operator. Automatically converts null to IS NULL.
      */
     eq: typeof eqHelper;
     /**
-     * Inequality operator. Automatically converts null/undefined to IS NOT NULL.
+     * Inequality operator. Automatically converts null to IS NOT NULL.
      */
     neq: typeof neqHelper;
     /**

package/build/src/SQLOperator.js

@@ -23,6 +23,9 @@ export class SQLFragment {
                 case 'identifier':
                     return b.name;
                 case '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;
             }
         });
@@ -98,8 +101,8 @@ export class SQLFragment {
      * Handles all SupportedSQLValue types.
      */
     static formatDebugValue(value) {
-        // Handle null and undefined
-        if (value === null || value === undefined) {
+        // Handle null
+        if (value === null) {
             return 'NULL';
         }
         // Handle primitives
@@ -299,26 +302,26 @@ export function sql(strings, ...values) {
 export class SQLChainableFragment extends SQLFragment {
     /**
      * 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) {
-        if (value === null || value === undefined) {
+        if (value === null) {
             return this.isNull();
         }
         return sql `${this} = ${value}`;
     }
     /**
      * 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) {
-        if (value === null || value === undefined) {
+        if (value === null) {
             return this.isNotNull();
         }
         return sql `${this} != ${value}`;
@@ -717,11 +720,11 @@ 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,
     /**