gloomberb 0.7.0 → 0.7.1

package/src/sources/gloomberb-cloud.test.ts

@@ -1,7 +1,7 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import { createGloomberbCloudCapabilities, GloomberbCloudProvider } from "./gloomberb-cloud";
 import type { NewsCapability } from "../capabilities";
-import { apiClient, type AuthUser } from "../utils/api-client";
+import { apiClient, type AuthUser, type CloudNewsPayload } from "../utils/api-client";
 
 const verifiedUser: AuthUser = {
   id: "user-1",
@@ -21,8 +21,56 @@ const originalGetCloudHolders = apiClient.getCloudHolders.bind(apiClient);
 const originalGetCloudAnalystResearch = apiClient.getCloudAnalystResearch.bind(apiClient);
 const originalGetCloudCorporateActions = apiClient.getCloudCorporateActions.bind(apiClient);
 const originalGetCloudNews = apiClient.getCloudNews.bind(apiClient);
+const originalGetCloudNewsStory = apiClient.getCloudNewsStory.bind(apiClient);
 const originalSubscribeQuotes = apiClient.subscribeQuotes.bind(apiClient);
 
+function makeCloudNewsPayload(overrides: Partial<CloudNewsPayload> = {}): CloudNewsPayload {
+  return {
+    id: "story-1",
+    headline: "Apple raises guidance",
+    summary: "Apple lifted its outlook after stronger iPhone demand.",
+    topic: "guidance",
+    topics: ["guidance"],
+    category: "guidance",
+    sentiment: "positive",
+    sectors: ["information_technology"],
+    firstPublishedAt: "2026-04-01T10:00:00.000Z",
+    lastPublishedAt: "2026-04-01T10:05:00.000Z",
+    firstSeenAt: "2026-04-01T10:00:10.000Z",
+    lastSeenAt: "2026-04-01T10:05:10.000Z",
+    primaryUrl: "https://example.com/aapl-guidance",
+    primarySource: "example-wire",
+    scores: {
+      importance: 91,
+      urgency: 74,
+      marketImpact: 88,
+      novelty: 86,
+      confidence: 95,
+    },
+    flags: {
+      breaking: true,
+      developing: false,
+      stale: false,
+    },
+    variantCount: 1,
+    sourceCount: 1,
+    sources: ["example-wire"],
+    entities: [],
+    tickerLinks: [{
+      symbol: "AAPL",
+      exchange: "XNAS",
+      canonicalTicker: "AAPL:XNAS",
+      relationType: "direct",
+      displayTier: "primary",
+      confidence: 0.98,
+      relevanceScore: 95,
+      impactScore: 93,
+      sentiment: "positive",
+    }],
+    ...overrides,
+  };
+}
+
 afterEach(() => {
   apiClient.ensureVerifiedSession = originalEnsureVerifiedSession;
   apiClient.getCloudHistory = originalGetCloudHistory;
@@ -31,6 +79,7 @@ afterEach(() => {
   apiClient.getCloudAnalystResearch = originalGetCloudAnalystResearch;
   apiClient.getCloudCorporateActions = originalGetCloudCorporateActions;
   apiClient.getCloudNews = originalGetCloudNews;
+  apiClient.getCloudNewsStory = originalGetCloudNewsStory;
   apiClient.subscribeQuotes = originalSubscribeQuotes;
 });
 
@@ -496,4 +545,40 @@ describe("GloomberbCloudProvider", () => {
       confidence: 93,
     });
   });
+
+  test("fetches story detail with ordered source items", async () => {
+    let requestedStoryId = "";
+    apiClient.getCloudNewsStory = async (storyId) => {
+      requestedStoryId = storyId;
+      return makeCloudNewsPayload({
+        id: storyId,
+        items: [{
+          id: "item-2",
+          sourceKey: "wire-b",
+          sourceName: "Wire B",
+          title: "Follow-up",
+          summary: "More details emerged.",
+          url: "https://example.com/follow-up",
+          publishedAt: "2026-04-01T10:05:00.000Z",
+          hasArticleText: true,
+        }, {
+          id: "item-1",
+          sourceKey: "wire-a",
+          sourceName: "Wire A",
+          title: "Original",
+          summary: "The first report.",
+          url: "https://example.com/original",
+          publishedAt: "2026-04-01T10:00:00.000Z",
+          hasArticleText: false,
+        }],
+      });
+    };
+
+    const source = createGloomberbCloudCapabilities().find((capability) => capability.kind === "news") as NewsCapability;
+    const story = await source.provider.fetchNewsStory?.("story-1");
+
+    expect(requestedStoryId).toBe("story-1");
+    expect(story?.items?.map((item) => item.id)).toEqual(["item-2", "item-1"]);
+    expect(story?.items?.[0]?.publishedAt).toEqual(new Date("2026-04-01T10:05:00.000Z"));
+  });
 });

package/src/sources/gloomberb-cloud.ts

@@ -5,15 +5,24 @@ import {
   type ManualChartResolution,
 } from "../components/chart/chart-resolution";
 import { assetDataProvider, newsProvider, type PluginCapability } from "../capabilities";
-import type { AssetDataProvider, MarketDataRequestContext, NewsItem, QuoteSubscriptionTarget, SearchRequestContext, SecFilingItem } from "../types/data-provider";
+import type {
+  AssetDataProvider,
+  CachedFinancialsTarget,
+  MarketDataRequestContext,
+  NewsItem,
+  QuoteBatchResult,
+  QuoteSubscriptionTarget,
+  SearchRequestContext,
+  SecFilingItem,
+  TickerFinancialsBatchResult,
+} from "../types/data-provider";
 import type { AnalystResearchData, CorporateActionsData, HolderData, OptionsChain, PricePoint, Quote, TickerFinancials } from "../types/financials";
 import type { InstrumentSearchResult } from "../types/instrument";
 import {
   apiClient,
   type CloudAnalystResearchPayload,
-  type CloudCompanyProfile,
   type CloudCorporateActionsPayload,
-  type CloudFundamentals,
+  type CloudMarketBatchItem,
   type CloudHoldersPayload,
   type CloudMarketResponse,
   type CloudNewsPayload,
@@ -103,6 +112,34 @@ function mapPricePoint(point: CloudPricePointPayload, divisor = 1): PricePoint {
   };
 }
 
+function mapCloudFinancials(financials: TickerFinancials): TickerFinancials {
+  const quote = financials.quote ? mapQuote(financials.quote as CloudQuotePayload) : undefined;
+  const divisor = quote ? resolveCurrencyUnit(quote.currency).divisor : 1;
+  return {
+    quote,
+    quoteContributions: financials.quoteContributions,
+    profile: financials.profile,
+    fundamentals: financials.fundamentals,
+    annualStatements: financials.annualStatements ?? [],
+    quarterlyStatements: financials.quarterlyStatements ?? [],
+    priceHistory: (financials.priceHistory ?? []).map((point) =>
+      point.date instanceof Date
+        ? point
+        : mapPricePoint(point as unknown as CloudPricePointPayload, divisor)
+    ),
+  };
+}
+
+function mapBatchError<T>(
+  item: CloudMarketBatchItem<T>,
+  fallbackMessage: string,
+): Error {
+  if (isEmptyCloudStatus(item.status)) {
+    return createProviderMiss(item.reasonCode ?? fallbackMessage);
+  }
+  return new Error(item.reasonCode ?? fallbackMessage);
+}
+
 function normalizeStringArray(value: unknown): string[] {
   return Array.isArray(value)
     ? value.filter((entry): entry is string => typeof entry === "string" && entry.trim().length > 0)
@@ -358,27 +395,45 @@ export class GloomberbCloudProvider implements AssetDataProvider {
   async getTickerFinancials(ticker: string, exchange = "", _context?: MarketDataRequestContext): Promise<TickerFinancials> {
     await requireVerifiedSession();
     return withCloudFallback(async () => {
-      const [quoteResponse, profileResponse, fundamentalsResponse, statementsResponse] = await Promise.all([
-        apiClient.getCloudQuote(ticker, exchange),
-        apiClient.getCloudProfile(ticker, exchange),
-        apiClient.getCloudFundamentals(ticker, exchange),
-        apiClient.getCloudStatements(ticker, exchange, "both"),
-      ]);
-      const quote = mapQuote(unwrapRequiredCloudResponse(quoteResponse, `Cloud quote is unavailable for ${ticker}`));
-      const profile = unwrapOptionalCloudResponse(profileResponse) as CloudCompanyProfile | null;
-      const fundamentals = unwrapOptionalCloudResponse(fundamentalsResponse) as CloudFundamentals | null;
-      const statements = unwrapOptionalCloudResponse(statementsResponse);
-      return {
-        quote,
-        profile: profile ?? undefined,
-        fundamentals: fundamentals ?? undefined,
-        annualStatements: statements?.annualStatements ?? [],
-        quarterlyStatements: statements?.quarterlyStatements ?? [],
-        priceHistory: [],
-      };
+      const response = await apiClient.getCloudFinancials(ticker, exchange);
+      return mapCloudFinancials(unwrapRequiredCloudResponse(response, `Cloud financials are unavailable for ${ticker}`));
     }, `Cloud financials are unavailable for ${ticker}`);
   }
 
+  async getTickerFinancialsBatch(
+    targets: CachedFinancialsTarget[],
+    options: { forceRefresh?: boolean } = {},
+  ): Promise<TickerFinancialsBatchResult[]> {
+    await requireVerifiedSession();
+    return withCloudFallback(async () => {
+      const response = await apiClient.getCloudFinancialsBatch(
+        targets.map((target) => ({
+          symbol: target.symbol,
+          exchange: target.exchange,
+        })),
+        options.forceRefresh ? "refresh" : "cache-first",
+      );
+      const payload = unwrapRequiredCloudResponse(response, "Cloud financials are unavailable");
+      return payload.items.map((item, index) => {
+        const target = targets[index] ?? {
+          symbol: item.symbol,
+          exchange: item.exchange,
+        };
+        if ((item.status === "success" || item.status === "partial") && item.data) {
+          return {
+            target,
+            financials: mapCloudFinancials(item.data),
+          };
+        }
+        return {
+          target,
+          financials: null,
+          error: mapBatchError(item, `Cloud financials are unavailable for ${target.symbol}`),
+        };
+      });
+    }, "Cloud financials are unavailable");
+  }
+
   async getQuote(ticker: string, exchange = "", _context?: MarketDataRequestContext): Promise<Quote> {
     await requireVerifiedSession();
     return withCloudFallback(
@@ -390,6 +445,40 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     );
   }
 
+  async getQuotesBatch(
+    targets: QuoteSubscriptionTarget[],
+    options: { forceRefresh?: boolean } = {},
+  ): Promise<QuoteBatchResult[]> {
+    await requireVerifiedSession();
+    return withCloudFallback(async () => {
+      const response = await apiClient.getCloudQuotesBatch(
+        targets.map((target) => ({
+          symbol: target.symbol,
+          exchange: target.exchange,
+        })),
+        options.forceRefresh ? "refresh" : "cache-first",
+      );
+      const payload = unwrapRequiredCloudResponse(response, "Cloud quotes are unavailable");
+      return payload.items.map((item, index) => {
+        const target = targets[index] ?? {
+          symbol: item.symbol,
+          exchange: item.exchange,
+        };
+        if ((item.status === "success" || item.status === "partial") && item.data) {
+          return {
+            target,
+            quote: mapQuote(item.data),
+          };
+        }
+        return {
+          target,
+          quote: null,
+          error: mapBatchError(item, `Cloud quotes are unavailable for ${target.symbol}`),
+        };
+      });
+    }, "Cloud quotes are unavailable");
+  }
+
   async getExchangeRate(fromCurrency: string): Promise<number> {
     await requireVerifiedSession();
     const response = await apiClient.getCloudExchangeRate(fromCurrency);
@@ -575,6 +664,13 @@ export function createGloomberbCloudCapabilities(provider = createGloomberbCloud
           );
           return response.items.map((item) => mapCloudNewsArticle(item, query.ticker));
         },
+        async fetchNewsStory(storyId: string): Promise<NewsArticle | null> {
+          const story = await withCloudFallback(
+            () => apiClient.getCloudNewsStory(storyId),
+            "Cloud news story is unavailable",
+          );
+          return mapCloudNewsArticle(story);
+        },
       },
     }),
   ];

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

@@ -195,6 +195,128 @@ describe("AssetDataRouter", () => {
     expect(holders.holders[0]?.name).toBe("Vanguard Group Inc");
   });
 
+  test("falls back to later analyst providers when rating targets are missing", async () => {
+    const cloudProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "cloud",
+      name: "Cloud",
+      priority: 100,
+      async getAnalystResearch(symbol) {
+        return {
+          providerId: "cloud",
+          symbol,
+          ratings: [{ date: "2026-05-01", firm: "Cloud Firm", action: "Raises", current: "Buy", prior: "Buy" }],
+          recommendations: [],
+          earningsEstimates: [],
+          revenueEstimates: [],
+        };
+      },
+    };
+    const yahooProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "yahoo",
+      name: "Yahoo",
+      priority: 1000,
+      async getAnalystResearch(symbol) {
+        return {
+          providerId: "yahoo",
+          symbol,
+          ratings: [{
+            date: "2026-05-01",
+            firm: "Yahoo Firm",
+            action: "Raises",
+            current: "Buy",
+            prior: "Buy",
+            currentPriceTarget: 680,
+            priorPriceTarget: 595,
+          }],
+          recommendations: [],
+          earningsEstimates: [],
+          revenueEstimates: [],
+        };
+      },
+    };
+
+    const router = new AssetDataRouter(yahooProvider, [cloudProvider]);
+    const research = await router.getAnalystResearch("AAPL", "NASDAQ");
+
+    expect(research.providerId).toBe("yahoo");
+    expect(research.ratings[0]?.currentPriceTarget).toBe(680);
+    expect(research.ratings[0]?.priorPriceTarget).toBe(595);
+  });
+
+  test("prefers cached analyst records with rating targets", async () => {
+    const dbPath = createTempDbPath("cached-analyst-targets");
+    const persistence = new AppPersistence(dbPath);
+    const cloudProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "cloud",
+      name: "Cloud",
+      priority: 100,
+      async getAnalystResearch(symbol) {
+        return {
+          providerId: "cloud",
+          symbol,
+          ratings: [{ date: "2026-05-01", firm: "Cloud Firm", action: "Raises", current: "Buy", prior: "Buy" }],
+          recommendations: [],
+          earningsEstimates: [],
+          revenueEstimates: [],
+        };
+      },
+    };
+    const yahooProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "yahoo",
+      name: "Yahoo",
+      priority: 1000,
+      async getAnalystResearch(symbol) {
+        return {
+          providerId: "yahoo",
+          symbol,
+          ratings: [{
+            date: "2026-05-01",
+            firm: "Yahoo Firm",
+            action: "Raises",
+            current: "Buy",
+            prior: "Buy",
+            currentPriceTarget: 680,
+            priorPriceTarget: 595,
+          }],
+          recommendations: [],
+          earningsEstimates: [],
+          revenueEstimates: [],
+        };
+      },
+    };
+    const unavailableProvider = (id: string, priority: number): DataProvider => ({
+      ...fallbackProvider,
+      id,
+      name: id,
+      priority,
+      async getAnalystResearch() {
+        throw new Error(`${id} should not be fetched`);
+      },
+    });
+
+    try {
+      const seedRouter = new AssetDataRouter(yahooProvider, [cloudProvider], persistence.resources);
+      await seedRouter.getAnalystResearch("AAPL", "NASDAQ");
+
+      const cachedRouter = new AssetDataRouter(
+        unavailableProvider("yahoo", 1000),
+        [unavailableProvider("cloud", 100)],
+        persistence.resources,
+      );
+      const research = await cachedRouter.getAnalystResearch("AAPL", "NASDAQ");
+
+      expect(research.providerId).toBe("yahoo");
+      expect(research.ratings[0]?.currentPriceTarget).toBe(680);
+      expect(research.ratings[0]?.priorPriceTarget).toBe(595);
+    } finally {
+      persistence.close();
+    }
+  });
+
   test("prefers broker quotes over fallback quotes", async () => {
     const router = new AssetDataRouter(fallbackProvider);
     const broker: BrokerAdapter = {