@pol-studios/db 1.0.9 → 1.0.10

package/dist/chunk-3M2U6TXH.js

@@ -0,0 +1,928 @@
+import {
+  getSupabaseUrl
+} from "./chunk-Y3INY2CS.js";
+import {
+  omit
+} from "./chunk-O3K7R32P.js";
+import {
+  useSupabase
+} from "./chunk-AWFMICFV.js";
+
+// src/providers/DataLayerContext.ts
+import { createContext } from "react";
+var DataLayerContext = createContext(null);
+DataLayerContext.displayName = "DataLayerContext";
+
+// src/hooks/useDataLayer.ts
+import { useContext } from "react";
+function useDataLayer() {
+  const context = useContext(DataLayerContext);
+  if (!context) {
+    throw new Error(
+      "useDataLayer must be used within a DataLayerProvider. Make sure you have wrapped your app with <DataLayerProvider>."
+    );
+  }
+  return context;
+}
+function useDataLayerOptional() {
+  return useContext(DataLayerContext);
+}
+
+// src/hooks/useDbQuery.ts
+import { useMemo, useEffect, useCallback } from "react";
+import { useQuery } from "@tanstack/react-query";
+function buildQueryKey(table, options, isInitialized, backend) {
+  return [
+    "v3",
+    "query",
+    table,
+    isInitialized,
+    backend,
+    options.select ?? "*",
+    JSON.stringify(options.where ?? {}),
+    JSON.stringify(options.orderBy ?? []),
+    options.limit,
+    options.offset
+  ];
+}
+function serializeQueryOptions(options) {
+  return JSON.stringify({
+    select: options.select,
+    where: options.where,
+    orderBy: options.orderBy,
+    limit: options.limit,
+    offset: options.offset
+  });
+}
+function resolveTableName(table) {
+  if (typeof table === "string") {
+    return table;
+  }
+  return `${table.schema}.${table.table}`;
+}
+function useDbQuery(table, options = {}) {
+  const tableName = typeof table === "string" ? table : resolveTableName(table);
+  const { registry, status, queryClient } = useDataLayer();
+  const isPowerSync = status.currentBackend === "powersync";
+  const {
+    enabled = true,
+    staleTime = isPowerSync ? 0 : 3e4,
+    gcTime = 3e5,
+    // 5 minutes - keep in memory for instant display while refetching
+    refetchOnWindowFocus = true,
+    refetchOnMount = isPowerSync ? "always" : true,
+    realtime = isPowerSync,
+    // Enable real-time subscriptions by default for PowerSync
+    ...queryOptions
+  } = options;
+  const adapter = useMemo(() => {
+    if (!status.isInitialized) return null;
+    try {
+      return registry.getAdapter(tableName);
+    } catch {
+      return null;
+    }
+  }, [registry, tableName, status.isInitialized, status.currentBackend]);
+  const queryKey = useMemo(
+    () => buildQueryKey(tableName, options, status.isInitialized, status.currentBackend),
+    [tableName, serializeQueryOptions(options), status.isInitialized, status.currentBackend]
+  );
+  const memoizedQueryOptions = useMemo(
+    () => ({
+      select: queryOptions.select,
+      where: queryOptions.where,
+      orderBy: queryOptions.orderBy,
+      limit: queryOptions.limit,
+      offset: queryOptions.offset
+    }),
+    [serializeQueryOptions(queryOptions)]
+  );
+  const queryFn = useCallback(async () => {
+    if (!adapter) {
+      throw new Error(`Adapter not available for table: ${tableName}`);
+    }
+    const result = await adapter.query(tableName, memoizedQueryOptions);
+    return result;
+  }, [adapter, tableName, memoizedQueryOptions]);
+  const query = useQuery({
+    queryKey,
+    queryFn,
+    enabled: enabled && status.isInitialized && adapter !== null,
+    staleTime,
+    gcTime,
+    refetchOnWindowFocus,
+    refetchOnMount
+  });
+  useEffect(() => {
+    if (!realtime || !adapter?.subscribe || !status.isInitialized) {
+      return;
+    }
+    const unsubscribe = adapter.subscribe(
+      tableName,
+      memoizedQueryOptions,
+      (data) => {
+        queryClient.setQueryData(queryKey, { data, count: data.length });
+      }
+    );
+    return () => {
+      unsubscribe();
+    };
+  }, [
+    realtime,
+    adapter,
+    tableName,
+    memoizedQueryOptions,
+    queryClient,
+    queryKey,
+    status.isInitialized
+  ]);
+  const refetch = useCallback(async () => {
+    await query.refetch();
+  }, [query]);
+  return {
+    data: query.data?.data,
+    isLoading: query.isLoading,
+    isPending: query.isPending,
+    isFetching: query.isFetching,
+    isRefetching: query.isFetching,
+    // Alias for V2 compatibility
+    isSuccess: query.isSuccess,
+    isError: query.isError,
+    error: query.error,
+    refetch,
+    count: query.data?.count,
+    isStale: query.isStale,
+    dataUpdatedAt: query.dataUpdatedAt ?? null
+  };
+}
+
+// src/hooks/useDbQueryById.ts
+import { useMemo as useMemo2, useCallback as useCallback2 } from "react";
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+function buildQueryKey2(table, id, select) {
+  return ["v3", "queryById", table, id, select ?? "*"];
+}
+function useDbQueryById(table, id, options = {}) {
+  const { registry, status } = useDataLayer();
+  const { select, enabled = id != null, staleTime = 3e4 } = options;
+  const adapter = useMemo2(() => {
+    if (!status.isInitialized) return null;
+    try {
+      return registry.getAdapter(table);
+    } catch {
+      return null;
+    }
+  }, [registry, table, status.isInitialized, status.currentBackend]);
+  const queryKey = useMemo2(
+    () => buildQueryKey2(table, id, select),
+    [table, id, select]
+  );
+  const queryFn = useCallback2(async () => {
+    if (!adapter) {
+      throw new Error(`Adapter not available for table: ${table}`);
+    }
+    if (id == null) {
+      return null;
+    }
+    if (adapter.queryById) {
+      return adapter.queryById(table, String(id), { select });
+    }
+    const result = await adapter.query(table, {
+      select,
+      where: { id },
+      limit: 1
+    });
+    return result.data[0] ?? null;
+  }, [adapter, table, id, select]);
+  const query = useQuery2({
+    queryKey,
+    queryFn,
+    enabled: enabled && status.isInitialized && adapter !== null && id != null,
+    staleTime
+  });
+  const refetch = useCallback2(async () => {
+    await query.refetch();
+  }, [query]);
+  return {
+    data: query.data,
+    isLoading: query.isLoading,
+    isPending: query.isPending,
+    isFetching: query.isFetching,
+    error: query.error,
+    refetch
+  };
+}
+
+// src/hooks/useAdvanceQuery.ts
+import {
+  useCallback as useCallback3,
+  useMemo as useMemo3,
+  useState,
+  useEffect as useEffect2
+} from "react";
+import { useQuery as useQuery3 } from "@tanstack/react-query";
+import { useSessionStorageState } from "@pol-studios/hooks/storage";
+var createDefaultFilterState = () => ({
+  id: "root",
+  op: "AND",
+  filters: [],
+  pagination: void 0,
+  sort: [],
+  isReady: true
+});
+function useAdvanceQuery(table, options) {
+  const tableName = typeof table === "string" ? table : `${table.schema}.${table.table}`;
+  const { registry, status, queryClient } = useDataLayer();
+  const supabase = useSupabase();
+  const {
+    filterKey,
+    initialFilters,
+    enabled = true,
+    timeout = 15e3,
+    count = "exact",
+    realtime,
+    select,
+    where,
+    orderBy,
+    limit,
+    offset,
+    ...restOptions
+  } = options;
+  const isPowerSync = status.currentBackend === "powersync";
+  const realtimeEnabled = realtime ?? isPowerSync;
+  const defaultFilterState = useMemo3(
+    () => initialFilters ?? createDefaultFilterState(),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+    // Only compute once
+  );
+  const [filtersRaw, setFiltersRaw] = useSessionStorageState(
+    filterKey,
+    defaultFilterState
+  );
+  const filters = filtersRaw ?? defaultFilterState;
+  const setFilters = useCallback3(
+    (action) => {
+      if (typeof action === "function") {
+        setFiltersRaw((prev) => action(prev ?? defaultFilterState));
+      } else {
+        setFiltersRaw(action);
+      }
+    },
+    [setFiltersRaw, defaultFilterState]
+  );
+  const hasAdvancedFilters = useMemo3(
+    () => (filters?.filters?.length ?? 0) > 0 || !!filters?.naturalLanguageQuery,
+    [filters?.filters?.length, filters?.naturalLanguageQuery]
+  );
+  const usePowerSyncPath = !hasAdvancedFilters && isPowerSync;
+  const powerSyncOrderBy = useMemo3(() => {
+    if (filters?.sort && filters.sort.length > 0) {
+      return filters.sort.map((s) => ({
+        field: s.field,
+        direction: s.direction
+      }));
+    }
+    return orderBy;
+  }, [filters?.sort, orderBy]);
+  const powerSyncResult = useDbQuery(table, {
+    select,
+    where,
+    orderBy: powerSyncOrderBy,
+    limit: filters?.pagination?.limit ?? limit,
+    offset: filters?.pagination?.offset ?? offset,
+    enabled: enabled && usePowerSyncPath && filters?.isReady !== false,
+    realtime: realtimeEnabled
+    // Enable watch() subscriptions for reactive updates
+  });
+  const [extraData, setExtraData] = useState({});
+  const edgeFunctionQueryKey = useMemo3(
+    () => [
+      "v3",
+      "advance-query",
+      tableName,
+      select,
+      JSON.stringify(where),
+      JSON.stringify(filters),
+      status.currentBackend
+    ],
+    [tableName, select, where, filters, status.currentBackend]
+  );
+  const edgeFunctionResult = useQuery3({
+    queryKey: edgeFunctionQueryKey,
+    queryFn: async ({ signal }) => {
+      const { data: { session } } = await supabase.auth.getSession();
+      if (!session?.access_token) {
+        throw new Error("No active session");
+      }
+      const controller = new AbortController();
+      signal.addEventListener("abort", () => controller.abort());
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      try {
+        const filterBody = {
+          id: filters.id || "root",
+          op: filters.op || "AND",
+          not: filters.not,
+          filters: filters.filters || []
+        };
+        const baseFilters = [];
+        if (where) {
+          Object.entries(where).forEach(([field, value]) => {
+            if (value !== void 0 && value !== null) {
+              if (typeof value === "object" && "in" in value) {
+                baseFilters.push({
+                  id: `base-${field}`,
+                  field,
+                  op: "in",
+                  value: value.in
+                });
+              } else {
+                baseFilters.push({
+                  id: `base-${field}`,
+                  field,
+                  op: "=",
+                  value
+                });
+              }
+            }
+          });
+        }
+        const combinedFilters = [...baseFilters, ...filterBody.filters];
+        const currentKey = `${tableName}${select}${JSON.stringify(omit(filters, ["pagination", "isReady"]))}`;
+        const res = await fetch(
+          `${getSupabaseUrl()}/functions/v1/query?forceDenoVersion=2`,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${session.access_token}`
+            },
+            body: JSON.stringify({
+              table: tableName,
+              schema: "public",
+              select: select ?? "*",
+              filters: {
+                id: filterBody.id,
+                op: filterBody.op,
+                not: filterBody.not,
+                filters: combinedFilters
+              },
+              pagination: filters.pagination,
+              sort: filters.sort || orderBy?.map((o) => ({
+                field: o.field,
+                direction: o.direction
+              })),
+              distinctOn: filters.distinctOn,
+              naturalLanguageQuery: filters.naturalLanguageQuery,
+              count: currentKey === extraData.key ? "" : count
+            }),
+            signal: controller.signal
+          }
+        );
+        if (!res.ok) {
+          const errorData = await res.json();
+          const errorMessage = typeof errorData?.error === "string" ? errorData.error : errorData?.error?.message || errorData?.message || "Query failed";
+          throw new Error(errorMessage);
+        }
+        const result2 = await res.json();
+        if (result2.clarification) {
+          return {
+            data: [],
+            count: 0,
+            clarification: result2.clarification
+          };
+        }
+        setExtraData((prev) => ({
+          count: prev.key === currentKey ? prev.count : result2.count,
+          key: currentKey
+        }));
+        return {
+          data: result2.data,
+          count: result2.count
+        };
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    },
+    enabled: enabled && !usePowerSyncPath && filters?.isReady !== false,
+    staleTime: 3e4,
+    gcTime: 3e5,
+    refetchOnMount: true,
+    refetchOnWindowFocus: false
+  });
+  useEffect2(() => {
+    if (!realtimeEnabled || usePowerSyncPath || !enabled) {
+      return;
+    }
+    const channel = supabase.channel(`advance-query-${tableName}-${filterKey}`).on(
+      "postgres_changes",
+      {
+        event: "*",
+        // Listen to INSERT, UPDATE, DELETE
+        schema: "public",
+        table: tableName
+        // Note: We can't easily filter by complex where clauses,
+        // so we invalidate on any change to the table
+      },
+      () => {
+        queryClient.invalidateQueries({ queryKey: edgeFunctionQueryKey });
+      }
+    ).subscribe();
+    return () => {
+      supabase.removeChannel(channel);
+    };
+  }, [
+    realtimeEnabled,
+    usePowerSyncPath,
+    enabled,
+    supabase,
+    tableName,
+    filterKey,
+    queryClient,
+    edgeFunctionQueryKey
+  ]);
+  const result = useMemo3(() => {
+    if (usePowerSyncPath) {
+      return {
+        data: powerSyncResult.data,
+        isLoading: powerSyncResult.isLoading,
+        isPending: powerSyncResult.isPending,
+        isFetching: powerSyncResult.isFetching,
+        isRefetching: powerSyncResult.isRefetching,
+        isSuccess: powerSyncResult.isSuccess,
+        isError: powerSyncResult.isError,
+        error: powerSyncResult.error,
+        refetch: powerSyncResult.refetch,
+        count: powerSyncResult.count ?? powerSyncResult.data?.length
+      };
+    }
+    return {
+      data: edgeFunctionResult.data?.data,
+      isLoading: edgeFunctionResult.isLoading,
+      isPending: edgeFunctionResult.isPending,
+      isFetching: edgeFunctionResult.isFetching,
+      isRefetching: edgeFunctionResult.isFetching,
+      isSuccess: edgeFunctionResult.isSuccess,
+      isError: edgeFunctionResult.isError,
+      error: edgeFunctionResult.error,
+      refetch: async () => {
+        await edgeFunctionResult.refetch();
+      },
+      count: edgeFunctionResult.data?.count ?? extraData.count,
+      clarification: edgeFunctionResult.data?.clarification
+    };
+  }, [
+    usePowerSyncPath,
+    powerSyncResult,
+    edgeFunctionResult,
+    extraData.count
+  ]);
+  return [result, filters, setFilters];
+}
+
+// src/hooks/useDbInsert.ts
+import { useCallback as useCallback4, useMemo as useMemo4 } from "react";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+function useDbInsert(table, options = {}) {
+  const { registry, status } = useDataLayer();
+  const queryClient = useQueryClient();
+  const { onSuccess, onError, invalidateTables = [table] } = options;
+  const adapter = useMemo4(() => {
+    if (!status.isInitialized) return null;
+    try {
+      return registry.getAdapter(table);
+    } catch {
+      return null;
+    }
+  }, [registry, table, status.isInitialized, status.currentBackend]);
+  const mutationFn = useCallback4(
+    async (data) => {
+      if (!adapter) {
+        throw new Error(`Adapter not available for table: ${table}`);
+      }
+      return adapter.insert(table, data);
+    },
+    [adapter, table]
+  );
+  const mutation = useMutation({
+    mutationFn,
+    onSuccess: (data) => {
+      invalidateTables.forEach((t) => {
+        queryClient.invalidateQueries({
+          predicate: (query) => query.queryKey[0] === "v3" && query.queryKey[2] === t
+        });
+      });
+      onSuccess?.(data);
+    },
+    onError: (error) => {
+      onError?.(error instanceof Error ? error : new Error(String(error)));
+    }
+  });
+  return {
+    mutate: mutation.mutate,
+    mutateAsync: mutation.mutateAsync,
+    isPending: mutation.isPending,
+    error: mutation.error,
+    reset: mutation.reset,
+    data: mutation.data
+  };
+}
+
+// src/hooks/useDbUpdate.ts
+import { useCallback as useCallback5, useMemo as useMemo5 } from "react";
+import { useMutation as useMutation2, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+function useDbUpdate(table, options = {}) {
+  const { registry, status } = useDataLayer();
+  const queryClient = useQueryClient2();
+  const {
+    onSuccess,
+    onError,
+    invalidateTables = [table],
+    optimistic = false
+  } = options;
+  const adapter = useMemo5(() => {
+    if (!status.isInitialized) return null;
+    try {
+      return registry.getAdapter(table);
+    } catch {
+      return null;
+    }
+  }, [registry, table, status.isInitialized, status.currentBackend]);
+  const mutationFn = useCallback5(
+    async (params) => {
+      if (!adapter) {
+        throw new Error(`Adapter not available for table: ${table}`);
+      }
+      return adapter.update(table, params.id, params.data);
+    },
+    [adapter, table]
+  );
+  const mutation = useMutation2({
+    mutationFn,
+    onMutate: optimistic ? async () => {
+      await queryClient.cancelQueries({
+        predicate: (query) => query.queryKey[0] === "v3" && query.queryKey[2] === table
+      });
+      const previousData = queryClient.getQueriesData({
+        predicate: (query) => query.queryKey[0] === "v3" && query.queryKey[2] === table
+      });
+      return { previousData };
+    } : void 0,
+    onSuccess: (data) => {
+      invalidateTables.forEach((t) => {
+        queryClient.invalidateQueries({
+          predicate: (query) => query.queryKey[0] === "v3" && query.queryKey[2] === t
+        });
+      });
+      onSuccess?.(data);
+    },
+    onError: (error, _variables, context) => {
+      if (optimistic && context?.previousData) {
+        context.previousData.forEach(([queryKey, data]) => {
+          queryClient.setQueryData(queryKey, data);
+        });
+      }
+      onError?.(error instanceof Error ? error : new Error(String(error)));
+    }
+  });
+  return {
+    mutate: mutation.mutate,
+    mutateAsync: mutation.mutateAsync,
+    isPending: mutation.isPending,
+    error: mutation.error,
+    reset: mutation.reset,
+    data: mutation.data
+  };
+}
+
+// src/hooks/useDbUpsert.ts
+import { useCallback as useCallback6, useMemo as useMemo6 } from "react";
+import { useMutation as useMutation3, useQueryClient as useQueryClient3 } from "@tanstack/react-query";
+function useDbUpsert(table, options = {}) {
+  const { registry, status } = useDataLayer();
+  const queryClient = useQueryClient3();
+  const { onSuccess, onError, invalidateTables = [table] } = options;
+  const adapter = useMemo6(() => {
+    if (!status.isInitialized) return null;
+    try {
+      return registry.getAdapter(table);
+    } catch {
+      return null;
+    }
+  }, [registry, table, status.isInitialized, status.currentBackend]);
+  const mutationFn = useCallback6(
+    async (data) => {
+      if (!adapter) {
+        throw new Error(`Adapter not available for table: ${table}`);
+      }
+      return adapter.upsert(table, data);
+    },
+    [adapter, table]
+  );
+  const mutation = useMutation3({
+    mutationFn,
+    onSuccess: (data) => {
+      invalidateTables.forEach((t) => {
+        queryClient.invalidateQueries({
+          predicate: (query) => query.queryKey[0] === "v3" && query.queryKey[2] === t
+        });
+      });
+      onSuccess?.(data);
+    },
+    onError: (error) => {
+      onError?.(error instanceof Error ? error : new Error(String(error)));
+    }
+  });
+  return {
+    mutate: mutation.mutate,
+    mutateAsync: mutation.mutateAsync,
+    isPending: mutation.isPending,
+    error: mutation.error,
+    reset: mutation.reset,
+    data: mutation.data
+  };
+}
+
+// src/hooks/useDbDelete.ts
+import { useCallback as useCallback7, useMemo as useMemo7 } from "react";
+import { useMutation as useMutation4, useQueryClient as useQueryClient4 } from "@tanstack/react-query";
+function useDbDelete(table, options = {}) {
+  const { registry, status } = useDataLayer();
+  const queryClient = useQueryClient4();
+  const {
+    onSuccess,
+    onError,
+    invalidateTables = [table],
+    optimistic = false
+  } = options;
+  const adapter = useMemo7(() => {
+    if (!status.isInitialized) return null;
+    try {
+      return registry.getAdapter(table);
+    } catch {
+      return null;
+    }
+  }, [registry, table, status.isInitialized, status.currentBackend]);
+  const mutationFn = useCallback7(
+    async (id) => {
+      if (!adapter) {
+        throw new Error(`Adapter not available for table: ${table}`);
+      }
+      await adapter.delete(table, id);
+    },
+    [adapter, table]
+  );
+  const mutation = useMutation4({
+    mutationFn,
+    onMutate: optimistic ? async (id) => {
+      await queryClient.cancelQueries({
+        predicate: (query) => query.queryKey[0] === "v3" && query.queryKey[2] === table
+      });
+      const previousData = queryClient.getQueriesData({
+        predicate: (query) => query.queryKey[0] === "v3" && query.queryKey[2] === table
+      });
+      queryClient.setQueriesData(
+        {
+          predicate: (query) => query.queryKey[0] === "v3" && query.queryKey[2] === table
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (old) => {
+          if (!old?.data) return old;
+          return {
+            ...old,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            data: old.data.filter((item) => item.id !== id)
+          };
+        }
+      );
+      return { previousData };
+    } : void 0,
+    onSuccess: () => {
+      invalidateTables.forEach((t) => {
+        queryClient.invalidateQueries({
+          predicate: (query) => query.queryKey[0] === "v3" && query.queryKey[2] === t
+        });
+      });
+      onSuccess?.();
+    },
+    onError: (error, _id, context) => {
+      if (optimistic && context?.previousData) {
+        context.previousData.forEach(([queryKey, data]) => {
+          queryClient.setQueryData(queryKey, data);
+        });
+      }
+      onError?.(error instanceof Error ? error : new Error(String(error)));
+    }
+  });
+  return {
+    mutate: mutation.mutate,
+    mutateAsync: mutation.mutateAsync,
+    isPending: mutation.isPending,
+    error: mutation.error,
+    reset: mutation.reset
+  };
+}
+
+// src/hooks/useDbInfiniteQuery.ts
+import { useMemo as useMemo8, useCallback as useCallback8 } from "react";
+import { useInfiniteQuery } from "@tanstack/react-query";
+function buildInfiniteQueryKey(table, options) {
+  return [
+    "v3",
+    "infinite-query",
+    table,
+    options.select ?? "*",
+    JSON.stringify(options.where ?? {}),
+    JSON.stringify(options.orderBy ?? []),
+    options.pageSize ?? 50,
+    options.searchText ?? "",
+    JSON.stringify(options.searchFields ?? [])
+  ];
+}
+function serializeInfiniteQueryOptions(options) {
+  return JSON.stringify({
+    select: options.select,
+    where: options.where,
+    orderBy: options.orderBy,
+    pageSize: options.pageSize,
+    searchText: options.searchText,
+    searchFields: options.searchFields
+  });
+}
+function resolveTableName2(table) {
+  if (typeof table === "string") {
+    return table;
+  }
+  return `${table.schema}.${table.table}`;
+}
+function buildSearchWhereClause(searchText, searchFields, existingWhere) {
+  const searchWhere = {};
+  if (searchFields.length === 1) {
+    searchWhere[searchFields[0]] = { like: `%${searchText}%` };
+  } else if (searchFields.length > 1) {
+    searchWhere[searchFields[0]] = { like: `%${searchText}%` };
+  }
+  return {
+    ...existingWhere,
+    ...searchWhere
+  };
+}
+function useDbInfiniteQuery(table, options = {}) {
+  const tableName = resolveTableName2(table);
+  const { registry, status } = useDataLayer();
+  const {
+    enabled = true,
+    staleTime = 3e4,
+    refetchOnWindowFocus = true,
+    pageSize = 50,
+    searchText,
+    searchFields,
+    ...queryOptions
+  } = options;
+  const adapter = useMemo8(() => {
+    if (!status.isInitialized) return null;
+    try {
+      return registry.getAdapter(tableName);
+    } catch {
+      return null;
+    }
+  }, [registry, tableName, status.isInitialized, status.currentBackend]);
+  const queryKey = useMemo8(
+    () => buildInfiniteQueryKey(tableName, options),
+    [tableName, serializeInfiniteQueryOptions(options)]
+  );
+  const effectiveWhere = useMemo8(() => {
+    if (searchText && searchFields && searchFields.length > 0) {
+      return buildSearchWhereClause(searchText, searchFields, queryOptions.where);
+    }
+    return queryOptions.where;
+  }, [searchText, searchFields, queryOptions.where]);
+  const memoizedQueryOptions = useMemo8(
+    () => ({
+      select: queryOptions.select,
+      where: effectiveWhere,
+      orderBy: queryOptions.orderBy
+    }),
+    [queryOptions.select, effectiveWhere, queryOptions.orderBy]
+  );
+  const infiniteQuery = useInfiniteQuery({
+    queryKey,
+    queryFn: async ({ pageParam }) => {
+      if (!adapter) {
+        throw new Error(`Adapter not available for table: ${tableName}`);
+      }
+      const offset = (pageParam - 1) * pageSize;
+      const result = await adapter.query(tableName, {
+        ...memoizedQueryOptions,
+        limit: pageSize,
+        offset
+      });
+      return {
+        data: result.data ?? [],
+        count: result.count
+      };
+    },
+    initialPageParam: 1,
+    getNextPageParam: (lastPage, allPages) => {
+      const totalLoaded = allPages.reduce((sum, page) => sum + page.data.length, 0);
+      const totalCount = lastPage.count;
+      if (totalCount !== void 0 && totalLoaded >= totalCount) {
+        return void 0;
+      }
+      if (lastPage.data.length < pageSize) {
+        return void 0;
+      }
+      return allPages.length + 1;
+    },
+    enabled: enabled && status.isInitialized && adapter !== null,
+    staleTime,
+    refetchOnWindowFocus
+  });
+  const flattenedData = useMemo8(() => {
+    if (!infiniteQuery.data?.pages) return void 0;
+    return infiniteQuery.data.pages.flatMap((page) => page.data);
+  }, [infiniteQuery.data?.pages]);
+  const count = useMemo8(() => {
+    if (!infiniteQuery.data?.pages || infiniteQuery.data.pages.length === 0) {
+      return void 0;
+    }
+    return infiniteQuery.data.pages[infiniteQuery.data.pages.length - 1].count;
+  }, [infiniteQuery.data?.pages]);
+  const fetchNextPage = useCallback8(async () => {
+    await infiniteQuery.fetchNextPage();
+  }, [infiniteQuery]);
+  const refetch = useCallback8(async () => {
+    await infiniteQuery.refetch();
+  }, [infiniteQuery]);
+  return {
+    data: flattenedData,
+    isLoading: infiniteQuery.isLoading,
+    isPending: infiniteQuery.isPending,
+    isFetching: infiniteQuery.isFetching,
+    error: infiniteQuery.error,
+    fetchNextPage,
+    hasNextPage: infiniteQuery.hasNextPage ?? false,
+    isFetchingNextPage: infiniteQuery.isFetchingNextPage,
+    count,
+    refetch
+  };
+}
+
+// src/hooks/useDbCount.ts
+import { useMemo as useMemo9, useCallback as useCallback9 } from "react";
+import { useQuery as useQuery4 } from "@tanstack/react-query";
+function useDbCount(table, options = {}) {
+  const { registry, status } = useDataLayer();
+  const { enabled = true, staleTime = 3e4, where } = options;
+  const adapter = useMemo9(() => {
+    if (!status.isInitialized) return null;
+    try {
+      return registry.getAdapter(table);
+    } catch {
+      return null;
+    }
+  }, [registry, table, status.isInitialized, status.currentBackend]);
+  const queryKey = useMemo9(
+    () => ["v3", "count", table, JSON.stringify(where ?? {})],
+    [table, where]
+  );
+  const queryFn = useCallback9(async () => {
+    if (!adapter) {
+      throw new Error(`Adapter not available for table: ${table}`);
+    }
+    const result = await adapter.query(table, { where, select: "id" });
+    return result.count ?? result.data.length;
+  }, [adapter, table, where]);
+  const query = useQuery4({
+    queryKey,
+    queryFn,
+    enabled: enabled && status.isInitialized && adapter !== null,
+    staleTime
+  });
+  const refetch = useCallback9(async () => {
+    await query.refetch();
+  }, [query]);
+  return {
+    count: query.data,
+    isLoading: query.isLoading,
+    isFetching: query.isFetching,
+    error: query.error,
+    refetch
+  };
+}
+
+export {
+  DataLayerContext,
+  useDataLayer,
+  useDataLayerOptional,
+  useDbQuery,
+  useDbQueryById,
+  useAdvanceQuery,
+  useDbInsert,
+  useDbUpdate,
+  useDbUpsert,
+  useDbDelete,
+  useDbInfiniteQuery,
+  useDbCount
+};
+//# sourceMappingURL=chunk-3M2U6TXH.js.map