@multiplatform.one/frappe 6.1.0 → 6.4.0

package/src/doctype.spec.ts

@@ -6,6 +6,7 @@ import {
   parseFormLayout,
   useDocTypeMeta,
   useLinkSearch,
+  useLinkTitle,
   useDocTypeSearch,
 } from "./doctype";
 
@@ -34,8 +35,6 @@ function field(
   return { fieldname, fieldtype, ...extra };
 }
 
-const baseConfig = { baseURL: "https://frappe.example.com" };
-
 // Use unique doctype names per test to avoid metaCache collisions
 let testId = 0;
 beforeEach(() => {
@@ -198,9 +197,49 @@ describe("parseFormLayout", () => {
       field("right", "Data"),
     ];
     const sections = parseFormLayout(fields);
-    expect(sections[1].columns).toHaveLength(2);
-    expect(sections[1].columns[0].fields).toHaveLength(0);
-    expect(sections[1].columns[1].fields[0].fieldname).toBe("right");
+    // The implicit fieldless leading section is dropped, so "sec" is first.
+    expect(sections).toHaveLength(1);
+    expect(sections[0].columns).toHaveLength(2);
+    expect(sections[0].columns[0].fields).toHaveLength(0);
+    expect(sections[0].columns[1].fields[0].fieldname).toBe("right");
+  });
+
+  it("drops the empty implicit section when meta starts with a Section Break", () => {
+    const fields = [field("sec", "Section Break", { label: "Details" }), field("field1", "Data")];
+    const sections = parseFormLayout(fields);
+    expect(sections).toHaveLength(1);
+    expect(sections[0].label).toBe("Details");
+    expect(sections[0].columns[0].fields[0].fieldname).toBe("field1");
+  });
+
+  it("drops a leading section whose fields are all hidden", () => {
+    const fields = [
+      field("secret", "Data", { hidden: true }),
+      field("sec", "Section Break", { label: "Details" }),
+      field("field1", "Data"),
+    ];
+    const sections = parseFormLayout(fields);
+    expect(sections).toHaveLength(1);
+    expect(sections[0].label).toBe("Details");
+  });
+
+  it("drops consecutive empty leading sections but keeps interior empty sections", () => {
+    const fields = [
+      field("sec0", "Section Break"),
+      field("sec1", "Section Break", { label: "First Real" }),
+      field("field1", "Data"),
+      field("sec2", "Section Break", { label: "Interior Empty" }),
+      field("sec3", "Section Break", { label: "Last" }),
+      field("field2", "Data"),
+    ];
+    const sections = parseFormLayout(fields);
+    expect(sections.map((s) => s.label)).toEqual(["First Real", "Interior Empty", "Last"]);
+  });
+
+  it("keeps one section for a fieldless doctype", () => {
+    const sections = parseFormLayout([field("secret", "Data", { hidden: true })]);
+    expect(sections).toHaveLength(1);
+    expect(sections[0].columns[0].fields).toHaveLength(0);
   });
 });
 
@@ -304,22 +343,9 @@ describe("useDocTypeMeta", () => {
 });
 
 // ---------------------------------------------------------------------------
-// useLinkSearch
+// useLinkSearch — stock search_link contract
 // ---------------------------------------------------------------------------
 
-// Minimal raw DocType response satisfying parseRawDocTypeMeta
-const minimalRawDocType = (name: string) => ({
-  name,
-  module: "Test",
-  sort_field: "modified",
-  sort_order: "DESC",
-  fields: [],
-  permissions: [],
-});
-
-// useLinkSearch calls useDocTypeMeta internally, which issues its own GET for
-// the DocType schema. Tests must account for that first HTTP call.
-
 describe("useLinkSearch", () => {
   beforeEach(() => {
     vi.useFakeTimers();
@@ -328,10 +354,8 @@ describe("useLinkSearch", () => {
     vi.useRealTimers();
   });
 
-  it("returns empty results and isLoading=false when query is empty", async () => {
+  it("returns empty results with no request when the query is empty (default)", async () => {
     const config = { baseURL: `https://link-${testId}.example.com` };
-    // First call = useDocTypeMeta schema fetch (no query means no search call)
-    mockGetFn.mockResolvedValueOnce({ payload: { data: minimalRawDocType("Customer") } });
 
     const { result } = renderHook(() => useLinkSearch(config, "Customer", { query: "" }));
 
@@ -341,45 +365,139 @@ describe("useLinkSearch", () => {
 
     expect(result.current.results).toHaveLength(0);
     expect(result.current.isLoading).toBe(false);
-    // Only the DocType meta call; no link search call for empty query
-    expect(mockGetFn).toHaveBeenCalledTimes(1);
+    expect(mockGetFn).not.toHaveBeenCalled();
   });
 
-  it("debounces and fetches results for a non-empty query", async () => {
+  it("calls frappe.desk.search.search_link with doctype/txt/page_length/filters", async () => {
     const config = { baseURL: `https://link2-${testId}.example.com` };
-    // Call 1: useDocTypeMeta schema fetch
-    mockGetFn.mockResolvedValueOnce({ payload: { data: minimalRawDocType("Customer") } });
-    // Call 2: link search (fires after 300ms debounce)
     mockGetFn.mockResolvedValueOnce({
       payload: {
         message: [
-          { name: "CUST-001", customer_name: "Acme Corp" },
-          { name: "CUST-002", customer_name: "Beta Inc" },
+          { value: "CUST-001", description: "Acme Corp" },
+          { value: "CUST-002", description: "Beta Inc" },
         ],
       },
     });
 
+    const filters = { disabled: 0 };
     const { result } = renderHook(() =>
-      useLinkSearch(config, "Customer", { query: "acme", limit: 10 }),
+      useLinkSearch(config, "Customer", { query: "acme", limit: 10, filters }),
     );
 
-    // Use runAllTimersAsync: advances the 300ms debounce timer AND flushes
-    // the resulting async fetch. waitFor can't be used with fake timers because
-    // its internal polling itself uses setTimeout.
+    // runAllTimersAsync advances the debounce timer AND flushes the fetch.
     await act(async () => {
       await vi.runAllTimersAsync();
     });
 
+    expect(mockGetFn).toHaveBeenCalledTimes(1);
+    expect(mockGetFn).toHaveBeenCalledWith("/api/method/frappe.desk.search.search_link", {
+      doctype: "Customer",
+      txt: "acme",
+      page_length: 10,
+      filters,
+    });
     expect(result.current.isLoading).toBe(false);
-    expect(result.current.results).toHaveLength(2);
-    expect(result.current.results[0].value).toBe("CUST-001");
+    expect(result.current.results).toEqual([
+      { value: "CUST-001", label: "CUST-001", description: "Acme Corp" },
+      { value: "CUST-002", label: "CUST-002", description: "Beta Inc" },
+    ]);
+  });
+
+  it("uses the server label when present (show_title_field_in_link doctypes)", async () => {
+    const config = { baseURL: `https://link-label-${testId}.example.com` };
+    mockGetFn.mockResolvedValueOnce({
+      payload: { message: [{ value: "u@x.com", label: "User X", description: "User X" }] },
+    });
+
+    const { result } = renderHook(() => useLinkSearch(config, "User", { query: "x" }));
+
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    expect(result.current.results).toEqual([
+      { value: "u@x.com", label: "User X", description: "User X" },
+    ]);
+  });
+
+  it("debounces: rapid query changes produce a single request with the final txt", async () => {
+    const config = { baseURL: `https://link-deb-${testId}.example.com` };
+    mockGetFn.mockResolvedValue({ payload: { message: [] } });
+
+    const { rerender } = renderHook(
+      ({ query }: { query: string }) => useLinkSearch(config, "Customer", { query }),
+      { initialProps: { query: "a" } },
+    );
+
+    // Retype twice within the 300ms debounce window
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(100);
+    });
+    rerender({ query: "ac" });
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(100);
+    });
+    rerender({ query: "acm" });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    expect(mockGetFn).toHaveBeenCalledTimes(1);
+    expect(mockGetFn.mock.calls[0][1]).toMatchObject({ txt: "acm" });
+  });
+
+  it("fetches the first page for an empty query when allowEmptyQuery is set", async () => {
+    const config = { baseURL: `https://link-empty-${testId}.example.com` };
+    mockGetFn.mockResolvedValueOnce({
+      payload: { message: [{ value: "CUST-001", description: "Acme" }] },
+    });
+
+    const { result } = renderHook(() =>
+      useLinkSearch(config, "Customer", { query: "", allowEmptyQuery: true }),
+    );
+
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    expect(mockGetFn).toHaveBeenCalledTimes(1);
+    expect(mockGetFn.mock.calls[0][1]).toMatchObject({ txt: "" });
+    expect(result.current.results).toHaveLength(1);
+  });
+
+  it("does not fetch when disabled via enabled=false", async () => {
+    const config = { baseURL: `https://link-dis-${testId}.example.com` };
+
+    const { result } = renderHook(() =>
+      useLinkSearch(config, "Customer", { query: "acme", enabled: false }),
+    );
+
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    expect(mockGetFn).not.toHaveBeenCalled();
+    expect(result.current.results).toHaveLength(0);
+  });
+
+  it("surfaces permission failures as error state (403 FrappeError)", async () => {
+    const config = { baseURL: `https://link-perm-${testId}.example.com` };
+    const permissionError = Object.assign(new Error("Insufficient Permission"), { status: 403 });
+    mockGetFn.mockRejectedValueOnce(permissionError);
+
+    const { result } = renderHook(() => useLinkSearch(config, "Customer", { query: "x" }));
+
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    expect(result.current.error).toBeInstanceOf(Error);
+    expect((result.current.error as { status?: number }).status).toBe(403);
+    expect(result.current.results).toHaveLength(0);
   });
 
   it("sets error state on fetch failure", async () => {
     const config = { baseURL: `https://link-err-${testId}.example.com` };
-    // Call 1: useDocTypeMeta schema fetch
-    mockGetFn.mockResolvedValueOnce({ payload: { data: minimalRawDocType("Customer") } });
-    // Call 2: link search fails
     mockGetFn.mockRejectedValueOnce(new Error("Search failed"));
 
     const { result } = renderHook(() => useLinkSearch(config, "Customer", { query: "x" }));
@@ -393,6 +511,56 @@ describe("useLinkSearch", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// useLinkTitle
+// ---------------------------------------------------------------------------
+
+describe("useLinkTitle", () => {
+  it("fetches the display title via get_link_title on mount", async () => {
+    const config = { baseURL: `https://title-${testId}.example.com` };
+    mockGetFn.mockResolvedValueOnce({ payload: { message: "Jane Doe" } });
+
+    const { result } = renderHook(() => useLinkTitle(config, "User", "jane@x.com"));
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    expect(mockGetFn).toHaveBeenCalledWith("/api/method/frappe.desk.search.get_link_title", {
+      doctype: "User",
+      docname: "jane@x.com",
+    });
+    expect(result.current.title).toBe("Jane Doe");
+  });
+
+  it("serves repeat lookups from the session cache (single request)", async () => {
+    const config = { baseURL: `https://title-cache-${testId}.example.com` };
+    mockGetFn.mockResolvedValueOnce({ payload: { message: "Jane Doe" } });
+
+    const first = renderHook(() => useLinkTitle(config, "User", "jane@x.com"));
+    await waitFor(() => expect(first.result.current.title).toBe("Jane Doe"));
+
+    const second = renderHook(() => useLinkTitle(config, "User", "jane@x.com"));
+    expect(second.result.current.title).toBe("Jane Doe");
+    expect(mockGetFn).toHaveBeenCalledTimes(1);
+  });
+
+  it("falls back to the raw name on fetch failure", async () => {
+    const config = { baseURL: `https://title-err-${testId}.example.com` };
+    mockGetFn.mockRejectedValueOnce(new Error("boom"));
+
+    const { result } = renderHook(() => useLinkTitle(config, "User", "jane@x.com"));
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.title).toBe("jane@x.com");
+  });
+
+  it("returns undefined when there is no value", () => {
+    const config = { baseURL: `https://title-none-${testId}.example.com` };
+    const { result } = renderHook(() => useLinkTitle(config, "User", undefined));
+    expect(result.current.title).toBeUndefined();
+    expect(mockGetFn).not.toHaveBeenCalled();
+  });
+});
+
 // ---------------------------------------------------------------------------
 // useDocTypeSearch
 // ---------------------------------------------------------------------------
@@ -448,4 +616,44 @@ describe("useDocTypeSearch", () => {
     const doctypes = [...new Set(result.current.results.map((r) => r.doctype))];
     expect(doctypes).toContain("Item");
   });
+
+  it("fetches once even when the caller allocates a new config object every render and the fetch fails", async () => {
+    // The desk callers (Awesomebar, DeskSidebar) build a fresh config per
+    // render. Before keying the fetch effect on the stable baseURL string,
+    // a failing fetch (Guest 403 — never cached) re-ran per render and spun
+    // into an infinite refetch loop against the bench.
+    const baseURL = `https://search-403-${testId}.example.com`;
+    mockGetFn.mockRejectedValue(new Error("403 PermissionError"));
+
+    const { result, rerender } = renderHook(
+      // a fresh object per render, like the real call sites
+      () => useDocTypeSearch({ baseURL }, "customer"),
+    );
+
+    await waitFor(() => expect(result.current.error).not.toBeNull());
+    rerender();
+    rerender();
+    rerender();
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    expect(mockGetFn).toHaveBeenCalledTimes(1);
+    expect(result.current.results).toHaveLength(0);
+  });
+
+  it("shares one in-flight fetch between concurrent consumers of the same baseURL", async () => {
+    // Awesomebar and DeskSidebar mount together on the desk; the DocType
+    // catalog must be fetched once, not once per consumer.
+    const config = { baseURL: `https://search-shared-${testId}.example.com` };
+    mockGetFn.mockResolvedValue({ payload: { data: docTypeList } });
+
+    const first = renderHook(() => useDocTypeSearch(config, "customer"));
+    const second = renderHook(() => useDocTypeSearch(config, " "));
+
+    await waitFor(() => expect(first.result.current.isLoading).toBe(false));
+    await waitFor(() => expect(second.result.current.isLoading).toBe(false));
+
+    expect(mockGetFn).toHaveBeenCalledTimes(1);
+    expect(first.result.current.results.length).toBeGreaterThan(0);
+    expect(second.result.current.results.length).toBeGreaterThan(0);
+  });
 });