@spaceinvoices/react-ui 0.1.1 → 0.4.0

package/src/generated/schemas/stripeappcreateinvoice_body.ts

@@ -0,0 +1,20 @@
+/**
+ * This file was automatically generated using 'bun generate-schemas'.
+ * Do not edit this file manually. To update, run the generator again.
+ * @generated
+ */
+
+import { z } from 'zod';
+
+// Schemas for stripeappcreateinvoice_body endpoints
+
+// Schema for create appcreateinvoice operation
+const createAppCreateInvoiceSchemaDefinition = z.object({
+  stripe_object_id: z.string().min(1),
+  note: z.string().max(2000).optional(),
+});
+
+// Type for create appcreateinvoice operation
+export type CreateAppCreateInvoiceSchema = z.infer<typeof createAppCreateInvoiceSchemaDefinition>;
+
+export const createAppCreateInvoiceSchema = createAppCreateInvoiceSchemaDefinition;

package/src/generated/schemas/stripeappupdatesettings_body.ts

@@ -0,0 +1,26 @@
+/**
+ * This file was automatically generated using 'bun generate-schemas'.
+ * Do not edit this file manually. To update, run the generator again.
+ * @generated
+ */
+
+import { z } from 'zod';
+
+// Schemas for stripeappupdatesettings_body endpoints
+
+// Schema for update appupdatesettings operation
+const updateAppUpdateSettingsSchemaDefinition = z
+  .object({
+    auto_invoice_enabled: z.boolean(),
+    auto_invoice_events: z.array(
+      z.enum(["payment_intent.succeeded", "invoice.paid"])
+    ),
+    default_note: z.string().max(500),
+    default_tax_rate: z.union([z.number(), z.null()]),
+  })
+  .partial();
+
+// Type for update appupdatesettings operation
+export type UpdateAppUpdateSettingsSchema = z.infer<typeof updateAppUpdateSettingsSchemaDefinition>;
+
+export const updateAppUpdateSettingsSchema = updateAppUpdateSettingsSchemaDefinition;

package/src/generated/schemas/webhook.ts

@@ -0,0 +1,143 @@
+/**
+ * This file was automatically generated using 'bun generate-schemas'.
+ * Do not edit this file manually. To update, run the generator again.
+ * @generated
+ */
+
+import { z } from 'zod';
+
+// Schemas for webhook endpoints
+
+// Schema for create webhook operation
+const createWebhookSchemaDefinition = z.object({
+  url: z.string().max(2048).url(),
+  description: z.string().max(500).optional(),
+  events: z
+    .array(
+      z.enum([
+        "invoice.created",
+        "invoice.updated",
+        "invoice.sent",
+        "invoice.paid",
+        "invoice.overdue",
+        "invoice.cancelled",
+        "invoice.deleted",
+        "invoice.restored",
+        "invoice.voided",
+        "invoice.finalized",
+        "customer.created",
+        "customer.updated",
+        "customer.deleted",
+        "customer.restored",
+        "customer.permanently_deleted",
+        "payment.received",
+        "payment.failed",
+        "payment.deleted",
+        "payment.restored",
+        "payment.permanently_deleted",
+        "estimate.created",
+        "estimate.sent",
+        "estimate.accepted",
+        "estimate.rejected",
+        "estimate.deleted",
+        "estimate.restored",
+        "credit_note.created",
+        "credit_note.issued",
+        "credit_note.deleted",
+        "credit_note.restored",
+        "advance_invoice.created",
+        "advance_invoice.paid",
+        "advance_invoice.applied",
+        "advance_invoice.deleted",
+        "advance_invoice.restored",
+        "item.created",
+        "item.deleted",
+        "item.restored",
+        "item.permanently_deleted",
+        "tax.created",
+        "tax.updated",
+        "tax.deleted",
+        "tax.restored",
+        "tax.permanently_deleted",
+        "stripe_app.connected",
+        "stripe_app.disconnected",
+        "stripe_app.settings_updated",
+      ])
+    )
+    .min(1),
+  active: z.boolean().optional().default(true),
+  metadata: z.union([z.record(z.string(), z.any()), z.null()]).optional(),
+});
+
+// Type for create webhook operation
+export type CreateWebhookSchema = z.infer<typeof createWebhookSchemaDefinition>;
+
+
+// Schema for update webhook operation
+const updateWebhookSchemaDefinition = z
+  .object({
+    url: z.string().max(2048).url(),
+    description: z.union([z.string().max(4000, "Description must not exceed 4000 characters"), z.null()]),
+    events: z
+      .array(
+        z.enum([
+          "invoice.created",
+          "invoice.updated",
+          "invoice.sent",
+          "invoice.paid",
+          "invoice.overdue",
+          "invoice.cancelled",
+          "invoice.deleted",
+          "invoice.restored",
+          "invoice.voided",
+          "invoice.finalized",
+          "customer.created",
+          "customer.updated",
+          "customer.deleted",
+          "customer.restored",
+          "customer.permanently_deleted",
+          "payment.received",
+          "payment.failed",
+          "payment.deleted",
+          "payment.restored",
+          "payment.permanently_deleted",
+          "estimate.created",
+          "estimate.sent",
+          "estimate.accepted",
+          "estimate.rejected",
+          "estimate.deleted",
+          "estimate.restored",
+          "credit_note.created",
+          "credit_note.issued",
+          "credit_note.deleted",
+          "credit_note.restored",
+          "advance_invoice.created",
+          "advance_invoice.paid",
+          "advance_invoice.applied",
+          "advance_invoice.deleted",
+          "advance_invoice.restored",
+          "item.created",
+          "item.deleted",
+          "item.restored",
+          "item.permanently_deleted",
+          "tax.created",
+          "tax.updated",
+          "tax.deleted",
+          "tax.restored",
+          "tax.permanently_deleted",
+          "stripe_app.connected",
+          "stripe_app.disconnected",
+          "stripe_app.settings_updated",
+        ])
+      )
+      .min(1),
+    active: z.boolean(),
+    metadata: z.union([z.record(z.string(), z.any()), z.null()]),
+  })
+  .partial();
+
+// Type for update webhook operation
+export type UpdateWebhookSchema = z.infer<typeof updateWebhookSchemaDefinition>;
+
+export const createWebhookSchema = createWebhookSchemaDefinition;
+export const updateWebhookSchema = updateWebhookSchemaDefinition;

package/src/hooks/create-resource-hooks.ts

@@ -65,7 +65,11 @@ export function createResourceHooks<
   TResource extends { id: string },
   TCreateData = unknown,
   TUpdateData = Partial<Omit<TResource, "id">>,
->(resourceName: keyof SDK, cacheKey: string) {
+>(
+  resourceName: keyof SDK,
+  cacheKey: string,
+  options?: { restoreMethodName?: string; permanentDeleteMethodName?: string },
+) {
   /**
    * Hook for creating a new resource
    */
@@ -292,9 +296,89 @@ export function createResourceHooks<
     });
   }
 
+  /**
+   * Hook for restoring a soft-deleted resource
+   */
+  function useRestoreResource<TError = Error>(
+    hookOptions: ResourceMutationHookOptions<TResource, TError, { id: string }> = {},
+  ) {
+    const queryClient = useQueryClient();
+    const methodName = options?.restoreMethodName;
+    if (!methodName) {
+      throw new Error(`restoreMethodName not configured for ${String(resourceName)}`);
+    }
+
+    return useResourceMutation<TResource, TError, { id: string }>({
+      resourceName,
+      methodName,
+      cacheKey,
+      entityId: hookOptions.entityId,
+      accountId: hookOptions.accountId,
+      mutationOptions: {
+        onSuccess: (data, variables, context) => {
+          invalidateResourceQueries(queryClient, cacheKey, variables.id, {
+            entityId: hookOptions.entityId,
+            accountId: hookOptions.accountId,
+          });
+          hookOptions.onSuccess?.(data, variables, context);
+        },
+        onError: hookOptions.onError,
+        ...hookOptions.mutationOptions,
+      },
+    });
+  }
+
+  /**
+   * Hook for permanently deleting a soft-deleted resource
+   */
+  function usePermanentDeleteResource<TError = Error>(
+    hookOptions: ResourceMutationHookOptions<void, TError, { id: string }> = {},
+  ) {
+    const queryClient = useQueryClient();
+    const methodName = options?.permanentDeleteMethodName;
+    if (!methodName) {
+      throw new Error(`permanentDeleteMethodName not configured for ${String(resourceName)}`);
+    }
+
+    return useResourceMutation<void, TError, { id: string }>({
+      resourceName,
+      methodName,
+      cacheKey,
+      entityId: hookOptions.entityId,
+      accountId: hookOptions.accountId,
+      mutationOptions: {
+        onSuccess: (data, variables, context) => {
+          invalidateResourceQueries(queryClient, cacheKey, variables.id, {
+            entityId: hookOptions.entityId,
+            accountId: hookOptions.accountId,
+          });
+
+          const listQueryKey = buildQueryKey(cacheKey, {
+            entityId: hookOptions.entityId,
+            accountId: hookOptions.accountId,
+          });
+
+          queryClient.setQueriesData({ queryKey: listQueryKey }, (oldData: any) => {
+            if (!oldData?.data) return oldData;
+            return {
+              ...oldData,
+              data: oldData.data.filter((resource: TResource) => resource.id !== variables.id),
+            };
+          });
+
+          hookOptions.onSuccess?.(data, variables, context);
+        },
+        onError: hookOptions.onError,
+        ...hookOptions.mutationOptions,
+      },
+    });
+  }
+
   return {
     useCreateResource,
     useUpdateResource,
     useDeleteResource,
+    useRestoreResource,
+    usePermanentDeleteResource,
   };
 }

package/src/hooks/use-duplicate-document.ts

@@ -1,12 +1,12 @@
 import type {
-  AdvanceInvoiceWithItems,
+  AdvanceInvoice,
   CreateAdvanceInvoiceRequest,
   CreateCreditNoteRequest,
   CreateEstimateRequest,
   CreateInvoiceRequest,
-  CreditNoteWithItems,
-  EstimateWithItems,
-  InvoiceWithItems,
+  CreditNote,
+  Estimate,
+  Invoice,
 } from "@spaceinvoices/js-sdk";
 import { useQuery } from "@tanstack/react-query";
 
@@ -14,7 +14,7 @@ import { useEntities } from "@/ui/providers/entities-context";
 import { useSDK } from "@/ui/providers/sdk-provider";
 
 export type DocumentType = "invoice" | "estimate" | "credit_note" | "advance_invoice";
-type Document = InvoiceWithItems | EstimateWithItems | CreditNoteWithItems | AdvanceInvoiceWithItems;
+type Document = Invoice | Estimate | CreditNote | AdvanceInvoice;
 type CreateRequest =
   | CreateInvoiceRequest
   | CreateEstimateRequest
@@ -56,16 +56,25 @@ export function getAllowedDuplicateTargets(sourceType: DocumentType): DocumentTy
  */
 function transformDocumentForDuplication(source: Document, _targetType: DocumentType): Partial<CreateRequest> {
   // Transform items - copy only the fields needed for creation
-  const items = source.items?.map((item: (typeof source.items)[number]) => ({
+  // Use type assertion for items since all document item types share the same shape
+  const sourceItems = source.items as Array<{
+    name: string;
+    description: string | null;
+    quantity: number;
+    price: number;
+    gross_price?: number | null;
+    taxes: Array<{ tax_id?: string }>;
+  }>;
+  const items = sourceItems?.map((item) => ({
     name: item.name,
     description: item.description,
     quantity: item.quantity,
     // Use gross_price if set, otherwise use price. The form uses is_gross_price as a UI toggle.
-    price: (item as { gross_price?: number }).gross_price ?? item.price,
+    price: item.gross_price ?? item.price,
     // Copy tax references (tax_id), not computed tax data
-    taxes: item.taxes?.map((tax: { tax_id?: string }) => ({ tax_id: tax.tax_id })),
+    taxes: item.taxes?.map((tax) => ({ tax_id: tax.tax_id })),
     // Derive is_gross_price from whether gross_price is set
-    gross_price: (item as { gross_price?: number }).gross_price,
+    gross_price: item.gross_price ?? undefined,
   }));
 
   // Build customer data - always copy if available (form needs this for display)
@@ -158,8 +167,7 @@ export function useDuplicateDocument({
       if (sourceType === "invoice") {
         source = await sdk.invoices.get(sourceId, undefined, { entity_id: activeEntity.id });
       } else if (sourceType === "estimate") {
-        // estimates.get only takes 2 args (no params)
-        source = await sdk.estimates.get(sourceId, { entity_id: activeEntity.id });
+        source = await sdk.estimates.get(sourceId, undefined, { entity_id: activeEntity.id });
       } else if (sourceType === "advance_invoice") {
         source = await sdk.advanceInvoices.get(sourceId, undefined, { entity_id: activeEntity.id });
       } else {

package/src/hooks/use-next-document-number.ts

@@ -9,7 +9,7 @@ export type DocumentType = "invoice" | "estimate" | "credit_note" | "advance_inv
 /** Response type for next document number preview */
 export type NextDocumentNumberResponse = {
   number: string | null;
-  furs: {
+  furs?: {
     business_premise_name: string;
     electronic_device_name: string;
   } | null;

package/src/hooks/use-resource-mutation.ts

@@ -62,7 +62,8 @@ export function useResourceMutation<TData, TError = Error, TVariables = unknown,
 
       // SDK API: method(data, options) or method(id, data, options)
       const isUpdateMethod = methodName === "update";
-      const isDeleteMethod = methodName === "delete";
+      const isIdOnlyMethod =
+        methodName === "delete" || methodName.startsWith("restore") || methodName.startsWith("permanentDelete");
 
       if (isUpdateMethod) {
         // Update: method(id, data, options)
@@ -70,8 +71,8 @@ export function useResourceMutation<TData, TError = Error, TVariables = unknown,
         return (await resource[methodName](id, data, options)) as TData;
       }
 
-      if (isDeleteMethod) {
-        // Delete: method(id, options)
+      if (isIdOnlyMethod) {
+        // Delete/Restore/PermanentDelete: method(id, options)
         const { id } = variables as { id: string };
         return (await resource[methodName](id, options)) as TData;
       }

package/src/lib/browser-cookies.ts

@@ -49,7 +49,7 @@ export function getCookie(name: string): string | undefined {
 }
 
 /**
- * Removes a cookie by name
+ * Removes a cookie by name, clearing both host-only and domain-scoped versions
  */
 export function deleteCookie(name: string, path = "/") {
   if (typeof window === "undefined") {
@@ -57,10 +57,21 @@ export function deleteCookie(name: string, path = "/") {
     return;
   }
 
+  // Delete host-only cookie (e.g. app.spaceinvoices.com)
   setCookie(name, "", {
     path,
     expires: new Date(0),
   });
+
+  // Also delete domain cookie (e.g. .spaceinvoices.com) if on spaceinvoices.com
+  const hostname = window.location.hostname;
+  if (hostname === "spaceinvoices.com" || hostname.endsWith(".spaceinvoices.com")) {
+    setCookie(name, "", {
+      path,
+      expires: new Date(0),
+      domain: ".spaceinvoices.com",
+    });
+  }
 }
 
 export function flushCookies() {

package/src/lib/cookies.ts

@@ -6,8 +6,8 @@
 export function getCookie(cookiesString: string, name: string) {
   const value = `; ${cookiesString}`;
   const parts = value.split(`; ${name}=`);
-  if (parts.length === 2) {
-    return decodeURIComponent(parts.pop()?.split(";").shift() ?? "");
+  if (parts.length >= 2) {
+    return decodeURIComponent(parts[1]?.split(";").shift() ?? "");
   }
   return undefined;
 }

package/src/lib/translation.ts

@@ -25,7 +25,7 @@ export function createTranslation({ t, namespace, locale = "en", translations =
       }
 
       // 2. Look up in local translations for current locale
-      if (locale !== "en" && translations[locale]) {
+      if (translations[locale]) {
         const translation = translations[locale][key];
         if (translation) return translation;
       }

package/src/providers/entities-provider.tsx

@@ -23,34 +23,38 @@ type EntitiesProviderProps = {
   children: ReactNode;
   initialActiveEntity?: Entity | null;
   onNoEntities?: () => void;
+  cookieDomain?: string;
+  /** When provided (from URL param), this entity ID is used as the source of truth instead of the cookie */
+  urlEntityId?: string;
 };
 
-export function EntitiesProvider({ children, initialActiveEntity, onNoEntities }: EntitiesProviderProps) {
+export function EntitiesProvider({
+  children,
+  initialActiveEntity,
+  onNoEntities,
+  cookieDomain,
+  urlEntityId,
+}: EntitiesProviderProps) {
   const { sdk, isInitialized } = useSDK();
   const [cookies, setCookie, removeCookie] = useCookies([ACTIVE_ENTITY_COOKIE, ACTIVE_ENVIRONMENT_COOKIE]);
   const isInitialMount = useRef(true);
   const initialEnvironmentFromCookie = cookies[ACTIVE_ENVIRONMENT_COOKIE] as EntityEnvironment | undefined;
-  const initialEntityFromCookie = cookies[ACTIVE_ENTITY_COOKIE] as Entity | undefined;
+  const initialEntityIdFromCookie = cookies[ACTIVE_ENTITY_COOKIE] as string | undefined;
+
+  // URL entity ID takes precedence over cookie
+  const resolvedEntityId = urlEntityId ?? initialEntityIdFromCookie;
 
   const resolvedInitialEnvironment: EntityEnvironment =
-    initialEnvironmentFromCookie ??
-    (initialEntityFromCookie?.environment as EntityEnvironment | undefined) ??
-    (initialActiveEntity?.environment as EntityEnvironment | undefined) ??
-    "live";
+    initialEnvironmentFromCookie ?? (initialActiveEntity?.environment as EntityEnvironment | undefined) ?? "live";
 
   const [environment, setEnvironmentState] = useState<EntityEnvironment>(resolvedInitialEnvironment);
   const previousEnvironment = useRef(environment);
 
-  // Initialize active entity from cookie or prop that matches the selected environment
-  const [activeEntityState, setActiveEntityState] = useState<Entity | null>(() => {
-    try {
-      if (initialEntityFromCookie && initialEntityFromCookie.environment === resolvedInitialEnvironment) {
-        return initialEntityFromCookie;
-      }
-    } catch (_e) {
-      // Ignore cookie parsing errors
-    }
+  // Store the initial entity ID (from URL or cookie) so we can match it when entities load
+  const initialEntityIdRef = useRef(resolvedEntityId);
 
+  // Initialize active entity from prop if it matches the selected environment
+  const [activeEntityState, setActiveEntityState] = useState<Entity | null>(() => {
     if (initialActiveEntity && initialActiveEntity.environment === resolvedInitialEnvironment) {
       return initialActiveEntity;
     }
@@ -83,14 +87,38 @@ export function EntitiesProvider({ children, initialActiveEntity, onNoEntities }
     refetchOnReconnect: true,
   });
 
-  // Redirect to add entity page when no entities exist
+  // When no entities in current environment, check the other before giving up
   const hasCalledNoEntities = useRef(false);
+  const hasTriedFallback = useRef(false);
   useEffect(() => {
-    if (!isLoading && entities.length === 0 && !hasCalledNoEntities.current) {
-      hasCalledNoEntities.current = true;
-      onNoEntities?.();
+    if (isLoading || entities.length > 0 || hasCalledNoEntities.current) return;
+
+    // Try the other environment before calling onNoEntities
+    if (!hasTriedFallback.current && sdk) {
+      hasTriedFallback.current = true;
+      const altEnv = environment === "live" ? "sandbox" : "live";
+      sdk.entities
+        .list({ limit: 1, environment: altEnv })
+        .then((res) => {
+          if (res.data.length > 0) {
+            // Other environment has entities — auto-switch
+            setEnvironmentState(altEnv as EntityEnvironment);
+          } else {
+            hasCalledNoEntities.current = true;
+            onNoEntities?.();
+          }
+        })
+        .catch(() => {
+          hasCalledNoEntities.current = true;
+          onNoEntities?.();
+        });
+      return;
     }
-  }, [isLoading, entities.length, onNoEntities]);
+
+    if (!hasTriedFallback.current) return;
+    hasCalledNoEntities.current = true;
+    onNoEntities?.();
+  }, [isLoading, entities.length, onNoEntities, sdk, environment]);
 
   // Memoize entities to prevent unnecessary re-renders
   const memoizedEntities = useMemo(() => entities, [entities]);
@@ -107,24 +135,39 @@ export function EntitiesProvider({ children, initialActiveEntity, onNoEntities }
   const activeEntityRef = useRef(activeEntityState);
   activeEntityRef.current = activeEntityState;
 
+  // When urlEntityId changes (e.g. entity switcher navigates to new URL), update the ref
+  useEffect(() => {
+    if (urlEntityId) {
+      initialEntityIdRef.current = urlEntityId;
+    }
+  }, [urlEntityId]);
+
   useEffect(() => {
     if (!memoizedEntities.length) return;
 
     const currentActive = activeEntityRef.current;
+    // When URL entity ID is provided, always try to match it first
+    const targetEntityId = urlEntityId ?? currentActive?.id;
 
     try {
-      if (currentActive) {
-        const updatedEntity = memoizedEntities.find((entity) => entity.id === currentActive.id);
+      if (targetEntityId) {
+        const updatedEntity = memoizedEntities.find((entity) => entity.id === targetEntityId);
 
         if (updatedEntity) {
           // Always update with fresh data from the server
           setActiveEntityState(updatedEntity);
+        } else if (currentActive) {
+          // URL entity not found but we have a current active — keep it or fall back
+          const stillExists = memoizedEntities.find((entity) => entity.id === currentActive.id);
+          setActiveEntityState(stillExists ?? memoizedEntities[0]);
         } else {
-          // If active entity no longer exists, fall back to first entity
           setActiveEntityState(memoizedEntities[0]);
         }
       } else {
-        setActiveEntityState(memoizedEntities[0]);
+        // No active entity yet — try to match by cookie/URL ID, then fall back to first
+        const entityId = initialEntityIdRef.current;
+        const matchedEntity = entityId ? memoizedEntities.find((entity) => entity.id === entityId) : undefined;
+        setActiveEntityState(matchedEntity ?? memoizedEntities[0]);
       }
     } catch (_e) {
       if (memoizedEntities.length > 0) {
@@ -135,28 +178,51 @@ export function EntitiesProvider({ children, initialActiveEntity, onNoEntities }
         isInitialMount.current = false;
       }
     }
-  }, [memoizedEntities]); // Only depend on entities list
+  }, [memoizedEntities, urlEntityId]); // Re-run when URL entity changes
 
-  // Update cookie when active entity changes
+  // When urlEntityId is provided but not found in current environment, auto-switch
+  const urlEntityFallbackAttempted = useRef<string | null>(null);
+  useEffect(() => {
+    if (!urlEntityId || isLoading) return;
+    if (memoizedEntities.length === 0) return;
+
+    const found = memoizedEntities.some((e) => e.id === urlEntityId);
+    if (found) {
+      urlEntityFallbackAttempted.current = null;
+      return;
+    }
+
+    // Prevent infinite switching between environments
+    if (urlEntityFallbackAttempted.current === urlEntityId) return;
+    urlEntityFallbackAttempted.current = urlEntityId;
+
+    // URL entity not in current environment — try the other
+    const altEnv: EntityEnvironment = environment === "live" ? "sandbox" : "live";
+    setEnvironmentState(altEnv);
+  }, [urlEntityId, memoizedEntities, isLoading, environment]);
+
+  const cookieOpts = useMemo(
+    () => ({
+      path: "/",
+      maxAge: 60 * 60 * 24 * 365,
+      sameSite: "lax" as const,
+      ...(cookieDomain && { domain: cookieDomain }),
+    }),
+    [cookieDomain],
+  );
+
+  // Update cookie when active entity changes (store only ID)
   useEffect(() => {
     if (activeEntityState) {
-      setCookie(ACTIVE_ENTITY_COOKIE, activeEntityState, {
-        path: "/",
-        maxAge: 60 * 60 * 24 * 365,
-        sameSite: "lax",
-      });
+      setCookie(ACTIVE_ENTITY_COOKIE, activeEntityState.id, cookieOpts);
     } else {
-      removeCookie(ACTIVE_ENTITY_COOKIE, { path: "/" });
+      removeCookie(ACTIVE_ENTITY_COOKIE, cookieOpts);
     }
-  }, [activeEntityState, setCookie, removeCookie]);
+  }, [activeEntityState, setCookie, removeCookie, cookieOpts]);
 
   useEffect(() => {
-    setCookie(ACTIVE_ENVIRONMENT_COOKIE, environment, {
-      path: "/",
-      maxAge: 60 * 60 * 24 * 365,
-      sameSite: "lax",
-    });
-  }, [environment, setCookie]);
+    setCookie(ACTIVE_ENVIRONMENT_COOKIE, environment, cookieOpts);
+  }, [environment, setCookie, cookieOpts]);
 
   const refetchEntities = useCallback(async () => {
     await refetch();