@multiplatform.one/backoffice 7.28.0 → 7.29.0

package/src/desk/DeskSurface.tsx

@@ -110,13 +110,10 @@ export function DeskSurface({
         <NewDocSurface doctype={target.doctype} defaults={target.defaults} readOnly={readOnly} />
       );
     case "form":
-      // MPO-15: DocFormScreen is the strong form today. The engine
-      // (formLayout + useFormEngine) lives in frappe-ui and FrappeForm now
-      // reads the one lossless meta model, but it still maps fields itself
-      // instead of through buildFormTabs, so it does not render permlevel,
-      // fetch_from, set_only_once or the *_depends_on chains yet. When it
-      // does, the exported FrappeForm becomes this branch's renderer. Swap
-      // here, nowhere else.
+      // DocFormScreen is desk chrome over FrappeForm (MPO-15): the fields
+      // are the exported FrappeForm's, on the controller useFrappeForm
+      // returns, so this branch and a bare <FrappeForm> resolve a doctype
+      // the same way.
       return <DocFormScreen doctype={target.doctype} name={target.name} readOnly={readOnly} />;
     case "report":
       return <QueryReportScreen reportName={target.reportName} />;

package/src/form/DocFormScreen.chrome.spec.ts

@@ -0,0 +1,77 @@
+/**
+ * MPO-15 AC2: DocFormScreen is page chrome over FrappeForm.
+ *
+ * The desk form page owns its toolbar, menu, dialogs, sidebar, timeline and
+ * banners. Which fields render, which are required, read-only or hidden, and
+ * how they lay out into tabs is FrappeForm's job, so the exported component
+ * and the desk can never resolve the same doctype differently again. Any
+ * DocField key name in the page, or an import of the layout engine, means the
+ * page has started resolving fields of its own.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+
+const source = fs.readFileSync(path.resolve(__dirname, "DocFormScreen.tsx"), "utf8");
+
+const docFieldKeys = [
+  "fieldname",
+  "fieldtype",
+  "permlevel",
+  "depends_on",
+  "mandatory_depends_on",
+  "read_only_depends_on",
+  "collapsible_depends_on",
+  "set_only_once",
+  "fetch_from",
+  "reqd",
+  "hidden",
+  "read_only",
+  "allow_on_submit",
+  "in_list_view",
+  "options",
+];
+
+const fieldResolution = [
+  "buildFormTabs",
+  "buildPermLevelMatrix",
+  "buildCopyValues",
+  "buildCreateDefaults",
+  "isPromptNamed",
+  "SchemaForm",
+  "useFormEngine",
+  "sessionDocRights",
+];
+
+function importedNames(from: string): string[] {
+  const names: string[] = [];
+  const pattern = /import\s+(?:type\s+)?\{([^}]*)\}\s+from\s+"([^"]+)"/g;
+  for (const match of source.matchAll(pattern)) {
+    if (match[2] !== from) continue;
+    for (const part of match[1].split(",")) {
+      const name = part
+        .trim()
+        .replace(/^type\s+/, "")
+        .split(/\s+as\s+/)[0];
+      if (name) names.push(name);
+    }
+  }
+  return names;
+}
+
+describe("DocFormScreen is chrome over FrappeForm (MPO-15 AC2)", () => {
+  it.each(docFieldKeys)("names no DocField key: %s", (key) => {
+    expect(source).not.toMatch(new RegExp(`\\b${key}\\b`));
+  });
+
+  it.each(fieldResolution)("does not resolve fields itself: %s", (name) => {
+    expect(source).not.toMatch(new RegExp(`\\b${name}\\b`));
+  });
+
+  it("renders the field body through FrappeForm and its controller", () => {
+    const frappeUi = importedNames("@multiplatform.one/frappe-ui");
+    expect(frappeUi).toContain("FrappeForm");
+    expect(frappeUi).toContain("useFrappeForm");
+    expect(source).toMatch(/<FrappeForm(?:<\w+>)?\s[^>]*\bform=\{form\}/s);
+  });
+});

package/src/form/DocFormScreen.guest.screen.spec.tsx

@@ -0,0 +1,175 @@
+// LC-96 on the desk form (MPO-473). Signed out, pokemon's bench refuses
+// getdoctype to Guest while Guest can still read the record, and the desk form
+// stopped at its own "Could not load Pokemon" before FrappeForm could lay the
+// record out. The bench below answers getdoctype the way Frappe's
+// is_whitelisted refuses Guest (one message, a <details> summary and body) and
+// answers or refuses the record per test.
+import { renderWithProviders } from "@multiplatform.one/test-utils";
+import { fireEvent, screen, waitFor } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { BackofficeProvider } from "../config/BackofficeProvider";
+import { createMemoryNavigator } from "../navigation/navigator";
+import { DocFormScreen } from "./DocFormScreen";
+
+const doctype = "Poke Move";
+
+const tackle = {
+  name: "a1b2c3",
+  doctype,
+  owner: "Administrator",
+  modified: "2026-09-29 10:00:00",
+  docstatus: 0,
+  idx: 0,
+  move_name: "tackle",
+  power: 40,
+};
+
+const refusal = {
+  message:
+    "<details><summary>You are not permitted to access this resource. Login to access</summary>Function <strong>frappe.desk.form.load.getdoctype</strong> is not whitelisted.</details>",
+  title: "Method Not Allowed",
+  indicator: "red",
+  raise_exception: 1,
+};
+
+const settle = { timeout: 8000 };
+
+let run = 0;
+let metaAnswer: "refused" | "broken" = "refused";
+let recordReadable = true;
+let metaReads = 0;
+
+function json(body: unknown, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+function refused() {
+  return json(
+    {
+      exc_type: "PermissionError",
+      exception: `frappe.exceptions.PermissionError: ${refusal.message}`,
+      _server_messages: JSON.stringify([JSON.stringify(refusal)]),
+    },
+    403,
+  );
+}
+
+beforeEach(() => {
+  run += 1;
+  metaAnswer = "refused";
+  recordReadable = true;
+  metaReads = 0;
+  vi.stubGlobal("fetch", async (input: string | URL | Request) => {
+    const url = new URL(String(input instanceof Request ? input.url : input));
+    const method = url.pathname.replace(/^\/api\/method\//, "");
+    if (method === "frappe.desk.form.load.getdoctype") {
+      metaReads += 1;
+      return metaAnswer === "refused"
+        ? refused()
+        : json({ exc_type: "ValidationError", exception: "Poke Move is being migrated" }, 417);
+    }
+    if (method.startsWith("frappe.")) return refused();
+    const resource = `/api/resource/${encodeURIComponent(doctype)}`;
+    if (url.pathname === resource || url.pathname.startsWith(`${resource}/`)) {
+      if (!recordReadable) {
+        return json({ exc_type: "PermissionError", exception: "Not permitted" }, 403);
+      }
+      return url.pathname === resource ? json({ data: [tackle] }) : json({ data: tackle });
+    }
+    return json({ data: [], message: [] });
+  });
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+});
+
+function renderForm(name: string) {
+  return renderWithProviders(
+    <BackofficeProvider
+      frappe={{ baseURL: `https://desk-form-guest-${run}.spec.test` }}
+      navigation={createMemoryNavigator("/backoffice")}
+    >
+      <DocFormScreen doctype={doctype} name={name} />
+    </BackofficeProvider>,
+  );
+}
+
+function inputOf(label: string): HTMLInputElement {
+  const field = screen.getByLabelText(label, { exact: false });
+  return (
+    field instanceof HTMLInputElement ? field : field.querySelector("input")
+  ) as HTMLInputElement;
+}
+
+function button(label: string): HTMLElement | undefined {
+  return Array.from(document.querySelectorAll('[role="button"], button')).find(
+    (node) => node.textContent?.trim() === label,
+  ) as HTMLElement | undefined;
+}
+
+describe("DocFormScreen with DocType meta refused (LC-96)", () => {
+  it("lays out the record's own fields read-only instead of stopping at 'Could not load'", async () => {
+    renderForm("a1b2c3");
+    await waitFor(() => expect(inputOf("Power").value).toBe("40"), settle);
+    expect(inputOf("Power").disabled || inputOf("Power").readOnly).toBe(true);
+    expect(inputOf("Move Name").value).toBe("tackle");
+    expect(screen.queryByText(/Could not load/)).toBeNull();
+    expect(screen.queryByLabelText("Owner", { exact: true })).toBeNull();
+    expect(button("Save")).toBeUndefined();
+    expect(metaReads).toBe(1);
+  });
+
+  it("offers nothing that needs the refused meta or docinfo", async () => {
+    renderForm("a1b2c3");
+    await waitFor(() => expect(inputOf("Power").value).toBe("40"), settle);
+    expect(screen.queryByText("Activity")).toBeNull();
+    fireEvent.click(screen.getByTestId("form-toolbar-menu"));
+    await waitFor(
+      () => expect(document.querySelectorAll('[role="menuitem"]').length).toBeGreaterThan(0),
+      settle,
+    );
+    const items = Array.from(document.querySelectorAll('[role="menuitem"]')).map(
+      (node) => node.textContent ?? "",
+    );
+    expect(items.some((label) => label.startsWith("Duplicate"))).toBe(false);
+    expect(items.some((label) => label.startsWith("Delete"))).toBe(false);
+  });
+
+  it("says the reader can't open a record refused too, with no retry", async () => {
+    recordReadable = false;
+    renderForm("a1b2c3");
+    const state = await screen.findByTestId("frappe-form-not-permitted", {}, settle);
+    expect(state.textContent).toContain(`You can't open ${doctype} a1b2c3`);
+    expect(screen.queryByText(/Could not load/)).toBeNull();
+    expect(screen.queryByRole("button", { name: /retry/i })).toBeNull();
+  });
+
+  it("says the reader can't create, with each server message on its own line", async () => {
+    renderForm("new");
+    const state = await screen.findByTestId("frappe-form-not-permitted", {}, settle);
+    expect(state.textContent).toContain(`You can't create ${doctype}`);
+    const lines = Array.from(state.querySelectorAll("p")).map((node) => node.textContent);
+    expect(lines).toContain("You are not permitted to access this resource. Login to access");
+    expect(lines).toContain("Function frappe.desk.form.load.getdoctype is not whitelisted.");
+    expect(lines.some((line) => line?.includes("accessFunction"))).toBe(false);
+    expect(button("Save")).toBeUndefined();
+  });
+
+  it("keeps a meta read that failed for another reason a retryable error", async () => {
+    metaAnswer = "broken";
+    renderForm("a1b2c3");
+    await waitFor(
+      () => expect(screen.getByText(/Poke Move is being migrated/)).toBeTruthy(),
+      settle,
+    );
+    expect(screen.queryByTestId("frappe-form-not-permitted")).toBeNull();
+    const retry = screen.getByRole("button", { name: /retry/i });
+    fireEvent.click(retry);
+    await waitFor(() => expect(metaReads).toBe(2), settle);
+  });
+});

package/src/form/DocFormScreen.rights.spec.tsx

@@ -2,6 +2,8 @@
 // usable permissions (a new record, or a token-auth bench answering
 // {"null": 0}) the screen used to union every role's DocPerm rows, so any
 // reader got an editable form and Save. It now resolves the session's roles.
+// The form body is FrappeForm's (MPO-15 AC2), so a reader asking for a new
+// record meets FrappeForm's not-permitted state, as desk refuses new_doc.
 import { renderWithProviders } from "@multiplatform.one/test-utils";
 import { act, screen, waitFor } from "@testing-library/react";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
@@ -111,13 +113,15 @@ describe("DocFormScreen rights without docinfo permissions", () => {
     expect(moveNameInput().disabled || moveNameInput().readOnly).toBe(false);
   });
 
-  it("gives a reader a read-only new record with no Save", async () => {
+  it("tells a reader they can't create one, with no Save", async () => {
     roles = ["Guest"];
     renderForm("new");
-    await waitFor(() => expect(moveNameInput()).toBeTruthy(), { timeout: 5000 });
+    await waitFor(() => expect(screen.getByTestId("frappe-form-not-permitted")).toBeTruthy(), {
+      timeout: 5000,
+    });
     await settle();
     expect(saveButton()).toBeUndefined();
-    expect(moveNameInput().disabled || moveNameInput().readOnly).toBe(true);
+    expect(screen.queryByLabelText("Move Name", { exact: false })).toBeNull();
   });
 
   it("gives a reader an existing record read-only", async () => {