@multiplatform.one/frappe 6.0.0

package/src/doctype.ts

@@ -0,0 +1,828 @@
+/**
+ * DocType metadata hooks for @multiplatform.one/frappe
+ *
+ * Provides hooks for fetching and caching DocType schemas, searching linked
+ * documents, and searching across DocTypes for navigation (Awesomebar).
+ */
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { HttpClient } from "./core/http";
+import type { AuthConfig } from "./core/types";
+import type { FrappeConnectionConfig } from "./pacer";
+
+// ---------------------------------------------------------------------------
+// Type Definitions
+// ---------------------------------------------------------------------------
+
+/** All Frappe field type strings */
+export type FrappeFieldType =
+  | "Autocomplete"
+  | "Attach"
+  | "Attach Image"
+  | "Barcode"
+  | "Check"
+  | "Code"
+  | "Color"
+  | "Column Break"
+  | "Currency"
+  | "Data"
+  | "Date"
+  | "Datetime"
+  | "Duration"
+  | "Dynamic Link"
+  | "Float"
+  | "Geolocation"
+  | "HTML"
+  | "HTML Editor"
+  | "Heading"
+  | "Icon"
+  | "Image"
+  | "Int"
+  | "JSON"
+  | "Link"
+  | "Long Text"
+  | "Markdown Editor"
+  | "Password"
+  | "Percent"
+  | "Phone"
+  | "Rating"
+  | "Read Only"
+  | "Section Break"
+  | "Select"
+  | "Signature"
+  | "Small Text"
+  | "Tab Break"
+  | "Table"
+  | "Table MultiSelect"
+  | "Text"
+  | "Text Editor"
+  | "Time";
+
+/** Normalized DocType field descriptor */
+export interface DocTypeField {
+  fieldname: string;
+  fieldtype: FrappeFieldType;
+  label?: string;
+  /** Link target DocType, Select options, or Table child DocType */
+  options?: string;
+  reqd?: boolean;
+  unique?: boolean;
+  default?: string;
+  /** Conditional visibility expression (e.g. `eval:doc.status=="Active"`) */
+  depends_on?: string;
+  read_only?: boolean;
+  hidden?: boolean;
+  in_list_view?: boolean;
+  in_standard_filter?: boolean;
+  description?: string;
+  length?: number;
+  precision?: number;
+  /** For Link fields: comma-separated search fields */
+  search_fields?: string;
+  /** For Section Break fields: whether the section is collapsible */
+  collapsible?: boolean;
+}
+
+/** DocType permission entry */
+export interface DocTypePermission {
+  role: string;
+  read?: boolean;
+  write?: boolean;
+  create?: boolean;
+  delete?: boolean;
+  submit?: boolean;
+  cancel?: boolean;
+  amend?: boolean;
+}
+
+/** A column in a form section, containing an ordered list of fields */
+export interface FormColumn {
+  fields: DocTypeField[];
+}
+
+/** A section in the form layout, containing one or more columns */
+export interface FormSection {
+  label?: string;
+  collapsible?: boolean;
+  /** Whether this section represents a Tab Break */
+  tab?: boolean;
+  columns: FormColumn[];
+}
+
+/** Normalized DocType metadata */
+export interface DocTypeMeta {
+  name: string;
+  module: string;
+  title_field?: string;
+  image_field?: string;
+  is_tree?: boolean;
+  sort_field: string;
+  sort_order: string;
+  /** Flat list of all fields (ordered by field_order or position) */
+  fields: DocTypeField[];
+  /** Parsed layout tree from Section Break / Column Break / Tab Break fields */
+  sections: FormSection[];
+  permissions: DocTypePermission[];
+}
+
+/** A search result for a Link field */
+export interface LinkSearchResult {
+  /** The document name (ID) */
+  value: string;
+  /** The display label (title_field value, or name) */
+  label: string;
+  /** Optional description from additional search fields */
+  description?: string;
+}
+
+/** Options for the `useLinkSearch` hook */
+export interface LinkSearchOptions {
+  /** Search query text */
+  query?: string;
+  /** Fields to search across (defaults to title_field + "name") */
+  searchFields?: string[];
+  /** Additional Frappe filters */
+  filters?: Record<string, unknown> | Array<[string, string, unknown]>;
+  /** Maximum results (default 20) */
+  limit?: number;
+}
+
+/** A navigation suggestion from DocType search */
+export interface DocTypeSearchResult {
+  /** Display label (e.g. "Pokemon List", "New Pokemon") */
+  label: string;
+  /** The DocType name */
+  doctype: string;
+  /** Suggestion type */
+  type: "list" | "report" | "new";
+}
+
+// ---------------------------------------------------------------------------
+// Module-level caches
+// ---------------------------------------------------------------------------
+
+/** Cache for parsed DocType metadata, keyed by "{baseURL}:{doctype}" */
+const metaCache = new Map<string, DocTypeMeta>();
+
+/** Cache for the full list of DocTypes, keyed by baseURL */
+const docTypeListCache = new Map<string, DocTypeListItem[]>();
+
+interface DocTypeListItem {
+  name: string;
+  module: string;
+  title?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Raw API response types (internal)
+// ---------------------------------------------------------------------------
+
+interface RawDocTypeResponse {
+  name: string;
+  module: string;
+  title_field?: string;
+  image_field?: string;
+  is_tree?: number;
+  sort_field?: string;
+  sort_order?: string;
+  field_order?: string[] | string;
+  fields: RawFieldResponse[];
+  permissions?: RawPermissionResponse[];
+}
+
+interface RawFieldResponse {
+  fieldname: string;
+  fieldtype: string;
+  label?: string;
+  options?: string;
+  reqd?: number;
+  unique?: number;
+  default?: string;
+  depends_on?: string;
+  read_only?: number;
+  hidden?: number;
+  in_list_view?: number;
+  in_standard_filter?: number;
+  description?: string;
+  length?: number;
+  precision?: number;
+  search_fields?: string;
+  collapsible?: number;
+}
+
+interface RawPermissionResponse {
+  role: string;
+  read?: number;
+  write?: number;
+  create?: number;
+  delete?: number;
+  submit?: number;
+  cancel?: number;
+  amend?: number;
+}
+
+// ---------------------------------------------------------------------------
+// Utility: parseDependsOn
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse a Frappe `depends_on` expression into an evaluable function.
+ *
+ * Handles expressions like:
+ * - `eval:doc.status=="Active"` — JS expression with `doc` bound
+ * - `doc.field_name` — truthy check on a field value
+ * - `eval:doc.field1 && doc.field2` — compound boolean
+ *
+ * @param expression - The depends_on expression string, or undefined
+ * @returns A function that evaluates the expression given a document object
+ */
+export function parseDependsOn(expression?: string): (doc: Record<string, unknown>) => boolean {
+  if (!expression) return () => true;
+
+  const trimmed = expression.trim();
+
+  if (trimmed.startsWith("eval:")) {
+    const code = trimmed.slice(5).trim();
+    try {
+      const fn = new Function("doc", `return !!(${code})`) as (
+        doc: Record<string, unknown>,
+      ) => boolean;
+      return (doc: Record<string, unknown>) => {
+        try {
+          return fn(doc);
+        } catch {
+          return false;
+        }
+      };
+    } catch {
+      return () => false;
+    }
+  }
+
+  // Expression containing "doc." — evaluate as JS (e.g. "doc.status")
+  if (trimmed.includes("doc.")) {
+    try {
+      const fn = new Function("doc", `return !!(${trimmed})`) as (
+        doc: Record<string, unknown>,
+      ) => boolean;
+      return (doc: Record<string, unknown>) => {
+        try {
+          return fn(doc);
+        } catch {
+          return false;
+        }
+      };
+    } catch {
+      return () => false;
+    }
+  }
+
+  // Bare field reference (e.g. "enabled") — truthy check on doc[fieldname]
+  return (doc) => !!doc[trimmed];
+}
+
+// ---------------------------------------------------------------------------
+// Utility: parseFormLayout
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse a flat array of DocType fields into a structured `FormSection[]` layout.
+ *
+ * Algorithm:
+ * 1. Start with an implicit first section (no label) containing one column.
+ * 2. `Section Break` → start a new section.
+ * 3. `Column Break` → start a new column within the current section.
+ * 4. `Tab Break` → start a new section with `tab: true`.
+ * 5. All other fields → add to the current column (skip hidden fields).
+ *
+ * @param fields - Flat list of DocType fields, ordered by field_order or position
+ * @returns Structured layout tree of sections and columns
+ */
+export function parseFormLayout(fields: DocTypeField[]): FormSection[] {
+  const sections: FormSection[] = [];
+  let currentSection: FormSection = { columns: [{ fields: [] }] };
+  sections.push(currentSection);
+
+  for (const field of fields) {
+    switch (field.fieldtype) {
+      case "Section Break":
+        currentSection = {
+          label: field.label,
+          collapsible: field.collapsible,
+          columns: [{ fields: [] }],
+        };
+        sections.push(currentSection);
+        break;
+
+      case "Column Break":
+        currentSection.columns.push({ fields: [] });
+        break;
+
+      case "Tab Break":
+        currentSection = {
+          label: field.label,
+          tab: true,
+          columns: [{ fields: [] }],
+        };
+        sections.push(currentSection);
+        break;
+
+      default:
+        if (!field.hidden) {
+          const lastColumn = currentSection.columns[currentSection.columns.length - 1];
+          lastColumn.fields.push(field);
+        }
+        break;
+    }
+  }
+
+  return sections;
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+function createHttpClient(config: FrappeConnectionConfig): HttpClient {
+  const authConfig: AuthConfig | undefined = config.auth
+    ? {
+        useToken: config.auth.useToken,
+        token: config.auth.token,
+        type: config.auth.type as AuthConfig["type"],
+      }
+    : undefined;
+  return new HttpClient(config.baseURL, authConfig);
+}
+
+function parseRawField(raw: RawFieldResponse): DocTypeField {
+  return {
+    fieldname: raw.fieldname,
+    fieldtype: raw.fieldtype as FrappeFieldType,
+    label: raw.label,
+    options: raw.options,
+    reqd: !!raw.reqd,
+    unique: !!raw.unique,
+    default: raw.default,
+    depends_on: raw.depends_on,
+    read_only: !!raw.read_only,
+    hidden: !!raw.hidden,
+    in_list_view: !!raw.in_list_view,
+    in_standard_filter: !!raw.in_standard_filter,
+    description: raw.description,
+    length: raw.length,
+    precision: raw.precision,
+    search_fields: raw.search_fields,
+    collapsible: !!raw.collapsible,
+  };
+}
+
+function parseRawPermission(raw: RawPermissionResponse): DocTypePermission {
+  return {
+    role: raw.role,
+    read: !!raw.read,
+    write: !!raw.write,
+    create: !!raw.create,
+    delete: !!raw.delete,
+    submit: !!raw.submit,
+    cancel: !!raw.cancel,
+    amend: !!raw.amend,
+  };
+}
+
+function orderFields(fields: DocTypeField[], fieldOrder: string[]): DocTypeField[] {
+  const fieldMap = new Map(fields.map((f) => [f.fieldname, f]));
+  const ordered: DocTypeField[] = [];
+  const seen = new Set<string>();
+
+  for (const name of fieldOrder) {
+    const field = fieldMap.get(name);
+    if (field) {
+      ordered.push(field);
+      seen.add(name);
+    }
+  }
+
+  // Append any fields not listed in field_order
+  for (const field of fields) {
+    if (!seen.has(field.fieldname)) {
+      ordered.push(field);
+    }
+  }
+
+  return ordered;
+}
+
+function parseRawDocTypeMeta(raw: RawDocTypeResponse): DocTypeMeta {
+  const fields = raw.fields.map(parseRawField);
+
+  // field_order may be a JSON string or an already-parsed array
+  let fieldOrder: string[] | undefined;
+  if (typeof raw.field_order === "string") {
+    try {
+      fieldOrder = JSON.parse(raw.field_order);
+    } catch {
+      fieldOrder = undefined;
+    }
+  } else if (Array.isArray(raw.field_order)) {
+    fieldOrder = raw.field_order;
+  }
+
+  const orderedFields = fieldOrder ? orderFields(fields, fieldOrder) : fields;
+  const permissions = (raw.permissions ?? []).map(parseRawPermission);
+  const sections = parseFormLayout(orderedFields);
+
+  return {
+    name: raw.name,
+    module: raw.module,
+    title_field: raw.title_field,
+    image_field: raw.image_field,
+    is_tree: !!raw.is_tree,
+    sort_field: raw.sort_field || "modified",
+    sort_order: raw.sort_order || "DESC",
+    fields: orderedFields,
+    sections,
+    permissions,
+  };
+}
+
+/**
+ * Setup pattern for a stable HttpClient ref, following the same pattern
+ * used in `useDebouncedSearch` for DbModule.
+ */
+function useHttpClientRef(
+  config: FrappeConnectionConfig | undefined,
+): React.RefObject<HttpClient | undefined> {
+  const httpRef = useRef<HttpClient | undefined>(undefined);
+  const configKeyRef = useRef("");
+  const configKey = config ? `${config.baseURL}:${config.auth?.token ?? ""}` : "";
+
+  if (config && configKey !== configKeyRef.current) {
+    httpRef.current = createHttpClient(config);
+    configKeyRef.current = configKey;
+  }
+  if (!config) {
+    httpRef.current = undefined;
+    configKeyRef.current = "";
+  }
+
+  return httpRef;
+}
+
+// ---------------------------------------------------------------------------
+// Hook: useDocTypeMeta
+// ---------------------------------------------------------------------------
+
+/**
+ * Fetch and cache DocType metadata (schema, fields, layout, permissions).
+ *
+ * Responses are cached per-session in memory keyed by `{baseURL}:{doctype}`.
+ * The `refetch` function clears the cache entry and forces a fresh fetch.
+ *
+ * @param config - Frappe connection config, or undefined to disable
+ * @param doctype - The DocType name to fetch metadata for
+ * @returns `{ meta, isLoading, error, refetch }`
+ *
+ * @example
+ * ```tsx
+ * function PokemonForm() {
+ *   const { meta, isLoading } = useDocTypeMeta(config, "Pokemon");
+ *   if (isLoading) return <Spinner />;
+ *   return meta?.sections.map(section => (
+ *     <FormSection key={section.label} section={section} />
+ *   ));
+ * }
+ * ```
+ */
+export function useDocTypeMeta(
+  config: FrappeConnectionConfig | undefined,
+  doctype: string,
+): {
+  meta: DocTypeMeta | undefined;
+  isLoading: boolean;
+  error: Error | null;
+  refetch: () => void;
+} {
+  const cacheKey = config ? `${config.baseURL}:${doctype}` : "";
+
+  const [meta, setMeta] = useState<DocTypeMeta | undefined>(() =>
+    cacheKey ? metaCache.get(cacheKey) : undefined,
+  );
+  const [isLoading, setIsLoading] = useState(
+    () => !!config && !!doctype && !(cacheKey && metaCache.has(cacheKey)),
+  );
+  const [error, setError] = useState<Error | null>(null);
+  const [version, setVersion] = useState(0);
+
+  // Synchronize state when cache key changes (doctype or baseURL changed)
+  const prevCacheKeyRef = useRef(cacheKey);
+  if (cacheKey !== prevCacheKeyRef.current) {
+    prevCacheKeyRef.current = cacheKey;
+    const cached = cacheKey ? metaCache.get(cacheKey) : undefined;
+    if (cached) {
+      setMeta(cached);
+      setIsLoading(false);
+    } else {
+      setMeta(undefined);
+      setIsLoading(!!config && !!doctype);
+    }
+    setError(null);
+  }
+
+  const httpRef = useHttpClientRef(config);
+
+  useEffect(() => {
+    if (!config || !doctype) {
+      return;
+    }
+
+    const key = `${config.baseURL}:${doctype}`;
+    // Already have cached data (synchronized during render)
+    if (metaCache.has(key)) return;
+
+    const http = httpRef.current;
+    if (!http) return;
+
+    let cancelled = false;
+    setIsLoading(true);
+    setError(null);
+
+    (async () => {
+      try {
+        const response = await http.get<{ data: RawDocTypeResponse }>(
+          `/api/resource/DocType/${encodeURIComponent(doctype)}`,
+        );
+
+        if (cancelled) return;
+
+        const raw = response.payload?.data;
+        if (!raw) {
+          throw new Error(`No data returned for DocType "${doctype}"`);
+        }
+
+        const parsed = parseRawDocTypeMeta(raw);
+        metaCache.set(key, parsed);
+        setMeta(parsed);
+      } catch (err) {
+        if (cancelled) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setMeta(undefined);
+      } finally {
+        if (!cancelled) setIsLoading(false);
+      }
+    })();
+
+    return () => {
+      cancelled = true;
+    };
+    // Depend on the stable string `cacheKey` (baseURL + doctype), NOT the
+    // `config` object — callers frequently pass a freshly-allocated config
+    // object every render. Keying on the object identity would re-run this
+    // effect on every render and, when the request fails (e.g. a Guest hitting
+    // the permission-gated DocType meta endpoint → 403, which never populates
+    // `metaCache`), spin into an infinite refetch loop.
+  }, [cacheKey, version]);
+
+  const refetch = useCallback(() => {
+    if (cacheKey) metaCache.delete(cacheKey);
+    setVersion((v) => v + 1);
+  }, [cacheKey]);
+
+  return { meta, isLoading, error, refetch };
+}
+
+// ---------------------------------------------------------------------------
+// Hook: useLinkSearch
+// ---------------------------------------------------------------------------
+
+/**
+ * Debounced search for Link field suggestions.
+ *
+ * Auto-configures the `title_field` from DocType metadata when `searchFields`
+ * is not explicitly provided. Calls `GET /api/method/frappe.client.get_list`
+ * with a 300ms debounce.
+ *
+ * @param config - Frappe connection config, or undefined to disable
+ * @param doctype - The target DocType to search within
+ * @param options - Search options (query, searchFields, filters, limit)
+ * @returns `{ results, isLoading, error }`
+ *
+ * @example
+ * ```tsx
+ * function SpeciesLink() {
+ *   const [text, setText] = useState("");
+ *   const { results, isLoading } = useLinkSearch(config, "Poke Species", {
+ *     query: text,
+ *     limit: 10,
+ *   });
+ *   return (
+ *     <div>
+ *       <input value={text} onChange={e => setText(e.target.value)} />
+ *       {isLoading && <span>Searching...</span>}
+ *       {results.map(r => <div key={r.value}>{r.label}</div>)}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useLinkSearch(
+  config: FrappeConnectionConfig | undefined,
+  doctype: string,
+  options?: LinkSearchOptions,
+): {
+  results: LinkSearchResult[];
+  isLoading: boolean;
+  error: Error | null;
+} {
+  const query = options?.query ?? "";
+  const searchFields = options?.searchFields;
+  const filters = options?.filters;
+  const limit = options?.limit ?? 20;
+
+  const [results, setResults] = useState<LinkSearchResult[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  // Get meta for auto-configuring title_field
+  const { meta } = useDocTypeMeta(config, doctype);
+
+  const httpRef = useHttpClientRef(config);
+
+  useEffect(() => {
+    const http = httpRef.current;
+    if (!http || !query) {
+      setResults([]);
+      setIsLoading(false);
+      setError(null);
+      return;
+    }
+
+    let cancelled = false;
+    setIsLoading(true);
+    setError(null);
+
+    const timer = setTimeout(async () => {
+      try {
+        const titleField = meta?.title_field || "name";
+        const effectiveSearchFields =
+          searchFields ?? (titleField !== "name" ? [titleField, "name"] : ["name"]);
+
+        // Build or_filters for searching across multiple fields
+        const orFilters = effectiveSearchFields.map((f) => [f, "like", `%${query}%`]);
+        const requestFields = [...new Set(["name", titleField, ...effectiveSearchFields])];
+
+        const params: Record<string, unknown> = {
+          doctype,
+          fields: requestFields,
+          or_filters: orFilters,
+          limit_page_length: limit,
+        };
+        if (filters) params.filters = filters;
+
+        const response = await http.get<{
+          message?: Record<string, unknown>[];
+        }>("/api/method/frappe.client.get_list", params);
+
+        if (cancelled) return;
+
+        const docs = response.payload?.message ?? [];
+        setResults(
+          docs.map((doc) => ({
+            value: String(doc.name ?? ""),
+            label: String(doc[titleField] ?? doc.name ?? ""),
+            description: undefined,
+          })),
+        );
+      } catch (err) {
+        if (cancelled) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setResults([]);
+      } finally {
+        if (!cancelled) setIsLoading(false);
+      }
+    }, 300);
+
+    return () => {
+      cancelled = true;
+      clearTimeout(timer);
+    };
+  }, [query, doctype, meta?.title_field, searchFields, filters, limit]);
+
+  return { results, isLoading, error };
+}
+
+// ---------------------------------------------------------------------------
+// Hook: useDocTypeSearch
+// ---------------------------------------------------------------------------
+
+/**
+ * Search across all DocType names for Awesomebar navigation.
+ *
+ * Fetches and caches the full list of DocTypes, then filters locally
+ * for instant results. Returns navigation suggestions in the format:
+ * "{name} List", "{name} Report", "New {name}".
+ *
+ * @param config - Frappe connection config, or undefined to disable
+ * @param query - Search query string
+ * @returns `{ results, isLoading, error }`
+ *
+ * @example
+ * ```tsx
+ * function Awesomebar() {
+ *   const [text, setText] = useState("");
+ *   const { results } = useDocTypeSearch(config, text);
+ *   return (
+ *     <div>
+ *       <input value={text} onChange={e => setText(e.target.value)} />
+ *       {results.map(r => <div key={r.label}>{r.label}</div>)}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useDocTypeSearch(
+  config: FrappeConnectionConfig | undefined,
+  query: string,
+): {
+  results: DocTypeSearchResult[];
+  isLoading: boolean;
+  error: Error | null;
+} {
+  const [allDocTypes, setAllDocTypes] = useState<DocTypeListItem[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const httpRef = useHttpClientRef(config);
+
+  useEffect(() => {
+    if (!config) {
+      setAllDocTypes([]);
+      setIsLoading(false);
+      return;
+    }
+
+    const key = config.baseURL;
+    const cached = docTypeListCache.get(key);
+    if (cached) {
+      setAllDocTypes(cached);
+      return;
+    }
+
+    const http = httpRef.current;
+    if (!http) return;
+
+    let cancelled = false;
+    setIsLoading(true);
+    setError(null);
+
+    (async () => {
+      try {
+        const response = await http.get<{
+          data?: DocTypeListItem[];
+        }>("/api/resource/DocType", {
+          limit_page_length: 0,
+          fields: ["name", "module", "title"],
+        });
+
+        if (cancelled) return;
+
+        const list = response.payload?.data ?? [];
+        docTypeListCache.set(key, list);
+        setAllDocTypes(list);
+      } catch (err) {
+        if (cancelled) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        if (!cancelled) setIsLoading(false);
+      }
+    })();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [config]);
+
+  // Filter locally for instant results
+  const results = useMemo<DocTypeSearchResult[]>(() => {
+    if (!query || allDocTypes.length === 0) return [];
+
+    const lowerQuery = query.toLowerCase();
+    const matching = allDocTypes.filter(
+      (dt) =>
+        dt.name.toLowerCase().includes(lowerQuery) ||
+        dt.module.toLowerCase().includes(lowerQuery) ||
+        dt.title?.toLowerCase().includes(lowerQuery),
+    );
+
+    return matching.flatMap((dt) => [
+      { label: `${dt.name} List`, doctype: dt.name, type: "list" as const },
+      {
+        label: `${dt.name} Report`,
+        doctype: dt.name,
+        type: "report" as const,
+      },
+      { label: `New ${dt.name}`, doctype: dt.name, type: "new" as const },
+    ]);
+  }, [query, allDocTypes]);
+
+  return { results, isLoading, error };
+}