@hashgrid/sdk 0.1.0

package/README.md

@@ -0,0 +1,88 @@
+# Hashgrid Client
+
+TypeScript/JavaScript SDK for the Hashgrid DNA Protocol API.
+
+## Installation
+
+```bash
+npm install @hashgrid/sdk
+```
+
+## Quick Start
+
+```typescript
+import { Hashgrid, Message } from "@hashgrid/sdk";
+
+async function main() {
+  // Connect to grid
+  const grid = await Hashgrid.connect("your-api-key");
+  
+  // Listen for ticks and process messages
+  for await (const tick of grid.listen()) {
+    for await (const node of grid.nodes()) {
+      const messages = await node.recv();
+      if (messages.length === 0) {
+        continue;
+      }
+      const replies = messages.map((msg) =>
+        new Message(
+          msg.peer_id,
+          "Hello, fellow grid peer!",
+          msg.round,
+          0.9
+        )
+      );
+      await node.send(replies);
+    }
+  }
+}
+
+main();
+```
+
+## Resources
+
+The SDK provides the following resources:
+
+- **`Grid`** - Grid connection with `listen()` and `nodes()` methods
+- **`Node`** - Node with `recv()`, `send()`, `update()`, and `delete()` methods
+- **`Edge`** - Edge data model
+- **`User`** - User data model
+- **`Quota`** - Quota data model
+- **`Message`** - Message for recv/send operations
+- **`Status`** - Status response from send operations
+
+## Examples
+
+See the `examples/` directory for example implementations.
+
+## Error Handling
+
+```typescript
+import {
+  HashgridError,
+  HashgridAPIError,
+  HashgridAuthenticationError,
+  HashgridNotFoundError,
+  HashgridValidationError,
+} from "@hashgrid/sdk";
+
+try {
+  const grid = await Hashgrid.connect("invalid-key");
+} catch (error) {
+  if (error instanceof HashgridAuthenticationError) {
+    console.log("Authentication failed");
+  } else if (error instanceof HashgridAPIError) {
+    console.log(`API error: ${error.message}`);
+  }
+}
+```
+
+## API Reference
+
+For detailed API documentation, see the official Hashgrid DNA documentation.
+
+## License
+
+MIT
+

package/dist/client.d.ts

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

package/dist/client.js

@@ -0,0 +1,114 @@
+"use strict";
+/** Main Hashgrid client class. */
+Object.defineProperty(exports, "__esModule", { value: true });
+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(/\/$/, "");
+        this.timeout = timeout;
+    }
+    _getHeaders() {
+        const headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+        };
+        if (this.api_key) {
+            headers["Authorization"] = `Bearer ${this.api_key}`;
+        }
+        return headers;
+    }
+    async _request(method, endpoint, params, json_data) {
+        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 path = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+            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();
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const options = {
+            method,
+            headers,
+            signal: controller.signal,
+        };
+        if (json_data !== undefined) {
+            options.body = JSON.stringify(json_data);
+        }
+        try {
+            const response = await fetch(url, options);
+            clearTimeout(timeoutId);
+            return await this._handleResponse(response);
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error.name === "AbortError") {
+                throw new exceptions_1.HashgridAPIError(`Request timeout after ${this.timeout}ms`);
+            }
+            throw new exceptions_1.HashgridAPIError(`Request failed: ${error.message}`);
+        }
+    }
+    async _handleResponse(response) {
+        try {
+            if (!response.ok) {
+                if (response.status === 401) {
+                    throw new exceptions_1.HashgridAuthenticationError("Authentication failed. Check your API key.", response.status, response);
+                }
+                else if (response.status === 404) {
+                    throw new exceptions_1.HashgridNotFoundError("Resource not found", response.status, response);
+                }
+                else if (response.status === 422) {
+                    const errorData = response.headers.get("content-type")?.includes("application/json")
+                        ? await response.json().catch(() => ({}))
+                        : {};
+                    throw new exceptions_1.HashgridValidationError(errorData.message || "Validation error", response.status, response);
+                }
+                else {
+                    const errorData = response.headers.get("content-type")?.includes("application/json")
+                        ? await response.json().catch(() => ({}))
+                        : {};
+                    throw new exceptions_1.HashgridAPIError(errorData.message || `API error: ${response.status}`, response.status, response);
+                }
+            }
+            if (!response.body) {
+                return {};
+            }
+            const contentType = response.headers.get("content-type");
+            if (contentType?.includes("application/json")) {
+                return await response.json();
+            }
+            else {
+                return { content: await response.text() };
+            }
+        }
+        catch (error) {
+            if (error instanceof exceptions_1.HashgridAPIError ||
+                error instanceof exceptions_1.HashgridAuthenticationError ||
+                error instanceof exceptions_1.HashgridNotFoundError ||
+                error instanceof exceptions_1.HashgridValidationError) {
+                throw error;
+            }
+            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");
+        const grid = new resources_1.Grid(data.name, data.tick, client);
+        return grid;
+    }
+}
+exports.Hashgrid = Hashgrid;

package/dist/exceptions.d.ts

@@ -0,0 +1,18 @@
+/** Custom exceptions for the Hashgrid client. */
+export declare class HashgridError extends Error {
+    constructor(message: string);
+}
+export declare class HashgridAPIError extends HashgridError {
+    status_code?: number;
+    response?: Response;
+    constructor(message: string, status_code?: number, response?: Response);
+}
+export declare class HashgridAuthenticationError extends HashgridAPIError {
+    constructor(message: string, status_code?: number, response?: Response);
+}
+export declare class HashgridNotFoundError extends HashgridAPIError {
+    constructor(message: string, status_code?: number, response?: Response);
+}
+export declare class HashgridValidationError extends HashgridAPIError {
+    constructor(message: string, status_code?: number, response?: Response);
+}

package/dist/exceptions.js

@@ -0,0 +1,46 @@
+"use strict";
+/** Custom exceptions for the Hashgrid client. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashgridValidationError = exports.HashgridNotFoundError = exports.HashgridAuthenticationError = exports.HashgridAPIError = exports.HashgridError = void 0;
+class HashgridError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "HashgridError";
+        Object.setPrototypeOf(this, HashgridError.prototype);
+    }
+}
+exports.HashgridError = HashgridError;
+class HashgridAPIError extends HashgridError {
+    constructor(message, status_code, response) {
+        super(message);
+        this.name = "HashgridAPIError";
+        this.status_code = status_code;
+        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);
+        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);
+        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);
+        this.name = "HashgridValidationError";
+        Object.setPrototypeOf(this, HashgridValidationError.prototype);
+    }
+}
+exports.HashgridValidationError = HashgridValidationError;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hashgrid Client - TypeScript/JavaScript SDK
+ */
+export { Hashgrid } from "./client";
+export { HashgridError, HashgridAPIError, HashgridAuthenticationError, HashgridNotFoundError, HashgridValidationError, } from "./exceptions";
+export { Grid, User, Quota, Node, Edge, Message, Status, } from "./resources";

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Hashgrid Client - TypeScript/JavaScript SDK
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Status = exports.Message = exports.Edge = exports.Node = exports.Quota = exports.User = exports.Grid = exports.HashgridValidationError = exports.HashgridNotFoundError = exports.HashgridAuthenticationError = exports.HashgridAPIError = exports.HashgridError = exports.Hashgrid = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "Hashgrid", { enumerable: true, get: function () { return client_1.Hashgrid; } });
+var exceptions_1 = require("./exceptions");
+Object.defineProperty(exports, "HashgridError", { enumerable: true, get: function () { return exceptions_1.HashgridError; } });
+Object.defineProperty(exports, "HashgridAPIError", { enumerable: true, get: function () { return exceptions_1.HashgridAPIError; } });
+Object.defineProperty(exports, "HashgridAuthenticationError", { enumerable: true, get: function () { return exceptions_1.HashgridAuthenticationError; } });
+Object.defineProperty(exports, "HashgridNotFoundError", { enumerable: true, get: function () { return exceptions_1.HashgridNotFoundError; } });
+Object.defineProperty(exports, "HashgridValidationError", { enumerable: true, get: function () { return exceptions_1.HashgridValidationError; } });
+var resources_1 = require("./resources");
+Object.defineProperty(exports, "Grid", { enumerable: true, get: function () { return resources_1.Grid; } });
+Object.defineProperty(exports, "User", { enumerable: true, get: function () { return resources_1.User; } });
+Object.defineProperty(exports, "Quota", { enumerable: true, get: function () { return resources_1.Quota; } });
+Object.defineProperty(exports, "Node", { enumerable: true, get: function () { return resources_1.Node; } });
+Object.defineProperty(exports, "Edge", { enumerable: true, get: function () { return resources_1.Edge; } });
+Object.defineProperty(exports, "Message", { enumerable: true, get: function () { return resources_1.Message; } });
+Object.defineProperty(exports, "Status", { enumerable: true, get: function () { return resources_1.Status; } });

package/dist/resources.d.ts

@@ -0,0 +1,58 @@
+/** Hashgrid API resources. */
+import { Hashgrid } from "./client";
+export declare class User {
+    user_id: string;
+    name: string;
+    is_superuser: boolean;
+    quota_id: string;
+    constructor(user_id: string, name: string, is_superuser: boolean, quota_id: string);
+}
+export declare class Quota {
+    quota_id: string;
+    name: string;
+    capacity: number;
+    constructor(quota_id: string, name: string, capacity: number);
+}
+export declare class Edge {
+    node_id: string;
+    peer_id: string;
+    recv_message: string;
+    send_message: 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);
+}
+export declare class Message {
+    peer_id: string;
+    message: string;
+    round: number;
+    score: number | null;
+    constructor(peer_id: string, message: string, round: number, score?: number | null);
+}
+export declare class Status {
+    peer_id: string;
+    success: boolean;
+    constructor(peer_id: string, 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>;
+    nodes(): AsyncGenerator<Node>;
+    create_node(name: string, message?: string, capacity?: number): Promise<Node>;
+}
+export declare class Node {
+    node_id: string;
+    owner_id: string;
+    name: string;
+    message: string;
+    capacity: number;
+    private _client;
+    constructor(node_id: string, owner_id: string, name: string, message: string, capacity: number, client: Hashgrid);
+    recv(): Promise<Message[]>;
+    send(replies: Message[]): Promise<Status[]>;
+    update(name?: string, message?: string, capacity?: number): Promise<Node>;
+    delete(): Promise<void>;
+}

package/dist/resources.js

@@ -0,0 +1,141 @@
+"use strict";
+/** Hashgrid API resources. */
+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;
+        this.name = name;
+        this.is_superuser = is_superuser;
+        this.quota_id = quota_id;
+    }
+}
+exports.User = User;
+class Quota {
+    constructor(quota_id, name, capacity) {
+        this.quota_id = quota_id;
+        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;
+        this.score = score;
+        this.round = round;
+    }
+}
+exports.Edge = Edge;
+class Message {
+    constructor(peer_id, message, round, score = null) {
+        this.peer_id = peer_id;
+        this.message = message;
+        this.round = round;
+        this.score = score;
+    }
+}
+exports.Message = Message;
+class Status {
+    constructor(peer_id, success) {
+        this.peer_id = peer_id;
+        this.success = success;
+    }
+}
+exports.Status = Status;
+class Grid {
+    constructor(name, tick, client) {
+        this.name = name;
+        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 *nodes() {
+        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);
+        }
+    }
+    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);
+    }
+}
+exports.Grid = Grid;
+class Node {
+    constructor(node_id, owner_id, name, message, capacity, client) {
+        this.node_id = node_id;
+        this.owner_id = owner_id;
+        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.message, item.round, item.score ?? null));
+    }
+    async send(replies) {
+        const json_data = replies.map((msg) => {
+            const obj = {
+                peer_id: msg.peer_id,
+                message: msg.message,
+                round: msg.round,
+            };
+            if (msg.score !== null) {
+                obj.score = msg.score;
+            }
+            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.success));
+    }
+    async update(name, message, capacity) {
+        const json_data = {};
+        if (name !== undefined)
+            json_data.name = name;
+        if (message !== undefined)
+            json_data.message = message;
+        if (capacity !== undefined)
+            json_data.capacity = capacity;
+        if (Object.keys(json_data).length === 0) {
+            return this;
+        }
+        const data = await this._client._request("PUT", `/api/v1/node/${this.node_id}`, undefined, json_data);
+        // Update local attributes
+        if (data.name !== undefined)
+            this.name = data.name;
+        if (data.message !== undefined)
+            this.message = data.message;
+        if (data.capacity !== undefined)
+            this.capacity = data.capacity;
+        return this;
+    }
+    async delete() {
+        await this._client._request("DELETE", `/api/v1/node/${this.node_id}`);
+    }
+}
+exports.Node = Node;

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@hashgrid/sdk",
+  "version": "0.1.0",
+  "description": "Hashgrid TypeScript/JavaScript SDK",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "browser": {
+    "./dist/index.js": "./dist/index.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hashgrid-labs/sdk.git"
+  },
+  "keywords": [
+    "hashgrid",
+    "client",
+    "sdk"
+  ],
+  "author": "Hashgrid",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/hashgrid-labs/sdk/issues"
+  },
+  "homepage": "https://github.com/hashgrid-labs/sdk#readme",
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/client.ts

@@ -0,0 +1,162 @@
+/** Main Hashgrid client class. */
+
+import {
+  HashgridAPIError,
+  HashgridAuthenticationError,
+  HashgridNotFoundError,
+  HashgridValidationError,
+} from "./exceptions";
+import { Grid } from "./resources";
+
+export class Hashgrid {
+  private api_key?: string;
+  private base_url: string;
+  private timeout: number;
+
+  constructor(
+    api_key?: string,
+    base_url: string = "https://dna.hashgrid.ai",
+    timeout: number = 30000
+  ) {
+    this.api_key = api_key;
+    this.base_url = base_url.replace(/\/$/, "");
+    this.timeout = timeout;
+  }
+
+  private _getHeaders(): Record<string, string> {
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    };
+    if (this.api_key) {
+      headers["Authorization"] = `Bearer ${this.api_key}`;
+    }
+    return headers;
+  }
+
+  async _request(
+    method: string,
+    endpoint: string,
+    params?: Record<string, any>,
+    json_data?: 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 path = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+      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();
+    const controller = new AbortController();
+    const timeoutId: ReturnType<typeof setTimeout> = setTimeout(() => controller.abort(), this.timeout);
+
+    const options: {
+      method: string;
+      headers: Record<string, string>;
+      signal: AbortSignal;
+      body?: string;
+    } = {
+      method,
+      headers,
+      signal: controller.signal,
+    };
+
+    if (json_data !== undefined) {
+      options.body = JSON.stringify(json_data);
+    }
+
+    try {
+      const response = await fetch(url, options);
+      clearTimeout(timeoutId);
+      return await this._handleResponse(response);
+    } catch (error: any) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        throw new HashgridAPIError(`Request timeout after ${this.timeout}ms`);
+      }
+      throw new HashgridAPIError(`Request failed: ${error.message}`);
+    }
+  }
+
+  async _handleResponse(response: Response): Promise<any> {
+    try {
+      if (!response.ok) {
+        if (response.status === 401) {
+          throw new HashgridAuthenticationError(
+            "Authentication failed. Check your API key.",
+            response.status,
+            response
+          );
+        } else if (response.status === 404) {
+          throw new HashgridNotFoundError(
+            "Resource not found",
+            response.status,
+            response
+          );
+        } else if (response.status === 422) {
+          const errorData = response.headers.get("content-type")?.includes("application/json")
+            ? await response.json().catch(() => ({}))
+            : {};
+          throw new HashgridValidationError(
+            errorData.message || "Validation error",
+            response.status,
+            response
+          );
+        } else {
+          const errorData = response.headers.get("content-type")?.includes("application/json")
+            ? await response.json().catch(() => ({}))
+            : {};
+          throw new HashgridAPIError(
+            errorData.message || `API error: ${response.status}`,
+            response.status,
+            response
+          );
+        }
+      }
+
+      if (!response.body) {
+        return {};
+      }
+
+      const contentType = response.headers.get("content-type");
+      if (contentType?.includes("application/json")) {
+        return await response.json();
+      } else {
+        return { content: await response.text() };
+      }
+    } catch (error) {
+      if (
+        error instanceof HashgridAPIError ||
+        error instanceof HashgridAuthenticationError ||
+        error instanceof HashgridNotFoundError ||
+        error instanceof HashgridValidationError
+      ) {
+        throw error;
+      }
+      throw new HashgridAPIError(`Response handling failed: ${error}`);
+    }
+  }
+
+  static async connect(
+    api_key?: string,
+    base_url: 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 grid = new Grid(data.name, data.tick, client);
+    return grid;
+  }
+}
+

package/src/exceptions.ts

@@ -0,0 +1,47 @@
+/** Custom exceptions for the Hashgrid client. */
+
+export class HashgridError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "HashgridError";
+    Object.setPrototypeOf(this, HashgridError.prototype);
+  }
+}
+
+export class HashgridAPIError extends HashgridError {
+  status_code?: number;
+  response?: Response;
+
+  constructor(message: string, status_code?: number, response?: Response) {
+    super(message);
+    this.name = "HashgridAPIError";
+    this.status_code = status_code;
+    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);
+    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);
+    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);
+    this.name = "HashgridValidationError";
+    Object.setPrototypeOf(this, HashgridValidationError.prototype);
+  }
+}
+

package/src/index.ts

@@ -0,0 +1,22 @@
+/**
+ * Hashgrid Client - TypeScript/JavaScript SDK
+ */
+
+export { Hashgrid } from "./client";
+export {
+  HashgridError,
+  HashgridAPIError,
+  HashgridAuthenticationError,
+  HashgridNotFoundError,
+  HashgridValidationError,
+} from "./exceptions";
+export {
+  Grid,
+  User,
+  Quota,
+  Node,
+  Edge,
+  Message,
+  Status,
+} from "./resources";
+

package/src/resources.ts

@@ -0,0 +1,244 @@
+/** Hashgrid API resources. */
+
+import { Hashgrid } from "./client";
+
+export class User {
+  user_id: string;
+  name: string;
+  is_superuser: boolean;
+  quota_id: string;
+
+  constructor(
+    user_id: string,
+    name: string,
+    is_superuser: boolean,
+    quota_id: string
+  ) {
+    this.user_id = user_id;
+    this.name = name;
+    this.is_superuser = is_superuser;
+    this.quota_id = quota_id;
+  }
+}
+
+export class Quota {
+  quota_id: string;
+  name: string;
+  capacity: number;
+
+  constructor(quota_id: string, name: string, capacity: number) {
+    this.quota_id = quota_id;
+    this.name = name;
+    this.capacity = capacity;
+  }
+}
+
+export class Edge {
+  node_id: string;
+  peer_id: string;
+  recv_message: string;
+  send_message: 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
+  ) {
+    this.node_id = node_id;
+    this.peer_id = peer_id;
+    this.recv_message = recv_message;
+    this.send_message = send_message;
+    this.score = score;
+    this.round = round;
+  }
+}
+
+export class Message {
+  peer_id: string;
+  message: string;
+  round: number;
+  score: number | null;
+
+  constructor(
+    peer_id: string,
+    message: string,
+    round: number,
+    score: number | null = null
+  ) {
+    this.peer_id = peer_id;
+    this.message = message;
+    this.round = round;
+    this.score = score;
+  }
+}
+
+export class Status {
+  peer_id: string;
+  success: boolean;
+
+  constructor(peer_id: string, success: boolean) {
+    this.peer_id = peer_id;
+    this.success = success;
+  }
+}
+
+export class Grid {
+  name: string;
+  tick: number;
+  private _client: Hashgrid;
+
+  constructor(name: string, tick: number, client: Hashgrid) {
+    this.name = name;
+    this.tick = tick;
+    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 *nodes(): AsyncGenerator<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
+      );
+    }
+  }
+
+  async create_node(
+    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);
+    return new Node(
+      data.node_id,
+      data.owner_id,
+      data.name,
+      data.message,
+      data.capacity,
+      this._client
+    );
+  }
+}
+
+export class Node {
+  node_id: string;
+  owner_id: string;
+  name: string;
+  message: string;
+  capacity: number;
+  private _client: Hashgrid;
+
+  constructor(
+    node_id: string,
+    owner_id: string,
+    name: string,
+    message: string,
+    capacity: number,
+    client: Hashgrid
+  ) {
+    this.node_id = node_id;
+    this.owner_id = owner_id;
+    this.name = name;
+    this.message = message;
+    this.capacity = capacity;
+    this._client = client;
+  }
+
+  async recv(): Promise<Message[]> {
+    const data = await this._client._request(
+      "GET",
+      `/api/v1/node/${this.node_id}/recv`
+    );
+    return data.map(
+      (item: any) =>
+        new Message(item.peer_id, item.message, item.round, item.score ?? null)
+    );
+  }
+
+  async send(replies: Message[]): Promise<Status[]> {
+    const json_data = replies.map((msg) => {
+      const obj: any = {
+        peer_id: msg.peer_id,
+        message: msg.message,
+        round: msg.round,
+      };
+      if (msg.score !== null) {
+        obj.score = msg.score;
+      }
+      return obj;
+    });
+    const data = await this._client._request(
+      "POST",
+      `/api/v1/node/${this.node_id}/send`,
+      undefined,
+      json_data
+    );
+    return data.map((item: any) => new Status(item.peer_id, item.success));
+  }
+
+  async update(
+    name?: string,
+    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;
+
+    if (Object.keys(json_data).length === 0) {
+      return this;
+    }
+
+    const data = await this._client._request(
+      "PUT",
+      `/api/v1/node/${this.node_id}`,
+      undefined,
+      json_data
+    );
+
+    // Update local attributes
+    if (data.name !== undefined) this.name = data.name;
+    if (data.message !== undefined) this.message = data.message;
+    if (data.capacity !== undefined) this.capacity = data.capacity;
+
+    return this;
+  }
+
+  async delete(): Promise<void> {
+    await this._client._request("DELETE", `/api/v1/node/${this.node_id}`);
+  }
+}
+

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": [
+      "ES2020",
+      "DOM"
+    ],
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node"
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}