Merge remote-tracking branch 'origin/dev' into fix/three-xs-fixes

# Conflicts:
#	apps/nextjs/src/components/board/items/widget-context-menu.tsx

packages/auth/callbacks.ts

@@ -3,24 +3,18 @@ import type { NextAuthConfig } from "next-auth";
 
 import type { Session } from "@homarr/auth";
 import type { Database } from "@homarr/db";
-import { eq, inArray } from "@homarr/db";
+import { eq } from "@homarr/db";
 import { groupMembers, groupPermissions, users } from "@homarr/db/schema";
 import { getPermissionsWithChildren } from "@homarr/definitions";
 
 export const getCurrentUserPermissionsAsync = async (db: Database, userId: string) => {
-  const dbGroupMembers = await db.query.groupMembers.findMany({
-    where: eq(groupMembers.userId, userId),
-  });
-  const groupIds = dbGroupMembers.map((groupMember) => groupMember.groupId);
-
-  if (groupIds.length === 0) return [];
-
   const dbGroupPermissions = await db
     .selectDistinct({
       permission: groupPermissions.permission,
     })
     .from(groupPermissions)
-    .where(inArray(groupPermissions.groupId, groupIds));
+    .innerJoin(groupMembers, eq(groupPermissions.groupId, groupMembers.groupId))
+    .where(eq(groupMembers.userId, userId));
   const permissionKeys = dbGroupPermissions.map(({ permission }) => permission);
 
   return getPermissionsWithChildren(permissionKeys);
@@ -43,12 +37,15 @@ export const createSessionAsync = async (
 
 export const createSessionCallback = (db: Database): NextAuthCallbackOf<"session"> => {
   return async ({ session, user }) => {
-    const additionalProperties = await db.query.users.findFirst({
-      where: eq(users.id, user.id),
-      columns: {
-        colorScheme: true,
-      },
-    });
+    const [additionalProperties, permissions] = await Promise.all([
+      db.query.users.findFirst({
+        where: eq(users.id, user.id),
+        columns: {
+          colorScheme: true,
+        },
+      }),
+      getCurrentUserPermissionsAsync(db, user.id),
+    ]);
 
     return {
       ...session,
@@ -57,7 +54,7 @@ export const createSessionCallback = (db: Database): NextAuthCallbackOf<"session
         ...additionalProperties,
         id: user.id,
         name: user.name,
-        permissions: await getCurrentUserPermissionsAsync(db, user.id),
+        permissions,
       },
     };
   };

packages/auth/permissions/integration-provider.tsx

@@ -3,14 +3,9 @@
 import type { PropsWithChildren } from "react";
 import { createContext, useContext } from "react";
 
-import type { IntegrationKind } from "@homarr/definitions";
-
 interface IntegrationContextProps {
   integrations: {
     id: string;
-    name: string;
-    url: string;
-    kind: IntegrationKind;
     permissions: {
       hasFullAccess: boolean;
       hasInteractAccess: boolean;

packages/auth/permissions/integrations-with-permissions.ts

@@ -6,31 +6,28 @@ import { groupMembers, integrationGroupPermissions, integrationUserPermissions }
 import { constructIntegrationPermissions } from "./integration-permissions";
 
 export const getIntegrationsWithPermissionsAsync = async (session: Session | null) => {
-  const groupsOfCurrentUser = await db.query.groupMembers.findMany({
-    where: eq(groupMembers.userId, session?.user.id ?? ""),
-  });
-  const integrations = await db.query.integrations.findMany({
+  const groupPermissionWhere = session
+    ? inArray(
+        integrationGroupPermissions.groupId,
+        db.select({ groupId: groupMembers.groupId }).from(groupMembers).where(eq(groupMembers.userId, session.user.id)),
+      )
+    : eq(integrationGroupPermissions.groupId, "");
+  const integrationRows = await db.query.integrations.findMany({
     columns: {
       id: true,
-      name: true,
-      url: true,
-      kind: true,
     },
     with: {
       userPermissions: {
         where: eq(integrationUserPermissions.userId, session?.user.id ?? ""),
       },
       groupPermissions: {
-        where: inArray(
-          integrationGroupPermissions.groupId,
-          groupsOfCurrentUser.map((group) => group.groupId),
-        ),
+        where: groupPermissionWhere,
       },
     },
   });
 
-  return integrations.map(({ userPermissions, groupPermissions, ...integration }) => ({
-    ...integration,
+  return integrationRows.map(({ id, userPermissions, groupPermissions }) => ({
+    id,
     permissions: constructIntegrationPermissions({ userPermissions, groupPermissions }, session),
   }));
 };