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

package/src/__tests__/SQLOperator-test.ts

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

package/src/__tests__/fixtures/StubPostgresDatabaseAdapter.ts

@@ -76,7 +76,7 @@ export class StubPostgresDatabaseAdapter<
   ): Promise<object[]> {
     const objectCollection = this.getObjectCollectionForTable(tableName);
     const results = StubPostgresDatabaseAdapter.uniqBy(tableTuples, (tuple) =>
-      tuple.join(':'),
+      JSON.stringify(tuple),
     ).reduce(
       (acc, tableTuple) => {
         return acc.concat(
@@ -193,23 +193,37 @@ export class StubPostgresDatabaseAdapter<
     return filteredObjects;
   }
 
-  protected fetchManyByRawWhereClauseInternalAsync(
+  protected fetchManyBySQLFragmentInternalAsync(
     _queryInterface: any,
     _tableName: string,
-    _rawWhereClause: string,
-    _bindings: object | any[],
+    _sqlFragment: SQLFragment<TFields>,
     _querySelectionModifiers: TableQuerySelectionModifiers<TFields>,
   ): Promise<object[]> {
-    throw new Error('Raw WHERE clauses not supported for StubDatabaseAdapter');
+    throw new Error('SQL fragments not supported for StubDatabaseAdapter');
   }
 
-  protected fetchManyBySQLFragmentInternalAsync(
+  protected async countByFieldEqualityConjunctionInternalAsync(
+    queryInterface: any,
+    tableName: string,
+    tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[],
+    tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[],
+  ): Promise<number> {
+    const results = await this.fetchManyByFieldEqualityConjunctionInternalAsync(
+      queryInterface,
+      tableName,
+      tableFieldSingleValueEqualityOperands,
+      tableFieldMultiValueEqualityOperands,
+      { orderBy: undefined, offset: undefined, limit: undefined },
+    );
+    return results.length;
+  }
+
+  protected countBySQLFragmentInternalAsync(
     _queryInterface: any,
     _tableName: string,
     _sqlFragment: SQLFragment<TFields>,
-    _querySelectionModifiers: TableQuerySelectionModifiers<TFields>,
-  ): Promise<object[]> {
-    throw new Error('SQL fragments not supported for StubDatabaseAdapter');
+  ): Promise<number> {
+    throw new Error('SQL fragment count not supported for StubDatabaseAdapter');
   }
 
   private generateRandomID(): any {
@@ -254,7 +268,7 @@ export class StubPostgresDatabaseAdapter<
     tableIdField: string,
     id: any,
     object: object,
-  ): Promise<object[]> {
+  ): Promise<{ updatedRowCount: number }> {
     // SQL does not support empty updates, mirror behavior here for better test simulation
     if (Object.keys(object).length === 0) {
       throw new Error(`Empty update (${tableIdField} = ${id})`);
@@ -269,14 +283,14 @@ export class StubPostgresDatabaseAdapter<
     // SQL updates to a nonexistent row succeed but affect 0 rows,
     // mirror that behavior here for better test simulation
     if (objectIndex < 0) {
-      return [];
+      return { updatedRowCount: 0 };
     }
 
     objectCollection[objectIndex] = {
       ...objectCollection[objectIndex],
       ...object,
     };
-    return [objectCollection[objectIndex]];
+    return { updatedRowCount: 1 };
   }
 
   protected async deleteInternalAsync(

package/src/internal/EntityKnexDataManager.ts

@@ -3,6 +3,7 @@ import {
   EntityDatabaseAdapterPaginationCursorInvalidError,
   EntityMetricsLoadType,
   getDatabaseFieldForEntityField,
+  timeAndLogCountEventAsync,
   timeAndLogLoadEventAsync,
 } from '@expo/entity';
 import assert from 'assert';
@@ -190,34 +191,19 @@ export class EntityKnexDataManager<
     );
   }
 
-  /**
-   * 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(
+  async countByFieldEqualityConjunctionAsync<N extends keyof TFields>(
     queryContext: EntityQueryContext,
-    rawWhereClause: string,
-    bindings: readonly any[] | object,
-    querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>,
-  ): Promise<readonly Readonly<TFields>[]> {
-    EntityKnexDataManager.validateOrderByClauses(querySelectionModifiers.orderBy);
-
-    return await timeAndLogLoadEventAsync(
+    fieldEqualityOperands: readonly FieldEqualityCondition<TFields, N>[],
+  ): Promise<number> {
+    return await timeAndLogCountEventAsync(
       this.metricsAdapter,
-      EntityMetricsLoadType.LOAD_MANY_RAW,
+      EntityMetricsLoadType.COUNT_EQUALITY_CONJUNCTION,
       this.entityClassName,
       queryContext,
     )(
-      this.databaseAdapter.fetchManyByRawWhereClauseAsync(
+      this.databaseAdapter.countByFieldEqualityConjunctionAsync(
         queryContext,
-        rawWhereClause,
-        bindings,
-        querySelectionModifiers,
+        fieldEqualityOperands,
       ),
     );
   }
@@ -243,6 +229,18 @@ export class EntityKnexDataManager<
     );
   }
 
+  async countBySQLFragmentAsync(
+    queryContext: EntityQueryContext,
+    sqlFragment: SQLFragment<TFields>,
+  ): Promise<number> {
+    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.
    *
@@ -482,17 +480,16 @@ export class EntityKnexDataManager<
     baseWhere: SQLFragment<TFields> | undefined,
     cursorCondition: SQLFragment<TFields> | null,
   ): SQLFragment<TFields> {
-    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}`;
   }
 
   private augmentOrderByIfNecessary(

package/src/internal/__tests__/EntityKnexDataManager-test.ts

@@ -2,17 +2,7 @@ import type { EntityQueryContext, IEntityMetricsAdapter } from '@expo/entity';
 import { EntityMetricsLoadType, NoOpEntityMetricsAdapter } from '@expo/entity';
 import { StubQueryContextProvider } from '@expo/entity-testing-utils';
 import { describe, expect, it } from '@jest/globals';
-import {
-  anyNumber,
-  anyString,
-  anything,
-  deepEqual,
-  instance,
-  mock,
-  resetCalls,
-  verify,
-  when,
-} from 'ts-mockito';
+import { anyNumber, anything, deepEqual, instance, mock, verify, when } from 'ts-mockito';
 
 import { OrderByOrdering } from '../../BasePostgresEntityDatabaseAdapter.ts';
 import { PaginationStrategy } from '../../PaginationStrategy.ts';
@@ -110,14 +100,6 @@ describe(EntityKnexDataManager, () => {
           nullableField: null,
         },
       ]);
-      when(
-        databaseAdapterMock.fetchManyByRawWhereClauseAsync(
-          anything(),
-          anyString(),
-          anything(),
-          anything(),
-        ),
-      ).thenResolve([]);
 
       const entityDataManager = new EntityKnexDataManager(
         testEntityConfiguration,
@@ -148,21 +130,6 @@ describe(EntityKnexDataManager, () => {
         ),
       ).once();
 
-      resetCalls(metricsAdapterMock);
-
-      await entityDataManager.loadManyByRawWhereClauseAsync(queryContext, '', [], {});
-      verify(
-        metricsAdapterMock.logDataManagerLoadEvent(
-          deepEqual({
-            type: EntityMetricsLoadType.LOAD_MANY_RAW,
-            isInTransaction: false,
-            entityClassName: TestEntity.name,
-            duration: anyNumber(),
-            count: 0,
-          }),
-        ),
-      ).once();
-
       verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).never();
     });
 
@@ -190,14 +157,6 @@ describe(EntityKnexDataManager, () => {
           nullableField: null,
         },
       ]);
-      when(
-        databaseAdapterMock.fetchManyByRawWhereClauseAsync(
-          anything(),
-          anyString(),
-          anything(),
-          anything(),
-        ),
-      ).thenResolve([]);
 
       const entityDataManager = new EntityKnexDataManager(
         testEntityConfiguration,
@@ -229,21 +188,6 @@ describe(EntityKnexDataManager, () => {
           ),
         ).once();
 
-        resetCalls(metricsAdapterMock);
-
-        await entityDataManager.loadManyByRawWhereClauseAsync(queryContext, '', [], {});
-        verify(
-          metricsAdapterMock.logDataManagerLoadEvent(
-            deepEqual({
-              type: EntityMetricsLoadType.LOAD_MANY_RAW,
-              isInTransaction: true,
-              entityClassName: TestEntity.name,
-              duration: anyNumber(),
-              count: 0,
-            }),
-          ),
-        ).once();
-
         verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).never();
       });
     });