@forgecharts/sdk 1.1.27 → 1.1.28

package/src/trading/UnmanagedIngestion.ts

@@ -1,156 +0,0 @@
-/**
- * UnmanagedIngestion
- *
- * External candle data ingestion for unmanaged mode.
- *
- * In unmanaged mode the client owns their data pipeline. They pass
- * normalised candle data to us; this layer validates the license gate,
- * delegates to the existing CandleEngine for bucket management, and
- * notifies callers via callbacks mirroring the CandleEngine contract.
- *
- * Critical constraint: the default RapidAPI-backed datafeed is completely
- * untouched. UnmanagedIngestion is an additive, opt-in path.
- *
- * Candle rules (matches CandleEngine behaviour):
- *   same timeMs   → update current candle
- *   newer timeMs  → append / new bucket
- *   older timeMs  → silently ignored (logged in debug mode)
- *
- * @example
- * ```ts
- * const ingestion = new UnmanagedIngestion('1m', {
- *   onBarUpdated: (bar) => series.update(bar),
- *   onResync:     (bars) => series.setData(bars),
- * });
- *
- * // Feed a full history snapshot first
- * ingestion.setHistory(historicalBars);
- *
- * // Then stream live ticks
- * ingestion.pushCandle(latestBar);
- * ```
- */
-
-import { CandleEngine } from '../engine/CandleEngine';
-import type { CandleBar, UpdateResult, GapInfo } from '../engine/CandleEngine';
-import { isUnmanagedMode } from '../licensing/ChartRuntimeResolver';
-import type { CandleInput } from './tradingTypes';
-import type { Timeframe } from '@forgecharts/types';
-
-export interface UnmanagedIngestionOptions {
-  /** Enable debug logging on the underlying CandleEngine. */
-  debug?: boolean;
-
-  /**
-   * Fired after every bar mutation (update or append from a live push).
-   * Corresponds to CandleEngine.onBarUpdated.
-   */
-  onBarUpdated?: (bar: CandleBar, result: UpdateResult) => void;
-
-  /**
-   * Fired when the full bar array changes (after setHistory or gap backfill).
-   * The chart adapter should call `series.setData(bars)`.
-   */
-  onResync?: (bars: readonly CandleBar[]) => void;
-
-  /** Fired when a candle bucket closes. */
-  onBarClosed?: (bar: CandleBar) => void;
-
-  /** Fired when the engine detects skipped buckets in the live stream. */
-  onGapDetected?: (info: GapInfo) => void;
-}
-
-export class UnmanagedIngestion {
-  private readonly _engine: CandleEngine;
-  private readonly _opts: UnmanagedIngestionOptions;
-  private _timeframe: Timeframe;
-
-  constructor(timeframe: Timeframe, opts: UnmanagedIngestionOptions = {}) {
-    this._opts      = opts;
-    this._timeframe = timeframe;
-    this._engine    = new CandleEngine({
-      ...(opts.debug         !== undefined ? { debug:         opts.debug         } : {}),
-      ...(opts.onBarUpdated  !== undefined ? { onBarUpdated:  opts.onBarUpdated  } : {}),
-      ...(opts.onBarClosed   !== undefined ? { onBarClosed:   opts.onBarClosed   } : {}),
-      ...(opts.onGapDetected !== undefined ? { onGapDetected: opts.onGapDetected } : {}),
-      ...(opts.onResync      !== undefined ? { onResync:      opts.onResync      } : {}),
-    });
-    // Prime the engine so it knows its timeframe before any data arrives
-    this._engine.initialize([], timeframe);
-  }
-
-  // ── Guard ────────────────────────────────────────────────────────────────────
-
-  private _assertUnmanaged(): void {
-    if (!isUnmanagedMode()) {
-      throw new Error(
-        '[ForgeCharts] External data ingestion is only available in unmanaged mode. ' +
-        'The active license is in managed mode.',
-      );
-    }
-  }
-
-  // ── History ──────────────────────────────────────────────────────────────────
-
-  /**
-   * Load a full historical bar snapshot.
-   * Replaces the engine's bar array and triggers `onResync` so the chart
-   * series is fully redrawn.
-   *
-   * Call this once at startup (or on symbol/interval change) before
-   * streaming live candles via `pushCandle`.
-   *
-   * @throws If the active license is not in unmanaged mode.
-   */
-  setHistory(bars: CandleInput[]): void {
-    this._assertUnmanaged();
-
-    // Sort ascending — initialize expects oldest → newest
-    const sorted = [...bars].sort((a, b) => a.time - b.time);
-    this._engine.initialize(sorted, this._timeframe);
-    // CandleEngine.initialize() does not fire onResync — invoke it explicitly
-    this._opts.onResync?.(this._engine.getBars());
-  }
-
-  // ── Live push ────────────────────────────────────────────────────────────────
-
-  /**
-   * Push a single live candle tick.
-   *
-   * Behaviour follows CandleEngine rules:
-   *   - same bucket  → updates existing bar (OHLCV merging)
-   *   - new bucket   → appends a new bar (previous bar is finalised)
-   *   - older bucket → silently ignored; debug-logged when `debug: true`
-   *
-   * @throws If the active license is not in unmanaged mode.
-   */
-  pushCandle(bar: CandleInput): UpdateResult {
-    this._assertUnmanaged();
-    return this._engine.applyLiveUpdate(bar);
-  }
-
-  // ── Accessors ────────────────────────────────────────────────────────────────
-
-  /** Returns the current bar array (chronological, ascending). */
-  getBars(): readonly CandleBar[] {
-    return this._engine.getBars();
-  }
-
-  /** Returns the latest candle, or null if no data has been loaded. */
-  getLatestBar(): CandleBar | null {
-    const bars = this._engine.getBars();
-    return bars.length > 0 ? bars[bars.length - 1]! : null;
-  }
-
-  /** Changes the active timeframe and clears all bar data. */
-  setTimeframe(timeframe: Timeframe): void {
-    this._timeframe = timeframe;
-    // Re-initialise with empty history — caller must follow up with setHistory()
-    this._engine.initialize([], timeframe);
-  }
-
-  /** Clears all bars (e.g. on symbol change before calling setHistory again). */
-  reset(): void {
-    this._engine.reset();
-  }
-}

package/src/trading/__tests__/ManagedTradingController.test.ts

@@ -1,338 +0,0 @@
-/**
- * ManagedTradingController — unit tests
- *
- * Covers:
- *   - Cannot initialize (registerProvider) in unmanaged mode
- *   - Can initialize in managed mode
- *   - isReady() reflects provider registration state
- *   - placeOrder() throws without a provider
- *   - placeOrder() with a mock provider: writes optimistic overlay entry,
- *     updates with provider id on success, rolls back on failure
- *   - cancelOrder() updates overlay status to 'cancelled'
- *   - modifyOrder() patches price / qty / label in overlay
- *   - placeBracketOrder() creates 3 orders with the same groupId in the overlay
- *   - reportFill() pushes to overlay + updates order status
- *   - All methods blocked in unmanaged mode
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { LicenseManager } from '../../licensing/LicenseManager';
-import { TradingOverlayStore } from '../TradingOverlayStore';
-import { ManagedTradingController } from '../managed/ManagedTradingController';
-import type { IExecutionProvider, PlaceOrderInput, PlaceBracketOrderInput } from '../managed/managedTypes';
-import type { ExecutionFill } from '../tradingTypes';
-
-// ─── License helpers ──────────────────────────────────────────────────────────
-
-function installManaged() {
-  LicenseManager.getInstance().loadLicense({ licenseKey: 'm', mode: 'managed' });
-}
-
-function installUnmanaged() {
-  LicenseManager.getInstance().loadLicense({ licenseKey: 'u', mode: 'unmanaged' });
-}
-
-function clearLicense() {
-  LicenseManager.getInstance().clear();
-}
-
-// ─── Mock provider factory ────────────────────────────────────────────────────
-
-function makeMockProvider(overrides: Partial<IExecutionProvider> = {}): IExecutionProvider {
-  return {
-    providerId: 'mock-provider',
-    placeOrder: vi.fn().mockResolvedValue({ orderId: 'prov-001', status: 'open' }),
-    cancelOrder: vi.fn().mockResolvedValue(undefined),
-    modifyOrder: vi.fn().mockResolvedValue({ orderId: 'prov-001', status: 'open' }),
-    placeBracketOrder: vi.fn().mockResolvedValue({
-      entry:      { orderId: 'prov-entry', timestamp: 1000 },
-      stopLoss:   { orderId: 'prov-sl',    timestamp: 1000 },
-      takeProfit: { orderId: 'prov-tp',    timestamp: 1000 },
-      groupId:    'bracket-test',
-    }),
-    ...overrides,
-  };
-}
-
-function makeOrderInput(overrides: Partial<PlaceOrderInput> = {}): PlaceOrderInput {
-  return {
-    symbol:     'BTCUSDT',
-    side:       'buy',
-    type:       'limit',
-    limitPrice: 50_000,
-    qty:        1,
-    ...overrides,
-  };
-}
-
-// ─── Mode gate ────────────────────────────────────────────────────────────────
-
-describe('ManagedTradingController — mode gate', () => {
-  afterEach(clearLicense);
-
-  it('registerProvider() throws in unmanaged mode', () => {
-    installUnmanaged();
-    const store = new TradingOverlayStore();
-    const ctrl  = new ManagedTradingController(store);
-    expect(() => ctrl.registerProvider(makeMockProvider())).toThrow(/managed/i);
-  });
-
-  it('registerProvider() throws when no license (defaults to unmanaged)', () => {
-    clearLicense();
-    const store = new TradingOverlayStore();
-    const ctrl  = new ManagedTradingController(store);
-    expect(() => ctrl.registerProvider(makeMockProvider())).toThrow(/managed/i);
-  });
-
-  it('registerProvider() succeeds in managed mode', () => {
-    installManaged();
-    const store = new TradingOverlayStore();
-    const ctrl  = new ManagedTradingController(store);
-    expect(() => ctrl.registerProvider(makeMockProvider())).not.toThrow();
-  });
-
-  it('placeOrder() throws in unmanaged mode', async () => {
-    installUnmanaged();
-    const store = new TradingOverlayStore();
-    const ctrl  = new ManagedTradingController(store);
-    await expect(ctrl.placeOrder(makeOrderInput())).rejects.toThrow(/managed/i);
-  });
-});
-
-// ─── isReady / getProviderId ──────────────────────────────────────────────────
-
-describe('ManagedTradingController — readiness', () => {
-  beforeEach(installManaged);
-  afterEach(clearLicense);
-
-  it('isReady() is false before provider registration', () => {
-    const ctrl = new ManagedTradingController(new TradingOverlayStore());
-    expect(ctrl.isReady()).toBe(false);
-  });
-
-  it('isReady() is true after registration', () => {
-    const ctrl = new ManagedTradingController(new TradingOverlayStore());
-    ctrl.registerProvider(makeMockProvider());
-    expect(ctrl.isReady()).toBe(true);
-  });
-
-  it('getProviderId() returns null before registration', () => {
-    const ctrl = new ManagedTradingController(new TradingOverlayStore());
-    expect(ctrl.getProviderId()).toBeNull();
-  });
-
-  it('getProviderId() returns the provider id after registration', () => {
-    const ctrl = new ManagedTradingController(new TradingOverlayStore());
-    ctrl.registerProvider(makeMockProvider({ providerId: 'rithmic' }));
-    expect(ctrl.getProviderId()).toBe('rithmic');
-  });
-});
-
-// ─── placeOrder ───────────────────────────────────────────────────────────────
-
-describe('ManagedTradingController — placeOrder', () => {
-  beforeEach(installManaged);
-  afterEach(clearLicense);
-
-  it('throws when no provider is registered', async () => {
-    const ctrl = new ManagedTradingController(new TradingOverlayStore());
-    await expect(ctrl.placeOrder(makeOrderInput())).rejects.toThrow(/no execution provider/i);
-  });
-
-  it('writes a pending order to overlay before provider responds', async () => {
-    const store    = new TradingOverlayStore();
-    const ctrl     = new ManagedTradingController(store);
-    let resolveAck: () => void;
-    const provider = makeMockProvider({
-      placeOrder: vi.fn().mockImplementation(
-        () => new Promise<{ orderId: string; status: 'open' }>((res) => {
-          resolveAck = () => res({ orderId: 'prov-001', status: 'open' });
-        }),
-      ),
-    });
-    ctrl.registerProvider(provider);
-
-    const promise = ctrl.placeOrder(makeOrderInput());
-    // Overlay should have a pending entry immediately (optimistic)
-    expect(store.getOrders().some(o => o.status === 'pending')).toBe(true);
-
-    resolveAck!();
-    await promise;
-  });
-
-  it('updates overlay with provider-assigned id on success', async () => {
-    const store    = new TradingOverlayStore();
-    const ctrl     = new ManagedTradingController(store);
-    const provider = makeMockProvider({
-      placeOrder: vi.fn().mockResolvedValue({ orderId: 'server-id-1', status: 'open' }),
-    });
-    ctrl.registerProvider(provider);
-
-    await ctrl.placeOrder(makeOrderInput());
-
-    const orders = store.getOrders();
-    expect(orders.some(o => o.id === 'server-id-1' && o.status === 'open')).toBe(true);
-  });
-
-  it('rolls back to rejected status when provider throws', async () => {
-    const store    = new TradingOverlayStore();
-    const ctrl     = new ManagedTradingController(store);
-    const provider = makeMockProvider({
-      placeOrder: vi.fn().mockRejectedValue(new Error('venue rejected')),
-    });
-    ctrl.registerProvider(provider);
-
-    await expect(ctrl.placeOrder(makeOrderInput())).rejects.toThrow('venue rejected');
-
-    const orders = store.getOrders();
-    expect(orders.some(o => o.status === 'rejected')).toBe(true);
-  });
-
-  it('delegates to the registered provider', async () => {
-    const store    = new TradingOverlayStore();
-    const ctrl     = new ManagedTradingController(store);
-    const mockFn   = vi.fn().mockResolvedValue({ orderId: 'x', status: 'open' });
-    ctrl.registerProvider(makeMockProvider({ placeOrder: mockFn }));
-
-    const input = makeOrderInput({ side: 'sell', qty: 3 });
-    await ctrl.placeOrder(input);
-
-    expect(mockFn).toHaveBeenCalledOnce();
-    expect(mockFn).toHaveBeenCalledWith(input);
-  });
-});
-
-// ─── cancelOrder ─────────────────────────────────────────────────────────────
-
-describe('ManagedTradingController — cancelOrder', () => {
-  beforeEach(installManaged);
-  afterEach(clearLicense);
-
-  it('updates overlay status to cancelled after provider confirms', async () => {
-    const store    = new TradingOverlayStore();
-    const ctrl     = new ManagedTradingController(store);
-    ctrl.registerProvider(makeMockProvider());
-
-    await ctrl.placeOrder(makeOrderInput());
-    // Find the confirmed order id
-    const orderId = store.getOrders().find(o => o.status === 'open')?.id;
-    expect(orderId).toBeDefined();
-
-    await ctrl.cancelOrder(orderId!);
-    expect(store.getOrders().find(o => o.id === orderId)!.status).toBe('cancelled');
-  });
-});
-
-// ─── modifyOrder ──────────────────────────────────────────────────────────────
-
-describe('ManagedTradingController — modifyOrder', () => {
-  beforeEach(installManaged);
-  afterEach(clearLicense);
-
-  it('patches price in overlay when limitPrice is provided', async () => {
-    const store    = new TradingOverlayStore();
-    const ctrl     = new ManagedTradingController(store);
-    ctrl.registerProvider(makeMockProvider());
-
-    await ctrl.placeOrder(makeOrderInput({ limitPrice: 50_000 }));
-    const orderId = store.getOrders().find(o => o.status === 'open')?.id;
-    expect(orderId).toBeDefined();
-
-    await ctrl.modifyOrder(orderId!, { limitPrice: 51_000 });
-    expect(store.getOrders().find(o => o.id === orderId)!.price).toBe(51_000);
-  });
-
-  it('patches qty in overlay when qty is provided', async () => {
-    const store    = new TradingOverlayStore();
-    const ctrl     = new ManagedTradingController(store);
-    ctrl.registerProvider(makeMockProvider());
-
-    await ctrl.placeOrder(makeOrderInput({ qty: 1 }));
-    const orderId = store.getOrders().find(o => o.status === 'open')?.id;
-    await ctrl.modifyOrder(orderId!, { qty: 5 });
-    expect(store.getOrders().find(o => o.id === orderId)!.qty).toBe(5);
-  });
-});
-
-// ─── placeBracketOrder ────────────────────────────────────────────────────────
-
-describe('ManagedTradingController — placeBracketOrder', () => {
-  beforeEach(installManaged);
-  afterEach(clearLicense);
-
-  it('throws without a provider', async () => {
-    const ctrl = new ManagedTradingController(new TradingOverlayStore());
-    const input: PlaceBracketOrderInput = {
-      entry:              makeOrderInput(),
-      stopLossPrice:      49_000,
-      takeProfitPrice:    55_000,
-    };
-    await expect(ctrl.placeBracketOrder(input)).rejects.toThrow(/no execution provider/i);
-  });
-
-  it('creates 3 orders sharing a groupId in the overlay', async () => {
-    const store    = new TradingOverlayStore();
-    const ctrl     = new ManagedTradingController(store);
-    ctrl.registerProvider(makeMockProvider());
-
-    const groupId = 'bracket-test';
-    const input: PlaceBracketOrderInput = {
-      entry:           makeOrderInput({ groupId }),
-      stopLossPrice:   49_000,
-      takeProfitPrice: 55_000,
-    };
-    await ctrl.placeBracketOrder(input);
-
-    const group = store.getOrdersByGroup(groupId);
-    expect(group).toHaveLength(3);
-
-    const roles = group.map(o => o.role).sort();
-    expect(roles).toContain('entry');
-    expect(roles).toContain('stop_loss');
-    expect(roles).toContain('take_profit');
-  });
-});
-
-// ─── reportFill ───────────────────────────────────────────────────────────────
-
-describe('ManagedTradingController — reportFill', () => {
-  beforeEach(installManaged);
-  afterEach(clearLicense);
-
-  it('pushes fill into overlay store', async () => {
-    const store = new TradingOverlayStore();
-    const ctrl  = new ManagedTradingController(store);
-    ctrl.registerProvider(makeMockProvider());
-
-    await ctrl.placeOrder(makeOrderInput());
-    const orderId = store.getOrders().find(o => o.status === 'open')?.id ?? 'oid';
-
-    const fill: ExecutionFill = {
-      id:        'fill-1',
-      orderId,
-      side:      'buy',
-      price:     50_000,
-      qty:       1,
-      timestamp: Date.now(),
-    };
-    ctrl.reportFill(fill);
-
-    expect(store.getFills()).toHaveLength(1);
-    expect(store.getFills()[0]!.id).toBe('fill-1');
-  });
-
-  it('updates order status to filled after a fill report', async () => {
-    const store = new TradingOverlayStore();
-    const ctrl  = new ManagedTradingController(store);
-    ctrl.registerProvider(makeMockProvider());
-
-    await ctrl.placeOrder(makeOrderInput());
-    const orderId = store.getOrders().find(o => o.status === 'open')?.id ?? 'oid';
-
-    ctrl.reportFill({
-      id: 'fill-2', orderId, side: 'buy', price: 50_000, qty: 1, timestamp: Date.now(),
-    });
-
-    expect(store.getOrders().find(o => o.id === orderId)!.status).toBe('filled');
-  });
-});