mindoodb 0.0.44 → 0.0.46

package/dist/core/copy/attachments.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Attachment chunk copying.
+ *
+ * Chunk entry ids embed the document id (`<docId>_a_<fileUuid7>_<chunkUuid>`)
+ * and a document's payload points at them by id through
+ * `_attachments[].lastChunkId`. That forces two different strategies depending
+ * on whether the copy crosses a store boundary:
+ *
+ * - **Different store** (the normal case, including every shard): keep the
+ *   chunk ids exactly as they are and only re-home the `docId` metadata field.
+ *   Nothing can collide, because the target store has never seen those ids, and
+ *   leaving them alone is what lets the document's change bytes replay
+ *   unmodified — the payload's `lastChunkId` values still resolve.
+ *
+ * - **Same store, new document id** (duplicating a document in place): the ids
+ *   must be re-prefixed. Reusing them is not an option: the stores implement an
+ *   id write as remove-then-insert, so a verbatim copy would overwrite the
+ *   source's own chunk metadata and re-point it at the copy. The copied history
+ *   keeps referring to the source's chunks (still present in the same store,
+ *   holding identical bytes, so attachment time travel still works), and one
+ *   trailing change re-points the copy's current revision at the chunks it owns.
+ *
+ * @module
+ */
+import type { StoreEntryMetadata } from "../types";
+import type { CopyEngineHost } from "./host";
+import type { CopyContext } from "./feasibility";
+import type { CopySigningKey, CopyProgressReporter } from "./copyDocument";
+import type { CopyDocumentOptions, CopyFeasibility } from "./types";
+/**
+ * The result of copying a document's attachment chunks, plus the deferred step
+ * that can only run once the document's own entries are in place.
+ *
+ * @internal
+ */
+export interface AttachmentCopyPlan {
+    /** True when the abort signal fired before the chunks were fully copied. */
+    cancelled: boolean;
+    /**
+     * Same-store copies only: append the one trailing change that re-points
+     * `_attachments[].lastChunkId` at the re-prefixed chunks. A no-op otherwise.
+     */
+    finalize(signing?: CopySigningKey): Promise<void>;
+}
+/**
+ * Copy every attachment chunk belonging to a document.
+ *
+ * Runs before the document's own entries so that the signed `attachmentRefs`
+ * snapshot each copied revision carries always describes chunks that already
+ * exist in the target.
+ */
+export declare function copyDocumentAttachments(source: CopyEngineHost, target: CopyEngineHost, context: CopyContext, feasibility: CopyFeasibility, options: CopyDocumentOptions, reporter: CopyProgressReporter, sourceDagEntries: StoreEntryMetadata[]): Promise<AttachmentCopyPlan>;
+//# sourceMappingURL=attachments.d.ts.map

package/dist/core/copy/attachments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachments.d.ts","sourceRoot":"","sources":["../../../src/core/copy/attachments.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAMH,OAAO,KAAK,EAAc,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,KAAK,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3E,OAAO,KAAK,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAKpE;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,4EAA4E;IAC5E,SAAS,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnD;AAQD;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,WAAW,EACpB,WAAW,EAAE,eAAe,EAC5B,OAAO,EAAE,mBAAmB,EAC5B,QAAQ,EAAE,oBAAoB,EAC9B,gBAAgB,EAAE,kBAAkB,EAAE,GACrC,OAAO,CAAC,kBAAkB,CAAC,CA8G7B"}

package/dist/core/copy/attachments.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * Attachment chunk copying.
+ *
+ * Chunk entry ids embed the document id (`<docId>_a_<fileUuid7>_<chunkUuid>`)
+ * and a document's payload points at them by id through
+ * `_attachments[].lastChunkId`. That forces two different strategies depending
+ * on whether the copy crosses a store boundary:
+ *
+ * - **Different store** (the normal case, including every shard): keep the
+ *   chunk ids exactly as they are and only re-home the `docId` metadata field.
+ *   Nothing can collide, because the target store has never seen those ids, and
+ *   leaving them alone is what lets the document's change bytes replay
+ *   unmodified — the payload's `lastChunkId` values still resolve.
+ *
+ * - **Same store, new document id** (duplicating a document in place): the ids
+ *   must be re-prefixed. Reusing them is not an option: the stores implement an
+ *   id write as remove-then-insert, so a verbatim copy would overwrite the
+ *   source's own chunk metadata and re-point it at the copy. The copied history
+ *   keeps referring to the source's chunks (still present in the same store,
+ *   holding identical bytes, so attachment time travel still works), and one
+ *   trailing change re-points the copy's current revision at the chunks it owns.
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyDocumentAttachments = copyDocumentAttachments;
+const DocumentDagAnalysis_1 = require("../DocumentDagAnalysis");
+const idGeneration_1 = require("../utils/idGeneration");
+const timeSource_1 = require("../utils/timeSource");
+const types_1 = require("../types");
+const entryRewrite_1 = require("./entryRewrite");
+/** Default entries written per `putEntries` call. */
+const DEFAULT_BATCH_SIZE = 200;
+/** A plan that does nothing, for documents without attachments. */
+const NO_ATTACHMENTS = {
+    cancelled: false,
+    finalize: async () => { },
+};
+/**
+ * Copy every attachment chunk belonging to a document.
+ *
+ * Runs before the document's own entries so that the signed `attachmentRefs`
+ * snapshot each copied revision carries always describes chunks that already
+ * exist in the target.
+ */
+async function copyDocumentAttachments(source, target, context, feasibility, options, reporter, sourceDagEntries) {
+    if (options.includeAttachments === false) {
+        return NO_ATTACHMENTS;
+    }
+    const sourceChunks = (await source.attachmentStore.findNewEntriesForDoc([], context.sourceDocId)).filter((entry) => entry.entryType === "attachment_chunk");
+    if (sourceChunks.length === 0) {
+        return NO_ATTACHMENTS;
+    }
+    // Only a same-store copy is forced to rename chunks; see the module comment.
+    const reprefixChunkIds = context.sameStore;
+    const chunkTargetDocId = context.targetDocId;
+    const remapChunkId = (chunkId) => reprefixChunkIds
+        ? (0, entryRewrite_1.remapEntryId)(chunkId, context.sourceDocId, chunkTargetDocId)
+        : chunkId;
+    const ordered = (0, DocumentDagAnalysis_1.orderDagEntriesCausally)(sourceChunks);
+    const targetIds = ordered.map((entry) => remapChunkId(entry.id));
+    const alreadyPresent = new Set(await target.attachmentStore.hasEntries(targetIds));
+    const batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
+    const signing = options.signingKeyPair && options.signingKeyPassword
+        ? {
+            signingKeyPair: options.signingKeyPair,
+            signingKeyPassword: options.signingKeyPassword,
+        }
+        : undefined;
+    const copierPublicKey = signing?.signingKeyPair.publicKey ??
+        (await target.tenant.getCurrentUserId()).userSigningPublicKey;
+    const copyTime = (0, timeSource_1.semanticNow)();
+    const copiedAttachmentIds = new Set();
+    for (let offset = 0; offset < ordered.length; offset += batchSize) {
+        if (options.signal?.aborted) {
+            return { cancelled: true, finalize: async () => { } };
+        }
+        const slice = ordered.slice(offset, offset + batchSize);
+        const needed = slice.filter((_entry, index) => !alreadyPresent.has(targetIds[offset + index]));
+        if (needed.length === 0)
+            continue;
+        const fetched = await source.attachmentStore.getEntries(needed.map((entry) => entry.id));
+        const transformed = [];
+        for (const sourceEntry of fetched) {
+            transformed.push(feasibility.strategy === "graft"
+                ? (0, entryRewrite_1.stripWitnessReceipt)({ ...sourceEntry })
+                : await replayChunk(source, target, context, feasibility, sourceEntry, {
+                    id: remapChunkId(sourceEntry.id),
+                    dependencyIds: sourceEntry.dependencyIds.map(remapChunkId),
+                    createdAt: copyTime,
+                    createdByPublicKey: copierPublicKey,
+                    signing,
+                }));
+            if (sourceEntry.attachmentId) {
+                copiedAttachmentIds.add(sourceEntry.attachmentId);
+            }
+        }
+        if (transformed.length > 0) {
+            await target.attachmentStore.putEntries(transformed);
+            reporter.copiedEntries += transformed.length;
+            for (const entry of transformed) {
+                reporter.copiedBytes += entry.encryptedSize;
+            }
+        }
+        reporter.emit("transferring", `Copied ${transformed.length} attachment chunks of ${context.sourceDocId}`);
+    }
+    reporter.copiedAttachments += copiedAttachmentIds.size;
+    if (!reprefixChunkIds) {
+        return { cancelled: false, finalize: async () => { } };
+    }
+    // The re-prefixed chunks are in place but nothing points at them yet: the
+    // copied revisions still carry the source's chunk ids in their payloads. Look
+    // up the document's live attachment set from the newest signed refs snapshot
+    // (no decryption needed) and hand the re-pointing to the target database.
+    const liveRefs = latestAttachmentRefs(sourceDagEntries);
+    return {
+        cancelled: false,
+        finalize: async (finalizeSigning) => {
+            if (liveRefs.length === 0)
+                return;
+            const pointerRemap = new Map();
+            for (const ref of liveRefs) {
+                pointerRemap.set(ref.attachmentId, remapChunkId(ref.lastChunkId));
+            }
+            await target.remapAttachmentPointers(chunkTargetDocId, pointerRemap, finalizeSigning ?? signing);
+        },
+    };
+}
+/**
+ * The document's current attachment set, read from the signed `attachmentRefs`
+ * snapshot on its newest revision.
+ *
+ * Every document revision carries the complete set as of that revision, so the
+ * newest one is authoritative — and reading it needs no decryption key.
+ */
+function latestAttachmentRefs(sourceDagEntries) {
+    let newest;
+    for (const entry of sourceDagEntries) {
+        if (!entry.attachmentRefs || entry.attachmentRefs.length === 0)
+            continue;
+        if (!newest || entry.createdAt > newest.createdAt) {
+            newest = entry;
+        }
+    }
+    return newest?.attachmentRefs ?? [];
+}
+/**
+ * Re-home and re-sign one attachment chunk.
+ *
+ * Attachment payloads use a deterministic IV, so re-encrypting the same chunk
+ * under the same key reproduces the same ciphertext and `contentHash` — which
+ * is why a same-tenant copy into the same store deduplicates the bytes instead
+ * of storing them twice.
+ */
+async function replayChunk(source, target, context, feasibility, sourceEntry, rewrite) {
+    let encryptedData = sourceEntry.encryptedData;
+    let contentHash = sourceEntry.contentHash;
+    if (feasibility.requiresReEncryption) {
+        const plaintext = await source.decryptAttachmentPayload(sourceEntry.encryptedData, sourceEntry.decryptionKeyId);
+        encryptedData = await target.encryptAttachmentPayload(plaintext, context.targetDecryptionKeyId);
+        contentHash = await (0, idGeneration_1.computeContentHash)(encryptedData, target.tenant.getCryptoAdapter().getSubtle());
+    }
+    const signature = rewrite.signing
+        ? await target.tenant.signPayloadWithKey(encryptedData, rewrite.signing.signingKeyPair, rewrite.signing.signingKeyPassword)
+        : await target.tenant.signPayload(encryptedData);
+    const entry = {
+        entryType: "attachment_chunk",
+        id: rewrite.id,
+        contentHash,
+        docId: context.targetDocId,
+        dependencyIds: rewrite.dependencyIds,
+        createdAt: rewrite.createdAt,
+        attachmentId: sourceEntry.attachmentId,
+        createdByPublicKey: rewrite.createdByPublicKey,
+        decryptionKeyId: context.targetDecryptionKeyId,
+        signature,
+        originalSize: sourceEntry.originalSize,
+        encryptedSize: encryptedData.length,
+        entryVersion: types_1.CURRENT_STORE_ENTRY_VERSION,
+        encryptedData,
+    };
+    entry.metadataSignature = await target.computeEntryMetadataSignature(entry, rewrite.signing);
+    return entry;
+}
+//# sourceMappingURL=attachments.js.map

package/dist/core/copy/attachments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachments.js","sourceRoot":"","sources":["../../../src/core/copy/attachments.ts"],"names":[],"mappings":"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"}

package/dist/core/copy/copyDocument.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The document copy engine.
+ *
+ * Orchestrates the three strategies described in `docs/document-copy.md`:
+ * `flatten` (delegated to `flatten.ts`, which goes through the public document
+ * API), and the two history-preserving strategies implemented here.
+ *
+ * `graft` and `replay` share one pipeline — order the source revision graph
+ * causally, skip what the target already has, transform in batches, write — and
+ * differ only in the per-entry transform:
+ *
+ * - **graft** strips the witness receipt and changes nothing else, so the
+ *   original authors' signatures remain valid.
+ * - **replay** re-homes each entry under the target document id and re-signs it
+ *   as the copying user, recording the original author in a verifiable
+ *   provenance record.
+ *
+ * @module
+ */
+import type { SigningKeyPair, StoreEntryMetadata } from "../types";
+import type { CopyEngineHost } from "./host";
+import { type CopyContext } from "./feasibility";
+import type { CopyDocumentOptions, CopyDocumentResult, CopyFeasibility, CopyProgress, CopyProgressPhase } from "./types";
+/**
+ * A resolved custom signing identity for a copy, or `undefined` to sign as the
+ * current user. Both fields are always present together.
+ *
+ * @internal
+ */
+export interface CopySigningKey {
+    signingKeyPair: SigningKeyPair;
+    signingKeyPassword: string;
+}
+/**
+ * Normalize the caller's signing options: a key pair is only usable together
+ * with its password, so a half-supplied pair is treated as absent.
+ *
+ * @internal
+ */
+export declare function resolveCopySigningKey(options: CopyDocumentOptions): CopySigningKey | undefined;
+/**
+ * The key the copy's entries will be signed with: the caller's service identity
+ * when supplied, the current user's otherwise.
+ *
+ * @internal
+ */
+export declare function resolveCopierPublicKey(target: CopyEngineHost, options: CopyDocumentOptions): Promise<string>;
+/**
+ * Accumulates copy totals and emits {@link CopyProgress} events.
+ *
+ * Shared by the single-document and bulk paths so a bulk run reports one
+ * continuously rising total rather than restarting the counters per document.
+ */
+export declare class CopyProgressReporter {
+    private readonly onProgress?;
+    copiedEntries: number;
+    copiedBytes: number;
+    scannedEntries: number;
+    copiedAttachments: number;
+    totalSourceEntries?: number;
+    currentDocId?: string;
+    documentsCompleted?: number;
+    totalDocuments?: number;
+    constructor(onProgress?: ((progress: CopyProgress) => void) | undefined);
+    emit(phase: CopyProgressPhase, message: string): void;
+}
+/**
+ * Gather the source/target facts the strategy resolver needs, then resolve it.
+ *
+ * Shared by `copyDocument` and `canCopyDocument` so the answer a caller gets
+ * from the dry run is the one the real run will act on.
+ */
+export declare function prepareCopy(source: CopyEngineHost, target: CopyEngineHost, sourceDocId: string, options: CopyDocumentOptions, precomputedTargetDocId?: string): Promise<{
+    context: CopyContext;
+    feasibility: CopyFeasibility;
+    sourceEntries: StoreEntryMetadata[];
+}>;
+/** Dry run: report what a copy would do without writing anything. */
+export declare function canCopyDocument(source: CopyEngineHost, target: CopyEngineHost, docId: string, options?: CopyDocumentOptions): Promise<CopyFeasibility>;
+/**
+ * Copy one document into another database.
+ *
+ * @see `docs/document-copy.md` for the strategy matrix and caveats.
+ */
+export declare function copyDocument(source: CopyEngineHost, target: CopyEngineHost, docId: string, options?: CopyDocumentOptions, sharedReporter?: CopyProgressReporter): Promise<CopyDocumentResult>;
+//# sourceMappingURL=copyDocument.d.ts.map

package/dist/core/copy/copyDocument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copyDocument.d.ts","sourceRoot":"","sources":["../../../src/core/copy/copyDocument.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAc,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC/E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,EAIL,KAAK,WAAW,EACjB,MAAM,eAAe,CAAC;AAUvB,OAAO,KAAK,EACV,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,EACf,YAAY,EACZ,iBAAiB,EAClB,MAAM,SAAS,CAAC;AAKjB;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,cAAc,EAAE,cAAc,CAAC;IAC/B,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,mBAAmB,GAC3B,cAAc,GAAG,SAAS,CAM5B;AAED;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,MAAM,CAAC,CAKjB;AAED;;;;;GAKG;AACH,qBAAa,oBAAoB;IAUnB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC;IATxC,aAAa,SAAK;IAClB,WAAW,SAAK;IAChB,cAAc,SAAK;IACnB,iBAAiB,SAAK;IACtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;gBAEK,UAAU,CAAC,GAAE,CAAC,QAAQ,EAAE,YAAY,KAAK,IAAI,aAAA;IAE1E,IAAI,CAAC,KAAK,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;CActD;AAkCD;;;;;GAKG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,cAAc,EACtB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,mBAAmB,EAC5B,sBAAsB,CAAC,EAAE,MAAM,GAC9B,OAAO,CAAC;IACT,OAAO,EAAE,WAAW,CAAC;IACrB,WAAW,EAAE,eAAe,CAAC;IAC7B,aAAa,EAAE,kBAAkB,EAAE,CAAC;CACrC,CAAC,CA8CD;AAED,qEAAqE;AACrE,wBAAsB,eAAe,CACnC,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,eAAe,CAAC,CAG1B;AAED;;;;GAIG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,mBAAwB,EACjC,cAAc,CAAC,EAAE,oBAAoB,GACpC,OAAO,CAAC,kBAAkB,CAAC,CA2B7B"}