@backtest-kit/cli 0.0.1 → 0.0.2

package/build/index.cjs

@@ -134,14 +134,14 @@ class ErrorService {
                 this.handleGlobalError(err);
             });
         };
-        this.init = () => {
+        this.init = functoolsKit.singleshot(() => {
             const global = globalThis;
             if (global[ERROR_HANDLER_INSTALLED]) {
                 return;
             }
             this._listenForError();
             global[ERROR_HANDLER_INSTALLED] = 1;
-        };
+        });
     }
 }
 
@@ -336,8 +336,8 @@ const ADD_EXCHANGE_FN = (self) => {
 class ExchangeSchemaService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.init = functoolsKit.singleshot(async () => {
-            this.loggerService.log("exchangeSchemaService init");
+        this.addSchema = functoolsKit.singleshot(async () => {
+            this.loggerService.log("exchangeSchemaService addSchema");
             const { length } = await backtestKit.listExchangeSchema();
             !length && ADD_EXCHANGE_FN(this);
         });
@@ -421,8 +421,8 @@ const ADD_FRAME_FN = (self) => {
 class FrameSchemaService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.init = functoolsKit.singleshot(async () => {
-            this.loggerService.log("frameSchemaService init");
+        this.addSchema = functoolsKit.singleshot(async () => {
+            this.loggerService.log("frameSchemaService addSchema");
             if (!getArgs().values.backtest) {
                 return;
             }
@@ -435,8 +435,8 @@ class FrameSchemaService {
 class SymbolSchemaService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.init = functoolsKit.singleshot(async () => {
-            this.loggerService.log("symbolSchemaService init");
+        this.addSchema = functoolsKit.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.");
             }
@@ -457,56 +457,69 @@ const notifyFinish = functoolsKit.singleshot(() => {
     disposeRef = functoolsKit.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 = functoolsKit.singleshot(async () => {
-            this.loggerService.log("backtestMainService init");
+        this.run = functoolsKit.singleshot(async (payload) => {
+            this.loggerService.log("backtestMainService run", {
+                payload,
+            });
             {
-                this.frontendProviderService.init();
-                this.telegramProviderService.init();
+                this.frontendProviderService.connect();
+                this.telegramProviderService.connect();
             }
-            const { values, positionals } = getArgs();
-            if (!values.backtest) {
-                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.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 backtestKit.listStrategySchema();
             const [defaultExchangeName = null] = await backtestKit.listExchangeSchema();
             const [defaultFrameName = null] = await backtestKit.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) {
                 backtestKit.overrideExchangeSchema({
                     exchangeName,
                     callbacks: {
@@ -523,46 +536,68 @@ class BacktestMainService {
             });
             notifyFinish();
         });
+        this.init = functoolsKit.singleshot(async () => {
+            this.loggerService.log("backtestMainService init");
+            if (!getEntry((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)))) {
+                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 = functoolsKit.singleshot(async () => {
-            this.loggerService.log("liveMainService init");
+        this.liveProviderService = inject(TYPES.liveProviderService);
+        this.run = functoolsKit.singleshot(async (payload) => {
+            this.loggerService.log("liveMainService run", {
+                payload,
+            });
             {
-                this.frontendProviderService.init();
-                this.telegramProviderService.init();
-            }
-            const { values, positionals } = getArgs();
-            if (!values.live) {
-                return;
-            }
-            const [entryPoint = null] = positionals;
-            if (!entryPoint) {
-                throw new Error("Entry point is required");
+                this.frontendProviderService.connect();
+                this.telegramProviderService.connect();
+                this.liveProviderService.connect();
             }
-            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 backtestKit.listStrategySchema();
             const [defaultExchangeName = null] = await backtestKit.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) {
                 backtestKit.overrideExchangeSchema({
                     exchangeName,
                     callbacks: {
@@ -578,46 +613,61 @@ class LiveMainService {
             });
             notifyFinish();
         });
+        this.init = functoolsKit.singleshot(async () => {
+            this.loggerService.log("liveMainService init");
+            if (!getEntry((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)))) {
+                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 = functoolsKit.singleshot(async () => {
+        this.run = functoolsKit.singleshot(async (payload) => {
             this.loggerService.log("paperMainService init");
             {
-                this.frontendProviderService.init();
-                this.telegramProviderService.init();
-            }
-            const { values, positionals } = getArgs();
-            if (!values.paper) {
-                return;
+                this.frontendProviderService.connect();
+                this.telegramProviderService.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 backtestKit.listStrategySchema();
             const [defaultExchangeName = null] = await backtestKit.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) {
                 backtestKit.overrideExchangeSchema({
                     exchangeName,
                     callbacks: {
@@ -633,6 +683,27 @@ class PaperMainService {
             });
             notifyFinish();
         });
+        this.init = functoolsKit.singleshot(async () => {
+            this.loggerService.log("paperMainService init");
+            if (!getEntry((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)))) {
+                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,
+            });
+        });
     }
 }
 
@@ -668,12 +739,12 @@ class FrontendProviderService {
                 lastSubscription();
             }
         };
-        this.init = functoolsKit.singleshot(async () => {
-            this.loggerService.log("frontendProviderService init");
+        this.connect = functoolsKit.singleshot(async () => {
+            this.loggerService.log("frontendProviderService connect");
             if (!getArgs().values.ui) {
                 return;
             }
-            entrySubject.subscribe(this.enable);
+            return entrySubject.subscribe(this.enable);
         });
     }
 }
@@ -704,12 +775,12 @@ class TelegramProviderService {
                 lastSubscription();
             }
         };
-        this.init = functoolsKit.singleshot(async () => {
-            this.loggerService.log("telegramProviderService init");
+        this.connect = functoolsKit.singleshot(async () => {
+            this.loggerService.log("telegramProviderService connect");
             if (!getArgs().values.telegram) {
                 return;
             }
-            entrySubject.subscribe(this.enable);
+            return entrySubject.subscribe(this.enable);
         });
     }
 }
@@ -1131,17 +1202,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 backtestKit.listFrameSchema();
     const frameSchema = frameList.find((frameSchema) => frameSchema.frameName === frameName);
@@ -1177,12 +1237,11 @@ const CACHE_CANDLES_FN = functoolsKit.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, {
@@ -1355,7 +1414,8 @@ class TelegramLogicService {
                     return;
                 }
             });
-            const unListen = functoolsKit.compose(() => unRisk(), () => unSignal(), () => unCommit());
+            const unConnect = () => this.connect.clear();
+            const unListen = functoolsKit.compose(() => unRisk(), () => unSignal(), () => unCommit(), () => unConnect());
             return () => {
                 STOP_BOT_FN();
                 unListen();
@@ -1505,10 +1565,10 @@ class ModuleConnectionService {
     }
 }
 
-const LOAD_INSTANCE_FN = functoolsKit.singleshot(async (self) => {
+const LOAD_INSTANCE_FN = functoolsKit.singleshot(functoolsKit.trycatch(async (self) => {
     const module = (await self.moduleConnectionService.getInstance("./live.module"));
     return module;
-});
+}, { defaultValue: null }));
 class LiveProviderService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
@@ -1518,7 +1578,7 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onTrailingTake) {
+            if (instance?.onTrailingTake) {
                 await instance.onTrailingTake(event);
             }
         };
@@ -1527,7 +1587,7 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onTrailingStop) {
+            if (instance?.onTrailingStop) {
                 await instance.onTrailingStop(event);
             }
         };
@@ -1536,7 +1596,7 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onBreakeven) {
+            if (instance?.onBreakeven) {
                 await instance.onBreakeven(event);
             }
         };
@@ -1545,7 +1605,7 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onPartialProfit) {
+            if (instance?.onPartialProfit) {
                 await instance.onPartialProfit(event);
             }
         };
@@ -1554,7 +1614,7 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onPartialLoss) {
+            if (instance?.onPartialLoss) {
                 await instance.onPartialLoss(event);
             }
         };
@@ -1563,7 +1623,7 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onScheduled) {
+            if (instance?.onScheduled) {
                 await instance.onScheduled(event);
             }
         };
@@ -1572,7 +1632,7 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onCancelled) {
+            if (instance?.onCancelled) {
                 await instance.onCancelled(event);
             }
         };
@@ -1581,7 +1641,7 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onOpened) {
+            if (instance?.onOpened) {
                 await instance.onOpened(event);
             }
         };
@@ -1590,7 +1650,7 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onClosed) {
+            if (instance?.onClosed) {
                 await instance.onClosed(event);
             }
         };
@@ -1599,12 +1659,20 @@ class LiveProviderService {
                 event,
             });
             const instance = await LOAD_INSTANCE_FN(this);
-            if (instance.onRisk) {
+            if (instance?.onRisk) {
                 await instance.onRisk(event);
             }
         };
         this.enable = functoolsKit.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 = backtestKit.listenRisk(async (event) => {
                 await this.handleRisk(event);
             });
@@ -1648,7 +1716,8 @@ class LiveProviderService {
                     return;
                 }
             });
-            return functoolsKit.compose(() => unRisk(), () => unSignal(), () => unCommit());
+            const unConnect = () => this.enable.clear();
+            return functoolsKit.compose(() => unRisk(), () => unSignal(), () => unCommit(), () => unConnect());
         });
         this.disable = () => {
             this.loggerService.log("liveProviderService disable");
@@ -1657,12 +1726,12 @@ class LiveProviderService {
                 lastSubscription();
             }
         };
-        this.init = functoolsKit.singleshot(async () => {
-            this.loggerService.log("liveProviderService init");
+        this.connect = functoolsKit.singleshot(async () => {
+            this.loggerService.log("liveProviderService connect");
             if (!getArgs().values.live) {
                 return;
             }
-            entrySubject.subscribe(this.enable);
+            return entrySubject.subscribe(this.enable);
         });
     }
 }
@@ -1777,6 +1846,9 @@ const BEFORE_EXIT_FN$4 = functoolsKit.singleshot(async () => {
     });
 });
 const main$4 = async () => {
+    if (!getEntry((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)))) {
+        return;
+    }
     const { values } = getArgs();
     if (!values.backtest) {
         return;
@@ -1802,6 +1874,9 @@ const BEFORE_EXIT_FN$3 = functoolsKit.singleshot(async () => {
     });
 });
 const main$3 = async () => {
+    if (!getEntry((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)))) {
+        return;
+    }
     const { values } = getArgs();
     if (!values.paper) {
         return;
@@ -1828,6 +1903,9 @@ const BEFORE_EXIT_FN$2 = functoolsKit.singleshot(async () => {
     backtestKit.listenDoneLive(cli.liveProviderService.disable);
 });
 const main$2 = async () => {
+    if (!getEntry((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)))) {
+        return;
+    }
     const { values } = getArgs();
     if (!values.live) {
         return;
@@ -1842,6 +1920,9 @@ const BEFORE_EXIT_FN$1 = functoolsKit.singleshot(async () => {
     cli.frontendProviderService.disable();
 });
 const main$1 = async () => {
+    if (!getEntry((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)))) {
+        return;
+    }
     const { values } = getArgs();
     if (!values.ui) {
         return;
@@ -1856,6 +1937,9 @@ const BEFORE_EXIT_FN = functoolsKit.singleshot(async () => {
     cli.telegramProviderService.disable();
 });
 const main = async () => {
+    if (!getEntry((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)))) {
+        return;
+    }
     const { values } = getArgs();
     if (!values.telegram) {
         return;
@@ -1868,5 +1952,26 @@ function setLogger(logger) {
     cli.loggerService.setLogger(logger);
 }
 
+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") {
+        return await cli.backtestMainService.run(args);
+    }
+    if (mode === "paper") {
+        return await cli.paperMainService.run(args);
+    }
+    if (mode === "live") {
+        return await cli.liveMainService.run(args);
+    }
+    throw new Error(`Invalid mode: ${mode}`);
+}
+
 exports.cli = cli;
+exports.run = run;
 exports.setLogger = setLogger;