@multiplatform.one/frappe-ui 7.7.4 → 7.8.0

package/src/fields/Slider/Slider.spec.tsx

@@ -0,0 +1,73 @@
+/**
+ * SliderField contract specs. The adapter wraps a scalar number as the
+ * forms Slider's `[number]` tuple. Pin that value, onChange, disabled,
+ * label and error survive the hop.
+ */
+import { renderWithProviders } from "@multiplatform.one/test-utils";
+import { cleanup, fireEvent } from "@testing-library/react";
+import type React from "react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { getFieldComponent, type FieldRenderProps } from "../../fieldRegistry";
+import { SliderField } from ".";
+
+afterEach(cleanup);
+
+const thumb = (container: HTMLElement) =>
+  container.querySelector('[role="slider"]') as HTMLElement | null;
+
+describe("SliderField composes the forms Slider", () => {
+  it("paints a controlled value onto the thumb", () => {
+    const result = renderWithProviders(
+      <SliderField label="Volume" value={40} min={0} max={100} onChange={() => {}} />,
+    );
+    expect(thumb(result.container)?.getAttribute("aria-valuenow")).toBe("40");
+  });
+
+  it("emits a scalar through canonical onChange", () => {
+    const onChange = vi.fn();
+    const result = renderWithProviders(
+      <SliderField label="Volume" value={40} min={0} max={100} step={1} onChange={onChange} />,
+    );
+    const el = thumb(result.container) as HTMLElement;
+    el.focus();
+    fireEvent.keyDown(el, { key: "ArrowRight" });
+    expect(onChange).toHaveBeenCalled();
+    expect(typeof onChange.mock.calls.at(-1)?.[0]).toBe("number");
+  });
+
+  it("forwards disabled onto the thumb", () => {
+    const result = renderWithProviders(
+      <SliderField label="Volume" value={40} disabled onChange={() => {}} />,
+    );
+    const el = thumb(result.container);
+    const disabledMarker =
+      el?.getAttribute("aria-disabled") === "true" ||
+      el?.hasAttribute("data-disabled") ||
+      Boolean(el?.closest("[data-disabled]"));
+    expect(disabledMarker).toBe(true);
+  });
+
+  it("shows the label and error", () => {
+    const result = renderWithProviders(
+      <SliderField label="Volume" value={40} error="out of range" onChange={() => {}} />,
+    );
+    expect(result.container.textContent).toContain("Volume");
+    expect(result.container.textContent).toContain("out of range");
+  });
+});
+
+describe("registry resolution (Slider fieldtype)", () => {
+  function propsFor(overrides: Partial<FieldRenderProps> = {}): FieldRenderProps {
+    return { value: "", onChange: () => {}, ...overrides };
+  }
+
+  it("resolves 'Slider' to SliderField and coerces a non-number to 0", () => {
+    const Component = getFieldComponent("Slider")!;
+    const element = (Component as Function)(
+      propsFor({ value: "nope", label: "Volume" }),
+    ) as React.ReactElement<Record<string, unknown>>;
+    expect(element.type).toBe(SliderField);
+    expect(element.props.value).toBe(0);
+    expect(element.props.label).toBe("Volume");
+  });
+});

package/src/fields/Switch/Switch.spec.tsx

@@ -0,0 +1,65 @@
+/**
+ * SwitchField contract specs. Frappe Switch is 1/0 in the doc; this adapter
+ * maps that onto the forms Switch's boolean checked/onCheckedChange. Pin
+ * that value, onChange, disabled, label and error survive the hop.
+ */
+import { renderWithProviders } from "@multiplatform.one/test-utils";
+import { act, cleanup, fireEvent } from "@testing-library/react";
+import type React from "react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { getFieldComponent, type FieldRenderProps } from "../../fieldRegistry";
+import { SwitchField } from ".";
+
+afterEach(cleanup);
+
+describe("SwitchField composes the forms Switch", () => {
+  it("paints a controlled true value as aria-checked=true", () => {
+    const result = renderWithProviders(
+      <SwitchField label="Enabled" value={true} onChange={() => {}} />,
+    );
+    expect(result.getSwitch()?.getAttribute("aria-checked")).toBe("true");
+  });
+
+  it("emits a boolean through canonical onChange", async () => {
+    const onChange = vi.fn();
+    const result = renderWithProviders(
+      <SwitchField label="Enabled" value={false} onChange={onChange} />,
+    );
+    await act(async () => {
+      fireEvent.click(result.getSwitch() as HTMLElement);
+    });
+    expect(onChange).toHaveBeenCalledWith(true);
+  });
+
+  it("forwards disabled onto the switch", () => {
+    const result = renderWithProviders(
+      <SwitchField label="Enabled" value={false} disabled onChange={() => {}} />,
+    );
+    const el = result.getSwitch();
+    expect(el?.hasAttribute("disabled") || el?.getAttribute("aria-disabled") === "true").toBe(true);
+  });
+
+  it("shows the label and error", () => {
+    const result = renderWithProviders(
+      <SwitchField label="Enabled" value={false} error="cannot enable" onChange={() => {}} />,
+    );
+    expect(result.container.textContent).toContain("Enabled");
+    expect(result.container.textContent).toContain("cannot enable");
+  });
+});
+
+describe("registry resolution (Switch fieldtype)", () => {
+  function propsFor(overrides: Partial<FieldRenderProps> = {}): FieldRenderProps {
+    return { value: "", onChange: () => {}, ...overrides };
+  }
+
+  it("resolves 'Switch' to SwitchField and maps a truthy doc value to true", () => {
+    const Component = getFieldComponent("Switch")!;
+    const element = (Component as Function)(
+      propsFor({ value: 1, label: "Enabled" }),
+    ) as React.ReactElement<Record<string, unknown>>;
+    expect(element.type).toBe(SwitchField);
+    expect(element.props.value).toBe(true);
+    expect(element.props.label).toBe("Enabled");
+  });
+});

package/src/fields/TableMultiSelect.tsx

@@ -69,6 +69,7 @@ export function TableMultiSelect({
         socketBaseURL: config?.socketBaseURL,
         auth: auth ?? config?.auth,
         syncOptions: config?.syncOptions,
+        realtime: config?.realtime,
         fixtures: config?.fixtures,
       }
     : undefined;

package/src/fields/TextEditor/TextEditor.spec.tsx

@@ -51,11 +51,10 @@ describe("TextEditor initialization emissions", () => {
     await waitFor(() => {
       expect(utils.container.querySelector(".ProseMirror")).toBeTruthy();
     });
-    // House RichTextEditor seeds via initialContent (mount). External HTML
-    // sync is the house editor's contract, not a forked TipTap in this wrapper.
+    // An external update changes the actual document without echoing an edit.
     utils.rerender(<TextEditor label="Description" value="<p>second</p>" onChange={onChange} />);
     await waitFor(() => {
-      expect(utils.container.querySelector(".ProseMirror")).toBeTruthy();
+      expect(utils.container.querySelector(".ProseMirror")?.textContent).toBe("second");
     });
     expect(onChange).not.toHaveBeenCalled();
   });

package/src/fields/TextEditor/TextEditor.stories.tsx

@@ -1,7 +1,8 @@
 import { action } from "@multiplatform.one/storybook";
+import { Button } from "@multiplatform.one/forms";
 import { DataTable, type DataTableColumn } from "@multiplatform.one/table";
 import { useState } from "react";
-import { YStack } from "tamagui";
+import { Text, YStack } from "tamagui";
 import { fieldtypeToTableField } from "../../fieldRegistry";
 import { FrappeStoryProvider } from "../../frappeStoryTarget";
 import { TextEditor, type TextEditorProps } from ".";
@@ -51,6 +52,35 @@ Main.args = {
 } as Partial<StoryProps>;
 Main.storyName = "Main";
 
+export const ExternalValueUpdates = {
+  name: "External value updates",
+  render: function ExternalValueUpdatesStory() {
+    const [value, setValue] = useState("<p>Original note</p>");
+    const [edits, setEdits] = useState(0);
+    return (
+      <YStack gap="$3" maxWidth={640}>
+        <TextEditor
+          label="Note"
+          value={value}
+          onChange={(next) => {
+            setValue(next);
+            setEdits((count) => count + 1);
+          }}
+        />
+        <Button
+          onPress={() => {
+            setEdits(0);
+            setValue("<p>Saved note</p>");
+          }}
+        >
+          Load saved note
+        </Button>
+        <Text testID="editor-user-edits">User edits: {edits}</Text>
+      </YStack>
+    );
+  },
+};
+
 export const Empty = (args: StoryProps) => <Controlled {...args} />;
 Empty.args = {
   label: "Empty editor",

package/src/fields/ToggleGroup/ToggleGroup.spec.tsx

@@ -0,0 +1,110 @@
+/**
+ * ToggleGroupField contract specs. The adapter maps `onChange` onto the forms
+ * ToggleGroup's `onValueChange`. Pin that value, onChange, disabled, label
+ * and error survive the hop.
+ */
+import { renderWithProviders } from "@multiplatform.one/test-utils";
+import { cleanup, fireEvent } from "@testing-library/react";
+import type React from "react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { getFieldComponent, type FieldRenderProps } from "../../fieldRegistry";
+import { ToggleGroupField } from ".";
+
+afterEach(cleanup);
+
+const options = [
+  { label: "Left", value: "left" },
+  { label: "Center", value: "center" },
+  { label: "Right", value: "right" },
+];
+
+describe("ToggleGroupField composes the forms ToggleGroup", () => {
+  it("paints a controlled value onto the matching item", () => {
+    const result = renderWithProviders(
+      <ToggleGroupField
+        label="Align"
+        type="single"
+        value="center"
+        options={options}
+        onChange={() => {}}
+      />,
+    );
+    expect(result.container.textContent).toContain("Center");
+    const pressed = result.container.querySelector('[aria-pressed="true"], [data-state="on"]');
+    expect(pressed).toBeTruthy();
+  });
+
+  it("emits the item value through canonical onChange", () => {
+    const onChange = vi.fn();
+    const result = renderWithProviders(
+      <ToggleGroupField
+        label="Align"
+        type="single"
+        value="left"
+        options={options}
+        onChange={onChange}
+      />,
+    );
+    const center = result.findTextElement("Center");
+    expect(center).toBeTruthy();
+    fireEvent.click(center as HTMLElement);
+    expect(onChange).toHaveBeenCalledWith("center");
+  });
+
+  it("forwards disabled onto the group", () => {
+    const result = renderWithProviders(
+      <ToggleGroupField
+        label="Align"
+        type="single"
+        value="left"
+        options={options}
+        disabled
+        onChange={() => {}}
+      />,
+    );
+    const el =
+      result.container.querySelector('[role="group"]') ||
+      result.container.querySelector('[data-disabled="true"]') ||
+      result.container.querySelector("[disabled]");
+    expect(el).toBeTruthy();
+  });
+
+  it("shows the label and error", () => {
+    const result = renderWithProviders(
+      <ToggleGroupField
+        label="Align"
+        type="single"
+        value="left"
+        options={options}
+        error="pick a side"
+        onChange={() => {}}
+      />,
+    );
+    expect(result.container.textContent).toContain("Align");
+    expect(result.container.textContent).toContain("pick a side");
+  });
+});
+
+describe("registry resolution (Toggle Group fieldtype)", () => {
+  function propsFor(overrides: Partial<FieldRenderProps> = {}): FieldRenderProps {
+    return { value: "", onChange: () => {}, ...overrides };
+  }
+
+  it("resolves 'Toggle Group' to ToggleGroupField and splits df.options on newlines", () => {
+    const Component = getFieldComponent("Toggle Group")!;
+    const element = (Component as Function)(
+      propsFor({
+        value: "Left",
+        label: "Align",
+        fieldMeta: { options: "Left\nCenter" },
+      } as Partial<FieldRenderProps>),
+    ) as React.ReactElement<Record<string, unknown>>;
+    expect(element.type).toBe(ToggleGroupField);
+    expect(element.props.value).toBe("Left");
+    expect(element.props.label).toBe("Align");
+    expect(element.props.options).toEqual([
+      { label: "Left", value: "Left" },
+      { label: "Center", value: "Center" },
+    ]);
+  });
+});

package/src/formEngine/formActions.ts

@@ -36,6 +36,8 @@ import type { FixtureProvider } from "@multiplatform.one/frappe";
  */
 export interface FrappeConnection {
   baseURL: string;
+  /** False keeps HTTP reads without realtime subscriptions. */
+  realtime?: boolean;
   socketPort?: number;
   /** Same-origin socket override (see FrappeConfig.socketBaseURL). */
   socketBaseURL?: string;

package/src/frappeUsers.ts

@@ -65,6 +65,7 @@ export function useFrappeUsers(
             socketBaseURL: config.socketBaseURL,
             auth: config.auth,
             syncOptions: config.syncOptions,
+            realtime: config.realtime,
             fixtures: config.fixtures,
           }
         : undefined,

package/src/frappeViews.designLaw.spec.ts

@@ -55,14 +55,15 @@ describe("Frappe view adapters — design-law 100%", () => {
     expect(source).toMatch(/from "@multiplatform.one\/components"/);
   });
 
-  it("FrappeGantt action banners use form ramps and do not steal Desk assembly", () => {
+  it("FrappeGantt action errors use Alert and keep the adapter boundary", () => {
     const source = read("FrappeGantt.tsx");
-    expect(source).toContain("formCommonColors");
+    expect(source).toMatch(/import \{[^}]*Alert[^}]*\} from "@multiplatform.one\/components"/);
+    expect(source).toMatch(/<Alert\b[^>]*intent="error"/);
     expect(source).toContain("containerRadius");
+    expect(source).not.toContain("knobProps.borderRadius");
     expect(source).not.toMatch(/fontSize=\{knobProps\.sizeToken\}/);
-    expect(source).not.toContain('color="$red11"');
-    expect(source).toContain("BACKOFFICE_VIEWS");
-    expect(source).toContain("MPO-14");
+    expect(source).not.toMatch(/\$red\d+/);
+    expect(source).not.toMatch(/from ["'](?:@multiplatform\.one\/backoffice|\.\/desk\/)/);
   });
 
   it("FrappeReportView uses the house Button and label fragments (LC-54)", () => {
@@ -81,12 +82,15 @@ describe("Frappe view adapters — design-law 100%", () => {
     expect(source).toContain("formCommonColors");
     expect(source).not.toMatch(/fontWeight="600"|fontWeight="500"/);
     expect(source).toContain('fontWeight="400"');
-    expect(source).toContain("outlined");
+    expect(source).not.toMatch(/<Button\b[^>]*\b(?:controlFill|backgroundColor|borderColor)=/);
   });
 
   it("FrappeTreeView empty chrome is EmptyState and labels use the label fragment", () => {
     const source = read("FrappeTreeView.tsx");
-    expect(source).toContain("EmptyState");
+    expect(source).toMatch(/import \{[^}]*EmptyState[^}]*\} from "@multiplatform.one\/components"/);
+    expect(source).toContain("<EmptyState");
+    expect(source).toContain("useGlyphColor(formCommonColors.muted)");
+    expect(source).not.toMatch(/<TreeStructureIcon\b[^>]*color=\{formCommonColors\./);
     expect(source).not.toMatch(/size=\{48\}/);
     expect(source).toContain("knobProps.label");
     expect(source).not.toMatch(/fontSize=\{display === "compressed" \? 12 : 14\}/);

package/src/index.ts

@@ -120,6 +120,19 @@ export {
   type FrappeChartDataSource,
 } from "./FrappeChartCard";
 
+// The composed doctype read (MPO-251) — the supported way to get rows out of
+// a doctype when the panel shape has no shipped component. FrappeTable and
+// the other live views read through it, so there is one implementation.
+export {
+  useFrappeRows,
+  useFrappeConnection,
+  DEFAULT_FRAPPE_ROWS_LIMIT,
+  type FrappeRowsConnection,
+  type FrappeRowsMessages,
+  type UseFrappeRowsOptions,
+  type UseFrappeRowsResult,
+} from "./useFrappeRows";
+
 export {
   useFrappeAggregate,
   type FrappeAggregateConnection,

package/src/schemaForm/index.tsx

@@ -17,9 +17,10 @@ import {
   type RequiredMarkStrategy,
 } from "@multiplatform.one/forms";
 import { useResolvedKnobs } from "@multiplatform.one/theme";
+import { Card } from "@multiplatform.one/components";
 import React, { useMemo } from "react";
 import { useTranslation } from "react-i18next";
-import { Card, Text, XStack, YStack } from "tamagui";
+import { Text, XStack, YStack } from "tamagui";
 
 import { compileDependsOn } from "../dependsOn";
 import { Heading, type HeadingLevel } from "../fields/Heading";
@@ -353,13 +354,12 @@ function SchemaFormSectionCard({ section, headingLevel, renderField }: SchemaFor
 
   return (
     <Card
-      borderWidth={hideBorder ? 0 : 1}
-      borderColor="$borderColor"
-      size={knobProps.sizeToken}
-      backgroundColor={hideBorder ? "transparent" : undefined}
+      data-mpo-schema-form-card=""
+      data-mpo-schema-form-borderless={hideBorder ? "" : undefined}
+      {...(hideBorder ? { borderWidth: 0, backgroundColor: "transparent" } : {})}
     >
       {(section.label || section.description) && (
-        <Card.Header {...knobProps.panelPadding}>
+        <Card.Header>
           {section.label ? (
             <Heading
               label={section.label}
@@ -380,7 +380,6 @@ function SchemaFormSectionCard({ section, headingLevel, renderField }: SchemaFor
       {/* Kept mounted while collapsed (display none) so field state and the
           collapse target survive toggles — matches desk's CSS hide. */}
       <Card.Footer
-        {...knobProps.panelPadding}
         display={effectiveCollapsed ? "none" : undefined}
         aria-hidden={effectiveCollapsed || undefined}
       >

package/src/shared/devWarn.ts

@@ -0,0 +1,42 @@
+/**
+ * Package-local DEV guardrails for frappe-ui, warned under a `[frappe-ui]`
+ * prefix.
+ *
+ * The canonical catalog is `devWarn` in `@multiplatform.one/theme`, whose
+ * `DevWarnCode` union is closed over design-guardrail codes. Live-data
+ * misconfiguration is a frappe-ui concern rather than a design-law one, so
+ * it warns from here, the same way AsyncBoundary keeps its own.
+ *
+ * No-ops when `NODE_ENV === "production"`, and each key warns once per
+ * process so a re-render never repeats a line.
+ */
+
+export type FrappeDevWarnCode = "kpi-datasource-without-baseurl";
+
+export type FrappeDevWarnDetail = {
+  component?: string;
+  id?: string;
+  doctype?: string;
+  suggest?: string;
+};
+
+const seen = new Set<string>();
+
+export function frappeDevWarn(code: FrappeDevWarnCode, detail: FrappeDevWarnDetail = {}): void {
+  if (process.env.NODE_ENV === "production") return;
+  const key = [code, detail.component ?? "", detail.id ?? "", detail.doctype ?? ""].join(":");
+  if (seen.has(key)) return;
+  seen.add(key);
+  const bits = [
+    detail.component ? `component=${detail.component}` : undefined,
+    detail.id ? `id=${detail.id}` : undefined,
+    detail.doctype ? `doctype=${detail.doctype}` : undefined,
+    detail.suggest ? `suggest=${detail.suggest}` : undefined,
+  ].filter(Boolean);
+  console.warn(`[frappe-ui] ${code}${bits.length ? ` (${bits.join(", ")})` : ""}`);
+}
+
+/** @internal test helper */
+export function __resetFrappeDevWarnSeen(): void {
+  seen.clear();
+}

package/src/useFrappeAggregate.ts

@@ -41,7 +41,10 @@ export type FrappeAggregateOperation = "count" | "sum" | "avg" | "min" | "max";
 
 /** Connection shape shared with the other frappe-ui widgets. */
 export interface FrappeAggregateConnection {
-  baseURL: string;
+  /** Required unless `fixtures` is set (see FrappeConfig.baseURL). */
+  baseURL?: string;
+  /** False keeps HTTP reads without realtime subscriptions. */
+  realtime?: boolean;
   socketPort?: number;
   /** Same-origin socket override (see FrappeConfig.socketBaseURL). */
   socketBaseURL?: string;
@@ -95,18 +98,18 @@ const DEFAULT_DEBOUNCE_MS = 300;
 // One REST client per connection — widgets sharing a bench share it.
 const dbCache = new Map<string, DbModule>();
 
-function getDb(connection: FrappeAggregateConnection): DbModule {
-  const key = `${connection.baseURL}:${connection.auth?.token ?? ""}:${connection.auth?.type ?? ""}`;
+function getDb(baseURL: string, auth: FrappeAggregateConnection["auth"]): DbModule {
+  const key = `${baseURL}:${auth?.token ?? ""}:${auth?.type ?? ""}`;
   let db = dbCache.get(key);
   if (!db) {
-    const authConfig: AuthConfig | undefined = connection.auth
+    const authConfig: AuthConfig | undefined = auth
       ? {
-          useToken: connection.auth.useToken,
-          token: connection.auth.token,
-          type: connection.auth.type as AuthConfig["type"],
+          useToken: auth.useToken,
+          token: auth.token,
+          type: auth.type as AuthConfig["type"],
         }
       : undefined;
-    db = new DbModule(new HttpClient(connection.baseURL, authConfig));
+    db = new DbModule(new HttpClient(baseURL, authConfig));
     dbCache.set(key, db);
   }
   return db;
@@ -269,9 +272,14 @@ export function useFrappeAggregate(
     if (!conn || !currentSpec.doctype) return;
     const seq = ++fetchSeq.current;
     try {
-      const result = conn.fixtures
-        ? await fetchFixtureAggregate(conn.fixtures, currentSpec)
-        : await fetchLiveAggregate(getDb(conn), currentSpec);
+      let result: AggregateData;
+      if (conn.fixtures) {
+        result = await fetchFixtureAggregate(conn.fixtures, currentSpec);
+      } else if (conn.baseURL) {
+        result = await fetchLiveAggregate(getDb(conn.baseURL, conn.auth), currentSpec);
+      } else {
+        throw new Error("useFrappeAggregate requires a connection with baseURL or fixtures");
+      }
       if (seq !== fetchSeq.current) return; // stale response — a newer fetch won
       setData(result);
       setError(undefined);

package/src/useFrappeFacets.ts

@@ -78,7 +78,8 @@ export interface FrappeFacetState {
 
 /** Connection shape shared with the other frappe-ui widgets. */
 export interface FrappeFacetsConnection {
-  baseURL: string;
+  /** Required unless `fixtures` is set (see FrappeConfig.baseURL). */
+  baseURL?: string;
   auth?: { useToken?: boolean; token?: string | (() => string | Promise<string>); type?: string };
   fixtures?: FixtureProvider;
 }
@@ -169,18 +170,18 @@ export function scrubUserFacetRows(
 // One RPC client per connection — facets sharing a bench share it.
 const callCache = new Map<string, CallModule>();
 
-function getCall(connection: FrappeFacetsConnection): CallModule {
-  const key = `${connection.baseURL}:${connection.auth?.token ?? ""}:${connection.auth?.type ?? ""}`;
+function getCall(baseURL: string, auth: FrappeFacetsConnection["auth"]): CallModule {
+  const key = `${baseURL}:${auth?.token ?? ""}:${auth?.type ?? ""}`;
   let call = callCache.get(key);
   if (!call) {
-    const authConfig: AuthConfig | undefined = connection.auth
+    const authConfig: AuthConfig | undefined = auth
       ? {
-          useToken: connection.auth.useToken,
-          token: connection.auth.token,
-          type: connection.auth.type as AuthConfig["type"],
+          useToken: auth.useToken,
+          token: auth.token,
+          type: auth.type as AuthConfig["type"],
         }
       : undefined;
-    call = new CallModule(new HttpClient(connection.baseURL, authConfig));
+    call = new CallModule(new HttpClient(baseURL, authConfig));
     callCache.set(key, call);
   }
   return call;
@@ -439,7 +440,9 @@ export function useFrappeFacets(
   useEffect(() => {
     if (!enabled) return;
     const conn = connectionRef.current;
-    if (!conn) return;
+    // Neither a corpus nor a bench can answer, so stay idle instead of
+    // entering a loading state nothing will ever resolve.
+    if (!conn || (!conn.fixtures && !conn.baseURL)) return;
     const seq = ++fetchSeq.current;
     const activeFilters = JSON.parse(filtersKey) as FrappeFacetFilters;
 
@@ -525,7 +528,11 @@ export function useFrappeFacets(
       return;
     }
 
-    const call = getCall(conn);
+    // Narrowing only: the guard at the top of the effect already returned
+    // when neither a corpus nor a baseURL is configured.
+    if (!conn.baseURL) return;
+
+    const call = getCall(conn.baseURL, conn.auth);
     fetchGroupByCount(call, doctype, filtersExcludingField(activeFilters, "_assign"), "assigned_to")
       .then((rows) => done("assigned", rows))
       .catch((error) => fail("assigned", error));