@object-ui/data-objectstack 17.5.0 → 17.6.0

package/src/onSaveAdvisory.test.ts

@@ -1,311 +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.
- */
-
-/**
- * The SECOND client class's metadata save door must surface the runtime
- * authoring gate's advisory findings (objectui#4237; backend objectstack#7435).
- *
- * `ObjectStackClient.meta.saveItem` writes through the same
- * `PUT /api/v1/meta/:type/:name` as `MetadataClient.save`, but it is a
- * different class and #4133/#4236 only covered the other one — every caller
- * here awaited the call and discarded the response, so an `advisories[]` the
- * server attached was parsed off the wire and dropped. These pins are the
- * red-first evidence: with `installSaveAdvisoryInterceptor()` reverted, every
- * "emits" case below fails because no event is ever produced.
- *
- * ## Why these drive a REAL SDK client through a fake `fetch`
- *
- * The sibling `onWriteWarning.test.ts` replaces `ds.client` with a stub, which
- * is right for the data door. It would be wrong here: the whole premise of this
- * fix is a measurement about the wire — that the SDK's `unwrapResponse` hands
- * the save body back VERBATIM (it strips its `{ success, data }` envelope only
- * when the body has a `data` key, and this one does not), so `advisories` is
- * still at the top level where the shared `readSaveAdvisories` looks for it.
- * Stubbing `meta` would assume exactly the thing under test. Driving the real
- * client keeps that measured on every run.
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import { ObjectStackAdapter } from './index';
-import type {
-  MetadataSaveAdvisoryEvent,
-  RuntimeAuthoringIssue,
-  WriteWarningEvent,
-} from './index';
-
-/** The measured `nightly_purge` finding, in the spec's D3 shape. */
-const PURGE_ADVISORY: RuntimeAuthoringIssue = {
-  severity: 'warning',
-  rule: 'flow/delete-without-filter',
-  where: 'flow "nightly_purge" · node "purge old rows"',
-  path: 'flows[0].nodes[2].config.filters',
-  message: 'this delete_record node sets multi: true with no filter, so it deletes every row',
-  hint: 'add a filter, or set multi: false to delete a single record',
-};
-
-/**
- * The clean part of a real save response. `success`/`version`/`seq`/`state` are
- * REQUIRED by `SaveMetaItemResponseSchema` (#5745) — spelled out here because
- * their presence is what makes the `unwrapResponse` measurement above
- * meaningful: a `success` boolean with NO sibling `data` key.
- */
-const CLEAN_BODY = { success: true, version: 'v2', seq: 4, state: 'active' as const };
-
-/** A `fetch` that answers every metadata PUT with `body`, and records the calls. */
-function fetchAnswering(body: unknown) {
-  return vi.fn(async (_input: RequestInfo | URL, _init?: RequestInit) =>
-    new Response(JSON.stringify(body), {
-      status: 200,
-      headers: { 'content-type': 'application/json' },
-    }),
-  );
-}
-
-/**
- * A connected adapter whose client talks to `fetchImpl`. `connected` is forced
- * rather than discovered, exactly as the sibling write-warning suite does — the
- * save door needs no discovery (`getRoute('metadata')` falls back to
- * `/api/v1/meta`), and skipping it keeps the module-level discovery cache out
- * of these tests.
- */
-function makeAdapter(body: unknown) {
-  const fetchImpl = fetchAnswering(body);
-  const ds: any = new ObjectStackAdapter({
-    baseUrl: 'http://test.local',
-    fetch: fetchImpl as unknown as typeof fetch,
-  });
-  ds.connected = true;
-  ds.connectionState = 'connected';
-  return { ds, fetchImpl };
-}
-
-describe('ObjectStackAdapter.onSaveAdvisory — the second client class (#4237)', () => {
-  it('emits the findings a successful save returned', async () => {
-    const { ds } = makeAdapter({ ...CLEAN_BODY, advisories: [PURGE_ADVISORY] });
-    const events: MetadataSaveAdvisoryEvent[] = [];
-    ds.onSaveAdvisory((e: MetadataSaveAdvisoryEvent) => events.push(e));
-
-    await ds.getClient().meta.saveItem('flow', 'nightly_purge', { name: 'nightly_purge' });
-
-    expect(events).toEqual([
-      {
-        type: 'flow',
-        name: 'nightly_purge',
-        mode: 'publish',
-        advisories: [PURGE_ADVISORY],
-      },
-    ]);
-  });
-
-  it('carries rule, message and hint through verbatim — they are server prose', async () => {
-    const { ds } = makeAdapter({ ...CLEAN_BODY, advisories: [PURGE_ADVISORY] });
-    const events: MetadataSaveAdvisoryEvent[] = [];
-    ds.onSaveAdvisory((e: MetadataSaveAdvisoryEvent) => events.push(e));
-
-    await ds.getClient().meta.saveItem('flow', 'nightly_purge', {});
-
-    const finding = events[0]!.advisories[0]!;
-    expect(finding.rule).toBe('flow/delete-without-filter');
-    expect(finding.message).toBe(PURGE_ADVISORY.message);
-    expect(finding.hint).toBe(PURGE_ADVISORY.hint);
-    // Never `error` on this channel — an error-severity finding is a 422.
-    expect(finding.severity).toBe('warning');
-  });
-
-  /**
-   * The response-shape measurement the fix rests on, asserted rather than
-   * assumed: this body is handed back whole. If a future SDK started wrapping
-   * the save response in `{ success, data }`, THIS is the case that goes red
-   * and says so, instead of the advisory channel quietly emitting nothing.
-   */
-  it('hands the caller the save response unchanged — the SDK does not unwrap this body', async () => {
-    const body = { ...CLEAN_BODY, advisories: [PURGE_ADVISORY] };
-    const { ds } = makeAdapter(body);
-
-    const result = await ds.getClient().meta.saveItem('flow', 'nightly_purge', {});
-
-    expect(result).toEqual(body);
-    expect(result.version).toBe('v2');
-    expect(result.advisories).toEqual([PURGE_ADVISORY]);
-  });
-
-  it('says nothing on a clean save — the server omits the key entirely', async () => {
-    const { ds } = makeAdapter(CLEAN_BODY);
-    const events: MetadataSaveAdvisoryEvent[] = [];
-    ds.onSaveAdvisory((e: MetadataSaveAdvisoryEvent) => events.push(e));
-
-    await ds.getClient().meta.saveItem('object', 'account', { name: 'account' });
-
-    expect(events).toEqual([]);
-  });
-
-  it('says nothing when the array is present but empty', async () => {
-    const { ds } = makeAdapter({ ...CLEAN_BODY, advisories: [] });
-    const events: MetadataSaveAdvisoryEvent[] = [];
-    ds.onSaveAdvisory((e: MetadataSaveAdvisoryEvent) => events.push(e));
-
-    await ds.getClient().meta.saveItem('object', 'account', {});
-
-    expect(events).toEqual([]);
-  });
-
-  it('drops half-shaped findings rather than rendering blanks at the author', async () => {
-    const { ds } = makeAdapter({
-      ...CLEAN_BODY,
-      advisories: [PURGE_ADVISORY, { rule: 'only-a-rule' }, null, 'string'],
-    });
-    const events: MetadataSaveAdvisoryEvent[] = [];
-    ds.onSaveAdvisory((e: MetadataSaveAdvisoryEvent) => events.push(e));
-
-    await ds.getClient().meta.saveItem('flow', 'nightly_purge', {});
-
-    // The SAME reader `MetadataClient.save` uses — one reader, two call sites.
-    expect(events[0]!.advisories).toEqual([PURGE_ADVISORY]);
-  });
-
-  it('a throwing listener never fails a save the server already committed', async () => {
-    const { ds } = makeAdapter({ ...CLEAN_BODY, advisories: [PURGE_ADVISORY] });
-    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    const seen: MetadataSaveAdvisoryEvent[] = [];
-    ds.onSaveAdvisory(() => {
-      throw new Error('renderer exploded');
-    });
-    // Registered second: a throwing listener must not starve the others.
-    ds.onSaveAdvisory((e: MetadataSaveAdvisoryEvent) => seen.push(e));
-
-    await expect(
-      ds.getClient().meta.saveItem('flow', 'nightly_purge', {}),
-    ).resolves.toBeTruthy();
-    expect(seen).toHaveLength(1);
-    warn.mockRestore();
-  });
-
-  it('unsubscribes', async () => {
-    const { ds } = makeAdapter({ ...CLEAN_BODY, advisories: [PURGE_ADVISORY] });
-    const events: MetadataSaveAdvisoryEvent[] = [];
-    const off = ds.onSaveAdvisory((e: MetadataSaveAdvisoryEvent) => events.push(e));
-
-    await ds.getClient().meta.saveItem('flow', 'a', {});
-    off();
-    await ds.getClient().meta.saveItem('flow', 'b', {});
-
-    expect(events).toHaveLength(1);
-  });
-
-  /**
-   * Control for the #4133/#4236 sibling channel: a metadata save is NOT a
-   * record write, and must not appear on the dropped-fields channel. This is
-   * what makes the "existing `onWriteWarning` consumers unchanged" claim
-   * checkable rather than asserted.
-   */
-  it('does not leak onto the write-warning channel', async () => {
-    const { ds } = makeAdapter({ ...CLEAN_BODY, advisories: [PURGE_ADVISORY] });
-    const warnings: WriteWarningEvent[] = [];
-    ds.onWriteWarning((e: WriteWarningEvent) => warnings.push(e));
-
-    await ds.getClient().meta.saveItem('flow', 'nightly_purge', {});
-
-    expect(warnings).toEqual([]);
-  });
-});
-
-/**
- * Draft-door honesty (D1), carried over from #4236's finding.
- *
- * Drafts are never gated — the framework returns at
- * `runtime-authoring-gate.ts`'s early return:
- *
- *     // D1 — drafts are never gated. Publishing one runs this same function.
- *     if (args.state !== 'active') return null;
- *
- * so a draft save produces no findings at all rather than producing some that
- * get withheld. Unlike the other client class, THIS one has no draft door to
- * begin with: the SDK's `saveItem(type, name, item)` takes no mode, so every
- * caller enumerated on #4237 writes the active door and the gate does run for
- * all of them. `mode` is therefore read off the response's own `state`.
- */
-describe('save-advisory mode reflects the door the server reports (D1)', () => {
-  it('a draft-state response with no findings emits nothing — the gate never ran', async () => {
-    const { ds } = makeAdapter({ ...CLEAN_BODY, state: 'draft' });
-    const events: MetadataSaveAdvisoryEvent[] = [];
-    ds.onSaveAdvisory((e: MetadataSaveAdvisoryEvent) => events.push(e));
-
-    await ds.getClient().meta.saveItem('flow', 'nightly_purge', {});
-
-    expect(events).toEqual([]);
-  });
-
-  it('labels the mode from the response state when a draft does somehow advise', async () => {
-    // Not reachable through today's server (see D1 above), but the event must
-    // tell the truth about which door it came through rather than hard-coding
-    // one, so the field is pinned on its own.
-    const { ds } = makeAdapter({
-      ...CLEAN_BODY,
-      state: 'draft',
-      advisories: [PURGE_ADVISORY],
-    });
-    const events: MetadataSaveAdvisoryEvent[] = [];
-    ds.onSaveAdvisory((e: MetadataSaveAdvisoryEvent) => events.push(e));
-
-    await ds.getClient().meta.saveItem('flow', 'nightly_purge', {});
-
-    expect(events[0]!.mode).toBe('draft');
-  });
-});
-
-/**
- * Caller coverage. The point of putting ONE emitter at the client seam is that
- * the enumerated call sites need no edit — so the pins that matter are the ones
- * that never mention the interceptor.
- */
-describe('the enumerated callers are covered without a per-site edit', () => {
-  it("covers the adapter's own view save path (updateViewConfig)", async () => {
-    const { ds } = makeAdapter({ ...CLEAN_BODY, advisories: [PURGE_ADVISORY] });
-    const events: MetadataSaveAdvisoryEvent[] = [];
-    ds.onSaveAdvisory((e: MetadataSaveAdvisoryEvent) => events.push(e));
-
-    await ds.updateViewConfig('lead', 'all_leads', { object: 'lead' });
-
-    expect(events).toHaveLength(1);
-    expect(events[0]!.type).toBe('view');
-    expect(events[0]!.name).toBe('all_leads');
-  });
-
-  it("covers the adapter's own dashboard save path (updateDashboard)", async () => {
-    const { ds } = makeAdapter({ ...CLEAN_BODY, advisories: [PURGE_ADVISORY] });
-    const events: MetadataSaveAdvisoryEvent[] = [];
-    ds.onSaveAdvisory((e: MetadataSaveAdvisoryEvent) => events.push(e));
-
-    await ds.updateDashboard('crm_overview_dashboard', { widgets: [] });
-
-    expect(events).toHaveLength(1);
-    expect(events[0]!.type).toBe('dashboard');
-    expect(events[0]!.name).toBe('crm_overview_dashboard');
-  });
-
-  /**
-   * `getClient()` hands back the adapter's own long-lived instance, which is
-   * how every caller OUTSIDE this package reaches the save door
-   * (`MetadataService`, `useNavigationSync`, plugin-designer's app wizard).
-   * If that ever started returning a fresh or wrapped client, the interceptor
-   * would stop covering them — so the identity is pinned here.
-   */
-  it('getClient() is the intercepted instance every external caller uses', async () => {
-    const { ds } = makeAdapter({ ...CLEAN_BODY, advisories: [PURGE_ADVISORY] });
-    const events: MetadataSaveAdvisoryEvent[] = [];
-    ds.onSaveAdvisory((e: MetadataSaveAdvisoryEvent) => events.push(e));
-
-    expect(ds.getClient()).toBe(ds.getClient());
-
-    // The `saveItem('app', …)` shape `useNavigationSync` and the plugin-designer
-    // app wizard both use.
-    await ds.getClient().meta.saveItem('app', 'crm', { name: 'crm' });
-
-    expect(events[0]).toMatchObject({ type: 'app', name: 'crm' });
-  });
-});

package/src/onWriteWarning.test.ts

@@ -1,273 +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.
- */
-
-/**
- * ObjectStackAdapter must surface the framework's write-observability channel
- * (#3431/#3455): when a create/update response carries `droppedFields` — fields
- * the backend LEGALLY stripped (read-only / locked-by-state) — the adapter emits
- * a WriteWarningEvent so the app shell can toast the user instead of letting the
- * dropped value vanish silently. The write itself still succeeded.
- */
-import { describe, it, expect, vi } from 'vitest';
-import { ObjectStackAdapter } from './index';
-import type { WriteWarningEvent } from './index';
-
-function makeDS(stub: Record<string, 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: stub };
-  return ds;
-}
-
-const ONE_DROP = [{ object: 'approval_case', fields: ['approval_status'], reason: 'readonly' }];
-
-describe('ObjectStackAdapter.onWriteWarning', () => {
-  it('emits a create write-warning carrying the dropped fields and the new id', async () => {
-    const create = vi.fn().mockResolvedValue({ record: { id: 'r1', title: 'A' }, droppedFields: ONE_DROP });
-    const ds = makeDS({ create });
-    const events: WriteWarningEvent[] = [];
-    ds.onWriteWarning((e: WriteWarningEvent) => events.push(e));
-
-    const rec = await ds.create('approval_case', { title: 'A', approval_status: 'approved' });
-
-    // The write still returns the plain record (unchanged behaviour).
-    expect(rec).toEqual({ id: 'r1', title: 'A' });
-    expect(events).toEqual([
-      { operation: 'create', resource: 'approval_case', id: 'r1', droppedFields: ONE_DROP },
-    ]);
-  });
-
-  it('emits an update write-warning carrying the target id', async () => {
-    const update = vi.fn().mockResolvedValue({ record: { id: 'r1' }, droppedFields: ONE_DROP });
-    const ds = makeDS({ update });
-    const events: WriteWarningEvent[] = [];
-    ds.onWriteWarning((e: WriteWarningEvent) => events.push(e));
-
-    await ds.update('approval_case', 'r1', { approval_status: 'approved' });
-
-    expect(events).toEqual([
-      { operation: 'update', resource: 'approval_case', id: 'r1', droppedFields: ONE_DROP },
-    ]);
-  });
-
-  it('does NOT emit when the response carries no droppedFields (the common case)', async () => {
-    const create = vi.fn().mockResolvedValue({ record: { id: 'r1', title: 'A' } });
-    const update = vi.fn().mockResolvedValue({ record: { id: 'r1' } });
-    const ds = makeDS({ create, update });
-    const events: WriteWarningEvent[] = [];
-    ds.onWriteWarning((e: WriteWarningEvent) => events.push(e));
-
-    await ds.create('approval_case', { title: 'A' });
-    await ds.update('approval_case', 'r1', { title: 'B' });
-
-    expect(events).toEqual([]);
-  });
-
-  it('does NOT emit for an empty or malformed droppedFields payload', async () => {
-    const create = vi
-      .fn()
-      .mockResolvedValueOnce({ record: { id: 'r1' }, droppedFields: [] })
-      .mockResolvedValueOnce({ record: { id: 'r2' }, droppedFields: 'nope' })
-      .mockResolvedValueOnce({ record: { id: 'r3' }, droppedFields: [{ object: 'x', fields: [] }] });
-    const ds = makeDS({ create });
-    const events: WriteWarningEvent[] = [];
-    ds.onWriteWarning((e: WriteWarningEvent) => events.push(e));
-
-    await ds.create('x', {});
-    await ds.create('x', {});
-    await ds.create('x', {}); // event present but its fields[] is empty → filtered out
-
-    expect(events).toEqual([]);
-  });
-
-  // ── cross-object batch (framework #3794) ─────────────────────────────────
-  //
-  // `batchTransaction` is the console record form's save path for a
-  // master-detail record, so this is where a `readonlyWhen` strip actually
-  // reaches a user editing a form. Its response tags each event with the index
-  // of the operation that produced it.
-
-  it('emits a write-warning per event on a cross-object batch, resolving the op', async () => {
-    const batchTransaction = vi.fn().mockResolvedValue({
-      results: [{ id: 'acc1' }, { id: 'inv1' }],
-      droppedFields: [
-        { object: 'invoice', fields: ['tax_rate'], reason: 'readonly_when', index: 1 },
-      ],
-    });
-    const ds = makeDS({ batchTransaction });
-    ds.atomicBatchCapability = true;
-    const events: WriteWarningEvent[] = [];
-    ds.onWriteWarning((e: WriteWarningEvent) => events.push(e));
-
-    await ds.batchTransaction([
-      { object: 'account', action: 'create', data: { name: 'Acme' } },
-      { object: 'invoice', action: 'update', id: 'inv1', data: { status: 'paid', tax_rate: 9 } },
-    ]);
-
-    expect(events).toEqual([
-      {
-        operation: 'update',
-        resource: 'invoice',
-        id: 'inv1',
-        droppedFields: [{ object: 'invoice', fields: ['tax_rate'], reason: 'readonly_when' }],
-      },
-    ]);
-  });
-
-  it('does NOT emit for a clean batch or a malformed droppedFields list', async () => {
-    const batchTransaction = vi
-      .fn()
-      .mockResolvedValueOnce({ results: [{ id: 'a' }] })
-      .mockResolvedValueOnce({ results: [{ id: 'a' }], droppedFields: [{ object: 'x', fields: [], index: 0 }] });
-    const ds = makeDS({ batchTransaction });
-    ds.atomicBatchCapability = true;
-    const events: WriteWarningEvent[] = [];
-    ds.onWriteWarning((e: WriteWarningEvent) => events.push(e));
-
-    await ds.batchTransaction([{ object: 'x', action: 'create', data: {} }]);
-    await ds.batchTransaction([{ object: 'x', action: 'create', data: {} }]);
-
-    expect(events).toEqual([]);
-  });
-
-  it('stops delivering after unsubscribe', async () => {
-    const create = vi.fn().mockResolvedValue({ record: { id: 'r1' }, droppedFields: ONE_DROP });
-    const ds = makeDS({ create });
-    const events: WriteWarningEvent[] = [];
-    const unsub = ds.onWriteWarning((e: WriteWarningEvent) => events.push(e));
-
-    await ds.create('approval_case', {});
-    unsub();
-    await ds.create('approval_case', {});
-
-    expect(events).toHaveLength(1);
-  });
-
-  // ── no-op strips are not news (objectui#3484) ─────────────────────────────
-  //
-  // The server is right to report a strip — the client DID send the key. But
-  // "was not saved" is only worth a toast when something was LOST. The console
-  // edit form used to round-trip the whole record, so every save of a
-  // state-locked record warned about fields the user never touched whose values
-  // never changed. When the echoed record proves the stripped value equals what
-  // was sent, stay quiet.
-
-  it('suppresses the warning when every stripped value equals what the record already holds', async () => {
-    const update = vi.fn().mockResolvedValue({
-      record: { id: 'r1', type: 'quality_abnormal', source_method: 'qc_judgment', title: 'B' },
-      droppedFields: [
-        { object: 'andon', fields: ['type', 'source_method'], reason: 'readonly_when' },
-      ],
-    });
-    const ds = makeDS({ update });
-    const events: WriteWarningEvent[] = [];
-    ds.onWriteWarning((e: WriteWarningEvent) => events.push(e));
-
-    await ds.update('andon', 'r1', {
-      title: 'B',
-      type: 'quality_abnormal',
-      source_method: 'qc_judgment',
-    });
-
-    expect(events).toEqual([]);
-  });
-
-  it('still warns about the fields that really did change, and only those', async () => {
-    const update = vi.fn().mockResolvedValue({
-      record: { id: 'r1', type: 'quality_abnormal', source_method: 'qc_judgment' },
-      droppedFields: [
-        { object: 'andon', fields: ['type', 'source_method'], reason: 'readonly_when' },
-      ],
-    });
-    const ds = makeDS({ update });
-    const events: WriteWarningEvent[] = [];
-    ds.onWriteWarning((e: WriteWarningEvent) => events.push(e));
-
-    // The user really did try to change `type`; `source_method` round-tripped.
-    await ds.update('andon', 'r1', { type: 'equipment_fault', source_method: 'qc_judgment' });
-
-    expect(events).toEqual([
-      {
-        operation: 'update',
-        resource: 'andon',
-        id: 'r1',
-        droppedFields: [{ object: 'andon', fields: ['type'], reason: 'readonly_when' }],
-      },
-    ]);
-  });
-
-  it('keeps the warning when the no-op cannot be PROVEN (record echo lacks the key)', async () => {
-    const update = vi.fn().mockResolvedValue({
-      record: { id: 'r1' },
-      droppedFields: [{ object: 'andon', fields: ['type'], reason: 'readonly_when' }],
-    });
-    const ds = makeDS({ update });
-    const events: WriteWarningEvent[] = [];
-    ds.onWriteWarning((e: WriteWarningEvent) => events.push(e));
-
-    await ds.update('andon', 'r1', { type: 'quality_abnormal' });
-
-    expect(events).toHaveLength(1);
-  });
-
-  it('does not treat a type change as a no-op (1 is not "1")', async () => {
-    const update = vi.fn().mockResolvedValue({
-      record: { id: 'r1', tax_rate: '9' },
-      droppedFields: [{ object: 'invoice', fields: ['tax_rate'], reason: 'readonly_when' }],
-    });
-    const ds = makeDS({ update });
-    const events: WriteWarningEvent[] = [];
-    ds.onWriteWarning((e: WriteWarningEvent) => events.push(e));
-
-    await ds.update('invoice', 'r1', { tax_rate: 9 });
-
-    expect(events).toHaveLength(1);
-  });
-
-  it('suppresses a no-op strip on the cross-object batch path too', async () => {
-    const batchTransaction = vi.fn().mockResolvedValue({
-      results: [{ id: 'acc1' }, { id: 'inv1', tax_rate: 9 }],
-      droppedFields: [
-        { object: 'invoice', fields: ['tax_rate'], reason: 'readonly_when', index: 1 },
-      ],
-    });
-    const ds = makeDS({ batchTransaction });
-    ds.atomicBatchCapability = true;
-    const events: WriteWarningEvent[] = [];
-    ds.onWriteWarning((e: WriteWarningEvent) => events.push(e));
-
-    await ds.batchTransaction([
-      { object: 'account', action: 'create', data: { name: 'Acme' } },
-      { object: 'invoice', action: 'update', id: 'inv1', data: { status: 'paid', tax_rate: 9 } },
-    ]);
-
-    expect(events).toEqual([]);
-  });
-
-  it('isolates a throwing listener so the write still resolves and other listeners fire', async () => {
-    const update = vi.fn().mockResolvedValue({ record: { id: 'r1' }, droppedFields: ONE_DROP });
-    const ds = makeDS({ update });
-    const good = vi.fn();
-    ds.onWriteWarning(() => { throw new Error('boom'); });
-    ds.onWriteWarning(good);
-    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
-
-    await expect(ds.update('approval_case', 'r1', { approval_status: 'x' })).resolves.toBeTruthy();
-    expect(good).toHaveBeenCalledTimes(1);
-    warn.mockRestore();
-  });
-});