Function addActionSchema

  • addActionSchema(actionSchema: IActionSchema): void

    Registers an action handler in the framework.

    Actions provide event-driven integration for:

    • State management (Redux, Zustand, MobX)
    • Real-time notifications (Telegram, Discord, email)
    • Event logging and monitoring
    • Analytics and metrics collection
    • Custom business logic triggers

    Each action instance is created per strategy-frame pair and receives all events emitted during strategy execution (signals, breakeven, partial profit/loss, etc.).

    Parameters

    • actionSchema: IActionSchema

      Action configuration object

      Action schema registered via addActionSchema(). Defines event handler implementation and lifecycle callbacks for state management integration.

      Actions provide a way to attach custom event handlers to strategies for:

      • State management (Redux, Zustand, MobX)
      • Event logging and monitoring
      • Real-time notifications (Telegram, Discord, email)
      • Analytics and metrics collection
      • Custom business logic triggers

      Each action instance is created per strategy-frame pair and receives all events emitted during strategy execution. Multiple actions can be attached to a single strategy.

      • actionName: string

        Unique action identifier for registration

      • Optionalcallbacks?: Partial<IActionCallbacks>

        Optional lifecycle and event callbacks

      • handler: Partial<IPublicAction> | TActionCtor

        Action handler constructor (instantiated per strategy-frame pair)

      • Optionalnote?: string

        Optional developer note for documentation

    Returns void

    Example

    // Using class-based handler
    class TelegramNotifier implements Partial<IPublicAction> {
      constructor(
        private strategyName: StrategyName,
        private frameName: FrameName,
        private actionName: ActionName
      ) {}

      async init() {
        this.bot = new TelegramBot(process.env.TELEGRAM_TOKEN);
        await this.bot.connect();
      }

      async signal(event: IStrategyTickResult) {
        if (event.action === 'opened') {
          await this.bot.send(`New signal: ${event.signal.side}`);
        }
      }

      async dispose() {
        await this.bot?.disconnect();
      }
    }

    addAction({
      actionName: "telegram-notifier",
      handler: TelegramNotifier,
      callbacks: {
        onInit: (actionName, strategyName, frameName, backtest) => {
          console.log(`[${actionName}] Initialized for ${strategyName}/${frameName}`);
        },
        onSignal: (event, actionName, strategyName, frameName, backtest) => {
          console.log(`[${actionName}] Signal event: ${event.action}`);
        },
      },
    });

    // Using plain object handler
    addAction({
      actionName: "simple-logger",
      handler: {
        signal: (event) => console.log('Signal:', event.action),
        breakeven: (event) => console.log('Breakeven triggered'),
      },
      callbacks: {},
    });

Settings

Member Visibility