gloomberb 0.3.7 → 0.4.0

package/src/sources/gloomberb-cloud.ts

@@ -1,4 +1,9 @@
 import type { TimeRange } from "../components/chart/chart-types";
+import {
+  normalizeChartResolutionSupport,
+  type ChartResolutionSupport,
+  type ManualChartResolution,
+} from "../components/chart/chart-resolution";
 import type { DataProvider, MarketDataRequestContext, NewsItem, QuoteSubscriptionTarget, SearchRequestContext, SecFilingItem } from "../types/data-provider";
 import type { OptionsChain, PricePoint, Quote, TickerFinancials } from "../types/financials";
 import type { InstrumentSearchResult } from "../types/instrument";
@@ -14,6 +19,17 @@ import { normalizePriceValueByDivisor, resolveCurrencyUnit } from "../utils/curr
 import { createProviderMiss } from "./provider-errors";
 
 const providerId = "gloomberb-cloud" as const;
+const CLOUD_RESOLUTION_SUPPORT = normalizeChartResolutionSupport([
+  { resolution: "1m", maxRange: "1W" },
+  { resolution: "5m", maxRange: "1M" },
+  { resolution: "15m", maxRange: "3M" },
+  { resolution: "30m", maxRange: "6M" },
+  { resolution: "45m", maxRange: "6M" },
+  { resolution: "1h", maxRange: "1Y" },
+  { resolution: "1d", maxRange: "ALL" },
+  { resolution: "1wk", maxRange: "ALL" },
+  { resolution: "1mo", maxRange: "ALL" },
+]);
 const CLOUD_PROVIDER_MISS_PATTERNS = [
   /data not found/i,
   /symbol.*missing or invalid/i,
@@ -39,6 +55,8 @@ async function withCloudFallback<T>(load: () => Promise<T>, message: string): Pr
 
 function mapQuote(quote: CloudQuotePayload): Quote {
   const { currency, divisor } = resolveCurrencyUnit(quote.currency);
+  const listingExchangeName = quote.listingExchangeName ?? quote.exchangeName;
+  const listingExchangeFullName = quote.listingExchangeFullName ?? quote.fullExchangeName ?? listingExchangeName;
   return {
     ...quote,
     currency: currency || quote.currency,
@@ -57,6 +75,10 @@ function mapQuote(quote: CloudQuotePayload): Quote {
     preMarketChange: normalizePriceValueByDivisor(quote.preMarketChange, divisor),
     postMarketPrice: normalizePriceValueByDivisor(quote.postMarketPrice, divisor),
     postMarketChange: normalizePriceValueByDivisor(quote.postMarketChange, divisor),
+    listingExchangeName,
+    listingExchangeFullName,
+    exchangeName: listingExchangeName,
+    fullExchangeName: listingExchangeFullName,
     providerId,
   };
 }
@@ -92,7 +114,7 @@ function toCloudInterval(interval: string): string {
       return "45min";
     case "1d":
       return "1day";
-    case "1w":
+    case "1wk":
       return "1week";
     case "1mo":
       return "1month";
@@ -118,12 +140,45 @@ function formatCloudDateTime(date: Date, includeTime: boolean): string {
   return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
 }
 
+function getRangeStartDate(range: TimeRange, endDate = new Date()): Date {
+  const startDate = new Date(endDate);
+  switch (range) {
+    case "1D":
+      startDate.setDate(startDate.getDate() - 1);
+      break;
+    case "1W":
+      startDate.setDate(startDate.getDate() - 7);
+      break;
+    case "1M":
+      startDate.setMonth(startDate.getMonth() - 1);
+      break;
+    case "3M":
+      startDate.setMonth(startDate.getMonth() - 3);
+      break;
+    case "6M":
+      startDate.setMonth(startDate.getMonth() - 6);
+      break;
+    case "1Y":
+      startDate.setFullYear(startDate.getFullYear() - 1);
+      break;
+    case "5Y":
+      startDate.setFullYear(startDate.getFullYear() - 5);
+      break;
+    case "ALL":
+      startDate.setFullYear(startDate.getFullYear() - 20);
+      break;
+  }
+  return startDate;
+}
+
 function toHistoryRequest(range: TimeRange): {
   interval: string;
   outputsize: number;
   rangeKey: TimeRange;
 } {
   switch (range) {
+    case "1D":
+      return { interval: "5min", outputsize: 24 * 12, rangeKey: range };
     case "1W":
       return { interval: "1h", outputsize: 7 * 24, rangeKey: range };
     case "1M":
@@ -179,6 +234,14 @@ export class GloomberbCloudProvider implements DataProvider {
   readonly name = "Gloomberb Cloud";
   readonly priority = 100;
 
+  getChartResolutionSupport(): ChartResolutionSupport[] {
+    return CLOUD_RESOLUTION_SUPPORT;
+  }
+
+  getChartResolutionCapabilities(): ManualChartResolution[] {
+    return CLOUD_RESOLUTION_SUPPORT.map((entry) => entry.resolution);
+  }
+
   async canProvide(): Promise<boolean> {
     return !!(await apiClient.ensureVerifiedSession());
   }
@@ -260,6 +323,31 @@ export class GloomberbCloudProvider implements DataProvider {
       .map((point) => mapPricePoint(point, divisor));
   }
 
+  async getPriceHistoryForResolution(
+    ticker: string,
+    exchange: string,
+    bufferRange: TimeRange,
+    resolution: ManualChartResolution,
+    _context?: MarketDataRequestContext,
+  ): Promise<PricePoint[]> {
+    await requireVerifiedSession();
+    const interval = toCloudInterval(resolution);
+    const endDate = new Date();
+    const startDate = getRangeStartDate(bufferRange, endDate);
+    const includeTime = /(min|h)$/i.test(interval);
+    const response = await withCloudFallback(
+      () => apiClient.getCloudHistory(ticker, exchange, {
+        interval,
+        startDate: formatCloudDateTime(startDate, includeTime),
+        endDate: formatCloudDateTime(endDate, includeTime),
+      }),
+      `Cloud chart data is unavailable for ${ticker}`,
+    );
+    const { divisor } = resolveCurrencyUnit(response.providerMeta?.currency);
+    return unwrapRequiredCloudResponse(response, `Cloud chart data is unavailable for ${ticker}`)
+      .map((point) => mapPricePoint(point, divisor));
+  }
+
   async getDetailedPriceHistory(
     ticker: string,
     exchange: string,

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

@@ -632,7 +632,7 @@ describe("ProviderRouter", () => {
     persistence.close();
   });
 
-  test("prefers fallback price data when broker and provider differ by a 100x unit mismatch", async () => {
+  test("keeps broker price authority when a fallback quote is off by a likely 100x unit mismatch", async () => {
     const router = new ProviderRouter({
       ...fallbackProvider,
       async getTickerFinancials() {
@@ -642,11 +642,13 @@ describe("ProviderRouter", () => {
           priceHistory: [{ date: new Date("2026-03-28T00:00:00Z"), close: 0.245 }],
           quote: {
             symbol: "IQE.L",
+            providerId: "yahoo",
             price: 0.245,
             currency: "GBP",
             change: -0.021,
             changePercent: -7.89,
             lastUpdated: Date.now(),
+            dataSource: "yahoo",
           },
           fundamentals: { revenue: 1000 },
         };
@@ -669,11 +671,13 @@ describe("ProviderRouter", () => {
           priceHistory: [{ date: new Date("2026-03-28T00:00:00Z"), close: 24.5 }],
           quote: {
             symbol: "IQE",
+            providerId: "ibkr",
             price: 24.5,
             currency: "GBP",
             change: -2.1,
             changePercent: -7.89,
             lastUpdated: Date.now(),
+            dataSource: "live",
           },
           fundamentals: { netIncome: 200 },
         };
@@ -718,7 +722,8 @@ describe("ProviderRouter", () => {
       brokerInstanceId: "ibkr-work",
     });
 
-    expect(merged.quote?.price).toBe(0.245);
+    expect(merged.quote?.price).toBe(24.5);
+    expect(merged.quote?.provenance?.rejectedPriceProviders).toContain("yahoo");
     expect(merged.priceHistory[0]?.close).toBe(0.245);
     expect(merged.fundamentals?.netIncome).toBe(200);
   });
@@ -1071,11 +1076,13 @@ describe("ProviderRouter", () => {
           priceHistory: [],
           quote: {
             symbol: "IQE.L",
+            providerId: "yahoo",
             price: 0.245,
             currency: "GBP",
             change: 0,
             changePercent: 0,
             lastUpdated: Date.now(),
+            dataSource: "yahoo",
           },
         };
       },
@@ -1100,11 +1107,13 @@ describe("ProviderRouter", () => {
           priceHistory: [],
           quote: {
             symbol: "IQE",
+            providerId: "ibkr",
             price: 24.5,
             currency: "GBP",
             change: 0,
             changePercent: 0,
             lastUpdated: Date.now(),
+            dataSource: "live",
           },
         };
       },
@@ -1157,7 +1166,7 @@ describe("ProviderRouter", () => {
       brokerId: "ibkr",
       brokerInstanceId: "ibkr-live",
     });
-    expect(live.quote?.price).toBe(0.245);
+    expect(live.quote?.price).toBe(24.5);
 
     const flex = await router.getTickerFinancials("IQE", "LSE", {
       brokerId: "ibkr",
@@ -1281,6 +1290,209 @@ describe("ProviderRouter", () => {
     persistence.close();
   });
 
+  test("drops stale cached cloud quotes while preserving cached cloud fundamentals", () => {
+    const dbPath = createTempDbPath("stale-cloud-cached-financials");
+    const persistence = new AppPersistence(dbPath);
+    const now = Date.parse("2026-04-08T10:55:00Z");
+
+    persistence.resources.set(
+      {
+        namespace: "market",
+        kind: "financials",
+        entityKey: "HY9H",
+        variantKey: "exchange=FWB2",
+        sourceKey: "provider:gloomberb-cloud",
+      },
+      {
+        annualStatements: [],
+        quarterlyStatements: [],
+        priceHistory: [],
+        quote: {
+          symbol: "HY9H",
+          price: 528,
+          currency: "EUR",
+          change: 28,
+          changePercent: 5.6,
+          lastUpdated: Date.parse("2026-04-07T19:55:00Z"),
+          marketState: "REGULAR",
+          exchangeName: "FWB2",
+          listingExchangeName: "FWB2",
+          providerId: "gloomberb-cloud",
+          dataSource: "delayed",
+        },
+        fundamentals: {
+          revenue: 1234,
+        },
+        profile: {
+          description: "Cloud profile",
+        },
+      },
+      {
+        cachePolicy: { staleMs: 60_000, expireMs: 60_000 },
+        fetchedAt: now,
+      },
+    );
+    persistence.resources.set(
+      {
+        namespace: "market",
+        kind: "financials",
+        entityKey: "HY9H",
+        variantKey: "exchange=FWB2",
+        sourceKey: "provider:yahoo",
+      },
+      {
+        annualStatements: [],
+        quarterlyStatements: [],
+        priceHistory: [],
+        quote: {
+          symbol: "HY9H.F",
+          price: 596,
+          currency: "EUR",
+          change: 68,
+          changePercent: 12.88,
+          lastUpdated: now,
+          marketState: "REGULAR",
+          exchangeName: "FWB2",
+          listingExchangeName: "FWB2",
+          providerId: "yahoo",
+          dataSource: "yahoo",
+        },
+      },
+      {
+        cachePolicy: { staleMs: 60_000, expireMs: 60_000 },
+        fetchedAt: now,
+      },
+    );
+
+    const router = new ProviderRouter({
+      ...fallbackProvider,
+      id: "yahoo",
+      name: "Yahoo",
+      async getTickerFinancials() {
+        throw new Error("should not fetch financials");
+      },
+    }, [{
+      ...fallbackProvider,
+      id: "gloomberb-cloud",
+      name: "Cloud",
+      priority: 100,
+      async getTickerFinancials() {
+        throw new Error("should not fetch financials");
+      },
+    }], persistence.resources);
+
+    const cached = router.getCachedFinancialsForTargets([{
+      symbol: "HY9H",
+      exchange: "FWB2",
+    }], { allowExpired: true });
+
+    expect(cached.get("HY9H")?.quote?.providerId).toBe("yahoo");
+    expect(cached.get("HY9H")?.quote?.price).toBe(596);
+    expect(cached.get("HY9H")?.fundamentals?.revenue).toBe(1234);
+    expect(cached.get("HY9H")?.profile?.description).toBe("Cloud profile");
+
+    persistence.close();
+  });
+
+  test("drops cached premarket cloud quotes that lack an active-session price", () => {
+    const dbPath = createTempDbPath("stale-cloud-premarket-cache");
+    const persistence = new AppPersistence(dbPath);
+    const now = Date.parse("2026-04-08T10:55:00Z");
+
+    persistence.resources.set(
+      {
+        namespace: "market",
+        kind: "financials",
+        entityKey: "AMD",
+        variantKey: "exchange=NASDAQ",
+        sourceKey: "provider:gloomberb-cloud",
+      },
+      {
+        annualStatements: [],
+        quarterlyStatements: [],
+        priceHistory: [],
+        quote: {
+          symbol: "AMD",
+          price: 221.53,
+          currency: "USD",
+          change: 1.35,
+          changePercent: 0.61,
+          lastUpdated: now,
+          marketState: "PRE",
+          exchangeName: "NASDAQ",
+          listingExchangeName: "NASDAQ",
+          providerId: "gloomberb-cloud",
+          dataSource: "delayed",
+        },
+      },
+      {
+        cachePolicy: { staleMs: 60_000, expireMs: 60_000 },
+        fetchedAt: now,
+      },
+    );
+    persistence.resources.set(
+      {
+        namespace: "market",
+        kind: "financials",
+        entityKey: "AMD",
+        variantKey: "exchange=NASDAQ",
+        sourceKey: "provider:yahoo",
+      },
+      {
+        annualStatements: [],
+        quarterlyStatements: [],
+        priceHistory: [],
+        quote: {
+          symbol: "AMD",
+          price: 221.53,
+          currency: "USD",
+          change: 1.35,
+          changePercent: 0.61,
+          lastUpdated: now,
+          marketState: "PRE",
+          preMarketPrice: 231,
+          preMarketChange: 9.47,
+          preMarketChangePercent: 4.27,
+          exchangeName: "NASDAQ",
+          listingExchangeName: "NASDAQ",
+          providerId: "yahoo",
+          dataSource: "yahoo",
+        },
+      },
+      {
+        cachePolicy: { staleMs: 60_000, expireMs: 60_000 },
+        fetchedAt: now,
+      },
+    );
+
+    const router = new ProviderRouter({
+      ...fallbackProvider,
+      id: "yahoo",
+      name: "Yahoo",
+      async getTickerFinancials() {
+        throw new Error("should not fetch financials");
+      },
+    }, [{
+      ...fallbackProvider,
+      id: "gloomberb-cloud",
+      name: "Cloud",
+      priority: 100,
+      async getTickerFinancials() {
+        throw new Error("should not fetch financials");
+      },
+    }], persistence.resources);
+
+    const cached = router.getCachedFinancialsForTargets([{
+      symbol: "AMD",
+      exchange: "NASDAQ",
+    }], { allowExpired: true });
+
+    expect(cached.get("AMD")?.quote?.providerId).toBe("yahoo");
+    expect(cached.get("AMD")?.quote?.preMarketPrice).toBe(231);
+
+    persistence.close();
+  });
+
   test("does not log expected provider misses for missing chart data", async () => {
     const noisyProvider: DataProvider = {
       ...fallbackProvider,
@@ -1485,6 +1697,56 @@ describe("ProviderRouter", () => {
     persistence.close();
   });
 
+  test("falls back to later providers for fixed-resolution chart history", async () => {
+    const cloudProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "cloud",
+      name: "Cloud",
+      priority: 100,
+      async getPriceHistoryForResolution() {
+        return [];
+      },
+    };
+    const yahooProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "yahoo",
+      name: "Yahoo",
+      priority: 1000,
+      async getPriceHistoryForResolution() {
+        return [{ date: new Date("2026-03-28T00:00:00Z"), close: 102 }];
+      },
+    };
+
+    const router = new ProviderRouter(yahooProvider, [cloudProvider]);
+    const history = await router.getPriceHistoryForResolution("AAPL", "NASDAQ", "1Y", "1d");
+
+    expect(history[0]?.close).toBe(102);
+  });
+
+  test("returns normalized manual chart resolution capabilities", async () => {
+    const cloudProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "cloud",
+      name: "Cloud",
+      priority: 100,
+      async getChartResolutionCapabilities() {
+        return [];
+      },
+    };
+    const yahooProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "yahoo",
+      name: "Yahoo",
+      priority: 1000,
+      async getChartResolutionCapabilities() {
+        return ["1wk", "auto", "1d", "bogus"];
+      },
+    };
+
+    const router = new ProviderRouter(yahooProvider, [cloudProvider]);
+    expect(await router.getChartResolutionCapabilities("AAPL", "NASDAQ")).toEqual(["1d", "1wk"]);
+  });
+
   test("falls back to later providers when detailed chart history is empty", async () => {
     const cloudProvider: DataProvider = {
       ...fallbackProvider,