@elytracms/studio 0.0.100 → 0.0.102

package/dist/lib/operations/cms-persistence.d.ts

@@ -129,6 +129,21 @@ export type CommitOutcome = {
     readonly status: 'failed';
     readonly error: OperationError;
 };
+/**
+ * EC-728 — what {@link CmsPersister.deleteCreated} did: `deleted`; `gone` (already deleted);
+ * `changed` (written since the create — edited or published); `referenced` (a document
+ * references it — any relation, weak or strict, draft or published, EC-739); `not-created`
+ * (this session holds no create receipt for it); `failed`.
+ */
+export type DeleteCreatedOutcome = 'deleted' | 'gone' | 'changed' | 'referenced' | 'not-created' | 'failed';
+/**
+ * EC-728 — the refusal of a conditional delete, read off the operation's error (pure). EC-739:
+ * `referenced` when the conflict names referrers (the unreferenced guard's refusal, before the
+ * store or re-judged after it refused); `changed` only for a REVISION conflict — one carrying
+ * the current row; `gone` when that row is absent. A conflict carrying neither (a referrer that
+ * refused the store's step and was gone again by the re-judge) is `failed`: it was never an edit.
+ */
+export declare function deleteCreatedRefusal(error: OperationError): Exclude<DeleteCreatedOutcome, 'deleted' | 'not-created'>;
 export interface CmsPersister {
     /** Adopt a server row as this session's base for its document (hydration, a create result). */
     track(row: TrackedRow): void;
@@ -193,6 +208,19 @@ export interface CmsPersister {
      */
     replace(document: CmsDocument, revision: number | undefined, authoredOn?: CmsDocument): void;
     deleteDocument(ref: DocumentRef): void;
+    /**
+     * EC-728 — delete a document THIS session created, only while it is exactly as created and
+     * nobody else has it: `documents.delete` with the precondition `{ revision, unreferenced }`.
+     * `revision` = the revision this session's own create landed at (its receipt — never a later
+     * read), so a write by anyone since (an edit, a publish — "never published" needs nothing
+     * more) refuses it in the store's own step; `unreferenced` (EC-739) refuses it while ANY
+     * document references it — weak or strict, draft or published — judged by the operation and
+     * re-checked by the store in that same step, so a reference saved since the guard's read
+     * refuses it too. One write, every condition. Sent after every write queued before it.
+     * Nothing is reported on the session's error surface — a refusal is an expected answer the
+     * caller words; the session drops the document only once the store has deleted it.
+     */
+    deleteCreated(ref: DocumentRef): Promise<DeleteCreatedOutcome>;
     unpublishDocument(ref: DocumentRef): void;
     /**
      * Adopt a server row pushed by the document subscription (EC-595 point 7): applied

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

@@ -1,5 +1,23 @@
 import { applyDocumentPatches, documentKey, expandValuePath, fieldPositionPatches, formatValuePath, isValuePathPrefix, readValueAt, selfTypeDocument, semanticValueEqual, touchedPaths, touchedPathsOfEntry, valuePathsOverlap, } from '@elytracms/core/cms-core';
 import { createPersistQueue } from './persist-queue.js';
+/**
+ * EC-728 — the refusal of a conditional delete, read off the operation's error (pure). EC-739:
+ * `referenced` when the conflict names referrers (the unreferenced guard's refusal, before the
+ * store or re-judged after it refused); `changed` only for a REVISION conflict — one carrying
+ * the current row; `gone` when that row is absent. A conflict carrying neither (a referrer that
+ * refused the store's step and was gone again by the re-judge) is `failed`: it was never an edit.
+ */
+export function deleteCreatedRefusal(error) {
+    if (error.code === 'not-found')
+        return 'gone';
+    if (error.code !== 'conflict')
+        return 'failed';
+    if ((error.referrers?.length ?? 0) > 0)
+        return 'referenced';
+    if (error.current === null)
+        return 'gone';
+    return error.current ? 'changed' : 'failed';
+}
 /** EC-686 — a decomposed alias is re-sent at most this often (each time a colleague wrote the document in between). */
 const ALIAS_ATTEMPTS = 3;
 /** How many own writes a document's ledger keeps (an older base just stops lifting — a conflict, never a borrow). */
@@ -1182,6 +1200,43 @@ export function createCmsPersister(options) {
             emitDocument(entry);
             schedule(entry);
         },
+        deleteCreated(ref) {
+            const entry = entryOf(ref);
+            return new Promise((resolve) => {
+                // Queued like every write: whatever was committed before it is sent first.
+                queue.push(async () => {
+                    if (entry.deleted)
+                        return resolve('gone');
+                    if (entry.created === undefined)
+                        return resolve('not-created');
+                    // A write of ours committed and not sent yet is an edit since the create.
+                    if (entry.queue.length > 0)
+                        return resolve('changed');
+                    const operations = await options.getOperations();
+                    entry.busy = true;
+                    try {
+                        const result = await operations.documents.delete({
+                            projectId: options.projectId,
+                            ref: entry.ref,
+                            precondition: { revision: entry.created, unreferenced: true },
+                        });
+                        if (result.ok) {
+                            markGone(entry);
+                            resolve('deleted');
+                        }
+                        else
+                            resolve(deleteCreatedRefusal(result.error));
+                    }
+                    catch {
+                        resolve('failed');
+                    }
+                    finally {
+                        entry.busy = false;
+                        adoptHeld(entry);
+                    }
+                });
+            });
+        },
         deleteDocument(ref) {
             const entry = entryOf(ref);
             dropQueued(entry, { status: 'failed', error: goneError(ref) });