@object-ui/data-objectstack 11.3.0 → 11.5.0

package/dist/index.js

@@ -760,13 +760,17 @@ async function parseError(res) {
   } 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);
+  const bodyObj = body && typeof body === "object" ? body : void 0;
+  const errNode = bodyObj?.error;
+  const message = (errNode && typeof errNode === "object" ? errNode.message : errNode) ?? bodyObj?.message ?? `Metadata request failed: ${res.status} ${res.statusText}`;
+  const err = new Error(String(message));
   err.status = res.status;
   err.body = body;
-  if (body && typeof body === "object" && "code" in body) {
-    err.code = String(body.code);
-  }
+  const details = errNode && typeof errNode === "object" ? errNode.details : void 0;
+  const issues = details?.issues ?? (errNode && typeof errNode === "object" ? errNode.issues : void 0) ?? bodyObj?.issues;
+  if (Array.isArray(issues)) err.issues = issues;
+  const code = details?.code ?? (errNode && typeof errNode === "object" ? errNode.code : void 0) ?? bodyObj?.code;
+  if (code != null) err.code = String(code);
   return err;
 }
 var MetadataClient = class _MetadataClient {
@@ -1476,6 +1480,11 @@ var ObjectStackAdapter = class {
     // so optional collections like sys_presence don't hammer the server with
     // failing requests on every record open / panel render.
     __publicField(this, "missingResources", /* @__PURE__ */ new Set());
+    // Subscribers registered via onMutation(). Emitted after each successful
+    // create/update/delete so data-bound views (ListView, ObjectView, kanban,
+    // calendar) auto-refresh — the interface ListView relies on to reflect
+    // inline-edit "Save All" writes without a manual reload.
+    __publicField(this, "mutationListeners", /* @__PURE__ */ new Set());
     this.client = new ObjectStackClient({ ...config, logger: createQuietHttpLogger() });
     this.metadataCache = new MetadataCache(config.cache);
     this.autoReconnect = config.autoReconnect ?? true;
@@ -1684,9 +1693,35 @@ var ObjectStackAdapter = class {
   /**
    * Create a new record.
    */
+  /**
+   * Notify all mutation subscribers. A throwing listener must not break the
+   * mutation or starve the other subscribers, so each is isolated.
+   */
+  emitMutation(event) {
+    for (const listener of this.mutationListeners) {
+      try {
+        listener(event);
+      } catch (err) {
+        console.warn("ObjectStackAdapter: mutation listener error", err);
+      }
+    }
+  }
+  /**
+   * Subscribe to create/update/delete events on any resource. Returns an
+   * unsubscribe function. Data-bound views use this to auto-refresh after a
+   * mutation (e.g. inline-edit "Save All", which writes through `update` and
+   * must repaint the list without a manual reload).
+   */
+  onMutation(callback) {
+    this.mutationListeners.add(callback);
+    return () => {
+      this.mutationListeners.delete(callback);
+    };
+  }
   async create(resource, data) {
     await this.connect();
     const result = await this.client.data.create(resource, data);
+    this.emitMutation({ type: "create", resource, record: { ...result.record } });
     return result.record;
   }
   /**
@@ -1709,6 +1744,7 @@ var ObjectStackAdapter = class {
         data,
         opts?.ifMatch ? { ifMatch: opts.ifMatch } : void 0
       );
+      this.emitMutation({ type: "update", resource, id, record: { ...result.record } });
       return result.record;
     } catch (err) {
       throw normaliseClientError(err);
@@ -1729,6 +1765,9 @@ var ObjectStackAdapter = class {
         String(id),
         opts?.ifMatch ? { ifMatch: opts.ifMatch } : void 0
       );
+      if (result.deleted) {
+        this.emitMutation({ type: "delete", resource, id });
+      }
       return result.deleted;
     } catch (err) {
       throw normaliseClientError(err);
@@ -1753,15 +1792,19 @@ var ObjectStackAdapter = class {
     await this.connect();
     if (!ids || ids.length === 0) return 0;
     const records = ids.map((id) => ({ id: String(id), data: patch }));
+    const emitBulk = (count) => {
+      if (count > 0) this.emitMutation({ type: "update", resource });
+      return count;
+    };
     const updateMany = this.client.data.updateMany;
     if (typeof updateMany === "function") {
       try {
         const res = await updateMany(resource, records, { continueOnError: true });
         if (res && typeof res === "object" && typeof res.succeeded === "number") {
-          return res.succeeded;
+          return emitBulk(res.succeeded);
         }
-        if (Array.isArray(res)) return res.length;
-        return ids.length;
+        if (Array.isArray(res)) return emitBulk(res.length);
+        return emitBulk(ids.length);
       } catch (err) {
         throw normaliseClientError(err);
       }
@@ -1774,7 +1817,7 @@ var ObjectStackAdapter = class {
       } catch {
       }
     }
-    return succeeded;
+    return emitBulk(succeeded);
   }
   /**
    * Single-call bulk delete. Mirrors the bulkUpdate contract: prefers
@@ -1787,15 +1830,19 @@ var ObjectStackAdapter = class {
     await this.connect();
     if (!ids || ids.length === 0) return 0;
     const strIds = ids.map((id) => String(id));
+    const emitBulk = (count) => {
+      if (count > 0) this.emitMutation({ type: "delete", resource });
+      return count;
+    };
     const deleteMany = this.client.data.deleteMany;
     if (typeof deleteMany === "function") {
       try {
         const res = await deleteMany(resource, strIds, { continueOnError: true });
         if (res && typeof res === "object" && typeof res.succeeded === "number") {
-          return res.succeeded;
+          return emitBulk(res.succeeded);
         }
-        if (Array.isArray(res)) return res.length;
-        return strIds.length;
+        if (Array.isArray(res)) return emitBulk(res.length);
+        return emitBulk(strIds.length);
       } catch (err) {
         throw normaliseClientError(err);
       }
@@ -1808,7 +1855,7 @@ var ObjectStackAdapter = class {
       } catch {
       }
     }
-    return succeeded;
+    return emitBulk(succeeded);
   }
   /**
    * Bulk operations with optimized batch processing and error handling.
@@ -1968,6 +2015,157 @@ var ObjectStackAdapter = class {
       );
     }
   }
+  /**
+   * Bulk-import raw spreadsheet rows in a single server round-trip via
+   * `POST /api/v1/data/:object/import`. The server performs all value coercion
+   * (booleans, numbers, dates→ISO, select label→code, lookup name→id) from the
+   * object's field metadata, so this method forwards the request verbatim and
+   * returns the aggregate + per-row result untouched.
+   *
+   * Requires `@objectstack/client` with `data.import` (server `/import` route).
+   * Callers should feature-detect (`typeof dataSource.importRecords`) and fall
+   * back to a per-row `create` loop when unavailable.
+   */
+  async importRecords(resource, request) {
+    await this.connect();
+    const importFn = this.client.data.import;
+    if (typeof importFn !== "function") {
+      throw new ObjectStackError(
+        "The connected @objectstack/client does not support data.import(). Upgrade the client, or import via a per-row create fallback.",
+        "UNSUPPORTED_OPERATION",
+        400
+      );
+    }
+    try {
+      const result = await importFn.call(this.client.data, resource, request);
+      return result;
+    } catch (err) {
+      throw normaliseClientError(err);
+    }
+  }
+  /**
+   * Feature-detect the async import-job API on the connected client. Older
+   * clients/servers lack these routes; callers fall back to {@link importRecords}.
+   */
+  importJobApi() {
+    const d = this.client.data;
+    if (typeof d.createImportJob !== "function") return void 0;
+    return d;
+  }
+  /**
+   * Start an asynchronous import job — the large-file counterpart to
+   * {@link importRecords}. Posts the whole payload once; the server processes
+   * rows in the background. Requires an `@objectstack/client` new enough to
+   * expose `data.createImportJob` (server `/import/jobs` route). Callers should
+   * feature-detect (`typeof dataSource.createImportJob`) and fall back to the
+   * synchronous path when unavailable.
+   */
+  async createImportJob(resource, request) {
+    await this.connect();
+    const api = this.importJobApi();
+    if (!api) {
+      throw new ObjectStackError(
+        "The connected @objectstack/client does not support async import jobs (data.createImportJob). Upgrade the client, or use the synchronous importRecords() path.",
+        "UNSUPPORTED_OPERATION",
+        400
+      );
+    }
+    try {
+      return await api.createImportJob.call(this.client.data, resource, request);
+    } catch (err) {
+      throw normaliseClientError(err);
+    }
+  }
+  /** Poll an import job's progress. Requires {@link createImportJob} support. */
+  async getImportJobProgress(jobId) {
+    await this.connect();
+    const api = this.importJobApi();
+    if (!api) {
+      throw new ObjectStackError(
+        "The connected @objectstack/client does not support async import jobs.",
+        "UNSUPPORTED_OPERATION",
+        400
+      );
+    }
+    try {
+      return await api.getImportJobProgress.call(this.client.data, jobId);
+    } catch (err) {
+      throw normaliseClientError(err);
+    }
+  }
+  /** Fetch an import job's capped per-row results. */
+  async getImportJobResults(jobId) {
+    await this.connect();
+    const api = this.importJobApi();
+    if (!api) {
+      throw new ObjectStackError(
+        "The connected @objectstack/client does not support async import jobs.",
+        "UNSUPPORTED_OPERATION",
+        400
+      );
+    }
+    try {
+      return await api.getImportJobResults.call(this.client.data, jobId);
+    } catch (err) {
+      throw normaliseClientError(err);
+    }
+  }
+  /** List recent import jobs (history), newest first. */
+  async listImportJobs(options = {}) {
+    await this.connect();
+    const api = this.importJobApi();
+    if (!api) {
+      throw new ObjectStackError(
+        "The connected @objectstack/client does not support async import jobs.",
+        "UNSUPPORTED_OPERATION",
+        400
+      );
+    }
+    try {
+      return await api.listImportJobs.call(this.client.data, options);
+    } catch (err) {
+      throw normaliseClientError(err);
+    }
+  }
+  /** Cancel a pending/running import job (cooperative). */
+  async cancelImportJob(jobId) {
+    await this.connect();
+    const api = this.importJobApi();
+    if (!api) {
+      throw new ObjectStackError(
+        "The connected @objectstack/client does not support async import jobs.",
+        "UNSUPPORTED_OPERATION",
+        400
+      );
+    }
+    try {
+      await api.cancelImportJob.call(this.client.data, jobId);
+    } catch (err) {
+      throw normaliseClientError(err);
+    }
+  }
+  /**
+   * Logically roll back a finished import job — delete the records it created
+   * and restore the records it updated to their pre-import values. Requires an
+   * `@objectstack/client` new enough to expose `data.undoImportJob`, and a job
+   * the server captured an undo log for (see {@link ImportJobProgressInfo.undoable}).
+   */
+  async undoImportJob(jobId) {
+    await this.connect();
+    const api = this.importJobApi();
+    if (!api || typeof api.undoImportJob !== "function") {
+      throw new ObjectStackError(
+        "The connected @objectstack/client does not support undoing import jobs (data.undoImportJob).",
+        "UNSUPPORTED_OPERATION",
+        400
+      );
+    }
+    try {
+      return await api.undoImportJob.call(this.client.data, jobId);
+    } catch (err) {
+      throw normaliseClientError(err);
+    }
+  }
   /**
    * Normalize the result from data.find() or data.query() into a consistent QueryResult.
    */
@@ -2399,6 +2597,25 @@ var ObjectStackAdapter = class {
       return [];
     }
   }
+  /**
+   * List registered import `mapping` artifacts targeting a given object
+   * (framework #2611). Reads the `mapping` metadata kind via the overlay API
+   * and filters by `targetObject` client-side (the metadata index is
+   * name-only). Feeds the import wizard's "saved mapping" selector; a failure
+   * (older server without the `mapping` kind) degrades to an empty list, so
+   * the selector simply doesn't appear.
+   */
+  async listImportMappings(objectName) {
+    await this.connect();
+    try {
+      const result = await this.client.meta.getItems("mapping");
+      const items = Array.isArray(result?.items) ? result.items : Array.isArray(result) ? result : [];
+      return items.filter((m) => m && m.targetObject === objectName);
+    } catch (err) {
+      console.warn("[OBJECTSTACKDataSource] listImportMappings failed:", err);
+      return [];
+    }
+  }
   /**
    * Create a new overlay view for an object. The view's `name` is the
    * stable identifier — must be unique within the project scope. Returns

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/data-objectstack",
-  "version": "11.3.0",
+  "version": "11.5.0",
   "description": "ObjectStack Data Adapter for Object UI",
   "license": "MIT",
   "type": "module",
@@ -22,9 +22,9 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@objectstack/client": "^11.2.0",
-    "@object-ui/core": "11.3.0",
-    "@object-ui/types": "11.3.0"
+    "@objectstack/client": "^11.5.0",
+    "@object-ui/core": "11.5.0",
+    "@object-ui/types": "11.5.0"
   },
   "devDependencies": {
     "tsup": "^8.5.1",

package/src/importJob.test.ts

@@ -0,0 +1,71 @@
+/**
+ * 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';
+
+/**
+ * Adapter over a mock client `data` namespace. The async import-job methods are
+ * thin pass-throughs to the client SDK, so we assert delegation + argument
+ * shaping, plus graceful degradation when the client lacks the job API.
+ */
+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;
+}
+
+describe('ObjectStackAdapter async import jobs', () => {
+  it('createImportJob delegates to client.data.createImportJob', async () => {
+    const createImportJob = vi.fn().mockResolvedValue({ jobId: 'imp_1', object: 'task', status: 'pending', total: 2 });
+    const ds = makeDS({ createImportJob });
+    const req = { format: 'json' as const, rows: [{ a: 1 }, { a: 2 }], writeMode: 'upsert' as const, matchFields: ['a'] };
+    const res = await ds.createImportJob('task', req);
+    expect(createImportJob).toHaveBeenCalledTimes(1);
+    expect(createImportJob.mock.calls[0]).toEqual(['task', req]);
+    expect(res).toMatchObject({ jobId: 'imp_1', status: 'pending', total: 2 });
+  });
+
+  it('getImportJobProgress / getImportJobResults / cancelImportJob delegate by jobId', async () => {
+    const getImportJobProgress = vi.fn().mockResolvedValue({ jobId: 'imp_1', status: 'running', percentComplete: 50 });
+    const getImportJobResults = vi.fn().mockResolvedValue({ jobId: 'imp_1', status: 'succeeded', results: [], resultsTruncated: false });
+    const cancelImportJob = vi.fn().mockResolvedValue({ success: true });
+    const ds = makeDS({ createImportJob: vi.fn(), getImportJobProgress, getImportJobResults, cancelImportJob });
+
+    expect((await ds.getImportJobProgress('imp_1')).percentComplete).toBe(50);
+    expect(getImportJobProgress).toHaveBeenCalledWith('imp_1');
+
+    expect((await ds.getImportJobResults('imp_1')).resultsTruncated).toBe(false);
+    expect(getImportJobResults).toHaveBeenCalledWith('imp_1');
+
+    await ds.cancelImportJob('imp_1');
+    expect(cancelImportJob).toHaveBeenCalledWith('imp_1');
+  });
+
+  it('listImportJobs forwards filters and returns the jobs array', async () => {
+    const listImportJobs = vi.fn().mockResolvedValue([{ jobId: 'imp_1', object: 'task', status: 'succeeded' }]);
+    const ds = makeDS({ createImportJob: vi.fn(), listImportJobs });
+    const jobs = await ds.listImportJobs({ object: 'task', status: 'succeeded', limit: 10 });
+    expect(listImportJobs).toHaveBeenCalledWith({ object: 'task', status: 'succeeded', limit: 10 });
+    expect(jobs).toHaveLength(1);
+  });
+
+  it('throws UNSUPPORTED_OPERATION when the client lacks the job API', async () => {
+    const ds = makeDS({ import: vi.fn() }); // sync import only, no createImportJob
+    await expect(ds.createImportJob('task', { format: 'json', rows: [] })).rejects.toMatchObject({ code: 'UNSUPPORTED_OPERATION' });
+    await expect(ds.getImportJobProgress('imp_1')).rejects.toMatchObject({ code: 'UNSUPPORTED_OPERATION' });
+  });
+});