initial request.security() support

Author: alaa-eddine

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Change Log
 
+## [0.1.2] - 2025-02-05 - initial request.security() support
+
+### Added
+
+-   Support for request.security() function : in this build we only support the security() function for timeframes higher than the current timeframe, also, gaps, ignore_invalid_symbol, currency and calc_bars_count parameters are supported yet
+
 ## [0.1.1] - 2025-02-01 - array namespace
 
 ### Added

package.json

@@ -1,8 +1,8 @@
 {
     "name": "pinets",
-    "version": "0.1.1",
+    "version": "0.1.2",
     "description": "",
-    "main": "dist/pinets.min.es.js",
+    "main": "dist/pinets.dev.es.js",
     "types": "dist/types/index.d.ts",
     "files": [
         "dist"

src/Context.class.ts

@@ -7,6 +7,7 @@ import PineMath from '@pinets/namespaces/PineMath';
 import { PineRequest } from '@pinets/namespaces/PineRequest';
 import TechnicalAnalysis from '@pinets/namespaces/TechnicalAnalysis';
 import { PineArray } from './namespaces/PineArray';
+import { IProvider } from './marketData/IProvider';
 
 export class Context {
     public data: any = {
@@ -19,6 +20,7 @@ export class Context {
         hlc3: [],
         ohlc4: [],
     };
+    public cache: any = {};
 
     public NA: any = NaN;
 
@@ -39,13 +41,48 @@ export class Context {
 
     public result: any = undefined;
     public plots: any = {};
+
+    public marketData: any;
+    public source: IProvider | any[];
+    public tickerId: string;
     public timeframe: string = '';
+    public limit: number;
+    public sDate: number;
+    public eDate: number;
+
+    public pineTSCode: Function | String;
+
+    constructor({
+        marketData,
+        source,
+        tickerId,
+        timeframe,
+        limit,
+        sDate,
+        eDate,
+    }: {
+        marketData: any;
+        source: IProvider | any[];
+        tickerId?: string;
+        timeframe?: string;
+        limit?: number;
+        sDate?: number;
+        eDate?: number;
+    }) {
+        this.marketData = marketData;
+        this.source = source;
+        this.tickerId = tickerId;
+        this.timeframe = timeframe;
+        this.limit = limit;
+        this.sDate = sDate;
+        this.eDate = eDate;
 
-    constructor(public marketData: any) {
         this.math = new PineMath(this);
+
         this.ta = new TechnicalAnalysis(this);
         this.input = new Input(this);
         this.request = new PineRequest(this);
+
         this.array = new PineArray(this);
         const core = new Core(this);
         this.core = {

src/PineTS.class.ts

@@ -94,15 +94,24 @@ export class PineTS {
         return this._readyPromise;
     }
 
-    public async run(fn: Function | String, n?: number) {
+    public async run(pineTSCode: Function | String, n?: number): Promise<Context> {
         await this.ready();
         if (!n) n = this._periods;
-        const context = new Context(this.data);
-        context.timeframe = this.timeframe;
 
-        const transformer = transpile.bind(this);
+        const context = new Context({
+            marketData: this.data,
+            source: this.source,
+            tickerId: this.tickerId,
+            timeframe: this.timeframe,
+            limit: this.limit,
+            sDate: this.sDate,
+            eDate: this.eDate,
+        });
 
-        let transformedFn = transformer(fn);
+        context.pineTSCode = pineTSCode;
+
+        const transformer = transpile.bind(this);
+        let transpiledFn = transformer(pineTSCode);
 
         //console.log('>>> transformedFn: ', transformedFn.toString());
 
@@ -121,7 +130,7 @@ export class PineTS {
             context.data.openTime = this.openTime.slice(idx);
             context.data.closeTime = this.closeTime.slice(idx);
 
-            const result = await transformedFn(context);
+            const result = await transpiledFn(context);
 
             //collect results
             if (typeof result === 'object') {

src/marketData/Binance/BinanceProvider.class.ts

@@ -23,6 +23,8 @@ const timeframe_to_binance = {
 import { IProvider } from '@pinets/marketData/IProvider';
 
 export class BinanceProvider implements IProvider {
+    //TODO : allow querying more than 1000 klines
+    //TODO : immplement cache
     async getMarketData(tickerId: string, timeframe: string, limit?: number, sDate?: number, eDate?: number): Promise<any> {
         try {
             const interval = timeframe_to_binance[timeframe.toUpperCase()];

src/marketData/Provider.class.ts

@@ -4,4 +4,5 @@ import { BinanceProvider } from './Binance/BinanceProvider.class';
 
 export const Provider = {
     Binance: new BinanceProvider(),
+    //TODO : add other providers (polygon, etc.)
 };

src/namespaces/PineRequest.ts

@@ -1,5 +1,9 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 
+import { PineTS, Provider } from '@pinets/index';
+//Pine Script Timeframes
+const TIMEFRAMES = ['1', '3', '5', '15', '30', '45', '60', '120', '180', '240', 'D', 'W', 'M'];
+
 export class PineRequest {
     private _cache = {};
     constructor(private context: any) {}
@@ -19,8 +23,60 @@ export class PineRequest {
         }
     }
 
-    async security(symbol: any, timeframe: any, expression: any) {
-        //not implemented
-        throw new Error('Not implemented');
+    async security(
+        symbol: any,
+        timeframe: any,
+        expression: any,
+        gaps = false,
+        lookahead = false,
+        ignore_invalid_symbol = false,
+        currency = null,
+        calc_bars_count = null
+    ) {
+        const _symbol = symbol[0];
+        const _timeframe = timeframe[0];
+        const _expression = expression[0];
+        const _expression_name = expression[1];
+
+        const ctxTimeframeIdx = TIMEFRAMES.indexOf(this.context.timeframe);
+        const reqTimeframeIdx = TIMEFRAMES.indexOf(_timeframe);
+
+        if (ctxTimeframeIdx == -1 || reqTimeframeIdx == -1) {
+            throw new Error('Invalid timeframe');
+        }
+        if (ctxTimeframeIdx > reqTimeframeIdx) {
+            throw new Error('Only higher timeframes are supported for now');
+        }
+
+        if (ctxTimeframeIdx === reqTimeframeIdx) {
+            return _expression;
+        }
+
+        const myOpenTime = this.context.data.openTime[0];
+        const myCloseTime = this.context.data.closeTime[0];
+
+        if (this.context.cache[_expression_name]) {
+            const secContext = this.context.cache[_expression_name];
+            const secContextIdx = this._findSecContextIdx(myOpenTime, myCloseTime, secContext.data.openTime, secContext.data.closeTime, lookahead);
+            return secContextIdx == -1 ? NaN : secContext.params[_expression_name][secContextIdx];
+        }
+
+        const pineTS = new PineTS(this.context.source, _symbol, _timeframe, this.context.limit || 1000, this.context.sDate, this.context.eDate);
+
+        const secContext = await pineTS.run(this.context.pineTSCode);
+
+        this.context.cache[_expression_name] = secContext;
+
+        const secContextIdx = this._findSecContextIdx(myOpenTime, myCloseTime, secContext.data.openTime, secContext.data.closeTime, lookahead);
+        return secContextIdx == -1 ? NaN : secContext.params[_expression_name][secContextIdx];
+    }
+
+    private _findSecContextIdx(myOpenTime: number, myCloseTime: number, openTime: number[], closeTime: number[], lookahead = false) {
+        for (let i = 0; i < openTime.length; i++) {
+            if (openTime[i] <= myOpenTime && myCloseTime <= closeTime[i]) {
+                return i + (lookahead ? 1 : 2); //lookahead_on +1 lookahead_off +2
+            }
+        }
+        return -1;
     }
 }