@object-ui/data-objectstack 6.0.4 → 6.2.0

package/dist/index.js

@@ -539,15 +539,21 @@ function createObjectStackUserStateAdapter(options) {
   let cachedRowId = null;
   const findExisting = async () => {
     const params = {
-      filter: {
+      $filter: {
         user_id: userId,
         key
       },
-      limit: 1
+      $top: 1
     };
     const result = await dataSource.find(resource, params);
     const rows = result?.data ?? [];
-    return rows.length > 0 ? rows[0] : null;
+    const match = rows.find((r) => {
+      if (!r) return false;
+      const userMismatch = r.user_id !== void 0 && r.user_id !== userId;
+      const keyMismatch = r.key !== void 0 && r.key !== key;
+      return !userMismatch && !keyMismatch;
+    });
+    return match ?? null;
   };
   const decodeValue = (value) => {
     if (Array.isArray(value)) return value;
@@ -726,6 +732,181 @@ var IntegrationManager = class {
   }
 };
 
+// src/metadata-client.ts
+var META_PREFIX = "/meta";
+var API_PREFIX = "/api/v1";
+function buildBase(config) {
+  const trimmed = config.baseUrl.replace(/\/+$/, "");
+  const scoped = config.environmentId ? `${API_PREFIX}/environments/${encodeURIComponent(config.environmentId)}${META_PREFIX}` : `${API_PREFIX}${META_PREFIX}`;
+  if (/\/api\/v\d+$/i.test(trimmed)) {
+    const stripped = trimmed.replace(/\/api\/v\d+$/i, "");
+    const scopedNoApi = config.environmentId ? `${API_PREFIX}/environments/${encodeURIComponent(config.environmentId)}${META_PREFIX}` : `${API_PREFIX}${META_PREFIX}`;
+    return `${stripped}${scopedNoApi}`;
+  }
+  return `${trimmed}${scoped}`;
+}
+async function parseError(res) {
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    body = await res.text().catch(() => void 0);
+  }
+  const message = (body && typeof body === "object" && "error" in body ? String(body.error) : void 0) ?? `Metadata request failed: ${res.status} ${res.statusText}`;
+  const err = new Error(message);
+  err.status = res.status;
+  err.body = body;
+  if (body && typeof body === "object" && "code" in body) {
+    err.code = String(body.code);
+  }
+  return err;
+}
+var MetadataClient = class _MetadataClient {
+  constructor(config) {
+    __publicField(this, "base");
+    __publicField(this, "fetchImpl");
+    __publicField(this, "headers");
+    this.base = buildBase(config);
+    this.fetchImpl = config.fetch ?? globalThis.fetch.bind(globalThis);
+    this.headers = { Accept: "application/json", ...config.headers ?? {} };
+  }
+  /** Update the client's environment scope at runtime. */
+  withEnvironment(environmentId) {
+    return new _MetadataClient({
+      baseUrl: this.base.replace(/\/api\/v\d+(?:\/environments\/[^/]+)?\/meta$/, "").replace(/\/+$/, ""),
+      environmentId,
+      fetch: this.fetchImpl,
+      headers: this.headers
+    });
+  }
+  /** List all registered metadata types (returns the registry rows). */
+  async listTypes() {
+    const res = await this.fetchImpl(this.base, { method: "GET", headers: this.headers, cache: "no-store" });
+    if (!res.ok) throw await parseError(res);
+    const data = await res.json();
+    if (Array.isArray(data)) return data;
+    if (data && Array.isArray(data.entries)) return data.entries;
+    if (data && Array.isArray(data.items)) return data.items;
+    if (data && Array.isArray(data.types)) {
+      return data.types.map((t) => ({ type: t }));
+    }
+    return [];
+  }
+  /** List items of a metadata type (e.g. `object`, `field`, `view`). */
+  async list(type, options = {}) {
+    const qs = options.packageId ? `?package=${encodeURIComponent(options.packageId)}` : "";
+    const url = `${this.base}/${encodeURIComponent(type)}${qs}`;
+    const res = await this.fetchImpl(url, { method: "GET", headers: this.headers, cache: "no-store" });
+    if (!res.ok) throw await parseError(res);
+    const data = await res.json();
+    if (Array.isArray(data)) return data;
+    if (data && Array.isArray(data.items)) {
+      return data.items;
+    }
+    return [];
+  }
+  /**
+   * Get a single metadata item. Returns the unwrapped item content
+   * (matching the framework REST handler which calls `res.json(item)`).
+   * Returns `null` on 404 to keep the call-site ergonomic.
+   */
+  async get(type, name) {
+    const url = `${this.base}/${encodeURIComponent(type)}/${encodeURIComponent(name)}`;
+    const res = await this.fetchImpl(url, { method: "GET", headers: this.headers, cache: "no-store" });
+    if (res.status === 404) return null;
+    if (!res.ok) throw await parseError(res);
+    return await res.json();
+  }
+  /**
+   * Save (PUT) a metadata item. The framework accepts both the bare
+   * item payload and the `{ item: ... }` / `{ metadata: ... }`
+   * envelopes; we send bare for consistency.
+   */
+  async save(type, name, item, options = {}) {
+    const qs = options.force ? "?force=true" : "";
+    const url = `${this.base}/${encodeURIComponent(type)}/${encodeURIComponent(name)}${qs}`;
+    const headers = {
+      ...this.headers,
+      "Content-Type": "application/json"
+    };
+    if (options.ifMatch) headers["If-Match"] = options.ifMatch;
+    if (options.actor) headers["X-Actor"] = options.actor;
+    const res = await this.fetchImpl(url, {
+      method: "PUT",
+      headers,
+      body: JSON.stringify(item)
+    });
+    if (!res.ok) throw await parseError(res);
+    return await res.json();
+  }
+  /**
+   * Get the 3-state layered view of a metadata item (Phase 3a). Returns
+   * `code` (the artifact / fallback default), `overlay` (the saved
+   * customisation, if any), and `effective` (what the runtime sees).
+   */
+  async layered(type, name) {
+    const url = `${this.base}/${encodeURIComponent(type)}/${encodeURIComponent(name)}?layers=true`;
+    const res = await this.fetchImpl(url, { method: "GET", headers: this.headers, cache: "no-store" });
+    if (res.status === 404) {
+      return { code: null, overlay: null, overlayScope: null, effective: null };
+    }
+    if (!res.ok) throw await parseError(res);
+    const body = await res.json();
+    const hasEnvelope = body && ("code" in body || "overlay" in body || "effective" in body);
+    if (!hasEnvelope) {
+      return {
+        code: null,
+        overlay: null,
+        overlayScope: null,
+        effective: body
+      };
+    }
+    return {
+      code: body.code ?? null,
+      overlay: body.overlay ?? null,
+      overlayScope: body.overlayScope ?? null,
+      effective: body.effective ?? null
+    };
+  }
+  /**
+   * Find every metadata item that references this one (Phase 3a). Useful
+   * for pre-delete impact analysis: "Are any views pointing at this
+   * object before I drop it?".
+   */
+  async references(type, name) {
+    const url = `${this.base}/${encodeURIComponent(type)}/${encodeURIComponent(name)}/references`;
+    const res = await this.fetchImpl(url, { method: "GET", headers: this.headers, cache: "no-store" });
+    if (res.status === 404) return [];
+    if (!res.ok) throw await parseError(res);
+    const data = await res.json();
+    return Array.isArray(data) ? data : data?.items ?? [];
+  }
+  /**
+   * Reset a metadata customization overlay back to the artifact default.
+   * Idempotent: returns the result even when no overlay row existed.
+   */
+  async reset(type, name, options = {}) {
+    const url = `${this.base}/${encodeURIComponent(type)}/${encodeURIComponent(name)}`;
+    const headers = { ...this.headers };
+    if (options.ifMatch) headers["If-Match"] = options.ifMatch;
+    if (options.actor) headers["X-Actor"] = options.actor;
+    const res = await this.fetchImpl(url, { method: "DELETE", headers });
+    if (!res.ok) throw await parseError(res);
+    return await res.json();
+  }
+  /** Fetch the durable history (change log) for one metadata item. */
+  async history(type, name, options = {}) {
+    const params = new URLSearchParams();
+    if (options.sinceSeq !== void 0) params.set("sinceSeq", String(options.sinceSeq));
+    if (options.limit !== void 0) params.set("limit", String(options.limit));
+    const qs = params.toString();
+    const url = `${this.base}/${encodeURIComponent(type)}/${encodeURIComponent(name)}/history${qs ? `?${qs}` : ""}`;
+    const res = await this.fetchImpl(url, { method: "GET", headers: this.headers, cache: "no-store" });
+    if (!res.ok) throw await parseError(res);
+    return await res.json();
+  }
+};
+
 // src/security.ts
 var SecurityManager = class {
   constructor(policy = {}) {
@@ -2294,6 +2475,7 @@ export {
   ConcurrentUpdateError,
   ConnectionError,
   IntegrationManager,
+  MetadataClient,
   MetadataNotFoundError,
   ObjectStackAdapter,
   ObjectStackError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/data-objectstack",
-  "version": "6.0.4",
+  "version": "6.2.0",
   "description": "ObjectStack Data Adapter for Object UI",
   "license": "MIT",
   "type": "module",
@@ -22,14 +22,14 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@objectstack/client": "^5.2.0",
-    "@object-ui/core": "6.0.4",
-    "@object-ui/types": "6.0.4"
+    "@objectstack/client": "^6.7.1",
+    "@object-ui/core": "6.2.0",
+    "@object-ui/types": "6.2.0"
   },
   "devDependencies": {
     "tsup": "^8.5.1",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.6"
+    "vitest": "^4.1.7"
   },
   "publishConfig": {
     "access": "public"

package/src/index.ts

@@ -2068,6 +2068,21 @@ export type { PluginContract, PluginExport, PluginAPIContract, ContractValidatio
 export { IntegrationManager } from './integration';
 export type { IntegrationConfig, IntegrationTrigger, IntegrationProvider, SlackIntegrationConfig, EmailIntegrationConfig, WebhookIntegrationConfig } from './integration';
 
+// Metadata API client — read/write protocol metadata via /api/v1/meta/*.
+// Used by plugin-designer to back the Setup-app Object Manager and Field
+// Designer surfaces; kept separate from ObjectStackAdapter so callers
+// can use it without the full data-source surface.
+export { MetadataClient } from './metadata-client';
+export type {
+  MetadataClientConfig,
+  MetadataListOptions,
+  MetadataSaveOptions,
+  MetadataHistoryOptions,
+  MetadataError,
+  MetadataLayered,
+  MetadataReference,
+} from './metadata-client';
+
 export { SecurityManager } from './security';
 export type { SecurityPolicy, CSPConfig, AuditLogConfig, AuditEventType, DataMaskingConfig, DataMaskingRule, AuditLogEntry } from './security';
 

package/src/metadata-client.test.ts

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