@korajs/store 1.0.0-beta.13 → 1.0.0-beta.14

package/dist/adapters/sqlite-wasm.js

@@ -6,22 +6,22 @@ import {
   loadDumpFromIndexedDB,
   readManifestRecord,
   restoreDumpStatements
-} from "../chunk-QDUSJMFV.js";
+} from "../chunk-BQSIL6TT.js";
 import {
   WebWorkerBridge
-} from "../chunk-MCQKEHOD.js";
+} from "../chunk-KK3GBONL.js";
 import {
   Mutex
 } from "../chunk-TVJEC5S2.js";
 import {
   leaderLockName,
   opfsPoolNameFor
-} from "../chunk-W5F2LWG6.js";
+} from "../chunk-5JMGMPUE.js";
 import {
   AdapterError,
   StorageInUseError,
   UnsyncedDataError
-} from "../chunk-DUKTWVZW.js";
+} from "../chunk-SRHDJF5B.js";
 
 // src/adapters/local-databases.ts
 async function listLocalDatabases() {
@@ -52,7 +52,7 @@ async function deleteLocalDatabase(dbName, options) {
   const record = await readManifestRecord(dbName);
   const backend = record?.backend ?? "opfs";
   return withExclusiveDatabase(dbName, async () => {
-    const { WebWorkerBridge: WebWorkerBridge2 } = await import("../sqlite-wasm-channel-MLHLKEED.js");
+    const { WebWorkerBridge: WebWorkerBridge2 } = await import("../sqlite-wasm-channel-QCCNBYCU.js");
     const worker = new WebWorkerBridge2(options.workerUrl, options.workerResponseTimeoutMs ?? 3e4);
     const send = async (request) => worker.send(request);
     const reader = {

package/dist/{backup-4NUPDEMB.js → backup-IHKVMUAM.js}

@@ -7,11 +7,11 @@ import {
   readBackupManifest,
   restoreBackup,
   verifyBackupChecksum
-} from "./chunk-P4V375FY.js";
-import "./chunk-32EDKWMI.js";
-import "./chunk-SJP2HTYZ.js";
+} from "./chunk-UC2LGFPV.js";
+import "./chunk-KTVNANUH.js";
+import "./chunk-QW4UU7NG.js";
 import "./chunk-J5AGXF3D.js";
-import "./chunk-DUKTWVZW.js";
+import "./chunk-SRHDJF5B.js";
 export {
   BACKUP_VERSION,
   BackupFormatError,
@@ -22,4 +22,4 @@ export {
   restoreBackup,
   verifyBackupChecksum
 };
-//# sourceMappingURL=backup-4NUPDEMB.js.map
+//# sourceMappingURL=backup-IHKVMUAM.js.map

package/dist/{chunk-Y5LRH7KI.js → chunk-5AQSGMJV.js}

@@ -16,7 +16,7 @@ import {
   writeDeleteInTx,
   writeInsertInTx,
   writeUpdateInTx
-} from "./chunk-HZTDBLDB.js";
+} from "./chunk-BILSA6XZ.js";
 import {
   STORED_SCHEMA_VERSION_SQL,
   parseSchemaAhead,
@@ -27,7 +27,7 @@ import {
   LOG_QUARANTINE_TABLE,
   readBackupManifest,
   scanLogIntegrity
-} from "./chunk-P4V375FY.js";
+} from "./chunk-UC2LGFPV.js";
 import {
   COMPACTED_THROUGH_TABLE,
   FOLD_MATERIALIZATION_CURRENT,
@@ -47,7 +47,7 @@ import {
   renumberOperationRow,
   repairSequenceUniqueness,
   rewriteDependentsInTx
-} from "./chunk-32EDKWMI.js";
+} from "./chunk-KTVNANUH.js";
 import {
   DELIVERY_WATERMARK_META_KEY,
   DELTA_CURSOR_META_KEY,
@@ -99,7 +99,7 @@ import {
   seedTerminalRejectionsOnce,
   serializeRowVersion,
   setLocalNodePrincipal
-} from "./chunk-SJP2HTYZ.js";
+} from "./chunk-QW4UU7NG.js";
 import {
   decodeRichtextFieldsFromOpData,
   deserializeOperationWithCollection,
@@ -110,12 +110,13 @@ import {
   toRichtextReadShape
 } from "./chunk-J5AGXF3D.js";
 import {
+  NodeOwnedByAnotherUserError,
   OptimisticLockError,
   QueryError,
   RecordNotFoundError,
   SchemaVersionAheadError,
   StoreNotOpenError
-} from "./chunk-DUKTWVZW.js";
+} from "./chunk-SRHDJF5B.js";
 
 // src/store/store.ts
 import {
@@ -140,7 +141,7 @@ import {
 // src/collection/collection.ts
 import { quoteIdent } from "@korajs/core";
 var Collection = class {
-  constructor(name, definition, schema, adapter, clock, nodeId, onMutation, relationEnforcer, mutationHandler, causalTracker, secretKeyProvider, onStorageError, fold, maxOperationBytes) {
+  constructor(name, definition, schema, adapter, clock, nodeId, onMutation, relationEnforcer, mutationHandler, causalTracker, secretKeyProvider, onStorageError, fold, maxOperationBytes, assertLocalWriteAllowed) {
     this.name = name;
     this.definition = definition;
     this.schema = schema;
@@ -155,6 +156,7 @@ var Collection = class {
     this.onStorageError = onStorageError;
     this.fold = fold;
     this.maxOperationBytes = maxOperationBytes;
+    this.assertLocalWriteAllowed = assertLocalWriteAllowed;
   }
   name;
   definition;
@@ -170,6 +172,7 @@ var Collection = class {
   onStorageError;
   fold;
   maxOperationBytes;
+  assertLocalWriteAllowed;
   /**
    * Point this collection at the store's new device identity after a node-id
    * rotation (RT-21). Internal: called by the owning Store only.
@@ -197,7 +200,8 @@ var Collection = class {
       causalTracker: this.causalTracker,
       ...this.secretKeyProvider ? { secretKeyProvider: this.secretKeyProvider } : {},
       ...this.onStorageError ? { onStorageError: this.onStorageError } : {},
-      ...this.maxOperationBytes !== void 0 ? { maxOperationBytes: this.maxOperationBytes } : {}
+      ...this.maxOperationBytes !== void 0 ? { maxOperationBytes: this.maxOperationBytes } : {},
+      ...this.assertLocalWriteAllowed ? { assertLocalWriteAllowed: this.assertLocalWriteAllowed } : {}
     };
   }
   async insert(data) {
@@ -2250,7 +2254,8 @@ async function rebaseUnsyncedOperationsInLog(adapter, schema, unsyncedOpIds, cor
 
 // src/sync/rotate-node-id.ts
 import { quoteIdent as quoteIdent11 } from "@korajs/core";
-async function rotateUnsyncedOperationsInLog(adapter, schema, unsyncedOpIds, oldNodeId, newNodeId) {
+async function rotateUnsyncedOperationsInLog(adapter, schema, unsyncedOpIds, oldNodeId, newNodeId, options = {}) {
+  const moveDatabaseNode = options.moveDatabaseNode !== false;
   const rotateIds = new Set(unsyncedOpIds);
   const idMapping = {};
   const rewritten = [];
@@ -2320,10 +2325,12 @@ async function rotateUnsyncedOperationsInLog(adapter, schema, unsyncedOpIds, old
         );
       }
     }
-    await tx.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES ('node_id', ?)", [
-      newNodeId
-    ]);
-    await tx.execute("DELETE FROM _kora_meta WHERE key = ?", [NODE_TOKEN_META_KEY]);
+    if (moveDatabaseNode) {
+      await tx.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES ('node_id', ?)", [
+        newNodeId
+      ]);
+      await tx.execute("DELETE FROM _kora_meta WHERE key = ?", [NODE_TOKEN_META_KEY]);
+    }
     if (rewritten.length > 0) {
       await tx.execute(
         `INSERT INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)
@@ -2469,7 +2476,9 @@ var TransactionContext = class {
       ...this.config.secretKeyProvider ? { secretKeyProvider: this.config.secretKeyProvider } : {},
       ...this.mutationName !== void 0 ? { mutationName: this.mutationName } : {},
       ...this.config.beforeLocalDelete ? { beforeLocalDelete: this.config.beforeLocalDelete } : {},
-      ...this.config.fold ? { fold: this.config.fold } : {}
+      ...this.config.fold ? { fold: this.config.fold } : {},
+      ...this.config.maxOperationBytes !== void 0 ? { maxOperationBytes: this.config.maxOperationBytes } : {},
+      ...this.config.assertLocalWriteAllowed ? { assertLocalWriteAllowed: this.config.assertLocalWriteAllowed } : {}
     };
   }
   ensureActive() {
@@ -2831,6 +2840,12 @@ var Store = class {
   schema;
   adapter;
   configNodeId;
+  /** The owner of the pinned node while it belongs to another user than the signed-in one (F9). */
+  pinnedNodeOwnedBy = null;
+  /** The sync server refused the pinned node as another user's (F9). */
+  pinnedNodeRefusedByServer = false;
+  /** The user of the last {@link bindPrincipal}. */
+  signedInPrincipal = null;
   dbName;
   isolation;
   emitter;
@@ -2905,8 +2920,10 @@ var Store = class {
     this.foldActive = false;
     await relaxValueDomainConstraints(this.adapter, this.schema);
     await dropLegacyIndexes(this.adapter, this.schema);
+    const persistedNodeId = await this.readPersistedNodeId();
     this.nodeId = await this.loadOrGenerateNodeId();
     await registerLocalNode(this.adapter, this.nodeId);
+    await this.registerUnregisteredAuthors(persistedNodeId);
     await this.scanLog("quick");
     await repairSequenceUniqueness(this.adapter, this.schema, this.nodeId);
     await seedTerminalRejectionsOnce(this.adapter);
@@ -2950,7 +2967,8 @@ var Store = class {
         this.secretKeyProvider,
         (error) => this.reportStorageError(error),
         () => this.activeFold(),
-        this.maxOperationBytes
+        this.maxOperationBytes,
+        () => this.assertLocalWriteAllowed()
       );
       this.collections.set(name, col);
     }
@@ -4242,6 +4260,7 @@ var Store = class {
       ...options?.extraCausalDeps ? { extraCausalDeps: options.extraCausalDeps } : {},
       ...this.secretKeyProvider ? { secretKeyProvider: this.secretKeyProvider } : {},
       ...this.maxOperationBytes !== void 0 ? { maxOperationBytes: this.maxOperationBytes } : {},
+      assertLocalWriteAllowed: () => this.assertLocalWriteAllowed(),
       ...beforeLocalDelete ? { beforeLocalDelete: beforeLocalDelete.bind(this.localMutationHandler) } : {},
       onStorageError: (error) => this.reportStorageError(error)
     };
@@ -4511,6 +4530,46 @@ var Store = class {
     await this.refoldRecordsOf(result.operations.map((op) => op.id));
     return result;
   }
+  /**
+   * Re-author another local node's never-acknowledged operations under a fresh node id
+   * bound to `principal` (the user they belong to). Used when the sync server refuses an
+   * adopted node whose writes belong to the signed-in user (the app assigned them, or
+   * the node was created for them) but which no claims-aware server ever accepted: a
+   * beta.12 database's node with history the server recorded no owner for. The store's
+   * own node id, clock and counters are untouched; the fresh node is registered, so the
+   * sync engine adopts it like any other local node.
+   *
+   * @param fromNodeId - The refused local node (never the store's own)
+   * @param unsyncedOpIds - Ids of its operations the server never acknowledged
+   * @param principal - The user the writes belong to (the fresh node's binding)
+   * @returns The fresh node id and the rewritten operations (for the outbound queue)
+   * @throws {KoraError} `NODE_ID_UNKNOWN` when `fromNodeId` is the store's own node or
+   *   not a local node
+   */
+  async reauthorLocalNode(fromNodeId, unsyncedOpIds, principal) {
+    this.ensureOpen();
+    const from = (await listLocalNodes(this.adapter)).find((node) => node.nodeId === fromNodeId);
+    if (fromNodeId === this.nodeId || !from) {
+      throw new KoraError4(
+        `Node id "${fromNodeId}" is not another local node of this database, so its writes cannot be re-authored.`,
+        "NODE_ID_UNKNOWN",
+        { nodeId: fromNodeId, storeNodeId: this.nodeId }
+      );
+    }
+    const result = await rotateUnsyncedOperationsInLog(
+      this.adapter,
+      this.schema,
+      unsyncedOpIds,
+      fromNodeId,
+      generateUUIDv73(),
+      { moveDatabaseNode: false }
+    );
+    await registerLocalNode(this.adapter, result.nodeId);
+    await setLocalNodePrincipal(this.adapter, result.nodeId, principal, "fresh");
+    this.versionVector = await this.loadVersionVector();
+    await this.refoldRecordsOf(result.operations.map((op) => op.id));
+    return result;
+  }
   /**
    * Move this database back to a node id it authored under before (RT-38): after the
    * sync server refused the current node, the device tries a node a returning user
@@ -4590,6 +4649,31 @@ var Store = class {
    * @returns The node now in use and whether it changed
    */
   async bindPrincipal(principal) {
+    const binding = await this.bindPrincipalToNode(principal);
+    if (principal !== this.signedInPrincipal) this.pinnedNodeRefusedByServer = false;
+    this.pinnedNodeOwnedBy = binding.conflict ? (await listLocalNodes(this.adapter)).find((node) => node.nodeId === this.nodeId)?.principal ?? null : null;
+    this.signedInPrincipal = principal;
+    return binding;
+  }
+  /**
+   * The sync server refused this store's pinned node id because another user owns it
+   * (`owned: true`), or later accepted it (`false`). A pinned node cannot move to a fresh
+   * id, so writes made under it could only ever upload as its owner: while the server
+   * says so, local writes are refused (F9). A no-op for a store whose node is not pinned
+   * (it moves to a fresh node instead).
+   *
+   * @param owned - Whether the server reported the node owned by another user
+   */
+  setPinnedNodeOwnedElsewhere(owned) {
+    if (!this.configNodeId) return;
+    this.pinnedNodeRefusedByServer = owned;
+  }
+  /** Refuse a local write while the pinned node belongs to another user (F9). */
+  assertLocalWriteAllowed() {
+    if (this.pinnedNodeOwnedBy === null && !this.pinnedNodeRefusedByServer) return;
+    throw new NodeOwnedByAnotherUserError(this.nodeId, this.signedInPrincipal);
+  }
+  async bindPrincipalToNode(principal) {
     this.ensureOpen();
     const previousNodeId = this.nodeId;
     const nodes = await listLocalNodes(this.adapter);
@@ -4969,6 +5053,8 @@ var Store = class {
     const beforeLocalDelete = this.localMutationHandler?.beforeLocalDelete;
     const fold = this.activeFold();
     return new TransactionContext({
+      ...this.maxOperationBytes !== void 0 ? { maxOperationBytes: this.maxOperationBytes } : {},
+      assertLocalWriteAllowed: () => this.assertLocalWriteAllowed(),
       ...fold ? { fold } : {},
       schema: this.schema,
       adapter: this.adapter,
@@ -5014,7 +5100,7 @@ var Store = class {
    */
   async exportBackup(options) {
     this.ensureOpen();
-    const { exportBackup: doExport } = await import("./backup-4NUPDEMB.js");
+    const { exportBackup: doExport } = await import("./backup-IHKVMUAM.js");
     return doExport(this.adapter, this.schema, this.nodeId, this.schema.version, options);
   }
   /**
@@ -5028,8 +5114,9 @@ var Store = class {
    *   move backwards, and unsynced own writes are kept (see
    *   `RestoreOptions.keepUnsyncedWrites`). Then {@link reloadFromDisk} runs.
    *
-   * A version-1 file is refused (`errorCode: 'BACKUP_FORMAT_OUTDATED'`); convert it with
-   * `convertBackupV1`.
+   * A version-1 file (Kora 1.0.0-beta.12 and earlier) is converted first, exactly as
+   * `convertBackupV1` does (`result.convertedFromVersion: 1`); one holding an operation
+   * whose timestamp cannot be recovered is refused (`BACKUP_OPERATION_INVALID`).
    *
    * @param data - The backup data
    * @param options - Restore options (merge, collections, keepUnsyncedWrites, onProgress)
@@ -5042,13 +5129,19 @@ var Store = class {
     const started = Date.now();
     const onProgress = options?.onProgress ?? (() => {
     });
-    const { BackupFormatError, parseBackup } = await import("./backup-4NUPDEMB.js");
-    const { restoreMerge, restoreReplace } = await import("./restore-FR7XIKT2.js");
+    const { BackupFormatError, convertBackupV1, parseBackup, readBackupManifest: readBackupManifest2 } = await import("./backup-IHKVMUAM.js");
+    const { restoreMerge, restoreReplace } = await import("./restore-MNDPR557.js");
     onProgress({ phase: "verifying", progress: 0, message: "Verifying backup" });
     let parsed;
+    let convertedFromVersion;
     try {
+      let bytes = data;
+      if (readBackupManifest2(data).version === 1) {
+        bytes = await convertBackupV1(data);
+        convertedFromVersion = 1;
+      }
       parsed = await parseBackup(
-        data,
+        bytes,
         options?.collections ? { collections: options.collections } : void 0
       );
     } catch (error) {
@@ -5100,6 +5193,7 @@ var Store = class {
       recordsRestored: counts.recordsRestored,
       ...options?.merge ? {} : { unsyncedWritesKept: counts.unsyncedWritesKept },
       ...counts.serverOperationsSkipped ? { serverOperationsSkipped: counts.serverOperationsSkipped } : {},
+      ...convertedFromVersion ? { convertedFromVersion } : {},
       success: true,
       duration: Date.now() - started
     };
@@ -5262,6 +5356,42 @@ var Store = class {
       onOperation: (operation) => this.publishLocalOperation(operation.collection, operation)
     });
   }
+  /** The node id the database persisted before this open, if any. */
+  async readPersistedNodeId() {
+    const rows = await this.adapter.query(
+      "SELECT value FROM _kora_meta WHERE key = 'node_id'"
+    );
+    return rows[0]?.value ?? null;
+  }
+  /**
+   * Register node ids this database authored under that the registry does not know
+   * yet: the node id a pinned `nodeId` (the auth device id) just replaced, and the
+   * authors of queued operations. A beta.12 database had no registry, and a template
+   * app created before its user signed in authored under a random node; once the
+   * store is pinned to the device id, that node's queued writes would otherwise sit in
+   * the queue forever, neither uploaded nor reported. Registered, they are adopted or
+   * held (`status.heldNodes`) like any other local node's writes. Only the outbound
+   * queue is read: received operations never enter it.
+   */
+  async registerUnregisteredAuthors(persistedNodeId) {
+    const authors = /* @__PURE__ */ new Set();
+    if (persistedNodeId !== null && persistedNodeId !== this.nodeId) authors.add(persistedNodeId);
+    const queued = await this.adapter.query(
+      "SELECT payload FROM _kora_sync_queue"
+    );
+    for (const row of queued) {
+      try {
+        const nodeId = JSON.parse(row.payload).node_id;
+        if (typeof nodeId === "string" && nodeId.length > 0) authors.add(nodeId);
+      } catch {
+      }
+    }
+    authors.delete(this.nodeId);
+    for (const nodeId of authors) {
+      if (isReservedNodeId(nodeId)) continue;
+      await registerLocalNode(this.adapter, nodeId);
+    }
+  }
   async loadOrGenerateNodeId() {
     if (this.configNodeId && isReservedNodeId(this.configNodeId)) {
       throw new ReservedNodeIdError(this.configNodeId, "StoreConfig.nodeId");
@@ -5338,4 +5468,4 @@ export {
   ReservedNodeIdError,
   Store
 };
-//# sourceMappingURL=chunk-Y5LRH7KI.js.map
+//# sourceMappingURL=chunk-5AQSGMJV.js.map