@invezgo/sdk 2.1.0 → 2.2.0

package/dist/index.js

@@ -422,7 +422,7 @@ class InvezgoResources {
     }
 }
 
-const encoder = new TextEncoder();
+const encoder$1 = new TextEncoder();
 class LruCache {
     maxEntries;
     maxBytes;
@@ -453,7 +453,7 @@ class LruCache {
         return entry.body;
     }
     set(key, body, ttlMs) {
-        const size = encoder.encode(body).length;
+        const size = encoder$1.encode(body).length;
         this.delete(key);
         if (ttlMs <= 0 || size > this.maxBytes || this.maxEntries <= 0)
             return;
@@ -543,7 +543,7 @@ function errorClassFor(status) {
     return InvezgoError;
 }
 
-const VERSION = '2.1.0';
+const VERSION = '2.2.0';
 const DEFAULT_BASE_URL = 'https://api.invezgo.com';
 const PERSONAL_SEGMENTS = new Set(['watchlists', 'journals', 'portfolios', 'trades', 'alerts', 'screener']);
 const QUOTA_MESSAGE = /quota|kuota|monthly|bulanan/i;
@@ -769,16 +769,280 @@ function buildError(res, text) {
     });
 }
 
+const DEFAULT_REALTIME_URL = 'wss://api.invezgo.com/ws';
+const handshakeStatus = new Map();
+let undiciHooked = false;
+function hookUndici() {
+    if (undiciHooked)
+        return;
+    undiciHooked = true;
+    const dc = globalThis.process?.getBuiltinModule?.('node:diagnostics_channel');
+    dc?.subscribe('undici:request:headers', (m) => {
+        const key = `${m?.request?.origin}${m?.request?.path}`;
+        if (handshakeStatus.has(key))
+            handshakeStatus.set(key, m.response?.statusCode ?? 0);
+    });
+}
+function defaultWebSocket() {
+    const node = Number(globalThis.process?.versions?.node?.split('.')[0]);
+    return node >= 22 ? globalThis.WebSocket : undefined;
+}
+class InvezgoRealtime {
+    #url;
+    #apiKey;
+    #reconnect;
+    #WS;
+    #native;
+    #listeners = new Map();
+    #ws;
+    #ready = false;
+    #closed = false;
+    #attempt = 0;
+    #timer;
+    #trades = null;
+    #minLot;
+    #minValue;
+    #orderbook = new Set();
+    constructor(options) {
+        if (!options || typeof options.apiKey !== 'string' || !options.apiKey.trim()) {
+            throw new TypeError('Invezgo: `apiKey` is required');
+        }
+        const WS = options.WebSocket ?? defaultWebSocket();
+        if (typeof WS !== 'function') {
+            throw new TypeError('Invezgo: this runtime has no WebSocket that accepts headers; pass `WebSocket: require("ws")` (Node < 22)');
+        }
+        this.#WS = WS;
+        this.#native = !options.WebSocket;
+        this.#apiKey = options.apiKey;
+        this.#url = options.url ?? DEFAULT_REALTIME_URL;
+        this.#reconnect = options.reconnect ?? true;
+        if (this.#native)
+            hookUndici();
+        this.#connect();
+    }
+    on(event, fn) {
+        if (!this.#listeners.has(event))
+            this.#listeners.set(event, new Set());
+        this.#listeners.get(event).add(fn);
+        return this;
+    }
+    off(event, fn) {
+        this.#listeners.get(event)?.delete(fn);
+        return this;
+    }
+    subscribeTrades(codes, filter = {}) {
+        const upper = codes?.map((c) => c.toUpperCase());
+        if (upper) {
+            const next = new Set(this.#trades instanceof Set ? this.#trades : []);
+            upper.forEach((c) => next.add(c));
+            if (next.size > 200)
+                throw new RangeError('Invezgo: at most 200 trade codes per connection');
+            if (this.#trades !== '*')
+                this.#trades = next;
+        }
+        else {
+            this.#trades = '*';
+        }
+        if (filter.minLot !== undefined)
+            this.#minLot = filter.minLot;
+        if (filter.minValue !== undefined)
+            this.#minValue = filter.minValue;
+        this.#send({ op: 'subscribe', channel: 'trades', codes: upper, min_lot: filter.minLot, min_value: filter.minValue });
+    }
+    subscribeOrderbook(codes) {
+        if (!Array.isArray(codes) || codes.length === 0)
+            throw new TypeError('Invezgo: orderbook `codes` must not be empty');
+        const upper = codes.map((c) => c.toUpperCase());
+        if (new Set([...this.#orderbook, ...upper]).size > 20)
+            throw new RangeError('Invezgo: at most 20 orderbook codes per connection');
+        upper.forEach((c) => this.#orderbook.add(c));
+        this.#send({ op: 'subscribe', channel: 'orderbook', codes: upper });
+    }
+    unsubscribe(channel, codes) {
+        const upper = codes?.map((c) => c.toUpperCase());
+        if (channel === 'trades') {
+            if (!upper)
+                [this.#trades, this.#minLot, this.#minValue] = [null, undefined, undefined];
+            else if (this.#trades instanceof Set)
+                upper.forEach((c) => this.#trades.delete(c));
+        }
+        else if (!upper)
+            this.#orderbook.clear();
+        else
+            upper.forEach((c) => this.#orderbook.delete(c));
+        this.#send({ op: 'unsubscribe', channel, codes: upper });
+    }
+    ping() {
+        if (!this.#ready)
+            throw new ConnectionError({ status: 0, message: 'Invezgo: realtime connection is not open' });
+        this.#send({ op: 'ping' });
+    }
+    close() {
+        this.#closed = true;
+        clearTimeout(this.#timer);
+        this.#ws?.close(1000);
+    }
+    #emit(event, payload) {
+        this.#listeners.get(event)?.forEach((fn) => fn(payload));
+    }
+    #send(message) {
+        if (this.#ready)
+            this.#ws.send(JSON.stringify(message));
+    }
+    #replay() {
+        if (this.#trades) {
+            this.#send({
+                op: 'subscribe', channel: 'trades', codes: this.#trades === '*' ? undefined : [...this.#trades],
+                min_lot: this.#minLot, min_value: this.#minValue,
+            });
+        }
+        if (this.#orderbook.size)
+            this.#send({ op: 'subscribe', channel: 'orderbook', codes: [...this.#orderbook] });
+    }
+    #connect() {
+        const statusKey = this.#url.replace(/^ws/, 'http');
+        if (this.#native)
+            handshakeStatus.set(statusKey, 0);
+        let opened = false;
+        let failure = '';
+        const ws = new this.#WS(this.#url, { headers: { Authorization: `Bearer ${this.#apiKey}`, 'User-Agent': `invezgo-js-sdk/${VERSION}` } });
+        this.#ws = ws;
+        ws.onopen = () => {
+            opened = true;
+            handshakeStatus.delete(statusKey);
+        };
+        ws.onerror = (ev) => {
+            failure = String(ev?.message ?? '');
+        };
+        ws.onmessage = (ev) => {
+            let msg;
+            try {
+                msg = JSON.parse(String(ev.data));
+            }
+            catch {
+                return;
+            }
+            if (msg.type === 'connected') {
+                this.#ready = true;
+                this.#attempt = 0;
+                this.#replay();
+            }
+            this.#emit('message', msg);
+            if (msg.type === 'error') {
+                this.#emit('error', new ValidationError({ status: 400, message: String(msg.message), body: msg }));
+            }
+            else if (typeof msg.type === 'string') {
+                this.#emit(msg.type, msg);
+            }
+        };
+        ws.onclose = (ev) => {
+            this.#ready = false;
+            let fatal = this.#closed || ev.code === 4400;
+            if (!opened) {
+                const status = Number(/response: (\d{3})/.exec(failure)?.[1] ?? handshakeStatus.get(statusKey) ?? 0);
+                handshakeStatus.delete(statusKey);
+                if (!this.#closed) {
+                    this.#emit('error', handshakeError(status, failure));
+                    fatal ||= status === 401 || status === 403;
+                }
+            }
+            this.#emit('close', { code: ev.code, reason: String(ev.reason ?? '') });
+            if (fatal || !this.#reconnect)
+                return;
+            const delay = Math.min(2 ** this.#attempt, 30);
+            this.#attempt++;
+            this.#emit('reconnect', { attempt: this.#attempt, delay });
+            this.#timer = setTimeout(() => this.#connect(), delay * 1000);
+        };
+    }
+}
+function handshakeError(status, detail) {
+    const init = { status, message: `Invezgo: realtime handshake failed${status ? ` (HTTP ${status})` : ''}${detail ? `: ${detail}` : ''}`, path: '/ws' };
+    if (status === 401)
+        return new AuthenticationError(init);
+    if (status === 403)
+        return new PaymentRequiredError(init);
+    if (status === 429)
+        return new RateLimitError({ ...init, retryAfter: 0, quotaExceeded: false });
+    if (status >= 500)
+        return new ServerError(init);
+    return new ConnectionError(init);
+}
+
 class Invezgo extends InvezgoResources {
     #transport;
+    #config;
     constructor(config) {
         const transport = new Transport(config);
         super(transport);
         this.#transport = transport;
+        this.#config = config;
     }
     clearCache() {
         this.#transport.clearCache();
     }
+    realtime(options = {}) {
+        const url = `${(this.#config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, '').replace(/^http/, 'ws')}/ws`;
+        return new InvezgoRealtime({ ...options, apiKey: this.#config.apiKey, url });
+    }
+}
+
+class WebhookVerificationError extends Error {
+    reason;
+    constructor(reason, message, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.name = 'WebhookVerificationError';
+        this.reason = reason;
+    }
+}
+function isWebhookEvent(event, name) {
+    return event.event === name;
+}
+const encoder = new TextEncoder();
+function header(headers, name, short) {
+    if (typeof headers.get === 'function')
+        return headers.get(name) ?? '';
+    const wanted = [name.toLowerCase(), short];
+    for (const [key, value] of Object.entries(headers)) {
+        if (wanted.includes(key.toLowerCase()))
+            return (Array.isArray(value) ? value[0] : value) ?? '';
+    }
+    return '';
+}
+function parseWebhook(rawBody) {
+    let event;
+    try {
+        event = JSON.parse(typeof rawBody === 'string' ? rawBody : new TextDecoder().decode(rawBody));
+    }
+    catch (cause) {
+        throw new WebhookVerificationError('payload', 'Invezgo webhook: body is not valid JSON', cause);
+    }
+    if (!event || typeof event !== 'object' || Array.isArray(event)) {
+        throw new WebhookVerificationError('payload', 'Invezgo webhook: body is not a JSON object');
+    }
+    event.event = `${event.domain}.${event.type}`;
+    return event;
+}
+async function verifyWebhook(rawBody, headers, secret, options = {}) {
+    if (typeof secret !== 'string' || !secret)
+        throw new TypeError('Invezgo webhook: `secret` is required');
+    const timestamp = header(headers, 'X-Invezgo-Timestamp', 'timestamp');
+    const signature = header(headers, 'X-Invezgo-Signature', 'signature');
+    const now = options.now ?? Date.now() / 1000;
+    if (!/^\d+$/.test(timestamp) || Math.abs(now - Number(timestamp)) > (options.tolerance ?? 300)) {
+        throw new WebhookVerificationError('timestamp', 'Invezgo webhook: timestamp is missing, invalid or outside the tolerance');
+    }
+    const hex = /^sha256=([0-9a-f]{64})$/.exec(signature)?.[1];
+    const body = typeof rawBody === 'string' ? encoder.encode(rawBody) : rawBody;
+    const prefix = encoder.encode(`${timestamp}.`);
+    const message = new Uint8Array(prefix.length + body.length);
+    message.set(prefix);
+    message.set(body, prefix.length);
+    const key = await globalThis.crypto.subtle.importKey('raw', encoder.encode(secret), { name: 'HMAC', hash: 'SHA-256' }, false, ['verify']);
+    const valid = !!hex && (await globalThis.crypto.subtle.verify('HMAC', key, Uint8Array.from(hex.match(/../g), (h) => parseInt(h, 16)), message));
+    if (!valid)
+        throw new WebhookVerificationError('signature', 'Invezgo webhook: signature mismatch');
+    return parseWebhook(body);
 }
 
 exports.AlertsResource = AlertsResource;
@@ -787,9 +1051,11 @@ exports.AuthenticationError = AuthenticationError;
 exports.BatchResource = BatchResource;
 exports.ConnectionError = ConnectionError;
 exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
+exports.DEFAULT_REALTIME_URL = DEFAULT_REALTIME_URL;
 exports.Invezgo = Invezgo;
 exports.InvezgoClient = Invezgo;
 exports.InvezgoError = InvezgoError;
+exports.InvezgoRealtime = InvezgoRealtime;
 exports.InvezgoResources = InvezgoResources;
 exports.JournalsResource = JournalsResource;
 exports.NotFoundError = NotFoundError;
@@ -806,5 +1072,9 @@ exports.UsageResource = UsageResource;
 exports.VERSION = VERSION;
 exports.ValidationError = ValidationError;
 exports.WatchlistsResource = WatchlistsResource;
+exports.WebhookVerificationError = WebhookVerificationError;
 exports.default = Invezgo;
+exports.isWebhookEvent = isWebhookEvent;
+exports.parseWebhook = parseWebhook;
+exports.verifyWebhook = verifyWebhook;
 //# sourceMappingURL=index.js.map