backtest-kit 1.3.1 → 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 = {
@@ -2671,11 +2677,14 @@ class StrategyConnectionService {
          * 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 () => {
+        this.getPendingSignal = async (strategyName) => {
             this.loggerService.log("strategyConnectionService getPendingSignal");
-            const strategy = await this.getStrategy(this.methodContextService.context.strategyName);
+            const strategy = await this.getStrategy(strategyName);
             return await strategy.getPendingSignal();
         };
         /**
@@ -3590,20 +3599,12 @@ class StrategyGlobalService {
          * @param backtest - Whether running in backtest mode
          * @returns Promise resolving to pending signal or null
          */
-        this.getPendingSignal = async (symbol, when, backtest) => {
+        this.getPendingSignal = async (strategyName) => {
             this.loggerService.log("strategyGlobalService getPendingSignal", {
-                symbol,
-                when,
-                backtest,
+                strategyName,
             });
             await this.validate(this.methodContextService.context.strategyName);
-            return await ExecutionContextService.runInContext(async () => {
-                return await this.strategyConnectionService.getPendingSignal();
-            }, {
-                symbol,
-                when,
-                backtest,
-            });
+            return await this.strategyConnectionService.getPendingSignal(strategyName);
         };
         /**
          * Checks signal status at a specific timestamp.
@@ -4607,6 +4608,7 @@ class LiveLogicPrivateService {
     }
 }
 
+const CANCEL_SYMBOL = Symbol("CANCEL_SYMBOL");
 /**
  * Private service for walker orchestration (strategy comparison).
  *
@@ -4664,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
@@ -4679,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,
@@ -9343,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;
             };
         };
@@ -9553,8 +9588,11 @@ class LiveUtils {
             return () => {
                 backtest$1.strategyGlobalService.stop(context.strategyName);
                 backtest$1.strategyGlobalService
-                    .getPendingSignal(symbol, new Date(), false)
-                    .then(async () => {
+                    .getPendingSignal(context.strategyName)
+                    .then(async (pendingSignal) => {
+                    if (pendingSignal) {
+                        return;
+                    }
                     if (!isDone) {
                         await doneLiveSubject.next({
                             exchangeName: context.exchangeName,
@@ -9990,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 = {
@@ -2669,11 +2675,14 @@ class StrategyConnectionService {
          * 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 () => {
+        this.getPendingSignal = async (strategyName) => {
             this.loggerService.log("strategyConnectionService getPendingSignal");
-            const strategy = await this.getStrategy(this.methodContextService.context.strategyName);
+            const strategy = await this.getStrategy(strategyName);
             return await strategy.getPendingSignal();
         };
         /**
@@ -3588,20 +3597,12 @@ class StrategyGlobalService {
          * @param backtest - Whether running in backtest mode
          * @returns Promise resolving to pending signal or null
          */
-        this.getPendingSignal = async (symbol, when, backtest) => {
+        this.getPendingSignal = async (strategyName) => {
             this.loggerService.log("strategyGlobalService getPendingSignal", {
-                symbol,
-                when,
-                backtest,
+                strategyName,
             });
             await this.validate(this.methodContextService.context.strategyName);
-            return await ExecutionContextService.runInContext(async () => {
-                return await this.strategyConnectionService.getPendingSignal();
-            }, {
-                symbol,
-                when,
-                backtest,
-            });
+            return await this.strategyConnectionService.getPendingSignal(strategyName);
         };
         /**
          * Checks signal status at a specific timestamp.
@@ -4605,6 +4606,7 @@ class LiveLogicPrivateService {
     }
 }
 
+const CANCEL_SYMBOL = Symbol("CANCEL_SYMBOL");
 /**
  * Private service for walker orchestration (strategy comparison).
  *
@@ -4662,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
@@ -4677,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,
@@ -9341,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;
             };
         };
@@ -9551,8 +9586,11 @@ class LiveUtils {
             return () => {
                 backtest$1.strategyGlobalService.stop(context.strategyName);
                 backtest$1.strategyGlobalService
-                    .getPendingSignal(symbol, new Date(), false)
-                    .then(async () => {
+                    .getPendingSignal(context.strategyName)
+                    .then(async (pendingSignal) => {
+                    if (pendingSignal) {
+                        return;
+                    }
                     if (!isDone) {
                         await doneLiveSubject.next({
                             exchangeName: context.exchangeName,
@@ -9988,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.1",
+  "version": "1.3.2",
   "description": "A TypeScript library for trading system backtest",
   "author": {
     "name": "Petr Tripolsky",

package/types.d.ts

@@ -4446,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.
@@ -4464,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 };
 }
 
 /**
@@ -4731,9 +4737,12 @@ declare class StrategyConnectionService implements IStrategy {
      * 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: () => Promise<ISignalRow | null>;
+    getPendingSignal: (strategyName: StrategyName) => Promise<ISignalRow | null>;
     /**
      * Executes live trading tick for current strategy.
      *
@@ -5191,7 +5200,7 @@ declare class StrategyGlobalService {
      * @param backtest - Whether running in backtest mode
      * @returns Promise resolving to pending signal or null
      */
-    getPendingSignal: (symbol: string, when: Date, backtest: boolean) => Promise<ISignalRow | null>;
+    getPendingSignal: (strategyName: StrategyName) => Promise<ISignalRow | null>;
     /**
      * Checks signal status at a specific timestamp.
      *