@object-ui/data-objectstack 3.4.0 → 4.0.3

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @object-ui/data-objectstack
 
+## 4.0.3
+
+### Patch Changes
+
+- 4be43e2: **Page-mode record forms (`editMode: 'page'`).** New per-object metadata flag that opts a record's create/edit form into a dedicated full-screen route (`/apps/:appName/:objectName/new`, `/apps/:appName/:objectName/record/:recordId/edit`). Two new declarative actions `navigate_create` and `navigate_edit` open these routes from JSON action buttons. Default modal behavior is preserved for objects that do not set `editMode`.
+
+  **`@object-ui/plugin-list` & `@object-ui/plugin-detail`: `ComponentRegistry` singleton fix.** Both plugins' Vite configs now mark all `@object-ui/*` packages as external so each plugin no longer bundles its own private copy of `@object-ui/core`. Cross-plugin component lookups now resolve correctly from the same singleton registry. `plugin-list` dist shrank from multi-MB to 67 kB (gzip 16 kB); `plugin-detail` to 124 kB (gzip 28 kB).
+
+  **`@object-ui/app-shell` `CreateViewDialog` churn fix.** `existingSet` is now memoised on the joined string key of `existingLabels` rather than the raw array reference, preventing the name-suggest `useEffect` from re-firing on every parent render.
+
+  **CI fixes.** `ReportViewer` conditional-formatting test now accepts both `rgb(...)` and hex color representations. `ObjectView` i18n mocks rewritten to mirror the real hook shapes (`useObjectTranslation`, `useObjectLabel`).
+
+- Updated dependencies [4be43e2]
+  - @object-ui/types@4.0.3
+  - @object-ui/core@4.0.3
+
+## 4.0.1
+
+### Patch Changes
+
+- @object-ui/types@4.0.1
+- @object-ui/core@4.0.1
+
+## 4.0.0
+
+### Patch Changes
+
+- Updated dependencies
+  - @object-ui/types@4.0.0
+  - @object-ui/core@4.0.0
+
 ## 3.4.0
 
 ### Patch Changes

package/dist/index.cjs

@@ -829,6 +829,57 @@ function calculateAutoLayout(items, canvasWidth, padding = 40, gap = 40) {
 }
 
 // src/index.ts
+var FILTER_OPERATOR_ALIASES = {
+  equals: "=",
+  eq: "=",
+  "==": "=",
+  not_equals: "!=",
+  notequals: "!=",
+  ne: "!=",
+  greater_than: ">",
+  greaterthan: ">",
+  gt: ">",
+  greater_than_or_equal: ">=",
+  greater_than_or_equals: ">=",
+  greaterthanorequal: ">=",
+  gte: ">=",
+  less_than: "<",
+  lessthan: "<",
+  lt: "<",
+  less_than_or_equal: "<=",
+  less_than_or_equals: "<=",
+  lessthanorequal: "<=",
+  lte: "<=",
+  in: "in",
+  not_in: "nin",
+  notin: "nin",
+  nin: "nin",
+  contains: "contains",
+  not_contains: "notcontains",
+  notcontains: "notcontains",
+  starts_with: "startswith",
+  startswith: "startswith",
+  ends_with: "endswith",
+  endswith: "endswith",
+  between: "between",
+  is_null: "isnull",
+  isnull: "isnull",
+  is_not_null: "isnotnull",
+  isnotnull: "isnotnull"
+};
+function normalizeFilterOperator(op) {
+  if (typeof op !== "string") return null;
+  const lower = op.toLowerCase();
+  return FILTER_OPERATOR_ALIASES[lower] ?? FILTER_OPERATOR_ALIASES[op] ?? op;
+}
+function objectFilterEntryToAST(entry) {
+  if (!entry || typeof entry !== "object") return null;
+  const field = entry.field ?? entry.name;
+  const rawOp = entry.operator ?? entry.op ?? "=";
+  const op = normalizeFilterOperator(rawOp);
+  if (!field || !op) return null;
+  return [String(field), op, entry.value];
+}
 var discoveryCache = /* @__PURE__ */ new Map();
 async function getSharedDiscovery(baseUrl, fetcher) {
   const key = baseUrl || "<default>";
@@ -1322,7 +1373,18 @@ var ObjectStackAdapter = class {
       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;
+          const isObjectForm = params.$filter.length > 0 && typeof params.$filter[0] === "object" && !Array.isArray(params.$filter[0]) && params.$filter[0].field !== void 0;
+          if (isObjectForm) {
+            const tuples = params.$filter.map((entry) => objectFilterEntryToAST(entry)).filter((t) => t !== null);
+            if (tuples.length === 0) {
+            } else if (tuples.length === 1) {
+              options.filters = tuples[0];
+            } else {
+              options.filters = ["and", ...tuples];
+            }
+          } else {
+            options.filters = params.$filter;
+          }
         } else {
           options.filters = convertFiltersToAST(params.$filter);
         }
@@ -1488,6 +1550,18 @@ var ObjectStackAdapter = class {
       }
       const data = await this.client.analytics.query(payload);
       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 : [];
+      const measureMissing = rawRows.length > 0 && rawRows.every((row) => {
+        if (row == null) return true;
+        if (measureName in row && row[measureName] != null) return false;
+        if (params.field in row && row[params.field] != null) return false;
+        return true;
+      });
+      if (measureMissing) {
+        const result = await this.find(resource);
+        const records = result.data || [];
+        if (records.length === 0) return [];
+        return this.aggregateClientSide(records, params);
+      }
       return rawRows.map((row) => {
         const mapped = { ...row };
         if (measureName !== params.field && measureName in mapped) {

package/dist/index.js

@@ -787,6 +787,57 @@ function calculateAutoLayout(items, canvasWidth, padding = 40, gap = 40) {
 }
 
 // src/index.ts
+var FILTER_OPERATOR_ALIASES = {
+  equals: "=",
+  eq: "=",
+  "==": "=",
+  not_equals: "!=",
+  notequals: "!=",
+  ne: "!=",
+  greater_than: ">",
+  greaterthan: ">",
+  gt: ">",
+  greater_than_or_equal: ">=",
+  greater_than_or_equals: ">=",
+  greaterthanorequal: ">=",
+  gte: ">=",
+  less_than: "<",
+  lessthan: "<",
+  lt: "<",
+  less_than_or_equal: "<=",
+  less_than_or_equals: "<=",
+  lessthanorequal: "<=",
+  lte: "<=",
+  in: "in",
+  not_in: "nin",
+  notin: "nin",
+  nin: "nin",
+  contains: "contains",
+  not_contains: "notcontains",
+  notcontains: "notcontains",
+  starts_with: "startswith",
+  startswith: "startswith",
+  ends_with: "endswith",
+  endswith: "endswith",
+  between: "between",
+  is_null: "isnull",
+  isnull: "isnull",
+  is_not_null: "isnotnull",
+  isnotnull: "isnotnull"
+};
+function normalizeFilterOperator(op) {
+  if (typeof op !== "string") return null;
+  const lower = op.toLowerCase();
+  return FILTER_OPERATOR_ALIASES[lower] ?? FILTER_OPERATOR_ALIASES[op] ?? op;
+}
+function objectFilterEntryToAST(entry) {
+  if (!entry || typeof entry !== "object") return null;
+  const field = entry.field ?? entry.name;
+  const rawOp = entry.operator ?? entry.op ?? "=";
+  const op = normalizeFilterOperator(rawOp);
+  if (!field || !op) return null;
+  return [String(field), op, entry.value];
+}
 var discoveryCache = /* @__PURE__ */ new Map();
 async function getSharedDiscovery(baseUrl, fetcher) {
   const key = baseUrl || "<default>";
@@ -1280,7 +1331,18 @@ var ObjectStackAdapter = class {
       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;
+          const isObjectForm = params.$filter.length > 0 && typeof params.$filter[0] === "object" && !Array.isArray(params.$filter[0]) && params.$filter[0].field !== void 0;
+          if (isObjectForm) {
+            const tuples = params.$filter.map((entry) => objectFilterEntryToAST(entry)).filter((t) => t !== null);
+            if (tuples.length === 0) {
+            } else if (tuples.length === 1) {
+              options.filters = tuples[0];
+            } else {
+              options.filters = ["and", ...tuples];
+            }
+          } else {
+            options.filters = params.$filter;
+          }
         } else {
           options.filters = convertFiltersToAST(params.$filter);
         }
@@ -1446,6 +1508,18 @@ var ObjectStackAdapter = class {
       }
       const data = await this.client.analytics.query(payload);
       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 : [];
+      const measureMissing = rawRows.length > 0 && rawRows.every((row) => {
+        if (row == null) return true;
+        if (measureName in row && row[measureName] != null) return false;
+        if (params.field in row && row[params.field] != null) return false;
+        return true;
+      });
+      if (measureMissing) {
+        const result = await this.find(resource);
+        const records = result.data || [];
+        if (records.length === 0) return [];
+        return this.aggregateClientSide(records, params);
+      }
       return rawRows.map((row) => {
         const mapped = { ...row };
         if (measureName !== params.field && measureName in mapped) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/data-objectstack",
-  "version": "3.4.0",
+  "version": "4.0.3",
   "description": "ObjectStack Data Adapter for Object UI",
   "license": "MIT",
   "type": "module",
@@ -23,8 +23,8 @@
   ],
   "dependencies": {
     "@objectstack/client": "^4.0.4",
-    "@object-ui/core": "3.4.0",
-    "@object-ui/types": "3.4.0"
+    "@object-ui/core": "4.0.3",
+    "@object-ui/types": "4.0.3"
   },
   "devDependencies": {
     "tsup": "^8.5.1",

package/src/index.ts

@@ -18,6 +18,66 @@ import {
   createErrorFromResponse,
 } from './errors';
 
+/**
+ * Map human-readable filter operator names produced by SDUI view configs
+ * (e.g. `lead.view.ts`) to the canonical operator symbols expected by the
+ * ObjectStack server's filter AST. Unknown operators fall through unchanged
+ * so existing AST-style entries keep working.
+ */
+const FILTER_OPERATOR_ALIASES: Record<string, string> = {
+  equals: '=',
+  eq: '=',
+  '==': '=',
+  not_equals: '!=',
+  notequals: '!=',
+  ne: '!=',
+  greater_than: '>',
+  greaterthan: '>',
+  gt: '>',
+  greater_than_or_equal: '>=',
+  greater_than_or_equals: '>=',
+  greaterthanorequal: '>=',
+  gte: '>=',
+  less_than: '<',
+  lessthan: '<',
+  lt: '<',
+  less_than_or_equal: '<=',
+  less_than_or_equals: '<=',
+  lessthanorequal: '<=',
+  lte: '<=',
+  in: 'in',
+  not_in: 'nin',
+  notin: 'nin',
+  nin: 'nin',
+  contains: 'contains',
+  not_contains: 'notcontains',
+  notcontains: 'notcontains',
+  starts_with: 'startswith',
+  startswith: 'startswith',
+  ends_with: 'endswith',
+  endswith: 'endswith',
+  between: 'between',
+  is_null: 'isnull',
+  isnull: 'isnull',
+  is_not_null: 'isnotnull',
+  isnotnull: 'isnotnull',
+};
+
+function normalizeFilterOperator(op: unknown): string | null {
+  if (typeof op !== 'string') return null;
+  const lower = op.toLowerCase();
+  return FILTER_OPERATOR_ALIASES[lower] ?? FILTER_OPERATOR_ALIASES[op] ?? op;
+}
+
+function objectFilterEntryToAST(entry: any): [string, string, any] | null {
+  if (!entry || typeof entry !== 'object') return null;
+  const field = entry.field ?? entry.name;
+  const rawOp = entry.operator ?? entry.op ?? '=';
+  const op = normalizeFilterOperator(rawOp);
+  if (!field || !op) return null;
+  return [String(field), op, entry.value];
+}
+
 // Module-level discovery cache. Multiple ObjectStackAdapter instances pointed
 // at the same baseUrl (e.g. ConditionalAuthWrapper's throwaway adapter +
 // AdapterProvider's main adapter) would otherwise each fire `/discovery`. By
@@ -749,8 +809,33 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
         : typeof params.$filter === 'object' && Object.keys(params.$filter).length === 0;
       if (!isEmpty) {
         if (Array.isArray(params.$filter)) {
-          // Assume active AST format if it's already an array
-          options.filters = params.$filter;
+          // Two array shapes are accepted from upstream:
+          //   1. AST tuples:  [field, op, value]                 — pass through.
+          //   2. Object form: [{ field, operator, value }, ...]  — server-driven
+          //      view configs (lead.view.ts etc.) use this. Translate each
+          //      entry into the AST tuple shape and map human-readable
+          //      operator names (`greater_than_or_equal`, `in`, `contains`,
+          //      …) to the canonical symbols the server understands.
+          const isObjectForm = params.$filter.length > 0
+            && typeof params.$filter[0] === 'object'
+            && !Array.isArray(params.$filter[0])
+            && (params.$filter[0] as any).field !== undefined;
+          if (isObjectForm) {
+            const tuples = (params.$filter as any[])
+              .map(entry => objectFilterEntryToAST(entry))
+              .filter((t): t is [string, string, any] => t !== null);
+            if (tuples.length === 0) {
+              // All entries were unrecognized — drop the filter rather than
+              // sending a malformed array.
+            } else if (tuples.length === 1) {
+              options.filters = tuples[0];
+            } else {
+              options.filters = ['and', ...tuples];
+            }
+          } else {
+            // Already in AST format
+            options.filters = params.$filter;
+          }
         } else {
           options.filters = convertFiltersToAST(params.$filter);
         }
@@ -970,6 +1055,24 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
         : data?.results && Array.isArray(data.results) ? data.results
         : [];
 
+      // Defensive guard: if the backend silently dropped the requested measure
+      // (e.g. it doesn't recognise the `${field}_${function}` alias and the
+      // canonical measure is named differently), the rows come back without
+      // any measure value. Detect this and fall back to client-side
+      // aggregation so charts still render.
+      const measureMissing = rawRows.length > 0 && rawRows.every((row: any) => {
+        if (row == null) return true;
+        if (measureName in row && row[measureName] != null) return false;
+        if (params.field in row && row[params.field] != null) return false;
+        return true;
+      });
+      if (measureMissing) {
+        const result = await this.find(resource as any);
+        const records = result.data || [];
+        if (records.length === 0) return [];
+        return this.aggregateClientSide(records, params);
+      }
+
       // Map measure keys back to the original field name so that consumers
       // (ObjectChart, DashboardRenderer, etc.) can access values by field name.
       // This includes count → field (e.g. 'count' → 'amount') to match the

package/src/aggregate.test.ts

@@ -1,277 +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, 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);
-  });
-});

package/src/expand.test.ts

@@ -1,267 +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, beforeEach, vi } from 'vitest';
-import { ObjectStackAdapter } from './index';
-
-// We test the adapter's $expand handling.
-// When $expand is present, the adapter makes a raw GET request to the REST API
-// with `populate` as a URL query param (since the client SDK's data.find()
-// QueryOptions does not support populate/expand).
-// The key scenarios:
-//   1. find() with $expand → raw GET /api/v1/data/:object?populate=...
-//   2. find() without $expand → client.data.find() (GET) as before
-//   3. findOne() with $expand → raw GET /api/v1/data/:object?filter={id:...}&populate=...
-//   4. findOne() without $expand → client.data.get() as before
-
-describe('ObjectStackAdapter $expand support', () => {
-  let adapter: ObjectStackAdapter;
-  let mockClient: any;
-  let mockFetch: ReturnType<typeof vi.fn>;
-
-  beforeEach(() => {
-    // Create a mock fetch that returns a successful response
-    mockFetch = vi.fn().mockResolvedValue({
-      ok: true,
-      json: () => Promise.resolve({ records: [], total: 0 }),
-    });
-
-    adapter = new ObjectStackAdapter({
-      baseUrl: 'http://localhost:3000',
-      autoReconnect: false,
-      fetch: mockFetch,
-    });
-
-    // Mock the internal client after construction
-    mockClient = {
-      data: {
-        find: vi.fn().mockResolvedValue({ records: [], total: 0 }),
-        query: vi.fn().mockResolvedValue({ records: [], total: 0 }),
-        get: vi.fn().mockResolvedValue({ record: { id: '1', name: 'Test' } }),
-      },
-      connect: vi.fn().mockResolvedValue(undefined),
-      discover: vi.fn().mockResolvedValue({ status: 'ok' }),
-    };
-
-    // Inject mock client and mark as connected to bypass connect()
-    (adapter as any).client = mockClient;
-    (adapter as any).connected = true;
-  });
-
-  describe('find() with $expand', () => {
-    it('should make a raw GET request with populate query param when $expand is present', async () => {
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({
-          records: [{ id: '1', name: 'Order 1', customer: { id: '2', name: 'Alice' } }],
-          total: 1,
-        }),
-      });
-
-      const result = await adapter.find('order', {
-        $top: 10,
-        $expand: ['customer', 'account'],
-      });
-
-      // Should use raw fetch, not client.data.query or client.data.find
-      expect(mockFetch).toHaveBeenCalled();
-      const fetchUrl = mockFetch.mock.calls[0][0] as string;
-      expect(fetchUrl).toContain('/api/v1/data/order');
-      expect(fetchUrl).toContain('populate=customer%2Caccount');
-      expect(fetchUrl).toContain('top=10');
-      expect(mockClient.data.find).not.toHaveBeenCalled();
-      expect(result.data).toHaveLength(1);
-      expect(result.data[0].customer).toEqual({ id: '2', name: 'Alice' });
-    });
-
-    it('should pass filters and sort as query params', async () => {
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({ records: [], total: 0 }),
-      });
-
-      await adapter.find('order', {
-        $filter: { status: 'active' },
-        $orderby: [{ field: 'name', order: 'asc' }],
-        $top: 50,
-        $skip: 10,
-        $expand: ['customer'],
-      });
-
-      expect(mockFetch).toHaveBeenCalled();
-      const fetchUrl = mockFetch.mock.calls[0][0] as string;
-      expect(fetchUrl).toContain('populate=customer');
-      expect(fetchUrl).toContain('top=50');
-      expect(fetchUrl).toContain('skip=10');
-      expect(fetchUrl).toContain('sort=name');
-      expect(fetchUrl).toContain('filter=');
-    });
-
-    it('should use data.find() when $expand is not present', async () => {
-      mockClient.data.find.mockResolvedValue({ records: [{ id: '1', name: 'Test' }], total: 1 });
-
-      const result = await adapter.find('order', { $top: 10 });
-
-      expect(mockClient.data.find).toHaveBeenCalled();
-      expect(result.data).toHaveLength(1);
-    });
-
-    it('should use data.find() when $expand is an empty array', async () => {
-      mockClient.data.find.mockResolvedValue({ records: [], total: 0 });
-
-      await adapter.find('order', { $top: 10, $expand: [] });
-
-      expect(mockClient.data.find).toHaveBeenCalled();
-    });
-  });
-
-  describe('findOne() with $expand', () => {
-    it('should make a raw GET request with id filter and populate when $expand is present', async () => {
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({
-          records: [{ id: 'order-1', name: 'Order 1', customer: { id: '2', name: 'Alice' } }],
-        }),
-      });
-
-      const result = await adapter.findOne('order', 'order-1', {
-        $expand: ['customer', 'account'],
-      });
-
-      expect(mockFetch).toHaveBeenCalled();
-      const fetchUrl = mockFetch.mock.calls[0][0] as string;
-      expect(fetchUrl).toContain('/api/v1/data/order');
-      expect(fetchUrl).toContain('populate=customer%2Caccount');
-      expect(fetchUrl).toContain('top=1');
-      expect(fetchUrl).toContain('filter=');
-      // Verify the filter contains id
-      const filterParam = new URL(fetchUrl).searchParams.get('filter');
-      expect(filterParam).toBeTruthy();
-      const parsedFilter = JSON.parse(filterParam!);
-      expect(parsedFilter).toEqual({ id: 'order-1' });
-      expect(mockClient.data.get).not.toHaveBeenCalled();
-      expect(result).toEqual({ id: 'order-1', name: 'Order 1', customer: { id: '2', name: 'Alice' } });
-    });
-
-    it('should return null when raw request returns no records', async () => {
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({ records: [] }),
-      });
-
-      const result = await adapter.findOne('order', 'nonexistent', {
-        $expand: ['customer'],
-      });
-
-      expect(result).toBeNull();
-    });
-
-    it('should use data.get() when $expand is not present', async () => {
-      mockClient.data.get.mockResolvedValue({ record: { id: '1', name: 'Test' } });
-
-      const result = await adapter.findOne('order', '1');
-
-      expect(mockClient.data.get).toHaveBeenCalledWith('order', '1');
-      expect(result).toEqual({ id: '1', name: 'Test' });
-    });
-
-    it('should return null for 404 errors without $expand', async () => {
-      mockClient.data.get.mockRejectedValue({ status: 404 });
-
-      const result = await adapter.findOne('order', 'nonexistent');
-
-      expect(result).toBeNull();
-    });
-
-    it('should fall through to data.get() when $expand raw request fails with non-404 error', async () => {
-      // The raw populate request fails (e.g., server doesn't support the filter+populate API)
-      mockFetch.mockResolvedValue({
-        ok: false,
-        status: 500,
-        statusText: 'Internal Server Error',
-        json: () => Promise.resolve({ message: 'unsupported' }),
-      });
-      // But the direct data.get() call succeeds
-      mockClient.data.get.mockResolvedValue({ record: { id: 'order-1', name: 'Order 1' } });
-
-      const result = await adapter.findOne('order', 'order-1', {
-        $expand: ['customer'],
-      });
-
-      // Should have tried raw request first
-      expect(mockFetch).toHaveBeenCalled();
-      // Then fell through to data.get()
-      expect(mockClient.data.get).toHaveBeenCalledWith('order', 'order-1');
-      expect(result).toEqual({ id: 'order-1', name: 'Order 1' });
-    });
-  });
-
-  describe('raw request format', () => {
-    it('should include Authorization header when token is set', async () => {
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({ records: [], total: 0 }),
-      });
-
-      (adapter as any).token = 'test-token';
-
-      await adapter.find('order', {
-        $expand: ['customer'],
-      });
-
-      expect(mockFetch).toHaveBeenCalled();
-      const fetchInit = mockFetch.mock.calls[0][1];
-      expect(fetchInit.headers.Authorization).toBe('Bearer test-token');
-    });
-
-    it('should unwrap response envelope with success/data wrapper', async () => {
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({
-          success: true,
-          data: {
-            records: [{ id: '1', name: 'Order' }],
-            total: 1,
-          },
-        }),
-      });
-
-      const result = await adapter.find('order', {
-        $expand: ['customer'],
-      });
-
-      expect(result.data).toHaveLength(1);
-    });
-
-    it('should not double /api/v1 when baseUrl already includes it', async () => {
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({ records: [], total: 0 }),
-      });
-
-      // Create adapter with /api/v1 in baseUrl
-      const apiAdapter = new ObjectStackAdapter({
-        baseUrl: 'http://localhost:3000/api/v1',
-        autoReconnect: false,
-        fetch: mockFetch,
-      });
-      (apiAdapter as any).client = mockClient;
-      (apiAdapter as any).connected = true;
-
-      await apiAdapter.find('order', {
-        $expand: ['customer'],
-      });
-
-      expect(mockFetch).toHaveBeenCalled();
-      const fetchUrl = mockFetch.mock.calls[0][0] as string;
-      // Should be /api/v1/data/order not /api/v1/api/v1/data/order
-      expect(fetchUrl).toBe('http://localhost:3000/api/v1/data/order?populate=customer');
-      expect(fetchUrl).not.toContain('/api/v1/api/v1');
-    });
-  });
-});

package/src/upload.test.ts

@@ -1,112 +0,0 @@
-/**
- * Tests for ObjectStackAdapter file upload integration
- */
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { ObjectStackAdapter } from './index';
-
-describe('ObjectStackAdapter File Upload', () => {
-  let adapter: ObjectStackAdapter;
-
-  beforeEach(() => {
-    adapter = new ObjectStackAdapter({
-      baseUrl: 'http://localhost:3000',
-      autoReconnect: false,
-    });
-    vi.clearAllMocks();
-  });
-
-  describe('uploadFile', () => {
-    it('should be a method on the adapter', () => {
-      expect(typeof adapter.uploadFile).toBe('function');
-    });
-
-    it('should call fetch with multipart form data when connected', async () => {
-      const mockResponse = {
-        ok: true,
-        json: vi.fn().mockResolvedValue({
-          id: 'file-1',
-          filename: 'test.pdf',
-          mimeType: 'application/pdf',
-          size: 1024,
-          url: 'http://localhost:3000/files/file-1',
-        }),
-      };
-
-      global.fetch = vi.fn().mockResolvedValue(mockResponse);
-
-      // Manually set connected state by accessing private field
-      (adapter as any).connected = true;
-      (adapter as any).connectionState = 'connected';
-
-      const file = new File(['test content'], 'test.pdf', { type: 'application/pdf' });
-
-      const result = await adapter.uploadFile('documents', file, {
-        recordId: 'rec-123',
-        fieldName: 'attachment',
-      });
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        expect.stringContaining('/api/data/documents/upload'),
-        expect.objectContaining({
-          method: 'POST',
-          body: expect.any(FormData),
-        }),
-      );
-
-      expect(result.id).toBe('file-1');
-      expect(result.filename).toBe('test.pdf');
-    });
-
-    it('should throw on upload failure', async () => {
-      const mockResponse = {
-        ok: false,
-        status: 413,
-        statusText: 'Payload Too Large',
-        json: vi.fn().mockResolvedValue({ message: 'File too large' }),
-      };
-
-      global.fetch = vi.fn().mockResolvedValue(mockResponse);
-
-      // Manually set connected state
-      (adapter as any).connected = true;
-      (adapter as any).connectionState = 'connected';
-
-      const file = new File(['test'], 'large.bin', { type: 'application/octet-stream' });
-
-      await expect(adapter.uploadFile('documents', file)).rejects.toThrow('File too large');
-    });
-  });
-
-  describe('uploadFiles', () => {
-    it('should be a method on the adapter', () => {
-      expect(typeof adapter.uploadFiles).toBe('function');
-    });
-
-    it('should upload multiple files', async () => {
-      const mockResponse = {
-        ok: true,
-        json: vi.fn().mockResolvedValue([
-          { id: 'file-1', filename: 'a.pdf', mimeType: 'application/pdf', size: 100, url: '/files/1' },
-          { id: 'file-2', filename: 'b.pdf', mimeType: 'application/pdf', size: 200, url: '/files/2' },
-        ]),
-      };
-
-      global.fetch = vi.fn().mockResolvedValue(mockResponse);
-
-      // Manually set connected state
-      (adapter as any).connected = true;
-      (adapter as any).connectionState = 'connected';
-
-      const files = [
-        new File(['content1'], 'a.pdf', { type: 'application/pdf' }),
-        new File(['content2'], 'b.pdf', { type: 'application/pdf' }),
-      ];
-
-      const results = await adapter.uploadFiles('documents', files);
-
-      expect(results).toHaveLength(2);
-      expect(results[0].id).toBe('file-1');
-      expect(results[1].id).toBe('file-2');
-    });
-  });
-});