@pol-studios/db 1.0.9 → 1.0.10

package/dist/chunk-7XT7K4QT.js

@@ -0,0 +1,2687 @@
+import {
+  normalizeFilter,
+  useDbAdvanceFilterQuery
+} from "./chunk-7HG6G25H.js";
+import {
+  OperationLog
+} from "./chunk-BRTW7CO5.js";
+import {
+  useDbQuery,
+  useDbUpsert
+} from "./chunk-GK7B66LY.js";
+import {
+  getSupabaseUrl
+} from "./chunk-Y3INY2CS.js";
+import {
+  PostgrestParser
+} from "./chunk-JUVE3DWY.js";
+import {
+  chunkArray,
+  diff,
+  getObjectChanges,
+  isNullOrWhitespace,
+  isUsable,
+  newUuid,
+  omit,
+  require_moment
+} from "./chunk-O3K7R32P.js";
+import {
+  buildNormalizedQuery,
+  encode,
+  normalizeResponse,
+  useDeleteItem,
+  useDeleteManyMutation,
+  useInsertMutation,
+  useQueriesForTableLoader,
+  useQuery,
+  useUpsertItem
+} from "./chunk-H6365JPC.js";
+import {
+  UserSessionId,
+  useSupabase
+} from "./chunk-AWFMICFV.js";
+import {
+  __require,
+  __toESM
+} from "./chunk-P4UZ7IXC.js";
+
+// src/useDbDelete.ts
+import { useMutation } from "@tanstack/react-query";
+function useDbDelete(relation, primaryKeys = ["id"]) {
+  const tableName = typeof relation === "object" ? relation.table : relation;
+  const schemaName = typeof relation === "object" ? relation.schema : "public";
+  const supabase = useSupabase();
+  const deleteItem = useDeleteItem({
+    primaryKeys: primaryKeys.map((k) => String(k)),
+    table: tableName,
+    schema: schemaName
+  });
+  const deleteMutation = useMutation({
+    mutationFn: async (item) => {
+      if (Array.isArray(item)) {
+        throw new Error("Item cannot be an array.");
+      }
+      const deleteQuery = supabase.schema(schemaName).from(tableName).delete();
+      primaryKeys.forEach((key) => {
+        const keyStr = String(key);
+        const value = item[keyStr];
+        if (isUsable(value)) {
+          deleteQuery.eq(keyStr, value);
+        }
+      });
+      const response = await deleteQuery.select().single();
+      if (response.error) {
+        throw response.error;
+      }
+      if (response.data) {
+        deleteItem(response.data);
+      } else {
+        deleteItem(item);
+      }
+      return response.data;
+    }
+  });
+  return deleteMutation;
+}
+
+// src/useDbInfiniteQuery.ts
+import {
+  useInfiniteQuery
+} from "@tanstack/react-query";
+import { useMemo, useRef } from "react";
+function useDbInfiniteQuery(query, countPerLoad, config) {
+  const initialQueryKey = encode(query, false).join("-");
+  const lastKnownQuery = useRef(initialQueryKey);
+  const currentPageNumber = useRef(1);
+  if (lastKnownQuery.current != initialQueryKey) {
+    lastKnownQuery.current = initialQueryKey;
+    currentPageNumber.current = 1;
+  }
+  const isFetching = useRef(false);
+  const queryKey = useMemo(
+    () => encode(query, false),
+    [initialQueryKey, config?.crossOrganization]
+  );
+  const getQuery = useInfiniteQuery({
+    ...config,
+    queryKey,
+    queryFn: async ({ pageParam, signal }) => {
+      let adjustableQuery = query;
+      const pageNumber = pageParam;
+      if (config?.onQuery && config?.enableOnQuery) {
+        config?.onQuery({ query: adjustableQuery, pageParam: pageNumber });
+      } else {
+        adjustableQuery = adjustableQuery.range(
+          (pageNumber - 1) * countPerLoad,
+          pageNumber * countPerLoad - 1
+        );
+      }
+      adjustableQuery = adjustableQuery.abortSignal(signal);
+      updatedCache.current = false;
+      const response = await adjustableQuery;
+      currentPageNumber.current = pageNumber;
+      if (response.error) {
+        throw response.error;
+      } else {
+        return response;
+      }
+    },
+    initialPageParam: 1,
+    getNextPageParam: (response, allResponses, lastParam) => {
+      const pageParam = lastParam;
+      const resp = response;
+      if (allResponses.length * countPerLoad >= (resp?.count ?? 0)) {
+        return void 0;
+      }
+      return pageParam + 1;
+    }
+  });
+  const updatedCache = useRef(true);
+  return useMemo(
+    () => {
+      const pages = getQuery.data?.pages;
+      return {
+        ...getQuery,
+        count: pages?.[pages.length - 1]?.count,
+        data: pages?.flatMap((x) => x.data ?? [])
+      };
+    },
+    [getQuery.data, currentPageNumber.current]
+  );
+}
+
+// src/useDbInsert.ts
+import { useMutation as useMutation2 } from "@tanstack/react-query";
+function useDbInsert(relation, primaryKeys = ["id"], query, mutationOption) {
+  const supabase = useSupabase();
+  const tableName = typeof relation === "object" ? relation.table : relation;
+  const schemaName = typeof relation === "object" ? String(relation.schema) : "public";
+  const primaryKeysAsStrings = primaryKeys.map((k) => String(k));
+  const mutation = useInsertMutation(
+    supabase.schema(schemaName).from(tableName),
+    primaryKeysAsStrings,
+    query,
+    mutationOption
+  );
+  const updateMutation = useMutation2({
+    mutationFn: async (item) => {
+      const primaryKeysNull = primaryKeys.filter((x) => x in item === false || isUsable(item[x]) === false).map((k) => String(k));
+      const response = await mutation.mutateAsync([
+        omit(item, primaryKeysNull)
+      ]);
+      mutation.reset();
+      return response?.[0];
+    }
+  });
+  return updateMutation;
+}
+
+// src/useDbMultiDelete.ts
+import { useMutation as useMutation3 } from "@tanstack/react-query";
+function useDbMultiDelete(relation, primaryKeys = ["id"]) {
+  const tableName = typeof relation === "object" ? relation.table : relation;
+  const schemaName = typeof relation === "object" ? String(relation.schema) : "public";
+  const supabase = useSupabase();
+  const primaryKeysAsStrings = primaryKeys.map((k) => String(k));
+  const deleteManyMutation = useDeleteManyMutation(
+    supabase.schema(schemaName).from(tableName),
+    primaryKeysAsStrings
+  );
+  const deleteMutation = useMutation3({
+    mutationFn: async (item) => {
+      if (Array.isArray(item)) {
+        const response = await deleteManyMutation.mutateAsync(item);
+        return response;
+      } else {
+        throw new Error("Item must be an array.");
+      }
+    }
+  });
+  return deleteMutation;
+}
+
+// src/useDbMultiUpsert.ts
+import { useMutation as useMutation4 } from "@tanstack/react-query";
+function useDbMultiUpsert(relation, primaryKeys = ["id"], query = "*") {
+  const supabase = useSupabase();
+  const tableName = typeof relation === "object" ? relation.table : relation;
+  const schemaName = typeof relation === "object" ? String(relation.schema) : "public";
+  const upsertItem = useUpsertItem({
+    primaryKeys,
+    table: relation,
+    schema: "public"
+  });
+  const primaryKeysAsStrings = primaryKeys.map((k) => String(k));
+  async function upsertItemAction(item) {
+    let task;
+    if (Object.keys(item).length !== primaryKeys.length && primaryKeys.every((key) => key in item && isUsable(item[key]))) {
+      const updateObject = omit(item, primaryKeysAsStrings);
+      task = supabase.schema(schemaName).from(tableName).update(updateObject);
+      primaryKeys.forEach((key) => {
+        task = task.eq(String(key), item[key]);
+      });
+    } else {
+      task = supabase.schema(schemaName).from(tableName).insert(omit(item, primaryKeysAsStrings));
+    }
+    const response = await task.select(query);
+    if (response.error) {
+      throw response.error;
+    }
+    return response.data[0];
+  }
+  const updateMutation = useMutation4({
+    mutationFn: async (item) => {
+      if (Array.isArray(item)) {
+        const data = await Promise.all(item.map((x) => upsertItemAction(x)));
+        data.filter((x) => isUsable(x)).forEach((x) => upsertItem(x));
+        return data;
+      }
+      throw new Error("Item must be an array.");
+    }
+  });
+  return updateMutation;
+}
+
+// src/useDbPartialAdvanceQuery.ts
+import { useLayoutEffect, useMemo as useMemo2, useState } from "react";
+import { useSessionStorageState } from "@pol-studios/hooks/storage";
+function useDbPartialAdvanceQuery(query, itemCountPerPage, config) {
+  const initialQuery = encode(query, false);
+  const [id, setId] = useState(window.location.pathname);
+  const [currentPage, setCurrentPage] = useSessionStorageState(
+    `${id}-currentPage`,
+    1
+  );
+  const rangedQuery = useMemo2(
+    () => {
+      const page = currentPage ?? 1;
+      return query.range(
+        (page - 1) * itemCountPerPage,
+        page * itemCountPerPage - 1
+      );
+    },
+    [query, currentPage, itemCountPerPage]
+  );
+  const [baseQuery, filter, setFilters] = useDbAdvanceFilterQuery(
+    rangedQuery,
+    {
+      ...config,
+      filterKey: config?.filterKey,
+      count: "exact",
+      key: (currentPage ?? 1).toString()
+    }
+  );
+  const filterKey = JSON.stringify(omit(filter, ["pagination"]));
+  const select = initialQuery[4].split("&").find(
+    (x) => x.startsWith("select=")
+  );
+  useLayoutEffect(() => {
+    const newId = [
+      initialQuery[3],
+      select,
+      initialQuery[5],
+      initialQuery[6],
+      initialQuery[7],
+      initialQuery[8],
+      filterKey
+    ].join("-");
+    console.log({ newId, id });
+    setId(newId);
+  }, [
+    initialQuery[3],
+    select,
+    initialQuery[5],
+    initialQuery[6],
+    initialQuery[7],
+    initialQuery[8],
+    filterKey
+  ]);
+  const safeFetchNextPage = () => {
+    setCurrentPage((currentPage2) => (currentPage2 ?? 1) + 1);
+  };
+  const fetchPreviousPage = () => {
+    setCurrentPage((currentPage2) => (currentPage2 ?? 1) - 1);
+  };
+  const pageCount = Math.max(
+    Math.ceil(
+      (baseQuery.count ?? 0) / itemCountPerPage
+    ),
+    1
+  );
+  const request = {
+    ...baseQuery,
+    clarification: baseQuery.clarification,
+    // Explicitly pass through clarification
+    fetchPreviousPage,
+    fetchNextPage: safeFetchNextPage,
+    currentPage: currentPage ?? 1,
+    setCurrentPage,
+    data: baseQuery.data ? toPagedResponse(
+      baseQuery.data,
+      currentPage ?? 1,
+      baseQuery.count ?? baseQuery.data.length,
+      itemCountPerPage
+    ) : null,
+    pageCount,
+    hasNextPage: (currentPage ?? 1) < pageCount,
+    hasPreviousPage: (currentPage ?? 1) > 1,
+    count: baseQuery.count ?? baseQuery.data?.length
+  };
+  return [
+    request,
+    filter,
+    setFilters
+  ];
+}
+function toPagedResponse(results, currentPage, totalCount, itemPerPage) {
+  const newPage = {
+    Items: results,
+    CurrentPage: currentPage,
+    ItemCount: totalCount,
+    MaxCountPerPage: itemPerPage,
+    PageCount: Math.max(Math.ceil(totalCount / itemPerPage), 1)
+  };
+  return newPage;
+}
+
+// src/useDbPartialQuery.ts
+import { useMemo as useMemo3 } from "react";
+import { useSessionStorageState as useSessionStorageState2 } from "@pol-studios/hooks/storage";
+function useDbPartialQuery(query, itemCountPerPage, config) {
+  const initialQuery = encode(query, false);
+  const id = useMemo3(
+    () => [
+      initialQuery[7],
+      initialQuery[8]
+    ].join("-"),
+    [
+      initialQuery[7],
+      initialQuery[8]
+    ]
+  );
+  const [currentPage, setCurrentPage] = useSessionStorageState2(id, 1);
+  const rangedQuery = useMemo3(
+    () => {
+      const page = currentPage ?? 1;
+      return query.range(
+        (page - 1) * itemCountPerPage,
+        page * itemCountPerPage - 1
+      );
+    },
+    [query, currentPage, itemCountPerPage]
+  );
+  const baseQuery = useDbQuery(rangedQuery, config);
+  const safeFetchNextPage = () => {
+    setCurrentPage((currentPage2) => currentPage2 + 1);
+  };
+  const fetchPreviousPage = () => {
+    setCurrentPage((currentPage2) => currentPage2 - 1);
+  };
+  const pageCount = Math.max(
+    Math.ceil(
+      (baseQuery.count ?? 0) / itemCountPerPage
+    ),
+    1
+  );
+  return {
+    ...baseQuery,
+    fetchPreviousPage,
+    fetchNextPage: safeFetchNextPage,
+    currentPage: currentPage ?? 1,
+    setCurrentPage,
+    data: baseQuery.data ? toPagedResponse2(
+      baseQuery.data,
+      currentPage ?? 1,
+      baseQuery.count ?? baseQuery.data.length,
+      itemCountPerPage
+    ) : null,
+    pageCount,
+    hasNextPage: (currentPage ?? 1) < pageCount,
+    hasPreviousPage: (currentPage ?? 1) > 1
+  };
+}
+function toPagedResponse2(results, currentPage, totalCount, itemPerPage) {
+  const newPage = {
+    Items: results,
+    CurrentPage: currentPage,
+    ItemCount: totalCount,
+    MaxCountPerPage: itemPerPage,
+    PageCount: Math.max(Math.ceil(totalCount / itemPerPage), 1)
+  };
+  return newPage;
+}
+
+// src/useDbRealtime.ts
+import { useEffect, useState as useState2, useRef as useRef2 } from "react";
+import {
+  REALTIME_POSTGRES_CHANGES_LISTEN_EVENT
+} from "@supabase/supabase-js";
+import { useDelayedValue } from "@pol-studios/hooks/state";
+function useDbRealtime(key, query, table, primaryKeys, options) {
+  const supabase = useSupabase();
+  const tableNameValue = typeof table === "string" ? table : table.table;
+  const schemaValue = typeof table === "string" ? "public" : table.schema;
+  const queriesForTable = useQueriesForTableLoader(tableNameValue);
+  const deleteItem = useDeleteItem({
+    primaryKeys,
+    table: tableNameValue,
+    schema: schemaValue
+  });
+  const upsertItem = useUpsertItem({
+    primaryKeys,
+    table: tableNameValue,
+    schema: schemaValue
+  });
+  const [realtimeState, setRealtimeState] = useState2("CLOSED");
+  const [retryTick, setRetryTick] = useState2(0);
+  const channelRef = useRef2(null);
+  const lastRetryTimeRef = useRef2(0);
+  const retryCountRef = useRef2(0);
+  const enabled = options?.enabled ?? true;
+  const filter = options?.filter;
+  const onChange = options?.onChange;
+  const debouncedKey = useDelayedValue(key, 50);
+  useEffect(() => {
+    if (!enabled) {
+      if (channelRef.current) {
+        channelRef.current.unsubscribe();
+        supabase.removeChannel(channelRef.current);
+        channelRef.current = null;
+      }
+      setRealtimeState("CLOSED");
+      return;
+    }
+    const now = Date.now();
+    const timeSinceLastRetry = now - lastRetryTimeRef.current;
+    const minRetryInterval = 2e3;
+    if (timeSinceLastRetry < minRetryInterval && retryTick > 0) {
+      return;
+    }
+    if (channelRef.current) {
+      channelRef.current.unsubscribe();
+      supabase.removeChannel(channelRef.current);
+      channelRef.current = null;
+    }
+    lastRetryTimeRef.current = now;
+    retryCountRef.current += 1;
+    const channel = supabase.channel(newUuid()).on(
+      "postgres_changes",
+      {
+        event: "*",
+        schema: schemaValue,
+        table: tableNameValue,
+        filter
+      },
+      async (payload) => {
+        let data = payload.new ?? payload.old;
+        if (payload.new && Object.keys(payload.new).length > 0) {
+          const selectQuery = buildNormalizedQuery({
+            queriesForTable,
+            query
+          });
+          if (payload.eventType !== REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.DELETE && selectQuery) {
+            if (selectQuery.groupedUserQueryPaths?.every(
+              (x) => x.path in data
+            ) === false) {
+              const qb = supabase.schema(payload.schema).from(payload.table).select(selectQuery.selectQuery);
+              for (const pk of primaryKeys) {
+                qb.eq(pk.toString(), data[pk]);
+              }
+              const res = await qb.single();
+              if (res.data) {
+                data = normalizeResponse(
+                  selectQuery.groupedPaths,
+                  res.data
+                );
+              }
+            }
+          }
+          if ("changedBySessionId" in data) {
+            const sessionId = data["changedBySessionId"];
+            if (sessionId !== UserSessionId) {
+              await upsertItem(data);
+            }
+          } else {
+            await upsertItem(data);
+          }
+        }
+        if (payload.eventType === REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.DELETE) {
+          await deleteItem(payload.old);
+        }
+        if (payload.errors?.length > 0) {
+          setRealtimeState("CHANNEL_ERROR");
+        }
+        if (onChange) {
+          onChange(payload);
+        }
+      }
+    ).on(
+      "postgres_changes",
+      {
+        event: "DELETE",
+        schema: schemaValue,
+        table: tableNameValue
+      },
+      async (payload) => {
+        if (payload.eventType === REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.DELETE) {
+          await deleteItem(payload.old);
+        }
+      }
+    ).subscribe((status) => {
+      setRealtimeState(status);
+      if (status === "SUBSCRIBED") {
+        retryCountRef.current = 0;
+      }
+    });
+    channelRef.current = channel;
+    return () => {
+      if (channelRef.current) {
+        channelRef.current.unsubscribe();
+        supabase.removeChannel(channelRef.current);
+        channelRef.current = null;
+      }
+    };
+  }, [
+    supabase,
+    tableNameValue,
+    schemaValue,
+    enabled,
+    filter,
+    query,
+    primaryKeys.join(","),
+    retryTick,
+    debouncedKey
+  ]);
+  useEffect(() => {
+    if (!enabled || realtimeState === "SUBSCRIBED") {
+      retryCountRef.current = 0;
+      return;
+    }
+    const baseDelay = 5e3;
+    const maxDelay = 6e4;
+    const delay = Math.min(
+      baseDelay * Math.pow(2, retryCountRef.current),
+      maxDelay
+    );
+    const id = setTimeout(() => {
+      setRetryTick((t) => t + 1);
+    }, delay);
+    return () => clearTimeout(id);
+  }, [realtimeState, enabled]);
+  return realtimeState;
+}
+
+// src/useDbRealtimeQuery.tsx
+import { useMemo as useMemo4 } from "react";
+function convertFilterToRealtimeQuery(filters) {
+  function convert(filter) {
+    if (!filter) return "";
+    if ("path" in filter) {
+      if (filter.path.includes(".")) return "";
+      let valueString = filter.value?.toString() ?? "null";
+      if (filter.operator === "in") {
+        valueString = '("' + valueString.slice(2, valueString.length - 2).split(",").join('","') + '")';
+      }
+      return `${filter.path}=${filter.negate ? "not." : ""}${filter.operator}.${valueString}`;
+    } else {
+      if (filter.or) {
+        return `(${filter.or.map((f) => convert(f)).join("|")})`;
+      } else if (filter.and) {
+        return `(${filter.and.map((f) => convert(f)).join("&")})`;
+      }
+    }
+    return "";
+  }
+  return convert(filters[0]);
+}
+function useDbRealtimeQuery(query, config, primaryKeys = ["id"]) {
+  const parser = useMemo4(
+    () => new PostgrestParser(query),
+    [query]
+  );
+  const request = useQuery(
+    query,
+    useMemo4(() => config, [config])
+  );
+  const queryKey = encode(query, false);
+  const filterString = convertFilterToRealtimeQuery(parser.filters);
+  let filter = request.data && typeof request.data === "object" && "id" in request.data ? "id=eq." + request.data.id : filterString;
+  if (filter.includes('in.(\\"\\")')) {
+    filter = void 0;
+  }
+  if (isNullOrWhitespace(filter)) {
+    filter = void 0;
+  }
+  const selectStatement = parser.select;
+  const realtimeStatus = useDbRealtime(
+    queryKey.join("-"),
+    selectStatement,
+    { schema: parser.schema, table: parser.table },
+    primaryKeys,
+    {
+      filter,
+      enabled: typeof config?.enabled === "boolean" ? config.enabled : true
+    }
+  );
+  const outputRealtimeStatus = request.isFetching ? "Loading..." : realtimeStatus;
+  return {
+    ...request,
+    data: request.data,
+    realtimeStatus: outputRealtimeStatus,
+    isRealtimeConnected: realtimeStatus == "SUBSCRIBED",
+    isRealtimeLoading: request.isFetching
+  };
+}
+
+// src/useDbUpdate.ts
+import { useMutation as useMutation5 } from "@tanstack/react-query";
+function useDbUpdate(relation, primaryKeys = ["id"], query, mutationOption) {
+  const supabase = useSupabase();
+  const tableName = typeof relation === "object" ? relation.table : relation;
+  const schemaName = typeof relation === "object" ? String(relation.schema) : "public";
+  const primaryKeysAsStrings = primaryKeys.map((k) => String(k));
+  const upsertItem = useUpsertItem({
+    primaryKeys: primaryKeysAsStrings,
+    table: relation,
+    schema: "public"
+  });
+  const updateMutation = useMutation5({
+    mutationFn: async (item) => {
+      let response = null;
+      if (primaryKeys.every((x) => x in item && isUsable(item[x]))) {
+        const query2 = supabase.schema(schemaName).from(tableName).update(omit(item, primaryKeysAsStrings));
+        primaryKeys.forEach((x) => {
+          query2.eq(String(x), item[x]);
+        });
+        const queryResponse = await query2.select().single().throwOnError();
+        if (queryResponse.data) {
+          response = queryResponse.data;
+          upsertItem(response);
+        }
+      }
+      return response;
+    }
+  });
+  return updateMutation;
+}
+
+// src/useMutationSuccess.ts
+import { useEffect as useEffect3, useRef as useRef3 } from "react";
+function useMutationSuccess(mutation, options = {}) {
+  const {
+    successMessage,
+    entityName,
+    enabled = true,
+    onSuccess
+  } = options;
+  const previousSuccessRef = useRef3(false);
+  const previousDataRef = useRef3(void 0);
+  useEffect3(() => {
+    if (!enabled) return;
+    const isSuccess = mutation.isSuccess;
+    const hasNewData = mutation.data !== previousDataRef.current;
+    if (isSuccess && hasNewData && !previousSuccessRef.current) {
+      const message = successMessage || getDefaultSuccessMessage(entityName);
+      if (typeof window !== "undefined") {
+        try {
+          const { toast } = __require("@pol-studios/hooks");
+          toast.toast({
+            title: "Success",
+            description: message
+          });
+        } catch {
+        }
+      } else {
+        try {
+          const { Toast } = __require("toastify-react-native");
+          Toast.success(message);
+        } catch {
+        }
+      }
+      onSuccess?.();
+    }
+    previousSuccessRef.current = isSuccess;
+    previousDataRef.current = mutation.data;
+  }, [mutation.isSuccess, mutation.data, enabled, successMessage, entityName, onSuccess]);
+  return mutation;
+}
+function getDefaultSuccessMessage(entityName) {
+  if (!entityName) {
+    return "Saved successfully";
+  }
+  return `${entityName} saved successfully`;
+}
+function useMutationSuccessRN(mutation, options = {}) {
+  return useMutationSuccess(mutation, options);
+}
+
+// src/adapters/types.ts
+var ADAPTER_STRATEGIES = {
+  POWERSYNC: "powersync",
+  SUPABASE: "supabase",
+  CACHED: "cached",
+  HYBRID: "hybrid",
+  AUTO: "auto"
+};
+
+// src/adapters/registry.ts
+var AdapterRegistry = class {
+  /**
+   * Create a new adapter registry
+   *
+   * @param config - Data layer configuration with table strategies
+   */
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Cache of created adapters by table name
+   */
+  adapters = /* @__PURE__ */ new Map();
+  /**
+   * PowerSync adapter instance (set during initialization)
+   */
+  powerSyncAdapter = null;
+  /**
+   * Supabase adapter instance (set during initialization)
+   */
+  supabaseAdapter = null;
+  /**
+   * Cached adapter instance (wraps Supabase with TanStack Query)
+   */
+  cachedAdapter = null;
+  /**
+   * Dependencies for creating adapters
+   */
+  deps = null;
+  /**
+   * Whether the registry has been initialized with adapters
+   */
+  _isInitialized = false;
+  /**
+   * Auto-detector instance for automatic backend selection
+   */
+  autoDetector = null;
+  /**
+   * Listeners for backend change events
+   */
+  backendChangeListeners = /* @__PURE__ */ new Set();
+  /**
+   * Last auto-detection result for debugging and status
+   */
+  lastDetectionResult = null;
+  // ===========================================================================
+  // Initialization
+  // ===========================================================================
+  /**
+   * Check if the registry has been initialized
+   */
+  get isInitialized() {
+    return this._isInitialized;
+  }
+  /**
+   * Initialize the registry with dependencies.
+   * Called by DataLayerProvider when PowerSync and Supabase are ready.
+   *
+   * @param deps - Dependencies needed to create adapters
+   */
+  initialize(deps) {
+    this.deps = deps;
+    this._isInitialized = true;
+  }
+  /**
+   * Set the PowerSync adapter instance
+   *
+   * @param adapter - PowerSync adapter implementation
+   */
+  setPowerSyncAdapter(adapter) {
+    this.powerSyncAdapter = adapter;
+  }
+  /**
+   * Set the Supabase adapter instance
+   *
+   * @param adapter - Supabase adapter implementation
+   */
+  setSupabaseAdapter(adapter) {
+    this.supabaseAdapter = adapter;
+  }
+  /**
+   * Set the Cached adapter instance
+   *
+   * @param adapter - Cached adapter implementation
+   */
+  setCachedAdapter(adapter) {
+    this.cachedAdapter = adapter;
+  }
+  /**
+   * Initialize auto-detection with a detector instance
+   *
+   * @param detector - The auto-detector to use
+   */
+  initializeAutoDetection(detector) {
+    this.autoDetector = detector;
+    detector.addListener((result) => {
+      this.lastDetectionResult = result;
+      this.notifyBackendChange(result.recommendedBackend);
+    });
+  }
+  // ===========================================================================
+  // Adapter Access
+  // ===========================================================================
+  /**
+   * Get the appropriate adapter for a table based on configuration.
+   *
+   * The adapter is selected based on the table's strategy in config.tables:
+   * - "powersync": Returns PowerSyncAdapter
+   * - "supabase": Returns SupabaseAdapter
+   * - "cached": Returns CachedAdapter (wrapping Supabase)
+   * - "hybrid": Returns HybridAdapter (combining PowerSync + Cached)
+   * - "auto": Uses auto-detection to select the best backend
+   *
+   * For tables not in config, defaults to auto-detection if available,
+   * otherwise falls back to SupabaseAdapter.
+   *
+   * @param table - The table name
+   * @returns The appropriate adapter for the table
+   * @throws Error if adapters are not initialized
+   */
+  getAdapter(table) {
+    const existing = this.adapters.get(table);
+    if (existing) {
+      return existing;
+    }
+    const strategy = this.config.tables[table];
+    if (!strategy || strategy.strategy === "auto") {
+      return this.getAutoAdapter(strategy);
+    }
+    const adapter = this.createAdapter(strategy);
+    this.adapters.set(table, adapter);
+    return adapter;
+  }
+  /**
+   * Get the PowerSync adapter directly
+   *
+   * @returns PowerSync adapter or null if not initialized
+   */
+  getPowerSyncAdapter() {
+    return this.powerSyncAdapter;
+  }
+  /**
+   * Get the Supabase adapter directly
+   *
+   * @returns Supabase adapter or null if not initialized
+   */
+  getSupabaseAdapter() {
+    return this.supabaseAdapter;
+  }
+  /**
+   * Get the Cached adapter directly
+   *
+   * @returns Cached adapter or null if not initialized
+   */
+  getCachedAdapter() {
+    return this.cachedAdapter;
+  }
+  /**
+   * Get all configured table names
+   *
+   * @returns Array of table names with explicit strategy configuration
+   */
+  getConfiguredTables() {
+    return Object.keys(this.config.tables);
+  }
+  /**
+   * Get the strategy for a specific table
+   *
+   * @param table - The table name
+   * @returns The table strategy or undefined if not configured
+   */
+  getTableStrategy(table) {
+    return this.config.tables[table];
+  }
+  /**
+   * Check if a table uses PowerSync strategy
+   *
+   * @param table - The table name
+   * @returns True if table uses PowerSync or Hybrid strategy
+   */
+  usesPowerSync(table) {
+    const strategy = this.config.tables[table];
+    return strategy?.strategy === "powersync" || strategy?.strategy === "hybrid";
+  }
+  /**
+   * Get all tables that use PowerSync
+   *
+   * @returns Array of table names using PowerSync or Hybrid strategy
+   */
+  getPowerSyncTables() {
+    return Object.entries(this.config.tables).filter(
+      ([_, strategy]) => strategy.strategy === "powersync" || strategy.strategy === "hybrid"
+    ).map(([table]) => table);
+  }
+  // ===========================================================================
+  // Auto-Detection Methods
+  // ===========================================================================
+  /**
+   * Get adapter using auto-detection
+   *
+   * @param strategy - Optional auto strategy configuration
+   * @returns The automatically selected adapter
+   */
+  getAutoAdapter(strategy) {
+    if (!this.autoDetector) {
+      if (!this.supabaseAdapter) {
+        throw new Error(
+          "No auto-detector configured and Supabase adapter not available. Either initialize auto-detection or set adapters explicitly."
+        );
+      }
+      return this.supabaseAdapter;
+    }
+    const detection = this.autoDetector.detect();
+    this.lastDetectionResult = detection;
+    if (detection.recommendedBackend === "powersync") {
+      if (!this.powerSyncAdapter) {
+        if (!this.supabaseAdapter) {
+          throw new Error(
+            "Neither PowerSync nor Supabase adapters are available."
+          );
+        }
+        return this.supabaseAdapter;
+      }
+      return this.powerSyncAdapter;
+    }
+    if (!this.supabaseAdapter) {
+      throw new Error(
+        "Supabase adapter not available and PowerSync not recommended."
+      );
+    }
+    return this.supabaseAdapter;
+  }
+  /**
+   * Subscribe to backend changes
+   *
+   * @param callback - Function called when recommended backend changes
+   * @returns Unsubscribe function
+   */
+  onBackendChange(callback) {
+    this.backendChangeListeners.add(callback);
+    return () => {
+      this.backendChangeListeners.delete(callback);
+    };
+  }
+  /**
+   * Notify listeners of backend change
+   *
+   * @param backend - The new recommended backend
+   */
+  notifyBackendChange(backend) {
+    this.backendChangeListeners.forEach((callback) => {
+      try {
+        callback(backend);
+      } catch (error) {
+        console.error("Error in backend change listener:", error);
+      }
+    });
+  }
+  /**
+   * Get the last auto-detection result
+   *
+   * @returns Last detection result or null if never detected
+   */
+  getLastDetectionResult() {
+    return this.lastDetectionResult;
+  }
+  /**
+   * Get the auto-detector instance
+   *
+   * @returns Auto-detector instance or null if not initialized
+   */
+  getAutoDetector() {
+    return this.autoDetector;
+  }
+  // ===========================================================================
+  // Private Methods
+  // ===========================================================================
+  /**
+   * Create an adapter based on the strategy type
+   *
+   * @param strategy - The table strategy configuration
+   * @returns The created adapter
+   * @throws Error if the required base adapter is not initialized
+   */
+  createAdapter(strategy) {
+    switch (strategy.strategy) {
+      case "powersync":
+        if (!this.powerSyncAdapter) {
+          throw new Error(
+            "PowerSync adapter not initialized. Ensure PowerSyncAdapter is set before accessing PowerSync tables."
+          );
+        }
+        return this.powerSyncAdapter;
+      case "supabase":
+        if (!this.supabaseAdapter) {
+          throw new Error(
+            "Supabase adapter not initialized. Ensure SupabaseAdapter is set before accessing Supabase tables."
+          );
+        }
+        return this.supabaseAdapter;
+      case "cached":
+        if (this.cachedAdapter) {
+          return this.cachedAdapter;
+        }
+        throw new Error(
+          "CachedAdapter not yet implemented. This feature will be available in Wave 2. For now, use 'supabase' strategy as a fallback."
+        );
+      case "hybrid":
+        throw new Error(
+          "HybridAdapter not yet implemented. This feature will be available in Wave 2. For now, use 'powersync' or 'supabase' strategy as a fallback."
+        );
+      default:
+        if (!this.supabaseAdapter) {
+          throw new Error(
+            "Supabase adapter not initialized. Ensure SupabaseAdapter is set before accessing tables."
+          );
+        }
+        return this.supabaseAdapter;
+    }
+  }
+  // ===========================================================================
+  // Utility Methods
+  // ===========================================================================
+  /**
+   * Clear all cached adapters.
+   * Useful when configuration changes and adapters need to be recreated.
+   */
+  clearCache() {
+    this.adapters.clear();
+  }
+  /**
+   * Reset the registry to uninitialized state.
+   * Used during cleanup or testing.
+   */
+  reset() {
+    this.adapters.clear();
+    this.powerSyncAdapter = null;
+    this.supabaseAdapter = null;
+    this.cachedAdapter = null;
+    this.deps = null;
+    this._isInitialized = false;
+    this.autoDetector = null;
+    this.backendChangeListeners.clear();
+    this.lastDetectionResult = null;
+  }
+  /**
+   * Dispose all adapters and clean up resources.
+   * Called when the DataLayerProvider unmounts.
+   */
+  dispose() {
+    this.reset();
+  }
+  /**
+   * Get debug information about the registry state
+   */
+  getDebugInfo() {
+    return {
+      isInitialized: this._isInitialized,
+      hasPowerSync: this.powerSyncAdapter !== null,
+      hasSupabase: this.supabaseAdapter !== null,
+      hasCached: this.cachedAdapter !== null,
+      cachedAdapterCount: this.adapters.size,
+      configuredTableCount: Object.keys(this.config.tables).length,
+      powerSyncTables: this.getPowerSyncTables(),
+      hasAutoDetector: this.autoDetector !== null,
+      lastDetectionResult: this.lastDetectionResult
+    };
+  }
+};
+function createAdapterRegistry(config) {
+  return new AdapterRegistry(config);
+}
+
+// src/adapters/auto-detector.ts
+var BackendStatus = /* @__PURE__ */ ((BackendStatus2) => {
+  BackendStatus2["AVAILABLE"] = "available";
+  BackendStatus2["INITIALIZING"] = "initializing";
+  BackendStatus2["UNAVAILABLE"] = "unavailable";
+  return BackendStatus2;
+})(BackendStatus || {});
+var AdapterAutoDetector = class {
+  constructor(powerSyncDb, supabase, options = {}) {
+    this.powerSyncDb = powerSyncDb;
+    this.supabase = supabase;
+    this.options = {
+      preferPowerSync: options.preferPowerSync ?? true,
+      statusCheckTimeout: options.statusCheckTimeout ?? 1e3
+    };
+  }
+  options;
+  listeners = /* @__PURE__ */ new Set();
+  lastResult = null;
+  // ===========================================================================
+  // Main Detection Methods
+  // ===========================================================================
+  /**
+   * Detect backend availability and recommend best option.
+   *
+   * The detection logic follows this priority:
+   * 1. If preferPowerSync is true and PowerSync is available, use PowerSync
+   * 2. If PowerSync is initializing and online with Supabase available, use Supabase temporarily
+   * 3. If online with Supabase available, use Supabase
+   * 4. If offline but PowerSync available, use PowerSync (offline mode)
+   * 5. Default to Supabase as fallback
+   *
+   * @returns Detection result with recommendation and reasoning
+   */
+  detect() {
+    const powerSyncStatus = this.detectPowerSyncStatus();
+    const supabaseStatus = this.detectSupabaseStatus();
+    const isOnline = this.checkOnlineStatus();
+    let recommendedBackend;
+    let reason;
+    if (this.options.preferPowerSync && powerSyncStatus === "available" /* AVAILABLE */) {
+      recommendedBackend = "powersync";
+      reason = "PowerSync is available and preferred for offline-first experience";
+    } else if (powerSyncStatus === "initializing" /* INITIALIZING */ && isOnline && supabaseStatus === "available" /* AVAILABLE */) {
+      recommendedBackend = "supabase";
+      reason = "PowerSync is initializing; using Supabase temporarily";
+    } else if (supabaseStatus === "available" /* AVAILABLE */ && isOnline) {
+      recommendedBackend = "supabase";
+      reason = "Using Supabase direct connection";
+    } else if (powerSyncStatus === "available" /* AVAILABLE */) {
+      recommendedBackend = "powersync";
+      reason = "Offline mode using PowerSync local data";
+    } else {
+      recommendedBackend = "supabase";
+      reason = "No confirmed available backend; defaulting to Supabase";
+    }
+    const result = {
+      powerSyncStatus,
+      supabaseStatus,
+      recommendedBackend,
+      isOnline,
+      reason
+    };
+    if (this.hasResultChanged(result)) {
+      this.lastResult = result;
+      this.notifyListeners(result);
+    }
+    return result;
+  }
+  /**
+   * Check if PowerSync is available.
+   *
+   * PowerSync is considered available if we have a database instance.
+   * The actual sync status would be checked via PowerSync's status API
+   * when the full SDK is integrated.
+   *
+   * @returns PowerSync backend status
+   */
+  detectPowerSyncStatus() {
+    if (!this.powerSyncDb) {
+      return "unavailable" /* UNAVAILABLE */;
+    }
+    try {
+      if (typeof this.powerSyncDb.getAll === "function") {
+        return "available" /* AVAILABLE */;
+      }
+      return "initializing" /* INITIALIZING */;
+    } catch {
+      return "initializing" /* INITIALIZING */;
+    }
+  }
+  /**
+   * Check if Supabase is available.
+   *
+   * Supabase is considered available if we have a client instance.
+   * The actual network connectivity is checked separately via checkOnlineStatus().
+   *
+   * @returns Supabase backend status
+   */
+  detectSupabaseStatus() {
+    if (!this.supabase) {
+      return "unavailable" /* UNAVAILABLE */;
+    }
+    try {
+      if (typeof this.supabase.from === "function") {
+        return "available" /* AVAILABLE */;
+      }
+      return "unavailable" /* UNAVAILABLE */;
+    } catch {
+      return "unavailable" /* UNAVAILABLE */;
+    }
+  }
+  /**
+   * Check if device is online.
+   *
+   * Uses navigator.onLine in browser environments.
+   * Returns true by default for non-browser environments (React Native
+   * would need NetInfo integration via dependency injection).
+   *
+   * @returns Whether the device has network connectivity
+   */
+  checkOnlineStatus() {
+    if (typeof window !== "undefined" && typeof navigator !== "undefined") {
+      return navigator.onLine;
+    }
+    return true;
+  }
+  // ===========================================================================
+  // Instance Management Methods
+  // ===========================================================================
+  /**
+   * Update PowerSync instance (e.g., when it becomes available).
+   *
+   * @param db - New PowerSync database instance or null
+   */
+  setPowerSync(db) {
+    this.powerSyncDb = db;
+  }
+  /**
+   * Update Supabase instance.
+   *
+   * @param supabase - New Supabase client instance or null
+   */
+  setSupabase(supabase) {
+    this.supabase = supabase;
+  }
+  /**
+   * Get current PowerSync instance.
+   *
+   * @returns Current PowerSync database instance or null
+   */
+  getPowerSync() {
+    return this.powerSyncDb;
+  }
+  /**
+   * Get current Supabase instance.
+   *
+   * @returns Current Supabase client instance or null
+   */
+  getSupabase() {
+    return this.supabase;
+  }
+  // ===========================================================================
+  // Options Management
+  // ===========================================================================
+  /**
+   * Update detector options.
+   *
+   * @param options - New options to merge with existing
+   */
+  setOptions(options) {
+    this.options = {
+      ...this.options,
+      ...options
+    };
+  }
+  /**
+   * Get current detector options.
+   *
+   * @returns Current detector options
+   */
+  getOptions() {
+    return { ...this.options };
+  }
+  // ===========================================================================
+  // Listener Management
+  // ===========================================================================
+  /**
+   * Add a listener for backend change events.
+   *
+   * @param listener - Callback to invoke when detection result changes
+   * @returns Function to remove the listener
+   */
+  addListener(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  /**
+   * Remove a listener for backend change events.
+   *
+   * @param listener - Listener to remove
+   */
+  removeListener(listener) {
+    this.listeners.delete(listener);
+  }
+  /**
+   * Get the last detection result.
+   *
+   * @returns Last detection result or null if never detected
+   */
+  getLastResult() {
+    return this.lastResult;
+  }
+  // ===========================================================================
+  // Private Helper Methods
+  // ===========================================================================
+  /**
+   * Check if the detection result has changed from the last result.
+   */
+  hasResultChanged(result) {
+    if (!this.lastResult) {
+      return true;
+    }
+    return this.lastResult.powerSyncStatus !== result.powerSyncStatus || this.lastResult.supabaseStatus !== result.supabaseStatus || this.lastResult.recommendedBackend !== result.recommendedBackend || this.lastResult.isOnline !== result.isOnline;
+  }
+  /**
+   * Notify all listeners of a detection result change.
+   */
+  notifyListeners(result) {
+    Array.from(this.listeners).forEach((listener) => {
+      try {
+        listener(result);
+      } catch (error) {
+        console.error("Error in backend change listener:", error);
+      }
+    });
+  }
+};
+function createAdapterAutoDetector(powerSyncDb, supabase, options) {
+  return new AdapterAutoDetector(powerSyncDb, supabase, options);
+}
+
+// src/adapters/supabase-adapter.ts
+var SupabaseAdapter = class {
+  constructor(supabase, schema) {
+    this.supabase = supabase;
+    this.schema = schema;
+  }
+  name = "supabase";
+  capabilities = {
+    supportsSubscribe: true,
+    supportsOffline: false,
+    supportsCache: false,
+    supportsSync: false
+  };
+  // ===========================================================================
+  // Private Helper - Table Name Parsing
+  // ===========================================================================
+  /**
+   * Parse a table identifier to extract schema and table name.
+   * Handles schema-qualified names like "core.Profile" -> { schema: "core", tableName: "Profile" }
+   *
+   * @param table - The table name, optionally schema-qualified (e.g., "users" or "core.Profile")
+   * @returns Object with schema (defaults to "public") and tableName
+   */
+  parseTableIdentifier(table) {
+    if (table.includes(".")) {
+      const [schema, ...rest] = table.split(".");
+      return { schema, tableName: rest.join(".") };
+    }
+    return { schema: "public", tableName: table };
+  }
+  // ===========================================================================
+  // Query Operations
+  // ===========================================================================
+  /**
+   * Execute a query and return results with optional count
+   *
+   * @param table - The table name to query
+   * @param options - Query options (select, where, orderBy, limit, offset)
+   * @returns Promise resolving to query results with optional count
+   */
+  async query(table, options) {
+    const { select = "*", where, orderBy, limit, offset } = options;
+    const { schema, tableName } = this.parseTableIdentifier(table);
+    let query = this.supabase.schema(schema).from(tableName).select(select, { count: "exact" });
+    if (where) {
+      query = this.applyWhereClause(query, where);
+    }
+    if (orderBy && orderBy.length > 0) {
+      for (const order of orderBy) {
+        query = query.order(order.field, {
+          ascending: order.direction === "asc"
+        });
+      }
+    }
+    if (limit !== void 0 && offset !== void 0) {
+      query = query.range(offset, offset + limit - 1);
+    } else if (limit !== void 0) {
+      query = query.limit(limit);
+    }
+    const { data, error, count } = await query;
+    if (error) {
+      throw new Error(`Supabase query error on ${table}: ${error.message}`);
+    }
+    return {
+      data: data ?? [],
+      count: count ?? void 0
+    };
+  }
+  /**
+   * Query a single record by ID
+   *
+   * @param table - The table name to query
+   * @param id - The record ID
+   * @param options - Optional query options (mainly for select)
+   * @returns Promise resolving to the record or null if not found
+   */
+  async queryById(table, id, options) {
+    const select = options?.select ?? "*";
+    const { schema, tableName } = this.parseTableIdentifier(table);
+    const { data, error } = await this.supabase.schema(schema).from(tableName).select(select).eq("id", id).single();
+    if (error) {
+      if (error.code === "PGRST116") {
+        return null;
+      }
+      throw new Error(`Supabase queryById error on ${table}: ${error.message}`);
+    }
+    return data;
+  }
+  // ===========================================================================
+  // Mutation Operations
+  // ===========================================================================
+  /**
+   * Insert a new record
+   *
+   * @param table - The table name
+   * @param data - The data to insert
+   * @returns Promise resolving to the inserted record
+   */
+  async insert(table, data) {
+    const { schema, tableName } = this.parseTableIdentifier(table);
+    const { data: insertedData, error } = await this.supabase.schema(schema).from(tableName).insert(data).select().single();
+    if (error) {
+      throw new Error(`Supabase insert error on ${table}: ${error.message}`);
+    }
+    return insertedData;
+  }
+  /**
+   * Update an existing record by ID
+   *
+   * @param table - The table name
+   * @param id - The record ID to update
+   * @param data - The data to update
+   * @returns Promise resolving to the updated record
+   */
+  async update(table, id, data) {
+    const { schema, tableName } = this.parseTableIdentifier(table);
+    const { data: updatedData, error } = await this.supabase.schema(schema).from(tableName).update(data).eq("id", id).select().single();
+    if (error) {
+      throw new Error(`Supabase update error on ${table}: ${error.message}`);
+    }
+    return updatedData;
+  }
+  /**
+   * Upsert (insert or update) a record
+   *
+   * @param table - The table name
+   * @param data - The data to upsert
+   * @returns Promise resolving to the upserted record
+   */
+  async upsert(table, data) {
+    const { schema, tableName } = this.parseTableIdentifier(table);
+    const { data: upsertedData, error } = await this.supabase.schema(schema).from(tableName).upsert(data, { onConflict: "id" }).select().single();
+    if (error) {
+      throw new Error(`Supabase upsert error on ${table}: ${error.message}`);
+    }
+    return upsertedData;
+  }
+  /**
+   * Delete a record by ID
+   *
+   * @param table - The table name
+   * @param id - The record ID to delete
+   * @returns Promise that resolves when deletion is complete
+   */
+  async delete(table, id) {
+    const { schema, tableName } = this.parseTableIdentifier(table);
+    const { error } = await this.supabase.schema(schema).from(tableName).delete().eq("id", id);
+    if (error) {
+      throw new Error(`Supabase delete error on ${table}: ${error.message}`);
+    }
+  }
+  // ===========================================================================
+  // Subscription (Real-time)
+  // ===========================================================================
+  /**
+   * Subscribe to real-time changes on a query
+   *
+   * @param table - The table name to watch
+   * @param options - Query options to filter what to watch
+   * @param callback - Function called with updated data
+   * @returns Unsubscribe function
+   */
+  subscribe(table, options, callback) {
+    const { schema, tableName } = this.parseTableIdentifier(table);
+    const channelName = `v3:${table}:${Date.now()}`;
+    const channel = this.supabase.channel(channelName).on(
+      "postgres_changes",
+      {
+        event: "*",
+        schema,
+        table: tableName
+      },
+      async () => {
+        try {
+          const { data } = await this.query(table, options);
+          callback(data);
+        } catch (error) {
+          console.error(
+            `Supabase subscription refetch error on ${table}:`,
+            error
+          );
+        }
+      }
+    ).subscribe();
+    return () => {
+      this.supabase.removeChannel(channel);
+    };
+  }
+  // ===========================================================================
+  // Private Helper Methods
+  // ===========================================================================
+  /**
+   * Apply where clause filters to a Supabase query
+   *
+   * Converts WhereClause to Supabase filter methods:
+   * - Direct value: .eq(field, value)
+   * - { in: [...] }: .in(field, values)
+   * - { gt: n }: .gt(field, n)
+   * - { gte: n }: .gte(field, n)
+   * - { lt: n }: .lt(field, n)
+   * - { lte: n }: .lte(field, n)
+   * - { like: s }: .ilike(field, s)
+   * - { is: null }: .is(field, null)
+   * - { neq: v }: .neq(field, v) or .not(field, "is", null)
+   * - { notIn: [...] }: .not().in(field, values)
+   *
+   * @param query - The Supabase query builder
+   * @param where - The where clause to apply
+   * @returns The query with filters applied
+   */
+  applyWhereClause(query, where) {
+    for (const [field, condition] of Object.entries(where)) {
+      if (condition === null) {
+        query = query.is(field, null);
+      } else if (typeof condition === "string" || typeof condition === "number" || typeof condition === "boolean") {
+        query = query.eq(field, condition);
+      } else if (typeof condition === "object") {
+        const operators = condition;
+        if (operators.in !== void 0) {
+          query = query.in(field, operators.in);
+        }
+        if (operators.gt !== void 0) {
+          query = query.gt(field, operators.gt);
+        }
+        if (operators.gte !== void 0) {
+          query = query.gte(field, operators.gte);
+        }
+        if (operators.lt !== void 0) {
+          query = query.lt(field, operators.lt);
+        }
+        if (operators.lte !== void 0) {
+          query = query.lte(field, operators.lte);
+        }
+        if (operators.like !== void 0) {
+          query = query.ilike(field, operators.like);
+        }
+        if (operators.is !== void 0) {
+          query = query.is(field, null);
+        }
+        if (operators.neq !== void 0) {
+          if (operators.neq === null) {
+            query = query.not(field, "is", null);
+          } else {
+            query = query.neq(field, operators.neq);
+          }
+        }
+        if (operators.notIn !== void 0) {
+          query = query.not(field, "in", `(${operators.notIn.join(",")})`);
+        }
+      }
+    }
+    return query;
+  }
+};
+function createSupabaseAdapter(supabase, schema) {
+  return new SupabaseAdapter(supabase, schema);
+}
+
+// src/supabase-functions.tsx
+async function getErrorBody(response) {
+  const stream = response.error.context.body;
+  const reader = stream.getReader();
+  const { value } = await reader.read();
+  const text = new TextDecoder().decode(value);
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    parsed = text;
+  }
+  return parsed;
+}
+
+// src/useAI.ts
+function useAI() {
+  const supabase = useSupabase();
+  const generate = async (prompt, context, options) => {
+    const response = await supabase.functions.invoke("ai", {
+      body: { prompt, context, options }
+    });
+    if (response.error) {
+      throw new Error(`Failed to invoke AI function: ${response.error.message}`);
+    }
+    if (response.data?.error) {
+      throw new Error(response.data.error);
+    }
+    if (!response.data?.success) {
+      throw new Error(response.data?.error || "Unknown error occurred");
+    }
+    if (!response.data?.data?.response) {
+      throw new Error("No response from AI");
+    }
+    return response.data.data.response;
+  };
+  return { generate };
+}
+
+// src/useServerAvailability.ts
+import { useState as useState3, useEffect as useEffect4, useCallback } from "react";
+var CHECK_TIMEOUT = 1e4;
+var CHECK_INTERVAL = 3e4;
+function useServerAvailability(options) {
+  const { enabled = true, checkInterval = CHECK_INTERVAL, timeout = CHECK_TIMEOUT } = options || {};
+  const [isAvailable, setIsAvailable] = useState3(null);
+  const [isChecking, setIsChecking] = useState3(false);
+  const [lastChecked, setLastChecked] = useState3(null);
+  const [error, setError] = useState3(null);
+  const checkAvailability = useCallback(async () => {
+    if (!enabled) return;
+    setIsChecking(true);
+    setError(null);
+    try {
+      const supabaseUrl = getSupabaseUrl();
+      const supabaseAnonKey = process.env.SUPABASE_ANON_KEY || process.env.EXPO_PUBLIC_SUPABASE_ANON_KEY;
+      if (!supabaseUrl) {
+        throw new Error("Supabase URL is not configured");
+      }
+      if (!supabaseAnonKey) {
+        throw new Error("Supabase anon key is not configured");
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      const healthCheckPromise = fetch(`${supabaseUrl}/rest/v1/`, {
+        method: "HEAD",
+        headers: {
+          apikey: supabaseAnonKey
+        },
+        signal: controller.signal
+      }).then((response) => {
+        clearTimeout(timeoutId);
+        return response.status < 500;
+      }).catch((err) => {
+        clearTimeout(timeoutId);
+        if (err.name === "AbortError") {
+          return false;
+        }
+        return false;
+      });
+      const available = await healthCheckPromise;
+      setIsAvailable(available);
+      setLastChecked(/* @__PURE__ */ new Date());
+      setError(null);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Unknown error checking server availability");
+      setIsAvailable(false);
+      setError(error2);
+      setLastChecked(/* @__PURE__ */ new Date());
+    } finally {
+      setIsChecking(false);
+    }
+  }, [enabled, timeout]);
+  useEffect4(() => {
+    if (enabled) {
+      checkAvailability();
+    }
+  }, [enabled, checkAvailability]);
+  useEffect4(() => {
+    if (!enabled || isAvailable !== false) return;
+    const intervalId = setInterval(() => {
+      checkAvailability();
+    }, checkInterval);
+    return () => clearInterval(intervalId);
+  }, [enabled, isAvailable, checkInterval, checkAvailability]);
+  return {
+    isAvailable,
+    isChecking,
+    lastChecked,
+    error,
+    checkAvailability
+  };
+}
+
+// src/useSearchQuery.ts
+import { useMemo as useMemo5 } from "react";
+import React from "react";
+function useSearchQuery(baseQuery, searchText, columns, options = { isOptional: true, additionCondition: [] }) {
+  const original = React.useRef(null);
+  if (original.current?.lastQuery !== baseQuery) {
+    const b = baseQuery;
+    const urlValue = b.url;
+    const url = urlValue ? typeof urlValue === "string" ? new URL(urlValue) : new URL(urlValue.toString()) : new URL("http://localhost");
+    const method = b.method ?? "GET";
+    const headers = b.headers ?? {};
+    const body = method !== "GET" && method !== "HEAD" ? b.body ?? null : null;
+    const signal = b.signal ?? null;
+    original.current = {
+      lastQuery: baseQuery,
+      original: {
+        url,
+        method,
+        headers,
+        body,
+        signal
+      }
+    };
+  }
+  return useMemo5(() => {
+    const qb = baseQuery;
+    const { url, method, body, signal } = original.current.original;
+    qb.url = new URL(url.toString());
+    qb.method = method;
+    if (method !== "GET" && method !== "HEAD") {
+      qb.body = body;
+    } else {
+      delete qb.body;
+    }
+    qb.signal = signal;
+    const term = searchText.trim();
+    if (term) {
+      const clauses = columns.map((col) => {
+        const [tbl, colName] = col.split(".");
+        return `${colName ?? tbl}.ilike.%${escapeLikePattern(term)}%`;
+      });
+      clauses.push(...options.additionCondition.filter(Boolean));
+      qb.or(
+        clauses.join(","),
+        {
+          referencedTable: columns.find((c) => c.includes("."))?.split(".")[0]
+        }
+      );
+    } else if (!options.isOptional) {
+      const conds = options.additionCondition.filter(Boolean);
+      conds?.length ? qb.or(conds.join(",")) : qb.limit(0);
+    }
+    return qb;
+  }, [
+    baseQuery,
+    searchText,
+    columns.join(","),
+    options.isOptional,
+    options.additionCondition.join(",")
+  ]);
+}
+function escapeLikePattern(text) {
+  return text?.replace(/[%_]/g, "\\$&");
+}
+
+// src/useLiveChangeTracking.ts
+import { useEffect as useEffect5, useState as useState4 } from "react";
+var import_moment = __toESM(require_moment(), 1);
+function useLiveChangeTracking(tableName, item, action) {
+  const [changeLog, setChangeLog] = useState4(null);
+  const [oldItem, setOldItem] = useState4(null);
+  const supabase = useSupabase();
+  useEffect5(() => {
+    setChangeLog(null);
+    if (isUsable(item) === false) return;
+    if (isUsable(oldItem) === false) {
+      setOldItem(item);
+      return;
+    }
+    const itemId = item["id"];
+    if (isUsable(itemId) === false) return;
+    const changes = getObjectChanges(oldItem, item);
+    if (Object.keys(changes).length === 0) return;
+    supabase.schema("core").from("OperationLog").select().filter("tableName", "eq", tableName).filter("recordId", "eq", itemId).order("changeAt", { ascending: false }).limit(1).single().then((x) => {
+      if (isUsable(x.data) === false) return;
+      const data = x.data;
+      if (data.sessionId === UserSessionId) return;
+      const changeLog2 = {
+        modifiedByUserId: data.changeBy,
+        changedOn: import_moment.default.utc(data.changeAt),
+        changes
+      };
+      setChangeLog(changeLog2);
+    });
+    setOldItem(item);
+  }, [item]);
+  useEffect5(() => {
+    if (isUsable(changeLog) && action) {
+      action(changeLog.changes, changeLog);
+    }
+  }, [changeLog]);
+  return changeLog;
+}
+
+// src/useLatestOperationLog.ts
+function useLatestOperationLog(tableName, recordId) {
+  const supabase = useSupabase();
+  return useDbQuery(
+    supabase.schema("core").from("OperationLog").select(OperationLog.defaultQuery).eq("recordId", String(recordId)).eq("tableName", tableName).order("changeAt", { ascending: false }).limit(1).maybeSingle(),
+    {
+      refetchOnMount: true,
+      refetchOnWindowFocus: true,
+      staleTime: 0,
+      enabled: isUsable(recordId)
+    }
+  );
+}
+
+// src/useAutosaveState.ts
+import {
+  useCallback as useCallback2,
+  useEffect as useEffect6,
+  useMemo as useMemo6,
+  useRef as useRef5,
+  useState as useState5
+} from "react";
+function newTimeActivity(date) {
+  return {
+    activityDate: date.clone().startOf("day").toISOString(true),
+    description: "",
+    hasRequestBillableChange: false,
+    hasRequestVerification: false,
+    hours: 0,
+    userNotes: "",
+    adminNotes: "",
+    userId: null,
+    clientId: null,
+    projectId: null,
+    workingPhaseId: null,
+    roleId: null,
+    taskId: null,
+    subtaskId: null,
+    weeklyTimesheetId: null,
+    id: null,
+    BillingDetails: {
+      status: "Unknown",
+      id: null,
+      orderHint: "",
+      chargeTableId: null,
+      cosmosId: null,
+      amount: 0,
+      rate: 0,
+      type: "TimeActivity"
+    }
+  };
+}
+function getNewValue(action, prevState) {
+  return typeof action === "function" ? action(prevState) : action;
+}
+function useAutosaveState(relation, defaultValue, options) {
+  const [value, setValue] = useState5(() => defaultValue);
+  const [baseValue, setBaseValue] = useState5(() => defaultValue);
+  const pendingChangesRef = useRef5(/* @__PURE__ */ new Map());
+  const currentId = useRef5(null);
+  const newOptions = useMemo6(
+    () => options ? { ...options, primaryKeys: options.primaryKeys ?? ["id"] } : { delay: 200, primaryKeys: ["id"] },
+    [options]
+  );
+  const upsertMutation = useDbUpsert(relation, newOptions.primaryKeys);
+  const saveEntityChanges = useCallback2(async (entityId) => {
+    const pending = pendingChangesRef.current.get(entityId);
+    if (!pending) return;
+    const changes = diff(pending.baseValue, pending.currentValue);
+    if (Object.keys(changes).length === 0) {
+      pendingChangesRef.current.delete(entityId);
+      return;
+    }
+    const patch = { ...changes, id: entityId };
+    const finalPatch = newOptions.transformBeforeMutation ? newOptions.transformBeforeMutation(patch) : patch;
+    await upsertMutation.mutateAsync(finalPatch);
+    pendingChangesRef.current.delete(entityId);
+  }, [upsertMutation, newOptions.transformBeforeMutation]);
+  const updateValue = useCallback2((update) => {
+    setValue((prev) => {
+      const newValue = getNewValue(update, prev);
+      const entityId = newValue.id;
+      if (!entityId) return newValue;
+      let pending = pendingChangesRef.current.get(entityId);
+      if (!pending) {
+        pending = {
+          baseValue,
+          currentValue: newValue,
+          timeoutId: null
+        };
+        pendingChangesRef.current.set(entityId, pending);
+      } else {
+        pending.currentValue = newValue;
+      }
+      if (pending.timeoutId) {
+        clearTimeout(pending.timeoutId);
+      }
+      pending.timeoutId = setTimeout(() => {
+        saveEntityChanges(entityId);
+      }, newOptions.delay);
+      return newValue;
+    });
+  }, [baseValue, saveEntityChanges, newOptions.delay]);
+  const setNewEntity = useCallback2((newEntity) => {
+    setValue(newEntity);
+    setBaseValue(newEntity);
+    currentId.current = newEntity.id;
+  }, []);
+  useEffect6(() => {
+    return () => {
+      pendingChangesRef.current.forEach((pending) => {
+        if (pending.timeoutId) clearTimeout(pending.timeoutId);
+      });
+    };
+  }, []);
+  const saveCurrentValue = useCallback2(async () => {
+    if (currentId.current) {
+      await saveEntityChanges(currentId.current);
+    }
+  }, [saveEntityChanges]);
+  return [
+    value,
+    updateValue,
+    upsertMutation,
+    setValue,
+    setNewEntity,
+    saveCurrentValue
+  ];
+}
+
+// src/useToastError.ts
+import { useEffect as useEffect7 } from "react";
+import { useToast } from "@pol-studios/hooks/toast";
+function useToastError(mutation) {
+  const toast = useToast();
+  useEffect7(() => {
+    if (isUsable(mutation.error) === false) return;
+    toast.toast({ title: "Error", description: mutation.error.message });
+  }, [mutation.error]);
+  return mutation;
+}
+
+// src/advance-query.tsx
+async function executeAdvanceQuery(supabase, query, filterLayer) {
+  const parser = new PostgrestParser(query);
+  const filterGroup = {
+    id: filterLayer.id,
+    op: filterLayer.op,
+    not: filterLayer.not,
+    filters: filterLayer.filters.map(normalizeFilter).filter((f) => f !== null)
+  };
+  const pagination = { offset: void 0, limit: void 0 };
+  const sort = [...filterLayer.sort || []];
+  const searchParams = Array.from(parser.searchParams.entries());
+  searchParams.forEach(([k, v]) => {
+    if (k.includes("offset")) {
+      pagination.offset = Number(v);
+      return;
+    }
+    if (k.includes("limit")) {
+      pagination.limit = Number(v);
+      return;
+    }
+    if (k.includes("order")) {
+      const orderColumns = v.split(",");
+      orderColumns.forEach((x) => {
+        const values2 = x.split(".");
+        sort.push({
+          field: values2[0],
+          direction: values2[1] === "asc" ? "asc" : "desc"
+        });
+      });
+      return;
+    }
+    if (v.includes(".") === false) return;
+    const values = v.split(".");
+    const column = k;
+    const rawCondition = values[0];
+    let condition = "";
+    const value = values[1];
+    if (column == "select") return;
+    switch (rawCondition) {
+      case "eq":
+        condition = "=";
+        break;
+      case "in":
+        condition = "in";
+        break;
+      case "lt":
+        condition = "<";
+        break;
+      case "gt":
+        condition = ">";
+        break;
+      case "lte":
+        condition = "<=";
+        break;
+      case "gte":
+        condition = ">=";
+        break;
+      case "is":
+        condition = "is";
+        break;
+      case "ilike":
+        condition = "ilike";
+        break;
+      case "neq":
+        condition = "=";
+        break;
+      case "like":
+        condition = "contains";
+        break;
+    }
+    filterGroup.filters.push({
+      id: `filter_${column}_${Date.now()}`,
+      field: column,
+      op: condition,
+      value,
+      display: `${column} ${condition} ${value}`
+    });
+  });
+  const stripUIProperties = (obj) => {
+    return JSON.parse(JSON.stringify(obj, (key, value) => {
+      if (key === "display" || key === "info" || key === "options") {
+        return void 0;
+      }
+      return value;
+    }));
+  };
+  const cleanedBody = stripUIProperties({
+    table: parser.table,
+    schema: parser.schema,
+    select: parser.select,
+    filters: filterGroup,
+    pagination,
+    sort,
+    count: "exact"
+  });
+  const response = await supabase.functions.invoke("query", {
+    body: cleanedBody,
+    method: "POST"
+  });
+  if (response.error) {
+    return { data: null, count: null, error: response.error };
+  }
+  return { data: response.data?.data ?? null, count: response.data?.count ?? null, error: null };
+}
+
+// src/storage/useStorageUrl.ts
+var import_moment2 = __toESM(require_moment(), 1);
+import { useRef as useRef6 } from "react";
+import { useIndexedDB } from "@pol-studios/hooks/storage";
+var cacheVersions = /* @__PURE__ */ new Map();
+var cacheVersionListeners = /* @__PURE__ */ new Map();
+var retryAttempts = /* @__PURE__ */ new Map();
+function useStorageUrl() {
+  const db = useIndexedDB({
+    dbName: "polstudios",
+    storeName: "cached-urls"
+  });
+  const storedUrls = useRef6(/* @__PURE__ */ new Map());
+  const supabase = useSupabase();
+  function getCacheVersion(entity) {
+    const key = `${entity.bucketId}${entity.path}`;
+    return cacheVersions.get(key) || 0;
+  }
+  function subscribeToCacheVersion(entity, callback) {
+    const key = `${entity.bucketId}${entity.path}`;
+    if (!cacheVersionListeners.has(key)) {
+      cacheVersionListeners.set(key, /* @__PURE__ */ new Set());
+    }
+    cacheVersionListeners.get(key).add(callback);
+    return () => {
+      cacheVersionListeners.get(key)?.delete(callback);
+    };
+  }
+  async function expireCache(entity) {
+    const key = `${entity.bucketId}${entity.path}`;
+    const dbKeys = await db.getAllKeys();
+    const keysToDelete = Array.from(
+      new Set(
+        [...Array.from(storedUrls.current.keys()), ...dbKeys].filter(
+          (value) => value.startsWith(key)
+        )
+      )
+    );
+    await Promise.all(
+      keysToDelete.map(
+        async (x) => {
+          storedUrls.current.delete(x);
+          await db.removeItem(x);
+        }
+      )
+    );
+    const currentVersion = cacheVersions.get(key) || 0;
+    cacheVersions.set(key, currentVersion + 1);
+    const listeners = cacheVersionListeners.get(key);
+    if (listeners) {
+      listeners.forEach((callback) => {
+        callback();
+      });
+    }
+  }
+  async function baseFetchUrl(entity, options, isPublic = false) {
+    if (isUsable(entity) === false) return;
+    const optionsString = JSON.stringify(options);
+    if (isUsable(entity.bucketId) === false) {
+      return;
+    }
+    if (isUsable(entity.path) === false) {
+      return;
+    }
+    const key = `${entity.bucketId}${entity.path}${optionsString ?? ""}-cached-url`;
+    const inMemoryItem = storedUrls.current.get(key);
+    let item = inMemoryItem;
+    if (isUsable(inMemoryItem) === false) {
+      item = await db.getItem(key) ?? void 0;
+      if (isUsable(item)) {
+      }
+    } else {
+    }
+    if (isUsable(item) && (0, import_moment2.default)(item.expiresOn).isAfter((0, import_moment2.default)().add(-1 * 60, "seconds"))) {
+      return item.url;
+    }
+    const base = supabase.storage.from(entity.bucketId);
+    let download = options?.download;
+    if (typeof options?.download === "string") {
+      const ext = entity.path.split(".").pop() ?? "";
+      download = options?.download.endsWith(ext) ? options?.download : options?.download + "." + ext;
+    }
+    const newOptions = options ? { ...options, download } : void 0;
+    const retryKey = `${entity.bucketId}/${entity.path}`;
+    const currentRetries = retryAttempts.get(retryKey) || 0;
+    let url;
+    if (isPublic) {
+      url = base.getPublicUrl(entity.path, newOptions).data.publicUrl;
+    } else {
+      try {
+        console.log("Creating signed URL for", entity.path);
+        const result = await base.createSignedUrl(entity.path, 60 * 100, newOptions);
+        url = result.data?.signedUrl;
+        if (isUsable(url)) {
+          retryAttempts.delete(retryKey);
+        } else if (currentRetries < 3) {
+          retryAttempts.set(retryKey, currentRetries + 1);
+          throw new Error("Failed to get signed URL");
+        }
+      } catch (error) {
+        if (currentRetries < 3) {
+          retryAttempts.set(retryKey, currentRetries + 1);
+          const delay = Math.min(1e3 * Math.pow(2, currentRetries), 5e3);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          return baseFetchUrl(entity, options, isPublic);
+        }
+        retryAttempts.delete(retryKey);
+        return void 0;
+      }
+    }
+    if (isUsable(url) === false) return url;
+    const cachedUrl = {
+      key,
+      url,
+      expiresOn: (0, import_moment2.default)().add(60 * 100, "seconds").toISOString(true)
+    };
+    storedUrls.current.set(key, cachedUrl);
+    db.setItem(key, cachedUrl);
+    return url;
+  }
+  async function fetchUrl(entity, options) {
+    return baseFetchUrl(entity, options, false);
+  }
+  async function fetchPublicUrl(entity, options) {
+    return baseFetchUrl(entity, options, true);
+  }
+  async function prefetchImage(entity, options) {
+    const url = await fetchUrl(entity, options);
+    if (url) {
+      new Image().src = url;
+    }
+  }
+  async function fetchUrls(entities, options) {
+    const results = /* @__PURE__ */ new Map();
+    if (entities.length === 0) return results;
+    const optionsString = JSON.stringify(options);
+    const expirySeconds = 60 * 100;
+    const byBucket = /* @__PURE__ */ new Map();
+    for (const entity of entities) {
+      if (!isUsable(entity.bucketId) || !isUsable(entity.path)) continue;
+      const list = byBucket.get(entity.bucketId) ?? [];
+      list.push(entity);
+      byBucket.set(entity.bucketId, list);
+    }
+    for (const [bucketId, bucketEntities] of byBucket) {
+      const uncached = [];
+      for (const entity of bucketEntities) {
+        const key = `${entity.bucketId}${entity.path}${optionsString ?? ""}-cached-url`;
+        const entityKey = `${entity.bucketId}/${entity.path}`;
+        let item = storedUrls.current.get(key);
+        if (!isUsable(item)) {
+          item = await db.getItem(key) ?? void 0;
+        }
+        if (isUsable(item) && (0, import_moment2.default)(item.expiresOn).isAfter((0, import_moment2.default)().add(-1 * 60, "seconds"))) {
+          results.set(entityKey, item.url);
+        } else {
+          uncached.push(entity);
+        }
+      }
+      if (uncached.length > 0) {
+        const paths = uncached.map((e) => e.path);
+        const base = supabase.storage.from(bucketId);
+        try {
+          console.log("Signed URLs created");
+          const { data, error } = await base.createSignedUrls(paths, expirySeconds);
+          if (!error && data) {
+            const expiresOn = (0, import_moment2.default)().add(expirySeconds, "seconds").toISOString(true);
+            for (let i = 0; i < uncached.length; i++) {
+              const entity = uncached[i];
+              const urlData = data[i];
+              const entityKey = `${entity.bucketId}/${entity.path}`;
+              const cacheKey = `${entity.bucketId}${entity.path}${optionsString ?? ""}-cached-url`;
+              if (urlData?.signedUrl) {
+                results.set(entityKey, urlData.signedUrl);
+                const cachedUrl = {
+                  key: cacheKey,
+                  url: urlData.signedUrl,
+                  expiresOn
+                };
+                storedUrls.current.set(cacheKey, cachedUrl);
+                db.setItem(cacheKey, cachedUrl);
+              } else {
+                results.set(entityKey, void 0);
+              }
+            }
+          } else {
+            for (const entity of uncached) {
+              const entityKey = `${entity.bucketId}/${entity.path}`;
+              const url = await fetchUrl(entity, options);
+              results.set(entityKey, url);
+            }
+          }
+        } catch {
+          for (const entity of uncached) {
+            const entityKey = `${entity.bucketId}/${entity.path}`;
+            const url = await fetchUrl(entity, options);
+            results.set(entityKey, url);
+          }
+        }
+      }
+    }
+    return results;
+  }
+  return { fetchUrl, fetchUrls, prefetchImage, fetchPublicUrl, expireCache, getCacheVersion, subscribeToCacheVersion };
+}
+
+// src/storage/useStoragePath.ts
+import { useEffect as useEffect8, useState as useState6 } from "react";
+function getContentType(metadata, path) {
+  if (metadata?.contentType) {
+    return metadata.contentType;
+  }
+  const ext = path.split(".").pop()?.toUpperCase();
+  return ext || "Unknown";
+}
+function useStoragePath(storagePath, bucketId, options = {}) {
+  const { fetchMetadata = true, transform, download } = options;
+  const [url, setUrl] = useState6(null);
+  const [error, setError] = useState6(null);
+  const { fetchUrl } = useStorageUrl();
+  const supabase = useSupabase();
+  useEffect8(() => {
+    if (!isUsable(storagePath) || !isUsable(bucketId)) {
+      setUrl(null);
+      return;
+    }
+    let cancelled = false;
+    fetchUrl({ bucketId, path: storagePath }, { transform, download }).then((signedUrl) => {
+      if (!cancelled) {
+        setUrl(signedUrl ?? null);
+        setError(null);
+      }
+    }).catch((err) => {
+      if (!cancelled) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setUrl(null);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [storagePath, bucketId, JSON.stringify(transform), download]);
+  const storageQuery = supabase.schema("storage").from("objects").select("metadata").eq("bucket_id", bucketId).eq("name", storagePath ?? "").maybeSingle();
+  const metadataRequest = useDbQuery(
+    storageQuery,
+    {
+      enabled: fetchMetadata && isUsable(storagePath) && isUsable(bucketId)
+    }
+  );
+  const metadata = metadataRequest.data?.metadata ?? null;
+  const contentType = getContentType(metadata, storagePath ?? "");
+  const isLoading = isUsable(storagePath) && url === null && error === null || fetchMetadata && metadataRequest.isFetching;
+  return {
+    url,
+    metadata,
+    contentType,
+    isLoading,
+    error
+  };
+}
+
+// src/storage/bucketConfig.ts
+var BUCKETS = {
+  AVATARS: "avatars",
+  FIXTURE_CATALOG_COVER: "fixture-catalog-cover",
+  FIXTURE_ATTACHMENTS: "fixture-attachments",
+  UNIT_DOCUMENTATION: "unit-documentation-attachments",
+  DATASHEETS: "datasheets",
+  PATTERNS: "patterns",
+  LOGOS: "logos",
+  RECEIPTS: "receipts",
+  TICKET_ATTACHMENTS: "ticket-attachment",
+  PROCESS_RESULTS: "process-results",
+  DATA_EXCHANGE_IMPORTS: "data-exchange-imports",
+  EMAIL_TEMPLATES: "email-templates",
+  EMAIL_TEMPLATES_ASSETS: "email-templates-assets"
+};
+
+// src/utilities/query-utils.ts
+function createInCondition(column, values) {
+  let condition = "";
+  if (values.length > 2e3) {
+    throw new Error("Too many values to create in condition");
+  }
+  chunkArray(values, 99).forEach((x, index) => {
+    if (index == 0) {
+      condition = `${column}.in.(${x.join(",")})`;
+      return;
+    }
+    condition += `,${column}.in.(${x.join(",")})`;
+  });
+  return condition;
+}
+
+// src/contexts/LiveChangeContext.tsx
+import { createContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var LiveChangeContext = createContext({});
+var LiveChangeContextProvider = ({
+  children,
+  changeLog
+}) => {
+  const supabase = useSupabase();
+  const userRequest = useDbQuery(
+    supabase.schema("core").from("Profile").select().eq("id", changeLog?.modifiedByUserId).single(),
+    {
+      enabled: isUsable(changeLog?.modifiedByUserId),
+      crossOrganization: true
+    }
+  );
+  return /* @__PURE__ */ jsx(
+    LiveChangeContext.Provider,
+    {
+      value: {
+        changeLog,
+        lastModifiedUserName: userRequest.data?.firstName + " " + userRequest.data?.lastName
+      },
+      children
+    }
+  );
+};
+
+// src/changelog/useChangelogMutations.ts
+var useUpsertChangelog = () => {
+  return useDbUpsert(
+    "Changelog",
+    ["id"],
+    `
+    *,
+    ChangelogEntry (
+      *,
+      ChangelogMedia (*)
+    )
+  `
+  );
+};
+var useDeleteChangelog = () => {
+  return useDbDelete("Changelog");
+};
+var useUpsertChangelogEntry = () => {
+  return useDbUpsert("ChangelogEntry", ["id"], "*, ChangelogMedia (*)");
+};
+var useMultiUpsertChangelogEntries = () => {
+  return useDbMultiUpsert("ChangelogEntry", ["id"], "*, ChangelogMedia (*)");
+};
+var useDeleteChangelogEntry = () => {
+  return useDbDelete("ChangelogEntry");
+};
+var useMultiDeleteChangelogEntries = () => {
+  return useDbMultiDelete("ChangelogEntry");
+};
+var useUpsertChangelogMedia = () => {
+  return useDbUpsert("ChangelogMedia", ["id"], "*");
+};
+var useDeleteChangelogMedia = () => {
+  return useDbDelete("ChangelogMedia");
+};
+var useUploadChangelogMedia = () => {
+  return { mutateAsync: async () => ({ path: "", publicUrl: "" }) };
+};
+
+// src/changelog/useChangelogQuery.ts
+var useChangelogs = (options) => {
+  const supabase = useSupabase();
+  const query = supabase.from("Changelog").select(
+    `
+      *,
+      ChangelogEntry (
+        *,
+        ChangelogMedia (*)
+      )
+    `
+  ).order("releaseDate", { ascending: false }).order("order", { foreignTable: "ChangelogEntry", ascending: true }).order("order", { foreignTable: "ChangelogEntry.ChangelogMedia", ascending: true });
+  if (options?.realtime) {
+    return useDbRealtimeQuery(query, { crossOrganization: true });
+  }
+  return useDbQuery(query, { crossOrganization: true });
+};
+var usePublishedChangelogs = (options) => {
+  const supabase = useSupabase();
+  const query = supabase.from("Changelog").select(
+    `
+      *,
+      ChangelogEntry (
+        *,
+        ChangelogMedia (*)
+      )
+    `
+  ).eq("isPublished", true).order("releaseDate", { ascending: false }).order("order", { foreignTable: "ChangelogEntry", ascending: true }).order("order", { foreignTable: "ChangelogEntry.ChangelogMedia", ascending: true });
+  if (options?.realtime) {
+    return useDbRealtimeQuery(query, { crossOrganization: true });
+  }
+  return useDbQuery(query, { crossOrganization: true });
+};
+var useChangelogById = (id) => {
+  const supabase = useSupabase();
+  return useDbQuery(
+    supabase.from("Changelog").select(
+      `
+        *,
+        ChangelogEntry (
+          *,
+          ChangelogMedia (*)
+        )
+      `
+    ).eq("id", id).order("order", { foreignTable: "ChangelogEntry", ascending: true }).order("order", { foreignTable: "ChangelogEntry.ChangelogMedia", ascending: true }).single(),
+    {
+      enabled: !!id,
+      crossOrganization: true
+    }
+  );
+};
+var useChangelogBySlug = (slug) => {
+  const supabase = useSupabase();
+  return useDbQuery(
+    supabase.from("Changelog").select(
+      `
+        *,
+        ChangelogEntry (
+          *,
+          ChangelogMedia (*)
+        )
+      `
+    ).eq("slug", slug).order("order", { foreignTable: "ChangelogEntry", ascending: true }).order("order", { foreignTable: "ChangelogEntry.ChangelogMedia", ascending: true }).single(),
+    {
+      enabled: !!slug,
+      crossOrganization: true
+    }
+  );
+};
+var useChangelogEntries = (changelogId) => {
+  const supabase = useSupabase();
+  return useDbQuery(
+    supabase.from("ChangelogEntry").select("*, ChangelogMedia (*)").eq("changelogId", changelogId).order("order", { ascending: true }).order("order", { foreignTable: "ChangelogMedia", ascending: true }),
+    {
+      enabled: !!changelogId,
+      crossOrganization: true
+    }
+  );
+};
+var useChangelogMedia = (entryId) => {
+  const supabase = useSupabase();
+  return useDbQuery(
+    supabase.from("ChangelogMedia").select("*").eq("changelogEntryId", entryId).order("order", { ascending: true }),
+    {
+      enabled: !!entryId,
+      crossOrganization: true
+    }
+  );
+};
+
+// src/nl-training/useFeedbackList.ts
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+function useFeedbackList(params = {}) {
+  const supabase = useSupabase();
+  return useQuery2({
+    queryKey: ["feedback-list", params],
+    queryFn: async () => {
+      const searchParams = new URLSearchParams();
+      if (params.resolved !== void 0) {
+        searchParams.append("resolved", String(params.resolved));
+      }
+      if (params.status) {
+        searchParams.append("status", params.status);
+      }
+      if (params.limit) {
+        searchParams.append("limit", String(params.limit));
+      }
+      if (params.offset) {
+        searchParams.append("offset", String(params.offset));
+      }
+      if (params.userId) {
+        searchParams.append("userId", params.userId);
+      }
+      if (params.startDate) {
+        searchParams.append("startDate", params.startDate);
+      }
+      if (params.endDate) {
+        searchParams.append("endDate", params.endDate);
+      }
+      const { data, error } = await supabase.functions.invoke("query", {
+        body: {},
+        method: "GET",
+        headers: {
+          "X-Path": `/query/feedback?${searchParams.toString()}`
+        }
+      });
+      if (error) throw error;
+      return data;
+    }
+  });
+}
+
+// src/nl-training/useSubmitFeedback.ts
+import { useMutation as useMutation6, useQueryClient } from "@tanstack/react-query";
+function useSubmitFeedback() {
+  const supabase = useSupabase();
+  const queryClient = useQueryClient();
+  return useMutation6({
+    mutationFn: async (params) => {
+      const { data, error } = await supabase.functions.invoke("query", {
+        body: params,
+        method: "POST",
+        headers: {
+          "X-Path": "/query/feedback"
+        }
+      });
+      if (error) throw error;
+      return data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["feedback-list"] });
+    }
+  });
+}
+
+// src/nl-training/useApplyFeedback.ts
+import { useMutation as useMutation7, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+function useApplyFeedback() {
+  const supabase = useSupabase();
+  const queryClient = useQueryClient2();
+  return useMutation7({
+    mutationFn: async (memoryId) => {
+      const { data, error } = await supabase.functions.invoke("query", {
+        body: {},
+        method: "POST",
+        headers: {
+          "X-Path": `/query/feedback/${memoryId}/apply`
+        }
+      });
+      if (error) throw error;
+      return data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["feedback-list"] });
+    }
+  });
+}
+
+// src/nl-training/useResolveFeedback.ts
+import { useMutation as useMutation8, useQueryClient as useQueryClient3 } from "@tanstack/react-query";
+function useResolveFeedback() {
+  const supabase = useSupabase();
+  const queryClient = useQueryClient3();
+  return useMutation8({
+    mutationFn: async (memoryId) => {
+      const { data, error } = await supabase.functions.invoke("query", {
+        body: {},
+        method: "POST",
+        headers: {
+          "X-Path": `/query/feedback/${memoryId}/resolve`
+        }
+      });
+      if (error) throw error;
+      return data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["feedback-list"] });
+    }
+  });
+}
+
+export {
+  useDbDelete,
+  useDbInfiniteQuery,
+  useDbInsert,
+  useDbMultiDelete,
+  useDbMultiUpsert,
+  useDbPartialAdvanceQuery,
+  useDbPartialQuery,
+  useDbRealtime,
+  convertFilterToRealtimeQuery,
+  useDbRealtimeQuery,
+  useDbUpdate,
+  useMutationSuccess,
+  useMutationSuccessRN,
+  ADAPTER_STRATEGIES,
+  AdapterRegistry,
+  createAdapterRegistry,
+  BackendStatus,
+  AdapterAutoDetector,
+  createAdapterAutoDetector,
+  SupabaseAdapter,
+  createSupabaseAdapter,
+  getErrorBody,
+  useAI,
+  useServerAvailability,
+  useSearchQuery,
+  useLiveChangeTracking,
+  useLatestOperationLog,
+  newTimeActivity,
+  useAutosaveState,
+  useToastError,
+  executeAdvanceQuery,
+  useStorageUrl,
+  useStoragePath,
+  BUCKETS,
+  createInCondition,
+  LiveChangeContext,
+  LiveChangeContextProvider,
+  useUpsertChangelog,
+  useDeleteChangelog,
+  useUpsertChangelogEntry,
+  useMultiUpsertChangelogEntries,
+  useDeleteChangelogEntry,
+  useMultiDeleteChangelogEntries,
+  useUpsertChangelogMedia,
+  useDeleteChangelogMedia,
+  useUploadChangelogMedia,
+  useChangelogs,
+  usePublishedChangelogs,
+  useChangelogById,
+  useChangelogBySlug,
+  useChangelogEntries,
+  useChangelogMedia,
+  useFeedbackList,
+  useSubmitFeedback,
+  useApplyFeedback,
+  useResolveFeedback
+};
+//# sourceMappingURL=chunk-7XT7K4QT.js.map