@debros/network-ts-sdk 0.1.4

package/dist/index.js

@@ -0,0 +1,826 @@
+// src/errors.ts
+var SDKError = class _SDKError extends Error {
+  constructor(message, httpStatus = 500, code = "SDK_ERROR", details = {}) {
+    super(message);
+    this.name = "SDKError";
+    this.httpStatus = httpStatus;
+    this.code = code;
+    this.details = details;
+  }
+  static fromResponse(status, body, message) {
+    const errorMsg = message || body?.error || `HTTP ${status}`;
+    const code = body?.code || `HTTP_${status}`;
+    return new _SDKError(errorMsg, status, code, body);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      httpStatus: this.httpStatus,
+      code: this.code,
+      details: this.details
+    };
+  }
+};
+
+// src/core/http.ts
+var HttpClient = class {
+  constructor(config) {
+    this.baseURL = config.baseURL.replace(/\/$/, "");
+    this.timeout = config.timeout ?? 3e4;
+    this.maxRetries = config.maxRetries ?? 3;
+    this.retryDelayMs = config.retryDelayMs ?? 1e3;
+    this.fetch = config.fetch ?? globalThis.fetch;
+  }
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
+    this.jwt = void 0;
+  }
+  setJwt(jwt) {
+    this.jwt = jwt;
+    this.apiKey = void 0;
+  }
+  getAuthHeaders() {
+    const headers = {};
+    if (this.jwt) {
+      headers["Authorization"] = `Bearer ${this.jwt}`;
+    } else if (this.apiKey) {
+      headers["X-API-Key"] = this.apiKey;
+    }
+    return headers;
+  }
+  getAuthToken() {
+    return this.jwt || this.apiKey;
+  }
+  async request(method, path, options = {}) {
+    const url = new URL(this.baseURL + path);
+    if (options.query) {
+      Object.entries(options.query).forEach(([key, value]) => {
+        url.searchParams.append(key, String(value));
+      });
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.getAuthHeaders(),
+      ...options.headers
+    };
+    const fetchOptions = {
+      method,
+      headers,
+      signal: AbortSignal.timeout(this.timeout)
+    };
+    if (options.body !== void 0) {
+      fetchOptions.body = JSON.stringify(options.body);
+    }
+    return this.requestWithRetry(url.toString(), fetchOptions);
+  }
+  async requestWithRetry(url, options, attempt = 0) {
+    try {
+      const response = await this.fetch(url, options);
+      if (!response.ok) {
+        let body;
+        try {
+          body = await response.json();
+        } catch {
+          body = { error: response.statusText };
+        }
+        throw SDKError.fromResponse(response.status, body);
+      }
+      const contentType = response.headers.get("content-type");
+      if (contentType?.includes("application/json")) {
+        return response.json();
+      }
+      return response.text();
+    } catch (error) {
+      if (error instanceof SDKError && attempt < this.maxRetries && [408, 429, 500, 502, 503, 504].includes(error.httpStatus)) {
+        await new Promise(
+          (resolve) => setTimeout(resolve, this.retryDelayMs * (attempt + 1))
+        );
+        return this.requestWithRetry(url, options, attempt + 1);
+      }
+      throw error;
+    }
+  }
+  async get(path, options) {
+    return this.request("GET", path, options);
+  }
+  async post(path, body, options) {
+    return this.request("POST", path, { ...options, body });
+  }
+  async put(path, body, options) {
+    return this.request("PUT", path, { ...options, body });
+  }
+  async delete(path, options) {
+    return this.request("DELETE", path, options);
+  }
+  getToken() {
+    return this.getAuthToken();
+  }
+};
+
+// src/auth/types.ts
+var MemoryStorage = class {
+  constructor() {
+    this.storage = /* @__PURE__ */ new Map();
+  }
+  async get(key) {
+    return this.storage.get(key) ?? null;
+  }
+  async set(key, value) {
+    this.storage.set(key, value);
+  }
+  async clear() {
+    this.storage.clear();
+  }
+};
+var LocalStorageAdapter = class {
+  constructor() {
+    this.prefix = "@network/sdk:";
+  }
+  async get(key) {
+    if (typeof globalThis !== "undefined" && globalThis.localStorage) {
+      return globalThis.localStorage.getItem(this.prefix + key);
+    }
+    return null;
+  }
+  async set(key, value) {
+    if (typeof globalThis !== "undefined" && globalThis.localStorage) {
+      globalThis.localStorage.setItem(this.prefix + key, value);
+    }
+  }
+  async clear() {
+    if (typeof globalThis !== "undefined" && globalThis.localStorage) {
+      const keysToDelete = [];
+      for (let i = 0; i < globalThis.localStorage.length; i++) {
+        const key = globalThis.localStorage.key(i);
+        if (key?.startsWith(this.prefix)) {
+          keysToDelete.push(key);
+        }
+      }
+      keysToDelete.forEach((key) => globalThis.localStorage.removeItem(key));
+    }
+  }
+};
+
+// src/auth/client.ts
+var AuthClient = class {
+  constructor(config) {
+    this.httpClient = config.httpClient;
+    this.storage = config.storage ?? new MemoryStorage();
+    this.currentApiKey = config.apiKey;
+    this.currentJwt = config.jwt;
+    if (this.currentApiKey) {
+      this.httpClient.setApiKey(this.currentApiKey);
+    }
+    if (this.currentJwt) {
+      this.httpClient.setJwt(this.currentJwt);
+    }
+  }
+  setApiKey(apiKey) {
+    this.currentApiKey = apiKey;
+    this.currentJwt = void 0;
+    this.httpClient.setApiKey(apiKey);
+    this.storage.set("apiKey", apiKey);
+  }
+  setJwt(jwt) {
+    this.currentJwt = jwt;
+    this.currentApiKey = void 0;
+    this.httpClient.setJwt(jwt);
+    this.storage.set("jwt", jwt);
+  }
+  getToken() {
+    return this.httpClient.getToken();
+  }
+  async whoami() {
+    try {
+      const response = await this.httpClient.get("/v1/auth/whoami");
+      return response;
+    } catch {
+      return { authenticated: false };
+    }
+  }
+  async refresh() {
+    const response = await this.httpClient.post(
+      "/v1/auth/refresh"
+    );
+    const token = response.token;
+    this.setJwt(token);
+    return token;
+  }
+  async logout() {
+    if (this.currentJwt) {
+      try {
+        await this.httpClient.post("/v1/auth/logout", { all: true });
+      } catch (error) {
+        console.warn("Server-side logout failed, continuing with local cleanup:", error);
+      }
+    }
+    this.currentApiKey = void 0;
+    this.currentJwt = void 0;
+    this.httpClient.setApiKey(void 0);
+    this.httpClient.setJwt(void 0);
+    await this.storage.clear();
+  }
+  async clear() {
+    this.currentApiKey = void 0;
+    this.currentJwt = void 0;
+    this.httpClient.setApiKey(void 0);
+    this.httpClient.setJwt(void 0);
+    await this.storage.clear();
+  }
+};
+
+// src/db/qb.ts
+var QueryBuilder = class {
+  constructor(httpClient, table) {
+    this.options = {};
+    this.httpClient = httpClient;
+    this.table = table;
+  }
+  select(...columns) {
+    this.options.select = columns;
+    return this;
+  }
+  innerJoin(table, on) {
+    if (!this.options.joins) this.options.joins = [];
+    this.options.joins.push({ kind: "INNER", table, on });
+    return this;
+  }
+  leftJoin(table, on) {
+    if (!this.options.joins) this.options.joins = [];
+    this.options.joins.push({ kind: "LEFT", table, on });
+    return this;
+  }
+  rightJoin(table, on) {
+    if (!this.options.joins) this.options.joins = [];
+    this.options.joins.push({ kind: "RIGHT", table, on });
+    return this;
+  }
+  where(expr, args) {
+    if (!this.options.where) this.options.where = [];
+    this.options.where.push({ conj: "AND", expr, args });
+    return this;
+  }
+  andWhere(expr, args) {
+    return this.where(expr, args);
+  }
+  orWhere(expr, args) {
+    if (!this.options.where) this.options.where = [];
+    this.options.where.push({ conj: "OR", expr, args });
+    return this;
+  }
+  groupBy(...columns) {
+    this.options.group_by = columns;
+    return this;
+  }
+  orderBy(...columns) {
+    this.options.order_by = columns;
+    return this;
+  }
+  limit(n) {
+    this.options.limit = n;
+    return this;
+  }
+  offset(n) {
+    this.options.offset = n;
+    return this;
+  }
+  async getMany(ctx) {
+    const response = await this.httpClient.post(
+      "/v1/rqlite/select",
+      {
+        table: this.table,
+        ...this.options
+      }
+    );
+    return response.items || [];
+  }
+  async getOne(ctx) {
+    const response = await this.httpClient.post(
+      "/v1/rqlite/select",
+      {
+        table: this.table,
+        ...this.options,
+        one: true,
+        limit: 1
+      }
+    );
+    const items = response.items || [];
+    return items.length > 0 ? items[0] : null;
+  }
+  async count() {
+    const response = await this.httpClient.post(
+      "/v1/rqlite/select",
+      {
+        table: this.table,
+        select: ["COUNT(*) AS count"],
+        where: this.options.where,
+        one: true
+      }
+    );
+    const items = response.items || [];
+    return items.length > 0 ? items[0].count : 0;
+  }
+};
+
+// src/db/repository.ts
+var Repository = class {
+  constructor(httpClient, tableName, primaryKey = "id") {
+    this.httpClient = httpClient;
+    this.tableName = tableName;
+    this.primaryKey = primaryKey;
+  }
+  createQueryBuilder() {
+    return new QueryBuilder(this.httpClient, this.tableName);
+  }
+  async find(criteria = {}, options = {}) {
+    const response = await this.httpClient.post(
+      "/v1/rqlite/find",
+      {
+        table: this.tableName,
+        criteria,
+        options
+      }
+    );
+    return response.items || [];
+  }
+  async findOne(criteria) {
+    try {
+      const response = await this.httpClient.post(
+        "/v1/rqlite/find-one",
+        {
+          table: this.tableName,
+          criteria
+        }
+      );
+      return response;
+    } catch (error) {
+      if (error instanceof SDKError && error.httpStatus === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async save(entity) {
+    const pkValue = entity[this.primaryKey];
+    if (!pkValue) {
+      const response = await this.httpClient.post("/v1/rqlite/exec", {
+        sql: this.buildInsertSql(entity),
+        args: this.buildInsertArgs(entity)
+      });
+      if (response.last_insert_id) {
+        entity[this.primaryKey] = response.last_insert_id;
+      }
+      return entity;
+    } else {
+      await this.httpClient.post("/v1/rqlite/exec", {
+        sql: this.buildUpdateSql(entity),
+        args: this.buildUpdateArgs(entity)
+      });
+      return entity;
+    }
+  }
+  async remove(entity) {
+    const pkValue = entity[this.primaryKey];
+    if (!pkValue) {
+      throw new SDKError(
+        `Primary key "${this.primaryKey}" is required for remove`,
+        400,
+        "MISSING_PK"
+      );
+    }
+    await this.httpClient.post("/v1/rqlite/exec", {
+      sql: `DELETE FROM ${this.tableName} WHERE ${this.primaryKey} = ?`,
+      args: [pkValue]
+    });
+  }
+  buildInsertSql(entity) {
+    const columns = Object.keys(entity).filter((k) => entity[k] !== void 0);
+    const placeholders = columns.map(() => "?").join(", ");
+    return `INSERT INTO ${this.tableName} (${columns.join(", ")}) VALUES (${placeholders})`;
+  }
+  buildInsertArgs(entity) {
+    return Object.entries(entity).filter(([, v]) => v !== void 0).map(([, v]) => v);
+  }
+  buildUpdateSql(entity) {
+    const columns = Object.keys(entity).filter((k) => entity[k] !== void 0 && k !== this.primaryKey).map((k) => `${k} = ?`);
+    return `UPDATE ${this.tableName} SET ${columns.join(", ")} WHERE ${this.primaryKey} = ?`;
+  }
+  buildUpdateArgs(entity) {
+    const args = Object.entries(entity).filter(([k, v]) => v !== void 0 && k !== this.primaryKey).map(([, v]) => v);
+    args.push(entity[this.primaryKey]);
+    return args;
+  }
+};
+
+// src/db/client.ts
+var DBClient = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  /**
+   * Execute a write/DDL SQL statement.
+   */
+  async exec(sql, args = []) {
+    return this.httpClient.post("/v1/rqlite/exec", { sql, args });
+  }
+  /**
+   * Execute a SELECT query.
+   */
+  async query(sql, args = []) {
+    const response = await this.httpClient.post(
+      "/v1/rqlite/query",
+      { sql, args }
+    );
+    return response.items || [];
+  }
+  /**
+   * Find rows with map-based criteria.
+   */
+  async find(table, criteria = {}, options = {}) {
+    const response = await this.httpClient.post(
+      "/v1/rqlite/find",
+      {
+        table,
+        criteria,
+        options
+      }
+    );
+    return response.items || [];
+  }
+  /**
+   * Find a single row with map-based criteria.
+   */
+  async findOne(table, criteria) {
+    return this.httpClient.post("/v1/rqlite/find-one", {
+      table,
+      criteria
+    });
+  }
+  /**
+   * Create a fluent QueryBuilder for complex SELECT queries.
+   */
+  createQueryBuilder(table) {
+    return new QueryBuilder(this.httpClient, table);
+  }
+  /**
+   * Create a Repository for entity-based operations.
+   */
+  repository(tableName, primaryKey = "id") {
+    return new Repository(this.httpClient, tableName, primaryKey);
+  }
+  /**
+   * Execute multiple operations atomically.
+   */
+  async transaction(ops, returnResults = true) {
+    const response = await this.httpClient.post(
+      "/v1/rqlite/transaction",
+      {
+        ops,
+        return_results: returnResults
+      }
+    );
+    return response.results || [];
+  }
+  /**
+   * Create a table from DDL SQL.
+   */
+  async createTable(schema) {
+    await this.httpClient.post("/v1/rqlite/create-table", { schema });
+  }
+  /**
+   * Drop a table.
+   */
+  async dropTable(table) {
+    await this.httpClient.post("/v1/rqlite/drop-table", { table });
+  }
+  /**
+   * Get current database schema.
+   */
+  async getSchema() {
+    return this.httpClient.get("/v1/rqlite/schema");
+  }
+};
+
+// src/core/ws.ts
+import WebSocket from "isomorphic-ws";
+var WSClient = class {
+  constructor(config) {
+    this.reconnectAttempts = 0;
+    this.messageHandlers = /* @__PURE__ */ new Set();
+    this.errorHandlers = /* @__PURE__ */ new Set();
+    this.closeHandlers = /* @__PURE__ */ new Set();
+    this.isManuallyClosed = false;
+    this.url = config.wsURL;
+    this.timeout = config.timeout ?? 3e4;
+    this.maxReconnectAttempts = config.maxReconnectAttempts ?? 5;
+    this.reconnectDelayMs = config.reconnectDelayMs ?? 1e3;
+    this.heartbeatIntervalMs = config.heartbeatIntervalMs ?? 3e4;
+    this.authMode = config.authMode ?? "header";
+    this.authToken = config.authToken;
+    this.WebSocketClass = config.WebSocket ?? WebSocket;
+  }
+  connect() {
+    return new Promise((resolve, reject) => {
+      try {
+        const wsUrl = this.buildWSUrl();
+        this.ws = new this.WebSocketClass(wsUrl);
+        const timeout = setTimeout(() => {
+          this.ws?.close();
+          reject(new SDKError("WebSocket connection timeout", 408, "WS_TIMEOUT"));
+        }, this.timeout);
+        this.ws.addEventListener("open", () => {
+          clearTimeout(timeout);
+          this.reconnectAttempts = 0;
+          this.startHeartbeat();
+          resolve();
+        });
+        this.ws.addEventListener("message", (event) => {
+          const msgEvent = event;
+          this.messageHandlers.forEach((handler) => handler(msgEvent.data));
+        });
+        this.ws.addEventListener("error", (event) => {
+          clearTimeout(timeout);
+          const error = new SDKError(
+            "WebSocket error",
+            500,
+            "WS_ERROR",
+            event
+          );
+          this.errorHandlers.forEach((handler) => handler(error));
+        });
+        this.ws.addEventListener("close", () => {
+          clearTimeout(timeout);
+          this.stopHeartbeat();
+          if (!this.isManuallyClosed) {
+            this.attemptReconnect();
+          } else {
+            this.closeHandlers.forEach((handler) => handler());
+          }
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  buildWSUrl() {
+    let url = this.url;
+    if (this.authToken) {
+      const separator = url.includes("?") ? "&" : "?";
+      const paramName = this.authToken.startsWith("ak_") ? "api_key" : "token";
+      url += `${separator}${paramName}=${encodeURIComponent(this.authToken)}`;
+    }
+    return url;
+  }
+  startHeartbeat() {
+    this.heartbeatInterval = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify({ type: "ping" }));
+      }
+    }, this.heartbeatIntervalMs);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = void 0;
+    }
+  }
+  attemptReconnect() {
+    if (this.reconnectAttempts < this.maxReconnectAttempts) {
+      this.reconnectAttempts++;
+      const delayMs = this.reconnectDelayMs * this.reconnectAttempts;
+      setTimeout(() => {
+        this.connect().catch((error) => {
+          this.errorHandlers.forEach((handler) => handler(error));
+        });
+      }, delayMs);
+    } else {
+      this.closeHandlers.forEach((handler) => handler());
+    }
+  }
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
+    return () => this.messageHandlers.delete(handler);
+  }
+  onError(handler) {
+    this.errorHandlers.add(handler);
+    return () => this.errorHandlers.delete(handler);
+  }
+  onClose(handler) {
+    this.closeHandlers.add(handler);
+    return () => this.closeHandlers.delete(handler);
+  }
+  send(data) {
+    if (this.ws?.readyState !== WebSocket.OPEN) {
+      throw new SDKError(
+        "WebSocket is not connected",
+        500,
+        "WS_NOT_CONNECTED"
+      );
+    }
+    this.ws.send(data);
+  }
+  close() {
+    this.isManuallyClosed = true;
+    this.stopHeartbeat();
+    this.ws?.close();
+  }
+  isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  setAuthToken(token) {
+    this.authToken = token;
+  }
+};
+
+// src/pubsub/client.ts
+var PubSubClient = class {
+  constructor(httpClient, wsConfig = {}) {
+    this.httpClient = httpClient;
+    this.wsConfig = wsConfig;
+  }
+  /**
+   * Publish a message to a topic.
+   */
+  async publish(topic, data) {
+    const dataBase64 = typeof data === "string" ? Buffer.from(data).toString("base64") : Buffer.from(data).toString("base64");
+    await this.httpClient.post("/v1/pubsub/publish", {
+      topic,
+      data_base64: dataBase64
+    });
+  }
+  /**
+   * List active topics in the current namespace.
+   */
+  async topics() {
+    const response = await this.httpClient.get(
+      "/v1/pubsub/topics"
+    );
+    return response.topics || [];
+  }
+  /**
+   * Subscribe to a topic via WebSocket.
+   * Returns a subscription object with event handlers.
+   */
+  async subscribe(topic, handlers = {}) {
+    const wsUrl = new URL(this.wsConfig.wsURL || "ws://localhost:6001");
+    wsUrl.pathname = "/v1/pubsub/ws";
+    wsUrl.searchParams.set("topic", topic);
+    const wsClient = new WSClient({
+      ...this.wsConfig,
+      wsURL: wsUrl.toString(),
+      authToken: this.httpClient.getToken()
+    });
+    const subscription = new Subscription(wsClient, topic);
+    if (handlers.onMessage) {
+      subscription.onMessage(handlers.onMessage);
+    }
+    if (handlers.onError) {
+      subscription.onError(handlers.onError);
+    }
+    if (handlers.onClose) {
+      subscription.onClose(handlers.onClose);
+    }
+    await wsClient.connect();
+    return subscription;
+  }
+};
+var Subscription = class {
+  constructor(wsClient, topic) {
+    this.messageHandlers = /* @__PURE__ */ new Set();
+    this.errorHandlers = /* @__PURE__ */ new Set();
+    this.closeHandlers = /* @__PURE__ */ new Set();
+    this.wsClient = wsClient;
+    this.topic = topic;
+    this.wsClient.onMessage((data) => {
+      try {
+        const message = {
+          topic: this.topic,
+          data,
+          timestamp: Date.now()
+        };
+        this.messageHandlers.forEach((handler) => handler(message));
+      } catch (error) {
+        this.errorHandlers.forEach(
+          (handler) => handler(error instanceof Error ? error : new Error(String(error)))
+        );
+      }
+    });
+    this.wsClient.onError((error) => {
+      this.errorHandlers.forEach((handler) => handler(error));
+    });
+    this.wsClient.onClose(() => {
+      this.closeHandlers.forEach((handler) => handler());
+    });
+  }
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
+    return () => this.messageHandlers.delete(handler);
+  }
+  onError(handler) {
+    this.errorHandlers.add(handler);
+    return () => this.errorHandlers.delete(handler);
+  }
+  onClose(handler) {
+    this.closeHandlers.add(handler);
+    return () => this.closeHandlers.delete(handler);
+  }
+  close() {
+    this.wsClient.close();
+  }
+  isConnected() {
+    return this.wsClient.isConnected();
+  }
+};
+
+// src/network/client.ts
+var NetworkClient = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  /**
+   * Check gateway health.
+   */
+  async health() {
+    try {
+      await this.httpClient.get("/v1/health");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get network status.
+   */
+  async status() {
+    const response = await this.httpClient.get("/v1/status");
+    return response;
+  }
+  /**
+   * Get connected peers.
+   */
+  async peers() {
+    const response = await this.httpClient.get(
+      "/v1/network/peers"
+    );
+    return response.peers || [];
+  }
+  /**
+   * Connect to a peer.
+   */
+  async connect(peerAddr) {
+    await this.httpClient.post("/v1/network/connect", { peer_addr: peerAddr });
+  }
+  /**
+   * Disconnect from a peer.
+   */
+  async disconnect(peerId) {
+    await this.httpClient.post("/v1/network/disconnect", { peer_id: peerId });
+  }
+};
+
+// src/index.ts
+function createClient(config) {
+  const httpClient = new HttpClient({
+    baseURL: config.baseURL,
+    timeout: config.timeout,
+    maxRetries: config.maxRetries,
+    retryDelayMs: config.retryDelayMs,
+    fetch: config.fetch
+  });
+  const auth = new AuthClient({
+    httpClient,
+    storage: config.storage,
+    apiKey: config.apiKey,
+    jwt: config.jwt
+  });
+  const wsURL = config.wsConfig?.wsURL ?? config.baseURL.replace(/^http/, "ws").replace(/\/$/, "");
+  const db = new DBClient(httpClient);
+  const pubsub = new PubSubClient(httpClient, {
+    ...config.wsConfig,
+    wsURL
+  });
+  const network = new NetworkClient(httpClient);
+  return {
+    auth,
+    db,
+    pubsub,
+    network
+  };
+}
+export {
+  AuthClient,
+  DBClient,
+  HttpClient,
+  LocalStorageAdapter,
+  MemoryStorage,
+  NetworkClient,
+  PubSubClient,
+  QueryBuilder,
+  Repository,
+  SDKError,
+  Subscription,
+  WSClient,
+  createClient
+};
+//# sourceMappingURL=index.js.map