@pol-studios/db 1.0.10 → 1.0.12

package/dist/chunk-ZVBHWU7O.js

@@ -0,0 +1,1412 @@
+import {
+  getSupabaseUrl
+} from "./chunk-GC3TBUWE.js";
+import {
+  omit
+} from "./chunk-OQ7U6EQ3.js";
+import {
+  useSupabase
+} from "./chunk-5EFDS7SR.js";
+
+// src/hooks/useDataLayer.ts
+import { useContext } from "react";
+
+// src/providers/DataLayerContext.ts
+import { createContext } from "react";
+var DataLayerContext = createContext(null);
+DataLayerContext.displayName = "DataLayerContext";
+
+// src/hooks/useDataLayer.ts
+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) {
+  return ["v3", "query", table, 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), [tableName, serializeQueryOptions(options)]);
+  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) => {
+      const hasRelations = memoizedQueryOptions.select?.includes("(");
+      if (hasRelations) {
+        queryClient.invalidateQueries({
+          queryKey
+        });
+      } else {
+        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 { useCallback as useCallback2, useMemo as useMemo2 } 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;
+  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 { c as _c } from "react/compiler-runtime";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+function useDbInsert(table, t0) {
+  const $ = _c(28);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === void 0 ? {} : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const options = t1;
+  const {
+    registry,
+    status
+  } = useDataLayer();
+  const queryClient = useQueryClient();
+  const {
+    onSuccess,
+    onError,
+    invalidateTables: t2
+  } = options;
+  let t3;
+  if ($[2] !== t2 || $[3] !== table) {
+    t3 = t2 === void 0 ? [table] : t2;
+    $[2] = t2;
+    $[3] = table;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  const invalidateTables = t3;
+  let t4;
+  bb0: {
+    if (!status.isInitialized) {
+      t4 = null;
+      break bb0;
+    }
+    try {
+      let t52;
+      if ($[5] !== registry || $[6] !== table) {
+        t52 = registry.getAdapter(table);
+        $[5] = registry;
+        $[6] = table;
+        $[7] = t52;
+      } else {
+        t52 = $[7];
+      }
+      t4 = t52;
+    } catch {
+      t4 = null;
+    }
+  }
+  const adapter = t4;
+  let t5;
+  if ($[8] !== adapter || $[9] !== table) {
+    t5 = async (data) => {
+      if (!adapter) {
+        throw new Error(`Adapter not available for table: ${table}`);
+      }
+      return adapter.insert(table, data);
+    };
+    $[8] = adapter;
+    $[9] = table;
+    $[10] = t5;
+  } else {
+    t5 = $[10];
+  }
+  const mutationFn = t5;
+  let t6;
+  if ($[11] !== invalidateTables || $[12] !== onSuccess || $[13] !== queryClient) {
+    t6 = (data_0) => {
+      invalidateTables.forEach((t) => {
+        queryClient.invalidateQueries({
+          predicate: (query) => query.queryKey[0] === "v3" && query.queryKey[2] === t
+        });
+      });
+      onSuccess?.(data_0);
+    };
+    $[11] = invalidateTables;
+    $[12] = onSuccess;
+    $[13] = queryClient;
+    $[14] = t6;
+  } else {
+    t6 = $[14];
+  }
+  let t7;
+  if ($[15] !== onError) {
+    t7 = (error) => {
+      onError?.(error instanceof Error ? error : new Error(String(error)));
+    };
+    $[15] = onError;
+    $[16] = t7;
+  } else {
+    t7 = $[16];
+  }
+  let t8;
+  if ($[17] !== mutationFn || $[18] !== t6 || $[19] !== t7) {
+    t8 = {
+      mutationFn,
+      onSuccess: t6,
+      onError: t7
+    };
+    $[17] = mutationFn;
+    $[18] = t6;
+    $[19] = t7;
+    $[20] = t8;
+  } else {
+    t8 = $[20];
+  }
+  const mutation = useMutation(t8);
+  const t9 = mutation.error;
+  let t10;
+  if ($[21] !== mutation.data || $[22] !== mutation.isPending || $[23] !== mutation.mutate || $[24] !== mutation.mutateAsync || $[25] !== mutation.reset || $[26] !== t9) {
+    t10 = {
+      mutate: mutation.mutate,
+      mutateAsync: mutation.mutateAsync,
+      isPending: mutation.isPending,
+      error: t9,
+      reset: mutation.reset,
+      data: mutation.data
+    };
+    $[21] = mutation.data;
+    $[22] = mutation.isPending;
+    $[23] = mutation.mutate;
+    $[24] = mutation.mutateAsync;
+    $[25] = mutation.reset;
+    $[26] = t9;
+    $[27] = t10;
+  } else {
+    t10 = $[27];
+  }
+  return t10;
+}
+
+// src/hooks/useDbUpdate.ts
+import { c as _c2 } from "react/compiler-runtime";
+import { useMutation as useMutation2, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+function useDbUpdate(table, t0) {
+  const $ = _c2(35);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === void 0 ? {} : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const options = t1;
+  const {
+    registry,
+    status
+  } = useDataLayer();
+  const queryClient = useQueryClient2();
+  const {
+    onSuccess,
+    onError,
+    invalidateTables: t2,
+    optimistic: t3
+  } = options;
+  let t4;
+  if ($[2] !== t2 || $[3] !== table) {
+    t4 = t2 === void 0 ? [table] : t2;
+    $[2] = t2;
+    $[3] = table;
+    $[4] = t4;
+  } else {
+    t4 = $[4];
+  }
+  const invalidateTables = t4;
+  const optimistic = t3 === void 0 ? false : t3;
+  let t5;
+  bb0: {
+    if (!status.isInitialized) {
+      t5 = null;
+      break bb0;
+    }
+    try {
+      let t62;
+      if ($[5] !== registry || $[6] !== table) {
+        t62 = registry.getAdapter(table);
+        $[5] = registry;
+        $[6] = table;
+        $[7] = t62;
+      } else {
+        t62 = $[7];
+      }
+      t5 = t62;
+    } catch {
+      t5 = null;
+    }
+  }
+  const adapter = t5;
+  let t6;
+  if ($[8] !== adapter || $[9] !== table) {
+    t6 = async (params) => {
+      if (!adapter) {
+        throw new Error(`Adapter not available for table: ${table}`);
+      }
+      return adapter.update(table, params.id, params.data);
+    };
+    $[8] = adapter;
+    $[9] = table;
+    $[10] = t6;
+  } else {
+    t6 = $[10];
+  }
+  const mutationFn = t6;
+  let t7;
+  if ($[11] !== optimistic || $[12] !== queryClient || $[13] !== table) {
+    t7 = optimistic ? async () => {
+      await queryClient.cancelQueries({
+        predicate: (query) => query.queryKey[0] === "v3" && query.queryKey[2] === table
+      });
+      const previousData = queryClient.getQueriesData({
+        predicate: (query_0) => query_0.queryKey[0] === "v3" && query_0.queryKey[2] === table
+      });
+      return {
+        previousData
+      };
+    } : void 0;
+    $[11] = optimistic;
+    $[12] = queryClient;
+    $[13] = table;
+    $[14] = t7;
+  } else {
+    t7 = $[14];
+  }
+  let t8;
+  if ($[15] !== invalidateTables || $[16] !== onSuccess || $[17] !== queryClient) {
+    t8 = (data) => {
+      invalidateTables.forEach((t) => {
+        queryClient.invalidateQueries({
+          predicate: (query_1) => query_1.queryKey[0] === "v3" && query_1.queryKey[2] === t
+        });
+      });
+      onSuccess?.(data);
+    };
+    $[15] = invalidateTables;
+    $[16] = onSuccess;
+    $[17] = queryClient;
+    $[18] = t8;
+  } else {
+    t8 = $[18];
+  }
+  let t9;
+  if ($[19] !== onError || $[20] !== optimistic || $[21] !== queryClient) {
+    t9 = (error, _variables, context) => {
+      if (optimistic && context?.previousData) {
+        context.previousData.forEach((t102) => {
+          const [queryKey, data_0] = t102;
+          queryClient.setQueryData(queryKey, data_0);
+        });
+      }
+      onError?.(error instanceof Error ? error : new Error(String(error)));
+    };
+    $[19] = onError;
+    $[20] = optimistic;
+    $[21] = queryClient;
+    $[22] = t9;
+  } else {
+    t9 = $[22];
+  }
+  let t10;
+  if ($[23] !== mutationFn || $[24] !== t7 || $[25] !== t8 || $[26] !== t9) {
+    t10 = {
+      mutationFn,
+      onMutate: t7,
+      onSuccess: t8,
+      onError: t9
+    };
+    $[23] = mutationFn;
+    $[24] = t7;
+    $[25] = t8;
+    $[26] = t9;
+    $[27] = t10;
+  } else {
+    t10 = $[27];
+  }
+  const mutation = useMutation2(t10);
+  const t11 = mutation.error;
+  let t12;
+  if ($[28] !== mutation.data || $[29] !== mutation.isPending || $[30] !== mutation.mutate || $[31] !== mutation.mutateAsync || $[32] !== mutation.reset || $[33] !== t11) {
+    t12 = {
+      mutate: mutation.mutate,
+      mutateAsync: mutation.mutateAsync,
+      isPending: mutation.isPending,
+      error: t11,
+      reset: mutation.reset,
+      data: mutation.data
+    };
+    $[28] = mutation.data;
+    $[29] = mutation.isPending;
+    $[30] = mutation.mutate;
+    $[31] = mutation.mutateAsync;
+    $[32] = mutation.reset;
+    $[33] = t11;
+    $[34] = t12;
+  } else {
+    t12 = $[34];
+  }
+  return t12;
+}
+
+// src/hooks/useDbUpsert.ts
+import { useCallback as useCallback4, useMemo as useMemo4 } 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 = useMemo4(() => {
+    if (!status.isInitialized) return null;
+    try {
+      const resolvedAdapter = registry.getAdapter(table);
+      if (__DEV__) {
+        console.log(`[useDbUpsert] Adapter resolved for table "${table}":`, {
+          adapterName: resolvedAdapter?.name ?? "unknown",
+          backend: status.currentBackend
+        });
+      }
+      return resolvedAdapter;
+    } catch (error) {
+      if (__DEV__) {
+        console.warn(`[useDbUpsert] Failed to get adapter for table "${table}":`, error);
+      }
+      return null;
+    }
+  }, [registry, table, status.isInitialized, status.currentBackend]);
+  const mutationFn = useCallback4(async (data) => {
+    if (__DEV__) {
+      console.log(`[useDbUpsert] mutationFn called for table "${table}":`, {
+        adapterName: adapter?.name ?? "null",
+        dataKeys: Object.keys(data),
+        hasId: "id" in data
+      });
+    }
+    if (!adapter) {
+      throw new Error(`Adapter not available for table: ${table}`);
+    }
+    const result = await adapter.upsert(table, data);
+    if (__DEV__) {
+      console.log(`[useDbUpsert] upsert completed for table "${table}":`, {
+        adapterName: adapter.name,
+        resultId: result?.id ?? "unknown"
+      });
+    }
+    return result;
+  }, [adapter, table]);
+  const mutation = useMutation3({
+    mutationFn,
+    onSuccess: (data_0) => {
+      invalidateTables.forEach((t) => {
+        queryClient.invalidateQueries({
+          predicate: (query) => query.queryKey[0] === "v3" && query.queryKey[2] === t
+        });
+      });
+      onSuccess?.(data_0);
+    },
+    onError: (error_0) => {
+      onError?.(error_0 instanceof Error ? error_0 : new Error(String(error_0)));
+    }
+  });
+  return {
+    mutate: mutation.mutate,
+    mutateAsync: mutation.mutateAsync,
+    isPending: mutation.isPending,
+    error: mutation.error,
+    reset: mutation.reset,
+    data: mutation.data
+  };
+}
+
+// src/hooks/useDbDelete.ts
+import { c as _c3 } from "react/compiler-runtime";
+import { useMutation as useMutation4, useQueryClient as useQueryClient4 } from "@tanstack/react-query";
+function useDbDelete(table, t0) {
+  const $ = _c3(34);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === void 0 ? {} : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const options = t1;
+  const {
+    registry,
+    status
+  } = useDataLayer();
+  const queryClient = useQueryClient4();
+  const {
+    onSuccess,
+    onError,
+    invalidateTables: t2,
+    optimistic: t3
+  } = options;
+  let t4;
+  if ($[2] !== t2 || $[3] !== table) {
+    t4 = t2 === void 0 ? [table] : t2;
+    $[2] = t2;
+    $[3] = table;
+    $[4] = t4;
+  } else {
+    t4 = $[4];
+  }
+  const invalidateTables = t4;
+  const optimistic = t3 === void 0 ? false : t3;
+  let t5;
+  bb0: {
+    if (!status.isInitialized) {
+      t5 = null;
+      break bb0;
+    }
+    try {
+      let t62;
+      if ($[5] !== registry || $[6] !== table) {
+        t62 = registry.getAdapter(table);
+        $[5] = registry;
+        $[6] = table;
+        $[7] = t62;
+      } else {
+        t62 = $[7];
+      }
+      t5 = t62;
+    } catch {
+      t5 = null;
+    }
+  }
+  const adapter = t5;
+  let t6;
+  if ($[8] !== adapter || $[9] !== table) {
+    t6 = async (id) => {
+      if (!adapter) {
+        throw new Error(`Adapter not available for table: ${table}`);
+      }
+      await adapter.delete(table, id);
+    };
+    $[8] = adapter;
+    $[9] = table;
+    $[10] = t6;
+  } else {
+    t6 = $[10];
+  }
+  const mutationFn = t6;
+  let t7;
+  if ($[11] !== optimistic || $[12] !== queryClient || $[13] !== table) {
+    t7 = optimistic ? async (id_0) => {
+      await queryClient.cancelQueries({
+        predicate: (query) => query.queryKey[0] === "v3" && query.queryKey[2] === table
+      });
+      const previousData = queryClient.getQueriesData({
+        predicate: (query_0) => query_0.queryKey[0] === "v3" && query_0.queryKey[2] === table
+      });
+      queryClient.setQueriesData({
+        predicate: (query_1) => query_1.queryKey[0] === "v3" && query_1.queryKey[2] === table
+      }, (old) => {
+        if (!old?.data) {
+          return old;
+        }
+        return {
+          ...old,
+          data: old.data.filter((item) => item.id !== id_0)
+        };
+      });
+      return {
+        previousData
+      };
+    } : void 0;
+    $[11] = optimistic;
+    $[12] = queryClient;
+    $[13] = table;
+    $[14] = t7;
+  } else {
+    t7 = $[14];
+  }
+  let t8;
+  if ($[15] !== invalidateTables || $[16] !== onSuccess || $[17] !== queryClient) {
+    t8 = () => {
+      invalidateTables.forEach((t) => {
+        queryClient.invalidateQueries({
+          predicate: (query_2) => query_2.queryKey[0] === "v3" && query_2.queryKey[2] === t
+        });
+      });
+      onSuccess?.();
+    };
+    $[15] = invalidateTables;
+    $[16] = onSuccess;
+    $[17] = queryClient;
+    $[18] = t8;
+  } else {
+    t8 = $[18];
+  }
+  let t9;
+  if ($[19] !== onError || $[20] !== optimistic || $[21] !== queryClient) {
+    t9 = (error, _id, context) => {
+      if (optimistic && context?.previousData) {
+        context.previousData.forEach((t102) => {
+          const [queryKey, data] = t102;
+          queryClient.setQueryData(queryKey, data);
+        });
+      }
+      onError?.(error instanceof Error ? error : new Error(String(error)));
+    };
+    $[19] = onError;
+    $[20] = optimistic;
+    $[21] = queryClient;
+    $[22] = t9;
+  } else {
+    t9 = $[22];
+  }
+  let t10;
+  if ($[23] !== mutationFn || $[24] !== t7 || $[25] !== t8 || $[26] !== t9) {
+    t10 = {
+      mutationFn,
+      onMutate: t7,
+      onSuccess: t8,
+      onError: t9
+    };
+    $[23] = mutationFn;
+    $[24] = t7;
+    $[25] = t8;
+    $[26] = t9;
+    $[27] = t10;
+  } else {
+    t10 = $[27];
+  }
+  const mutation = useMutation4(t10);
+  const t11 = mutation.error;
+  let t12;
+  if ($[28] !== mutation.isPending || $[29] !== mutation.mutate || $[30] !== mutation.mutateAsync || $[31] !== mutation.reset || $[32] !== t11) {
+    t12 = {
+      mutate: mutation.mutate,
+      mutateAsync: mutation.mutateAsync,
+      isPending: mutation.isPending,
+      error: t11,
+      reset: mutation.reset
+    };
+    $[28] = mutation.isPending;
+    $[29] = mutation.mutate;
+    $[30] = mutation.mutateAsync;
+    $[31] = mutation.reset;
+    $[32] = t11;
+    $[33] = t12;
+  } else {
+    t12 = $[33];
+  }
+  return t12;
+}
+
+// src/hooks/useDbInfiniteQuery.ts
+import { useMemo as useMemo5, useCallback as useCallback5 } 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 = useMemo5(() => {
+    if (!status.isInitialized) return null;
+    try {
+      return registry.getAdapter(tableName);
+    } catch {
+      return null;
+    }
+  }, [registry, tableName, status.isInitialized, status.currentBackend]);
+  const queryKey = useMemo5(() => buildInfiniteQueryKey(tableName, options), [tableName, serializeInfiniteQueryOptions(options)]);
+  const effectiveWhere = useMemo5(() => {
+    if (searchText && searchFields && searchFields.length > 0) {
+      return buildSearchWhereClause(searchText, searchFields, queryOptions.where);
+    }
+    return queryOptions.where;
+  }, [searchText, searchFields, queryOptions.where]);
+  const memoizedQueryOptions = useMemo5(() => ({
+    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 = useMemo5(() => {
+    if (!infiniteQuery.data?.pages) return void 0;
+    return infiniteQuery.data.pages.flatMap((page_0) => page_0.data);
+  }, [infiniteQuery.data?.pages]);
+  const count = useMemo5(() => {
+    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 = useCallback5(async () => {
+    await infiniteQuery.fetchNextPage();
+  }, [infiniteQuery]);
+  const refetch = useCallback5(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 { c as _c4 } from "react/compiler-runtime";
+import { useQuery as useQuery4 } from "@tanstack/react-query";
+function useDbCount(table, t0) {
+  const $ = _c4(27);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === void 0 ? {} : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const options = t1;
+  const {
+    registry,
+    status
+  } = useDataLayer();
+  const {
+    enabled: t2,
+    staleTime: t3,
+    where
+  } = options;
+  const enabled = t2 === void 0 ? true : t2;
+  const staleTime = t3 === void 0 ? 3e4 : t3;
+  let t4;
+  bb0: {
+    if (!status.isInitialized) {
+      t4 = null;
+      break bb0;
+    }
+    try {
+      let t52;
+      if ($[2] !== registry || $[3] !== table) {
+        t52 = registry.getAdapter(table);
+        $[2] = registry;
+        $[3] = table;
+        $[4] = t52;
+      } else {
+        t52 = $[4];
+      }
+      t4 = t52;
+    } catch {
+      t4 = null;
+    }
+  }
+  const adapter = t4;
+  let t5;
+  if ($[5] !== where) {
+    t5 = JSON.stringify(where ?? {});
+    $[5] = where;
+    $[6] = t5;
+  } else {
+    t5 = $[6];
+  }
+  let t6;
+  if ($[7] !== t5 || $[8] !== table) {
+    t6 = ["v3", "count", table, t5];
+    $[7] = t5;
+    $[8] = table;
+    $[9] = t6;
+  } else {
+    t6 = $[9];
+  }
+  const queryKey = t6;
+  let t7;
+  if ($[10] !== adapter || $[11] !== table || $[12] !== where) {
+    t7 = 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;
+    };
+    $[10] = adapter;
+    $[11] = table;
+    $[12] = where;
+    $[13] = t7;
+  } else {
+    t7 = $[13];
+  }
+  const queryFn = t7;
+  const t8 = enabled && status.isInitialized && adapter !== null;
+  let t9;
+  if ($[14] !== queryFn || $[15] !== queryKey || $[16] !== staleTime || $[17] !== t8) {
+    t9 = {
+      queryKey,
+      queryFn,
+      enabled: t8,
+      staleTime
+    };
+    $[14] = queryFn;
+    $[15] = queryKey;
+    $[16] = staleTime;
+    $[17] = t8;
+    $[18] = t9;
+  } else {
+    t9 = $[18];
+  }
+  const query = useQuery4(t9);
+  let t10;
+  if ($[19] !== query) {
+    t10 = async () => {
+      await query.refetch();
+    };
+    $[19] = query;
+    $[20] = t10;
+  } else {
+    t10 = $[20];
+  }
+  const refetch = t10;
+  const t11 = query.error;
+  let t12;
+  if ($[21] !== query.data || $[22] !== query.isFetching || $[23] !== query.isLoading || $[24] !== refetch || $[25] !== t11) {
+    t12 = {
+      count: query.data,
+      isLoading: query.isLoading,
+      isFetching: query.isFetching,
+      error: t11,
+      refetch
+    };
+    $[21] = query.data;
+    $[22] = query.isFetching;
+    $[23] = query.isLoading;
+    $[24] = refetch;
+    $[25] = t11;
+    $[26] = t12;
+  } else {
+    t12 = $[26];
+  }
+  return t12;
+}
+
+// src/hooks/useSyncStatus.ts
+import { c as _c5 } from "react/compiler-runtime";
+import { useState as useState2, useEffect as useEffect3 } from "react";
+var defaultSyncStatus = {
+  isConnected: true,
+  // Supabase-only mode is always "connected" when online
+  isSyncing: false,
+  lastSyncedAt: null,
+  pendingUploads: 0,
+  error: null
+};
+function useSyncStatus() {
+  const $ = _c5(6);
+  const {
+    syncStatus,
+    status,
+    powerSync
+  } = useDataLayer();
+  const [currentStatus, setCurrentStatus] = useState2(syncStatus);
+  let t0;
+  let t1;
+  if ($[0] !== powerSync || $[1] !== status.currentBackend || $[2] !== status.isOnline || $[3] !== syncStatus) {
+    t0 = () => {
+      if (powerSync && status.currentBackend === "powersync") {
+        setCurrentStatus(syncStatus);
+      } else {
+        setCurrentStatus({
+          ...defaultSyncStatus,
+          isConnected: status.isOnline
+        });
+      }
+    };
+    t1 = [syncStatus, status.currentBackend, status.isOnline, powerSync];
+    $[0] = powerSync;
+    $[1] = status.currentBackend;
+    $[2] = status.isOnline;
+    $[3] = syncStatus;
+    $[4] = t0;
+    $[5] = t1;
+  } else {
+    t0 = $[4];
+    t1 = $[5];
+  }
+  useEffect3(t0, t1);
+  return currentStatus;
+}
+
+// src/hooks/useSyncControl.ts
+import { c as _c6 } from "react/compiler-runtime";
+function useSyncControl() {
+  const $ = _c6(1);
+  const {
+    syncControl,
+    status,
+    powerSync
+  } = useDataLayer();
+  let t0;
+  if ($[0] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t0 = {
+      triggerSync: _temp,
+      startLiveSync: _temp2,
+      stopLiveSync: _temp3,
+      setScope: _temp4
+    };
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const noOpControls = t0;
+  let t1;
+  bb0: {
+    if (powerSync && status.currentBackend === "powersync") {
+      t1 = syncControl;
+      break bb0;
+    }
+    t1 = noOpControls;
+  }
+  const controls = t1;
+  return controls;
+}
+async function _temp4(_scopeName, _values) {
+  console.warn("[useSyncControl] setScope called but PowerSync is not available");
+}
+function _temp3() {
+  console.warn("[useSyncControl] stopLiveSync called but PowerSync is not available");
+}
+async function _temp2() {
+  console.warn("[useSyncControl] startLiveSync called but PowerSync is not available");
+}
+async function _temp() {
+  console.warn("[useSyncControl] triggerSync called but PowerSync is not available");
+}
+
+// src/hooks/useOnlineStatus.ts
+import { c as _c7 } from "react/compiler-runtime";
+function useOnlineStatus() {
+  const $ = _c7(4);
+  const {
+    status,
+    powerSync
+  } = useDataLayer();
+  const t0 = powerSync !== null && status.powerSyncStatus === "available";
+  let t1;
+  if ($[0] !== status.currentBackend || $[1] !== status.isOnline || $[2] !== t0) {
+    t1 = {
+      isOnline: status.isOnline,
+      isConnected: t0,
+      backend: status.currentBackend
+    };
+    $[0] = status.currentBackend;
+    $[1] = status.isOnline;
+    $[2] = t0;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  return t1;
+}
+
+export {
+  DataLayerContext,
+  useDataLayer,
+  useDataLayerOptional,
+  useDbQuery,
+  useDbQueryById,
+  useAdvanceQuery,
+  useDbInsert,
+  useDbUpdate,
+  useDbUpsert,
+  useDbDelete,
+  useDbInfiniteQuery,
+  useDbCount,
+  useSyncStatus,
+  useSyncControl,
+  useOnlineStatus
+};
+//# sourceMappingURL=chunk-ZVBHWU7O.js.map