@pipsend/sdk 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -7,11 +7,30 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // src/types/index.ts
 var PipsendError = class extends Error {
-  constructor(message, code, statusCode) {
+  constructor(message, code, statusCode, errors, response) {
     super(message);
     this.code = code;
     this.statusCode = statusCode;
     this.name = "PipsendError";
+    this.errors = errors;
+    this.response = response;
+  }
+  /**
+   * Get formatted error message with validation details
+   */
+  getDetailedMessage() {
+    if (!this.errors || this.errors.length === 0) {
+      return this.message;
+    }
+    const errorDetails = this.errors.map((err) => `  - ${err.field}: ${err.message}`).join("\n");
+    return `${this.message}
+${errorDetails}`;
+  }
+  /**
+   * Check if this is a validation error
+   */
+  isValidationError() {
+    return this.statusCode === 422 || this.code === "VALIDATION_ERROR";
   }
 };
 var AuthenticationError = class extends PipsendError {
@@ -66,17 +85,35 @@ var AuthManager = class {
   }
   /**
    * Performs authentication with the server
-   * TODO: Implement real API call when available
    */
   async authenticate() {
+    if (!this.config.login || !this.config.password) {
+      throw new AuthenticationError(
+        "Login and password are required for authentication. Please provide them in the config."
+      );
+    }
     try {
-      const mockResponse = {
-        token: "mock_token_" + Date.now(),
-        expiresIn: 180 * 60
-        // 180 minutes in seconds
-      };
-      this.setTokenInfo(mockResponse);
-      console.log("\u2705 Authentication successful (mock)");
+      const response = await fetch(`${this.config.server}/api/v1/auth/login`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          login: this.config.login,
+          password: this.config.password
+        })
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new AuthenticationError(
+          errorData.message || `Authentication failed: ${response.status} ${response.statusText}`
+        );
+      }
+      const data = await response.json();
+      this.setTokenInfo(data);
+      console.log("\u2705 Authentication successful");
+      console.log(`   User: ${data.user.first_name} ${data.user.last_name} (${data.user.email})`);
+      console.log(`   Login: ${data.user.login}`);
+      console.log(`   Balance: $${data.user.balance.toFixed(2)}`);
+      console.log(`   Logged with: ${data.logged_with}`);
     } catch (error) {
       if (error instanceof AuthenticationError) {
         throw error;
@@ -87,11 +124,45 @@ var AuthManager = class {
     }
   }
   /**
-   * Forces a re-authentication
+   * Refreshes the access token using the refresh token
    */
   async refreshToken() {
-    this.tokenInfo = void 0;
-    await this.authenticate();
+    if (!this.tokenInfo?.refreshToken) {
+      console.log("\u26A0\uFE0F No refresh token available, performing full authentication");
+      this.tokenInfo = void 0;
+      await this.authenticate();
+      return;
+    }
+    try {
+      const response = await fetch(`${this.config.server}/api/v1/auth/refresh`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          refresh_token: this.tokenInfo.refreshToken
+        })
+      });
+      if (!response.ok) {
+        console.log("\u26A0\uFE0F Refresh token failed, performing full authentication");
+        this.tokenInfo = void 0;
+        await this.authenticate();
+        return;
+      }
+      const data = await response.json();
+      const now = /* @__PURE__ */ new Date();
+      const expiresAt = new Date(now.getTime() + data.expires_in * 1e3);
+      this.tokenInfo = {
+        token: data.access_token,
+        refreshToken: this.tokenInfo.refreshToken,
+        // Keep the same refresh token
+        issuedAt: now,
+        expiresAt
+      };
+      console.log("\u2705 Token refreshed successfully");
+    } catch (error) {
+      console.error("\u274C Error refreshing token:", error);
+      this.tokenInfo = void 0;
+      await this.authenticate();
+    }
   }
   /**
    * Clears the current token
@@ -113,9 +184,10 @@ var AuthManager = class {
    */
   setTokenInfo(response) {
     const now = /* @__PURE__ */ new Date();
-    const expiresAt = new Date(now.getTime() + response.expiresIn * 1e3);
+    const expiresAt = new Date(now.getTime() + response.expires_in * 1e3);
     this.tokenInfo = {
-      token: response.token,
+      token: response.access_token,
+      refreshToken: response.refresh_token,
       issuedAt: now,
       expiresAt
     };
@@ -146,8 +218,9 @@ var WebSocketManager = class {
       console.log("\u26A0\uFE0F WebSocket reconnection in progress");
       return;
     }
-    const wsUrl = this.buildWebSocketUrl();
     const token = await this.authManager.ensureAuthenticated();
+    const baseWsUrl = this.buildWebSocketUrl();
+    const wsUrl = `${baseWsUrl}${baseWsUrl.includes("?") ? "&" : "?"}token=${encodeURIComponent(token)}`;
     return new Promise((resolve, reject) => {
       try {
         const WS = this.getWebSocketConstructor();
@@ -157,11 +230,6 @@ var WebSocketManager = class {
           this.isConnected = true;
           this.isReconnecting = false;
           this.reconnectAttempts = 0;
-          this.send({
-            type: "auth",
-            payload: { token },
-            timestamp: Date.now()
-          });
           this.emit("connected", { timestamp: Date.now() });
           if (this.subscribedChannels.length > 0) {
             console.log("\u{1F504} Resubscribing to channels:", this.subscribedChannels);
@@ -204,24 +272,22 @@ var WebSocketManager = class {
     });
   }
   /**
-   * Subscribes to channels (symbols, events, etc.)
-   * TODO: Adjust message format according to real WebSocket API
+   * Subscribes to WebSocket channels
    */
   subscribe(channels) {
     if (!this.isConnected) {
       throw new WebSocketError("WebSocket not connected. Call connect() first.");
     }
     this.subscribedChannels = [.../* @__PURE__ */ new Set([...this.subscribedChannels, ...channels])];
-    this.send({
-      type: "subscribe",
-      payload: { channels },
-      timestamp: Date.now()
-    });
+    const message = {
+      action: "subscribe",
+      channels
+    };
+    this.sendAction(message);
     console.log("\u{1F4E1} Subscribed to channels:", channels);
   }
   /**
-   * Unsubscribes from channels
-   * TODO: Adjust message format according to real WebSocket API
+   * Unsubscribes from WebSocket channels
    */
   unsubscribe(channels) {
     if (!this.isConnected) {
@@ -231,11 +297,11 @@ var WebSocketManager = class {
     this.subscribedChannels = this.subscribedChannels.filter(
       (ch) => !channels.includes(ch)
     );
-    this.send({
-      type: "unsubscribe",
-      payload: { channels },
-      timestamp: Date.now()
-    });
+    const message = {
+      action: "unsubscribe",
+      channels
+    };
+    this.sendAction(message);
     console.log("\u{1F4E1} Unsubscribed from channels:", channels);
   }
   /**
@@ -292,7 +358,7 @@ var WebSocketManager = class {
     try {
       const url = new URL(this.config.server);
       url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-      const wsPath = this.config.websocket?.path || "/ws";
+      const wsPath = this.config.websocket?.path || "/api/v1/ws";
       url.pathname = wsPath;
       return url.toString();
     } catch (error) {
@@ -315,11 +381,11 @@ var WebSocketManager = class {
     }
   }
   /**
-   * Sends a message through WebSocket
+   * Sends an action message through WebSocket
    */
-  send(message) {
+  sendAction(message) {
     if (!this.ws || !this.isConnected) {
-      console.warn("\u26A0\uFE0F WebSocket not ready, message not sent:", message.type);
+      console.warn("\u26A0\uFE0F WebSocket not ready, message not sent:", message.action);
       return;
     }
     try {
@@ -330,21 +396,99 @@ var WebSocketManager = class {
     }
   }
   /**
-   * Handles incoming WebSocket messages
-   * TODO: Adjust message handling according to real WebSocket API
+   * Sends a ping message (for heartbeat)
    */
-  handleMessage(data) {
-    if (data.type === "authenticated") {
-      console.log("\u2705 WebSocket authenticated");
-      this.emit("authenticated", data.payload || {});
+  sendPing() {
+    if (!this.ws || !this.isConnected) {
       return;
     }
-    if (data.type === "pong") {
-      return;
+    try {
+      this.ws.send(JSON.stringify({ action: "ping" }));
+    } catch (error) {
+      console.error("\u274C Failed to send ping:", error);
     }
-    const eventType = data.type;
-    this.emit(eventType, data.payload || data);
-    this.emit("*", data);
+  }
+  /**
+   * Handles incoming WebSocket messages
+   */
+  handleMessage(message) {
+    switch (message.op) {
+      case "connected":
+        this.handleConnected(message);
+        break;
+      case "subscription_success":
+        this.handleSubscriptionSuccess(message);
+        break;
+      case "unsubscription_success":
+        this.handleUnsubscriptionSuccess(message);
+        break;
+      case "push":
+        this.handlePushEvent(message);
+        break;
+      case "error":
+        this.handleError(message);
+        break;
+      default:
+        console.warn(message.op);
+    }
+    this.emit("*", message);
+  }
+  /**
+   * Handles connected message from server
+   */
+  handleConnected(message) {
+    console.log("\u2705 WebSocket connected:", message.data.message);
+    console.log("   Available channels:", message.data.available_channels);
+    this.emit("connected", message.data);
+  }
+  /**
+   * Handles subscription success
+   */
+  handleSubscriptionSuccess(message) {
+    console.log("\u2705 Subscription successful:", message.data.subscribed);
+    this.emit("subscription_success", message.data);
+  }
+  /**
+   * Handles unsubscription success
+   */
+  handleUnsubscriptionSuccess(message) {
+    console.log("\u2705 Unsubscription successful:", message.data.unsubscribed);
+    this.emit("unsubscription_success", message.data);
+  }
+  /**
+   * Handles push events (actual data events)
+   */
+  handlePushEvent(message) {
+    const eventData = message.data;
+    const eventType = eventData.type;
+    switch (eventType) {
+      case "position.opened":
+        this.emit("position:opened", eventData);
+        break;
+      case "position.closed":
+      case "position.partially_closed":
+        this.emit("position:closed", eventData);
+        break;
+      case "position.updated":
+        this.emit("position:updated", eventData);
+        break;
+      default:
+        if (message.topic?.startsWith("balance:")) {
+          this.emit("balance:updated", eventData);
+        } else {
+          console.warn("Unknown event type:", eventType);
+        }
+    }
+  }
+  /**
+   * Handles error messages from server
+   */
+  handleError(message) {
+    console.error("\u274C WebSocket error:", message.data.message);
+    if (message.data.error) {
+      console.error("   Error details:", message.data.error);
+    }
+    this.emit("error", message.data);
   }
   /**
    * Emits an event to all registered listeners
@@ -395,10 +539,7 @@ var WebSocketManager = class {
     const interval = this.config.websocket?.heartbeatInterval || 3e4;
     this.heartbeatTimer = setInterval(() => {
       if (this.isConnected) {
-        this.send({
-          type: "ping",
-          timestamp: Date.now()
-        });
+        this.sendPing();
       }
     }, interval);
   }
@@ -415,28 +556,59 @@ var WebSocketManager = class {
 
 // src/api/http-client.ts
 var HttpClient = class {
-  constructor(baseUrl) {
+  constructor(baseUrl, authManager) {
     this.baseUrl = baseUrl;
+    this.authManager = authManager;
   }
   /**
    * Makes an HTTP request
    */
-  async request(endpoint, options = {}) {
+  async request(endpoint, options = {}, retryOn401 = true) {
     const url = `${this.baseUrl}${endpoint}`;
     try {
+      const headers = {
+        "Content-Type": "application/json",
+        ...options.headers || {}
+      };
+      if (this.authManager) {
+        const token = await this.authManager.ensureAuthenticated();
+        headers["Authorization"] = `Bearer ${token}`;
+      }
       const response = await fetch(url, {
         ...options,
-        headers: {
-          "Content-Type": "application/json",
-          ...options.headers
-        }
+        headers
       });
+      if (response.status === 401 && this.authManager && retryOn401) {
+        console.log("\u26A0\uFE0F Received 401, attempting to refresh token...");
+        await this.authManager.refreshToken();
+        return this.request(endpoint, options, false);
+      }
       if (!response.ok) {
         const errorText = await response.text();
+        let errorMessage = `HTTP ${response.status}: ${errorText || response.statusText}`;
+        let errorCode = "HTTP_ERROR";
+        let validationErrors;
+        let errorResponse;
+        try {
+          const errorJson = JSON.parse(errorText);
+          errorResponse = errorJson;
+          if (errorJson.message) {
+            errorMessage = errorJson.message;
+          }
+          if (errorJson.status_code) {
+            errorCode = errorJson.status_code;
+          }
+          if (errorJson.errors && Array.isArray(errorJson.errors)) {
+            validationErrors = errorJson.errors;
+          }
+        } catch {
+        }
         throw new PipsendError(
-          `HTTP ${response.status}: ${errorText || response.statusText}`,
-          "HTTP_ERROR",
-          response.status
+          errorMessage,
+          errorCode,
+          response.status,
+          validationErrors,
+          errorResponse
         );
       }
       const text = await response.text();
@@ -500,6 +672,12 @@ var AccountsAPI = class {
   constructor(http) {
     this.http = http;
   }
+  /**
+   * Create a new trading account
+   */
+  async create(request) {
+    return this.http.post("/api/v1/accounts", request);
+  }
   /**
    * List all accounts with optional filters and pagination
    */
@@ -512,6 +690,12 @@ var AccountsAPI = class {
   async getLogins() {
     return this.http.get("/api/v1/accounts/logins");
   }
+  /**
+   * Get account status/metrics (balance, equity, credit, margin)
+   */
+  async getStatus(login) {
+    return this.http.get(`/api/v1/accounts/${login}/status`);
+  }
   /**
    * Get account statistics with optional filters
    */
@@ -542,6 +726,20 @@ var AccountsAPI = class {
   async unarchive(login) {
     return this.http.put(`/api/v1/accounts/${login}/unarchive`);
   }
+  /**
+   * Update account information (partial update)
+   * All fields are optional, only send the ones you want to update
+   */
+  async update(login, request) {
+    return this.http.put(`/api/v1/accounts/${login}`, request);
+  }
+  /**
+   * Adjust balance or credit for an account
+   * The adjustment is relative: amount is added or subtracted from current value
+   */
+  async balance(login, request) {
+    return this.http.put(`/api/v1/accounts/${login}/adjust`, request);
+  }
 };
 
 // src/api/trading-groups.ts
@@ -838,9 +1036,9 @@ var PipsendClient = class {
         return this.wsManager?.isWebSocketConnected() ?? false;
       },
       /**
-       * Subscribes to symbols or channels
+       * Subscribes to WebSocket channels
        * @example
-       * client.stream.subscribe(['EURUSD', 'GBPUSD']);
+       * client.stream.subscribe(['positions:new', 'positions:closed']);
        */
       subscribe: (channels) => {
         if (!this.wsManager) {
@@ -849,7 +1047,7 @@ var PipsendClient = class {
         this.wsManager.subscribe(channels);
       },
       /**
-       * Unsubscribes from symbols or channels
+       * Unsubscribes from WebSocket channels
        */
       unsubscribe: (channels) => {
         if (!this.wsManager) {
@@ -864,40 +1062,81 @@ var PipsendClient = class {
         return this.wsManager?.getSubscribedChannels() ?? [];
       },
       /**
-       * Listens to real-time price updates
+       * Listens to position opened events
+       */
+      onPositionOpened: (callback) => {
+        if (!this.wsManager) {
+          throw new WebSocketError("WebSocket not enabled");
+        }
+        this.wsManager.on("position:opened", callback);
+      },
+      /**
+       * Listens to position closed events (includes partial closes)
+       */
+      onPositionClosed: (callback) => {
+        if (!this.wsManager) {
+          throw new WebSocketError("WebSocket not enabled");
+        }
+        this.wsManager.on("position:closed", callback);
+      },
+      /**
+       * Listens to position updated events (throttled to max 1 per 2 seconds)
+       */
+      onPositionUpdated: (callback) => {
+        if (!this.wsManager) {
+          throw new WebSocketError("WebSocket not enabled");
+        }
+        this.wsManager.on("position:updated", callback);
+      },
+      /**
+       * Listens to balance updated events
+       */
+      onBalanceUpdated: (callback) => {
+        if (!this.wsManager) {
+          throw new WebSocketError("WebSocket not enabled");
+        }
+        this.wsManager.on("balance:updated", callback);
+      },
+      // Legacy methods (deprecated but kept for compatibility)
+      /**
+       * @deprecated Use onPositionUpdated instead
        */
       onPriceUpdate: (callback) => {
+        console.warn("\u26A0\uFE0F onPriceUpdate is deprecated. Use onPositionUpdated instead.");
         if (!this.wsManager) {
           throw new WebSocketError("WebSocket not enabled");
         }
-        this.wsManager.on("price", callback);
+        this.wsManager.on("position:updated", callback);
       },
       /**
-       * Listens to real-time order updates
+       * @deprecated Use onPositionOpened/onPositionClosed instead
        */
       onOrderUpdate: (callback) => {
+        console.warn("\u26A0\uFE0F onOrderUpdate is deprecated. Use onPositionOpened/onPositionClosed instead.");
         if (!this.wsManager) {
           throw new WebSocketError("WebSocket not enabled");
         }
-        this.wsManager.on("order", callback);
+        this.wsManager.on("position:opened", callback);
       },
       /**
-       * Listens to real-time position updates
+       * @deprecated Use onPositionUpdated instead
        */
       onPositionUpdate: (callback) => {
+        console.warn("\u26A0\uFE0F onPositionUpdate is deprecated. Use onPositionUpdated instead.");
         if (!this.wsManager) {
           throw new WebSocketError("WebSocket not enabled");
         }
-        this.wsManager.on("position", callback);
+        this.wsManager.on("position:updated", callback);
       },
       /**
-       * Listens to real-time balance updates
+       * @deprecated Use onBalanceUpdated instead
        */
       onBalanceUpdate: (callback) => {
+        console.warn("\u26A0\uFE0F onBalanceUpdate is deprecated. Use onBalanceUpdated instead.");
         if (!this.wsManager) {
           throw new WebSocketError("WebSocket not enabled");
         }
-        this.wsManager.on("balance", callback);
+        this.wsManager.on("balance:updated", callback);
       },
       /**
        * Listens to connection events
@@ -941,7 +1180,7 @@ var PipsendClient = class {
       timezone: config.timezone ?? "UTC"
     };
     this.authManager = new AuthManager(this.config);
-    this.http = new HttpClient(this.config.server);
+    this.http = new HttpClient(this.config.server, this.authManager);
     this.accounts = new AccountsAPI(this.http);
     this.tradingGroups = new TradingGroupsAPI(this.http);
     this.marketData = new MarketDataAPI(this.http);