backtest-kit 1.3.0 → 1.3.1

package/build/index.cjs

@@ -1625,6 +1625,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 +2354,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 +2667,17 @@ 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.
+         * @returns Promise resolving to pending signal or null
+         */
+        this.getPendingSignal = async () => {
+            this.loggerService.log("strategyConnectionService getPendingSignal");
+            const strategy = await this.getStrategy(this.methodContextService.context.strategyName);
+            return await strategy.getPendingSignal();
+        };
         /**
          * Executes live trading tick for current strategy.
          *
@@ -3558,6 +3580,31 @@ 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 (symbol, when, backtest) => {
+            this.loggerService.log("strategyGlobalService getPendingSignal", {
+                symbol,
+                when,
+                backtest,
+            });
+            await this.validate(this.methodContextService.context.strategyName);
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.strategyConnectionService.getPendingSignal();
+            }, {
+                symbol,
+                when,
+                backtest,
+            });
+        };
         /**
          * Checks signal status at a specific timestamp.
          *
@@ -9485,22 +9532,39 @@ 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(symbol, new Date(), false)
+                    .then(async () => {
+                    if (!isDone) {
+                        await doneLiveSubject.next({
+                            exchangeName: context.exchangeName,
+                            strategyName: context.strategyName,
+                            backtest: false,
+                            symbol,
+                        });
+                    }
+                    isDone = true;
+                });
                 isStopped = true;
             };
         };

package/build/index.mjs

@@ -1623,6 +1623,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 +2352,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 +2665,17 @@ 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.
+         * @returns Promise resolving to pending signal or null
+         */
+        this.getPendingSignal = async () => {
+            this.loggerService.log("strategyConnectionService getPendingSignal");
+            const strategy = await this.getStrategy(this.methodContextService.context.strategyName);
+            return await strategy.getPendingSignal();
+        };
         /**
          * Executes live trading tick for current strategy.
          *
@@ -3556,6 +3578,31 @@ 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 (symbol, when, backtest) => {
+            this.loggerService.log("strategyGlobalService getPendingSignal", {
+                symbol,
+                when,
+                backtest,
+            });
+            await this.validate(this.methodContextService.context.strategyName);
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.strategyConnectionService.getPendingSignal();
+            }, {
+                symbol,
+                when,
+                backtest,
+            });
+        };
         /**
          * Checks signal status at a specific timestamp.
          *
@@ -9483,22 +9530,39 @@ 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(symbol, new Date(), false)
+                    .then(async () => {
+                    if (!isDone) {
+                        await doneLiveSubject.next({
+                            exchangeName: context.exchangeName,
+                            strategyName: context.strategyName,
+                            backtest: false,
+                            symbol,
+                        });
+                    }
+                    isDone = true;
+                });
                 isStopped = true;
             };
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backtest-kit",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "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.
@@ -4718,6 +4727,13 @@ 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.
+     * @returns Promise resolving to pending signal or null
+     */
+    getPendingSignal: () => Promise<ISignalRow | null>;
     /**
      * Executes live trading tick for current strategy.
      *
@@ -5165,6 +5181,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: (symbol: string, when: Date, backtest: boolean) => Promise<ISignalRow | null>;
     /**
      * Checks signal status at a specific timestamp.
      *