Replace entire codebase with homarr-labs/homarr

packages/auth/permissions/test/board-permissions.spec.ts

@@ -0,0 +1,307 @@
+import type { Session } from "next-auth";
+import { describe, expect, test } from "vitest";
+
+import { getPermissionsWithChildren } from "@homarr/definitions";
+
+import { constructBoardPermissions } from "../board-permissions";
+
+describe("constructBoardPermissions", () => {
+  test("should return all board permissions as true when session user id is equal to creator id", () => {
+    // Arrange
+    const board = {
+      creator: {
+        id: "1",
+      },
+      userPermissions: [],
+      groupPermissions: [],
+      isPublic: false,
+    };
+    const session = {
+      user: {
+        id: "1",
+        permissions: [],
+        colorScheme: "light",
+      },
+      expires: new Date().toISOString(),
+    } satisfies Session;
+
+    // Act
+    const result = constructBoardPermissions(board, session);
+
+    // Assert
+    expect(result.hasFullAccess).toBe(true);
+    expect(result.hasChangeAccess).toBe(true);
+    expect(result.hasViewAccess).toBe(true);
+  });
+
+  test("should return hasFullAccess as true when session permissions include board-full-all", () => {
+    // Arrange
+    const board = {
+      creator: {
+        id: "1",
+      },
+      userPermissions: [],
+      groupPermissions: [],
+      isPublic: false,
+    };
+    const session = {
+      user: {
+        id: "2",
+        permissions: getPermissionsWithChildren(["board-full-all"]),
+        colorScheme: "light",
+      },
+      expires: new Date().toISOString(),
+    } satisfies Session;
+
+    // Act
+    const result = constructBoardPermissions(board, session);
+
+    // Assert
+    expect(result.hasFullAccess).toBe(true);
+    expect(result.hasChangeAccess).toBe(true);
+    expect(result.hasViewAccess).toBe(true);
+  });
+
+  test("should return hasChangeAccess as true when session permissions include board-modify-all", () => {
+    // Arrange
+    const board = {
+      creator: {
+        id: "1",
+      },
+      userPermissions: [],
+      groupPermissions: [],
+      isPublic: false,
+    };
+    const session = {
+      user: {
+        id: "2",
+        permissions: getPermissionsWithChildren(["board-modify-all"]),
+        colorScheme: "light",
+      },
+      expires: new Date().toISOString(),
+    } satisfies Session;
+
+    // Act
+    const result = constructBoardPermissions(board, session);
+
+    // Assert
+    expect(result.hasFullAccess).toBe(false);
+    expect(result.hasChangeAccess).toBe(true);
+    expect(result.hasViewAccess).toBe(true);
+  });
+
+  test('should return hasChangeAccess as true when board user permissions include "modify"', () => {
+    // Arrange
+    const board = {
+      creator: {
+        id: "1",
+      },
+
+      userPermissions: [{ permission: "modify" as const }],
+      groupPermissions: [],
+      isPublic: false,
+    };
+    const session = {
+      user: {
+        id: "2",
+        permissions: [],
+        colorScheme: "light",
+      },
+      expires: new Date().toISOString(),
+    } satisfies Session;
+
+    // Act
+    const result = constructBoardPermissions(board, session);
+
+    // Assert
+    expect(result.hasFullAccess).toBe(false);
+    expect(result.hasChangeAccess).toBe(true);
+    expect(result.hasViewAccess).toBe(true);
+  });
+
+  test("should return hasChangeAccess as true when board group permissions include modify", () => {
+    // Arrange
+    const board = {
+      creator: {
+        id: "1",
+      },
+      userPermissions: [],
+      groupPermissions: [{ permission: "modify" as const }],
+      isPublic: false,
+    };
+    const session = {
+      user: {
+        id: "2",
+        permissions: [],
+        colorScheme: "light",
+      },
+      expires: new Date().toISOString(),
+    } satisfies Session;
+
+    // Act
+    const result = constructBoardPermissions(board, session);
+
+    // Assert
+    expect(result.hasFullAccess).toBe(false);
+    expect(result.hasChangeAccess).toBe(true);
+    expect(result.hasViewAccess).toBe(true);
+  });
+
+  test("should return hasViewAccess as true when session permissions include board-view-all", () => {
+    // Arrange
+    const board = {
+      creator: {
+        id: "1",
+      },
+      userPermissions: [],
+      groupPermissions: [],
+      isPublic: false,
+    };
+    const session = {
+      user: {
+        id: "2",
+        permissions: getPermissionsWithChildren(["board-view-all"]),
+        colorScheme: "light",
+      },
+      expires: new Date().toISOString(),
+    } satisfies Session;
+
+    // Act
+    const result = constructBoardPermissions(board, session);
+
+    // Assert
+    expect(result.hasFullAccess).toBe(false);
+    expect(result.hasChangeAccess).toBe(false);
+    expect(result.hasViewAccess).toBe(true);
+  });
+
+  test("should return hasViewAccess as true when board user permissions length is greater than or equal to 1", () => {
+    // Arrange
+    const board = {
+      creator: {
+        id: "1",
+      },
+      userPermissions: [{ permission: "view" as const }],
+      groupPermissions: [],
+      isPublic: false,
+    };
+    const session = {
+      user: {
+        id: "2",
+        permissions: [],
+        colorScheme: "light",
+      },
+      expires: new Date().toISOString(),
+    } satisfies Session;
+
+    // Act
+    const result = constructBoardPermissions(board, session);
+
+    // Assert
+    expect(result.hasFullAccess).toBe(false);
+    expect(result.hasChangeAccess).toBe(false);
+    expect(result.hasViewAccess).toBe(true);
+  });
+
+  test("should return hasViewAccess as true when board group permissions length is greater than or equal to 1", () => {
+    // Arrange
+    const board = {
+      creator: {
+        id: "1",
+      },
+      userPermissions: [],
+      groupPermissions: [{ permission: "view" as const }],
+      isPublic: false,
+    };
+    const session = {
+      user: {
+        id: "2",
+        permissions: [],
+        colorScheme: "light",
+      },
+      expires: new Date().toISOString(),
+    } satisfies Session;
+
+    // Act
+    const result = constructBoardPermissions(board, session);
+
+    // Assert
+    expect(result.hasFullAccess).toBe(false);
+    expect(result.hasChangeAccess).toBe(false);
+    expect(result.hasViewAccess).toBe(true);
+  });
+
+  test("should return all false when board is not public and session user id is not equal to creator id and no permissions", () => {
+    // Arrange
+    const board = {
+      creator: {
+        id: "1",
+      },
+      userPermissions: [],
+      groupPermissions: [],
+      isPublic: false,
+    };
+    const session = {
+      user: {
+        id: "2",
+        permissions: [],
+        colorScheme: "light",
+      },
+      expires: new Date().toISOString(),
+    } satisfies Session;
+
+    // Act
+    const result = constructBoardPermissions(board, session);
+
+    // Assert
+    expect(result.hasFullAccess).toBe(false);
+    expect(result.hasChangeAccess).toBe(false);
+    expect(result.hasViewAccess).toBe(false);
+  });
+
+  test("should return hasViewAccess as true when board is public", () => {
+    // Arrange
+    const board = {
+      creator: {
+        id: "1",
+      },
+      userPermissions: [],
+      groupPermissions: [],
+      isPublic: true,
+    };
+    const session = {
+      user: {
+        id: "2",
+        permissions: [],
+        colorScheme: "light",
+      },
+      expires: new Date().toISOString(),
+    } satisfies Session;
+
+    // Act
+    const result = constructBoardPermissions(board, session);
+
+    // Assert
+    expect(result.hasFullAccess).toBe(false);
+    expect(result.hasChangeAccess).toBe(false);
+    expect(result.hasViewAccess).toBe(true);
+  });
+  test("should return all false when creator is null and session is null", () => {
+    // Arrange
+    const board = {
+      creator: null,
+      userPermissions: [],
+      groupPermissions: [],
+      isPublic: false,
+    };
+    const session = null;
+
+    // Act
+    const result = constructBoardPermissions(board, session);
+
+    // Assert
+    expect(result.hasFullAccess).toBe(false);
+    expect(result.hasChangeAccess).toBe(false);
+    expect(result.hasViewAccess).toBe(false);
+  });
+});

packages/auth/permissions/test/integration-permissions.spec.ts

@@ -0,0 +1,200 @@
+import type { Session } from "next-auth";
+import { describe, expect, test } from "vitest";
+
+import { getPermissionsWithChildren } from "@homarr/definitions";
+
+import { constructIntegrationPermissions } from "../integration-permissions";
+
+describe("constructIntegrationPermissions", () => {
+  test("should return hasFullAccess as true when session permissions include integration-full-all", () => {
+    // Arrange
+    const integration = {
+      userPermissions: [],
+      groupPermissions: [],
+    };
+    const session = {
+      user: {
+        id: "2",
+        permissions: getPermissionsWithChildren(["integration-full-all"]),
+        colorScheme: "light",
+      },
+      expires: new Date().toISOString(),
+    } satisfies Session;
+
+    // Act
+    const result = constructIntegrationPermissions(integration, session);
+
+    // Assert
+    expect(result.hasFullAccess).toBe(true);
+    expect(result.hasInteractAccess).toBe(true);
+    expect(result.hasUseAccess).toBe(true);
+  });
+
+  test("should return hasInteractAccess as true when session permissions include integration-interact-all", () => {
+    // Arrange
+    const integration = {
+      userPermissions: [],
+      groupPermissions: [],
+    };
+    const session = {
+      user: {
+        id: "2",
+        permissions: getPermissionsWithChildren(["integration-interact-all"]),
+        colorScheme: "light",
+      },
+      expires: new Date().toISOString(),
+    } satisfies Session;
+
+    // Act
+    const result = constructIntegrationPermissions(integration, session);
+
+    // Assert
+    expect(result.hasFullAccess).toBe(false);
+    expect(result.hasInteractAccess).toBe(true);
+    expect(result.hasUseAccess).toBe(true);
+  });
+
+  test('should return hasInteractAccess as true when integration user permissions include "interact"', () => {
+    // Arrange
+    const integration = {
+      userPermissions: [{ permission: "interact" as const }],
+      groupPermissions: [],
+    };
+    const session = {
+      user: {
+        id: "2",
+        permissions: [],
+        colorScheme: "light",
+      },
+      expires: new Date().toISOString(),
+    } satisfies Session;
+
+    // Act
+    const result = constructIntegrationPermissions(integration, session);
+
+    // Assert
+    expect(result.hasFullAccess).toBe(false);
+    expect(result.hasInteractAccess).toBe(true);
+    expect(result.hasUseAccess).toBe(true);
+  });
+
+  test("should return hasInteractAccess as true when integration group permissions include interact", () => {
+    // Arrange
+    const integration = {
+      userPermissions: [],
+      groupPermissions: [{ permission: "interact" as const }],
+    };
+    const session = {
+      user: {
+        id: "2",
+        permissions: [],
+        colorScheme: "light",
+      },
+      expires: new Date().toISOString(),
+    } satisfies Session;
+
+    // Act
+    const result = constructIntegrationPermissions(integration, session);
+
+    // Assert
+    expect(result.hasFullAccess).toBe(false);
+    expect(result.hasInteractAccess).toBe(true);
+    expect(result.hasUseAccess).toBe(true);
+  });
+
+  test("should return hasUseAccess as true when session permissions include integration-use-all", () => {
+    // Arrange
+    const integration = {
+      userPermissions: [],
+      groupPermissions: [],
+    };
+    const session = {
+      user: {
+        id: "2",
+        permissions: getPermissionsWithChildren(["integration-use-all"]),
+        colorScheme: "light",
+      },
+      expires: new Date().toISOString(),
+    } satisfies Session;
+
+    // Act
+    const result = constructIntegrationPermissions(integration, session);
+
+    // Assert
+    expect(result.hasFullAccess).toBe(false);
+    expect(result.hasInteractAccess).toBe(false);
+    expect(result.hasUseAccess).toBe(true);
+  });
+
+  test("should return hasUseAccess as true when integration user permissions length is greater than or equal to 1", () => {
+    // Arrange
+    const integration = {
+      userPermissions: [{ permission: "use" as const }],
+      groupPermissions: [],
+    };
+    const session = {
+      user: {
+        id: "2",
+        permissions: [],
+        colorScheme: "light",
+      },
+      expires: new Date().toISOString(),
+    } satisfies Session;
+
+    // Act
+    const result = constructIntegrationPermissions(integration, session);
+
+    // Assert
+    expect(result.hasFullAccess).toBe(false);
+    expect(result.hasInteractAccess).toBe(false);
+    expect(result.hasUseAccess).toBe(true);
+  });
+
+  test("should return hasUseAccess as true when integration group permissions length is greater than or equal to 1", () => {
+    // Arrange
+    const integration = {
+      userPermissions: [],
+      groupPermissions: [{ permission: "use" as const }],
+    };
+    const session = {
+      user: {
+        id: "2",
+        permissions: [],
+        colorScheme: "light",
+      },
+      expires: new Date().toISOString(),
+    } satisfies Session;
+
+    // Act
+    const result = constructIntegrationPermissions(integration, session);
+
+    // Assert
+    expect(result.hasFullAccess).toBe(false);
+    expect(result.hasInteractAccess).toBe(false);
+    expect(result.hasUseAccess).toBe(true);
+  });
+
+  test("should return all false when integration no permissions", () => {
+    // Arrange
+    const integration = {
+      userPermissions: [],
+      groupPermissions: [],
+    };
+    const session = {
+      user: {
+        id: "2",
+        permissions: [],
+        colorScheme: "light",
+      },
+      expires: new Date().toISOString(),
+    } satisfies Session;
+
+    // Act
+    const result = constructIntegrationPermissions(integration, session);
+
+    // Assert
+    expect(result.hasFullAccess).toBe(false);
+    expect(result.hasInteractAccess).toBe(false);
+    expect(result.hasUseAccess).toBe(false);
+  });
+});

packages/auth/permissions/test/integration-query-permissions.spec.ts

@@ -0,0 +1,583 @@
+import type { Session } from "next-auth";
+import { describe, expect, test, vi } from "vitest";
+
+import { createId } from "@homarr/common";
+import type { InferInsertModel } from "@homarr/db";
+import { boardGroupPermissions, boards, boardUserPermissions, groupMembers, groups, users } from "@homarr/db/schema";
+import { createDb } from "@homarr/db/test";
+
+import * as integrationPermissions from "../integration-permissions";
+import { hasQueryAccessToIntegrationsAsync } from "../integration-query-permissions";
+
+const createSession = (user: Partial<Session["user"]>): Session => ({
+  user: {
+    id: "1",
+    permissions: [],
+    colorScheme: "light",
+    ...user,
+  },
+  expires: new Date().toISOString(),
+});
+
+describe("hasQueryAccessToIntegrationsAsync should check if the user has query access to the specified integrations", () => {
+  test("should return true if the user has the board-view-all permission and the integrations are used anywhere", async () => {
+    // Arrange
+    const db = createDb();
+    const session = createSession({
+      permissions: ["board-view-all"],
+    });
+    const integrations = [
+      {
+        id: "1",
+        items: [{ item: { boardId: "1" } }],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+      {
+        id: "2",
+        items: [{ item: { boardId: "2" } }],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+    ];
+
+    // Act
+    const result = await hasQueryAccessToIntegrationsAsync(db, integrations, session);
+
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  test("should return true if the user has the board-view-all permission, the first integration is used and the second one he has use access", async () => {
+    // Arrange
+    const db = createDb();
+    const session = createSession({
+      permissions: ["board-view-all"],
+    });
+    const spy = vi.spyOn(integrationPermissions, "constructIntegrationPermissions");
+    spy.mockReturnValue({
+      hasFullAccess: false,
+      hasInteractAccess: false,
+      hasUseAccess: true,
+    });
+    const integrations = [
+      {
+        id: "1",
+        items: [{ item: { boardId: "1" } }],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+      {
+        id: "2",
+        items: [],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+    ];
+
+    // Act
+    const result = await hasQueryAccessToIntegrationsAsync(db, integrations, session);
+
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  test("should return true if the user has use access to all integrations", async () => {
+    // Arrange
+    const db = createDb();
+    const session = createSession({});
+    const spy = vi.spyOn(integrationPermissions, "constructIntegrationPermissions");
+    spy.mockReturnValue({
+      hasFullAccess: false,
+      hasInteractAccess: false,
+      hasUseAccess: true,
+    });
+    const integrations = [
+      {
+        id: "1",
+        items: [],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+      {
+        id: "2",
+        items: [],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+    ];
+
+    // Act
+    const result = await hasQueryAccessToIntegrationsAsync(db, integrations, session);
+
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  test("should return true if the user has user permission to access to at least one board of each integration", async () => {
+    // Arrange
+    const db = createDb();
+    const session = createSession({});
+    await db.insert(users).values({ id: session.user.id });
+    const spy = vi.spyOn(integrationPermissions, "constructIntegrationPermissions");
+    spy.mockReturnValue({
+      hasFullAccess: false,
+      hasInteractAccess: false,
+      hasUseAccess: false,
+    });
+    const integrations = [
+      {
+        id: "1",
+        items: [
+          {
+            item: {
+              boardId: "1",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+      {
+        id: "2",
+        items: [
+          {
+            item: {
+              boardId: "1",
+            },
+          },
+          {
+            item: {
+              boardId: "2",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+    ];
+    await db.insert(boards).values(createMockBoard({ id: "1" }));
+    await db.insert(boardUserPermissions).values({ userId: session.user.id, boardId: "1", permission: "view" });
+
+    // Act
+    const result = await hasQueryAccessToIntegrationsAsync(db, integrations, session);
+
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  test("should return false if the user has user permission to access board of first integration but not of second one", async () => {
+    // Arrange
+    const db = createDb();
+    const session = createSession({});
+    await db.insert(users).values({ id: session.user.id });
+    const spy = vi.spyOn(integrationPermissions, "constructIntegrationPermissions");
+    spy.mockReturnValue({
+      hasFullAccess: false,
+      hasInteractAccess: false,
+      hasUseAccess: false,
+    });
+    const integrations = [
+      {
+        id: "1",
+        items: [
+          {
+            item: {
+              boardId: "1",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+      {
+        id: "2",
+        items: [
+          {
+            item: {
+              boardId: "2",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+    ];
+    await db.insert(boards).values(createMockBoard({ id: "1" }));
+    await db.insert(boardUserPermissions).values({ userId: session.user.id, boardId: "1", permission: "view" });
+
+    // Act
+    const result = await hasQueryAccessToIntegrationsAsync(db, integrations, session);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  test("should return true if the user has group permission to access to at least one board of each integration", async () => {
+    // Arrange
+    const db = createDb();
+    const session = createSession({});
+    await db.insert(users).values({ id: session.user.id });
+    const spy = vi.spyOn(integrationPermissions, "constructIntegrationPermissions");
+    spy.mockReturnValue({
+      hasFullAccess: false,
+      hasInteractAccess: false,
+      hasUseAccess: false,
+    });
+    const integrations = [
+      {
+        id: "1",
+        items: [
+          {
+            item: {
+              boardId: "1",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+      {
+        id: "2",
+        items: [
+          {
+            item: {
+              boardId: "1",
+            },
+          },
+          {
+            item: {
+              boardId: "2",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+    ];
+    await db.insert(boards).values(createMockBoard({ id: "1" }));
+    await db.insert(groups).values({ id: "1", name: "", position: 1 });
+    await db.insert(groupMembers).values({ userId: session.user.id, groupId: "1" });
+    await db.insert(boardGroupPermissions).values({ groupId: "1", boardId: "1", permission: "view" });
+
+    // Act
+    const result = await hasQueryAccessToIntegrationsAsync(db, integrations, session);
+
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  test("should return false if the user has group permission to access board of first integration but not of second one", async () => {
+    // Arrange
+    const db = createDb();
+    const session = createSession({});
+    await db.insert(users).values({ id: session.user.id });
+    const spy = vi.spyOn(integrationPermissions, "constructIntegrationPermissions");
+    spy.mockReturnValue({
+      hasFullAccess: false,
+      hasInteractAccess: false,
+      hasUseAccess: false,
+    });
+    const integrations = [
+      {
+        id: "1",
+        items: [
+          {
+            item: {
+              boardId: "1",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+      {
+        id: "2",
+        items: [
+          {
+            item: {
+              boardId: "2",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+    ];
+    await db.insert(boards).values(createMockBoard({ id: "1" }));
+    await db.insert(groups).values({ id: "1", name: "", position: 1 });
+    await db.insert(groupMembers).values({ userId: session.user.id, groupId: "1" });
+    await db.insert(boardGroupPermissions).values({ groupId: "1", boardId: "1", permission: "view" });
+
+    // Act
+    const result = await hasQueryAccessToIntegrationsAsync(db, integrations, session);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  test("should return true if the user has user permission to access first board and group permission to access second one", async () => {
+    // Arrange
+    const db = createDb();
+    const session = createSession({});
+    await db.insert(users).values({ id: session.user.id });
+    const spy = vi.spyOn(integrationPermissions, "constructIntegrationPermissions");
+    spy.mockReturnValue({
+      hasFullAccess: false,
+      hasInteractAccess: false,
+      hasUseAccess: false,
+    });
+    const integrations = [
+      {
+        id: "1",
+        items: [
+          {
+            item: {
+              boardId: "1",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+      {
+        id: "2",
+        items: [
+          {
+            item: {
+              boardId: "2",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+    ];
+    await db.insert(boards).values(createMockBoard({ id: "1" }));
+    await db.insert(boards).values(createMockBoard({ id: "2" }));
+    await db.insert(groups).values({ id: "1", name: "", position: 1 });
+    await db.insert(groupMembers).values({ userId: session.user.id, groupId: "1" });
+    await db.insert(boardGroupPermissions).values({ groupId: "1", boardId: "2", permission: "view" });
+    await db.insert(boardUserPermissions).values({ userId: session.user.id, boardId: "1", permission: "view" });
+
+    // Act
+    const result = await hasQueryAccessToIntegrationsAsync(db, integrations, session);
+
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  test("should return true if one of the boards the integration is used is public", async () => {
+    // Arrange
+    const db = createDb();
+    const session = createSession({});
+    const integrations = [
+      {
+        id: "1",
+        items: [
+          {
+            item: {
+              boardId: "1",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+      {
+        id: "2",
+        items: [
+          {
+            item: {
+              boardId: "2",
+            },
+          },
+          {
+            item: {
+              boardId: "1",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+    ];
+    await db.insert(boards).values(createMockBoard({ id: "1", isPublic: true }));
+
+    // Act
+    const result = await hasQueryAccessToIntegrationsAsync(db, integrations, session);
+
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  test("should return true if the user is creator of the board the integration is used", async () => {
+    // Arrange
+    const db = createDb();
+    const session = createSession({});
+    await db.insert(users).values({ id: session.user.id });
+    const integrations = [
+      {
+        id: "1",
+        items: [
+          {
+            item: {
+              boardId: "1",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+      {
+        id: "2",
+        items: [
+          {
+            item: {
+              boardId: "2",
+            },
+          },
+          {
+            item: {
+              boardId: "1",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+    ];
+    await db.insert(boards).values(createMockBoard({ id: "1", creatorId: session.user.id }));
+
+    // Act
+    const result = await hasQueryAccessToIntegrationsAsync(db, integrations, session);
+
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  test("should return false if the user has no access to any of the integrations", async () => {
+    // Arrange
+    const db = createDb();
+    const session = createSession({});
+    const integrations = [
+      {
+        id: "1",
+        items: [
+          {
+            item: {
+              boardId: "1",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+      {
+        id: "2",
+        items: [
+          {
+            item: {
+              boardId: "2",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+    ];
+
+    // Act
+    const result = await hasQueryAccessToIntegrationsAsync(db, integrations, session);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  test("should return false if the user is anonymous and the board is not public", async () => {
+    // Arrange
+    const db = createDb();
+    const integrations = [
+      {
+        id: "1",
+        items: [
+          {
+            item: {
+              boardId: "1",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+      {
+        id: "2",
+        items: [
+          {
+            item: {
+              boardId: "2",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+    ];
+    await db.insert(boards).values(createMockBoard({ id: "1" }));
+
+    // Act
+    const result = await hasQueryAccessToIntegrationsAsync(db, integrations, null);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  test("should return true if the user is anonymous and the board is public", async () => {
+    // Arrange
+    const db = createDb();
+    const integrations = [
+      {
+        id: "1",
+        items: [
+          {
+            item: {
+              boardId: "1",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+      {
+        id: "2",
+        items: [
+          {
+            item: {
+              boardId: "2",
+            },
+          },
+          {
+            item: {
+              boardId: "1",
+            },
+          },
+        ],
+        userPermissions: [],
+        groupPermissions: [],
+      },
+    ];
+    await db.insert(boards).values(createMockBoard({ id: "1", isPublic: true }));
+
+    // Act
+    const result = await hasQueryAccessToIntegrationsAsync(db, integrations, null);
+
+    // Assert
+    expect(result).toBe(true);
+  });
+});
+
+const createMockBoard = (board: Partial<InferInsertModel<typeof boards>>): InferInsertModel<typeof boards> => ({
+  id: createId(),
+  name: board.id ?? createId(),
+  ...board,
+});