@debros/network-ts-sdk 0.1.4 → 0.2.5

package/src/core/ws.ts

@@ -4,10 +4,6 @@ import { SDKError } from "../errors";
 export interface WSClientConfig {
   wsURL: string;
   timeout?: number;
-  maxReconnectAttempts?: number;
-  reconnectDelayMs?: number;
-  heartbeatIntervalMs?: number;
-  authMode?: "header" | "query";
   authToken?: string;
   WebSocket?: typeof WebSocket;
 }
@@ -15,54 +11,53 @@ export interface WSClientConfig {
 export type WSMessageHandler = (data: string) => void;
 export type WSErrorHandler = (error: Error) => void;
 export type WSCloseHandler = () => void;
+export type WSOpenHandler = () => void;
 
+/**
+ * Simple WebSocket client with minimal abstractions
+ * No complex reconnection, no heartbeats - keep it simple
+ */
 export class WSClient {
   private url: string;
   private timeout: number;
-  private maxReconnectAttempts: number;
-  private reconnectDelayMs: number;
-  private heartbeatIntervalMs: number;
-  private authMode: "header" | "query";
   private authToken?: string;
   private WebSocketClass: typeof WebSocket;
 
   private ws?: WebSocket;
-  private reconnectAttempts = 0;
-  private heartbeatInterval?: NodeJS.Timeout;
   private messageHandlers: Set<WSMessageHandler> = new Set();
   private errorHandlers: Set<WSErrorHandler> = new Set();
   private closeHandlers: Set<WSCloseHandler> = new Set();
-  private isManuallyClosed = false;
+  private openHandlers: Set<WSOpenHandler> = new Set();
+  private isClosed = false;
 
   constructor(config: WSClientConfig) {
     this.url = config.wsURL;
     this.timeout = config.timeout ?? 30000;
-    this.maxReconnectAttempts = config.maxReconnectAttempts ?? 5;
-    this.reconnectDelayMs = config.reconnectDelayMs ?? 1000;
-    this.heartbeatIntervalMs = config.heartbeatIntervalMs ?? 30000;
-    this.authMode = config.authMode ?? "header";
     this.authToken = config.authToken;
     this.WebSocketClass = config.WebSocket ?? WebSocket;
   }
 
+  /**
+   * Connect to WebSocket server
+   */
   connect(): Promise<void> {
     return new Promise((resolve, reject) => {
       try {
         const wsUrl = this.buildWSUrl();
         this.ws = new this.WebSocketClass(wsUrl);
-
-        // Note: Custom headers via ws library in Node.js are not sent with WebSocket upgrade requests
-        // so we rely on query parameters for authentication
+        this.isClosed = false;
 
         const timeout = setTimeout(() => {
           this.ws?.close();
-          reject(new SDKError("WebSocket connection timeout", 408, "WS_TIMEOUT"));
+          reject(
+            new SDKError("WebSocket connection timeout", 408, "WS_TIMEOUT")
+          );
         }, this.timeout);
 
         this.ws.addEventListener("open", () => {
           clearTimeout(timeout);
-          this.reconnectAttempts = 0;
-          this.startHeartbeat();
+          console.log("[WSClient] Connected to", this.url);
+          this.openHandlers.forEach((handler) => handler());
           resolve();
         });
 
@@ -72,24 +67,16 @@ export class WSClient {
         });
 
         this.ws.addEventListener("error", (event: Event) => {
+          console.error("[WSClient] WebSocket error:", event);
           clearTimeout(timeout);
-          const error = new SDKError(
-            "WebSocket error",
-            500,
-            "WS_ERROR",
-            event
-          );
+          const error = new SDKError("WebSocket error", 500, "WS_ERROR", event);
           this.errorHandlers.forEach((handler) => handler(error));
         });
 
         this.ws.addEventListener("close", () => {
           clearTimeout(timeout);
-          this.stopHeartbeat();
-          if (!this.isManuallyClosed) {
-            this.attemptReconnect();
-          } else {
-            this.closeHandlers.forEach((handler) => handler());
-          }
+          console.log("[WSClient] Connection closed");
+          this.closeHandlers.forEach((handler) => handler());
         });
       } catch (error) {
         reject(error);
@@ -97,86 +84,106 @@ export class WSClient {
     });
   }
 
+  /**
+   * Build WebSocket URL with auth token
+   */
   private buildWSUrl(): string {
     let url = this.url;
-    
-    // Always append auth token as query parameter for compatibility
-    // Works in both Node.js and browser environments
+
     if (this.authToken) {
       const separator = url.includes("?") ? "&" : "?";
       const paramName = this.authToken.startsWith("ak_") ? "api_key" : "token";
       url += `${separator}${paramName}=${encodeURIComponent(this.authToken)}`;
     }
-    
-    return url;
-  }
 
-  private startHeartbeat() {
-    this.heartbeatInterval = setInterval(() => {
-      if (this.ws?.readyState === WebSocket.OPEN) {
-        this.ws.send(JSON.stringify({ type: "ping" }));
-      }
-    }, this.heartbeatIntervalMs);
-  }
-
-  private stopHeartbeat() {
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = undefined;
-    }
-  }
-
-  private attemptReconnect() {
-    if (this.reconnectAttempts < this.maxReconnectAttempts) {
-      this.reconnectAttempts++;
-      const delayMs = this.reconnectDelayMs * this.reconnectAttempts;
-      setTimeout(() => {
-        this.connect().catch((error) => {
-          this.errorHandlers.forEach((handler) => handler(error));
-        });
-      }, delayMs);
-    } else {
-      this.closeHandlers.forEach((handler) => handler());
-    }
+    return url;
   }
 
-  onMessage(handler: WSMessageHandler) {
+  /**
+   * Register message handler
+   */
+  onMessage(handler: WSMessageHandler): () => void {
     this.messageHandlers.add(handler);
     return () => this.messageHandlers.delete(handler);
   }
 
-  onError(handler: WSErrorHandler) {
+  /**
+   * Unregister message handler
+   */
+  offMessage(handler: WSMessageHandler): void {
+    this.messageHandlers.delete(handler);
+  }
+
+  /**
+   * Register error handler
+   */
+  onError(handler: WSErrorHandler): () => void {
     this.errorHandlers.add(handler);
     return () => this.errorHandlers.delete(handler);
   }
 
-  onClose(handler: WSCloseHandler) {
+  /**
+   * Unregister error handler
+   */
+  offError(handler: WSErrorHandler): void {
+    this.errorHandlers.delete(handler);
+  }
+
+  /**
+   * Register close handler
+   */
+  onClose(handler: WSCloseHandler): () => void {
     this.closeHandlers.add(handler);
     return () => this.closeHandlers.delete(handler);
   }
 
-  send(data: string) {
+  /**
+   * Unregister close handler
+   */
+  offClose(handler: WSCloseHandler): void {
+    this.closeHandlers.delete(handler);
+  }
+
+  /**
+   * Register open handler
+   */
+  onOpen(handler: WSOpenHandler): () => void {
+    this.openHandlers.add(handler);
+    return () => this.openHandlers.delete(handler);
+  }
+
+  /**
+   * Send data through WebSocket
+   */
+  send(data: string): void {
     if (this.ws?.readyState !== WebSocket.OPEN) {
-      throw new SDKError(
-        "WebSocket is not connected",
-        500,
-        "WS_NOT_CONNECTED"
-      );
+      throw new SDKError("WebSocket is not connected", 500, "WS_NOT_CONNECTED");
     }
     this.ws.send(data);
   }
 
-  close() {
-    this.isManuallyClosed = true;
-    this.stopHeartbeat();
+  /**
+   * Close WebSocket connection
+   */
+  close(): void {
+    if (this.isClosed) {
+      return;
+    }
+    this.isClosed = true;
     this.ws?.close();
   }
 
+  /**
+   * Check if WebSocket is connected
+   */
   isConnected(): boolean {
-    return this.ws?.readyState === WebSocket.OPEN;
+    return !this.isClosed && this.ws?.readyState === WebSocket.OPEN;
   }
 
-  setAuthToken(token?: string) {
+  /**
+   * Update auth token
+   */
+  setAuthToken(token?: string): void {
     this.authToken = token;
   }
 }

package/src/index.ts

@@ -4,7 +4,11 @@ import { DBClient } from "./db/client";
 import { PubSubClient } from "./pubsub/client";
 import { NetworkClient } from "./network/client";
 import { WSClientConfig } from "./core/ws";
-import { StorageAdapter, MemoryStorage, LocalStorageAdapter } from "./auth/types";
+import {
+  StorageAdapter,
+  MemoryStorage,
+  LocalStorageAdapter,
+} from "./auth/types";
 
 export interface ClientConfig extends Omit<HttpClientConfig, "fetch"> {
   apiKey?: string;
@@ -38,8 +42,9 @@ export function createClient(config: ClientConfig): Client {
   });
 
   // Derive WebSocket URL from baseURL if not explicitly provided
-  const wsURL = config.wsConfig?.wsURL ?? 
-    config.baseURL.replace(/^http/, 'ws').replace(/\/$/, '');
+  const wsURL =
+    config.wsConfig?.wsURL ??
+    config.baseURL.replace(/^http/, "ws").replace(/\/$/, "");
 
   const db = new DBClient(httpClient);
   const pubsub = new PubSubClient(httpClient, {
@@ -67,11 +72,7 @@ export { PubSubClient, Subscription } from "./pubsub/client";
 export { NetworkClient } from "./network/client";
 export { SDKError } from "./errors";
 export { MemoryStorage, LocalStorageAdapter } from "./auth/types";
-export type {
-  StorageAdapter,
-  AuthConfig,
-  WhoAmI,
-} from "./auth/types";
+export type { StorageAdapter, AuthConfig, WhoAmI } from "./auth/types";
 export type * from "./db/types";
 export type {
   Message,
@@ -79,4 +80,9 @@ export type {
   ErrorHandler,
   CloseHandler,
 } from "./pubsub/client";
-export type { PeerInfo, NetworkStatus } from "./network/client";
+export type {
+  PeerInfo,
+  NetworkStatus,
+  ProxyRequest,
+  ProxyResponse,
+} from "./network/client";

package/src/network/client.ts

@@ -7,9 +7,25 @@ export interface PeerInfo {
 }
 
 export interface NetworkStatus {
-  healthy: boolean;
-  peers: number;
-  uptime?: number;
+  node_id: string;
+  connected: boolean;
+  peer_count: number;
+  database_size: number;
+  uptime: number;
+}
+
+export interface ProxyRequest {
+  url: string;
+  method: string;
+  headers?: Record<string, string>;
+  body?: string;
+}
+
+export interface ProxyResponse {
+  status_code: number;
+  headers: Record<string, string>;
+  body: string;
+  error?: string;
 }
 
 export class NetworkClient {
@@ -35,7 +51,9 @@ export class NetworkClient {
    * Get network status.
    */
   async status(): Promise<NetworkStatus> {
-    const response = await this.httpClient.get<NetworkStatus>("/v1/status");
+    const response = await this.httpClient.get<NetworkStatus>(
+      "/v1/network/status"
+    );
     return response;
   }
 
@@ -62,4 +80,40 @@ export class NetworkClient {
   async disconnect(peerId: string): Promise<void> {
     await this.httpClient.post("/v1/network/disconnect", { peer_id: peerId });
   }
+
+  /**
+   * Proxy an HTTP request through the Anyone network.
+   * Requires authentication (API key or JWT).
+   *
+   * @param request - The proxy request configuration
+   * @returns The proxied response
+   * @throws {SDKError} If the Anyone proxy is not available or the request fails
+   *
+   * @example
+   * ```ts
+   * const response = await client.network.proxyAnon({
+   *   url: 'https://api.example.com/data',
+   *   method: 'GET',
+   *   headers: {
+   *     'Accept': 'application/json'
+   *   }
+   * });
+   *
+   * console.log(response.status_code); // 200
+   * console.log(response.body); // Response data
+   * ```
+   */
+  async proxyAnon(request: ProxyRequest): Promise<ProxyResponse> {
+    const response = await this.httpClient.post<ProxyResponse>(
+      "/v1/proxy/anon",
+      request
+    );
+
+    // Check if the response contains an error
+    if (response.error) {
+      throw new Error(`Proxy request failed: ${response.error}`);
+    }
+
+    return response;
+  }
 }

package/src/pubsub/client.ts

@@ -4,13 +4,64 @@ import { WSClient, WSClientConfig } from "../core/ws";
 export interface Message {
   data: string;
   topic: string;
-  timestamp?: number;
+  timestamp: number;
+}
+
+export interface RawEnvelope {
+  data: string; // base64-encoded
+  timestamp: number;
+  topic: string;
+}
+
+// Cross-platform base64 encoding/decoding utilities
+function base64Encode(str: string): string {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(str).toString("base64");
+  } else if (typeof btoa !== "undefined") {
+    return btoa(
+      encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, (match, p1) =>
+        String.fromCharCode(parseInt(p1, 16))
+      )
+    );
+  }
+  throw new Error("No base64 encoding method available");
+}
+
+function base64EncodeBytes(bytes: Uint8Array): string {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  } else if (typeof btoa !== "undefined") {
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
+  throw new Error("No base64 encoding method available");
+}
+
+function base64Decode(b64: string): string {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(b64, "base64").toString("utf-8");
+  } else if (typeof atob !== "undefined") {
+    const binary = atob(b64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return new TextDecoder().decode(bytes);
+  }
+  throw new Error("No base64 decoding method available");
 }
 
 export type MessageHandler = (message: Message) => void;
 export type ErrorHandler = (error: Error) => void;
 export type CloseHandler = () => void;
 
+/**
+ * Simple PubSub client - one WebSocket connection per topic
+ * No connection pooling, no reference counting - keep it simple
+ */
 export class PubSubClient {
   private httpClient: HttpClient;
   private wsConfig: Partial<WSClientConfig>;
@@ -21,20 +72,30 @@ export class PubSubClient {
   }
 
   /**
-   * Publish a message to a topic.
+   * Publish a message to a topic via HTTP
    */
   async publish(topic: string, data: string | Uint8Array): Promise<void> {
-    const dataBase64 =
-      typeof data === "string" ? Buffer.from(data).toString("base64") : Buffer.from(data).toString("base64");
+    let dataBase64: string;
+    if (typeof data === "string") {
+      dataBase64 = base64Encode(data);
+    } else {
+      dataBase64 = base64EncodeBytes(data);
+    }
 
-    await this.httpClient.post("/v1/pubsub/publish", {
-      topic,
-      data_base64: dataBase64,
-    });
+    await this.httpClient.post(
+      "/v1/pubsub/publish",
+      {
+        topic,
+        data_base64: dataBase64,
+      },
+      {
+        timeout: 30000,
+      }
+    );
   }
 
   /**
-   * List active topics in the current namespace.
+   * List active topics in the current namespace
    */
   async topics(): Promise<string[]> {
     const response = await this.httpClient.get<{ topics: string[] }>(
@@ -44,8 +105,8 @@ export class PubSubClient {
   }
 
   /**
-   * Subscribe to a topic via WebSocket.
-   * Returns a subscription object with event handlers.
+   * Subscribe to a topic via WebSocket
+   * Creates one WebSocket connection per topic
    */
   async subscribe(
     topic: string,
@@ -55,16 +116,23 @@ export class PubSubClient {
       onClose?: CloseHandler;
     } = {}
   ): Promise<Subscription> {
-    const wsUrl = new URL(this.wsConfig.wsURL || "ws://localhost:6001");
+    // Build WebSocket URL for this topic
+    const wsUrl = new URL(this.wsConfig.wsURL || "ws://127.0.0.1:6001");
     wsUrl.pathname = "/v1/pubsub/ws";
     wsUrl.searchParams.set("topic", topic);
 
+    const authToken = this.httpClient.getApiKey() ?? this.httpClient.getToken();
+
+    // Create WebSocket client
     const wsClient = new WSClient({
       ...this.wsConfig,
       wsURL: wsUrl.toString(),
-      authToken: this.httpClient.getToken(),
+      authToken,
     });
 
+    await wsClient.connect();
+
+    // Create subscription wrapper
     const subscription = new Subscription(wsClient, topic);
 
     if (handlers.onMessage) {
@@ -77,66 +145,144 @@ export class PubSubClient {
       subscription.onClose(handlers.onClose);
     }
 
-    await wsClient.connect();
     return subscription;
   }
 }
 
+/**
+ * Subscription represents an active WebSocket subscription to a topic
+ */
 export class Subscription {
   private wsClient: WSClient;
   private topic: string;
   private messageHandlers: Set<MessageHandler> = new Set();
   private errorHandlers: Set<ErrorHandler> = new Set();
   private closeHandlers: Set<CloseHandler> = new Set();
+  private isClosed = false;
+  private wsMessageHandler: ((data: string) => void) | null = null;
+  private wsErrorHandler: ((error: Error) => void) | null = null;
+  private wsCloseHandler: (() => void) | null = null;
 
   constructor(wsClient: WSClient, topic: string) {
     this.wsClient = wsClient;
     this.topic = topic;
 
-    this.wsClient.onMessage((data) => {
+    // Register message handler
+    this.wsMessageHandler = (data) => {
       try {
+        // Parse gateway JSON envelope: {data: base64String, timestamp, topic}
+        const envelope: RawEnvelope = JSON.parse(data);
+
+        // Validate envelope structure
+        if (!envelope || typeof envelope !== "object") {
+          throw new Error("Invalid envelope: not an object");
+        }
+        if (!envelope.data || typeof envelope.data !== "string") {
+          throw new Error("Invalid envelope: missing or invalid data field");
+        }
+        if (!envelope.topic || typeof envelope.topic !== "string") {
+          throw new Error("Invalid envelope: missing or invalid topic field");
+        }
+        if (typeof envelope.timestamp !== "number") {
+          throw new Error(
+            "Invalid envelope: missing or invalid timestamp field"
+          );
+        }
+
+        // Decode base64 data
+        const messageData = base64Decode(envelope.data);
+
         const message: Message = {
-          topic: this.topic,
-          data: data,
-          timestamp: Date.now(),
+          topic: envelope.topic,
+          data: messageData,
+          timestamp: envelope.timestamp,
         };
+
+        console.log("[Subscription] Received message on topic:", this.topic);
         this.messageHandlers.forEach((handler) => handler(message));
       } catch (error) {
+        console.error("[Subscription] Error processing message:", error);
         this.errorHandlers.forEach((handler) =>
           handler(error instanceof Error ? error : new Error(String(error)))
         );
       }
-    });
+    };
+
+    this.wsClient.onMessage(this.wsMessageHandler);
 
-    this.wsClient.onError((error) => {
+    // Register error handler
+    this.wsErrorHandler = (error) => {
       this.errorHandlers.forEach((handler) => handler(error));
-    });
+    };
+    this.wsClient.onError(this.wsErrorHandler);
 
-    this.wsClient.onClose(() => {
+    // Register close handler
+    this.wsCloseHandler = () => {
       this.closeHandlers.forEach((handler) => handler());
-    });
+    };
+    this.wsClient.onClose(this.wsCloseHandler);
   }
 
-  onMessage(handler: MessageHandler) {
+  /**
+   * Register message handler
+   */
+  onMessage(handler: MessageHandler): () => void {
     this.messageHandlers.add(handler);
     return () => this.messageHandlers.delete(handler);
   }
 
-  onError(handler: ErrorHandler) {
+  /**
+   * Register error handler
+   */
+  onError(handler: ErrorHandler): () => void {
     this.errorHandlers.add(handler);
     return () => this.errorHandlers.delete(handler);
   }
 
-  onClose(handler: CloseHandler) {
+  /**
+   * Register close handler
+   */
+  onClose(handler: CloseHandler): () => void {
     this.closeHandlers.add(handler);
     return () => this.closeHandlers.delete(handler);
   }
 
-  close() {
+  /**
+   * Close subscription and underlying WebSocket
+   */
+  close(): void {
+    if (this.isClosed) {
+      return;
+    }
+    this.isClosed = true;
+
+    // Remove handlers from WSClient
+    if (this.wsMessageHandler) {
+      this.wsClient.offMessage(this.wsMessageHandler);
+      this.wsMessageHandler = null;
+    }
+    if (this.wsErrorHandler) {
+      this.wsClient.offError(this.wsErrorHandler);
+      this.wsErrorHandler = null;
+    }
+    if (this.wsCloseHandler) {
+      this.wsClient.offClose(this.wsCloseHandler);
+      this.wsCloseHandler = null;
+    }
+
+    // Clear all local handlers
+    this.messageHandlers.clear();
+    this.errorHandlers.clear();
+    this.closeHandlers.clear();
+
+    // Close WebSocket connection
     this.wsClient.close();
   }
 
+  /**
+   * Check if subscription is active
+   */
   isConnected(): boolean {
-    return this.wsClient.isConnected();
+    return !this.isClosed && this.wsClient.isConnected();
   }
 }