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

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));
@@ -284,10 +271,10 @@ export class EntityKnexDataManager {
         catch (e) {
             throw new EntityDatabaseAdapterPaginationCursorInvalidError(`Failed to decode cursor`, e instanceof Error ? e : undefined);
         }
-        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)}`);
     }
     resolveSearchFieldToSQLFragment(field, tableAlias) {
         if (field instanceof SQLFragment) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/entity-database-adapter-knex",
-  "version": "0.61.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.61.0",
+    "@expo/entity": "^0.63.0",
     "knex": "^3.1.0"
   },
   "devDependencies": {
-    "@expo/entity-testing-utils": "^0.61.0",
-    "@jest/globals": "30.2.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": "a6f1dd723262cb1c3e8022d3a8799c17602cd15b"
+  "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(