korajs 0.4.0 → 0.5.0

package/dist/chunk-WALHLVVF.js

@@ -0,0 +1,683 @@
+// src/apply-pipeline.ts
+import { HybridLogicalClock, KoraError, createOperation as createOperation2 } from "@korajs/core";
+import { topologicalSort } from "@korajs/core/internal";
+import { buildMergeRelationLookup, checkReferentialIntegrityOnDelete } from "@korajs/merge";
+import { richtextStatesEqual } from "@korajs/store";
+import {
+  executeDelete,
+  executeInsert,
+  executeUpdate,
+  resolveCausalDeps
+} from "@korajs/store/internal";
+
+// src/build-side-effect-entry.ts
+import { createOperation } from "@korajs/core";
+import {
+  buildInsertQuery,
+  buildSoftDeleteQuery,
+  buildUpdateQuery,
+  serializeOperation,
+  serializeRecord,
+  serializeRowVersion
+} from "@korajs/store/internal";
+async function buildSideEffectEntry(ctx, effect, parentOpId, transactionId, mutationName) {
+  const causalDeps = [parentOpId];
+  const baseInput = {
+    nodeId: ctx.nodeId,
+    collection: effect.collection,
+    recordId: effect.recordId,
+    sequenceNumber: await ctx.allocateSequenceNumber(),
+    causalDeps,
+    schemaVersion: ctx.schema.version,
+    ...transactionId !== void 0 ? { transactionId } : {},
+    ...mutationName !== void 0 ? { mutationName } : {}
+  };
+  if (effect.type === "delete") {
+    const operation2 = await createOperation(
+      {
+        ...baseInput,
+        type: "delete",
+        data: null,
+        previousData: effect.previousData
+      },
+      ctx.clock
+    );
+    ctx.causalTracker?.afterOperation(effect.collection, operation2.id, ctx.inTransaction);
+    const version2 = serializeRowVersion(operation2.timestamp);
+    const deleteQuery = buildSoftDeleteQuery(
+      effect.collection,
+      effect.recordId,
+      operation2.timestamp.wallTime,
+      version2
+    );
+    const opInsert2 = buildInsertQuery(
+      `_kora_ops_${effect.collection}`,
+      serializeOperation(operation2)
+    );
+    return {
+      operation: operation2,
+      collection: effect.collection,
+      commands: [
+        { sql: deleteQuery.sql, params: deleteQuery.params },
+        { sql: opInsert2.sql, params: opInsert2.params },
+        {
+          sql: "INSERT OR REPLACE INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
+          params: [ctx.nodeId, operation2.sequenceNumber]
+        }
+      ]
+    };
+  }
+  const operation = await createOperation(
+    {
+      ...baseInput,
+      type: "update",
+      data: effect.data,
+      previousData: effect.previousData
+    },
+    ctx.clock
+  );
+  ctx.causalTracker?.afterOperation(effect.collection, operation.id, ctx.inTransaction);
+  const definition = ctx.schema.collections[effect.collection];
+  const serializedChanges = effect.data && definition ? serializeRecord(effect.data, definition.fields) : effect.data ?? {};
+  const version = serializeRowVersion(operation.timestamp);
+  const updateQuery = buildUpdateQuery(effect.collection, effect.recordId, {
+    ...serializedChanges,
+    _updated_at: operation.timestamp.wallTime,
+    _version: version
+  });
+  const opInsert = buildInsertQuery(
+    `_kora_ops_${effect.collection}`,
+    serializeOperation(operation)
+  );
+  return {
+    operation,
+    collection: effect.collection,
+    commands: [
+      { sql: updateQuery.sql, params: updateQuery.params },
+      { sql: opInsert.sql, params: opInsert.params },
+      {
+        sql: "INSERT OR REPLACE INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
+        params: [ctx.nodeId, operation.sequenceNumber]
+      }
+    ]
+  };
+}
+
+// src/apply-pipeline.ts
+var ApplyPipeline = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.relationLookupMap = buildMergeRelationLookup(deps.store.getSchema());
+  }
+  deps;
+  relationLookupMap;
+  /** Local insert — same persistence path as remote apply side effects. */
+  async insert(collection, data) {
+    return executeInsert(this.deps.store.createMutationContext(collection), data);
+  }
+  /** Local update. */
+  async update(collection, id, data) {
+    return executeUpdate(this.deps.store.createMutationContext(collection), id, data);
+  }
+  /**
+   * Local delete with merge-package referential integrity (same rules as remote delete).
+   */
+  async delete(collection, id) {
+    const ctx = this.deps.store.createMutationContext(collection);
+    const causalDeps = resolveCausalDeps(ctx);
+    const operation = await createOperation2(
+      {
+        nodeId: ctx.nodeId,
+        type: "delete",
+        collection,
+        recordId: id,
+        data: null,
+        previousData: null,
+        sequenceNumber: await ctx.allocateSequenceNumber(),
+        causalDeps,
+        schemaVersion: ctx.schema.version
+      },
+      ctx.clock
+    );
+    ctx.causalTracker?.afterOperation(collection, operation.id, ctx.inTransaction);
+    const refCtx = createReferentialMergeContext(this.deps.store);
+    const check = await checkReferentialIntegrityOnDelete(
+      operation,
+      this.deps.store.getSchema(),
+      refCtx,
+      this.relationLookupMap
+    );
+    for (const trace of check.traces) {
+      this.deps.emitter?.emit({ type: "merge:conflict", trace });
+    }
+    if (!check.allowed) {
+      throw new KoraError(
+        `Cannot delete record "${id}" from "${collection}": referential restrict policy violated`,
+        "REFERENTIAL_INTEGRITY",
+        { collection, recordId: id }
+      );
+    }
+    await executeDelete(ctx, id, {
+      skipReferentialEnforcement: true,
+      operation
+    });
+    if (check.sideEffectOps.length > 0) {
+      await applySideEffectOps(this.deps.store, check.sideEffectOps, operation.id);
+    }
+  }
+  /**
+   * Commit a buffered transaction: merge-package delete enforcement, causal ordering, single DB txn.
+   */
+  async commitTransaction(batch) {
+    const store = this.deps.store;
+    const supplemental = [];
+    for (const entry of batch.entries) {
+      if (entry.operation.type !== "delete") {
+        continue;
+      }
+      const refCtx = createReferentialMergeContext(store);
+      const check = await checkReferentialIntegrityOnDelete(
+        entry.operation,
+        store.getSchema(),
+        refCtx,
+        this.relationLookupMap
+      );
+      for (const trace of check.traces) {
+        this.deps.emitter?.emit({ type: "merge:conflict", trace });
+      }
+      if (!check.allowed) {
+        throw new KoraError(
+          `Cannot delete record "${entry.operation.recordId}" from "${entry.collection}": referential restrict policy violated`,
+          "REFERENTIAL_INTEGRITY",
+          { collection: entry.collection, recordId: entry.operation.recordId }
+        );
+      }
+      for (const effect of check.sideEffectOps) {
+        const ctx2 = store.createMutationContext(effect.collection, { inTransaction: true });
+        supplemental.push(
+          await buildSideEffectEntry(
+            ctx2,
+            effect,
+            entry.operation.id,
+            batch.transactionId,
+            batch.mutationName
+          )
+        );
+      }
+    }
+    const allEntries = [...batch.entries, ...supplemental];
+    const sortedOps = topologicalSort(allEntries.map((e) => e.operation));
+    const commandsByOpId = new Map(allEntries.map((e) => [e.operation.id, e.commands]));
+    const ctx = store.createMutationContext(
+      batch.entries[0]?.collection ?? Object.keys(store.getSchema().collections)[0] ?? "todos",
+      { inTransaction: true }
+    );
+    await ctx.adapter.transaction(async (tx) => {
+      for (const op of sortedOps) {
+        const commands = commandsByOpId.get(op.id);
+        if (!commands) {
+          continue;
+        }
+        for (const cmd of commands) {
+          await tx.execute(cmd.sql, cmd.params);
+        }
+      }
+    });
+    const affectedCollections = /* @__PURE__ */ new Set();
+    for (const entry of allEntries) {
+      affectedCollections.add(entry.collection);
+    }
+    return { operations: sortedOps, affectedCollections };
+  }
+  async applyRemote(op) {
+    return this.apply(op, { mode: "remote", schema: this.deps.store.getSchema() });
+  }
+  async apply(op, context) {
+    if (context.mode === "local") {
+      return this.deps.store.applyRemoteOperation(op);
+    }
+    if (op.type === "delete") {
+      return this.applyRemoteDelete(op);
+    }
+    if (op.type === "insert" && op.data) {
+      return this.applyRemoteInsert(op);
+    }
+    if (op.type === "update" && op.data && op.previousData) {
+      return this.applyRemoteUpdate(op);
+    }
+    return this.deps.store.applyRemoteOperation(op);
+  }
+  async applyRemoteDelete(op) {
+    const blocked = await this.resolveRemoteDeleteVsLocalUpdate(op);
+    if (blocked) {
+      return "skipped";
+    }
+    const refCtx = createReferentialMergeContext(this.deps.store);
+    const check = await checkReferentialIntegrityOnDelete(
+      op,
+      this.deps.store.getSchema(),
+      refCtx,
+      this.relationLookupMap
+    );
+    for (const trace of check.traces) {
+      this.deps.emitter?.emit({ type: "merge:conflict", trace });
+    }
+    if (!check.allowed) {
+      return "rejected";
+    }
+    const result = await this.deps.store.applyRemoteOperation(op);
+    if (result !== "applied") {
+      return result;
+    }
+    if (check.sideEffectOps.length > 0) {
+      await applySideEffectOps(this.deps.store, check.sideEffectOps, op.id);
+    }
+    return "applied";
+  }
+  /**
+   * When a local update is newer than a remote delete, keep the record alive.
+   */
+  async resolveRemoteDeleteVsLocalUpdate(op) {
+    const collectionDef = this.deps.store.getSchema().collections[op.collection];
+    if (!collectionDef) {
+      return false;
+    }
+    const localOp = await this.deps.store.getLatestLocalOperationForRecord(
+      op.collection,
+      op.recordId
+    );
+    if (!localOp || localOp.type !== "update") {
+      return false;
+    }
+    const baseState = localOp.previousData ?? {};
+    const mergeResult = await this.deps.mergeEngine.merge({
+      local: localOp,
+      remote: op,
+      baseState,
+      collectionDef
+    });
+    this.emitMergeLifecycle(op, localOp, mergeResult);
+    return mergeResult.appliedOperation === "local";
+  }
+  async applyRemoteUpdate(op) {
+    const schema = this.deps.store.getSchema();
+    const collectionDef = schema.collections[op.collection];
+    if (!collectionDef) {
+      return this.deps.store.applyRemoteOperation(op);
+    }
+    const accessor = this.deps.store.collection(op.collection);
+    const currentRecord = await accessor.findById(op.recordId);
+    if (!currentRecord) {
+      const tombstoneResult = await this.applyRemoteUpdateOnDeletedRow(op, collectionDef);
+      if (tombstoneResult !== null) {
+        return tombstoneResult;
+      }
+      return this.deps.store.applyRemoteOperation(op);
+    }
+    let hasConflict = false;
+    for (const field of Object.keys(op.data ?? {})) {
+      const fieldDef = collectionDef.fields[field];
+      const expectedBase = op.previousData?.[field];
+      const currentLocal = currentRecord[field];
+      if (fieldDef?.kind === "richtext") {
+        if (!richtextStatesEqual(currentLocal, expectedBase)) {
+          hasConflict = true;
+        }
+        continue;
+      }
+      if (!deepEqual(expectedBase, currentLocal)) {
+        hasConflict = true;
+        break;
+      }
+    }
+    if (!hasConflict) {
+      return this.deps.store.applyRemoteOperation(op);
+    }
+    return this.applyMergedUpdate(op, collectionDef, currentRecord, op.previousData ?? {});
+  }
+  /**
+   * Remote update vs local soft-delete: merge before materializing to avoid zombie rows.
+   */
+  async applyRemoteUpdateOnDeletedRow(op, collectionDef) {
+    const snapshot = await this.deps.store.findMaterializedRow(op.collection, op.recordId);
+    if (!snapshot?.deleted) {
+      return null;
+    }
+    const localOp = await this.deps.store.getLatestLocalOperationForRecord(
+      op.collection,
+      op.recordId
+    );
+    if (!localOp || localOp.type !== "delete") {
+      return null;
+    }
+    const mergeResult = await this.deps.mergeEngine.merge({
+      local: localOp,
+      remote: op,
+      baseState: op.previousData ?? {},
+      collectionDef
+    });
+    this.emitMergeLifecycle(op, localOp, mergeResult);
+    if (mergeResult.appliedOperation === "local") {
+      return "skipped";
+    }
+    const mergedOp = {
+      ...op,
+      data: { ...mergeResult.mergedData },
+      timestamp: maxTimestamp(op.timestamp, localOp.timestamp)
+    };
+    const applyResult = await this.deps.store.applyRemoteOperation(mergedOp, {
+      reactivateIfDeleted: true
+    });
+    if (applyResult === "applied" && mergeResult.sideEffects.length > 0) {
+      await applySideEffectOps(this.deps.store, mergeResult.sideEffects, op.id);
+    }
+    return applyResult;
+  }
+  async applyMergedUpdate(op, collectionDef, currentRecord, baseState, applyOptions) {
+    const localTimestamp = await resolveLocalTimestamp(
+      this.deps.store,
+      op.collection,
+      op.recordId,
+      currentRecord,
+      this.deps.store.getNodeId()
+    );
+    const localOp = {
+      ...op,
+      data: buildLocalDiff(baseState, currentRecord, Object.keys(op.data ?? {})),
+      previousData: op.previousData,
+      nodeId: this.deps.store.getNodeId(),
+      timestamp: localTimestamp
+    };
+    const constraintContext = createConstraintContext(this.deps.store);
+    const mergeResult = await this.deps.mergeEngine.merge(
+      {
+        local: localOp,
+        remote: op,
+        baseState,
+        collectionDef
+      },
+      constraintContext
+    );
+    this.emitMergeLifecycle(op, localOp, mergeResult);
+    const mergedOp = {
+      ...op,
+      data: mergeResult.mergedData,
+      timestamp: maxTimestamp(op.timestamp, localTimestamp)
+    };
+    const applyResult = await this.deps.store.applyRemoteOperation(mergedOp, applyOptions);
+    if (applyResult === "applied" && mergeResult.sideEffects.length > 0) {
+      await applySideEffectOps(this.deps.store, mergeResult.sideEffects, op.id);
+    }
+    return applyResult;
+  }
+  async applyRemoteInsert(op) {
+    const collectionDef = this.deps.store.getSchema().collections[op.collection];
+    if (!collectionDef || !op.data) {
+      return this.deps.store.applyRemoteOperation(op);
+    }
+    const snapshot = await this.deps.store.findMaterializedRow(op.collection, op.recordId);
+    if (!snapshot || snapshot.deleted) {
+      return this.deps.store.applyRemoteOperation(op);
+    }
+    const localOp = await resolveLocalOpForRecord(
+      this.deps.store,
+      op.collection,
+      op.recordId,
+      snapshot.record
+    );
+    const mergeResult = await this.deps.mergeEngine.merge({
+      local: localOp,
+      remote: op,
+      baseState: {},
+      collectionDef
+    });
+    this.emitMergeLifecycle(op, localOp, mergeResult);
+    const mergedOp = {
+      ...op,
+      data: mergeResult.mergedData,
+      timestamp: maxTimestamp(op.timestamp, localOp.timestamp)
+    };
+    return this.deps.store.applyRemoteOperation(mergedOp);
+  }
+  emitMergeLifecycle(remote, local, mergeResult) {
+    this.deps.emitter?.emit({
+      type: "merge:started",
+      operationA: remote,
+      operationB: local
+    });
+    const hadMergeConflict = mergeResult.traces.some(
+      (t) => t.strategy !== "no-conflict-local" && t.strategy !== "no-conflict-remote" && t.strategy !== "no-conflict-unchanged"
+    );
+    if (hadMergeConflict) {
+      this.deps.onMergeConflict?.();
+    }
+    for (const trace of mergeResult.traces) {
+      if (trace.strategy !== "no-conflict-local" && trace.strategy !== "no-conflict-remote" && trace.strategy !== "no-conflict-unchanged") {
+        this.deps.emitter?.emit({ type: "merge:conflict", trace });
+      }
+    }
+    const firstTrace = mergeResult.traces[0];
+    if (firstTrace) {
+      this.deps.emitter?.emit({ type: "merge:completed", trace: firstTrace });
+    }
+  }
+};
+async function resolveLocalOpForRecord(store, collection, recordId, record) {
+  const localLatest = await store.getLatestLocalOperationForRecord(collection, recordId);
+  if (localLatest) {
+    return localLatest;
+  }
+  const anyLatest = await store.getLatestOperationForRecord(collection, recordId);
+  if (anyLatest) {
+    return anyLatest;
+  }
+  return syntheticInsertFromSnapshot(
+    record,
+    collection,
+    store.getNodeId(),
+    store.getSchema().version
+  );
+}
+function syntheticInsertFromSnapshot(record, collection, nodeId, schemaVersion) {
+  const { id, createdAt, updatedAt, ...fields } = record;
+  return {
+    id: `synthetic-local-${id}`,
+    nodeId,
+    type: "insert",
+    collection,
+    recordId: id,
+    data: fields,
+    previousData: null,
+    timestamp: { wallTime: updatedAt, logical: 0, nodeId },
+    sequenceNumber: 0,
+    causalDeps: [],
+    schemaVersion
+  };
+}
+function createConstraintContext(store) {
+  return {
+    async queryRecords(collection, where) {
+      const rows = await store.collection(collection).where(where).exec();
+      return rows;
+    },
+    async countRecords(collection, where) {
+      return store.collection(collection).where(where).count();
+    }
+  };
+}
+function createReferentialMergeContext(store) {
+  return {
+    async queryRecords(collection, where) {
+      const rows = await store.collection(collection).where(where).exec();
+      return rows;
+    },
+    async recordExists(collection, recordId) {
+      const row = await store.collection(collection).findById(recordId);
+      return row !== null;
+    }
+  };
+}
+async function applySideEffectOps(store, sideEffects, parentOpId) {
+  for (const effect of sideEffects) {
+    const ctx = store.createMutationContext(effect.collection, {
+      extraCausalDeps: [parentOpId]
+    });
+    if (effect.type === "delete") {
+      await executeDelete(ctx, effect.recordId, { skipReferentialEnforcement: true });
+    } else if (effect.type === "update" && effect.data) {
+      await executeUpdate(ctx, effect.recordId, effect.data);
+    }
+  }
+}
+function buildLocalDiff(baseState, currentRecord, fields) {
+  const diff = {};
+  for (const field of fields) {
+    diff[field] = currentRecord[field];
+  }
+  return diff;
+}
+async function resolveLocalTimestamp(store, collection, recordId, currentRecord, nodeId) {
+  const latestLocal = await store.getLatestLocalOperationForRecord(collection, recordId);
+  if (latestLocal) {
+    return latestLocal.timestamp;
+  }
+  const updatedAt = currentRecord.updatedAt;
+  if (typeof updatedAt === "number") {
+    return { wallTime: updatedAt, logical: 0, nodeId };
+  }
+  return { wallTime: Date.now(), logical: 0, nodeId };
+}
+function maxTimestamp(a, b) {
+  return HybridLogicalClock.compare(a, b) >= 0 ? a : b;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (a === void 0 || b === void 0) return false;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((val, i) => deepEqual(val, b[i]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every(
+      (key) => deepEqual(a[key], b[key])
+    );
+  }
+  return false;
+}
+
+// src/merge-aware-sync-store.ts
+var MergeAwareSyncStore = class {
+  constructor(store, mergeEngine, emitter, options) {
+    this.store = store;
+    this.pipeline = new ApplyPipeline({
+      store,
+      mergeEngine,
+      emitter,
+      onMergeConflict: options?.onMergeConflict
+    });
+  }
+  store;
+  pipeline;
+  getVersionVector() {
+    return this.store.getVersionVector();
+  }
+  getNodeId() {
+    return this.store.getNodeId();
+  }
+  async getOperationRange(nodeId, fromSeq, toSeq) {
+    return this.store.getOperationRange(nodeId, fromSeq, toSeq);
+  }
+  async applyRemoteOperation(op) {
+    return this.pipeline.applyRemote(op);
+  }
+};
+
+// src/store-queue-storage.ts
+import { deserializeOperation, serializeOperation as serializeOperation2 } from "@korajs/store/internal";
+var StoreQueueStorage = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  adapter;
+  async load() {
+    const rows = await this.adapter.query(
+      "SELECT id, payload FROM _kora_sync_queue ORDER BY rowid ASC"
+    );
+    return rows.map((row) => operationFromQueuePayload(row.payload));
+  }
+  async enqueue(op) {
+    const row = serializeOperation2(op);
+    const payload = { ...row, _collection: op.collection };
+    await this.adapter.execute(
+      "INSERT OR REPLACE INTO _kora_sync_queue (id, payload) VALUES (?, ?)",
+      [op.id, JSON.stringify(payload)]
+    );
+  }
+  async dequeue(ids) {
+    if (ids.length === 0) return;
+    const placeholders = ids.map(() => "?").join(", ");
+    await this.adapter.execute(`DELETE FROM _kora_sync_queue WHERE id IN (${placeholders})`, ids);
+  }
+  async count() {
+    const rows = await this.adapter.query(
+      "SELECT COUNT(*) as cnt FROM _kora_sync_queue"
+    );
+    return rows[0]?.cnt ?? 0;
+  }
+};
+function operationFromQueuePayload(payload) {
+  const parsed = JSON.parse(payload);
+  const op = deserializeOperation(parsed);
+  return {
+    ...op,
+    collection: parsed._collection
+  };
+}
+
+// src/store-sync-state.ts
+import "@korajs/store";
+import { decodeDeltaCursor, encodeDeltaCursor, operationMatchesScope } from "@korajs/sync";
+var StoreSyncStatePersistence = class {
+  constructor(store, scope) {
+    this.store = store;
+    this.scope = scope;
+  }
+  store;
+  scope;
+  loadLastAckedServerVector() {
+    return this.store.loadLastAckedServerVector();
+  }
+  saveLastAckedServerVector(vector) {
+    return this.store.saveLastAckedServerVector(vector);
+  }
+  mergeServerVectors(a, b) {
+    return this.store.mergeServerVectors(a, b);
+  }
+  async countUnsyncedOperations(serverVector) {
+    const ops = await this.getUnsyncedOperations(serverVector);
+    return ops.length;
+  }
+  async getUnsyncedOperations(serverVector) {
+    const ops = await this.store.getUnsyncedOperations(serverVector);
+    return ops.filter((op) => operationMatchesScope(op, this.scope));
+  }
+  loadDeltaCursor() {
+    return this.store.loadDeltaCursor().then((encoded) => decodeDeltaCursor(encoded));
+  }
+  async saveDeltaCursor(cursor) {
+    await this.store.saveDeltaCursor(cursor ? encodeDeltaCursor(cursor) : null);
+  }
+};
+
+export {
+  ApplyPipeline,
+  MergeAwareSyncStore,
+  StoreQueueStorage,
+  StoreSyncStatePersistence
+};
+//# sourceMappingURL=chunk-WALHLVVF.js.map