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

package/README.md

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

package/build/src/AuthorizationResultBasedKnexEntityLoader.d.ts

@@ -235,6 +235,24 @@ export declare class AuthorizationResultBasedKnexEntityLoader<TFields extends Re
      * @returns array of entity results that match the query, where result error can be UnauthorizedError
      */
     loadManyByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(fieldEqualityOperands: readonly FieldEqualityCondition<TFields, N>[], querySelectionModifiers?: EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>): Promise<readonly Result<TEntity>[]>;
+    /**
+     * 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.
+     *
+     * @returns count of entities matching the query
+     */
+    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

@@ -43,6 +43,34 @@ export class AuthorizationResultBasedKnexEntityLoader {
         const fieldObjects = await this.knexDataManager.loadManyByFieldEqualityConjunctionAsync(this.queryContext, fieldEqualityOperands, querySelectionModifiers);
         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(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.
      * @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/BasePostgresEntityDatabaseAdapter.d.ts

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

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

@@ -38,6 +38,24 @@ export declare class EnforcingKnexEntityLoader<TFields extends Record<string, an
      * @returns entities matching the filters
      */
     loadManyByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(fieldEqualityOperands: FieldEqualityCondition<TFields, N>[], querySelectionModifiers?: EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>): Promise<readonly TEntity[]>;
+    /**
+     * 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: 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.
+     *
+     * @returns count of entities matching the query
+     */
+    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

@@ -45,6 +45,28 @@ export class EnforcingKnexEntityLoader {
         const entityResults = await this.knexEntityLoader.loadManyByFieldEqualityConjunctionAsync(fieldEqualityOperands, querySelectionModifiers);
         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(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.
+     *
+     * @returns count of entities matching the query
+     */
+    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,8 +12,12 @@ 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[]>;
+    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<{
         updatedRowCount: 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,17 +130,31 @@ export class PostgresEntityDatabaseAdapter extends BasePostgresEntityDatabaseAda
                 });
             }
         }
+        return result;
+    }
+    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('*'));
     }

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,
     /**

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

@@ -88,7 +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>[]>;
+    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,10 +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));
     }
+    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.
      *
@@ -210,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.63.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.63.0",
-    "knex": "^3.1.0"
+    "@expo/entity": "^0.64.0",
+    "knex": "^3.2.9"
   },
   "devDependencies": {
-    "@expo/entity-testing-utils": "^0.63.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": "dbd1cc847952754acc0eb407165cbb7b8350d2df"
+  "gitHead": "3f10a9e70eab45ae95acdae133055d8a3ec04ce8"
 }