@363045841yyt/klinechart-core 0.8.1 → 0.8.3

package/src/data-fetchers/__tests__/fetcherRegistry.test.ts

@@ -0,0 +1,192 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest'
+import {
+  DataFetcher,
+  getRegisteredFetcher,
+  fetcherSupportsPeriod,
+  clearRegisteredFetchersForTest,
+} from '../fetcherDefinitionRegistry'
+import { routerDataFetcher } from '../router'
+import type { DataFetcherFn } from '../types'
+import type { KLineData } from '../../controllers/types'
+
+const mockFetch = vi.fn<() => Promise<ReadonlyArray<KLineData>>>()
+
+const fetchFn: DataFetcherFn = async () => mockFetch()
+
+const defaultConfig = {
+  symbol: '000001',
+  startDate: '2024-01-01',
+  endDate: '2024-01-31',
+  period: 'daily',
+  adjust: 'none',
+}
+
+describe('DataFetcher registry', () => {
+  beforeEach(() => {
+    clearRegisteredFetchersForTest()
+  })
+
+  it('collects decorated fetcher definition with metadata', () => {
+    @DataFetcher({
+      name: 'test',
+      displayName: 'Test',
+      version: '1.0.0',
+      capabilities: ['daily', 'weekly'],
+    })
+    class TestFetcher {
+      static fetcher = fetchFn
+    }
+    void TestFetcher
+
+    const def = getRegisteredFetcher('test')
+    expect(def).toBeDefined()
+    expect(def!.name).toBe('test')
+    expect(def!.displayName).toBe('Test')
+    expect(def!.version).toBe('1.0.0')
+    expect(def!.capabilities).toEqual(['daily', 'weekly'])
+    expect(def!.fetcher).toBe(fetchFn)
+  })
+
+  it('fetcherSupportsPeriod returns true for exact match', () => {
+    @DataFetcher({ name: 'test', displayName: 'Test', capabilities: ['daily', 'weekly'] })
+    class TestFetcher { static fetcher = fetchFn }
+    void TestFetcher
+
+    expect(fetcherSupportsPeriod('test', 'daily')).toBe(true)
+    expect(fetcherSupportsPeriod('test', 'weekly')).toBe(true)
+  })
+
+  it('fetcherSupportsPeriod returns false for unsupported period', () => {
+    @DataFetcher({ name: 'test', displayName: 'Test', capabilities: ['weekly'] })
+    class TestFetcher { static fetcher = fetchFn }
+    void TestFetcher
+
+    expect(fetcherSupportsPeriod('test', 'daily')).toBe(false)
+    expect(fetcherSupportsPeriod('test', '5min')).toBe(false)
+  })
+
+  it('fetcherSupportsPeriod accepts wildcard * for any period', () => {
+    @DataFetcher({ name: 'test', displayName: 'Test', capabilities: ['*'] })
+    class TestFetcher { static fetcher = fetchFn }
+    void TestFetcher
+
+    expect(fetcherSupportsPeriod('test', 'daily')).toBe(true)
+    expect(fetcherSupportsPeriod('test', '5min')).toBe(true)
+    expect(fetcherSupportsPeriod('test', 'quarterly')).toBe(true)
+  })
+
+  it('fetcherSupportsPeriod returns false for empty capabilities', () => {
+    @DataFetcher({ name: 'test', displayName: 'Test', capabilities: [] })
+    class TestFetcher { static fetcher = fetchFn }
+    void TestFetcher
+
+    expect(fetcherSupportsPeriod('test', 'daily')).toBe(false)
+  })
+
+  it('fetcherSupportsPeriod returns false when capabilities not set', () => {
+    @DataFetcher({ name: 'test', displayName: 'Test' })
+    class TestFetcher { static fetcher = fetchFn }
+    void TestFetcher
+
+    expect(fetcherSupportsPeriod('test', 'daily')).toBe(false)
+  })
+
+  it('fetcherSupportsPeriod returns false for unknown source', () => {
+    expect(fetcherSupportsPeriod('nonexistent', 'daily')).toBe(false)
+  })
+
+  it('clearRegisteredFetchersForTest removes all definitions', () => {
+    @DataFetcher({ name: 'test', displayName: 'Test', capabilities: ['daily'] })
+    class TestFetcher { static fetcher = fetchFn }
+    void TestFetcher
+
+    expect(getRegisteredFetcher('test')).toBeDefined()
+    clearRegisteredFetchersForTest()
+    expect(getRegisteredFetcher('test')).toBeUndefined()
+  })
+})
+
+describe('routerDataFetcher capability check', () => {
+  beforeEach(() => {
+    clearRegisteredFetchersForTest()
+    mockFetch.mockReset()
+  })
+
+  it('passes through request when period is supported', async () => {
+    const data: KLineData[] = [{ timestamp: 1000, open: 100, high: 110, low: 90, close: 105, volume: 1000 }]
+    mockFetch.mockResolvedValue(data)
+
+    @DataFetcher({ name: 'test', displayName: 'Test', capabilities: ['daily'] })
+    class TestFetcher { static fetcher = fetchFn }
+    void TestFetcher
+
+    const result = await routerDataFetcher('test', defaultConfig)
+    expect(result).toBe(data)
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+  })
+
+  it('passes through request when capabilities are wildcard', async () => {
+    const data: KLineData[] = [{ timestamp: 1000, open: 100, high: 110, low: 90, close: 105, volume: 1000 }]
+    mockFetch.mockResolvedValue(data)
+
+    @DataFetcher({ name: 'test', displayName: 'Test', capabilities: ['*'] })
+    class TestFetcher { static fetcher = fetchFn }
+    void TestFetcher
+
+    const result = await routerDataFetcher('test', { ...defaultConfig, period: '5min' })
+    expect(result).toBe(data)
+  })
+
+  it('throws when period is not in capabilities', async () => {
+    @DataFetcher({ name: 'test', displayName: 'Test', capabilities: ['weekly'] })
+    class TestFetcher { static fetcher = fetchFn }
+    void TestFetcher
+
+    await expect(
+      routerDataFetcher('test', defaultConfig),
+    ).rejects.toThrow(/does not support period/)
+  })
+
+  it('throws with error message listing supported capabilities', async () => {
+    @DataFetcher({ name: 'test', displayName: 'Test', capabilities: ['weekly', 'monthly'] })
+    class TestFetcher { static fetcher = fetchFn }
+    void TestFetcher
+
+    await expect(
+      routerDataFetcher('test', { ...defaultConfig, period: '5min' }),
+    ).rejects.toThrow(/weekly, monthly/)
+  })
+
+  it('throws when capabilities is empty array', async () => {
+    @DataFetcher({ name: 'test', displayName: 'Test', capabilities: [] })
+    class TestFetcher { static fetcher = fetchFn }
+    void TestFetcher
+
+    await expect(
+      routerDataFetcher('test', defaultConfig),
+    ).rejects.toThrow(/does not support period/)
+  })
+
+  it('throws when capabilities is not set', async () => {
+    @DataFetcher({ name: 'test', displayName: 'Test' })
+    class TestFetcher { static fetcher = fetchFn }
+    void TestFetcher
+
+    await expect(
+      routerDataFetcher('test', defaultConfig),
+    ).rejects.toThrow(/does not support period/)
+  })
+
+  it('falls back to registered baostock for unknown source', async () => {
+    const data: KLineData[] = [{ timestamp: 2000, open: 200, high: 210, low: 190, close: 205, volume: 2000 }]
+    const baostockFn = vi.fn<DataFetcherFn>().mockResolvedValue(data)
+
+    @DataFetcher({ name: 'baostock', displayName: 'BaoStock', capabilities: ['*'] })
+    class BaoStockStub { static fetcher = baostockFn }
+    void BaoStockStub
+
+    const result = await routerDataFetcher('nonexistent', defaultConfig)
+    expect(result).toBe(data)
+    expect(baostockFn).toHaveBeenCalledWith('nonexistent', expect.objectContaining({ period: 'daily' }))
+  })
+})

package/src/data-fetchers/baostock.ts

@@ -1,34 +1,66 @@
-import type { DataFetcher, KLineData } from '../controllers/types'
+import type { KLineData } from '../controllers/types'
+import { DataFetcher } from './fetcherDefinitionRegistry'
+import type { FetchConfig } from './types'
 
-export const baostockDataFetcher: DataFetcher = async (source, config) => {
-  console.log(`[baostock] fetching ${config.symbol} ${config.period} ${config.startDate}~${config.endDate}`)
-  const baseUrl = source === 'baostock' ? 'http://localhost:8000' : ''
-  const adjustMap: Record<string, string> = { qfq: '2', hfq: '1', none: '3' }
-const periodMap: Record<string, string> = { daily: 'd', weekly: 'w', monthly: 'm', '5min': '5', '15min': '15', '30min': '30', '60min': '60' }
-  const adjustflag = adjustMap[config.adjust] ?? '3'
-  const url = `${baseUrl}/api/stock/kdata?stock_code=${config.symbol}&start_date=${config.startDate}&end_date=${config.endDate}&frequency=${periodMap[config.period] ?? 'd'}&adjustflag=${adjustflag}`
+const ADJUST_MAP: Record<string, string> = { qfq: '2', hfq: '1', none: '3' }
+
+const PERIOD_MAP: Record<string, string> = {
+  daily: 'd',
+  weekly: 'w',
+  monthly: 'm',
+  '5min': '5',
+  '15min': '15',
+  '30min': '30',
+  '60min': '60',
+}
+
+const BASE_URL = 'http://localhost:8000'
+
+async function fetchBaoStock(
+  _source: string,
+  config: FetchConfig,
+): Promise<ReadonlyArray<KLineData>> {
+  console.log(
+    `[baostock] fetching ${config.symbol} ${config.period} ${config.startDate}~${config.endDate}`,
+  )
+  const url = `${BASE_URL}/api/stock/kdata?stock_code=${config.symbol}&start_date=${config.startDate}&end_date=${config.endDate}&frequency=${PERIOD_MAP[config.period] ?? 'd'}&adjustflag=${ADJUST_MAP[config.adjust] ?? '3'}`
   try {
     const res = await fetch(url)
-    console.log(res)
     if (!res.ok) {
       throw new Error(`[baostock] fetch failed: ${res.status} ${res.statusText}`)
     }
     const json = await res.json()
-    console.log(json)
-    return (json.data ?? json).map((item: Record<string, unknown>) => ({
-      timestamp: new Date(item.date as string).getTime(),
-      date: item.date as string,
-      open: Number(item.open),
-      high: Number(item.high),
-      low: Number(item.low),
-      close: Number(item.close),
-      volume: Number(item.volume),
-      turnover: Number(item.amount ?? 0),
-      turnoverRate: item.turn === '' ? 0 : Number(item.turn),
-      stockCode: String(item.code ?? config.symbol),
-    })) as KLineData[]
+    return (json.data ?? json).map(
+      (item: Record<string, unknown>) =>
+        ({
+          timestamp: new Date(item.date as string).getTime(),
+          date: item.date as string,
+          open: Number(item.open),
+          high: Number(item.high),
+          low: Number(item.low),
+          close: Number(item.close),
+          volume: Number(item.volume),
+          turnover: Number(item.amount ?? 0),
+          turnoverRate: item.turn === '' ? 0 : Number(item.turn),
+          stockCode: String(item.code ?? config.symbol),
+        }) as KLineData,
+    )
   } catch (err) {
     console.warn('[baostock] network error:', err)
     throw err
   }
 }
+
+@DataFetcher({
+  name: 'baostock',
+  displayName: 'BaoStock',
+  description: 'BaoStock data source via local proxy',
+  version: '1.0.0',
+  capabilities: ['daily', 'weekly', 'monthly', '5min', '15min', '30min', '60min'],
+})
+export class BaoStockFetcher {
+  static fetcher = fetchBaoStock
+}
+
+/** @deprecated Use `BaoStockFetcher.fetcher` directly or rely on routerDataFetcher. */
+export const baostockDataFetcher = fetchBaoStock

package/src/data-fetchers/dataBuffer.ts

@@ -153,6 +153,12 @@ export class DataBuffer {
             return fetchPromise.then((incoming) => {
                 if (this._disposed) return
 
+                if (incoming.length === 0) {
+                    throw new Error(
+                        `[DataBuffer] empty data for ${spec.symbol} ${formatDate(startTs)}~${formatDate(endTs)}`,
+                    )
+                }
+
                 const oldLength = this._data.length
                 const oldEarliestTs = oldLength > 0 ? this._data[0]!.timestamp : null
                 const merged = mergeSortedData(this._data, [...incoming])

package/src/data-fetchers/fetcherDefinitionRegistry.ts

@@ -0,0 +1,50 @@
+import type { DataFetcherDefinitionConfig, DataFetcherDefinition, DataFetcherFn } from './types'
+
+type DataFetcherClass = {
+  new(...args: never[]): unknown
+  fetcher: DataFetcherFn
+}
+
+const definitions = new Map<string, DataFetcherDefinition>()
+
+export function DataFetcher(config: DataFetcherDefinitionConfig) {
+  return function <T extends DataFetcherClass>(value: T, context: ClassDecoratorContext<T>): T {
+    context.addInitializer(function (this: T) {
+      if (typeof this.fetcher !== 'function') {
+        throw new Error(
+          `[DataFetcher] '${config.name}' definition must expose static fetcher`,
+        )
+      }
+      definitions.set(config.name, {
+        ...config,
+        fetcher: this.fetcher,
+      })
+    })
+    return value
+  }
+}
+
+export function getRegisteredFetcher(
+  name: string,
+): DataFetcherDefinition | undefined {
+  return definitions.get(name)
+}
+
+export function getRegisteredFetchers(): DataFetcherDefinition[] {
+  return Array.from(definitions.values())
+}
+
+export function fetcherHasCapability(name: string, capability: string): boolean {
+  return definitions.get(name)?.capabilities?.includes(capability) ?? false
+}
+
+export function fetcherSupportsPeriod(name: string, period: string): boolean {
+  const def = definitions.get(name)
+  if (!def) return false
+  if (!def.capabilities || def.capabilities.length === 0) return false
+  return def.capabilities.includes('*') || def.capabilities.includes(period)
+}
+
+export function clearRegisteredFetchersForTest(): void {
+  definitions.clear()
+}

package/src/data-fetchers/gotdx.ts

@@ -0,0 +1,160 @@
+import type { KLineData } from '../controllers/types'
+import { DataFetcher } from './fetcherDefinitionRegistry'
+import type { FetchConfig } from './types'
+
+const PERIOD_TO_CATEGORY: Record<string, number> = {
+  '1min': 8,
+  '5min': 0,
+  '15min': 1,
+  '30min': 2,
+  '60min': 3,
+  daily: 4,
+  weekly: 5,
+  monthly: 6,
+  quarterly: 10,
+  yearly: 11,
+}
+
+const ADJUST_MAP: Record<string, number> = {
+  none: 0,
+  qfq: 1,
+  hfq: 2,
+  splits: 0,
+}
+
+const EXCHANGE_EX_CATEGORY: Record<string, number> = {
+  US: 74,
+  HK: 71,
+  SG: 78,
+  DE: 73,
+}
+
+const BASE_URL = 'http://127.0.0.1:8080'
+
+interface SecurityBar {
+  Last: number
+  Open: number
+  Close: number
+  High: number
+  Low: number
+  Vol: number
+  Amount: number
+  Turnover: number
+  RisePrice: number
+  RiseRate: number
+  Year: number
+  Month: number
+  Day: number
+  Hour: number
+  Minute: number
+  DateTime: string
+  UpCount: number
+  DownCount: number
+}
+
+interface ExKLineItem {
+  DateTime: string
+  Open: number
+  High: number
+  Low: number
+  Close: number
+  Amount: number
+  Vol: number
+}
+
+function mapBar(item: SecurityBar, code: string): KLineData {
+  const ts = new Date(item.DateTime).getTime()
+  return {
+    timestamp: ts,
+    date: item.DateTime.split('T')[0],
+    open: item.Open,
+    high: item.High,
+    low: item.Low,
+    close: item.Close,
+    volume: item.Vol,
+    turnover: item.Amount,
+    turnoverRate: item.Turnover,
+    changeAmount: item.RisePrice,
+    changePercent: item.RiseRate,
+    stockCode: code,
+  }
+}
+
+function mapExItem(item: ExKLineItem, code: string): KLineData {
+  const ts = new Date(item.DateTime).getTime()
+  return {
+    timestamp: ts,
+    date: item.DateTime.split('T')[0],
+    open: item.Open,
+    high: item.High,
+    low: item.Low,
+    close: item.Close,
+    volume: item.Vol,
+    turnover: item.Amount,
+    stockCode: code,
+  }
+}
+
+async function fetchGotdx(
+  _source: string,
+  config: FetchConfig,
+): Promise<ReadonlyArray<KLineData>> {
+  if (config.exchange && config.exchange in EXCHANGE_EX_CATEGORY) {
+    const category = EXCHANGE_EX_CATEGORY[config.exchange]
+    const period = PERIOD_TO_CATEGORY[config.period] ?? 4
+    const body = {
+      category,
+      code: config.symbol,
+      period,
+      start_date: config.startDate,
+      end_date: config.endDate,
+      times: 1,
+    }
+    const res = await fetch(`${BASE_URL}/api/ex/kline-by-date`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    })
+    if (!res.ok) throw new Error(`[gotdx] ex/kline-by-date failed: ${res.status} ${res.statusText}`)
+    const list: ExKLineItem[] = await res.json()
+    return list.map((item) => mapExItem(item, config.symbol))
+  }
+
+  const market = config.symbol.startsWith('6') || config.symbol.startsWith('9') ? 1 : 0
+  const category = PERIOD_TO_CATEGORY[config.period] ?? 4
+  const adjust = ADJUST_MAP[config.adjust] ?? 0
+  const body = {
+    market,
+    code: config.symbol,
+    category,
+    start_date: config.startDate,
+    end_date: config.endDate,
+    times: 1,
+    adjust,
+  }
+  const res = await fetch(`${BASE_URL}/api/stock/kline-by-date`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+  if (!res.ok) throw new Error(`[gotdx] stock/kline-by-date failed: ${res.status} ${res.statusText}`)
+  const list: SecurityBar[] = await res.json()
+  return list.map((item) => mapBar(item, config.symbol))
+}
+
+@DataFetcher({
+  name: 'gotdx',
+  displayName: 'GOTDX',
+  description: 'TDX data source via local proxy',
+  version: '1.0.0',
+  capabilities: [
+    '1min', '5min', '15min', '30min', '60min',
+    'daily', 'weekly', 'monthly', 'quarterly', 'yearly',
+  ],
+})
+export class GotdxFetcher {
+  static fetcher = fetchGotdx
+}
+
+/** @deprecated Use `GotdxFetcher.fetcher` directly or rely on routerDataFetcher. */
+export const gotdxDataFetcher = fetchGotdx

package/src/data-fetchers/hundred-mock.ts

@@ -1,18 +1,51 @@
-import type { DataFetcher, KLineData } from '../controllers/types'
+import type { KLineData } from '../controllers/types'
+import { DataFetcher } from './fetcherDefinitionRegistry'
+import type { FetchConfig } from './types'
 
-export const hundredMockDataFetcher: DataFetcher = async (_source, config) => {
+async function fetchHundredMock(
+  _source: string,
+  config: FetchConfig,
+): Promise<ReadonlyArray<KLineData>> {
   console.log(`[hundred-mock] generating ${config.symbol} ${config.period}`)
   const start = new Date(config.startDate).getTime()
   const end = new Date(config.endDate).getTime()
   const dayMs = 86400000
   const totalDays = Math.floor((end - start) / dayMs) + 1
+  if (totalDays <= 0) return []
+
+  const basePrice = 12.5
   const data: KLineData[] = []
-  let price = 10 + Math.random() * 5
+
+  if (totalDays === 1) {
+    data.push({
+      timestamp: start,
+      open: basePrice,
+      high: basePrice,
+      low: basePrice,
+      close: basePrice,
+      volume: Math.round(Math.random() * 10000000 + 1000000),
+    })
+    return data
+  }
+
+  const meanReversionStrength = 0.005
+
+  const rawWalk: number[] = [basePrice]
+  for (let i = 1; i < totalDays; i++) {
+    const prev = rawWalk[i - 1]!
+    const reversion = meanReversionStrength * (basePrice - prev)
+    const change = (Math.random() - 0.48) * prev * 0.06 + reversion
+    rawWalk.push(prev + change)
+  }
+
+  const finalOffset = rawWalk[totalDays - 1]! - basePrice
   for (let i = 0; i < totalDays; i++) {
+    const bridge = finalOffset * (i / (totalDays - 1))
+    const close = Math.round((rawWalk[i]! - bridge) * 100) / 100
+
     const ts = start + i * dayMs
-    const change = (Math.random() - 0.48) * price * 0.06
-    const open = price
-    const close = Math.round((open + change) * 100) / 100
+    const open = i === 0 ? basePrice : data[i - 1]!.close
+
     const high = Math.round(Math.max(open, close) * (1 + Math.random() * 0.03) * 100) / 100
     const low = Math.round(Math.min(open, close) * (1 - Math.random() * 0.03) * 100) / 100
     const volume = Math.round(Math.random() * 10000000 + 1000000)
@@ -25,7 +58,21 @@ export const hundredMockDataFetcher: DataFetcher = async (_source, config) => {
       volume,
       turnover: Math.round((volume * (open + close)) / 2),
     })
-    price = close
   }
+
   return data
 }
+
+@DataFetcher({
+  name: 'mock-100',
+  displayName: 'Mock 100',
+  description: 'Generates ~100 random K-line bars with Brownian bridge',
+  version: '1.0.0',
+  capabilities: ['*'],
+})
+export class HundredMockFetcher {
+  static fetcher = fetchHundredMock
+}
+
+/** @deprecated Use `HundredMockFetcher.fetcher` directly or rely on routerDataFetcher. */
+export const hundredMockDataFetcher = fetchHundredMock

package/src/data-fetchers/index.ts

@@ -1,7 +1,22 @@
-export { thousandMockDataFetcher } from './thousand-mock'
-export { hundredMockDataFetcher } from './hundred-mock'
-export { baostockDataFetcher } from './baostock'
-export { tradingviewDataFetcher } from './tradingview'
+export { HundredMockFetcher, hundredMockDataFetcher } from './hundred-mock'
+export { ThousandMockFetcher, thousandMockDataFetcher } from './thousand-mock'
+export { BaoStockFetcher, baostockDataFetcher } from './baostock'
+export { TradingviewFetcher, tradingviewDataFetcher } from './tradingview'
+export { GotdxFetcher, gotdxDataFetcher } from './gotdx'
 export { routerDataFetcher } from './router'
 export { DataBuffer } from './dataBuffer'
 export type { DataWindow } from './dataBuffer'
+export {
+  DataFetcher,
+  getRegisteredFetcher,
+  getRegisteredFetchers,
+  fetcherHasCapability,
+  fetcherSupportsPeriod,
+  clearRegisteredFetchersForTest,
+} from './fetcherDefinitionRegistry'
+export type {
+  FetchConfig,
+  DataFetcherDefinitionConfig,
+  DataFetcherDefinition,
+  DataFetcherFn,
+} from './types'

package/src/data-fetchers/router.ts

@@ -1,20 +1,32 @@
 import type { DataFetcher } from '../controllers/types'
-import { baostockDataFetcher } from './baostock'
-import { hundredMockDataFetcher } from './hundred-mock'
-import { thousandMockDataFetcher } from './thousand-mock'
-import { tradingviewDataFetcher } from './tradingview'
+import { getRegisteredFetcher, fetcherSupportsPeriod } from './fetcherDefinitionRegistry'
+
+const FALLBACK_SOURCE = 'baostock'
 
 export const routerDataFetcher: DataFetcher = (source, config) => {
-  switch (source) {
-    case 'baostock':
-      return baostockDataFetcher(source, config)
-    case 'tradingview':
-      return tradingviewDataFetcher(source, config)
-    case 'mock-100':
-      return hundredMockDataFetcher(source, config)
-    case 'mock-10000':
-      return thousandMockDataFetcher(source, config)
-    default:
-      return hundredMockDataFetcher(source, config)
+  const def = getRegisteredFetcher(source)
+  if (!def) {
+    console.warn(
+      `[DataFetcher] unknown source "${source}", falling back to "${FALLBACK_SOURCE}"`,
+    )
+    const fallback = getRegisteredFetcher(FALLBACK_SOURCE)
+    if (!fallback) {
+      return Promise.reject(
+        new Error(
+          `[DataFetcher] no fetcher registered for "${source}" and no fallback available`,
+        ),
+      )
+    }
+    return fallback.fetcher(source, config)
+  }
+
+  if (!fetcherSupportsPeriod(source, config.period)) {
+    return Promise.reject(
+      new Error(
+        `[DataFetcher] "${source}" does not support period "${config.period}". Supported: ${def.capabilities?.join(', ') ?? 'none'}`,
+      ),
+    )
   }
+
+  return def.fetcher(source, config)
 }