@object-ui/data-objectstack 5.1.1 → 5.3.0

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # @object-ui/data-objectstack
 
+## 5.3.0
+
+### Patch Changes
+
+- @object-ui/types@5.3.0
+- @object-ui/core@5.3.0
+
+## 5.2.1
+
+### Patch Changes
+
+- @object-ui/types@5.2.1
+- @object-ui/core@5.2.1
+
+## 5.2.0
+
+### Minor Changes
+
+- de0c5e6: Add `DataSource.bulkDelete(resource, ids)` as the symmetric counterpart
+  to `bulkUpdate`. Implemented in `data-objectstack` via the client's
+  `deleteMany` primitive with a per-id fallback that emulates
+  `continueOnError` semantics for older clients.
+
+  Extract the bulk-vs-per-row decision into a reusable
+  `executeBulkBatch(input, ops)` helper in `@object-ui/core`:
+  - Single decision tree shared by both update and delete fast paths.
+  - Bulk success → no per-row pass.
+  - Bulk partial-count → aggregate batch error.
+  - Bulk throw → per-row fallback so users still get id-level error detail.
+
+  `useBulkExecutor` in plugin-grid now uses the helper for both `update`
+  and `delete` batches, cutting "delete 500 selected rows" from 500 HTTP
+  requests down to ~3.
+
+- 9997cae: DataSource: add optional `bulkUpdate(resource, ids, patch)` for "same patch, many rows" interactions (Slack "mark all as read", Linear "archive selected"). The ObjectStack adapter routes to `POST /api/v1/data/:object/updateMany` so the client pays one HTTP/auth/RLS round-trip instead of N parallel PATCHes, eliminating mark-all-read jank on inboxes with 50+ unread.
+
+  AppHeader's `markAllRead` now prefers `bulkUpdate`, with a transparent fallback to the per-id loop for adapters that don't implement the helper.
+
+### Patch Changes
+
+- Updated dependencies [de0c5e6]
+- Updated dependencies [9997cae]
+- Updated dependencies [70b5570]
+- Updated dependencies [d1442e3]
+  - @object-ui/types@5.2.0
+  - @object-ui/core@5.2.0
+
 ## 5.1.1
 
 ### Patch Changes

package/dist/index.cjs

@@ -1368,6 +1368,82 @@ var ObjectStackAdapter = class {
       throw normaliseClientError(err);
     }
   }
+  /**
+   * Apply the same patch to many records in a single round-trip.
+   *
+   * Sends one `POST /api/v1/data/:object/updateMany` request whose body
+   * is `{ records: ids.map(id => ({id, data: patch})), options: { continueOnError: true }}`.
+   * The server iterates server-side (still N engine writes) but the
+   * client only pays for ONE HTTP/auth/RLS round-trip — the relevant
+   * perf win for inbox / list-toolbar "mark all read" / "archive
+   * selected" interactions where N can easily be in the hundreds.
+   *
+   * Falls back to a sequential per-id loop when the connected client
+   * does not expose `updateMany` (older clients / offline adapters).
+   * In that case `continueOnError` semantics are emulated locally so
+   * callers see the same return shape.
+   */
+  async bulkUpdate(resource, ids, patch) {
+    await this.connect();
+    if (!ids || ids.length === 0) return 0;
+    const records = ids.map((id) => ({ id: String(id), data: patch }));
+    const updateMany = this.client.data.updateMany;
+    if (typeof updateMany === "function") {
+      try {
+        const res = await updateMany(resource, records, { continueOnError: true });
+        if (res && typeof res === "object" && typeof res.succeeded === "number") {
+          return res.succeeded;
+        }
+        if (Array.isArray(res)) return res.length;
+        return ids.length;
+      } catch (err) {
+        throw normaliseClientError(err);
+      }
+    }
+    let succeeded = 0;
+    for (const id of ids) {
+      try {
+        await this.client.data.update(resource, String(id), patch);
+        succeeded++;
+      } catch {
+      }
+    }
+    return succeeded;
+  }
+  /**
+   * Single-call bulk delete. Mirrors the bulkUpdate contract: prefers
+   * the server's `deleteMany` primitive when the client supports it;
+   * otherwise emulates `continueOnError` by looping `delete` per id and
+   * swallowing per-row failures. Returns the count of rows reported
+   * deleted by the server (or successfully deleted in fallback mode).
+   */
+  async bulkDelete(resource, ids) {
+    await this.connect();
+    if (!ids || ids.length === 0) return 0;
+    const strIds = ids.map((id) => String(id));
+    const deleteMany = this.client.data.deleteMany;
+    if (typeof deleteMany === "function") {
+      try {
+        const res = await deleteMany(resource, strIds, { continueOnError: true });
+        if (res && typeof res === "object" && typeof res.succeeded === "number") {
+          return res.succeeded;
+        }
+        if (Array.isArray(res)) return res.length;
+        return strIds.length;
+      } catch (err) {
+        throw normaliseClientError(err);
+      }
+    }
+    let succeeded = 0;
+    for (const id of strIds) {
+      try {
+        await this.client.data.delete(resource, id);
+        succeeded++;
+      } catch {
+      }
+    }
+    return succeeded;
+  }
   /**
    * Bulk operations with optimized batch processing and error handling.
    * Emits progress events for tracking operation status.

package/dist/index.d.cts

@@ -938,6 +938,30 @@ declare class ObjectStackAdapter<T = unknown> implements DataSource<T> {
     delete(resource: string, id: string | number, opts?: {
         ifMatch?: string;
     }): Promise<boolean>;
+    /**
+     * Apply the same patch to many records in a single round-trip.
+     *
+     * Sends one `POST /api/v1/data/:object/updateMany` request whose body
+     * is `{ records: ids.map(id => ({id, data: patch})), options: { continueOnError: true }}`.
+     * The server iterates server-side (still N engine writes) but the
+     * client only pays for ONE HTTP/auth/RLS round-trip — the relevant
+     * perf win for inbox / list-toolbar "mark all read" / "archive
+     * selected" interactions where N can easily be in the hundreds.
+     *
+     * Falls back to a sequential per-id loop when the connected client
+     * does not expose `updateMany` (older clients / offline adapters).
+     * In that case `continueOnError` semantics are emulated locally so
+     * callers see the same return shape.
+     */
+    bulkUpdate(resource: string, ids: ReadonlyArray<string | number>, patch: Partial<T>): Promise<number>;
+    /**
+     * Single-call bulk delete. Mirrors the bulkUpdate contract: prefers
+     * the server's `deleteMany` primitive when the client supports it;
+     * otherwise emulates `continueOnError` by looping `delete` per id and
+     * swallowing per-row failures. Returns the count of rows reported
+     * deleted by the server (or successfully deleted in fallback mode).
+     */
+    bulkDelete(resource: string, ids: ReadonlyArray<string | number>): Promise<number>;
     /**
      * Bulk operations with optimized batch processing and error handling.
      * Emits progress events for tracking operation status.

package/dist/index.d.ts

@@ -938,6 +938,30 @@ declare class ObjectStackAdapter<T = unknown> implements DataSource<T> {
     delete(resource: string, id: string | number, opts?: {
         ifMatch?: string;
     }): Promise<boolean>;
+    /**
+     * Apply the same patch to many records in a single round-trip.
+     *
+     * Sends one `POST /api/v1/data/:object/updateMany` request whose body
+     * is `{ records: ids.map(id => ({id, data: patch})), options: { continueOnError: true }}`.
+     * The server iterates server-side (still N engine writes) but the
+     * client only pays for ONE HTTP/auth/RLS round-trip — the relevant
+     * perf win for inbox / list-toolbar "mark all read" / "archive
+     * selected" interactions where N can easily be in the hundreds.
+     *
+     * Falls back to a sequential per-id loop when the connected client
+     * does not expose `updateMany` (older clients / offline adapters).
+     * In that case `continueOnError` semantics are emulated locally so
+     * callers see the same return shape.
+     */
+    bulkUpdate(resource: string, ids: ReadonlyArray<string | number>, patch: Partial<T>): Promise<number>;
+    /**
+     * Single-call bulk delete. Mirrors the bulkUpdate contract: prefers
+     * the server's `deleteMany` primitive when the client supports it;
+     * otherwise emulates `continueOnError` by looping `delete` per id and
+     * swallowing per-row failures. Returns the count of rows reported
+     * deleted by the server (or successfully deleted in fallback mode).
+     */
+    bulkDelete(resource: string, ids: ReadonlyArray<string | number>): Promise<number>;
     /**
      * Bulk operations with optimized batch processing and error handling.
      * Emits progress events for tracking operation status.

package/dist/index.js

@@ -1321,6 +1321,82 @@ var ObjectStackAdapter = class {
       throw normaliseClientError(err);
     }
   }
+  /**
+   * Apply the same patch to many records in a single round-trip.
+   *
+   * Sends one `POST /api/v1/data/:object/updateMany` request whose body
+   * is `{ records: ids.map(id => ({id, data: patch})), options: { continueOnError: true }}`.
+   * The server iterates server-side (still N engine writes) but the
+   * client only pays for ONE HTTP/auth/RLS round-trip — the relevant
+   * perf win for inbox / list-toolbar "mark all read" / "archive
+   * selected" interactions where N can easily be in the hundreds.
+   *
+   * Falls back to a sequential per-id loop when the connected client
+   * does not expose `updateMany` (older clients / offline adapters).
+   * In that case `continueOnError` semantics are emulated locally so
+   * callers see the same return shape.
+   */
+  async bulkUpdate(resource, ids, patch) {
+    await this.connect();
+    if (!ids || ids.length === 0) return 0;
+    const records = ids.map((id) => ({ id: String(id), data: patch }));
+    const updateMany = this.client.data.updateMany;
+    if (typeof updateMany === "function") {
+      try {
+        const res = await updateMany(resource, records, { continueOnError: true });
+        if (res && typeof res === "object" && typeof res.succeeded === "number") {
+          return res.succeeded;
+        }
+        if (Array.isArray(res)) return res.length;
+        return ids.length;
+      } catch (err) {
+        throw normaliseClientError(err);
+      }
+    }
+    let succeeded = 0;
+    for (const id of ids) {
+      try {
+        await this.client.data.update(resource, String(id), patch);
+        succeeded++;
+      } catch {
+      }
+    }
+    return succeeded;
+  }
+  /**
+   * Single-call bulk delete. Mirrors the bulkUpdate contract: prefers
+   * the server's `deleteMany` primitive when the client supports it;
+   * otherwise emulates `continueOnError` by looping `delete` per id and
+   * swallowing per-row failures. Returns the count of rows reported
+   * deleted by the server (or successfully deleted in fallback mode).
+   */
+  async bulkDelete(resource, ids) {
+    await this.connect();
+    if (!ids || ids.length === 0) return 0;
+    const strIds = ids.map((id) => String(id));
+    const deleteMany = this.client.data.deleteMany;
+    if (typeof deleteMany === "function") {
+      try {
+        const res = await deleteMany(resource, strIds, { continueOnError: true });
+        if (res && typeof res === "object" && typeof res.succeeded === "number") {
+          return res.succeeded;
+        }
+        if (Array.isArray(res)) return res.length;
+        return strIds.length;
+      } catch (err) {
+        throw normaliseClientError(err);
+      }
+    }
+    let succeeded = 0;
+    for (const id of strIds) {
+      try {
+        await this.client.data.delete(resource, id);
+        succeeded++;
+      } catch {
+      }
+    }
+    return succeeded;
+  }
   /**
    * Bulk operations with optimized batch processing and error handling.
    * Emits progress events for tracking operation status.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/data-objectstack",
-  "version": "5.1.1",
+  "version": "5.3.0",
   "description": "ObjectStack Data Adapter for Object UI",
   "license": "MIT",
   "type": "module",
@@ -23,8 +23,8 @@
   ],
   "dependencies": {
     "@objectstack/client": "^4.2.0",
-    "@object-ui/core": "5.1.1",
-    "@object-ui/types": "5.1.1"
+    "@object-ui/core": "5.3.0",
+    "@object-ui/types": "5.3.0"
   },
   "devDependencies": {
     "tsup": "^8.5.1",

package/src/bulkDelete.test.ts

@@ -0,0 +1,75 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { ObjectStackAdapter } from './index';
+
+function makeDS(stub: { deleteMany?: any; delete?: any }) {
+  const ds: any = new ObjectStackAdapter({
+    baseUrl: 'http://test.local',
+    fetch: vi.fn(async () => {
+      const body = { success: true, data: { capabilities: {}, routes: {} } };
+      return new Response(JSON.stringify(body), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }),
+  });
+  ds.connected = true;
+  ds.connectionState = 'connected';
+  ds.client = { data: stub };
+  return ds;
+}
+
+describe('ObjectStackDataSource.bulkDelete', () => {
+  it('returns 0 and skips network when ids is empty', async () => {
+    const deleteMany = vi.fn();
+    const ds = makeDS({ deleteMany });
+    const n = await ds.bulkDelete('sys_notification', []);
+    expect(n).toBe(0);
+    expect(deleteMany).not.toHaveBeenCalled();
+  });
+
+  it('issues a single deleteMany call with the id list', async () => {
+    const deleteMany = vi.fn().mockResolvedValue({ succeeded: 3, failed: 0 });
+    const ds = makeDS({ deleteMany });
+    const n = await ds.bulkDelete('task', ['a', 'b', 'c']);
+    expect(n).toBe(3);
+    expect(deleteMany).toHaveBeenCalledTimes(1);
+    const [resource, ids, opts] = deleteMany.mock.calls[0];
+    expect(resource).toBe('task');
+    expect(ids).toEqual(['a', 'b', 'c']);
+    expect(opts).toEqual({ continueOnError: true });
+  });
+
+  it('returns ids.length when deleteMany returns void (older clients)', async () => {
+    const deleteMany = vi.fn().mockResolvedValue(undefined);
+    const ds = makeDS({ deleteMany });
+    const n = await ds.bulkDelete('task', ['a', 'b']);
+    expect(n).toBe(2);
+  });
+
+  it('falls back to per-id delete loop when deleteMany is missing', async () => {
+    const del = vi.fn(async (_: string, id: string) => {
+      if (id === 'b') throw new Error('FK violation');
+    });
+    const ds = makeDS({ delete: del });
+    const n = await ds.bulkDelete('task', ['a', 'b', 'c']);
+    // continueOnError-emulated: b throws, a + c succeed.
+    expect(n).toBe(2);
+    expect(del).toHaveBeenCalledTimes(3);
+  });
+
+  it('coerces non-string ids before sending', async () => {
+    const deleteMany = vi.fn().mockResolvedValue({ succeeded: 2 });
+    const ds = makeDS({ deleteMany });
+    await ds.bulkDelete('task', [1, 2]);
+    const [, ids] = deleteMany.mock.calls[0];
+    expect(ids).toEqual(['1', '2']);
+  });
+});

package/src/bulkUpdate.test.ts

@@ -0,0 +1,93 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { ObjectStackAdapter } from './index';
+
+/**
+ * Build a DataSource instance with a stubbed `fetch` that satisfies the
+ * one-shot discovery probe inside `connect()`. The client object is then
+ * swapped out for a lightweight mock so we can assert directly against
+ * the `updateMany` / `update` calls without spinning real HTTP.
+ */
+function makeDS(stub: { updateMany?: any; update?: any }) {
+  const ds: any = new ObjectStackAdapter({
+    baseUrl: 'http://test.local',
+    fetch: vi.fn(async (_url: any, _init: any) => {
+      const body = { success: true, data: { capabilities: {}, routes: {} } };
+      return new Response(JSON.stringify(body), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }),
+  });
+  // Pre-mark connected so connect() short-circuits without hitting fetch.
+  ds.connected = true;
+  ds.connectionState = 'connected';
+  ds.client = { data: stub };
+  return ds;
+}
+
+describe('ObjectStackDataSource.bulkUpdate', () => {
+  it('returns 0 and skips network when ids is empty', async () => {
+    const updateMany = vi.fn();
+    const ds = makeDS({ updateMany });
+    const n = await ds.bulkUpdate('sys_notification', [], { is_read: true });
+    expect(n).toBe(0);
+    expect(updateMany).not.toHaveBeenCalled();
+  });
+
+  it('issues a single updateMany call with the per-id record shape', async () => {
+    const updateMany = vi.fn().mockResolvedValue({ succeeded: 3, failed: 0, results: [] });
+    const ds = makeDS({ updateMany });
+    const n = await ds.bulkUpdate('sys_notification', ['a', 'b', 'c'], {
+      is_read: true,
+      read_at: '2026-05-23T05:00:00.000Z',
+    });
+    expect(n).toBe(3);
+    expect(updateMany).toHaveBeenCalledTimes(1);
+    const [resource, records, opts] = updateMany.mock.calls[0];
+    expect(resource).toBe('sys_notification');
+    expect(opts).toEqual({ continueOnError: true });
+    expect(records).toEqual([
+      { id: 'a', data: { is_read: true, read_at: '2026-05-23T05:00:00.000Z' } },
+      { id: 'b', data: { is_read: true, read_at: '2026-05-23T05:00:00.000Z' } },
+      { id: 'c', data: { is_read: true, read_at: '2026-05-23T05:00:00.000Z' } },
+    ]);
+  });
+
+  it('honors server-reported partial success counts', async () => {
+    const updateMany = vi.fn().mockResolvedValue({ succeeded: 2, failed: 1, results: [] });
+    const ds = makeDS({ updateMany });
+    const n = await ds.bulkUpdate('sys_notification', ['a', 'b', 'c'], { is_read: true });
+    expect(n).toBe(2);
+  });
+
+  it('falls back to per-id updates when client.data.updateMany is missing', async () => {
+    const update = vi.fn().mockResolvedValue({ record: {} });
+    const ds = makeDS({ update });
+    const n = await ds.bulkUpdate('sys_notification', ['a', 'b'], { is_read: true });
+    expect(n).toBe(2);
+    expect(update).toHaveBeenCalledTimes(2);
+    expect(update.mock.calls[0][0]).toBe('sys_notification');
+    expect(update.mock.calls[0][1]).toBe('a');
+    expect(update.mock.calls[0][2]).toEqual({ is_read: true });
+  });
+
+  it('fallback path tolerates per-row failures (continueOnError semantics)', async () => {
+    const update = vi
+      .fn()
+      .mockResolvedValueOnce({ record: {} })
+      .mockRejectedValueOnce(new Error('row 2 failed'))
+      .mockResolvedValueOnce({ record: {} });
+    const ds = makeDS({ update });
+    const n = await ds.bulkUpdate('sys_notification', ['a', 'b', 'c'], { is_read: true });
+    expect(n).toBe(2);
+    expect(update).toHaveBeenCalledTimes(3);
+  });
+});

package/src/index.ts

@@ -750,6 +750,104 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
     }
   }
 
+  /**
+   * Apply the same patch to many records in a single round-trip.
+   *
+   * Sends one `POST /api/v1/data/:object/updateMany` request whose body
+   * is `{ records: ids.map(id => ({id, data: patch})), options: { continueOnError: true }}`.
+   * The server iterates server-side (still N engine writes) but the
+   * client only pays for ONE HTTP/auth/RLS round-trip — the relevant
+   * perf win for inbox / list-toolbar "mark all read" / "archive
+   * selected" interactions where N can easily be in the hundreds.
+   *
+   * Falls back to a sequential per-id loop when the connected client
+   * does not expose `updateMany` (older clients / offline adapters).
+   * In that case `continueOnError` semantics are emulated locally so
+   * callers see the same return shape.
+   */
+  async bulkUpdate(
+    resource: string,
+    ids: ReadonlyArray<string | number>,
+    patch: Partial<T>,
+  ): Promise<number> {
+    await this.connect();
+    if (!ids || ids.length === 0) return 0;
+    const records = ids.map((id) => ({ id: String(id), data: patch as any }));
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const updateMany = (this.client.data as any).updateMany;
+    if (typeof updateMany === 'function') {
+      try {
+        const res = await updateMany(resource, records, { continueOnError: true });
+        // The server returns BatchUpdateResponse { succeeded, failed, ... };
+        // fall back to ids.length on adapters that return a bare array.
+        if (res && typeof res === 'object' && typeof (res as any).succeeded === 'number') {
+          return (res as any).succeeded as number;
+        }
+        if (Array.isArray(res)) return (res as any[]).length;
+        return ids.length;
+      } catch (err) {
+        throw normaliseClientError(err);
+      }
+    }
+
+    // Fallback: sequential per-id updates, tolerating failures.
+    let succeeded = 0;
+    for (const id of ids) {
+      try {
+        await this.client.data.update<T>(resource, String(id), patch);
+        succeeded++;
+      } catch {
+        // continueOnError semantics — swallow per-row errors
+      }
+    }
+    return succeeded;
+  }
+
+  /**
+   * Single-call bulk delete. Mirrors the bulkUpdate contract: prefers
+   * the server's `deleteMany` primitive when the client supports it;
+   * otherwise emulates `continueOnError` by looping `delete` per id and
+   * swallowing per-row failures. Returns the count of rows reported
+   * deleted by the server (or successfully deleted in fallback mode).
+   */
+  async bulkDelete(
+    resource: string,
+    ids: ReadonlyArray<string | number>,
+  ): Promise<number> {
+    await this.connect();
+    if (!ids || ids.length === 0) return 0;
+    const strIds = ids.map((id) => String(id));
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const deleteMany = (this.client.data as any).deleteMany;
+    if (typeof deleteMany === 'function') {
+      try {
+        const res = await deleteMany(resource, strIds, { continueOnError: true });
+        if (res && typeof res === 'object' && typeof (res as any).succeeded === 'number') {
+          return (res as any).succeeded as number;
+        }
+        if (Array.isArray(res)) return (res as any[]).length;
+        // deleteMany historically returns void on success — assume all hit.
+        return strIds.length;
+      } catch (err) {
+        throw normaliseClientError(err);
+      }
+    }
+
+    // Fallback: sequential per-id deletes, tolerating failures.
+    let succeeded = 0;
+    for (const id of strIds) {
+      try {
+        await this.client.data.delete(resource, id);
+        succeeded++;
+      } catch {
+        // continueOnError semantics — swallow per-row errors
+      }
+    }
+    return succeeded;
+  }
+
   /**
    * Bulk operations with optimized batch processing and error handling.
    * Emits progress events for tracking operation status.