backtest-kit 2.2.7 → 2.2.9

package/build/index.cjs

@@ -6554,6 +6554,40 @@ class RiskUtils {
  */
 const Risk = new RiskUtils();
 
+/**
+ * Emits signal tick results with correct execution context timestamp.
+ * Wraps emitter calls in ExecutionContextService.runInContext to preserve
+ * the temporal context from the tick's createdAt timestamp.
+ */
+const CALL_SIGNAL_EMIT_FN = functoolsKit.trycatch(beginTime(async (self, tick, context, isBacktest, symbol) => {
+    await ExecutionContextService.runInContext(async () => {
+        if (isBacktest) {
+            await signalBacktestEmitter.next(tick);
+            await self.actionCoreService.signalBacktest(isBacktest, tick, context);
+        }
+        if (!isBacktest) {
+            await signalLiveEmitter.next(tick);
+            await self.actionCoreService.signalLive(isBacktest, tick, context);
+        }
+        await signalEmitter.next(tick);
+        await self.actionCoreService.signal(isBacktest, tick, context);
+    }, {
+        when: new Date(tick.createdAt),
+        symbol: symbol,
+        backtest: isBacktest,
+    });
+}), {
+    fallback: (error) => {
+        const message = "StrategyConnectionService CALL_SIGNAL_EMIT_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * No-operation IRisk implementation.
  * Always allows signals and performs no actions.
@@ -6926,16 +6960,7 @@ class StrategyConnectionService {
             await strategy.waitForInit();
             const tick = await strategy.tick(symbol, context.strategyName);
             {
-                if (this.executionContextService.context.backtest) {
-                    await signalBacktestEmitter.next(tick);
-                    await this.actionCoreService.signalBacktest(backtest, tick, context);
-                }
-                if (!this.executionContextService.context.backtest) {
-                    await signalLiveEmitter.next(tick);
-                    await this.actionCoreService.signalLive(backtest, tick, context);
-                }
-                await signalEmitter.next(tick);
-                await this.actionCoreService.signal(backtest, tick, context);
+                await CALL_SIGNAL_EMIT_FN(this, tick, context, backtest, symbol);
             }
             return tick;
         };
@@ -6962,16 +6987,7 @@ class StrategyConnectionService {
             await strategy.waitForInit();
             const tick = await strategy.backtest(symbol, context.strategyName, candles);
             {
-                if (this.executionContextService.context.backtest) {
-                    await signalBacktestEmitter.next(tick);
-                    await this.actionCoreService.signalBacktest(backtest, tick, context);
-                }
-                if (!this.executionContextService.context.backtest) {
-                    await signalLiveEmitter.next(tick);
-                    await this.actionCoreService.signalLive(backtest, tick, context);
-                }
-                await signalEmitter.next(tick);
-                await this.actionCoreService.signal(backtest, tick, context);
+                await CALL_SIGNAL_EMIT_FN(this, tick, context, backtest, symbol);
             }
             return tick;
         };
@@ -12001,6 +12017,7 @@ class BacktestLogicPrivateService {
         this.exchangeCoreService = inject(TYPES.exchangeCoreService);
         this.frameCoreService = inject(TYPES.frameCoreService);
         this.methodContextService = inject(TYPES.methodContextService);
+        this.actionCoreService = inject(TYPES.actionCoreService);
     }
     /**
      * Runs backtest for a symbol, streaming closed signals as async generator.
@@ -12136,18 +12153,29 @@ class BacktestLogicPrivateService {
                 // и если активируется - продолжит с TP/SL мониторингом
                 let backtestResult;
                 let unScheduleOpen;
+                let scheduleOpenResult;
                 {
                     const { strategyName, exchangeName, frameName } = this.methodContextService.context;
                     unScheduleOpen = backtestScheduleOpenSubject.filter((event) => {
                         let isOk = true;
                         {
+                            isOk = isOk && event.action === "opened";
                             isOk = isOk && event.strategyName === strategyName;
                             isOk = isOk && event.exchangeName === exchangeName;
                             isOk = isOk && event.frameName === frameName;
                             isOk = isOk && event.symbol === symbol;
                         }
                         return isOk;
-                    }).connect(async (tick) => await signalBacktestEmitter.next(tick));
+                    }).connect(async (tick) => {
+                        scheduleOpenResult = tick;
+                        await signalEmitter.next(tick);
+                        await signalBacktestEmitter.next(tick);
+                        await this.actionCoreService.signalBacktest(true, tick, {
+                            strategyName,
+                            exchangeName,
+                            frameName,
+                        });
+                    });
                 }
                 try {
                     backtestResult = await this.strategyCoreService.backtest(symbol, candles, when, true, {
@@ -12199,6 +12227,9 @@ class BacktestLogicPrivateService {
                     timeframes[i].getTime() < backtestResult.closeTimestamp) {
                     i++;
                 }
+                if (scheduleOpenResult) {
+                    yield scheduleOpenResult;
+                }
                 yield backtestResult;
                 // Check if strategy should stop after signal is closed
                 if (await this.strategyCoreService.getStopped(true, symbol, {
@@ -32411,6 +32442,7 @@ class NotificationInstance {
         this._notifications = [];
         /**
          * Processes signal events and creates appropriate notifications.
+         * Sorts signal notifications by createdAt to maintain chronological order.
          */
         this._handleSignal = async (data) => {
             if (data.action === "opened") {
@@ -32489,6 +32521,12 @@ class NotificationInstance {
                     createdAt: data.createdAt,
                 });
             }
+            // Sort signal notifications by createdAt (newest first)
+            this._notifications.sort((a, b) => {
+                const aCreatedAt = "createdAt" in a ? a.createdAt : 0;
+                const bCreatedAt = "createdAt" in b ? b.createdAt : 0;
+                return bCreatedAt - aCreatedAt;
+            });
         };
         /**
          * Processes partial profit events.

package/build/index.mjs

@@ -6534,6 +6534,40 @@ class RiskUtils {
  */
 const Risk = new RiskUtils();
 
+/**
+ * Emits signal tick results with correct execution context timestamp.
+ * Wraps emitter calls in ExecutionContextService.runInContext to preserve
+ * the temporal context from the tick's createdAt timestamp.
+ */
+const CALL_SIGNAL_EMIT_FN = trycatch(beginTime(async (self, tick, context, isBacktest, symbol) => {
+    await ExecutionContextService.runInContext(async () => {
+        if (isBacktest) {
+            await signalBacktestEmitter.next(tick);
+            await self.actionCoreService.signalBacktest(isBacktest, tick, context);
+        }
+        if (!isBacktest) {
+            await signalLiveEmitter.next(tick);
+            await self.actionCoreService.signalLive(isBacktest, tick, context);
+        }
+        await signalEmitter.next(tick);
+        await self.actionCoreService.signal(isBacktest, tick, context);
+    }, {
+        when: new Date(tick.createdAt),
+        symbol: symbol,
+        backtest: isBacktest,
+    });
+}), {
+    fallback: (error) => {
+        const message = "StrategyConnectionService CALL_SIGNAL_EMIT_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * No-operation IRisk implementation.
  * Always allows signals and performs no actions.
@@ -6906,16 +6940,7 @@ class StrategyConnectionService {
             await strategy.waitForInit();
             const tick = await strategy.tick(symbol, context.strategyName);
             {
-                if (this.executionContextService.context.backtest) {
-                    await signalBacktestEmitter.next(tick);
-                    await this.actionCoreService.signalBacktest(backtest, tick, context);
-                }
-                if (!this.executionContextService.context.backtest) {
-                    await signalLiveEmitter.next(tick);
-                    await this.actionCoreService.signalLive(backtest, tick, context);
-                }
-                await signalEmitter.next(tick);
-                await this.actionCoreService.signal(backtest, tick, context);
+                await CALL_SIGNAL_EMIT_FN(this, tick, context, backtest, symbol);
             }
             return tick;
         };
@@ -6942,16 +6967,7 @@ class StrategyConnectionService {
             await strategy.waitForInit();
             const tick = await strategy.backtest(symbol, context.strategyName, candles);
             {
-                if (this.executionContextService.context.backtest) {
-                    await signalBacktestEmitter.next(tick);
-                    await this.actionCoreService.signalBacktest(backtest, tick, context);
-                }
-                if (!this.executionContextService.context.backtest) {
-                    await signalLiveEmitter.next(tick);
-                    await this.actionCoreService.signalLive(backtest, tick, context);
-                }
-                await signalEmitter.next(tick);
-                await this.actionCoreService.signal(backtest, tick, context);
+                await CALL_SIGNAL_EMIT_FN(this, tick, context, backtest, symbol);
             }
             return tick;
         };
@@ -11981,6 +11997,7 @@ class BacktestLogicPrivateService {
         this.exchangeCoreService = inject(TYPES.exchangeCoreService);
         this.frameCoreService = inject(TYPES.frameCoreService);
         this.methodContextService = inject(TYPES.methodContextService);
+        this.actionCoreService = inject(TYPES.actionCoreService);
     }
     /**
      * Runs backtest for a symbol, streaming closed signals as async generator.
@@ -12116,18 +12133,29 @@ class BacktestLogicPrivateService {
                 // и если активируется - продолжит с TP/SL мониторингом
                 let backtestResult;
                 let unScheduleOpen;
+                let scheduleOpenResult;
                 {
                     const { strategyName, exchangeName, frameName } = this.methodContextService.context;
                     unScheduleOpen = backtestScheduleOpenSubject.filter((event) => {
                         let isOk = true;
                         {
+                            isOk = isOk && event.action === "opened";
                             isOk = isOk && event.strategyName === strategyName;
                             isOk = isOk && event.exchangeName === exchangeName;
                             isOk = isOk && event.frameName === frameName;
                             isOk = isOk && event.symbol === symbol;
                         }
                         return isOk;
-                    }).connect(async (tick) => await signalBacktestEmitter.next(tick));
+                    }).connect(async (tick) => {
+                        scheduleOpenResult = tick;
+                        await signalEmitter.next(tick);
+                        await signalBacktestEmitter.next(tick);
+                        await this.actionCoreService.signalBacktest(true, tick, {
+                            strategyName,
+                            exchangeName,
+                            frameName,
+                        });
+                    });
                 }
                 try {
                     backtestResult = await this.strategyCoreService.backtest(symbol, candles, when, true, {
@@ -12179,6 +12207,9 @@ class BacktestLogicPrivateService {
                     timeframes[i].getTime() < backtestResult.closeTimestamp) {
                     i++;
                 }
+                if (scheduleOpenResult) {
+                    yield scheduleOpenResult;
+                }
                 yield backtestResult;
                 // Check if strategy should stop after signal is closed
                 if (await this.strategyCoreService.getStopped(true, symbol, {
@@ -32391,6 +32422,7 @@ class NotificationInstance {
         this._notifications = [];
         /**
          * Processes signal events and creates appropriate notifications.
+         * Sorts signal notifications by createdAt to maintain chronological order.
          */
         this._handleSignal = async (data) => {
             if (data.action === "opened") {
@@ -32469,6 +32501,12 @@ class NotificationInstance {
                     createdAt: data.createdAt,
                 });
             }
+            // Sort signal notifications by createdAt (newest first)
+            this._notifications.sort((a, b) => {
+                const aCreatedAt = "createdAt" in a ? a.createdAt : 0;
+                const bCreatedAt = "createdAt" in b ? b.createdAt : 0;
+                return bCreatedAt - aCreatedAt;
+            });
         };
         /**
          * Processes partial profit events.

package/package.json

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

package/types.d.ts

@@ -8899,7 +8899,7 @@ declare class BacktestUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }) => AsyncGenerator<IStrategyBacktestResult, void, unknown>;
+    }) => AsyncGenerator<IStrategyTickResultOpened | IStrategyBacktestResult, void, unknown>;
     /**
      * Runs backtest in background without yielding results.
      *
@@ -17436,6 +17436,7 @@ declare class BacktestLogicPrivateService {
     private readonly exchangeCoreService;
     private readonly frameCoreService;
     private readonly methodContextService;
+    private readonly actionCoreService;
     /**
      * Runs backtest for a symbol, streaming closed signals as async generator.
      *
@@ -17450,7 +17451,7 @@ declare class BacktestLogicPrivateService {
      * }
      * ```
      */
-    run(symbol: string): AsyncGenerator<IStrategyBacktestResult, void, unknown>;
+    run(symbol: string): AsyncGenerator<IStrategyTickResultOpened | IStrategyBacktestResult, void, unknown>;
 }
 
 /**
@@ -17557,7 +17558,7 @@ declare class BacktestLogicPublicService implements TBacktestLogicPrivateService
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }) => AsyncGenerator<IStrategyBacktestResult, void, unknown>;
+    }) => AsyncGenerator<IStrategyTickResultOpened | IStrategyBacktestResult, void, unknown>;
 }
 
 /**
@@ -17696,7 +17697,7 @@ declare class BacktestCommandService implements TBacktestLogicPublicService {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }) => AsyncGenerator<IStrategyBacktestResult, void, unknown>;
+    }) => AsyncGenerator<IStrategyTickResultOpened | IStrategyBacktestResult, void, unknown>;
 }
 
 /**