@multiplatform.one/frappe-ui 7.7.6 → 7.10.0

package/src/FrappeKPICard.spec.tsx

@@ -0,0 +1,153 @@
+/**
+ * MPO-237: a `dataSource` with no `baseURL` in scope is a misconfiguration,
+ * not static mode. The card asked for a computed figure and there is nowhere
+ * to compute it, so `config.value` must never be painted as the KPI: a wrong
+ * number presented confidently is worse than a visible gap, because nothing
+ * downstream can tell it was never computed.
+ *
+ * Static mode (no `dataSource` at all) is the documented, intended path and
+ * is asserted here too, so the fix cannot over-correct into it.
+ */
+
+import { InMemoryFixtureProvider } from "@multiplatform.one/frappe";
+import { renderWithProviders } from "@multiplatform.one/test-utils";
+import { cleanup, screen, waitFor } from "@testing-library/react";
+import i18next from "i18next";
+import { initReactI18next } from "react-i18next";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { FrappeKPICard } from "./FrappeKPICard";
+import { FrappeProvider } from "./FrappeProvider";
+import { __resetFrappeDevWarnSeen } from "./shared/devWarn";
+
+beforeAll(async () => {
+  await i18next.use(initReactI18next).init({
+    lng: "en",
+    interpolation: { escapeValue: false },
+    resources: { en: { translation: {} } },
+  });
+});
+
+beforeEach(() => {
+  __resetFrappeDevWarnSeen();
+});
+
+afterEach(() => {
+  cleanup();
+  vi.restoreAllMocks();
+});
+
+const config = { id: "open-todos", title: "Open ToDos", value: 999, format: "number" as const };
+
+describe("FrappeKPICard with a dataSource and no baseURL (MPO-237)", () => {
+  it("does not render config.value as though it were the computed figure", () => {
+    vi.spyOn(console, "warn").mockImplementation(() => {});
+    renderWithProviders(<FrappeKPICard config={config} dataSource={{ doctype: "ToDo" }} />);
+
+    expect(screen.queryByText("999")).toBeNull();
+    expect(screen.getByText("Open ToDos is not configured")).toBeInTheDocument();
+    expect(screen.getByText(/no Frappe baseURL is in scope/)).toBeInTheDocument();
+  });
+
+  it("logs a development warning naming the missing baseURL", () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    renderWithProviders(<FrappeKPICard config={config} dataSource={{ doctype: "ToDo" }} />);
+
+    const line = warn.mock.calls.map((call) => String(call[0])).join("\n");
+    expect(line).toContain("[frappe-ui] kpi-datasource-without-baseurl");
+    expect(line).toContain("baseURL");
+    expect(line).toContain("component=FrappeKPICard");
+    expect(line).toContain("id=open-todos");
+    expect(line).toContain("doctype=ToDo");
+  });
+
+  it("warns once per card, not once per render", () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const { rerender } = renderWithProviders(
+      <FrappeKPICard config={config} dataSource={{ doctype: "ToDo" }} />,
+    );
+    rerender(<FrappeKPICard config={{ ...config }} dataSource={{ doctype: "ToDo" }} />);
+    rerender(<FrappeKPICard config={{ ...config }} dataSource={{ doctype: "ToDo" }} />);
+
+    const lines = warn.mock.calls.filter((call) =>
+      String(call[0]).includes("kpi-datasource-without-baseurl"),
+    );
+    expect(lines).toHaveLength(1);
+  });
+
+  it("stays silent in production", () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const previous = process.env.NODE_ENV;
+    process.env.NODE_ENV = "production";
+    try {
+      renderWithProviders(<FrappeKPICard config={config} dataSource={{ doctype: "ToDo" }} />);
+    } finally {
+      process.env.NODE_ENV = previous;
+    }
+
+    expect(
+      warn.mock.calls.filter((call) => String(call[0]).includes("kpi-datasource-without-baseurl")),
+    ).toHaveLength(0);
+  });
+});
+
+describe("FrappeKPICard configured paths stay untouched (MPO-237)", () => {
+  it("renders config.value with no warning when no dataSource is set", () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    renderWithProviders(<FrappeKPICard config={config} />);
+
+    expect(screen.getByText("999")).toBeInTheDocument();
+    expect(
+      warn.mock.calls.filter((call) => String(call[0]).includes("kpi-datasource-without-baseurl")),
+    ).toHaveLength(0);
+  });
+
+  it("computes the figure, and does not warn, when the provider supplies a baseURL", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    renderWithProviders(
+      <FrappeProvider
+        baseURL="http://test"
+        fixtures={
+          new InMemoryFixtureProvider({
+            ToDo: [
+              { name: "TD-1", doctype: "ToDo", status: "Open" },
+              { name: "TD-2", doctype: "ToDo", status: "Open" },
+            ],
+          })
+        }
+      >
+        <FrappeKPICard config={config} dataSource={{ doctype: "ToDo" }} />
+      </FrappeProvider>,
+    );
+
+    await waitFor(() => expect(screen.getByText("2")).toBeInTheDocument());
+    expect(screen.queryByText("999")).toBeNull();
+    expect(
+      warn.mock.calls.filter((call) => String(call[0]).includes("kpi-datasource-without-baseurl")),
+    ).toHaveLength(0);
+  });
+
+  it("treats a fixture corpus as the data source when no baseURL is set (MPO-228)", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    renderWithProviders(
+      <FrappeProvider
+        fixtures={
+          new InMemoryFixtureProvider({
+            ToDo: [
+              { name: "TD-1", doctype: "ToDo", status: "Open" },
+              { name: "TD-2", doctype: "ToDo", status: "Open" },
+            ],
+          })
+        }
+      >
+        <FrappeKPICard config={config} dataSource={{ doctype: "ToDo" }} />
+      </FrappeProvider>,
+    );
+
+    await waitFor(() => expect(screen.getByText("2")).toBeInTheDocument());
+    expect(screen.queryByText("999")).toBeNull();
+    expect(screen.queryByText("Open ToDos is not configured")).toBeNull();
+    expect(
+      warn.mock.calls.filter((call) => String(call[0]).includes("kpi-datasource-without-baseurl")),
+    ).toHaveLength(0);
+  });
+});

package/src/FrappeKPICard.tsx

@@ -11,6 +11,14 @@
  * (permission failures called out explicitly), a subtle stale affordance
  * (the card dims while a post-event refetch is in flight), and "—" when the
  * aggregate has no result (e.g. avg over an empty set).
+ *
+ * A `dataSource` with no data source in scope — no `baseURL` from the prop
+ * or a FrappeProvider, and no fixture corpus either — is a misconfiguration,
+ * not static mode: the caller asked for a computed figure and there is
+ * nowhere to compute it. The card renders the not-configured surface and
+ * warns in dev. It never falls back to `config.value`, which would present
+ * an uncomputed number as the KPI. A fixture corpus answers every read
+ * locally, so it stands in for a baseURL (MPO-228).
  */
 import {
   AsyncBoundary,
@@ -19,10 +27,11 @@ import {
   Skeleton,
   type KPICardConfig,
 } from "@multiplatform.one/components";
-import React, { useMemo } from "react";
+import React, { useEffect, useMemo } from "react";
 import { useTranslation } from "react-i18next";
 import { type YStackProps } from "tamagui";
 import { useFrappeConfig } from "./FrappeProvider";
+import { frappeDevWarn } from "./shared/devWarn";
 import {
   useFrappeAggregate,
   type FrappeAggregateConnection,
@@ -44,11 +53,16 @@ export interface FrappeKPIDataSource {
 export interface FrappeKPICardProps extends Omit<YStackProps, "children"> {
   /**
    * KPI chrome (title, format, trend, icon…). In live mode `value` is
-   * overridden by the aggregate; in static mode it renders as-is.
+   * overridden by the aggregate; in static mode it renders as-is. With a
+   * `dataSource` and no `baseURL`, `value` is not rendered at all.
    */
   config: KPICardConfig;
   /** When set, the card's value goes live against this doctype. */
   dataSource?: FrappeKPIDataSource;
+  /**
+   * Falls back to the FrappeProvider's. Required whenever `dataSource` is
+   * set, unless the provider carries a fixture corpus.
+   */
   baseURL?: string;
   auth?: { useToken?: boolean; token?: string; type?: string };
   syncOptions?: unknown;
@@ -78,8 +92,9 @@ export function FrappeKPICard({
   const { t } = useTranslation();
 
   const finalBaseURL = baseURL ?? providerConfig?.baseURL;
+  const fixtures = providerConfig?.fixtures;
   const connection: FrappeAggregateConnection | undefined =
-    dataSource && finalBaseURL
+    dataSource && (finalBaseURL || fixtures)
       ? {
           baseURL: finalBaseURL,
           socketPort: providerConfig?.socketPort,
@@ -88,10 +103,22 @@ export function FrappeKPICard({
           auth: auth ?? providerConfig?.auth,
           syncOptions: syncOptions ?? providerConfig?.syncOptions,
           realtime: providerConfig?.realtime,
-          fixtures: providerConfig?.fixtures,
+          fixtures,
         }
       : undefined;
 
+  const missingConnection = !!dataSource && !connection;
+  const doctype = dataSource?.doctype;
+  useEffect(() => {
+    if (!missingConnection) return;
+    frappeDevWarn("kpi-datasource-without-baseurl", {
+      component: "FrappeKPICard",
+      id: config.id,
+      doctype,
+      suggest: "set baseURL on FrappeKPICard or on the FrappeProvider above it",
+    });
+  }, [missingConnection, config.id, doctype]);
+
   const { value, isLoading, isStale, error, isPermissionError } = useFrappeAggregate(connection, {
     doctype: dataSource?.doctype ?? "",
     aggregate: dataSource?.aggregate,
@@ -106,11 +133,30 @@ export function FrappeKPICard({
     return { ...config, value: value ?? "—" };
   }, [config, dataSource, value]);
 
-  // Static passthrough — same component object semantics as before.
-  if (!dataSource || !connection) {
+  // Static passthrough. The caller supplied the figure and asked for no
+  // computation.
+  if (!dataSource) {
     return <KPICard config={config} {...stackProps} />;
   }
 
+  // A requested figure with nowhere to compute it. `config.value` is the
+  // caller's placeholder, so painting it here would publish a number nothing
+  // downstream could tell was never computed.
+  if (!connection) {
+    return (
+      <AsyncBoundary
+        compact
+        error
+        errorTitle={t("{{title}} is not configured", { title: config.title })}
+        errorDescription={t(
+          "This card reads {{doctype}} live, but no Frappe baseURL is in scope, so the figure was never computed.",
+          { doctype: dataSource.doctype },
+        )}
+        {...stackProps}
+      />
+    );
+  }
+
   if (isLoading) {
     return <KPICardSkeleton {...stackProps} />;
   }

package/src/FrappeKanban.tsx

@@ -1,4 +1,3 @@
-import { useFrappeCollection, useLiveQuery } from "@multiplatform.one/frappe";
 import {
   Kanban,
   componentColors,
@@ -15,6 +14,7 @@ import { useResolvedKnobs } from "@multiplatform.one/theme";
 import { FrappeConnectionIndicator } from "./FrappeConnectionIndicator";
 import { useFrappeConfig } from "./FrappeProvider";
 import { describeSyncError } from "./syncError";
+import { useFrappeRows } from "./useFrappeRows";
 
 /**
  * Configuration for a single Kanban column.
@@ -91,16 +91,15 @@ export function FrappeKanban<TDoc extends { name: string; doctype: string }>({
   const { knobProps } = useResolvedKnobs();
   const { t } = useTranslation();
   const [actionError, setActionError] = useState<Error | null>(null);
-  // Honest error state: the collection swallows failed subscription fetches
-  // (board would just look empty) — onSyncError reports them here.
-  const [syncError, setSyncError] = useState<unknown>(null);
 
   const finalBaseURL = baseURL ?? config?.baseURL;
   const finalAuth = auth ?? config?.auth;
   const finalSyncOptions = syncOptions ?? config?.syncOptions;
 
-  if (!finalBaseURL) {
-    throw new Error("FrappeKanban requires baseURL prop or FrappeProvider with baseURL");
+  if (!finalBaseURL && !config?.fixtures) {
+    throw new Error(
+      "FrappeKanban requires baseURL prop or FrappeProvider with baseURL or fixtures",
+    );
   }
 
   // Ensure required fields are fetched
@@ -139,17 +138,25 @@ export function FrappeKanban<TDoc extends { name: string; doctype: string }>({
     ],
   );
 
-  const collection = useFrappeCollection<TDoc>(connectionConfig, doctype, {
+  // The shared doctype read (MPO-251). `mapError` keeps this board's own
+  // error copy (describeSyncError) rather than the hook's default shape, and
+  // `limit: null` keeps the bench's own page length.
+  const mapSyncError = useCallback(
+    (err: unknown) => new Error(describeSyncError(err, doctype, t)),
+    [doctype, t],
+  );
+  const {
+    rows: cards,
+    isQueryLoading: isLoading,
+    isError,
+    syncError,
+    collection,
+  } = useFrappeRows<TDoc>(connectionConfig, doctype, {
     fields: effectiveFields,
     filters,
-    onSyncError: setSyncError,
+    limit: null,
+    mapError: mapSyncError,
   });
-  const {
-    data: rawData,
-    isLoading,
-    isError,
-  } = useLiveQuery((q) => (collection ? q.from({ _list: collection }) : null), [collection]);
-  const cards = useMemo(() => (rawData as TDoc[] | undefined) ?? [], [rawData]);
 
   // Group cards by status into generic KanbanColumn format.
   // Cards with an unknown status land in an "Unassigned" column so they
@@ -286,9 +293,9 @@ export function FrappeKanban<TDoc extends { name: string; doctype: string }>({
   // Real subscription failure (permission-error, network, bad doctype)
   // reported by the collection via onSyncError — honest error UI instead of
   // an empty board. The `error` render prop stays the consumer override.
-  const boardError = syncError != null ? describeSyncError(syncError, doctype, t) : null;
-  if (boardError && error) {
-    return <>{error(new Error(boardError))}</>;
+  const boardError = syncError ? syncError.message : null;
+  if (syncError && error) {
+    return <>{error(syncError)}</>;
   }
 
   // Opt-in query error panel via `error` prop. Empty/fixture-less collections

package/src/FrappeLikedBy.tsx

@@ -168,7 +168,7 @@ function FrappeLikedByBody({
 
   const http = useMemo(
     () =>
-      config && !config.fixtures
+      config?.baseURL && !config.fixtures
         ? new HttpClient(
             config.baseURL,
             config.auth as Parameters<typeof HttpClient.prototype.updateAuth>[0],

package/src/FrappeList.tsx

@@ -51,8 +51,9 @@ export function FrappeList<TDoc extends { name: string; doctype: string }>({
   const finalAuth = auth ?? config?.auth;
   const finalSyncOptions = syncOptions ?? config?.syncOptions;
 
-  if (!finalBaseURL) {
-    throw new Error("FrappeList requires baseURL prop or FrappeProvider with baseURL");
+  // Fixtures answer every read locally, so they stand in for a baseURL.
+  if (!finalBaseURL && !config?.fixtures) {
+    throw new Error("FrappeList requires baseURL prop or FrappeProvider with baseURL or fixtures");
   }
 
   const connectionConfig = useMemo(

package/src/FrappeListView.tsx

@@ -298,7 +298,7 @@ export function FrappeListView<TDoc extends { name: string; doctype: string }>({
               {title}
             </Text>
             {subtitleParts.length > 0 && (
-              <Text {...knobProps.body} color={componentColors.text.muted} numberOfLines={1}>
+              <Text {...knobProps.body} color={knobProps.textAccentColor} numberOfLines={1}>
                 {subtitleParts.map((part, index) => (
                   <React.Fragment key={index}>
                     {index > 0 ? " · " : null}
@@ -432,7 +432,7 @@ export function FrappeListView<TDoc extends { name: string; doctype: string }>({
         {...stackProps}
       >
         <Spinner size="large" />
-        <Text {...knobProps.body} color={componentColors.text.muted} marginTop="$2">
+        <Text {...knobProps.body} color={knobProps.textAccentColor} marginTop="$2">
           {t("Loading {{doctype}} schema...", { doctype })}
         </Text>
       </YStack>
@@ -517,17 +517,17 @@ export function FrappeListView<TDoc extends { name: string; doctype: string }>({
         {...knobProps.panelPadding}
         {...knobProps.gap}
       >
-        <Text {...knobProps.label} color={componentColors.text.muted}>
+        <Text {...knobProps.label} color={knobProps.textAccentColor}>
           {t("Filters")}
         </Text>
         {standardFilterFields.length > 0 && (
           <YStack {...knobProps.gap}>
             {standardFilterFields.map((field) => (
               <YStack key={field.fieldname} {...knobProps.gap}>
-                <Text {...knobProps.label} color={componentColors.text.muted}>
+                <Text {...knobProps.label} color={knobProps.textAccentColor}>
                   {field.label || field.fieldname}
                 </Text>
-                <Text {...knobProps.body} color={componentColors.text.muted}>
+                <Text {...knobProps.body} color={knobProps.textAccentColor}>
                   {field.fieldtype === "Select" ? field.options || "—" : "—"}
                 </Text>
               </YStack>
@@ -536,7 +536,7 @@ export function FrappeListView<TDoc extends { name: string; doctype: string }>({
         )}
         {savedFiltersHook.filters.length > 0 && (
           <YStack {...knobProps.gap}>
-            <Text {...knobProps.label} color={componentColors.text.muted}>
+            <Text {...knobProps.label} color={knobProps.textAccentColor}>
               {t("Saved Filters")}
             </Text>
             <SavedFilterDropdown

package/src/FrappeProvider.fixturesOnly.spec.tsx

@@ -0,0 +1,129 @@
+/**
+ * A fixture corpus satisfies the connection requirement on its own (MPO-228).
+ *
+ * `createApp({ frappe: { fixtures } })` mounts a FrappeProvider with NO
+ * baseURL, so the collection-backed components must read the corpus instead
+ * of demanding a bench URL. These specs pin that: rows render, doctype meta
+ * comes from the corpus, and `fetch` is never called — a fixtures-only app
+ * runs with no server. The old error still fires when neither is configured.
+ */
+
+import { InMemoryFixtureProvider } from "@multiplatform.one/frappe";
+import type { DataTableColumn } from "@multiplatform.one/table";
+import { renderWithProviders } from "@multiplatform.one/test-utils";
+import { cleanup, screen } from "@testing-library/react";
+import i18next from "i18next";
+import { initReactI18next } from "react-i18next";
+import { Text } from "tamagui";
+import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
+import { FrappeList } from "./FrappeList";
+import { FrappeProvider } from "./FrappeProvider";
+import { FrappeTable } from "./FrappeTable";
+
+beforeAll(async () => {
+  await i18next.use(initReactI18next).init({
+    lng: "en",
+    interpolation: { escapeValue: false },
+    resources: { en: { translation: {} } },
+  });
+});
+
+afterEach(() => {
+  cleanup();
+  vi.restoreAllMocks();
+});
+
+interface Customer {
+  name: string;
+  doctype: string;
+  customer_name: string;
+  status: string;
+}
+
+const customers: Customer[] = [
+  { name: "CUST-001", doctype: "Customer", customer_name: "Acme Corp", status: "Active" },
+  { name: "CUST-002", doctype: "Customer", customer_name: "Globex", status: "Lead" },
+];
+
+const columns: DataTableColumn<Partial<Customer>>[] = [
+  { id: "name", accessorKey: "name", header: "ID" },
+  { id: "customer_name", accessorKey: "customer_name", header: "Customer Name" },
+];
+
+/**
+ * Corpus carrying both documents and the getdoctype-shaped meta doc, so the
+ * table's `useDocTypeMeta` call is answered locally too (no filterableFields
+ * prop, which would skip that path).
+ */
+function fixtureCorpus() {
+  return new InMemoryFixtureProvider({
+    DocType: [
+      {
+        name: "Customer",
+        doctype: "DocType",
+        module: "Selling",
+        fields: [
+          { fieldname: "customer_name", fieldtype: "Data", label: "Customer Name" },
+          { fieldname: "status", fieldtype: "Select", label: "Status", options: "Active\nLead" },
+        ],
+      },
+    ],
+    Customer: customers,
+  });
+}
+
+/** Fails the test if anything dials the network. */
+function forbidFetch() {
+  return vi.spyOn(globalThis, "fetch").mockImplementation((input) => {
+    throw new Error(`unexpected network request: ${String(input)}`);
+  });
+}
+
+describe("FrappeProvider with fixtures and no baseURL", () => {
+  it("renders a FrappeTable off the corpus without touching the network", async () => {
+    const fetchSpy = forbidFetch();
+    renderWithProviders(
+      <FrappeProvider fixtures={fixtureCorpus()}>
+        <FrappeTable<Customer>
+          doctype="Customer"
+          columns={columns}
+          layout="table"
+          enablePagination={false}
+        />
+      </FrappeProvider>,
+    );
+
+    expect(await screen.findByText("Acme Corp")).toBeTruthy();
+    expect(await screen.findByText("Globex")).toBeTruthy();
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+
+  it("renders a FrappeList off the corpus without touching the network", async () => {
+    const fetchSpy = forbidFetch();
+    renderWithProviders(
+      <FrappeProvider fixtures={fixtureCorpus()}>
+        <FrappeList<Customer>
+          doctype="Customer"
+          fields={["name", "customer_name"]}
+          renderItem={(item) => <Text>{item.customer_name}</Text>}
+        />
+      </FrappeProvider>,
+    );
+
+    expect(await screen.findByText("Acme Corp")).toBeTruthy();
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+});
+
+describe("FrappeProvider with neither baseURL nor fixtures", () => {
+  it("still names what is missing", () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    expect(() =>
+      renderWithProviders(
+        <FrappeProvider>
+          <FrappeTable<Customer> doctype="Customer" columns={columns} layout="table" />
+        </FrappeProvider>,
+      ),
+    ).toThrow(/baseURL or fixtures/);
+  });
+});

package/src/FrappeProvider.tsx

@@ -7,8 +7,12 @@ import React, { createContext, use, useContext } from "react";
  * @category Types
  */
 export interface FrappeConfig {
-  /** The base URL of the Frappe server */
-  baseURL: string;
+  /**
+   * The base URL of the Frappe server. Required unless `fixtures` is set:
+   * a fixture corpus answers every read locally, so a fixtures-only app has
+   * no bench to name and nothing dials one.
+   */
+  baseURL?: string;
   /** False uses HTTP collections without a realtime transport. Defaults to true. */
   realtime?: boolean;
   /**
@@ -52,7 +56,10 @@ export interface FrappeConfig {
    * can't forward WebSocket upgrades.
    */
   socketOptions?: UseFrappeCollectionConfig["socketOptions"];
-  /** Fixture provider for testing */
+  /**
+   * Fixture corpus every read and write is served from. Set it without a
+   * `baseURL` to run the whole app off fixtures with no server.
+   */
   fixtures?: FixtureProvider;
 }
 
@@ -66,8 +73,8 @@ const FrappeContext = createContext<FrappeConfig | undefined>(undefined);
 export interface FrappeProviderProps {
   /** Child components */
   children: React.ReactNode;
-  /** The base URL of the Frappe server */
-  baseURL: string;
+  /** The base URL of the Frappe server. Required unless `fixtures` is set. */
+  baseURL?: string;
   /** False uses HTTP collections without a realtime transport. Defaults to true. */
   realtime?: boolean;
   /** Override port for Socket.IO realtime connection (e.g. 9000 in dev). */
@@ -89,7 +96,10 @@ export interface FrappeProviderProps {
   syncOptions?: any;
   /** Extra Socket.IO client options for the realtime connection. */
   socketOptions?: UseFrappeCollectionConfig["socketOptions"];
-  /** Fixture provider for testing */
+  /**
+   * Fixture corpus every read and write is served from. Set it without a
+   * `baseURL` to run the whole app off fixtures with no server.
+   */
   fixtures?: FixtureProvider;
 }
 

package/src/FrappeReportBuilder.tsx

@@ -125,8 +125,10 @@ export function FrappeReportBuilder({
   const finalAuth = auth ?? config?.auth;
   const finalSyncOptions = syncOptions ?? config?.syncOptions;
 
-  if (!finalBaseURL) {
-    throw new Error("FrappeReportBuilder requires baseURL prop or FrappeProvider with baseURL");
+  if (!finalBaseURL && !config?.fixtures) {
+    throw new Error(
+      "FrappeReportBuilder requires baseURL prop or FrappeProvider with baseURL or fixtures",
+    );
   }
 
   const connectionConfig = {