gloomberb 0.10.1 → 0.10.2

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

@@ -1,15 +1,18 @@
-import type { MarketDataRequestContext } from "../../types/data-provider";
+import type { BrokerCandidate } from "./brokers";
+import { withBrokerTimeout } from "./brokers";
+import type { DataProvider, MarketDataRequestContext } from "../../types/data-provider";
 import type { PricePoint } from "../../types/financials";
-import type { TimeRange } from "../../components/chart/core/types";
+import type { TimeRange } from "../../time-series/range";
 import {
   isIntradayResolution,
   normalizeChartResolutionSupport,
   type ChartResolutionSupport,
   type ManualChartResolution,
-} from "../../components/chart/core/resolution";
+} from "../../time-series/resolution";
 import { canonicalExchange } from "../../utils/exchanges";
 import { resolvePriceHistoryCurrencyUnit } from "../../utils/currency-units";
 import { isPriceHistoryStaleForCurrentWindow, normalizePriceHistory } from "../../utils/price-history";
+import { shouldLogProviderError } from "../provider-errors";
 import {
   buildVariantKey,
   compactDate,
@@ -17,53 +20,105 @@ import {
   isIntradayRange,
   isStaleIntradayHistory,
   selectCachedArrayResource,
+  type ProviderRouterCachePolicyKey,
 } from "./cache";
-import { shouldLogProviderError } from "../provider-errors";
-import { withBrokerTimeout } from "./brokers";
 import type { ProviderRouterCoreDeps, SourceResult } from "./route-types";
+import { makeRouterRequestIdentity, type RouterRequestIdentity } from "./routing";
+
+type PriceHistoryCachePolicyKey = Extract<
+  ProviderRouterCachePolicyKey,
+  "priceHistoryIntraday" | "priceHistoryDaily"
+>;
+const PRICE_HISTORY_CACHE_VERSION = 3;
+
+interface HistoryRequestDescriptor {
+  identity: RouterRequestIdentity;
+  cacheVariantKeys: string[];
+  context?: MarketDataRequestContext;
+  cachePolicyKey: PriceHistoryCachePolicyKey;
+  missingProviderError?: string;
+  isCachedValueStale(value: PricePoint[]): boolean;
+  isFetchedValueStale(value: PricePoint[]): boolean;
+  fetchBroker(candidate: BrokerCandidate): Promise<PricePoint[] | null>;
+  fetchProvider(provider: DataProvider): Promise<PricePoint[] | null>;
+}
 
-function buildPriceHistoryVariantKey(
+function priceHistoryVariantParts(
   parts: Array<[string, string | number | undefined | null]>,
   exchange: string,
-): string {
+): Array<[string, string | number | undefined | null]> {
   const unit = resolvePriceHistoryCurrencyUnit(null, exchange);
-  const unitPart: Array<[string, string]> = unit.divisor === 1 ? [] : [["unit", unit.currency]];
-  return buildVariantKey([...parts, ...unitPart]);
+  const versionedParts: Array<[string, string | number | undefined | null]> = [
+    ...parts,
+    ["version", PRICE_HISTORY_CACHE_VERSION],
+  ];
+  return unit.divisor === 1
+    ? versionedParts
+    : [...versionedParts, ["unit", unit.currency]];
+}
+
+function makeHistoryRequestIdentity(
+  deps: Pick<ProviderRouterCoreDeps, "getEntityKey">,
+  input: {
+    kind: string;
+    ticker: string;
+    exchange: string;
+    context?: MarketDataRequestContext;
+    variantParts: Array<[string, string | number | undefined | null]>;
+    fallbackVariantParts: Array<[string, string | number | undefined | null]>;
+  },
+): Pick<HistoryRequestDescriptor, "identity" | "cacheVariantKeys"> {
+  const identity = makeRouterRequestIdentity(deps, {
+    kind: input.kind,
+    ticker: input.ticker,
+    context: input.context,
+    variantParts: priceHistoryVariantParts(input.variantParts, input.exchange),
+  });
+  return {
+    identity,
+    cacheVariantKeys: [
+      identity.variantKey,
+      buildVariantKey(priceHistoryVariantParts(input.fallbackVariantParts, input.exchange)),
+    ],
+  };
 }
 
 export class ProviderRouterHistoryRoutes {
   constructor(private readonly deps: ProviderRouterCoreDeps) {}
 
-  async getPriceHistory(ticker: string, exchange: string, range: TimeRange, context?: MarketDataRequestContext): Promise<PricePoint[]> {
-    const entityKey = this.deps.getEntityKey(ticker, context?.instrument);
-    const variantKeys = [
-      buildPriceHistoryVariantKey([["exchange", canonicalExchange(exchange)], ["range", range]], exchange),
-      buildPriceHistoryVariantKey([["range", range]], exchange),
-    ];
-    const sourceKeys = [
-      ...this.deps.getBrokerCandidatesForContext(context, false).map((candidate) => this.deps.brokerSourceKey(candidate)),
-      ...this.deps.getProviderSourceKeys(),
-    ];
-    const cached = selectCachedArrayResource<PricePoint>(this.deps.resources, "price-history", entityKey, variantKeys, sourceKeys, false);
-    const cachedValue = cached ? normalizePriceHistory(cached.value) : [];
-    const cachedHistoryStale = isStaleIntradayHistory(cachedValue, isIntradayRange(range), exchange);
-    const forceRefresh = context?.cacheMode === "refresh";
-    if (cachedValue.length > 0 && !forceRefresh && cached && !cached.stale && !cachedHistoryStale) {
-      return cachedValue;
-    }
-
-    const brokerHistory = await withBrokerTimeout(this.fetchBrokerPriceHistory(ticker, exchange, range, context));
-    if (brokerHistory && brokerHistory.value.length > 0) return brokerHistory.value;
-
-    const providerHistory = await this.fetchProviderPriceHistory(ticker, exchange, range, context);
-    if (providerHistory && providerHistory.value.length > 0) {
-      return providerHistory.value;
-    }
-    if (cachedValue.length > 0 && !cachedHistoryStale) return cachedValue;
-    if (!providerHistory) {
-      throw new Error(`No history provider available for ${ticker}`);
-    }
-    return providerHistory.value;
+  async getPriceHistory(
+    ticker: string,
+    exchange: string,
+    range: TimeRange,
+    context?: MarketDataRequestContext,
+  ): Promise<PricePoint[]> {
+    const identity = makeHistoryRequestIdentity(this.deps, {
+      kind: "price-history",
+      ticker,
+      exchange,
+      context,
+      variantParts: [["exchange", canonicalExchange(exchange)], ["range", range]],
+      fallbackVariantParts: [["range", range]],
+    });
+    const intraday = isIntradayRange(range);
+    return this.executeHistoryRequest({
+      ...identity,
+      context,
+      cachePolicyKey: intraday ? "priceHistoryIntraday" : "priceHistoryDaily",
+      missingProviderError: `No history provider available for ${ticker}`,
+      isCachedValueStale: (value) => isStaleIntradayHistory(value, intraday, exchange),
+      isFetchedValueStale: (value) => isStaleIntradayHistory(value, intraday, exchange),
+      fetchBroker: async (candidate) => candidate.broker.getPriceHistory
+        ? candidate.broker.getPriceHistory(
+          ticker,
+          candidate.instance,
+          exchange,
+          range,
+          context?.instrument ?? null,
+        )
+        : null,
+      fetchProvider: (provider) => provider.getPriceHistory(ticker, exchange, range, context),
+    });
   }
 
   async getPriceHistoryForResolution(
@@ -73,35 +128,40 @@ export class ProviderRouterHistoryRoutes {
     resolution: ManualChartResolution,
     context?: MarketDataRequestContext,
   ): Promise<PricePoint[]> {
-    const entityKey = this.deps.getEntityKey(ticker, context?.instrument);
-    const variantKeys = [
-      buildPriceHistoryVariantKey([["exchange", canonicalExchange(exchange)], ["range", bufferRange], ["resolution", resolution]], exchange),
-      buildPriceHistoryVariantKey([["range", bufferRange], ["resolution", resolution]], exchange),
-    ];
-    const sourceKeys = [
-      ...this.deps.getBrokerCandidatesForContext(context, false).map((candidate) => this.deps.brokerSourceKey(candidate)),
-      ...this.deps.getProviderSourceKeys(),
-    ];
-    const cached = selectCachedArrayResource<PricePoint>(this.deps.resources, "price-history", entityKey, variantKeys, sourceKeys, false);
-    const cachedValue = cached ? normalizePriceHistory(cached.value) : [];
-    const cachedHistoryStale = isStaleIntradayHistory(cachedValue, isIntradayResolution(resolution), exchange);
-    const forceRefresh = context?.cacheMode === "refresh";
-    if (cachedValue.length > 0 && !forceRefresh && cached && !cached.stale && !cachedHistoryStale) {
-      return cachedValue;
-    }
-
-    const brokerHistory = await withBrokerTimeout(this.fetchBrokerPriceHistoryForResolution(ticker, exchange, bufferRange, resolution, context));
-    if (brokerHistory && brokerHistory.value.length > 0) return brokerHistory.value;
-
-    const providerHistory = await this.fetchProviderPriceHistoryForResolution(ticker, exchange, bufferRange, resolution, context);
-    if (providerHistory && providerHistory.value.length > 0) {
-      return providerHistory.value;
-    }
-    if (cachedValue.length > 0 && !cachedHistoryStale) return cachedValue;
-    if (!providerHistory) {
-      throw new Error(`No resolution-aware history provider available for ${ticker}`);
-    }
-    return providerHistory.value;
+    const identity = makeHistoryRequestIdentity(this.deps, {
+      kind: "price-history",
+      ticker,
+      exchange,
+      context,
+      variantParts: [
+        ["exchange", canonicalExchange(exchange)],
+        ["range", bufferRange],
+        ["resolution", resolution],
+      ],
+      fallbackVariantParts: [["range", bufferRange], ["resolution", resolution]],
+    });
+    const intraday = isIntradayResolution(resolution);
+    return this.executeHistoryRequest({
+      ...identity,
+      context,
+      cachePolicyKey: intraday ? "priceHistoryIntraday" : "priceHistoryDaily",
+      missingProviderError: `No resolution-aware history provider available for ${ticker}`,
+      isCachedValueStale: (value) => isStaleIntradayHistory(value, intraday, exchange),
+      isFetchedValueStale: (value) => isStaleIntradayHistory(value, intraday, exchange),
+      fetchBroker: async (candidate) => candidate.broker.getPriceHistoryForResolution
+        ? candidate.broker.getPriceHistoryForResolution(
+          ticker,
+          candidate.instance,
+          exchange,
+          bufferRange,
+          resolution,
+          context?.instrument ?? null,
+        )
+        : null,
+      fetchProvider: async (provider) => provider.getPriceHistoryForResolution
+        ? provider.getPriceHistoryForResolution(ticker, exchange, bufferRange, resolution, context)
+        : null,
+    });
   }
 
   async getChartResolutionSupport(
@@ -109,11 +169,44 @@ export class ProviderRouterHistoryRoutes {
     exchange?: string,
     context?: MarketDataRequestContext,
   ): Promise<ChartResolutionSupport[]> {
-    const brokerSupport = await withBrokerTimeout(this.fetchBrokerChartResolutionSupport(ticker, exchange, context));
-    if (brokerSupport && brokerSupport.value.length > 0) {
-      return brokerSupport.value;
-    }
-    const providerSupport = await this.fetchProviderChartResolutionSupport(ticker, exchange, context);
+    const candidates = this.deps.getBrokerCandidatesForContext(context, false);
+    const brokerSupport = await withBrokerTimeout(this.firstBrokerResult(candidates, async (candidate) => {
+      const result = candidate.broker.getChartResolutionSupport
+        ? normalizeChartResolutionSupport(await candidate.broker.getChartResolutionSupport(
+          ticker,
+          candidate.instance,
+          exchange,
+          context?.instrument ?? null,
+        ))
+        : candidate.broker.getChartResolutionCapabilities
+          ? normalizeChartResolutionSupport(
+            (await candidate.broker.getChartResolutionCapabilities(
+              ticker,
+              candidate.instance,
+              exchange,
+              context?.instrument ?? null,
+            )).map((resolution) => ({ resolution, maxRange: "ALL" })),
+          )
+          : null;
+      return result && result.length > 0 ? result : null;
+    }));
+    if (brokerSupport) return brokerSupport.value;
+
+    const providerSupport = await this.firstProviderArrayResult(async (provider) => {
+      if (provider.canProvide && !await provider.canProvide(ticker, exchange, context)) {
+        return null;
+      }
+      if (provider.getChartResolutionSupport) {
+        return normalizeChartResolutionSupport(await provider.getChartResolutionSupport(ticker, exchange, context));
+      }
+      if (provider.getChartResolutionCapabilities) {
+        return normalizeChartResolutionSupport(
+          (await provider.getChartResolutionCapabilities(ticker, exchange, context))
+            .map((resolution) => ({ resolution, maxRange: "ALL" })),
+        );
+      }
+      return null;
+    });
     return providerSupport?.value ?? [];
   }
 
@@ -134,315 +227,153 @@ export class ProviderRouterHistoryRoutes {
     barSize: string,
     context?: MarketDataRequestContext,
   ): Promise<PricePoint[]> {
-    const entityKey = this.deps.getEntityKey(ticker, context?.instrument);
-    const variantKeys = [
-      buildPriceHistoryVariantKey([["exchange", canonicalExchange(exchange)], ["start", compactDate(startDate)], ["end", compactDate(endDate)], ["bar", barSize]], exchange),
-      buildPriceHistoryVariantKey([["start", compactDate(startDate)], ["end", compactDate(endDate)], ["bar", barSize]], exchange),
+    const primaryParts: Array<[string, string | number | undefined | null]> = [
+      ["exchange", canonicalExchange(exchange)],
+      ["start", compactDate(startDate)],
+      ["end", compactDate(endDate)],
+      ["bar", barSize],
     ];
+    const fallbackParts = primaryParts.slice(1);
+    const identity = makeHistoryRequestIdentity(this.deps, {
+      kind: "detailed-price-history",
+      ticker,
+      exchange,
+      context,
+      variantParts: primaryParts,
+      fallbackVariantParts: fallbackParts,
+    });
+    const currentWindowAtLookup = isCurrentHistoryWindow(endDate);
+    return this.executeHistoryRequest({
+      ...identity,
+      context,
+      cachePolicyKey: "priceHistoryIntraday",
+      isCachedValueStale: (value) => currentWindowAtLookup
+        && isPriceHistoryStaleForCurrentWindow(value, Date.now(), { exchange }),
+      isFetchedValueStale: (value) => isCurrentHistoryWindow(endDate)
+        && isPriceHistoryStaleForCurrentWindow(value, Date.now(), { exchange }),
+      fetchBroker: async (candidate) => candidate.broker.getDetailedPriceHistory
+        ? candidate.broker.getDetailedPriceHistory(
+          ticker,
+          candidate.instance,
+          exchange,
+          startDate,
+          endDate,
+          barSize,
+          context?.instrument ?? null,
+        )
+        : null,
+      fetchProvider: async (provider) => provider.getDetailedPriceHistory
+        ? provider.getDetailedPriceHistory(ticker, exchange, startDate, endDate, barSize, context)
+        : null,
+    });
+  }
+
+  private async executeHistoryRequest(request: HistoryRequestDescriptor): Promise<PricePoint[]> {
+    const brokerCandidates = this.deps.getBrokerCandidatesForContext(request.context, false);
     const sourceKeys = [
-      ...this.deps.getBrokerCandidatesForContext(context, false).map((candidate) => this.deps.brokerSourceKey(candidate)),
+      ...brokerCandidates.map((candidate) => this.deps.brokerSourceKey(candidate)),
       ...this.deps.getProviderSourceKeys(),
     ];
-    const cached = selectCachedArrayResource<PricePoint>(this.deps.resources, "detailed-price-history", entityKey, variantKeys, sourceKeys, false);
+    const cached = selectCachedArrayResource<PricePoint>(
+      this.deps.resources,
+      request.identity.kind,
+      request.identity.entityKey,
+      request.cacheVariantKeys,
+      sourceKeys,
+      false,
+    );
     const cachedValue = cached ? normalizePriceHistory(cached.value) : [];
-    const isCurrentWindow = isCurrentHistoryWindow(endDate);
-    const cachedHistoryStale = isCurrentWindow && isPriceHistoryStaleForCurrentWindow(cachedValue, Date.now(), { exchange });
-    const forceRefresh = context?.cacheMode === "refresh";
+    const cachedHistoryStale = request.isCachedValueStale(cachedValue);
+    const forceRefresh = request.context?.cacheMode === "refresh";
     if (cachedValue.length > 0 && !forceRefresh && cached && !cached.stale && !cachedHistoryStale) {
       return cachedValue;
     }
 
-    const brokerResult = await withBrokerTimeout(this.fetchBrokerDetailedPriceHistory(ticker, exchange, startDate, endDate, barSize, context));
+    const brokerResult = await withBrokerTimeout(this.fetchBrokerHistory(request, brokerCandidates));
     if (brokerResult && brokerResult.value.length > 0) return brokerResult.value;
 
-    const providerResult = await this.fetchProviderDetailedPriceHistory(ticker, exchange, startDate, endDate, barSize, context);
-    if (providerResult && providerResult.value.length > 0) {
-      return providerResult.value;
-    }
-    return cachedValue.length > 0 && !cachedHistoryStale ? cachedValue : (providerResult?.value ?? []);
-  }
-
-  private async fetchBrokerPriceHistory(
-    ticker: string,
-    exchange: string,
-    range: TimeRange,
-    context?: MarketDataRequestContext,
-  ): Promise<SourceResult<PricePoint[]> | null> {
-    const entityKey = this.deps.getEntityKey(ticker, context?.instrument);
-    const variantKey = buildPriceHistoryVariantKey([["exchange", canonicalExchange(exchange)], ["range", range]], exchange);
-    for (const candidate of this.deps.getBrokerCandidatesForContext(context, false)) {
-      if (!candidate.broker.getPriceHistory) continue;
-      try {
-        const result = normalizePriceHistory(await candidate.broker.getPriceHistory(
-          ticker,
-          candidate.instance,
-          exchange,
-          range,
-          context?.instrument ?? null,
-        ));
-        if (isStaleIntradayHistory(result, isIntradayRange(range), exchange)) continue;
-        this.deps.cacheResource(
-          "price-history",
-          entityKey,
-          variantKey,
-          this.deps.brokerSourceKey(candidate),
-          result,
-          this.deps.resolveBrokerPolicy(isIntradayRange(range) ? "priceHistoryIntraday" : "priceHistoryDaily", candidate.broker),
-        );
-        return { sourceKey: this.deps.brokerSourceKey(candidate), value: result };
-      } catch {
-        // continue
-      }
-    }
-    return null;
-  }
-
-  private async fetchBrokerPriceHistoryForResolution(
-    ticker: string,
-    exchange: string,
-    bufferRange: TimeRange,
-    resolution: ManualChartResolution,
-    context?: MarketDataRequestContext,
-  ): Promise<SourceResult<PricePoint[]> | null> {
-    const entityKey = this.deps.getEntityKey(ticker, context?.instrument);
-    const variantKey = buildPriceHistoryVariantKey([["exchange", canonicalExchange(exchange)], ["range", bufferRange], ["resolution", resolution]], exchange);
-    for (const candidate of this.deps.getBrokerCandidatesForContext(context, false)) {
-      if (!candidate.broker.getPriceHistoryForResolution) continue;
-      try {
-        const result = normalizePriceHistory(await candidate.broker.getPriceHistoryForResolution(
-          ticker,
-          candidate.instance,
-          exchange,
-          bufferRange,
-          resolution,
-          context?.instrument ?? null,
-        ));
-        if (isStaleIntradayHistory(result, isIntradayResolution(resolution), exchange)) continue;
-        this.deps.cacheResource(
-          "price-history",
-          entityKey,
-          variantKey,
-          this.deps.brokerSourceKey(candidate),
-          result,
-          this.deps.resolveBrokerPolicy(isIntradayResolution(resolution) ? "priceHistoryIntraday" : "priceHistoryDaily", candidate.broker),
-        );
-        return { sourceKey: this.deps.brokerSourceKey(candidate), value: result };
-      } catch {
-        // continue
-      }
-    }
-    return null;
-  }
-
-  private async fetchProviderPriceHistory(
-    ticker: string,
-    exchange: string,
-    range: TimeRange,
-    context?: MarketDataRequestContext,
-  ): Promise<SourceResult<PricePoint[]> | null> {
-    const entityKey = this.deps.getEntityKey(ticker, context?.instrument);
-    const variantKey = buildPriceHistoryVariantKey([["exchange", canonicalExchange(exchange)], ["range", range]], exchange);
-    let firstEmptyResult: SourceResult<PricePoint[]> | null = null;
-
-    for (const provider of this.deps.providersInPriorityOrder()) {
-      try {
-        const value = normalizePriceHistory(await provider.getPriceHistory(ticker, exchange, range, context));
-        if (isStaleIntradayHistory(value, isIntradayRange(range), exchange)) continue;
-        const sourceKey = this.deps.providerSourceKey(provider);
-        this.deps.cacheResource(
-          "price-history",
-          entityKey,
-          variantKey,
-          sourceKey,
-          value,
-          this.deps.resolveProviderPolicy(isIntradayRange(range) ? "priceHistoryIntraday" : "priceHistoryDaily", provider),
-        );
-        if (value.length > 0) {
-          return { sourceKey, value };
-        }
-        firstEmptyResult ??= { sourceKey, value };
-      } catch (error) {
-        if (shouldLogProviderError(error)) {
-          this.deps.logProviderError(`${provider.id} failed: ${error}`);
-        }
-      }
+    const providerResult = await this.fetchProviderHistory(request);
+    if (providerResult && providerResult.value.length > 0) return providerResult.value;
+    if (cachedValue.length > 0 && !cachedHistoryStale) return cachedValue;
+    if (!providerResult && request.missingProviderError) {
+      throw new Error(request.missingProviderError);
     }
-
-    return firstEmptyResult;
+    return providerResult?.value ?? [];
   }
 
-  private async fetchProviderPriceHistoryForResolution(
-    ticker: string,
-    exchange: string,
-    bufferRange: TimeRange,
-    resolution: ManualChartResolution,
-    context?: MarketDataRequestContext,
+  private fetchBrokerHistory(
+    request: HistoryRequestDescriptor,
+    candidates: BrokerCandidate[],
   ): Promise<SourceResult<PricePoint[]> | null> {
-    const entityKey = this.deps.getEntityKey(ticker, context?.instrument);
-    const variantKey = buildPriceHistoryVariantKey([["exchange", canonicalExchange(exchange)], ["range", bufferRange], ["resolution", resolution]], exchange);
-    let firstEmptyResult: SourceResult<PricePoint[]> | null = null;
-
-    for (const provider of this.deps.providersInPriorityOrder()) {
-      if (!provider.getPriceHistoryForResolution) continue;
-      try {
-        const value = normalizePriceHistory(await provider.getPriceHistoryForResolution(ticker, exchange, bufferRange, resolution, context));
-        if (isStaleIntradayHistory(value, isIntradayResolution(resolution), exchange)) continue;
-        const sourceKey = this.deps.providerSourceKey(provider);
-        this.deps.cacheResource(
-          "price-history",
-          entityKey,
-          variantKey,
-          sourceKey,
-          value,
-          this.deps.resolveProviderPolicy(isIntradayResolution(resolution) ? "priceHistoryIntraday" : "priceHistoryDaily", provider),
-        );
-        if (value.length > 0) {
-          return { sourceKey, value };
-        }
-        firstEmptyResult ??= { sourceKey, value };
-      } catch (error) {
-        if (shouldLogProviderError(error)) {
-          this.deps.logProviderError(`${provider.id} failed: ${error}`);
-        }
-      }
-    }
-
-    return firstEmptyResult;
+    return this.firstBrokerResult(candidates, async (candidate) => {
+      const fetched = await request.fetchBroker(candidate);
+      if (fetched === null) return null;
+      const value = normalizePriceHistory(fetched);
+      if (request.isFetchedValueStale(value)) return null;
+      this.deps.cacheResource(
+        request.identity.kind,
+        request.identity.entityKey,
+        request.identity.variantKey,
+        this.deps.brokerSourceKey(candidate),
+        value,
+        this.deps.resolveBrokerPolicy(request.cachePolicyKey, candidate.broker),
+      );
+      return value;
+    });
   }
 
-  private async fetchBrokerChartResolutionSupport(
-    ticker: string,
-    exchange?: string,
-    context?: MarketDataRequestContext,
-  ): Promise<SourceResult<ChartResolutionSupport[]> | null> {
-    for (const candidate of this.deps.getBrokerCandidatesForContext(context, false)) {
-      if (!candidate.broker.getChartResolutionSupport && !candidate.broker.getChartResolutionCapabilities) continue;
-      try {
-        const result = candidate.broker.getChartResolutionSupport
-          ? normalizeChartResolutionSupport(await candidate.broker.getChartResolutionSupport(
-            ticker,
-            candidate.instance,
-            exchange,
-            context?.instrument ?? null,
-          ))
-          : normalizeChartResolutionSupport(
-            (await candidate.broker.getChartResolutionCapabilities!(
-              ticker,
-              candidate.instance,
-              exchange,
-              context?.instrument ?? null,
-            )).map((resolution) => ({ resolution, maxRange: "ALL" })),
-          );
-        if (result.length === 0) continue;
-        return { sourceKey: this.deps.brokerSourceKey(candidate), value: result };
-      } catch {
-        // continue
-      }
-    }
-    return null;
+  private fetchProviderHistory(request: HistoryRequestDescriptor): Promise<SourceResult<PricePoint[]> | null> {
+    return this.firstProviderArrayResult(async (provider) => {
+      const fetched = await request.fetchProvider(provider);
+      if (fetched === null) return null;
+      const value = normalizePriceHistory(fetched);
+      if (request.isFetchedValueStale(value)) return null;
+      this.deps.cacheResource(
+        request.identity.kind,
+        request.identity.entityKey,
+        request.identity.variantKey,
+        this.deps.providerSourceKey(provider),
+        value,
+        this.deps.resolveProviderPolicy(request.cachePolicyKey, provider),
+      );
+      return value;
+    });
   }
 
-  private async fetchProviderChartResolutionSupport(
-    ticker: string,
-    exchange?: string,
-    context?: MarketDataRequestContext,
-  ): Promise<SourceResult<ChartResolutionSupport[]> | null> {
-    for (const provider of this.deps.providersInPriorityOrder()) {
-      if (!provider.getChartResolutionSupport && !provider.getChartResolutionCapabilities) continue;
+  private async firstBrokerResult<T>(
+    candidates: BrokerCandidate[],
+    fetch: (candidate: BrokerCandidate) => Promise<T | null>,
+  ): Promise<SourceResult<T> | null> {
+    for (const candidate of candidates) {
       try {
-        const result = provider.getChartResolutionSupport
-          ? normalizeChartResolutionSupport(await provider.getChartResolutionSupport(ticker, exchange, context))
-          : normalizeChartResolutionSupport(
-            (await provider.getChartResolutionCapabilities!(ticker, exchange, context)).map((resolution) => ({ resolution, maxRange: "ALL" })),
-          );
-        if (result.length === 0) continue;
-        return { sourceKey: this.deps.providerSourceKey(provider), value: result };
-      } catch (error) {
-        if (shouldLogProviderError(error)) {
-          this.deps.logProviderError(`${provider.id} failed: ${error}`);
+        const value = await fetch(candidate);
+        if (value !== null) {
+          return { sourceKey: this.deps.brokerSourceKey(candidate), value };
         }
-      }
-    }
-
-    return null;
-  }
-
-  private async fetchBrokerDetailedPriceHistory(
-    ticker: string,
-    exchange: string,
-    startDate: Date,
-    endDate: Date,
-    barSize: string,
-    context?: MarketDataRequestContext,
-  ): Promise<SourceResult<PricePoint[]> | null> {
-    const entityKey = this.deps.getEntityKey(ticker, context?.instrument);
-    const variantKey = buildPriceHistoryVariantKey([["exchange", canonicalExchange(exchange)], ["start", compactDate(startDate)], ["end", compactDate(endDate)], ["bar", barSize]], exchange);
-    for (const candidate of this.deps.getBrokerCandidatesForContext(context, false)) {
-      if (!candidate.broker.getDetailedPriceHistory) continue;
-      try {
-        const result = normalizePriceHistory(await candidate.broker.getDetailedPriceHistory(
-          ticker,
-          candidate.instance,
-          exchange,
-          startDate,
-          endDate,
-          barSize,
-          context?.instrument ?? null,
-        ));
-        if (isCurrentHistoryWindow(endDate) && isPriceHistoryStaleForCurrentWindow(result, Date.now(), { exchange })) continue;
-        this.deps.cacheResource(
-          "detailed-price-history",
-          entityKey,
-          variantKey,
-          this.deps.brokerSourceKey(candidate),
-          result,
-          this.deps.resolveBrokerPolicy("priceHistoryIntraday", candidate.broker),
-        );
-        return { sourceKey: this.deps.brokerSourceKey(candidate), value: result };
       } catch {
-        // continue
+        // Continue through the broker candidates.
       }
     }
     return null;
   }
 
-  private async fetchProviderDetailedPriceHistory(
-    ticker: string,
-    exchange: string,
-    startDate: Date,
-    endDate: Date,
-    barSize: string,
-    context?: MarketDataRequestContext,
-  ): Promise<SourceResult<PricePoint[]> | null> {
-    const entityKey = this.deps.getEntityKey(ticker, context?.instrument);
-    const variantKey = buildPriceHistoryVariantKey([["exchange", canonicalExchange(exchange)], ["start", compactDate(startDate)], ["end", compactDate(endDate)], ["bar", barSize]], exchange);
-    let firstEmptyResult: SourceResult<PricePoint[]> | null = null;
-
+  private async firstProviderArrayResult<T>(
+    fetch: (provider: DataProvider) => Promise<T[] | null>,
+  ): Promise<SourceResult<T[]> | null> {
+    let firstEmptyResult: SourceResult<T[]> | null = null;
     for (const provider of this.deps.providersInPriorityOrder()) {
-      if (!provider.getDetailedPriceHistory) continue;
       try {
-        const value = normalizePriceHistory(await provider.getDetailedPriceHistory(ticker, exchange, startDate, endDate, barSize, context));
-        if (isCurrentHistoryWindow(endDate) && isPriceHistoryStaleForCurrentWindow(value, Date.now(), { exchange })) continue;
-        const sourceKey = this.deps.providerSourceKey(provider);
-        this.deps.cacheResource(
-          "detailed-price-history",
-          entityKey,
-          variantKey,
-          sourceKey,
-          value,
-          this.deps.resolveProviderPolicy("priceHistoryIntraday", provider),
-        );
-        if (value.length > 0) {
-          return { sourceKey, value };
-        }
-        firstEmptyResult ??= { sourceKey, value };
+        const value = await fetch(provider);
+        if (value === null) continue;
+        const result = { sourceKey: this.deps.providerSourceKey(provider), value };
+        if (value.length > 0) return result;
+        firstEmptyResult ??= result;
       } catch (error) {
         if (shouldLogProviderError(error)) {
           this.deps.logProviderError(`${provider.id} failed: ${error}`);
         }
       }
     }
-
     return firstEmptyResult;
   }
 }