mindoodb 0.0.45 → 0.0.47

package/dist/core/BaseMindooDB.js

@@ -18,6 +18,8 @@ const idGeneration_1 = require("./utils/idGeneration");
 const timeSource_1 = require("./utils/timeSource");
 const errors_1 = require("./errors");
 const EntrySignature_1 = require("./crypto/EntrySignature");
+const copyDocument_1 = require("./copy/copyDocument");
+const copyDocuments_1 = require("./copy/copyDocuments");
 const materializationGuard_1 = require("./accesscontrol/materializationGuard");
 const Ed25519WitnessProvider_1 = require("./accesscontrol/timestamp/Ed25519WitnessProvider");
 const AccessDeniedError_1 = require("./accesscontrol/AccessDeniedError");
@@ -4278,6 +4280,7 @@ class BaseMindooDB {
                     doc: wrappedDoc,
                     changeCreatedAt: entryMetadata.createdAt,
                     changeCreatedByPublicKey: entryMetadata.createdByPublicKey,
+                    changeDependencyIds: [...entryMetadata.dependencyIds],
                 };
             }
         }
@@ -4881,6 +4884,49 @@ class BaseMindooDB {
             doc: this.wrapDocument(internalDoc),
         };
     }
+    async materializeDocumentAtHeads(docId, headEntryIds) {
+        const startedAt = Date.now();
+        const allEntryMetadata = await this.scanAllMetadata(this.store, { docId });
+        const plan = (0, DocumentDagAnalysis_1.computeHeadsMaterializationPlan)(docId, allEntryMetadata, headEntryIds);
+        if (!plan) {
+            this.performanceCallback?.onHistoryOperation?.({
+                operation: "materializeDocumentAtHeads",
+                docId,
+                time: Date.now() - startedAt,
+                scannedEntries: allEntryMetadata.length,
+                returnedEntries: 0,
+                bounded: true,
+            });
+            return null;
+        }
+        const metadataById = new Map(allEntryMetadata.map((entry) => [entry.id, entry]));
+        const branchEntries = plan.branchEntryIds
+            .map((entryId) => metadataById.get(entryId))
+            .filter((entry) => entry !== undefined);
+        const internalDoc = await this.materializeDocumentFromPlan(docId, allEntryMetadata, branchEntries, plan.snapshotEntryId, plan.entryIdsToApply, plan.headCreatedAt);
+        this.performanceCallback?.onHistoryOperation?.({
+            operation: "materializeDocumentAtHeads",
+            docId,
+            time: Date.now() - startedAt,
+            scannedEntries: allEntryMetadata.length,
+            returnedEntries: internalDoc ? 1 : 0,
+            bounded: true,
+        });
+        if (!internalDoc) {
+            return null;
+        }
+        return {
+            docId,
+            headEntryId: plan.headEntryIds[plan.headEntryIds.length - 1],
+            headEntryIds: [...plan.headEntryIds],
+            headCreatedAt: plan.headCreatedAt,
+            headCreatedByPublicKey: plan.headCreatedByPublicKey,
+            snapshotEntryId: plan.snapshotEntryId,
+            entryIdsApplied: [...plan.entryIdsToApply],
+            branchEntryIds: [...plan.branchEntryIds],
+            doc: this.wrapDocument(internalDoc),
+        };
+    }
     async materializeDocumentBranchAtTimestamp(docId, timestamp, headEntryId) {
         const startedAt = Date.now();
         const resolvedTimestamp = this.resolveDagTimestamp(timestamp);
@@ -10545,6 +10591,164 @@ class BaseMindooDB {
             }
         };
     }
+    // ==========================================================================
+    // Document copy across databases (src/core/copy/, docs/document-copy.md)
+    // ==========================================================================
+    /**
+     * The seam the copy engine reaches this database through.
+     *
+     * The engine lives in `src/core/copy/` rather than as more methods on this
+     * already-large class, and needs a few things that are private here (entry
+     * signing, the attachment-ref snapshot, the attachment crypto envelope). This
+     * hands them over as one narrow object instead of widening their visibility.
+     *
+     * @internal Not part of the supported API; may change without notice.
+     */
+    getCopyEngineHost() {
+        return {
+            db: this,
+            tenant: this.tenant,
+            store: this.store,
+            attachmentStore: this.getEffectiveAttachmentStore(),
+            computeEntryMetadataSignature: (meta, signing) => this.computeEntryMetadataSignature(meta, signing),
+            collectAttachmentRefs: (doc) => this.collectAttachmentRefs(doc),
+            decryptAttachmentPayload: (payload, keyId) => this.tenant.decryptAttachmentPayload(payload, keyId),
+            encryptAttachmentPayload: (payload, keyId) => this.tenant.encryptAttachmentPayload(payload, keyId),
+            syncStoreChanges: () => this.syncStoreChanges(),
+            evaluateWriteAccess: (op, signerKey, isAuthor) => this.evaluateClientWriteAccess({ op, signerKey, isAuthor }),
+            hasWriteContentRules: async (op) => {
+                const directory = await this.tenant.openDirectory();
+                return (await directory.hasWriteContentRules?.(op, this.store.getId())) ?? false;
+            },
+            remapAttachmentPointers: (docId, lastChunkIdByAttachmentId, signing) => this.remapAttachmentPointers(docId, lastChunkIdByAttachmentId, signing),
+        };
+    }
+    /** Obtain the copy seam from another database, with a clear error if absent. */
+    resolveCopyHost(db, role) {
+        const host = db.getCopyEngineHost?.();
+        if (!host) {
+            throw new Error(`The ${role} database does not support document copying (expected a BaseMindooDB instance).`);
+        }
+        return host;
+    }
+    /**
+     * Re-point `_attachments[].lastChunkId` at a different set of chunks, as one
+     * `doc_change`.
+     *
+     * Only used when a document is duplicated inside its own database: the copied
+     * chunks had to be renamed to avoid colliding with the source's (see
+     * `copy/attachments.ts`), so the copy's current revision has to be told where
+     * its own chunks are. `changeDoc` deliberately offers no way to write
+     * `_attachments` directly, hence this internal path.
+     */
+    async remapAttachmentPointers(docId, lastChunkIdByAttachmentId, signing) {
+        if (lastChunkIdByAttachmentId.size === 0) {
+            return;
+        }
+        const internalDoc = this.getCachedDocument(docId) ?? (await this.loadDocumentInternal(docId));
+        if (!internalDoc) {
+            throw new Error(`Cannot remap attachment pointers: document ${docId} was not found.`);
+        }
+        const now = (0, timeSource_1.semanticNow)();
+        let changed = false;
+        const newDoc = this.runChangeWithOutdatedDocRecovery(internalDoc, (doc) => automerge_adapter_1.Automerge.change(doc, { time: now }, (mutableDoc) => {
+            const attachments = mutableDoc._attachments ?? [];
+            for (const attachment of attachments) {
+                const nextChunkId = lastChunkIdByAttachmentId.get(attachment.attachmentId);
+                if (nextChunkId && attachment.lastChunkId !== nextChunkId) {
+                    attachment.lastChunkId = nextChunkId;
+                    changed = true;
+                }
+            }
+            if (changed) {
+                mutableDoc._lastModified = now;
+            }
+        }));
+        if (!changed) {
+            return;
+        }
+        const changeBytes = automerge_adapter_1.Automerge.getLastLocalChange(newDoc);
+        if (!changeBytes) {
+            throw new Error("Failed to get change bytes while remapping attachment pointers");
+        }
+        const entry = await this.buildDocChangeStoreEntry({
+            internalDoc,
+            changeBytes,
+            now,
+            useCustomKey: signing !== undefined,
+            signingKeyPair: signing?.signingKeyPair,
+            signingKeyPassword: signing?.signingKeyPassword,
+            attachmentRefs: this.collectAttachmentRefs(newDoc),
+        });
+        await this.store.putEntries([entry]);
+        this.registerAutomergeHashMapping(docId, automerge_adapter_1.Automerge.decodeChange(changeBytes).hash, entry.id);
+        internalDoc.doc = newDoc;
+        internalDoc.lastModified = now;
+        internalDoc.awaitingWitness = (0, storeEntryTime_1.isProvisional)(entry) || (internalDoc.awaitingWitness ?? false);
+        const versioned = (0, storeEntryTime_1.isVersioned)(entry) || internalDoc.awaitingWitness || (internalDoc.witnessed ?? false);
+        internalDoc.witnessed = versioned && !internalDoc.awaitingWitness;
+        await this.storeCachedDocument(internalDoc);
+        this.updateIndex(docId, internalDoc.lastModified, internalDoc.isDeleted, internalDoc.decryptionKeyId, "visible", internalDoc.awaitingWitness, internalDoc.witnessed, true);
+        this.markDocDirty(docId);
+    }
+    /**
+     * Report what {@link copyDocumentTo} would do with these options — the chosen
+     * strategy, whether the original authors' signatures would survive, whether
+     * the copy would merge into an existing document — without writing anything.
+     *
+     * The returned `reasons` explain a refusal, and also explain why a permitted
+     * copy has to re-author, so a caller can distinguish an unavoidable
+     * re-authoring from an accidental one.
+     *
+     * @param docId The document to copy.
+     * @param target The database the copy would be written to.
+     * @param options The same options that would be passed to {@link copyDocumentTo}.
+     */
+    async canCopyDocumentTo(docId, target, options) {
+        return (0, copyDocument_1.canCopyDocument)(this.getCopyEngineHost(), this.resolveCopyHost(target, "target"), docId, options);
+    }
+    /**
+     * Copy one document into another database, either flattened to a single
+     * revision or with its full history.
+     *
+     * See `docs/document-copy.md` for the strategy matrix. In short: the default
+     * writes a flattened copy under a fresh id; `mode: "history"` carries the
+     * whole revision graph; and adding `targetDocId: "same"` with
+     * `authorship: "preserve"` (same tenant, same key, different database) keeps
+     * the original signers, which is what makes sharding possible.
+     *
+     * @param docId The document to copy.
+     * @param target The database to copy into.
+     * @param options See {@link CopyDocumentOptions}; every default is documented there.
+     * @return What was copied, including the target document id — returned even on
+     *   cancellation, so a resumed run can target the same id.
+     */
+    async copyDocumentTo(docId, target, options) {
+        const targetHost = this.resolveCopyHost(target, "target");
+        this.assertWritable("copyDocumentTo");
+        return (0, copyDocument_1.copyDocument)(this.getCopyEngineHost(), targetHost, docId, options);
+    }
+    /**
+     * Copy many documents into another database in one pass.
+     *
+     * With `mode: "history"`, `targetDocId: "same"` and `authorship: "preserve"`
+     * this is the database sharding primitive: document ids, full history and the
+     * original signers all survive the split, and nothing is decrypted or
+     * re-signed along the way. Repeated runs are safe and transfer only the delta,
+     * so a shard can proceed against a live database.
+     *
+     * Per-document failures do not abort the run; they are collected in
+     * {@link CopyDocumentsResult.failed}.
+     *
+     * @param selector Which documents to copy — explicit ids, id prefixes, or both.
+     * @param target The database to copy into.
+     * @param options See {@link CopyDocumentsOptions}.
+     */
+    async copyDocumentsTo(selector, target, options) {
+        const targetHost = this.resolveCopyHost(target, "target");
+        this.assertWritable("copyDocumentsTo");
+        return (0, copyDocuments_1.copyDocuments)(this.getCopyEngineHost(), targetHost, selector, options);
+    }
     /**
      * Pull changes from a remote content-addressed store or another MindooDB instance.
      *