@elytracms/studio 0.0.99 → 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, documentValueBuckets, expandValuePath, fieldPath, formatValuePath, isValuePathPrefix, readValueAt, selfTypeDocument, semanticValueEqual, touchedPaths, touchedPathsOfEntry, valuePathsOverlap, } from '@elytracms/core/cms-core';
+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). */
@@ -231,22 +241,16 @@ function withAlias(document, alias) {
 /**
  * EC-686 item 1 — what a whole-document snapshot changed against the view it was made from,
  * position by position: a `set` (or an `unset`, the value gone) of every field position —
- * `values[f]`, `localized[l][f]` — whose value differs by THE equality
- * (`documentValueBuckets` + `semanticValueEqual`, the document diff's own reading). Every
- * value change of a document is one of these; its slot `alias` is the one key that is not.
+ * `values[f]`, `localized[l][f]` — whose value differs by THE equality. Every value change of
+ * a document is one of these; its slot `alias` is the one key that is not.
+ *
+ * EC-703 (Codex round 6 F33): THE own-property per-position diff (`fieldPositionPatches`,
+ * cms-core — the one the publish strip reads too). This copy read `bucket.after[key]`, so a
+ * removed field named after an `Object.prototype` member became `set constructor = Object`
+ * and every later `documentOf` threw (measured).
  */
 function positionPatches(view, snapshot) {
-    const patches = [];
-    for (const bucket of documentValueBuckets(view, snapshot)) {
-        for (const key of new Set([...Object.keys(bucket.before), ...Object.keys(bucket.after)])) {
-            if (semanticValueEqual(bucket.before[key], bucket.after[key]))
-                continue;
-            const path = fieldPath(key, bucket.locale);
-            const value = bucket.after[key];
-            patches.push(value === undefined ? { op: 'unset', path } : { op: 'set', path, value });
-        }
-    }
-    return patches;
+    return fieldPositionPatches(view, snapshot);
 }
 export function createCmsPersister(options) {
     const queue = createPersistQueue((error) => {
@@ -1188,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) });