@hashgrid/sdk 0.2.8 → 0.3.1

package/README.md

@@ -50,9 +50,6 @@ The SDK provides the following resources:
 - **`User`** - User data model
 - **`Quota`** - Quota data model
 - **`Message`** - Message for recv/send operations
-  - Constructor: `new Message(peer_id, round, message = "", score = null)`
-- **`Status`** - Status response from send operations
-  - Properties: `peer_id`, `round`, `success`
 
 ## Examples
 

package/dist/client.d.ts

@@ -1,12 +1,13 @@
 /** Main Hashgrid client class. */
 import { Grid } from "./resources";
 export declare class Hashgrid {
-    private api_key?;
-    private base_url;
+    private apiKey?;
+    private baseUrl;
     private timeout;
-    constructor(api_key?: string, base_url?: string, timeout?: number);
+    constructor(apiKey?: string, baseUrl?: string, timeout?: number);
     private _getHeaders;
-    _request(method: string, endpoint: string, params?: Record<string, any>, json_data?: any): Promise<any>;
+    request(method: string, endpoint: string, params?: Record<string, any>, jsonData?: any): Promise<any>;
     _handleResponse(response: Response): Promise<any>;
-    static connect(api_key?: string, base_url?: string, timeout?: number): Promise<Grid>;
+    stream(method: string, endpoint: string, params?: Record<string, any>, jsonData?: any): AsyncGenerator<string>;
+    static connect(apiKey?: string, baseUrl?: string, timeout?: number): Promise<Grid>;
 }

package/dist/client.js

@@ -5,9 +5,9 @@ exports.Hashgrid = void 0;
 const exceptions_1 = require("./exceptions");
 const resources_1 = require("./resources");
 class Hashgrid {
-    constructor(api_key, base_url = "https://dna.hashgrid.ai", timeout = 30000) {
-        this.api_key = api_key;
-        this.base_url = base_url.replace(/\/$/, "");
+    constructor(apiKey, baseUrl = "https://dna.hashgrid.ai", timeout = 30000) {
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl.replace(/\/$/, "");
         this.timeout = timeout;
     }
     _getHeaders() {
@@ -15,18 +15,18 @@ class Hashgrid {
             "Content-Type": "application/json",
             Accept: "application/json",
         };
-        if (this.api_key) {
-            headers["Authorization"] = `Bearer ${this.api_key}`;
+        if (this.apiKey) {
+            headers["Authorization"] = `Bearer ${this.apiKey}`;
         }
         return headers;
     }
-    async _request(method, endpoint, params, json_data) {
+    async request(method, endpoint, params, jsonData) {
         let url;
         if (endpoint.startsWith("http://") || endpoint.startsWith("https://")) {
             url = endpoint;
         }
         else {
-            const base = this.base_url.endsWith("/") ? this.base_url.slice(0, -1) : this.base_url;
+            const base = this.baseUrl.endsWith("/") ? this.baseUrl.slice(0, -1) : this.baseUrl;
             const path = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
             url = `${base}${path}`;
         }
@@ -45,8 +45,8 @@ class Hashgrid {
             headers,
             signal: controller.signal,
         };
-        if (json_data !== undefined) {
-            options.body = JSON.stringify(json_data);
+        if (jsonData !== undefined) {
+            options.body = JSON.stringify(jsonData);
         }
         try {
             const response = await fetch(url, options);
@@ -104,9 +104,58 @@ class Hashgrid {
             throw new exceptions_1.HashgridAPIError(`Response handling failed: ${error}`);
         }
     }
-    static async connect(api_key, base_url = "https://dna.hashgrid.ai", timeout = 30000) {
-        const client = new Hashgrid(api_key, base_url, timeout);
-        const data = await client._request("GET", "/api/v1");
+    async *stream(method, endpoint, params, jsonData) {
+        const base = this.baseUrl.endsWith("/") ? this.baseUrl.slice(0, -1) : this.baseUrl;
+        const path = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+        let url = `${base}${path}`;
+        if (params) {
+            const searchParams = new URLSearchParams();
+            Object.entries(params).forEach(([key, value]) => {
+                searchParams.append(key, String(value));
+            });
+            url += `?${searchParams.toString()}`;
+        }
+        const headers = this._getHeaders();
+        headers["Accept"] = "text/event-stream";
+        const options = {
+            method,
+            headers,
+        };
+        if (jsonData !== undefined) {
+            options.body = JSON.stringify(jsonData);
+        }
+        const response = await fetch(url, options);
+        if (!response.ok) {
+            throw new exceptions_1.HashgridAPIError(`SSE connection failed: ${response.status}`);
+        }
+        const reader = response.body?.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        if (!reader) {
+            throw new exceptions_1.HashgridAPIError("Response body is not readable");
+        }
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    if (line.startsWith("data: ")) {
+                        yield line.slice(6).trim();
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    static async connect(apiKey, baseUrl = "https://dna.hashgrid.ai", timeout = 30000) {
+        const client = new Hashgrid(apiKey, baseUrl, timeout);
+        const data = await client.request("GET", "/api/v1");
         const grid = new resources_1.Grid(data.name, data.tick, client);
         return grid;
     }

package/dist/exceptions.d.ts

@@ -3,16 +3,16 @@ export declare class HashgridError extends Error {
     constructor(message: string);
 }
 export declare class HashgridAPIError extends HashgridError {
-    status_code?: number;
+    statusCode?: number;
     response?: Response;
-    constructor(message: string, status_code?: number, response?: Response);
+    constructor(message: string, statusCode?: number, response?: Response);
 }
 export declare class HashgridAuthenticationError extends HashgridAPIError {
-    constructor(message: string, status_code?: number, response?: Response);
+    constructor(message: string, statusCode?: number, response?: Response);
 }
 export declare class HashgridNotFoundError extends HashgridAPIError {
-    constructor(message: string, status_code?: number, response?: Response);
+    constructor(message: string, statusCode?: number, response?: Response);
 }
 export declare class HashgridValidationError extends HashgridAPIError {
-    constructor(message: string, status_code?: number, response?: Response);
+    constructor(message: string, statusCode?: number, response?: Response);
 }

package/dist/exceptions.js

@@ -11,34 +11,34 @@ class HashgridError extends Error {
 }
 exports.HashgridError = HashgridError;
 class HashgridAPIError extends HashgridError {
-    constructor(message, status_code, response) {
+    constructor(message, statusCode, response) {
         super(message);
         this.name = "HashgridAPIError";
-        this.status_code = status_code;
+        this.statusCode = statusCode;
         this.response = response;
         Object.setPrototypeOf(this, HashgridAPIError.prototype);
     }
 }
 exports.HashgridAPIError = HashgridAPIError;
 class HashgridAuthenticationError extends HashgridAPIError {
-    constructor(message, status_code, response) {
-        super(message, status_code, response);
+    constructor(message, statusCode, response) {
+        super(message, statusCode, response);
         this.name = "HashgridAuthenticationError";
         Object.setPrototypeOf(this, HashgridAuthenticationError.prototype);
     }
 }
 exports.HashgridAuthenticationError = HashgridAuthenticationError;
 class HashgridNotFoundError extends HashgridAPIError {
-    constructor(message, status_code, response) {
-        super(message, status_code, response);
+    constructor(message, statusCode, response) {
+        super(message, statusCode, response);
         this.name = "HashgridNotFoundError";
         Object.setPrototypeOf(this, HashgridNotFoundError.prototype);
     }
 }
 exports.HashgridNotFoundError = HashgridNotFoundError;
 class HashgridValidationError extends HashgridAPIError {
-    constructor(message, status_code, response) {
-        super(message, status_code, response);
+    constructor(message, statusCode, response) {
+        super(message, statusCode, response);
         this.name = "HashgridValidationError";
         Object.setPrototypeOf(this, HashgridValidationError.prototype);
     }

package/dist/resources.d.ts

@@ -1,59 +1,59 @@
 /** Hashgrid API resources. */
 import { Hashgrid } from "./client";
 export declare class User {
-    user_id: string;
+    userId: string;
     name: string;
-    is_superuser: boolean;
-    quota_id: string;
-    constructor(user_id: string, name: string, is_superuser: boolean, quota_id: string);
+    isSuperuser: boolean;
+    quotaId: string;
+    constructor(userId: string, name: string, isSuperuser: boolean, quotaId: string);
 }
 export declare class Quota {
-    quota_id: string;
+    quotaId: string;
     name: string;
     capacity: number;
-    constructor(quota_id: string, name: string, capacity: number);
+    constructor(quotaId: string, name: string, capacity: number);
 }
 export declare class Edge {
-    node_id: string;
-    peer_id: string;
-    recv_message: string;
-    send_message: string | null;
+    nodeId: string;
+    peerId: string;
+    recvMessage: string;
+    sendMessage: string | null;
     score: number | null;
     round: number;
-    constructor(node_id: string, peer_id: string, recv_message: string, send_message: string | null, score: number | null, round: number);
+    constructor(nodeId: string, peerId: string, recvMessage: string, sendMessage: string | null, score: number | null, round: number);
 }
 export declare class Message {
-    peer_id: string;
+    peerId: string;
     round: number;
     message: string;
     score: number | null;
-    constructor(peer_id: string, round: number, message?: string, score?: number | null);
+    constructor(peerId: string, round: number, message?: string, score?: number | null);
 }
 export declare class Status {
-    peer_id: string;
+    peerId: string;
     round: number;
     success: boolean;
-    constructor(peer_id: string, round: number, success: boolean);
+    constructor(peerId: string, round: number, success: boolean);
 }
 export declare class Grid {
     name: string;
     tick: number;
     private _client;
     constructor(name: string, tick: number, client: Hashgrid);
-    listen(poll_interval?: number): AsyncGenerator<number>;
+    listen(): AsyncGenerator<number>;
     nodes(): AsyncGenerator<Node>;
-    create_node(name: string, message?: string, capacity?: number): Promise<Node>;
+    createNode(name: string, message?: string, capacity?: number): Promise<Node>;
 }
 export declare class Node {
-    node_id: string;
-    owner_id: string;
+    nodeId: string;
+    ownerId: string;
     name: string;
     message: string;
     capacity: number;
     private _client;
-    constructor(node_id: string, owner_id: string, name: string, message: string, capacity: number, client: Hashgrid);
+    constructor(nodeId: string, ownerId: string, name: string, message: string, capacity: number, client: Hashgrid);
     recv(): Promise<Message[]>;
-    send(replies: Message[]): Promise<Status[]>;
+    send(replies: Message[]): Promise<Message[]>;
     update(name?: string, message?: string, capacity?: number): Promise<Node>;
     delete(): Promise<void>;
 }

package/dist/resources.js

@@ -3,36 +3,36 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Node = exports.Grid = exports.Status = exports.Message = exports.Edge = exports.Quota = exports.User = void 0;
 class User {
-    constructor(user_id, name, is_superuser, quota_id) {
-        this.user_id = user_id;
+    constructor(userId, name, isSuperuser, quotaId) {
+        this.userId = userId;
         this.name = name;
-        this.is_superuser = is_superuser;
-        this.quota_id = quota_id;
+        this.isSuperuser = isSuperuser;
+        this.quotaId = quotaId;
     }
 }
 exports.User = User;
 class Quota {
-    constructor(quota_id, name, capacity) {
-        this.quota_id = quota_id;
+    constructor(quotaId, name, capacity) {
+        this.quotaId = quotaId;
         this.name = name;
         this.capacity = capacity;
     }
 }
 exports.Quota = Quota;
 class Edge {
-    constructor(node_id, peer_id, recv_message, send_message, score, round) {
-        this.node_id = node_id;
-        this.peer_id = peer_id;
-        this.recv_message = recv_message;
-        this.send_message = send_message;
+    constructor(nodeId, peerId, recvMessage, sendMessage, score, round) {
+        this.nodeId = nodeId;
+        this.peerId = peerId;
+        this.recvMessage = recvMessage;
+        this.sendMessage = sendMessage;
         this.score = score;
         this.round = round;
     }
 }
 exports.Edge = Edge;
 class Message {
-    constructor(peer_id, round, message = "", score = null) {
-        this.peer_id = peer_id;
+    constructor(peerId, round, message = "", score = null) {
+        this.peerId = peerId;
         this.round = round;
         this.message = message;
         this.score = score;
@@ -40,8 +40,8 @@ class Message {
 }
 exports.Message = Message;
 class Status {
-    constructor(peer_id, round, success) {
-        this.peer_id = peer_id;
+    constructor(peerId, round, success) {
+        this.peerId = peerId;
         this.round = round;
         this.success = success;
     }
@@ -53,56 +53,45 @@ class Grid {
         this.tick = tick;
         this._client = client;
     }
-    async *listen(poll_interval = 30000) {
-        let last_tick = -1;
-        while (true) {
-            try {
-                const data = await this._client._request("GET", "/api/v1");
-                this.name = data.name;
-                this.tick = data.tick;
-                const current_tick = this.tick;
-                if (current_tick !== last_tick) {
-                    yield current_tick;
-                    last_tick = current_tick;
-                }
-                await new Promise((resolve) => setTimeout(resolve, poll_interval));
-            }
-            catch (error) {
-                console.warn(`Error while listening for ticks: ${error}`);
-                await new Promise((resolve) => setTimeout(resolve, poll_interval * 2));
+    async *listen() {
+        for await (const data of this._client.stream("GET", "/api/v1/listen")) {
+            const tick = parseInt(data, 10);
+            if (!isNaN(tick) && tick !== this.tick) {
+                this.tick = tick;
+                yield tick;
             }
         }
     }
     async *nodes() {
-        const data = await this._client._request("GET", "/api/v1/node");
+        const data = await this._client.request("GET", "/api/v1/node");
         for (const item of data) {
-            yield new Node(item.node_id, item.owner_id, item.name, item.message, item.capacity, this._client);
+            yield new Node(item.node_id || item.nodeId, item.owner_id || item.ownerId, item.name, item.message, item.capacity, this._client);
         }
     }
-    async create_node(name, message = "", capacity = 100) {
-        const json_data = { name, message, capacity };
-        const data = await this._client._request("POST", "/api/v1/node", undefined, json_data);
-        return new Node(data.node_id, data.owner_id, data.name, data.message, data.capacity, this._client);
+    async createNode(name, message = "", capacity = 100) {
+        const jsonData = { name, message, capacity };
+        const data = await this._client.request("POST", "/api/v1/node", undefined, jsonData);
+        return new Node(data.node_id || data.nodeId, data.owner_id || data.ownerId, data.name, data.message, data.capacity, this._client);
     }
 }
 exports.Grid = Grid;
 class Node {
-    constructor(node_id, owner_id, name, message, capacity, client) {
-        this.node_id = node_id;
-        this.owner_id = owner_id;
+    constructor(nodeId, ownerId, name, message, capacity, client) {
+        this.nodeId = nodeId;
+        this.ownerId = ownerId;
         this.name = name;
         this.message = message;
         this.capacity = capacity;
         this._client = client;
     }
     async recv() {
-        const data = await this._client._request("GET", `/api/v1/node/${this.node_id}/recv`);
-        return data.map((item) => new Message(item.peer_id, item.round, item.message, item.score ?? null));
+        const data = await this._client.request("GET", `/api/v1/node/${this.nodeId}/recv`);
+        return data.map((item) => new Message(item.peer_id || item.peerId, item.round, item.message, item.score ?? null));
     }
     async send(replies) {
-        const json_data = replies.map((msg) => {
+        const jsonData = replies.map((msg) => {
             const obj = {
-                peer_id: msg.peer_id,
+                peer_id: msg.peerId,
                 message: msg.message,
                 round: msg.round,
             };
@@ -111,21 +100,21 @@ class Node {
             }
             return obj;
         });
-        const data = await this._client._request("POST", `/api/v1/node/${this.node_id}/send`, undefined, json_data);
-        return data.map((item) => new Status(item.peer_id, item.round, item.success));
+        const data = await this._client.request("POST", `/api/v1/node/${this.nodeId}/send`, undefined, jsonData);
+        return data.map((item) => new Message(item.peer_id || item.peerId, item.round, item.message, item.score ?? null));
     }
     async update(name, message, capacity) {
-        const json_data = {};
+        const jsonData = {};
         if (name !== undefined)
-            json_data.name = name;
+            jsonData.name = name;
         if (message !== undefined)
-            json_data.message = message;
+            jsonData.message = message;
         if (capacity !== undefined)
-            json_data.capacity = capacity;
-        if (Object.keys(json_data).length === 0) {
+            jsonData.capacity = capacity;
+        if (Object.keys(jsonData).length === 0) {
             return this;
         }
-        const data = await this._client._request("PUT", `/api/v1/node/${this.node_id}`, undefined, json_data);
+        const data = await this._client.request("PUT", `/api/v1/node/${this.nodeId}`, undefined, jsonData);
         // Update local attributes
         if (data.name !== undefined)
             this.name = data.name;
@@ -136,7 +125,7 @@ class Node {
         return this;
     }
     async delete() {
-        await this._client._request("DELETE", `/api/v1/node/${this.node_id}`);
+        await this._client.request("DELETE", `/api/v1/node/${this.nodeId}`);
     }
 }
 exports.Node = Node;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashgrid/sdk",
-  "version": "0.2.8",
+  "version": "0.3.1",
   "description": "Hashgrid TypeScript/JavaScript SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/client.ts

@@ -9,17 +9,17 @@ import {
 import { Grid } from "./resources";
 
 export class Hashgrid {
-  private api_key?: string;
-  private base_url: string;
+  private apiKey?: string;
+  private baseUrl: string;
   private timeout: number;
 
   constructor(
-    api_key?: string,
-    base_url: string = "https://dna.hashgrid.ai",
+    apiKey?: string,
+    baseUrl: string = "https://dna.hashgrid.ai",
     timeout: number = 30000
   ) {
-    this.api_key = api_key;
-    this.base_url = base_url.replace(/\/$/, "");
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
     this.timeout = timeout;
   }
 
@@ -28,23 +28,23 @@ export class Hashgrid {
       "Content-Type": "application/json",
       Accept: "application/json",
     };
-    if (this.api_key) {
-      headers["Authorization"] = `Bearer ${this.api_key}`;
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
     }
     return headers;
   }
 
-  async _request(
+  async request(
     method: string,
     endpoint: string,
     params?: Record<string, any>,
-    json_data?: any
+    jsonData?: any
   ): Promise<any> {
     let url: string;
     if (endpoint.startsWith("http://") || endpoint.startsWith("https://")) {
       url = endpoint;
     } else {
-      const base = this.base_url.endsWith("/") ? this.base_url.slice(0, -1) : this.base_url;
+      const base = this.baseUrl.endsWith("/") ? this.baseUrl.slice(0, -1) : this.baseUrl;
       const path = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
       url = `${base}${path}`;
     }
@@ -72,8 +72,8 @@ export class Hashgrid {
       signal: controller.signal,
     };
 
-    if (json_data !== undefined) {
-      options.body = JSON.stringify(json_data);
+    if (jsonData !== undefined) {
+      options.body = JSON.stringify(jsonData);
     }
 
     try {
@@ -148,15 +148,82 @@ export class Hashgrid {
     }
   }
 
+  async *stream(
+    method: string,
+    endpoint: string,
+    params?: Record<string, any>,
+    jsonData?: any
+  ): AsyncGenerator<string> {
+    const base = this.baseUrl.endsWith("/") ? this.baseUrl.slice(0, -1) : this.baseUrl;
+    const path = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+    let url = `${base}${path}`;
+
+    if (params) {
+      const searchParams = new URLSearchParams();
+      Object.entries(params).forEach(([key, value]) => {
+        searchParams.append(key, String(value));
+      });
+      url += `?${searchParams.toString()}`;
+    }
+
+    const headers = this._getHeaders();
+    headers["Accept"] = "text/event-stream";
+
+    const options: {
+      method: string;
+      headers: Record<string, string>;
+      body?: string;
+    } = {
+      method,
+      headers,
+    };
+
+    if (jsonData !== undefined) {
+      options.body = JSON.stringify(jsonData);
+    }
+
+    const response = await fetch(url, options);
+
+    if (!response.ok) {
+      throw new HashgridAPIError(`SSE connection failed: ${response.status}`);
+    }
+
+    const reader = response.body?.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    if (!reader) {
+      throw new HashgridAPIError("Response body is not readable");
+    }
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n\n");
+        buffer = lines.pop() || "";
+
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            yield line.slice(6).trim();
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+
   static async connect(
-    api_key?: string,
-    base_url: string = "https://dna.hashgrid.ai",
+    apiKey?: string,
+    baseUrl: string = "https://dna.hashgrid.ai",
     timeout: number = 30000
   ): Promise<Grid> {
-    const client = new Hashgrid(api_key, base_url, timeout);
-    const data = await client._request("GET", "/api/v1");
+    const client = new Hashgrid(apiKey, baseUrl, timeout);
+    const data = await client.request("GET", "/api/v1");
     const grid = new Grid(data.name, data.tick, client);
     return grid;
   }
 }
-

package/src/exceptions.ts

@@ -9,39 +9,38 @@ export class HashgridError extends Error {
 }
 
 export class HashgridAPIError extends HashgridError {
-  status_code?: number;
+  statusCode?: number;
   response?: Response;
 
-  constructor(message: string, status_code?: number, response?: Response) {
+  constructor(message: string, statusCode?: number, response?: Response) {
     super(message);
     this.name = "HashgridAPIError";
-    this.status_code = status_code;
+    this.statusCode = statusCode;
     this.response = response;
     Object.setPrototypeOf(this, HashgridAPIError.prototype);
   }
 }
 
 export class HashgridAuthenticationError extends HashgridAPIError {
-  constructor(message: string, status_code?: number, response?: Response) {
-    super(message, status_code, response);
+  constructor(message: string, statusCode?: number, response?: Response) {
+    super(message, statusCode, response);
     this.name = "HashgridAuthenticationError";
     Object.setPrototypeOf(this, HashgridAuthenticationError.prototype);
   }
 }
 
 export class HashgridNotFoundError extends HashgridAPIError {
-  constructor(message: string, status_code?: number, response?: Response) {
-    super(message, status_code, response);
+  constructor(message: string, statusCode?: number, response?: Response) {
+    super(message, statusCode, response);
     this.name = "HashgridNotFoundError";
     Object.setPrototypeOf(this, HashgridNotFoundError.prototype);
   }
 }
 
 export class HashgridValidationError extends HashgridAPIError {
-  constructor(message: string, status_code?: number, response?: Response) {
-    super(message, status_code, response);
+  constructor(message: string, statusCode?: number, response?: Response) {
+    super(message, statusCode, response);
     this.name = "HashgridValidationError";
     Object.setPrototypeOf(this, HashgridValidationError.prototype);
   }
 }
-

package/src/resources.ts

@@ -3,74 +3,74 @@
 import { Hashgrid } from "./client";
 
 export class User {
-  user_id: string;
+  userId: string;
   name: string;
-  is_superuser: boolean;
-  quota_id: string;
+  isSuperuser: boolean;
+  quotaId: string;
 
   constructor(
-    user_id: string,
+    userId: string,
     name: string,
-    is_superuser: boolean,
-    quota_id: string
+    isSuperuser: boolean,
+    quotaId: string
   ) {
-    this.user_id = user_id;
+    this.userId = userId;
     this.name = name;
-    this.is_superuser = is_superuser;
-    this.quota_id = quota_id;
+    this.isSuperuser = isSuperuser;
+    this.quotaId = quotaId;
   }
 }
 
 export class Quota {
-  quota_id: string;
+  quotaId: string;
   name: string;
   capacity: number;
 
-  constructor(quota_id: string, name: string, capacity: number) {
-    this.quota_id = quota_id;
+  constructor(quotaId: string, name: string, capacity: number) {
+    this.quotaId = quotaId;
     this.name = name;
     this.capacity = capacity;
   }
 }
 
 export class Edge {
-  node_id: string;
-  peer_id: string;
-  recv_message: string;
-  send_message: string | null;
+  nodeId: string;
+  peerId: string;
+  recvMessage: string;
+  sendMessage: string | null;
   score: number | null;
   round: number;
 
   constructor(
-    node_id: string,
-    peer_id: string,
-    recv_message: string,
-    send_message: string | null,
+    nodeId: string,
+    peerId: string,
+    recvMessage: string,
+    sendMessage: string | null,
     score: number | null,
     round: number
   ) {
-    this.node_id = node_id;
-    this.peer_id = peer_id;
-    this.recv_message = recv_message;
-    this.send_message = send_message;
+    this.nodeId = nodeId;
+    this.peerId = peerId;
+    this.recvMessage = recvMessage;
+    this.sendMessage = sendMessage;
     this.score = score;
     this.round = round;
   }
 }
 
 export class Message {
-  peer_id: string;
+  peerId: string;
   round: number;
   message: string;
   score: number | null;
 
   constructor(
-    peer_id: string,
+    peerId: string,
     round: number,
     message: string = "",
     score: number | null = null
   ) {
-    this.peer_id = peer_id;
+    this.peerId = peerId;
     this.round = round;
     this.message = message;
     this.score = score;
@@ -78,12 +78,12 @@ export class Message {
 }
 
 export class Status {
-  peer_id: string;
+  peerId: string;
   round: number;
   success: boolean;
 
-  constructor(peer_id: string, round: number, success: boolean) {
-    this.peer_id = peer_id;
+  constructor(peerId: string, round: number, success: boolean) {
+    this.peerId = peerId;
     this.round = round;
     this.success = success;
   }
@@ -100,34 +100,22 @@ export class Grid {
     this._client = client;
   }
 
-  async *listen(poll_interval: number = 30000): AsyncGenerator<number> {
-    let last_tick = -1;
-    while (true) {
-      try {
-        const data = await this._client._request("GET", "/api/v1");
-        this.name = data.name;
-        this.tick = data.tick;
-        const current_tick = this.tick;
-
-        if (current_tick !== last_tick) {
-          yield current_tick;
-          last_tick = current_tick;
-        }
-
-        await new Promise((resolve) => setTimeout(resolve, poll_interval));
-      } catch (error) {
-        console.warn(`Error while listening for ticks: ${error}`);
-        await new Promise((resolve) => setTimeout(resolve, poll_interval * 2));
+  async *listen(): AsyncGenerator<number> {
+    for await (const data of this._client.stream("GET", "/api/v1/listen")) {
+      const tick = parseInt(data, 10);
+      if (!isNaN(tick) && tick !== this.tick) {
+        this.tick = tick;
+        yield tick;
       }
     }
   }
 
   async *nodes(): AsyncGenerator<Node> {
-    const data = await this._client._request("GET", "/api/v1/node");
+    const data = await this._client.request("GET", "/api/v1/node");
     for (const item of data) {
       yield new Node(
-        item.node_id,
-        item.owner_id,
+        item.node_id || item.nodeId,
+        item.owner_id || item.ownerId,
         item.name,
         item.message,
         item.capacity,
@@ -136,16 +124,16 @@ export class Grid {
     }
   }
 
-  async create_node(
+  async createNode(
     name: string,
     message: string = "",
     capacity: number = 100
   ): Promise<Node> {
-    const json_data = { name, message, capacity };
-    const data = await this._client._request("POST", "/api/v1/node", undefined, json_data);
+    const jsonData = { name, message, capacity };
+    const data = await this._client.request("POST", "/api/v1/node", undefined, jsonData);
     return new Node(
-      data.node_id,
-      data.owner_id,
+      data.node_id || data.nodeId,
+      data.owner_id || data.ownerId,
       data.name,
       data.message,
       data.capacity,
@@ -155,23 +143,23 @@ export class Grid {
 }
 
 export class Node {
-  node_id: string;
-  owner_id: string;
+  nodeId: string;
+  ownerId: string;
   name: string;
   message: string;
   capacity: number;
   private _client: Hashgrid;
 
   constructor(
-    node_id: string,
-    owner_id: string,
+    nodeId: string,
+    ownerId: string,
     name: string,
     message: string,
     capacity: number,
     client: Hashgrid
   ) {
-    this.node_id = node_id;
-    this.owner_id = owner_id;
+    this.nodeId = nodeId;
+    this.ownerId = ownerId;
     this.name = name;
     this.message = message;
     this.capacity = capacity;
@@ -179,20 +167,20 @@ export class Node {
   }
 
   async recv(): Promise<Message[]> {
-    const data = await this._client._request(
+    const data = await this._client.request(
       "GET",
-      `/api/v1/node/${this.node_id}/recv`
+      `/api/v1/node/${this.nodeId}/recv`
     );
     return data.map(
       (item: any) =>
-        new Message(item.peer_id, item.round, item.message, item.score ?? null)
+        new Message(item.peer_id || item.peerId, item.round, item.message, item.score ?? null)
     );
   }
 
-  async send(replies: Message[]): Promise<Status[]> {
-    const json_data = replies.map((msg) => {
+  async send(replies: Message[]): Promise<Message[]> {
+    const jsonData = replies.map((msg) => {
       const obj: any = {
-        peer_id: msg.peer_id,
+        peer_id: msg.peerId,
         message: msg.message,
         round: msg.round,
       };
@@ -201,13 +189,16 @@ export class Node {
       }
       return obj;
     });
-    const data = await this._client._request(
+    const data = await this._client.request(
       "POST",
-      `/api/v1/node/${this.node_id}/send`,
+      `/api/v1/node/${this.nodeId}/send`,
       undefined,
-      json_data
+      jsonData
+    );
+    return data.map(
+      (item: any) =>
+        new Message(item.peer_id || item.peerId, item.round, item.message, item.score ?? null)
     );
-    return data.map((item: any) => new Status(item.peer_id, item.round, item.success));
   }
 
   async update(
@@ -215,20 +206,20 @@ export class Node {
     message?: string,
     capacity?: number
   ): Promise<Node> {
-    const json_data: any = {};
-    if (name !== undefined) json_data.name = name;
-    if (message !== undefined) json_data.message = message;
-    if (capacity !== undefined) json_data.capacity = capacity;
+    const jsonData: any = {};
+    if (name !== undefined) jsonData.name = name;
+    if (message !== undefined) jsonData.message = message;
+    if (capacity !== undefined) jsonData.capacity = capacity;
 
-    if (Object.keys(json_data).length === 0) {
+    if (Object.keys(jsonData).length === 0) {
       return this;
     }
 
-    const data = await this._client._request(
+    const data = await this._client.request(
       "PUT",
-      `/api/v1/node/${this.node_id}`,
+      `/api/v1/node/${this.nodeId}`,
       undefined,
-      json_data
+      jsonData
     );
 
     // Update local attributes
@@ -240,7 +231,6 @@ export class Node {
   }
 
   async delete(): Promise<void> {
-    await this._client._request("DELETE", `/api/v1/node/${this.node_id}`);
+    await this._client.request("DELETE", `/api/v1/node/${this.nodeId}`);
   }
 }
-