@pol-studios/db 1.0.31 → 1.0.34

package/dist/{chunk-WX4ABYIF.js → chunk-67HMVGV7.js}

@@ -1,18 +1,16 @@
 import {
-  useDbUpsert
-} from "./chunk-VGEMLNNM.js";
+  useDbQuery
+} from "./chunk-UBHORKBS.js";
 import {
-  isUsable,
-  newUuid,
-  omit
-} from "./chunk-OQ7U6EQ3.js";
-import {
-  encode
-} from "./chunk-H6365JPC.js";
+  buildNormalizedQuery,
+  encode,
+  useQueriesForTableLoader,
+  useUpsertItem
+} from "./chunk-YUX6RGLZ.js";
 import {
   typedSupabase,
   useSupabase
-} from "./chunk-5EFDS7SR.js";
+} from "./chunk-DMVUEJG2.js";
 
 // src/errors/TimeoutError.ts
 var TIMEOUT_ERROR_MESSAGE = "Request timed out";
@@ -24,9 +22,10 @@ function isTimeoutError(error) {
 
 // src/useDbQuery.ts
 import { useMemo, useRef } from "react";
+import { omit } from "@pol-studios/utils";
 import { useQuery } from "@tanstack/react-query";
 import { useDelayedValue } from "@pol-studios/hooks/state";
-function useDbQuery(query, config) {
+function useDbQuery2(query, config) {
   const queryKey = encode(query, false);
   const queryKeyString = queryKey.join("-");
   const debouncedKeyString = useDelayedValue(queryKeyString, 50);
@@ -472,6 +471,7 @@ function usePermissions() {
 }
 
 // src/auth/context/AuthProvider.tsx
+import { isUsable, newUuid } from "@pol-studios/utils";
 import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo3, useRef as useRef3, useState as useState2 } from "react";
 import { jsx as jsx2 } from "react/jsx-runtime";
 function getPermissionLevel(action) {
@@ -491,6 +491,9 @@ function getPermissionLevel(action) {
   }
 }
 var profileQuery = typedSupabase?.schema("core").from("Profile").select("*, UserAccess(accessKey), status").single();
+function isNotExpired(expiresAt) {
+  return !expiresAt || new Date(expiresAt) > /* @__PURE__ */ new Date();
+}
 function AuthProvider({
   children,
   enableEntityPermissions = false
@@ -577,40 +580,80 @@ function AuthProvider({
       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 {
+    data: profileData,
+    isLoading: profileLoading,
+    refetch: refetchProfile
+  } = useDbQuery("core.Profile", {
+    where: {
+      id: currentUser?.id
+    },
+    enabled: isUsable(currentUser)
   });
-  const accessKeysRequest = useDbQuery(supabase.schema("core").rpc("get_user_access_keys", {
-    user_id: currentUser?.id
-  }), {
-    enabled: isUsable(currentUser),
-    crossOrganization: true
+  const profile = profileData?.[0] ?? null;
+  const {
+    data: directAccess,
+    isLoading: directAccessLoading,
+    refetch: refetchDirectAccess
+  } = useDbQuery("core.UserAccess", {
+    where: {
+      userId: currentUser?.id
+    },
+    enabled: isUsable(currentUser)
   });
-  const effectivePermissionsRequest = useDbQuery(supabase.schema("core").rpc("get_user_effective_permissions", {
-    user_id: currentUser?.id
-  }), {
-    enabled: isUsable(currentUser),
-    crossOrganization: true
+  const {
+    data: userGroups,
+    isLoading: userGroupsLoading,
+    refetch: refetchUserGroups
+  } = useDbQuery("core.UserGroup", {
+    where: {
+      userId: currentUser?.id
+    },
+    enabled: isUsable(currentUser)
+  });
+  const {
+    data: groups,
+    isLoading: groupsLoading,
+    refetch: refetchGroups
+  } = useDbQuery("core.Group", {
+    where: {
+      isActive: 1
+    },
+    // PowerSync stores booleans as 0/1
+    enabled: isUsable(currentUser)
+  });
+  const groupIds = useMemo3(() => userGroups?.map((ug) => ug.groupId) ?? [], [userGroups]);
+  const groupsMap = useMemo3(() => new Map(groups?.map((g) => [g.id, g]) ?? []), [groups]);
+  const {
+    data: groupAccess,
+    isLoading: groupAccessLoading,
+    refetch: refetchGroupAccess
+  } = useDbQuery("core.GroupAccessKey", {
+    where: groupIds.length > 0 ? {
+      groupId: {
+        in: groupIds
+      }
+    } : void 0,
+    enabled: groupIds.length > 0
   });
-  const refetchAccessKeys = useCallback2(() => {
-    accessKeysRequest.refetch();
-  }, [accessKeysRequest.refetch]);
-  const refetchEffectivePermissions = useCallback2(() => {
-    effectivePermissionsRequest.refetch();
-  }, [effectivePermissionsRequest.refetch]);
+  const refetchAccessData = useCallback2(() => {
+    refetchDirectAccess();
+    refetchUserGroups();
+    refetchGroups();
+    refetchGroupAccess();
+  }, [refetchDirectAccess, refetchUserGroups, refetchGroups, refetchGroupAccess]);
   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);
+    if (userGroups) {
+      const groupIdSet = /* @__PURE__ */ new Set();
+      for (const ug_0 of userGroups) {
+        if (ug_0.groupId) {
+          groupIdSet.add(typeof ug_0.groupId === "number" ? ug_0.groupId : parseInt(ug_0.groupId, 10));
         }
       }
-      userGroupIdsRef.current = groupIds;
+      userGroupIdsRef.current = groupIdSet;
     }
-  }, [accessKeysRequest.data]);
+  }, [userGroups]);
   useEffect2(() => {
     if (!currentUser?.id) return;
     const channel = supabase.channel(`user-access-keys-${currentUser.id}`).on("postgres_changes", {
@@ -619,16 +662,14 @@ function AuthProvider({
       table: "UserAccess",
       filter: `userId=eq.${currentUser.id}`
     }, () => {
-      refetchAccessKeys();
-      refetchEffectivePermissions();
+      refetchAccessData();
     }).on("postgres_changes", {
       event: "*",
       schema: "core",
       table: "UserGroup",
       filter: `userId=eq.${currentUser.id}`
     }, () => {
-      refetchAccessKeys();
-      refetchEffectivePermissions();
+      refetchAccessData();
     }).on("postgres_changes", {
       event: "*",
       schema: "core",
@@ -636,8 +677,7 @@ function AuthProvider({
     }, (payload) => {
       const groupId = payload.new?.groupId || payload.old?.groupId;
       if (groupId && userGroupIdsRef.current.has(groupId)) {
-        refetchAccessKeys();
-        refetchEffectivePermissions();
+        refetchAccessData();
       }
     }).on("postgres_changes", {
       event: "UPDATE",
@@ -648,15 +688,14 @@ function AuthProvider({
       const newActive = payload_0.new?.isActive;
       const groupId_0 = payload_0.new?.id;
       if (oldActive !== newActive && groupId_0 && userGroupIdsRef.current.has(groupId_0)) {
-        refetchAccessKeys();
-        refetchEffectivePermissions();
+        refetchAccessData();
       }
     }).subscribe();
     return () => {
       channel.unsubscribe();
       supabase.removeChannel(channel);
     };
-  }, [supabase, currentUser?.id, refetchAccessKeys, refetchEffectivePermissions]);
+  }, [supabase, currentUser?.id, refetchAccessData]);
   useEffect2(() => {
     if (!currentUser?.id) return;
     const profileChannel = supabase.channel(`profile-status-${currentUser.id}`).on("postgres_changes", {
@@ -670,40 +709,72 @@ function AuthProvider({
       if (oldStatus === "active" && (newStatus === "archived" || newStatus === "suspended")) {
         signOutAsync();
       }
-      profileRequest.refetch();
+      refetchProfile();
     }).subscribe();
     return () => {
       profileChannel.unsubscribe();
       supabase.removeChannel(profileChannel);
     };
-  }, [supabase, currentUser?.id, profileRequest.refetch]);
+  }, [supabase, currentUser?.id, refetchProfile]);
+  const allAccessKeys = useMemo3(() => {
+    const keys = [];
+    directAccess?.forEach((a) => {
+      if (isNotExpired(a.expiresAt)) {
+        keys.push({
+          accessKey: a.accessKey,
+          effect: a.effect ?? "allow",
+          source: "direct",
+          expiresAt: a.expiresAt
+        });
+      }
+    });
+    const activeGroupIds = new Set(userGroups?.filter((ug_1) => {
+      const group = groupsMap.get(ug_1.groupId);
+      return group?.isActive === 1 && isNotExpired(ug_1.expiresAt);
+    }).map((ug_2) => ug_2.groupId) ?? []);
+    groupAccess?.forEach((ga) => {
+      if (activeGroupIds.has(ga.groupId) && isNotExpired(ga.expiresAt)) {
+        keys.push({
+          accessKey: ga.accessKey,
+          effect: ga.effect ?? "allow",
+          source: "group",
+          expiresAt: ga.expiresAt
+        });
+      }
+    });
+    return keys;
+  }, [directAccess, userGroups, groupsMap, groupAccess]);
   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);
-        }
+    const uniqueKeys = /* @__PURE__ */ new Set();
+    for (const item of allAccessKeys) {
+      if (item.accessKey && item.effect === "allow") {
+        uniqueKeys.add(item.accessKey);
       }
-      return Array.from(uniqueKeys);
     }
-    return profileRequest.data?.UserAccess?.map((x_3) => x_3.accessKey) || [];
-  }, [accessKeysRequest.data, profileRequest.data?.UserAccess]);
+    return Array.from(uniqueKeys);
+  }, [allAccessKeys]);
   const effectivePermissions = useMemo3(() => {
-    if (!effectivePermissionsRequest.data) {
-      return [];
-    }
-    return effectivePermissionsRequest.data.map((item_1) => ({
-      resourceType: item_1.resource_type,
-      resourceId: item_1.resource_id,
-      permission: item_1.permission,
-      permissionLevel: item_1.permission_level,
-      source: item_1.source,
-      inheritedFrom: item_1.inherited_from,
-      expiresAt: item_1.expires_at
-    }));
-  }, [effectivePermissionsRequest.data]);
-  const profileStatus = profileRequest.data?.status;
+    const permissions = [];
+    for (const item_0 of allAccessKeys) {
+      if (item_0.effect !== "allow") continue;
+      const parts = item_0.accessKey.split(":");
+      if (parts.length === 3) {
+        const [resourceType, resourceId, permission] = parts;
+        const permissionLevel = getPermissionLevel(permission);
+        permissions.push({
+          resourceType,
+          resourceId,
+          permission,
+          permissionLevel,
+          source: item_0.source,
+          inheritedFrom: null,
+          expiresAt: item_0.expiresAt ?? null
+        });
+      }
+    }
+    return permissions;
+  }, [allAccessKeys]);
+  const profileStatus = profile?.status;
   const isArchived = profileStatus === "archived";
   const isSuspended = profileStatus === "suspended";
   const hasAccess = useCallback2((key) => {
@@ -712,12 +783,12 @@ function AuthProvider({
     }
     const accessGiven = combinedAccess;
     if (isUsable(accessGiven) === false) return false;
-    if (accessGiven.includes("owner")) return true;
+    if (accessGiven.includes("*:*:*")) return true;
     if (accessGiven.includes(key)) return true;
     if (isUsable(key) === false) return true;
-    const parts = key.split(":");
-    if (parts.length === 3) {
-      const [type, id_1, action_0] = parts;
+    const parts_0 = key.split(":");
+    if (parts_0.length === 3) {
+      const [type, id_1, action_0] = parts_0;
       const requiredLevel = getPermissionLevel(action_0);
       const hasPermission = effectivePermissions.some((p) => p.resourceType === type && p.resourceId === id_1 && p.permissionLevel >= requiredLevel);
       if (hasPermission) {
@@ -726,30 +797,149 @@ function AuthProvider({
     }
     return false;
   }, [combinedAccess, effectivePermissions, isArchived, isSuspended]);
+  const isAccessLoading = directAccessLoading || userGroupsLoading || groupsLoading || groupAccessLoading;
   const authStateWithLoading = useMemo3(() => ({
     hasAccess,
     user: currentUser,
-    profile: profileRequest.data,
+    profile,
     access: combinedAccess,
     effectivePermissions,
     profileStatus,
     isArchived,
     isSuspended,
-    isLoading: currentUser === null ? false : profileRequest.isLoading || accessKeysRequest.isLoading || effectivePermissionsRequest.isLoading || currentUser === void 0,
+    isLoading: currentUser === null ? false : profileLoading || isAccessLoading || currentUser === void 0,
     signInAsync,
     signOutAsync,
     onSignOut,
     removeOnSignOut,
     registerAsync,
     refreshAsync
-  }), [profileRequest.data, profileRequest.isLoading, accessKeysRequest.data, accessKeysRequest.isLoading, effectivePermissionsRequest.isLoading, currentUser, combinedAccess, effectivePermissions, profileStatus, isArchived, isSuspended, hasAccess]);
+  }), [profile, profileLoading, isAccessLoading, currentUser, combinedAccess, effectivePermissions, profileStatus, isArchived, isSuspended, hasAccess]);
   const content = enableEntityPermissions ? /* @__PURE__ */ jsx2(PermissionProvider, { children }) : children;
   return /* @__PURE__ */ jsx2(setupAuthContext.Provider, { value: authStateWithLoading, children: content });
 }
 
 // src/auth/context/UserMetadataContext.tsx
-import { c as _c } from "react/compiler-runtime";
+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";
+
+// src/useDbUpsert.ts
+import { c as _c } from "react/compiler-runtime";
+import { useMutation } from "@tanstack/react-query";
+import { isUsable as isUsable2 } from "@pol-studios/utils";
+import { omit as omit2 } from "@pol-studios/utils";
+function useDbUpsert(relation, t0, query, mutationOption) {
+  const $ = _c(16);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === void 0 ? ["id"] : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const primaryKeys = t1;
+  const tableName = typeof relation === "object" ? relation.table : relation;
+  const schemaName = typeof relation === "object" ? String(relation.schema) : "public";
+  const supabase = useSupabase();
+  let t2;
+  if ($[2] !== primaryKeys) {
+    t2 = primaryKeys.map(_temp);
+    $[2] = primaryKeys;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const primaryKeysAsStrings = t2;
+  const t3 = primaryKeysAsStrings;
+  const t4 = relation;
+  let t5;
+  if ($[4] !== t3 || $[5] !== t4) {
+    t5 = {
+      primaryKeys: t3,
+      table: t4,
+      schema: "public"
+    };
+    $[4] = t3;
+    $[5] = t4;
+    $[6] = t5;
+  } else {
+    t5 = $[6];
+  }
+  const upsertItem = useUpsertItem(t5);
+  const queriesForTable = useQueriesForTableLoader(tableName);
+  let t6;
+  if ($[7] !== primaryKeys || $[8] !== primaryKeysAsStrings || $[9] !== queriesForTable || $[10] !== query || $[11] !== schemaName || $[12] !== supabase || $[13] !== tableName || $[14] !== upsertItem) {
+    t6 = {
+      mutationFn: async (item) => {
+        let result = null;
+        const selectQuery = buildNormalizedQuery({
+          queriesForTable,
+          query
+        });
+        const insert = async function insert2() {
+          const keysToFilter = primaryKeys.filter((x) => isUsable2(item[x]) === false);
+          const keysToFilterAsStrings = keysToFilter.map(_temp2);
+          const response = await supabase.schema(schemaName).from(tableName).insert(omit2(item, keysToFilterAsStrings)).select(query).single();
+          if (response.error) {
+            throw response.error;
+          }
+          result = response.data;
+          if (result) {
+            upsertItem(result);
+          }
+        };
+        const isUpsertable = primaryKeys.every((x_0) => x_0 in item && isUsable2(item[x_0]));
+        if (isUpsertable) {
+          const query_0 = supabase.schema(schemaName).from(tableName).update(omit2(item, primaryKeysAsStrings));
+          primaryKeys.forEach((x_1) => {
+            query_0.eq(String(x_1), item[x_1]);
+          });
+          const queryResponse = await query_0.select(selectQuery?.selectQuery).single();
+          console.log("queryResponse", queryResponse, tableName);
+          if (queryResponse.status === 406) {
+            await insert();
+          } else {
+            if (queryResponse.error) {
+              throw queryResponse.error;
+            }
+            if (queryResponse.data) {
+              result = queryResponse.data;
+              if (result) {
+                upsertItem(result);
+              }
+            }
+          }
+        } else {
+          await insert();
+        }
+        return result;
+      }
+    };
+    $[7] = primaryKeys;
+    $[8] = primaryKeysAsStrings;
+    $[9] = queriesForTable;
+    $[10] = query;
+    $[11] = schemaName;
+    $[12] = supabase;
+    $[13] = tableName;
+    $[14] = upsertItem;
+    $[15] = t6;
+  } else {
+    t6 = $[15];
+  }
+  const mutation = useMutation(t6);
+  return mutation;
+}
+function _temp2(k_0) {
+  return String(k_0);
+}
+function _temp(k) {
+  return String(k);
+}
+
+// src/auth/context/UserMetadataContext.tsx
+import { isUsable as isUsable3 } from "@pol-studios/utils";
 import { jsx as jsx3 } from "react/jsx-runtime";
 var UserMetadataQuery = {
   schema: "core",
@@ -766,17 +956,22 @@ function UserMetadataProvider({
   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),
+  const metadataQuery = useDbQuery2(supabase.schema("core").from("UserMetadata").select(UserMetadataQuery.defaultQuery).eq("userId", userId).order("key"), {
+    enabled: isUsable3(userId),
     crossOrganization: true
   });
-  const upsertMutation = useDbUpsert("UserMetadata", {
-    invalidateTables: ["UserMetadata"]
-  });
+  const upsertMutation = useDbUpsert(
+    {
+      table: "UserMetadata",
+      schema: "core"
+    },
+    ["userId", "key"]
+    // composite primary keys
+  );
   const upsertMutationRef = useRef4(upsertMutation);
   upsertMutationRef.current = upsertMutation;
   useEffect3(() => {
-    if (metadataQuery.data) {
+    if (metadataQuery.data && Array.isArray(metadataQuery.data)) {
       const metadataMap = {};
       metadataQuery.data.forEach((item) => {
         metadataMap[item.key] = item.value;
@@ -789,6 +984,9 @@ function UserMetadataProvider({
       setIsLoading(false);
     } else if (metadataQuery.isLoading) {
       setIsLoading(true);
+    } else if (metadataQuery.data && !Array.isArray(metadataQuery.data)) {
+      setMetadataState({});
+      setIsLoading(false);
     }
   }, [metadataQuery.data, metadataQuery.error, metadataQuery.isLoading]);
   const setMetadata = useCallback3(async (key, value) => {
@@ -853,7 +1051,7 @@ function useUserMetadata() {
   return context;
 }
 function useUserMetadataValue(key) {
-  const $ = _c(3);
+  const $ = _c2(3);
   const {
     getMetadata
   } = useUserMetadata();
@@ -869,7 +1067,7 @@ function useUserMetadataValue(key) {
   return t0;
 }
 function useSetUserMetadata() {
-  const $ = _c(3);
+  const $ = _c2(3);
   const {
     setMetadata,
     removeMetadata
@@ -889,14 +1087,14 @@ function useSetUserMetadata() {
   return t0;
 }
 function useUserMetadataState(key, defaultValue, options) {
-  const $ = _c(11);
+  const $ = _c2(11);
   const {
     metadata,
     setMetadata,
     isLoading
   } = useUserMetadata();
-  const serialize = options?.serialize ?? _temp;
-  const deserialize = options?.deserialize ?? _temp2;
+  const serialize = options?.serialize ?? _temp3;
+  const deserialize = options?.deserialize ?? _temp22;
   let t0;
   bb0: {
     const rawValue = metadata[key];
@@ -949,10 +1147,10 @@ function useUserMetadataState(key, defaultValue, options) {
   }
   return t2;
 }
-function _temp2(value_0) {
+function _temp22(value_0) {
   return JSON.parse(value_0);
 }
-function _temp(value) {
+function _temp3(value) {
   return JSON.stringify(value);
 }
 
@@ -960,7 +1158,7 @@ export {
   TIMEOUT_ERROR_MESSAGE,
   DEFAULT_QUERY_TIMEOUT,
   isTimeoutError,
-  useDbQuery,
+  useDbQuery2 as useDbQuery,
   setupAuthContext,
   permissionContext,
   entityPermissionContext,
@@ -974,4 +1172,4 @@ export {
   useSetUserMetadata,
   useUserMetadataState
 };
-//# sourceMappingURL=chunk-WX4ABYIF.js.map
+//# sourceMappingURL=chunk-67HMVGV7.js.map