@object-ui/data-objectstack 17.5.0 → 17.7.0

package/src/apiAccessDenied.test.ts

@@ -1,233 +0,0 @@
-/**
- * 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.
- */
-
-/**
- * objectui#4408 — an `enable`-block denial must not arrive at the surface as
- * "no data".
- *
- * `find()` degraded EVERY 404 into `{ data: [], total: 0 }` and memoised the
- * resource in `missingResources`, so a list pointed at an object the server
- * refuses to expose (`enable.apiEnabled: false` → HTTP 404 +
- * `code: 'OBJECT_API_DISABLED'`) resolved successfully with zero rows. A
- * resolved promise with zero rows is indistinguishable from a genuinely empty
- * object, so the list rendered its ordinary empty state: "you have no records"
- * over a page that can never hold any. The reported instance (Setup › Advanced
- * › Signing Keys) could not load for any persona and said so to nobody — which
- * is also how the upstream defect objectstack#7544 survived review for its
- * whole life.
- *
- * The discrimination is on the ADR-0112 `code`, never the status: a 404 from a
- * missing collection and a 404 from a disabled object are the same status, and
- * the optional-collection probes below depend on the missing-collection half
- * still degrading to empty. Both halves are asserted here, in both directions.
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import { ObjectStackAdapter, isApiAccessDeniedError, API_ACCESS_DENIED_CODES } from './index';
-
-/** An error shaped the way `@objectstack/client`'s fetch wrapper throws one. */
-function clientError(message: string, httpStatus: number, code?: string) {
-  const err = new Error(message) as Error & { httpStatus: number; code?: string };
-  err.httpStatus = httpStatus;
-  if (code) err.code = code;
-  return err;
-}
-
-function makeDS(find: any) {
-  const ds: any = new ObjectStackAdapter({
-    baseUrl: 'http://test.local',
-    fetch: vi.fn(async () =>
-      new Response(JSON.stringify({ success: true, data: { capabilities: {}, routes: {} } }), {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' },
-      })),
-  });
-  ds.connected = true;
-  ds.connectionState = 'connected';
-  ds.client = { data: { find } };
-  return ds;
-}
-
-describe('isApiAccessDeniedError', () => {
-  it('matches both enable-block denial codes', () => {
-    expect(isApiAccessDeniedError({ code: 'OBJECT_API_DISABLED' })).toBe(true);
-    expect(isApiAccessDeniedError({ code: 'OBJECT_API_METHOD_NOT_ALLOWED' })).toBe(true);
-    expect([...API_ACCESS_DENIED_CODES]).toEqual([
-      'OBJECT_API_DISABLED',
-      'OBJECT_API_METHOD_NOT_ALLOWED',
-    ]);
-  });
-
-  it('matches case-insensitively (the pre-ADR-0112 spelling still resolves)', () => {
-    expect(isApiAccessDeniedError({ code: 'object_api_disabled' })).toBe(true);
-  });
-
-  it('does NOT match the codes a missing collection or record answers with', () => {
-    expect(isApiAccessDeniedError({ code: 'OBJECT_NOT_FOUND' })).toBe(false);
-    expect(isApiAccessDeniedError({ code: 'RECORD_NOT_FOUND' })).toBe(false);
-    expect(isApiAccessDeniedError({ code: 'PERMISSION_DENIED' })).toBe(false);
-    // A bare 404 carries no code at all — status alone must never qualify.
-    expect(isApiAccessDeniedError({ httpStatus: 404 })).toBe(false);
-    expect(isApiAccessDeniedError(undefined)).toBe(false);
-  });
-});
-
-describe('ObjectStackDataSource.find — enable-block denials are surfaced, not emptied', () => {
-  // ── The defect pin ────────────────────────────────────────────────────────
-  it('REJECTS a 404 OBJECT_API_DISABLED instead of resolving to zero rows', async () => {
-    const find = vi.fn().mockRejectedValue(
-      clientError('Object API is disabled', 404, 'OBJECT_API_DISABLED'),
-    );
-    const ds = makeDS(find);
-
-    await expect(ds.find('sys_jwks')).rejects.toMatchObject({
-      code: 'OBJECT_API_DISABLED',
-      httpStatus: 404,
-    });
-  });
-
-  it('REJECTS the 405 sibling and keeps its code intact for the surface', async () => {
-    const find = vi.fn().mockRejectedValue(
-      clientError('Method not allowed', 405, 'OBJECT_API_METHOD_NOT_ALLOWED'),
-    );
-    const ds = makeDS(find);
-
-    await expect(ds.find('sys_jwks')).rejects.toMatchObject({
-      code: 'OBJECT_API_METHOD_NOT_ALLOWED',
-      httpStatus: 405,
-    });
-  });
-
-  it('does not memoise a denial — the second call still asks and still rejects', async () => {
-    // `missingResources` short-circuits later calls to `{ data: [], total: 0 }`
-    // WITHOUT touching the network. Absorbing a denial into it would pin the
-    // object to "empty" for the rest of the session, so the honest state would
-    // appear once and then silently revert to the masking empty state.
-    const find = vi.fn().mockRejectedValue(
-      clientError('Object API is disabled', 404, 'OBJECT_API_DISABLED'),
-    );
-    const ds = makeDS(find);
-
-    await expect(ds.find('sys_jwks')).rejects.toThrow();
-    await expect(ds.find('sys_jwks')).rejects.toMatchObject({ code: 'OBJECT_API_DISABLED' });
-    expect(find).toHaveBeenCalledTimes(2);
-  });
-
-  // ── The controls: must stay green on BOTH sides of the fix ────────────────
-  it('CONTROL: a bare 404 (collection absent on this backend) still degrades to empty', async () => {
-    // The optional-collection probes (AppHeader's sys_presence/sys_activity …)
-    // read empty data as "feature unavailable". Turning those into thrown
-    // errors would be a worse bug than the one being fixed.
-    const find = vi.fn().mockRejectedValue(clientError('Not found', 404));
-    const ds = makeDS(find);
-
-    await expect(ds.find('sys_presence')).resolves.toMatchObject({ data: [], total: 0 });
-  });
-
-  it('CONTROL: a 404 OBJECT_NOT_FOUND still degrades to empty, and is still memoised', async () => {
-    const find = vi.fn().mockRejectedValue(clientError('No such object', 404, 'OBJECT_NOT_FOUND'));
-    const ds = makeDS(find);
-
-    await expect(ds.find('sys_activity')).resolves.toMatchObject({ data: [], total: 0 });
-    // Memoised: the second call short-circuits without asking again.
-    await expect(ds.find('sys_activity')).resolves.toMatchObject({ data: [], total: 0 });
-    expect(find).toHaveBeenCalledTimes(1);
-  });
-
-  it('CONTROL: a 404 RECORD_NOT_FOUND is not an enable-block denial', async () => {
-    const find = vi.fn().mockRejectedValue(clientError('No such record', 404, 'RECORD_NOT_FOUND'));
-    const ds = makeDS(find);
-
-    await expect(ds.find('account')).resolves.toMatchObject({ data: [], total: 0 });
-  });
-
-  it('CONTROL: a 2xx with zero rows resolves as an ordinary empty result', async () => {
-    // The overwhelmingly common case, and the one the empty state exists for.
-    // A fix that turned "no records yet" into an error surface would be worse
-    // than the bug.
-    const find = vi.fn().mockResolvedValue({ records: [], total: 0 });
-    const ds = makeDS(find);
-
-    await expect(ds.find('account')).resolves.toMatchObject({ data: [], total: 0 });
-  });
-
-  it('CONTROL: a 2xx with rows is untouched', async () => {
-    const find = vi.fn().mockResolvedValue({ records: [{ id: '1' }], total: 1 });
-    const ds = makeDS(find);
-
-    await expect(ds.find('account')).resolves.toMatchObject({ data: [{ id: '1' }], total: 1 });
-  });
-
-  it('CONTROL: a 403 still propagates (it was never swallowed)', async () => {
-    const find = vi.fn().mockRejectedValue(clientError('Forbidden', 403, 'PERMISSION_DENIED'));
-    const ds = makeDS(find);
-
-    await expect(ds.find('account')).rejects.toMatchObject({ code: 'PERMISSION_DENIED' });
-  });
-});
-
-/**
- * The `$expand` / `$search` branch of `find()` bypasses `@objectstack/client`
- * and hand-rolls its own fetch, so it also has to stamp the ADR-0112 envelope
- * itself. It used to set only `status`, which left the surface with a bare 404
- * or 405 and nothing to discriminate on — the same denial, arriving anonymous,
- * on the path a list takes whenever it expands a lookup or runs a search.
- */
-describe('ObjectStackDataSource.find — the raw $expand/$search branch carries the code', () => {
-  function makeRawDS(status: number, body: unknown) {
-    const fetchImpl = vi.fn(async (url: RequestInfo | URL) => {
-      if (String(url).includes('/data/')) {
-        return new Response(JSON.stringify(body), {
-          status,
-          headers: { 'Content-Type': 'application/json' },
-        });
-      }
-      return new Response(JSON.stringify({ success: true, data: { capabilities: {}, routes: {} } }), {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' },
-      });
-    });
-    const ds: any = new ObjectStackAdapter({ baseUrl: 'http://test.local', fetch: fetchImpl });
-    ds.connected = true;
-    ds.connectionState = 'connected';
-    return ds;
-  }
-
-  it('propagates a top-level `code` from the error body', async () => {
-    const ds = makeRawDS(404, { code: 'OBJECT_API_DISABLED', message: 'Object API is disabled' });
-
-    await expect(ds.find('sys_jwks', { $search: 'anything' })).rejects.toMatchObject({
-      code: 'OBJECT_API_DISABLED',
-      status: 404,
-      httpStatus: 404,
-    });
-  });
-
-  it('propagates a nested `error.code` envelope, like the client wrapper does', async () => {
-    const ds = makeRawDS(405, {
-      error: { code: 'OBJECT_API_METHOD_NOT_ALLOWED', message: 'Method not allowed' },
-    });
-
-    await expect(ds.find('sys_jwks', { $expand: ['owner'] })).rejects.toMatchObject({
-      code: 'OBJECT_API_METHOD_NOT_ALLOWED',
-      httpStatus: 405,
-    });
-  });
-
-  it('CONTROL: a body with no code leaves `code` undefined rather than inventing one', async () => {
-    const ds = makeRawDS(404, { message: 'Not found' });
-
-    await expect(ds.find('sys_jwks', { $expand: ['owner'] })).rejects.toMatchObject({
-      status: 404,
-    });
-    await ds.find('sys_jwks', { $expand: ['owner'] }).catch((e: any) => {
-      expect(e.code).toBeUndefined();
-      expect(isApiAccessDeniedError(e)).toBe(false);
-    });
-  });
-});

package/src/appAccessProbe.test.ts

@@ -1,147 +0,0 @@
-/**
- * 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.
- */
-
-/**
- * objectui#4252 — an app the session may not open must be distinguishable from
- * an app that is not there.
- *
- * `GET /api/v1/meta/apps` is filtered per session server-side
- * (`filterAppForUser`), so those two conditions are byte-identical in the list:
- * both are simply absent. The maintainer ruling (2026-08-12) put the
- * distinction on the BY-NAME route instead of flagging the list — the
- * enumeration surface is not widened past what a by-name probe already implies
- * — and objectstack#8013 (PR #8135) shipped it:
- *
- *   - EXISTS + session lacks `requiredPermissions` → `403`
- *     `{ success: false, error: { code: 'PERMISSION_DENIED', message } }`
- *   - a nonexistent name, an unpublished app (ADR-0045 §3 keeps it externally
- *     unobservable), an app gated by an absent optional service (ADR-0057 D10 —
- *     nothing was denied to the CALLER) → `404 RESOURCE_NOT_FOUND`, unchanged.
- *
- * Every case here goes through the real `ObjectStackClient` over a stubbed
- * `fetch`, so what is measured includes the client's own error stamping
- * (`error.code` off `body.error.code`, `error.httpStatus` off the status) —
- * the seam a hand-built rejection would have skipped straight past.
- *
- * The discrimination is on the ADR-0112 CODE, never the status (objectui#4408),
- * and the last two cases are what hold that: they cross the two apart, so a
- * reimplementation that reads `httpStatus === 403` goes red in both directions
- * rather than passing on the happy path.
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import {
-  ObjectStackAdapter,
-  isAppPermissionDeniedError,
-  APP_PERMISSION_DENIED_CODE,
-} from './index';
-
-const json = (status: number, body: unknown) =>
-  new Response(JSON.stringify(body), { status, headers: { 'Content-Type': 'application/json' } });
-
-/** The 403 body objectstack#8135 emits, transcribed from that merged diff. */
-const DENIED_BODY = {
-  success: false,
-  error: {
-    code: 'PERMISSION_DENIED',
-    message: "You do not have permission to open the 'finance' app.",
-  },
-};
-
-/** The absence body the same route keeps answering for every other refusal. */
-const ABSENT_BODY = {
-  error: { code: 'RESOURCE_NOT_FOUND', message: 'Metadata item not found or access denied.' },
-};
-
-function makeAdapter(answer: (url: string) => Response) {
-  const fetchImpl = vi.fn(async (input: RequestInfo | URL) => answer(String(input)));
-  const adapter = new ObjectStackAdapter({ baseUrl: 'http://test.local', fetch: fetchImpl });
-  return { adapter, fetchImpl };
-}
-
-describe('isAppPermissionDeniedError', () => {
-  it('matches the by-name route\'s denial code, in either ADR-0112 spelling', () => {
-    expect(APP_PERMISSION_DENIED_CODE).toBe('PERMISSION_DENIED');
-    expect(isAppPermissionDeniedError({ code: 'PERMISSION_DENIED' })).toBe(true);
-    // The console is versioned separately from the server it talks to; the
-    // pre-ADR-0112 lowercase spelling still resolves (`errorCodeIs`).
-    expect(isAppPermissionDeniedError({ code: 'permission_denied' })).toBe(true);
-  });
-
-  it('does NOT match absence, the enable-block denials, or a bare status', () => {
-    expect(isAppPermissionDeniedError({ code: 'RESOURCE_NOT_FOUND' })).toBe(false);
-    // `API_ACCESS_DENIED_CODES` (objectui#4408) is a different question: those
-    // are pure functions of an object's `enable` metadata and identical for
-    // every persona. This one is a statement about the caller.
-    expect(isAppPermissionDeniedError({ code: 'OBJECT_API_DISABLED' })).toBe(false);
-    expect(isAppPermissionDeniedError({ httpStatus: 403 })).toBe(false);
-    expect(isAppPermissionDeniedError(undefined)).toBe(false);
-  });
-});
-
-describe('ObjectStackAdapter.probeAppAccess — over the wire', () => {
-  it('reports `denied` for the 403 PERMISSION_DENIED envelope', async () => {
-    const { adapter, fetchImpl } = makeAdapter(() => json(403, DENIED_BODY));
-
-    await expect(adapter.probeAppAccess('finance')).resolves.toBe('denied');
-    // The by-name address, singular — what objectstack#8013 pinned its cases
-    // against and what `MetadataProvider` already reads items by.
-    expect(String(fetchImpl.mock.calls[0][0])).toContain('/api/v1/meta/app/finance');
-  });
-
-  it('reports `unknown` for the 404 absence envelope — the copy must not move', async () => {
-    const { adapter } = makeAdapter(() => json(404, ABSENT_BODY));
-    await expect(adapter.probeAppAccess('no_such_app')).resolves.toBe('unknown');
-  });
-
-  it('reports `granted` when the route serves the app', async () => {
-    const { adapter } = makeAdapter(() =>
-      json(200, { type: 'app', name: 'finance', item: { name: 'finance', label: 'Finance' } }),
-    );
-    await expect(adapter.probeAppAccess('finance')).resolves.toBe('granted');
-  });
-
-  it('reports `unknown` — never `denied` — when the server cannot be reached', async () => {
-    const { adapter } = makeAdapter(() => {
-      throw new Error('network down');
-    });
-    await expect(adapter.probeAppAccess('finance')).resolves.toBe('unknown');
-  });
-
-  it('reports `unknown` for an empty name without asking anything', async () => {
-    const { adapter, fetchImpl } = makeAdapter(() => json(200, {}));
-    await expect(adapter.probeAppAccess('')).resolves.toBe('unknown');
-    expect(fetchImpl).not.toHaveBeenCalled();
-  });
-
-  it('never throws — a caller renders a screen off this, not a catch block', async () => {
-    const { adapter } = makeAdapter(() => new Response('<html>gateway</html>', { status: 502 }));
-    await expect(adapter.probeAppAccess('finance')).resolves.toBe('unknown');
-  });
-
-  // ── code, not status ─────────────────────────────────────────────────────
-  //
-  // Both directions, because a status-reading implementation passes every case
-  // above. 403 is not the fact; `PERMISSION_DENIED` is.
-
-  it('a 403 WITHOUT the code is `unknown` — a status alone never denies', async () => {
-    const { adapter } = makeAdapter(() =>
-      json(403, { error: { code: 'CSRF_TOKEN_INVALID', message: 'stale token' } }),
-    );
-    await expect(adapter.probeAppAccess('finance')).resolves.toBe('unknown');
-  });
-
-  it('the code decides even when the status is not 403', async () => {
-    // Hypothetical on today's server, and deliberately so: the contract this
-    // console consumes is the code. If the route ever answers the same denial
-    // under a different status, the branch must follow the code — and if this
-    // case is ever deleted, the reason must be that the CODE changed.
-    const { adapter } = makeAdapter(() => json(401, DENIED_BODY));
-    await expect(adapter.probeAppAccess('finance')).resolves.toBe('denied');
-  });
-});

package/src/bulkDelete.test.ts

@@ -1,75 +0,0 @@
-/**
- * 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

@@ -1,93 +0,0 @@
-/**
- * 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);
-  });
-});