@backtest-kit/pinets 0.0.1

package/build/index.cjs

@@ -0,0 +1,588 @@
+'use strict';
+
+var path = require('path');
+var backtestKit = require('backtest-kit');
+var diKit = require('di-kit');
+var functoolsKit = require('functools-kit');
+var fs = require('fs/promises');
+var module$1 = require('module');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const CODE_TYPE_SYMBOL = Symbol("code-type");
+class Code {
+    constructor(source) {
+        this.source = source;
+        this.__type__ = CODE_TYPE_SYMBOL;
+    }
+}
+Code.fromString = (source) => {
+    if (!source || typeof source !== "string" || !source.trim()) {
+        throw new Error("Source must be a non-empty string");
+    }
+    return new Code(source);
+};
+Code.isCode = (value) => {
+    return (value !== null &&
+        typeof value === "object" &&
+        value.__type__ === CODE_TYPE_SYMBOL);
+};
+
+const FILE_TYPE_SYMBOL = Symbol("file-type");
+class File {
+    constructor(path, baseDir) {
+        this.path = path;
+        this.baseDir = baseDir;
+        this.__type__ = FILE_TYPE_SYMBOL;
+    }
+}
+File.fromPath = (path$1, baseDir = path.join(process.cwd(), "config/source")) => {
+    if (!path$1 || typeof path$1 !== "string" || !path$1.trim()) {
+        throw new Error("Path must be a non-empty string");
+    }
+    return new File(path$1, baseDir);
+};
+File.isFile = (value) => {
+    return (value !== null &&
+        typeof value === "object" &&
+        value.__type__ === FILE_TYPE_SYMBOL);
+};
+
+const NOOP_LOGGER = {
+    log() {
+    },
+    debug() {
+    },
+    info() {
+    },
+    warn() {
+    },
+};
+class LoggerService {
+    constructor() {
+        this._commonLogger = NOOP_LOGGER;
+        this.log = async (topic, ...args) => {
+            await this._commonLogger.log(topic, ...args);
+        };
+        this.debug = async (topic, ...args) => {
+            await this._commonLogger.debug(topic, ...args);
+        };
+        this.info = async (topic, ...args) => {
+            await this._commonLogger.info(topic, ...args);
+        };
+        this.warn = async (topic, ...args) => {
+            await this._commonLogger.warn(topic, ...args);
+        };
+        this.setLogger = (logger) => {
+            this._commonLogger = logger;
+        };
+    }
+}
+
+const { provide, inject, init, override } = diKit.createActivator("pine");
+
+const baseServices = {
+    loggerService: Symbol("loggerService"),
+};
+const providerServices$1 = {
+    axisProviderService: Symbol("axisProviderService"),
+    candleProviderService: Symbol("candleProviderService"),
+};
+const jobServices$1 = {
+    pineJobService: Symbol("pineJobService"),
+};
+const dataServices$1 = {
+    pineDataService: Symbol("pineDataService"),
+};
+const cacheServices$1 = {
+    pineCacheService: Symbol("pineCacheService"),
+};
+const connectionServices$1 = {
+    pineConnectionService: Symbol("pineConnectionService"),
+};
+const TYPES = {
+    ...baseServices,
+    ...providerServices$1,
+    ...jobServices$1,
+    ...dataServices$1,
+    ...cacheServices$1,
+    ...connectionServices$1,
+};
+
+const MS_PER_MINUTE = 60000;
+const INTERVAL_MINUTES = {
+    "1m": 1,
+    "3m": 3,
+    "5m": 5,
+    "15m": 15,
+    "30m": 30,
+    "1h": 60,
+    "2h": 120,
+    "4h": 240,
+    "6h": 360,
+    "8h": 480,
+};
+const AXIS_SYMBOL = "_AXIS";
+class AxisProviderService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    async getMarketData(_, timeframe, limit, sDate, eDate) {
+        this.loggerService.log("axisProviderService getMarketData", {
+            timeframe,
+            limit,
+            sDate,
+            eDate,
+        });
+        const step = INTERVAL_MINUTES[timeframe];
+        if (!step) {
+            throw new Error(`AxisProvider getMarketData: unknown timeframe=${timeframe}. Allowed values: ${Object.keys(INTERVAL_MINUTES).join(", ")}`);
+        }
+        const currentDate = await backtestKit.getDate();
+        const whenTimestamp = currentDate.getTime();
+        const intervalMs = step * MS_PER_MINUTE;
+        let sinceTimestamp;
+        let untilTimestamp;
+        let calculatedLimit;
+        if (sDate !== undefined && eDate !== undefined && limit !== undefined) {
+            if (sDate >= eDate) {
+                throw new Error(`AxisProvider getMarketData: sDate (${sDate}) must be < eDate (${eDate})`);
+            }
+            if (eDate > whenTimestamp) {
+                throw new Error(`AxisProvider getMarketData: eDate (${eDate}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
+            }
+            sinceTimestamp = sDate;
+            untilTimestamp = eDate;
+            calculatedLimit = limit;
+        }
+        else if (sDate !== undefined && eDate !== undefined && limit === undefined) {
+            if (sDate >= eDate) {
+                throw new Error(`AxisProvider getMarketData: sDate (${sDate}) must be < eDate (${eDate})`);
+            }
+            if (eDate > whenTimestamp) {
+                throw new Error(`AxisProvider getMarketData: eDate (${eDate}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
+            }
+            sinceTimestamp = sDate;
+            untilTimestamp = eDate;
+            calculatedLimit = Math.ceil((eDate - sDate) / intervalMs);
+            if (calculatedLimit <= 0) {
+                throw new Error(`AxisProvider getMarketData: calculated limit is ${calculatedLimit}, must be > 0`);
+            }
+        }
+        else if (sDate === undefined && eDate !== undefined && limit !== undefined) {
+            if (eDate > whenTimestamp) {
+                throw new Error(`AxisProvider getMarketData: eDate (${eDate}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
+            }
+            untilTimestamp = eDate;
+            sinceTimestamp = eDate - limit * intervalMs;
+            calculatedLimit = limit;
+        }
+        else if (sDate !== undefined && eDate === undefined && limit !== undefined) {
+            sinceTimestamp = sDate;
+            untilTimestamp = sDate + limit * intervalMs;
+            if (untilTimestamp > whenTimestamp) {
+                throw new Error(`AxisProvider getMarketData: calculated endTimestamp (${untilTimestamp}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
+            }
+            calculatedLimit = limit;
+        }
+        else if (sDate === undefined && eDate === undefined && limit !== undefined) {
+            untilTimestamp = whenTimestamp;
+            sinceTimestamp = whenTimestamp - limit * intervalMs;
+            calculatedLimit = limit;
+        }
+        else {
+            throw new Error(`AxisProvider getMarketData: invalid parameter combination. ` +
+                `Provide one of: (sDate+eDate+limit), (sDate+eDate), (eDate+limit), (sDate+limit), or (limit only). ` +
+                `Got: sDate=${sDate}, eDate=${eDate}, limit=${limit}`);
+        }
+        const candles = [];
+        for (let i = 0; i < calculatedLimit; i++) {
+            const openTime = sinceTimestamp + i * intervalMs;
+            if (openTime >= untilTimestamp) {
+                break;
+            }
+            candles.push({
+                openTime,
+                open: 0,
+                high: 0,
+                low: 0,
+                close: 0,
+                volume: 0,
+            });
+        }
+        return candles;
+    }
+    async getSymbolInfo() {
+        this.loggerService.log("axisProviderService getSymbolInfo");
+        const result = {
+            ticker: AXIS_SYMBOL,
+            tickerid: AXIS_SYMBOL,
+            description: "Time Axis",
+            type: "index",
+            basecurrency: "",
+            currency: "",
+            timezone: "UTC",
+        };
+        return result;
+    }
+}
+
+class CandleProviderService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    async getMarketData(tickerId, timeframe, limit, sDate, eDate) {
+        this.loggerService.log("candleProviderService getMarketData", {
+            tickerId,
+            timeframe,
+            limit,
+            sDate,
+            eDate,
+        });
+        const symbol = tickerId
+            .toUpperCase()
+            .replace(/^BINANCE:|^BYBIT:|^OKX:/, "");
+        const rawCandles = await backtestKit.getRawCandles(symbol, timeframe, limit, sDate, eDate);
+        const candles = rawCandles.map((c) => ({
+            openTime: c.timestamp,
+            open: c.open,
+            high: c.high,
+            low: c.low,
+            close: c.close,
+            volume: c.volume,
+        }));
+        return candles;
+    }
+    async getSymbolInfo(tickerId) {
+        this.loggerService.log("candleProviderService getSymbolInfo", {
+            tickerId,
+        });
+        const symbol = tickerId
+            .toUpperCase()
+            .replace(/^BINANCE:|^BYBIT:|^OKX:/, "");
+        const base = symbol.replace(/USDT$|BUSD$|USD$/, "");
+        const quote = symbol.replace(base, "");
+        const result = {
+            ticker: symbol,
+            tickerid: symbol,
+            description: `${base}/${quote}`,
+            type: "crypto",
+            basecurrency: base,
+            currency: quote || "USDT",
+            timezone: "UTC",
+        };
+        return result;
+    }
+}
+
+const CREATE_PROVIDER_FN = functoolsKit.singleshot((self) => ({
+    async getMarketData(tickerId, timeframe, limit, sDate, eDate) {
+        if (tickerId === AXIS_SYMBOL) {
+            return await self.axisProviderService.getMarketData(tickerId, timeframe, limit, sDate, eDate);
+        }
+        return await self.candleProviderService.getMarketData(tickerId, timeframe, limit, sDate, eDate);
+    },
+    async getSymbolInfo(tickerId) {
+        if (tickerId === AXIS_SYMBOL) {
+            return await self.axisProviderService.getSymbolInfo();
+        }
+        return await self.candleProviderService.getSymbolInfo(tickerId);
+    },
+}));
+const CREATE_RUNNER_FN = async (self, tickerId, timeframe, limit) => {
+    const provider = CREATE_PROVIDER_FN(self);
+    const instance = await self.pineConnectionService.getInstance(provider, tickerId, timeframe, limit);
+    await instance.ready();
+    return instance;
+};
+class PineJobService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.axisProviderService = inject(TYPES.axisProviderService);
+        this.candleProviderService = inject(TYPES.candleProviderService);
+        this.pineConnectionService = inject(TYPES.pineConnectionService);
+        this.run = async (code, tickerId, timeframe = "1m", limit = 100) => {
+            this.loggerService.log("pineJobService run", {
+                script: code.source,
+                tickerId,
+                timeframe,
+                limit,
+            });
+            const runner = await CREATE_RUNNER_FN(this, tickerId, timeframe, limit);
+            return await runner.run(code.source);
+        };
+    }
+}
+
+const GET_VALUE_FN = (plots, name, barsBack = 0) => {
+    const data = plots[name]?.data;
+    if (!data || data.length === 0)
+        return 0;
+    const idx = data.length - 1 - barsBack;
+    return idx >= 0 ? (data[idx]?.value ?? 0) : 0;
+};
+class PineDataService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    extract(plots, mapping) {
+        this.loggerService.log("pineDataService extract", {
+            plotCount: Object.keys(plots).length,
+            mapping,
+        });
+        const result = {};
+        for (const key in mapping) {
+            const config = mapping[key];
+            if (typeof config === "string") {
+                Object.assign(result, { [key]: GET_VALUE_FN(plots, config) });
+            }
+            else {
+                const value = GET_VALUE_FN(plots, config.plot, config.barsBack ?? 0);
+                Object.assign(result, {
+                    [key]: config.transform ? config.transform(value) : value,
+                });
+            }
+        }
+        return result;
+    }
+}
+
+const READ_FILE_FN = functoolsKit.memoize(([filePath]) => filePath, async (filePath) => {
+    const fileContent = await fs.readFile(filePath, "utf-8");
+    return fileContent;
+});
+class PineCacheService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.readFile = async (path$1, baseDir = path.join(process.cwd(), "config/source")) => {
+            this.loggerService.log("pineCacheService readFile", {
+                path: path$1,
+                baseDir,
+            });
+            const filePath = path.join(baseDir, path$1);
+            return await READ_FILE_FN(filePath);
+        };
+        this.clear = async (path$1, baseDir = path.join(process.cwd(), "config/source")) => {
+            this.loggerService.log("pineCacheService clear", {
+                path: path$1,
+                baseDir,
+            });
+            if (path$1) {
+                const filePath = path.join(baseDir, path$1);
+                READ_FILE_FN.clear(filePath);
+                return;
+            }
+            READ_FILE_FN.clear();
+        };
+    }
+}
+
+const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+const REQUIRE_PINE_FACTORY = () => {
+    try {
+        // @ts-ignore
+        const { PineTS } = require$1("pinets");
+        // @ts-ignore
+        return PineTS;
+    }
+    catch {
+        return null;
+    }
+};
+const IMPORT_PINE_FACTORY = async () => {
+    try {
+        // @ts-ignore
+        const { PineTS } = await import('pinets');
+        // @ts-ignore
+        return PineTS;
+    }
+    catch {
+        return null;
+    }
+};
+const LOAD_PINE_FACTORY_FN = functoolsKit.singleshot(async () => {
+    let ctor = null;
+    if (ctor = REQUIRE_PINE_FACTORY()) {
+        return ctor;
+    }
+    if (ctor = await IMPORT_PINE_FACTORY()) {
+        return ctor;
+    }
+    throw new Error("PineTS import failed. Call usePine to provide a PineTS class to @backtest-kit/pinets.");
+});
+class PineConnectionService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.getInstance = async (...args) => {
+            this.loggerService.log("pineConnectionService getInstance", {
+                args,
+            });
+            if (!this.PineFactory) {
+                this.PineFactory = await LOAD_PINE_FACTORY_FN();
+            }
+            if (!this.PineFactory) {
+                throw new Error("PineTS import failed. Call usePine to provide a PineTS class to @backtest-kit/pinets.");
+            }
+            return Reflect.construct(this.PineFactory, args);
+        };
+        this.usePine = (ctor) => {
+            this.loggerService.log("pineConnectionService usePine", {
+                ctor,
+            });
+            this.PineFactory = ctor;
+        };
+        this.clear = () => {
+            this.loggerService.log("pineConnectionService clear");
+            LOAD_PINE_FACTORY_FN.clear();
+            this.PineFactory = null;
+        };
+    }
+}
+
+{
+    provide(TYPES.loggerService, () => new LoggerService());
+}
+{
+    provide(TYPES.axisProviderService, () => new AxisProviderService());
+    provide(TYPES.candleProviderService, () => new CandleProviderService());
+}
+{
+    provide(TYPES.pineJobService, () => new PineJobService());
+}
+{
+    provide(TYPES.pineDataService, () => new PineDataService());
+}
+{
+    provide(TYPES.pineCacheService, () => new PineCacheService());
+}
+{
+    provide(TYPES.pineConnectionService, () => new PineConnectionService());
+}
+
+const commonServices = {
+    loggerService: inject(TYPES.loggerService),
+};
+const providerServices = {
+    axisProviderService: inject(TYPES.axisProviderService),
+    candleProviderService: inject(TYPES.candleProviderService),
+};
+const jobServices = {
+    pineJobService: inject(TYPES.pineJobService),
+};
+const dataServices = {
+    pineDataService: inject(TYPES.pineDataService),
+};
+const cacheServices = {
+    pineCacheService: inject(TYPES.pineCacheService),
+};
+const connectionServices = {
+    pineConnectionService: inject(TYPES.pineConnectionService),
+};
+const pine = {
+    ...commonServices,
+    ...providerServices,
+    ...jobServices,
+    ...dataServices,
+    ...cacheServices,
+    ...connectionServices,
+};
+init();
+
+const METHOD_NAME_USE_PINE = "pine.usePine";
+function usePine(ctor) {
+    pine.loggerService.log(METHOD_NAME_USE_PINE, {
+        ctor,
+    });
+    pine.pineConnectionService.usePine(ctor);
+}
+
+const METHOD_NAME_RUN$1 = "run.run";
+const GET_SOURCE_FN$1 = async (source) => {
+    if (File.isFile(source)) {
+        const code = await pine.pineCacheService.readFile(source.path, source.baseDir);
+        return Code.fromString(code);
+    }
+    if (Code.isCode(source)) {
+        return source;
+    }
+    throw new Error("Source must be a File or Code instance");
+};
+async function run(source, { symbol, timeframe, mapping, limit }) {
+    pine.loggerService.info(METHOD_NAME_RUN$1, {
+        source,
+        symbol,
+        timeframe,
+        mapping,
+        limit,
+    });
+    const script = await GET_SOURCE_FN$1(source);
+    const { plots } = await pine.pineJobService.run(script, symbol, timeframe, limit);
+    return pine.pineDataService.extract(plots, mapping);
+}
+
+function setLogger(logger) {
+    pine.loggerService.setLogger(logger);
+}
+
+const METHOD_NAME_RUN = "strategy.getSignal";
+const DEFAULT_ESTIMATED_TIME = 240;
+const GET_SOURCE_FN = async (source) => {
+    if (File.isFile(source)) {
+        const code = await pine.pineCacheService.readFile(source.path, source.baseDir);
+        return Code.fromString(code);
+    }
+    if (Code.isCode(source)) {
+        return source;
+    }
+    throw new Error("Source must be a File or Code instance");
+};
+const SIGNAL_SCHEMA = {
+    position: "Signal",
+    priceOpen: "Close",
+    priceTakeProfit: "TakeProfit",
+    priceStopLoss: "StopLoss",
+    minuteEstimatedTime: {
+        plot: "EstimatedTime",
+        transform: (v) => v || DEFAULT_ESTIMATED_TIME,
+    },
+};
+function toSignalDto(data) {
+    if (data.position === 1) {
+        return {
+            position: "long",
+            priceOpen: data.priceOpen,
+            priceTakeProfit: data.priceTakeProfit,
+            priceStopLoss: data.priceStopLoss,
+            minuteEstimatedTime: data.minuteEstimatedTime,
+        };
+    }
+    if (data.position === -1) {
+        return {
+            position: "short",
+            priceOpen: data.priceOpen,
+            priceTakeProfit: data.priceTakeProfit,
+            priceStopLoss: data.priceStopLoss,
+            minuteEstimatedTime: data.minuteEstimatedTime,
+        };
+    }
+    return null;
+}
+async function getSignal(source, { symbol, timeframe, limit }) {
+    pine.loggerService.info(METHOD_NAME_RUN, {
+        source,
+        symbol,
+        timeframe,
+        limit,
+    });
+    const { plots } = await pine.pineJobService.run(await GET_SOURCE_FN(source), symbol, timeframe, limit);
+    const data = pine.pineDataService.extract(plots, SIGNAL_SCHEMA);
+    return toSignalDto(data);
+}
+
+exports.AXIS_SYMBOL = AXIS_SYMBOL;
+exports.Code = Code;
+exports.File = File;
+exports.getSignal = getSignal;
+exports.lib = pine;
+exports.run = run;
+exports.setLogger = setLogger;
+exports.usePine = usePine;