@object-ui/data-objectstack 17.3.0 → 17.5.0

package/src/updateView.draft.test.ts

@@ -0,0 +1,242 @@
+/**
+ * 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';
+
+/**
+ * `updateView` read/write addressing (#4139).
+ *
+ * ADR-0034 routes a runtime-created view through the per-item DRAFT seam
+ * (`createRuntimeMetadata` → `metadataClient.save(..., { mode: 'draft' })`),
+ * so a view made from the `+` tab exists ONLY as a draft row until an
+ * explicit Publish. `updateView` used to read *and* write the published
+ * overlay on both halves: the read 404ed, a `catch {}` labelled
+ * "treat missing as create-equivalent" substituted `current = {}`, and the
+ * merge degenerated into a `{label, name, object}` partial that the server
+ * rejects (422) — while the draft row the UI actually reads back through
+ * `?preview=draft` kept the old label. The rename was silently lost.
+ *
+ * These pins fix the addressing on BOTH halves: whichever row the read
+ * resolved is the row the write updates.
+ */
+
+/** The canonical ViewItem envelope `viewEnvelope()` stages as a draft. */
+const DRAFT_VIEW = {
+  name: 'crm_activity.kanban_board',
+  object: 'crm_activity',
+  viewKind: 'list',
+  label: 'Kanban Board',
+  config: {
+    type: 'kanban',
+    columns: ['subject', 'status', 'due_date'],
+    kanban: { columns: ['subject', 'status', 'due_date'], groupBy: 'status' },
+    data: { provider: 'object', object: 'crm_activity' },
+  },
+};
+
+interface Harness {
+  ds: any;
+  /** Published-overlay writes (`client.meta.saveItem`) — the wrong address for a draft. */
+  saveItem: ReturnType<typeof vi.fn>;
+  /** Draft-addressed writes: `[url, parsedBody]` per `PUT ...?mode=draft`. */
+  draftPuts: Array<[string, any]>;
+  /** Every metadata URL the adapter fetched, in order. */
+  urls: string[];
+}
+
+/**
+ * Build an adapter whose two metadata addresses answer independently.
+ *
+ * @param opts.draft      body served at `GET /meta/view/:name?state=draft`
+ *                        (`null` → 404, i.e. nothing pending), wrapped in the
+ *                        `{type,name,item}` envelope the framework sends for
+ *                        draft reads.
+ * @param opts.published  what `client.meta.getItem` (the published read) does:
+ *                        a body to resolve, or an Error to throw.
+ */
+function makeDS(opts: { draft: any | null; published: any | Error }): Harness {
+  const draftPuts: Array<[string, any]> = [];
+  const urls: string[] = [];
+
+  const fetchImpl = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
+    const url = String(input);
+    const json = (body: unknown, status = 200) =>
+      new Response(JSON.stringify(body), {
+        status,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    if (url.includes('/meta/view/')) {
+      urls.push(url);
+      if ((init?.method ?? 'GET') === 'PUT') {
+        draftPuts.push([url, JSON.parse(String(init?.body ?? '{}'))]);
+        return json({ success: true, version: 2 });
+      }
+      if (url.includes('state=draft')) {
+        if (opts.draft == null) return json({ error: 'not found' }, 404);
+        // Draft reads answer the `{type,name,item}` envelope (unlike the
+        // bare-body published read) — the asymmetry `unwrapDraftBody` exists for.
+        return json({ type: 'view', name: opts.draft.name, item: opts.draft });
+      }
+      return json({ error: 'not found' }, 404);
+    }
+    return json({ success: true, data: { capabilities: {}, routes: {} } });
+  });
+
+  const ds: any = new ObjectStackAdapter({ baseUrl: 'http://test.local', fetch: fetchImpl });
+  ds.connected = true;
+  ds.connectionState = 'connected';
+  const saveItem = vi.fn(async () => ({ success: true }));
+  ds.client = {
+    meta: {
+      getItem: vi.fn(async () => {
+        if (opts.published instanceof Error) throw opts.published;
+        return { item: opts.published };
+      }),
+      saveItem,
+    },
+  };
+  return { ds, saveItem, draftPuts, urls };
+}
+
+/** A published read that 404s, decorated the way the SDK client decorates. */
+function notFound(): Error {
+  return Object.assign(new Error('Metadata item not found'), { httpStatus: 404 });
+}
+
+describe('ObjectStackDataSource.updateView — draft addressing (#4139)', () => {
+  it('renames a draft-only view by merging onto the DRAFT body and writing the draft back', async () => {
+    const { ds, saveItem, draftPuts } = makeDS({ draft: DRAFT_VIEW, published: notFound() });
+
+    await ds.updateView('crm_activity', DRAFT_VIEW.name, { label: 'Pipeline Board' });
+
+    // The write must be draft-addressed — the published overlay is the wrong
+    // row, and writing it would publish a view the user never published.
+    expect(saveItem).not.toHaveBeenCalled();
+    expect(draftPuts).toHaveLength(1);
+    const [url, body] = draftPuts[0];
+    expect(url).toContain('mode=draft');
+    expect(url).toContain(encodeURIComponent(DRAFT_VIEW.name));
+
+    // …and it must carry the FULL merged document, not the
+    // `{label, name, object}` partial the create-equivalent path produced.
+    expect(body.label).toBe('Pipeline Board');
+    expect(body.viewKind).toBe('list');
+    expect(body.name).toBe(DRAFT_VIEW.name);
+    expect(body.object).toBe('crm_activity');
+    expect(body.config).toEqual(DRAFT_VIEW.config);
+    // The pre-fix partial had exactly these three keys — pin the shape so a
+    // regression cannot pass by carrying the label alone.
+    expect(Object.keys(body).sort()).toEqual(
+      ['config', 'label', 'name', 'object', 'viewKind'].sort(),
+    );
+  });
+
+  it('probes the draft BEFORE the published overlay, so a pending draft is never shadowed', async () => {
+    // A view with both a published overlay and a pending draft: the edit
+    // belongs to the draft. Writing the published row instead would be
+    // overwritten at publish time — the rename would vanish on Publish.
+    const published = { ...DRAFT_VIEW, label: 'Old Published Label' };
+    const { ds, saveItem, draftPuts } = makeDS({ draft: DRAFT_VIEW, published });
+
+    await ds.updateView('crm_activity', DRAFT_VIEW.name, { label: 'Pipeline Board' });
+
+    expect(saveItem).not.toHaveBeenCalled();
+    expect(draftPuts).toHaveLength(1);
+    expect(draftPuts[0][1].label).toBe('Pipeline Board');
+  });
+
+  it('carries the full document for a set-default patch too, not just renames', async () => {
+    // `handleSetDefaultView` drives the same read-merge-write cycle with
+    // `{isDefault}`, so it degraded into the same partial write (#4139).
+    const { ds, draftPuts } = makeDS({ draft: DRAFT_VIEW, published: notFound() });
+
+    await ds.updateView('crm_activity', DRAFT_VIEW.name, { isDefault: true });
+
+    expect(draftPuts).toHaveLength(1);
+    const body = draftPuts[0][1];
+    expect(body.isDefault).toBe(true);
+    expect(body.label).toBe('Kanban Board');
+    expect(body.config).toEqual(DRAFT_VIEW.config);
+  });
+
+  it('CONTROL — a published view with no pending draft still updates the published overlay', async () => {
+    const published = {
+      name: 'crm_activity.all',
+      object: 'crm_activity',
+      viewKind: 'list',
+      label: 'All Activities',
+      config: { type: 'grid', data: { object: 'crm_activity' } },
+    };
+    const { ds, saveItem, draftPuts } = makeDS({ draft: null, published });
+
+    await ds.updateView('crm_activity', 'crm_activity.all', { label: 'Everything' });
+
+    // No draft row → the published path is unchanged.
+    expect(draftPuts).toHaveLength(0);
+    expect(saveItem).toHaveBeenCalledTimes(1);
+    const [type, name, body] = saveItem.mock.calls[0];
+    expect(type).toBe('view');
+    expect(name).toBe('crm_activity.all');
+    expect(body.label).toBe('Everything');
+    expect(body.viewKind).toBe('list');
+    expect(body.config).toEqual(published.config);
+  });
+
+  it('surfaces a genuinely-missing view instead of writing a create-equivalent partial', async () => {
+    const { ds, saveItem, draftPuts } = makeDS({ draft: null, published: notFound() });
+
+    await expect(
+      ds.updateView('crm_activity', 'crm_activity.ghost', { label: 'Nope' }),
+    ).rejects.toThrow(/crm_activity\.ghost/);
+
+    // The whole point: no partial write is emitted on the way out.
+    expect(saveItem).not.toHaveBeenCalled();
+    expect(draftPuts).toHaveLength(0);
+  });
+
+  it('surfaces a transport failure on the published read rather than degrading to a partial write', async () => {
+    const boom = Object.assign(new Error('Internal Server Error'), { httpStatus: 500 });
+    const { ds, saveItem, draftPuts } = makeDS({ draft: null, published: boom });
+
+    await expect(
+      ds.updateView('crm_activity', 'crm_activity.all', { label: 'Nope' }),
+    ).rejects.toThrow('Internal Server Error');
+
+    expect(saveItem).not.toHaveBeenCalled();
+    expect(draftPuts).toHaveLength(0);
+  });
+
+  it('surfaces a transport failure on the DRAFT probe rather than falling through to the published row', async () => {
+    // A 500 on the draft probe is not "no draft pending" — falling through
+    // would write the published overlay while a draft may still shadow it.
+    const fetchImpl = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.includes('/meta/view/') && url.includes('state=draft')) {
+        return new Response(JSON.stringify({ error: 'boom' }), {
+          status: 503,
+          headers: { 'Content-Type': 'application/json' },
+        });
+      }
+      return new Response(JSON.stringify({ success: true, data: {} }), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    });
+    const ds: any = new ObjectStackAdapter({ baseUrl: 'http://test.local', fetch: fetchImpl });
+    ds.connected = true;
+    ds.connectionState = 'connected';
+    const saveItem = vi.fn(async () => ({ success: true }));
+    ds.client = { meta: { getItem: vi.fn(async () => ({ item: DRAFT_VIEW })), saveItem } };
+
+    await expect(
+      ds.updateView('crm_activity', DRAFT_VIEW.name, { label: 'Nope' }),
+    ).rejects.toThrow();
+    expect(saveItem).not.toHaveBeenCalled();
+  });
+});

package/src/v3-compat.test.ts

@@ -6,30 +6,19 @@ import { describe, it, expect } from 'vitest';
 import { validatePluginContract, generateContractManifest } from './contracts';
 import { IntegrationManager } from './integration';
 import { SecurityManager } from './security';
-import { CloudOperations } from './cloud';
 import { createDefaultCanvasConfig, snapToGrid, calculateAutoLayout } from './studio';
 
-describe('v3.0.0 Compatibility', () => {
-  describe('Cloud namespace (replacing Hub)', () => {
-    it('should create cloud operations instance', () => {
-      const ops = new CloudOperations(() => ({}));
-      expect(ops).toBeDefined();
-    });
-
-    it('should handle deploy when client has no cloud support', async () => {
-      const ops = new CloudOperations(() => ({}));
-      const result = await ops.deploy('app-1', { environment: 'production' });
-      expect(result).toHaveProperty('deploymentId');
-      expect(result).toHaveProperty('status');
-    });
-
-    it('should handle marketplace search when client has no cloud support', async () => {
-      const ops = new CloudOperations(() => ({}));
-      const results = await ops.searchMarketplace('grid');
-      expect(Array.isArray(results)).toBe(true);
-    });
-  });
+// The `Cloud namespace (replacing Hub)` block that used to open this file is
+// gone with its subject (objectui#4152). Its three cases constructed
+// `CloudOperations` against a client stub of `{}` and asserted that the results
+// had the right KEYS — which is precisely how the surface stayed green for as
+// long as it did: every method optional-chained into a `cloud` namespace no
+// released `@objectstack/client` has ever exported, so what the assertions were
+// reading was the fallback literal, not a deployment. The replacement is a
+// negative pin next door, `cloud-surface-retired-4152.pin.test.ts`, which fails
+// if the exports come back.
 
+describe('v3.0.0 Compatibility', () => {
   describe('Contracts module', () => {
     it('should validate a valid plugin contract', () => {
       const contract = {

package/src/viewCacheInvalidation.pin.test.ts

@@ -0,0 +1,260 @@
+/**
+ * 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';
+
+/**
+ * View metadata cache keys — invalidation matches the read keys (objectui#3778).
+ *
+ * `ObjectStackAdapter` caches exactly two view-shaped reads:
+ *
+ * | reader              | cache key                    |
+ * |---------------------|------------------------------|
+ * | `getView`           | `view:{object}:{viewId}`     |
+ * | `listViewOverrides` | `view-overrides:{object}`    |
+ *
+ * `listViews` is **not** one of them: it fetches `meta.getItems('view')`
+ * directly on every call, with no `metadataCache.get` wrapper. Five write
+ * paths nevertheless used to invalidate a `views:{object}` key that no read
+ * path has ever populated — five permanent no-ops. They are gone; these pins
+ * keep both halves of that honest:
+ *
+ * 1. the surviving invalidations still name the keys that DO have readers, so
+ *    the deletion cannot be mistaken for "cache invalidation was dropped"; and
+ * 2. `listViews` keeps its uncached behavior — the deletion changed no
+ *    request count, which is what makes it a pure dead-code removal rather
+ *    than a caching change. (Whether `listViews` SHOULD be cached is a
+ *    separate product question, deliberately not settled here.)
+ *
+ * ## objectui#4363 — every write path names BOTH keys
+ *
+ * Removing the dead key made the surviving asymmetry visible: only
+ * `updateViewConfig` invalidated `view-overrides:{object}`, so `createView` /
+ * `updateView` / `deleteView` left the batch map stale for the cache's
+ * 5-minute TTL. It does not self-heal — `loadViewOverrides` (app-shell
+ * `ObjectView`) treats a RESOLVED map as authoritative and deliberately does
+ * not re-probe per view (#3774), so the per-view `getView` fallback that would
+ * have masked a stale map is by design unreachable.
+ *
+ * So the rule these pins now enforce is uniform and per-METHOD, not
+ * per-branch: **a write to a view row invalidates the per-view key and the
+ * object's override map.** Four paths (five call sites — `updateView` has a
+ * draft half and a published half) emit the same ordered pair. The two sweep
+ * pins are untouched controls: `listViews` stays uncached, and no path names a
+ * `views:` key.
+ */
+
+interface Harness {
+  ds: any;
+  /** Every key passed to `metadataCache.invalidate`, in order. */
+  invalidated: string[];
+  /** Every key passed to `metadataCache.get`, in order. */
+  cacheReads: string[];
+  getItems: ReturnType<typeof vi.fn>;
+  saveItem: ReturnType<typeof vi.fn>;
+  deleteItem: ReturnType<typeof vi.fn>;
+}
+
+/**
+ * Adapter with a recording metadata cache.
+ *
+ * @param opts.items      what `client.meta.getItems('view')` returns
+ * @param opts.published  what `client.meta.getItem` answers (body, or an
+ *                        Error to throw — a 404 means "no published overlay")
+ * @param opts.draft      body served at `GET /meta/view/:name?state=draft`
+ *                        (`null` → 404, i.e. nothing pending)
+ */
+function makeDS(opts: {
+  items?: any[];
+  published?: any | Error;
+  draft?: any | null;
+} = {}): Harness {
+  const invalidated: string[] = [];
+  const cacheReads: string[] = [];
+
+  const fetchImpl = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
+    const url = String(input);
+    const json = (body: unknown, status = 200) =>
+      new Response(JSON.stringify(body), {
+        status,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    if (url.includes('/meta/view/')) {
+      if ((init?.method ?? 'GET') === 'PUT') return json({ success: true, version: 2 });
+      // #4479 — `deleteView` addresses BOTH homes over this wire, so the
+      // harness has to answer DELETE. The framework never 404s a missing
+      // home: it reports one with a 200 carrying `reset:false`. Modelled
+      // faithfully (a home "has a row" exactly when this harness was told to
+      // serve one) so the pins below stay pins on INVALIDATION rather than
+      // becoming accidental assertions about the transport.
+      if ((init?.method ?? 'GET') === 'DELETE') {
+        const hasRow = url.includes('state=draft')
+          ? opts.draft != null
+          : opts.published != null && !(opts.published instanceof Error);
+        return json({ success: true, reset: hasRow });
+      }
+      if (url.includes('state=draft')) {
+        if (opts.draft == null) return json({ error: 'not found' }, 404);
+        return json({ type: 'view', name: opts.draft.name, item: opts.draft });
+      }
+      return json({ error: 'not found' }, 404);
+    }
+    return json({ success: true, data: { capabilities: {}, routes: {} } });
+  });
+
+  const ds: any = new ObjectStackAdapter({ baseUrl: 'http://test.local', fetch: fetchImpl });
+  ds.connected = true;
+  ds.connectionState = 'connected';
+
+  // Recording stand-in for the real MetadataCache: `get` records the key and
+  // always misses (runs the loader), `invalidate` records the key.
+  ds.metadataCache = {
+    get: async (key: string, loader: () => Promise<any>) => {
+      cacheReads.push(key);
+      return loader();
+    },
+    invalidate: (key: string) => {
+      invalidated.push(key);
+    },
+    getCachedSync: () => undefined,
+    getStats: () => ({}),
+  };
+
+  const getItems = vi.fn(async () => ({ items: opts.items ?? [] }));
+  const saveItem = vi.fn(async () => ({ success: true }));
+  const deleteItem = vi.fn(async () => ({ deleted: true }));
+  ds.client = {
+    meta: {
+      getItems,
+      saveItem,
+      deleteItem,
+      getItem: vi.fn(async () => {
+        if (opts.published instanceof Error) throw opts.published;
+        return { item: opts.published ?? { name: 'v1', object: 'account' } };
+      }),
+    },
+  };
+
+  return { ds, invalidated, cacheReads, getItems, saveItem, deleteItem };
+}
+
+/** A published read that 404s, decorated the way the SDK client decorates. */
+function notFound(): Error {
+  return Object.assign(new Error('Metadata item not found'), { httpStatus: 404 });
+}
+
+const VIEW = {
+  name: 'account.all',
+  object: 'account',
+  viewKind: 'list',
+  label: 'All Accounts',
+  config: { type: 'grid', data: { object: 'account' } },
+};
+
+describe('view metadata cache — invalidation names only keys with readers (#3778)', () => {
+  it('listViews reads the transport on every call and consults no cache key', async () => {
+    const { ds, getItems, cacheReads } = makeDS({ items: [VIEW] });
+
+    await ds.listViews('account');
+    await ds.listViews('account');
+
+    // Uncached: two calls, two round trips. This is the behavior the removed
+    // `views:{object}` invalidations pretended to manage.
+    expect(getItems).toHaveBeenCalledTimes(2);
+    expect(getItems).toHaveBeenCalledWith('view');
+    expect(cacheReads).toEqual([]);
+  });
+
+  it('updateViewConfig invalidates exactly the two keys that have readers', async () => {
+    const { ds, invalidated } = makeDS();
+
+    await ds.updateViewConfig('account', 'v1', { label: 'Renamed' });
+
+    // `view:{object}:{viewId}` → getView; `view-overrides:{object}` →
+    // listViewOverrides. Nothing else is read back under a view-shaped key.
+    expect(invalidated).toEqual(['view:account:v1', 'view-overrides:account']);
+  });
+
+  it('listViewOverrides reads back under the key the write paths invalidate', async () => {
+    // The pairing, not the string: every assertion below names
+    // `view-overrides:account` because THIS is the key the batch reader caches
+    // under. An invalidation that named anything else would be the `views:`
+    // mistake again, one rename later.
+    const { ds, cacheReads } = makeDS({ items: [VIEW] });
+
+    await ds.listViewOverrides('account');
+
+    expect(cacheReads).toEqual(['view-overrides:account']);
+  });
+
+  it('createView invalidates the per-view key and the override map (#4363)', async () => {
+    const { ds, invalidated } = makeDS();
+
+    await ds.createView('account', { name: 'account.mine', object: 'account' });
+
+    // A created view is a new row in the batch map; nothing else notices.
+    // `saveItem` is an upsert, so the per-view key is named too — an explicit
+    // `name` that already exists overwrites a row `getView` may hold cached.
+    expect(invalidated).toEqual(['view:account:account.mine', 'view-overrides:account']);
+  });
+
+  it('updateView (published overlay) invalidates both keys (#4363)', async () => {
+    const { ds, invalidated } = makeDS({ published: { name: 'v1', object: 'account' } });
+
+    await ds.updateView('account', 'v1', { label: 'Renamed' });
+
+    expect(invalidated).toEqual(['view:account:v1', 'view-overrides:account']);
+  });
+
+  it('updateView (pending draft) invalidates both keys (#4363)', async () => {
+    const { ds, invalidated } = makeDS({ draft: VIEW, published: notFound() });
+
+    await ds.updateView('account', VIEW.name, { label: 'Renamed' });
+
+    // Deliberate over-invalidation on this half: both readers enumerate
+    // PUBLISHED rows, so a draft write stales neither — as was already true of
+    // the per-view line this pairs with. Pinned so the uniform per-method rule
+    // is a decision on the record, not an oversight the next reader "fixes".
+    expect(invalidated).toEqual([
+      `view:account:${VIEW.name}`,
+      'view-overrides:account',
+    ]);
+  });
+
+  it('deleteView invalidates both keys (#4363)', async () => {
+    const { ds, invalidated } = makeDS();
+
+    await ds.deleteView('account', 'v1');
+
+    // The deleted row leaves the override map too — a ghost entry there is what
+    // the object page would keep applying for the rest of the TTL.
+    expect(invalidated).toEqual(['view:account:v1', 'view-overrides:account']);
+  });
+
+  it('no write path invalidates a `views:` key — nothing populates one', async () => {
+    // createView is the path whose ONLY invalidation was the dead key. #3778
+    // asserted "no `views:` key" here rather than "no invalidation at all",
+    // deliberately leaving the override-map question to its own card — and
+    // #4363 answered it: createView now names both live keys (pinned above).
+    // The ASSERTION is unchanged, which is the point of the slot: the dead key
+    // stays dead however the live key set grows.
+    const created = makeDS();
+    await created.ds.createView('account', { name: 'account.mine', object: 'account' });
+
+    const config = makeDS();
+    await config.ds.updateViewConfig('account', 'v1', { label: 'Renamed' });
+
+    const removed = makeDS();
+    await removed.ds.deleteView('account', 'v1');
+
+    for (const { invalidated } of [created, config, removed]) {
+      expect(invalidated.filter((k) => k.startsWith('views:'))).toEqual([]);
+    }
+  });
+});