@elytracms/studio 0.0.91 → 0.0.93

package/dist/lib/operations/cms-persistence.js

@@ -1,100 +1,479 @@
-import { selfTypeDocument } from '@elytracms/core/cms-core';
+import { applyDocumentPatches, documentKey, formatValuePath, selfTypeDocument, touchedPaths, valuePathsOverlap, } from '@elytracms/core/cms-core';
 import { createPersistQueue } from './persist-queue.js';
+/** A patch's identity within one call: op + target path (no two value writes of one path share a run). */
+function targetKey(op, path) {
+    return `${op} ${formatValuePath(path)}`;
+}
+function patchTarget(patch) {
+    return patch.op === 'insert' ? [...patch.at.parent, { kind: 'node', id: patch.node.id }] : patch.path;
+}
+function conflictId(ref, path) {
+    return `${documentKey(ref)}|${formatValuePath(path)}`;
+}
+/** Paths two patches have in common (either touches a prefix of the other's). */
+function patchesOverlap(a, b) {
+    return touchedPaths(a).some((p) => touchedPaths(b).some((q) => valuePathsOverlap(p, q)));
+}
+/** A `set`/`unset` on exactly one path — the shape a later edit of the same field supersedes. */
+function isValueWrite(patch) {
+    return patch.op === 'set' || patch.op === 'unset';
+}
+function samePath(a, b) {
+    return a.length === b.length && valuePathsOverlap(a, b);
+}
 export function createCmsPersister(options) {
-    const queue = createPersistQueue();
-    let baselineDone = false;
-    /**
-     * EC-277 → EC-586: canonicalise a document (+ the manifest for composition static
-     * props) before it is dispatched — THE write canonicaliser (`selfTypeDocument` →
-     * `FIELD_TYPES`), the same function `documents.upsert` runs on arrival and `writeField`
-     * runs on the first in-session write. It is idempotent and identity-preserving, so the
-     * operation's own pass over an already-canonical document is a pointer walk; this call
-     * is here because the studio's operations client carries no manifest lookup and the
-     * session does. Drift-tolerant: an undeclared collection passes through unchanged.
-     */
-    function selfType(doc) {
+    const queue = createPersistQueue((error) => {
+        options.onError({
+            code: 'unknown',
+            message: error instanceof Error ? error.message : String(error),
+        });
+    });
+    const entries = new Map();
+    function entryOf(ref) {
+        const key = documentKey(ref);
+        let entry = entries.get(key);
+        if (!entry) {
+            entry = {
+                ref: { collection: ref.collection, id: ref.id },
+                base: undefined,
+                provisional: undefined,
+                queue: [],
+                inFlight: [],
+                busy: false,
+                conflicts: [],
+                held: undefined,
+                scheduled: false,
+                deleted: false,
+            };
+            entries.set(key, entry);
+        }
+        return entry;
+    }
+    /** EC-586: THE write canonicaliser over a whole document a writer hands us (create/import). */
+    function canonical(doc) {
         const collection = options.getCollections().find((c) => c.id === doc.collection);
         if (!collection)
             return doc;
         return selfTypeDocument(doc, collection, options.lookupManifest ? { lookupManifest: options.lookupManifest } : {});
     }
-    async function ensureBaselineNow() {
-        if (baselineDone)
-            return true;
-        const operations = await options.getOperations();
-        const schema = await operations.schema.get({ projectId: options.projectId });
-        if (schema.ok) {
-            // A persisted schema exists (seeded sample project or an earlier
-            // session) — the session started from the same fixtures, so commands
-            // can apply directly.
-            baselineDone = true;
-            return true;
+    /** The session's view: base ⊕ unresolved mine ⊕ in-flight ⊕ queued (the pure merge, no log). */
+    function display(entry) {
+        const baseDocument = entry.base?.document ?? entry.provisional;
+        if (entry.deleted || !baseDocument)
+            return undefined;
+        const patches = [
+            ...entry.conflicts.map((conflict) => conflict.patch),
+            ...entry.inFlight.map((queued) => queued.patch),
+            ...entry.queue.map((queued) => queued.patch),
+        ];
+        if (patches.length === 0)
+            return baseDocument;
+        return applyDocumentPatches({ document: baseDocument, patches, since: [] }).document;
+    }
+    function emitDocument(entry) {
+        if (entry.deleted)
+            return;
+        const shown = display(entry);
+        if (shown)
+            options.onDocument?.(entry.ref, shown);
+    }
+    function emitConflicts(entry) {
+        options.onConflicts?.(entry.ref, [...entry.conflicts]);
+    }
+    /** Adopt a server row as the base (never a lower revision), re-derive the view. */
+    function adopt(entry, record) {
+        if (entry.base && record.revision < entry.base.revision)
+            return;
+        entry.base = record;
+        options.onRecord?.(record);
+        emitDocument(entry);
+    }
+    /** After a write: apply a subscription row that arrived meanwhile, if newer. */
+    function adoptHeld(entry) {
+        const held = entry.held;
+        entry.held = undefined;
+        if (held === undefined)
+            return;
+        if (held === null) {
+            markGone(entry);
+            return;
         }
-        const saved = await operations.schema.save({
-            projectId: options.projectId,
-            collections: [...options.getCollections()],
+        if (!entry.base || held.revision > entry.base.revision)
+            adopt(entry, held);
+    }
+    function markGone(entry) {
+        if (entry.deleted)
+            return;
+        entry.deleted = true;
+        entry.queue = [];
+        options.onDocument?.(entry.ref, undefined);
+    }
+    function schedule(entry) {
+        if (entry.scheduled)
+            return;
+        entry.scheduled = true;
+        queue.push(async () => {
+            entry.scheduled = false;
+            await drain(entry);
+            adoptHeld(entry);
         });
-        if (!saved.ok) {
-            options.onError(saved.error);
-            return false;
+    }
+    /** Who changed a refused path — the newest patch-log row in (base, current] touching it. Best-effort. */
+    async function resolveActors(entry, sentBase, refused) {
+        try {
+            const operations = await options.getOperations();
+            const log = await operations.documents.listPatches({
+                projectId: options.projectId,
+                ref: entry.ref,
+                afterRevision: sentBase,
+            });
+            if (!log.ok)
+                return;
+            let changed = false;
+            entry.conflicts = entry.conflicts.map((conflict) => {
+                if (conflict.actor !== undefined || !refused.some((r) => r.id === conflict.id))
+                    return conflict;
+                const row = [...log.value]
+                    .reverse()
+                    .find((candidate) => candidate.kind === 'replace' ||
+                    candidate.patches.some((patch) => touchedPaths(patch).some((path) => valuePathsOverlap(path, conflict.path))));
+                if (!row?.actor)
+                    return conflict;
+                changed = true;
+                return { ...conflict, actor: row.actor };
+            });
+            if (changed)
+                emitConflicts(entry);
         }
-        for (const document of options.getDocuments()) {
-            const result = await operations.documents.upsert({
+        catch {
+            // The actor is decoration on a conflict the user can already resolve.
+        }
+    }
+    /** Send the queue, one run of equal base at a time, until it is empty or a write fails. */
+    async function drain(entry) {
+        while (entry.queue.length > 0 && !entry.deleted) {
+            const operations = await options.getOperations();
+            if (!entry.base) {
+                // Untracked (a document the session never hydrated a revision for): read it.
+                // The user's view of it is the session's, so this is the narrowest window left.
+                const read = await operations.documents.get({ projectId: options.projectId, ref: entry.ref });
+                if (!read.ok) {
+                    options.onError(read.error);
+                    return;
+                }
+                entry.base = read.value;
+            }
+            const resolveBase = (queued) => queued.base ?? entry.base.revision;
+            const first = resolveBase(entry.queue[0]);
+            let end = 1;
+            while (end < entry.queue.length && resolveBase(entry.queue[end]) === first)
+                end += 1;
+            const run = entry.queue.splice(0, end);
+            entry.inFlight = run;
+            const result = await operations.documents.patch({
                 projectId: options.projectId,
-                document: selfType(document),
+                ref: entry.ref,
+                baseRevision: first,
+                patches: run.map((queued) => queued.patch),
             });
-            if (!result.ok) {
-                options.onError(result.error);
-                return false;
+            entry.inFlight = [];
+            if (result.ok) {
+                rebaseCovered(entry, run, result.value.revision);
+                adopt(entry, result.value);
+                adoptHeld(entry);
+                settleAll(run, { status: 'applied', record: result.value });
+                continue;
             }
+            const error = result.error;
+            if (error.code === 'conflict' && error.refused && error.current) {
+                const current = error.current;
+                // Refusals are matched to the run by op + target path (the operation re-parses
+                // and canonicalises the patches, so object identity does not survive the call).
+                const refusedByKey = new Map(error.refused.map((refused) => [targetKey(refused.patch.op, refused.path), refused]));
+                const applied = [];
+                const conflicts = [];
+                for (const queued of run) {
+                    const refused = refusedByKey.get(targetKey(queued.patch.op, patchTarget(queued.patch)));
+                    if (!refused) {
+                        applied.push(queued);
+                        continue;
+                    }
+                    // MINE is what the user wrote (the queued patch), not the canonicalised echo.
+                    const conflict = upsertConflict(entry, { ...refused, patch: queued.patch }, current.revision);
+                    conflicts.push(conflict);
+                    for (const settle of queued.settle)
+                        settle({ status: 'refused', conflicts: [conflict] });
+                }
+                rebaseCovered(entry, applied, current.revision);
+                adopt(entry, current);
+                adoptHeld(entry);
+                emitConflicts(entry);
+                settleAll(applied, { status: 'applied', record: current });
+                void resolveActors(entry, first, conflicts);
+                continue;
+            }
+            if (error.code === 'conflict' && 'current' in error && error.current === null) {
+                // The document was deleted since — nothing to write into.
+                markGone(entry);
+                options.onError(error);
+                settleAll(run, { status: 'failed', error });
+                return;
+            }
+            // A transport / authorization failure: the patches stay local (shown, unsent) and
+            // the error is visible; the next commit or forced flush retries them. The commits
+            // waiting on them learn of the failure now.
+            settleAll(run, { status: 'failed', error });
+            entry.queue.unshift(...run.map((queued) => ({ ...queued, settle: [] })));
+            adoptHeld(entry);
+            options.onError(error);
+            return;
+        }
+    }
+    function settleAll(queued, outcome) {
+        for (const item of queued)
+            for (const settle of item.settle)
+                settle(outcome);
+    }
+    /** Queued patches on a path our own write just covered move their base to that write's revision. */
+    function rebaseCovered(entry, written, revision) {
+        if (written.length === 0)
+            return;
+        for (const queued of entry.queue) {
+            if (queued.base !== undefined && queued.base >= revision)
+                continue;
+            if (written.some((done) => patchesOverlap(done.patch, queued.patch)))
+                queued.base = revision;
         }
-        baselineDone = true;
-        return true;
     }
-    function command(run) {
+    function upsertConflict(entry, refused, revision) {
+        const conflict = {
+            id: conflictId(entry.ref, refused.path),
+            ref: entry.ref,
+            patch: refused.patch,
+            path: refused.path,
+            theirs: refused.current,
+            reason: refused.reason,
+            revision,
+        };
+        entry.conflicts = [...entry.conflicts.filter((c) => c.id !== conflict.id), conflict];
+        return conflict;
+    }
+    function command(entry, run) {
         queue.push(async () => {
-            // A failed baseline already surfaced through onError — running the
-            // command against missing records would only add a confusing follow-up.
-            if (!(await ensureBaselineNow()))
-                return;
             const operations = await options.getOperations();
-            const result = await run(operations);
-            if (!result.ok)
-                options.onError(result.error);
+            entry.busy = true;
+            try {
+                const result = await run(operations);
+                if (!result.ok)
+                    options.onError(result.error);
+            }
+            finally {
+                entry.busy = false;
+                adoptHeld(entry);
+            }
         });
     }
     return {
-        upsertDocument(doc) {
-            const document = selfType(doc);
-            command(async (operations) => {
-                const result = await operations.documents.upsert({ projectId: options.projectId, document });
-                // EC-449: hand the authoritative saved record back to the session so it
-                // adopts the server-computed `hasUnpublishedChanges` verdict (the queue
-                // swallows successful results otherwise).
-                if (result.ok)
-                    options.onDocumentSaved?.(result.value);
-                return result;
-            });
+        track(row) {
+            const entry = entryOf(row.document);
+            if (!entry.base || row.revision > entry.base.revision)
+                entry.base = row;
         },
-        deleteDocument(ref) {
-            command((operations) => operations.documents.delete({ projectId: options.projectId, ref }));
+        revisionOf: (ref) => entries.get(documentKey(ref))?.base?.revision,
+        documentOf: (ref) => {
+            const entry = entries.get(documentKey(ref));
+            return entry ? display(entry) : undefined;
         },
-        publishDocument(ref) {
-            command((operations) => operations.documents.publish({ projectId: options.projectId, ref }));
+        adoptRecord(record) {
+            const entry = entryOf(record.document);
+            if (entry.deleted)
+                return;
+            if (!entry.base || record.revision > entry.base.revision)
+                adopt(entry, record);
         },
-        unpublishDocument(ref) {
-            command((operations) => operations.documents.unpublish({ projectId: options.projectId, ref }));
+        commit(ref, patches, view, bases) {
+            const entry = entryOf(ref);
+            if (patches.length === 0 || entry.deleted) {
+                return Promise.resolve({
+                    status: 'failed',
+                    error: { code: 'not-found', message: 'The document is gone.', entity: 'cms-document', key: documentKey(ref) },
+                });
+            }
+            if (!entry.base && !entry.provisional && view)
+                entry.provisional = view;
+            let conflictsChanged = false;
+            const waits = [];
+            for (const [index, patch] of patches.entries()) {
+                const madeAt = bases?.[index] ?? entry.base?.revision;
+                let settle;
+                waits.push(new Promise((resolve) => (settle = resolve)));
+                // A field with an unresolved conflict: the new value replaces MINE, unsent —
+                // the user decides (keep mine sends it), never an implicit overwrite of theirs.
+                const open = entry.conflicts.find((conflict) => patchesOverlap(conflict.patch, patch));
+                if (open && isValueWrite(patch) && isValueWrite(open.patch) && samePath(open.patch.path, patch.path)) {
+                    const replaced = { ...open, patch };
+                    entry.conflicts = entry.conflicts.map((c) => (c === open ? replaced : c));
+                    conflictsChanged = true;
+                    settle({ status: 'refused', conflicts: [replaced] });
+                    continue;
+                }
+                // A later value write of the same field supersedes an unsent one (keeping the
+                // EARLIER base — the user never saw a foreign value of a field they were typing in).
+                if (isValueWrite(patch)) {
+                    const pending = entry.queue.findIndex((queued) => isValueWrite(queued.patch) && samePath(queued.patch.path, patch.path));
+                    if (pending >= 0) {
+                        const superseded = entry.queue[pending];
+                        entry.queue[pending] = { patch, base: superseded.base, settle: [...superseded.settle, settle] };
+                        continue;
+                    }
+                }
+                entry.queue.push({ patch, base: madeAt, settle: [settle] });
+            }
+            emitDocument(entry);
+            if (conflictsChanged)
+                emitConflicts(entry);
+            schedule(entry);
+            // The commit's outcome: failed if any of its patches failed, refused if any was.
+            return Promise.all(waits).then((outcomes) => {
+                const failed = outcomes.find((o) => o.status === 'failed');
+                if (failed)
+                    return failed;
+                const refused = outcomes.flatMap((o) => (o.status === 'refused' ? o.conflicts : []));
+                if (refused.length > 0)
+                    return { status: 'refused', conflicts: refused };
+                return outcomes[outcomes.length - 1];
+            });
         },
-        upsertCollection(collection) {
-            command((operations) => operations.schema.upsertCollection({ projectId: options.projectId, collection }));
+        create(document) {
+            const doc = canonical(document);
+            const entry = entryOf(doc);
+            entry.deleted = false;
+            // Optimistic: the session shows the document at once; the base is the created row.
+            entry.provisional = doc;
+            options.onDocument?.(entry.ref, doc);
+            queue.push(async () => {
+                const operations = await options.getOperations();
+                entry.busy = true;
+                try {
+                    const result = await operations.documents.replace({
+                        projectId: options.projectId,
+                        document: doc,
+                        precondition: { ifAbsent: true },
+                    });
+                    if (result.ok)
+                        adopt(entry, result.value);
+                    else
+                        options.onError(result.error);
+                }
+                finally {
+                    entry.busy = false;
+                    adoptHeld(entry);
+                }
+                if (entry.queue.length > 0)
+                    await drain(entry);
+            });
         },
-        async ensureBaseline() {
+        replace(document) {
+            const doc = canonical(document);
+            const entry = entryOf(doc);
+            if (!entry.base)
+                entry.provisional = doc;
+            options.onDocument?.(entry.ref, doc);
             queue.push(async () => {
-                await ensureBaselineNow();
+                await drain(entry);
+                const operations = await options.getOperations();
+                entry.busy = true;
+                try {
+                    const result = await operations.documents.replace({
+                        projectId: options.projectId,
+                        document: doc,
+                        precondition: entry.base ? { revision: entry.base.revision } : { ifAbsent: true },
+                    });
+                    if (result.ok)
+                        adopt(entry, result.value);
+                    else {
+                        if (result.error.code === 'conflict' && 'current' in result.error && result.error.current) {
+                            adopt(entry, result.error.current);
+                        }
+                        options.onError(result.error);
+                    }
+                }
+                finally {
+                    entry.busy = false;
+                    adoptHeld(entry);
+                }
             });
+        },
+        deleteDocument(ref) {
+            const entry = entryOf(ref);
+            entry.queue = [];
+            entry.conflicts = [];
+            entry.deleted = true;
+            emitConflicts(entry);
+            command(entry, (operations) => operations.documents.delete({ projectId: options.projectId, ref }));
+        },
+        unpublishDocument(ref) {
+            const entry = entryOf(ref);
+            queue.push(async () => {
+                await drain(entry);
+                const operations = await options.getOperations();
+                entry.busy = true;
+                try {
+                    const result = await operations.documents.unpublish({ projectId: options.projectId, ref });
+                    if (result.ok)
+                        adopt(entry, result.value);
+                    else
+                        options.onError(result.error);
+                }
+                finally {
+                    entry.busy = false;
+                    adoptHeld(entry);
+                }
+            });
+        },
+        adoptSnapshot(ref, record) {
+            const entry = entryOf(ref);
+            if (entry.inFlight.length > 0 || entry.busy || entry.scheduled) {
+                // Hold it: the write's own result decides first; the newer of the two wins.
+                if (record === undefined)
+                    entry.held = null;
+                else if (!entry.held || record.revision > entry.held.revision)
+                    entry.held = record;
+                return;
+            }
+            if (record === undefined) {
+                if (entry.base)
+                    markGone(entry);
+                return;
+            }
+            if (!entry.base || record.revision > entry.base.revision)
+                adopt(entry, record);
+        },
+        conflicts: (ref) => entries.get(documentKey(ref))?.conflicts ?? [],
+        resolveConflict(ref, id, choice) {
+            const entry = entries.get(documentKey(ref));
+            if (!entry)
+                return;
+            const conflict = entry.conflicts.find((c) => c.id === id);
+            if (!conflict)
+                return;
+            entry.conflicts = entry.conflicts.filter((c) => c !== conflict);
+            if (choice === 'mine') {
+                // Keep mine: re-send at the CURRENT base — a visible, explicit second write.
+                entry.queue.push({ patch: conflict.patch, base: entry.base?.revision, settle: [] });
+                schedule(entry);
+            }
+            emitDocument(entry);
+            emitConflicts(entry);
+        },
+        async flush(ref) {
+            if (ref) {
+                const entry = entries.get(documentKey(ref));
+                if (entry && entry.queue.length > 0)
+                    schedule(entry);
+            }
             await queue.flush();
         },
-        flush: () => queue.flush(),
     };
 }
 //# sourceMappingURL=cms-persistence.js.map