infoway-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,615 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BasicClient: () => BasicClient,
+  Business: () => Business,
+  CommonClient: () => CommonClient,
+  CryptoClient: () => CryptoClient,
+  HttpClient: () => HttpClient,
+  IndiaClient: () => IndiaClient,
+  InfowayAPIError: () => InfowayAPIError,
+  InfowayAuthError: () => InfowayAuthError,
+  InfowayClient: () => InfowayClient,
+  InfowayTimeoutError: () => InfowayTimeoutError,
+  InfowayWebSocket: () => InfowayWebSocket,
+  JapanClient: () => JapanClient,
+  KlineType: () => KlineType,
+  MarketClient: () => MarketClient,
+  PlateClient: () => PlateClient,
+  StockClient: () => StockClient,
+  StockInfoClient: () => StockInfoClient,
+  WsCode: () => WsCode
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var InfowayTimeoutError = class extends Error {
+  constructor(message = "Request timed out") {
+    super(message);
+    this.name = "InfowayTimeoutError";
+  }
+};
+var InfowayAPIError = class extends Error {
+  ret;
+  msg;
+  traceId;
+  constructor(ret, msg, traceId) {
+    const suffix = traceId ? ` (trace: ${traceId})` : "";
+    super(`[${ret}] ${msg}${suffix}`);
+    this.name = "InfowayAPIError";
+    this.ret = ret;
+    this.msg = msg;
+    this.traceId = traceId;
+  }
+};
+var InfowayAuthError = class extends InfowayAPIError {
+  constructor(msg = "Unauthorized") {
+    super(401, msg);
+    this.name = "InfowayAuthError";
+  }
+};
+
+// src/http.ts
+var DEFAULT_BASE_URL = "https://data.infoway.io";
+var DEFAULT_TIMEOUT = 15e3;
+var DEFAULT_RETRIES = 3;
+var HttpClient = class {
+  _apiKey;
+  _baseUrl;
+  _timeout;
+  _maxRetries;
+  constructor(options = {}) {
+    this._apiKey = options.apiKey || process.env.INFOWAY_API_KEY || "";
+    this._baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this._timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    this._maxRetries = options.maxRetries ?? DEFAULT_RETRIES;
+  }
+  /** Expose apiKey for testing. */
+  get apiKey() {
+    return this._apiKey;
+  }
+  async get(path, params) {
+    const url = this._buildUrl(path, params);
+    return this._request("GET", url);
+  }
+  async post(path, body) {
+    const url = this._buildUrl(path);
+    return this._request("POST", url, body);
+  }
+  _buildUrl(path, params) {
+    const url = new URL(path, this._baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  async _request(method, url, body) {
+    let lastError;
+    for (let attempt = 0; attempt < this._maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this._timeout);
+        const headers = {
+          apiKey: this._apiKey
+        };
+        const init = {
+          method,
+          headers,
+          signal: controller.signal
+        };
+        if (body) {
+          headers["Content-Type"] = "application/json";
+          init.body = JSON.stringify(body);
+        }
+        const resp = await fetch(url, init);
+        clearTimeout(timeoutId);
+        return this._handleResponse(resp);
+      } catch (error) {
+        if (error instanceof InfowayAPIError || error instanceof InfowayAuthError) {
+          throw error;
+        }
+        if (error instanceof DOMException && error.name === "AbortError") {
+          lastError = new InfowayTimeoutError(`Request to ${url} timed out`);
+        } else {
+          lastError = error instanceof Error ? error : new Error(String(error));
+        }
+        if (attempt < this._maxRetries - 1) {
+          await this._sleep(Math.min(2 ** attempt * 1e3, 8e3));
+        }
+      }
+    }
+    throw lastError;
+  }
+  async _handleResponse(resp) {
+    if (resp.status === 401) {
+      throw new InfowayAuthError();
+    }
+    const data = await resp.json();
+    const ret = data.ret ?? data.code ?? 200;
+    const msg = data.msg ?? "";
+    const traceId = data.traceId;
+    if (ret === 401) {
+      throw new InfowayAuthError(msg);
+    }
+    if (ret !== 200) {
+      throw new InfowayAPIError(ret, msg, traceId);
+    }
+    return data.data;
+  }
+  _sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/rest/market-data.ts
+var MarketDataClient = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * Get real-time trade data.
+   * @param codes - Comma-separated symbol codes (e.g. "AAPL.US" or "AAPL.US,TSLA.US")
+   */
+  async getTrade(codes) {
+    return this._http.get(`/${this._prefix}/batch_trade/${codes}`);
+  }
+  /**
+   * Get real-time order book depth.
+   * @param codes - Comma-separated symbol codes
+   */
+  async getDepth(codes) {
+    return this._http.get(`/${this._prefix}/batch_depth/${codes}`);
+  }
+  /**
+   * Get candlestick/K-line data.
+   * @param codes - Comma-separated symbol codes
+   * @param klineType - K-line interval (use KlineType enum or number 1-12)
+   * @param count - Number of candles to return
+   */
+  async getKline(codes, klineType, count) {
+    return this._http.post(`/${this._prefix}/v2/batch_kline`, {
+      codes,
+      klineType,
+      klineCount: count
+    });
+  }
+};
+
+// src/rest/stock.ts
+var StockClient = class extends MarketDataClient {
+  _prefix = "stock";
+};
+
+// src/rest/crypto.ts
+var CryptoClient = class extends MarketDataClient {
+  _prefix = "crypto";
+};
+
+// src/rest/japan.ts
+var JapanClient = class extends MarketDataClient {
+  _prefix = "japan";
+};
+
+// src/rest/india.ts
+var IndiaClient = class extends MarketDataClient {
+  _prefix = "india";
+};
+
+// src/rest/common.ts
+var CommonClient = class extends MarketDataClient {
+  _prefix = "common";
+};
+
+// src/rest/basic.ts
+var BasicClient = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  async getSymbols(market) {
+    return this._http.get("/common/basic/symbols", market ? { market } : void 0);
+  }
+  async getSymbolInfo(codes) {
+    return this._http.get("/common/basic/symbols/info", { codes });
+  }
+  async getAdjustmentFactors(codes) {
+    return this._http.get("/common/basic/symbols/adjustment_factors", { codes });
+  }
+  async getTradingDays(market) {
+    return this._http.get("/common/basic/markets/trading_days", { market });
+  }
+  async getTradingHours(market) {
+    return this._http.get("/common/basic/markets", market ? { market } : void 0);
+  }
+};
+
+// src/rest/market.ts
+var MarketClient = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  async getTemperature(market = "HK,US,CN,SG") {
+    return this._http.get("/common/v2/basic/market/temperature", { market });
+  }
+  async getBreadth(market) {
+    return this._http.get(`/common/v2/basic/market/breadth/${market}`);
+  }
+  async getIndexes() {
+    return this._http.get("/common/v2/basic/market/indexes");
+  }
+  async getLeaders(market, limit = 10) {
+    return this._http.get(`/common/v2/basic/market/leaders/${market}`, { limit });
+  }
+  async getRankConfig(market) {
+    return this._http.get(`/common/v2/basic/market/rank-config/${market}`);
+  }
+};
+
+// src/rest/plate.ts
+var PlateClient = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  async getIndustry(market, limit = 200) {
+    return this._http.get(`/common/v2/basic/plate/industry/${market}`, { limit });
+  }
+  async getConcept(market, limit = 100) {
+    return this._http.get(`/common/v2/basic/plate/concept/${market}`, { limit });
+  }
+  async getMembers(plateSymbol, offset = 0, limit = 50) {
+    return this._http.get(`/common/v2/basic/plate/members/${plateSymbol}`, { offset, limit });
+  }
+  async getIntro(plateSymbol) {
+    return this._http.get(`/common/v2/basic/plate/intro/${plateSymbol}`);
+  }
+  async getChart(market, limit = 50) {
+    return this._http.get(`/common/v2/basic/plate/chart/${market}`, { limit });
+  }
+};
+
+// src/rest/stock-info.ts
+var StockInfoClient = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  async getValuation(symbol) {
+    return this._http.get(`/common/v2/basic/stock/valuation/${symbol}`);
+  }
+  async getRatings(symbol) {
+    return this._http.get(`/common/v2/basic/stock/ratings/${symbol}`);
+  }
+  async getCompany(symbol) {
+    return this._http.get(`/common/v2/basic/stock/company/${symbol}`);
+  }
+  async getPanorama(symbol) {
+    return this._http.get(`/common/v2/basic/stock/panorama/${symbol}`);
+  }
+  async getConcepts(symbol) {
+    return this._http.get(`/common/v2/basic/stock/concepts/${symbol}`);
+  }
+  async getEvents(symbol, limit = 20) {
+    return this._http.get(`/common/v2/basic/stock/events/${symbol}`, { limit });
+  }
+  async getDrivers(symbol) {
+    return this._http.get(`/common/v2/basic/stock/drivers/${symbol}`);
+  }
+};
+
+// src/client.ts
+var InfowayClient = class {
+  /** @internal */
+  _http;
+  stock;
+  crypto;
+  japan;
+  india;
+  common;
+  basic;
+  market;
+  plate;
+  stockInfo;
+  constructor(options = {}) {
+    this._http = new HttpClient({
+      apiKey: options.apiKey,
+      baseUrl: options.baseUrl,
+      timeout: options.timeout,
+      maxRetries: options.maxRetries
+    });
+    this.stock = new StockClient(this._http);
+    this.crypto = new CryptoClient(this._http);
+    this.japan = new JapanClient(this._http);
+    this.india = new IndiaClient(this._http);
+    this.common = new CommonClient(this._http);
+    this.basic = new BasicClient(this._http);
+    this.market = new MarketClient(this._http);
+    this.plate = new PlateClient(this._http);
+    this.stockInfo = new StockInfoClient(this._http);
+  }
+};
+
+// src/ws/client.ts
+var import_ws = __toESM(require("ws"));
+var import_node_crypto = require("crypto");
+
+// src/types.ts
+var KlineType = /* @__PURE__ */ ((KlineType2) => {
+  KlineType2[KlineType2["MIN_1"] = 1] = "MIN_1";
+  KlineType2[KlineType2["MIN_5"] = 2] = "MIN_5";
+  KlineType2[KlineType2["MIN_15"] = 3] = "MIN_15";
+  KlineType2[KlineType2["MIN_30"] = 4] = "MIN_30";
+  KlineType2[KlineType2["HOUR_1"] = 5] = "HOUR_1";
+  KlineType2[KlineType2["HOUR_2"] = 6] = "HOUR_2";
+  KlineType2[KlineType2["HOUR_4"] = 7] = "HOUR_4";
+  KlineType2[KlineType2["DAY"] = 8] = "DAY";
+  KlineType2[KlineType2["WEEK"] = 9] = "WEEK";
+  KlineType2[KlineType2["MONTH"] = 10] = "MONTH";
+  KlineType2[KlineType2["QUARTER"] = 11] = "QUARTER";
+  KlineType2[KlineType2["YEAR"] = 12] = "YEAR";
+  return KlineType2;
+})(KlineType || {});
+var Business = {
+  STOCK: "stock",
+  JAPAN: "japan",
+  INDIA: "india",
+  CRYPTO: "crypto",
+  COMMON: "common"
+};
+var WsCode = /* @__PURE__ */ ((WsCode2) => {
+  WsCode2[WsCode2["SUB_TRADE"] = 1e4] = "SUB_TRADE";
+  WsCode2[WsCode2["PUSH_TRADE"] = 10001] = "PUSH_TRADE";
+  WsCode2[WsCode2["UNSUB_TRADE"] = 10002] = "UNSUB_TRADE";
+  WsCode2[WsCode2["SUB_DEPTH"] = 10003] = "SUB_DEPTH";
+  WsCode2[WsCode2["PUSH_DEPTH"] = 10004] = "PUSH_DEPTH";
+  WsCode2[WsCode2["UNSUB_DEPTH"] = 10005] = "UNSUB_DEPTH";
+  WsCode2[WsCode2["SUB_KLINE"] = 10006] = "SUB_KLINE";
+  WsCode2[WsCode2["PUSH_KLINE"] = 10007] = "PUSH_KLINE";
+  WsCode2[WsCode2["UNSUB_KLINE"] = 10008] = "UNSUB_KLINE";
+  WsCode2[WsCode2["HEARTBEAT"] = 10010] = "HEARTBEAT";
+  return WsCode2;
+})(WsCode || {});
+
+// src/ws/client.ts
+var BASE_WS_URL = "wss://data.infoway.io/ws";
+var HEARTBEAT_INTERVAL = 3e4;
+var INITIAL_BACKOFF = 1e3;
+var MAX_BACKOFF = 3e4;
+var InfowayWebSocket = class {
+  /** @internal */
+  _url;
+  _maxReconnect;
+  _ws = null;
+  /** @internal */
+  _subscriptions = /* @__PURE__ */ new Set();
+  _running = false;
+  _backoff = INITIAL_BACKOFF;
+  _heartbeatTimer = null;
+  /** Called when a trade push message is received. */
+  onTrade = null;
+  /** Called when a depth push message is received. */
+  onDepth = null;
+  /** Called when a kline push message is received. */
+  onKline = null;
+  /** Called when an error occurs. */
+  onError = null;
+  /** Called after a successful reconnection. */
+  onReconnect = null;
+  /** Called when the connection is lost. */
+  onDisconnect = null;
+  constructor(options) {
+    const baseUrl = options.baseUrl || BASE_WS_URL;
+    this._url = `${baseUrl}?business=${options.business}&apikey=${options.apiKey}`;
+    this._maxReconnect = options.maxReconnectAttempts;
+  }
+  /**
+   * Build a WebSocket message JSON string.
+   * @internal
+   */
+  _buildMessage(code, codes) {
+    const msg = {
+      code: Number(code),
+      trace: (0, import_node_crypto.randomBytes)(6).toString("hex")
+    };
+    if (codes !== void 0) {
+      msg.data = { codes };
+    }
+    return JSON.stringify(msg);
+  }
+  /**
+   * Connect and start listening. Returns a Promise that resolves
+   * when the connection is closed intentionally or max reconnects exceeded.
+   */
+  async connect() {
+    this._running = true;
+    let attempt = 0;
+    while (this._running) {
+      try {
+        await this._connectOnce();
+        if (!this._running) break;
+      } catch (err) {
+        if (!this._running) break;
+        attempt++;
+        if (this._maxReconnect !== void 0 && attempt > this._maxReconnect) {
+          break;
+        }
+        if (this.onDisconnect) this.onDisconnect();
+        await this._sleep(this._backoff);
+        this._backoff = Math.min(this._backoff * 2, MAX_BACKOFF);
+      }
+    }
+  }
+  _connectOnce() {
+    return new Promise((resolve, reject) => {
+      const ws = new import_ws.default(this._url);
+      this._ws = ws;
+      ws.on("open", () => {
+        this._backoff = INITIAL_BACKOFF;
+        this._startHeartbeat();
+        if (this._subscriptions.size > 0) {
+          this._resubscribe();
+          if (this.onReconnect) this.onReconnect();
+        }
+      });
+      ws.on("message", (raw) => {
+        try {
+          const msg = JSON.parse(raw.toString());
+          const code = msg.code;
+          if (code === 10001 /* PUSH_TRADE */ && this.onTrade) {
+            this.onTrade(msg);
+          } else if (code === 10004 /* PUSH_DEPTH */ && this.onDepth) {
+            this.onDepth(msg);
+          } else if (code === 10007 /* PUSH_KLINE */ && this.onKline) {
+            this.onKline(msg);
+          }
+        } catch {
+        }
+      });
+      ws.on("close", () => {
+        this._stopHeartbeat();
+        if (this._running) {
+          reject(new Error("Connection closed"));
+        } else {
+          resolve();
+        }
+      });
+      ws.on("error", (err) => {
+        this._stopHeartbeat();
+        if (this.onError) this.onError(err);
+        reject(err);
+      });
+    });
+  }
+  _startHeartbeat() {
+    this._stopHeartbeat();
+    this._heartbeatTimer = setInterval(() => {
+      if (this._ws && this._ws.readyState === import_ws.default.OPEN) {
+        this._ws.send(this._buildMessage(10010 /* HEARTBEAT */));
+      }
+    }, HEARTBEAT_INTERVAL);
+  }
+  _stopHeartbeat() {
+    if (this._heartbeatTimer) {
+      clearInterval(this._heartbeatTimer);
+      this._heartbeatTimer = null;
+    }
+  }
+  _resubscribe() {
+    const codeMap = {
+      trade: 1e4 /* SUB_TRADE */,
+      depth: 10003 /* SUB_DEPTH */,
+      kline: 10006 /* SUB_KLINE */
+    };
+    for (const entry of this._subscriptions) {
+      const [subType, codes] = entry.split("|", 2);
+      const wsCode = codeMap[subType];
+      if (wsCode && this._ws && this._ws.readyState === import_ws.default.OPEN) {
+        this._ws.send(this._buildMessage(wsCode, codes));
+      }
+    }
+  }
+  async subscribeTrade(codes) {
+    this._subscriptions.add(`trade|${codes}`);
+    if (this._ws && this._ws.readyState === import_ws.default.OPEN) {
+      this._ws.send(this._buildMessage(1e4 /* SUB_TRADE */, codes));
+    }
+  }
+  async subscribeDepth(codes) {
+    this._subscriptions.add(`depth|${codes}`);
+    if (this._ws && this._ws.readyState === import_ws.default.OPEN) {
+      this._ws.send(this._buildMessage(10003 /* SUB_DEPTH */, codes));
+    }
+  }
+  async subscribeKline(codes) {
+    this._subscriptions.add(`kline|${codes}`);
+    if (this._ws && this._ws.readyState === import_ws.default.OPEN) {
+      this._ws.send(this._buildMessage(10006 /* SUB_KLINE */, codes));
+    }
+  }
+  async unsubscribeTrade(codes) {
+    this._subscriptions.delete(`trade|${codes}`);
+    if (this._ws && this._ws.readyState === import_ws.default.OPEN) {
+      this._ws.send(this._buildMessage(10002 /* UNSUB_TRADE */, codes));
+    }
+  }
+  async unsubscribeDepth(codes) {
+    this._subscriptions.delete(`depth|${codes}`);
+    if (this._ws && this._ws.readyState === import_ws.default.OPEN) {
+      this._ws.send(this._buildMessage(10005 /* UNSUB_DEPTH */, codes));
+    }
+  }
+  async unsubscribeKline(codes) {
+    this._subscriptions.delete(`kline|${codes}`);
+    if (this._ws && this._ws.readyState === import_ws.default.OPEN) {
+      this._ws.send(this._buildMessage(10008 /* UNSUB_KLINE */, codes));
+    }
+  }
+  async close() {
+    this._running = false;
+    this._stopHeartbeat();
+    if (this._ws) {
+      this._ws.close();
+      this._ws = null;
+    }
+  }
+  _sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BasicClient,
+  Business,
+  CommonClient,
+  CryptoClient,
+  HttpClient,
+  IndiaClient,
+  InfowayAPIError,
+  InfowayAuthError,
+  InfowayClient,
+  InfowayTimeoutError,
+  InfowayWebSocket,
+  JapanClient,
+  KlineType,
+  MarketClient,
+  PlateClient,
+  StockClient,
+  StockInfoClient,
+  WsCode
+});
+//# sourceMappingURL=index.js.map