@pol-studios/db 1.0.10 → 1.0.12

package/dist/chunk-WGDJ4IXR.js

@@ -0,0 +1,921 @@
+import {
+  useDbUpsert
+} from "./chunk-ZVBHWU7O.js";
+import {
+  isUsable,
+  newUuid,
+  omit
+} from "./chunk-OQ7U6EQ3.js";
+import {
+  encode
+} from "./chunk-H6365JPC.js";
+import {
+  typedSupabase,
+  useSupabase
+} from "./chunk-5EFDS7SR.js";
+
+// src/errors/TimeoutError.ts
+var TIMEOUT_ERROR_MESSAGE = "Request timed out";
+var DEFAULT_QUERY_TIMEOUT = 15e3;
+function isTimeoutError(error) {
+  if (!error) return false;
+  return error.name === "AbortError" || error.message === TIMEOUT_ERROR_MESSAGE || error.message.toLowerCase().includes("timed out");
+}
+
+// src/useDbQuery.ts
+import { useMemo, useRef } from "react";
+import { useQuery } from "@tanstack/react-query";
+import { useDelayedValue } from "@pol-studios/hooks/state";
+function useDbQuery(query, config) {
+  const queryKey = encode(query, false);
+  const queryKeyString = queryKey.join("-");
+  const debouncedKeyString = useDelayedValue(queryKeyString, 50);
+  const isKeyStable = queryKeyString === debouncedKeyString;
+  const effectiveEnabled = config?.enabled !== false && isKeyStable;
+  const timeoutMs = config?.timeout ?? DEFAULT_QUERY_TIMEOUT;
+  const countRef = useRef(null);
+  const request = useQuery(useMemo(() => ({
+    queryKey,
+    queryFn: async ({
+      signal
+    }) => {
+      const controller = new AbortController();
+      signal.addEventListener("abort", () => controller.abort());
+      const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const queryWithSignal = query.abortSignal?.(controller.signal) ?? query;
+        const result = await queryWithSignal;
+        if (result.error) throw result.error;
+        countRef.current = result.count ?? null;
+        return result.data;
+      } catch (err) {
+        if (err.name === "AbortError") {
+          throw new Error(TIMEOUT_ERROR_MESSAGE);
+        }
+        throw err;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    },
+    ...omit({
+      retry: 1,
+      ...config,
+      enabled: effectiveEnabled
+    }, ["queryKey", "timeout"])
+  }), [queryKey, config, effectiveEnabled, timeoutMs, query]));
+  return useMemo(() => ({
+    ...request,
+    count: countRef.current
+  }), [request, countRef.current]);
+}
+
+// src/auth/context/setupAuthContext.tsx
+import { c as _c } from "react/compiler-runtime";
+import { createContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var setupAuthContext = createContext({});
+function SetupAuthContextProvider(t0) {
+  const $ = _c(3);
+  const {
+    children,
+    auth
+  } = t0;
+  let t1;
+  if ($[0] !== auth || $[1] !== children) {
+    t1 = /* @__PURE__ */ jsx(setupAuthContext.Provider, { value: auth, children });
+    $[0] = auth;
+    $[1] = children;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  return t1;
+}
+
+// src/auth/context/PermissionContext.tsx
+import { createContext as createContext2, useCallback, useContext, useEffect, useMemo as useMemo2, useRef as useRef2, useState } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function getCacheKey(userId, entityType, entityId) {
+  return `${userId || "anon"}:${entityType}:${entityId}`;
+}
+var loadingPermission = {
+  canView: false,
+  canAdminView: false,
+  canEdit: false,
+  canCreate: false,
+  canDelete: false,
+  canShare: false,
+  permissionLevel: null,
+  isLoading: true
+};
+var noPermission = {
+  canView: false,
+  canAdminView: false,
+  canEdit: false,
+  canCreate: false,
+  canDelete: false,
+  canShare: false,
+  permissionLevel: null,
+  isLoading: false,
+  isDenied: false
+};
+var deniedPermission = {
+  canView: false,
+  canAdminView: false,
+  canEdit: false,
+  canCreate: false,
+  canDelete: false,
+  canShare: false,
+  permissionLevel: null,
+  isLoading: false,
+  isDenied: true
+};
+function mapPermissionLevel(level) {
+  if (!level) {
+    return noPermission;
+  }
+  const normalizedLevel = level.toLowerCase();
+  switch (normalizedLevel) {
+    // Legacy format: ReadOnly, New format: view
+    case "readonly":
+    case "view":
+      return {
+        canView: true,
+        canAdminView: false,
+        canEdit: false,
+        canCreate: false,
+        canDelete: false,
+        canShare: false,
+        permissionLevel: "ReadOnly",
+        isLoading: false,
+        isDenied: false
+      };
+    // Legacy format: AdminReadOnly (no new equivalent, keep for backwards compatibility)
+    case "adminreadonly":
+      return {
+        canView: true,
+        canAdminView: true,
+        canEdit: false,
+        canCreate: false,
+        canDelete: false,
+        canShare: false,
+        permissionLevel: "AdminReadOnly",
+        isLoading: false,
+        isDenied: false
+      };
+    // Legacy format: ReadWrite, New format: edit
+    case "readwrite":
+    case "edit":
+      return {
+        canView: true,
+        canAdminView: false,
+        canEdit: true,
+        canCreate: true,
+        canDelete: false,
+        canShare: false,
+        permissionLevel: "ReadWrite",
+        isLoading: false,
+        isDenied: false
+      };
+    // Legacy format: Admin, New format: admin
+    case "admin":
+      return {
+        canView: true,
+        canAdminView: true,
+        canEdit: true,
+        canCreate: true,
+        canDelete: true,
+        canShare: true,
+        permissionLevel: "Admin",
+        isLoading: false,
+        isDenied: false
+      };
+    // New format: denied - explicit access denial
+    case "denied":
+      return deniedPermission;
+    default:
+      console.warn(`Unknown permission level: ${level}`);
+      return noPermission;
+  }
+}
+var permissionContext = createContext2({});
+var entityPermissionContext = permissionContext;
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var ERROR_CACHE_TTL_MS = 30 * 1e3;
+var BATCH_DELAY_MS = 50;
+function PermissionProvider({
+  children
+}) {
+  const supabase = useSupabase();
+  const setupAuth = useContext(setupAuthContext);
+  const user = setupAuth?.user;
+  const cacheRef = useRef2(/* @__PURE__ */ new Map());
+  const pendingLookupsRef = useRef2(/* @__PURE__ */ new Set());
+  const inFlightRef = useRef2(/* @__PURE__ */ new Set());
+  const batchTimerRef = useRef2(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [, forceUpdate] = useState(0);
+  const cleanupExpiredEntries = useCallback(() => {
+    const now = Date.now();
+    const cache = cacheRef.current;
+    let hasExpired = false;
+    for (const [key, entry] of cache.entries()) {
+      if (entry.expiresAt < now) {
+        cache.delete(key);
+        hasExpired = true;
+      }
+    }
+    if (hasExpired) {
+      forceUpdate((prev) => prev + 1);
+    }
+  }, []);
+  useEffect(() => {
+    const cleanupInterval = setInterval(cleanupExpiredEntries, 60 * 1e3);
+    return () => clearInterval(cleanupInterval);
+  }, [cleanupExpiredEntries]);
+  const executeBatchLookup = useCallback(async () => {
+    const pending = Array.from(pendingLookupsRef.current);
+    pendingLookupsRef.current.clear();
+    if (pending.length === 0 || !user?.id) {
+      return;
+    }
+    pending.forEach((k) => inFlightRef.current.add(k));
+    setIsLoading(true);
+    try {
+      const entities = pending.map((key_0) => {
+        const parts = key_0.split(":");
+        const entityType = parts[1];
+        const entityIdStr = parts[2];
+        return {
+          entity_type: entityType,
+          entity_id: parseInt(entityIdStr, 10)
+        };
+      });
+      const {
+        data,
+        error
+      } = await supabase.rpc("get_user_entity_permissions", {
+        p_user_id: user.id,
+        p_entities: entities
+      });
+      if (error) {
+        console.error("Failed to fetch entity permissions:", error);
+        const cache_0 = cacheRef.current;
+        const now_0 = Date.now();
+        for (const key_1 of pending) {
+          cache_0.set(key_1, {
+            permission: noPermission,
+            expiresAt: now_0 + ERROR_CACHE_TTL_MS
+          });
+        }
+      } else if (data) {
+        const cache_1 = cacheRef.current;
+        const now_1 = Date.now();
+        const resultsMap = /* @__PURE__ */ new Map();
+        const results = data;
+        for (const result of results) {
+          const key_2 = getCacheKey(user?.id, result.entity_type, result.entity_id);
+          resultsMap.set(key_2, result.permission);
+        }
+        for (const key_3 of pending) {
+          const permissionLevel = resultsMap.get(key_3) || null;
+          cache_1.set(key_3, {
+            permission: mapPermissionLevel(permissionLevel),
+            expiresAt: now_1 + CACHE_TTL_MS
+          });
+        }
+      }
+      forceUpdate((prev_0) => prev_0 + 1);
+    } catch (err) {
+      console.error("Unexpected error fetching entity permissions:", err);
+    } finally {
+      pending.forEach((k) => inFlightRef.current.delete(k));
+      setIsLoading(false);
+    }
+  }, [supabase, user?.id]);
+  const scheduleBatchLookup = useCallback(() => {
+    if (batchTimerRef.current) {
+      clearTimeout(batchTimerRef.current);
+    }
+    batchTimerRef.current = setTimeout(() => {
+      batchTimerRef.current = null;
+      executeBatchLookup();
+    }, BATCH_DELAY_MS);
+  }, [executeBatchLookup]);
+  const getPermission = useCallback((entityType_0, entityId) => {
+    const key_4 = getCacheKey(user?.id, entityType_0, entityId);
+    const cache_2 = cacheRef.current;
+    const cached = cache_2.get(key_4);
+    const now_2 = Date.now();
+    if (cached && cached.expiresAt > now_2) {
+      return cached.permission;
+    }
+    if (!pendingLookupsRef.current.has(key_4) && !inFlightRef.current.has(key_4)) {
+      pendingLookupsRef.current.add(key_4);
+      scheduleBatchLookup();
+    }
+    return loadingPermission;
+  }, [scheduleBatchLookup, user?.id]);
+  const checkPermission = useCallback((entityType_1, entityId_0, action) => {
+    const permission = getPermission(entityType_1, entityId_0);
+    if (permission.isLoading) {
+      return false;
+    }
+    switch (action) {
+      case "view":
+        return permission.canView;
+      case "adminView":
+        return permission.canAdminView;
+      case "edit":
+        return permission.canEdit;
+      case "create":
+        return permission.canCreate;
+      case "delete":
+        return permission.canDelete;
+      case "share":
+        return permission.canShare;
+      default:
+        return false;
+    }
+  }, [getPermission]);
+  const prefetchPermissions = useCallback(async (entities_0) => {
+    if (!user?.id || entities_0.length === 0) {
+      return;
+    }
+    const cache_3 = cacheRef.current;
+    const now_3 = Date.now();
+    const toFetch = entities_0.filter((entity) => {
+      const key_5 = getCacheKey(user?.id, entity.entityType, entity.entityId);
+      const cached_0 = cache_3.get(key_5);
+      const isPending = pendingLookupsRef.current.has(key_5);
+      const isInFlight = inFlightRef.current.has(key_5);
+      return !isPending && !isInFlight && (!cached_0 || cached_0.expiresAt <= now_3);
+    });
+    if (toFetch.length === 0) {
+      return;
+    }
+    setIsLoading(true);
+    try {
+      const entitiesParam = toFetch.map((e) => ({
+        entity_type: e.entityType,
+        entity_id: e.entityId
+      }));
+      const {
+        data: data_0,
+        error: error_0
+      } = await supabase.rpc("get_user_entity_permissions", {
+        p_user_id: user.id,
+        p_entities: entitiesParam
+      });
+      if (error_0) {
+        console.error("Failed to prefetch entity permissions:", error_0);
+        return;
+      }
+      if (data_0) {
+        const cacheTimestamp = Date.now();
+        const resultsMap_0 = /* @__PURE__ */ new Map();
+        const results_0 = data_0;
+        for (const result_0 of results_0) {
+          const key_6 = getCacheKey(user?.id, result_0.entity_type, result_0.entity_id);
+          resultsMap_0.set(key_6, result_0.permission);
+        }
+        for (const entity_0 of toFetch) {
+          const key_7 = getCacheKey(user?.id, entity_0.entityType, entity_0.entityId);
+          const permissionLevel_0 = resultsMap_0.get(key_7) || null;
+          cache_3.set(key_7, {
+            permission: mapPermissionLevel(permissionLevel_0),
+            expiresAt: cacheTimestamp + CACHE_TTL_MS
+          });
+        }
+        forceUpdate((prev_1) => prev_1 + 1);
+      }
+    } catch (err_0) {
+      console.error("Unexpected error prefetching entity permissions:", err_0);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [supabase, user?.id]);
+  const invalidatePermission = useCallback((entityType_2, entityId_1) => {
+    const key_8 = getCacheKey(user?.id, entityType_2, entityId_1);
+    cacheRef.current.delete(key_8);
+    forceUpdate((prev_2) => prev_2 + 1);
+  }, [user?.id]);
+  const parseScopedAccessKey = useCallback((key_9) => {
+    if (!key_9 || typeof key_9 !== "string") {
+      return null;
+    }
+    const parts_0 = key_9.split(":");
+    if (parts_0.length < 2) {
+      return null;
+    }
+    const entityType_3 = parts_0[0];
+    const entityId_2 = parseInt(parts_0[1], 10);
+    if (isNaN(entityId_2)) {
+      return null;
+    }
+    const entityTypeMap = {
+      client: "Client",
+      project: "Project",
+      database: "ProjectDatabase",
+      projectdatabase: "ProjectDatabase"
+    };
+    const normalizedEntityType = entityTypeMap[entityType_3.toLowerCase()];
+    if (!normalizedEntityType) {
+      return null;
+    }
+    return {
+      entityType: normalizedEntityType,
+      entityId: entityId_2
+    };
+  }, []);
+  useEffect(() => {
+    if (!user?.id) {
+      return;
+    }
+    const channel = supabase.channel(`entity-permissions-${user.id}`).on("postgres_changes", {
+      event: "*",
+      schema: "core",
+      table: "UserAccess",
+      filter: `userId=eq.${user.id}`
+    }, (payload) => {
+      if (payload.new && typeof payload.new === "object" && "scopedAccessKey" in payload.new && typeof payload.new.scopedAccessKey === "string") {
+        const parsed = parseScopedAccessKey(payload.new.scopedAccessKey);
+        if (parsed) {
+          invalidatePermission(parsed.entityType, parsed.entityId);
+        }
+      }
+      if (payload.old && typeof payload.old === "object" && "scopedAccessKey" in payload.old && typeof payload.old.scopedAccessKey === "string") {
+        const parsed_0 = parseScopedAccessKey(payload.old.scopedAccessKey);
+        if (parsed_0) {
+          invalidatePermission(parsed_0.entityType, parsed_0.entityId);
+        }
+      }
+    }).subscribe();
+    return () => {
+      channel.unsubscribe();
+      supabase.removeChannel(channel);
+    };
+  }, [supabase, user?.id, invalidatePermission, parseScopedAccessKey]);
+  useEffect(() => {
+    cacheRef.current.clear();
+    pendingLookupsRef.current.clear();
+    inFlightRef.current.clear();
+    if (batchTimerRef.current) {
+      clearTimeout(batchTimerRef.current);
+      batchTimerRef.current = null;
+    }
+    forceUpdate((prev_3) => prev_3 + 1);
+  }, [user?.id]);
+  useEffect(() => {
+    return () => {
+      if (batchTimerRef.current) {
+        clearTimeout(batchTimerRef.current);
+      }
+    };
+  }, []);
+  const value = useMemo2(() => ({
+    getPermission,
+    checkPermission,
+    prefetchPermissions,
+    invalidatePermission,
+    isLoading
+  }), [getPermission, checkPermission, prefetchPermissions, invalidatePermission, isLoading]);
+  return /* @__PURE__ */ jsx2(permissionContext.Provider, { value, children });
+}
+function usePermissions() {
+  const context = useContext(permissionContext);
+  if (!context || Object.keys(context).length === 0) {
+    throw new Error("usePermissions must be used within a PermissionProvider");
+  }
+  return context;
+}
+
+// src/auth/context/AuthProvider.tsx
+import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo3, useRef as useRef3, useState as useState2 } from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var profileQuery = typedSupabase?.schema("core").from("Profile").select("*, UserAccess(accessKey), status").single();
+function AuthProvider({
+  children,
+  enableEntityPermissions = false
+}) {
+  const supabase = useSupabase();
+  const [currentUser, setCurrentUser] = useState2(void 0);
+  const [userNeedsChange, setUserNeedsChange] = useState2(true);
+  const [onSignOutCallbacks, setOnSignOutCallbacks] = useState2(/* @__PURE__ */ new Map());
+  async function registerAsync(register) {
+    const response = await supabase.auth.signUp(register);
+    setCurrentUser(response.data.user);
+    return response;
+  }
+  async function signInAsync(username, password) {
+    const response_0 = await supabase.auth.signInWithPassword({
+      email: username,
+      password
+    });
+    if (response_0.data) {
+      setCurrentUser(response_0.data.user);
+    }
+    return response_0;
+  }
+  async function signOutAsync() {
+    const response_1 = await supabase.auth.signOut();
+    if (isUsable(response_1.error) === false) {
+      Array.from(onSignOutCallbacks.values()).forEach((x) => {
+        x();
+      });
+    }
+    return response_1;
+  }
+  function onSignOut(action) {
+    const id = newUuid();
+    setOnSignOutCallbacks((x_0) => new Map(x_0).set(id, action));
+    return id;
+  }
+  function removeOnSignOut(id_0) {
+    setOnSignOutCallbacks((x_1) => {
+      const map = new Map(x_1);
+      map.delete(id_0);
+      return map;
+    });
+  }
+  async function refreshAsync() {
+  }
+  useEffect2(() => {
+    const request = supabase.auth.onAuthStateChange((event) => {
+      if (event === "SIGNED_IN" || event === "SIGNED_OUT") {
+        setUserNeedsChange(true);
+      }
+    });
+    return () => {
+      request.data.subscription.unsubscribe();
+    };
+  }, [supabase.auth]);
+  useEffect2(() => {
+    if (userNeedsChange === false) return;
+    supabase.auth.getSession().then((x_2) => {
+      setCurrentUser(x_2?.data?.session?.user ?? null);
+      setUserNeedsChange(false);
+    });
+  }, [userNeedsChange]);
+  const profileRequest = useDbQuery(supabase.schema("core").from("Profile").select("*, UserAccess(accessKey), status").eq("id", currentUser?.id).limit(1).maybeSingle(), {
+    enabled: isUsable(currentUser),
+    crossOrganization: true
+  });
+  const accessKeysRequest = useDbQuery(supabase.schema("core").rpc("get_user_access_keys", {
+    user_id: currentUser?.id
+  }), {
+    enabled: isUsable(currentUser),
+    crossOrganization: true
+  });
+  const refetchAccessKeys = useCallback2(() => {
+    accessKeysRequest.refetch();
+  }, [accessKeysRequest.refetch]);
+  const userGroupIdsRef = useRef3(/* @__PURE__ */ new Set());
+  useEffect2(() => {
+    if (accessKeysRequest.data) {
+      const groupIds = /* @__PURE__ */ new Set();
+      for (const item of accessKeysRequest.data) {
+        if (item.source === "group" && item.source_id) {
+          groupIds.add(item.source_id);
+        }
+      }
+      userGroupIdsRef.current = groupIds;
+    }
+  }, [accessKeysRequest.data]);
+  useEffect2(() => {
+    if (!currentUser?.id) return;
+    const channel = supabase.channel(`user-access-keys-${currentUser.id}`).on("postgres_changes", {
+      event: "*",
+      schema: "core",
+      table: "UserAccess",
+      filter: `userId=eq.${currentUser.id}`
+    }, () => {
+      refetchAccessKeys();
+    }).on("postgres_changes", {
+      event: "*",
+      schema: "core",
+      table: "UserGroup",
+      filter: `userId=eq.${currentUser.id}`
+    }, () => {
+      refetchAccessKeys();
+    }).on("postgres_changes", {
+      event: "*",
+      schema: "core",
+      table: "GroupAccessKey"
+    }, (payload) => {
+      const groupId = payload.new?.groupId || payload.old?.groupId;
+      if (groupId && userGroupIdsRef.current.has(groupId)) {
+        refetchAccessKeys();
+      }
+    }).on("postgres_changes", {
+      event: "UPDATE",
+      schema: "core",
+      table: "Group"
+    }, (payload_0) => {
+      const oldActive = payload_0.old?.isActive;
+      const newActive = payload_0.new?.isActive;
+      const groupId_0 = payload_0.new?.id;
+      if (oldActive !== newActive && groupId_0 && userGroupIdsRef.current.has(groupId_0)) {
+        refetchAccessKeys();
+      }
+    }).subscribe();
+    return () => {
+      channel.unsubscribe();
+      supabase.removeChannel(channel);
+    };
+  }, [supabase, currentUser?.id, refetchAccessKeys]);
+  useEffect2(() => {
+    if (!currentUser?.id) return;
+    const profileChannel = supabase.channel(`profile-status-${currentUser.id}`).on("postgres_changes", {
+      event: "UPDATE",
+      schema: "core",
+      table: "Profile",
+      filter: `id=eq.${currentUser.id}`
+    }, (payload_1) => {
+      const newStatus = payload_1.new?.status;
+      const oldStatus = payload_1.old?.status;
+      if (oldStatus === "active" && (newStatus === "archived" || newStatus === "suspended")) {
+        signOutAsync();
+      }
+      profileRequest.refetch();
+    }).subscribe();
+    return () => {
+      profileChannel.unsubscribe();
+      supabase.removeChannel(profileChannel);
+    };
+  }, [supabase, currentUser?.id, profileRequest.refetch]);
+  const combinedAccess = useMemo3(() => {
+    if (accessKeysRequest.data) {
+      const uniqueKeys = /* @__PURE__ */ new Set();
+      for (const item_0 of accessKeysRequest.data) {
+        if (item_0.access_key) {
+          uniqueKeys.add(item_0.access_key);
+        }
+      }
+      return Array.from(uniqueKeys);
+    }
+    return profileRequest.data?.UserAccess?.map((x_3) => x_3.accessKey) || [];
+  }, [accessKeysRequest.data, profileRequest.data?.UserAccess]);
+  const profileStatus = profileRequest.data?.status;
+  const isArchived = profileStatus === "archived";
+  const isSuspended = profileStatus === "suspended";
+  const hasAccess = useCallback2((key) => {
+    if (isArchived || isSuspended) {
+      return false;
+    }
+    const accessGiven = combinedAccess;
+    if (isUsable(accessGiven) === false) return false;
+    if (accessGiven.includes("owner")) return true;
+    if (accessGiven.includes(key)) return true;
+    if (isUsable(key) === false) return true;
+    return false;
+  }, [combinedAccess, isArchived, isSuspended]);
+  const authStateWithLoading = useMemo3(() => ({
+    hasAccess,
+    user: currentUser,
+    profile: profileRequest.data,
+    access: combinedAccess,
+    profileStatus,
+    isArchived,
+    isSuspended,
+    isLoading: currentUser === null ? false : profileRequest.isLoading || accessKeysRequest.isLoading || currentUser === void 0,
+    signInAsync,
+    signOutAsync,
+    onSignOut,
+    removeOnSignOut,
+    registerAsync,
+    refreshAsync
+  }), [profileRequest.data, profileRequest.isLoading, accessKeysRequest.data, accessKeysRequest.isLoading, currentUser, combinedAccess, profileStatus, isArchived, isSuspended, hasAccess]);
+  const content = enableEntityPermissions ? /* @__PURE__ */ jsx3(PermissionProvider, { children }) : children;
+  return /* @__PURE__ */ jsx3(setupAuthContext.Provider, { value: authStateWithLoading, children: content });
+}
+
+// src/auth/context/UserMetadataContext.tsx
+import { c as _c2 } from "react/compiler-runtime";
+import { createContext as createContext3, useContext as useContext2, useEffect as useEffect3, useMemo as useMemo4, useState as useState3, useCallback as useCallback3, useRef as useRef4 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var UserMetadataQuery = {
+  schema: "core",
+  table: "UserMetadata",
+  defaultQuery: "key, userId, value"
+};
+var userMetadataContext = createContext3(null);
+function UserMetadataProvider({
+  children
+}) {
+  const supabase = useSupabase();
+  const [metadata, setMetadataState] = useState3({});
+  const [isLoading, setIsLoading] = useState3(true);
+  const [error, setError] = useState3(null);
+  const setupAuth = useContext2(setupAuthContext);
+  const userId = setupAuth?.user?.id;
+  const metadataQuery = useDbQuery(supabase.schema("core").from("UserMetadata").select(UserMetadataQuery.defaultQuery).eq("userId", userId).order("key"), {
+    enabled: isUsable(userId),
+    crossOrganization: true
+  });
+  const upsertMutation = useDbUpsert("UserMetadata", {
+    invalidateTables: ["UserMetadata"]
+  });
+  const upsertMutationRef = useRef4(upsertMutation);
+  upsertMutationRef.current = upsertMutation;
+  useEffect3(() => {
+    if (metadataQuery.data) {
+      const metadataMap = {};
+      metadataQuery.data.forEach((item) => {
+        metadataMap[item.key] = item.value;
+      });
+      setMetadataState(metadataMap);
+      setIsLoading(false);
+      setError(null);
+    } else if (metadataQuery.error) {
+      setError(metadataQuery.error);
+      setIsLoading(false);
+    } else if (metadataQuery.isLoading) {
+      setIsLoading(true);
+    }
+  }, [metadataQuery.data, metadataQuery.error, metadataQuery.isLoading]);
+  const setMetadata = useCallback3(async (key, value) => {
+    if (!userId) {
+      throw new Error("User not authenticated");
+    }
+    try {
+      await upsertMutationRef.current.mutateAsync({
+        userId,
+        key,
+        value
+      });
+      setMetadataState((prev) => ({
+        ...prev,
+        [key]: value
+      }));
+    } catch (err) {
+      setError(err);
+      throw err;
+    }
+  }, [userId]);
+  const getMetadata = useCallback3((key_0) => {
+    return metadata[key_0];
+  }, [metadata]);
+  const removeMetadata = useCallback3(async (key_1) => {
+    if (!userId) {
+      throw new Error("User not authenticated");
+    }
+    try {
+      await supabase.schema("core").from("UserMetadata").delete().eq("userId", userId).eq("key", key_1);
+      setMetadataState((prev_0) => {
+        const newState = {
+          ...prev_0
+        };
+        delete newState[key_1];
+        return newState;
+      });
+    } catch (err_0) {
+      setError(err_0);
+      throw err_0;
+    }
+  }, [userId, supabase]);
+  const refreshMetadata = useCallback3(async () => {
+    await metadataQuery.refetch();
+  }, [metadataQuery]);
+  const contextValue = useMemo4(() => ({
+    metadata,
+    isLoading,
+    error,
+    setMetadata,
+    getMetadata,
+    removeMetadata,
+    refreshMetadata
+  }), [metadata, isLoading, error, setMetadata, getMetadata, removeMetadata, refreshMetadata]);
+  return /* @__PURE__ */ jsx4(userMetadataContext.Provider, { value: contextValue, children });
+}
+function useUserMetadata() {
+  const context = useContext2(userMetadataContext);
+  if (!context) {
+    throw new Error("useUserMetadata must be used within a UserMetadataProvider");
+  }
+  return context;
+}
+function useUserMetadataValue(key) {
+  const $ = _c2(3);
+  const {
+    getMetadata
+  } = useUserMetadata();
+  let t0;
+  if ($[0] !== getMetadata || $[1] !== key) {
+    t0 = getMetadata(key);
+    $[0] = getMetadata;
+    $[1] = key;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
+}
+function useSetUserMetadata() {
+  const $ = _c2(3);
+  const {
+    setMetadata,
+    removeMetadata
+  } = useUserMetadata();
+  let t0;
+  if ($[0] !== removeMetadata || $[1] !== setMetadata) {
+    t0 = {
+      setMetadata,
+      removeMetadata
+    };
+    $[0] = removeMetadata;
+    $[1] = setMetadata;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
+}
+function useUserMetadataState(key, defaultValue, options) {
+  const $ = _c2(11);
+  const {
+    metadata,
+    setMetadata,
+    isLoading
+  } = useUserMetadata();
+  const serialize = options?.serialize ?? _temp;
+  const deserialize = options?.deserialize ?? _temp2;
+  let t0;
+  bb0: {
+    const rawValue = metadata[key];
+    if (!rawValue) {
+      t0 = defaultValue;
+      break bb0;
+    }
+    ;
+    try {
+      let t22;
+      if ($[0] !== deserialize || $[1] !== rawValue) {
+        t22 = deserialize(rawValue);
+        $[0] = deserialize;
+        $[1] = rawValue;
+        $[2] = t22;
+      } else {
+        t22 = $[2];
+      }
+      t0 = t22;
+    } catch (t12) {
+      const error = t12;
+      console.warn(`Failed to deserialize metadata for key "${key}":`, error);
+      t0 = defaultValue;
+    }
+  }
+  const currentValue = t0;
+  let t1;
+  if ($[3] !== key || $[4] !== serialize || $[5] !== setMetadata) {
+    t1 = async (value_1) => {
+      const serializedValue = serialize(value_1);
+      await setMetadata(key, serializedValue);
+    };
+    $[3] = key;
+    $[4] = serialize;
+    $[5] = setMetadata;
+    $[6] = t1;
+  } else {
+    t1 = $[6];
+  }
+  const setValue = t1;
+  let t2;
+  if ($[7] !== currentValue || $[8] !== isLoading || $[9] !== setValue) {
+    t2 = [currentValue, setValue, isLoading];
+    $[7] = currentValue;
+    $[8] = isLoading;
+    $[9] = setValue;
+    $[10] = t2;
+  } else {
+    t2 = $[10];
+  }
+  return t2;
+}
+function _temp2(value_0) {
+  return JSON.parse(value_0);
+}
+function _temp(value) {
+  return JSON.stringify(value);
+}
+
+export {
+  TIMEOUT_ERROR_MESSAGE,
+  DEFAULT_QUERY_TIMEOUT,
+  isTimeoutError,
+  useDbQuery,
+  setupAuthContext,
+  SetupAuthContextProvider,
+  permissionContext,
+  entityPermissionContext,
+  PermissionProvider,
+  usePermissions,
+  AuthProvider,
+  userMetadataContext,
+  UserMetadataProvider,
+  useUserMetadata,
+  useUserMetadataValue,
+  useSetUserMetadata,
+  useUserMetadataState
+};
+//# sourceMappingURL=chunk-WGDJ4IXR.js.map