Skip to content

armgit / kaneo

Public Imported from GitHub
0

⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.

fix(api): honor every assigned workspace role in permission checks

Andrejba783c35ca2c
diff --git a/apps/api/src/utils/require-workspace-permission.ts b/apps/api/src/utils/require-workspace-permission.ts
index 4dead6cbe..d75a0c5a3 100644
--- a/apps/api/src/utils/require-workspace-permission.ts
+++ b/apps/api/src/utils/require-workspace-permission.ts
@@ -1,27 +1,34 @@
-import { and, eq } from "drizzle-orm";
+import { and, eq, inArray } from "drizzle-orm";
import type { Context, Next } from "hono";
import { HTTPException } from "hono/http-exception";
import db, { schema } from "../database";
import { isInstanceAdmin } from "./is-instance-admin";
-import { type PermissionMap, roleAllows, satisfies } from "./role-permissions";
-
-async function storedRolePermission(
+import {
+ type PermissionMap,
+ rolesAllow,
+ type StoredRolePermission,
+ satisfies,
+} from "./role-permissions";
+import { splitRoles } from "./split-roles";
+
+async function storedRolePermissions(
workspaceId: string,
- role: string,
- database: Pick<typeof db, "select"> = db,
-): Promise<string | null> {
- const [row] = await database
- .select({ permission: schema.workspaceRoleTable.permission })
+ roles: string[],
+ database: Pick<typeof db, "select">,
+): Promise<StoredRolePermission[]> {
+ if (roles.length === 0) return [];
+ return database
+ .select({
+ role: schema.workspaceRoleTable.role,
+ permission: schema.workspaceRoleTable.permission,
+ })
.from(schema.workspaceRoleTable)
.where(
and(
eq(schema.workspaceRoleTable.workspaceId, workspaceId),
- eq(schema.workspaceRoleTable.role, role),
+ inArray(schema.workspaceRoleTable.role, roles),
),
- )
- .limit(1);
-
- return row?.permission ?? null;
+ );
}
function apiKeyAllows(c: Context, permissions: PermissionMap) {
@@ -43,9 +50,10 @@ export async function roleHasWorkspacePermission(
permissions: PermissionMap,
database: Pick<typeof db, "select"> = db,
) {
- return roleAllows(
- role,
- await storedRolePermission(workspaceId, role, database),
+ const roles = splitRoles(role);
+ return rolesAllow(
+ roles,
+ await storedRolePermissions(workspaceId, roles, database),
permissions,
);
}
diff --git a/apps/api/src/utils/role-permissions.test.ts b/apps/api/src/utils/role-permissions.test.ts
index e55b1079d..c391931cf 100644
--- a/apps/api/src/utils/role-permissions.test.ts
+++ b/apps/api/src/utils/role-permissions.test.ts
@@ -1,5 +1,5 @@
import { describe, expect, it } from "vite-plus/test";
-import { roleAllows, satisfies } from "./role-permissions";
+import { roleAllows, rolesAllow, satisfies } from "./role-permissions";
const workspaceRead = { workspace: ["read"] };
@@ -39,6 +39,73 @@ describe("roleAllows", () => {
});
});
+describe("rolesAllow", () => {
+ const noRead = JSON.stringify({ task: ["read"] });
+ const read = JSON.stringify(workspaceRead);
+
+ it("allows when any role grants the permission", () => {
+ expect(
+ rolesAllow(
+ ["limited", "reader"],
+ [
+ { role: "limited", permission: noRead },
+ { role: "reader", permission: read },
+ ],
+ workspaceRead,
+ ),
+ ).toBe(true);
+ expect(
+ rolesAllow(
+ ["limited", "viewer"],
+ [{ role: "limited", permission: noRead }],
+ workspaceRead,
+ ),
+ ).toBe(true);
+ });
+
+ it("denies when no role grants the permission", () => {
+ expect(
+ rolesAllow(
+ ["limited", "viewer"],
+ [
+ { role: "limited", permission: noRead },
+ { role: "viewer", permission: noRead },
+ ],
+ workspaceRead,
+ ),
+ ).toBe(false);
+ expect(rolesAllow([], [], workspaceRead)).toBe(false);
+ });
+
+ it("allows when any duplicate row for a role grants the permission", () => {
+ for (const stored of [
+ [
+ { role: "custom", permission: noRead },
+ { role: "custom", permission: read },
+ ],
+ [
+ { role: "custom", permission: read },
+ { role: "custom", permission: noRead },
+ ],
+ ]) {
+ expect(rolesAllow(["custom"], stored, workspaceRead)).toBe(true);
+ }
+ });
+
+ it("ignores stored rows for roles the member does not have", () => {
+ expect(
+ rolesAllow(
+ ["limited"],
+ [
+ { role: "limited", permission: noRead },
+ { role: "reader", permission: read },
+ ],
+ workspaceRead,
+ ),
+ ).toBe(false);
+ });
+});
+
describe("satisfies", () => {
it("requires every action of every resource", () => {
const statements = { task: ["read", "update"], label: ["read"] };
diff --git a/apps/api/src/utils/role-permissions.ts b/apps/api/src/utils/role-permissions.ts
index f6d04d2f7..982fe5b13 100644
--- a/apps/api/src/utils/role-permissions.ts
+++ b/apps/api/src/utils/role-permissions.ts
@@ -65,3 +65,20 @@ export function roleAllows(
builtInRoleStatements(role);
return Boolean(statements && satisfies(statements, permissions));
}
+
+export type StoredRolePermission = {
+ role: string;
+ permission: string | null;
+};
+
+export function rolesAllow(
+ roles: readonly string[],
+ stored: readonly StoredRolePermission[],
+ permissions: PermissionMap,
+) {
+ return roles.some((role) => {
+ const rows = stored.filter((row) => row.role === role);
+ if (rows.length === 0) return roleAllows(role, null, permissions);
+ return rows.some((row) => roleAllows(role, row.permission, permissions));
+ });
+}
diff --git a/apps/api/src/utils/split-roles.test.ts b/apps/api/src/utils/split-roles.test.ts
new file mode 100644
index 000000000..19acaaf99
--- /dev/null
+++ b/apps/api/src/utils/split-roles.test.ts
@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vite-plus/test";
+import { splitRoles } from "./split-roles";
+
+describe("splitRoles", () => {
+ it("returns a single role as a one-item list", () => {
+ expect(splitRoles("member")).toEqual(["member"]);
+ });
+
+ it("splits comma-separated roles", () => {
+ expect(splitRoles("owner,viewer")).toEqual(["owner", "viewer"]);
+ });
+
+ it("trims names and drops empty and repeated entries", () => {
+ expect(splitRoles(" owner , ,viewer,owner,")).toEqual(["owner", "viewer"]);
+ });
+
+ it("returns an empty list for a missing or blank role", () => {
+ expect(splitRoles(null)).toEqual([]);
+ expect(splitRoles(undefined)).toEqual([]);
+ expect(splitRoles(" , ")).toEqual([]);
+ });
+});
diff --git a/apps/api/src/utils/split-roles.ts b/apps/api/src/utils/split-roles.ts
new file mode 100644
index 000000000..2c0de206a
--- /dev/null
+++ b/apps/api/src/utils/split-roles.ts
@@ -0,0 +1,8 @@
+export function splitRoles(role: string | null | undefined): string[] {
+ if (typeof role !== "string") return [];
+ const names = role
+ .split(",")
+ .map((name) => name.trim())
+ .filter(Boolean);
+ return [...new Set(names)];
+}
diff --git a/apps/api/src/workspace/can-read-workspace.test.ts b/apps/api/src/workspace/can-read-workspace.test.ts
index fd0d1d56d..08a9230a9 100644
--- a/apps/api/src/workspace/can-read-workspace.test.ts
+++ b/apps/api/src/workspace/can-read-workspace.test.ts
@@ -2,50 +2,60 @@ import { describe, expect, it } from "vite-plus/test";
import { canReadWorkspace } from "./can-read-workspace";
const noRead = JSON.stringify({ task: ["read"] });
+const read = JSON.stringify({ workspace: ["read"] });
describe("canReadWorkspace", () => {
it("allows built-in roles", () => {
for (const role of ["viewer", "member", "admin", "owner"]) {
- expect(
- canReadWorkspace({ role, rolePermission: null, instanceAdmin: false }),
- ).toBe(true);
+ expect(canReadWorkspace({ role, instanceAdmin: false }, [])).toBe(true);
}
});
it("denies a role whose permission lacks workspace:read", () => {
expect(
- canReadWorkspace({
- role: "custom",
- rolePermission: noRead,
- instanceAdmin: false,
- }),
+ canReadWorkspace({ role: "custom", instanceAdmin: false }, [
+ { role: "custom", permission: noRead },
+ ]),
).toBe(false);
});
- it("denies a non-member who is not an instance admin", () => {
+ it("allows a member when any of their roles grants workspace:read", () => {
+ expect(
+ canReadWorkspace({ role: "limited,reader", instanceAdmin: false }, [
+ { role: "limited", permission: noRead },
+ { role: "reader", permission: read },
+ ]),
+ ).toBe(true);
+ expect(
+ canReadWorkspace({ role: "limited,viewer", instanceAdmin: false }, [
+ { role: "limited", permission: noRead },
+ ]),
+ ).toBe(true);
+ });
+
+ it("denies a member when none of their roles grants workspace:read", () => {
expect(
- canReadWorkspace({
- role: null,
- rolePermission: null,
- instanceAdmin: false,
- }),
+ canReadWorkspace({ role: "limited,other", instanceAdmin: false }, [
+ { role: "limited", permission: noRead },
+ { role: "other", permission: noRead },
+ ]),
).toBe(false);
});
+ it("denies a non-member who is not an instance admin", () => {
+ expect(canReadWorkspace({ role: null, instanceAdmin: false }, [])).toBe(
+ false,
+ );
+ });
+
it("lets instance admins read regardless of their role", () => {
expect(
- canReadWorkspace({
- role: "custom",
- rolePermission: noRead,
- instanceAdmin: true,
- }),
- ).toBe(true);
- expect(
- canReadWorkspace({
- role: null,
- rolePermission: null,
- instanceAdmin: true,
- }),
+ canReadWorkspace({ role: "custom", instanceAdmin: true }, [
+ { role: "custom", permission: noRead },
+ ]),
).toBe(true);
+ expect(canReadWorkspace({ role: null, instanceAdmin: true }, [])).toBe(
+ true,
+ );
});
});
diff --git a/apps/api/src/workspace/can-read-workspace.ts b/apps/api/src/workspace/can-read-workspace.ts
index f037c60c7..fb2c0d472 100644
--- a/apps/api/src/workspace/can-read-workspace.ts
+++ b/apps/api/src/workspace/can-read-workspace.ts
@@ -1,26 +1,28 @@
import { sql } from "drizzle-orm";
-import {
- userTable,
- workspaceRoleTable,
- workspaceUserTable,
-} from "../database/schema";
+import { userTable, workspaceUserTable } from "../database/schema";
import { instanceAdminRoleSql } from "../utils/instance-admin-role";
-import { roleAllows } from "../utils/role-permissions";
+import {
+ rolesAllow,
+ type StoredRolePermission,
+} from "../utils/role-permissions";
+import { splitRoles } from "../utils/split-roles";
export const workspaceAccessColumns = {
role: workspaceUserTable.role,
- rolePermission: workspaceRoleTable.permission,
instanceAdmin: sql<boolean>`coalesce(${instanceAdminRoleSql(userTable.role)}, false)`,
};
-export function canReadWorkspace(row: {
+export type WorkspaceAccess = {
role: string | null;
- rolePermission: string | null;
instanceAdmin: boolean;
-}) {
- if (row.instanceAdmin) return true;
- return (
- row.role !== null &&
- roleAllows(row.role, row.rolePermission, { workspace: ["read"] })
- );
+};
+
+export function canReadWorkspace(
+ access: WorkspaceAccess,
+ storedRoles: readonly StoredRolePermission[],
+) {
+ if (access.instanceAdmin) return true;
+ return rolesAllow(splitRoles(access.role), storedRoles, {
+ workspace: ["read"],
+ });
}
diff --git a/apps/api/src/workspace/controllers/get-workspace.ts b/apps/api/src/workspace/controllers/get-workspace.ts
index 8fdbe8f2c..8800eb4a6 100644
--- a/apps/api/src/workspace/controllers/get-workspace.ts
+++ b/apps/api/src/workspace/controllers/get-workspace.ts
@@ -3,22 +3,19 @@ import { HTTPException } from "hono/http-exception";
import db from "../../database";
import {
userTable,
- workspaceRoleTable,
workspaceTable,
workspaceUserTable,
} from "../../database/schema";
import { instanceAdminRoleSql } from "../../utils/instance-admin-role";
-import {
- canReadWorkspace,
- workspaceAccessColumns,
-} from "../can-read-workspace";
+import { workspaceAccessColumns } from "../can-read-workspace";
+import { filterReadableWorkspaces } from "../filter-readable-workspaces";
import {
toWorkspaceResponse,
workspaceColumns,
} from "../to-workspace-response";
async function getWorkspace(workspaceId: string, userId: string) {
- const [row] = await db
+ const rows = await db
.select({ ...workspaceColumns, ...workspaceAccessColumns })
.from(workspaceTable)
.innerJoin(userTable, eq(userTable.id, userId))
@@ -29,13 +26,6 @@ async function getWorkspace(workspaceId: string, userId: string) {
eq(workspaceUserTable.userId, userTable.id),
),
)
- .leftJoin(
- workspaceRoleTable,
- and(
- eq(workspaceRoleTable.workspaceId, workspaceTable.id),
- eq(workspaceRoleTable.role, workspaceUserTable.role),
- ),
- )
.where(
and(
eq(workspaceTable.id, workspaceId),
@@ -48,7 +38,8 @@ async function getWorkspace(workspaceId: string, userId: string) {
.orderBy(workspaceUserTable.joinedAt, workspaceUserTable.id)
.limit(1);
- if (!row || !canReadWorkspace(row)) {
+ const [row] = await filterReadableWorkspaces(rows);
+ if (!row) {
throw new HTTPException(404, { message: "Workspace not found" });
}
diff --git a/apps/api/src/workspace/controllers/list-workspaces.ts b/apps/api/src/workspace/controllers/list-workspaces.ts
index 2ea5a9480..48f113abd 100644
--- a/apps/api/src/workspace/controllers/list-workspaces.ts
+++ b/apps/api/src/workspace/controllers/list-workspaces.ts
@@ -2,14 +2,11 @@ import { and, eq, sql } from "drizzle-orm";
import db from "../../database";
import {
userTable,
- workspaceRoleTable,
workspaceTable,
workspaceUserTable,
} from "../../database/schema";
-import {
- canReadWorkspace,
- workspaceAccessColumns,
-} from "../can-read-workspace";
+import { workspaceAccessColumns } from "../can-read-workspace";
+import { filterReadableWorkspaces } from "../filter-readable-workspaces";
import {
toWorkspaceResponse,
workspaceColumns,
@@ -32,13 +29,6 @@ async function listWorkspaces(userId: string) {
),
)
.innerJoin(userTable, eq(userTable.id, workspaceUserTable.userId))
- .leftJoin(
- workspaceRoleTable,
- and(
- eq(workspaceRoleTable.workspaceId, workspaceTable.id),
- eq(workspaceRoleTable.role, workspaceUserTable.role),
- ),
- )
.orderBy(
sortName,
workspaceTable.id,
@@ -46,7 +36,7 @@ async function listWorkspaces(userId: string) {
workspaceUserTable.id,
);
- return rows.filter(canReadWorkspace).map(toWorkspaceResponse);
+ return (await filterReadableWorkspaces(rows)).map(toWorkspaceResponse);
}
export default listWorkspaces;
diff --git a/apps/api/src/workspace/filter-readable-workspaces.ts b/apps/api/src/workspace/filter-readable-workspaces.ts
new file mode 100644
index 000000000..b242a04ce
--- /dev/null
+++ b/apps/api/src/workspace/filter-readable-workspaces.ts
@@ -0,0 +1,44 @@
+import { and, inArray } from "drizzle-orm";
+import db from "../database";
+import { workspaceRoleTable } from "../database/schema";
+import type { StoredRolePermission } from "../utils/role-permissions";
+import { splitRoles } from "../utils/split-roles";
+import { canReadWorkspace, type WorkspaceAccess } from "./can-read-workspace";
+
+async function loadStoredRoles(rows: (WorkspaceAccess & { id: string })[]) {
+ const pending = rows.filter((row) => !row.instanceAdmin);
+ const workspaceIds = [...new Set(pending.map((row) => row.id))];
+ const roles = [...new Set(pending.flatMap((row) => splitRoles(row.role)))];
+ const byWorkspace = new Map<string, StoredRolePermission[]>();
+ if (workspaceIds.length === 0 || roles.length === 0) return byWorkspace;
+
+ const stored = await db
+ .select({
+ workspaceId: workspaceRoleTable.workspaceId,
+ role: workspaceRoleTable.role,
+ permission: workspaceRoleTable.permission,
+ })
+ .from(workspaceRoleTable)
+ .where(
+ and(
+ inArray(workspaceRoleTable.workspaceId, workspaceIds),
+ inArray(workspaceRoleTable.role, roles),
+ ),
+ );
+
+ for (const { workspaceId, ...role } of stored) {
+ const list = byWorkspace.get(workspaceId) ?? [];
+ list.push(role);
+ byWorkspace.set(workspaceId, list);
+ }
+ return byWorkspace;
+}
+
+export async function filterReadableWorkspaces<
+ T extends WorkspaceAccess & { id: string },
+>(rows: T[]): Promise<T[]> {
+ const storedRoles = await loadStoredRoles(rows);
+ return rows.filter((row) =>
+ canReadWorkspace(row, storedRoles.get(row.id) ?? []),
+ );
+}
diff --git a/apps/api/src/workspace/index.ts b/apps/api/src/workspace/index.ts
index 8e82f6c78..76823a0f9 100644
--- a/apps/api/src/workspace/index.ts
+++ b/apps/api/src/workspace/index.ts
@@ -37,7 +37,7 @@ const listWorkspacesRoute = createRoute({
tags: ["Workspaces"],
summary: "List workspaces",
description:
- "List the workspaces where the caller is a member with a role that grants workspace:read, with the caller's role, sorted by name. Instance admins get every workspace they are a member of, and only those.",
+ "List the workspaces where one of the caller's roles grants workspace:read, with the caller's role, sorted by name. Instance admins get every workspace they are a member of, and only those.",
middleware: [requireApiKeyScope({ workspace: ["read"] })] as const,
responses: {
200: jsonResponse("The caller's workspaces", workspaceListSchema),
@@ -52,14 +52,14 @@ const getWorkspaceRoute = createRoute({
tags: ["Workspaces"],
summary: "Get workspace",
description:
- "Get a workspace the caller is a member of with a role that grants workspace:read, with the caller's role. Instance admins can get any workspace, with a null role when they are not a member.",
+ "Get a workspace where one of the caller's roles grants workspace:read, with the caller's role. Instance admins can get any workspace, with a null role when they are not a member.",
middleware: [requireApiKeyScope({ workspace: ["read"] })] as const,
request: { params: workspaceIdParam },
responses: {
200: jsonResponse("The workspace", workspaceSchema),
403: errorResponse("The API key lacks workspace:read"),
404: errorResponse(
- "Workspace not found, the caller is not a member of it, or their role lacks workspace:read",
+ "Workspace not found, the caller is not a member of it, or none of their roles grants workspace:read",
),
},
});
diff --git a/apps/api/src/workspace/response.ts b/apps/api/src/workspace/response.ts
index 618909819..5464095d3 100644
--- a/apps/api/src/workspace/response.ts
+++ b/apps/api/src/workspace/response.ts
@@ -11,7 +11,7 @@ export const workspaceSchema = z
createdAt: responseTimestamp,
role: z.string().nullable().openapi({
description:
- "The caller's workspace role: a built-in role (owner, admin, member, viewer) or the name of a custom role defined in the workspace. Null when an instance admin views a workspace they are not a member of.",
+ "The caller's workspace role: a built-in role (owner, admin, member, viewer) or the name of a custom role defined in the workspace. Several roles are comma-separated, for example owner,viewer. Null when an instance admin views a workspace they are not a member of.",
}),
})
.openapi("Workspace");
@@ -26,7 +26,7 @@ export const workspaceMemberSchema = z
image: z.string().nullable(),
role: z.string().openapi({
description:
- "The member's workspace role: a built-in role (owner, admin, member, viewer) or the name of a custom role defined in the workspace.",
+ "The member's workspace role: a built-in role (owner, admin, member, viewer) or the name of a custom role defined in the workspace. Several roles are comma-separated, for example owner,viewer.",
}),
})
.openapi("WorkspaceMember");
diff --git a/apps/docs/openapi.json b/apps/docs/openapi.json
index 3b0caf2eb..fdf36f8f4 100644
--- a/apps/docs/openapi.json
+++ b/apps/docs/openapi.json
@@ -4327,7 +4327,7 @@
"string",
"null"
],
- "description": "The caller's workspace role: a built-in role (owner, admin, member, viewer) or the name of a custom role defined in the workspace. Null when an instance admin views a workspace they are not a member of."
+ "description": "The caller's workspace role: a built-in role (owner, admin, member, viewer) or the name of a custom role defined in the workspace. Several roles are comma-separated, for example owner,viewer. Null when an instance admin views a workspace they are not a member of."
}
},
"required": [
@@ -4360,7 +4360,7 @@
},
"role": {
"type": "string",
- "description": "The member's workspace role: a built-in role (owner, admin, member, viewer) or the name of a custom role defined in the workspace."
+ "description": "The member's workspace role: a built-in role (owner, admin, member, viewer) or the name of a custom role defined in the workspace. Several roles are comma-separated, for example owner,viewer."
}
},
"required": [
@@ -19020,7 +19020,7 @@
"Workspaces"
],
"summary": "List workspaces",
- "description": "List the workspaces where the caller is a member with a role that grants workspace:read, with the caller's role, sorted by name. Instance admins get every workspace they are a member of, and only those.",
+ "description": "List the workspaces where one of the caller's roles grants workspace:read, with the caller's role, sorted by name. Instance admins get every workspace they are a member of, and only those.",
"responses": {
"200": {
"description": "The caller's workspaces",
@@ -19058,7 +19058,7 @@
"Workspaces"
],
"summary": "Get workspace",
- "description": "Get a workspace the caller is a member of with a role that grants workspace:read, with the caller's role. Instance admins can get any workspace, with a null role when they are not a member.",
+ "description": "Get a workspace where one of the caller's roles grants workspace:read, with the caller's role. Instance admins can get any workspace, with a null role when they are not a member.",
"parameters": [
{
"schema": {
@@ -19094,7 +19094,7 @@
}
},
"404": {
- "description": "Workspace not found, the caller is not a member of it, or their role lacks workspace:read",
+ "description": "Workspace not found, the caller is not a member of it, or none of their roles grants workspace:read",
"content": {
"text/plain": {
"schema": {
diff --git a/tests/api-integration/workspace-endpoints.test.ts b/tests/api-integration/workspace-endpoints.test.ts
index 43f7183d7..628d20fe7 100644
--- a/tests/api-integration/workspace-endpoints.test.ts
+++ b/tests/api-integration/workspace-endpoints.test.ts
@@ -164,6 +164,85 @@ describe("GET /api/workspace", () => {
]);
});
+ it("lists and reads a workspace when any of the caller's roles grants workspace:read", async () => {
+ const { user, workspace: custom } = await createWorkspaceMember({
+ role: "limited,reader",
+ workspaceName: "Custom",
+ });
+ await addRole(custom.id, "limited", { task: ["read"] });
+ await addRole(custom.id, "reader", { workspace: ["read"] });
+ const builtIn = await createWorkspace({ name: "Built-in" });
+ await addMembership(builtIn.id, user.id, "limited, viewer");
+ await addRole(builtIn.id, "limited", { task: ["read"] });
+ mockAuthenticatedSession(user);
+ const { app } = createApp();
+
+ const list = await app.request("/api/workspace");
+ const customSingle = await app.request(`/api/workspace/${custom.id}`);
+ const builtInSingle = await app.request(`/api/workspace/${builtIn.id}`);
+
+ expect(await readJson(list)).toEqual([
+ expected(builtIn, "limited, viewer"),
+ expected(custom, "limited,reader"),
+ ]);
+ expect(await readJson(customSingle)).toEqual(
+ expected(custom, "limited,reader"),
+ );
+ expect(await readJson(builtInSingle)).toEqual(
+ expected(builtIn, "limited, viewer"),
+ );
+ });
+
+ it("hides a workspace when none of the caller's roles grants workspace:read", async () => {
+ const { user, workspace } = await createWorkspaceMember({
+ role: "limited,other",
+ });
+ await addRole(workspace.id, "limited", { task: ["read"] });
+ await addRole(workspace.id, "other", { project: ["read"] });
+ await addRole(workspace.id, "reader", { workspace: ["read"] });
+ mockAuthenticatedSession(user);
+ const { app } = createApp();
+
+ const list = await app.request("/api/workspace");
+ const single = await app.request(`/api/workspace/${workspace.id}`);
+
+ expect(await readJson(list)).toEqual([]);
+ expect(single.status).toBe(404);
+ expect(await single.text()).toContain("Workspace not found");
+ });
+
+ it("grants access when any duplicate role row grants workspace:read", async () => {
+ const { user, workspace: readFirst } = await createWorkspaceMember({
+ role: "custom",
+ workspaceName: "Read first",
+ });
+ await addRole(readFirst.id, "custom", { workspace: ["read"] });
+ await addRole(readFirst.id, "custom", { task: ["read"] });
+ const readLast = await createWorkspace({ name: "Read last" });
+ await addMembership(readLast.id, user.id, "custom");
+ await addRole(readLast.id, "custom", { task: ["read"] });
+ await addRole(readLast.id, "custom", { workspace: ["read"] });
+ const noRead = await createWorkspace({ name: "No read" });
+ await addMembership(noRead.id, user.id, "custom");
+ await addRole(noRead.id, "custom", { task: ["read"] });
+ await addRole(noRead.id, "custom", { project: ["read"] });
+ mockAuthenticatedSession(user);
+ const { app } = createApp();
+
+ const list = await app.request("/api/workspace");
+ const first = await app.request(`/api/workspace/${readFirst.id}`);
+ const last = await app.request(`/api/workspace/${readLast.id}`);
+ const denied = await app.request(`/api/workspace/${noRead.id}`);
+
+ expect(await readJson(list)).toEqual([
+ expected(readFirst, "custom"),
+ expected(readLast, "custom"),
+ ]);
+ expect(await readJson(first)).toEqual(expected(readFirst, "custom"));
+ expect(await readJson(last)).toEqual(expected(readLast, "custom"));
+ expect(denied.status).toBe(404);
+ });
+
it("lists an instance admin's membership even when the role lacks workspace:read", async () => {
const admin = await createInstanceAdmin();
const workspace = await createWorkspace({ name: "Limited" });
diff --git a/tests/api-integration/workspace-rbac.test.ts b/tests/api-integration/workspace-rbac.test.ts
index cea4f1d47..57c5fa4f7 100644
--- a/tests/api-integration/workspace-rbac.test.ts
+++ b/tests/api-integration/workspace-rbac.test.ts
@@ -580,6 +580,59 @@ describe("API integration: workspace RBAC enforcement", () => {
expect(response.status).toBe(200);
});
+ it("allows a member with several roles when any role grants the permission", async () => {
+ const member = await createWorkspaceMember({ role: "readonly,member" });
+ const { project } = await createProjectFixture({
+ workspaceId: member.workspace.id,
+ });
+ await createWorkspaceRoleRow(member.workspace.id, "readonly", {
+ task: ["read"],
+ });
+
+ mockAuthenticatedSession(member.user);
+ const { app } = createApp();
+
+ const response = await postCreateTask(app, project.id);
+ expect(response.status).toBe(200);
+ });
+
+ it("blocks a member with several roles when no role grants the permission", async () => {
+ const member = await createWorkspaceMember({ role: "readonly,viewer" });
+ const { project } = await createProjectFixture({
+ workspaceId: member.workspace.id,
+ });
+ await createWorkspaceRoleRow(member.workspace.id, "readonly", {
+ task: ["read"],
+ });
+
+ mockAuthenticatedSession(member.user);
+ const { app } = createApp();
+
+ const response = await postCreateTask(app, project.id);
+ expect(response.status).toBe(403);
+ });
+
+ it("allows a role when any duplicate workspace_role row grants the permission", async () => {
+ const member = await createWorkspaceMember({ role: "creator" });
+ const { project } = await createProjectFixture({
+ workspaceId: member.workspace.id,
+ });
+ await createWorkspaceRoleRow(member.workspace.id, "creator", {
+ task: ["read"],
+ project: ["read"],
+ });
+ await createWorkspaceRoleRow(member.workspace.id, "creator", {
+ task: ["create", "read"],
+ project: ["read"],
+ });
+
+ mockAuthenticatedSession(member.user);
+ const { app } = createApp();
+
+ const response = await postCreateTask(app, project.id);
+ expect(response.status).toBe(200);
+ });
+
it("falls back to built-in role when no workspace_role row exists for the name", async () => {
// No workspace_role row, role is the compiled-in "admin"; should work.
const member = await createWorkspaceMember({ role: "admin" });