@object-ui/data-objectstack 3.3.0 → 3.3.2

package/CHANGELOG.md

@@ -0,0 +1,125 @@
+# @object-ui/data-objectstack
+
+## 3.3.2
+
+### Patch Changes
+
+- @object-ui/types@3.3.2
+- @object-ui/core@3.3.2
+
+## 3.3.1
+
+### Patch Changes
+
+- @object-ui/types@3.3.1
+- @object-ui/core@3.3.1
+
+## 3.3.0
+
+### Patch Changes
+
+- @object-ui/types@3.3.0
+- @object-ui/core@3.3.0
+
+## 3.2.0
+
+### Patch Changes
+
+- @object-ui/types@3.2.0
+- @object-ui/core@3.2.0
+
+## 3.1.5
+
+### Patch Changes
+
+- @object-ui/types@3.1.5
+- @object-ui/core@3.1.5
+
+## 3.1.4
+
+### Patch Changes
+
+- @object-ui/types@3.1.4
+- @object-ui/core@3.1.4
+
+## 3.1.3
+
+### Patch Changes
+
+- @object-ui/types@3.1.3
+- @object-ui/core@3.1.3
+
+## 3.1.2
+
+### Patch Changes
+
+- @object-ui/types@3.1.2
+- @object-ui/core@3.1.2
+
+## 3.1.1
+
+### Patch Changes
+
+- Updated dependencies
+  - @object-ui/types@3.1.1
+  - @object-ui/core@3.1.1
+
+## 3.0.3
+
+### Patch Changes
+
+- @object-ui/types@3.0.3
+- @object-ui/core@3.0.3
+
+## 3.0.2
+
+### Patch Changes
+
+- @object-ui/types@3.0.2
+- @object-ui/core@3.0.2
+
+## 3.0.1
+
+### Patch Changes
+
+- @object-ui/types@3.0.1
+- @object-ui/core@3.0.1
+
+## 3.0.0
+
+### Minor Changes
+
+- 87979c3: Upgrade to @objectstack v3.0.0 and console bundle optimization
+  - Upgraded all @objectstack/\* packages from ^2.0.7 to ^3.0.0
+  - Breaking change migrations: Hub → Cloud namespace, definePlugin removed, PaginatedResult.value → .records, PaginatedResult.count → .total, client.meta.getObject() → client.meta.getItem()
+  - Console bundle optimization: split monolithic 3.7 MB chunk into 17 granular cacheable chunks (95% main entry reduction)
+  - Added gzip + brotli pre-compression via vite-plugin-compression2
+  - Lazy MSW loading for build:server (~150 KB gzip saved)
+  - Added bundle analysis with rollup-plugin-visualizer
+
+### Patch Changes
+
+- Updated dependencies [87979c3]
+  - @object-ui/types@3.0.0
+  - @object-ui/core@3.0.0
+
+## 2.0.0
+
+### Major Changes
+
+- b859617: Release v1.0.0 — unify all package versions to 1.0.0
+
+### Patch Changes
+
+- Updated dependencies [b859617]
+  - @object-ui/types@2.0.0
+  - @object-ui/core@2.0.0
+
+## 0.3.1
+
+### Patch Changes
+
+- Maintenance release - Documentation and build improvements
+- Updated dependencies
+  - @object-ui/types@0.3.1
+  - @object-ui/core@0.3.1

package/README.md

@@ -356,6 +356,25 @@ dataSource.clearCache();
 dataSource.invalidateCache('users');
 ```
 
+<!-- release-metadata:v3.3.0 -->
+
+## Compatibility
+
+- **Node.js:** ≥ 18
+- **TypeScript:** ≥ 5.0 (strict mode)
+- **`@objectstack/spec`:** ^3.3.0
+- **`@objectstack/client`:** ^3.3.0
+- **Tailwind CSS:** ≥ 3.4 (for packages with UI)
+
+## Links
+
+- 📚 [Documentation](https://www.objectui.org/docs/guide/data-source)
+- 📦 [npm package](https://www.npmjs.com/package/@object-ui/data-objectstack)
+- 📝 [Changelog](./CHANGELOG.md)
+- 🐛 [Report an issue](https://github.com/objectstack-ai/objectui/issues)
+- 🤝 [Contributing Guide](https://github.com/objectstack-ai/objectui/blob/main/CONTRIBUTING.md)
+- 🗺️ [Roadmap](https://github.com/objectstack-ai/objectui/blob/main/ROADMAP.md)
+
 ## License
 
-MIT
+MIT — see [LICENSE](./LICENSE).

package/dist/index.cjs

@@ -33,10 +33,12 @@ __export(index_exports, {
   SecurityManager: () => SecurityManager,
   ValidationError: () => ValidationError,
   calculateAutoLayout: () => calculateAutoLayout,
+  clearSharedDiscoveryCache: () => clearSharedDiscoveryCache,
   createDefaultCanvasConfig: () => createDefaultCanvasConfig,
   createErrorFromResponse: () => createErrorFromResponse,
   createObjectStackAdapter: () => createObjectStackAdapter,
   generateContractManifest: () => generateContractManifest,
+  getSharedDiscovery: () => getSharedDiscovery,
   isErrorType: () => isErrorType,
   isObjectStackError: () => isObjectStackError,
   snapToGrid: () => snapToGrid,
@@ -44,7 +46,72 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 var import_client = require("@objectstack/client");
-var import_core = require("@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 {
@@ -57,16 +124,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
     };
   }
   /**
@@ -92,10 +162,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
@@ -142,10 +233,12 @@ var MetadataCache = class {
    */
   clear() {
     this.cache.clear();
+    this.inflight.clear();
     this.stats = {
       hits: 0,
       misses: 0,
-      evictions: 0
+      evictions: 0,
+      coalesced: 0
     };
   }
   /**
@@ -162,6 +255,7 @@ var MetadataCache = class {
       hits: this.stats.hits,
       misses: this.stats.misses,
       evictions: this.stats.evictions,
+      coalesced: this.stats.coalesced,
       hitRate
     };
   }
@@ -735,10 +829,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", []);
@@ -764,10 +874,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");
@@ -784,8 +909,11 @@ var ObjectStackAdapter = class {
         } else {
           throw connectionError;
         }
+      } finally {
+        this.connectPromise = null;
       }
-    }
+    })();
+    return this.connectPromise;
   }
   /**
    * Attempt to reconnect to the server with exponential backoff
@@ -1126,8 +1254,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();
@@ -1163,11 +1294,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 = (0, import_core.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) {
@@ -1532,10 +1666,12 @@ function createObjectStackAdapter(config) {
   SecurityManager,
   ValidationError,
   calculateAutoLayout,
+  clearSharedDiscoveryCache,
   createDefaultCanvasConfig,
   createErrorFromResponse,
   createObjectStackAdapter,
   generateContractManifest,
+  getSharedDiscovery,
   isErrorType,
   isObjectStackError,
   snapToGrid,

package/dist/index.d.cts

@@ -156,6 +156,8 @@ interface CacheStats {
     hits: number;
     misses: number;
     evictions: number;
+    /** Number of concurrent fetches that were coalesced onto an in-flight request. */
+    coalesced: number;
     hitRate: number;
 }
 
@@ -638,6 +640,14 @@ declare function calculateAutoLayout(items: Array<{
     y: number;
 }>;
 
+/**
+ * Fetch the server `discovery` document once per (baseUrl) and reuse the
+ * resulting Promise. Used by `ObjectStackAdapter.connect()` (and any caller
+ * that wants the discovery payload without spinning up a new client).
+ */
+declare function getSharedDiscovery(baseUrl: string, fetcher: () => Promise<unknown>): Promise<unknown>;
+/** Test/dev helper to drop the cache (e.g. on logout or origin change). */
+declare function clearSharedDiscoveryCache(): void;
 /**
  * Connection state for monitoring
  */
@@ -701,6 +711,7 @@ type BatchProgressListener = (event: BatchProgressEvent) => void;
 declare class ObjectStackAdapter<T = unknown> implements DataSource<T> {
     private client;
     private connected;
+    private connectPromise;
     private metadataCache;
     private connectionState;
     private connectionStateListeners;
@@ -954,4 +965,4 @@ declare function createObjectStackAdapter<T = unknown>(config: {
     reconnectDelay?: number;
 }): DataSource<T>;
 
-export { type AuditEventType, type AuditLogConfig, type AuditLogEntry, AuthenticationError, type BatchProgressEvent, type BatchProgressListener, BulkOperationError, type CSPConfig, type CacheStats, type CloudDeploymentConfig, type CloudHostingConfig, type CloudMarketplaceEntry, CloudOperations, ConnectionError, type ConnectionState, type ConnectionStateEvent, type ConnectionStateListener, type ContractValidationError, type ContractValidationResult, type DataMaskingConfig, type DataMaskingRule, type EmailIntegrationConfig, type IntegrationConfig, IntegrationManager, type IntegrationProvider, type IntegrationTrigger, MetadataNotFoundError, ObjectStackAdapter, ObjectStackError, type PluginAPIContract, type PluginContract, type PluginExport, SecurityManager, type SecurityPolicy, type SlackIntegrationConfig, type StudioCanvasConfig, type StudioColorPalette, type StudioPropertyEditor, type StudioShadowPreset, type StudioThemeBuilderConfig, type StudioTypographyPreset, ValidationError, type WebhookIntegrationConfig, calculateAutoLayout, createDefaultCanvasConfig, createErrorFromResponse, createObjectStackAdapter, generateContractManifest, isErrorType, isObjectStackError, snapToGrid, validatePluginContract };
+export { type AuditEventType, type AuditLogConfig, type AuditLogEntry, AuthenticationError, type BatchProgressEvent, type BatchProgressListener, BulkOperationError, type CSPConfig, type CacheStats, type CloudDeploymentConfig, type CloudHostingConfig, type CloudMarketplaceEntry, CloudOperations, ConnectionError, type ConnectionState, type ConnectionStateEvent, type ConnectionStateListener, type ContractValidationError, type ContractValidationResult, type DataMaskingConfig, type DataMaskingRule, type EmailIntegrationConfig, type IntegrationConfig, IntegrationManager, type IntegrationProvider, type IntegrationTrigger, MetadataNotFoundError, ObjectStackAdapter, ObjectStackError, type PluginAPIContract, type PluginContract, type PluginExport, SecurityManager, type SecurityPolicy, type SlackIntegrationConfig, type StudioCanvasConfig, type StudioColorPalette, type StudioPropertyEditor, type StudioShadowPreset, type StudioThemeBuilderConfig, type StudioTypographyPreset, ValidationError, type WebhookIntegrationConfig, calculateAutoLayout, clearSharedDiscoveryCache, createDefaultCanvasConfig, createErrorFromResponse, createObjectStackAdapter, generateContractManifest, getSharedDiscovery, isErrorType, isObjectStackError, snapToGrid, validatePluginContract };

package/dist/index.d.ts

@@ -156,6 +156,8 @@ interface CacheStats {
     hits: number;
     misses: number;
     evictions: number;
+    /** Number of concurrent fetches that were coalesced onto an in-flight request. */
+    coalesced: number;
     hitRate: number;
 }
 
@@ -638,6 +640,14 @@ declare function calculateAutoLayout(items: Array<{
     y: number;
 }>;
 
+/**
+ * Fetch the server `discovery` document once per (baseUrl) and reuse the
+ * resulting Promise. Used by `ObjectStackAdapter.connect()` (and any caller
+ * that wants the discovery payload without spinning up a new client).
+ */
+declare function getSharedDiscovery(baseUrl: string, fetcher: () => Promise<unknown>): Promise<unknown>;
+/** Test/dev helper to drop the cache (e.g. on logout or origin change). */
+declare function clearSharedDiscoveryCache(): void;
 /**
  * Connection state for monitoring
  */
@@ -701,6 +711,7 @@ type BatchProgressListener = (event: BatchProgressEvent) => void;
 declare class ObjectStackAdapter<T = unknown> implements DataSource<T> {
     private client;
     private connected;
+    private connectPromise;
     private metadataCache;
     private connectionState;
     private connectionStateListeners;
@@ -954,4 +965,4 @@ declare function createObjectStackAdapter<T = unknown>(config: {
     reconnectDelay?: number;
 }): DataSource<T>;
 
-export { type AuditEventType, type AuditLogConfig, type AuditLogEntry, AuthenticationError, type BatchProgressEvent, type BatchProgressListener, BulkOperationError, type CSPConfig, type CacheStats, type CloudDeploymentConfig, type CloudHostingConfig, type CloudMarketplaceEntry, CloudOperations, ConnectionError, type ConnectionState, type ConnectionStateEvent, type ConnectionStateListener, type ContractValidationError, type ContractValidationResult, type DataMaskingConfig, type DataMaskingRule, type EmailIntegrationConfig, type IntegrationConfig, IntegrationManager, type IntegrationProvider, type IntegrationTrigger, MetadataNotFoundError, ObjectStackAdapter, ObjectStackError, type PluginAPIContract, type PluginContract, type PluginExport, SecurityManager, type SecurityPolicy, type SlackIntegrationConfig, type StudioCanvasConfig, type StudioColorPalette, type StudioPropertyEditor, type StudioShadowPreset, type StudioThemeBuilderConfig, type StudioTypographyPreset, ValidationError, type WebhookIntegrationConfig, calculateAutoLayout, createDefaultCanvasConfig, createErrorFromResponse, createObjectStackAdapter, generateContractManifest, isErrorType, isObjectStackError, snapToGrid, validatePluginContract };
+export { type AuditEventType, type AuditLogConfig, type AuditLogEntry, AuthenticationError, type BatchProgressEvent, type BatchProgressListener, BulkOperationError, type CSPConfig, type CacheStats, type CloudDeploymentConfig, type CloudHostingConfig, type CloudMarketplaceEntry, CloudOperations, ConnectionError, type ConnectionState, type ConnectionStateEvent, type ConnectionStateListener, type ContractValidationError, type ContractValidationResult, type DataMaskingConfig, type DataMaskingRule, type EmailIntegrationConfig, type IntegrationConfig, IntegrationManager, type IntegrationProvider, type IntegrationTrigger, MetadataNotFoundError, ObjectStackAdapter, ObjectStackError, type PluginAPIContract, type PluginContract, type PluginExport, SecurityManager, type SecurityPolicy, type SlackIntegrationConfig, type StudioCanvasConfig, type StudioColorPalette, type StudioPropertyEditor, type StudioShadowPreset, type StudioThemeBuilderConfig, type StudioTypographyPreset, ValidationError, type WebhookIntegrationConfig, calculateAutoLayout, clearSharedDiscoveryCache, createDefaultCanvasConfig, createErrorFromResponse, createObjectStackAdapter, generateContractManifest, getSharedDiscovery, isErrorType, isObjectStackError, snapToGrid, validatePluginContract };

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
     };
   }
@@ -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) {
@@ -1491,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.3.0",
+  "version": "3.3.2",
   "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": "^4.0.3",
-    "@object-ui/core": "3.3.0",
-    "@object-ui/types": "3.3.0"
+    "@objectstack/client": "^4.0.4",
+    "@object-ui/core": "3.3.2",
+    "@object-ui/types": "3.3.2"
   },
   "devDependencies": {
     "tsup": "^8.5.1",
-    "typescript": "^6.0.2",
-    "vitest": "^4.1.4"
+    "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/cache/MetadataCache.test.ts

@@ -410,6 +410,57 @@ describe('MetadataCache', () => {
       expect(fetcher).toHaveBeenCalledTimes(1);
     });
 
+    it('should coalesce concurrent fetches for the same key', async () => {
+      let resolveFetch: (v: { data: string }) => void = () => {};
+      const fetcher = vi.fn(
+        () =>
+          new Promise<{ data: string }>((resolve) => {
+            resolveFetch = resolve;
+          })
+      );
+
+      const p1 = cache.get('shared-key', fetcher);
+      const p2 = cache.get('shared-key', fetcher);
+      const p3 = cache.get('shared-key', fetcher);
+
+      // All three calls should share a single in-flight fetcher invocation
+      expect(fetcher).toHaveBeenCalledTimes(1);
+
+      resolveFetch({ data: 'shared' });
+      const [r1, r2, r3] = await Promise.all([p1, p2, p3]);
+
+      expect(r1).toEqual({ data: 'shared' });
+      expect(r2).toBe(r1);
+      expect(r3).toBe(r1);
+
+      const stats = cache.getStats();
+      expect(stats.coalesced).toBe(2);
+      expect(stats.misses).toBe(1);
+    });
+
+    it('should clear inflight slot after fetch rejection so retries are possible', async () => {
+      const fetcher = vi
+        .fn()
+        .mockRejectedValueOnce(new Error('boom'))
+        .mockResolvedValueOnce({ data: 'ok' });
+
+      await expect(cache.get('retry-key', fetcher)).rejects.toThrow('boom');
+      const result = await cache.get('retry-key', fetcher);
+
+      expect(result).toEqual({ data: 'ok' });
+      expect(fetcher).toHaveBeenCalledTimes(2);
+    });
+
+    it('should expose prime() to seed cache from bulk endpoints', async () => {
+      cache.prime('object:account', { name: 'account', fields: [] });
+
+      const fetcher = vi.fn(async () => ({ name: 'account', fields: [{ name: 'id' }] }));
+      const result = await cache.get('object:account', fetcher);
+
+      expect(fetcher).not.toHaveBeenCalled();
+      expect(result).toEqual({ name: 'account', fields: [] });
+    });
+
     it('should handle very large cache', async () => {
       const largeCache = new MetadataCache({ maxSize: 10000, ttl: 60000 });
       

package/src/cache/MetadataCache.ts

@@ -25,6 +25,8 @@ export interface CacheStats {
   hits: number;
   misses: number;
   evictions: number;
+  /** Number of concurrent fetches that were coalesced onto an in-flight request. */
+  coalesced: number;
   hitRate: number;
 }
 
@@ -38,9 +40,9 @@ export interface CacheStats {
  * - Async-safe operations
  * - Performance statistics tracking
  * 
- * Note: Concurrent requests for the same uncached key may result in multiple
- * fetcher calls. For production use cases requiring request deduplication,
- * consider wrapping the cache with a promise-based deduplication layer.
+ * Concurrent requests for the same uncached key are deduplicated via an
+ * internal in-flight Promise map: only the first call invokes the fetcher,
+ * and subsequent callers receive the same Promise.
  * 
  * @example
  * ```typescript
@@ -55,12 +57,14 @@ export interface CacheStats {
  */
 export class MetadataCache {
   private cache: Map<string, CachedSchema>;
+  private inflight: Map<string, Promise<unknown>>;
   private maxSize: number;
   private ttl: number;
   private stats: {
     hits: number;
     misses: number;
     evictions: number;
+    coalesced: number;
   };
 
   /**
@@ -72,12 +76,14 @@ export class MetadataCache {
    */
   constructor(options: { maxSize?: number; ttl?: number } = {}) {
     this.cache = new Map();
+    this.inflight = new Map();
     this.maxSize = options.maxSize || 100;
     this.ttl = options.ttl || 5 * 60 * 1000; // 5 minutes default
     this.stats = {
       hits: 0,
       misses: 0,
       evictions: 0,
+      coalesced: 0,
     };
   }
 
@@ -113,14 +119,34 @@ export class MetadataCache {
       }
     }
 
-    // Cache miss - fetch the data
+    // Cache miss - dedupe concurrent fetches for the same key
+    const existing = this.inflight.get(key);
+    if (existing) {
+      this.stats.coalesced++;
+      return existing as Promise<T>;
+    }
+
     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 as Promise<unknown>);
+    return promise;
+  }
 
-    // Store in cache
+  /**
+   * 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: string, data: unknown): void {
     this.set(key, data);
-
-    return data;
   }
 
   /**
@@ -178,10 +204,12 @@ export class MetadataCache {
    */
   clear(): void {
     this.cache.clear();
+    this.inflight.clear();
     this.stats = {
       hits: 0,
       misses: 0,
       evictions: 0,
+      coalesced: 0,
     };
   }
 
@@ -200,6 +228,7 @@ export class MetadataCache {
       hits: this.stats.hits,
       misses: this.stats.misses,
       evictions: this.stats.evictions,
+      coalesced: this.stats.coalesced,
       hitRate: hitRate,
     };
   }

package/src/connection.test.ts

@@ -7,7 +7,13 @@
  */
 
 import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { ObjectStackAdapter, ConnectionState, ConnectionStateEvent, BatchProgressEvent } from './index';
+import {
+  ObjectStackAdapter,
+  ConnectionState,
+  ConnectionStateEvent,
+  BatchProgressEvent,
+  clearSharedDiscoveryCache,
+} from './index';
 
 describe('Connection State Monitoring', () => {
   let adapter: ObjectStackAdapter;
@@ -100,6 +106,10 @@ describe('Batch Progress Events', () => {
 });
 
 describe('getDiscovery', () => {
+  beforeEach(() => {
+    clearSharedDiscoveryCache();
+  });
+
   it('should return discoveryInfo from the underlying client after connect', async () => {
     const mockDiscovery = {
       name: 'test-server',
@@ -110,32 +120,69 @@ describe('getDiscovery', () => {
       },
     };
 
+    const fetchImpl = vi.fn(async () =>
+      ({
+        ok: true,
+        json: async () => ({ success: true, data: mockDiscovery }),
+      }) as unknown as Response,
+    );
+
     const adapter = new ObjectStackAdapter({
       baseUrl: 'http://localhost:3000',
       autoReconnect: false,
+      fetch: fetchImpl,
     });
 
-    // Mock the underlying client's connect method and discoveryInfo property
-    const client = adapter.getClient();
-    vi.spyOn(client, 'connect').mockResolvedValue(mockDiscovery as any);
-    // Simulate what connect() does: sets discoveryInfo
-    (client as any).discoveryInfo = mockDiscovery;
+    await adapter.connect();
 
     const discovery = await adapter.getDiscovery();
     expect(discovery).toEqual(mockDiscovery);
     expect((discovery as any)?.services?.auth?.enabled).toBe(false);
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+    expect(fetchImpl.mock.calls[0][0]).toContain('/api/v1/discovery');
   });
 
   it('should return null when connection fails', async () => {
+    const fetchImpl = vi.fn(async () => {
+      throw new Error('Connection failed');
+    });
+
     const adapter = new ObjectStackAdapter({
       baseUrl: 'http://localhost:3000',
       autoReconnect: false,
+      fetch: fetchImpl as any,
     });
 
-    const client = adapter.getClient();
-    vi.spyOn(client, 'connect').mockRejectedValue(new Error('Connection failed'));
+    await expect(adapter.connect()).rejects.toThrow();
 
     const discovery = await adapter.getDiscovery();
     expect(discovery).toBeNull();
   });
+
+  it('should share a single discovery fetch across adapters with the same baseUrl', async () => {
+    const mockDiscovery = { name: 'shared', version: '1.0.0' };
+    const fetchImpl = vi.fn(async () =>
+      ({
+        ok: true,
+        json: async () => ({ success: true, data: mockDiscovery }),
+      }) as unknown as Response,
+    );
+
+    const a1 = new ObjectStackAdapter({
+      baseUrl: 'http://localhost:3000',
+      autoReconnect: false,
+      fetch: fetchImpl,
+    });
+    const a2 = new ObjectStackAdapter({
+      baseUrl: 'http://localhost:3000',
+      autoReconnect: false,
+      fetch: fetchImpl,
+    });
+
+    await Promise.all([a1.connect(), a2.connect()]);
+
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+    expect(await a1.getDiscovery()).toEqual(mockDiscovery);
+    expect(await a2.getDiscovery()).toEqual(mockDiscovery);
+  });
 });

package/src/index.ts

@@ -18,6 +18,38 @@ import {
   createErrorFromResponse,
 } from './errors';
 
+// 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
+// keying on baseUrl we collapse them to a single network round trip per origin.
+const discoveryCache = new Map<string, Promise<unknown>>();
+
+/**
+ * Fetch the server `discovery` document once per (baseUrl) and reuse the
+ * resulting Promise. Used by `ObjectStackAdapter.connect()` (and any caller
+ * that wants the discovery payload without spinning up a new client).
+ */
+export async function getSharedDiscovery(
+  baseUrl: string,
+  fetcher: () => Promise<unknown>,
+): Promise<unknown> {
+  const key = baseUrl || '<default>';
+  const cached = discoveryCache.get(key);
+  if (cached) return cached;
+  const p = fetcher().catch((err) => {
+    // Allow retry on failure
+    discoveryCache.delete(key);
+    throw err;
+  });
+  discoveryCache.set(key, p);
+  return p;
+}
+
+/** Test/dev helper to drop the cache (e.g. on logout or origin change). */
+export function clearSharedDiscoveryCache(): void {
+  discoveryCache.clear();
+}
+
 /**
  * Connection state for monitoring
  */
@@ -88,6 +120,7 @@ export type { FileUploadResult } from '@object-ui/types';
 export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
   private client: ObjectStackClient;
   private connected: boolean = false;
+  private connectPromise: Promise<void> | null = null;
   private metadataCache: MetadataCache;
   private connectionState: ConnectionState = 'disconnected';
   private connectionStateListeners: ConnectionStateListener[] = [];
@@ -127,11 +160,44 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
    * Call this before making requests or it will auto-connect on first request.
    */
   async connect(): Promise<void> {
-    if (!this.connected) {
-      this.setConnectionState('connecting');
-      
+    if (this.connected) return;
+    // Dedupe concurrent connect() calls — without this, every component
+    // that mounts on first paint can trigger an independent discovery
+    // request before the first one completes.
+    if (this.connectPromise) return this.connectPromise;
+
+    this.setConnectionState('connecting');
+    this.connectPromise = (async () => {
       try {
-        await this.client.connect();
+        // Use the module-level discovery cache so multiple adapter instances
+        // (or React StrictMode double-mounts) at the same baseUrl share a
+        // single network round trip. We inject the result into the client's
+        // private `discoveryInfo` field to avoid client.connect() re-fetching.
+        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}` }
+              : undefined,
+          });
+          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;
+        });
+
+        // Prime the underlying client's cached discovery so capability/route
+        // helpers continue to work without a redundant fetch.
+        (this.client as unknown as { discoveryInfo?: unknown }).discoveryInfo = data;
+
         this.connected = true;
         this.reconnectAttempts = 0;
         this.setConnectionState('connected');
@@ -142,17 +208,20 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
           undefined,
           { originalError: error }
         );
-        
+
         this.setConnectionState('error', connectionError);
-        
+
         // Attempt auto-reconnect if enabled
         if (this.autoReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
           await this.attemptReconnect();
         } else {
           throw connectionError;
         }
+      } finally {
+        this.connectPromise = null;
       }
-    }
+    })();
+    return this.connectPromise;
   }
 
   /**
@@ -582,9 +651,14 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
       }
     }
 
-    // Filter
-    if (params.$filter) {
-      queryParams.set('filter', JSON.stringify(params.$filter));
+    // Filter — drop empty arrays/objects so we don't send `?filter=%5B%5D`
+    if (params.$filter !== undefined && 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(/\/$/, '');
@@ -632,13 +706,19 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
       options.select = params.$select;
     }
 
-    // Filtering - convert to ObjectStack FilterNode AST format
-    if (params.$filter) {
-      if (Array.isArray(params.$filter)) {
-        // Assume active AST format if it's already an array
-        options.filters = params.$filter;
-      } else {
-        options.filters = convertFiltersToAST(params.$filter);
+    // Filtering - convert to ObjectStack FilterNode AST format. Treat empty
+    // arrays/objects as "no filter" to avoid emitting `filter=[]` over the wire.
+    if (params.$filter !== undefined && 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)) {
+          // Assume active AST format if it's already an array
+          options.filters = params.$filter;
+        } else {
+          options.filters = convertFiltersToAST(params.$filter);
+        }
       }
     }