@spaceinvoices/react-ui 0.4.6 → 0.4.8

package/src/components/dashboard/shared/use-revenue-data.ts

@@ -1,11 +1,10 @@
 /**
  * Revenue data hook using the entity stats API.
  * Server-side aggregation for accurate calculations.
+ * Sends 7 queries in a single batch request.
  */
-import type { StatsQueryDataItem } from "@spaceinvoices/js-sdk";
-import { useQueries } from "@tanstack/react-query";
-import { useSDK } from "@/ui/providers/sdk-provider";
-import { STATS_QUERY_CACHE_KEY } from "./use-stats-query";
+import type { StatsQueryDataItem, StatsQueryRequest } from "@spaceinvoices/js-sdk";
+import { useStatsBatchQuery } from "./use-stats-query";
 
 export const REVENUE_DATA_CACHE_KEY = "dashboard-revenue-data";
 
@@ -37,192 +36,117 @@ export type RevenueData = {
 };
 
 export function useRevenueData(entityId: string | undefined) {
-  const { sdk } = useSDK();
   const monthRange = getMonthDateRange();
   const yearRange = getYearDateRange();
 
-  const queries = useQueries({
-    queries: [
-      // This month revenue (using converted amounts for multi-currency support)
-      {
-        queryKey: [STATS_QUERY_CACHE_KEY, entityId, "revenue-this-month", monthRange.from],
-        queryFn: async () => {
-          if (!entityId || !sdk) throw new Error("Missing entity or SDK");
-          return sdk.entityStats.queryEntityStats(
-            {
-              metrics: [{ type: "sum", field: "total_with_tax_converted", alias: "revenue" }],
-              table: "invoices",
-              date_from: monthRange.from,
-              date_to: monthRange.to,
-              filters: { is_draft: false },
-              group_by: ["quote_currency"], // Get the currency for display
-            },
-            { entity_id: entityId },
-          );
-        },
-        enabled: !!entityId && !!sdk,
-        staleTime: 120_000,
-      },
-      // This year revenue (using converted amounts for multi-currency support)
-      {
-        queryKey: [STATS_QUERY_CACHE_KEY, entityId, "revenue-this-year", yearRange.from],
-        queryFn: async () => {
-          if (!entityId || !sdk) throw new Error("Missing entity or SDK");
-          return sdk.entityStats.queryEntityStats(
-            {
-              metrics: [{ type: "sum", field: "total_with_tax_converted", alias: "revenue" }],
-              table: "invoices",
-              date_from: yearRange.from,
-              date_to: yearRange.to,
-              filters: { is_draft: false },
-            },
-            { entity_id: entityId },
-          );
-        },
-        enabled: !!entityId && !!sdk,
-        staleTime: 120_000,
-      },
-      // Outstanding (unpaid, not voided)
-      {
-        queryKey: [STATS_QUERY_CACHE_KEY, entityId, "outstanding"],
-        queryFn: async () => {
-          if (!entityId || !sdk) throw new Error("Missing entity or SDK");
-          return sdk.entityStats.queryEntityStats(
-            {
-              metrics: [{ type: "sum", field: "total_due", alias: "outstanding" }],
-              table: "invoices",
-              filters: { is_draft: false, paid_in_full: false },
-            },
-            { entity_id: entityId },
-          );
-        },
-        enabled: !!entityId && !!sdk,
-        staleTime: 120_000,
-      },
-      // Overdue (past due date, unpaid)
-      {
-        queryKey: [STATS_QUERY_CACHE_KEY, entityId, "overdue"],
-        queryFn: async () => {
-          if (!entityId || !sdk) throw new Error("Missing entity or SDK");
-          return sdk.entityStats.queryEntityStats(
-            {
-              metrics: [
-                { type: "sum", field: "total_due", alias: "overdue" },
-                { type: "count", alias: "count" },
-              ],
-              table: "invoices",
-              filters: { is_draft: false, paid_in_full: false },
-              group_by: ["overdue_bucket"],
-            },
-            { entity_id: entityId },
-          );
-        },
-        enabled: !!entityId && !!sdk,
-        staleTime: 120_000,
-      },
-      // Credit notes: this month
-      {
-        queryKey: [STATS_QUERY_CACHE_KEY, entityId, "cn-this-month", monthRange.from],
-        queryFn: async () => {
-          if (!entityId || !sdk) throw new Error("Missing entity or SDK");
-          return sdk.entityStats.queryEntityStats(
-            {
-              metrics: [{ type: "sum", field: "total_with_tax_converted", alias: "revenue" }],
-              table: "credit_notes",
-              date_from: monthRange.from,
-              date_to: monthRange.to,
-              filters: { is_draft: false },
-            },
-            { entity_id: entityId },
-          );
-        },
-        enabled: !!entityId && !!sdk,
-        staleTime: 120_000,
-      },
-      // Credit notes: this year
-      {
-        queryKey: [STATS_QUERY_CACHE_KEY, entityId, "cn-this-year", yearRange.from],
-        queryFn: async () => {
-          if (!entityId || !sdk) throw new Error("Missing entity or SDK");
-          return sdk.entityStats.queryEntityStats(
-            {
-              metrics: [{ type: "sum", field: "total_with_tax_converted", alias: "revenue" }],
-              table: "credit_notes",
-              date_from: yearRange.from,
-              date_to: yearRange.to,
-              filters: { is_draft: false },
-            },
-            { entity_id: entityId },
-          );
-        },
-        enabled: !!entityId && !!sdk,
-        staleTime: 120_000,
-      },
-      // Credit notes: outstanding
-      {
-        queryKey: [STATS_QUERY_CACHE_KEY, entityId, "cn-outstanding"],
-        queryFn: async () => {
-          if (!entityId || !sdk) throw new Error("Missing entity or SDK");
-          return sdk.entityStats.queryEntityStats(
-            {
-              metrics: [{ type: "sum", field: "total_due", alias: "outstanding" }],
-              table: "credit_notes",
-              filters: { is_draft: false, paid_in_full: false },
-            },
-            { entity_id: entityId },
-          );
-        },
-        enabled: !!entityId && !!sdk,
-        staleTime: 120_000,
-      },
-    ],
-  });
+  const queries: StatsQueryRequest[] = [
+    // [0] This month revenue (using converted amounts for multi-currency support)
+    {
+      metrics: [{ type: "sum", field: "total_with_tax_converted", alias: "revenue" }],
+      table: "invoices",
+      date_from: monthRange.from,
+      date_to: monthRange.to,
+      filters: { is_draft: false },
+      group_by: ["quote_currency"],
+    },
+    // [1] This year revenue
+    {
+      metrics: [{ type: "sum", field: "total_with_tax_converted", alias: "revenue" }],
+      table: "invoices",
+      date_from: yearRange.from,
+      date_to: yearRange.to,
+      filters: { is_draft: false },
+    },
+    // [2] Outstanding (unpaid, not voided)
+    {
+      metrics: [{ type: "sum", field: "total_due", alias: "outstanding" }],
+      table: "invoices",
+      filters: { is_draft: false, paid_in_full: false },
+    },
+    // [3] Overdue (past due date, unpaid)
+    {
+      metrics: [
+        { type: "sum", field: "total_due", alias: "overdue" },
+        { type: "count", alias: "count" },
+      ],
+      table: "invoices",
+      filters: { is_draft: false, paid_in_full: false },
+      group_by: ["overdue_bucket"],
+    },
+    // [4] Credit notes: this month
+    {
+      metrics: [{ type: "sum", field: "total_with_tax_converted", alias: "revenue" }],
+      table: "credit_notes",
+      date_from: monthRange.from,
+      date_to: monthRange.to,
+      filters: { is_draft: false },
+    },
+    // [5] Credit notes: this year
+    {
+      metrics: [{ type: "sum", field: "total_with_tax_converted", alias: "revenue" }],
+      table: "credit_notes",
+      date_from: yearRange.from,
+      date_to: yearRange.to,
+      filters: { is_draft: false },
+    },
+    // [6] Credit notes: outstanding
+    {
+      metrics: [{ type: "sum", field: "total_due", alias: "outstanding" }],
+      table: "credit_notes",
+      filters: { is_draft: false, paid_in_full: false },
+    },
+  ];
+
+  const { data: results, isLoading } = useStatsBatchQuery(entityId, "revenue-data", queries, {
+    select: (batch) => {
+      const [thisMonthRes, thisYearRes, outstandingRes, overdueRes, cnThisMonthRes, cnThisYearRes, cnOutstandingRes] =
+        batch;
 
-  const [
-    thisMonthQuery,
-    thisYearQuery,
-    outstandingQuery,
-    overdueQuery,
-    cnThisMonthQuery,
-    cnThisYearQuery,
-    cnOutstandingQuery,
-  ] = queries;
+      // Extract this month revenue and currency (may have multiple rows if grouped by quote_currency)
+      const thisMonthData = thisMonthRes.data || [];
+      const thisMonthRevenue = thisMonthData.reduce(
+        (sum: number, row: StatsQueryDataItem) => sum + (Number(row.revenue) || 0),
+        0,
+      );
+      const currency = (thisMonthData[0]?.quote_currency as string) || "EUR";
 
-  // Extract this month revenue and currency (may have multiple rows if grouped by quote_currency)
-  const thisMonthData = thisMonthQuery.data?.data || [];
-  const thisMonthRevenue = thisMonthData.reduce(
-    (sum: number, row: StatsQueryDataItem) => sum + (Number(row.revenue) || 0),
-    0,
-  );
-  // Get currency from first row with data
-  const currency = (thisMonthData[0]?.quote_currency as string) || "EUR";
+      // Credit note totals
+      const cnThisMonth = Number(cnThisMonthRes.data?.[0]?.revenue) || 0;
+      const cnThisYear = Number(cnThisYearRes.data?.[0]?.revenue) || 0;
+      const cnOutstanding = Number(cnOutstandingRes.data?.[0]?.outstanding) || 0;
 
-  // Credit note totals
-  const cnThisMonth = Number(cnThisMonthQuery.data?.data?.[0]?.revenue) || 0;
-  const cnThisYear = Number(cnThisYearQuery.data?.data?.[0]?.revenue) || 0;
-  const cnOutstanding = Number(cnOutstandingQuery.data?.data?.[0]?.outstanding) || 0;
+      // Extract overdue data (buckets other than "current") — stays invoice-only
+      const overdueData = overdueRes.data || [];
+      const overdueBuckets = overdueData.filter((row: StatsQueryDataItem) => row.overdue_bucket !== "current");
+      const totalOverdue = overdueBuckets.reduce(
+        (sum: number, row: StatsQueryDataItem) => sum + (Number(row.overdue) || 0),
+        0,
+      );
+      const overdueCount = overdueBuckets.reduce(
+        (sum: number, row: StatsQueryDataItem) => sum + (Number(row.count) || 0),
+        0,
+      );
 
-  // Extract overdue data (buckets other than "current") — stays invoice-only
-  const overdueData = overdueQuery.data?.data || [];
-  const overdueBuckets = overdueData.filter((row: StatsQueryDataItem) => row.overdue_bucket !== "current");
-  const totalOverdue = overdueBuckets.reduce(
-    (sum: number, row: StatsQueryDataItem) => sum + (Number(row.overdue) || 0),
-    0,
-  );
-  const overdueCount = overdueBuckets.reduce(
-    (sum: number, row: StatsQueryDataItem) => sum + (Number(row.count) || 0),
-    0,
-  );
+      return {
+        thisMonth: thisMonthRevenue - cnThisMonth,
+        thisYear: (Number(thisYearRes.data?.[0]?.revenue) || 0) - cnThisYear,
+        outstanding: (Number(outstandingRes.data?.[0]?.outstanding) || 0) - cnOutstanding,
+        overdue: totalOverdue,
+        overdueCount,
+        currency,
+      } as RevenueData;
+    },
+  });
 
   return {
-    data: {
-      thisMonth: thisMonthRevenue - cnThisMonth,
-      thisYear: (Number(thisYearQuery.data?.data?.[0]?.revenue) || 0) - cnThisYear,
-      outstanding: (Number(outstandingQuery.data?.data?.[0]?.outstanding) || 0) - cnOutstanding,
-      overdue: totalOverdue,
-      overdueCount,
-      currency, // Currency from document data
-    } as RevenueData,
-    isLoading: queries.some((q) => q.isLoading),
+    data: results ?? {
+      thisMonth: 0,
+      thisYear: 0,
+      outstanding: 0,
+      overdue: 0,
+      overdueCount: 0,
+      currency: "EUR",
+    },
+    isLoading,
   };
 }

package/src/components/dashboard/shared/use-stats-counts.ts

@@ -1,10 +1,10 @@
 /**
  * Stats counts hook using the entity stats API.
  * Server-side counting for accurate totals.
+ * Sends 4 queries in a single batch request.
  */
-import { useQueries } from "@tanstack/react-query";
-import { useSDK } from "@/ui/providers/sdk-provider";
-import { STATS_QUERY_CACHE_KEY } from "./use-stats-query";
+import type { StatsQueryRequest } from "@spaceinvoices/js-sdk";
+import { useStatsBatchQuery } from "./use-stats-query";
 
 export const STATS_COUNTS_CACHE_KEY = "dashboard-stats-counts";
 
@@ -16,74 +16,24 @@ export type StatsCountsData = {
 };
 
 export function useStatsCountsData(entityId: string | undefined) {
-  const { sdk } = useSDK();
+  const queries: StatsQueryRequest[] = [
+    { metrics: [{ type: "count", alias: "total" }], table: "invoices" },
+    { metrics: [{ type: "count", alias: "total" }], table: "estimates" },
+    { metrics: [{ type: "count", alias: "total" }], table: "customers" },
+    { metrics: [{ type: "count", alias: "total" }], table: "items" },
+  ];
 
-  const queries = useQueries({
-    queries: [
-      // Invoices count
-      {
-        queryKey: [STATS_QUERY_CACHE_KEY, entityId, "count-invoices"],
-        queryFn: async () => {
-          if (!entityId || !sdk) throw new Error("Missing entity or SDK");
-          return sdk.entityStats.queryEntityStats(
-            { metrics: [{ type: "count", alias: "total" }], table: "invoices" },
-            { entity_id: entityId },
-          );
-        },
-        enabled: !!entityId && !!sdk,
-        staleTime: 120_000,
-      },
-      // Estimates count
-      {
-        queryKey: [STATS_QUERY_CACHE_KEY, entityId, "count-estimates"],
-        queryFn: async () => {
-          if (!entityId || !sdk) throw new Error("Missing entity or SDK");
-          return sdk.entityStats.queryEntityStats(
-            { metrics: [{ type: "count", alias: "total" }], table: "estimates" },
-            { entity_id: entityId },
-          );
-        },
-        enabled: !!entityId && !!sdk,
-        staleTime: 120_000,
-      },
-      // Customers count
-      {
-        queryKey: [STATS_QUERY_CACHE_KEY, entityId, "count-customers"],
-        queryFn: async () => {
-          if (!entityId || !sdk) throw new Error("Missing entity or SDK");
-          return sdk.entityStats.queryEntityStats(
-            { metrics: [{ type: "count", alias: "total" }], table: "customers" },
-            { entity_id: entityId },
-          );
-        },
-        enabled: !!entityId && !!sdk,
-        staleTime: 120_000,
-      },
-      // Items count
-      {
-        queryKey: [STATS_QUERY_CACHE_KEY, entityId, "count-items"],
-        queryFn: async () => {
-          if (!entityId || !sdk) throw new Error("Missing entity or SDK");
-          return sdk.entityStats.queryEntityStats(
-            { metrics: [{ type: "count", alias: "total" }], table: "items" },
-            { entity_id: entityId },
-          );
-        },
-        enabled: !!entityId && !!sdk,
-        staleTime: 120_000,
-      },
-    ],
+  const { data: results, isLoading } = useStatsBatchQuery(entityId, "stats-counts", queries, {
+    select: (batch) => ({
+      invoices: Number(batch[0].data?.[0]?.total) || 0,
+      estimates: Number(batch[1].data?.[0]?.total) || 0,
+      customers: Number(batch[2].data?.[0]?.total) || 0,
+      items: Number(batch[3].data?.[0]?.total) || 0,
+    }),
   });
 
-  const [invoicesQuery, estimatesQuery, customersQuery, itemsQuery] = queries;
-
   return {
-    data: {
-      invoices: Number(invoicesQuery.data?.data?.[0]?.total) || 0,
-      estimates: Number(estimatesQuery.data?.data?.[0]?.total) || 0,
-      customers: Number(customersQuery.data?.data?.[0]?.total) || 0,
-      items: Number(itemsQuery.data?.data?.[0]?.total) || 0,
-    } as StatsCountsData,
-    isLoading: queries.some((q) => q.isLoading),
+    data: (results ?? { invoices: 0, estimates: 0, customers: 0, items: 0 }) as StatsCountsData,
+    isLoading,
   };
 }

package/src/components/dashboard/shared/use-stats-query.ts

@@ -2,7 +2,7 @@
  * Base hook for stats queries using the entity stats API.
  * Provides server-side aggregation instead of client-side calculation.
  */
-import type { StatsQueryRequest, StatsQueryResponse } from "@spaceinvoices/js-sdk";
+import type { StatsQueryBatchResponse, StatsQueryRequest, StatsQueryResponse } from "@spaceinvoices/js-sdk";
 import { type UseQueryOptions, useQuery } from "@tanstack/react-query";
 import { useSDK } from "@/ui/providers/sdk-provider";
 
@@ -14,8 +14,9 @@ export type StatsQueryOptions<TData = StatsQueryResponse> = Omit<
 >;
 
 /**
- * Generic hook for executing stats queries.
- * Use this as a base for specific stats hooks.
+ * Generic hook for executing a single stats query.
+ * Wraps the query in a batch array and unwraps the first result.
+ * Use this as a base for simple stats hooks.
  */
 export function useStatsQuery<TData = StatsQueryResponse>(
   entityId: string | undefined,
@@ -28,11 +29,40 @@ export function useStatsQuery<TData = StatsQueryResponse>(
     queryKey: [STATS_QUERY_CACHE_KEY, entityId, query],
     queryFn: async () => {
       if (!entityId || !sdk) throw new Error("Missing entity or SDK");
-      // SDK's wrapMethod already unwraps success response and throws on error
-      return await sdk.entityStats.queryEntityStats(query, { entity_id: entityId });
+      const results = await sdk.entityStats.queryEntityStats([query], { entity_id: entityId });
+      return results[0];
     },
     enabled: !!entityId && !!sdk,
     staleTime: 120_000, // 2 minutes
     ...options,
   });
 }
+
+export type StatsBatchQueryOptions<TData = StatsQueryBatchResponse> = Omit<
+  UseQueryOptions<StatsQueryBatchResponse, Error, TData>,
+  "queryKey" | "queryFn"
+>;
+
+/**
+ * Hook for executing a batch of stats queries in a single request.
+ * Returns all results in the same order as the input queries.
+ */
+export function useStatsBatchQuery<TData = StatsQueryBatchResponse>(
+  entityId: string | undefined,
+  queryKey: string,
+  queries: StatsQueryRequest[],
+  options?: StatsBatchQueryOptions<TData>,
+) {
+  const { sdk } = useSDK();
+
+  return useQuery({
+    queryKey: [STATS_QUERY_CACHE_KEY, entityId, queryKey, queries],
+    queryFn: async () => {
+      if (!entityId || !sdk) throw new Error("Missing entity or SDK");
+      return sdk.entityStats.queryEntityStats(queries, { entity_id: entityId });
+    },
+    enabled: !!entityId && !!sdk,
+    staleTime: 120_000,
+    ...options,
+  });
+}

package/src/components/dashboard/tax-collected-card/use-tax-collected.ts

@@ -1,10 +1,10 @@
 /**
  * Tax collected hook - uses stats API to aggregate tax amounts by rate.
  * Shows tax breakdown for previous month and current year.
+ * Sends 2 queries in a single batch request.
  */
-import type { StatsQueryDataItem } from "@spaceinvoices/js-sdk";
-import { useQueries } from "@tanstack/react-query";
-import { useSDK } from "@/ui/providers/sdk-provider";
+import type { StatsQueryDataItem, StatsQueryRequest } from "@spaceinvoices/js-sdk";
+import { useStatsBatchQuery } from "../shared/use-stats-query";
 
 export const TAX_COLLECTED_CACHE_KEY = "dashboard-tax-collected";
 
@@ -55,91 +55,73 @@ function transformTaxData(data: StatsQueryDataItem[]): TaxByRate[] {
   return data
     .filter((row) => row.rate != null && row.tax_total != null)
     .map((row) => ({
-      name: "Tax", // Could be enhanced to include tax name if available
+      name: "Tax",
       rate: Number(row.rate),
       amount: Number(row.tax_total),
     }))
-    .sort((a, b) => b.rate - a.rate); // Sort by rate descending
+    .sort((a, b) => b.rate - a.rate);
 }
 
 export function useTaxCollectedData(entityId: string | undefined) {
-  const { sdk } = useSDK();
   const prevMonthRange = getPreviousMonthDateRange();
   const yearRange = getYearDateRange();
 
-  const queries = useQueries({
-    queries: [
-      // Previous month taxes - aggregated by rate using stats API
-      {
-        queryKey: [TAX_COLLECTED_CACHE_KEY, entityId, "prev-month", prevMonthRange.from],
-        queryFn: async () => {
-          if (!entityId || !sdk) throw new Error("Missing entity or SDK");
-          // Use invoice_taxes virtual table to aggregate taxes by rate
-          return sdk.entityStats.queryEntityStats(
-            {
-              table: "invoice_taxes",
-              metrics: [{ type: "sum", field: "tax", alias: "tax_total" }],
-              group_by: ["rate", "quote_currency"],
-              date_from: prevMonthRange.from,
-              date_to: prevMonthRange.to,
-              filters: { is_draft: false, voided_at: null },
-            },
-            { entity_id: entityId },
-          );
-        },
-        enabled: !!entityId && !!sdk,
-        staleTime: 120_000, // 1 minute
-      },
-      // Current year taxes - aggregated by rate using stats API
-      {
-        queryKey: [TAX_COLLECTED_CACHE_KEY, entityId, "year", yearRange.from],
-        queryFn: async () => {
-          if (!entityId || !sdk) throw new Error("Missing entity or SDK");
-          return sdk.entityStats.queryEntityStats(
-            {
-              table: "invoice_taxes",
-              metrics: [{ type: "sum", field: "tax", alias: "tax_total" }],
-              group_by: ["rate", "quote_currency"],
-              date_from: yearRange.from,
-              date_to: yearRange.to,
-              filters: { is_draft: false, voided_at: null },
-            },
-            { entity_id: entityId },
-          );
-        },
-        enabled: !!entityId && !!sdk,
-        staleTime: 120_000,
-      },
-    ],
-  });
+  const queries: StatsQueryRequest[] = [
+    // [0] Previous month taxes
+    {
+      table: "invoice_taxes",
+      metrics: [{ type: "sum", field: "tax", alias: "tax_total" }],
+      group_by: ["rate", "quote_currency"],
+      date_from: prevMonthRange.from,
+      date_to: prevMonthRange.to,
+      filters: { is_draft: false, voided_at: null },
+    },
+    // [1] Current year taxes
+    {
+      table: "invoice_taxes",
+      metrics: [{ type: "sum", field: "tax", alias: "tax_total" }],
+      group_by: ["rate", "quote_currency"],
+      date_from: yearRange.from,
+      date_to: yearRange.to,
+      filters: { is_draft: false, voided_at: null },
+    },
+  ];
 
-  const [prevMonthQuery, yearQuery] = queries;
+  const {
+    data: results,
+    isLoading,
+    error,
+  } = useStatsBatchQuery(entityId, "tax-collected", queries, {
+    select: (batch) => {
+      const prevMonthTaxes = transformTaxData(batch[0].data || []);
+      const yearTaxes = transformTaxData(batch[1].data || []);
 
-  // Transform stats data to TaxByRate arrays
-  const prevMonthTaxes = transformTaxData(prevMonthQuery.data?.data || []);
-  const yearTaxes = transformTaxData(yearQuery.data?.data || []);
+      const currency =
+        (batch[0].data?.[0]?.quote_currency as string) || (batch[1].data?.[0]?.quote_currency as string) || "EUR";
 
-  // Get currency from first result or default
-  const currency =
-    (prevMonthQuery.data?.data?.[0]?.quote_currency as string) ||
-    (yearQuery.data?.data?.[0]?.quote_currency as string) ||
-    "EUR";
+      return {
+        previousMonth: {
+          label: prevMonthRange.label,
+          taxes: prevMonthTaxes,
+          total: prevMonthTaxes.reduce((sum, t) => sum + t.amount, 0),
+        },
+        currentYear: {
+          label: yearRange.label,
+          taxes: yearTaxes,
+          total: yearTaxes.reduce((sum, t) => sum + t.amount, 0),
+        },
+        currency,
+      } as TaxCollectedData;
+    },
+  });
 
   return {
-    data: {
-      previousMonth: {
-        label: prevMonthRange.label,
-        taxes: prevMonthTaxes,
-        total: prevMonthTaxes.reduce((sum, t) => sum + t.amount, 0),
-      },
-      currentYear: {
-        label: yearRange.label,
-        taxes: yearTaxes,
-        total: yearTaxes.reduce((sum, t) => sum + t.amount, 0),
-      },
-      currency,
-    } as TaxCollectedData,
-    isLoading: queries.some((q) => q.isLoading),
-    error: queries.find((q) => q.error)?.error,
+    data: results ?? {
+      previousMonth: { label: prevMonthRange.label, taxes: [], total: 0 },
+      currentYear: { label: yearRange.label, taxes: [], total: 0 },
+      currency: "EUR",
+    },
+    isLoading,
+    error,
   };
 }