@backtest-kit/cli 0.0.1 → 0.0.3

package/build/index.mjs

@@ -1,5 +1,5 @@
 import { Storage, Notification, Markdown, Report, StorageLive, StorageBacktest, NotificationLive, NotificationBacktest, listExchangeSchema, addExchangeSchema, roundTicks, listFrameSchema, addFrameSchema, listenDoneLive, listenDoneBacktest, listStrategySchema, overrideExchangeSchema, Backtest, Live, getCandles, checkCandles, warmCandles, listenRisk, listenSignal, listenStrategyCommit } from 'backtest-kit';
-import { getErrorMessage, errorData, str, BehaviorSubject, singleshot, compose, execpool, queued, sleep, randomString, createAwaiter, TIMEOUT_SYMBOL, typo, retry, memoize } from 'functools-kit';
+import { getErrorMessage, errorData, singleshot, str, BehaviorSubject, compose, execpool, queued, sleep, randomString, createAwaiter, TIMEOUT_SYMBOL, typo, retry, memoize, trycatch } from 'functools-kit';
 import fs, { constants } from 'fs';
 import * as stackTrace from 'stack-trace';
 import { fileURLToPath, pathToFileURL } from 'url';
@@ -112,14 +112,14 @@ class ErrorService {
                 this.handleGlobalError(err);
             });
         };
-        this.init = () => {
+        this.init = singleshot(() => {
             const global = globalThis;
             if (global[ERROR_HANDLER_INSTALLED]) {
                 return;
             }
             this._listenForError();
             global[ERROR_HANDLER_INSTALLED] = 1;
-        };
+        });
     }
 }
 
@@ -314,8 +314,8 @@ const ADD_EXCHANGE_FN = (self) => {
 class ExchangeSchemaService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.init = singleshot(async () => {
-            this.loggerService.log("exchangeSchemaService init");
+        this.addSchema = singleshot(async () => {
+            this.loggerService.log("exchangeSchemaService addSchema");
             const { length } = await listExchangeSchema();
             !length && ADD_EXCHANGE_FN(this);
         });
@@ -399,8 +399,8 @@ const ADD_FRAME_FN = (self) => {
 class FrameSchemaService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.init = singleshot(async () => {
-            this.loggerService.log("frameSchemaService init");
+        this.addSchema = singleshot(async () => {
+            this.loggerService.log("frameSchemaService addSchema");
             if (!getArgs().values.backtest) {
                 return;
             }
@@ -413,8 +413,8 @@ class FrameSchemaService {
 class SymbolSchemaService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.init = singleshot(async () => {
-            this.loggerService.log("symbolSchemaService init");
+        this.addSchema = singleshot(async () => {
+            this.loggerService.log("symbolSchemaService addSchema");
             if (!getArgs().values.symbol) {
                 console.warn("Warning: The default symbol is set to BTCUSDT. Please make sure to update it according to your needs using --symbol cli param.");
             }
@@ -435,56 +435,69 @@ const notifyFinish = singleshot(() => {
     disposeRef = compose(() => unLive(), () => unBacktest());
 });
 
+const getEntry = (metaUrl) => {
+    return process.argv[1] === new URL(metaUrl).pathname;
+};
+
+const DEFAULT_CACHE_LIST = ["1m", "15m", "30m", "1h", "4h"];
+const GET_CACHE_LIST_FN = () => {
+    const { values } = getArgs();
+    if (!values.cache) {
+        console.warn(`Warning: No cache timeframes provided. Using default timeframes: ${DEFAULT_CACHE_LIST.join(", ")}`);
+        return DEFAULT_CACHE_LIST;
+    }
+    return String(values.cache)
+        .split(",")
+        .map((timeframe) => timeframe.trim());
+};
 class BacktestMainService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
+        this.resolveService = inject(TYPES.resolveService);
         this.exchangeSchemaService = inject(TYPES.exchangeSchemaService);
         this.frameSchemaService = inject(TYPES.frameSchemaService);
+        this.symbolSchemaService = inject(TYPES.symbolSchemaService);
         this.cacheLogicService = inject(TYPES.cacheLogicService);
-        this.resolveService = inject(TYPES.resolveService);
         this.frontendProviderService = inject(TYPES.frontendProviderService);
         this.telegramProviderService = inject(TYPES.telegramProviderService);
-        this.init = singleshot(async () => {
-            this.loggerService.log("backtestMainService init");
+        this.run = singleshot(async (payload) => {
+            this.loggerService.log("backtestMainService run", {
+                payload,
+            });
             {
-                this.frontendProviderService.init();
-                this.telegramProviderService.init();
-            }
-            const { values, positionals } = getArgs();
-            if (!values.backtest) {
-                return;
-            }
-            const [entryPoint = null] = positionals;
-            if (!entryPoint) {
-                throw new Error("Entry point is required");
+                this.frontendProviderService.connect();
+                this.telegramProviderService.connect();
             }
-            await this.resolveService.attachEntryPoint(entryPoint);
+            await this.resolveService.attachEntryPoint(payload.entryPoint);
             {
-                this.exchangeSchemaService.init();
-                this.frameSchemaService.init();
+                this.exchangeSchemaService.addSchema();
+                this.symbolSchemaService.addSchema();
+                this.frameSchemaService.addSchema();
             }
-            const symbol = values.symbol || "BTCUSDT";
+            const symbol = payload.symbol || "BTCUSDT";
             const [defaultStrategyName = null] = await listStrategySchema();
             const [defaultExchangeName = null] = await listExchangeSchema();
             const [defaultFrameName = null] = await listFrameSchema();
-            const strategyName = values.strategy || defaultStrategyName?.strategyName;
+            const strategyName = payload.strategy || defaultStrategyName?.strategyName;
             if (!strategyName) {
                 throw new Error("Strategy name is required");
             }
-            const exchangeName = values.exchange || defaultExchangeName?.exchangeName;
+            const exchangeName = payload.exchange || defaultExchangeName?.exchangeName;
             if (!exchangeName) {
                 throw new Error("Exchange name is required");
             }
-            const frameName = values.frame || defaultFrameName?.frameName;
+            const frameName = payload.frame || defaultFrameName?.frameName;
             if (!frameName) {
                 throw new Error("Frame name is required");
             }
-            await this.cacheLogicService.execute({
-                exchangeName,
-                frameName,
-                symbol,
-            });
-            if (values.verbose) {
+            {
+                await this.cacheLogicService.execute(payload.cacheList, {
+                    exchangeName,
+                    frameName,
+                    symbol,
+                });
+            }
+            if (payload.verbose) {
                 overrideExchangeSchema({
                     exchangeName,
                     callbacks: {
@@ -501,46 +514,68 @@ class BacktestMainService {
             });
             notifyFinish();
         });
+        this.connect = singleshot(async () => {
+            this.loggerService.log("backtestMainService connect");
+            if (!getEntry(import.meta.url)) {
+                return;
+            }
+            const { values, positionals } = getArgs();
+            if (!values.backtest) {
+                return;
+            }
+            const [entryPoint = null] = positionals;
+            if (!entryPoint) {
+                throw new Error("Entry point is required");
+            }
+            const cacheList = GET_CACHE_LIST_FN();
+            return await this.run({
+                symbol: values.symbol,
+                entryPoint,
+                cacheList,
+                exchange: values.exchange,
+                frame: values.frame,
+                strategy: values.strategy,
+                verbose: values.verbose,
+            });
+        });
     }
 }
 
 class LiveMainService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.exchangeSchemaService = inject(TYPES.exchangeSchemaService);
         this.resolveService = inject(TYPES.resolveService);
+        this.exchangeSchemaService = inject(TYPES.exchangeSchemaService);
+        this.symbolSchemaService = inject(TYPES.symbolSchemaService);
         this.frontendProviderService = inject(TYPES.frontendProviderService);
         this.telegramProviderService = inject(TYPES.telegramProviderService);
-        this.init = singleshot(async () => {
-            this.loggerService.log("liveMainService init");
+        this.liveProviderService = inject(TYPES.liveProviderService);
+        this.run = singleshot(async (payload) => {
+            this.loggerService.log("liveMainService run", {
+                payload,
+            });
             {
-                this.frontendProviderService.init();
-                this.telegramProviderService.init();
-            }
-            const { values, positionals } = getArgs();
-            if (!values.live) {
-                return;
+                this.frontendProviderService.connect();
+                this.telegramProviderService.connect();
+                this.liveProviderService.connect();
             }
-            const [entryPoint = null] = positionals;
-            if (!entryPoint) {
-                throw new Error("Entry point is required");
-            }
-            await this.resolveService.attachEntryPoint(entryPoint);
+            await this.resolveService.attachEntryPoint(payload.entryPoint);
             {
-                this.exchangeSchemaService.init();
+                this.exchangeSchemaService.addSchema();
+                this.symbolSchemaService.addSchema();
             }
-            const symbol = values.symbol || "BTCUSDT";
+            const symbol = payload.symbol || "BTCUSDT";
             const [defaultStrategyName = null] = await listStrategySchema();
             const [defaultExchangeName = null] = await listExchangeSchema();
-            const strategyName = values.strategy || defaultStrategyName?.strategyName;
+            const strategyName = payload.strategy || defaultStrategyName?.strategyName;
             if (!strategyName) {
                 throw new Error("Strategy name is required");
             }
-            const exchangeName = values.exchange || defaultExchangeName?.exchangeName;
+            const exchangeName = payload.exchange || defaultExchangeName?.exchangeName;
             if (!exchangeName) {
                 throw new Error("Exchange name is required");
             }
-            if (values.verbose) {
+            if (payload.verbose) {
                 overrideExchangeSchema({
                     exchangeName,
                     callbacks: {
@@ -556,46 +591,61 @@ class LiveMainService {
             });
             notifyFinish();
         });
+        this.connect = singleshot(async () => {
+            this.loggerService.log("liveMainService connect");
+            if (!getEntry(import.meta.url)) {
+                return;
+            }
+            const { values, positionals } = getArgs();
+            if (!values.live) {
+                return;
+            }
+            const [entryPoint = null] = positionals;
+            if (!entryPoint) {
+                throw new Error("Entry point is required");
+            }
+            return await this.run({
+                entryPoint,
+                exchange: values.exchange,
+                strategy: values.strategy,
+                symbol: values.symbol,
+                verbose: values.verbose,
+            });
+        });
     }
 }
 
 class PaperMainService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.exchangeSchemaService = inject(TYPES.exchangeSchemaService);
         this.resolveService = inject(TYPES.resolveService);
+        this.exchangeSchemaService = inject(TYPES.exchangeSchemaService);
+        this.symbolSchemaService = inject(TYPES.symbolSchemaService);
         this.frontendProviderService = inject(TYPES.frontendProviderService);
         this.telegramProviderService = inject(TYPES.telegramProviderService);
-        this.init = singleshot(async () => {
+        this.run = singleshot(async (payload) => {
             this.loggerService.log("paperMainService init");
             {
-                this.frontendProviderService.init();
-                this.telegramProviderService.init();
+                this.frontendProviderService.connect();
+                this.telegramProviderService.connect();
             }
-            const { values, positionals } = getArgs();
-            if (!values.paper) {
-                return;
-            }
-            const [entryPoint = null] = positionals;
-            if (!entryPoint) {
-                throw new Error("Entry point is required");
-            }
-            await this.resolveService.attachEntryPoint(entryPoint);
+            await this.resolveService.attachEntryPoint(payload.entryPoint);
             {
-                this.exchangeSchemaService.init();
+                this.exchangeSchemaService.addSchema();
+                this.symbolSchemaService.addSchema();
             }
-            const symbol = values.symbol || "BTCUSDT";
+            const symbol = payload.symbol || "BTCUSDT";
             const [defaultStrategyName = null] = await listStrategySchema();
             const [defaultExchangeName = null] = await listExchangeSchema();
-            const strategyName = values.strategy || defaultStrategyName?.strategyName;
+            const strategyName = payload.strategy || defaultStrategyName?.strategyName;
             if (!strategyName) {
                 throw new Error("Strategy name is required");
             }
-            const exchangeName = values.exchange || defaultExchangeName?.exchangeName;
+            const exchangeName = payload.exchange || defaultExchangeName?.exchangeName;
             if (!exchangeName) {
                 throw new Error("Exchange name is required");
             }
-            if (values.verbose) {
+            if (payload.verbose) {
                 overrideExchangeSchema({
                     exchangeName,
                     callbacks: {
@@ -611,6 +661,27 @@ class PaperMainService {
             });
             notifyFinish();
         });
+        this.connect = singleshot(async () => {
+            this.loggerService.log("paperMainService connect");
+            if (!getEntry(import.meta.url)) {
+                return;
+            }
+            const { values, positionals } = getArgs();
+            if (!values.paper) {
+                return;
+            }
+            const [entryPoint = null] = positionals;
+            if (!entryPoint) {
+                throw new Error("Entry point is required");
+            }
+            return await this.run({
+                entryPoint,
+                exchange: values.exchange,
+                strategy: values.strategy,
+                symbol: values.symbol,
+                verbose: values.verbose,
+            });
+        });
     }
 }
 
@@ -646,12 +717,12 @@ class FrontendProviderService {
                 lastSubscription();
             }
         };
-        this.init = singleshot(async () => {
-            this.loggerService.log("frontendProviderService init");
+        this.connect = singleshot(async () => {
+            this.loggerService.log("frontendProviderService connect");
             if (!getArgs().values.ui) {
                 return;
             }
-            entrySubject.subscribe(this.enable);
+            return entrySubject.subscribe(this.enable);
         });
     }
 }
@@ -682,12 +753,12 @@ class TelegramProviderService {
                 lastSubscription();
             }
         };
-        this.init = singleshot(async () => {
-            this.loggerService.log("telegramProviderService init");
+        this.connect = singleshot(async () => {
+            this.loggerService.log("telegramProviderService connect");
             if (!getArgs().values.telegram) {
                 return;
             }
-            entrySubject.subscribe(this.enable);
+            return entrySubject.subscribe(this.enable);
         });
     }
 }
@@ -1109,17 +1180,6 @@ class TelegramWebService {
     }
 }
 
-const DEFAULT_TIMEFRAME_LIST = ["1m", "15m", "30m", "1h", "4h"];
-const GET_TIMEFRAME_LIST_FN = async () => {
-    const { values } = getArgs();
-    if (!values.cache) {
-        console.warn(`Warning: No cache timeframes provided. Using default timeframes: ${DEFAULT_TIMEFRAME_LIST.join(", ")}`);
-        return DEFAULT_TIMEFRAME_LIST;
-    }
-    return String(values.cache)
-        .split(",")
-        .map((timeframe) => timeframe.trim());
-};
 const GET_TIMEFRAME_RANGE_FN = async (frameName) => {
     const frameList = await listFrameSchema();
     const frameSchema = frameList.find((frameSchema) => frameSchema.frameName === frameName);
@@ -1155,12 +1215,11 @@ const CACHE_CANDLES_FN = retry(async (interval, dto) => {
 class CacheLogicService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.execute = async (dto) => {
+        this.execute = async (intervalList, dto) => {
             this.loggerService.log("cacheLogicService execute", {
                 dto,
             });
             const { startDate, endDate } = await GET_TIMEFRAME_RANGE_FN(dto.frameName);
-            const intervalList = await GET_TIMEFRAME_LIST_FN();
             try {
                 for (const interval of intervalList) {
                     await CACHE_CANDLES_FN(interval, {
@@ -1333,7 +1392,8 @@ class TelegramLogicService {
                     return;
                 }
             });
-            const unListen = compose(() => unRisk(), () => unSignal(), () => unCommit());
+            const unConnect = () => this.connect.clear();
+            const unListen = compose(() => unRisk(), () => unSignal(), () => unCommit(), () => unConnect());
             return () => {
                 STOP_BOT_FN();
                 unListen();
@@ -1483,10 +1543,10 @@ class ModuleConnectionService {
     }
 }
 
-const LOAD_INSTANCE_FN = singleshot(async (self) => {
+const LOAD_INSTANCE_FN = singleshot(trycatch(async (self) => {
     const module = (await self.moduleConnectionService.getInstance("./live.module"));
     return module;
-});
+}, { defaultValue: null }));
 class LiveProviderService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
@@ -1496,7 +1556,7 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onTrailingTake) {
+            if (instance?.onTrailingTake) {
                 await instance.onTrailingTake(event);
             }
         };
@@ -1505,7 +1565,7 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onTrailingStop) {
+            if (instance?.onTrailingStop) {
                 await instance.onTrailingStop(event);
             }
         };
@@ -1514,7 +1574,7 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onBreakeven) {
+            if (instance?.onBreakeven) {
                 await instance.onBreakeven(event);
             }
         };
@@ -1523,7 +1583,7 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onPartialProfit) {
+            if (instance?.onPartialProfit) {
                 await instance.onPartialProfit(event);
             }
         };
@@ -1532,7 +1592,7 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onPartialLoss) {
+            if (instance?.onPartialLoss) {
                 await instance.onPartialLoss(event);
             }
         };
@@ -1541,7 +1601,7 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onScheduled) {
+            if (instance?.onScheduled) {
                 await instance.onScheduled(event);
             }
         };
@@ -1550,7 +1610,7 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onCancelled) {
+            if (instance?.onCancelled) {
                 await instance.onCancelled(event);
             }
         };
@@ -1559,7 +1619,7 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onOpened) {
+            if (instance?.onOpened) {
                 await instance.onOpened(event);
             }
         };
@@ -1568,7 +1628,7 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onClosed) {
+            if (instance?.onClosed) {
                 await instance.onClosed(event);
             }
         };
@@ -1577,12 +1637,20 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onRisk) {
+            if (instance?.onRisk) {
                 await instance.onRisk(event);
             }
         };
         this.enable = singleshot(() => {
             this.loggerService.log("liveProviderService enable");
+            LOAD_INSTANCE_FN(this).then((module) => {
+                if (module) {
+                    this.loggerService.log("Live trading initialized successfully with ./modules/live.module.mjs");
+                    return;
+                }
+                console.log("No ./modules/live.module.mjs found, live trading failed to initialize");
+                process.exit(-1);
+            });
             const unRisk = listenRisk(async (event) => {
                 await this.handleRisk(event);
             });
@@ -1626,7 +1694,8 @@ class LiveProviderService {
                     return;
                 }
             });
-            return compose(() => unRisk(), () => unSignal(), () => unCommit());
+            const unConnect = () => this.enable.clear();
+            return compose(() => unRisk(), () => unSignal(), () => unCommit(), () => unConnect());
         });
         this.disable = () => {
             this.loggerService.log("liveProviderService disable");
@@ -1635,12 +1704,12 @@ class LiveProviderService {
                 lastSubscription();
             }
         };
-        this.init = singleshot(async () => {
-            this.loggerService.log("liveProviderService init");
+        this.connect = singleshot(async () => {
+            this.loggerService.log("liveProviderService connect");
             if (!getArgs().values.live) {
                 return;
             }
-            entrySubject.subscribe(this.enable);
+            return entrySubject.subscribe(this.enable);
         });
     }
 }
@@ -1754,12 +1823,19 @@ const BEFORE_EXIT_FN$4 = singleshot(async () => {
         frameName,
     });
 });
+const listenGracefulShutdown$4 = singleshot(() => {
+    process.on("SIGINT", BEFORE_EXIT_FN$4);
+});
 const main$4 = async () => {
+    if (!getEntry(import.meta.url)) {
+        return;
+    }
     const { values } = getArgs();
     if (!values.backtest) {
         return;
     }
-    process.on("SIGINT", BEFORE_EXIT_FN$4);
+    await cli.backtestMainService.connect();
+    listenGracefulShutdown$4();
 };
 main$4();
 
@@ -1779,12 +1855,19 @@ const BEFORE_EXIT_FN$3 = singleshot(async () => {
         strategyName,
     });
 });
+const listenGracefulShutdown$3 = singleshot(() => {
+    process.on("SIGINT", BEFORE_EXIT_FN$3);
+});
 const main$3 = async () => {
+    if (!getEntry(import.meta.url)) {
+        return;
+    }
     const { values } = getArgs();
     if (!values.paper) {
         return;
     }
-    process.on("SIGINT", BEFORE_EXIT_FN$3);
+    cli.paperMainService.connect();
+    listenGracefulShutdown$3();
 };
 main$3();
 
@@ -1805,12 +1888,19 @@ const BEFORE_EXIT_FN$2 = singleshot(async () => {
     });
     listenDoneLive(cli.liveProviderService.disable);
 });
+const listenGracefulShutdown$2 = singleshot(() => {
+    process.on("SIGINT", BEFORE_EXIT_FN$2);
+});
 const main$2 = async () => {
+    if (!getEntry(import.meta.url)) {
+        return;
+    }
     const { values } = getArgs();
     if (!values.live) {
         return;
     }
-    process.on("SIGINT", BEFORE_EXIT_FN$2);
+    await cli.liveMainService.connect();
+    listenGracefulShutdown$2();
 };
 main$2();
 
@@ -1819,12 +1909,18 @@ const BEFORE_EXIT_FN$1 = singleshot(async () => {
     notifyShutdown();
     cli.frontendProviderService.disable();
 });
+const listenGracefulShutdown$1 = singleshot(() => {
+    process.on("SIGINT", BEFORE_EXIT_FN$1);
+});
 const main$1 = async () => {
+    if (!getEntry(import.meta.url)) {
+        return;
+    }
     const { values } = getArgs();
     if (!values.ui) {
         return;
     }
-    process.on("SIGINT", BEFORE_EXIT_FN$1);
+    listenGracefulShutdown$1();
 };
 main$1();
 
@@ -1833,12 +1929,18 @@ const BEFORE_EXIT_FN = singleshot(async () => {
     notifyShutdown();
     cli.telegramProviderService.disable();
 });
+const listenGracefulShutdown = singleshot(() => {
+    process.on("SIGINT", BEFORE_EXIT_FN);
+});
 const main = async () => {
+    if (!getEntry(import.meta.url)) {
+        return;
+    }
     const { values } = getArgs();
     if (!values.telegram) {
         return;
     }
-    process.on("SIGINT", BEFORE_EXIT_FN);
+    listenGracefulShutdown();
 };
 main();
 
@@ -1846,4 +1948,30 @@ function setLogger(logger) {
     cli.loggerService.setLogger(logger);
 }
 
-export { cli, setLogger };
+let _is_started = false;
+async function run(mode, args) {
+    {
+        if (_is_started) {
+            throw new Error("Should be called only once");
+        }
+        _is_started = true;
+    }
+    if (mode === "backtest") {
+        await cli.backtestMainService.run(args);
+        listenGracefulShutdown$4();
+        return;
+    }
+    if (mode === "paper") {
+        await cli.paperMainService.run(args);
+        listenGracefulShutdown$3();
+        return;
+    }
+    if (mode === "live") {
+        await cli.liveMainService.run(args);
+        listenGracefulShutdown$2();
+        return;
+    }
+    throw new Error(`Invalid mode: ${mode}`);
+}
+
+export { cli, run, setLogger };