@yuants/app-virtual-exchange 0.11.7 → 0.12.0

package/dist/series-data/fifo-queue.js

@@ -0,0 +1,25 @@
+export const createFifoQueue = () => {
+    let items = [];
+    let head = 0;
+    return {
+        enqueue: (value) => {
+            items.push(value);
+        },
+        dequeue: () => {
+            if (head >= items.length)
+                return undefined;
+            const value = items[head++];
+            if (head > 1024 && head * 2 > items.length) {
+                items = items.slice(head);
+                head = 0;
+            }
+            return value;
+        },
+        size: () => items.length - head,
+        snapshot: (limit = 20) => {
+            const safeLimit = Math.max(0, Math.floor(limit));
+            return items.slice(head, head + safeLimit);
+        },
+    };
+};
+//# sourceMappingURL=fifo-queue.js.map

package/dist/series-data/fifo-queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fifo-queue.js","sourceRoot":"","sources":["../../src/series-data/fifo-queue.ts"],"names":[],"mappings":"AAOA,MAAM,CAAC,MAAM,eAAe,GAAG,GAAiB,EAAE;IAChD,IAAI,KAAK,GAAQ,EAAE,CAAC;IACpB,IAAI,IAAI,GAAG,CAAC,CAAC;IAEb,OAAO;QACL,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;YACjB,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACpB,CAAC;QACD,OAAO,EAAE,GAAG,EAAE;YACZ,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM;gBAAE,OAAO,SAAS,CAAC;YAC3C,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;YAC5B,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE;gBAC1C,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBAC1B,IAAI,GAAG,CAAC,CAAC;aACV;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,IAAI;QAC/B,QAAQ,EAAE,CAAC,KAAK,GAAG,EAAE,EAAE,EAAE;YACvB,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;YACjD,OAAO,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,CAAC,CAAC;QAC7C,CAAC;KACF,CAAC;AACJ,CAAC,CAAC","sourcesContent":["export interface IQueue<T> {\n  enqueue: (value: T) => void;\n  dequeue: () => T | undefined;\n  size: () => number;\n  snapshot: (limit?: number) => T[];\n}\n\nexport const createFifoQueue = <T>(): IQueue<T> => {\n  let items: T[] = [];\n  let head = 0;\n\n  return {\n    enqueue: (value) => {\n      items.push(value);\n    },\n    dequeue: () => {\n      if (head >= items.length) return undefined;\n      const value = items[head++];\n      if (head > 1024 && head * 2 > items.length) {\n        items = items.slice(head);\n        head = 0;\n      }\n      return value;\n    },\n    size: () => items.length - head,\n    snapshot: (limit = 20) => {\n      const safeLimit = Math.max(0, Math.floor(limit));\n      return items.slice(head, head + safeLimit);\n    },\n  };\n};\n"]}

package/dist/series-data/index.js

@@ -0,0 +1,2 @@
+import './scheduler';
+//# sourceMappingURL=index.js.map

package/dist/series-data/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/series-data/index.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,CAAC","sourcesContent":["import './scheduler';\n"]}

package/dist/series-data/scheduler.js

@@ -0,0 +1,568 @@
+var _a, _b;
+import { encodeInterestRateSeriesId } from '@yuants/data-interest-rate';
+import { encodeOHLCSeriesId } from '@yuants/data-ohlc';
+import { parseInterestRateServiceMetadataFromSchema, parseOHLCServiceMetadataFromSchema, } from '@yuants/exchange';
+import { Terminal } from '@yuants/protocol';
+import { escapeSQL, requestSQL } from '@yuants/sql';
+import { convertDurationToOffset, encodePath, formatTime } from '@yuants/utils';
+import { catchError, defer, EMPTY, filter, from, map, mergeMap, repeat, tap, timer, toArray } from 'rxjs';
+import { createFifoQueue } from './fifo-queue';
+const terminal = Terminal.fromNodeEnv();
+const isEnabled = process.env.VEX_SERIES_DATA_ENABLED === '1';
+const onlyProductIdPrefix = ((_a = process.env.VEX_SERIES_DATA_ONLY_PRODUCT_ID_PREFIX) !== null && _a !== void 0 ? _a : '').trim();
+const CONFIG = {
+    tickIntervalMs: 1000,
+    scanFullLoopIntervalMs: 5 * 60000,
+    /**
+     * Maximum number of inflight series data ingest requests.
+     */
+    maxInflight: 20,
+    /**
+     * Only run tail jobs when the global head backlog is below this threshold.
+     */
+    tailOnlyWhenGlobalHeadBelow: 20,
+    defaultInterestRateHeadLagMs: 8 * 60 * 60000,
+    defaultForwardSeedWindowMs: 24 * 60 * 60000,
+    maxBackoffMs: 5 * 60000,
+    backoffStepMs: 5000,
+};
+const capabilities = [];
+const mapCapKeyToCapability = new Map();
+const mapCapKeyToState = new Map();
+const mapSeriesKeyToState = new Map();
+let inflight = 0;
+let scanIndex = 0;
+let capRunIndex = 0;
+const LOG_QUEUE_INTERVAL_MS = Number((_b = process.env.VEX_SERIES_DATA_LOG_QUEUE_INTERVAL_MS) !== null && _b !== void 0 ? _b : '10000');
+const getOrCreateCapState = (capKey) => {
+    const existing = mapCapKeyToState.get(capKey);
+    if (existing)
+        return existing;
+    const next = {
+        capKey,
+        headQueue: createFifoQueue(),
+        tailQueue: createFifoQueue(),
+        pendingHead: new Set(),
+        pendingTail: new Set(),
+        inflight: false,
+        nextEligibleAt: 0,
+        backoffMs: 0,
+    };
+    mapCapKeyToState.set(capKey, next);
+    return next;
+};
+const computeSeriesId = (seriesType, product_id, duration) => {
+    if (seriesType === 'ohlc')
+        return encodeOHLCSeriesId(product_id, duration !== null && duration !== void 0 ? duration : '');
+    return encodeInterestRateSeriesId(product_id);
+};
+const getOrCreateSeriesState = (params) => {
+    const { capKey, seriesType, product_id, duration, direction } = params;
+    const table_name = seriesType === 'ohlc' ? 'ohlc_v2' : 'interest_rate';
+    const series_id = computeSeriesId(seriesType, product_id, duration);
+    const seriesKey = encodePath(table_name, direction, product_id, duration !== null && duration !== void 0 ? duration : '');
+    const existing = mapSeriesKeyToState.get(seriesKey);
+    if (existing) {
+        existing.capKey = capKey;
+        return existing;
+    }
+    const next = {
+        capKey,
+        seriesKey,
+        seriesType,
+        table_name,
+        series_id,
+        product_id,
+        duration,
+        direction,
+        ranges: [],
+    };
+    mapSeriesKeyToState.set(seriesKey, next);
+    return next;
+};
+const computeHeadLagMs = (series) => {
+    var _a;
+    if (series.seriesType === 'interest_rate')
+        return CONFIG.defaultInterestRateHeadLagMs;
+    const offset = convertDurationToOffset((_a = series.duration) !== null && _a !== void 0 ? _a : '');
+    if (!isFinite(offset) || offset <= 0)
+        return 60000;
+    return Math.max(60000, offset);
+};
+const computeOverlapMs = (series) => {
+    var _a;
+    const maxOverlapMs = 60 * 60000;
+    let overlapMs = 60000;
+    if (series.seriesType === 'ohlc') {
+        const offset = convertDurationToOffset((_a = series.duration) !== null && _a !== void 0 ? _a : '');
+        if (isFinite(offset) && offset > 0)
+            overlapMs = offset;
+    }
+    else {
+        overlapMs = 60 * 60000;
+    }
+    if (series.last_window_ms && isFinite(series.last_window_ms) && series.last_window_ms > 0) {
+        overlapMs = Math.min(overlapMs, Math.max(1, series.last_window_ms - 1));
+    }
+    return Math.max(1, Math.min(maxOverlapMs, overlapMs));
+};
+const applyOverlapToRequestTime = (series, baseTime) => {
+    const hasAnyRange = series.union_start_ms !== undefined || series.union_end_ms !== undefined || series.ranges.length > 0;
+    if (!hasAnyRange)
+        return baseTime;
+    const overlapMs = computeOverlapMs(series);
+    if (series.direction === 'backward')
+        return Math.min(baseTime + overlapMs, Date.now());
+    return Math.max(0, baseTime - overlapMs);
+};
+const computeBackoffMs = (current) => {
+    const next = current <= 0 ? CONFIG.backoffStepMs : Math.min(CONFIG.maxBackoffMs, current + CONFIG.backoffStepMs);
+    return next;
+};
+const enqueueCapJob = (capKey, kind, seriesKey) => {
+    const capState = getOrCreateCapState(capKey);
+    const pendingSet = kind === 'head' ? capState.pendingHead : capState.pendingTail;
+    const queue = kind === 'head' ? capState.headQueue : capState.tailQueue;
+    if (pendingSet.has(seriesKey))
+        return;
+    pendingSet.add(seriesKey);
+    queue.enqueue({ kind, seriesKey });
+};
+const scheduleSeries = (series) => {
+    const now = Date.now();
+    const headLagMs = computeHeadLagMs(series);
+    const needHead = series.union_end_ms === undefined || now - series.union_end_ms > headLagMs;
+    if (needHead) {
+        enqueueCapJob(series.capKey, 'head', series.seriesKey);
+        return;
+    }
+    if (series.union_start_ms === undefined)
+        return;
+    enqueueCapJob(series.capKey, 'tail', series.seriesKey);
+};
+const mergeRangesAndGetUnion = async (series_id, table_name) => {
+    const rows = await requestSQL(terminal, `
+    WITH locked AS (
+      SELECT series_id, table_name, start_time, end_time
+      FROM series_data_range
+      WHERE series_id = ${escapeSQL(series_id)} AND table_name = ${escapeSQL(table_name)}
+      ORDER BY start_time ASC, end_time ASC
+      FOR UPDATE
+    ),
+    ordered AS (
+      SELECT
+        start_time,
+        end_time,
+        max(end_time) OVER (
+          ORDER BY start_time ASC, end_time ASC
+          ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
+        ) AS running_end
+      FROM locked
+    ),
+    marks AS (
+      SELECT
+        start_time,
+        end_time,
+        running_end,
+        CASE
+          WHEN start_time >= COALESCE(
+            lag(running_end) OVER (ORDER BY start_time ASC, end_time ASC),
+            '-infinity'::timestamptz
+          ) THEN 1
+          ELSE 0
+        END AS is_new_group
+      FROM ordered
+    ),
+    groups AS (
+      SELECT
+        start_time,
+        end_time,
+        sum(is_new_group) OVER (
+          ORDER BY start_time ASC, end_time ASC
+          ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
+        ) AS grp
+      FROM marks
+    ),
+    merged AS (
+      SELECT min(start_time) AS start_time, max(end_time) AS end_time
+      FROM groups
+      GROUP BY grp
+    ),
+    to_delete AS (
+      SELECT l.series_id, l.table_name, l.start_time, l.end_time
+      FROM locked l
+      WHERE NOT EXISTS (
+        SELECT 1
+        FROM merged m
+        WHERE m.start_time = l.start_time AND m.end_time = l.end_time
+      )
+    ),
+    deleted AS (
+      DELETE FROM series_data_range t
+      USING to_delete d
+      WHERE
+        t.series_id = d.series_id
+        AND t.table_name = d.table_name
+        AND t.start_time = d.start_time
+        AND t.end_time = d.end_time
+      RETURNING 1
+    ),
+    to_insert AS (
+      SELECT m.start_time, m.end_time
+      FROM merged m
+      WHERE NOT EXISTS (
+        SELECT 1
+        FROM locked l
+        WHERE l.start_time = m.start_time AND l.end_time = m.end_time
+      )
+    ),
+    inserted AS (
+      INSERT INTO series_data_range (series_id, table_name, start_time, end_time)
+      SELECT ${escapeSQL(series_id)}, ${escapeSQL(table_name)}, start_time, end_time
+      FROM to_insert
+      ON CONFLICT DO NOTHING
+      RETURNING 1
+    )
+    SELECT start_time, end_time
+    FROM series_data_range
+    WHERE series_id = ${escapeSQL(series_id)} AND table_name = ${escapeSQL(table_name)}
+    ORDER BY start_time ASC, end_time ASC;
+    `);
+    if (rows.length === 0)
+        return { segments: [] };
+    const segments = [];
+    let startMs = Number.POSITIVE_INFINITY;
+    let endMs = Number.NEGATIVE_INFINITY;
+    for (const r of rows) {
+        const s = Date.parse(r.start_time);
+        const e = Date.parse(r.end_time);
+        if (!isNaN(s) && !isNaN(e) && e >= s) {
+            segments.push({ startMs: s, endMs: e });
+            startMs = Math.min(startMs, s);
+            endMs = Math.max(endMs, e);
+        }
+    }
+    if (!isFinite(startMs) || !isFinite(endMs))
+        return { segments };
+    return { segments, union: { startMs, endMs } };
+};
+const findNearestGap = (segments) => {
+    for (let i = segments.length - 2; i >= 0; i--) {
+        const left = segments[i];
+        const right = segments[i + 1];
+        if (left.endMs < right.startMs)
+            return { left, right };
+    }
+};
+const computeTailTime = (series, now) => {
+    var _a, _b, _c, _d, _e;
+    const gap = findNearestGap(series.ranges);
+    if (gap) {
+        return series.direction === 'backward' ? gap.right.startMs : gap.left.endMs;
+    }
+    const first = series.ranges[0];
+    const mostRecent = series.ranges[series.ranges.length - 1];
+    if (series.direction === 'backward') {
+        return (_c = (_b = (_a = series.union_start_ms) !== null && _a !== void 0 ? _a : first === null || first === void 0 ? void 0 : first.startMs) !== null && _b !== void 0 ? _b : mostRecent === null || mostRecent === void 0 ? void 0 : mostRecent.startMs) !== null && _c !== void 0 ? _c : now;
+    }
+    const windowMs = (_d = series.last_window_ms) !== null && _d !== void 0 ? _d : CONFIG.defaultForwardSeedWindowMs;
+    const start = (_e = series.union_start_ms) !== null && _e !== void 0 ? _e : Math.max(0, now - windowMs);
+    return Math.max(0, start - windowMs);
+};
+const computeRequestTime = (series, kind) => {
+    var _a;
+    const now = Date.now();
+    if (series.direction === 'backward') {
+        if (kind === 'head')
+            return applyOverlapToRequestTime(series, now);
+        return applyOverlapToRequestTime(series, computeTailTime(series, now));
+    }
+    const windowMs = (_a = series.last_window_ms) !== null && _a !== void 0 ? _a : CONFIG.defaultForwardSeedWindowMs;
+    if (kind === 'head') {
+        if (series.union_end_ms !== undefined)
+            return applyOverlapToRequestTime(series, series.union_end_ms);
+        return applyOverlapToRequestTime(series, Math.max(0, now - windowMs));
+    }
+    return applyOverlapToRequestTime(series, computeTailTime(series, now));
+};
+const requestIngest = async (series, time) => {
+    var _a;
+    if (series.seriesType === 'ohlc') {
+        const req = {
+            product_id: series.product_id,
+            duration: (_a = series.duration) !== null && _a !== void 0 ? _a : '',
+            direction: series.direction,
+            time,
+        };
+        return terminal.client.requestForResponseData('IngestOHLC', req);
+    }
+    const req = {
+        product_id: series.product_id,
+        direction: series.direction,
+        time,
+    };
+    return terminal.client.requestForResponseData('IngestInterestRate', req);
+};
+const executeJob = async (capState, job) => {
+    const series = mapSeriesKeyToState.get(job.seriesKey);
+    if (!series)
+        return;
+    if (job.kind === 'head')
+        capState.pendingHead.delete(job.seriesKey);
+    else
+        capState.pendingTail.delete(job.seriesKey);
+    try {
+        // make sure each request overlaps existing ranges
+        const time = computeRequestTime(series, job.kind);
+        const result = await requestIngest(series, time);
+        capState.backoffMs = 0;
+        capState.nextEligibleAt = 0;
+        if (!result.range) {
+            capState.backoffMs = computeBackoffMs(capState.backoffMs);
+            capState.nextEligibleAt = Date.now() + capState.backoffMs;
+            scheduleSeries(series);
+            return;
+        }
+        const startMs = Date.parse(result.range.start_time);
+        const endMs = Date.parse(result.range.end_time);
+        if (!isNaN(startMs) && !isNaN(endMs) && endMs > startMs) {
+            series.last_window_ms = endMs - startMs;
+        }
+        const merged = await mergeRangesAndGetUnion(series.series_id, series.table_name);
+        series.ranges = merged.segments;
+        if (merged.union) {
+            series.union_start_ms = merged.union.startMs;
+            series.union_end_ms = merged.union.endMs;
+        }
+        scheduleSeries(series);
+    }
+    catch (e) {
+        capState.backoffMs = computeBackoffMs(capState.backoffMs);
+        capState.nextEligibleAt = Date.now() + capState.backoffMs;
+        console.warn(formatTime(Date.now()), '[VEX][SeriesData]CapFailed', `cap=${capState.capKey}`, `backoff_ms=${capState.backoffMs}`, `${e}`);
+        scheduleSeries(series);
+    }
+};
+const computeGlobalHeadBacklog = () => {
+    let total = 0;
+    for (const s of mapCapKeyToState.values()) {
+        total += s.headQueue.size();
+    }
+    return total;
+};
+const pickNextRunnableCap = (now) => {
+    if (capabilities.length === 0)
+        return;
+    const n = capabilities.length;
+    for (let i = 0; i < n; i++) {
+        // Round-robin pick
+        const cap = capabilities[capRunIndex++ % n];
+        const capState = getOrCreateCapState(cap.capKey);
+        if (capState.inflight)
+            continue;
+        if (capState.nextEligibleAt > now)
+            continue;
+        if (capState.headQueue.size() === 0 && capState.tailQueue.size() === 0)
+            continue;
+        return capState;
+    }
+};
+const dequeueFromCap = (capState, canRunTail) => {
+    const head = capState.headQueue.dequeue();
+    if (head)
+        return { job: head, kind: 'head' };
+    if (!canRunTail)
+        return;
+    const tail = capState.tailQueue.dequeue();
+    if (!tail)
+        return;
+    return { job: tail, kind: 'tail' };
+};
+const scanProductsOnce = async () => {
+    var _a;
+    if (capabilities.length === 0)
+        return;
+    const now = Date.now();
+    const cap = capabilities[scanIndex++ % capabilities.length];
+    if (cap.nextScanAt > now)
+        return;
+    const where = [
+        `product_id LIKE ${escapeSQL(`${cap.product_id_prefix}%`)}`,
+        onlyProductIdPrefix ? `product_id LIKE ${escapeSQL(`${onlyProductIdPrefix}%`)}` : '',
+        cap.seriesType === 'interest_rate' ? `COALESCE(no_interest_rate, false) = false` : '',
+    ]
+        .filter(Boolean)
+        .join(' AND ');
+    const rows = await requestSQL(terminal, `
+    SELECT product_id
+    FROM product
+    WHERE ${where}
+    ORDER BY product_id ASC
+    `);
+    cap.nextScanAt = now + CONFIG.scanFullLoopIntervalMs;
+    for (const row of rows) {
+        if (cap.seriesType === 'ohlc') {
+            for (const duration of (_a = cap.duration_list) !== null && _a !== void 0 ? _a : []) {
+                const series = getOrCreateSeriesState({
+                    capKey: cap.capKey,
+                    seriesType: 'ohlc',
+                    product_id: row.product_id,
+                    duration,
+                    direction: cap.direction,
+                });
+                scheduleSeries(series);
+            }
+        }
+        else {
+            const series = getOrCreateSeriesState({
+                capKey: cap.capKey,
+                seriesType: 'interest_rate',
+                product_id: row.product_id,
+                direction: cap.direction,
+            });
+            scheduleSeries(series);
+        }
+    }
+};
+const tick = async () => {
+    if (!isEnabled)
+        return;
+    try {
+        await scanProductsOnce();
+    }
+    catch (e) {
+        console.error(formatTime(Date.now()), '[VEX][SeriesData]ScanFailed', `${e}`);
+    }
+    const now = Date.now();
+    while (inflight < CONFIG.maxInflight) {
+        const capState = pickNextRunnableCap(now);
+        if (!capState)
+            return;
+        const globalHeadBacklog = computeGlobalHeadBacklog();
+        const canRunTail = globalHeadBacklog < CONFIG.tailOnlyWhenGlobalHeadBelow && capState.headQueue.size() === 0;
+        const next = dequeueFromCap(capState, canRunTail);
+        if (!next)
+            return;
+        capState.inflight = true;
+        inflight++;
+        executeJob(capState, next.job).finally(() => {
+            capState.inflight = false;
+            inflight--;
+        });
+    }
+};
+if (!isEnabled) {
+    console.info(formatTime(Date.now()), '[VEX][SeriesData]Disabled', 'VEX_SERIES_DATA_ENABLED!=1');
+}
+else {
+    terminal.server.provideService('VEX/SeriesData/Peek', {}, async () => {
+        const now = Date.now();
+        const caps = capabilities.map((cap) => {
+            const s = getOrCreateCapState(cap.capKey);
+            return {
+                capKey: cap.capKey,
+                method: cap.method,
+                product_id_prefix: cap.product_id_prefix,
+                direction: cap.direction,
+                head_queue_size: s.headQueue.size(),
+                tail_queue_size: s.tailQueue.size(),
+                inflight: s.inflight,
+                backoff_ms: s.backoffMs,
+                nextEligibleAt: s.nextEligibleAt > now ? formatTime(s.nextEligibleAt) : undefined,
+            };
+        });
+        return {
+            res: {
+                code: 0,
+                message: 'OK',
+                data: {
+                    enabled: true,
+                    only_product_id_prefix: onlyProductIdPrefix || undefined,
+                    inflight,
+                    cap_count: capabilities.length,
+                    global_head_backlog: computeGlobalHeadBacklog(),
+                    series_count: mapSeriesKeyToState.size,
+                    caps: caps.slice(0, 50),
+                },
+            },
+        };
+    });
+    // Setup trace log
+    timer(0, LOG_QUEUE_INTERVAL_MS).subscribe(() => {
+        const now = Date.now();
+        const caps = capabilities
+            .map((cap) => {
+            const s = getOrCreateCapState(cap.capKey);
+            return {
+                capKey: cap.capKey,
+                head: s.headQueue.size(),
+                tail: s.tailQueue.size(),
+                inflight: s.inflight,
+                backoffMs: s.backoffMs,
+                nextEligibleAt: s.nextEligibleAt,
+            };
+        })
+            .filter((x) => x.inflight || x.head > 0 || x.tail > 0 || x.nextEligibleAt > now)
+            .slice(0, 20)
+            .map((x) => `cap=${x.capKey} head=${x.head} tail=${x.tail} inflight=${x.inflight ? 1 : 0} backoff_ms=${x.backoffMs}${x.nextEligibleAt > now ? ` next=${formatTime(x.nextEligibleAt)}` : ''}`);
+        console.info(formatTime(now), '[VEX][SeriesData]Queues', `inflight=${inflight}`, `cap_count=${capabilities.length}`, `global_head_backlog=${computeGlobalHeadBacklog()}`, `series_count=${mapSeriesKeyToState.size}`, caps.length ? `caps=[${caps.join(' | ')}]` : 'caps=[]');
+    });
+    terminal.terminalInfos$
+        .pipe(mergeMap((terminalInfos) => from(terminalInfos).pipe(mergeMap((terminalInfo) => from(Object.values(terminalInfo.serviceInfo || {})).pipe(filter((serviceInfo) => serviceInfo.method === 'IngestOHLC' || serviceInfo.method === 'IngestInterestRate'), map((serviceInfo) => {
+        try {
+            if (serviceInfo.method === 'IngestOHLC') {
+                const meta = parseOHLCServiceMetadataFromSchema(serviceInfo.schema);
+                const capKey = encodePath('IngestOHLC', meta.product_id_prefix, meta.direction);
+                const existing = mapCapKeyToCapability.get(capKey);
+                const duration_list = [...new Set(meta.duration_list)].sort();
+                if (existing) {
+                    existing.duration_list = duration_list;
+                    return existing;
+                }
+                return {
+                    capKey,
+                    method: 'IngestOHLC',
+                    seriesType: 'ohlc',
+                    product_id_prefix: meta.product_id_prefix,
+                    direction: meta.direction,
+                    duration_list,
+                    nextScanAt: 0,
+                };
+            }
+            const meta = parseInterestRateServiceMetadataFromSchema(serviceInfo.schema);
+            const capKey = encodePath('IngestInterestRate', meta.product_id_prefix, meta.direction);
+            const existing = mapCapKeyToCapability.get(capKey);
+            if (existing)
+                return existing;
+            return {
+                capKey,
+                method: 'IngestInterestRate',
+                seriesType: 'interest_rate',
+                product_id_prefix: meta.product_id_prefix,
+                direction: meta.direction,
+                nextScanAt: 0,
+            };
+        }
+        catch (_a) {
+            console.info(formatTime(Date.now()), '[VEX][SeriesData]ParseServiceMetadataFailed', `method=${serviceInfo.method}`, `terminal_id=${terminalInfo.terminal_id}`);
+            return;
+        }
+    }), filter((x) => !!x))), toArray(), tap((nextCaps) => {
+        const nextMap = new Map();
+        for (const cap of nextCaps) {
+            nextMap.set(cap.capKey, cap);
+        }
+        mapCapKeyToCapability.clear();
+        nextMap.forEach((v, k) => mapCapKeyToCapability.set(k, v));
+        capabilities.length = 0;
+        nextMap.forEach((v) => capabilities.push(v));
+    }))))
+        .subscribe();
+    defer(() => from(tick()))
+        .pipe(catchError((e) => {
+        console.error(formatTime(Date.now()), '[VEX][SeriesData]TickError', `${e}`);
+        return EMPTY;
+    }), repeat({ delay: CONFIG.tickIntervalMs }))
+        .subscribe();
+}
+//# sourceMappingURL=scheduler.js.map