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

package/build/src/AuthorizationResultBasedKnexEntityLoader.d.ts

@@ -235,14 +235,6 @@ 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>[]>;
-    /**
-     * 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
-     *
-     * @deprecated Use loadManyBySQL instead for safer value bindings and more flexible query building.
-     */
-    loadManyByRawWhereClauseAsync(rawWhereClause: string, bindings: any[] | object, querySelectionModifiers?: EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>): Promise<readonly Result<TEntity>[]>;
     /**
      * 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,17 +43,6 @@ export class AuthorizationResultBasedKnexEntityLoader {
         const fieldObjects = await this.knexDataManager.loadManyByFieldEqualityConjunctionAsync(this.queryContext, fieldEqualityOperands, querySelectionModifiers);
         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
-     *
-     * @deprecated Use loadManyBySQL instead for safer value bindings and more flexible query building.
-     */
-    async loadManyByRawWhereClauseAsync(rawWhereClause, bindings, querySelectionModifiers = {}) {
-        const fieldObjects = await this.knexDataManager.loadManyByRawWhereClauseAsync(this.queryContext, rawWhereClause, bindings, querySelectionModifiers);
-        return await this.constructionUtils.constructAndAuthorizeEntitiesArrayAsync(fieldObjects);
-    }
     /**
      * 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

@@ -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.
      *

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.
      *

package/build/src/EnforcingKnexEntityLoader.d.ts

@@ -38,38 +38,6 @@ 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[]>;
-    /**
-     * Load entities with a raw SQL WHERE clause.
-     *
-     * @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
-     *
-     * @deprecated Use loadManyBySQL instead for safer value bindings and more flexible query building.
-     */
-    loadManyByRawWhereClauseAsync(rawWhereClause: string, bindings: any[] | object, querySelectionModifiers?: EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>): Promise<readonly TEntity[]>;
     /**
      * 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,41 +45,6 @@ export class EnforcingKnexEntityLoader {
         const entityResults = await this.knexEntityLoader.loadManyByFieldEqualityConjunctionAsync(fieldEqualityOperands, querySelectionModifiers);
         return entityResults.map((result) => result.enforceValue());
     }
-    /**
-     * Load entities with a raw SQL WHERE clause.
-     *
-     * @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
-     *
-     * @deprecated Use loadManyBySQL instead for safer value bindings and more flexible query building.
-     */
-    async loadManyByRawWhereClauseAsync(rawWhereClause, bindings, querySelectionModifiers = {}) {
-        const entityResults = await this.knexEntityLoader.loadManyByRawWhereClauseAsync(rawWhereClause, bindings, querySelectionModifiers);
-        return entityResults.map((result) => result.enforceValue());
-    }
     /**
      * 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

@@ -13,9 +13,10 @@ export declare class PostgresEntityDatabaseAdapter<TFields extends Record<string
     protected fetchOneWhereInternalAsync(queryInterface: Knex, tableName: string, tableColumns: readonly string[], tableTuple: readonly any[]): Promise<object | null>;
     private applyQueryModifiersToQuery;
     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[]>;
     protected fetchManyBySQLFragmentInternalAsync(queryInterface: Knex, tableName: string, sqlFragment: SQLFragment<TFields>, querySelectionModifiers: TableQuerySelectionModifiers<TFields>): Promise<object[]>;
     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

@@ -133,11 +133,6 @@ export class PostgresEntityDatabaseAdapter extends BasePostgresEntityDatabaseAda
         query = this.applyQueryModifiersToQuery(query, querySelectionModifiers);
         return await wrapNativePostgresCallAsync(() => query);
     }
-    async fetchManyByRawWhereClauseInternalAsync(queryInterface, tableName, rawWhereClause, bindings, querySelectionModifiers) {
-        let query = queryInterface.select().from(tableName).whereRaw(rawWhereClause, bindings);
-        query = this.applyQueryModifiersToQuery(query, querySelectionModifiers);
-        return await wrapNativePostgresCallAsync(() => query);
-    }
     async fetchManyBySQLFragmentInternalAsync(queryInterface, tableName, sqlFragment, querySelectionModifiers) {
         let query = queryInterface
             .select()
@@ -150,7 +145,8 @@ export class PostgresEntityDatabaseAdapter extends BasePostgresEntityDatabaseAda
         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/internal/EntityKnexDataManager.d.ts

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

package/build/src/internal/EntityKnexDataManager.js

@@ -42,19 +42,6 @@ export class EntityKnexDataManager {
         EntityKnexDataManager.validateOrderByClauses(querySelectionModifiers.orderBy);
         return await timeAndLogLoadEventAsync(this.metricsAdapter, EntityMetricsLoadType.LOAD_MANY_EQUALITY_CONJUNCTION, this.entityClassName, queryContext)(this.databaseAdapter.fetchManyByFieldEqualityConjunctionAsync(queryContext, fieldEqualityOperands, querySelectionModifiers));
     }
-    /**
-     * Loads many objects matching the raw WHERE clause.
-     *
-     * @param queryContext - query context in which to perform the load
-     * @param rawWhereClause - parameterized SQL WHERE clause with positional binding placeholders or named binding placeholders
-     * @param bindings - array of positional bindings or object of named bindings
-     * @param querySelectionModifiers - limit, offset, orderBy, and orderByRaw for the query
-     * @returns array of objects matching the query
-     */
-    async loadManyByRawWhereClauseAsync(queryContext, rawWhereClause, bindings, querySelectionModifiers) {
-        EntityKnexDataManager.validateOrderByClauses(querySelectionModifiers.orderBy);
-        return await timeAndLogLoadEventAsync(this.metricsAdapter, EntityMetricsLoadType.LOAD_MANY_RAW, this.entityClassName, queryContext)(this.databaseAdapter.fetchManyByRawWhereClauseAsync(queryContext, rawWhereClause, bindings, querySelectionModifiers));
-    }
     async 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));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/entity-database-adapter-knex",
-  "version": "0.62.0",
+  "version": "0.63.0",
   "description": "Knex database adapter for @expo/entity",
   "files": [
     "build",
@@ -29,15 +29,15 @@
   "license": "MIT",
   "type": "module",
   "dependencies": {
-    "@expo/entity": "^0.62.0",
+    "@expo/entity": "^0.63.0",
     "knex": "^3.1.0"
   },
   "devDependencies": {
-    "@expo/entity-testing-utils": "^0.62.0",
+    "@expo/entity-testing-utils": "^0.63.0",
     "@jest/globals": "30.3.0",
     "pg": "8.20.0",
     "ts-mockito": "2.6.1",
     "typescript": "5.9.3"
   },
-  "gitHead": "4965cc238882982e6315beca48a68679ed45456b"
+  "gitHead": "dbd1cc847952754acc0eb407165cbb7b8350d2df"
 }

package/src/AuthorizationResultBasedKnexEntityLoader.ts

@@ -400,27 +400,6 @@ 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
-   *
-   * @deprecated Use loadManyBySQL instead for safer value bindings and more flexible query building.
-   */
-  async loadManyByRawWhereClauseAsync(
-    rawWhereClause: string,
-    bindings: any[] | object,
-    querySelectionModifiers: EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields> = {},
-  ): Promise<readonly Result<TEntity>[]> {
-    const fieldObjects = await this.knexDataManager.loadManyByRawWhereClauseAsync(
-      this.queryContext,
-      rawWhereClause,
-      bindings,
-      querySelectionModifiers,
-    );
-    return await this.constructionUtils.constructAndAuthorizeEntitiesArrayAsync(fieldObjects);
-  }
-
   /**
    * 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/src/BasePostgresEntityDatabaseAdapter.ts

@@ -216,42 +216,6 @@ export abstract class BasePostgresEntityDatabaseAdapter<
     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
-   */
-  async fetchManyByRawWhereClauseAsync(
-    queryContext: EntityQueryContext,
-    rawWhereClause: string,
-    bindings: any[] | object,
-    querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>,
-  ): Promise<readonly Readonly<TFields>[]> {
-    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),
-    );
-  }
-
-  protected abstract fetchManyByRawWhereClauseInternalAsync(
-    queryInterface: Knex,
-    tableName: string,
-    rawWhereClause: string,
-    bindings: object | any[],
-    querySelectionModifiers: TableQuerySelectionModifiers<TFields>,
-  ): Promise<object[]>;
-
   /**
    * Fetch many objects matching the SQL fragment.
    *

package/src/EnforcingKnexEntityLoader.ts

@@ -104,50 +104,6 @@ export class EnforcingKnexEntityLoader<
     return entityResults.map((result) => result.enforceValue());
   }
 
-  /**
-   * Load entities with a raw SQL WHERE clause.
-   *
-   * @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
-   *
-   * @deprecated Use loadManyBySQL instead for safer value bindings and more flexible query building.
-   */
-  async loadManyByRawWhereClauseAsync(
-    rawWhereClause: string,
-    bindings: any[] | object,
-    querySelectionModifiers: EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields> = {},
-  ): Promise<readonly TEntity[]> {
-    const entityResults = await this.knexEntityLoader.loadManyByRawWhereClauseAsync(
-      rawWhereClause,
-      bindings,
-      querySelectionModifiers,
-    );
-    return entityResults.map((result) => result.enforceValue());
-  }
-
   /**
    * Load entities using a SQL query builder. When executed, all queries will enforce authorization and throw if not authorized.
    *

package/src/PostgresEntityDatabaseAdapter.ts

@@ -210,18 +210,6 @@ export class PostgresEntityDatabaseAdapter<
     return await wrapNativePostgresCallAsync(() => query);
   }
 
-  protected async fetchManyByRawWhereClauseInternalAsync(
-    queryInterface: Knex,
-    tableName: string,
-    rawWhereClause: string,
-    bindings: object | any[],
-    querySelectionModifiers: TableQuerySelectionModifiers<TFields>,
-  ): Promise<object[]> {
-    let query = queryInterface.select().from(tableName).whereRaw(rawWhereClause, bindings);
-    query = this.applyQueryModifiersToQuery(query, querySelectionModifiers);
-    return await wrapNativePostgresCallAsync(() => query);
-  }
-
   protected async fetchManyBySQLFragmentInternalAsync(
     queryInterface: Knex,
     tableName: string,
@@ -257,10 +245,11 @@ export class PostgresEntityDatabaseAdapter<
     tableIdField: string,
     id: any,
     object: object,
-  ): Promise<object[]> {
-    return await wrapNativePostgresCallAsync(() =>
-      queryInterface.update(object).into(tableName).where(tableIdField, id).returning('*'),
+  ): Promise<{ updatedRowCount: number }> {
+    const updatedRowCount = await wrapNativePostgresCallAsync(() =>
+      queryInterface.update(object).into(tableName).where(tableIdField, id),
     );
+    return { updatedRowCount };
   }
 
   protected async deleteInternalAsync(

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 () => {

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

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