@rivium/sync-node 0.1.0

package/dist/index.js

@@ -0,0 +1,888 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  RiviumSyncAdmin: () => RiviumSyncAdmin,
+  RiviumSyncError: () => RiviumSyncError,
+  RiviumSyncErrorCode: () => RiviumSyncErrorCode,
+  RiviumSyncLogLevel: () => RiviumSyncLogLevel,
+  SyncCollection: () => SyncCollection,
+  SyncDatabase: () => SyncDatabase,
+  SyncDocumentRef: () => SyncDocumentRef,
+  SyncQuery: () => SyncQuery,
+  WriteBatch: () => WriteBatch,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_mqtt = __toESM(require("mqtt"));
+var RiviumSyncErrorCode = /* @__PURE__ */ ((RiviumSyncErrorCode2) => {
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["CONNECTION_FAILED"] = 1e3] = "CONNECTION_FAILED";
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["CONNECTION_TIMEOUT"] = 1001] = "CONNECTION_TIMEOUT";
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["CONNECTION_LOST"] = 1002] = "CONNECTION_LOST";
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["AUTHENTICATION_FAILED"] = 1004] = "AUTHENTICATION_FAILED";
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["SUBSCRIPTION_FAILED"] = 1100] = "SUBSCRIPTION_FAILED";
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["DATA_FETCH_FAILED"] = 1200] = "DATA_FETCH_FAILED";
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["DATA_PARSE_ERROR"] = 1201] = "DATA_PARSE_ERROR";
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["DATA_WRITE_FAILED"] = 1202] = "DATA_WRITE_FAILED";
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["DATA_DELETE_FAILED"] = 1203] = "DATA_DELETE_FAILED";
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["DOCUMENT_NOT_FOUND"] = 1204] = "DOCUMENT_NOT_FOUND";
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["INVALID_CONFIG"] = 1300] = "INVALID_CONFIG";
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["MISSING_API_KEY"] = 1301] = "MISSING_API_KEY";
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["MISSING_SERVER_URL"] = 1302] = "MISSING_SERVER_URL";
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["MISSING_SERVER_SECRET"] = 1303] = "MISSING_SERVER_SECRET";
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["NOT_INITIALIZED"] = 1500] = "NOT_INITIALIZED";
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["NOT_CONNECTED"] = 1501] = "NOT_CONNECTED";
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["INVALID_QUERY"] = 1700] = "INVALID_QUERY";
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["QUERY_EXECUTION_FAILED"] = 1701] = "QUERY_EXECUTION_FAILED";
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["BATCH_WRITE_FAILED"] = 1800] = "BATCH_WRITE_FAILED";
+  RiviumSyncErrorCode2[RiviumSyncErrorCode2["UNKNOWN_ERROR"] = 9999] = "UNKNOWN_ERROR";
+  return RiviumSyncErrorCode2;
+})(RiviumSyncErrorCode || {});
+var ERROR_MESSAGES = {
+  [1e3 /* CONNECTION_FAILED */]: "Failed to connect to server",
+  [1001 /* CONNECTION_TIMEOUT */]: "Connection timed out",
+  [1002 /* CONNECTION_LOST */]: "Connection to server was lost",
+  [1004 /* AUTHENTICATION_FAILED */]: "Authentication failed - invalid API key",
+  [1100 /* SUBSCRIPTION_FAILED */]: "Failed to subscribe to path",
+  [1200 /* DATA_FETCH_FAILED */]: "Failed to fetch data",
+  [1201 /* DATA_PARSE_ERROR */]: "Failed to parse data",
+  [1202 /* DATA_WRITE_FAILED */]: "Failed to write data",
+  [1203 /* DATA_DELETE_FAILED */]: "Failed to delete data",
+  [1204 /* DOCUMENT_NOT_FOUND */]: "Document not found",
+  [1300 /* INVALID_CONFIG */]: "Invalid configuration",
+  [1301 /* MISSING_API_KEY */]: "API key is missing",
+  [1302 /* MISSING_SERVER_URL */]: "Server URL is missing",
+  [1303 /* MISSING_SERVER_SECRET */]: "Server secret is missing",
+  [1500 /* NOT_INITIALIZED */]: "SDK is not initialized",
+  [1501 /* NOT_CONNECTED */]: "Not connected to server",
+  [1700 /* INVALID_QUERY */]: "Invalid query parameters",
+  [1701 /* QUERY_EXECUTION_FAILED */]: "Query execution failed",
+  [1800 /* BATCH_WRITE_FAILED */]: "Batch write operation failed",
+  [9999 /* UNKNOWN_ERROR */]: "An unknown error occurred"
+};
+var RiviumSyncError = class extends Error {
+  constructor(code, details) {
+    super(ERROR_MESSAGES[code] || "Unknown error");
+    this.name = "RiviumSyncError";
+    this.code = code;
+    this.details = details;
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      details: this.details
+    };
+  }
+};
+var RiviumSyncLogLevel = /* @__PURE__ */ ((RiviumSyncLogLevel2) => {
+  RiviumSyncLogLevel2[RiviumSyncLogLevel2["NONE"] = 0] = "NONE";
+  RiviumSyncLogLevel2[RiviumSyncLogLevel2["ERROR"] = 1] = "ERROR";
+  RiviumSyncLogLevel2[RiviumSyncLogLevel2["WARNING"] = 2] = "WARNING";
+  RiviumSyncLogLevel2[RiviumSyncLogLevel2["INFO"] = 3] = "INFO";
+  RiviumSyncLogLevel2[RiviumSyncLogLevel2["DEBUG"] = 4] = "DEBUG";
+  RiviumSyncLogLevel2[RiviumSyncLogLevel2["VERBOSE"] = 5] = "VERBOSE";
+  return RiviumSyncLogLevel2;
+})(RiviumSyncLogLevel || {});
+var SyncCollection = class {
+  constructor(admin, databaseId, collectionId) {
+    this.admin = admin;
+    this.databaseId = databaseId;
+    this.collectionId = collectionId;
+  }
+  /**
+   * Get a document reference
+   */
+  doc(documentId) {
+    return new SyncDocumentRef(this.admin, this.databaseId, this.collectionId, documentId);
+  }
+  /**
+   * Create a new document with auto-generated ID
+   */
+  async add(data) {
+    return this.admin.addDocument(this.databaseId, this.collectionId, data);
+  }
+  /**
+   * Get a single document by ID
+   */
+  async get(documentId) {
+    return this.admin.getDocument(this.databaseId, this.collectionId, documentId);
+  }
+  /**
+   * Get all documents in collection
+   */
+  async getAll(options) {
+    return this.admin.getDocuments(this.databaseId, this.collectionId, options);
+  }
+  /**
+   * Listen to collection changes (requires enableRealtime: true)
+   */
+  onSnapshot(callback, options) {
+    return this.admin.listenCollection(this.databaseId, this.collectionId, callback, options);
+  }
+  /**
+   * Start a query builder
+   */
+  query() {
+    return new SyncQuery(this.admin, this.databaseId, this.collectionId);
+  }
+  /**
+   * Add a filter condition
+   */
+  where(field, operator, value) {
+    return new SyncQuery(this.admin, this.databaseId, this.collectionId).where(field, operator, value);
+  }
+  /**
+   * Order results
+   */
+  orderBy(field, direction = "asc") {
+    return new SyncQuery(this.admin, this.databaseId, this.collectionId).orderBy(field, direction);
+  }
+  /**
+   * Limit results
+   */
+  limit(count) {
+    return new SyncQuery(this.admin, this.databaseId, this.collectionId).limit(count);
+  }
+};
+var SyncDocumentRef = class {
+  constructor(admin, databaseId, collectionId, documentId) {
+    this.admin = admin;
+    this.databaseId = databaseId;
+    this.collectionId = collectionId;
+    this.documentId = documentId;
+  }
+  get id() {
+    return this.documentId;
+  }
+  get path() {
+    return `/${this.databaseId}/${this.collectionId}/${this.documentId}`;
+  }
+  /**
+   * Get document data
+   */
+  async get() {
+    return this.admin.getDocument(this.databaseId, this.collectionId, this.documentId);
+  }
+  /**
+   * Check if document exists
+   */
+  async exists() {
+    const doc = await this.get();
+    return doc !== null;
+  }
+  /**
+   * Set document data (overwrite)
+   */
+  async set(data) {
+    await this.admin.setDocument(this.databaseId, this.collectionId, this.documentId, data);
+  }
+  /**
+   * Update document data (merge)
+   */
+  async update(data) {
+    await this.admin.updateDocument(this.databaseId, this.collectionId, this.documentId, data);
+  }
+  /**
+   * Delete document
+   */
+  async delete() {
+    await this.admin.deleteDocument(this.databaseId, this.collectionId, this.documentId);
+  }
+  /**
+   * Listen to document changes (requires enableRealtime: true)
+   */
+  onSnapshot(callback) {
+    return this.admin.listenDocument(this.databaseId, this.collectionId, this.documentId, callback);
+  }
+};
+var SyncQuery = class {
+  constructor(admin, databaseId, collectionId) {
+    this.options = {};
+    this.admin = admin;
+    this.databaseId = databaseId;
+    this.collectionId = collectionId;
+  }
+  /**
+   * Add a filter condition
+   */
+  where(field, operator, value) {
+    if (!this.options.filters) {
+      this.options.filters = [];
+    }
+    this.options.filters.push({ field, operator, value });
+    return this;
+  }
+  /**
+   * Order results
+   */
+  orderBy(field, direction = "asc") {
+    this.options.orderBy = field;
+    this.options.orderDirection = direction;
+    return this;
+  }
+  /**
+   * Limit results
+   */
+  limit(count) {
+    this.options.limit = count;
+    return this;
+  }
+  /**
+   * Skip results (for pagination)
+   */
+  offset(count) {
+    this.options.offset = count;
+    return this;
+  }
+  /**
+   * Alias for offset - skip first N results
+   */
+  startAfter(count) {
+    return this.offset(count);
+  }
+  /**
+   * Execute query and get results
+   */
+  async get() {
+    return this.admin.getDocuments(this.databaseId, this.collectionId, this.options);
+  }
+  /**
+   * Get first result only
+   */
+  async getFirst() {
+    const originalLimit = this.options.limit;
+    this.options.limit = 1;
+    const results = await this.get();
+    this.options.limit = originalLimit;
+    return results.length > 0 ? results[0] : null;
+  }
+  /**
+   * Count matching documents
+   */
+  async count() {
+    const results = await this.get();
+    return results.length;
+  }
+  /**
+   * Listen to query results (requires enableRealtime: true)
+   */
+  onSnapshot(callback) {
+    return this.admin.listenCollection(this.databaseId, this.collectionId, callback, this.options);
+  }
+};
+var SyncDatabase = class {
+  constructor(admin, databaseId) {
+    this.admin = admin;
+    this.databaseId = databaseId;
+  }
+  get id() {
+    return this.databaseId;
+  }
+  /**
+   * Get a collection reference
+   */
+  collection(collectionId) {
+    return new SyncCollection(this.admin, this.databaseId, collectionId);
+  }
+};
+var WriteBatch = class {
+  constructor(admin) {
+    this.operations = [];
+    this.admin = admin;
+  }
+  /**
+   * Add a set operation to the batch
+   */
+  set(docRef, data) {
+    this.operations.push({
+      type: "set",
+      databaseId: docRef.databaseId,
+      collectionId: docRef.collectionId,
+      documentId: docRef.id,
+      data
+    });
+    return this;
+  }
+  /**
+   * Add an update operation to the batch
+   */
+  update(docRef, data) {
+    this.operations.push({
+      type: "update",
+      databaseId: docRef.databaseId,
+      collectionId: docRef.collectionId,
+      documentId: docRef.id,
+      data
+    });
+    return this;
+  }
+  /**
+   * Add a delete operation to the batch
+   */
+  delete(docRef) {
+    this.operations.push({
+      type: "delete",
+      databaseId: docRef.databaseId,
+      collectionId: docRef.collectionId,
+      documentId: docRef.id
+    });
+    return this;
+  }
+  /**
+   * Commit all operations in the batch
+   */
+  async commit() {
+    await this.admin.executeBatch(this.operations);
+    this.operations = [];
+  }
+  /**
+   * Get the number of pending operations
+   */
+  get size() {
+    return this.operations.length;
+  }
+};
+var _RiviumSyncAdmin = class _RiviumSyncAdmin {
+  constructor(config) {
+    this.mqttClient = null;
+    this.mqttConfig = null;
+    // Realtime listeners
+    this.documentListeners = /* @__PURE__ */ new Map();
+    this.collectionListeners = /* @__PURE__ */ new Map();
+    this.cachedCollections = /* @__PURE__ */ new Map();
+    if (!config.apiKey) {
+      throw new RiviumSyncError(1301 /* MISSING_API_KEY */);
+    }
+    if (!config.serverSecret) {
+      throw new RiviumSyncError(1303 /* MISSING_SERVER_SECRET */);
+    }
+    this.config = {
+      ...config,
+      baseUrl: _RiviumSyncAdmin.DEFAULT_BASE_URL,
+      enableRealtime: config.enableRealtime ?? false,
+      logLevel: config.logLevel ?? 1 /* ERROR */,
+      timeout: config.timeout ?? 3e4
+    };
+    this.logLevel = this.config.logLevel;
+    this.timeout = this.config.timeout;
+    this.log(3 /* INFO */, "RiviumSyncAdmin SDK initialized");
+    if (this.config.enableRealtime) {
+      this.initRealtime();
+    }
+  }
+  // ==========================================================================
+  // Logging
+  // ==========================================================================
+  log(level, message, ...args) {
+    if (level > this.logLevel) return;
+    const prefix = "[RiviumSync]";
+    switch (level) {
+      case 1 /* ERROR */:
+        console.error(prefix, message, ...args);
+        break;
+      case 2 /* WARNING */:
+        console.warn(prefix, message, ...args);
+        break;
+      case 3 /* INFO */:
+        console.info(prefix, message, ...args);
+        break;
+      default:
+        console.log(prefix, message, ...args);
+    }
+  }
+  setLogLevel(level) {
+    this.logLevel = level;
+  }
+  // ==========================================================================
+  // HTTP Client
+  // ==========================================================================
+  async request(method, path, body) {
+    const url = `${this.config.baseUrl}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "x-api-key": this.config.apiKey,
+      "x-server-secret": this.config.serverSecret
+    };
+    if (this.config.userId) {
+      headers["X-User-Id"] = this.config.userId;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new RiviumSyncError(
+          1200 /* DATA_FETCH_FAILED */,
+          `HTTP ${response.status}: ${errorText}`
+        );
+      }
+      const text = await response.text();
+      if (!text) {
+        return {};
+      }
+      return JSON.parse(text);
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof RiviumSyncError) {
+        throw error;
+      }
+      if (error.name === "AbortError") {
+        throw new RiviumSyncError(1001 /* CONNECTION_TIMEOUT */);
+      }
+      throw new RiviumSyncError(
+        1200 /* DATA_FETCH_FAILED */,
+        error.message
+      );
+    }
+  }
+  // ==========================================================================
+  // Public API - Database Access
+  // ==========================================================================
+  /**
+   * Get a database reference
+   */
+  database(databaseId) {
+    return new SyncDatabase(this, databaseId);
+  }
+  /**
+   * Create a new write batch
+   */
+  batch() {
+    return new WriteBatch(this);
+  }
+  // ==========================================================================
+  // Document Operations (Internal)
+  // ==========================================================================
+  async getDocument(databaseId, collectionId, documentId) {
+    try {
+      const response = await this.request(
+        "GET",
+        `/databases/${databaseId}/collections/${collectionId}/documents/sdk/${documentId}`
+      );
+      return response;
+    } catch (error) {
+      if (error.details?.includes("404")) {
+        return null;
+      }
+      this.log(1 /* ERROR */, "Failed to get document:", error);
+      throw error;
+    }
+  }
+  async getDocuments(databaseId, collectionId, options) {
+    try {
+      const queryParams = new URLSearchParams();
+      if (options?.filters) {
+        queryParams.set("filters", JSON.stringify(options.filters));
+      }
+      if (options?.orderBy) {
+        queryParams.set("orderBy", options.orderBy);
+        queryParams.set("orderDirection", options.orderDirection || "asc");
+      }
+      if (options?.limit) {
+        queryParams.set("limit", options.limit.toString());
+      }
+      if (options?.offset) {
+        queryParams.set("offset", options.offset.toString());
+      }
+      const queryString = queryParams.toString();
+      const path = `/databases/${databaseId}/collections/${collectionId}/documents/sdk${queryString ? `?${queryString}` : ""}`;
+      const response = await this.request(
+        "GET",
+        path
+      );
+      return Array.isArray(response) ? response : response.documents || [];
+    } catch (error) {
+      this.log(1 /* ERROR */, "Failed to get documents:", error);
+      throw error;
+    }
+  }
+  async addDocument(databaseId, collectionId, data) {
+    try {
+      const response = await this.request(
+        "POST",
+        `/databases/${databaseId}/collections/${collectionId}/documents/sdk`,
+        { data }
+      );
+      return response;
+    } catch (error) {
+      this.log(1 /* ERROR */, "Failed to add document:", error);
+      throw error;
+    }
+  }
+  async setDocument(databaseId, collectionId, documentId, data) {
+    try {
+      await this.request(
+        "PUT",
+        `/databases/${databaseId}/collections/${collectionId}/documents/sdk/${documentId}`,
+        { data }
+      );
+    } catch (error) {
+      this.log(1 /* ERROR */, "Failed to set document:", error);
+      throw error;
+    }
+  }
+  async updateDocument(databaseId, collectionId, documentId, data) {
+    try {
+      await this.request(
+        "PATCH",
+        `/databases/${databaseId}/collections/${collectionId}/documents/sdk/${documentId}`,
+        { data }
+      );
+    } catch (error) {
+      this.log(1 /* ERROR */, "Failed to update document:", error);
+      throw error;
+    }
+  }
+  async deleteDocument(databaseId, collectionId, documentId) {
+    try {
+      await this.request(
+        "DELETE",
+        `/databases/${databaseId}/collections/${collectionId}/documents/sdk/${documentId}`
+      );
+    } catch (error) {
+      this.log(1 /* ERROR */, "Failed to delete document:", error);
+      throw error;
+    }
+  }
+  // ==========================================================================
+  // Batch Operations
+  // ==========================================================================
+  async executeBatch(operations) {
+    for (const op of operations) {
+      switch (op.type) {
+        case "set":
+          await this.setDocument(op.databaseId, op.collectionId, op.documentId, op.data);
+          break;
+        case "update":
+          await this.updateDocument(op.databaseId, op.collectionId, op.documentId, op.data);
+          break;
+        case "delete":
+          await this.deleteDocument(op.databaseId, op.collectionId, op.documentId);
+          break;
+      }
+    }
+  }
+  // ==========================================================================
+  // Realtime (Optional)
+  // ==========================================================================
+  async initRealtime() {
+    try {
+      this.log(4 /* DEBUG */, "Fetching MQTT token...");
+      const tokenData = await this.request("POST", "/connections/token");
+      this.mqttConfig = {
+        host: tokenData.mqtt.host,
+        port: tokenData.mqtt.port,
+        wsHost: tokenData.mqtt.host,
+        wsPort: tokenData.mqtt.port,
+        password: tokenData.token
+      };
+      this.connectMqtt();
+    } catch (error) {
+      this.log(1 /* ERROR */, "Failed to fetch MQTT token:", error);
+    }
+  }
+  connectMqtt() {
+    if (!this.mqttConfig) {
+      return;
+    }
+    const url = `mqtt://${this.mqttConfig.host}:${this.mqttConfig.port}`;
+    const clientId = `rivium_sync_node_${this.generateUUID()}`;
+    const options = {
+      clientId,
+      clean: false,
+      connectTimeout: 1e4,
+      username: "jwt",
+      password: this.mqttConfig.password
+    };
+    this.log(4 /* DEBUG */, "Connecting to MQTT:", url);
+    this.mqttClient = import_mqtt.default.connect(url, options);
+    this.mqttClient.on("connect", () => {
+      this.log(3 /* INFO */, "MQTT connected");
+      this.resubscribeAll();
+    });
+    this.mqttClient.on("message", (topic, payload) => {
+      try {
+        const data = JSON.parse(payload.toString());
+        this.handleMqttMessage(topic, data);
+      } catch (error) {
+        this.log(1 /* ERROR */, "MQTT message parse error:", error);
+      }
+    });
+    this.mqttClient.on("error", (error) => {
+      this.log(1 /* ERROR */, "MQTT error:", error);
+    });
+    this.mqttClient.on("close", () => {
+      this.log(3 /* INFO */, "MQTT disconnected");
+    });
+  }
+  listenDocument(databaseId, collectionId, documentId, callback) {
+    if (!this.config.enableRealtime) {
+      this.log(2 /* WARNING */, "Realtime not enabled. Set enableRealtime: true in config.");
+      this.getDocument(databaseId, collectionId, documentId).then((doc) => {
+        callback(doc);
+      });
+      return () => {
+      };
+    }
+    const path = `/${databaseId}/${collectionId}/${documentId}`;
+    const mqttTopic = `rivium_sync/${this.config.apiKey.substring(0, 16)}/db/${databaseId}/${collectionId}/${documentId}`;
+    if (!this.documentListeners.has(path)) {
+      this.documentListeners.set(path, /* @__PURE__ */ new Set());
+    }
+    this.documentListeners.get(path).add(callback);
+    if (this.mqttClient?.connected) {
+      this.mqttClient.subscribe(mqttTopic, { qos: 1 });
+    }
+    this.getDocument(databaseId, collectionId, documentId).then((doc) => {
+      callback(doc);
+    });
+    return () => {
+      const listeners = this.documentListeners.get(path);
+      if (listeners) {
+        listeners.delete(callback);
+        if (listeners.size === 0) {
+          this.documentListeners.delete(path);
+          this.mqttClient?.unsubscribe(mqttTopic);
+        }
+      }
+    };
+  }
+  listenCollection(databaseId, collectionId, callback, options) {
+    if (!this.config.enableRealtime) {
+      this.log(2 /* WARNING */, "Realtime not enabled. Set enableRealtime: true in config.");
+      this.getDocuments(databaseId, collectionId, options).then((docs) => {
+        callback(docs);
+      });
+      return () => {
+      };
+    }
+    const path = `/${databaseId}/${collectionId}`;
+    const mqttTopic = `rivium_sync/${this.config.apiKey.substring(0, 16)}/db/${databaseId}/${collectionId}/+`;
+    if (!this.collectionListeners.has(path)) {
+      this.collectionListeners.set(path, /* @__PURE__ */ new Set());
+    }
+    this.collectionListeners.get(path).add({
+      callback,
+      options
+    });
+    if (this.mqttClient?.connected) {
+      this.mqttClient.subscribe(mqttTopic, { qos: 1 });
+    }
+    this.getDocuments(databaseId, collectionId, options).then((docs) => {
+      this.cachedCollections.set(path, docs);
+      callback(docs);
+    });
+    return () => {
+      const listeners = this.collectionListeners.get(path);
+      if (listeners) {
+        const listenerObj = Array.from(listeners).find((l) => l.callback === callback);
+        if (listenerObj) {
+          listeners.delete(listenerObj);
+        }
+        if (listeners.size === 0) {
+          this.collectionListeners.delete(path);
+          this.cachedCollections.delete(path);
+          this.mqttClient?.unsubscribe(mqttTopic);
+        }
+      }
+    };
+  }
+  resubscribeAll() {
+    if (!this.mqttClient?.connected) return;
+    const appId = this.config.apiKey.substring(0, 16);
+    this.documentListeners.forEach((_, path) => {
+      const parts = path.split("/").filter((p) => p);
+      if (parts.length === 3) {
+        const [databaseId, collectionId, documentId] = parts;
+        const topic = `rivium_sync/${appId}/db/${databaseId}/${collectionId}/${documentId}`;
+        this.mqttClient.subscribe(topic, { qos: 1 });
+      }
+    });
+    this.collectionListeners.forEach((_, path) => {
+      const parts = path.split("/").filter((p) => p);
+      if (parts.length === 2) {
+        const [databaseId, collectionId] = parts;
+        const topic = `rivium_sync/${appId}/db/${databaseId}/${collectionId}/+`;
+        this.mqttClient.subscribe(topic, { qos: 1 });
+      }
+    });
+  }
+  handleMqttMessage(topic, data) {
+    const parts = topic.split("/");
+    if (parts.length < 6) return;
+    const databaseId = parts[3];
+    const collectionId = parts[4];
+    const documentId = parts[5];
+    const documentPath = `/${databaseId}/${collectionId}/${documentId}`;
+    const collectionPath = `/${databaseId}/${collectionId}`;
+    const typedData = data;
+    const docListeners = this.documentListeners.get(documentPath);
+    if (docListeners) {
+      const document = {
+        id: documentId,
+        data: typedData.data || typedData,
+        createdAt: typedData.createdAt,
+        updatedAt: typedData.updatedAt,
+        version: typedData.version
+      };
+      docListeners.forEach((callback) => {
+        if (typedData.deleted) {
+          callback(null);
+        } else {
+          callback(document);
+        }
+      });
+    }
+    const colListeners = this.collectionListeners.get(collectionPath);
+    if (colListeners) {
+      let docs = this.cachedCollections.get(collectionPath) || [];
+      if (typedData.deleted) {
+        docs = docs.filter((d) => d.id !== documentId);
+      } else {
+        const existingIndex = docs.findIndex((d) => d.id === documentId);
+        const newDoc = {
+          id: documentId,
+          data: typedData.data || typedData,
+          createdAt: typedData.createdAt,
+          updatedAt: typedData.updatedAt,
+          version: typedData.version
+        };
+        if (existingIndex >= 0) {
+          docs[existingIndex] = newDoc;
+        } else {
+          docs.push(newDoc);
+        }
+      }
+      this.cachedCollections.set(collectionPath, docs);
+      colListeners.forEach(({ callback, options }) => {
+        let filteredDocs = [...docs];
+        if (options?.filters) {
+          filteredDocs = this.applyFilters(filteredDocs, options.filters);
+        }
+        if (options?.orderBy) {
+          filteredDocs = this.applyOrdering(filteredDocs, options.orderBy, options.orderDirection);
+        }
+        if (options?.limit) {
+          filteredDocs = filteredDocs.slice(options.offset || 0, (options.offset || 0) + options.limit);
+        }
+        callback(filteredDocs);
+      });
+    }
+  }
+  applyFilters(docs, filters) {
+    return docs.filter((doc) => {
+      const data = doc.data;
+      return filters.every((filter) => {
+        const value = data[filter.field];
+        switch (filter.operator) {
+          case "==":
+            return value === filter.value;
+          case "!=":
+            return value !== filter.value;
+          case "<":
+            return value < filter.value;
+          case "<=":
+            return value <= filter.value;
+          case ">":
+            return value > filter.value;
+          case ">=":
+            return value >= filter.value;
+          case "in":
+            return Array.isArray(filter.value) && filter.value.includes(value);
+          case "not-in":
+            return Array.isArray(filter.value) && !filter.value.includes(value);
+          case "array-contains":
+            return Array.isArray(value) && value.includes(filter.value);
+          default:
+            return true;
+        }
+      });
+    });
+  }
+  applyOrdering(docs, orderBy, direction) {
+    return [...docs].sort((a, b) => {
+      const aData = a.data;
+      const bData = b.data;
+      const aVal = aData[orderBy];
+      const bVal = bData[orderBy];
+      let comparison = 0;
+      if (aVal == null && bVal != null) comparison = -1;
+      else if (aVal != null && bVal == null) comparison = 1;
+      else if (aVal != null && bVal != null) {
+        if (aVal < bVal) comparison = -1;
+        else if (aVal > bVal) comparison = 1;
+      }
+      return direction === "desc" ? -comparison : comparison;
+    });
+  }
+  // ==========================================================================
+  // Utilities
+  // ==========================================================================
+  generateUUID() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+  /**
+   * Disconnect from realtime updates
+   */
+  disconnect() {
+    if (this.mqttClient) {
+      this.mqttClient.end(true);
+      this.mqttClient = null;
+    }
+  }
+};
+_RiviumSyncAdmin.DEFAULT_BASE_URL = "https://sync.rivium.co";
+var RiviumSyncAdmin = _RiviumSyncAdmin;
+var index_default = RiviumSyncAdmin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RiviumSyncAdmin,
+  RiviumSyncError,
+  RiviumSyncErrorCode,
+  RiviumSyncLogLevel,
+  SyncCollection,
+  SyncDatabase,
+  SyncDocumentRef,
+  SyncQuery,
+  WriteBatch
+});