@pol-studios/db 1.0.33 → 1.0.35

package/dist/{chunk-3XCW225W.js → chunk-NP34C3O3.js}

@@ -1,3 +1,12 @@
+import {
+  DataLayerCoreContext,
+  DataLayerStatusContext,
+  devLog,
+  devWarn,
+  useDataLayerCore,
+  useDataLayerStatus,
+  useDbQuery
+} from "./chunk-UBHORKBS.js";
 import {
   getSupabaseUrl
 } from "./chunk-GC3TBUWE.js";
@@ -5,213 +14,10 @@ import {
   useSupabase
 } from "./chunk-DMVUEJG2.js";
 
-// src/hooks/useDataLayer.ts
-import { useContext } from "react";
-
-// src/providers/DataLayerContext.ts
-import { createContext } from "react";
-var DataLayerCoreContext = createContext(null);
-DataLayerCoreContext.displayName = "DataLayerCoreContext";
-var DataLayerStatusContext = createContext(null);
-DataLayerStatusContext.displayName = "DataLayerStatusContext";
-var DataLayerContext = createContext(null);
-DataLayerContext.displayName = "DataLayerContext";
-
-// src/hooks/useDataLayer.ts
-function useDataLayerCore() {
-  const context = useContext(DataLayerCoreContext);
-  if (!context) {
-    throw new Error("useDataLayerCore must be used within a DataLayerProvider. Make sure you have wrapped your app with <DataLayerProvider>.");
-  }
-  return context;
-}
-function useDataLayerCoreOptional() {
-  return useContext(DataLayerCoreContext);
-}
-function useDataLayerStatus() {
-  const context = useContext(DataLayerStatusContext);
-  if (!context) {
-    throw new Error("useDataLayerStatus must be used within a DataLayerProvider. Make sure you have wrapped your app with <DataLayerProvider>.");
-  }
-  return context;
-}
-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, useRef } from "react";
-import { useQuery } from "@tanstack/react-query";
-
-// src/utils/dev-log.ts
-function devLog(prefix, message) {
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log(`[${prefix}] ${message}`);
-  }
-}
-function devWarn(prefix, message) {
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.warn(`[${prefix}] ${message}`);
-  }
-}
-
-// src/hooks/useDbQuery.ts
-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,
-    queryClient,
-    powerSync
-  } = useDataLayerCore();
-  const isPowerSync = powerSync !== null;
-  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(() => {
-    try {
-      return registry.getAdapter(tableName);
-    } catch {
-      return null;
-    }
-  }, [registry, tableName]);
-  const serializedOptions = useMemo(() => serializeQueryOptions(options), [options.select, options.where, options.orderBy, options.limit, options.offset]);
-  const queryKey = useMemo(() => buildQueryKey(tableName, options), [tableName, serializedOptions]);
-  const memoizedQueryOptions = useMemo(() => ({
-    select: queryOptions.select,
-    where: queryOptions.where,
-    orderBy: queryOptions.orderBy,
-    limit: queryOptions.limit,
-    offset: queryOptions.offset
-  }), [serializedOptions]);
-  const queryFn = useCallback(async () => {
-    const currentAdapter = registry.getAdapter(tableName);
-    const result = await currentAdapter.query(tableName, memoizedQueryOptions);
-    return result;
-  }, [registry, tableName, memoizedQueryOptions]);
-  const query = useQuery({
-    queryKey,
-    queryFn,
-    enabled: enabled && adapter !== null,
-    staleTime,
-    gcTime,
-    refetchOnWindowFocus,
-    refetchOnMount
-  });
-  const invalidateTimeoutRef = useRef(null);
-  const debouncedInvalidate = useCallback(() => {
-    if (invalidateTimeoutRef.current) {
-      clearTimeout(invalidateTimeoutRef.current);
-    }
-    invalidateTimeoutRef.current = setTimeout(() => {
-      queryClient.invalidateQueries({
-        queryKey
-      });
-    }, 100);
-  }, [queryClient, queryKey]);
-  useEffect(() => {
-    return () => {
-      if (invalidateTimeoutRef.current) {
-        clearTimeout(invalidateTimeoutRef.current);
-      }
-    };
-  }, []);
-  useEffect(() => {
-    let currentAdapter_0;
-    try {
-      currentAdapter_0 = registry.getAdapter(tableName);
-    } catch {
-      return;
-    }
-    if (!realtime || !currentAdapter_0?.subscribe) {
-      return;
-    }
-    const isPowerSyncAdapter = currentAdapter_0.name === "powersync";
-    let isFirstCallback = isPowerSyncAdapter;
-    const unsubscribe = currentAdapter_0.subscribe(tableName, memoizedQueryOptions, (data) => {
-      if (isFirstCallback) {
-        isFirstCallback = false;
-        return;
-      }
-      const hasRelations = memoizedQueryOptions.select?.includes("(");
-      if (hasRelations) {
-        debouncedInvalidate();
-      } else {
-        queryClient.setQueryData(queryKey, {
-          data,
-          count: data.length
-        });
-      }
-    });
-    return () => {
-      unsubscribe?.();
-    };
-  }, [realtime, registry, tableName, memoizedQueryOptions, queryClient, queryKey, debouncedInvalidate]);
-  useEffect(() => {
-    const adapterName = adapter?.name ?? "unknown";
-    if (query.isError && query.error) {
-      devWarn("useDbQuery", `${tableName} via ${adapterName}: Error - ${query.error.message}`);
-    }
-    if (query.isSuccess && query.data?.data?.length === 0) {
-      devLog("useDbQuery", `${tableName} via ${adapterName}: 0 results`);
-    }
-  }, [query.isError, query.error, query.isSuccess, query.data, tableName, adapter]);
-  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, useEffect as useEffect2, useMemo as useMemo2 } from "react";
-import { useQuery as useQuery2 } from "@tanstack/react-query";
-function buildQueryKey2(table, id, select) {
+import { useCallback, useEffect, useMemo } from "react";
+import { useQuery } from "@tanstack/react-query";
+function buildQueryKey(table, id, select) {
   return ["v3", "queryById", table, id, select ?? "*"];
 }
 function useDbQueryById(table, id, options = {}) {
@@ -223,15 +29,15 @@ function useDbQueryById(table, id, options = {}) {
     enabled = id != null,
     staleTime = 3e4
   } = options;
-  const adapter = useMemo2(() => {
+  const adapter = useMemo(() => {
     try {
       return registry.getAdapter(table);
     } catch {
       return null;
     }
   }, [registry, table]);
-  const queryKey = useMemo2(() => buildQueryKey2(table, id, select), [table, id, select]);
-  const queryFn = useCallback2(async () => {
+  const queryKey = useMemo(() => buildQueryKey(table, id, select), [table, id, select]);
+  const queryFn = useCallback(async () => {
     if (!adapter) {
       throw new Error(`Adapter not available for table: ${table}`);
     }
@@ -252,13 +58,13 @@ function useDbQueryById(table, id, options = {}) {
     });
     return result.data[0] ?? null;
   }, [adapter, table, id, select]);
-  const query = useQuery2({
+  const query = useQuery({
     queryKey,
     queryFn,
     enabled: enabled && adapter !== null && id != null,
     staleTime
   });
-  useEffect2(() => {
+  useEffect(() => {
     const adapterName = adapter?.name ?? "unknown";
     if (query.isError && query.error) {
       devWarn("useDbQueryById", `${table}(${id}) via ${adapterName}: Error - ${query.error.message}`);
@@ -267,7 +73,7 @@ function useDbQueryById(table, id, options = {}) {
       devLog("useDbQueryById", `${table}(${id}) via ${adapterName}: not found`);
     }
   }, [query.isError, query.error, query.isSuccess, query.data, table, id, adapter]);
-  const refetch = useCallback2(async () => {
+  const refetch = useCallback(async () => {
     await query.refetch();
   }, [query]);
   return {
@@ -281,8 +87,8 @@ function useDbQueryById(table, id, options = {}) {
 }
 
 // src/hooks/useAdvanceQuery.ts
-import { useCallback as useCallback3, useMemo as useMemo3, useState, useEffect as useEffect3 } from "react";
-import { useQuery as useQuery3 } from "@tanstack/react-query";
+import { useCallback as useCallback2, useMemo as useMemo2, useState, useEffect as useEffect2 } from "react";
+import { useQuery as useQuery2 } from "@tanstack/react-query";
 import { useSessionStorageState } from "@pol-studios/hooks/storage";
 import { omit } from "@pol-studios/utils";
 var createDefaultFilterState = () => ({
@@ -317,7 +123,7 @@ function useAdvanceQuery(table, options) {
   } = options;
   const isPowerSync = powerSync !== null;
   const realtimeEnabled = realtime ?? isPowerSync;
-  const defaultFilterState = useMemo3(
+  const defaultFilterState = useMemo2(
     () => initialFilters ?? createDefaultFilterState(),
     // eslint-disable-next-line react-hooks/exhaustive-deps
     []
@@ -325,16 +131,16 @@ function useAdvanceQuery(table, options) {
   );
   const [filtersRaw, setFiltersRaw] = useSessionStorageState(filterKey, defaultFilterState);
   const filters = filtersRaw ?? defaultFilterState;
-  const setFilters = useCallback3((action) => {
+  const setFilters = useCallback2((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 hasAdvancedFilters = useMemo2(() => (filters?.filters?.length ?? 0) > 0 || !!filters?.naturalLanguageQuery, [filters?.filters?.length, filters?.naturalLanguageQuery]);
   const usePowerSyncPath = !hasAdvancedFilters;
-  const powerSyncOrderBy = useMemo3(() => {
+  const powerSyncOrderBy = useMemo2(() => {
     if (filters?.sort && filters.sort.length > 0) {
       return filters.sort.map((s) => ({
         field: s.field,
@@ -354,8 +160,8 @@ function useAdvanceQuery(table, options) {
     // Enable watch() subscriptions for reactive updates
   });
   const [extraData, setExtraData] = useState({});
-  const edgeFunctionQueryKey = useMemo3(() => ["v3", "advance-query", tableName, select, JSON.stringify(where), JSON.stringify(filters)], [tableName, select, where, filters]);
-  const edgeFunctionResult = useQuery3({
+  const edgeFunctionQueryKey = useMemo2(() => ["v3", "advance-query", tableName, select, JSON.stringify(where), JSON.stringify(filters)], [tableName, select, where, filters]);
+  const edgeFunctionResult = useQuery2({
     queryKey: edgeFunctionQueryKey,
     queryFn: async ({
       signal
@@ -460,7 +266,7 @@ function useAdvanceQuery(table, options) {
     refetchOnMount: true,
     refetchOnWindowFocus: false
   });
-  useEffect3(() => {
+  useEffect2(() => {
     if (!realtimeEnabled || usePowerSyncPath || !enabled) {
       return;
     }
@@ -480,7 +286,7 @@ function useAdvanceQuery(table, options) {
       supabase.removeChannel(channel);
     };
   }, [realtimeEnabled, usePowerSyncPath, enabled, supabase, tableName, filterKey, queryClient, edgeFunctionQueryKey]);
-  useEffect3(() => {
+  useEffect2(() => {
     if (usePowerSyncPath) return;
     const pathName = "EdgeFunction";
     if (edgeFunctionResult.isError && edgeFunctionResult.error) {
@@ -490,7 +296,7 @@ function useAdvanceQuery(table, options) {
       devLog("useAdvanceQuery", `${tableName} via ${pathName}: 0 results`);
     }
   }, [usePowerSyncPath, edgeFunctionResult.isError, edgeFunctionResult.error, edgeFunctionResult.isSuccess, edgeFunctionResult.data, tableName]);
-  const result = useMemo3(() => {
+  const result = useMemo2(() => {
     if (usePowerSyncPath) {
       return {
         data: powerSyncResult.data,
@@ -1046,7 +852,7 @@ function useDbDelete(table, t0) {
 }
 
 // src/hooks/useDbInfiniteQuery.ts
-import { useMemo as useMemo4, useCallback as useCallback4, useEffect as useEffect4 } from "react";
+import { useMemo as useMemo3, useCallback as useCallback3, useEffect as useEffect3 } 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 ?? [])];
@@ -1061,7 +867,7 @@ function serializeInfiniteQueryOptions(options) {
     searchFields: options.searchFields
   });
 }
-function resolveTableName2(table) {
+function resolveTableName(table) {
   if (typeof table === "string") {
     return table;
   }
@@ -1084,7 +890,7 @@ function buildSearchWhereClause(searchText, searchFields, existingWhere) {
   };
 }
 function useDbInfiniteQuery(table, options = {}) {
-  const tableName = resolveTableName2(table);
+  const tableName = resolveTableName(table);
   const {
     registry
   } = useDataLayerCore();
@@ -1097,22 +903,22 @@ function useDbInfiniteQuery(table, options = {}) {
     searchFields,
     ...queryOptions
   } = options;
-  const adapter = useMemo4(() => {
+  const adapter = useMemo3(() => {
     try {
       return registry.getAdapter(tableName);
     } catch {
       return null;
     }
   }, [registry, tableName]);
-  const serializedOptions = useMemo4(() => serializeInfiniteQueryOptions(options), [options.select, options.where, options.orderBy, options.pageSize, options.searchText, options.searchFields]);
-  const queryKey = useMemo4(() => buildInfiniteQueryKey(tableName, options), [tableName, serializedOptions]);
-  const effectiveWhere = useMemo4(() => {
+  const serializedOptions = useMemo3(() => serializeInfiniteQueryOptions(options), [options.select, options.where, options.orderBy, options.pageSize, options.searchText, options.searchFields]);
+  const queryKey = useMemo3(() => buildInfiniteQueryKey(tableName, options), [tableName, serializedOptions]);
+  const effectiveWhere = useMemo3(() => {
     if (searchText && searchFields && searchFields.length > 0) {
       return buildSearchWhereClause(searchText, searchFields, queryOptions.where);
     }
     return queryOptions.where;
   }, [searchText, searchFields, queryOptions.where]);
-  const memoizedQueryOptions = useMemo4(() => ({
+  const memoizedQueryOptions = useMemo3(() => ({
     select: queryOptions.select,
     where: effectiveWhere,
     orderBy: queryOptions.orderBy
@@ -1152,23 +958,23 @@ function useDbInfiniteQuery(table, options = {}) {
     staleTime,
     refetchOnWindowFocus
   });
-  const flattenedData = useMemo4(() => {
+  const flattenedData = useMemo3(() => {
     if (!infiniteQuery.data?.pages) return void 0;
     return infiniteQuery.data.pages.flatMap((page_0) => page_0.data);
   }, [infiniteQuery.data?.pages]);
-  const count = useMemo4(() => {
+  const count = useMemo3(() => {
     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 = useCallback4(async () => {
+  const fetchNextPage = useCallback3(async () => {
     await infiniteQuery.fetchNextPage();
   }, [infiniteQuery]);
-  const refetch = useCallback4(async () => {
+  const refetch = useCallback3(async () => {
     await infiniteQuery.refetch();
   }, [infiniteQuery]);
-  useEffect4(() => {
+  useEffect3(() => {
     const adapterName = adapter?.name ?? "unknown";
     if (infiniteQuery.isError && infiniteQuery.error) {
       devWarn("useDbInfiniteQuery", `${tableName} via ${adapterName}: Error - ${infiniteQuery.error.message}`);
@@ -1193,8 +999,8 @@ function useDbInfiniteQuery(table, options = {}) {
 
 // src/hooks/useDbCount.ts
 import { c as _c5 } from "react/compiler-runtime";
-import { useEffect as useEffect5 } from "react";
-import { useQuery as useQuery4 } from "@tanstack/react-query";
+import { useEffect as useEffect4 } from "react";
+import { useQuery as useQuery3 } from "@tanstack/react-query";
 function useDbCount(table, t0) {
   const $ = _c5(37);
   let t1;
@@ -1287,7 +1093,7 @@ function useDbCount(table, t0) {
   } else {
     t9 = $[18];
   }
-  const query = useQuery4(t9);
+  const query = useQuery3(t9);
   let t10;
   if ($[19] !== adapter?.name || $[20] !== query.error || $[21] !== query.isError || $[22] !== table) {
     t10 = () => {
@@ -1315,7 +1121,7 @@ function useDbCount(table, t0) {
   } else {
     t11 = $[28];
   }
-  useEffect5(t10, t11);
+  useEffect4(t10, t11);
   let t12;
   if ($[29] !== query) {
     t12 = async () => {
@@ -1351,7 +1157,7 @@ function useDbCount(table, t0) {
 
 // src/hooks/useSyncStatus.ts
 import { c as _c6 } from "react/compiler-runtime";
-import { useState as useState2, useEffect as useEffect6, useContext as useContext2 } from "react";
+import { useState as useState2, useEffect as useEffect5, useContext } from "react";
 var defaultSyncStatus = {
   isConnected: true,
   // Supabase-only mode is always "connected" when online
@@ -1362,8 +1168,8 @@ var defaultSyncStatus = {
 };
 function useSyncStatus() {
   const $ = _c6(6);
-  const statusContext = useContext2(DataLayerStatusContext);
-  const coreContext = useContext2(DataLayerCoreContext);
+  const statusContext = useContext(DataLayerStatusContext);
+  const coreContext = useContext(DataLayerCoreContext);
   if (!statusContext || !coreContext) {
     throw new Error("useSyncStatus must be used within a DataLayerProvider. Make sure you have wrapped your app with <DataLayerProvider>.");
   }
@@ -1399,16 +1205,16 @@ function useSyncStatus() {
     t0 = $[4];
     t1 = $[5];
   }
-  useEffect6(t0, t1);
+  useEffect5(t0, t1);
   return currentStatus;
 }
 
 // src/hooks/useSyncControl.ts
 import { c as _c7 } from "react/compiler-runtime";
-import { useContext as useContext3 } from "react";
+import { useContext as useContext2 } from "react";
 function useSyncControl() {
   const $ = _c7(1);
-  const coreContext = useContext3(DataLayerCoreContext);
+  const coreContext = useContext2(DataLayerCoreContext);
   if (!coreContext) {
     throw new Error("useSyncControl must be used within a DataLayerProvider. Make sure you have wrapped your app with <DataLayerProvider>.");
   }
@@ -1498,15 +1304,6 @@ function useOnlineStatus() {
 }
 
 export {
-  DataLayerCoreContext,
-  DataLayerStatusContext,
-  DataLayerContext,
-  useDataLayerCore,
-  useDataLayerCoreOptional,
-  useDataLayerStatus,
-  useDataLayer,
-  useDataLayerOptional,
-  useDbQuery,
   useDbQueryById,
   useAdvanceQuery,
   useDbInsert,
@@ -1519,4 +1316,4 @@ export {
   useSyncControl,
   useOnlineStatus
 };
-//# sourceMappingURL=chunk-3XCW225W.js.map
+//# sourceMappingURL=chunk-NP34C3O3.js.map