@object-ui/data-objectstack 3.3.1 → 3.4.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @object-ui/data-objectstack
 
+## 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
+
+- @object-ui/types@3.3.2
+- @object-ui/core@3.3.2
+
 ## 3.3.1
 
 ### Patch Changes

package/dist/index.cjs

@@ -844,6 +844,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 +867,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 +1009,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.

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

@@ -802,6 +802,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 +825,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 +967,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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/data-objectstack",
-  "version": "3.3.1",
+  "version": "3.4.0",
   "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.1",
-    "@object-ui/types": "3.3.1"
+    "@object-ui/core": "3.4.0",
+    "@object-ui/types": "3.4.0"
   },
   "devDependencies": {
     "tsup": "^8.5.1",

package/src/index.ts

@@ -88,6 +88,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 +146,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 +342,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;
   }
 
   /**