@elytracms/studio 0.0.100 → 0.0.101

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

@@ -129,6 +129,14 @@ 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 strict relation
+ * references it); `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). */
+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 +201,16 @@ 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:
+     * `documents.delete` with the precondition `{ 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) refuses it in the store's own step, and the store's strict-referrer guard
+     * refuses it while a strict relation references it. 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,15 @@
 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). */
+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';
+    return error.current === null ? 'gone' : 'changed';
+}
 /** 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 +1192,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 },
+                        });
+                        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) });