@elytracms/studio 0.0.101 → 0.0.103

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

@@ -131,11 +131,18 @@ export type CommitOutcome = {
 };
 /**
  * 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`.
+ * `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-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). */
@@ -202,13 +209,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.
+     * 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;

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

@@ -1,6 +1,12 @@
 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-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';
@@ -8,7 +14,9 @@ export function deleteCreatedRefusal(error) {
         return 'failed';
     if ((error.referrers?.length ?? 0) > 0)
         return 'referenced';
-    return error.current === null ? 'gone' : 'changed';
+    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;
@@ -1210,7 +1218,7 @@ export function createCmsPersister(options) {
                         const result = await operations.documents.delete({
                             projectId: options.projectId,
                             ref: entry.ref,
-                            precondition: { revision: entry.created },
+                            precondition: { revision: entry.created, unreferenced: true },
                         });
                         if (result.ok) {
                             markGone(entry);