@dench.com/cli 3.5.8-staging.350 → 3.6.0

package/lib/campaign-steps.ts

@@ -0,0 +1,721 @@
+export const MAX_CAMPAIGN_STEPS = 20;
+export const MAX_WAIT_HOURS = 2160;
+export const DEFAULT_CONNECTION_WAIT_HOURS = 720;
+export const MAX_LINKEDIN_MESSAGE_CHARS = 3000;
+export const MAX_CONNECTION_NOTE_CHARS = 300;
+export const MAX_INMAIL_SUBJECT_CHARS = 200;
+export const MAX_INMAIL_BODY_CHARS = 1900;
+export const MAX_LIKE_POST_AGE_DAYS = 365;
+export const MIN_WITHDRAW_AFTER_HOURS = 7 * 24;
+export const LINKEDIN_REACTIONS = [
+  "like",
+  "celebrate",
+  "support",
+  "love",
+  "insightful",
+  "funny",
+] as const;
+
+export const STEP_TYPES = [
+  "wait",
+  "email",
+  "linkedin_connection",
+  "linkedin_message",
+  "linkedin_visit",
+  "linkedin_like_post",
+  "linkedin_inmail",
+] as const;
+
+export type StepType = (typeof STEP_TYPES)[number];
+
+export const STEP_KEYS = [
+  "type",
+  "waitHours",
+  "emailMailboxAccountId",
+  "emailSubject",
+  "emailHtmlBody",
+  "emailTextBody",
+  "emailReplyToPrevious",
+  "onlyIf",
+  "linkedinAccountId",
+  "linkedinMessageBody",
+  "linkedinMessageMode",
+  "connectionTimeoutHours",
+  "likeReaction",
+  "likeMaxPostAgeDays",
+  "likeSkipNextWait",
+  "inmailSubject",
+  "withdrawAfterHours",
+] as const;
+
+const FIELDS_BY_TYPE: Record<StepType, readonly string[]> = {
+  wait: ["waitHours"],
+  email: [
+    "emailMailboxAccountId",
+    "emailSubject",
+    "emailHtmlBody",
+    "emailTextBody",
+    "emailReplyToPrevious",
+    "onlyIf",
+  ],
+  linkedin_visit: ["linkedinAccountId"],
+  linkedin_connection: [
+    "linkedinAccountId",
+    "linkedinMessageBody",
+    "withdrawAfterHours",
+  ],
+  linkedin_message: [
+    "linkedinAccountId",
+    "linkedinMessageBody",
+    "linkedinMessageMode",
+    "connectionTimeoutHours",
+  ],
+  linkedin_like_post: [
+    "linkedinAccountId",
+    "onlyIf",
+    "likeReaction",
+    "likeMaxPostAgeDays",
+    "likeSkipNextWait",
+  ],
+  linkedin_inmail: [
+    "linkedinAccountId",
+    "linkedinMessageBody",
+    "inmailSubject",
+  ],
+};
+
+const TEXT_FIELDS = [
+  "emailMailboxAccountId",
+  "emailSubject",
+  "emailHtmlBody",
+  "emailTextBody",
+  "linkedinAccountId",
+  "linkedinMessageBody",
+  "inmailSubject",
+] as const;
+
+const TEMPLATE_FIELDS = [
+  "emailSubject",
+  "emailHtmlBody",
+  "emailTextBody",
+  "linkedinMessageBody",
+  "inmailSubject",
+] as const;
+
+const ONLY_IF = ["always", "connected", "not_connected"];
+const MESSAGE_MODES = ["skip_if_not_connected", "wait_until_connected"];
+
+export type StepCheckOptions = {
+  allowSingleBraces?: boolean;
+  singleBraceOverride?: string;
+};
+
+export type StepIssue = { step: number; field?: string; message: string };
+
+export type StepCheck = { errors: StepIssue[]; warnings: string[] };
+
+function holdsNothing(field: string, value: unknown): boolean {
+  if (value === undefined) return true;
+  if (field === "emailReplyToPrevious") return value === false;
+  if (field === "onlyIf") return value === "always";
+  if (field === "withdrawAfterHours") return value === null;
+  if (typeof value === "string") return !value.trim();
+  return false;
+}
+
+export function singleBraceTokens(text: string): string[] {
+  const outside = text.replace(/\{\{[^{}]*\}\}/g, " ");
+  return [
+    ...new Set(
+      [...outside.matchAll(/\{\s*([A-Za-z_][A-Za-z0-9_ .-]{0,60}?)\s*\}/g)].map(
+        (match) => match[0],
+      ),
+    ),
+  ];
+}
+
+function trimmedText(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+export function hasHtmlAndTextBody(step: unknown): boolean {
+  if (!step || typeof step !== "object") return false;
+  const row = step as Record<string, unknown>;
+  return (
+    row.type === "email" &&
+    trimmedText(row.emailHtmlBody) !== "" &&
+    trimmedText(row.emailTextBody) !== ""
+  );
+}
+
+export function staleHtmlSteps(
+  next: readonly unknown[],
+  stored: readonly unknown[],
+): number[] {
+  const storedEmails = stored.filter(hasHtmlAndTextBody) as Array<
+    Record<string, unknown>
+  >;
+  return next.flatMap((step, index) => {
+    if (!hasHtmlAndTextBody(step)) return [];
+    const row = step as Record<string, unknown>;
+    const html = trimmedText(row.emailHtmlBody);
+    const text = trimmedText(row.emailTextBody);
+    const sameHtml = storedEmails.filter(
+      (candidate) => trimmedText(candidate.emailHtmlBody) === html,
+    );
+    return sameHtml.length > 0 &&
+      sameHtml.every(
+        (candidate) => trimmedText(candidate.emailTextBody) !== text,
+      )
+      ? [index]
+      : [];
+  });
+}
+
+export function staleHtmlWarning(index: number): string {
+  return `Step ${index + 1}: "emailTextBody" was edited but "emailHtmlBody" is still the copy from before, and the HTML is what gets sent, so the old HTML was dropped and the email goes out as the new text.`;
+}
+
+function hasEmptyMergeToken(text: string): boolean {
+  return /\{\{\s*\}\}/.test(text);
+}
+
+function listSteps(numbers: number[]): string {
+  if (numbers.length <= 1) return `Step ${numbers[0]}`;
+  return `Steps ${numbers.slice(0, -1).join(", ")} and ${numbers.at(-1)}`;
+}
+
+type Fail = (message: string, field?: string) => void;
+
+function checkStepFieldShapes(
+  row: Record<string, unknown>,
+  stepType: StepType,
+  label: string,
+  fail: Fail,
+): void {
+  for (const field of TEXT_FIELDS)
+    if (row[field] !== undefined && typeof row[field] !== "string")
+      fail(`${label}: "${field}" must be text.`, field);
+  if (
+    row.emailReplyToPrevious !== undefined &&
+    typeof row.emailReplyToPrevious !== "boolean"
+  )
+    fail(`${label}: "emailReplyToPrevious" must be true or false.`);
+  if (
+    row.onlyIf !== undefined &&
+    (typeof row.onlyIf !== "string" || !ONLY_IF.includes(row.onlyIf))
+  )
+    fail(
+      `${label}: "onlyIf" must be always, connected or not_connected.`,
+      "onlyIf",
+    );
+  if (
+    row.linkedinMessageMode !== undefined &&
+    (typeof row.linkedinMessageMode !== "string" ||
+      !MESSAGE_MODES.includes(row.linkedinMessageMode))
+  )
+    fail(
+      `${label}: "linkedinMessageMode" must be skip_if_not_connected or wait_until_connected.`,
+      "linkedinMessageMode",
+    );
+  if (row.waitHours !== undefined && typeof row.waitHours !== "number")
+    fail(`${label}: "waitHours" must be a number of hours.`, "waitHours");
+  if (
+    row.likeReaction !== undefined &&
+    (typeof row.likeReaction !== "string" ||
+      !(LINKEDIN_REACTIONS as readonly string[]).includes(row.likeReaction))
+  )
+    fail(
+      `${label}: "likeReaction" must be one of: ${LINKEDIN_REACTIONS.join(", ")}.`,
+      "likeReaction",
+    );
+  if (
+    row.likeMaxPostAgeDays !== undefined &&
+    (typeof row.likeMaxPostAgeDays !== "number" ||
+      !Number.isInteger(row.likeMaxPostAgeDays) ||
+      row.likeMaxPostAgeDays < 1 ||
+      row.likeMaxPostAgeDays > MAX_LIKE_POST_AGE_DAYS)
+  )
+    fail(
+      `${label}: "likeMaxPostAgeDays" must be a whole number from 1 to ${MAX_LIKE_POST_AGE_DAYS}.`,
+      "likeMaxPostAgeDays",
+    );
+  if (
+    row.likeSkipNextWait !== undefined &&
+    typeof row.likeSkipNextWait !== "boolean"
+  )
+    fail(
+      `${label}: "likeSkipNextWait" must be true or false.`,
+      "likeSkipNextWait",
+    );
+  if (
+    row.withdrawAfterHours !== undefined &&
+    row.withdrawAfterHours !== null &&
+    (typeof row.withdrawAfterHours !== "number" ||
+      !Number.isFinite(row.withdrawAfterHours) ||
+      row.withdrawAfterHours < MIN_WITHDRAW_AFTER_HOURS ||
+      row.withdrawAfterHours > MAX_WAIT_HOURS)
+  )
+    fail(
+      `${label}: "withdrawAfterHours" must be ${MIN_WITHDRAW_AFTER_HOURS}-${MAX_WAIT_HOURS} hours (7-90 days), or null to turn withdrawal off.`,
+      "withdrawAfterHours",
+    );
+
+  const kind = stepType === "email" ? "an email" : `a ${stepType}`;
+  const allowed = FIELDS_BY_TYPE[stepType];
+  const dropped = (STEP_KEYS as readonly string[]).filter(
+    (key) =>
+      key !== "type" && !allowed.includes(key) && !holdsNothing(key, row[key]),
+  );
+  for (const field of dropped) {
+    if (field === "onlyIf")
+      fail(
+        `${label}: "onlyIf" only works on email or linkedin_like_post steps; ${kind} step would drop it. InMail already skips connected people.`,
+        field,
+      );
+    else if (field === "linkedinMessageBody" && stepType === "linkedin_visit")
+      fail(
+        `${label}: ${kind} step sends no text, so "linkedinMessageBody" would be dropped. Use linkedin_connection for an invite note or linkedin_message for a message.`,
+        field,
+      );
+    else
+      fail(
+        `${label}: "${field}" does not apply to ${kind} step and would be dropped.`,
+        field,
+      );
+  }
+}
+
+function checkTemplateTokens(
+  row: Record<string, unknown>,
+  label: string,
+  fail: Fail,
+  options: StepCheckOptions,
+): void {
+  const override = options.singleBraceOverride ?? '"allowSingleBraces": true';
+  for (const field of TEMPLATE_FIELDS) {
+    const text = row[field];
+    if (typeof text !== "string") continue;
+    if (hasEmptyMergeToken(text))
+      fail(`${label}: "${field}" has an empty {{ }} merge token.`, field);
+    if (options.allowSingleBraces) continue;
+    const tokens = singleBraceTokens(text);
+    if (tokens.length)
+      fail(
+        `${label}: "${field}" has ${tokens.join(", ")}. Single braces are sent exactly as typed; merge tokens use double braces: ${tokens
+          .map((token) => `{${token}}`)
+          .join(", ")}. If the braces are meant literally, pass ${override}.`,
+        field,
+      );
+  }
+}
+
+function checkWaitHours(hours: unknown, label: string, fail: Fail): void {
+  if (typeof hours !== "number" || !(hours > 0))
+    fail(`${label} is a wait step and needs "waitHours" above 0.`, "waitHours");
+  else if (!Number.isFinite(hours) || hours > MAX_WAIT_HOURS)
+    fail(
+      `${label}: "waitHours" must be at most ${MAX_WAIT_HOURS} (90 days).`,
+      "waitHours",
+    );
+}
+
+function checkConnectionNote(note: string, label: string, fail: Fail): void {
+  if (note.length > MAX_CONNECTION_NOTE_CHARS)
+    fail(
+      `${label}: the connection note is ${note.length} characters; LinkedIn allows ${MAX_CONNECTION_NOTE_CHARS}.`,
+      "linkedinMessageBody",
+    );
+}
+
+function checkMessageBody(
+  body: string,
+  label: string,
+  fail: Fail,
+  type: "linkedin_message" | "linkedin_inmail" = "linkedin_message",
+): void {
+  const limit =
+    type === "linkedin_inmail"
+      ? MAX_INMAIL_BODY_CHARS
+      : MAX_LINKEDIN_MESSAGE_CHARS;
+  const name =
+    type === "linkedin_inmail" ? "InMail messages" : "LinkedIn messages";
+  if (!body)
+    fail(
+      `${label} is a ${type} step and needs "linkedinMessageBody".`,
+      "linkedinMessageBody",
+    );
+  else if (body.length > limit)
+    fail(
+      `${label}: "linkedinMessageBody" is ${body.length} characters; ${name} are limited to ${limit}.`,
+      "linkedinMessageBody",
+    );
+}
+
+function checkInmailSubject(subject: string, label: string, fail: Fail): void {
+  if (subject.length > MAX_INMAIL_SUBJECT_CHARS)
+    fail(
+      `${label}: "inmailSubject" is ${subject.length} characters; InMail subjects are limited to ${MAX_INMAIL_SUBJECT_CHARS}.`,
+      "inmailSubject",
+    );
+}
+
+function checkTimeoutRange(timeout: unknown, label: string, fail: Fail): void {
+  if (
+    typeof timeout !== "number" ||
+    !Number.isFinite(timeout) ||
+    timeout < 1 ||
+    timeout > MAX_WAIT_HOURS
+  )
+    fail(
+      `${label}: "connectionTimeoutHours" must be 1-${MAX_WAIT_HOURS} hours.`,
+      "connectionTimeoutHours",
+    );
+}
+
+function stepRow(
+  value: unknown,
+  label: string,
+  fail: Fail,
+): { row: Record<string, unknown>; stepType: StepType } | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    fail(`${label} must be an object with a "type".`);
+    return null;
+  }
+  const row = value as Record<string, unknown>;
+  const type = row.type;
+  if (
+    typeof type !== "string" ||
+    !(STEP_TYPES as readonly string[]).includes(type)
+  ) {
+    fail(
+      `${label} has type ${JSON.stringify(type)}. Use one of: ${STEP_TYPES.join(", ")}.`,
+      "type",
+    );
+    return null;
+  }
+  return { row, stepType: type as StepType };
+}
+
+export function checkCampaignSteps(
+  steps: readonly unknown[],
+  options: StepCheckOptions = {},
+): StepCheck {
+  const errors: StepIssue[] = [];
+  const warnings: string[] = [];
+  if (steps.length > MAX_CAMPAIGN_STEPS)
+    errors.push({
+      step: 0,
+      message: `A campaign can have at most ${MAX_CAMPAIGN_STEPS} steps (got ${steps.length}).`,
+    });
+  let emailSeen = false;
+  let connectSeen = false;
+  const waitingMessages: number[] = [];
+  steps.forEach((value, index) => {
+    const step = index + 1;
+    const label = `Step ${step}`;
+    const fail: Fail = (message, field) =>
+      errors.push({ step, ...(field ? { field } : {}), message });
+    const parsed = stepRow(value, label, fail);
+    if (!parsed) return;
+    const { row, stepType } = parsed;
+    const unknown = Object.keys(row).filter(
+      (key) => !(STEP_KEYS as readonly string[]).includes(key),
+    );
+    if (unknown.length)
+      fail(
+        `${label} has keys the engine does not know: ${unknown.join(", ")}. Allowed: ${STEP_KEYS.join(", ")}.`,
+      );
+    checkStepFieldShapes(row, stepType, label, fail);
+
+    if (stepType === "wait") checkWaitHours(row.waitHours, label, fail);
+
+    if (stepType === "email") {
+      const reply = row.emailReplyToPrevious === true;
+      if (reply && !emailSeen)
+        fail(
+          `${label}: "emailReplyToPrevious" needs an earlier email step to reply to, so the first email would lose it. Give this email its own "emailSubject".`,
+          "emailReplyToPrevious",
+        );
+      const subject = trimmedText(row.emailSubject);
+      if (!subject && !reply)
+        fail(
+          `${label} is an email step and needs "emailSubject"${emailSeen ? ' (or "emailReplyToPrevious": true to reply in the same thread)' : ""}.`,
+          "emailSubject",
+        );
+      if (!trimmedText(row.emailHtmlBody) && !trimmedText(row.emailTextBody))
+        fail(
+          `${label} is an email step and needs "emailTextBody" or "emailHtmlBody".`,
+          "emailTextBody",
+        );
+      emailSeen = true;
+    }
+
+    if (stepType === "linkedin_connection") {
+      checkConnectionNote(trimmedText(row.linkedinMessageBody), label, fail);
+      connectSeen = true;
+    }
+
+    if (stepType === "linkedin_inmail") {
+      checkMessageBody(
+        trimmedText(row.linkedinMessageBody),
+        label,
+        fail,
+        stepType,
+      );
+      checkInmailSubject(trimmedText(row.inmailSubject), label, fail);
+    }
+
+    if (stepType === "linkedin_message") {
+      checkMessageBody(trimmedText(row.linkedinMessageBody), label, fail);
+      const mode =
+        row.linkedinMessageMode ??
+        (connectSeen ? "wait_until_connected" : "skip_if_not_connected");
+      const timeout = row.connectionTimeoutHours;
+      if (timeout !== undefined) {
+        if (mode !== "wait_until_connected")
+          fail(
+            `${label}: "connectionTimeoutHours" only applies with "linkedinMessageMode": "wait_until_connected"${connectSeen ? "" : " (the default only after a linkedin_connection step)"}, so it would be dropped.`,
+            "connectionTimeoutHours",
+          );
+        else checkTimeoutRange(timeout, label, fail);
+      }
+      if (
+        connectSeen &&
+        mode === "wait_until_connected" &&
+        (timeout ?? DEFAULT_CONNECTION_WAIT_HOURS) ===
+          DEFAULT_CONNECTION_WAIT_HOURS
+      )
+        waitingMessages.push(step);
+    }
+
+    checkTemplateTokens(row, label, fail, options);
+  });
+  if (waitingMessages.length >= 2)
+    warnings.push(
+      `${listSteps(waitingMessages)} are LinkedIn messages after the connection request. Each waits up to ${DEFAULT_CONNECTION_WAIT_HOURS / 24} days for the accept by default, so someone who never accepts holds the sequence for up to ${(waitingMessages.length * DEFAULT_CONNECTION_WAIT_HOURS) / 24} days. Give the later ones "linkedinMessageMode": "skip_if_not_connected" or a shorter "connectionTimeoutHours".`,
+    );
+  return { errors, warnings };
+}
+
+export function stepToInput(
+  step: Record<string, unknown>,
+): Record<string, unknown> {
+  const input: Record<string, unknown> = {};
+  for (const key of STEP_KEYS) {
+    if (
+      step[key] !== undefined &&
+      (step[key] !== null || key === "withdrawAfterHours")
+    )
+      input[key] = step[key];
+  }
+  return input;
+}
+
+export function checkStepEdits(
+  edits: readonly unknown[],
+  options: StepCheckOptions = {},
+): StepCheck {
+  const errors: StepIssue[] = [];
+  edits.forEach((value, index) => {
+    const step = index + 1;
+    const label = `Edit ${step}`;
+    const fail: Fail = (message, field) =>
+      errors.push({ step, ...(field ? { field } : {}), message });
+    const parsed = stepRow(value, label, fail);
+    if (!parsed) return;
+    const { row, stepType } = parsed;
+    checkStepFieldShapes(row, stepType, label, fail);
+    if (stepType === "wait" && row.waitHours !== undefined)
+      checkWaitHours(row.waitHours, label, fail);
+    if (stepType === "linkedin_connection")
+      checkConnectionNote(trimmedText(row.linkedinMessageBody), label, fail);
+    if (stepType === "linkedin_inmail") {
+      if (row.linkedinMessageBody !== undefined)
+        checkMessageBody(
+          trimmedText(row.linkedinMessageBody),
+          label,
+          fail,
+          stepType,
+        );
+      checkInmailSubject(trimmedText(row.inmailSubject), label, fail);
+    }
+    if (stepType === "linkedin_message") {
+      if (row.linkedinMessageBody !== undefined)
+        checkMessageBody(trimmedText(row.linkedinMessageBody), label, fail);
+      if (row.connectionTimeoutHours !== undefined) {
+        checkTimeoutRange(row.connectionTimeoutHours, label, fail);
+        if (row.linkedinMessageMode === "skip_if_not_connected")
+          fail(
+            `${label}: "connectionTimeoutHours" only applies with "linkedinMessageMode": "wait_until_connected".`,
+            "connectionTimeoutHours",
+          );
+      }
+    }
+    checkTemplateTokens(row, label, fail, options);
+  });
+  return { errors, warnings: [] };
+}
+
+const KEEP_WHEN_OMITTED = [
+  "emailMailboxAccountId",
+  "linkedinAccountId",
+  "linkedinMessageMode",
+  "connectionTimeoutHours",
+  "likeReaction",
+  "likeMaxPostAgeDays",
+  "likeSkipNextWait",
+  "withdrawAfterHours",
+] as const;
+
+const CLEARED_VALUES: Record<string, unknown> = {
+  emailSubject: "",
+  emailHtmlBody: "",
+  emailTextBody: "",
+  linkedinMessageBody: "",
+  emailReplyToPrevious: false,
+  onlyIf: "always",
+  inmailSubject: "",
+  withdrawAfterHours: null,
+};
+
+const TYPE_NAMES: Record<StepType, string> = {
+  wait: "a wait",
+  email: "an email",
+  linkedin_visit: "a profile visit",
+  linkedin_connection: "a connection request",
+  linkedin_message: "a LinkedIn message",
+  linkedin_like_post: "a post reaction",
+  linkedin_inmail: "an InMail",
+};
+
+export class StepEditError extends Error {}
+
+export type StoredStep = Record<string, unknown> & { type: string };
+
+export type StepChange = { step: number; type: string; fields: string[] };
+
+export type StepEditPlan = {
+  steps: Record<string, unknown>[];
+  updates: Record<string, unknown>[];
+  changes: StepChange[];
+  warnings: string[];
+};
+
+export type StepEditOptions = StepCheckOptions & {
+  campaign?: string;
+  draft?: boolean;
+};
+
+export function planStepEdits(
+  storedSteps: readonly StoredStep[],
+  entries: readonly unknown[],
+  options: StepEditOptions = {},
+): StepEditPlan {
+  const campaign = options.campaign ?? "<campaign>";
+  const stored = [...storedSteps].sort(
+    (a, b) => Number(a.order ?? 0) - Number(b.order ?? 0),
+  );
+  if (!entries.length) throw new StepEditError("The file has no steps.");
+  const rows = entries.map((entry, index) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+      throw new StepEditError(
+        `Step ${index + 1} in the file must be an object with a "type".`,
+      );
+    return entry as Record<string, unknown>;
+  });
+  const withIds = rows.filter((row) => row.stepId !== undefined).length;
+  if (withIds > 0 && withIds < rows.length)
+    throw new StepEditError(
+      `Give every step its "stepId" (from dench campaign steps get ${campaign} --with-ids), or leave "stepId" out of all of them to match the steps by order.`,
+    );
+  const byId = withIds > 0;
+  if (!byId && rows.length !== stored.length)
+    throw new StepEditError(
+      `The file has ${rows.length} ${rows.length === 1 ? "step" : "steps"} and the campaign has ${stored.length}. steps edit changes steps in place, matched by order, so it needs all ${stored.length}; to edit only some, include "stepId" from dench campaign steps get ${campaign} --with-ids.`,
+    );
+  const restructure = options.draft
+    ? `To add, remove, reorder or retype steps on a draft, use dench campaign steps set ${campaign} --file steps.json.`
+    : `After launch a step keeps its type and place; to change the sequence, copy it with dench campaign duplicate ${campaign} and set the copy's steps.`;
+  const edits = new Map<number, Record<string, unknown>>();
+  rows.forEach((row, position) => {
+    let index = position;
+    if (byId) {
+      index = stored.findIndex(
+        (step) => String(step._id) === String(row.stepId),
+      );
+      if (index < 0)
+        throw new StepEditError(
+          `Step id ${String(row.stepId)} is not in this campaign. Run dench campaign steps get ${campaign} --with-ids for the current ids.`,
+        );
+      if (edits.has(index))
+        throw new StepEditError(
+          `Step ${index + 1} (id ${String(row.stepId)}) is in the file twice.`,
+        );
+    }
+    const current = stored[index];
+    if (row.type !== current.type)
+      throw new StepEditError(
+        `Step ${index + 1} is ${TYPE_NAMES[current.type as StepType] ?? current.type} step, and the file makes it ${JSON.stringify(row.type)}. ${restructure}`,
+      );
+    if (row.updatedAt !== undefined && row.updatedAt !== current.updatedAt)
+      throw new StepEditError(
+        `Step ${index + 1} was saved again after you read it. Run dench campaign steps get ${campaign} --with-ids again and redo the edit, so the newer change is not overwritten.`,
+      );
+    const { stepId: _stepId, updatedAt: _updatedAt, ...fields } = row;
+    edits.set(index, fields);
+  });
+
+  const warnings: string[] = [];
+  const steps = stored.map((step, index) => {
+    const before = stepToInput(step);
+    const fields = edits.get(index);
+    if (!fields) return before;
+    const after: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(fields))
+      if (value !== undefined) after[key] = value;
+    for (const key of KEEP_WHEN_OMITTED)
+      if (after[key] === undefined && before[key] !== undefined)
+        after[key] = before[key];
+    if (
+      hasHtmlAndTextBody(before) &&
+      trimmedText(after.emailTextBody) !== "" &&
+      trimmedText(after.emailHtmlBody) === trimmedText(before.emailHtmlBody) &&
+      trimmedText(after.emailTextBody) !== trimmedText(before.emailTextBody)
+    ) {
+      delete after.emailHtmlBody;
+      warnings.push(staleHtmlWarning(index));
+    }
+    return after;
+  });
+
+  const check = checkCampaignSteps(steps, options);
+  if (check.errors.length)
+    throw new StepEditError(
+      check.errors.map((issue) => issue.message).join("\n"),
+    );
+  warnings.push(...check.warnings);
+
+  const updates: Record<string, unknown>[] = [];
+  const changes: StepChange[] = [];
+  steps.forEach((after, index) => {
+    const step = stored[index];
+    const before = stepToInput(step);
+    const fields = [...new Set([...Object.keys(before), ...Object.keys(after)])]
+      .filter((key) => key !== "type" && before[key] !== after[key])
+      .filter(
+        (key) => after[key] !== undefined || CLEARED_VALUES[key] !== undefined,
+      );
+    if (!fields.length) return;
+    updates.push({
+      stepId: String(step._id),
+      expectedUpdatedAt: step.updatedAt,
+      type: step.type,
+      ...Object.fromEntries(
+        fields.map((key) => [key, after[key] ?? CLEARED_VALUES[key]]),
+      ),
+    });
+    changes.push({ step: index + 1, type: step.type, fields });
+  });
+  return { steps, updates, changes, warnings };
+}