@backtest-kit/ui 0.0.1

package/build/index.mjs

@@ -0,0 +1,1312 @@
+import http from 'http';
+import { isObject, singleshot, pickDocuments, str, memoize, errorData, getErrorMessage } from 'functools-kit';
+import micro from 'micro';
+import Router from 'router';
+import finalhandler from 'finalhandler';
+import serveHandler from 'serve-handler';
+import os from 'os';
+import { createActivator } from 'di-kit';
+import { Exchange, Notification, Storage } from 'backtest-kit';
+import fs, { readdir, readFile } from 'fs/promises';
+import path, { join, dirname } from 'path';
+import { createRequire } from 'module';
+import { existsSync } from 'fs';
+
+const CC_WWWROOT_PATH = process.env.CC_WWWROOT_PATH || "";
+const CC_WWWROOT_HOST = process.env.CC_WWWROOT_HOST || "0.0.0.0";
+const CC_WWWROOT_PORT = parseInt(process.env.CC_WWWROOT_PORT) || 60050;
+const CC_ENABLE_MOCK = !!parseInt(process.env.CC_ENABLE_MOCK) || false;
+
+const router$6 = Router({
+    params: true,
+});
+router$6.get("/api/v1/health/health_check", async (req, res) => {
+    const [cpuLoad] = os.loadavg();
+    return await micro.send(res, 200, {
+        uptime: process.uptime(),
+        memoryUsage: process.memoryUsage(),
+        cpuLoad,
+        pid: process.pid,
+    });
+});
+
+function omit(obj, ...keys) {
+    const keySet = new Set(keys);
+    return Object.keys(obj).reduce((acc, key) => {
+        if (keySet.has(key)) {
+            return acc;
+        }
+        const value = obj[key];
+        if (isObject(value)) {
+            acc[key] = omit(value, ...keys);
+        }
+        else {
+            acc[key] = value;
+        }
+        return acc;
+    }, {});
+}
+
+const { provide, inject, init, override } = createActivator("ui");
+
+const baseServices$1 = {
+    loggerService: Symbol("loggerService"),
+    exchangeService: Symbol('exchangeService'),
+};
+const connectionServices$1 = {
+    symbolConnectionService: Symbol("symbolConnectionService"),
+};
+const metaServices$1 = {
+    symbolMetaService: Symbol("symbolMetaService"),
+};
+const mockServices$1 = {
+    notificationMockService: Symbol("notificationMockService"),
+    storageMockService: Symbol("storageMockService"),
+    exchangeMockService: Symbol("exchangeMockService"),
+};
+const viewServices$1 = {
+    notificationViewService: Symbol("notificationViewService"),
+    storageViewService: Symbol("storageViewService"),
+    exchangeViewService: Symbol("exchangeViewService"),
+};
+const TYPES = {
+    ...baseServices$1,
+    ...connectionServices$1,
+    ...metaServices$1,
+    ...mockServices$1,
+    ...viewServices$1,
+};
+
+const INTERVAL_MINUTES = {
+    "1m": 1,
+    "3m": 3,
+    "5m": 5,
+    "15m": 15,
+    "30m": 30,
+    "1h": 60,
+    "2h": 120,
+    "4h": 240,
+    "6h": 360,
+    "8h": 480,
+};
+const STEP_TICKS = {
+    "1m": 960,
+    "3m": 960,
+    "5m": 960,
+    "15m": 960,
+    "30m": 960,
+    "1h": 960,
+    "2h": 960,
+    "4h": 960,
+    "6h": 960,
+    "8h": 960,
+};
+class ExchangeService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.getRangeCandles = async (dto) => {
+            this.loggerService.log("exchangeService getRangeCandles", {
+                dto,
+            });
+            const step = INTERVAL_MINUTES[dto.interval];
+            const tick = STEP_TICKS[dto.interval];
+            if (!step || !tick) {
+                throw new Error(`Unsupported interval: ${dto.interval}`);
+            }
+            const offsetMs = tick * step * 60 * 1000;
+            const sDate = dto.signalStartTime - offsetMs;
+            const eDate = Math.min(dto.signalStopTime + offsetMs, Date.now() - 1);
+            return await Exchange.getRawCandles(dto.symbol, dto.interval, {
+                exchangeName: dto.exchangeName,
+            }, undefined, sDate, eDate);
+        };
+        this.getPointCandles = async (dto) => {
+            this.loggerService.log("exchangeService getPointCandles", {
+                dto,
+            });
+            const step = INTERVAL_MINUTES[dto.interval];
+            const tick = STEP_TICKS[dto.interval];
+            if (!step || !tick) {
+                throw new Error(`Unsupported interval: ${dto.interval}`);
+            }
+            const offsetMs = tick * step * 60 * 1000;
+            const sDate = dto.currentTime - offsetMs;
+            const eDate = Math.min(dto.currentTime + offsetMs, Date.now() - 1);
+            return await Exchange.getRawCandles(dto.symbol, dto.interval, {
+                exchangeName: dto.exchangeName,
+            }, undefined, sDate, eDate);
+        };
+    }
+}
+
+const NOOP_LOGGER = {
+    log() {
+    },
+    debug() {
+    },
+    info() {
+    },
+    warn() {
+    },
+};
+class LoggerService {
+    constructor() {
+        this._commonLogger = NOOP_LOGGER;
+        this.log = async (topic, ...args) => {
+            await this._commonLogger.log(topic, ...args);
+        };
+        this.debug = async (topic, ...args) => {
+            await this._commonLogger.debug(topic, ...args);
+        };
+        this.info = async (topic, ...args) => {
+            await this._commonLogger.info(topic, ...args);
+        };
+        this.warn = async (topic, ...args) => {
+            await this._commonLogger.warn(topic, ...args);
+        };
+        this.setLogger = (logger) => {
+            this._commonLogger = logger;
+        };
+    }
+}
+
+const MOCK_PATH$1 = "./mock/notifications.json";
+const READ_NOTIFICATION_LIST_FN = singleshot(async () => {
+    const data = await fs.readFile(MOCK_PATH$1, "utf-8");
+    return JSON.parse(data);
+});
+const DEFAULT_LIMIT$1 = 25;
+const DEFAULT_OFFSET$1 = 0;
+const CREATE_FILTER_LIST_FN$1 = (filterData) => Object.keys(filterData).map((key) => (row) => new RegExp(filterData[key], "i").test(row[key]));
+class NotificationMockService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.findByFilter = async (filterData, limit = DEFAULT_LIMIT$1, offset = DEFAULT_OFFSET$1) => {
+            this.loggerService.log("notificationMockService findByFilter", {
+                filterData,
+                limit,
+                offset,
+            });
+            const iter = pickDocuments(limit, offset);
+            const filterList = CREATE_FILTER_LIST_FN$1(filterData);
+            for (const notification of await this.getList()) {
+                let isOk = true;
+                for (const filterFn of filterList) {
+                    isOk = isOk && filterFn(notification);
+                }
+                if (!isOk) {
+                    continue;
+                }
+                if (iter([notification]).done) {
+                    break;
+                }
+            }
+            return iter().rows;
+        };
+        this.getList = async () => {
+            this.loggerService.log("notificationMockService getList");
+            return await READ_NOTIFICATION_LIST_FN();
+        };
+        this.getOne = async (id) => {
+            this.loggerService.log("notificationMockService getOne");
+            const notificationList = await this.getList();
+            return notificationList.find((item) => item.id === id) ?? null;
+        };
+    }
+}
+
+const MOCK_PATH = "./mock/db";
+const READ_BACKTEST_STORAGE_FN = singleshot(async () => {
+    const dbPath = join(process.cwd(), MOCK_PATH);
+    const files = await readdir(dbPath);
+    const signals = [];
+    for (const file of files) {
+        if (!file.endsWith(".json")) {
+            continue;
+        }
+        const filePath = join(dbPath, file);
+        signals.push(JSON.parse(await readFile(filePath, "utf-8")));
+    }
+    return signals;
+});
+class StorageMockService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.findSignalById = async (signalId) => {
+            this.loggerService.log("storageMockService findSignalById", {
+                signalId,
+            });
+            const signalList = await READ_BACKTEST_STORAGE_FN();
+            const signalMap = new Map(signalList.map((signal) => [signal.id, signal]));
+            const signalValue = signalMap.get(signalId);
+            return signalValue ?? null;
+        };
+        this.listSignalLive = async () => {
+            this.loggerService.log("storageMockService listSignalLive");
+            return Promise.resolve([]);
+        };
+        this.listSignalBacktest = async () => {
+            this.loggerService.log("storageMockService listSignalBacktest");
+            return await READ_BACKTEST_STORAGE_FN();
+        };
+    }
+}
+
+class ExchangeMockService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.storageMockService = inject(TYPES.storageMockService);
+        this.exchangeService = inject(TYPES.exchangeService);
+        this.getSignalCandles = async (signalId, interval) => {
+            this.loggerService.log("exchangeMockService getSignalCandles", {
+                signalId,
+                interval,
+            });
+            const signal = await this.storageMockService.findSignalById(signalId);
+            if (!signal) {
+                throw new Error(`Signal with ID ${signalId} not found`);
+            }
+            const { pendingAt, scheduledAt, createdAt = pendingAt || scheduledAt, updatedAt, } = signal;
+            return await this.exchangeService.getRangeCandles({
+                symbol: signal.symbol,
+                exchangeName: signal.exchangeName,
+                signalStartTime: createdAt,
+                signalStopTime: updatedAt,
+                interval,
+            });
+        };
+    }
+}
+
+const DEFAULT_LIMIT = 25;
+const DEFAULT_OFFSET = 0;
+const CREATE_FILTER_LIST_FN = (filterData) => Object.keys(filterData).map((key) => (row) => new RegExp(filterData[key], "i").test(row[key]));
+class NotificationViewService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.notificationMockService = inject(TYPES.notificationMockService);
+        this.findByFilter = async (filterData, limit = DEFAULT_LIMIT, offset = DEFAULT_OFFSET) => {
+            this.loggerService.log("notificationViewService findByFilter", {
+                filterData,
+                limit,
+                offset,
+            });
+            if (CC_ENABLE_MOCK) {
+                return await this.notificationMockService.findByFilter(filterData, limit, offset);
+            }
+            const iter = pickDocuments(limit, offset);
+            const filterList = CREATE_FILTER_LIST_FN(filterData);
+            for (const notification of await this.getList()) {
+                let isOk = true;
+                for (const filterFn of filterList) {
+                    isOk = isOk && filterFn(notification);
+                }
+                if (!isOk) {
+                    continue;
+                }
+                if (iter([notification]).done) {
+                    break;
+                }
+            }
+            return iter().rows;
+        };
+        this.getList = async () => {
+            this.loggerService.log("notificationViewService getList");
+            if (CC_ENABLE_MOCK) {
+                return await this.notificationMockService.getList();
+            }
+            const notificationList = [];
+            for (const notification of await Notification.getData(false)) {
+                notificationList.push(notification);
+            }
+            for (const notification of await Notification.getData(true)) {
+                notificationList.push(notification);
+            }
+            return notificationList;
+        };
+        this.getOne = async (id) => {
+            this.loggerService.log("notificationViewService getOne", {
+                id,
+            });
+            if (CC_ENABLE_MOCK) {
+                return await this.notificationMockService.getOne(id);
+            }
+            const notificationList = await this.getList();
+            return notificationList.find((item) => item.id === id) ?? null;
+        };
+        this.init = singleshot(async () => {
+            this.loggerService.log("notificationViewService init");
+            if (CC_ENABLE_MOCK) {
+                return;
+            }
+            Notification.enable();
+        });
+    }
+}
+
+class StorageViewService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.storageMockService = inject(TYPES.storageMockService);
+        this.findSignalById = async (signalId) => {
+            this.loggerService.log("storageViewService findSignalById", {
+                signalId,
+            });
+            if (CC_ENABLE_MOCK) {
+                return await this.storageMockService.findSignalById(signalId);
+            }
+            return await Storage.findSignalById(signalId);
+        };
+        this.listSignalLive = async () => {
+            this.loggerService.log("storageViewService listSignalLive");
+            if (CC_ENABLE_MOCK) {
+                return await this.storageMockService.listSignalLive();
+            }
+            return await Storage.listSignalLive();
+        };
+        this.listSignalBacktest = async () => {
+            this.loggerService.log("storageViewService listSignalBacktest");
+            if (CC_ENABLE_MOCK) {
+                return await this.storageMockService.listSignalBacktest();
+            }
+            return await Storage.listSignalBacktest();
+        };
+        this.init = singleshot(async () => {
+            this.loggerService.log("storageViewService init");
+            if (CC_ENABLE_MOCK) {
+                return;
+            }
+            Storage.enable();
+        });
+    }
+}
+
+class ExchangeViewService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.storageViewService = inject(TYPES.storageViewService);
+        this.exchangeService = inject(TYPES.exchangeService);
+        this.exchangeMockService = inject(TYPES.exchangeMockService);
+        this.getSignalCandles = async (signalId, interval) => {
+            this.loggerService.log("exchangeViewService getCandles", {
+                signalId,
+                interval,
+            });
+            if (CC_ENABLE_MOCK) {
+                return await this.exchangeMockService.getSignalCandles(signalId, interval);
+            }
+            const signal = await this.storageViewService.findSignalById(signalId);
+            if (!signal) {
+                throw new Error(`Signal with ID ${signalId} not found`);
+            }
+            const { pendingAt, scheduledAt, createdAt = pendingAt || scheduledAt, updatedAt, } = signal;
+            return await this.exchangeService.getRangeCandles({
+                symbol: signal.symbol,
+                exchangeName: signal.exchangeName,
+                signalStartTime: createdAt,
+                signalStopTime: updatedAt,
+                interval,
+            });
+        };
+    }
+}
+
+const symbol_list = [
+    {
+        icon: "/icon/btc.png",
+        logo: "/icon/128/btc.png",
+        symbol: "BTCUSDT",
+        displayName: "Bitcoin",
+        color: "#F7931A",
+        priority: 50,
+        description: str.newline("Bitcoin - the first and most popular cryptocurrency", "Digital gold with a limited supply of 21 million coins", "Used as a reserve asset and a store of value", "Highly liquid market with large trading volumes"),
+    },
+    {
+        icon: "/icon/eth.png",
+        logo: "/icon/128/eth.png",
+        symbol: "ETHUSDT",
+        color: "#6F42C1",
+        displayName: "Ethereum",
+        priority: 50,
+        description: str.newline("Ethereum - a blockchain platform for smart contracts", "The foundation of DeFi and NFT ecosystems", "Transition to Proof-of-Stake (Ethereum 2.0)", "Second largest cryptocurrency by market capitalization"),
+    },
+    {
+        icon: "/icon/bnb.png",
+        logo: "/icon/128/bnb.png",
+        symbol: "BNBUSDT",
+        color: "#F3BA2F",
+        displayName: "BNB",
+        priority: 50,
+        description: str.newline("Binance Coin - the native token of the largest exchange", "Used for trading fee discounts", "Core of BNB Smart Chain for decentralized apps (DApps)", "Regular token burns reduce the circulating supply"),
+    },
+    {
+        icon: "/icon/xrp.png",
+        logo: "/icon/128/xrp.png",
+        symbol: "XRPUSDT",
+        color: "#23292F",
+        displayName: "Ripple",
+        priority: 100,
+        description: str.newline("XRP - a digital asset for international payments", "Fast and low-cost cross-border transfers", "Used by banks and financial institutions", "Low fees and transaction times of 3-5 seconds"),
+    },
+    {
+        icon: "/icon/sol.png",
+        logo: "/icon/128/sol.png",
+        symbol: "SOLUSDT",
+        color: "#00e676",
+        displayName: "Solana",
+        priority: 100,
+        description: str.newline("Solana - a high-performance blockchain", "Up to 65,000 transactions per second", "A popular platform for NFT and DeFi projects", "Low fees and fast transaction confirmation"),
+    },
+];
+
+const require$2 = createRequire(import.meta.url);
+const getSymbolList = singleshot(() => {
+    try {
+        const modulePath = require$2.resolve(path.join(process.cwd(), `./config/symbol.config.cjs`));
+        console.log(`Using ${modulePath} implementation as symbol.config.cjs`);
+        return require$2(modulePath);
+    }
+    catch (error) {
+        console.log(`Using default implementation for symbol.config.cjs`, error);
+        return symbol_list;
+    }
+});
+class SymbolConnectionService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.getSymbolList = singleshot(async () => {
+            this.loggerService.log("symbolConnectionService getSymbolList");
+            const symbolListRaw = await getSymbolList();
+            const uniqueSymbols = new Set();
+            const symbolList = symbolListRaw
+                .filter((item) => {
+                if (uniqueSymbols.has(item.symbol)) {
+                    return false;
+                }
+                uniqueSymbols.add(item.symbol);
+                return true;
+            })
+                .map(({ priority, displayName, symbol, logo, icon, ...other }, idx) => ({
+                symbol,
+                icon,
+                logo: logo ?? icon,
+                priority: priority ?? idx,
+                displayName: displayName ?? symbol,
+                index: idx,
+                ...other,
+            }));
+            symbolList.sort(({ priority: a_p, index: a_x }, { priority: b_p, index: b_x }) => b_p - a_p || a_x - b_x);
+            return symbolList;
+        });
+        this.init = singleshot(async () => {
+            this.loggerService.log("symbolConnectionService init");
+            getSymbolList();
+        });
+    }
+}
+
+class SymbolMetaService {
+    constructor() {
+        this.symbolConnectionService = inject(TYPES.symbolConnectionService);
+        this.loggerService = inject(TYPES.loggerService);
+        this.getSymbolList = singleshot(async () => {
+            this.loggerService.log("symbolMetaService getSymbolList");
+            const symbolList = await this.symbolConnectionService.getSymbolList();
+            return symbolList.map(({ symbol }) => symbol);
+        });
+        this.getSymbolMap = singleshot(async () => {
+            this.loggerService.log("symbolMetaService getSymbolMap");
+            const symbolList = await this.symbolConnectionService.getSymbolList();
+            return symbolList.reduce((acm, { symbol, ...other }) => ({
+                ...acm,
+                [symbol]: { symbol, ...other },
+            }), {});
+        });
+        this.getSymbol = memoize(([symbol]) => `${symbol}`, async (symbol) => {
+            this.loggerService.log("symbolMetaService getSymbol", {
+                symbol,
+            });
+            const symbolList = await this.symbolConnectionService.getSymbolList();
+            const target = symbolList.find((item) => item.symbol === symbol);
+            if (!target) {
+                throw new Error(`symbolMetaService getSymbol no item found symbol=${symbol}`);
+            }
+            return target;
+        });
+    }
+}
+
+{
+    provide(TYPES.loggerService, () => new LoggerService());
+    provide(TYPES.exchangeService, () => new ExchangeService());
+}
+{
+    provide(TYPES.symbolConnectionService, () => new SymbolConnectionService());
+}
+{
+    provide(TYPES.symbolMetaService, () => new SymbolMetaService());
+}
+{
+    provide(TYPES.notificationMockService, () => new NotificationMockService());
+    provide(TYPES.storageMockService, () => new StorageMockService());
+    provide(TYPES.exchangeMockService, () => new ExchangeMockService());
+}
+{
+    provide(TYPES.notificationViewService, () => new NotificationViewService());
+    provide(TYPES.storageViewService, () => new StorageViewService());
+    provide(TYPES.exchangeViewService, () => new ExchangeViewService());
+}
+
+const baseServices = {
+    loggerService: inject(TYPES.loggerService),
+    exchangeService: inject(TYPES.exchangeService),
+};
+const connectionServices = {
+    symbolConnectionService: inject(TYPES.symbolConnectionService),
+};
+const metaServices = {
+    symbolMetaService: inject(TYPES.symbolMetaService),
+};
+const mockServices = {
+    notificationMockService: inject(TYPES.notificationMockService),
+    storageMockService: inject(TYPES.storageMockService),
+    exchangeMockService: inject(TYPES.exchangeMockService),
+};
+const viewServices = {
+    notificationViewService: inject(TYPES.notificationViewService),
+    storageViewService: inject(TYPES.storageViewService),
+    exchangeViewService: inject(TYPES.exchangeViewService),
+};
+const ioc = {
+    ...baseServices,
+    ...connectionServices,
+    ...metaServices,
+    ...mockServices,
+    ...viewServices,
+};
+init();
+
+const router$5 = Router({
+    params: true,
+});
+// ExchangeMockService endpoints
+router$5.post("/api/v1/mock/candles_signal", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { signalId, interval, requestId, serviceName } = request;
+        const data = await ioc.exchangeMockService.getSignalCandles(signalId, interval);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/candles_signal ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/candles_signal error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+router$5.post("/api/v1/mock/candles_point", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { currentTime, interval, requestId, serviceName, symbol, exchangeName } = request;
+        const data = await ioc.exchangeService.getPointCandles({
+            currentTime,
+            interval,
+            symbol,
+            exchangeName,
+        });
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/candles_point ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/candles_point error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+// NotificationMockService endpoints
+router$5.post("/api/v1/mock/notification_list", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.notificationMockService.getList();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/notification_list ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/notification_list error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+router$5.post("/api/v1/mock/notification_one/:id", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const id = req.params.id;
+        const data = await ioc.notificationMockService.getOne(id);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/notification_one/:id ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/notification_one/:id error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+router$5.post("/api/v1/mock/notification_filter", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, filterData, limit, offset } = request;
+        const data = await ioc.notificationMockService.findByFilter(filterData, limit, offset);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/notification_filter ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/notification_filter error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+// StorageMockService endpoints
+router$5.post("/api/v1/mock/storage_one/:id", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const signalId = req.params.id;
+        const data = await ioc.storageMockService.findSignalById(signalId);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/storage_one/:id ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/storage_one/:id error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+router$5.post("/api/v1/mock/storage_list/live", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.storageMockService.listSignalLive();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/storage_list/live ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/storage_list/live error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+router$5.post("/api/v1/mock/storage_list/backtest", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.storageMockService.listSignalBacktest();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/storage_list/backtest ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/storage_list/backtest error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+
+const router$4 = Router({
+    params: true,
+});
+// ExchangeViewService endpoints
+router$4.post("/api/v1/view/candles_signal", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { signalId, interval, requestId, serviceName } = request;
+        const data = await ioc.exchangeViewService.getSignalCandles(signalId, interval);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/candles_signal ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/candles_signal error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+router$4.post("/api/v1/view/candles_point", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { currentTime, interval, requestId, serviceName, symbol, exchangeName } = request;
+        const data = await ioc.exchangeService.getPointCandles({
+            currentTime,
+            interval,
+            symbol,
+            exchangeName,
+        });
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/candles_point ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/candles_point error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+// NotificationViewService endpoints
+router$4.post("/api/v1/view/notification_list", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.notificationViewService.getList();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/notification_list ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/notification_list error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+router$4.post("/api/v1/view/notification_one/:id", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const id = req.params.id;
+        const data = await ioc.notificationViewService.getOne(id);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/notification_one/:id ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/notification_one/:id error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+router$4.post("/api/v1/view/notification_filter", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, filterData, limit, offset } = request;
+        const data = await ioc.notificationViewService.findByFilter(filterData, limit, offset);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/notification_filter ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/notification_filter error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+// StorageViewService endpoints
+router$4.post("/api/v1/view/storage_one/:id", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const signalId = req.params.id;
+        const data = await ioc.storageViewService.findSignalById(signalId);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/storage_one/:id ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/storage_one/:id error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+router$4.post("/api/v1/view/storage_list/live", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.storageViewService.listSignalLive();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/storage_list/live ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/storage_list/live error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+router$4.post("/api/v1/view/storage_list/backtest", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.storageViewService.listSignalBacktest();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/storage_list/backtest ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/storage_list/backtest error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+
+const require$1 = createRequire(import.meta.url);
+function getModulesPath() {
+    const modulePath = require$1.resolve('@backtest-kit/ui');
+    const basePath = dirname(modulePath);
+    return join(basePath, "../../");
+}
+
+const router$3 = Router({
+    params: true,
+});
+// getModulesPath
+const ASSET_SVG = CC_ENABLE_MOCK
+    ? join(process.cwd(), "node_modules/cryptocurrency-icons/svg/color")
+    : join(getModulesPath(), "cryptocurrency-icons/svg/color");
+const ASSET_128 = CC_ENABLE_MOCK
+    ? join(process.cwd(), "node_modules/cryptocurrency-icons/128/color")
+    : join(getModulesPath(), "cryptocurrency-icons/128/color");
+const ASSET_32 = CC_ENABLE_MOCK
+    ? join(process.cwd(), "node_modules/cryptocurrency-icons/32/color")
+    : join(getModulesPath(), "cryptocurrency-icons/32/color");
+// File caches to avoid repeated disk reads
+const cache128 = new Map();
+const cache32 = new Map();
+const cacheSvg = new Map();
+router$3.get("/icon/128/:filename", async (req, res) => {
+    const filename = req.params.filename;
+    // Check cache first
+    if (cache128.has(filename)) {
+        res.setHeader("Content-Type", "image/png");
+        return await micro.send(res, 200, cache128.get(filename));
+    }
+    const filePath = join(ASSET_128, filename);
+    if (existsSync(filePath)) {
+        const fileBuffer = await readFile(filePath);
+        cache128.set(filename, fileBuffer);
+        res.setHeader("Content-Type", "image/png");
+        return await micro.send(res, 200, fileBuffer);
+    }
+    return await micro.send(res, 404, "File not found (128)");
+});
+router$3.get("/icon/32/:filename", async (req, res) => {
+    const filename = req.params.filename;
+    // Check cache first
+    if (cache32.has(filename)) {
+        res.setHeader("Content-Type", "image/png");
+        return await micro.send(res, 200, cache32.get(filename));
+    }
+    const filePath = join(ASSET_32, filename);
+    if (existsSync(filePath)) {
+        const fileBuffer = await readFile(filePath);
+        cache32.set(filename, fileBuffer);
+        res.setHeader("Content-Type", "image/png");
+        return await micro.send(res, 200, fileBuffer);
+    }
+    return await micro.send(res, 404, "File not found (32)");
+});
+router$3.get("/icon/svg/:filename", async (req, res) => {
+    const filename = req.params.filename;
+    // Check cache first
+    if (cacheSvg.has(filename)) {
+        res.setHeader("Content-Type", "image/svg+xml");
+        return await micro.send(res, 200, cacheSvg.get(filename));
+    }
+    const filePath = join(ASSET_SVG, filename);
+    if (existsSync(filePath)) {
+        const fileBuffer = await readFile(filePath);
+        cacheSvg.set(filename, fileBuffer);
+        res.setHeader("Content-Type", "image/svg+xml");
+        return await micro.send(res, 200, fileBuffer);
+    }
+    return await micro.send(res, 404, "File not found (svg)");
+});
+router$3.get("/icon/:filename", async (req, res) => {
+    const filename = req.params.filename;
+    // Check cache first
+    if (cache32.has(filename)) {
+        res.setHeader("Content-Type", "image/png");
+        return await micro.send(res, 200, cache32.get(filename));
+    }
+    const filePath = join(ASSET_32, filename);
+    if (existsSync(filePath)) {
+        const fileBuffer = await readFile(filePath);
+        cache32.set(filename, fileBuffer);
+        res.setHeader("Content-Type", "image/png");
+        return await micro.send(res, 200, fileBuffer);
+    }
+    return await micro.send(res, 404, "File not found (root)");
+});
+
+const router$2 = Router({
+    params: true,
+});
+router$2.post("/api/v1/dict/symbol/list", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.symbolMetaService.getSymbolList();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/dict/symbol/list ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/dict/symbol/list error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+router$2.post("/api/v1/dict/symbol/map", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.symbolMetaService.getSymbolMap();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/dict/symbol/map ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/dict/symbol/map error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+router$2.post("/api/v1/dict/symbol/one", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, id } = request;
+        const data = await ioc.symbolMetaService.getSymbol(id);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/dict/symbol/one ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/dict/symbol/one error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+
+const require = createRequire(import.meta.url);
+function getPublicPath() {
+    const modulePath = require.resolve('@backtest-kit/ui');
+    const basePath = dirname(modulePath);
+    return join(basePath, "./modules/frontend/build");
+}
+
+const router = Router({
+    params: true,
+});
+router.all("/api/v1/health/*", (req, res) => {
+    return router$6(req, res, finalhandler(req, res));
+});
+router.all("/api/v1/mock/*", (req, res) => {
+    return router$5(req, res, finalhandler(req, res));
+});
+router.all("/api/v1/view/*", (req, res) => {
+    return router$4(req, res, finalhandler(req, res));
+});
+router.all("/icon/*", (req, res) => {
+    return router$3(req, res, finalhandler(req, res));
+});
+router.all("/api/v1/dict/*", (req, res) => {
+    return router$2(req, res, finalhandler(req, res));
+});
+router.get("/*", (req, res) => serveHandler(req, res, {
+    public: CC_ENABLE_MOCK
+        ? CC_WWWROOT_PATH || "./build/modules/frontend/build"
+        : CC_WWWROOT_PATH || getPublicPath(),
+}));
+var router$1 = micro.serve(async (req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Headers", "*");
+    res.setHeader("Access-Control-Allow-Credentials", "true");
+    res.setHeader("Access-Control-Allow-Methods", "GET,PUT,POST,DELETE");
+    return router(req, res, finalhandler(req, res));
+});
+
+const METHOD_NAME_SERVE = "serve.serve";
+const METHOD_NAME_GET_ROUTER = "serve.getRouter";
+const MAX_CONNECTIONS = 1000;
+const SOCKET_TIMEOUT = 60 * 10 * 1000;
+const serveInternal = singleshot((host = CC_WWWROOT_HOST, port = CC_WWWROOT_PORT) => {
+    const server = new http.Server(router$1);
+    server.listen(port, host).addListener("listening", () => {
+        console.log(`Listening on http://${host}:${port}`);
+    });
+    server.maxConnections = MAX_CONNECTIONS;
+    server.setTimeout(SOCKET_TIMEOUT);
+    return () => {
+        server.close();
+        serveInternal.clear();
+    };
+});
+function serve(host, port) {
+    ioc.loggerService.log(METHOD_NAME_SERVE, {
+        host,
+        port,
+    });
+    return serveInternal(host, port);
+}
+function getRouter() {
+    ioc.loggerService.log(METHOD_NAME_GET_ROUTER);
+    return router$1;
+}
+
+const setLogger = (logger) => {
+    ioc.loggerService.setLogger(logger);
+};
+
+export { getModulesPath, getPublicPath, getRouter, ioc as lib, serve, setLogger };