gloomberb 0.11.2 → 0.12.0

package/src/sources/provider-router/search.test.ts

@@ -0,0 +1,191 @@
+import { describe, expect, test } from "bun:test";
+import type { DataProvider, SearchRequestContext } from "../../types/data-provider";
+import type { InstrumentSearchResult } from "../../types/instrument";
+import { ProviderRouterSearchRoutes } from "./search";
+
+function result(symbol: string, extra: Partial<InstrumentSearchResult> = {}): InstrumentSearchResult {
+  return { symbol, name: symbol, exchange: "NASDAQ", type: "EQUITY", ...extra };
+}
+
+function provider(
+  id: string,
+  items: InstrumentSearchResult[],
+  delayMs = 0,
+): DataProvider {
+  return {
+    id,
+    search: async () => {
+      if (delayMs > 0) await new Promise((resolve) => setTimeout(resolve, delayMs));
+      return items;
+    },
+  } as unknown as DataProvider;
+}
+
+function broker(
+  id: string,
+  items: InstrumentSearchResult[] | null,
+  delayMs = 0,
+) {
+  return {
+    brokerId: id,
+    brokerInstanceId: `${id}-1`,
+    brokerLabel: id,
+    instance: {},
+    broker: {
+      searchInstruments: async () => {
+        if (delayMs > 0) await new Promise((resolve) => setTimeout(resolve, delayMs));
+        if (!items) throw new Error("broker down");
+        return items;
+      },
+    },
+  };
+}
+
+function makeRoutes(options: {
+  brokers?: ReturnType<typeof broker>[];
+  providers?: DataProvider[];
+}) {
+  return new ProviderRouterSearchRoutes({
+    getBrokerCandidates: () => (options.brokers ?? []) as never,
+    providersInPriorityOrder: () => options.providers ?? [],
+    logProviderError: () => {},
+  });
+}
+
+describe("provider search racing", () => {
+  /**
+   * The reason this exists: brokers used to be awaited one at a time before the
+   * cloud was asked at all, so a single unreachable broker delayed every ticker
+   * lookup in the app by its full timeout.
+   */
+  test("a hanging broker does not delay a provider that can answer", async () => {
+    const routes = makeRoutes({
+      brokers: [broker("dead", [result("NVDA")], 5_000)],
+      providers: [provider("cloud", [result("NVDA")])],
+    });
+
+    const started = Date.now();
+    const results = await routes.search("nvidia", { preferBroker: true, interactive: true });
+
+    expect(results.map((item) => item.symbol)).toEqual(["NVDA"]);
+    // Sequentially this waited on the broker's timeout first.
+    expect(Date.now() - started).toBeLessThan(400);
+  });
+
+  test("interactive lookups abandon a stalled source in well under a second", async () => {
+    const routes = makeRoutes({ providers: [provider("slow", [result("AAPL")], 5_000)] });
+
+    const started = Date.now();
+    const results = await routes.search("apple", { interactive: true });
+
+    expect(results).toEqual([]);
+    expect(Date.now() - started).toBeLessThan(1_500);
+  });
+
+  test("a broker that answers after the cloud upgrades the row in place", async () => {
+    const partials: InstrumentSearchResult[][] = [];
+    const routes = makeRoutes({
+      brokers: [broker("ibkr", [result("NVDA", { brokerContract: { brokerId: "ibkr" } as never })], 60)],
+      providers: [provider("cloud", [result("NVDA")])],
+    });
+
+    const first = await routes.search("nvidia", {
+      preferBroker: true,
+      interactive: true,
+      onPartial: (items) => partials.push(items),
+    });
+
+    // The cloud answers immediately and that is what the caller renders.
+    expect(first.map((item) => item.symbol)).toEqual(["NVDA"]);
+    expect(first[0]?.brokerContract).toBeUndefined();
+
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    // The broker's richer copy replaces it without duplicating the symbol.
+    expect(partials).toHaveLength(1);
+    expect(partials[0]).toHaveLength(1);
+    expect(partials[0]?.[0]?.brokerContract).toBeDefined();
+  });
+
+  /**
+   * Racing everything would bill a metered fallback on every keystroke for an
+   * answer already in hand, so the second tier only runs when the first found
+   * nothing.
+   */
+  test("a fallback provider is not asked when the preferred one answers", async () => {
+    let fallbackCalls = 0;
+    const fallback = {
+      id: "fallback",
+      search: async () => {
+        fallbackCalls += 1;
+        return [result("WRONG")];
+      },
+    } as unknown as DataProvider;
+    const routes = makeRoutes({ providers: [provider("preferred", [result("NVDA")]), fallback] });
+
+    const results = await routes.search("nvidia", { interactive: true });
+
+    expect(results.map((item) => item.symbol)).toEqual(["NVDA"]);
+    expect(fallbackCalls).toBe(0);
+  });
+
+  test("a fallback provider is asked when the preferred one finds nothing", async () => {
+    let fallbackCalls = 0;
+    const fallback = {
+      id: "fallback",
+      search: async () => {
+        fallbackCalls += 1;
+        return [result("NVDA")];
+      },
+    } as unknown as DataProvider;
+    const routes = makeRoutes({ providers: [provider("preferred", []), fallback] });
+
+    const results = await routes.search("nvidia", { interactive: true });
+
+    expect(results.map((item) => item.symbol)).toEqual(["NVDA"]);
+    expect(fallbackCalls).toBe(1);
+  });
+
+  test("a failing broker leaves the provider result intact", async () => {
+    const routes = makeRoutes({
+      brokers: [broker("dead", null)],
+      providers: [provider("cloud", [result("MSFT")])],
+    });
+
+    const results = await routes.search("microsoft", { preferBroker: true });
+    expect(results.map((item) => item.symbol)).toEqual(["MSFT"]);
+  });
+
+  test("concurrent identical queries share one run", async () => {
+    let calls = 0;
+    const counting = {
+      id: "cloud",
+      search: async () => {
+        calls += 1;
+        await new Promise((resolve) => setTimeout(resolve, 30));
+        return [result("TSLA")];
+      },
+    } as unknown as DataProvider;
+    const routes = makeRoutes({ providers: [counting] });
+
+    const [a, b] = await Promise.all([routes.search("tesla"), routes.search("tesla")]);
+
+    expect(a.map((item) => item.symbol)).toEqual(["TSLA"]);
+    expect(b.map((item) => item.symbol)).toEqual(["TSLA"]);
+    expect(calls).toBe(1);
+  });
+
+  test("results returned to one caller are not mutated by a later source", async () => {
+    const routes = makeRoutes({
+      brokers: [broker("late", [result("AMD")], 50)],
+      providers: [provider("cloud", [result("NVDA")])],
+    });
+
+    const first = await routes.search("chips", { preferBroker: true } as SearchRequestContext);
+    expect(first).toHaveLength(1);
+
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    // The array handed back stays the answer that was handed back.
+    expect(first).toHaveLength(1);
+  });
+});

package/src/sources/provider-router/search.ts

@@ -7,6 +7,12 @@ const SEARCH_CACHE_TTL_MS = 30_000;
 const SEARCH_CACHE_MAX_ENTRIES = 100;
 
 const SEARCH_PROVIDER_TIMEOUT_MS = 5_000;
+/**
+ * A keystroke path cannot wait the batch budget on a source that is failing
+ * slowly. A broker whose gateway is down is the common case, and five seconds
+ * of it is indistinguishable from the feature being broken.
+ */
+const INTERACTIVE_SEARCH_TIMEOUT_MS = 800;
 
 interface BrokerSearchCandidate {
   brokerId: string;
@@ -14,9 +20,9 @@ interface BrokerSearchCandidate {
   brokerLabel: string;
 }
 
-function withSearchTimeout<T>(promise: Promise<T>): Promise<T | null> {
+function withSearchTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T | null> {
   return new Promise<T | null>((resolve) => {
-    const timer = setTimeout(() => resolve(null), SEARCH_PROVIDER_TIMEOUT_MS);
+    const timer = setTimeout(() => resolve(null), timeoutMs);
     promise.then(
       (value) => { clearTimeout(timer); resolve(value); },
       () => { clearTimeout(timer); resolve(null); },
@@ -93,72 +99,119 @@ export class ProviderRouterSearchRoutes {
     const inFlight = this.searchInFlight.get(cacheKey);
     if (inFlight) return inFlight;
 
-    const task = this.fetchSearchResults(query, context, cacheKey).finally(() => {
+    const { first, settled } = this.fetchSearchResults(query, context, cacheKey);
+    // Held until every source settles, not until the first answer, so a repeat
+    // of the same query joins this run instead of starting a second one.
+    this.searchInFlight.set(cacheKey, first);
+    void settled.finally(() => {
       this.searchInFlight.delete(cacheKey);
     });
-
-    this.searchInFlight.set(cacheKey, task);
-    return task;
+    return first;
   }
 
-  private async fetchSearchResults(
+  /**
+   * Brokers and the preferred provider run at once, rather than each being
+   * awaited in turn. The old order tried brokers one at a time before the
+   * preferred provider was asked at all, so one unreachable broker delayed
+   * every lookup by its full timeout.
+   *
+   * Fallback providers stay a fallback: they are only asked when that first
+   * round found nothing, because they are metered upstreams and racing them on
+   * every keystroke would bill for answers already in hand.
+   *
+   * Ordering still matters, it just no longer costs latency: `mergeSearchResults`
+   * keeps the richest entry per symbol, so a broker arriving after the cloud
+   * still upgrades the row, and `onPartial` hands that upgrade to the caller.
+   */
+  private fetchSearchResults(
     query: string,
     context: SearchRequestContext | undefined,
     cacheKey: string,
-  ): Promise<InstrumentSearchResult[]> {
+  ): { first: Promise<InstrumentSearchResult[]>; settled: Promise<void> } {
     const results: InstrumentSearchResult[] = [];
     const resultIndexByKey = new Map<string, number>();
+    const timeoutMs = context?.interactive
+      ? INTERACTIVE_SEARCH_TIMEOUT_MS
+      : SEARCH_PROVIDER_TIMEOUT_MS;
+
     const cacheResults = (ttl = SEARCH_CACHE_TTL_MS) => {
       this.searchCache.set(cacheKey, {
         expiresAt: Date.now() + ttl,
-        results,
+        results: [...results],
       });
       if (this.searchCache.size > SEARCH_CACHE_MAX_ENTRIES) {
         this.searchCache.delete(this.searchCache.keys().next().value!);
       }
     };
-    const push = (items: InstrumentSearchResult[]) => {
+
+    let resolveFirst!: (value: InstrumentSearchResult[]) => void;
+    const first = new Promise<InstrumentSearchResult[]>((resolve) => {
+      resolveFirst = resolve;
+    });
+    let answered = false;
+
+    const record = (items: InstrumentSearchResult[] | null) => {
+      if (!items?.length) return;
       mergeSearchResults(results, resultIndexByKey, items, context);
+      cacheResults();
+      if (!answered) {
+        answered = true;
+        resolveFirst([...results]);
+        return;
+      }
+      // The caller already has an answer, so a later, richer source is handed
+      // over rather than silently dropped into the cache.
+      context?.onPartial?.([...results]);
     };
 
-    if (context?.preferBroker !== false) {
-      for (const candidate of this.deps.getBrokerCandidates(
-        context?.brokerInstanceId,
-        context?.brokerId,
-      )) {
-        if (!candidate.broker.searchInstruments) continue;
-        try {
-          const items = await withSearchTimeout(candidate.broker.searchInstruments(query, candidate.instance));
-          if (!items) continue;
-          push(annotateBrokerSearchResults(items, candidate));
-          if (results.length > 0) {
-            cacheResults();
-            return results;
-          }
-        } catch {
-          // continue through broker candidates
-        }
+    const searchBroker = (candidate: BrokerCandidate) => (async () => {
+      try {
+        const items = await withSearchTimeout(
+          candidate.broker.searchInstruments!(query, candidate.instance),
+          timeoutMs,
+        );
+        record(items && annotateBrokerSearchResults(items, candidate));
+      } catch {
+        // A broker that cannot answer must not hold up the ones that can.
       }
-    }
+    })();
 
-    for (const provider of this.deps.providersInPriorityOrder()) {
+    const searchProvider = (provider: DataProvider) => (async () => {
       try {
-        const items = await withSearchTimeout(provider.search(query, context));
-        if (!items) continue;
-        push(items);
-        if (results.length > 0) {
-          cacheResults();
-          return results;
-        }
+        record(await withSearchTimeout(provider.search(query, context), timeoutMs));
       } catch (error) {
         if (shouldLogProviderError(error)) {
           this.deps.logProviderError(`${provider.id} failed: ${error}`);
         }
       }
-    }
+    })();
+
+    const brokers = context?.preferBroker === false
+      ? []
+      : this.deps
+        .getBrokerCandidates(context?.brokerInstanceId, context?.brokerId)
+        .filter((candidate) => candidate.broker.searchInstruments);
+    const [preferred, ...fallbacks] = this.deps.providersInPriorityOrder();
+
+    const settled = (async () => {
+      await Promise.allSettled([
+        ...brokers.map(searchBroker),
+        ...(preferred ? [searchProvider(preferred)] : []),
+      ]);
+      if (results.length === 0) {
+        await Promise.allSettled(fallbacks.map(searchProvider));
+      }
+    })().then(() => {
+      if (!answered) {
+        answered = true;
+        // Nothing matched anywhere, so hold the empty answer briefly rather
+        // than asking every source again on the next keystroke.
+        cacheResults(Math.min(SEARCH_CACHE_TTL_MS, 5_000));
+        resolveFirst([]);
+      }
+    });
 
-    cacheResults(Math.min(SEARCH_CACHE_TTL_MS, 5_000));
-    return results;
+    return { first, settled };
   }
 }
 

package/src/state/app/context/index.tsx

@@ -287,6 +287,7 @@ export function usePaneStateValue<T>(key: string, fallback: T, paneId?: string):
     const resolved = typeof nextValue === "function"
       ? (nextValue as (previousValue: T) => T)(currentValue)
       : nextValue;
+    if (Object.is(currentValue, resolved)) return;
     dispatch({ type: "UPDATE_PANE_STATE", paneId: scopedPaneId, patch: { [key]: resolved } });
   }, [dispatch, key, scopedPaneId, stateRef]);
   return [value, setValue];
@@ -309,6 +310,7 @@ export function usePaneSettingValue<T>(
     const resolved = typeof nextValue === "function"
       ? (nextValue as (previousValue: T) => T)(currentValue)
       : nextValue;
+    if (Object.is(currentValue, resolved)) return;
     const layout = setPaneSetting(currentState.config.layout, scopedPaneId, key, resolved);
     const nextConfig = syncConfigActiveLayoutState(
       { ...currentState.config, layout },

package/src/state/app/context/selector.test.tsx

@@ -1,7 +1,7 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import { act, useRef, type Dispatch } from "react";
 import { testRender } from "../../../renderers/opentui/test-utils";
-import { AppProvider, PaneInstanceProvider, useAppDispatch, useAppSelector, usePaneTicker, type AppAction } from "./index";
+import { AppProvider, PaneInstanceProvider, useAppDispatch, useAppSelector, usePaneSettingValue, usePaneTicker, type AppAction } from "./index";
 import { cloneLayout, createDefaultConfig, type AppConfig } from "../../../types/config";
 import { applyTheme } from "../../../theme/colors";
 import { useThemeId } from "../../../theme/theme-context";
@@ -11,6 +11,7 @@ const TEST_PANE_ID = "ticker-detail:test";
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
 let capturedDispatch: Dispatch<AppAction> | null = null;
+let capturedPaneSetting: ((value: string) => void) | null = null;
 
 function createTickerDetailConfig(symbol: string): AppConfig {
   const config = createDefaultConfig("/tmp/gloomberb-test");
@@ -44,6 +45,14 @@ function PaneTickerHarness() {
   return <text>{`${symbol ?? "none"}:${renderCountRef.current}`}</text>;
 }
 
+function PaneSettingHarness() {
+  const renderCountRef = useRef(0);
+  renderCountRef.current += 1;
+  const [value, setValue] = usePaneSettingValue("mode", "table");
+  capturedPaneSetting = setValue;
+  return <text>{`${value}:${renderCountRef.current}`}</text>;
+}
+
 function ThemeSelectorHarness() {
   const focusedPaneId = useAppSelector((state) => state.focusedPaneId);
   const themeId = useThemeId();
@@ -99,6 +108,7 @@ describe("pane selectors", () => {
     }
     testSetup = undefined;
     capturedDispatch = null;
+    capturedPaneSetting = null;
     applyTheme("amber");
   });
 
@@ -125,6 +135,28 @@ describe("pane selectors", () => {
     expect(testSetup.captureCharFrame()).toContain("AAPL:1");
   });
 
+  test("does not dispatch or rerender when a pane setting keeps its effective value", async () => {
+    testSetup = await testRender(
+      <AppProvider config={createTickerDetailConfig("AAPL")}>
+        <PaneInstanceProvider paneId={TEST_PANE_ID}>
+          <PaneSettingHarness />
+        </PaneInstanceProvider>
+      </AppProvider>,
+      { width: 24, height: 4 },
+    );
+
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain("table:1");
+
+    await act(() => {
+      capturedPaneSetting?.("table");
+    });
+    await testSetup.renderOnce();
+    await testSetup.renderOnce();
+
+    expect(testSetup.captureCharFrame()).toContain("table:1");
+  });
+
   test("rerenders theme hook consumers when the theme changes", async () => {
     testSetup = await testRender(
       <AppProvider config={createTickerDetailConfig("AAPL")}>

package/src/state/hooks/quote-streaming.test.tsx

@@ -10,6 +10,7 @@ import { useLiveQuoteEntries, useQuoteStreaming, useQuoteUpdates } from "./quote
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
 let bumpHarness: (() => void) | null = null;
+let toggleStreamingPriority: (() => void) | null = null;
 let togglePollingPriority: (() => void) | null = null;
 let updateLiveTargets: ((symbol: string) => void) | null = null;
 let updateFreshnessScope: ((scope: string) => void) | null = null;
@@ -27,6 +28,31 @@ function QuoteStreamingHarness() {
   return <text>{String(tick)}</text>;
 }
 
+function QuoteStreamingPriorityHarness() {
+  const [selected, setSelected] = useState(false);
+  toggleStreamingPriority = () => setSelected((current) => !current);
+  useQuoteStreaming([{
+    symbol: "AAPL",
+    exchange: "NASDAQ",
+    context: {
+      brokerId: "ibkr",
+      brokerInstanceId: "ibkr-work",
+      instrument: {
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr-work",
+        conId: 1001,
+        symbol: "AAPL",
+      },
+    },
+    route: "provider",
+    surface: selected ? "detail" : "portfolio",
+    visible: true,
+    selected,
+    weight: selected ? 100 : 10,
+  }]);
+  return <text>{selected ? "selected" : "idle"}</text>;
+}
+
 function QuotePollingHarness() {
   useQuoteUpdates([{
     symbol: "AAPL",
@@ -82,6 +108,7 @@ afterEach(async () => {
     testSetup = undefined;
   }
   bumpHarness = null;
+  toggleStreamingPriority = null;
   togglePollingPriority = null;
   updateLiveTargets = null;
   updateFreshnessScope = null;
@@ -127,6 +154,72 @@ describe("useQuoteStreaming", () => {
     expect(unsubscribeCalls).toBe(0);
   });
 
+  test("updates priorities without replacing the hook subscription", async () => {
+    type CoordinatorTargets = Parameters<MarketDataCoordinator["subscribeQuotes"]>[0];
+    const initialTargets: CoordinatorTargets[] = [];
+    const updates: CoordinatorTargets[] = [];
+    let unsubscribeCalls = 0;
+    const coordinator = {
+      subscribeQuotes: (targets: CoordinatorTargets) => {
+        initialTargets.push(targets);
+        return Object.assign(
+          () => { unsubscribeCalls += 1; },
+          { update: (nextTargets: CoordinatorTargets) => updates.push(nextTargets) },
+        );
+      },
+    };
+    setSharedMarketDataCoordinator(coordinator as unknown as MarketDataCoordinator);
+
+    testSetup = await testRender(<QuoteStreamingPriorityHarness />, {
+      width: 20,
+      height: 1,
+    });
+    await act(async () => testSetup!.renderOnce());
+
+    expect(initialTargets).toHaveLength(1);
+    expect(initialTargets[0]?.[0]).toMatchObject({
+      instrument: {
+        symbol: "AAPL",
+        exchange: "NASDAQ",
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr-work",
+        instrument: { conId: 1001, symbol: "AAPL" },
+      },
+      priority: {
+        route: "provider",
+        surface: "portfolio",
+        visible: true,
+        selected: false,
+        weight: 10,
+      },
+    });
+
+    await act(async () => {
+      toggleStreamingPriority?.();
+      await Promise.resolve();
+      await testSetup!.renderOnce();
+    });
+
+    expect(initialTargets).toHaveLength(1);
+    expect(unsubscribeCalls).toBe(0);
+    expect(updates).toHaveLength(1);
+    expect(updates[0]?.[0]).toMatchObject({
+      instrument: {
+        symbol: "AAPL",
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr-work",
+        instrument: { conId: 1001 },
+      },
+      priority: {
+        route: "provider",
+        surface: "detail",
+        visible: true,
+        selected: true,
+        weight: 100,
+      },
+    });
+  });
+
   test("uses forced polling instead of a subscription when live streaming is disabled", async () => {
     let subscribeCalls = 0;
     let loadCalls = 0;