@multiplatform.one/backoffice 6.4.3 → 6.6.0

package/src/quickEntry/quickEntryPlan.spec.ts

@@ -0,0 +1,367 @@
+/**
+ * quickEntryPlan — desk-parity quick-entry planning, defaults seeding,
+ * schema building, and server response/error parsing. Fixtures follow the
+ * bench-probed shapes in p-results/backoffice/integration-notes.md:
+ * stock ToDo (description reqd-only, date quick-entry-flagged) motivates
+ * the reqd|bold|allow_in_quick_entry union; create_doc responses arrive in
+ * a {message: {...}} envelope; MandatoryError exceptions look like
+ * "frappe.exceptions.MandatoryError: [ToDo, xxx]: field_a, field_b".
+ */
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { DocFieldMeta, DoctypeMeta } from "../shared/useDoctypeMeta";
+import {
+  PROMPT_NAME_FIELD,
+  buildQuickEntryDefaults,
+  buildQuickEntrySchema,
+  isEmptyFieldValue,
+  parseServerError,
+  planQuickEntry,
+  resolveCreatedName,
+} from "./quickEntryPlan";
+
+function field(partial: Partial<DocFieldMeta> & { fieldname: string }): DocFieldMeta {
+  return { fieldtype: "Data", ...partial } as DocFieldMeta;
+}
+
+function makeMeta(partial: Partial<DoctypeMeta>): DoctypeMeta {
+  return { name: "ToDo", fields: [], ...partial } as DoctypeMeta;
+}
+
+describe("planQuickEntry", () => {
+  it("defers to the full form when quick entry is disabled on the meta", () => {
+    expect(planQuickEntry(makeMeta({ quick_entry: 0 }))).toEqual({
+      kind: "full-form",
+      reason: "quick-entry-disabled",
+    });
+    expect(planQuickEntry(makeMeta({}))).toEqual({
+      kind: "full-form",
+      reason: "quick-entry-disabled",
+    });
+  });
+
+  it("selects the union of reqd | bold | allow_in_quick_entry fields (stock ToDo case)", () => {
+    const meta = makeMeta({
+      quick_entry: 1,
+      fields: [
+        field({ fieldname: "description", fieldtype: "Text Editor", reqd: 1 }),
+        field({ fieldname: "date", fieldtype: "Date", allow_in_quick_entry: 1 }),
+        field({ fieldname: "priority", fieldtype: "Select", bold: 1 }),
+        field({ fieldname: "status", fieldtype: "Select" }),
+      ],
+    });
+    const plan = planQuickEntry(meta);
+    expect(plan.kind).toBe("fields");
+    if (plan.kind !== "fields") return;
+    // reqd-only description MUST be included or server-side validation
+    // would always fail (the union regression the notes call out).
+    expect(plan.fields.map((f) => f.fieldname)).toEqual(["description", "date", "priority"]);
+    expect(plan.promptName).toBe(false);
+  });
+
+  it("excludes hidden, read-only, virtual, and layout fields even when flagged", () => {
+    const meta = makeMeta({
+      quick_entry: 1,
+      fields: [
+        field({ fieldname: "keep", reqd: 1 }),
+        field({ fieldname: "secret", reqd: 1, hidden: 1 }),
+        field({ fieldname: "frozen", bold: 1, read_only: 1 }),
+        field({ fieldname: "computed", reqd: 1, is_virtual: 1 } as Partial<DocFieldMeta> & {
+          fieldname: string;
+        }),
+        field({ fieldname: "sec", fieldtype: "Section Break", allow_in_quick_entry: 1 }),
+        field({ fieldname: "col", fieldtype: "Column Break", reqd: 1 }),
+        field({ fieldname: "tab", fieldtype: "Tab Break", bold: 1 }),
+        field({ fieldname: "fold", fieldtype: "Fold", reqd: 1 }),
+      ],
+    });
+    const plan = planQuickEntry(meta);
+    expect(plan.kind).toBe("fields");
+    if (plan.kind !== "fields") return;
+    expect(plan.fields.map((f) => f.fieldname)).toEqual(["keep"]);
+  });
+
+  it("defers to the full form when no usable field remains", () => {
+    const meta = makeMeta({
+      quick_entry: 1,
+      fields: [
+        field({ fieldname: "plain" }),
+        field({ fieldname: "hidden_reqd", reqd: 1, hidden: 1 }),
+      ],
+    });
+    expect(planQuickEntry(meta)).toEqual({ kind: "full-form", reason: "no-fields" });
+  });
+
+  it("defers to the full form when a selected field is a child Table", () => {
+    const meta = makeMeta({
+      quick_entry: 1,
+      fields: [
+        field({ fieldname: "title", reqd: 1 }),
+        field({ fieldname: "items", fieldtype: "Table", reqd: 1, options: "Item Row" }),
+      ],
+    });
+    expect(planQuickEntry(meta)).toEqual({ kind: "full-form", reason: "child-table" });
+  });
+
+  it("flags prompt-autonamed doctypes (case-insensitive)", () => {
+    const fields = [field({ fieldname: "title", reqd: 1 })];
+    const prompt = planQuickEntry(makeMeta({ quick_entry: 1, autoname: "Prompt", fields }));
+    expect(prompt.kind === "fields" && prompt.promptName).toBe(true);
+    const lower = planQuickEntry(makeMeta({ quick_entry: 1, autoname: "prompt", fields }));
+    expect(lower.kind === "fields" && lower.promptName).toBe(true);
+    const hash = planQuickEntry(makeMeta({ quick_entry: 1, autoname: "hash", fields }));
+    expect(hash.kind === "fields" && hash.promptName).toBe(false);
+  });
+
+  it("exposes the synthetic prompt-name fieldname", () => {
+    expect(PROMPT_NAME_FIELD).toBe("__newname");
+  });
+});
+
+describe("buildQuickEntryDefaults", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("resolves Today for Date and Datetime fields", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(2026, 7, 12, 10, 30)); // local 2026-08-12
+    const draft = buildQuickEntryDefaults([
+      field({ fieldname: "date", fieldtype: "Date", default: "Today" }),
+      field({ fieldname: "at", fieldtype: "Datetime", default: "Today" }),
+    ]);
+    expect(draft).toEqual({ date: "2026-08-12", at: "2026-08-12" });
+  });
+
+  it("keeps a literal Today on non-date fields", () => {
+    const draft = buildQuickEntryDefaults([
+      field({ fieldname: "note", fieldtype: "Data", default: "Today" }),
+    ]);
+    expect(draft).toEqual({ note: "Today" });
+  });
+
+  it("coerces numeric fieldtype defaults (incl. Check 0/1)", () => {
+    const draft = buildQuickEntryDefaults([
+      field({ fieldname: "qty", fieldtype: "Int", default: "5" }),
+      field({ fieldname: "rate", fieldtype: "Float", default: "2.5" }),
+      field({ fieldname: "enabled", fieldtype: "Check", default: "1" }),
+      field({ fieldname: "disabled", fieldtype: "Check", default: "0" }),
+      field({ fieldname: "stars", fieldtype: "Rating", default: "0.4" }),
+    ]);
+    expect(draft).toEqual({ qty: 5, rate: 2.5, enabled: 1, disabled: 0, stars: 0.4 });
+  });
+
+  it("coerces unparseable numeric defaults to 0", () => {
+    const draft = buildQuickEntryDefaults([
+      field({ fieldname: "qty", fieldtype: "Int", default: "abc" }),
+    ]);
+    expect(draft).toEqual({ qty: 0 });
+  });
+
+  it("keeps literal string defaults on non-numeric fields", () => {
+    const draft = buildQuickEntryDefaults([
+      field({ fieldname: "status", fieldtype: "Select", default: "Open" }),
+    ]);
+    expect(draft).toEqual({ status: "Open" });
+  });
+
+  it("uses pre-coerced non-string defaults as-is", () => {
+    const draft = buildQuickEntryDefaults([
+      field({ fieldname: "qty", fieldtype: "Int", default: 7 as unknown as string }),
+    ]);
+    expect(draft).toEqual({ qty: 7 });
+  });
+
+  it("skips empty defaults and server-resolved tokens", () => {
+    const draft = buildQuickEntryDefaults([
+      field({ fieldname: "a" }),
+      field({ fieldname: "b", default: "" }),
+      field({ fieldname: "owner", default: "__user" }),
+      field({ fieldname: "linked", default: ":customer" }),
+      field({ fieldname: "company", default: "frappe.defaults.get_user_default('Company')" }),
+    ]);
+    expect(draft).toEqual({});
+  });
+
+  it("merges extra defaults over meta defaults", () => {
+    const draft = buildQuickEntryDefaults(
+      [field({ fieldname: "status", fieldtype: "Select", default: "Open" })],
+      { status: "Closed", priority: "High" },
+    );
+    expect(draft).toEqual({ status: "Closed", priority: "High" });
+  });
+});
+
+describe("buildQuickEntrySchema", () => {
+  it("builds a single-section single-column schema with mapped fields", () => {
+    const schema = buildQuickEntrySchema([
+      field({
+        fieldname: "description",
+        fieldtype: "Text Editor",
+        label: "Description",
+        reqd: 1,
+        depends_on: "eval:doc.status != 'Closed'",
+      }),
+      field({ fieldname: "rate", fieldtype: "Float", precision: "2", read_only: 1 }),
+    ]);
+    expect(schema.sections).toHaveLength(1);
+    expect(schema.sections?.[0]?.columns).toHaveLength(1);
+    expect(schema.sections?.[0]?.columns?.[0]?.fields).toBe(schema.fields);
+
+    const [description, rate] = schema.fields ?? [];
+    expect(description).toMatchObject({
+      type: "Text Editor",
+      fieldtype: "Text Editor",
+      name: "description",
+      fieldname: "description",
+      label: "Description",
+      required: true,
+      readOnly: false,
+      depends_on: "eval:doc.status != 'Closed'",
+    });
+    expect(rate).toMatchObject({ required: false, readOnly: true, precision: 2 });
+  });
+
+  it("leaves precision undefined when meta omits it", () => {
+    const schema = buildQuickEntrySchema([field({ fieldname: "x", precision: "" })]);
+    expect(schema.fields?.[0]?.precision).toBeUndefined();
+  });
+});
+
+describe("isEmptyFieldValue", () => {
+  it("treats nullish, blank strings, and empty arrays as empty", () => {
+    expect(isEmptyFieldValue(undefined)).toBe(true);
+    expect(isEmptyFieldValue(null)).toBe(true);
+    expect(isEmptyFieldValue("")).toBe(true);
+    expect(isEmptyFieldValue("   ")).toBe(true);
+    expect(isEmptyFieldValue([])).toBe(true);
+  });
+
+  it("treats 0 and false as VALUES (valid Check state), not empty", () => {
+    expect(isEmptyFieldValue(0)).toBe(false);
+    expect(isEmptyFieldValue(false)).toBe(false);
+  });
+
+  it("treats real content as non-empty", () => {
+    expect(isEmptyFieldValue("x")).toBe(false);
+    expect(isEmptyFieldValue([1])).toBe(false);
+    expect(isEmptyFieldValue({})).toBe(false);
+  });
+});
+
+describe("resolveCreatedName", () => {
+  it("reads the name from a direct doc payload (fixture providers)", () => {
+    expect(resolveCreatedName({ name: "07mrhbtku7", doctype: "ToDo" })).toBe("07mrhbtku7");
+  });
+
+  it("reads the name from the {message} envelope (live create_doc)", () => {
+    expect(resolveCreatedName({ message: { name: "TODO-0001", doctype: "ToDo" } })).toBe(
+      "TODO-0001",
+    );
+  });
+
+  it("prefers the direct name over the envelope", () => {
+    expect(resolveCreatedName({ name: "outer", message: { name: "inner" } })).toBe("outer");
+  });
+
+  it("falls through an empty direct name to the envelope", () => {
+    expect(resolveCreatedName({ name: "", message: { name: "inner" } })).toBe("inner");
+  });
+
+  it("returns empty string for unusable payloads", () => {
+    expect(resolveCreatedName(undefined)).toBe("");
+    expect(resolveCreatedName(null)).toBe("");
+    expect(resolveCreatedName("string")).toBe("");
+    expect(resolveCreatedName(42)).toBe("");
+    expect(resolveCreatedName({})).toBe("");
+    expect(resolveCreatedName({ message: "not a doc" })).toBe("");
+    expect(resolveCreatedName({ message: { name: 5 } })).toBe("");
+  });
+});
+
+describe("parseServerError", () => {
+  const FALLBACK = "Could not create the document.";
+
+  it("extracts missing fieldnames from a MandatoryError exception", () => {
+    const err = {
+      data: {
+        exc_type: "MandatoryError",
+        exception: "frappe.exceptions.MandatoryError: [ToDo, new-todo-aaa]: description",
+      },
+    };
+    expect(parseServerError(err, FALLBACK)).toEqual({ missingFields: ["description"] });
+  });
+
+  it("splits multiple missing fields on commas", () => {
+    const err = {
+      exc_type: "MandatoryError",
+      exception: "frappe.exceptions.MandatoryError: [Note, new-note-bbb]: title, content",
+    };
+    expect(parseServerError(err, FALLBACK)).toEqual({ missingFields: ["title", "content"] });
+  });
+
+  it("parses _server_messages (JSON array of JSON strings) and strips HTML", () => {
+    const err = {
+      data: {
+        _server_messages: JSON.stringify([
+          JSON.stringify({ message: "<b>Value missing</b> for Priority", title: "Message" }),
+        ]),
+      },
+    };
+    expect(parseServerError(err, FALLBACK)).toEqual({
+      general: "Value missing for Priority",
+      missingFields: [],
+    });
+  });
+
+  it("joins multiple server messages with newlines and keeps raw string entries", () => {
+    const err = {
+      _server_messages: JSON.stringify([
+        JSON.stringify({ message: "First problem" }),
+        "Second raw problem",
+      ]),
+    };
+    expect(parseServerError(err, FALLBACK)).toEqual({
+      general: "First problem\nSecond raw problem",
+      missingFields: [],
+    });
+  });
+
+  it("keeps the human part of a ValidationError exception string", () => {
+    const err = {
+      data: {
+        exc_type: "ValidationError",
+        exception: "frappe.exceptions.ValidationError: Date must be in the future",
+      },
+    };
+    expect(parseServerError(err, FALLBACK)).toEqual({
+      general: "Date must be in the future",
+      missingFields: [],
+    });
+  });
+
+  it("uses a short plain error message when nothing frappe-shaped exists", () => {
+    expect(parseServerError(new Error("Network request failed"), FALLBACK)).toEqual({
+      general: "Network request failed",
+      missingFields: [],
+    });
+  });
+
+  it("never surfaces tracebacks or oversized messages", () => {
+    expect(parseServerError(new Error("Traceback (most recent call last): ..."), FALLBACK)).toEqual(
+      { general: FALLBACK, missingFields: [] },
+    );
+    expect(parseServerError(new Error("x".repeat(301)), FALLBACK)).toEqual({
+      general: FALLBACK,
+      missingFields: [],
+    });
+  });
+
+  it("falls back for empty or non-object errors", () => {
+    expect(parseServerError(undefined, FALLBACK)).toEqual({
+      general: FALLBACK,
+      missingFields: [],
+    });
+    expect(parseServerError("boom", FALLBACK)).toEqual({ general: FALLBACK, missingFields: [] });
+    expect(parseServerError({}, FALLBACK)).toEqual({ general: FALLBACK, missingFields: [] });
+  });
+});

package/src/quickEntry/quickEntryPlan.ts

@@ -0,0 +1,228 @@
+/**
+ * Quick-entry planning — desk parity with
+ * frappe/public/js/frappe/form/quick_entry.js:
+ *
+ * - Field selection unions `reqd`, `bold`, and `allow_in_quick_entry` fields
+ *   (excluding read-only / hidden / virtual / layout breaks). The union
+ *   matters: a doctype whose quick-entry-flagged fields don't cover its
+ *   mandatory fields (stock ToDo: `date` is flagged, `description` is only
+ *   reqd) would otherwise always fail server-side validation.
+ * - Quick entry applies only when `meta.quick_entry == 1`, at least one
+ *   usable field exists, and no selected field is a child `Table` —
+ *   otherwise the desk routes straight to the full form.
+ * - Prompt-named doctypes (`autoname: "Prompt"`) prepend a required name
+ *   field (rendered as the synthetic `__newname` Data field).
+ */
+
+import type { DocFieldMeta, DoctypeMeta } from "../shared/useDoctypeMeta";
+import type { FieldSchema, FormSchema } from "@multiplatform.one/frappe-ui";
+
+const LAYOUT_FIELDTYPES = new Set(["Section Break", "Column Break", "Tab Break", "Fold"]);
+/** Fieldtypes whose string meta `default` coerces to a number (incl. Check 0/1). */
+const NUMERIC_FIELDTYPES = new Set(["Int", "Float", "Currency", "Percent", "Check", "Rating"]);
+
+/** Synthetic fieldname for the prompt-autoname input (maps to `name` on insert). */
+export const PROMPT_NAME_FIELD = "__newname";
+
+export type QuickEntryPlan =
+  | { kind: "fields"; fields: DocFieldMeta[]; promptName: boolean }
+  | { kind: "full-form"; reason: "quick-entry-disabled" | "no-fields" | "child-table" };
+
+/** Decide whether a doctype quick-enters or defers to the full form. */
+export function planQuickEntry(meta: DoctypeMeta): QuickEntryPlan {
+  if (meta.quick_entry !== 1) return { kind: "full-form", reason: "quick-entry-disabled" };
+  const fields = meta.fields.filter(
+    (field) =>
+      (field.reqd || field.bold || field.allow_in_quick_entry) &&
+      !field.hidden &&
+      !field.read_only &&
+      !(field as { is_virtual?: 0 | 1 }).is_virtual &&
+      !LAYOUT_FIELDTYPES.has(field.fieldtype),
+  );
+  if (fields.length === 0) return { kind: "full-form", reason: "no-fields" };
+  if (fields.some((field) => field.fieldtype === "Table")) {
+    return { kind: "full-form", reason: "child-table" };
+  }
+  return {
+    kind: "fields",
+    fields,
+    promptName: (meta.autoname ?? "").toLowerCase() === "prompt",
+  };
+}
+
+function todayISO(): string {
+  const now = new Date();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  return `${now.getFullYear()}-${month}-${day}`;
+}
+
+/**
+ * Seed a draft from simple meta field defaults ("Today" for Date/Datetime,
+ * numeric coercion for numeric/Check types, literal strings). Session /
+ * server-resolved tokens (`__user`, `:field`, `frappe.*`) are skipped — the
+ * server fills those on insert.
+ */
+export function buildQuickEntryDefaults(
+  fields: DocFieldMeta[],
+  extra?: Record<string, unknown>,
+): Record<string, unknown> {
+  const draft: Record<string, unknown> = {};
+  for (const field of fields) {
+    const raw = field.default;
+    if (raw === null || raw === undefined || raw === "") continue;
+    if (typeof raw !== "string") {
+      // Loose meta payloads may carry pre-coerced numbers/booleans — use as-is.
+      draft[field.fieldname] = raw;
+      continue;
+    }
+    if (raw === "Today" && (field.fieldtype === "Date" || field.fieldtype === "Datetime")) {
+      draft[field.fieldname] = todayISO();
+      continue;
+    }
+    if (raw === "__user" || raw.startsWith(":") || raw.startsWith("frappe.")) continue;
+    draft[field.fieldname] = NUMERIC_FIELDTYPES.has(field.fieldtype) ? Number(raw) || 0 : raw;
+  }
+  return extra ? { ...draft, ...extra } : draft;
+}
+
+function fieldToSchema(field: DocFieldMeta): FieldSchema {
+  return {
+    type: field.fieldtype,
+    name: field.fieldname,
+    label: field.label,
+    options: field.options,
+    description: field.description,
+    required: !!field.reqd,
+    readOnly: !!field.read_only,
+    precision:
+      field.precision !== null && field.precision !== undefined && field.precision !== ""
+        ? Number(field.precision) || undefined
+        : undefined,
+    depends_on: field.depends_on,
+    fieldtype: field.fieldtype,
+    fieldname: field.fieldname,
+  };
+}
+
+/** Single-section, single-column compact schema for the mini-form. */
+export function buildQuickEntrySchema(fields: DocFieldMeta[]): FormSchema {
+  const schemaFields = fields.map(fieldToSchema);
+  return { sections: [{ columns: [{ fields: schemaFields }] }], fields: schemaFields };
+}
+
+export function isEmptyFieldValue(value: unknown): boolean {
+  if (value === undefined || value === null) return true;
+  if (typeof value === "string" && value.trim() === "") return true;
+  if (Array.isArray(value) && value.length === 0) return true;
+  return false;
+}
+
+// ---------------------------------------------------------------------------
+// Server response / error parsing (defensive — probed against a live bench)
+// ---------------------------------------------------------------------------
+
+/**
+ * Created-doc name from an insert response. `live.live.api.create_doc`
+ * wraps the doc in `{message: {...}}` (whitelisted-method envelope); fixture
+ * providers return the doc directly. Handles both.
+ */
+export function resolveCreatedName(payload: unknown): string {
+  if (!payload || typeof payload !== "object") return "";
+  const record = payload as Record<string, unknown>;
+  if (typeof record.name === "string" && record.name) return record.name;
+  if (record.message && typeof record.message === "object") {
+    const name = (record.message as Record<string, unknown>).name;
+    if (typeof name === "string" && name) return name;
+  }
+  return "";
+}
+
+export interface ParsedServerError {
+  /** Human-readable message for the general slot (never a traceback). */
+  general?: string;
+  /** Fieldnames the server reported missing (MandatoryError). */
+  missingFields: string[];
+}
+
+/** FrappeError carries the JSON error body in `.data`; plain errors don't. */
+function errorPayload(err: unknown): Record<string, unknown> {
+  if (!err || typeof err !== "object") return {};
+  const data = (err as { data?: unknown }).data;
+  if (data && typeof data === "object") return data as Record<string, unknown>;
+  return err as Record<string, unknown>;
+}
+
+function stripHtml(text: string): string {
+  return text.replace(/<[^>]*>/g, "").trim();
+}
+
+/**
+ * Parse a frappe error response into an honest message. Probed shapes:
+ * - `frappe.throw` → `_server_messages`: JSON array of JSON strings with a
+ *   `message` key (+ `exc_type`, `exception`).
+ * - Direct exceptions (MandatoryError) → `exc_type` + `exception`
+ *   ("frappe.exceptions.MandatoryError: [ToDo, xxx]: field_a, field_b"),
+ *   no `_server_messages`.
+ * - `err.message` can be a raw traceback (`payload.exc` fallback in the
+ *   HTTP client) — never surfaced to the user.
+ */
+export function parseServerError(err: unknown, fallback: string): ParsedServerError {
+  const payload = errorPayload(err);
+  const excType = typeof payload.exc_type === "string" ? payload.exc_type : undefined;
+  const exception = typeof payload.exception === "string" ? payload.exception : undefined;
+
+  if (excType === "MandatoryError" && exception) {
+    // Only extract fields when the "[DocType, name]: a, b" delimiter is present;
+    // lastIndexOf miss (-1) + 2 would otherwise slice garbage from index 1.
+    const delim = exception.lastIndexOf("]:");
+    if (delim !== -1) {
+      const tail = exception.slice(delim + 2);
+      const missingFields = tail
+        .split(",")
+        .map((part) => part.trim())
+        .filter(Boolean);
+      if (missingFields.length > 0) return { missingFields };
+    }
+  }
+
+  const rawMessages = payload._server_messages;
+  if (typeof rawMessages === "string" && rawMessages) {
+    try {
+      const entries = JSON.parse(rawMessages) as unknown[];
+      const texts = entries
+        .map((entry) => {
+          if (typeof entry !== "string") return "";
+          try {
+            const parsed = JSON.parse(entry) as { message?: unknown };
+            return typeof parsed.message === "string" ? parsed.message : entry;
+          } catch {
+            return entry;
+          }
+        })
+        .map(stripHtml)
+        .filter(Boolean);
+      if (texts.length > 0) return { general: texts.join("\n"), missingFields: [] };
+    } catch {
+      // fall through to the exception string
+    }
+  }
+
+  if (exception) {
+    // "frappe.exceptions.ValidationError: human text" → keep the human part.
+    const colon = exception.indexOf(": ");
+    const human = colon >= 0 ? exception.slice(colon + 2) : exception;
+    if (human) return { general: stripHtml(human), missingFields: [] };
+  }
+
+  const message = (err as { message?: unknown } | undefined)?.message;
+  if (
+    typeof message === "string" &&
+    message &&
+    !/Traceback/i.test(message) &&
+    message.length <= 300
+  ) {
+    return { general: stripHtml(message), missingFields: [] };
+  }
+  return { general: fallback, missingFields: [] };
+}