@pro/core Services: Logger, Scraper, Parser & Candle DB

interface ILogger {
  log(topic: string, ...args: any[]): void;
  debug(topic: string, ...args: any[]): void;
  info(topic: string, ...args: any[]): void;
  warn(topic: string, ...args: any[]): void;
}

const NOOP_LOGGER: ILogger = {
  log()  { void 0; },
  debug(){ void 0; },
  info() { void 0; },
  warn() { void 0; },
};

import { core } from "@pro/core";

// Wire in a real logger at startup
core.loggerService.setLogger(console);

// All subsequent calls from any service will now use console
core.loggerService.info("app started", { env: process.env.NODE_ENV });

export interface ScraperMessage {
  id: number;       // Telegram message ID
  channel: string;  // Channel username or ID passed to scrapeDay
  content: string;  // Raw text body of the message
  date: Date;       // UTC timestamp of the message
}

const messages = await core.scraperService.scrapeDay(
  "crypto_yoda_channel",
  new Date("2024-03-15")
);
// messages: ScraperMessage[] for the full UTC day 2024-03-15

export type ExtractConfig<T = string> = {
  pattern: RegExp;                                        // regex to match
  group?: number;                                         // capture group index (default: 1)
  transform?: (raw: string, match: RegExpMatchArray) => T; // coerce string to T
  validate?: (value: T) => boolean;                       // reject bad values
  multi?: boolean;                                        // use matchAll, return T[]
  optional?: boolean;                                     // skip field if no match (don't null the message)
};

export type FieldMapping = {
  [key: string]: RegExp | ExtractConfig<any>;
};

export type ExtractedData<M extends FieldMapping> = {
  [K in keyof M]: M[K] extends ExtractConfig<infer R>
    ? M[K] extends { multi: true } ? R[] : R
    : M[K] extends RegExp ? string : never;
};

export type ParseFormat<T> = {
  [K in keyof T]: RegExp | ExtractConfig<T[K] extends (infer U)[] ? U : T[K]>;
};

export interface ParserMessageRaw<M extends FieldMapping> extends ScraperMessage {
  data: ExtractedData<M> | null; // null when any required pattern fails
}

export interface ParserMessageSuccess<M extends FieldMapping> extends ScraperMessage {
  data: ExtractedData<M>; // always present — non-null
}

const successes = results.filter(
  (r): r is ParserMessageSuccess<typeof SIGNAL_FORMAT> => r.data !== null
);

type SignalFields = {
  symbol: string;
  direction: "short" | "long";
  entry: { from: number; to: number };
  targets: number[];
  stoploss: number;
};

const SIGNAL_FORMAT: ParseFormat<SignalFields> = {
  symbol: {
    pattern: /#([A-Z0-9]+)\/USDT/,
    group: 1,
    validate: (v) => v.length > 0,
  },
  direction: {
    pattern: /(ШОРТ|ЛОНГ)/i,
    transform: (raw) => (raw.toUpperCase() === "ШОРТ" ? "short" : "long"),
    validate: (v) => v === "short" || v === "long",
  },
  entry: {
    pattern: /зоне\s+\$?([\d.,]+)\s*[-–—]\s*(?:\$?[\d.,]+\s*[-–—]\s*)?\$?([\d.,]+)(?=\s)/i,
    transform: (_, m) => ({ from: num(m[1]), to: num(m[2]) }),
    validate: (v) => isNum(v.from) && isNum(v.to) && v.from < v.to,
  },
  targets: {
    pattern: /Закрыть(?:\s+ордер)?\s+по(?:\s+цене)?\s+\$?([\d.,]+)/gi,
    transform: (_, m) => num(m[1]),
    validate: (v) => isNum(v),
    multi: true,  // uses matchAll — returns number[]
  },
  stoploss: {
    pattern: /СТОП-?ЛОСС:\s*\$?([\d.,]+)/i,
    transform: (_, m) => num(m[1]),
    validate: (v) => isNum(v),
  },
};

// In a strategy file — no imports needed
const today = new Date();
const results = await core.cryptoYodaScreenService.screenDay(today);

const signals = results.filter((r) => r.data !== null);

for (const signal of signals) {
  const { symbol, direction, entry, targets, stoploss } = signal.data!;
  console.log(`${symbol} ${direction} entry ${entry.from}–${entry.to}`);
  console.log(`  targets: ${targets.join(", ")}  stoploss: ${stoploss}`);
}

// ICandleDto — the shape used when writing a candle
interface ICandleDto {
  symbol: string;           // e.g. "BTCUSDT"
  interval: CandleInterval; // "1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "6h" | "8h" | "1d"
  timestamp: number;        // Unix epoch in milliseconds (candle open time)
  open: number;
  high: number;
  low: number;
  close: number;
  volume: number;
}

// ICandleRow — the shape returned after a read
interface ICandleRow extends ICandleDto {
  id: string;               // MongoDB _id as string
  exchangeName: string;     // Always "ccxt_binance"
  createDate: Date;         // Mongoose timestamps.createdAt
  updatedDate: Date;        // Mongoose timestamps.updatedAt
}

// In a strategy file
const exists = await core.candleDbService.hasCandle("ETHUSDT", "1h", 1710460800000);

if (!exists) {
  await core.candleDbService.create({
    symbol: "ETHUSDT",
    interval: "1h",
    timestamp: 1710460800000,
    open: 3500,
    high: 3550,
    low: 3480,
    close: 3520,
    volume: 12345.67,
  });
}

const candle = await core.candleDbService.findBySymbolIntervalTimestamp(
  "ETHUSDT",
  "1h",
  1710460800000
);