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

package/src/__integration-tests__/PostgresEntityIntegration-test.ts

@@ -1085,6 +1085,49 @@ describe('postgres entity integration', () => {
       expect(results.map((e) => e.getField('name'))).toEqual(['alpha', 'gamma', 'beta']);
     });
 
+    it('supports fieldFragment orderBy with entityField', async () => {
+      const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+
+      await enforceAsyncResult(
+        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
+          .setField('name', 'alpha')
+          .setField('hasACat', true)
+          .createAsync(),
+      );
+
+      await enforceAsyncResult(
+        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
+          .setField('name', 'beta')
+          .setField('hasACat', false)
+          .createAsync(),
+      );
+
+      await enforceAsyncResult(
+        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
+          .setField('name', 'gamma')
+          .setField('hasACat', true)
+          .createAsync(),
+      );
+
+      // Order by entityField references, which translate entity field names to DB column names
+      const results = await PostgresTestEntity.knexLoader(
+        vc1,
+      ).loadManyByFieldEqualityConjunctionAsync([], {
+        orderBy: [
+          {
+            fieldFragment: sql`${entityField('hasACat')}`,
+            order: OrderByOrdering.DESCENDING,
+          },
+          {
+            fieldFragment: sql`${entityField('name')}`,
+            order: OrderByOrdering.ASCENDING,
+          },
+        ],
+      });
+      expect(results).toHaveLength(3);
+      expect(results.map((e) => e.getField('name'))).toEqual(['alpha', 'gamma', 'beta']);
+    });
+
     it('rejects fieldFragment containing trailing ASC or DESC', async () => {
       const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
 
@@ -1165,122 +1208,6 @@ describe('postgres entity integration', () => {
     });
   });
 
-  describe('raw where clause loading', () => {
-    it('loads by raw where clause', async () => {
-      const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
-      await enforceAsyncResult(
-        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
-          .setField('name', 'hello')
-          .setField('hasACat', false)
-          .setField('hasADog', true)
-          .createAsync(),
-      );
-
-      const results = await PostgresTestEntity.knexLoader(vc1).loadManyByRawWhereClauseAsync(
-        'name = ?',
-        ['hello'],
-      );
-
-      expect(results).toHaveLength(1);
-    });
-
-    it('throws with invalid where clause', async () => {
-      const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
-      await enforceAsyncResult(
-        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
-          .setField('name', 'hello')
-          .setField('hasACat', false)
-          .setField('hasADog', true)
-          .createAsync(),
-      );
-
-      await expect(
-        PostgresTestEntity.knexLoader(vc1).loadManyByRawWhereClauseAsync('invalid_column = ?', [
-          'hello',
-        ]),
-      ).rejects.toThrow();
-    });
-
-    it('supports query modifiers', async () => {
-      const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
-
-      await enforceAsyncResult(
-        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
-          .setField('name', 'a')
-          .setField('hasADog', true)
-          .createAsync(),
-      );
-
-      await enforceAsyncResult(
-        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
-          .setField('name', 'b')
-          .setField('hasADog', true)
-          .createAsync(),
-      );
-
-      await enforceAsyncResult(
-        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
-          .setField('name', 'c')
-          .setField('hasADog', true)
-          .createAsync(),
-      );
-
-      const results = await PostgresTestEntity.knexLoader(vc1).loadManyByRawWhereClauseAsync(
-        'has_a_dog = ?',
-        [true],
-        {
-          limit: 2,
-          offset: 1,
-          orderBy: [
-            {
-              fieldName: 'name',
-              order: OrderByOrdering.ASCENDING,
-            },
-          ],
-        },
-      );
-
-      expect(results).toHaveLength(2);
-      expect(results.map((e) => e.getField('name'))).toEqual(['b', 'c']);
-
-      const resultsMultipleOrderBy = await PostgresTestEntity.knexLoader(
-        vc1,
-      ).loadManyByRawWhereClauseAsync('has_a_dog = ?', [true], {
-        orderBy: [
-          {
-            fieldName: 'hasADog',
-            order: OrderByOrdering.ASCENDING,
-          },
-          {
-            fieldName: 'name',
-            order: OrderByOrdering.DESCENDING,
-          },
-        ],
-      });
-
-      expect(resultsMultipleOrderBy).toHaveLength(3);
-      expect(resultsMultipleOrderBy.map((e) => e.getField('name'))).toEqual(['c', 'b', 'a']);
-
-      const resultsOrderByRaw = await PostgresTestEntity.knexLoader(
-        vc1,
-      ).loadManyByRawWhereClauseAsync('has_a_dog = ?', [true], {
-        orderBy: [
-          {
-            fieldFragment: sql`${entityField('hasADog')}`,
-            order: OrderByOrdering.ASCENDING,
-          },
-          {
-            fieldFragment: sql`${entityField('name')}`,
-            order: OrderByOrdering.DESCENDING,
-          },
-        ],
-      });
-
-      expect(resultsOrderByRaw).toHaveLength(3);
-      expect(resultsOrderByRaw.map((e) => e.getField('name'))).toEqual(['c', 'b', 'a']);
-    });
-  });
-
   describe('trigger transaction behavior', () => {
     describe('create', () => {
       it('rolls back transaction when trigger throws except afterCommit', async () => {
@@ -2196,6 +2123,32 @@ describe('postgres entity integration', () => {
             },
           }),
         ).rejects.toThrow("Cursor is missing required 'id' field.");
+
+        // Try with valid base64-encoded JSON that decodes to a non-object primitive
+        const primitiveCursor = Buffer.from(JSON.stringify(12345)).toString('base64url');
+        await expect(
+          PostgresTestEntity.knexLoader(vc).loadPageAsync({
+            first: 10,
+            after: primitiveCursor,
+            pagination: {
+              strategy: PaginationStrategy.STANDARD,
+              orderBy: [],
+            },
+          }),
+        ).rejects.toThrow("Cursor is missing required 'id' field.");
+
+        // Try with valid base64-encoded JSON string primitive
+        const stringPrimitiveCursor = Buffer.from(JSON.stringify('hello')).toString('base64url');
+        await expect(
+          PostgresTestEntity.knexLoader(vc).loadPageAsync({
+            first: 10,
+            after: stringPrimitiveCursor,
+            pagination: {
+              strategy: PaginationStrategy.STANDARD,
+              orderBy: [],
+            },
+          }),
+        ).rejects.toThrow("Cursor is missing required 'id' field.");
       });
 
       it('performs pagination with both loader types', async () => {

package/src/__tests__/AuthorizationResultBasedKnexEntityLoader-test.ts

@@ -205,81 +205,6 @@ describe(AuthorizationResultBasedKnexEntityLoader, () => {
     ).once();
   });
 
-  it('loads entities with loadManyByRawWhereClauseAsync', async () => {
-    const privacyPolicy = new TestEntityPrivacyPolicy();
-    const spiedPrivacyPolicy = spy(privacyPolicy);
-    const viewerContext = instance(mock(ViewerContext));
-    const privacyPolicyEvaluationContext =
-      instance(
-        mock<
-          EntityPrivacyPolicyEvaluationContext<
-            TestFields,
-            'customIdField',
-            ViewerContext,
-            TestEntity
-          >
-        >(),
-      );
-    const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
-    const queryContext = instance(mock<EntityQueryContext>());
-
-    const knexDataManagerMock =
-      mock<EntityKnexDataManager<TestFields, 'customIdField'>>(EntityKnexDataManager);
-    when(
-      knexDataManagerMock.loadManyByRawWhereClauseAsync(
-        queryContext,
-        anything(),
-        anything(),
-        anything(),
-      ),
-    ).thenResolve([
-      {
-        customIdField: 'id',
-        stringField: 'huh',
-        intField: 4,
-        testIndexedField: '4',
-        dateField: new Date(),
-        nullableField: null,
-      },
-    ]);
-    const knexDataManager = instance(knexDataManagerMock);
-
-    const constructionUtils = new EntityConstructionUtils(
-      viewerContext,
-      queryContext,
-      privacyPolicyEvaluationContext,
-      testEntityConfiguration,
-      TestEntity,
-      /* entitySelectedFields */ undefined,
-      privacyPolicy,
-      metricsAdapter,
-    );
-    const knexEntityLoader = new AuthorizationResultBasedKnexEntityLoader(
-      queryContext,
-      knexDataManager,
-      metricsAdapter,
-      constructionUtils,
-    );
-
-    const result = await knexEntityLoader.loadManyByRawWhereClauseAsync('id = ?', [1], {
-      orderBy: [{ fieldName: 'testIndexedField', order: OrderByOrdering.DESCENDING }],
-    });
-    expect(result).toHaveLength(1);
-    expect(result[0]).not.toBeNull();
-    expect(result[0]!.ok).toBe(true);
-    expect(result[0]!.enforceValue().getField('testIndexedField')).toEqual('4');
-
-    verify(
-      spiedPrivacyPolicy.authorizeReadAsync(
-        viewerContext,
-        queryContext,
-        privacyPolicyEvaluationContext,
-        anyOfClass(TestEntity),
-        anything(),
-      ),
-    ).once();
-  });
-
   describe('loads entities with loadManyBySQL', () => {
     it('returns entities with authorization results', async () => {
       const privacyPolicy = new TestEntityPrivacyPolicy();

package/src/__tests__/BasePostgresEntityDatabaseAdapter-test.ts

@@ -18,9 +18,8 @@ class TestEntityDatabaseAdapter extends BasePostgresEntityDatabaseAdapter<
   private readonly fetchResults: object[];
   private readonly fetchOneResult: object | null;
   private readonly insertResults: object[];
-  private readonly updateResults: object[];
+  private readonly updateResults: { updatedRowCount: number };
   private readonly fetchEqualityConditionResults: object[];
-  private readonly fetchRawWhereResults: object[];
   private readonly fetchSQLFragmentResults: object[];
   private readonly deleteCount: number;
 
@@ -28,18 +27,16 @@ class TestEntityDatabaseAdapter extends BasePostgresEntityDatabaseAdapter<
     fetchResults = [],
     fetchOneResult = null,
     insertResults = [],
-    updateResults = [],
+    updateResults = { updatedRowCount: 0 },
     fetchEqualityConditionResults = [],
-    fetchRawWhereResults = [],
     fetchSQLFragmentResults = [],
     deleteCount = 0,
   }: {
     fetchResults?: object[];
     fetchOneResult?: object | null;
     insertResults?: object[];
-    updateResults?: object[];
+    updateResults?: { updatedRowCount: number };
     fetchEqualityConditionResults?: object[];
-    fetchRawWhereResults?: object[];
     fetchSQLFragmentResults?: object[];
     deleteCount?: number;
   }) {
@@ -49,7 +46,6 @@ class TestEntityDatabaseAdapter extends BasePostgresEntityDatabaseAdapter<
     this.insertResults = insertResults;
     this.updateResults = updateResults;
     this.fetchEqualityConditionResults = fetchEqualityConditionResults;
-    this.fetchRawWhereResults = fetchRawWhereResults;
     this.fetchSQLFragmentResults = fetchSQLFragmentResults;
     this.deleteCount = deleteCount;
   }
@@ -76,15 +72,6 @@ class TestEntityDatabaseAdapter extends BasePostgresEntityDatabaseAdapter<
     return this.fetchOneResult;
   }
 
-  protected async fetchManyByRawWhereClauseInternalAsync(
-    _queryInterface: any,
-    _tableName: string,
-    _rawWhereClause: string,
-    _bindings: object | any[],
-  ): Promise<object[]> {
-    return this.fetchRawWhereResults;
-  }
-
   protected async fetchManyBySQLFragmentInternalAsync(
     _queryInterface: any,
     _tableName: string,
@@ -116,7 +103,7 @@ class TestEntityDatabaseAdapter extends BasePostgresEntityDatabaseAdapter<
     _tableIdField: string,
     _id: any,
     _object: object,
-  ): Promise<object[]> {
+  ): Promise<{ updatedRowCount: number }> {
     return this.updateResults;
   }
 
@@ -148,15 +135,4 @@ describe(BasePostgresEntityDatabaseAdapter, () => {
       expect(results).toEqual([{ stringField: 'hello' }]);
     });
   });
-
-  describe('fetchManyWithRawWhereClause', () => {
-    it('transforms object', async () => {
-      const queryContext = instance(mock(EntityQueryContext));
-      const adapter = new TestEntityDatabaseAdapter({
-        fetchRawWhereResults: [{ string_field: 'hello' }],
-      });
-      const results = await adapter.fetchManyByRawWhereClauseAsync(queryContext, 'hello', [], {});
-      expect(results).toEqual([{ stringField: 'hello' }]);
-    });
-  });
 });

package/src/__tests__/EnforcingKnexEntityLoader-test.ts

@@ -137,58 +137,6 @@ describe(EnforcingKnexEntityLoader, () => {
     });
   });
 
-  describe('loadManyByRawWhereClause', () => {
-    it('throws when result is unsuccessful', async () => {
-      const nonEnforcingKnexEntityLoaderMock = mock(
-        AuthorizationResultBasedKnexEntityLoader<any, any, any, any, any, any>,
-      );
-      const rejection = new Error();
-      when(
-        nonEnforcingKnexEntityLoaderMock.loadManyByRawWhereClauseAsync(
-          anything(),
-          anything(),
-          anything(),
-        ),
-      ).thenResolve([result(rejection)]);
-      const nonEnforcingKnexEntityLoader = instance(nonEnforcingKnexEntityLoaderMock);
-      const enforcingKnexEntityLoader = new EnforcingKnexEntityLoader(
-        nonEnforcingKnexEntityLoader,
-        instance(mock(EntityQueryContext)),
-        instance(mock(EntityKnexDataManager)),
-        instance(mock<IEntityMetricsAdapter>()),
-        instance(mock(EntityConstructionUtils)),
-      );
-      await expect(
-        enforcingKnexEntityLoader.loadManyByRawWhereClauseAsync(anything(), anything(), anything()),
-      ).rejects.toThrow(rejection);
-    });
-
-    it('returns value when result is successful', async () => {
-      const nonEnforcingKnexEntityLoaderMock = mock(
-        AuthorizationResultBasedKnexEntityLoader<any, any, any, any, any, any>,
-      );
-      const resolved = {};
-      when(
-        nonEnforcingKnexEntityLoaderMock.loadManyByRawWhereClauseAsync(
-          anything(),
-          anything(),
-          anything(),
-        ),
-      ).thenResolve([result(resolved)]);
-      const nonEnforcingKnexEntityLoader = instance(nonEnforcingKnexEntityLoaderMock);
-      const enforcingKnexEntityLoader = new EnforcingKnexEntityLoader(
-        nonEnforcingKnexEntityLoader,
-        instance(mock(EntityQueryContext)),
-        instance(mock(EntityKnexDataManager)),
-        instance(mock<IEntityMetricsAdapter>()),
-        instance(mock(EntityConstructionUtils)),
-      );
-      await expect(
-        enforcingKnexEntityLoader.loadManyByRawWhereClauseAsync(anything(), anything(), anything()),
-      ).resolves.toEqual([resolved]);
-    });
-  });
-
   describe('loadManyBySQL', () => {
     it('throws when result is unsuccessful', async () => {
       const nonEnforcingKnexEntityLoaderMock = mock(

package/src/__tests__/fixtures/StubPostgresDatabaseAdapter.ts

@@ -193,16 +193,6 @@ export class StubPostgresDatabaseAdapter<
     return filteredObjects;
   }
 
-  protected fetchManyByRawWhereClauseInternalAsync(
-    _queryInterface: any,
-    _tableName: string,
-    _rawWhereClause: string,
-    _bindings: object | any[],
-    _querySelectionModifiers: TableQuerySelectionModifiers<TFields>,
-  ): Promise<object[]> {
-    throw new Error('Raw WHERE clauses not supported for StubDatabaseAdapter');
-  }
-
   protected fetchManyBySQLFragmentInternalAsync(
     _queryInterface: any,
     _tableName: string,
@@ -254,7 +244,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 +259,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

@@ -190,38 +190,6 @@ 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(
-    queryContext: EntityQueryContext,
-    rawWhereClause: string,
-    bindings: readonly any[] | object,
-    querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>,
-  ): Promise<readonly Readonly<TFields>[]> {
-    EntityKnexDataManager.validateOrderByClauses(querySelectionModifiers.orderBy);
-
-    return await timeAndLogLoadEventAsync(
-      this.metricsAdapter,
-      EntityMetricsLoadType.LOAD_MANY_RAW,
-      this.entityClassName,
-      queryContext,
-    )(
-      this.databaseAdapter.fetchManyByRawWhereClauseAsync(
-        queryContext,
-        rawWhereClause,
-        bindings,
-        querySelectionModifiers,
-      ),
-    );
-  }
-
   async loadManyBySQLFragmentAsync(
     queryContext: EntityQueryContext,
     sqlFragment: SQLFragment<TFields>,
@@ -559,6 +527,7 @@ export class EntityKnexDataManager<
 
   private decodeOpaqueCursor(cursor: string): TFields[TIDField] {
     let parsedCursor: any;
+
     try {
       const decoded = Buffer.from(cursor, 'base64url').toString();
       parsedCursor = JSON.parse(decoded);
@@ -569,13 +538,13 @@ export class EntityKnexDataManager<
       );
     }
 
-    if (!('id' in parsedCursor)) {
-      throw new EntityDatabaseAdapterPaginationCursorInvalidError(
-        `Cursor is missing required 'id' field. Parsed cursor: ${JSON.stringify(parsedCursor)}`,
-      );
+    if (typeof parsedCursor === 'object' && 'id' in parsedCursor) {
+      return parsedCursor.id;
     }
 
-    return parsedCursor.id;
+    throw new EntityDatabaseAdapterPaginationCursorInvalidError(
+      `Cursor is missing required 'id' field. Parsed cursor: ${JSON.stringify(parsedCursor)}`,
+    );
   }
 
   private resolveSearchFieldToSQLFragment(

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