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(auth): revoke deleted workspaces for instance admins

Tind321ae695683
diff --git a/apps/api/src/auth.ts b/apps/api/src/auth.ts
index 30672271b..2a69e66b4 100644
--- a/apps/api/src/auth.ts
+++ b/apps/api/src/auth.ts
@@ -61,7 +61,10 @@ import { getDefaultCookieAttributes } from "./utils/get-default-cookie-attribute
import { getInvitationEmailSubject } from "./utils/get-invitation-email-subject";
import { getWorkspaceInvitationEmailCopy } from "./utils/get-workspace-invitation-email-copy";
import { getGithubSsoOAuthCredentials } from "./utils/github-sso-env";
-import { hasInstanceAdminRole } from "./utils/instance-admin-role";
+import {
+ hasInstanceAdminRole,
+ instanceAdminRoleSql,
+} from "./utils/instance-admin-role";
import {
hasRegisteredUsers,
promoteInitialAdministrator,
@@ -502,10 +505,15 @@ export const auth = betterAuth({
.where(
eq(schema.workspaceUserTable.workspaceId, organization.id),
);
- deletedWorkspaceMembers.set(
- ctx.context,
- members.map((member) => member.userId),
- );
+ const admins = await db
+ .select({ userId: schema.userTable.id })
+ .from(schema.userTable)
+ .where(instanceAdminRoleSql(schema.userTable.role));
+ deletedWorkspaceMembers.set(ctx.context, [
+ ...new Set(
+ [...members, ...admins].map((member) => member.userId),
+ ),
+ ]);
}
},
afterDeleteOrganization: async ({ organization }, ctx) => {
diff --git a/apps/api/src/ws/workspace-access.ts b/apps/api/src/ws/workspace-access.ts
index 04d86c26e..4e5bb51a6 100644
--- a/apps/api/src/ws/workspace-access.ts
+++ b/apps/api/src/ws/workspace-access.ts
@@ -1,31 +1,38 @@
import { and, eq } from "drizzle-orm";
import type { WSContext } from "hono/ws";
import db from "../database";
-import { userTable, workspaceUserTable } from "../database/schema";
+import {
+ userTable,
+ workspaceTable,
+ workspaceUserTable,
+} from "../database/schema";
import { hasInstanceAdminRole } from "../utils/instance-admin-role";
export async function syncWorkspaceAccess(userId: string, ws: WSContext) {
try {
- const [[user], memberships] = await Promise.all([
- db
- .select({ role: userTable.role })
- .from(userTable)
- .where(eq(userTable.id, userId)),
- db
- .select({ workspaceId: workspaceUserTable.workspaceId })
- .from(workspaceUserTable)
- .where(eq(workspaceUserTable.userId, userId)),
- ]);
+ const [user] = await db
+ .select({ role: userTable.role })
+ .from(userTable)
+ .where(eq(userTable.id, userId));
if (!user) {
ws.close(1008, "User access revoked");
return;
}
+ // Administrators need an existing-workspace snapshot too: an unrestricted
+ // marker cannot remove a workspace deleted while their socket was offline.
+ const workspaces = hasInstanceAdminRole(user.role)
+ ? await db
+ .select({ workspaceId: workspaceTable.id })
+ .from(workspaceTable)
+ .where(undefined)
+ : await db
+ .select({ workspaceId: workspaceUserTable.workspaceId })
+ .from(workspaceUserTable)
+ .where(eq(workspaceUserTable.userId, userId));
ws.send(
JSON.stringify({
type: "WORKSPACE_ACCESS_SYNC",
- workspaceIds: hasInstanceAdminRole(user.role)
- ? null
- : memberships.map((member) => member.workspaceId),
+ workspaceIds: workspaces.map((workspace) => workspace.workspaceId),
}),
);
} catch (error) {
diff --git a/apps/web/src/lib/evict-workspace-cache.test.ts b/apps/web/src/lib/evict-workspace-cache.test.ts
index 680060495..eeb3f904c 100644
--- a/apps/web/src/lib/evict-workspace-cache.test.ts
+++ b/apps/web/src/lib/evict-workspace-cache.test.ts
@@ -124,3 +124,21 @@ it("refetches an active board whose pending read has no workspace scope yet", as
unsubscribe();
client.clear();
});
+
+it.each(["revocation", "snapshot"])(
+ "preserves nested workspace-scoped search keys during %s",
+ (kind) => {
+ const client = new QueryClient();
+ const allowedKey = ["search", { query: "task", workspaceId: "allowed" }];
+ const revokedKey = ["search", { query: "task", workspaceId: "revoked" }];
+ client.setQueryData(allowedKey, { results: ["allowed task"] });
+ client.setQueryData(revokedKey, { results: ["private task"] });
+ if (kind === "revocation") evictWorkspaceCache(client, "revoked");
+ else evictInaccessibleWorkspaceCache(client, ["allowed"]);
+ expect(client.getQueryData(allowedKey)).toEqual({
+ results: ["allowed task"],
+ });
+ expect(client.getQueryData(revokedKey)).toBeUndefined();
+ client.clear();
+ },
+);
diff --git a/apps/web/src/lib/evict-workspace-cache.ts b/apps/web/src/lib/evict-workspace-cache.ts
index 7e51fca64..c9df89bb3 100644
--- a/apps/web/src/lib/evict-workspace-cache.ts
+++ b/apps/web/src/lib/evict-workspace-cache.ts
@@ -81,7 +81,7 @@ function evictPrivateQueries(
)
affected = true;
});
- const knownOtherWorkspace = query.queryKey.some(
+ let knownOtherWorkspace = query.queryKey.some(
(value) =>
typeof value === "string" &&
scopes.has(value) &&
@@ -89,6 +89,26 @@ function evictPrivateQueries(
? allowed.has(scopes.get(value)!)
: scopes.get(value) !== workspaceId),
);
+ visit(query.queryKey, (record) => {
+ if (
+ typeof record.workspaceId === "string" &&
+ (allowed
+ ? allowed.has(record.workspaceId)
+ : record.workspaceId !== workspaceId)
+ )
+ knownOtherWorkspace = true;
+ if (
+ Object.values(record).some(
+ (value) =>
+ typeof value === "string" &&
+ scopes.has(value) &&
+ (allowed
+ ? allowed.has(scopes.get(value)!)
+ : scopes.get(value) !== workspaceId),
+ )
+ )
+ knownOtherWorkspace = true;
+ });
const privatePrefixes = new Set([
"github-repositories",
"gitea-repositories",
diff --git a/tests/api-integration/workspace-admin-revocation.test.ts b/tests/api-integration/workspace-admin-revocation.test.ts
new file mode 100644
index 000000000..73632a781
--- /dev/null
+++ b/tests/api-integration/workspace-admin-revocation.test.ts
@@ -0,0 +1,98 @@
+import { and, eq } from "drizzle-orm";
+import type { WSContext } from "hono/ws";
+import { beforeEach, expect, it, vi } from "vite-plus/test";
+import db, { schema } from "../../apps/api/src/database";
+import { createApp } from "../../apps/api/src/index";
+import {
+ addConnection,
+ addUserConnection,
+ removeConnection,
+ removeUserConnection,
+} from "../../apps/api/src/ws";
+import { syncWorkspaceAccess } from "../../apps/api/src/ws/workspace-access";
+import { resetTestDatabase } from "./helpers/database";
+import {
+ createProjectFixture,
+ createWorkspaceMember,
+} from "./helpers/fixtures";
+beforeEach(resetTestDatabase);
+it("evicts a deleted workspace for an implicit administrator and reconciles offline administrators", async () => {
+ const admin = await createWorkspaceMember();
+ await db
+ .update(schema.userTable)
+ .set({ role: "user,admin" })
+ .where(eq(schema.userTable.id, admin.user.id));
+ const { app } = createApp();
+ const signup = await app.request("/api/auth/sign-up/email", {
+ method: "POST",
+ headers: { "content-type": "application/json" },
+ body: JSON.stringify({
+ email: "[email protected]",
+ password: "correct horse battery staple",
+ name: "Owner",
+ }),
+ });
+ expect(signup.status).toBe(200);
+ const cookie = signup.headers
+ .getSetCookie()
+ .map((entry) => entry.split(";")[0])
+ .join("; ");
+ const created = await app.request("/api/auth/organization/create", {
+ method: "POST",
+ headers: { "content-type": "application/json", cookie },
+ body: JSON.stringify({
+ name: "Deleted workspace",
+ slug: "deleted-workspace",
+ }),
+ });
+ expect(created.status).toBe(200);
+ const workspace = (await created.json()) as { id: string };
+ const { project } = await createProjectFixture({ workspaceId: workspace.id });
+ expect(
+ await db.query.workspaceUserTable.findFirst({
+ where: and(
+ eq(schema.workspaceUserTable.workspaceId, workspace.id),
+ eq(schema.workspaceUserTable.userId, admin.user.id),
+ ),
+ }),
+ ).toBeUndefined();
+ const global = { send: vi.fn(), close: vi.fn() };
+ const board = { send: vi.fn(), close: vi.fn() };
+ const userConnection = addUserConnection(
+ admin.user.id,
+ global as unknown as WSContext,
+ );
+ const projectConnection = addConnection(
+ project.id,
+ board as unknown as WSContext,
+ admin.user.id,
+ "window",
+ workspace.id,
+ );
+ try {
+ const deleted = await app.request("/api/auth/organization/delete", {
+ method: "POST",
+ headers: { "content-type": "application/json", cookie },
+ body: JSON.stringify({ organizationId: workspace.id }),
+ });
+ expect(deleted.status).toBe(200);
+ expect(board.close).toHaveBeenCalledWith(1008, "Workspace access revoked");
+ expect(
+ global.send.mock.calls.map(([message]) => JSON.parse(message)),
+ ).toContainEqual({
+ type: "WORKSPACE_ACCESS_REVOKED",
+ workspaceId: workspace.id,
+ });
+ const reconnected = { send: vi.fn(), close: vi.fn() };
+ await syncWorkspaceAccess(
+ admin.user.id,
+ reconnected as unknown as WSContext,
+ );
+ const snapshot = JSON.parse(reconnected.send.mock.calls[0][0]);
+ expect(snapshot.workspaceIds).toContain(admin.workspace.id);
+ expect(snapshot.workspaceIds).not.toContain(workspace.id);
+ } finally {
+ removeConnection(project.id, projectConnection);
+ removeUserConnection(admin.user.id, userConnection);
+ }
+});
diff --git a/tests/api/ws/workspace-access.test.ts b/tests/api/ws/workspace-access.test.ts
index f110236b1..b89745064 100644
--- a/tests/api/ws/workspace-access.test.ts
+++ b/tests/api/ws/workspace-access.test.ts
@@ -1,19 +1,32 @@
import { beforeEach, expect, it, vi } from "vite-plus/test";
+import { workspaceTable } from "../../../apps/api/src/database/schema";
import type { WSContext } from "hono/ws";
import {
hasWorkspaceAccess,
syncWorkspaceAccess,
} from "../../../apps/api/src/ws/workspace-access";
-const m = vi.hoisted(() => ({ user: vi.fn(), memberships: vi.fn() }));
+const m = vi.hoisted(() => ({
+ user: vi.fn(),
+ memberships: vi.fn(),
+ workspaces: vi.fn(),
+}));
vi.mock("../../../apps/api/src/database", () => ({
default: {
select: (fields: Record<string, unknown>) => ({
- from: () => ({ where: () => (fields.role ? m.user() : m.memberships()) }),
+ from: (table: unknown) => ({
+ where: () =>
+ fields.role
+ ? m.user()
+ : table === workspaceTable
+ ? m.workspaces()
+ : m.memberships(),
+ }),
}),
},
}));
beforeEach(() => {
m.user.mockResolvedValue([{ role: "user" }]);
+ m.workspaces.mockResolvedValue([{ workspaceId: "admin-accessible" }]);
m.memberships.mockResolvedValue([{ workspaceId: "still-authorized" }]);
});
it("sends current workspace access when reconnecting after an offline removal", async () => {
@@ -26,11 +39,12 @@ it("sends current workspace access when reconnecting after an offline removal",
});
it("preserves instance-admin access independently of memberships", async () => {
m.user.mockResolvedValue([{ role: "user,admin" }]);
+ m.memberships.mockResolvedValue([]);
const ws = { send: vi.fn(), close: vi.fn() };
await syncWorkspaceAccess("user", ws as unknown as WSContext);
expect(JSON.parse(ws.send.mock.calls[0][0])).toEqual({
type: "WORKSPACE_ACCESS_SYNC",
- workspaceIds: null,
+ workspaceIds: ["admin-accessible"],
});
});
it("requires a reconnect if access synchronization fails", async () => {