@object-ui/data-objectstack 17.5.0 → 17.6.0

package/src/v3-compat.test.ts

@@ -1,229 +0,0 @@
-/**
- * v3.0.0 compatibility tests for @objectstack dependencies.
- * Validates that all integration modules work correctly with the spec.
- */
-import { describe, it, expect } from 'vitest';
-import { validatePluginContract, generateContractManifest } from './contracts';
-import { IntegrationManager } from './integration';
-import { SecurityManager } from './security';
-import { createDefaultCanvasConfig, snapToGrid, calculateAutoLayout } from './studio';
-
-// 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 = {
-        name: 'my-plugin',
-        version: '1.0.0',
-        exports: [{ name: 'MyComponent', type: 'component' as const }],
-        permissions: ['data.read'],
-      };
-      const result = validatePluginContract(contract);
-      expect(result.valid).toBe(true);
-      expect(result.errors).toHaveLength(0);
-    });
-
-    it('should reject invalid plugin contract', () => {
-      const contract = {
-        name: '',
-        version: 'invalid',
-        exports: [],
-      };
-      const result = validatePluginContract(contract);
-      expect(result.valid).toBe(false);
-      expect(result.errors.length).toBeGreaterThan(0);
-    });
-
-    it('should generate contract manifest', () => {
-      const contract = {
-        name: 'test-plugin',
-        version: '2.0.0',
-        exports: [{ name: 'GridView', type: 'component' as const, description: 'A grid view' }],
-        permissions: ['data.read', 'data.write'],
-      };
-      const manifest = generateContractManifest(contract);
-      expect(manifest.$schema).toBeDefined();
-      expect(manifest.name).toBe('test-plugin');
-      expect(manifest.version).toBe('2.0.0');
-    });
-  });
-
-  describe('Integration module', () => {
-    it('should register and retrieve integrations', () => {
-      const manager = new IntegrationManager();
-      manager.register('slack-1', {
-        provider: 'slack',
-        enabled: true,
-        config: { webhookUrl: 'https://hooks.slack.com/test' },
-        triggers: [{ event: 'record.created' }],
-      });
-
-      const all = manager.getAll();
-      expect(all.size).toBe(1);
-    });
-
-    it('should filter integrations by event', () => {
-      const manager = new IntegrationManager();
-      manager.register('webhook-1', {
-        provider: 'webhook',
-        enabled: true,
-        config: { url: 'https://example.com/hook', method: 'POST' },
-        triggers: [{ event: 'record.created' }],
-      });
-      manager.register('webhook-2', {
-        provider: 'webhook',
-        enabled: true,
-        config: { url: 'https://example.com/hook2', method: 'POST' },
-        triggers: [{ event: 'record.deleted' }],
-      });
-
-      const createMatches = manager.getForEvent('record.created');
-      expect(createMatches).toHaveLength(1);
-    });
-
-    it('should unregister integrations', () => {
-      const manager = new IntegrationManager();
-      manager.register('test', {
-        provider: 'webhook',
-        enabled: true,
-        config: { url: 'https://example.com', method: 'POST' },
-      });
-      manager.unregister('test');
-      expect(manager.getAll().size).toBe(0);
-    });
-  });
-
-  describe('Security module', () => {
-    it('should generate CSP header', () => {
-      const manager = new SecurityManager({
-        csp: {
-          scriptSrc: ["'self'", "'unsafe-inline'"],
-          styleSrc: ["'self'", "'unsafe-inline'"],
-          imgSrc: ["'self'", 'data:', 'https:'],
-          connectSrc: ["'self'", 'https://api.example.com'],
-          fontSrc: ["'self'"],
-        },
-      });
-
-      const header = manager.generateCSPHeader();
-      expect(header).toContain("script-src 'self' 'unsafe-inline'");
-      expect(header).toContain("connect-src 'self' https://api.example.com");
-    });
-
-    it('should record and filter audit logs', () => {
-      const manager = new SecurityManager({
-        auditLog: {
-          enabled: true,
-          events: ['data.create', 'data.read', 'auth.login'],
-          destination: 'console',
-        },
-      });
-
-      manager.recordAudit({ event: 'data.create', userId: 'user-1', resource: 'accounts' });
-      manager.recordAudit({ event: 'auth.login', userId: 'user-2' });
-      manager.recordAudit({ event: 'data.create', userId: 'user-1', resource: 'contacts' });
-
-      const allLogs = manager.getAuditLog();
-      expect(allLogs).toHaveLength(3);
-
-      const userLogs = manager.getAuditLog({ userId: 'user-1' });
-      expect(userLogs).toHaveLength(2);
-
-      const loginLogs = manager.getAuditLog({ event: 'auth.login' });
-      expect(loginLogs).toHaveLength(1);
-    });
-
-    it('should mask record data', () => {
-      const manager = new SecurityManager({
-        dataMasking: {
-          rules: [
-            { field: 'ssn', strategy: 'partial', visibleChars: 4 },
-            { field: 'password', strategy: 'redact' },
-            { field: 'email', strategy: 'full' },
-            { field: 'phone', strategy: 'partial', visibleChars: 3, exemptRoles: ['admin'] },
-          ],
-        },
-      });
-
-      const record = {
-        ssn: '123-45-6789',
-        password: 'secret123',
-        email: 'john@example.com',
-        phone: '555-1234',
-        name: 'John',
-      };
-      
-      const masked = manager.maskRecord(record);
-      expect(masked.ssn).toBe('123-*******');
-      expect(masked.password).toBe('[REDACTED]');
-      expect(masked.email).toBe('****************');
-      expect(masked.name).toBe('John'); // Not masked
-      
-      // Admin sees phone unmasked
-      const adminMasked = manager.maskRecord(record, ['admin']);
-      expect(adminMasked.phone).toBe('555-1234');
-    });
-  });
-
-  describe('Studio module', () => {
-    it('should create default canvas config', () => {
-      const config = createDefaultCanvasConfig();
-      expect(config.width).toBe(1200);
-      expect(config.height).toBe(800);
-      expect(config.snapToGrid).toBe(true);
-      expect(config.zoom.min).toBe(0.25);
-      expect(config.zoom.max).toBe(3);
-    });
-
-    it('should create canvas config with overrides', () => {
-      const config = createDefaultCanvasConfig({ width: 1600, showMinimap: true });
-      expect(config.width).toBe(1600);
-      expect(config.showMinimap).toBe(true);
-      expect(config.height).toBe(800); // Default
-    });
-
-    it('should snap positions to grid', () => {
-      expect(snapToGrid(13, 27, 8)).toEqual({ x: 16, y: 24 });
-      expect(snapToGrid(0, 0, 8)).toEqual({ x: 0, y: 0 });
-      expect(snapToGrid(4, 4, 8)).toEqual({ x: 8, y: 8 });
-    });
-
-    it('should calculate auto-layout positions', () => {
-      const items = [
-        { id: '1', width: 200, height: 150 },
-        { id: '2', width: 200, height: 100 },
-        { id: '3', width: 200, height: 200 },
-      ];
-      const positions = calculateAutoLayout(items, 1200);
-      expect(positions).toHaveLength(3);
-      expect(positions[0].x).toBe(40); // padding
-      expect(positions[0].y).toBe(40); // padding
-      expect(positions[1].x).toBeGreaterThan(positions[0].x);
-    });
-  });
-
-  describe('PaginatedResult API (records/total/hasMore)', () => {
-    it('should support v3.0.0 PaginatedResult fields', () => {
-      // Verify the QueryResult type supports records/total/hasMore
-      const result = {
-        data: [{ id: '1' }],
-        total: 10,
-        page: 1,
-        pageSize: 5,
-        hasMore: true,
-      };
-      expect(result.data).toHaveLength(1);
-      expect(result.total).toBe(10);
-      expect(result.hasMore).toBe(true);
-    });
-  });
-});

package/src/validation-error.test.ts

@@ -1,94 +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 } from 'vitest';
-
-import { normaliseClientError } from './index';
-import { DataApiValidationError } from './errors';
-
-/**
- * The server has always sent per-field rejection detail; the adapter used to
- * hand callers the raw client error, so `fields[]` had no typed home and every
- * form fell back to one undirected toast.
- */
-describe('normaliseClientError — VALIDATION_FAILED', () => {
-  // `@objectstack/rest` serves a thrown validation failure as 400 with `fields[]`
-  // verbatim; `@objectstack/client` sets `error.details` to the parsed body's
-  // `details` OR — as here, since the envelope has no such key — the whole body.
-  const upstream = () =>
-    Object.assign(new Error('Name is required; Stage is not a valid option'), {
-      code: 'VALIDATION_FAILED',
-      httpStatus: 400,
-      details: {
-        error: 'Name is required; Stage is not a valid option',
-        code: 'VALIDATION_FAILED',
-        fields: [
-          { field: 'name', code: 'required', message: 'Name is required' },
-          { field: 'stage', code: 'invalid_option', message: 'Stage is not a valid option' },
-        ],
-        object: 'crm_opportunity',
-      },
-    });
-
-  it('wraps it into a typed DataApiValidationError', () => {
-    const normalised = normaliseClientError(upstream());
-    expect(normalised).toBeInstanceOf(DataApiValidationError);
-  });
-
-  it('carries every field entry through', () => {
-    const normalised = normaliseClientError(upstream()) as DataApiValidationError;
-    expect(normalised.validationErrors).toEqual([
-      { field: 'name', message: 'Name is required' },
-      { field: 'stage', message: 'Stage is not a valid option' },
-    ]);
-  });
-
-  it('keeps the server message verbatim — it names every field', () => {
-    const normalised = normaliseClientError(upstream()) as DataApiValidationError;
-    expect(normalised.message).toBe('Name is required; Stage is not a valid option');
-  });
-
-  it('exposes the first offending field on `.field`', () => {
-    const normalised = normaliseClientError(upstream()) as DataApiValidationError;
-    expect(normalised.field).toBe('name');
-  });
-
-  it('falls back to the machine code when an entry has no message', () => {
-    const err = Object.assign(new Error('Validation failed'), {
-      code: 'VALIDATION_FAILED',
-      details: { fields: [{ field: 'name', code: 'required' }] },
-    });
-    const normalised = normaliseClientError(err) as DataApiValidationError;
-    expect(normalised.validationErrors).toEqual([{ field: 'name', message: 'required' }]);
-  });
-
-  it('drops entries with no field rather than inventing one', () => {
-    const err = Object.assign(new Error('Validation failed'), {
-      code: 'VALIDATION_FAILED',
-      details: { fields: [{ message: 'something is wrong' }] },
-    });
-    const normalised = normaliseClientError(err) as DataApiValidationError;
-    expect(normalised.validationErrors).toEqual([]);
-  });
-
-  it('still wraps when the error carries `fields` directly (hand-rolled shape)', () => {
-    // The server duck-types on `code`/`name`, so a hook throwing the bare shape
-    // is served identically — the client must not be pickier than the server.
-    const err = Object.assign(new Error('nope'), {
-      name: 'ValidationError',
-      fields: [{ field: 'amount', message: 'Amount must be positive' }],
-    });
-    const normalised = normaliseClientError(err) as DataApiValidationError;
-    expect(normalised.validationErrors).toEqual([{ field: 'amount', message: 'Amount must be positive' }]);
-  });
-
-  it('leaves an unrelated 400 untouched', () => {
-    const err = Object.assign(new Error('bad request'), { code: 'BAD_REQUEST', httpStatus: 400 });
-    expect(normaliseClientError(err)).toBe(err);
-  });
-});

package/src/viewCacheInvalidation.pin.test.ts

@@ -1,260 +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';
-
-/**
- * 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([]);
-    }
-  });
-});