@object-ui/data-objectstack 3.1.5 → 3.3.1

package/dist/index.js

@@ -4,7 +4,72 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 
 // src/index.ts
 import { ObjectStackClient } from "@objectstack/client";
-import { convertFiltersToAST } from "@object-ui/core";
+
+// ../core/src/utils/filter-converter.ts
+function convertOperatorToAST(operator) {
+  const operatorMap = {
+    "$eq": "=",
+    "$ne": "!=",
+    "$gt": ">",
+    "$gte": ">=",
+    "$lt": "<",
+    "$lte": "<=",
+    "$in": "in",
+    "$nin": "nin",
+    "$notin": "nin",
+    "$between": "between",
+    "$contains": "contains",
+    "$notContains": "notcontains",
+    "$notcontains": "notcontains",
+    "$startsWith": "startswith",
+    "$startswith": "startswith",
+    "$endsWith": "endswith",
+    "$endswith": "endswith"
+  };
+  return operatorMap[operator] || null;
+}
+function convertFiltersToAST(filter) {
+  const conditions = [];
+  for (const [field, value] of Object.entries(filter)) {
+    if (value === null || value === void 0) continue;
+    if (typeof value === "object" && !Array.isArray(value)) {
+      for (const [operator, operatorValue] of Object.entries(value)) {
+        if (operator === "$regex") {
+          console.warn(
+            `[ObjectUI] Warning: $regex operator is not fully supported. Converting to 'contains' which only supports substring matching, not regex patterns. Field: '${field}', Value: ${JSON.stringify(operatorValue)}. Consider using $contains or $startsWith instead.`
+          );
+          conditions.push([field, "contains", operatorValue]);
+          continue;
+        }
+        if (operator === "$null") {
+          conditions.push([field, operatorValue ? "is_null" : "is_not_null", true]);
+          continue;
+        }
+        if (operator === "$exists") {
+          conditions.push([field, operatorValue ? "is_not_null" : "is_null", true]);
+          continue;
+        }
+        const astOperator = convertOperatorToAST(operator);
+        if (astOperator) {
+          conditions.push([field, astOperator, operatorValue]);
+        } else {
+          throw new Error(
+            `[ObjectUI] Unknown filter operator '${operator}' for field '${field}'. Supported operators: $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin, $between, $contains, $notContains, $startsWith, $endsWith, $null, $exists. If you need exact object matching, use the value directly without an operator.`
+          );
+        }
+      }
+    } else {
+      conditions.push([field, "=", value]);
+    }
+  }
+  if (conditions.length === 0) {
+    return filter;
+  }
+  if (conditions.length === 1) {
+    return conditions[0];
+  }
+  return ["and", ...conditions];
+}
 
 // src/cache/MetadataCache.ts
 var MetadataCache = class {
@@ -17,16 +82,19 @@ var MetadataCache = class {
    */
   constructor(options = {}) {
     __publicField(this, "cache");
+    __publicField(this, "inflight");
     __publicField(this, "maxSize");
     __publicField(this, "ttl");
     __publicField(this, "stats");
     this.cache = /* @__PURE__ */ new Map();
+    this.inflight = /* @__PURE__ */ new Map();
     this.maxSize = options.maxSize || 100;
     this.ttl = options.ttl || 5 * 60 * 1e3;
     this.stats = {
       hits: 0,
       misses: 0,
-      evictions: 0
+      evictions: 0,
+      coalesced: 0
     };
   }
   /**
@@ -52,10 +120,31 @@ var MetadataCache = class {
         this.cache.delete(key);
       }
     }
+    const existing = this.inflight.get(key);
+    if (existing) {
+      this.stats.coalesced++;
+      return existing;
+    }
     this.stats.misses++;
-    const data = await fetcher();
+    const promise = (async () => {
+      try {
+        const data = await fetcher();
+        this.set(key, data);
+        return data;
+      } finally {
+        this.inflight.delete(key);
+      }
+    })();
+    this.inflight.set(key, promise);
+    return promise;
+  }
+  /**
+   * Prime the cache with a pre-fetched value. Useful when a bulk endpoint
+   * (e.g. list of all object schemas) returns data that would otherwise
+   * be fetched again per item.
+   */
+  prime(key, data) {
     this.set(key, data);
-    return data;
   }
   /**
    * Set a value in the cache
@@ -102,10 +191,12 @@ var MetadataCache = class {
    */
   clear() {
     this.cache.clear();
+    this.inflight.clear();
     this.stats = {
       hits: 0,
       misses: 0,
-      evictions: 0
+      evictions: 0,
+      coalesced: 0
     };
   }
   /**
@@ -122,6 +213,7 @@ var MetadataCache = class {
       hits: this.stats.hits,
       misses: this.stats.misses,
       evictions: this.stats.evictions,
+      coalesced: this.stats.coalesced,
       hitRate
     };
   }
@@ -173,9 +265,9 @@ var ObjectStackError = class extends Error {
    */
   constructor(message, code, statusCode, details) {
     super(message);
-    this.code = code;
-    this.statusCode = statusCode;
-    this.details = details;
+    __publicField(this, "code", code);
+    __publicField(this, "statusCode", statusCode);
+    __publicField(this, "details", details);
     this.name = "ObjectStackError";
     if (Error.captureStackTrace) {
       Error.captureStackTrace(this, this.constructor);
@@ -229,9 +321,9 @@ var BulkOperationError = class extends ObjectStackError {
         ...details
       }
     );
-    this.successCount = successCount;
-    this.failureCount = failureCount;
-    this.errors = errors;
+    __publicField(this, "successCount", successCount);
+    __publicField(this, "failureCount", failureCount);
+    __publicField(this, "errors", errors);
     this.name = "BulkOperationError";
   }
   /**
@@ -258,7 +350,7 @@ var ConnectionError = class extends ObjectStackError {
       statusCode || 503,
       { url, ...details }
     );
-    this.url = url;
+    __publicField(this, "url", url);
     this.name = "ConnectionError";
   }
 };
@@ -293,8 +385,8 @@ var ValidationError = class extends ObjectStackError {
         ...details
       }
     );
-    this.field = field;
-    this.validationErrors = validationErrors;
+    __publicField(this, "field", field);
+    __publicField(this, "validationErrors", validationErrors);
     this.name = "ValidationError";
   }
   /**
@@ -351,7 +443,7 @@ function isErrorType(error, errorClass) {
 // src/cloud.ts
 var CloudOperations = class {
   constructor(getClient) {
-    this.getClient = getClient;
+    __publicField(this, "getClient", getClient);
   }
   /**
    * Deploy an application to the cloud.
@@ -695,10 +787,26 @@ function calculateAutoLayout(items, canvasWidth, padding = 40, gap = 40) {
 }
 
 // src/index.ts
+var discoveryCache = /* @__PURE__ */ new Map();
+async function getSharedDiscovery(baseUrl, fetcher) {
+  const key = baseUrl || "<default>";
+  const cached = discoveryCache.get(key);
+  if (cached) return cached;
+  const p = fetcher().catch((err) => {
+    discoveryCache.delete(key);
+    throw err;
+  });
+  discoveryCache.set(key, p);
+  return p;
+}
+function clearSharedDiscoveryCache() {
+  discoveryCache.clear();
+}
 var ObjectStackAdapter = class {
   constructor(config) {
     __publicField(this, "client");
     __publicField(this, "connected", false);
+    __publicField(this, "connectPromise", null);
     __publicField(this, "metadataCache");
     __publicField(this, "connectionState", "disconnected");
     __publicField(this, "connectionStateListeners", []);
@@ -724,10 +832,25 @@ var ObjectStackAdapter = class {
    * Call this before making requests or it will auto-connect on first request.
    */
   async connect() {
-    if (!this.connected) {
-      this.setConnectionState("connecting");
+    if (this.connected) return;
+    if (this.connectPromise) return this.connectPromise;
+    this.setConnectionState("connecting");
+    this.connectPromise = (async () => {
       try {
-        await this.client.connect();
+        const baseUrl = this.baseUrl || "";
+        const discoveryUrl = baseUrl ? `${baseUrl.replace(/\/$/, "")}/api/v1/discovery` : "/api/v1/discovery";
+        const data = await getSharedDiscovery(baseUrl, async () => {
+          const res = await this.fetchImpl(discoveryUrl, {
+            method: "GET",
+            headers: this.token ? { Authorization: `Bearer ${this.token}` } : void 0
+          });
+          if (!res.ok) {
+            throw new Error(`discovery ${res.status} ${res.statusText}`);
+          }
+          const body = await res.json();
+          return body && typeof body.success === "boolean" && "data" in body ? body.data : body;
+        });
+        this.client.discoveryInfo = data;
         this.connected = true;
         this.reconnectAttempts = 0;
         this.setConnectionState("connected");
@@ -744,8 +867,11 @@ var ObjectStackAdapter = class {
         } else {
           throw connectionError;
         }
+      } finally {
+        this.connectPromise = null;
       }
-    }
+    })();
+    return this.connectPromise;
   }
   /**
    * Attempt to reconnect to the server with exponential backoff
@@ -1086,8 +1212,11 @@ var ObjectStackAdapter = class {
         queryParams.set("sort", sortStr);
       }
     }
-    if (params.$filter) {
-      queryParams.set("filter", JSON.stringify(params.$filter));
+    if (params.$filter !== void 0 && params.$filter !== null) {
+      const isEmpty = Array.isArray(params.$filter) ? params.$filter.length === 0 : typeof params.$filter === "object" && Object.keys(params.$filter).length === 0;
+      if (!isEmpty) {
+        queryParams.set("filter", JSON.stringify(params.$filter));
+      }
     }
     const baseUrl = this.baseUrl.replace(/\/$/, "");
     const qs = queryParams.toString();
@@ -1123,11 +1252,14 @@ var ObjectStackAdapter = class {
     if (params.$select) {
       options.select = params.$select;
     }
-    if (params.$filter) {
-      if (Array.isArray(params.$filter)) {
-        options.filters = params.$filter;
-      } else {
-        options.filters = convertFiltersToAST(params.$filter);
+    if (params.$filter !== void 0 && params.$filter !== null) {
+      const isEmpty = Array.isArray(params.$filter) ? params.$filter.length === 0 : typeof params.$filter === "object" && Object.keys(params.$filter).length === 0;
+      if (!isEmpty) {
+        if (Array.isArray(params.$filter)) {
+          options.filters = params.$filter;
+        } else {
+          options.filters = convertFiltersToAST(params.$filter);
+        }
       }
     }
     if (params.$orderby) {
@@ -1278,19 +1410,26 @@ var ObjectStackAdapter = class {
   async aggregate(resource, params) {
     await this.connect();
     try {
+      const measureName = params.function === "count" ? "count" : `${params.field}_${params.function}`;
       const payload = {
-        object: resource,
-        measures: [{ field: params.field, function: params.function }],
-        dimensions: [params.groupBy]
+        cube: resource,
+        measures: [measureName],
+        // When groupBy is '_all' no dimensions are needed (single-bucket).
+        dimensions: params.groupBy && params.groupBy !== "_all" ? [params.groupBy] : []
       };
       if (params.filter) {
         payload.filters = params.filter;
       }
       const data = await this.client.analytics.query(payload);
-      if (Array.isArray(data)) return data;
-      if (data?.data && Array.isArray(data.data)) return data.data;
-      if (data?.results && Array.isArray(data.results)) return data.results;
-      return [];
+      const rawRows = Array.isArray(data) ? data : data?.rows && Array.isArray(data.rows) ? data.rows : data?.data && Array.isArray(data.data) ? data.data : data?.data?.rows && Array.isArray(data.data.rows) ? data.data.rows : data?.results && Array.isArray(data.results) ? data.results : [];
+      return rawRows.map((row) => {
+        const mapped = { ...row };
+        if (measureName !== params.field && measureName in mapped) {
+          mapped[params.field] = mapped[measureName];
+          delete mapped[measureName];
+        }
+        return mapped;
+      });
     } catch {
       const result = await this.find(resource);
       const records = result.data || [];
@@ -1484,10 +1623,12 @@ export {
   SecurityManager,
   ValidationError,
   calculateAutoLayout,
+  clearSharedDiscoveryCache,
   createDefaultCanvasConfig,
   createErrorFromResponse,
   createObjectStackAdapter,
   generateContractManifest,
+  getSharedDiscovery,
   isErrorType,
   isObjectStackError,
   snapToGrid,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/data-objectstack",
-  "version": "3.1.5",
+  "version": "3.3.1",
   "description": "ObjectStack Data Adapter for Object UI",
   "license": "MIT",
   "type": "module",
@@ -17,24 +17,49 @@
   "files": [
     "dist",
     "src",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
   ],
   "dependencies": {
-    "@objectstack/client": "^3.3.0",
-    "@object-ui/core": "3.1.5",
-    "@object-ui/types": "3.1.5"
+    "@objectstack/client": "^4.0.4",
+    "@object-ui/core": "3.3.1",
+    "@object-ui/types": "3.3.1"
   },
   "devDependencies": {
     "tsup": "^8.5.1",
-    "typescript": "^5.9.3",
-    "vitest": "^4.1.0"
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
   },
   "publishConfig": {
     "access": "public"
   },
+  "keywords": [
+    "objectui",
+    "sdui",
+    "schema-driven-ui",
+    "react",
+    "tailwind",
+    "shadcn",
+    "objectstack",
+    "data-source",
+    "adapter",
+    "objectql",
+    "objectstack-client"
+  ],
+  "author": "ObjectStack Team <team@objectstack.ai>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/objectstack-ai/objectui.git",
+    "directory": "packages/data-objectstack"
+  },
+  "bugs": {
+    "url": "https://github.com/objectstack-ai/objectui/issues"
+  },
+  "homepage": "https://www.objectui.org/docs/guide/data-source",
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
-    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "build": "tsup",
+    "dev": "tsup --watch",
     "clean": "rm -rf dist",
     "type-check": "tsc --noEmit",
     "test": "vitest run",

package/src/aggregate.test.ts

@@ -0,0 +1,277 @@
+/**
+ * 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, beforeEach, vi } from 'vitest';
+import { ObjectStackAdapter } from './index';
+
+/**
+ * Tests for ObjectStackAdapter.aggregate() — verifies that the analytics
+ * query payload uses the correct string-based measure/dimension format
+ * expected by the backend analytics service (MemoryAnalyticsService).
+ *
+ * See: https://github.com/objectstack-ai/objectui/issues (measures format bug)
+ */
+describe('ObjectStackAdapter aggregate()', () => {
+  let adapter: ObjectStackAdapter;
+  let mockAnalyticsQuery: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    mockAnalyticsQuery = vi.fn().mockResolvedValue({ data: [] });
+
+    adapter = new ObjectStackAdapter({
+      baseUrl: 'http://localhost:3000',
+      autoReconnect: false,
+    });
+
+    // Inject mock client and mark as connected to bypass connect()
+    (adapter as any).client = {
+      data: {
+        find: vi.fn().mockResolvedValue({ records: [], total: 0 }),
+      },
+      analytics: {
+        query: mockAnalyticsQuery,
+      },
+      connect: vi.fn().mockResolvedValue(undefined),
+      discover: vi.fn().mockResolvedValue({ status: 'ok' }),
+    };
+    (adapter as any).connected = true;
+  });
+
+  it('should send measures as string array with field_function format for sum', async () => {
+    mockAnalyticsQuery.mockResolvedValue({ data: [] });
+
+    await adapter.aggregate('opportunity', {
+      field: 'amount',
+      function: 'sum',
+      groupBy: 'stage',
+    });
+
+    expect(mockAnalyticsQuery).toHaveBeenCalledWith({
+      cube: 'opportunity',
+      measures: ['amount_sum'],
+      dimensions: ['stage'],
+    });
+  });
+
+  it('should send measures as ["count"] for count aggregation', async () => {
+    mockAnalyticsQuery.mockResolvedValue({ data: [] });
+
+    await adapter.aggregate('opportunity', {
+      field: 'amount',
+      function: 'count',
+      groupBy: 'stage',
+    });
+
+    expect(mockAnalyticsQuery).toHaveBeenCalledWith({
+      cube: 'opportunity',
+      measures: ['count'],
+      dimensions: ['stage'],
+    });
+  });
+
+  it('should send measures as string for avg aggregation', async () => {
+    mockAnalyticsQuery.mockResolvedValue({ data: [] });
+
+    await adapter.aggregate('opportunity', {
+      field: 'amount',
+      function: 'avg',
+      groupBy: 'stage',
+    });
+
+    expect(mockAnalyticsQuery).toHaveBeenCalledWith({
+      cube: 'opportunity',
+      measures: ['amount_avg'],
+      dimensions: ['stage'],
+    });
+  });
+
+  it('should send empty dimensions when groupBy is _all', async () => {
+    mockAnalyticsQuery.mockResolvedValue({ data: [] });
+
+    await adapter.aggregate('opportunity', {
+      field: 'amount',
+      function: 'sum',
+      groupBy: '_all',
+    });
+
+    expect(mockAnalyticsQuery).toHaveBeenCalledWith({
+      cube: 'opportunity',
+      measures: ['amount_sum'],
+      dimensions: [],
+    });
+  });
+
+  it('should include filters in payload when provided', async () => {
+    const filter = [{ member: 'stage', operator: 'equals', values: ['Closed Won'] }];
+    mockAnalyticsQuery.mockResolvedValue({ data: [] });
+
+    await adapter.aggregate('opportunity', {
+      field: 'amount',
+      function: 'sum',
+      groupBy: 'stage',
+      filter,
+    });
+
+    expect(mockAnalyticsQuery).toHaveBeenCalledWith({
+      cube: 'opportunity',
+      measures: ['amount_sum'],
+      dimensions: ['stage'],
+      filters: filter,
+    });
+  });
+
+  it('should map measure key back to field name in response', async () => {
+    mockAnalyticsQuery.mockResolvedValue({
+      data: [
+        { stage: 'Prospect', amount_sum: 300 },
+        { stage: 'Closed Won', amount_sum: 500 },
+      ],
+    });
+
+    const result = await adapter.aggregate('opportunity', {
+      field: 'amount',
+      function: 'sum',
+      groupBy: 'stage',
+    });
+
+    expect(result).toEqual([
+      { stage: 'Prospect', amount: 300 },
+      { stage: 'Closed Won', amount: 500 },
+    ]);
+  });
+
+  it('should map count measure back to field name in response', async () => {
+    mockAnalyticsQuery.mockResolvedValue({
+      data: [
+        { stage: 'Prospect', count: 5 },
+        { stage: 'Closed Won', count: 3 },
+      ],
+    });
+
+    const result = await adapter.aggregate('opportunity', {
+      field: 'amount',
+      function: 'count',
+      groupBy: 'stage',
+    });
+
+    expect(result).toEqual([
+      { stage: 'Prospect', amount: 5 },
+      { stage: 'Closed Won', amount: 3 },
+    ]);
+  });
+
+  it('should handle direct array response from analytics', async () => {
+    mockAnalyticsQuery.mockResolvedValue([
+      { stage: 'Prospect', amount_sum: 300 },
+    ]);
+
+    const result = await adapter.aggregate('opportunity', {
+      field: 'amount',
+      function: 'sum',
+      groupBy: 'stage',
+    });
+
+    expect(result).toEqual([
+      { stage: 'Prospect', amount: 300 },
+    ]);
+  });
+
+  it('should handle results wrapper in response', async () => {
+    mockAnalyticsQuery.mockResolvedValue({
+      results: [
+        { stage: 'Prospect', amount_avg: 150 },
+      ],
+    });
+
+    const result = await adapter.aggregate('opportunity', {
+      field: 'amount',
+      function: 'avg',
+      groupBy: 'stage',
+    });
+
+    expect(result).toEqual([
+      { stage: 'Prospect', amount: 150 },
+    ]);
+  });
+
+  it('should extract rows from { rows: [...] } envelope (SDK unwraps outer success/data)', async () => {
+    mockAnalyticsQuery.mockResolvedValue({
+      rows: [
+        { stage: 'closed_won', expected_revenue_sum: 225000 },
+        { stage: 'negotiation', expected_revenue_sum: 36000 },
+      ],
+      fields: [
+        { name: 'stage', type: 'string' },
+        { name: 'expected_revenue_sum', type: 'number' },
+      ],
+    });
+
+    const result = await adapter.aggregate('opportunity', {
+      field: 'expected_revenue',
+      function: 'sum',
+      groupBy: 'stage',
+    });
+
+    expect(result).toEqual([
+      { stage: 'closed_won', expected_revenue: 225000 },
+      { stage: 'negotiation', expected_revenue: 36000 },
+    ]);
+  });
+
+  it('should extract rows from { data: { rows: [...] } } envelope (SDK does not unwrap)', async () => {
+    mockAnalyticsQuery.mockResolvedValue({
+      success: true,
+      data: {
+        rows: [
+          { stage: 'closed_won', expected_revenue_sum: 225000 },
+          { stage: 'negotiation', expected_revenue_sum: 36000 },
+        ],
+        fields: [
+          { name: 'stage', type: 'string' },
+          { name: 'expected_revenue_sum', type: 'number' },
+        ],
+        sql: '-- MongoDB Aggregation Pipeline',
+      },
+    });
+
+    const result = await adapter.aggregate('opportunity', {
+      field: 'expected_revenue',
+      function: 'sum',
+      groupBy: 'stage',
+    });
+
+    expect(result).toEqual([
+      { stage: 'closed_won', expected_revenue: 225000 },
+      { stage: 'negotiation', expected_revenue: 36000 },
+    ]);
+  });
+
+  it('should fall back to client-side aggregation when analytics endpoint fails', async () => {
+    mockAnalyticsQuery.mockRejectedValue(new Error('Analytics not available'));
+
+    // Mock find() to return records for client-side aggregation
+    (adapter as any).client.data.find = vi.fn().mockResolvedValue({
+      records: [
+        { stage: 'Prospect', amount: 100 },
+        { stage: 'Prospect', amount: 200 },
+        { stage: 'Closed Won', amount: 500 },
+      ],
+      total: 3,
+    });
+
+    const result = await adapter.aggregate('opportunity', {
+      field: 'amount',
+      function: 'sum',
+      groupBy: 'stage',
+    });
+
+    expect(result).toHaveLength(2);
+    expect(result.find((r: any) => r.stage === 'Prospect')?.amount).toBe(300);
+    expect(result.find((r: any) => r.stage === 'Closed Won')?.amount).toBe(500);
+  });
+});