drupal-mcp-connector 2.14.2 → 2.15.0

package/src/lib/draft-write.js

@@ -4,6 +4,8 @@
  * Translation create/update uses the same surface with X-MCP-Draft-Langcode.
  */
 
+import { entityRevisionId } from "./write-revision.js";
+
 const LANGCODE_RE = /^[a-z][a-z0-9_-]{0,11}$/;
 const MISSING_DRAFT_ENDPOINT =
   "The site does not provide Sentinel's governed draft endpoint (d.o #3621022). " +
@@ -56,9 +58,9 @@ function requireWorkingPair(draftRevision) {
  * @param {string} id
  * @returns {string}
  */
-function nodeResource(backend, entityType, bundle, id) {
-  if (entityType !== "node") {
-    throw new Error("Governed draft translation is implemented for nodes.");
+function draftResource(backend, entityType, bundle, id) {
+  if (entityType !== "node" && entityType !== "paragraph") {
+    throw new Error("Governed draft translation is implemented for nodes and paragraphs.");
   }
   if (typeof backend.rawQuery !== "function" || typeof backend.resourcePath !== "function") {
     throw new Error("This backend does not support governed draft continuation.");
@@ -66,6 +68,18 @@ function nodeResource(backend, entityType, bundle, id) {
   return `${backend.resourcePath(entityType, bundle)}/${encodeURIComponent(id)}`;
 }
 
+/**
+ * @param {object} [draftRevision]
+ * @returns {string}
+ */
+function requireParagraphRevisionId(draftRevision) {
+  const revisionId = String(draftRevision?.revisionId ?? draftRevision?.workingVid ?? "");
+  if (!/^[1-9]\d*$/.test(revisionId)) {
+    throw new Error("Paragraph translation requires a verified paragraph revision ID.");
+  }
+  return revisionId;
+}
+
 /**
  * Validate or continue a draft, using the same payload and revision precondition.
  * No canonical fallback: an absent endpoint or refused precondition stops work.
@@ -76,8 +90,11 @@ function nodeResource(backend, entityType, bundle, id) {
  */
 export async function writeDraft(backend, input, preflight = false) {
   const { entityType, bundle, id, attributes = {}, relationships, draftRevision, langcode } = input;
+  if (entityType === "paragraph") {
+    return writeParagraphDraft(backend, input, preflight);
+  }
   const { live, working } = requireWorkingPair(draftRevision);
-  const base = nodeResource(backend, entityType, bundle, id);
+  const base = draftResource(backend, entityType, bundle, id);
   const data = { type: `${entityType}--${bundle}`, id, attributes };
   if (relationships) data.relationships = relationships;
   const headers = {
@@ -123,6 +140,11 @@ export async function writeDraft(backend, input, preflight = false) {
 export async function createTranslationDraft(backend, input, preflight = false) {
   const { entityType, bundle, id, attributes = {}, relationships, draftRevision } = input;
   const langcode = assertDraftLangcode(input.langcode);
+  if (entityType === "paragraph") {
+    return createParagraphTranslationDraft(backend, {
+      entityType, bundle, id, attributes, relationships, draftRevision, langcode,
+    }, preflight);
+  }
   const live = String(draftRevision?.liveVid ?? "");
   const workingRaw = draftRevision?.workingVid;
   const working = workingRaw === undefined || workingRaw === null || workingRaw === ""
@@ -134,7 +156,7 @@ export async function createTranslationDraft(backend, input, preflight = false)
   if (working && (!/^[1-9]\d*$/.test(working) || working === live)) {
     throw new Error("Translation create requires distinct live and working revision IDs when a working copy exists.");
   }
-  const base = nodeResource(backend, entityType, bundle, id);
+  const base = draftResource(backend, entityType, bundle, id);
   const safeAttributes = { ...attributes };
   delete safeAttributes.langcode;
   const data = { type: `${entityType}--${bundle}`, id, attributes: safeAttributes };
@@ -155,7 +177,7 @@ export async function createTranslationDraft(backend, input, preflight = false)
       },
     });
   } catch (error) {
-    throw missingEndpointError(error, MISSING_TRANSLATION_ENDPOINT);
+    throw rewriteTranslationWorkingRevisionError(missingEndpointError(error, MISSING_TRANSLATION_ENDPOINT));
   }
   if (preflight) {
     if (result?.meta?.draft_preflight !== true || String(result.meta.live) !== live) {
@@ -169,16 +191,77 @@ export async function createTranslationDraft(backend, input, preflight = false)
   return backend.toCanonical(result.data);
 }
 
+/**
+ * Live + working revision ids for a node translation create.
+ * Prefers Sentinel's mcp-translations inventory over JSON:API
+ * `rel:working-copy`, which 403s on some unpublished drafts even when a
+ * working revision exists (#282).
+ * @param {object} backend
+ * @param {{entityType: string, bundle: string, id: string, existing?: ?object}} ref
+ * @returns {Promise<{liveVid: ?(number|string), workingVid: ?(number|string)}>}
+ */
+export async function resolveNodeTranslationPair(backend, { entityType, bundle, id, existing }) {
+  const fromEntity = existing ? entityRevisionId(existing) : null;
+  try {
+    const meta = await readTranslationInventory(backend, { entityType, bundle, id });
+    const liveVid = meta.live?.vid ?? fromEntity;
+    const workingVid = meta.working?.vid;
+    const distinct = workingVid !== undefined && workingVid !== null && workingVid !== ""
+      && liveVid !== undefined && liveVid !== null
+      && String(workingVid) !== String(liveVid);
+    return { liveVid, workingVid: distinct ? workingVid : undefined };
+  } catch {
+    if (typeof backend.getEntity !== "function") {
+      return { liveVid: fromEntity, workingVid: undefined };
+    }
+    let workingCopy = null;
+    try {
+      workingCopy = await backend.getEntity({
+        entityType, bundle, id, resourceVersion: "rel:working-copy",
+      });
+    } catch {
+      workingCopy = null;
+    }
+    const workingVid = workingCopy ? entityRevisionId(workingCopy) : null;
+    const distinct = workingVid !== null && fromEntity !== null && String(workingVid) !== String(fromEntity);
+    return { liveVid: fromEntity, workingVid: distinct ? workingVid : undefined };
+  }
+}
+
+/**
+ * Rewrite Sentinel's live-only 409 into an actionable connector error.
+ * @param {unknown} error
+ * @returns {Error}
+ */
+export function rewriteTranslationWorkingRevisionError(error) {
+  if (/A working revision exists\. Reload and send both revision IDs/i.test(String(error?.message || ""))) {
+    return new Error(
+      "Translation create sent only the live revision, but a working draft exists. " +
+      "The connector should have sent both live and working revision IDs (If-Match). " +
+      "Reload with drupal_list_translations and retry. See connector #282.",
+      { cause: error instanceof Error ? error : undefined },
+    );
+  }
+  return error instanceof Error ? error : new Error(String(error));
+}
+
 /**
  * Read live/working translation inventory from Sentinel.
  * @param {object} backend
- * @param {{entityType: string, bundle: string, id: string}} ref
+ * @param {{entityType: string, bundle: string, id: string, revisionId?: string|number}} ref
  * @returns {Promise<object>}
  */
-export async function readTranslationInventory(backend, { entityType, bundle, id }) {
-  const base = nodeResource(backend, entityType, bundle, id);
+export async function readTranslationInventory(backend, { entityType, bundle, id, revisionId }) {
+  const base = draftResource(backend, entityType, bundle, id);
+  const headers = {};
+  if (revisionId !== undefined && revisionId !== null && revisionId !== "") {
+    headers["If-Match"] = `"${requireParagraphRevisionId({ revisionId })}"`;
+  }
   try {
-    const result = await backend.rawQuery({ path: `${base}/mcp-translations` });
+    const result = await backend.rawQuery({
+      path: `${base}/mcp-translations`,
+      options: Object.keys(headers).length ? { method: "GET", headers } : undefined,
+    });
     if (!result?.meta?.live) {
       throw new Error("The site did not return a translation inventory.");
     }
@@ -197,8 +280,11 @@ export async function readTranslationInventory(backend, { entityType, bundle, id
 export async function readDraftTranslation(backend, input) {
   const { entityType, bundle, id, draftRevision } = input;
   const langcode = assertDraftLangcode(input.langcode);
+  if (entityType === "paragraph") {
+    return readParagraphDraftTranslation(backend, input);
+  }
   const { live, working } = requireWorkingPair(draftRevision);
-  const base = nodeResource(backend, entityType, bundle, id);
+  const base = draftResource(backend, entityType, bundle, id);
   let result;
   try {
     result = await backend.rawQuery({
@@ -219,3 +305,126 @@ export async function readDraftTranslation(backend, input) {
   }
   return backend.toCanonical(result.data);
 }
+
+/**
+ * Continue an unpublished paragraph translation on a pinned revision.
+ * @param {object} backend
+ * @param {object} input
+ * @param {boolean} [preflight]
+ * @returns {Promise<object>}
+ */
+async function writeParagraphDraft(backend, input, preflight = false) {
+  const { entityType, bundle, id, attributes = {}, relationships, draftRevision } = input;
+  const langcode = assertDraftLangcode(input.langcode);
+  const revisionId = requireParagraphRevisionId(draftRevision);
+  const draftState = input.draftState;
+  if (typeof draftState !== "string" || !/^[a-f0-9]{64}$/.test(draftState)) {
+    throw new Error("Paragraph translation update requires draftState from the previous draft read. Re-read the draft; do not retry old copy with a refreshed token.");
+  }
+  const base = draftResource(backend, entityType, bundle, id);
+  const data = { type: `${entityType}--${bundle}`, id, attributes };
+  if (relationships) data.relationships = relationships;
+  const headers = {
+    "If-Match": `"${revisionId}"`,
+    "X-MCP-Draft-Preflight": preflight ? "1" : "0",
+    "X-MCP-Draft-Langcode": langcode,
+    "X-MCP-Draft-State": draftState,
+  };
+  let result;
+  try {
+    result = await backend.rawQuery({
+      path: `${base}/mcp-draft`,
+      options: { method: "PATCH", headers, body: JSON.stringify({ data }) },
+    });
+  } catch (error) {
+    throw missingEndpointError(error, MISSING_DRAFT_ENDPOINT);
+  }
+  if (preflight) {
+    if (result?.meta?.draft_preflight !== true
+      || String(result.meta.live) !== revisionId
+      || (result.meta.langcode && String(result.meta.langcode) !== langcode)) {
+      throw new Error("The site did not confirm a non-saving paragraph translation preflight. Refusing to continue.");
+    }
+    return result;
+  }
+  if (!result?.data || result.data.id !== id || result.data.type !== data.type) {
+    throw new Error("Paragraph translation write did not identify the requested entity. The write outcome is uncertain; re-read before retrying.");
+  }
+  return { ...backend.toCanonical(result.data), draftState: result.meta?.draft_state };
+}
+
+/**
+ * Create an unpublished paragraph translation on a pinned revision.
+ * @param {object} backend
+ * @param {object} input
+ * @param {boolean} [preflight]
+ * @returns {Promise<object>}
+ */
+async function createParagraphTranslationDraft(backend, input, preflight = false) {
+  const { entityType, bundle, id, attributes = {}, relationships, draftRevision, langcode } = input;
+  const revisionId = requireParagraphRevisionId(draftRevision);
+  const base = draftResource(backend, entityType, bundle, id);
+  const safeAttributes = { ...attributes };
+  delete safeAttributes.langcode;
+  const data = { type: `${entityType}--${bundle}`, id, attributes: safeAttributes };
+  if (relationships) data.relationships = relationships;
+  let result;
+  try {
+    result = await backend.rawQuery({
+      path: `${base}/mcp-draft/translations`,
+      options: {
+        method: "POST",
+        headers: {
+          "If-Match": `"${revisionId}"`,
+          "X-MCP-Draft-Preflight": preflight ? "1" : "0",
+          "X-MCP-Draft-Langcode": langcode,
+        },
+        body: JSON.stringify({ data }),
+      },
+    });
+  } catch (error) {
+    throw missingEndpointError(error, MISSING_TRANSLATION_ENDPOINT);
+  }
+  if (preflight) {
+    if (result?.meta?.draft_preflight !== true || String(result.meta.live) !== revisionId) {
+      throw new Error("The site did not confirm a non-saving paragraph translation preflight. Refusing to continue.");
+    }
+    return result;
+  }
+  if (!result?.data || result.data.id !== id || result.data.type !== data.type) {
+    throw new Error("Paragraph translation create did not identify the requested entity. The write outcome is uncertain; re-read before retrying.");
+  }
+  return { ...backend.toCanonical(result.data), draftState: result.meta?.draft_state };
+}
+
+/**
+ * Read one unpublished paragraph translation of a pinned revision.
+ * @param {object} backend
+ * @param {object} input
+ * @returns {Promise<object>}
+ */
+async function readParagraphDraftTranslation(backend, input) {
+  const { entityType, bundle, id, draftRevision } = input;
+  const langcode = assertDraftLangcode(input.langcode);
+  const revisionId = requireParagraphRevisionId(draftRevision);
+  const base = draftResource(backend, entityType, bundle, id);
+  let result;
+  try {
+    result = await backend.rawQuery({
+      path: `${base}/mcp-draft`,
+      options: {
+        method: "GET",
+        headers: {
+          "If-Match": `"${revisionId}"`,
+          "X-MCP-Draft-Langcode": langcode,
+        },
+      },
+    });
+  } catch (error) {
+    throw missingEndpointError(error, MISSING_TRANSLATION_ENDPOINT);
+  }
+  if (!result?.data || result.data.id !== id) {
+    throw new Error("Paragraph draft translation read did not identify the requested entity.");
+  }
+  return { ...backend.toCanonical(result.data), draftState: result.meta?.draft_state };
+}

package/src/lib/entity-response.js

@@ -75,6 +75,31 @@ export function flagUnrequestedStatusChange(result, existing, sentAttributes) {
   };
 }
 
+/** Why computed `metatag` is dropped on unpublished working-translation bodies. */
+export const METATAG_OMITTED_NOTE =
+  "The computed metatag array is omitted: JSON:API resolves it from the live " +
+  "default revision, not the unpublished working translation. Use the stored " +
+  "field (field_metatags / field_metatag) to verify the draft. See connector #283.";
+
+/**
+ * Drop the computed `metatag` array from a working-translation body.
+ * The stored override field is left intact. No-op when `metatag` is absent.
+ * @param {?object} entity Canonical entity.
+ * @returns {?object}
+ */
+export function omitLiveComputedMetatag(entity) {
+  if (!entity || typeof entity !== "object") return entity;
+  const fields = entity.fields && typeof entity.fields === "object" ? entity.fields : null;
+  if (!fields || !Object.prototype.hasOwnProperty.call(fields, "metatag")) return entity;
+  const nextFields = { ...fields };
+  delete nextFields.metatag;
+  return {
+    ...entity,
+    fields: nextFields,
+    _metatagOmitted: { reason: METATAG_OMITTED_NOTE },
+  };
+}
+
 /** JSON Schema fragment for the shared `returning` parameter. */
 export const RETURNING_SCHEMA = {
   type: "string",

package/src/lib/patch-preflight.js

@@ -35,6 +35,9 @@ export const PATCH_WORKING_COPY_STALE_CODE = "PATCH_WORKING_COPY_STALE";
 /** Stable error code when the working-copy resource does not match the target. */
 export const PATCH_TARGET_AMBIGUOUS_CODE = "PATCH_TARGET_AMBIGUOUS";
 
+/** Stable error code for Sentinel's save-time stale-default-revision refusal. */
+export const STALE_COPY_CODE = "STALE_COPY";
+
 const WORKING_COPY_PATCH_RE = /has a working copy is not yet supported/i;
 
 /**
@@ -98,6 +101,81 @@ export class WorkingCopyStaleError extends Error {
   }
 }
 
+/**
+ * Sentinel's save-time stale-default check (McpWritePreconditions) is not
+ * exercised by the id-mismatch PATCH probe — that probe fails before
+ * entity validation / presave. A published node with no distinct working
+ * copy and a changed timestamp later than its own revision_timestamp is
+ * the readable fingerprint (`possiblyPatchBlocked`). dryRun and the real
+ * write must refuse the same way; reloading and retrying does not help.
+ * Do not bypass the draft or publish gate. See connector #273.
+ */
+export const STALE_COPY_MESSAGE =
+  "This entity cannot be updated: MCP Sentinel refused a stale default-revision " +
+  "write (the content changed after this copy was loaded). dryRun and the real " +
+  "write share this check. rel:latest-version and rel:working-copy report the " +
+  "same vid, but the default revision's changed timestamp is later than its " +
+  "revision_timestamp (possiblyPatchBlocked). Reloading and retrying the same " +
+  "canonical PATCH will not help. Do not bypass the draft or publish gate. " +
+  "See connector #273 / #201.";
+
+const STALE_COPY_RE = /changed after this copy was loaded/i;
+
+/**
+ * Thrown when a canonical write (or its dryRun) would hit Sentinel's
+ * stale-default-revision check (#273).
+ */
+export class StaleCopyError extends Error {
+  /**
+   * @param {?Error} [cause]
+   */
+  constructor(cause) {
+    super(STALE_COPY_MESSAGE);
+    this.name = "StaleCopyError";
+    this.code = STALE_COPY_CODE;
+    if (cause) this.cause = cause;
+  }
+}
+
+/**
+ * Whether an error is Sentinel's stale-version refusal (or our rewrite).
+ * @param {unknown} err
+ * @returns {boolean}
+ */
+export function isStaleCopyError(err) {
+  if (err instanceof StaleCopyError) return true;
+  return STALE_COPY_RE.test(String(err?.message || ""));
+}
+
+/**
+ * Whether a canonical entity's `changed` is later than its own
+ * `revision_timestamp` — the same fingerprint `drupal_list_revisions`
+ * reports as `possiblyPatchBlocked`.
+ * @param {?object} entity Canonical entity or revision summary.
+ * @returns {boolean}
+ */
+export function changedAheadOfRevision(entity) {
+  if (!entity || typeof entity !== "object") return false;
+  const fields = entity.fields && typeof entity.fields === "object" ? entity.fields : {};
+  const changed = entity.changed;
+  const rev = entity.revisionTimestamp ?? fields.revision_timestamp;
+  if (!changed || !rev) return false;
+  const changedMs = Date.parse(changed);
+  const revMs = Date.parse(rev);
+  if (!Number.isFinite(changedMs) || !Number.isFinite(revMs)) return false;
+  return changedMs > revMs;
+}
+
+/**
+ * Rewrite Sentinel's save-time stale-version refusal into {@link StaleCopyError}.
+ * @param {unknown} err
+ * @returns {unknown}
+ */
+export function rewriteStaleCopyError(err) {
+  if (!isStaleCopyError(err) || err instanceof StaleCopyError) return err;
+  return new StaleCopyError(err instanceof Error ? err : new Error(String(err)));
+}
+
 /**
  * Thrown when `rel:working-copy` resolves to a different UUID than the
  * entity being updated.
@@ -305,6 +383,25 @@ export async function prepareGuardedPatch(backend, {
   const target = shouldPreflightPatch({ existing, attributes })
     ? await resolveWorkingCopyPatchTarget(backend, { entityType, bundle, id, existing })
     : { resourceVersion: undefined, workingCopy: null, liveVid: null, workingVid: null };
+  if (shouldPreflightPatch({ existing, attributes }) && !target.resourceVersion) {
+    // Canonical path (no distinct working copy). The id-mismatch probe never
+    // reaches Sentinel's save-time stale-default check; refuse here when the
+    // possiblyPatchBlocked fingerprint is already readable (#273).
+    let fingerprint = existing;
+    const fields = fingerprint?.fields && typeof fingerprint.fields === "object" ? fingerprint.fields : {};
+    const hasTimestamps = Boolean(
+      fingerprint?.changed && (fingerprint.revisionTimestamp || fields.revision_timestamp),
+    );
+    if (!hasTimestamps && typeof backend?.getEntity === "function") {
+      const latest = await backend.getEntity({
+        entityType, bundle, id, resourceVersion: "rel:latest-version",
+      }).catch(() => null);
+      if (latest) fingerprint = latest;
+    }
+    if (changedAheadOfRevision(fingerprint)) {
+      throw new StaleCopyError();
+    }
+  }
   if (langcode) {
     if (!target.workingVid || !target.liveVid || String(target.workingVid) === String(target.liveVid)) {
       throw new Error(
@@ -313,23 +410,35 @@ export async function prepareGuardedPatch(backend, {
       );
     }
     target.draftRevision = { liveVid: target.liveVid, workingVid: target.workingVid };
-    await writeDraft(backend, {
-      entityType, bundle, id, attributes, relationships, langcode,
-      draftRevision: target.draftRevision,
-    }, true);
+    try {
+      await writeDraft(backend, {
+        entityType, bundle, id, attributes, relationships, langcode,
+        draftRevision: target.draftRevision,
+      }, true);
+    } catch (err) {
+      throw rewriteStaleCopyError(err);
+    }
     return target;
   }
   if (target.resourceVersion) {
     target.draftRevision = { liveVid: target.liveVid, workingVid: target.workingVid };
-    await writeDraft(backend, {
-      entityType, bundle, id, attributes, relationships, draftRevision: target.draftRevision,
-    }, true);
+    try {
+      await writeDraft(backend, {
+        entityType, bundle, id, attributes, relationships, draftRevision: target.draftRevision,
+      }, true);
+    } catch (err) {
+      throw rewriteStaleCopyError(err);
+    }
     return target;
   }
-  await preflightPatchWritable({
-    backend, entityType, bundle, id, existing, attributes,
-    resourceVersion: target.resourceVersion,
-  });
+  try {
+    await preflightPatchWritable({
+      backend, entityType, bundle, id, existing, attributes,
+      resourceVersion: target.resourceVersion,
+    });
+  } catch (err) {
+    throw rewriteStaleCopyError(err);
+  }
   return target;
 }
 
@@ -350,6 +459,8 @@ export async function updateEntityGuarded(backend, input) {
     }
     return await backend.updateEntity(input);
   } catch (err) {
+    const stale = rewriteStaleCopyError(err);
+    if (stale !== err) throw stale;
     if (!isWorkingCopyPatchError(err)) throw err;
     const cause = err instanceof Error ? err : new Error(String(err));
     if (input?.resourceVersion === "rel:working-copy") {

package/src/lib/path-alias.js

@@ -0,0 +1,37 @@
+/**
+ * URL-alias helpers shared by node writes and the JSON:API path reader.
+ *
+ * Path aliases are not revisioned. The node's `path` field is a computed
+ * view of `path_alias` rows; unpublished / forward revisions often omit
+ * `pid` even when a row exists. Round-tripping that pid (and verifying
+ * after save) is how title-only edits keep the existing alias (#274).
+ */
+
+/** JSON:API entity type + bundle for a path alias row. */
+export const PATH_ALIAS_ENTITY_TYPE = "path_alias";
+
+/**
+ * Normalize a URL-alias path for storage/comparison: trim, ensure a single
+ * leading slash, drop a trailing slash (except root).
+ * @param {*} value A raw alias.
+ * @returns {?string} The normalized alias, or null when empty.
+ */
+export function normalizeAlias(value) {
+  if (value === undefined || value === null) return null;
+  let s = String(value).trim();
+  if (!s) return null;
+  if (!s.startsWith("/")) s = `/${s}`;
+  if (s.length > 1) s = s.replace(/\/+$/, "");
+  return s;
+}
+
+/**
+ * Whether a value is a positive integer node id suitable for `/node/{nid}`.
+ * @param {*} value Raw drupal internal id.
+ * @returns {boolean}
+ */
+export function isPositiveNid(value) {
+  if (value === undefined || value === null || value === "") return false;
+  const n = Number(value);
+  return Number.isInteger(n) && n > 0;
+}

package/src/tools/entities.js

@@ -294,7 +294,7 @@ export const definitions = [
         langcode:      { type: "string", description: "Target language for an unpublished working translation (nodes). Continues that translation via Sentinel." },
         attributes:    { type: "object" },
         relationships: { type: "object" },
-        dryRun:        { type: "boolean", default: false, description: "Validate, resolve ERR identifiers, and (on moderated targets) run the core PATCH-guard probe against Drupal, then return a preview without the real write. An existing node draft uses Sentinel's non-saving draft endpoint with the real payload and revision preconditions. Otherwise an id-mismatch core PATCH probes writability without saving. Any refusal fails the dryRun." },
+        dryRun:        { type: "boolean", default: false, description: "Validate, resolve ERR identifiers, and (on moderated targets) run the core PATCH-guard probe against Drupal, then return a preview without the real write. An existing node draft uses Sentinel's non-saving draft endpoint with the real payload and revision preconditions. Otherwise an id-mismatch core PATCH probes writability without saving. A published node with no distinct working copy whose changed timestamp is later than revision_timestamp (possiblyPatchBlocked) fails dryRun the same as the real write (#273). Any refusal fails the dryRun." },
         returning:     RETURNING_SCHEMA,
       },
     },