backtest-kit 1.3.0 → 1.3.2

package/build/index.cjs

@@ -1430,6 +1430,11 @@ const walkerEmitter = new functoolsKit.Subject();
  * Emits when all strategies have been tested and final results are available.
  */
 const walkerCompleteSubject = new functoolsKit.Subject();
+/**
+ * Walker stop emitter for walker cancellation events.
+ * Emits when a walker comparison is stopped/cancelled.
+ */
+const walkerStopSubject = new functoolsKit.Subject();
 /**
  * Validation emitter for risk validation errors.
  * Emits when risk validation functions throw errors during signal checking.
@@ -1449,7 +1454,8 @@ var emitters = /*#__PURE__*/Object.freeze({
     signalLiveEmitter: signalLiveEmitter,
     validationSubject: validationSubject,
     walkerCompleteSubject: walkerCompleteSubject,
-    walkerEmitter: walkerEmitter
+    walkerEmitter: walkerEmitter,
+    walkerStopSubject: walkerStopSubject
 });
 
 const INTERVAL_MINUTES$1 = {
@@ -1625,6 +1631,9 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
     if (!signal) {
         return null;
     }
+    if (self._isStopped) {
+        return null;
+    }
     // Если priceOpen указан - проверяем нужно ли ждать активации или открыть сразу
     if (signal.priceOpen !== undefined) {
         // КРИТИЧЕСКАЯ ПРОВЕРКА: достигнут ли priceOpen?
@@ -2351,6 +2360,14 @@ class ClientStrategy {
         }
         await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.strategyName, this.params.execution.context.symbol);
     }
+    /**
+     * Retrieves the current pending signal.
+     * If no signal is pending, returns null.
+     * @returns Promise resolving to the pending signal or null.
+     */
+    async getPendingSignal() {
+        return this._pendingSignal;
+    }
     /**
      * Performs a single tick of strategy execution.
      *
@@ -2656,6 +2673,20 @@ class StrategyConnectionService {
                 callbacks,
             });
         });
+        /**
+         * Retrieves the currently active pending signal for the strategy.
+         * If no active signal exists, returns null.
+         * Used internally for monitoring TP/SL and time expiration.
+         *
+         * @param strategyName - Name of strategy to get pending signal for
+         *
+         * @returns Promise resolving to pending signal or null
+         */
+        this.getPendingSignal = async (strategyName) => {
+            this.loggerService.log("strategyConnectionService getPendingSignal");
+            const strategy = await this.getStrategy(strategyName);
+            return await strategy.getPendingSignal();
+        };
         /**
          * Executes live trading tick for current strategy.
          *
@@ -3558,6 +3589,23 @@ class StrategyGlobalService {
             riskName &&
                 this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE);
         });
+        /**
+         * Retrieves the currently active pending signal for the symbol.
+         * If no active signal exists, returns null.
+         * Used internally for monitoring TP/SL and time expiration.
+         *
+         * @param symbol - Trading pair symbol
+         * @param when - Timestamp for tick evaluation
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to pending signal or null
+         */
+        this.getPendingSignal = async (strategyName) => {
+            this.loggerService.log("strategyGlobalService getPendingSignal", {
+                strategyName,
+            });
+            await this.validate(this.methodContextService.context.strategyName);
+            return await this.strategyConnectionService.getPendingSignal(strategyName);
+        };
         /**
          * Checks signal status at a specific timestamp.
          *
@@ -4560,6 +4608,7 @@ class LiveLogicPrivateService {
     }
 }
 
+const CANCEL_SYMBOL = Symbol("CANCEL_SYMBOL");
 /**
  * Private service for walker orchestration (strategy comparison).
  *
@@ -4617,6 +4666,10 @@ class WalkerLogicPrivateService {
         let strategiesTested = 0;
         let bestMetric = null;
         let bestStrategy = null;
+        const listenStop = walkerStopSubject
+            .filter((walkerName) => walkerName === context.walkerName)
+            .map(() => CANCEL_SYMBOL)
+            .toPromise();
         // Run backtest for each strategy
         for (const strategyName of strategies) {
             // Call onStrategyStart callback if provided
@@ -4632,7 +4685,16 @@ class WalkerLogicPrivateService {
                 exchangeName: context.exchangeName,
                 frameName: context.frameName,
             });
-            await functoolsKit.resolveDocuments(iterator);
+            const result = await Promise.race([
+                await functoolsKit.resolveDocuments(iterator),
+                listenStop,
+            ]);
+            if (result === CANCEL_SYMBOL) {
+                this.loggerService.info("walkerLogicPrivateService received stop signal, cancelling walker", {
+                    context,
+                });
+                break;
+            }
             this.loggerService.info("walkerLogicPrivateService backtest complete", {
                 strategyName,
                 symbol,
@@ -9296,22 +9358,42 @@ class BacktestUtils {
                 context,
             });
             let isStopped = false;
+            let isDone = false;
             const task = async () => {
                 for await (const _ of this.run(symbol, context)) {
                     if (isStopped) {
                         break;
                     }
                 }
-                await doneBacktestSubject.next({
-                    exchangeName: context.exchangeName,
-                    strategyName: context.strategyName,
-                    backtest: true,
-                    symbol,
-                });
+                if (!isDone) {
+                    await doneBacktestSubject.next({
+                        exchangeName: context.exchangeName,
+                        strategyName: context.strategyName,
+                        backtest: true,
+                        symbol,
+                    });
+                }
+                isDone = true;
             };
             task().catch((error) => errorEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
                 backtest$1.strategyGlobalService.stop(context.strategyName);
+                backtest$1.strategyGlobalService
+                    .getPendingSignal(context.strategyName)
+                    .then(async (pendingSignal) => {
+                    if (pendingSignal) {
+                        return;
+                    }
+                    if (!isDone) {
+                        await doneBacktestSubject.next({
+                            exchangeName: context.exchangeName,
+                            strategyName: context.strategyName,
+                            backtest: true,
+                            symbol,
+                        });
+                    }
+                    isDone = true;
+                });
                 isStopped = true;
             };
         };
@@ -9485,22 +9567,42 @@ class LiveUtils {
                 context,
             });
             let isStopped = false;
+            let isDone = false;
             const task = async () => {
                 for await (const signal of this.run(symbol, context)) {
                     if (signal?.action === "closed" && isStopped) {
                         break;
                     }
                 }
-                await doneLiveSubject.next({
-                    exchangeName: context.exchangeName,
-                    strategyName: context.strategyName,
-                    backtest: false,
-                    symbol,
-                });
+                if (!isDone) {
+                    await doneLiveSubject.next({
+                        exchangeName: context.exchangeName,
+                        strategyName: context.strategyName,
+                        backtest: false,
+                        symbol,
+                    });
+                }
+                isDone = true;
             };
             task().catch((error) => errorEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
                 backtest$1.strategyGlobalService.stop(context.strategyName);
+                backtest$1.strategyGlobalService
+                    .getPendingSignal(context.strategyName)
+                    .then(async (pendingSignal) => {
+                    if (pendingSignal) {
+                        return;
+                    }
+                    if (!isDone) {
+                        await doneLiveSubject.next({
+                            exchangeName: context.exchangeName,
+                            strategyName: context.strategyName,
+                            backtest: false,
+                            symbol,
+                        });
+                    }
+                    isDone = true;
+                });
                 isStopped = true;
             };
         };
@@ -9926,25 +10028,39 @@ class WalkerUtils {
             });
             const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
             let isStopped = false;
+            let isDone = false;
             const task = async () => {
                 for await (const _ of this.run(symbol, context)) {
                     if (isStopped) {
                         break;
                     }
                 }
-                await doneWalkerSubject.next({
-                    exchangeName: walkerSchema.exchangeName,
-                    strategyName: context.walkerName,
-                    backtest: true,
-                    symbol,
-                });
+                if (!isDone) {
+                    await doneWalkerSubject.next({
+                        exchangeName: walkerSchema.exchangeName,
+                        strategyName: context.walkerName,
+                        backtest: true,
+                        symbol,
+                    });
+                }
+                isDone = true;
             };
             task().catch((error) => errorEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
-                isStopped = true;
                 for (const strategyName of walkerSchema.strategies) {
                     backtest$1.strategyGlobalService.stop(strategyName);
                 }
+                walkerStopSubject.next(context.walkerName);
+                if (!isDone) {
+                    doneWalkerSubject.next({
+                        exchangeName: walkerSchema.exchangeName,
+                        strategyName: context.walkerName,
+                        backtest: true,
+                        symbol,
+                    });
+                }
+                isDone = true;
+                isStopped = true;
             };
         };
         /**

package/build/index.mjs

@@ -1428,6 +1428,11 @@ const walkerEmitter = new Subject();
  * Emits when all strategies have been tested and final results are available.
  */
 const walkerCompleteSubject = new Subject();
+/**
+ * Walker stop emitter for walker cancellation events.
+ * Emits when a walker comparison is stopped/cancelled.
+ */
+const walkerStopSubject = new Subject();
 /**
  * Validation emitter for risk validation errors.
  * Emits when risk validation functions throw errors during signal checking.
@@ -1447,7 +1452,8 @@ var emitters = /*#__PURE__*/Object.freeze({
     signalLiveEmitter: signalLiveEmitter,
     validationSubject: validationSubject,
     walkerCompleteSubject: walkerCompleteSubject,
-    walkerEmitter: walkerEmitter
+    walkerEmitter: walkerEmitter,
+    walkerStopSubject: walkerStopSubject
 });
 
 const INTERVAL_MINUTES$1 = {
@@ -1623,6 +1629,9 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
     if (!signal) {
         return null;
     }
+    if (self._isStopped) {
+        return null;
+    }
     // Если priceOpen указан - проверяем нужно ли ждать активации или открыть сразу
     if (signal.priceOpen !== undefined) {
         // КРИТИЧЕСКАЯ ПРОВЕРКА: достигнут ли priceOpen?
@@ -2349,6 +2358,14 @@ class ClientStrategy {
         }
         await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.strategyName, this.params.execution.context.symbol);
     }
+    /**
+     * Retrieves the current pending signal.
+     * If no signal is pending, returns null.
+     * @returns Promise resolving to the pending signal or null.
+     */
+    async getPendingSignal() {
+        return this._pendingSignal;
+    }
     /**
      * Performs a single tick of strategy execution.
      *
@@ -2654,6 +2671,20 @@ class StrategyConnectionService {
                 callbacks,
             });
         });
+        /**
+         * Retrieves the currently active pending signal for the strategy.
+         * If no active signal exists, returns null.
+         * Used internally for monitoring TP/SL and time expiration.
+         *
+         * @param strategyName - Name of strategy to get pending signal for
+         *
+         * @returns Promise resolving to pending signal or null
+         */
+        this.getPendingSignal = async (strategyName) => {
+            this.loggerService.log("strategyConnectionService getPendingSignal");
+            const strategy = await this.getStrategy(strategyName);
+            return await strategy.getPendingSignal();
+        };
         /**
          * Executes live trading tick for current strategy.
          *
@@ -3556,6 +3587,23 @@ class StrategyGlobalService {
             riskName &&
                 this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE);
         });
+        /**
+         * Retrieves the currently active pending signal for the symbol.
+         * If no active signal exists, returns null.
+         * Used internally for monitoring TP/SL and time expiration.
+         *
+         * @param symbol - Trading pair symbol
+         * @param when - Timestamp for tick evaluation
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to pending signal or null
+         */
+        this.getPendingSignal = async (strategyName) => {
+            this.loggerService.log("strategyGlobalService getPendingSignal", {
+                strategyName,
+            });
+            await this.validate(this.methodContextService.context.strategyName);
+            return await this.strategyConnectionService.getPendingSignal(strategyName);
+        };
         /**
          * Checks signal status at a specific timestamp.
          *
@@ -4558,6 +4606,7 @@ class LiveLogicPrivateService {
     }
 }
 
+const CANCEL_SYMBOL = Symbol("CANCEL_SYMBOL");
 /**
  * Private service for walker orchestration (strategy comparison).
  *
@@ -4615,6 +4664,10 @@ class WalkerLogicPrivateService {
         let strategiesTested = 0;
         let bestMetric = null;
         let bestStrategy = null;
+        const listenStop = walkerStopSubject
+            .filter((walkerName) => walkerName === context.walkerName)
+            .map(() => CANCEL_SYMBOL)
+            .toPromise();
         // Run backtest for each strategy
         for (const strategyName of strategies) {
             // Call onStrategyStart callback if provided
@@ -4630,7 +4683,16 @@ class WalkerLogicPrivateService {
                 exchangeName: context.exchangeName,
                 frameName: context.frameName,
             });
-            await resolveDocuments(iterator);
+            const result = await Promise.race([
+                await resolveDocuments(iterator),
+                listenStop,
+            ]);
+            if (result === CANCEL_SYMBOL) {
+                this.loggerService.info("walkerLogicPrivateService received stop signal, cancelling walker", {
+                    context,
+                });
+                break;
+            }
             this.loggerService.info("walkerLogicPrivateService backtest complete", {
                 strategyName,
                 symbol,
@@ -9294,22 +9356,42 @@ class BacktestUtils {
                 context,
             });
             let isStopped = false;
+            let isDone = false;
             const task = async () => {
                 for await (const _ of this.run(symbol, context)) {
                     if (isStopped) {
                         break;
                     }
                 }
-                await doneBacktestSubject.next({
-                    exchangeName: context.exchangeName,
-                    strategyName: context.strategyName,
-                    backtest: true,
-                    symbol,
-                });
+                if (!isDone) {
+                    await doneBacktestSubject.next({
+                        exchangeName: context.exchangeName,
+                        strategyName: context.strategyName,
+                        backtest: true,
+                        symbol,
+                    });
+                }
+                isDone = true;
             };
             task().catch((error) => errorEmitter.next(new Error(getErrorMessage(error))));
             return () => {
                 backtest$1.strategyGlobalService.stop(context.strategyName);
+                backtest$1.strategyGlobalService
+                    .getPendingSignal(context.strategyName)
+                    .then(async (pendingSignal) => {
+                    if (pendingSignal) {
+                        return;
+                    }
+                    if (!isDone) {
+                        await doneBacktestSubject.next({
+                            exchangeName: context.exchangeName,
+                            strategyName: context.strategyName,
+                            backtest: true,
+                            symbol,
+                        });
+                    }
+                    isDone = true;
+                });
                 isStopped = true;
             };
         };
@@ -9483,22 +9565,42 @@ class LiveUtils {
                 context,
             });
             let isStopped = false;
+            let isDone = false;
             const task = async () => {
                 for await (const signal of this.run(symbol, context)) {
                     if (signal?.action === "closed" && isStopped) {
                         break;
                     }
                 }
-                await doneLiveSubject.next({
-                    exchangeName: context.exchangeName,
-                    strategyName: context.strategyName,
-                    backtest: false,
-                    symbol,
-                });
+                if (!isDone) {
+                    await doneLiveSubject.next({
+                        exchangeName: context.exchangeName,
+                        strategyName: context.strategyName,
+                        backtest: false,
+                        symbol,
+                    });
+                }
+                isDone = true;
             };
             task().catch((error) => errorEmitter.next(new Error(getErrorMessage(error))));
             return () => {
                 backtest$1.strategyGlobalService.stop(context.strategyName);
+                backtest$1.strategyGlobalService
+                    .getPendingSignal(context.strategyName)
+                    .then(async (pendingSignal) => {
+                    if (pendingSignal) {
+                        return;
+                    }
+                    if (!isDone) {
+                        await doneLiveSubject.next({
+                            exchangeName: context.exchangeName,
+                            strategyName: context.strategyName,
+                            backtest: false,
+                            symbol,
+                        });
+                    }
+                    isDone = true;
+                });
                 isStopped = true;
             };
         };
@@ -9924,25 +10026,39 @@ class WalkerUtils {
             });
             const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
             let isStopped = false;
+            let isDone = false;
             const task = async () => {
                 for await (const _ of this.run(symbol, context)) {
                     if (isStopped) {
                         break;
                     }
                 }
-                await doneWalkerSubject.next({
-                    exchangeName: walkerSchema.exchangeName,
-                    strategyName: context.walkerName,
-                    backtest: true,
-                    symbol,
-                });
+                if (!isDone) {
+                    await doneWalkerSubject.next({
+                        exchangeName: walkerSchema.exchangeName,
+                        strategyName: context.walkerName,
+                        backtest: true,
+                        symbol,
+                    });
+                }
+                isDone = true;
             };
             task().catch((error) => errorEmitter.next(new Error(getErrorMessage(error))));
             return () => {
-                isStopped = true;
                 for (const strategyName of walkerSchema.strategies) {
                     backtest$1.strategyGlobalService.stop(strategyName);
                 }
+                walkerStopSubject.next(context.walkerName);
+                if (!isDone) {
+                    doneWalkerSubject.next({
+                        exchangeName: walkerSchema.exchangeName,
+                        strategyName: context.walkerName,
+                        backtest: true,
+                        symbol,
+                    });
+                }
+                isDone = true;
+                isStopped = true;
             };
         };
         /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backtest-kit",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "A TypeScript library for trading system backtest",
   "author": {
     "name": "Petr Tripolsky",

package/types.d.ts

@@ -825,6 +825,15 @@ interface IStrategy {
      * @returns Promise resolving to tick result (idle | opened | active | closed)
      */
     tick: (symbol: string) => Promise<IStrategyTickResult>;
+    /**
+     * Retrieves the currently active pending signal for the symbol.
+     * If no active signal exists, returns null.
+     * Used internally for monitoring TP/SL and time expiration.
+     *
+     * @param symbol
+     * @returns
+     */
+    getPendingSignal: (symbol: string) => Promise<ISignalRow | null>;
     /**
      * Fast backtest using historical candles.
      * Iterates through candles, calculates VWAP, checks TP/SL on each candle.
@@ -4437,6 +4446,11 @@ declare const walkerEmitter: Subject<WalkerContract>;
  * Emits when all strategies have been tested and final results are available.
  */
 declare const walkerCompleteSubject: Subject<IWalkerResults>;
+/**
+ * Walker stop emitter for walker cancellation events.
+ * Emits when a walker comparison is stopped/cancelled.
+ */
+declare const walkerStopSubject: Subject<string>;
 /**
  * Validation emitter for risk validation errors.
  * Emits when risk validation functions throw errors during signal checking.
@@ -4455,8 +4469,9 @@ declare const emitters_signalLiveEmitter: typeof signalLiveEmitter;
 declare const emitters_validationSubject: typeof validationSubject;
 declare const emitters_walkerCompleteSubject: typeof walkerCompleteSubject;
 declare const emitters_walkerEmitter: typeof walkerEmitter;
+declare const emitters_walkerStopSubject: typeof walkerStopSubject;
 declare namespace emitters {
-  export { emitters_doneBacktestSubject as doneBacktestSubject, emitters_doneLiveSubject as doneLiveSubject, emitters_doneWalkerSubject as doneWalkerSubject, emitters_errorEmitter as errorEmitter, emitters_performanceEmitter as performanceEmitter, emitters_progressEmitter as progressEmitter, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter };
+  export { emitters_doneBacktestSubject as doneBacktestSubject, emitters_doneLiveSubject as doneLiveSubject, emitters_doneWalkerSubject as doneWalkerSubject, emitters_errorEmitter as errorEmitter, emitters_performanceEmitter as performanceEmitter, emitters_progressEmitter as progressEmitter, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
 }
 
 /**
@@ -4718,6 +4733,16 @@ declare class StrategyConnectionService implements IStrategy {
      * @returns Configured ClientStrategy instance
      */
     private getStrategy;
+    /**
+     * Retrieves the currently active pending signal for the strategy.
+     * If no active signal exists, returns null.
+     * Used internally for monitoring TP/SL and time expiration.
+     *
+     * @param strategyName - Name of strategy to get pending signal for
+     *
+     * @returns Promise resolving to pending signal or null
+     */
+    getPendingSignal: (strategyName: StrategyName) => Promise<ISignalRow | null>;
     /**
      * Executes live trading tick for current strategy.
      *
@@ -5165,6 +5190,17 @@ declare class StrategyGlobalService {
      * @returns Promise that resolves when validation is complete
      */
     private validate;
+    /**
+     * Retrieves the currently active pending signal for the symbol.
+     * If no active signal exists, returns null.
+     * Used internally for monitoring TP/SL and time expiration.
+     *
+     * @param symbol - Trading pair symbol
+     * @param when - Timestamp for tick evaluation
+     * @param backtest - Whether running in backtest mode
+     * @returns Promise resolving to pending signal or null
+     */
+    getPendingSignal: (strategyName: StrategyName) => Promise<ISignalRow | null>;
     /**
      * Checks signal status at a specific timestamp.
      *