@chainstream-io/sdk 0.1.20 → 0.1.22

package/README.md

@@ -1,4 +1,4 @@
-## @chainstream-io/sdk@0.1.20
+## @chainstream-io/sdk@0.1.22
 
 This generator creates TypeScript/JavaScript client that utilizes [Fetch API](https://fetch.spec.whatwg.org/). The generated Node module can be used in the following environments:
 

package/dist/{index-Rg3zipzv.d.cts → index-CuPWnFsI.d.cts}

@@ -320,9 +320,42 @@ interface Unsubscrible {
 declare class StreamApi {
     private realtimeClient;
     private listenersMap;
-    private getTokenValue;
+    private context;
+    private initPromise;
     constructor(context: DexRequestContext);
-    connect(): Promise<void>;
+    /**
+     * Initialize Centrifuge client with current token
+     * This is called lazily when connect() is called
+     */
+    private initClient;
+    /**
+     * Wait for initialization to complete
+     * If not initialized, auto-connect first
+     */
+    private ensureInitialized;
+    /**
+     * Get token value from string or TokenProvider
+     */
+    private getTokenValue;
+    /**
+     * Build WebSocket URL with token as query parameter
+     */
+    private buildWsUrl;
+    /**
+     * Connect to the WebSocket server.
+     * This is automatically called when you use subscribe methods if not already connected.
+     * You can also call this method manually for explicit control.
+     */
+    connect(): void;
+    /**
+     * Disconnect from the WebSocket server.
+     * All subscriptions will be automatically removed.
+     */
+    disconnect(): void;
+    /**
+     * Check if the WebSocket is currently connected.
+     */
+    isConnected(): boolean;
     /**
      * Start batching commands for efficient bulk operations
      * All subscription commands after this call will be batched until stopBatching is called
@@ -467,8 +500,16 @@ interface DexAggregatorOptions {
     debug?: boolean;
     serverUrl?: string;
     streamUrl?: string;
+    /**
+     * Whether to automatically connect to WebSocket on initialization.
+     * Default: false
+     *
+     * If set to true, WebSocket will connect automatically.
+     * If false or not set, you need to manually call `client.stream.connect()` when needed.
+     */
+    autoConnectWebSocket?: boolean;
 }
-declare const LIB_VERSION = "0.1.20";
+declare const LIB_VERSION = "0.1.22";
 declare class DexClient {
     readonly requestCtx: DexRequestContext;
     readonly _configuration: Configuration;

package/dist/{index-8REU_oTW.d.ts → index-DWL6morC.d.ts}

@@ -320,9 +320,42 @@ interface Unsubscrible {
 declare class StreamApi {
     private realtimeClient;
     private listenersMap;
-    private getTokenValue;
+    private context;
+    private initPromise;
     constructor(context: DexRequestContext);
-    connect(): Promise<void>;
+    /**
+     * Initialize Centrifuge client with current token
+     * This is called lazily when connect() is called
+     */
+    private initClient;
+    /**
+     * Wait for initialization to complete
+     * If not initialized, auto-connect first
+     */
+    private ensureInitialized;
+    /**
+     * Get token value from string or TokenProvider
+     */
+    private getTokenValue;
+    /**
+     * Build WebSocket URL with token as query parameter
+     */
+    private buildWsUrl;
+    /**
+     * Connect to the WebSocket server.
+     * This is automatically called when you use subscribe methods if not already connected.
+     * You can also call this method manually for explicit control.
+     */
+    connect(): void;
+    /**
+     * Disconnect from the WebSocket server.
+     * All subscriptions will be automatically removed.
+     */
+    disconnect(): void;
+    /**
+     * Check if the WebSocket is currently connected.
+     */
+    isConnected(): boolean;
     /**
      * Start batching commands for efficient bulk operations
      * All subscription commands after this call will be batched until stopBatching is called
@@ -467,8 +500,16 @@ interface DexAggregatorOptions {
     debug?: boolean;
     serverUrl?: string;
     streamUrl?: string;
+    /**
+     * Whether to automatically connect to WebSocket on initialization.
+     * Default: false
+     *
+     * If set to true, WebSocket will connect automatically.
+     * If false or not set, you need to manually call `client.stream.connect()` when needed.
+     */
+    autoConnectWebSocket?: boolean;
 }
-declare const LIB_VERSION = "0.1.20";
+declare const LIB_VERSION = "0.1.22";
 declare class DexClient {
     readonly requestCtx: DexRequestContext;
     readonly _configuration: Configuration;

package/dist/index.cjs

@@ -29,7 +29,6 @@ module.exports = __toCommonJS(index_exports);
 
 // src/stream/stream.ts
 var import_centrifuge = require("@chainstream-io/centrifuge");
-var import_module = require("module");
 
 // src/stream/stream.fields.ts
 var CEL_FIELD_MAPPINGS = {
@@ -286,67 +285,104 @@ function replaceFilterFields(filter, methodName) {
 }
 
 // src/stream/stream.ts
-var import_meta = {};
 var StreamApi = class {
   constructor(context) {
     __publicField(this, "realtimeClient");
     __publicField(this, "listenersMap");
-    __publicField(this, "getTokenValue");
-    const realtimeEndpoint = context.streamUrl;
-    this.getTokenValue = async () => {
-      return typeof context.accessToken === "string" ? context.accessToken : await context.accessToken.getToken();
-    };
-    let wsImpl = void 0;
-    if (typeof process !== "undefined" && process.versions?.node) {
-      try {
-        const require2 = (0, import_module.createRequire)(import_meta.url);
-        wsImpl = require2("ws");
-      } catch {
-      }
-    }
-    if (!wsImpl && typeof WebSocket !== "undefined") {
-      wsImpl = WebSocket;
+    __publicField(this, "context");
+    __publicField(this, "initPromise", null);
+    this.context = context;
+    this.listenersMap = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Initialize Centrifuge client with current token
+   * This is called lazily when connect() is called
+   */
+  async initClient() {
+    if (this.realtimeClient) {
+      return;
     }
+    const token = await this.getTokenValue();
+    const realtimeEndpoint = this.buildWsUrl(this.context.streamUrl, token);
     this.realtimeClient = new import_centrifuge.Centrifuge(realtimeEndpoint, {
-      ...wsImpl && { websocket: wsImpl },
       getToken: async (_ctx) => {
-        const token = await this.getTokenValue();
-        this.realtimeClient.setHttpHeaders({
-          Authorization: `Bearer ${token}`,
-          "User-Agent": `chainstream-io/sdk/javascript`
-        });
-        return token;
+        return this.getTokenValue();
       }
     });
     this.realtimeClient.on("connected", () => {
       console.log("[streaming] connected");
-    }).on("disconnected", (err) => {
-      console.warn("[streaming] disconnected", err);
+    }).on("disconnected", (ctx) => {
+      console.warn("[streaming] disconnected", ctx);
     }).on("error", (err) => {
       console.error("[streaming] error: ", err);
     });
-    this.listenersMap = /* @__PURE__ */ new Map();
   }
-  async connect() {
-    const token = await this.getTokenValue();
-    this.realtimeClient.setHttpHeaders({
-      Authorization: `Bearer ${token}`
+  /**
+   * Wait for initialization to complete
+   * If not initialized, auto-connect first
+   */
+  async ensureInitialized() {
+    if (!this.initPromise) {
+      this.connect();
+    }
+    await this.initPromise;
+  }
+  /**
+   * Get token value from string or TokenProvider
+   */
+  async getTokenValue() {
+    return typeof this.context.accessToken === "string" ? this.context.accessToken : await this.context.accessToken.getToken();
+  }
+  /**
+   * Build WebSocket URL with token as query parameter
+   */
+  buildWsUrl(endpoint, token) {
+    const url = new URL(endpoint);
+    url.searchParams.set("token", token);
+    return url.toString();
+  }
+  /**
+   * Connect to the WebSocket server.
+   * This is automatically called when you use subscribe methods if not already connected.
+   * You can also call this method manually for explicit control.
+   */
+  connect() {
+    this.initPromise = this.initClient().then(() => {
+      this.realtimeClient.connect();
     });
-    this.realtimeClient.connect();
+  }
+  /**
+   * Disconnect from the WebSocket server.
+   * All subscriptions will be automatically removed.
+   */
+  disconnect() {
+    if (this.realtimeClient) {
+      this.realtimeClient.disconnect();
+    }
+  }
+  /**
+   * Check if the WebSocket is currently connected.
+   */
+  isConnected() {
+    return this.realtimeClient?.state === "connected";
   }
   /**
    * Start batching commands for efficient bulk operations
    * All subscription commands after this call will be batched until stopBatching is called
    */
   startBatching() {
-    this.realtimeClient.startBatching();
+    if (this.realtimeClient) {
+      this.realtimeClient.startBatching();
+    }
   }
   /**
    * Stop batching and flush all collected commands to the server
    * This will send all batched subscription commands in a single network request
    */
   stopBatching() {
-    this.realtimeClient.stopBatching();
+    if (this.realtimeClient) {
+      this.realtimeClient.stopBatching();
+    }
   }
   /**
    * Batch subscribe method that accepts a function containing subscription calls
@@ -376,26 +412,31 @@ var StreamApi = class {
     });
   }
   subscribe(channel, fn, filter, methodName) {
-    let sub = this.realtimeClient.getSubscription(channel);
     let listeners = this.listenersMap.get(channel);
-    if (!sub) {
+    if (!listeners) {
       listeners = /* @__PURE__ */ new Set();
       this.listenersMap.set(channel, listeners);
-      console.log("[xrealtime] create new sub: ", channel);
-      const processedFilter = filter && methodName ? replaceFilterFields(filter, methodName) : filter;
-      sub = this.realtimeClient.newSubscription(channel, {
-        delta: "fossil",
-        ...processedFilter && { filter: processedFilter }
-      });
-      sub.on("subscribed", () => {
-        console.log("[xrealtime] subscribed", channel);
-      }).on("unsubscribed", () => {
-        console.log("[xrealtime] unsubscribed", channel);
-      }).on("publication", (ctx) => {
-        listeners?.forEach((it) => it(ctx.data));
-      }).subscribe();
-    }
-    listeners?.add(fn);
+    }
+    listeners.add(fn);
+    this.ensureInitialized().then(() => {
+      let sub = this.realtimeClient.getSubscription(channel);
+      if (!sub) {
+        console.log("[xrealtime] create new sub: ", channel);
+        const processedFilter = filter && methodName ? replaceFilterFields(filter, methodName) : filter;
+        sub = this.realtimeClient.newSubscription(channel, {
+          delta: "fossil",
+          ...processedFilter && { filter: processedFilter }
+        });
+        sub.on("subscribed", () => {
+          console.log("[xrealtime] subscribed", channel);
+        }).on("unsubscribed", () => {
+          console.log("[xrealtime] unsubscribed", channel);
+        }).on("publication", (ctx) => {
+          const currentListeners = this.listenersMap.get(channel);
+          currentListeners?.forEach((it) => it(ctx.data));
+        }).subscribe();
+      }
+    });
     return new StreamUnsubscrible(this, channel, fn);
   }
   unsubscribe(channel, fn) {
@@ -407,12 +448,14 @@ var StreamApi = class {
     console.log("unsubscribe, remain listeners: ", listeners.size);
     if (listeners.size === 0) {
       console.log("unsubscribe channel: ", channel);
-      const sub = this.realtimeClient.getSubscription(channel);
-      if (sub) {
-        sub.unsubscribe();
-        this.realtimeClient.removeSubscription(sub);
-      }
       this.listenersMap.delete(channel);
+      this.ensureInitialized().then(() => {
+        const sub = this.realtimeClient.getSubscription(channel);
+        if (sub) {
+          sub.unsubscribe();
+          this.realtimeClient.removeSubscription(sub);
+        }
+      });
     }
   }
   formatScientificNotation(value) {
@@ -8189,7 +8232,7 @@ var WatchlistApi = class extends BaseAPI {
 
 // src/index.ts
 var import_event_source_polyfill = require("event-source-polyfill");
-var LIB_VERSION = "0.1.20";
+var LIB_VERSION = "0.1.22";
 var UserAgentMiddleware = class {
   async pre(context) {
     if (!context.init.headers) {
@@ -8227,9 +8270,6 @@ var DexClient = class {
     __publicField(this, "endpoint");
     const baseUrl = options.serverUrl ?? "https://api-dex.chainstream.io";
     const streamUrl = options.streamUrl ?? "wss://realtime-dex.chainstream.io/connection/websocket";
-    const tokenProvider = typeof accessToken === "string" ? {
-      getToken: () => accessToken
-    } : accessToken;
     this.requestCtx = { baseUrl, streamUrl, accessToken };
     const config = new Configuration({
       basePath: baseUrl,
@@ -8259,7 +8299,9 @@ var DexClient = class {
     this.jobs = new JobsApi(config);
     this.kyt = new KYTApi(config);
     this.endpoint = new EndpointApi(config);
-    this.stream.connect();
+    if (options.autoConnectWebSocket === true) {
+      this.stream.connect();
+    }
   }
   async waitForJob(jobId, timeout = 6e4) {
     const accessToken = typeof this.requestCtx.accessToken === "string" ? this.requestCtx.accessToken : await this.requestCtx.accessToken.getToken();