@xnetjs/data-bridge 0.0.2 → 0.0.3

package/dist/chunk-5GTIP33X.js

@@ -0,0 +1,201 @@
+// src/query-descriptor.ts
+import {
+  applyNodeQueryDescriptor,
+  createNodeQueryDescriptor,
+  decodeNodeQueryCursor,
+  encodeNodeQueryCursor,
+  matchesNodeQueryDescriptor,
+  nodeQueryDescriptorNeedsBoundedReload,
+  nodeQueryDescriptorToOptions,
+  serializeNodeQueryDescriptor,
+  sortNodeQueryResults
+} from "@xnetjs/data";
+var BOUNDED_QUERY_OVERFETCH = 25;
+var QUERY_EXECUTION_MODES = /* @__PURE__ */ new Set([
+  "local",
+  "local-then-remote",
+  "remote",
+  "live",
+  "stream"
+]);
+var QUERY_SOURCE_PREFERENCES = /* @__PURE__ */ new Set([
+  "auto",
+  "local",
+  "hub",
+  "federated"
+]);
+function toNodeDescriptor(descriptor) {
+  return descriptor;
+}
+function normalizeQueryExecutionMode(mode) {
+  return mode && QUERY_EXECUTION_MODES.has(mode) ? mode : void 0;
+}
+function normalizeQuerySourcePreference(source) {
+  return source && QUERY_SOURCE_PREFERENCES.has(source) ? source : void 0;
+}
+function createQueryDescriptor(schemaId, options) {
+  const descriptor = createNodeQueryDescriptor(
+    schemaId,
+    options
+  );
+  const mode = normalizeQueryExecutionMode(options?.mode);
+  const source = normalizeQuerySourcePreference(options?.source);
+  return {
+    ...descriptor,
+    ...mode ? { mode } : {},
+    ...source ? { source } : {}
+  };
+}
+function queryDescriptorToOptions(descriptor) {
+  return {
+    ...nodeQueryDescriptorToOptions(toNodeDescriptor(descriptor)),
+    ...descriptor.mode ? { mode: descriptor.mode } : {},
+    ...descriptor.source ? { source: descriptor.source } : {}
+  };
+}
+function serializeQueryDescriptor(descriptor) {
+  return serializeNodeQueryDescriptor(toNodeDescriptor(descriptor));
+}
+function encodeQueryCursor(descriptor, node) {
+  return encodeNodeQueryCursor(toNodeDescriptor(descriptor), node);
+}
+function decodeQueryCursor(cursor) {
+  return decodeNodeQueryCursor(cursor);
+}
+function matchesQueryDescriptor(descriptor, node) {
+  return matchesNodeQueryDescriptor(toNodeDescriptor(descriptor), node);
+}
+function filterQueryNodes(nodes, descriptor) {
+  return nodes.filter((node) => matchesQueryDescriptor(descriptor, node));
+}
+function sortQueryNodes(nodes, descriptor) {
+  return sortNodeQueryResults(nodes, toNodeDescriptor(descriptor));
+}
+function applyQueryDescriptor(nodes, descriptor) {
+  return applyNodeQueryDescriptor(nodes, toNodeDescriptor(descriptor));
+}
+function queryDescriptorNeedsBoundedReload(descriptor) {
+  return nodeQueryDescriptorNeedsBoundedReload(toNodeDescriptor(descriptor));
+}
+function areNodeStatesEquivalent(left, right) {
+  if (left === right) return true;
+  if (left.id !== right.id || left.schemaId !== right.schemaId || left.deleted !== right.deleted || left.createdAt !== right.createdAt || left.createdBy !== right.createdBy || left.updatedAt !== right.updatedAt || left.updatedBy !== right.updatedBy) {
+    return false;
+  }
+  const leftKeys = Object.keys(left.properties);
+  const rightKeys = Object.keys(right.properties);
+  if (leftKeys.length !== rightKeys.length) return false;
+  for (const key of leftKeys) {
+    if (left.properties[key] !== right.properties[key]) return false;
+  }
+  return true;
+}
+function reuseEquivalentNodeReferences(nextNodes, previousNodes) {
+  if (!previousNodes || previousNodes.length === 0 || nextNodes.length === 0) {
+    return nextNodes;
+  }
+  const previousById = /* @__PURE__ */ new Map();
+  for (const node of previousNodes) {
+    if (node) previousById.set(node.id, node);
+  }
+  let reusedAny = false;
+  const merged = nextNodes.map((node) => {
+    const previous = previousById.get(node.id);
+    if (previous && areNodeStatesEquivalent(previous, node)) {
+      reusedAny = true;
+      return previous;
+    }
+    return node;
+  });
+  return reusedAny ? merged : nextNodes;
+}
+function queryDescriptorSupportsBoundedDelta(descriptor) {
+  return descriptor.limit !== void 0 && descriptor.limit > 0 && (descriptor.offset ?? 0) === 0 && descriptor.after === void 0 && descriptor.materializedView === void 0 && descriptor.orderBy !== void 0 && Object.keys(descriptor.orderBy).length > 0;
+}
+function createBoundedWorkingSetDescriptor(descriptor) {
+  return { ...descriptor, limit: descriptor.limit + BOUNDED_QUERY_OVERFETCH };
+}
+function createBoundedWorkingSet(descriptor, nodes) {
+  const capacity = descriptor.limit + BOUNDED_QUERY_OVERFETCH;
+  return { nodes, complete: nodes.length < capacity };
+}
+function applyNodeChangeToBoundedQueryResult(input) {
+  const { descriptor, workingSet, nodeId, nextNode } = input;
+  const limit = descriptor.limit;
+  const currentNodes = workingSet.nodes;
+  const currentContains = currentNodes.some((node) => node.id === nodeId);
+  const nextMatches = matchesQueryDescriptor(descriptor, nextNode);
+  if (!currentContains && !nextMatches) {
+    return { kind: "noop" };
+  }
+  const base = currentContains ? currentNodes.filter((node) => node.id !== nodeId) : currentNodes;
+  if (!nextMatches || !nextNode) {
+    if (!workingSet.complete && base.length < limit) {
+      return { kind: "reload" };
+    }
+    return boundedSet(base, workingSet.complete, limit);
+  }
+  const merged = sortQueryNodes([...base, nextNode], descriptor);
+  if (!workingSet.complete) {
+    if (base.length < limit) {
+      return { kind: "reload" };
+    }
+    if (merged[merged.length - 1]?.id === nodeId) {
+      return currentContains ? boundedSet(base, false, limit) : { kind: "noop" };
+    }
+  }
+  return boundedSet(merged, workingSet.complete, limit);
+}
+function boundedSet(nodes, complete, limit) {
+  return {
+    kind: "set",
+    data: nodes.slice(0, limit),
+    workingSet: { nodes, complete }
+  };
+}
+function applyNodeChangeToQueryResult(input) {
+  const { descriptor, currentData, nodeId, nextNode } = input;
+  const currentIndex = currentData.findIndex((node) => node.id === nodeId);
+  const currentContains = currentIndex >= 0;
+  const nextMatches = matchesQueryDescriptor(descriptor, nextNode);
+  if (queryDescriptorNeedsBoundedReload(descriptor)) {
+    return currentContains || nextMatches ? { kind: "reload" } : { kind: "noop" };
+  }
+  if (!currentContains && !nextMatches) {
+    return { kind: "noop" };
+  }
+  if (currentContains && !nextMatches) {
+    return {
+      kind: "set",
+      data: currentData.filter((node) => node.id !== nodeId)
+    };
+  }
+  if (!nextNode) {
+    return { kind: "noop" };
+  }
+  const nextData = currentContains ? currentData.map((node) => node.id === nodeId ? nextNode : node) : [...currentData, nextNode];
+  return {
+    kind: "set",
+    data: applyQueryDescriptor(nextData, descriptor)
+  };
+}
+
+export {
+  BOUNDED_QUERY_OVERFETCH,
+  createQueryDescriptor,
+  queryDescriptorToOptions,
+  serializeQueryDescriptor,
+  encodeQueryCursor,
+  decodeQueryCursor,
+  matchesQueryDescriptor,
+  filterQueryNodes,
+  sortQueryNodes,
+  applyQueryDescriptor,
+  queryDescriptorNeedsBoundedReload,
+  reuseEquivalentNodeReferences,
+  queryDescriptorSupportsBoundedDelta,
+  createBoundedWorkingSetDescriptor,
+  createBoundedWorkingSet,
+  applyNodeChangeToBoundedQueryResult,
+  applyNodeChangeToQueryResult
+};

package/dist/chunk-EPNW4GGU.js

@@ -0,0 +1,460 @@
+// src/utils/binary-state.ts
+var TAG_NULL = 0;
+var TAG_UNDEFINED = 1;
+var TAG_BOOLEAN_FALSE = 2;
+var TAG_BOOLEAN_TRUE = 3;
+var TAG_NUMBER = 4;
+var TAG_STRING = 5;
+var TAG_UINT8ARRAY = 6;
+var TAG_ARRAY = 7;
+var TAG_OBJECT = 8;
+var TAG_BIGINT = 9;
+var NodeStateEncoder = class {
+  chunks = [];
+  textEncoder = new TextEncoder();
+  /**
+   * Encode an array of NodeState objects.
+   */
+  encode(states) {
+    this.chunks = [];
+    this.writeUint32(states.length);
+    for (const state of states) {
+      this.writeNodeState(state);
+    }
+    return this.finish();
+  }
+  writeNodeState(state) {
+    this.writeString(state.id);
+    this.writeString(state.schemaId);
+    this.writeProperties(state.properties);
+    this.writeTimestamps(state.timestamps);
+    this.writeByte(state.deleted ? 1 : 0);
+    if (state.deletedAt) {
+      this.writeByte(1);
+      this.writeTimestamp(state.deletedAt);
+    } else {
+      this.writeByte(0);
+    }
+    this.writeFloat64(state.createdAt);
+    this.writeString(state.createdBy);
+    this.writeFloat64(state.updatedAt);
+    this.writeString(state.updatedBy);
+    if (state.documentContent) {
+      this.writeByte(1);
+      this.writeUint8Array(state.documentContent);
+    } else {
+      this.writeByte(0);
+    }
+    if (state._unknown && Object.keys(state._unknown).length > 0) {
+      this.writeByte(1);
+      this.writeProperties(state._unknown);
+    } else {
+      this.writeByte(0);
+    }
+    if (state._schemaVersion) {
+      this.writeByte(1);
+      this.writeString(state._schemaVersion);
+    } else {
+      this.writeByte(0);
+    }
+  }
+  writeProperties(props) {
+    const keys = Object.keys(props);
+    this.writeUint32(keys.length);
+    for (const key of keys) {
+      this.writeString(key);
+      this.writeValue(props[key]);
+    }
+  }
+  writeTimestamps(timestamps) {
+    const keys = Object.keys(timestamps);
+    this.writeUint32(keys.length);
+    for (const key of keys) {
+      this.writeString(key);
+      this.writeTimestamp(timestamps[key]);
+    }
+  }
+  writeTimestamp(ts) {
+    this.writeUint32(ts.lamport);
+    this.writeString(ts.author);
+    this.writeFloat64(ts.wallTime);
+  }
+  writeValue(value) {
+    if (value === null) {
+      this.writeByte(TAG_NULL);
+    } else if (value === void 0) {
+      this.writeByte(TAG_UNDEFINED);
+    } else if (typeof value === "boolean") {
+      this.writeByte(value ? TAG_BOOLEAN_TRUE : TAG_BOOLEAN_FALSE);
+    } else if (typeof value === "number") {
+      this.writeByte(TAG_NUMBER);
+      this.writeFloat64(value);
+    } else if (typeof value === "string") {
+      this.writeByte(TAG_STRING);
+      this.writeString(value);
+    } else if (value instanceof Uint8Array) {
+      this.writeByte(TAG_UINT8ARRAY);
+      this.writeUint8Array(value);
+    } else if (Array.isArray(value)) {
+      this.writeByte(TAG_ARRAY);
+      this.writeUint32(value.length);
+      for (const item of value) {
+        this.writeValue(item);
+      }
+    } else if (typeof value === "bigint") {
+      this.writeByte(TAG_BIGINT);
+      this.writeString(value.toString());
+    } else if (typeof value === "object") {
+      this.writeByte(TAG_OBJECT);
+      const obj = value;
+      const keys = Object.keys(obj);
+      this.writeUint32(keys.length);
+      for (const key of keys) {
+        this.writeString(key);
+        this.writeValue(obj[key]);
+      }
+    } else {
+      this.writeByte(TAG_STRING);
+      this.writeString(JSON.stringify(value));
+    }
+  }
+  writeByte(value) {
+    this.chunks.push(new Uint8Array([value]));
+  }
+  writeUint32(value) {
+    const buf = new ArrayBuffer(4);
+    new DataView(buf).setUint32(0, value, true);
+    this.chunks.push(new Uint8Array(buf));
+  }
+  writeFloat64(value) {
+    const buf = new ArrayBuffer(8);
+    new DataView(buf).setFloat64(0, value, true);
+    this.chunks.push(new Uint8Array(buf));
+  }
+  writeString(value) {
+    const bytes = this.textEncoder.encode(value);
+    this.writeUint32(bytes.length);
+    this.chunks.push(bytes);
+  }
+  writeUint8Array(value) {
+    this.writeUint32(value.length);
+    this.chunks.push(value);
+  }
+  finish() {
+    let totalSize = 0;
+    for (const chunk of this.chunks) {
+      totalSize += chunk.length;
+    }
+    const result = new Uint8Array(totalSize);
+    let offset = 0;
+    for (const chunk of this.chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result;
+  }
+};
+var NodeStateDecoder = class {
+  data;
+  view;
+  offset = 0;
+  textDecoder = new TextDecoder();
+  constructor(data) {
+    this.data = data;
+    this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  }
+  /**
+   * Decode a Uint8Array back to an array of NodeState objects.
+   */
+  decode() {
+    const count = this.readUint32();
+    const states = [];
+    for (let i = 0; i < count; i++) {
+      states.push(this.readNodeState());
+    }
+    return states;
+  }
+  readNodeState() {
+    const id = this.readString();
+    const schemaId = this.readString();
+    const properties = this.readProperties();
+    const timestamps = this.readTimestamps();
+    const deleted = this.readByte() === 1;
+    const hasDeletedAt = this.readByte() === 1;
+    const deletedAt = hasDeletedAt ? this.readTimestamp() : void 0;
+    const createdAt = this.readFloat64();
+    const createdBy = this.readString();
+    const updatedAt = this.readFloat64();
+    const updatedBy = this.readString();
+    const hasDocumentContent = this.readByte() === 1;
+    const documentContent = hasDocumentContent ? this.readUint8Array() : void 0;
+    const hasUnknown = this.readByte() === 1;
+    const _unknown = hasUnknown ? this.readProperties() : void 0;
+    const hasSchemaVersion = this.readByte() === 1;
+    const _schemaVersion = hasSchemaVersion ? this.readString() : void 0;
+    const state = {
+      id,
+      schemaId,
+      properties,
+      timestamps,
+      deleted,
+      createdAt,
+      createdBy,
+      updatedAt,
+      updatedBy
+    };
+    if (deletedAt) state.deletedAt = deletedAt;
+    if (documentContent) state.documentContent = documentContent;
+    if (_unknown) state._unknown = _unknown;
+    if (_schemaVersion) state._schemaVersion = _schemaVersion;
+    return state;
+  }
+  readProperties() {
+    const count = this.readUint32();
+    const props = {};
+    for (let i = 0; i < count; i++) {
+      const key = this.readString();
+      const value = this.readValue();
+      props[key] = value;
+    }
+    return props;
+  }
+  readTimestamps() {
+    const count = this.readUint32();
+    const timestamps = {};
+    for (let i = 0; i < count; i++) {
+      const key = this.readString();
+      timestamps[key] = this.readTimestamp();
+    }
+    return timestamps;
+  }
+  readTimestamp() {
+    const lamport = this.readUint32();
+    const author = this.readString();
+    const wallTime = this.readFloat64();
+    return {
+      lamport,
+      author,
+      wallTime
+    };
+  }
+  readValue() {
+    const tag = this.readByte();
+    switch (tag) {
+      case TAG_NULL:
+        return null;
+      case TAG_UNDEFINED:
+        return void 0;
+      case TAG_BOOLEAN_FALSE:
+        return false;
+      case TAG_BOOLEAN_TRUE:
+        return true;
+      case TAG_NUMBER:
+        return this.readFloat64();
+      case TAG_STRING:
+        return this.readString();
+      case TAG_UINT8ARRAY:
+        return this.readUint8Array();
+      case TAG_ARRAY: {
+        const length = this.readUint32();
+        const arr = [];
+        for (let i = 0; i < length; i++) {
+          arr.push(this.readValue());
+        }
+        return arr;
+      }
+      case TAG_BIGINT:
+        return BigInt(this.readString());
+      case TAG_OBJECT: {
+        const length = this.readUint32();
+        const obj = {};
+        for (let i = 0; i < length; i++) {
+          const key = this.readString();
+          obj[key] = this.readValue();
+        }
+        return obj;
+      }
+      default:
+        throw new Error(`Unknown tag: ${tag}`);
+    }
+  }
+  readByte() {
+    return this.data[this.offset++];
+  }
+  readUint32() {
+    const value = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  readFloat64() {
+    const value = this.view.getFloat64(this.offset, true);
+    this.offset += 8;
+    return value;
+  }
+  readString() {
+    const length = this.readUint32();
+    const bytes = this.data.subarray(this.offset, this.offset + length);
+    this.offset += length;
+    return this.textDecoder.decode(bytes);
+  }
+  readUint8Array() {
+    const length = this.readUint32();
+    const bytes = this.data.slice(this.offset, this.offset + length);
+    this.offset += length;
+    return bytes;
+  }
+};
+function encodeNodeStates(states) {
+  return new NodeStateEncoder().encode(states);
+}
+function decodeNodeStates(data) {
+  return new NodeStateDecoder(data).decode();
+}
+function shouldUseBinaryEncoding(states) {
+  if (states.length > 100) return true;
+  return states.some((s) => s.documentContent && s.documentContent.length > 1e3);
+}
+function encodeWorkerQuerySnapshot(nodes) {
+  if (!shouldUseBinaryEncoding(nodes)) {
+    return { encoding: "json", nodes };
+  }
+  return { encoding: "binary", data: encodeNodeStates(nodes) };
+}
+function decodeWorkerQuerySnapshot(snapshot) {
+  return snapshot.encoding === "binary" ? decodeNodeStates(snapshot.data) : snapshot.nodes;
+}
+
+// src/worker/port-sqlite-adapter.ts
+import { wrap } from "comlink";
+var PortSQLiteAdapter = class {
+  port;
+  proxy;
+  inTransaction = false;
+  constructor(port) {
+    this.port = port;
+    this.proxy = wrap(port);
+  }
+  async open(_config) {
+    if (!this.proxy) throw new Error("Port closed");
+    const isOpen = await this.proxy.isOpen();
+    if (!isOpen) {
+      throw new Error("PortSQLiteAdapter: database not open on the SQLite worker");
+    }
+  }
+  async close() {
+    this.proxy = null;
+    this.port?.close();
+    this.port = null;
+    this.inTransaction = false;
+  }
+  isOpen() {
+    return this.proxy !== null;
+  }
+  requireProxy() {
+    if (!this.proxy) throw new Error("Database not open");
+    return this.proxy;
+  }
+  async query(sql, params) {
+    const result = await this.requireProxy().query(sql, params);
+    return result;
+  }
+  async queryOne(sql, params) {
+    const result = await this.requireProxy().queryOne(sql, params);
+    return result;
+  }
+  async run(sql, params) {
+    return this.requireProxy().run(sql, params);
+  }
+  async exec(sql) {
+    return this.requireProxy().exec(sql);
+  }
+  async transaction(_fn) {
+    throw new Error("Complex transactions not supported over a port. Use transactionBatch().");
+  }
+  async transactionBatch(operations) {
+    await this.requireProxy().transaction(operations);
+  }
+  async applyNodeBatch(input) {
+    return this.requireProxy().applyNodeBatch(input);
+  }
+  async beginTransaction() {
+    if (this.inTransaction) {
+      throw new Error("Transaction already in progress");
+    }
+    await this.requireProxy().exec("BEGIN IMMEDIATE");
+    this.inTransaction = true;
+  }
+  async commit() {
+    if (!this.inTransaction) {
+      throw new Error("No transaction in progress");
+    }
+    await this.requireProxy().exec("COMMIT");
+    this.inTransaction = false;
+  }
+  async rollback() {
+    if (!this.inTransaction) {
+      return;
+    }
+    await this.requireProxy().exec("ROLLBACK");
+    this.inTransaction = false;
+  }
+  async prepare(_sql) {
+    throw new Error("Prepared statements not supported over a port. Use query() or run().");
+  }
+  async getSchemaVersion() {
+    return this.requireProxy().getSchemaVersion();
+  }
+  // Schema versioning mirrors WebSQLiteProxy byte-for-byte on purpose:
+  // both speak the same worker protocol against the same _schema_version
+  // table, and diverging here would corrupt version tracking.
+  async setSchemaVersion(version) {
+    await this.requireProxy().run(
+      "INSERT INTO _schema_version (version, applied_at) VALUES (?, ?)",
+      [version, Date.now()]
+    );
+  }
+  async applySchema(version, sql) {
+    const currentVersion = await this.getSchemaVersion();
+    if (currentVersion >= version) return false;
+    await this.exec(sql);
+    await this.setSchemaVersion(version);
+    return true;
+  }
+  async getDatabaseSize() {
+    return this.requireProxy().getDatabaseSize();
+  }
+  async vacuum() {
+    return this.requireProxy().vacuum();
+  }
+  async checkpoint() {
+    return 0;
+  }
+  async getStorageMode() {
+    return this.requireProxy().getStorageMode();
+  }
+};
+
+// src/utils/change-events.ts
+function groupNodeChangeEventsBySchema(events) {
+  const eventsBySchema = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const schemaId = event.node?.schemaId ?? event.change.payload.schemaId;
+    if (!schemaId) continue;
+    const next = eventsBySchema.get(schemaId) ?? [];
+    next.push(event);
+    eventsBySchema.set(schemaId, next);
+  }
+  return eventsBySchema;
+}
+
+export {
+  groupNodeChangeEventsBySchema,
+  NodeStateEncoder,
+  NodeStateDecoder,
+  encodeNodeStates,
+  decodeNodeStates,
+  shouldUseBinaryEncoding,
+  encodeWorkerQuerySnapshot,
+  decodeWorkerQuerySnapshot,
+  PortSQLiteAdapter
+};