@nextlyhq/adapter-drizzle 0.0.2-alpha.58 → 0.0.2-alpha.60

package/dist/{adapter-DVoa72DA.d.cts → adapter-BG7MnOUw.d.cts}

@@ -498,6 +498,23 @@ declare abstract class DrizzleAdapter {
      * ```
      */
     update<T = unknown>(table: string, data: Record<string, unknown>, where: WhereClause, options?: UpdateOptions, executor?: unknown): Promise<T[]>;
+    /**
+     * Update records in a table and report how many rows the statement affected.
+     *
+     * The count is the whole return value, mirroring `delete`. `update` cannot answer this: without
+     * `returning` it discards the driver's count, and WITH `returning` on a dialect that lacks
+     * RETURNING it re-SELECTs using the same WHERE — so a conditional update that just changed a
+     * column named in that WHERE reads back zero rows and a write that landed reports as unmatched.
+     * Reading the driver's own count has no second query to disagree with the first.
+     *
+     * 🔴 MySQL reports CHANGED rows, not matched rows: an UPDATE that matches a row but writes values
+     * identical to what it holds counts zero. A caller using this as a compare-and-set must therefore
+     * include a column the write always moves — a version bump, a timestamp with enough resolution —
+     * so that matched implies changed. Postgres (`rowCount`) and SQLite (`changes`) count matched
+     * rows and do not need the precaution, which is exactly why it cannot be dropped: the dialect
+     * where the distinction exists is the one with no RETURNING to fall back on.
+     */
+    updateCount(table: string, data: Record<string, unknown>, where: WhereClause, executor?: unknown): Promise<number>;
     /**
      * Delete records from a table.
      *

package/dist/{adapter-BRcXAStD.d.ts → adapter-DjPoLjBK.d.ts}

@@ -498,6 +498,23 @@ declare abstract class DrizzleAdapter {
      * ```
      */
     update<T = unknown>(table: string, data: Record<string, unknown>, where: WhereClause, options?: UpdateOptions, executor?: unknown): Promise<T[]>;
+    /**
+     * Update records in a table and report how many rows the statement affected.
+     *
+     * The count is the whole return value, mirroring `delete`. `update` cannot answer this: without
+     * `returning` it discards the driver's count, and WITH `returning` on a dialect that lacks
+     * RETURNING it re-SELECTs using the same WHERE — so a conditional update that just changed a
+     * column named in that WHERE reads back zero rows and a write that landed reports as unmatched.
+     * Reading the driver's own count has no second query to disagree with the first.
+     *
+     * 🔴 MySQL reports CHANGED rows, not matched rows: an UPDATE that matches a row but writes values
+     * identical to what it holds counts zero. A caller using this as a compare-and-set must therefore
+     * include a column the write always moves — a version bump, a timestamp with enough resolution —
+     * so that matched implies changed. Postgres (`rowCount`) and SQLite (`changes`) count matched
+     * rows and do not need the precaution, which is exactly why it cannot be dropped: the dialect
+     * where the distinction exists is the one with no RETURNING to fall back on.
+     */
+    updateCount(table: string, data: Record<string, unknown>, where: WhereClause, executor?: unknown): Promise<number>;
     /**
      * Delete records from a table.
      *

package/dist/index.cjs

@@ -913,6 +913,42 @@ var DrizzleAdapter = class {
       void 0
     );
   }
+  /**
+   * Update records in a table and report how many rows the statement affected.
+   *
+   * The count is the whole return value, mirroring `delete`. `update` cannot answer this: without
+   * `returning` it discards the driver's count, and WITH `returning` on a dialect that lacks
+   * RETURNING it re-SELECTs using the same WHERE — so a conditional update that just changed a
+   * column named in that WHERE reads back zero rows and a write that landed reports as unmatched.
+   * Reading the driver's own count has no second query to disagree with the first.
+   *
+   * 🔴 MySQL reports CHANGED rows, not matched rows: an UPDATE that matches a row but writes values
+   * identical to what it holds counts zero. A caller using this as a compare-and-set must therefore
+   * include a column the write always moves — a version bump, a timestamp with enough resolution —
+   * so that matched implies changed. Postgres (`rowCount`) and SQLite (`changes`) count matched
+   * rows and do not need the precaution, which is exactly why it cannot be dropped: the dialect
+   * where the distinction exists is the one with no RETURNING to fall back on.
+   */
+  async updateCount(table, data, where, executor) {
+    const tableObj = this.getTableObject(table);
+    if (tableObj) {
+      try {
+        const db = executor ?? this.getDrizzle();
+        const mappedData = this.mapDataToColumnNames(tableObj, data);
+        const statement = db.update(tableObj).set(mappedData);
+        const whereCondition = buildDrizzleWhere(tableObj, where);
+        const result = await (whereCondition ? statement.where(whereCondition) : statement);
+        return affectedRowCount(result);
+      } catch (error) {
+        throw this.handleQueryError(error, "update", table);
+      }
+    }
+    throw this.createDatabaseError(
+      "query",
+      `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`,
+      void 0
+    );
+  }
   /**
    * Delete records from a table.
    *