@n1xyz/nord-ts 0.1.7 → 0.1.8

package/src/websocket/NordWebSocketClient.ts

@@ -1,316 +0,0 @@
-import { EventEmitter } from "events";
-import WebSocket from "ws";
-import {
-  WebSocketAccountUpdate,
-  WebSocketDeltaUpdate,
-  WebSocketMessage,
-  WebSocketTradeUpdate,
-} from "../types";
-import { NordWebSocketClientEvents } from "./events";
-
-// Define a type that works for both Node.js ws and browser WebSocket
-type BrowserWebSocket = {
-  OPEN: number;
-  CONNECTING: number;
-  CLOSING: number;
-  CLOSED: number;
-  readyState: number;
-  send: (data: string) => void;
-  close: () => void;
-  onopen: ((this: any, ev: any) => any) | null;
-  onmessage: ((this: any, ev: { data: any }) => any) | null;
-  onclose: ((this: any, ev: any) => any) | null;
-  onerror: ((this: any, ev: any) => any) | null;
-};
-
-type WebSocketInstance = WebSocket | BrowserWebSocket;
-
-const VALID_STREAM_TYPES = ["trades", "delta", "account"];
-
-/**
- * WebSocket client for Nord exchange
- *
- * This client connects to one of the specific Nord WebSocket endpoints:
- *
- * Each endpoint handles a specific type of data and subscriptions must match
- * the endpoint type (e.g., only 'trades@BTCUSDC' subscriptions are valid on
- * the /ws/trades endpoint).
- */
-export class NordWebSocketClient
-  extends EventEmitter
-  implements NordWebSocketClientEvents
-{
-  private ws: WebSocketInstance | null = null;
-  private url: string;
-  private reconnectAttempts: number = 0;
-  private maxReconnectAttempts: number = 5;
-  private reconnectDelay: number = 1000;
-  private pingInterval: NodeJS.Timeout | null = null;
-  private pingTimeout: NodeJS.Timeout | null = null;
-  private isBrowser: boolean;
-
-  /**
-   * Create a new NordWebSocketClient
-   * @param url WebSocket server URL
-   */
-  constructor(url: string) {
-    super();
-    this.url = url;
-    // Check if we're in a browser environment
-    // The most reliable way is to check for Node.js process
-    this.isBrowser =
-      typeof process === "undefined" ||
-      !process.versions ||
-      !process.versions.node;
-  }
-
-  /**
-   * Validate stream format
-   * @param stream Stream identifier to validate
-   * @throws Error if stream format is invalid
-   */
-  private validateStream(stream: string): void {
-    const [type, params] = stream.split("@");
-
-    if (!type || !params) {
-      throw new Error(
-        `Invalid stream format: ${stream}. Expected format: <type>@<params>`,
-      );
-    }
-
-    // Extract the endpoint from the URL
-    const urlPath = new URL(this.url).pathname;
-    const endpoint = urlPath.split("/").pop();
-
-    // Ensure the stream type matches the endpoint we're connected to
-    if (endpoint && type !== endpoint) {
-      throw new Error(
-        `Stream type '${type}' doesn't match the connected endpoint '${endpoint}'`,
-      );
-    }
-
-    if (!VALID_STREAM_TYPES.includes(type)) {
-      throw new Error(
-        `Invalid stream type: ${type}. Valid types are: ${VALID_STREAM_TYPES.join(", ")}`,
-      );
-    }
-
-    if (type === "account" && !/^\d+$/.test(params)) {
-      throw new Error(
-        `Invalid account ID in stream: ${params}. Expected numeric ID`,
-      );
-    }
-  }
-
-  /**
-   * Setup WebSocket ping/pong heartbeat
-   */
-  private setupHeartbeat(): void {
-    if (this.pingInterval) {
-      clearInterval(this.pingInterval);
-    }
-    if (this.pingTimeout) {
-      clearTimeout(this.pingTimeout);
-    }
-
-    // In browser, we rely on the browser's WebSocket implementation to handle ping/pong
-    if (this.isBrowser) {
-      return;
-    }
-
-    this.pingInterval = setInterval(() => {
-      if (this.ws && !this.isBrowser) {
-        // Only use ping() method in Node.js environment
-        (this.ws as WebSocket).ping();
-
-        // Set timeout for pong response
-        this.pingTimeout = setTimeout(() => {
-          this.emit("error", new Error("WebSocket ping timeout"));
-          this.close();
-          this.reconnect();
-        }, 5000); // 5 second timeout
-      }
-    }, 30000); // Send ping every 30 seconds
-  }
-
-  /**
-   * Get the appropriate WebSocket class based on environment
-   */
-  private getWebSocketClass(): any {
-    if (this.isBrowser) {
-      // In browser environments
-      if (typeof globalThis !== "undefined" && globalThis.WebSocket) {
-        return globalThis.WebSocket;
-      }
-      throw new Error("WebSocket is not available in this environment");
-    } else {
-      // In Node.js
-      return WebSocket;
-    }
-  }
-
-  /**
-   * Connect to the Nord WebSocket server
-   */
-  public connect(): void {
-    if (this.ws) {
-      return;
-    }
-
-    try {
-      const WebSocketClass = this.getWebSocketClass();
-
-      if (this.isBrowser) {
-        // Browser WebSocket setup
-        this.ws = new WebSocketClass(this.url) as BrowserWebSocket;
-
-        (this.ws as BrowserWebSocket).onopen = () => {
-          this.emit("connected");
-          this.reconnectAttempts = 0;
-          this.reconnectDelay = 1000;
-        };
-
-        (this.ws as BrowserWebSocket).onmessage = (event: { data: any }) => {
-          try {
-            const message = JSON.parse(
-              event.data as string,
-            ) as WebSocketMessage;
-            this.handleMessage(message);
-          } catch (error) {
-            this.emit(
-              "error",
-              new Error(
-                `Failed to parse message: ${error instanceof Error ? error.message : String(error)}`,
-              ),
-            );
-          }
-        };
-
-        (this.ws as BrowserWebSocket).onclose = (_event: any) => {
-          this.emit("disconnected");
-          this.reconnect();
-        };
-
-        (this.ws as BrowserWebSocket).onerror = (event: any) => {
-          const errorMsg = `WebSocket error: ${event && event.type ? event.type : "unknown"}`;
-          this.emit("error", new Error(errorMsg));
-        };
-      } else {
-        // Node.js WebSocket setup
-        const nodeWs = new WebSocketClass(this.url) as WebSocket;
-        this.ws = nodeWs;
-
-        nodeWs.on("open", () => {
-          this.emit("connected");
-          this.reconnectAttempts = 0;
-          this.reconnectDelay = 1000;
-          this.setupHeartbeat();
-        });
-
-        nodeWs.on("message", (data: WebSocket.Data) => {
-          try {
-            const message = JSON.parse(data.toString()) as WebSocketMessage;
-            this.handleMessage(message);
-          } catch (error) {
-            this.emit(
-              "error",
-              new Error(
-                `Failed to parse message: ${error instanceof Error ? error.message : String(error)}`,
-              ),
-            );
-          }
-        });
-
-        nodeWs.on("close", (_code: number, _reason: string) => {
-          this.emit("disconnected");
-          if (this.pingInterval) {
-            clearInterval(this.pingInterval);
-          }
-          if (this.pingTimeout) {
-            clearTimeout(this.pingTimeout);
-          }
-          this.reconnect();
-        });
-
-        nodeWs.on("error", (error: Error) => {
-          this.emit("error", error);
-        });
-
-        nodeWs.on("pong", () => {
-          if (this.pingTimeout) {
-            clearTimeout(this.pingTimeout);
-          }
-        });
-      }
-    } catch (error) {
-      const errorMsg = `Failed to initialize WebSocket: ${error instanceof Error ? error.message : String(error)}`;
-      this.emit("error", new Error(errorMsg));
-    }
-  }
-
-  /**
-   * Close the WebSocket connection
-   */
-  public close(): void {
-    if (this.ws) {
-      if (this.isBrowser) {
-        (this.ws as BrowserWebSocket).close();
-      } else {
-        (this.ws as WebSocket).close();
-      }
-      this.ws = null;
-    }
-    if (this.pingInterval) {
-      clearInterval(this.pingInterval);
-      this.pingInterval = null;
-    }
-    if (this.pingTimeout) {
-      clearTimeout(this.pingTimeout);
-      this.pingTimeout = null;
-    }
-  }
-
-  /**
-   * Handle incoming WebSocket messages
-   * @param message WebSocket message
-   */
-  private handleMessage(message: WebSocketMessage): void {
-    if (!message || typeof message !== "object") {
-      this.emit("error", new Error(`Unexpected message type: ${message}`));
-      return;
-    }
-
-    const hasOwn = (k: string) =>
-      Object.prototype.hasOwnProperty.call(message, k);
-    if (hasOwn("trades")) {
-      this.emit("trades", message as WebSocketTradeUpdate);
-      return;
-    }
-    if (hasOwn("delta")) {
-      this.emit("delta", message as WebSocketDeltaUpdate);
-      return;
-    }
-    if (hasOwn("account")) {
-      this.emit("account", message as WebSocketAccountUpdate);
-      return;
-    }
-
-    this.emit("error", new Error(`Unexpected message type: ${message}`));
-  }
-
-  /**
-   * Attempt to reconnect to the WebSocket server
-   */
-  private reconnect(): void {
-    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-      this.emit("error", new Error("Max reconnection attempts reached"));
-      return;
-    }
-
-    setTimeout(() => {
-      this.reconnectAttempts++;
-      this.reconnectDelay *= 2; // Exponential backoff
-      this.connect();
-    }, this.reconnectDelay);
-  }
-}

package/src/websocket/Subscriber.ts

@@ -1,56 +0,0 @@
-import { EventEmitter } from "events";
-import {
-  Account,
-  DeltaEvent,
-  OrderbookResponse,
-  SubscriberConfig,
-  StreamTrade,
-  Trades,
-} from "../types";
-import { MAX_BUFFER_LEN } from "../utils";
-
-/**
- * Subscriber class for handling WebSocket subscriptions
- */
-export class Subscriber {
-  streamURL: string;
-  buffer: (DeltaEvent | Trades | Account)[];
-  maxBufferLen: number;
-
-  /**
-   * Create a new Subscriber instance
-   * @param config Subscriber configuration
-   */
-  constructor(config: SubscriberConfig) {
-    this.streamURL = config.streamURL;
-    this.buffer = [];
-    this.maxBufferLen = config.maxBufferLen ?? MAX_BUFFER_LEN;
-  }
-
-  /**
-   * Subscribe to WebSocket events
-   */
-  subscribe(): void {
-    // TODO: Implement subscription logic
-  }
-}
-
-/**
- * Interface for orderbook subscription
- */
-export interface OrderbookSubscription extends EventEmitter {
-  on(event: "message", listener: (data: OrderbookResponse) => void): this;
-  on(event: "error", listener: (error: Error) => void): this;
-  close(): void;
-  removeAllListeners(event?: string): this;
-}
-
-/**
- * Interface for trade subscription
- */
-export interface TradeSubscription extends EventEmitter {
-  on(event: "message", listener: (data: StreamTrade[]) => void): this;
-  on(event: "error", listener: (error: Error) => void): this;
-  close(): void;
-  removeAllListeners(event?: string): this;
-}

package/src/websocket/events.ts

@@ -1,31 +0,0 @@
-import {
-  WebSocketTradeUpdate,
-  WebSocketDeltaUpdate,
-  WebSocketAccountUpdate,
-} from "../types";
-
-/**
- * Event type definitions for the NordWebSocketClient
- */
-export interface NordWebSocketEvents {
-  connected: () => void;
-  disconnected: () => void;
-  error: (error: Error) => void;
-  trade: (update: WebSocketTradeUpdate) => void;
-  delta: (update: WebSocketDeltaUpdate) => void;
-  account: (update: WebSocketAccountUpdate) => void;
-}
-
-/**
- * Type declaration for NordWebSocketClient event methods
- */
-export declare interface NordWebSocketClientEvents {
-  on<E extends keyof NordWebSocketEvents>(
-    event: E,
-    listener: NordWebSocketEvents[E],
-  ): this;
-  emit<E extends keyof NordWebSocketEvents>(
-    event: E,
-    ...args: Parameters<NordWebSocketEvents[E]>
-  ): boolean;
-}

package/src/websocket/index.ts

@@ -1,105 +0,0 @@
-import { NordWebSocketClient } from "./NordWebSocketClient";
-import { NordError } from "../error";
-import type { SubscriptionPattern } from "../types";
-import type { NordWebSocketEvents, NordWebSocketClientEvents } from "./events";
-import { Subscriber } from "./Subscriber";
-
-export {
-  NordWebSocketClient,
-  NordWebSocketEvents,
-  NordWebSocketClientEvents,
-  Subscriber,
-};
-
-/**
- * Initialize a WebSocket client for Nord
- *
- * Connects to the Nord WebSocket endpoint with support for multiple subscription types:
- * - trades@SYMBOL - For trade updates
- * - deltas@SYMBOL - For orderbook delta updates
- * - account@ACCOUNT_ID - For user-specific updates
- *
- * @param webServerUrl - Base URL for the Nord web server
- * @param subscriptions - Array of subscriptions (e.g., ["trades@BTCUSDC", "deltas@BTCUSDC", "account@42"])
- * @returns WebSocket client
- * @throws {NordError} If initialization fails or invalid subscription is provided
- */
-export function initWebSocketClient(
-  webServerUrl: string,
-  subscriptions?: SubscriptionPattern[] | "trades" | "delta" | "account",
-): NordWebSocketClient {
-  try {
-    // Determine URL and subscriptions based on parameters
-    let wsUrl = webServerUrl.replace(/^http/, "ws") + `/ws`;
-
-    // Validate subscriptions parameter
-    if (typeof subscriptions === "string") {
-      // Legacy mode - handle endpoint string
-      if (
-        subscriptions === "trades" ||
-        subscriptions === "delta" ||
-        subscriptions === "account"
-      ) {
-        wsUrl += `/${subscriptions}`;
-      } else {
-        throw new NordError(
-          `Invalid endpoint: ${subscriptions}. Must be "trades", "deltas", or "account".`,
-        );
-      }
-    } else if (Array.isArray(subscriptions) && subscriptions.length > 0) {
-      // New mode - validate and combine subscriptions in URL
-      subscriptions.forEach(validateSubscription);
-      wsUrl += `/${subscriptions.join("&")}`;
-    } else {
-      // Default to trades endpoint if no subscriptions specified
-      wsUrl += `/trades`;
-    }
-
-    console.log(`Initializing WebSocket client with URL: ${wsUrl}`);
-
-    // Create and connect the WebSocket client
-    const ws = new NordWebSocketClient(wsUrl);
-
-    // Add error handler
-    ws.on("error", (error) => {
-      console.error("Nord WebSocket error:", error);
-    });
-
-    // Add connected handler for debugging
-    ws.on("connected", () => {
-      console.log("Nord WebSocket connected successfully");
-    });
-
-    // Connect the WebSocket
-    ws.connect();
-    return ws;
-  } catch (error) {
-    console.error("Failed to initialize WebSocket client:", error);
-    throw new NordError("Failed to initialize WebSocket client", {
-      cause: error,
-    });
-  }
-}
-
-/**
- * Validates a subscription string follows the correct format
- *
- * @param subscription - The subscription to validate
- * @throws {NordError} If the subscription format is invalid
- */
-function validateSubscription(subscription: string): void {
-  const [type, param] = subscription.split("@");
-
-  if (!type || !param || !["trades", "deltas", "account"].includes(type)) {
-    throw new NordError(
-      `Invalid subscription format: ${subscription}. Expected format: "trades@SYMBOL", "deltas@SYMBOL", or "account@ID"`,
-    );
-  }
-
-  // Additional validation for account subscriptions
-  if (type === "account" && isNaN(Number(param))) {
-    throw new NordError(
-      `Invalid account ID in subscription: ${subscription}. Account ID must be a number.`,
-    );
-  }
-}