@multiplatform.one/frappe 7.10.0 → 7.15.0

package/src/doctype.spec.ts

@@ -2,8 +2,11 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { act, renderHook, waitFor } from "@testing-library/react";
 import type { DocTypeField, FrappeFieldType } from "./doctype";
 import {
+  customFieldTypes,
+  frappeFieldTypes,
   parseDependsOn,
   parseFormLayout,
+  stockFieldTypes,
   useDocTypeMeta,
   useLinkSearch,
   useLinkTitle,
@@ -53,6 +56,18 @@ describe("FrappeFieldType", () => {
     const action = field("make_payment_entry", "Button", { label: "Make Payment Entry" });
     expect(action.fieldtype).toBe("Button");
   });
+
+  it("is the one list of fieldtypes: every stock type plus the registry's custom ones", () => {
+    expect(frappeFieldTypes).toEqual([...stockFieldTypes, ...customFieldTypes]);
+    expect(new Set(frappeFieldTypes).size).toBe(frappeFieldTypes.length);
+    expect(stockFieldTypes).toContain("Fold");
+    expect(stockFieldTypes).toHaveLength(43);
+    const fold: FrappeFieldType = "Fold";
+    const toggle: FrappeFieldType = "Toggle Group";
+    expect([fold, toggle].every((t) => frappeFieldTypes.includes(t))).toBe(true);
+    // @ts-expect-error a fieldtype outside the union is not a DocTypeField
+    field("bogus", "Not A Fieldtype");
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -141,7 +156,7 @@ describe("parseFormLayout", () => {
   });
 
   it("skips hidden fields", () => {
-    const fields = [field("visible", "Data"), field("secret", "Data", { hidden: true })];
+    const fields = [field("visible", "Data"), field("secret", "Data", { hidden: 1 })];
     const sections = parseFormLayout(fields);
     expect(sections[0].columns[0].fields).toHaveLength(1);
     expect(sections[0].columns[0].fields[0].fieldname).toBe("visible");
@@ -150,7 +165,7 @@ describe("parseFormLayout", () => {
   it("starts a new section on Section Break", () => {
     const fields = [
       field("field1", "Data"),
-      field("sec", "Section Break", { label: "Details", collapsible: true }),
+      field("sec", "Section Break", { label: "Details", collapsible: 1 }),
       field("field2", "Data"),
     ];
     const sections = parseFormLayout(fields);
@@ -227,7 +242,7 @@ describe("parseFormLayout", () => {
 
   it("drops a leading section whose fields are all hidden", () => {
     const fields = [
-      field("secret", "Data", { hidden: true }),
+      field("secret", "Data", { hidden: 1 }),
       field("sec", "Section Break", { label: "Details" }),
       field("field1", "Data"),
     ];
@@ -250,7 +265,7 @@ describe("parseFormLayout", () => {
   });
 
   it("keeps one section for a fieldless doctype", () => {
-    const sections = parseFormLayout([field("secret", "Data", { hidden: true })]);
+    const sections = parseFormLayout([field("secret", "Data", { hidden: 1 })]);
     expect(sections).toHaveLength(1);
     expect(sections[0].columns[0].fields).toHaveLength(0);
   });
@@ -295,7 +310,58 @@ describe("useDocTypeMeta", () => {
     expect(result.current.meta).toBeDefined();
     expect(result.current.meta!.name).toBe(doctype);
     expect(result.current.meta!.fields).toHaveLength(2);
-    expect(result.current.meta!.permissions[0].read).toBe(true);
+    expect(result.current.meta!.permissions?.[0]?.read).toBe(1);
+  });
+
+  // FrappeForm read this hook's meta, and the old parse copied seventeen keys
+  // and dropped the rest, so permlevel, fetch_from, set_only_once and the
+  // *_depends_on chains never reached a form. The meta is the server's own
+  // now, keys and 0|1 flags alike.
+  it("keeps every key the server sends, on the fields and on the meta", async () => {
+    const doctype = `DocLossless${testId}`;
+    const config = { baseURL: `https://meta-lossless-${testId}.example.com` };
+    const raw = {
+      ...rawDocType(doctype),
+      is_submittable: 1,
+      links: [{ link_doctype: "Payment Entry", link_fieldname: "reference_name", group: null }],
+      fields: [
+        {
+          fieldname: "customer",
+          fieldtype: "Link",
+          options: "Customer",
+          reqd: 1,
+          set_only_once: 1,
+          permlevel: 1,
+        },
+        { fieldname: "customer_name", fieldtype: "Data", fetch_from: "customer.customer_name" },
+        {
+          fieldname: "po_no",
+          fieldtype: "Data",
+          mandatory_depends_on: "eval:doc.is_export",
+          read_only_depends_on: "eval:doc.docstatus==1",
+          allow_on_submit: 1,
+        },
+        { fieldname: "more", fieldtype: "Section Break", collapsible_depends_on: "po_no" },
+      ],
+    };
+    mockGetFn.mockResolvedValueOnce({ payload: { docs: [raw] } });
+
+    const { result } = renderHook(() => useDocTypeMeta(config, doctype));
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    const meta = result.current.meta!;
+    expect(meta.is_submittable).toBe(1);
+    expect(meta.links?.[0]?.link_doctype).toBe("Payment Entry");
+    const byName = Object.fromEntries(meta.fields.map((f) => [f.fieldname, f]));
+    expect(byName.customer).toMatchObject({ reqd: 1, set_only_once: 1, permlevel: 1 });
+    expect(byName.customer_name.fetch_from).toBe("customer.customer_name");
+    expect(byName.po_no).toMatchObject({
+      mandatory_depends_on: "eval:doc.is_export",
+      read_only_depends_on: "eval:doc.docstatus==1",
+      allow_on_submit: 1,
+    });
+    expect(byName.more.collapsible_depends_on).toBe("po_no");
+    expect(meta.fields[0]).not.toBe(raw.fields[0]);
   });
 
   // The REST route reads the DocType *document* — System-Manager-only, so
@@ -391,6 +457,83 @@ describe("useDocTypeMeta", () => {
     expect(result.current.error!.message).toBe("Not found");
   });
 
+  // MPO-322: getdoctype and the DocType document are closed to Guest, so a
+  // signed-out visitor's meta read was a certain 403 in the browser log.
+  describe("signed out", () => {
+    const signedOut = { useToken: true, type: "Bearer", token: async () => "" };
+
+    afterEach(() => {
+      document.cookie = "user_id=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/";
+    });
+
+    it("never asks for meta when the token source resolves empty", async () => {
+      const doctype = `DocGuest${testId}`;
+      const config = { baseURL: `https://meta-guest-${testId}.example.com`, auth: signedOut };
+
+      const { result } = renderHook(() => useDocTypeMeta(config, doctype));
+      await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+      expect(mockGetFn).not.toHaveBeenCalled();
+      expect(result.current.meta).toBeUndefined();
+      expect(result.current.error).toMatchObject({ status: 403 });
+    });
+
+    it("still reads fixture meta", async () => {
+      const doctype = `DocGuestFix${testId}`;
+      const fixtures = {
+        getDoc: vi.fn(async () => rawDocType(doctype)),
+      } as unknown as NonNullable<Parameters<typeof useDocTypeMeta>[0]>["fixtures"];
+      const config = {
+        baseURL: `https://meta-guest-fix-${testId}.example.com`,
+        auth: signedOut,
+        fixtures,
+      };
+
+      const { result } = renderHook(() => useDocTypeMeta(config, doctype));
+      await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+      expect(result.current.meta!.name).toBe(doctype);
+      expect(mockGetFn).not.toHaveBeenCalled();
+    });
+
+    it("asks when a token resolves", async () => {
+      const doctype = `DocSignedIn${testId}`;
+      const config = {
+        baseURL: `https://meta-signed-in-${testId}.example.com`,
+        auth: { ...signedOut, token: async () => "jwt" },
+      };
+      mockGetFn.mockResolvedValueOnce({ payload: { docs: [rawDocType(doctype)] } });
+
+      const { result } = renderHook(() => useDocTypeMeta(config, doctype));
+      await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+      expect(result.current.meta!.name).toBe(doctype);
+    });
+
+    it("asks when a Frappe desk session names a user", async () => {
+      document.cookie = "user_id=desk%40example.com; path=/";
+      const doctype = `DocDesk${testId}`;
+      const config = { baseURL: `https://meta-desk-${testId}.example.com`, auth: signedOut };
+      mockGetFn.mockResolvedValueOnce({ payload: { docs: [rawDocType(doctype)] } });
+
+      const { result } = renderHook(() => useDocTypeMeta(config, doctype));
+      await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+      expect(result.current.meta!.name).toBe(doctype);
+    });
+
+    it("asks on a cookie connection, which names no token source", async () => {
+      const doctype = `DocCookie${testId}`;
+      const config = { baseURL: `https://meta-cookie-${testId}.example.com` };
+      mockGetFn.mockRejectedValueOnce(Object.assign(new Error("Not permitted"), { status: 403 }));
+
+      const { result } = renderHook(() => useDocTypeMeta(config, doctype));
+      await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+      expect(mockGetFn).toHaveBeenCalledTimes(1);
+    });
+  });
+
   it("returns undefined meta and isLoading=false when config is undefined", () => {
     const { result } = renderHook(() => useDocTypeMeta(undefined, "AnyDoc"));