@backtest-kit/ui 3.8.0 → 5.0.0

package/build/index.cjs

@@ -68,12 +68,14 @@ const mockServices$1 = {
     storageMockService: Symbol("storageMockService"),
     exchangeMockService: Symbol("exchangeMockService"),
     logMockService: Symbol("logMockService"),
+    statusMockService: Symbol("statusMockService"),
 };
 const viewServices$1 = {
     notificationViewService: Symbol("notificationViewService"),
     storageViewService: Symbol("storageViewService"),
     exchangeViewService: Symbol("exchangeViewService"),
     logViewService: Symbol("logViewService"),
+    statusViewService: Symbol("statusViewService"),
 };
 const TYPES = {
     ...baseServices$1,
@@ -176,9 +178,9 @@ class LoggerService {
     }
 }
 
-const MOCK_PATH$2 = "./mock/notifications.json";
+const MOCK_PATH$3 = "./mock/notifications.json";
 const READ_NOTIFICATION_LIST_FN = functoolsKit.singleshot(async () => {
-    const data = await fs.readFile(MOCK_PATH$2, "utf-8");
+    const data = await fs.readFile(MOCK_PATH$3, "utf-8");
     return JSON.parse(data);
 });
 const DEFAULT_LIMIT$3 = 25;
@@ -238,9 +240,9 @@ class NotificationMockService {
     }
 }
 
-const MOCK_PATH$1 = "./mock/db";
+const MOCK_PATH$2 = "./mock/db";
 const READ_BACKTEST_STORAGE_FN = functoolsKit.singleshot(async () => {
-    const dbPath = path.join(process.cwd(), MOCK_PATH$1);
+    const dbPath = path.join(process.cwd(), MOCK_PATH$2);
     const files = await fs.readdir(dbPath);
     const signals = [];
     for (const file of files) {
@@ -275,6 +277,7 @@ class StorageMockService {
     }
 }
 
+const MS_PER_MINUTE$1 = 60000;
 class ExchangeMockService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
@@ -298,12 +301,31 @@ class ExchangeMockService {
                 interval,
             });
         };
+        this.getLiveCandles = async (signalId, interval) => {
+            this.loggerService.log("exchangeMockService getLiveCandles", {
+                signalId,
+                interval,
+            });
+            const signal = await this.storageMockService.findSignalById(signalId);
+            if (!signal) {
+                throw new Error(`Signal with ID ${signalId} not found`);
+            }
+            const { pendingAt, scheduledAt, minuteEstimatedTime, } = signal;
+            const eventAt = pendingAt || scheduledAt;
+            return await this.exchangeService.getRangeCandles({
+                symbol: signal.symbol,
+                exchangeName: signal.exchangeName,
+                signalStartTime: eventAt,
+                signalStopTime: eventAt + minuteEstimatedTime * MS_PER_MINUTE$1,
+                interval,
+            });
+        };
     }
 }
 
-const MOCK_PATH = "./mock/logs.json";
+const MOCK_PATH$1 = "./mock/logs.json";
 const READ_LOG_LIST_FN = functoolsKit.singleshot(async () => {
-    const data = await fs.readFile(MOCK_PATH, "utf-8");
+    const data = await fs.readFile(MOCK_PATH$1, "utf-8");
     return JSON.parse(data);
 });
 const DEFAULT_LIMIT$2 = 25;
@@ -351,6 +373,68 @@ class LogMockService {
     }
 }
 
+const MOCK_PATH = "./mock/status.json";
+const READ_STATUS_LIST_FN = functoolsKit.singleshot(async () => {
+    const data = await fs.readFile(MOCK_PATH, "utf-8");
+    return JSON.parse(data);
+});
+class StatusMockService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.getStatusList = async () => {
+            this.loggerService.log("statusMockService getStatusList");
+            const list = await READ_STATUS_LIST_FN();
+            return list.map(({ id, symbol, strategyName, exchangeName }) => ({
+                id,
+                symbol,
+                strategyName,
+                exchangeName,
+                status: "pending",
+            }));
+        };
+        this.getStatusMap = async () => {
+            this.loggerService.log("statusMockService getStatusMap");
+            const list = await this.getStatusList();
+            return list.reduce((acm, cur) => ({ ...acm, [cur.id]: cur }), {});
+        };
+        this.getStatusOne = async (id) => {
+            this.loggerService.log("statusMockService getStatusOne", { id });
+            const list = await READ_STATUS_LIST_FN();
+            const signal = list.find((s) => s.id === id);
+            if (!signal) {
+                return null;
+            }
+            const positionEntries = signal._entry ?? [];
+            const positionLevels = positionEntries.map((e) => e.price);
+            const positionPartials = signal._partial ?? [];
+            return {
+                signalId: signal.signalId,
+                position: signal.position,
+                symbol: signal.symbol,
+                exchangeName: signal.exchangeName,
+                strategyName: signal.strategyName,
+                totalEntries: signal.totalEntries,
+                totalPartials: signal.totalPartials,
+                originalPriceStopLoss: signal.originalPriceStopLoss,
+                originalPriceTakeProfit: signal.originalPriceTakeProfit,
+                originalPriceOpen: signal.originalPriceOpen,
+                priceOpen: signal.priceOpen,
+                priceTakeProfit: signal.priceTakeProfit,
+                priceStopLoss: signal.priceStopLoss,
+                pnlPercentage: signal.pnl.pnlPercentage,
+                pnlCost: signal.pnl.pnlCost,
+                pnlEntries: signal.pnl.pnlEntries,
+                partialExecuted: signal.partialExecuted,
+                minuteEstimatedTime: signal.minuteEstimatedTime,
+                pendingAt: signal.pendingAt,
+                positionLevels,
+                positionEntries,
+                positionPartials,
+            };
+        };
+    }
+}
+
 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]));
@@ -495,6 +579,7 @@ class StorageViewService {
     }
 }
 
+const MS_PER_MINUTE = 60000;
 class ExchangeViewService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
@@ -522,6 +607,28 @@ class ExchangeViewService {
                 interval,
             });
         };
+        this.getLiveCandles = async (signalId, interval) => {
+            this.loggerService.log("exchangeViewService getLiveCandles", {
+                signalId,
+                interval,
+            });
+            if (CC_ENABLE_MOCK) {
+                return await this.exchangeMockService.getLiveCandles(signalId, interval);
+            }
+            const signal = await this.storageViewService.findSignalById(signalId);
+            if (!signal) {
+                throw new Error(`Signal with ID ${signalId} not found`);
+            }
+            const { pendingAt, scheduledAt, minuteEstimatedTime, } = signal;
+            const eventAt = pendingAt || scheduledAt;
+            return await this.exchangeService.getRangeCandles({
+                symbol: signal.symbol,
+                exchangeName: signal.exchangeName,
+                signalStartTime: eventAt,
+                signalStopTime: eventAt + minuteEstimatedTime * MS_PER_MINUTE,
+                interval,
+            });
+        };
     }
 }
 
@@ -580,6 +687,100 @@ class LogViewService {
     }
 }
 
+class StatusViewService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.statusMockService = inject(TYPES.statusMockService);
+        this.getStatusList = async () => {
+            this.loggerService.log("statusViewService getStatusList");
+            if (CC_ENABLE_MOCK) {
+                const liveList = await this.statusMockService.getStatusList();
+                return liveList.filter(({ status }) => status === "pending");
+            }
+            return await backtestKit.Live.list();
+        };
+        this.getStatusMap = async () => {
+            this.loggerService.log("statusViewService getStatusMap");
+            if (CC_ENABLE_MOCK) {
+                return await this.statusMockService.getStatusMap();
+            }
+            const liveList = await backtestKit.Live.list();
+            return liveList
+                .filter(({ status }) => status === "pending")
+                .reduce((acm, cur) => ({ ...acm, [cur.id]: cur }), {});
+        };
+        this.getStatusOne = async (id) => {
+            this.loggerService.log("statusViewService getStatusOne", {
+                id,
+            });
+            if (CC_ENABLE_MOCK) {
+                return await this.statusMockService.getStatusOne(id);
+            }
+            const liveList = await backtestKit.Live.list();
+            const liveOne = liveList.find((live) => live.id === id);
+            if (!liveOne) {
+                throw new Error(`Live with id ${id} not found`);
+            }
+            const { symbol, strategyName, exchangeName } = liveOne;
+            const currentPrice = await backtestKit.Exchange.getAveragePrice(symbol, {
+                exchangeName,
+            });
+            const pendingSignal = await backtestKit.Live.getPendingSignal(symbol, currentPrice, {
+                strategyName,
+                exchangeName,
+            });
+            if (!pendingSignal) {
+                return null;
+            }
+            const positionLevels = await backtestKit.Live.getPositionLevels(symbol, {
+                strategyName,
+                exchangeName,
+            });
+            if (!positionLevels) {
+                return null;
+            }
+            const positionEntries = await backtestKit.Live.getPositionEntries(symbol, {
+                strategyName,
+                exchangeName,
+            });
+            if (!positionEntries) {
+                return null;
+            }
+            const positionPartials = await backtestKit.Live.getPositionPartials(symbol, {
+                strategyName,
+                exchangeName,
+            });
+            if (!positionPartials) {
+                return null;
+            }
+            return {
+                signalId: pendingSignal.id,
+                position: pendingSignal.position,
+                symbol: pendingSignal.symbol,
+                exchangeName: pendingSignal.exchangeName,
+                strategyName: pendingSignal.strategyName,
+                totalEntries: pendingSignal.totalEntries,
+                totalPartials: pendingSignal.totalPartials,
+                originalPriceStopLoss: pendingSignal.originalPriceStopLoss,
+                originalPriceTakeProfit: pendingSignal.originalPriceTakeProfit,
+                originalPriceOpen: pendingSignal.originalPriceOpen,
+                priceOpen: pendingSignal.priceOpen,
+                priceTakeProfit: pendingSignal.priceTakeProfit,
+                priceStopLoss: pendingSignal.priceStopLoss,
+                pnlPercentage: pendingSignal.pnl.pnlPercentage,
+                pnlCost: pendingSignal.pnl.pnlCost,
+                pnlEntries: pendingSignal.pnl.pnlEntries,
+                partialExecuted: pendingSignal.partialExecuted,
+                pendingAt: pendingSignal.pendingAt,
+                minuteEstimatedTime: pendingSignal.minuteEstimatedTime,
+                positionEntries,
+                positionLevels,
+                positionPartials,
+            };
+        };
+    }
+}
+
 const symbol_list = [
     {
         icon: "/icon/btc.png",
@@ -764,12 +965,14 @@ class PriceConnectionService {
     provide(TYPES.storageMockService, () => new StorageMockService());
     provide(TYPES.exchangeMockService, () => new ExchangeMockService());
     provide(TYPES.logMockService, () => new LogMockService());
+    provide(TYPES.statusMockService, () => new StatusMockService());
 }
 {
     provide(TYPES.notificationViewService, () => new NotificationViewService());
     provide(TYPES.storageViewService, () => new StorageViewService());
     provide(TYPES.exchangeViewService, () => new ExchangeViewService());
     provide(TYPES.logViewService, () => new LogViewService());
+    provide(TYPES.statusViewService, () => new StatusViewService());
 }
 
 const baseServices = {
@@ -788,12 +991,14 @@ const mockServices = {
     storageMockService: inject(TYPES.storageMockService),
     exchangeMockService: inject(TYPES.exchangeMockService),
     logMockService: inject(TYPES.logMockService),
+    statusMockService: inject(TYPES.statusMockService),
 };
 const viewServices = {
     notificationViewService: inject(TYPES.notificationViewService),
     storageViewService: inject(TYPES.storageViewService),
     exchangeViewService: inject(TYPES.exchangeViewService),
     logViewService: inject(TYPES.logViewService),
+    statusViewService: inject(TYPES.statusViewService),
 };
 const ioc = {
     ...baseServices,
@@ -1127,6 +1332,92 @@ router$6.post("/api/v1/mock/log_filter", async (req, res) => {
         });
     }
 });
+router$6.post("/api/v1/mock/candles_live", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { signalId, interval, requestId, serviceName } = request;
+        const data = await ioc.exchangeMockService.getLiveCandles(signalId, interval);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/candles_live ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/candles_live error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+// StatusMockService endpoints
+router$6.post("/api/v1/mock/status_list", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.statusMockService.getStatusList();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/status_list ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/status_list error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$6.post("/api/v1/mock/status_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.statusMockService.getStatusOne(id);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/status_one/:id ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/status_one/:id error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
 
 const router$5 = Router({
     params: true,
@@ -1193,6 +1484,34 @@ router$5.post("/api/v1/view/candles_point", async (req, res) => {
         });
     }
 });
+router$5.post("/api/v1/view/candles_live", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { signalId, interval, requestId, serviceName } = request;
+        const data = await ioc.exchangeViewService.getLiveCandles(signalId, interval);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/candles_live ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/candles_live error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
 // NotificationViewService endpoints
 router$5.post("/api/v1/view/notification_list", async (req, res) => {
     try {
@@ -1451,6 +1770,64 @@ router$5.post("/api/v1/view/log_filter", async (req, res) => {
         });
     }
 });
+// StatusViewService endpoints
+router$5.post("/api/v1/view/status_list", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.statusViewService.getStatusList();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/status_list ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/status_list error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$5.post("/api/v1/view/status_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.statusViewService.getStatusOne(id);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/status_one/:id ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/status_one/:id error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
 
 const require$2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
 function getModulesPath() {