@multiplatform.one/backoffice 6.7.0 → 7.1.0

package/src/report/reportShapes.spec.ts

@@ -1,8 +1,14 @@
 // Normalizer specs pinned to PROBED bench payloads (see reportShapes.ts
 // header): v15 dict columns/rows from frappe.desk.query_report.run plus the
-// defensive old-style string-column / positional-array-row forms.
+// defensive old-style string-column / positional-array-row forms, and the
+// script-module filter extraction (probed get_script payloads).
 import { describe, expect, it } from "vitest";
 import {
+  buildRunFilters,
+  compactQueryReportFilters,
+  defaultFilterValues,
+  extractScriptFilters,
+  normalizeFilterMeta,
   normalizeQueryReportColumns,
   normalizeQueryReportRows,
   scrubFieldname,
@@ -99,3 +105,287 @@ describe("stripHtml", () => {
     expect(stripHtml("plain")).toBe("plain");
   });
 });
+
+describe("normalizeFilterMeta", () => {
+  it("normalizes Report Filter doc rows (mandatory flag, wildcard, defaults)", () => {
+    expect(
+      normalizeFilterMeta([
+        {
+          fieldname: "status",
+          label: "Status",
+          fieldtype: "Select",
+          options: "Open\nClosed",
+          mandatory: 1,
+          wildcard_filter: 0,
+          default: "Open",
+        },
+        { label: "Search Term", fieldtype: "Data", wildcard_filter: "1" },
+        null,
+        "junk",
+      ]),
+    ).toEqual([
+      {
+        fieldname: "status",
+        label: "Status",
+        fieldtype: "Select",
+        options: "Open\nClosed",
+        default: "Open",
+        mandatory: 1,
+        wildcard_filter: 0,
+        hidden: 0,
+        read_only: 0,
+      },
+      {
+        fieldname: "search_term",
+        label: "Search Term",
+        fieldtype: "Data",
+        options: undefined,
+        default: undefined,
+        mandatory: 0,
+        wildcard_filter: 1,
+        hidden: 0,
+        read_only: 0,
+      },
+    ]);
+  });
+
+  it("accepts script vocabulary: reqd, boolean/number defaults, options arrays", () => {
+    const [filter] = normalizeFilterMeta([
+      {
+        fieldname: "show_permissions",
+        fieldtype: "Check",
+        reqd: 1,
+        default: true,
+        options: ["", "Open", "Closed"],
+      },
+    ]);
+    expect(filter).toMatchObject({
+      fieldname: "show_permissions",
+      mandatory: 1,
+      default: 1,
+      options: "\nOpen\nClosed",
+    });
+  });
+
+  it("honors read_only / readOnly so locked filters stay visible but inert", () => {
+    const [locked] = normalizeFilterMeta([
+      { fieldname: "company", fieldtype: "Link", options: "Company", read_only: 1 },
+    ]);
+    const [alsoLocked] = normalizeFilterMeta([
+      { fieldname: "company", fieldtype: "Link", options: "Company", readOnly: true },
+    ]);
+    expect(locked).toMatchObject({ read_only: 1 });
+    expect(alsoLocked).toMatchObject({ read_only: 1 });
+  });
+});
+
+describe("extractScriptFilters", () => {
+  it("extracts the declarative subset (probed Permitted Documents For User script)", () => {
+    // Verbatim get_script payload from the bench probe (2026-08-13) —
+    // includes a get_query function that must be skipped, not parsed.
+    const script = `// Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
+// MIT License. See license.txt
+
+frappe.query_reports["Permitted Documents For User"] = {
+\tfilters: [
+\t\t{
+\t\t\tfieldname: "user",
+\t\t\tlabel: __("User"),
+\t\t\tfieldtype: "Link",
+\t\t\toptions: "User",
+\t\t\treqd: 1,
+\t\t},
+\t\t{
+\t\t\tfieldname: "doctype",
+\t\t\tlabel: __("DocType"),
+\t\t\tfieldtype: "Link",
+\t\t\toptions: "DocType",
+\t\t\treqd: 1,
+\t\t\tget_query: function () {
+\t\t\t\treturn {
+\t\t\t\t\tquery: "frappe.core.report.permitted_documents_for_user.permitted_documents_for_user.query_doctypes",
+\t\t\t\t\tfilters: {
+\t\t\t\t\t\tuser: frappe.query_report.get_filter_value("user"),
+\t\t\t\t\t},
+\t\t\t\t};
+\t\t\t},
+\t\t},
+\t\t{
+\t\t\tfieldname: "show_permissions",
+\t\t\tlabel: __("Show Permissions"),
+\t\t\tfieldtype: "Check",
+\t\t},
+\t],
+};
+
+//# sourceURL=permitted_documents_for_user.js`;
+    const extraction = extractScriptFilters(script);
+    expect(extraction.declared).toBe(true);
+    expect(extraction.declaredCount).toBe(3);
+    expect(extraction.filters).toEqual([
+      {
+        fieldname: "user",
+        label: "User",
+        fieldtype: "Link",
+        options: "User",
+        default: undefined,
+        mandatory: 1,
+        wildcard_filter: 0,
+        hidden: 0,
+        read_only: 0,
+      },
+      {
+        fieldname: "doctype",
+        label: "DocType",
+        fieldtype: "Link",
+        options: "DocType",
+        default: undefined,
+        mandatory: 1,
+        wildcard_filter: 0,
+        hidden: 0,
+        read_only: 0,
+      },
+      {
+        fieldname: "show_permissions",
+        label: "Show Permissions",
+        fieldtype: "Check",
+        options: undefined,
+        default: undefined,
+        mandatory: 0,
+        wildcard_filter: 0,
+        hidden: 0,
+        read_only: 0,
+      },
+    ]);
+  });
+
+  it("treats an empty declared array as declared with no filters (probed ToDo script)", () => {
+    const extraction = extractScriptFilters(
+      'frappe.query_reports["ToDo"] = {\n\tfilters: [],\n};\n',
+    );
+    expect(extraction).toEqual({ declared: true, declaredCount: 0, filters: [] });
+  });
+
+  it("reports no declaration for scripts without a filters key (and for no script)", () => {
+    expect(extractScriptFilters('frappe.query_reports["X"] = {};').declared).toBe(false);
+    expect(extractScriptFilters(undefined).declared).toBe(false);
+  });
+
+  it("counts non-declarative and desk-only entries as gaps", () => {
+    const script = `frappe.query_reports["X"] = {
+      filters: [
+        { fieldname: "user", fieldtype: "Link", options: "User" },
+        { fieldname: dynamic_name, fieldtype: "Data" },
+        { fieldname: "companies", label: __("Companies"), fieldtype: "MultiSelectList",
+          get_data: function (txt) { return frappe.db.get_link_options("Company", txt); } },
+      ],
+    };`;
+    const extraction = extractScriptFilters(script);
+    expect(extraction.declaredCount).toBe(3);
+    expect(extraction.filters.map((filter) => filter.fieldname)).toEqual(["user"]);
+  });
+
+  it("skips dynamic defaults but keeps scalar ones (numbers, quoted strings, arrays)", () => {
+    const script = `frappe.query_reports["X"] = {
+      filters: [
+        { fieldname: "from_date", fieldtype: "Date", default: frappe.datetime.get_today() },
+        { fieldname: "status", fieldtype: "Select", options: ["", "Open", "Closed"], default: "Open" },
+        { fieldname: "limit", fieldtype: "Int", default: 20 },
+        // trailing comment inside the array
+        { fieldname: "hidden_flag", fieldtype: "Check", default: 1, hidden: 1 },
+      ],
+    };`;
+    const extraction = extractScriptFilters(script);
+    expect(extraction.declaredCount).toBe(4);
+    expect(extraction.filters).toHaveLength(4);
+    const [fromDate, status, limit, hiddenFlag] = extraction.filters;
+    expect(fromDate).toMatchObject({ fieldname: "from_date", default: undefined });
+    expect(status).toMatchObject({ options: "\nOpen\nClosed", default: "Open" });
+    expect(limit).toMatchObject({ default: 20 });
+    expect(hiddenFlag).toMatchObject({ hidden: 1, default: 1 });
+  });
+
+  it("handles strings containing commas, braces, and escapes", () => {
+    const script = `frappe.query_reports["X"] = {
+      filters: [
+        { fieldname: "note", fieldtype: "Data", label: __("A, {B} \\"quoted\\"") },
+      ],
+    };`;
+    const [filter] = extractScriptFilters(script).filters;
+    expect(filter.label).toBe('A, {B} "quoted"');
+  });
+
+  it("drops Select/Link entries without options (unrenderable)", () => {
+    const script = `frappe.query_reports["X"] = {
+      filters: [{ fieldname: "pick", fieldtype: "Select" }],
+    };`;
+    const extraction = extractScriptFilters(script);
+    expect(extraction.declaredCount).toBe(1);
+    expect(extraction.filters).toHaveLength(0);
+  });
+});
+
+describe("defaultFilterValues", () => {
+  it("collects seedable defaults and skips empty ones", () => {
+    expect(
+      defaultFilterValues([
+        { fieldname: "status", default: "Open" },
+        { fieldname: "limit", default: 0 },
+        { fieldname: "user", default: "" },
+        { fieldname: "doctype" },
+      ]),
+    ).toEqual({ status: "Open", limit: 0 });
+  });
+});
+
+describe("compactQueryReportFilters", () => {
+  it("drops empty values and keeps hidden defaults so a visible clear-all is honest", () => {
+    const meta = normalizeFilterMeta([
+      { fieldname: "status", fieldtype: "Select", options: "Open\nClosed" },
+      { fieldname: "owner", fieldtype: "Data" },
+      { fieldname: "hidden_flag", fieldtype: "Check", hidden: 1, default: 1 },
+    ]);
+    expect(
+      compactQueryReportFilters(meta, {
+        status: "Open",
+        owner: "",
+        hidden_flag: 1,
+      }),
+    ).toEqual({ status: "Open", hidden_flag: 1 });
+  });
+});
+
+describe("buildRunFilters", () => {
+  const meta = normalizeFilterMeta([
+    { fieldname: "search", fieldtype: "Data", wildcard_filter: 1 },
+    { fieldname: "limit", fieldtype: "Int" },
+    { fieldname: "show_permissions", fieldtype: "Check" },
+  ]);
+
+  it("omits empty and falsy values (desk get_filter_values parity)", () => {
+    expect(
+      buildRunFilters(meta, {
+        search: "",
+        limit: 0,
+        show_permissions: false,
+        user: null,
+        doctype: undefined,
+      }),
+    ).toEqual({});
+  });
+
+  it("wraps wildcard filters and coerces numeric fieldtypes", () => {
+    expect(buildRunFilters(meta, { search: "todo", limit: "25", show_permissions: true })).toEqual({
+      search: "%todo%",
+      limit: 25,
+      show_permissions: 1,
+    });
+  });
+
+  it("respects user-typed wildcards and passes unknown fieldnames through", () => {
+    expect(buildRunFilters(meta, { search: "to%do", extra: "kept" })).toEqual({
+      search: "to%do",
+      extra: "kept",
+    });
+  });
+});