@object-ui/data-objectstack 3.1.5 → 3.3.1

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/errors.ts

@@ -28,8 +28,8 @@ export class ObjectStackError extends Error {
     this.name = 'ObjectStackError';
     
     // Maintains proper stack trace for where error was thrown (only in V8)
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
+    if ((Error as any).captureStackTrace) {
+      (Error as any).captureStackTrace(this, this.constructor);
     }
   }
 

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);
+        }
       }
     }
 
@@ -829,20 +909,44 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
     await this.connect();
 
     try {
+      // Build measure name in the format expected by the backend analytics
+      // service (memory-analytics / cube).  For 'count' the measure key is
+      // simply 'count'; for other aggregation functions it follows the
+      // convention `${field}_${function}` (e.g. 'amount_sum').
+      const measureName = params.function === 'count'
+        ? 'count'
+        : `${params.field}_${params.function}`;
+
       const payload: Record<string, unknown> = {
-        object: resource,
-        measures: [{ field: params.field, function: params.function }],
-        dimensions: [params.groupBy],
+        cube: resource,
+        measures: [measureName],
+        // When groupBy is '_all' no dimensions are needed (single-bucket).
+        dimensions: params.groupBy && params.groupBy !== '_all' ? [params.groupBy] : [],
       };
       if (params.filter) {
         payload.filters = params.filter;
       }
 
       const data = await this.client.analytics.query(payload);
-      if (Array.isArray(data)) return data;
-      if (data?.data && Array.isArray(data.data)) return data.data;
-      if (data?.results && Array.isArray(data.results)) return data.results;
-      return [];
+      const rawRows: any[] = 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
+        : [];
+
+      // 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
+      // output format of aggregateClientSide() which always uses params.field.
+      return rawRows.map((row: any) => {
+        const mapped = { ...row };
+        if (measureName !== params.field && measureName in mapped) {
+          mapped[params.field] = mapped[measureName];
+          delete mapped[measureName];
+        }
+        return mapped;
+      });
     } catch {
       // If the analytics endpoint is not available, fall back to
       // find() + client-side aggregation