@xnetjs/data-bridge 0.0.2

package/dist/worker/data-worker.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/worker/data-worker.js

@@ -0,0 +1,304 @@
+import {
+  QueryCache
+} from "../chunk-X6F5CPJI.js";
+
+// src/worker/data-worker.ts
+import {
+  NodeStore,
+  MemoryNodeStorageAdapter
+} from "@xnetjs/data";
+import { expose, proxy, transfer } from "comlink";
+import * as Y from "yjs";
+var MAX_DOC_POOL_SIZE = 50;
+var MIN_DOC_AGE_FOR_EVICTION = 6e4;
+var DataWorker = class {
+  store = null;
+  storage = null;
+  subscriptions = /* @__PURE__ */ new Map();
+  cache = new QueryCache();
+  status = "disconnected";
+  statusHandlers = /* @__PURE__ */ new Set();
+  storeUnsubscribe = null;
+  // Y.Doc pool - the "source of truth" for all documents
+  docPool = /* @__PURE__ */ new Map();
+  // Client ID counter for Y.Doc instances
+  nextClientId = Math.floor(Math.random() * 2147483647);
+  async initialize(config) {
+    this.storage = new MemoryNodeStorageAdapter();
+    this.store = new NodeStore({
+      storage: this.storage,
+      authorDID: config.authorDID,
+      signingKey: new Uint8Array(config.signingKey)
+    });
+    await this.store.initialize();
+    this.storeUnsubscribe = this.store.subscribe((event) => {
+      this.handleStoreChange(event);
+    });
+    this.setStatus("connected");
+  }
+  async subscribe(queryId, schemaId, options, onDelta) {
+    if (!this.store) {
+      throw new Error("DataWorker not initialized");
+    }
+    const nodes = await this.loadQuery(schemaId, options);
+    this.subscriptions.set(queryId, {
+      schemaId,
+      options,
+      lastResult: nodes,
+      onDelta: proxy(onDelta)
+    });
+    return nodes;
+  }
+  async unsubscribe(queryId) {
+    this.subscriptions.delete(queryId);
+  }
+  async create(schemaId, data, id) {
+    if (!this.store) {
+      throw new Error("DataWorker not initialized");
+    }
+    return this.store.create({
+      id,
+      schemaId,
+      properties: data
+    });
+  }
+  async update(nodeId, changes) {
+    if (!this.store) {
+      throw new Error("DataWorker not initialized");
+    }
+    return this.store.update(nodeId, { properties: changes });
+  }
+  async delete(nodeId) {
+    if (!this.store) {
+      throw new Error("DataWorker not initialized");
+    }
+    await this.store.delete(nodeId);
+  }
+  async restore(nodeId) {
+    if (!this.store) {
+      throw new Error("DataWorker not initialized");
+    }
+    return this.store.restore(nodeId);
+  }
+  async get(nodeId) {
+    if (!this.store) {
+      throw new Error("DataWorker not initialized");
+    }
+    return this.store.get(nodeId);
+  }
+  // ─── Document Operations ────────────────────────────────────────────────────
+  async acquireDoc(nodeId, onUpdate) {
+    if (!this.storage) {
+      throw new Error("DataWorker not initialized");
+    }
+    let entry = this.docPool.get(nodeId);
+    if (entry) {
+      entry.lastAccessed = Date.now();
+    } else {
+      const doc = new Y.Doc({ guid: nodeId, gc: false });
+      const storedContent = await this.storage.getDocumentContent(nodeId);
+      if (storedContent && storedContent.length > 0) {
+        Y.applyUpdate(doc, storedContent, "storage");
+      }
+      entry = {
+        doc,
+        refCount: 0,
+        updateHandlers: /* @__PURE__ */ new Set(),
+        lastAccessed: Date.now()
+      };
+      this.evictOldDocs();
+      doc.on("update", (update, origin) => {
+        const content = Y.encodeStateAsUpdate(doc);
+        this.storage?.setDocumentContent(nodeId, content).catch((err) => {
+          console.error("[DataWorker] Failed to persist doc:", err);
+        });
+        if (origin === "remote") {
+          const handlers = Array.from(entry.updateHandlers);
+          for (let i = 0; i < handlers.length; i++) {
+            try {
+              const isLast = i === handlers.length - 1;
+              const updateToSend = isLast ? update : new Uint8Array(update);
+              if (isLast && update.buffer.byteLength === update.byteLength) {
+                handlers[i](
+                  transfer(updateToSend, [updateToSend.buffer]),
+                  "remote"
+                );
+              } else {
+                handlers[i](updateToSend, "remote");
+              }
+            } catch (err) {
+              console.error("[DataWorker] Update handler error:", err);
+            }
+          }
+        }
+      });
+      this.docPool.set(nodeId, entry);
+    }
+    const proxiedHandler = proxy(onUpdate);
+    entry.updateHandlers.add(proxiedHandler);
+    entry.refCount++;
+    const state = Y.encodeStateAsUpdate(entry.doc);
+    return transfer(
+      {
+        nodeId,
+        state,
+        clientId: this.nextClientId++
+      },
+      [state.buffer]
+    );
+  }
+  releaseDoc(nodeId) {
+    const entry = this.docPool.get(nodeId);
+    if (!entry) return;
+    entry.refCount--;
+  }
+  applyLocalUpdate(nodeId, update) {
+    const entry = this.docPool.get(nodeId);
+    if (!entry) {
+      console.warn("[DataWorker] applyLocalUpdate: doc not acquired:", nodeId);
+      return;
+    }
+    Y.applyUpdate(entry.doc, update, "local");
+  }
+  // ─── Status ─────────────────────────────────────────────────────────────────
+  getStatus() {
+    return this.status;
+  }
+  onStatusChange(handler) {
+    this.statusHandlers.add(proxy(handler));
+  }
+  async destroy() {
+    if (this.storeUnsubscribe) {
+      this.storeUnsubscribe();
+      this.storeUnsubscribe = null;
+    }
+    for (const entry of this.docPool.values()) {
+      entry.doc.destroy();
+    }
+    this.docPool.clear();
+    if (this.storage?.close) {
+      await this.storage.close();
+    }
+    this.storage = null;
+    this.store = null;
+    this.subscriptions.clear();
+    this.cache.clear();
+    this.statusHandlers.clear();
+    this.setStatus("disconnected");
+  }
+  // ─── Private Methods ─────────────────────────────────────────────────────────
+  async loadQuery(schemaId, options) {
+    if (!this.store) return [];
+    let nodes;
+    if (options.nodeId) {
+      const node = await this.store.get(options.nodeId);
+      nodes = node && node.schemaId === schemaId && !node.deleted ? [node] : [];
+    } else {
+      nodes = await this.store.list({
+        schemaId,
+        includeDeleted: options.includeDeleted,
+        limit: options.limit,
+        offset: options.offset
+      });
+    }
+    nodes = this.cache.filterNodes(nodes, options);
+    nodes = this.cache.sortNodes(nodes, options);
+    return nodes;
+  }
+  handleStoreChange(event) {
+    const { node, change } = event;
+    const schemaId = node?.schemaId ?? change.payload.schemaId;
+    if (!schemaId) return;
+    for (const [queryId, sub] of this.subscriptions) {
+      if (sub.schemaId !== schemaId) continue;
+      const delta = this.computeDelta(event, sub);
+      if (delta) {
+        this.applyDeltaToSubscription(queryId, delta);
+        sub.onDelta(delta);
+      }
+    }
+  }
+  computeDelta(event, sub) {
+    const { node, change } = event;
+    const passesFilter = node ? this.nodeMatchesFilter(node, sub.options) : false;
+    const existingIndex = sub.lastResult.findIndex((n) => n.id === change.payload.nodeId);
+    if (existingIndex >= 0) {
+      if (!node || node.deleted || !passesFilter) {
+        return { type: "remove", nodeId: change.payload.nodeId };
+      } else {
+        return { type: "update", nodeId: node.id, node };
+      }
+    } else {
+      if (node && !node.deleted && passesFilter) {
+        return { type: "add", node, index: sub.lastResult.length };
+      }
+    }
+    return null;
+  }
+  nodeMatchesFilter(node, options) {
+    if (node.deleted && !options.includeDeleted) {
+      return false;
+    }
+    if (options.where) {
+      for (const [key, value] of Object.entries(options.where)) {
+        if (node.properties[key] !== value) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  applyDeltaToSubscription(queryId, delta) {
+    const sub = this.subscriptions.get(queryId);
+    if (!sub) return;
+    switch (delta.type) {
+      case "add":
+        sub.lastResult = [...sub.lastResult, delta.node];
+        break;
+      case "remove":
+        sub.lastResult = sub.lastResult.filter((n) => n.id !== delta.nodeId);
+        break;
+      case "update":
+        sub.lastResult = sub.lastResult.map((n) => n.id === delta.nodeId ? delta.node : n);
+        break;
+    }
+  }
+  setStatus(status) {
+    this.status = status;
+    for (const handler of this.statusHandlers) {
+      handler(status);
+    }
+  }
+  /**
+   * Evict unused Y.Docs from the pool to manage memory.
+   * Only evicts docs with refCount=0 that haven't been accessed recently.
+   */
+  evictOldDocs() {
+    if (this.docPool.size < MAX_DOC_POOL_SIZE) return;
+    const now = Date.now();
+    const candidates = [];
+    for (const [nodeId, entry] of this.docPool) {
+      if (entry.refCount === 0 && now - entry.lastAccessed > MIN_DOC_AGE_FOR_EVICTION) {
+        candidates.push({ nodeId, lastAccessed: entry.lastAccessed });
+      }
+    }
+    if (candidates.length === 0) return;
+    candidates.sort((a, b) => a.lastAccessed - b.lastAccessed);
+    const targetSize = Math.floor(MAX_DOC_POOL_SIZE * 0.8);
+    const toEvict = this.docPool.size - targetSize;
+    for (let i = 0; i < Math.min(toEvict, candidates.length); i++) {
+      const nodeId = candidates[i].nodeId;
+      const entry = this.docPool.get(nodeId);
+      if (entry) {
+        if (this.storage) {
+          const content = Y.encodeStateAsUpdate(entry.doc);
+          this.storage.setDocumentContent(nodeId, content).catch(() => {
+          });
+        }
+        entry.doc.destroy();
+        this.docPool.delete(nodeId);
+      }
+    }
+  }
+};
+expose(new DataWorker());

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@xnetjs/data-bridge",
+  "version": "0.0.2",
+  "description": "DataBridge abstraction for off-main-thread data access in xNet",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/crs48/xNet"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./worker": {
+      "import": "./dist/worker/data-worker.js",
+      "types": "./dist/worker/data-worker.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "comlink": "^4.4.2",
+    "y-protocols": "^1.0.6",
+    "yjs": "^13.6.24",
+    "@xnetjs/core": "0.0.2",
+    "@xnetjs/data": "0.0.2"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^4.0.0",
+    "@xnetjs/crypto": "0.0.2",
+    "@xnetjs/identity": "0.0.2"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/worker/data-worker.ts --format esm --dts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}