@object-ui/data-objectstack 17.3.0 → 17.6.0

package/src/integration.ts

@@ -1,200 +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.
- */
-
-/**
- * Integration module for @objectstack/spec v3.0.0
- * Provides third-party service connectors for Slack, email, webhooks.
- */
-
-export type IntegrationProvider = 'slack' | 'email' | 'webhook' | 'teams' | 'discord';
-
-export interface IntegrationConfig {
-  /** Integration provider type */
-  provider: IntegrationProvider;
-  /** Whether this integration is enabled */
-  enabled: boolean;
-  /** Provider-specific configuration */
-  config: Record<string, unknown>;
-  /** Event triggers */
-  triggers?: IntegrationTrigger[];
-}
-
-export interface IntegrationTrigger {
-  /** Event name (e.g. 'record.created', 'record.updated') */
-  event: string;
-  /** Filter condition */
-  filter?: string;
-  /** Template for the message/payload */
-  template?: string;
-}
-
-export interface SlackIntegrationConfig extends IntegrationConfig {
-  provider: 'slack';
-  config: {
-    webhookUrl: string;
-    channel?: string;
-    username?: string;
-    iconEmoji?: string;
-  };
-}
-
-export interface EmailIntegrationConfig extends IntegrationConfig {
-  provider: 'email';
-  config: {
-    smtpHost: string;
-    smtpPort: number;
-    secure: boolean;
-    from: string;
-    to: string[];
-    subject?: string;
-  };
-}
-
-export interface WebhookIntegrationConfig extends IntegrationConfig {
-  provider: 'webhook';
-  config: {
-    url: string;
-    method: 'GET' | 'POST' | 'PUT' | 'PATCH';
-    headers?: Record<string, string>;
-    retryCount?: number;
-    retryDelay?: number;
-  };
-}
-
-/**
- * Integration service manager.
- * Manages third-party service connections and event dispatching.
- */
-export class IntegrationManager {
-  private integrations: Map<string, IntegrationConfig> = new Map();
-
-  /**
-   * Register a new integration.
-   */
-  register(id: string, config: IntegrationConfig): void {
-    this.integrations.set(id, config);
-  }
-
-  /**
-   * Remove an integration.
-   */
-  unregister(id: string): void {
-    this.integrations.delete(id);
-  }
-
-  /**
-   * Get all registered integrations.
-   */
-  getAll(): Map<string, IntegrationConfig> {
-    return new Map(this.integrations);
-  }
-
-  /**
-   * Get integrations that match a specific event.
-   */
-  getForEvent(event: string): IntegrationConfig[] {
-    return Array.from(this.integrations.values()).filter(
-      (integration) =>
-        integration.enabled &&
-        integration.triggers?.some((t) => t.event === event)
-    );
-  }
-
-  /**
-   * Dispatch an event to all matching integrations.
-   * Returns results for each integration.
-   */
-  async dispatch(event: string, payload: Record<string, unknown>): Promise<Array<{ id: string; success: boolean; error?: string }>> {
-    const matching = this.getForEvent(event);
-    const results: Array<{ id: string; success: boolean; error?: string }> = [];
-
-    for (const [id, integration] of this.integrations) {
-      if (!matching.includes(integration)) continue;
-      
-      try {
-        await this.send(integration, payload);
-        results.push({ id, success: true });
-      } catch (err) {
-        results.push({ id, success: false, error: (err as Error).message });
-      }
-    }
-
-    return results;
-  }
-
-  /**
-   * Send payload to a specific integration.
-   */
-  private async send(integration: IntegrationConfig, payload: Record<string, unknown>): Promise<void> {
-    switch (integration.provider) {
-      case 'webhook': {
-        const cfg = integration.config as WebhookIntegrationConfig['config'];
-        const url = cfg.url;
-        // Validate URL - only allow http and https protocols
-        try {
-          const parsed = new URL(url);
-          if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-            throw new Error(`Invalid URL protocol: ${parsed.protocol}`);
-          }
-        } catch (e) {
-          if (e instanceof TypeError) {
-            // A malformed URL surfaces as its own message; we can't attach `e`
-            // as the `Error` `cause` because this package targets ES2020, whose
-            // lib types the 1-arg `Error` constructor only. Scoped disable.
-            // eslint-disable-next-line preserve-caught-error
-            throw new Error(`Invalid webhook URL: ${url}`);
-          }
-          throw e;
-        }
-        await fetch(url, {
-          method: cfg.method,
-          headers: {
-            'Content-Type': 'application/json',
-            ...cfg.headers,
-          },
-          body: JSON.stringify(payload),
-        });
-        break;
-      }
-      case 'slack': {
-        const cfg = integration.config as SlackIntegrationConfig['config'];
-        const url = cfg.webhookUrl;
-        // Validate URL - only allow https protocol for Slack webhooks
-        try {
-          const parsed = new URL(url);
-          if (parsed.protocol !== 'https:') {
-            throw new Error(`Invalid Slack webhook URL protocol: ${parsed.protocol}`);
-          }
-        } catch (e) {
-          if (e instanceof TypeError) {
-            // A malformed URL surfaces as its own message; we can't attach `e`
-            // as the `Error` `cause` because this package targets ES2020, whose
-            // lib types the 1-arg `Error` constructor only. Scoped disable.
-            // eslint-disable-next-line preserve-caught-error
-            throw new Error(`Invalid Slack webhook URL: ${url}`);
-          }
-          throw e;
-        }
-        await fetch(url, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            channel: cfg.channel,
-            username: cfg.username,
-            icon_emoji: cfg.iconEmoji,
-            text: JSON.stringify(payload),
-          }),
-        });
-        break;
-      }
-      // Email and other providers would require server-side implementation
-      default:
-        break;
-    }
-  }
-}

package/src/listViews.test.ts

@@ -1,175 +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';
-
-/**
- * `listViews(object)` feeds the list-view switcher (ObjectView → ViewTabBar),
- * so it must return LIST-family views only. The backend exposes each view as
- * an independent ViewItem carrying a `viewKind` discriminant (ADR-0017); a
- * form-family view (e.g. `crm_activity.default`) must NOT leak in as a tab.
- */
-function makeDS(items: 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 = { meta: { getItems: vi.fn(async () => ({ items })) } };
-  return ds;
-}
-
-/**
- * A DS whose HTTP layer answers the `?preview=draft` metadata route with a
- * pre-overlaid list (the shape the framework already returns: draft wins by
- * name, each draft tagged `_draft`). The published `client.meta.getItems` stub
- * is present but MUST NOT be used in preview mode.
- */
-function makeDraftDS(overlaid: any[]) {
-  const fetchImpl = vi.fn(async (input: RequestInfo | URL) => {
-    const url = String(input);
-    if (url.includes('/meta/view')) {
-      return new Response(JSON.stringify({ items: overlaid }), {
-        status: 200,
-        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';
-  ds.client = { meta: { getItems: vi.fn(async () => ({ items: [] })) } };
-  return { ds, fetchImpl };
-}
-
-describe('ObjectStackDataSource.listViews', () => {
-  // The crm_activity view set as the framework expands it.
-  const listAll = {
-    name: 'crm_activity.all', object: 'crm_activity', viewKind: 'list', isDefault: true,
-    label: 'All Activities', config: { type: 'grid', data: { object: 'crm_activity' } },
-  };
-  const listCalendar = {
-    name: 'crm_activity.calendar', object: 'crm_activity', viewKind: 'list',
-    label: 'Activity Calendar', config: { type: 'calendar', data: { object: 'crm_activity' } },
-  };
-  const formDefault = {
-    name: 'crm_activity.default', object: 'crm_activity', viewKind: 'form',
-    label: 'Activity', config: { type: 'simple' },
-  };
-
-  it('excludes form-family ViewItems from the list-view switcher', async () => {
-    const ds = makeDS([listAll, listCalendar, formDefault]);
-    const views = await ds.listViews('crm_activity');
-    const names = views.map((v: any) => v.name).sort();
-    expect(names).toEqual(['crm_activity.all', 'crm_activity.calendar']);
-    // The form view is the original leak — it must be gone.
-    expect(views.find((v: any) => v.name === 'crm_activity.default')).toBeUndefined();
-  });
-
-  it('excludes detail-family views too', async () => {
-    const detail = { name: 'crm_activity.detail', object: 'crm_activity', viewKind: 'detail', config: {} };
-    const ds = makeDS([listAll, detail]);
-    const views = await ds.listViews('crm_activity');
-    expect(views.map((v: any) => v.name)).toEqual(['crm_activity.all']);
-  });
-
-  it('filters by object binding', async () => {
-    const otherList = { name: 'crm_lead.all', object: 'crm_lead', viewKind: 'list', config: {} };
-    const ds = makeDS([listAll, otherList]);
-    const views = await ds.listViews('crm_activity');
-    expect(views.map((v: any) => v.name)).toEqual(['crm_activity.all']);
-  });
-
-  it('keeps legacy bare specs without a viewKind (saved/list views)', async () => {
-    const legacy = { name: 'saved_grid', object: 'crm_activity', type: 'grid' };
-    const wrapped = { list: { name: 'wrapped_grid', object: 'crm_activity', type: 'grid' } };
-    const ds = makeDS([legacy, wrapped]);
-    const views = await ds.listViews('crm_activity');
-    expect(views.map((v: any) => v.name).sort()).toEqual(['saved_grid', 'wrapped_grid']);
-  });
-
-  // ── #2767 draft-preview branch ───────────────────────────────────────────
-  describe('previewDrafts (#2767 P2/P3)', () => {
-    it('reads the draft-overlaid list in a SINGLE preview=draft request', async () => {
-      // Server response overlays a draft edit of `all` (draft wins by name) and
-      // a brand-new draft-only `mine`; `calendar` is untouched/published.
-      const overlaid = [
-        {
-          name: 'crm_activity.all', object: 'crm_activity', viewKind: 'list',
-          label: 'All (edited)', config: { type: 'grid', data: { object: 'crm_activity' } },
-          _draft: true,
-        },
-        {
-          name: 'crm_activity.calendar', object: 'crm_activity', viewKind: 'list',
-          label: 'Activity Calendar', config: { type: 'calendar', data: { object: 'crm_activity' } },
-        },
-        {
-          name: 'crm_activity.mine', object: 'crm_activity', viewKind: 'list',
-          label: 'Mine', config: { type: 'grid', data: { object: 'crm_activity' } },
-          _draft: true,
-        },
-      ];
-      const { ds, fetchImpl } = makeDraftDS(overlaid);
-      const views = await ds.listViews('crm_activity', { previewDrafts: true });
-
-      // Exactly one request, and it carries the preview flag.
-      const metaCalls = fetchImpl.mock.calls.filter(([u]: any[]) => String(u).includes('/meta/view'));
-      expect(metaCalls).toHaveLength(1);
-      expect(String(metaCalls[0][0])).toContain('preview=draft');
-      // Preview mode must NOT also hit the published path (that's the P2 dupe bug).
-      expect(ds.client.meta.getItems).not.toHaveBeenCalled();
-
-      // One tab per name — the draft edit of `all` does not duplicate it.
-      expect(views.map((v: any) => v.name).sort()).toEqual([
-        'crm_activity.all', 'crm_activity.calendar', 'crm_activity.mine',
-      ]);
-    });
-
-    it('flows the _draft provenance flag through for the switcher badge', async () => {
-      const overlaid = [
-        {
-          name: 'crm_activity.mine', object: 'crm_activity', viewKind: 'list',
-          label: 'Mine', config: { type: 'grid', data: { object: 'crm_activity' } }, _draft: true,
-        },
-        {
-          name: 'crm_activity.calendar', object: 'crm_activity', viewKind: 'list',
-          label: 'Cal', config: { type: 'calendar', data: { object: 'crm_activity' } },
-        },
-      ];
-      const { ds } = makeDraftDS(overlaid);
-      const views = await ds.listViews('crm_activity', { previewDrafts: true });
-      expect(views.find((v: any) => v.name === 'crm_activity.mine')?._draft).toBe(true);
-      expect(views.find((v: any) => v.name === 'crm_activity.calendar')?._draft).toBeUndefined();
-    });
-
-    it('non-preview mode uses the published getItems path (no draft fetch)', async () => {
-      const { ds, fetchImpl } = makeDraftDS([]);
-      ds.client.meta.getItems = vi.fn(async () => ({
-        items: [{
-          name: 'crm_activity.all', object: 'crm_activity', viewKind: 'list',
-          config: { type: 'grid', data: { object: 'crm_activity' } },
-        }],
-      }));
-      const views = await ds.listViews('crm_activity');
-      expect(ds.client.meta.getItems).toHaveBeenCalledTimes(1);
-      expect(fetchImpl.mock.calls.filter(([u]: any[]) => String(u).includes('/meta/view'))).toHaveLength(0);
-      expect(views.map((v: any) => v.name)).toEqual(['crm_activity.all']);
-      expect(views[0]._draft).toBeUndefined();
-    });
-  });
-});

package/src/metadata-client.test.ts

@@ -1,303 +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, beforeEach } from 'vitest';
-import { MetadataClient } from './metadata-client';
-
-function mockFetch(handler: (url: string, init?: RequestInit) => Promise<Response>): typeof fetch {
-  return vi.fn(handler) as unknown as typeof fetch;
-}
-
-function jsonResponse(body: unknown, init?: ResponseInit): Response {
-  return new Response(JSON.stringify(body), {
-    status: 200,
-    headers: { 'content-type': 'application/json' },
-    ...init,
-  });
-}
-
-describe('MetadataClient', () => {
-  let urls: string[];
-  let inits: (RequestInit | undefined)[];
-
-  beforeEach(() => {
-    urls = [];
-    inits = [];
-  });
-
-  function client(baseUrl: string, environmentId?: string) {
-    return new MetadataClient({
-      baseUrl,
-      environmentId,
-      fetch: mockFetch(async (url, init) => {
-        urls.push(url);
-        inits.push(init);
-        if (init?.method === 'PUT' || init?.method === 'DELETE') {
-          return jsonResponse({ ok: true });
-        }
-        if (url.endsWith('/meta')) return jsonResponse([{ type: 'object' }]);
-        if (url.match(/\/meta\/object$/)) return jsonResponse([{ name: 'account' }]);
-        if (url.match(/\/meta\/object\/account$/)) {
-          return jsonResponse({ name: 'account', label: 'Account' });
-        }
-        if (url.match(/\/meta\/object\/missing$/)) {
-          return new Response('not found', { status: 404 });
-        }
-        if (url.match(/history$/)) return jsonResponse({ events: [] });
-        return jsonResponse({ items: [{ name: 'fallback' }] });
-      }),
-    });
-  }
-
-  it('builds unscoped URLs against the bare baseUrl', async () => {
-    await client('http://localhost:3000').list('object');
-    expect(urls[0]).toBe('http://localhost:3000/api/v1/meta/object');
-  });
-
-  it('save() rejects an empty name before any request (#2767 empty-name 405)', async () => {
-    const c = client('http://localhost:3000');
-    await expect(c.save('view', '', { columns: [] })).rejects.toThrow(/name must be non-empty/);
-    await expect(c.save('view', '   ', { columns: [] })).rejects.toThrow(/name must be non-empty/);
-    // No malformed `PUT /meta/view/` ever reached the transport.
-    expect(urls).toEqual([]);
-  });
-
-  it('builds scoped URLs when environmentId is set', async () => {
-    await client('http://localhost:3000', 'env_42').list('object');
-    expect(urls[0]).toBe('http://localhost:3000/api/v1/environments/env_42/meta/object');
-  });
-
-  it('collapses /api/v1 suffix on baseUrl to avoid duplication', async () => {
-    await client('http://localhost:3000/api/v1').list('object');
-    expect(urls[0]).toBe('http://localhost:3000/api/v1/meta/object');
-  });
-
-  it('returns null on 404 from get()', async () => {
-    const result = await client('http://localhost:3000').get('object', 'missing');
-    expect(result).toBeNull();
-  });
-
-  it('unwraps `items` envelope on list when the server returns one', async () => {
-    const c = new MetadataClient({
-      baseUrl: 'http://localhost:3000',
-      fetch: mockFetch(async () => jsonResponse({ items: [{ name: 'wrapped' }] })),
-    });
-    const items = await c.list<{ name: string }>('field');
-    expect(items).toEqual([{ name: 'wrapped' }]);
-  });
-
-  it('sends If-Match and X-Actor headers on save when provided', async () => {
-    await client('http://localhost:3000').save('object', 'account', { foo: 1 }, {
-      ifMatch: 'sha256:abc',
-      actor: 'user_1',
-    });
-    expect(inits[0]?.method).toBe('PUT');
-    const headers = inits[0]?.headers as Record<string, string>;
-    expect(headers['If-Match']).toBe('sha256:abc');
-    expect(headers['X-Actor']).toBe('user_1');
-    expect(headers['Content-Type']).toBe('application/json');
-    expect(inits[0]?.body).toBe(JSON.stringify({ foo: 1 }));
-  });
-
-  it('encodes type and name path segments', async () => {
-    await client('http://localhost:3000').get('object', 'has spaces');
-    expect(urls[0]).toBe('http://localhost:3000/api/v1/meta/object/has%20spaces');
-  });
-
-  it('builds history URL with query params', async () => {
-    await client('http://localhost:3000').history('view', 'all', { sinceSeq: 10, limit: 5 });
-    expect(urls[0]).toBe('http://localhost:3000/api/v1/meta/view/all/history?sinceSeq=10&limit=5');
-  });
-
-  it('throws MetadataError with status and body on failure', async () => {
-    const c = new MetadataClient({
-      baseUrl: 'http://localhost:3000',
-      fetch: mockFetch(async () =>
-        new Response(JSON.stringify({ error: 'metadata_conflict', code: 'metadata_conflict' }), {
-          status: 409,
-          headers: { 'content-type': 'application/json' },
-        })),
-    });
-    await expect(c.save('object', 'account', {})).rejects.toMatchObject({
-      status: 409,
-      code: 'metadata_conflict',
-      message: 'metadata_conflict',
-    });
-  });
-
-  it('extracts message, code + field-anchored issues from the dispatcher error shape', async () => {
-    // The dispatcher sends `error` as an OBJECT { message, code, details:{ code, issues } }.
-    // Reading `.message` (not String(object) → "[object Object]") and surfacing
-    // `details.issues` is what lets the Studio point at the offending field.
-    const c = new MetadataClient({
-      baseUrl: 'http://localhost:3000',
-      fetch: mockFetch(async () =>
-        new Response(
-          JSON.stringify({
-            success: false,
-            error: {
-              message: '[invalid_metadata] object/bad failed spec validation: label: Required',
-              code: 422,
-              details: {
-                code: 'invalid_metadata',
-                issues: [{ path: 'label', message: 'Required', code: 'invalid_type' }],
-              },
-            },
-          }),
-          { status: 422, headers: { 'content-type': 'application/json' } },
-        )),
-    });
-    await expect(c.save('object', 'bad', {})).rejects.toMatchObject({
-      status: 422,
-      code: 'invalid_metadata',
-      message: '[invalid_metadata] object/bad failed spec validation: label: Required',
-      issues: [{ path: 'label', message: 'Required', code: 'invalid_type' }],
-    });
-  });
-
-  it('listDrafts requests /meta/_drafts with packageId + type and parses {drafts}', async () => {
-    const seen: string[] = [];
-    const c = new MetadataClient({
-      baseUrl: 'http://localhost:3000',
-      fetch: mockFetch(async (url) => {
-        seen.push(url);
-        return jsonResponse({
-          drafts: [{ type: 'object', name: 'course', packageId: 'app.edu', updatedAt: 't', updatedBy: 'ai' }],
-        });
-      }),
-    });
-    const out = await c.listDrafts({ packageId: 'app.edu', type: 'object' });
-    expect(seen[0]).toBe('http://localhost:3000/api/v1/meta/_drafts?packageId=app.edu&type=object');
-    expect(out).toEqual([
-      { type: 'object', name: 'course', packageId: 'app.edu', updatedAt: 't', updatedBy: 'ai' },
-    ]);
-  });
-
-  it('listDrafts tolerates the {data:{drafts}} envelope and a bare array', async () => {
-    const enveloped = new MetadataClient({
-      baseUrl: '',
-      fetch: mockFetch(async () =>
-        jsonResponse({ data: { drafts: [{ type: 'view', name: 'v', packageId: null, updatedAt: null, updatedBy: null }] } })),
-    });
-    expect((await enveloped.listDrafts()).map((d) => d.name)).toEqual(['v']);
-
-    const bare = new MetadataClient({
-      baseUrl: '',
-      fetch: mockFetch(async () =>
-        jsonResponse([{ type: 'object', name: 'b', packageId: null, updatedAt: null, updatedBy: null }])),
-    });
-    expect((await bare.listDrafts()).map((d) => d.name)).toEqual(['b']);
-  });
-
-  it('publishDraft POSTs /meta/:type/:name/publish (promotes a draft by ref, no package needed)', async () => {
-    const seen: { url: string; method?: string }[] = [];
-    const c = new MetadataClient({
-      baseUrl: 'http://localhost:3000',
-      fetch: mockFetch(async (url, init) => {
-        seen.push({ url, method: init?.method });
-        return jsonResponse({ success: true });
-      }),
-    });
-    await c.publishDraft('dashboard', 'sales_dashboard');
-    expect(seen[0]?.method).toBe('POST');
-    expect(seen[0]?.url).toBe('http://localhost:3000/api/v1/meta/dashboard/sales_dashboard/publish');
-  });
-
-  it('publishDraft throws on a non-ok response', async () => {
-    const c = new MetadataClient({
-      baseUrl: '',
-      fetch: mockFetch(async () => new Response('nope', { status: 500 })),
-    });
-    await expect(c.publishDraft('view', 'x')).rejects.toBeTruthy();
-  });
-
-  it('publishDraft returns the result (incl. seedApplied) and unwraps the {data} envelope', async () => {
-    // Flat shape (rest-server passes protocol result through).
-    const flat = new MetadataClient({
-      baseUrl: '',
-      fetch: mockFetch(async () =>
-        jsonResponse({ success: true, seedApplied: { success: false, error: 'no readable seed bodies' } })),
-    });
-    const r1 = await flat.publishDraft('seed', 'job_sample');
-    expect(r1.seedApplied).toEqual({ success: false, error: 'no readable seed bodies' });
-
-    // Dispatcher `{ success, data: {...} }` envelope.
-    const enveloped = new MetadataClient({
-      baseUrl: '',
-      fetch: mockFetch(async () =>
-        jsonResponse({ success: true, data: { success: true, seedApplied: { success: true, inserted: 6, updated: 0 } } })),
-    });
-    const r2 = await enveloped.publishDraft('seed', 'candidate_sample');
-    expect(r2.seedApplied).toEqual({ success: true, inserted: 6, updated: 0 });
-  });
-});
-
-describe('MetadataClient — ADR-0037 previewDrafts', () => {
-  function previewClient(opts: { previewDrafts?: boolean; environmentId?: string } = {}) {
-    const urls: string[] = [];
-    const c = new MetadataClient({
-      baseUrl: 'http://localhost:3000',
-      ...opts,
-      fetch: mockFetch(async (url) => {
-        urls.push(url);
-        return jsonResponse([{ name: 'account' }]);
-      }),
-    });
-    return { c, urls };
-  }
-
-  it('list() and get() append ?preview=draft when enabled', async () => {
-    const { c, urls } = previewClient({ previewDrafts: true });
-    await c.list('object');
-    await c.get('object', 'account');
-    expect(urls[0]).toBe('http://localhost:3000/api/v1/meta/object?preview=draft');
-    expect(urls[1]).toBe('http://localhost:3000/api/v1/meta/object/account?preview=draft');
-  });
-
-  it('combines preview with the package filter on list()', async () => {
-    const { c, urls } = previewClient({ previewDrafts: true });
-    await c.list('object', { packageId: 'app.crm' });
-    expect(urls[0]).toBe('http://localhost:3000/api/v1/meta/object?package=app.crm&preview=draft');
-  });
-
-  it('an explicit state=draft read wins over the overlay flag', async () => {
-    const { c, urls } = previewClient({ previewDrafts: true });
-    await c.get('object', 'account', { state: 'draft' });
-    expect(urls[0]).toBe('http://localhost:3000/api/v1/meta/object/account?state=draft');
-  });
-
-  it('default client never sends the flag', async () => {
-    const { c, urls } = previewClient();
-    await c.list('object');
-    await c.get('object', 'account');
-    expect(urls[0]).not.toContain('preview');
-    expect(urls[1]).not.toContain('preview');
-  });
-
-  it('withPreviewDrafts derives a preview client and PRESERVES the environment scope', async () => {
-    const { c } = previewClient({ environmentId: 'env_1' });
-    const p = c.withPreviewDrafts(true);
-    expect(p.previewDrafts).toBe(true);
-    // Same instance back when the flag already matches.
-    expect(p.withPreviewDrafts(true)).toBe(p);
-    // Environment-scoped path survives the derivation (regression guard:
-    // a naive rebuild dropped /environments/:id from the base).
-    const urls: string[] = [];
-    const scoped = new MetadataClient({
-      baseUrl: 'http://localhost:3000',
-      environmentId: 'env_1',
-      previewDrafts: false,
-      fetch: mockFetch(async (url) => {
-        urls.push(url);
-        return jsonResponse([]);
-      }),
-    }).withPreviewDrafts(true);
-    await scoped.list('object');
-    expect(urls[0]).toBe('http://localhost:3000/api/v1/environments/env_1/meta/object?preview=draft');
-  });
-});