@object-ui/data-objectstack 3.3.2 → 4.0.1

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @object-ui/data-objectstack
 
+## 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
+
+- Updated dependencies [f1ca238]
+- Updated dependencies [de881ef]
+  - @object-ui/types@3.4.0
+  - @object-ui/core@3.4.0
+
 ## 3.3.2
 
 ### 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>";
@@ -844,6 +895,13 @@ async function getSharedDiscovery(baseUrl, fetcher) {
 function clearSharedDiscoveryCache() {
   discoveryCache.clear();
 }
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
+}
 var ObjectStackAdapter = class {
   constructor(config) {
     __publicField(this, "client");
@@ -860,6 +918,11 @@ var ObjectStackAdapter = class {
     __publicField(this, "baseUrl");
     __publicField(this, "token");
     __publicField(this, "fetchImpl");
+    // In-flight find() requests keyed by resource + serialized params.
+    // Coalesces concurrent identical reads (e.g. React StrictMode double-mount,
+    // multiple sibling components requesting the same dataset on first paint)
+    // into a single network round trip.
+    __publicField(this, "inflightFinds", /* @__PURE__ */ new Map());
     this.client = new import_client.ObjectStackClient(config);
     this.metadataCache = new MetadataCache(config.cache);
     this.autoReconnect = config.autoReconnect ?? true;
@@ -997,14 +1060,26 @@ var ObjectStackAdapter = class {
    * Converts OData-style params to ObjectStack query options.
    */
   async find(resource, params) {
-    await this.connect();
-    if (params?.$expand && params.$expand.length > 0) {
-      const result2 = await this.rawFindWithPopulate(resource, params);
-      return this.normalizeQueryResult(result2, params);
-    }
-    const queryOptions = this.convertQueryParams(params);
-    const result = await this.client.data.find(resource, queryOptions);
-    return this.normalizeQueryResult(result, params);
+    const key = `${resource}::${stableStringify(params)}`;
+    const existing = this.inflightFinds.get(key);
+    if (existing) return existing;
+    const promise = (async () => {
+      await this.connect();
+      if (params?.$expand && params.$expand.length > 0) {
+        const result2 = await this.rawFindWithPopulate(resource, params);
+        return this.normalizeQueryResult(result2, params);
+      }
+      const queryOptions = this.convertQueryParams(params);
+      const result = await this.client.data.find(resource, queryOptions);
+      return this.normalizeQueryResult(result, params);
+    })();
+    this.inflightFinds.set(key, promise);
+    promise.finally(() => {
+      if (this.inflightFinds.get(key) === promise) {
+        this.inflightFinds.delete(key);
+      }
+    });
+    return promise;
   }
   /**
    * Find a single record by ID.
@@ -1298,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);
         }

package/dist/index.d.cts

@@ -723,6 +723,7 @@ declare class ObjectStackAdapter<T = unknown> implements DataSource<T> {
     private baseUrl;
     private token?;
     private fetchImpl;
+    private inflightFinds;
     constructor(config: {
         baseUrl: string;
         token?: string;

package/dist/index.d.ts

@@ -723,6 +723,7 @@ declare class ObjectStackAdapter<T = unknown> implements DataSource<T> {
     private baseUrl;
     private token?;
     private fetchImpl;
+    private inflightFinds;
     constructor(config: {
         baseUrl: string;
         token?: string;

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>";
@@ -802,6 +853,13 @@ async function getSharedDiscovery(baseUrl, fetcher) {
 function clearSharedDiscoveryCache() {
   discoveryCache.clear();
 }
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
+}
 var ObjectStackAdapter = class {
   constructor(config) {
     __publicField(this, "client");
@@ -818,6 +876,11 @@ var ObjectStackAdapter = class {
     __publicField(this, "baseUrl");
     __publicField(this, "token");
     __publicField(this, "fetchImpl");
+    // In-flight find() requests keyed by resource + serialized params.
+    // Coalesces concurrent identical reads (e.g. React StrictMode double-mount,
+    // multiple sibling components requesting the same dataset on first paint)
+    // into a single network round trip.
+    __publicField(this, "inflightFinds", /* @__PURE__ */ new Map());
     this.client = new ObjectStackClient(config);
     this.metadataCache = new MetadataCache(config.cache);
     this.autoReconnect = config.autoReconnect ?? true;
@@ -955,14 +1018,26 @@ var ObjectStackAdapter = class {
    * Converts OData-style params to ObjectStack query options.
    */
   async find(resource, params) {
-    await this.connect();
-    if (params?.$expand && params.$expand.length > 0) {
-      const result2 = await this.rawFindWithPopulate(resource, params);
-      return this.normalizeQueryResult(result2, params);
-    }
-    const queryOptions = this.convertQueryParams(params);
-    const result = await this.client.data.find(resource, queryOptions);
-    return this.normalizeQueryResult(result, params);
+    const key = `${resource}::${stableStringify(params)}`;
+    const existing = this.inflightFinds.get(key);
+    if (existing) return existing;
+    const promise = (async () => {
+      await this.connect();
+      if (params?.$expand && params.$expand.length > 0) {
+        const result2 = await this.rawFindWithPopulate(resource, params);
+        return this.normalizeQueryResult(result2, params);
+      }
+      const queryOptions = this.convertQueryParams(params);
+      const result = await this.client.data.find(resource, queryOptions);
+      return this.normalizeQueryResult(result, params);
+    })();
+    this.inflightFinds.set(key, promise);
+    promise.finally(() => {
+      if (this.inflightFinds.get(key) === promise) {
+        this.inflightFinds.delete(key);
+      }
+    });
+    return promise;
   }
   /**
    * Find a single record by ID.
@@ -1256,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);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/data-objectstack",
-  "version": "3.3.2",
+  "version": "4.0.1",
   "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.3.2",
-    "@object-ui/types": "3.3.2"
+    "@object-ui/core": "4.0.1",
+    "@object-ui/types": "4.0.1"
   },
   "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
@@ -88,6 +148,20 @@ export type BatchProgressListener = (event: BatchProgressEvent) => void;
 // Re-export FileUploadResult from types for consumers
 export type { FileUploadResult } from '@object-ui/types';
 
+/**
+ * Deterministic JSON.stringify with sorted object keys, used to build cache
+ * keys for in-flight request coalescing. Produces identical output for
+ * `{ a: 1, b: 2 }` and `{ b: 2, a: 1 }` so callers that build params in
+ * different orders still hit the same key.
+ */
+function stableStringify(value: unknown): string {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  const obj = value as Record<string, unknown>;
+  const keys = Object.keys(obj).sort();
+  return `{${keys.map(k => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(',')}}`;
+}
+
 /**
  * ObjectStack Data Source Adapter
  * 
@@ -132,6 +206,11 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
   private baseUrl: string;
   private token?: string;
   private fetchImpl: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+  // In-flight find() requests keyed by resource + serialized params.
+  // Coalesces concurrent identical reads (e.g. React StrictMode double-mount,
+  // multiple sibling components requesting the same dataset on first paint)
+  // into a single network round trip.
+  private inflightFinds = new Map<string, Promise<QueryResult<T>>>();
 
   constructor(config: {
     baseUrl: string;
@@ -323,22 +402,38 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
    * Converts OData-style params to ObjectStack query options.
    */
   async find(resource: string, params?: QueryParams): Promise<QueryResult<T>> {
-    await this.connect();
+    const key = `${resource}::${stableStringify(params)}`;
+    const existing = this.inflightFinds.get(key);
+    if (existing) return existing;
 
-    // When $expand is requested, use a raw GET request to the REST API with
-    // `populate` as a URL query param. The server's REST plugin routes
-    // GET /data/:object to protocol.findData({ object, query: req.query }),
-    // which parses `populate` (comma-separated) into an array for lookup expansion.
-    // We use a raw request because the client SDK's data.find() QueryOptions
-    // interface does not include populate/expand fields.
-    if (params?.$expand && params.$expand.length > 0) {
-      const result = await this.rawFindWithPopulate(resource, params);
+    const promise = (async () => {
+      await this.connect();
+
+      // When $expand is requested, use a raw GET request to the REST API with
+      // `populate` as a URL query param. The server's REST plugin routes
+      // GET /data/:object to protocol.findData({ object, query: req.query }),
+      // which parses `populate` (comma-separated) into an array for lookup expansion.
+      // We use a raw request because the client SDK's data.find() QueryOptions
+      // interface does not include populate/expand fields.
+      if (params?.$expand && params.$expand.length > 0) {
+        const result = await this.rawFindWithPopulate(resource, params);
+        return this.normalizeQueryResult(result, params);
+      }
+
+      const queryOptions = this.convertQueryParams(params);
+      const result: unknown = await this.client.data.find<T>(resource, queryOptions);
       return this.normalizeQueryResult(result, params);
-    }
+    })();
 
-    const queryOptions = this.convertQueryParams(params);
-    const result: unknown = await this.client.data.find<T>(resource, queryOptions);
-    return this.normalizeQueryResult(result, params);
+    this.inflightFinds.set(key, promise);
+    promise.finally(() => {
+      // Only clear if the entry still points at this promise; a later call
+      // that started after settle may have already replaced it.
+      if (this.inflightFinds.get(key) === promise) {
+        this.inflightFinds.delete(key);
+      }
+    });
+    return promise;
   }
 
   /**
@@ -714,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);
         }