Refresh HiveGrid Cloud reference snapshot

This commit is contained in:
david committed 2026-08-03 15:31:14 +02:00
1 parent 5e99e14772
commit 7f88026f79
5955 files changed
+1177325 -188362

No files matched your search

@@ -0,0 +1,196 @@
// @vitest-environment node
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { createSharedStore, MemoryAdapter } from "@hivegrid/shared-store";
const { clearCacheKey, getSharedStore, logError, logInfo, logWarn } = vi.hoisted(() => ({
clearCacheKey: vi.fn(),
getSharedStore: vi.fn(),
logError: vi.fn(),
logInfo: vi.fn(),
logWarn: vi.fn(),
}));
vi.mock("~/shared-store.server", () => ({ getSharedStore }));
vi.mock("~/utils/cache.server", () => ({ clearCacheKey }));
vi.mock("~/utils/logger.server", () => ({
createScopedLogger: () => ({ error: logError, info: logInfo, warn: logWarn }),
}));
import {
__resetPermissionCacheForTests,
cachePermissionNames,
createPermissionCache,
getCachedPermissionNames,
getPermissionCache,
invalidateUserPermissionCache,
invalidateUserPermissionCacheScopes,
subscribePermissionCache,
} from "./permission-cache.server";
const disposers: Array<() => Promise<void>> = [];
const originalCacheInvalidationEnabled = process.env.CACHE_INVALIDATION_ENABLED;
beforeEach(() => {
vi.clearAllMocks();
__resetPermissionCacheForTests();
delete process.env.CACHE_INVALIDATION_ENABLED;
getSharedStore.mockReturnValue(createSharedStore({ namespace: "permission-singleton-test", adapter: new MemoryAdapter() }));
});
afterEach(async () => {
await Promise.all(disposers.splice(0).map((dispose) => dispose()));
__resetPermissionCacheForTests();
if (originalCacheInvalidationEnabled === undefined) delete process.env.CACHE_INVALIDATION_ENABLED;
else process.env.CACHE_INVALIDATION_ENABLED = originalCacheInvalidationEnabled;
});
describe("permission authorization cache", () => {
it("revokes a cached grant on a second replica through shared-store pub/sub", async () => {
const adapter = new MemoryAdapter();
const replicaA = createPermissionCache(createSharedStore({ namespace: "permission-replica-test", adapter }));
const replicaB = createPermissionCache(createSharedStore({ namespace: "permission-replica-test", adapter }));
disposers.push(await replicaA.subscribe(), await replicaB.subscribe());
const key = "user_1:tenant_1";
await replicaA.set(key, ["settings.members.delete"]);
expect(await replicaB.get(key)).toEqual(["settings.members.delete"]);
expect(replicaB.l1.get(key)).toEqual(["settings.members.delete"]);
replicaA.deleteLocal(key);
await replicaA.l2.invalidate(key);
expect(replicaB.l1.get(key)).toBeUndefined();
expect(await replicaB.get(key)).toBeNull();
});
it("memoizes the process cache and stores defensive permission snapshots", async () => {
const first = getPermissionCache();
expect(getPermissionCache()).toBe(first);
expect(getSharedStore).toHaveBeenCalledTimes(1);
const names = ["settings.members.read"];
await expect(cachePermissionNames("user_1", "tenant_1", names)).resolves.toBe(true);
names.push("settings.members.delete");
const cached = await getCachedPermissionNames("user_1", "tenant_1");
expect(cached).toEqual(["settings.members.read"]);
cached?.push("mutated.by.caller");
await expect(getCachedPermissionNames("user_1", "tenant_1")).resolves.toEqual(["settings.members.read"]);
await expect(getCachedPermissionNames("missing", null)).resolves.toBeNull();
});
it("falls back to the database when cache reads or writes fail", async () => {
const cache = getPermissionCache();
vi.spyOn(cache, "get").mockRejectedValueOnce(new TypeError("read unavailable")).mockRejectedValueOnce("unknown read failure");
vi.spyOn(cache, "set").mockRejectedValueOnce(new RangeError("write unavailable")).mockRejectedValueOnce("unknown write failure");
await expect(getCachedPermissionNames("user_1", "tenant_1")).resolves.toBeNull();
await expect(getCachedPermissionNames("user_1", null)).resolves.toBeNull();
await expect(cachePermissionNames("user_1", "tenant_1", ["projects.read"])).resolves.toBe(false);
await expect(cachePermissionNames("user_1", null, ["admin.read"])).resolves.toBe(false);
expect(logWarn).toHaveBeenCalledTimes(4);
expect(logWarn.mock.calls.map(([context]) => context)).toEqual([
expect.objectContaining({ op: "permission-cache.read", err: { name: "TypeError" } }),
expect.objectContaining({ op: "permission-cache.read", err: { name: "Error" } }),
expect.objectContaining({ op: "permission-cache.write", err: { name: "RangeError" } }),
expect.objectContaining({ op: "permission-cache.write", err: { name: "Error" } }),
]);
});
it("invalidates one scope locally, in L2, and through the legacy cache", async () => {
const cache = getPermissionCache();
await cache.set("user_1:tenant_1", ["projects.read"]);
const invalidate = vi.spyOn(cache.l2, "invalidate");
await invalidateUserPermissionCache("user_1", "tenant_1");
expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:tenant_1");
expect(cache.l1.get("user_1:tenant_1")).toBeUndefined();
expect(invalidate).toHaveBeenCalledWith("user_1:tenant_1");
});
it("propagates single-scope invalidation failures", async () => {
const cache = getPermissionCache();
vi.spyOn(cache.l2, "invalidate").mockRejectedValueOnce(new TypeError("publish unavailable")).mockRejectedValueOnce("publish secret");
await expect(invalidateUserPermissionCache("user_1", null)).rejects.toThrow("publish unavailable");
await expect(invalidateUserPermissionCache("user_1", null)).rejects.toBe("publish secret");
expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:null");
expect(logError.mock.calls.map(([context]) => context)).toEqual(
expect.arrayContaining([
expect.objectContaining({ op: "permission-cache.invalidate", err: { name: "TypeError" } }),
expect.objectContaining({ op: "permission-cache.invalidate", err: { name: "Error" } }),
])
);
});
it("deduplicates batch scopes, deletes L2 snapshots, and broadcasts one wildcard", async () => {
const cache = getPermissionCache();
await cache.set("user_1:tenant_1", ["projects.read"]);
await cache.set("user_2:__admin__", ["admin.read"]);
const remove = vi.spyOn(cache.l2, "delete");
const invalidate = vi.spyOn(cache.l2, "invalidate");
await invalidateUserPermissionCacheScopes([
{ userId: "user_1", tenantId: "tenant_1" },
{ userId: "user_1", tenantId: "tenant_1" },
{ userId: "user_2", tenantId: null },
]);
expect(remove).toHaveBeenCalledTimes(2);
expect(remove).toHaveBeenCalledWith("user_1:tenant_1");
expect(remove).toHaveBeenCalledWith("user_2:__admin__");
expect(invalidate).toHaveBeenCalledWith("*");
expect(clearCacheKey.mock.calls).toEqual(expect.arrayContaining([["userRoles:user_1:tenant_1"], ["userRoles:user_2:null"]]));
expect(cache.l1.get("user_1:tenant_1")).toBeUndefined();
expect(cache.l1.get("user_2:__admin__")).toBeUndefined();
});
it("handles empty and single-scope batches without wildcard invalidation", async () => {
const cache = getPermissionCache();
const invalidate = vi.spyOn(cache.l2, "invalidate");
await invalidateUserPermissionCacheScopes([]);
expect(invalidate).not.toHaveBeenCalled();
await invalidateUserPermissionCacheScopes([{ userId: "user_1", tenantId: null }]);
expect(invalidate).toHaveBeenCalledWith("user_1:__admin__");
expect(invalidate).not.toHaveBeenCalledWith("*");
});
it("propagates batch invalidation failures without hiding stale-peer risk", async () => {
const cache = getPermissionCache();
const remove = vi.spyOn(cache.l2, "delete").mockRejectedValueOnce("delete unavailable");
const scopes = [
{ userId: "user_1", tenantId: "tenant_1" },
{ userId: "user_2", tenantId: "tenant_1" },
];
await expect(invalidateUserPermissionCacheScopes(scopes)).rejects.toBe("delete unavailable");
remove.mockRejectedValueOnce(new TypeError("delete failed"));
await expect(invalidateUserPermissionCacheScopes(scopes)).rejects.toThrow("delete failed");
expect(logError.mock.calls.map(([context]) => context)).toEqual(
expect.arrayContaining([
expect.objectContaining({ op: "permission-cache.invalidate-many", err: { name: "Error" } }),
expect.objectContaining({ op: "permission-cache.invalidate-many", err: { name: "TypeError" } }),
])
);
});
it("reuses the singleton subscriber and honours explicit pubsub disable values", async () => {
process.env.CACHE_INVALIDATION_ENABLED = "false";
createPermissionCache(createSharedStore({ namespace: "permission-pubsub-false", adapter: new MemoryAdapter() }));
process.env.CACHE_INVALIDATION_ENABLED = "0";
createPermissionCache(createSharedStore({ namespace: "permission-pubsub-zero", adapter: new MemoryAdapter() }));
process.env.CACHE_INVALIDATION_ENABLED = "TRUE";
createPermissionCache(createSharedStore({ namespace: "permission-pubsub-true", adapter: new MemoryAdapter() }));
process.env.CACHE_INVALIDATION_ENABLED = "";
createPermissionCache(createSharedStore({ namespace: "permission-pubsub-default", adapter: new MemoryAdapter() }));
const cache = getPermissionCache();
const subscribe = vi.spyOn(cache, "subscribe");
const first = await subscribePermissionCache();
disposers.push(first);
await expect(subscribePermissionCache()).resolves.toBe(first);
expect(subscribe).toHaveBeenCalledTimes(1);
expect(logInfo).toHaveBeenCalledWith({ namespace: "user-permissions" }, "Permission cache subscriber started.");
});
});
@@ -0,0 +1,142 @@
import { createTwoTierCache, type SharedStore, type TwoTierCache } from "@hivegrid/shared-store";
import { getSharedStore } from "~/shared-store.server";
import { clearCacheKey } from "~/utils/cache.server";
import { createScopedLogger } from "~/utils/logger.server";
const log = createScopedLogger("permission-cache");
// Pub/sub is the primary revocation path. The short TTL is the safety net for
// a replica that was disconnected while an invalidation was published.
const AUTHORIZATION_CACHE_TTL_SECONDS = 30;
const ADMIN_SCOPE_KEY = "__admin__";
export type PermissionCache = TwoTierCache<string[]>;
let cacheSingleton: PermissionCache | null = null;
let subscribeDisposer: (() => Promise<void>) | null = null;
function permissionCacheKey(userId: string, tenantId: string | null): string {
return `${userId}:${tenantId ?? ADMIN_SCOPE_KEY}`;
}
function legacyPermissionCacheKey(userId: string, tenantId: string | null): string {
return `userRoles:${userId}:${tenantId}`;
}
function pubsubEnabledFromEnv(): boolean {
const raw = process.env.CACHE_INVALIDATION_ENABLED;
if (raw === undefined || raw === null || raw === "") return true;
return raw.toLowerCase() !== "false" && raw !== "0";
}
export function createPermissionCache(store: SharedStore): PermissionCache {
return createTwoTierCache<string[]>({
store,
namespace: "user-permissions",
ttlSeconds: AUTHORIZATION_CACHE_TTL_SECONDS,
pubsubEnabled: pubsubEnabledFromEnv(),
logger: {
warn: (obj, msg) => log.warn(obj, msg),
info: (obj, msg) => log.info(obj, msg),
error: (obj, msg) => log.error(obj, msg),
},
});
}
export function getPermissionCache(): PermissionCache {
if (!cacheSingleton) {
cacheSingleton = createPermissionCache(getSharedStore());
}
return cacheSingleton;
}
export async function getCachedPermissionNames(userId: string, tenantId: string | null): Promise<string[] | null> {
try {
const cached = await getPermissionCache().get(permissionCacheKey(userId, tenantId));
return cached === null ? null : [...cached];
} catch (error) {
// Cache availability must not become an authorization availability
// dependency. The caller falls back to the authoritative database.
log.warn(
{ op: "permission-cache.read", err: { name: error instanceof Error ? error.name : "Error" } },
"Permission cache read failed; falling back to the database."
);
return null;
}
}
export async function cachePermissionNames(userId: string, tenantId: string | null, permissionNames: readonly string[]): Promise<boolean> {
try {
await getPermissionCache().set(permissionCacheKey(userId, tenantId), [...permissionNames]);
return true;
} catch (error) {
log.warn(
{ op: "permission-cache.write", err: { name: error instanceof Error ? error.name : "Error" } },
"Permission cache write failed; continuing with the database result."
);
return false;
}
}
/**
* Invalidates one authorization scope locally, in shared L2, and on every
* subscribed web replica. Publish errors propagate: callers changing roles
* must not report success while peer replicas could still hold a stale grant.
*/
export async function invalidateUserPermissionCache(userId: string, tenantId: string | null): Promise<void> {
const key = permissionCacheKey(userId, tenantId);
clearCacheKey(legacyPermissionCacheKey(userId, tenantId));
const cache = getPermissionCache();
cache.deleteLocal(key);
try {
await cache.l2.invalidate(key);
} catch (error) {
log.error(
{ op: "permission-cache.invalidate", err: { name: error instanceof Error ? error.name : "Error" } },
"Permission cache invalidation could not be published."
);
throw error;
}
}
export async function invalidateUserPermissionCacheScopes(scopes: readonly { userId: string; tenantId: string | null }[]): Promise<void> {
const unique = [...new Map(scopes.map((scope) => [permissionCacheKey(scope.userId, scope.tenantId), scope])).values()];
if (unique.length === 0) return;
if (unique.length === 1) {
const scope = unique[0]!;
await invalidateUserPermissionCache(scope.userId, scope.tenantId);
return;
}
const cache = getPermissionCache();
const keys = unique.map((scope) => permissionCacheKey(scope.userId, scope.tenantId));
unique.forEach((scope) => {
clearCacheKey(legacyPermissionCacheKey(scope.userId, scope.tenantId));
cache.deleteLocal(permissionCacheKey(scope.userId, scope.tenantId));
});
try {
// Delete every affected shared snapshot, then use one wildcard broadcast
// to flush peer L1s. This avoids one PUBLISH per user on large roles.
await Promise.all(keys.map((key) => cache.l2.delete(key)));
await cache.l2.invalidate("*");
} catch (error) {
log.error(
{ op: "permission-cache.invalidate-many", err: { name: error instanceof Error ? error.name : "Error" } },
"Permission cache invalidation batch could not be published."
);
throw error;
}
}
export async function subscribePermissionCache(): Promise<() => Promise<void>> {
if (subscribeDisposer) return subscribeDisposer;
subscribeDisposer = await getPermissionCache().subscribe();
log.info({ namespace: "user-permissions" }, "Permission cache subscriber started.");
return subscribeDisposer;
}
/** Test seam. */
export function __resetPermissionCacheForTests(): void {
cacheSingleton = null;
subscribeDisposer = null;
}
@@ -12,17 +12,24 @@ vi.mock("../../db.server", () => ({
create: vi.fn(),
update: vi.fn(),
},
rolePermission: {
findMany: vi.fn(),
},
},
}));
vi.mock("./roles.db.server", () => ({ getAllRolesNames: vi.fn(), getRoleByName: vi.fn() }));
vi.mock("./rolePermissions.db.server", () => ({ createRolePermission: vi.fn(), getAllRolePermissions: vi.fn() }));
vi.mock("./rolePermissions.db.server", () => ({
createRolePermission: vi.fn(),
getAllRolePermissions: vi.fn(),
invalidateRoleAssignmentScopes: vi.fn(),
}));
vi.mock("~/utils/cache.server", () => ({ cachified: vi.fn(), clearCacheKey: vi.fn() }));
vi.mock("~/utils/helpers/RowFiltersHelper", () => ({ default: { getFiltersCondition: vi.fn() } }));
import { cachified, clearCacheKey } from "~/utils/cache.server";
import RowFiltersHelper from "~/utils/helpers/RowFiltersHelper";
import { db } from "../../db.server";
import { createRolePermission, getAllRolePermissions } from "./rolePermissions.db.server";
import { createRolePermission, getAllRolePermissions, invalidateRoleAssignmentScopes } from "./rolePermissions.db.server";
import { getRoleByName } from "./roles.db.server";
import {
createPermissions,
@@ -40,8 +47,9 @@ import {
describe("permission persistence", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(cachified).mockImplementation((async (options: { getFreshValue: () => unknown }) =>
options.getFreshValue()) as never);
vi.mocked(cachified).mockImplementation((async (options: { getFreshValue: () => unknown }) => options.getFreshValue()) as never);
vi.mocked(db.rolePermission.findMany).mockResolvedValue([] as never);
vi.mocked(invalidateRoleAssignmentScopes).mockResolvedValue();
});
it("lists permissions with filters, role filters, and type constraints", async () => {
@@ -75,19 +83,10 @@ describe("permission persistence", () => {
select: { id: true, name: true },
orderBy: { name: "asc" },
});
expect(db.permission.findUnique).toHaveBeenNthCalledWith(
1,
expect.objectContaining({ where: { id: "permission_1" } })
);
expect(db.permission.findUnique).toHaveBeenNthCalledWith(
2,
expect.objectContaining({ where: { name: "admin.users.view" } })
);
expect(db.permission.findUnique).toHaveBeenNthCalledWith(1, expect.objectContaining({ where: { id: "permission_1" } }));
expect(db.permission.findUnique).toHaveBeenNthCalledWith(2, expect.objectContaining({ where: { name: "admin.users.view" } }));
expect(cachified).toHaveBeenCalledWith(expect.objectContaining({ key: "permission:admin.users.view" }));
expect(db.permission.findMany).toHaveBeenNthCalledWith(
2,
expect.objectContaining({ where: { name: { in: ["admin.users.view", "admin.users.edit"] } } })
);
expect(db.permission.findMany).toHaveBeenNthCalledWith(2, expect.objectContaining({ where: { name: { in: ["admin.users.view", "admin.users.edit"] } } }));
});
it("calculates the next permission order with and without a type filter", async () => {
@@ -158,12 +157,15 @@ describe("permission persistence", () => {
vi.mocked(getAllRolePermissions).mockResolvedValue([]);
vi.mocked(getRoleByName).mockResolvedValue(null);
await expect(
createPermissions([{ name: "admin.users.view", description: "View users", type: "admin", inRoles: ["Missing"] }])
).rejects.toThrow("Role required: Missing");
await expect(createPermissions([{ name: "admin.users.view", description: "View users", type: "admin", inRoles: ["Missing"] }])).rejects.toThrow(
"Role required: Missing"
);
});
it("updates and deletes permissions while clearing the permission cache", async () => {
vi.mocked(db.rolePermission.findMany)
.mockResolvedValueOnce([{ roleId: "role_admin" }] as never)
.mockResolvedValueOnce([{ roleId: "role_member" }] as never);
vi.mocked(db.permission.update).mockResolvedValueOnce({ id: "permission_1", name: "admin.users.view" } as never);
vi.mocked(db.permission.delete).mockResolvedValueOnce({ id: "permission_1", name: "admin.users.delete" } as never);
@@ -172,5 +174,7 @@ describe("permission persistence", () => {
expect(clearCacheKey).toHaveBeenCalledWith("permission:admin.users.view");
expect(clearCacheKey).toHaveBeenCalledWith("permission:admin.users.delete");
expect(invalidateRoleAssignmentScopes).toHaveBeenNthCalledWith(1, ["role_admin"]);
expect(invalidateRoleAssignmentScopes).toHaveBeenNthCalledWith(2, ["role_member"]);
});
});
@@ -1,7 +1,7 @@
import { db } from "../../db.server";
import { Permission, Role, RolePermission } from "@hivegrid/db/prisma-browser";
import { getRoleByName } from "./roles.db.server";
import { createRolePermission, getAllRolePermissions } from "./rolePermissions.db.server";
import { createRolePermission, getAllRolePermissions, invalidateRoleAssignmentScopes } from "./rolePermissions.db.server";
import RowFiltersHelper from "~/utils/helpers/RowFiltersHelper";
import { FiltersDto } from "~/application/dtos/data/FiltersDto";
import { cachified, clearCacheKey } from "~/utils/cache.server";
@@ -131,10 +131,7 @@ export async function getNextPermissionsOrder(type?: string): Promise<number> {
);
}
export async function createPermissions(
permissions: { inRoles: string[]; name: string; description: string; type: string }[],
fromOrder: number = 0
) {
export async function createPermissions(permissions: { inRoles: string[]; name: string; description: string; type: string }[], fromOrder: number = 0) {
const allRolePermissions = await getAllRolePermissions();
const allPermissions = await getAllPermissions();
const permissionByName = new Map<string, { id: string; name: string }>(allPermissions.map((permission) => [permission.name, permission]));
@@ -196,24 +193,17 @@ export async function updatePermission(
order?: number;
}
) {
return await db.permission
.update({
where: { id },
data,
})
.then((item) => {
clearCacheKey(`permission:${item.name}`);
return item;
});
const links = await db.rolePermission.findMany({ where: { permissionId: id }, select: { roleId: true } });
const item = await db.permission.update({ where: { id }, data });
clearCacheKey(`permission:${item.name}`);
await invalidateRoleAssignmentScopes(links.map((link) => link.roleId));
return item;
}
export async function deletePermission(id: string) {
return await db.permission
.delete({
where: { id },
})
.then((item) => {
clearCacheKey(`permission:${item.name}`);
return item;
});
const links = await db.rolePermission.findMany({ where: { permissionId: id }, select: { roleId: true } });
const item = await db.permission.delete({ where: { id } });
clearCacheKey(`permission:${item.name}`);
await invalidateRoleAssignmentScopes(links.map((link) => link.roleId));
return item;
}
@@ -16,18 +16,20 @@ vi.mock("../../db.server", () => ({
delete: vi.fn(),
deleteMany: vi.fn(),
findFirst: vi.fn(),
findUnique: vi.fn(),
findMany: vi.fn(),
},
userRole: {
findMany: vi.fn(),
},
$transaction: vi.fn(),
},
}));
vi.mock("~/utils/cache.server", () => ({ clearCacheKey: vi.fn() }));
vi.mock("../tenants.db.server", () => ({ adminGetAllTenants: vi.fn() }));
vi.mock("../users.db.server", () => ({ adminGetAllUsersNames: vi.fn() }));
vi.mock("./permission-cache.server", () => ({ invalidateUserPermissionCacheScopes: vi.fn() }));
import { clearCacheKey } from "~/utils/cache.server";
import { adminGetAllTenants } from "../tenants.db.server";
import { adminGetAllUsersNames } from "../users.db.server";
import { invalidateUserPermissionCacheScopes } from "./permission-cache.server";
import { db } from "../../db.server";
import {
createRolePermission,
@@ -47,8 +49,9 @@ describe("role permission persistence", () => {
beforeEach(() => {
vi.clearAllMocks();
dbMock.$transaction.mockImplementation(async (callback: (tx: typeof dbMock) => Promise<unknown>) => callback(dbMock));
vi.mocked(adminGetAllTenants).mockResolvedValue([]);
vi.mocked(adminGetAllUsersNames).mockResolvedValue([]);
dbMock.userRole.findMany.mockResolvedValue([] as never);
dbMock.rolePermission.findMany.mockResolvedValue([] as never);
vi.mocked(invalidateUserPermissionCacheScopes).mockResolvedValue();
});
it("sets role permissions inside one awaited transaction before clearing caches", async () => {
@@ -74,9 +77,7 @@ describe("role permission persistence", () => {
it("reads and creates role-permission links without duplicating existing links", async () => {
dbMock.rolePermission.findMany.mockResolvedValueOnce([{ id: "rp_1" }] as never);
dbMock.rolePermission.findFirst
.mockResolvedValueOnce({ id: "rp_existing" } as never)
.mockResolvedValueOnce(null);
dbMock.rolePermission.findFirst.mockResolvedValueOnce({ id: "rp_existing" } as never).mockResolvedValueOnce(null);
dbMock.rolePermission.create.mockResolvedValueOnce({ id: "rp_created" } as never);
await expect(getAllRolePermissions()).resolves.toEqual([{ id: "rp_1" }]);
@@ -96,24 +97,24 @@ describe("role permission persistence", () => {
expect(dbMock.$transaction).not.toHaveBeenCalled();
});
it("clears app role user caches across tenants and user-role lookup caches", async () => {
it("invalidates exactly the assigned users across replicas after an app-role permission change", async () => {
findRoleByIdMock.mockResolvedValue({ id: "role_1", name: "Member", type: "app" } as never);
findPermissionsMock.mockResolvedValue([]);
vi.mocked(adminGetAllTenants).mockResolvedValue([
{ id: "tenant_1", users: [{ userId: "user_1" }, { userId: "user_2" }] },
{ id: "tenant_2", users: [{ userId: "user_3" }] },
dbMock.userRole.findMany.mockResolvedValue([
{ userId: "user_1", tenantId: "tenant_1" },
{ userId: "user_2", tenantId: "tenant_1" },
{ userId: "user_3", tenantId: "tenant_2" },
] as never);
vi.mocked(adminGetAllUsersNames).mockResolvedValue([{ id: "user_1" }, { id: "user_4" }] as never);
await setRolePermissions("role_1", []);
expect(dbMock.rolePermission.createMany).not.toHaveBeenCalled();
expect(clearCacheKey).toHaveBeenCalledWith("roles:app");
expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:tenant_1");
expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_2:tenant_1");
expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_3:tenant_2");
expect(clearCacheKey).toHaveBeenCalledWith("userRole:user_1:Member");
expect(clearCacheKey).toHaveBeenCalledWith("userRole:user_4:Member");
expect(invalidateUserPermissionCacheScopes).toHaveBeenCalledWith([
{ userId: "user_1", tenantId: "tenant_1" },
{ userId: "user_2", tenantId: "tenant_1" },
{ userId: "user_3", tenantId: "tenant_2" },
]);
});
it("sets permission roles inside one awaited transaction", async () => {
@@ -146,6 +147,7 @@ describe("role permission persistence", () => {
it("deletes role-permission links by composite keys or id", async () => {
dbMock.rolePermission.deleteMany.mockResolvedValueOnce({ count: 1 } as never);
dbMock.rolePermission.findUnique.mockResolvedValueOnce({ roleId: "role_2" } as never);
dbMock.rolePermission.delete.mockResolvedValueOnce({ id: "rp_1" } as never);
await expect(deleteRolePermission("role_1", "permission_1")).resolves.toEqual({ count: 1 });
@@ -153,5 +155,13 @@ describe("role permission persistence", () => {
expect(dbMock.rolePermission.deleteMany).toHaveBeenCalledWith({ where: { roleId: "role_1", permissionId: "permission_1" } });
expect(dbMock.rolePermission.delete).toHaveBeenCalledWith({ where: { id: "rp_1" } });
expect(dbMock.userRole.findMany).toHaveBeenCalledWith({
where: { roleId: { in: ["role_1"] } },
select: { userId: true, tenantId: true },
});
expect(dbMock.userRole.findMany).toHaveBeenCalledWith({
where: { roleId: { in: ["role_2"] } },
select: { userId: true, tenantId: true },
});
});
});
@@ -1,10 +1,15 @@
import { clearCacheKey } from "~/utils/cache.server";
import { createScopedLogger } from "~/utils/logger.server";
import { db } from "../../db.server";
import { adminGetAllTenants } from "../tenants.db.server";
import { adminGetAllUsersNames } from "../users.db.server";
import { invalidateUserPermissionCacheScopes } from "./permission-cache.server";
const rolePermissionsLogger = createScopedLogger("db.rolePermissions");
export async function invalidateRoleAssignmentScopes(roleIds: readonly string[]): Promise<void> {
if (roleIds.length === 0) return;
const assignments = await db.userRole.findMany({
where: { roleId: { in: [...new Set(roleIds)] } },
select: { userId: true, tenantId: true },
});
await invalidateUserPermissionCacheScopes(assignments);
}
export async function getAllRolePermissions() {
return await db.rolePermission.findMany({
@@ -24,9 +29,11 @@ export async function createRolePermission(data: { roleId: string; permissionId:
if (existing) {
return existing;
}
return await db.rolePermission.create({
const created = await db.rolePermission.create({
data,
});
await invalidateRoleAssignmentScopes([data.roleId]);
return created;
}
export async function setRolePermissions(roleId: string, permissionNames: string[]) {
@@ -59,20 +66,7 @@ export async function setRolePermissions(roleId: string, permissionNames: string
});
clearCacheKey(`roles:${role.type}`);
if (role.type === "app") {
const allTenants = await adminGetAllTenants();
rolePermissionsLogger.info({ tenantCount: allTenants.length }, "Clearing user roles cache");
for (const tenant of allTenants) {
for (const user of tenant.users) {
clearCacheKey(`userRoles:${user.userId}:${tenant.id}`);
}
}
}
const allUsers = await adminGetAllUsersNames();
for (const user of allUsers) {
clearCacheKey(`userRole:${user.id}:${role.name}`);
}
await invalidateRoleAssignmentScopes([roleId]);
}
export async function setPermissionRoles(permissionId: string, roleNames: string[]) {
@@ -83,6 +77,10 @@ export async function setPermissionRoles(permissionId: string, roleNames: string
select: { id: true },
})
: [];
const previousLinks = await db.rolePermission.findMany({
where: { permissionId },
select: { roleId: true },
});
await db.$transaction(async (tx) => {
await tx.rolePermission.deleteMany({
@@ -98,16 +96,24 @@ export async function setPermissionRoles(permissionId: string, roleNames: string
});
}
});
await invalidateRoleAssignmentScopes([...previousLinks.map((link) => link.roleId), ...roles.map((role) => role.id)]);
}
export async function deleteRolePermission(roleId: string, permissionId: string) {
return await db.rolePermission.deleteMany({
const result = await db.rolePermission.deleteMany({
where: { roleId, permissionId },
});
await invalidateRoleAssignmentScopes([roleId]);
return result;
}
export async function deleteRolePermissionById(id: string) {
return await db.rolePermission.delete({
const existing = await db.rolePermission.findUnique({ where: { id }, select: { roleId: true } });
const result = await db.rolePermission.delete({
where: { id },
});
if (existing) {
await invalidateRoleAssignmentScopes([existing.roleId]);
}
return result;
}
@@ -12,14 +12,19 @@ vi.mock("../../db.server", () => ({
findUnique: vi.fn(),
update: vi.fn(),
},
userRole: {
findMany: vi.fn(),
},
},
}));
vi.mock("~/utils/cache.server", () => ({ cachified: vi.fn(), clearCacheKey: vi.fn() }));
vi.mock("./permission-cache.server", () => ({ invalidateUserPermissionCacheScopes: vi.fn() }));
vi.mock("~/utils/helpers/RowFiltersHelper", () => ({ default: { getFiltersCondition: vi.fn() } }));
import { cachified, clearCacheKey } from "~/utils/cache.server";
import RowFiltersHelper from "~/utils/helpers/RowFiltersHelper";
import { db } from "../../db.server";
import { invalidateUserPermissionCacheScopes } from "./permission-cache.server";
import {
createRole,
deleteRole,
@@ -34,6 +39,7 @@ import {
getRolesByName,
getTenantAppRoleByName,
getTenantAssignableAppRole,
getTenantAssignableAppRoles,
getTenantMutableAppRole,
updateRole,
} from "./roles.db.server";
@@ -43,8 +49,9 @@ const dbMock = vi.mocked(db);
describe("role persistence", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(cachified).mockImplementation((async (options: { getFreshValue: () => unknown }) =>
options.getFreshValue()) as never);
vi.mocked(cachified).mockImplementation((async (options: { getFreshValue: () => unknown }) => options.getFreshValue()) as never);
vi.mocked(dbMock.userRole.findMany).mockResolvedValue([] as never);
vi.mocked(invalidateUserPermissionCacheScopes).mockResolvedValue();
});
it("lists global roles with permissions and supports type filtering", async () => {
@@ -94,11 +101,7 @@ describe("role persistence", () => {
vi.mocked(RowFiltersHelper.getFiltersCondition).mockReturnValue({ name: { contains: "editor" } } as never);
vi.mocked(dbMock.role.findMany).mockResolvedValueOnce([] as never);
await getAllRolesWithUsers(
"app",
{ properties: [{ name: "permissionId", value: "permission_1" }] } as never,
"tenant_1"
);
await getAllRolesWithUsers("app", { properties: [{ name: "permissionId", value: "permission_1" }] } as never, "tenant_1");
expect(dbMock.role.findMany).toHaveBeenCalledWith(
expect.objectContaining({
@@ -178,6 +181,20 @@ describe("role persistence", () => {
expect(dbMock.role.findFirst).toHaveBeenNthCalledWith(4, expect.objectContaining({ where: { name: "Support", tenantId: "tenant_1", type: "app" } }));
});
it("lists shared defaults and tenant-owned roles that the tenant may assign", async () => {
vi.mocked(dbMock.role.findMany).mockResolvedValueOnce([{ id: "role_1" }] as never);
await expect(getTenantAssignableAppRoles("tenant_1")).resolves.toEqual([{ id: "role_1" }]);
expect(dbMock.role.findMany).toHaveBeenCalledWith({
where: {
type: "app",
OR: [{ isDefault: true, tenantId: null }, { tenantId: "tenant_1" }],
},
orderBy: [{ type: "asc" }, { order: "asc" }],
});
});
it("calculates next role order for global and tenant-scoped roles", async () => {
vi.mocked(dbMock.role.aggregate)
.mockResolvedValueOnce({ _max: { order: 4 } } as never)
@@ -202,6 +219,7 @@ describe("role persistence", () => {
vi.mocked(dbMock.role.create).mockResolvedValueOnce({ id: "role_1", type: "app" } as never);
vi.mocked(dbMock.role.update).mockResolvedValueOnce({ id: "role_1", type: "admin" } as never);
vi.mocked(dbMock.role.delete).mockResolvedValueOnce({ id: "role_1", type: "app" } as never);
vi.mocked(dbMock.userRole.findMany).mockResolvedValueOnce([{ userId: "user_1", tenantId: "tenant_1" }] as never);
await createRole({
order: 1,
@@ -234,5 +252,6 @@ describe("role persistence", () => {
expect(clearCacheKey).toHaveBeenNthCalledWith(1, "roles:app");
expect(clearCacheKey).toHaveBeenNthCalledWith(2, "roles:admin");
expect(clearCacheKey).toHaveBeenNthCalledWith(3, "roles:app");
expect(invalidateUserPermissionCacheScopes).toHaveBeenCalledWith([{ userId: "user_1", tenantId: "tenant_1" }]);
});
});
@@ -5,6 +5,7 @@ import RowFiltersHelper from "~/utils/helpers/RowFiltersHelper";
import { UserSimple } from "../users.db.server";
import UserModelHelper from "~/utils/helpers/models/UserModelHelper";
import { cachified, clearCacheKey } from "~/utils/cache.server";
import { invalidateUserPermissionCacheScopes } from "./permission-cache.server";
export type RoleWithPermissions = Role & {
permissions: (RolePermission & { permission: Permission })[];
@@ -318,12 +319,12 @@ export async function updateRole(id: string, data: { name: string; description:
}
export async function deleteRole(id: string) {
return await db.role
.delete({
where: { id },
})
.then((item) => {
clearCacheKey(`roles:${item.type}`);
return item;
});
const assignments = await db.userRole.findMany({
where: { roleId: id },
select: { userId: true, tenantId: true },
});
const item = await db.role.delete({ where: { id } });
clearCacheKey(`roles:${item.type}`);
await invalidateUserPermissionCacheScopes(assignments);
return item;
}
@@ -0,0 +1,110 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
vi.mock("../../db.server", () => ({
db: {
userRole: {
findMany: vi.fn(),
},
tenantUser: {
findUnique: vi.fn(),
findMany: vi.fn(),
},
},
}));
import { db } from "../../db.server";
import { getTenantSeatCounts, getUserEffectiveSeatType } from "./seatType.db.server";
import { TenantUserStatus } from "~/application/enums/tenants/TenantUserStatus";
const dbMock = vi.mocked(db, true);
describe("getUserEffectiveSeatType", () => {
beforeEach(() => {
vi.clearAllMocks();
dbMock.tenantUser.findUnique.mockResolvedValue(null as never);
});
it("derives office when the user holds at least one office role", async () => {
dbMock.userRole.findMany.mockResolvedValue([{ role: { seatCategory: "field" } }, { role: { seatCategory: "office" } }] as never);
await expect(getUserEffectiveSeatType("user-1", "tenant-1")).resolves.toBe("office");
expect(dbMock.userRole.findMany).toHaveBeenCalledWith({
where: { userId: "user-1", tenantId: "tenant-1" },
select: { role: { select: { seatCategory: true } } },
});
});
it("derives field when every role is a field role", async () => {
dbMock.userRole.findMany.mockResolvedValue([{ role: { seatCategory: "field" } }] as never);
await expect(getUserEffectiveSeatType("user-1", "tenant-1")).resolves.toBe("field");
});
it("derives field when the user holds no roles in the tenant", async () => {
dbMock.userRole.findMany.mockResolvedValue([] as never);
await expect(getUserEffectiveSeatType("user-1", "tenant-1")).resolves.toBe("field");
});
it("prefers the TenantUser.seatType admin override over the role-derived seat", async () => {
dbMock.userRole.findMany.mockResolvedValue([{ role: { seatCategory: "office" } }] as never);
dbMock.tenantUser.findUnique.mockResolvedValue({ seatType: "field" } as never);
await expect(getUserEffectiveSeatType("user-1", "tenant-1")).resolves.toBe("field");
expect(dbMock.tenantUser.findUnique).toHaveBeenCalledWith({
where: { tenantId_userId: { tenantId: "tenant-1", userId: "user-1" } },
select: { seatType: true },
});
});
});
describe("getTenantSeatCounts", () => {
beforeEach(() => {
vi.clearAllMocks();
});
it("queries only ACTIVE members with their tenant roles (no N+1)", async () => {
dbMock.tenantUser.findMany.mockResolvedValue([] as never);
await getTenantSeatCounts("tenant-1");
expect(dbMock.tenantUser.findMany).toHaveBeenCalledTimes(1);
expect(dbMock.tenantUser.findMany).toHaveBeenCalledWith({
where: { tenantId: "tenant-1", status: TenantUserStatus.ACTIVE },
select: {
seatType: true,
user: { select: { roles: { where: { tenantId: "tenant-1" }, select: { role: { select: { seatCategory: true } } } } } },
},
});
});
it("buckets members by effective seat type: any office role => office, else field", async () => {
dbMock.tenantUser.findMany.mockResolvedValue([
// office (has an office role)
{ seatType: null, user: { roles: [{ role: { seatCategory: "office" } }, { role: { seatCategory: "field" } }] } },
// field (only field roles)
{ seatType: null, user: { roles: [{ role: { seatCategory: "field" } }] } },
// field (no roles at all)
{ seatType: null, user: { roles: [] } },
] as never);
await expect(getTenantSeatCounts("tenant-1")).resolves.toEqual({ office: 1, field: 2 });
});
it("honours the TenantUser.seatType admin override over the role-derived seat", async () => {
dbMock.tenantUser.findMany.mockResolvedValue([
// office role but overridden to field
{ seatType: "field", user: { roles: [{ role: { seatCategory: "office" } }] } },
// field role but overridden to office
{ seatType: "office", user: { roles: [{ role: { seatCategory: "field" } }] } },
] as never);
await expect(getTenantSeatCounts("tenant-1")).resolves.toEqual({ office: 1, field: 1 });
});
it("returns zero counts when the tenant has no active members", async () => {
dbMock.tenantUser.findMany.mockResolvedValue([] as never);
await expect(getTenantSeatCounts("tenant-1")).resolves.toEqual({ office: 0, field: 0 });
});
});
@@ -0,0 +1,70 @@
import type { SeatType } from "@hivegrid/db/prisma-browser";
import { deriveSeatType } from "@hivegrid/entitlements";
import { TenantUserStatus } from "~/application/enums/tenants/TenantUserStatus";
import { db } from "../../db.server";
/**
* Effective seat type of a single member in a tenant (Fundament C).
*
* Loads the tenant roles the user holds via the UserRole -> Role path (reading
* `Role.seatCategory`) plus the `TenantUser.seatType` admin override, then applies
* the shared `deriveSeatType` rule. Two batched queries, run in parallel — no N+1.
*/
export async function getUserEffectiveSeatType(userId: string, tenantId: string): Promise<SeatType> {
const [userRoles, tenantUser] = await Promise.all([
db.userRole.findMany({
where: { userId, tenantId },
select: { role: { select: { seatCategory: true } } },
}),
db.tenantUser.findUnique({
where: { tenantId_userId: { tenantId, userId } },
select: { seatType: true },
}),
]);
return deriveSeatType({
roleSeatCategories: userRoles.map((userRole) => userRole.role.seatCategory),
override: tenantUser?.seatType ?? null,
});
}
/** Count of the tenant's active seats per effective seat category (Fundament E). */
export interface TenantSeatCounts {
readonly office: number;
readonly field: number;
}
/**
* Counts the ACTIVE members of a tenant by their effective seat type (Fundament E).
*
* One batched `findMany` loads every active member together with the roles they
* hold in the tenant (for `Role.seatCategory`) plus the `TenantUser.seatType`
* admin override, then the shared `deriveSeatType` rule buckets each member —
* no N+1. Only `TenantUserStatus.ACTIVE` members count toward billed seats.
*/
export async function getTenantSeatCounts(tenantId: string): Promise<TenantSeatCounts> {
const members = await db.tenantUser.findMany({
where: { tenantId, status: TenantUserStatus.ACTIVE },
select: {
seatType: true,
user: {
select: {
roles: {
where: { tenantId },
select: { role: { select: { seatCategory: true } } },
},
},
},
},
});
const counts = { office: 0, field: 0 };
for (const member of members) {
const seat = deriveSeatType({
roleSeatCategories: member.user.roles.map((userRole) => userRole.role.seatCategory),
override: member.seatType,
});
counts[seat] += 1;
}
return counts;
}
@@ -1,47 +1,98 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
syncGroupChats: vi.fn(),
syncProjectChats: vi.fn(),
lockGroups: vi.fn(),
logActivity: vi.fn(),
publishAudit: vi.fn(),
withTenantRLS: vi.fn(),
}));
vi.mock("../../db.server", () => ({
db: {
group: { findFirst: vi.fn(), create: vi.fn(), deleteMany: vi.fn() },
tenantUser: { findMany: vi.fn() },
groupUser: {
create: vi.fn(),
createMany: vi.fn(),
deleteMany: vi.fn(),
},
teamChatGroupSource: { deleteMany: vi.fn() },
projektMitglied: { findMany: vi.fn(), updateMany: vi.fn() },
$transaction: vi.fn(),
},
}));
vi.mock("@hivegrid/chat/group-sync.server", () => ({
syncPermissionGroupChatsIfEnabledWithTx: (...args: unknown[]) => mocks.syncGroupChats(...args),
}));
vi.mock("@hivegrid/chat/project-sync.server", () => ({
syncProjectChannelsForPermissionGroupWithTx: (...args: unknown[]) => mocks.syncProjectChats(...args),
}));
vi.mock("@hivegrid/chat/sync-locks.server", () => ({
lockPermissionGroupsWithTx: (...args: unknown[]) => mocks.lockGroups(...args),
}));
vi.mock("@hivegrid/activity", () => ({
logActivity: (...args: unknown[]) => mocks.logActivity(...args),
}));
vi.mock("@hivegrid/db/audit-events.server", () => ({
publishAuditEventViaOutbox: (...args: unknown[]) => mocks.publishAudit(...args),
}));
vi.mock("~/utils/db/.server/tenantRls.server", () => ({
withTenantRLS: (...args: unknown[]) => mocks.withTenantRLS(...args),
}));
import { db } from "../../db.server";
import { createUserGroup, createUserGroups, deleteGroupUsers, deleteUserGroup, replaceGroupUsers } from "./userGroups.db.server";
import {
addGroupUsersAndSync,
createPermissionGroupWithUsers,
deletePermissionGroupAndSync,
removeGroupUsersAndSync,
replaceGroupUsers,
} from "./userGroups.db.server";
const dbMock = vi.mocked(db);
const syncContext = { actorUserId: "user_actor", requestId: "request_group_change" } as const;
describe("user group persistence", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(dbMock.$transaction).mockImplementation((async (callback: (tx: typeof dbMock) => Promise<unknown>) => callback(dbMock)) as never);
vi.mocked(dbMock.group.findFirst).mockResolvedValue({ id: "group_1", name: "Dispatch" } as never);
vi.mocked(dbMock.tenantUser.findMany).mockImplementation(
(async (args: { where: { userId: { in: string[] } } }) => args.where.userId.in.map((userId) => ({ userId }))) as never
);
mocks.withTenantRLS.mockImplementation((_tenantId: string, callback: (tx: typeof dbMock) => Promise<unknown>) => callback(dbMock));
mocks.syncGroupChats.mockResolvedValue({ changedChatIds: [], addedUserIds: [], removedUserIds: [] });
mocks.syncProjectChats.mockResolvedValue([]);
mocks.lockGroups.mockResolvedValue(["group_1"]);
mocks.logActivity.mockResolvedValue(undefined);
mocks.publishAudit.mockResolvedValue(undefined);
});
it("creates and deletes single group memberships", async () => {
vi.mocked(dbMock.groupUser.create).mockResolvedValueOnce({ id: "group_user_1" } as never);
vi.mocked(dbMock.groupUser.deleteMany).mockResolvedValueOnce({ count: 1 } as never);
vi.mocked(dbMock.groupUser.deleteMany).mockResolvedValueOnce({ count: 2 } as never);
await expect(createUserGroup("user_1", "group_1")).resolves.toEqual({ id: "group_user_1" });
await expect(deleteUserGroup("user_1", "group_1")).resolves.toEqual({ count: 1 });
await expect(deleteGroupUsers("group_1", "tenant_1")).resolves.toEqual({ count: 2 });
expect(dbMock.groupUser.create).toHaveBeenCalledWith({ data: { userId: "user_1", groupId: "group_1" } });
expect(dbMock.groupUser.deleteMany).toHaveBeenNthCalledWith(1, { where: { userId: "user_1", groupId: "group_1" } });
expect(dbMock.groupUser.deleteMany).toHaveBeenNthCalledWith(2, { where: { groupId: "group_1", group: { tenantId: "tenant_1" } } });
});
it("bulk-creates deduplicated group memberships with database duplicate protection", async () => {
it("creates a permission group and deduplicated memberships inside tenant RLS", async () => {
vi.mocked(dbMock.group.create).mockResolvedValueOnce({ id: "group_1" } as never);
vi.mocked(dbMock.groupUser.createMany).mockResolvedValueOnce({ count: 2 } as never);
await expect(createUserGroups("group_1", ["user_1", "user_2", "user_1"])).resolves.toEqual({ count: 2 });
await expect(
createPermissionGroupWithUsers(
"tenant_1",
{ createdByUserId: "user_actor", name: "Dispatch", description: "Dispatch team", color: 2 },
["user_1", "user_2", "user_1"]
)
).resolves.toEqual({ id: "group_1" });
expect(mocks.withTenantRLS).toHaveBeenCalledWith("tenant_1", expect.any(Function));
expect(dbMock.group.create).toHaveBeenCalledWith({
data: { tenantId: "tenant_1", createdByUserId: "user_actor", name: "Dispatch", description: "Dispatch team", color: 2 },
});
expect(dbMock.groupUser.createMany).toHaveBeenCalledWith({
data: [
{ userId: "user_1", groupId: "group_1" },
@@ -51,19 +102,75 @@ describe("user group persistence", () => {
});
});
it("skips bulk membership writes when no users are selected", async () => {
await expect(createUserGroups("group_1", [])).resolves.toEqual({ count: 0 });
it("creates a permission group without a membership write when no users are selected", async () => {
vi.mocked(dbMock.group.create).mockResolvedValueOnce({ id: "group_1" } as never);
await expect(
createPermissionGroupWithUsers(
"tenant_1",
{ createdByUserId: "user_actor", name: "Empty", description: "", color: 0 },
[]
)
).resolves.toEqual({ id: "group_1" });
expect(dbMock.groupUser.createMany).not.toHaveBeenCalled();
});
it("revokes group-derived chat access and archives project history before deleting the group", async () => {
vi.mocked(dbMock.groupUser.deleteMany).mockResolvedValueOnce({ count: 2 } as never);
vi.mocked(dbMock.teamChatGroupSource.deleteMany).mockResolvedValueOnce({ count: 1 } as never);
vi.mocked(dbMock.projektMitglied.findMany).mockResolvedValueOnce([
{ id: "membership_1", projektId: "project_1", rolle: "monteur" },
{ id: "membership_2", projektId: "project_1", rolle: "beobachter" },
] as never);
vi.mocked(dbMock.projektMitglied.updateMany).mockResolvedValueOnce({ count: 2 } as never);
vi.mocked(dbMock.group.deleteMany).mockResolvedValueOnce({ count: 1 } as never);
await expect(deletePermissionGroupAndSync("group_1", "tenant_1", syncContext)).resolves.toEqual({ count: 1 });
expect(dbMock.groupUser.deleteMany).toHaveBeenCalledWith({ where: { groupId: "group_1", group: { tenantId: "tenant_1" } } });
expect(mocks.syncGroupChats).toHaveBeenCalledWith(
dbMock,
expect.objectContaining({ tenantId: "tenant_1", groupId: "group_1", actorUserId: "user_actor" })
);
expect(mocks.syncProjectChats).toHaveBeenCalledWith(
dbMock,
expect.objectContaining({ tenantId: "tenant_1", groupId: "group_1", actorUserId: "user_actor" })
);
expect(dbMock.teamChatGroupSource.deleteMany).toHaveBeenCalledWith({ where: { tenantId: "tenant_1", groupId: "group_1" } });
expect(dbMock.projektMitglied.updateMany).toHaveBeenCalledWith({
where: { tenantId: "tenant_1", groupId: "group_1", archivedAt: null },
data: { archivedAt: expect.any(Date) },
});
expect(mocks.logActivity).toHaveBeenCalledWith(
expect.objectContaining({
tenantId: "tenant_1",
actorUserId: "user_actor",
activityType: "project_member_removed",
subjectId: "project_1",
summaryText: "activity.runtime.permissions.groupProjectMembershipArchived",
metadata: expect.objectContaining({ groupId: "group_1", membershipIds: ["membership_1", "membership_2"] }),
}),
{ client: dbMock }
);
expect(mocks.publishAudit).toHaveBeenCalledWith(
dbMock,
expect.objectContaining({
tenantId: "tenant_1",
actorId: "user_actor",
action: "permissions.group.deleted",
targetId: "group_1",
})
);
expect(dbMock.group.deleteMany).toHaveBeenCalledWith({ where: { tenantId: "tenant_1", id: "group_1" } });
});
it("replaces group memberships inside one transaction", async () => {
vi.mocked(dbMock.groupUser.deleteMany).mockResolvedValueOnce({ count: 3 } as never);
vi.mocked(dbMock.groupUser.createMany).mockResolvedValueOnce({ count: 2 } as never);
await expect(replaceGroupUsers("group_1", "tenant_1", ["user_1", "user_2", "user_1"])).resolves.toEqual({ count: 2 });
await expect(replaceGroupUsers("group_1", "tenant_1", ["user_1", "user_2", "user_1"], syncContext)).resolves.toEqual({ count: 2 });
expect(dbMock.$transaction).toHaveBeenCalledTimes(1);
expect(mocks.withTenantRLS).toHaveBeenCalledWith("tenant_1", expect.any(Function));
expect(dbMock.groupUser.deleteMany).toHaveBeenCalledWith({ where: { groupId: "group_1", group: { tenantId: "tenant_1" } } });
expect(dbMock.groupUser.createMany).toHaveBeenCalledWith({
data: [
@@ -72,15 +179,70 @@ describe("user group persistence", () => {
],
skipDuplicates: true,
});
expect(mocks.syncGroupChats).toHaveBeenCalledWith(
dbMock,
expect.objectContaining({ tenantId: "tenant_1", groupId: "group_1", actorUserId: "user_actor" })
);
expect(mocks.syncProjectChats).toHaveBeenCalledWith(
dbMock,
expect.objectContaining({ tenantId: "tenant_1", groupId: "group_1", actorUserId: "user_actor" })
);
});
it("fails closed before replacing a group with a user outside the active tenant membership", async () => {
vi.mocked(dbMock.tenantUser.findMany).mockResolvedValueOnce([{ userId: "user_1" }] as never);
await expect(replaceGroupUsers("group_1", "tenant_1", ["user_1", "foreign_user"], syncContext)).rejects.toThrow(
"outside the active tenant membership"
);
expect(dbMock.groupUser.deleteMany).not.toHaveBeenCalled();
expect(dbMock.groupUser.createMany).not.toHaveBeenCalled();
expect(mocks.syncGroupChats).not.toHaveBeenCalled();
expect(mocks.syncProjectChats).not.toHaveBeenCalled();
});
it("replaces group memberships with an empty set without bulk insert", async () => {
vi.mocked(dbMock.groupUser.deleteMany).mockResolvedValueOnce({ count: 3 } as never);
await expect(replaceGroupUsers("group_1", "tenant_1", [])).resolves.toEqual({ count: 0 });
await expect(replaceGroupUsers("group_1", "tenant_1", [], syncContext)).resolves.toEqual({ count: 0 });
expect(dbMock.$transaction).toHaveBeenCalledTimes(1);
expect(mocks.withTenantRLS).toHaveBeenCalledWith("tenant_1", expect.any(Function));
expect(dbMock.groupUser.deleteMany).toHaveBeenCalledWith({ where: { groupId: "group_1", group: { tenantId: "tenant_1" } } });
expect(dbMock.groupUser.createMany).not.toHaveBeenCalled();
expect(mocks.syncGroupChats).toHaveBeenCalledOnce();
expect(mocks.syncProjectChats).toHaveBeenCalledOnce();
});
it("syncs dependent group and project chats after additive and subtractive membership changes", async () => {
vi.mocked(dbMock.groupUser.createMany).mockResolvedValueOnce({ count: 2 } as never);
vi.mocked(dbMock.groupUser.deleteMany).mockResolvedValueOnce({ count: 1 } as never);
await expect(addGroupUsersAndSync("group_1", "tenant_1", ["user_1", "user_2"], syncContext)).resolves.toEqual({ count: 2 });
await expect(removeGroupUsersAndSync("group_1", "tenant_1", ["user_2"], syncContext)).resolves.toEqual({ count: 1 });
expect(mocks.syncGroupChats).toHaveBeenCalledTimes(2);
expect(mocks.syncProjectChats).toHaveBeenCalledTimes(2);
expect(mocks.lockGroups).toHaveBeenCalledTimes(2);
});
it("returns without opening an RLS transaction when additive or subtractive inputs are empty", async () => {
await expect(addGroupUsersAndSync("group_1", "tenant_1", [], syncContext)).resolves.toEqual({ count: 0 });
await expect(removeGroupUsersAndSync("group_1", "tenant_1", [], syncContext)).resolves.toEqual({ count: 0 });
expect(mocks.withTenantRLS).not.toHaveBeenCalled();
expect(mocks.lockGroups).not.toHaveBeenCalled();
});
it("fails closed when the permission group does not belong to the tenant", async () => {
vi.mocked(dbMock.group.findFirst).mockResolvedValueOnce(null);
await expect(addGroupUsersAndSync("foreign_group", "tenant_1", ["user_1"], syncContext)).rejects.toThrow(
"Permission group is not available in the tenant"
);
expect(dbMock.groupUser.createMany).not.toHaveBeenCalled();
expect(mocks.syncGroupChats).not.toHaveBeenCalled();
expect(mocks.syncProjectChats).not.toHaveBeenCalled();
});
});
@@ -1,64 +1,245 @@
import { db } from "~/utils/db.server";
import { logActivity } from "@hivegrid/activity";
import { syncPermissionGroupChatsIfEnabledWithTx } from "@hivegrid/chat/group-sync.server";
import { syncProjectChannelsForPermissionGroupWithTx } from "@hivegrid/chat/project-sync.server";
import { lockPermissionGroupsWithTx } from "@hivegrid/chat/sync-locks.server";
import { publishAuditEventViaOutbox } from "@hivegrid/db/audit-events.server";
import type { OutboxPublisherTransaction } from "@hivegrid/db/outbox";
import type { DbTransactionClient } from "@hivegrid/db/transactions.server";
import { withTenantScope } from "@hivegrid/foundation";
import { withTenantRLS } from "~/utils/db/.server/tenantRls.server";
export async function createUserGroup(userId: string, groupId: string) {
return await db.groupUser.create({
data: {
userId,
groupId,
},
export type GroupMembershipSyncContext = Readonly<{
actorUserId: string;
requestId: string;
}>;
export type PermissionGroupCreateInput = Readonly<{
createdByUserId: string;
name: string;
description: string;
color: number;
}>;
async function syncGroupMembershipDependents(
tx: DbTransactionClient,
tenantId: string,
groupId: string,
context: GroupMembershipSyncContext
): Promise<void> {
await syncPermissionGroupChatsIfEnabledWithTx(tx, {
tenantId,
groupId,
actorUserId: context.actorUserId,
requestId: `${context.requestId}:group-chats`,
});
await syncProjectChannelsForPermissionGroupWithTx(tx, {
tenantId,
groupId,
actorUserId: context.actorUserId,
requestId: `${context.requestId}:project-chats`,
});
}
export async function createUserGroups(groupId: string, userIds: string[]) {
const uniqueUserIds = [...new Set(userIds)];
if (uniqueUserIds.length === 0) {
return { count: 0 };
async function requireTenantGroup(
tx: DbTransactionClient,
tenantId: string,
groupId: string
): Promise<Readonly<{ id: string; name: string }>> {
const group = await tx.group.findFirst({
where: withTenantScope(tenantId, { id: groupId }),
select: { id: true, name: true },
});
if (!group) throw new Error("Permission group is not available in the tenant");
return group;
}
async function requireActiveTenantUsers(tx: DbTransactionClient, tenantId: string, userIds: readonly string[]): Promise<void> {
if (userIds.length === 0) return;
const expectedUserIds = [...userIds].sort();
const memberships = await tx.tenantUser.findMany({
where: withTenantScope(tenantId, {
userId: { in: expectedUserIds },
status: 2,
user: { active: true, pendingDeletion: false, pseudonymized: false },
}),
select: { userId: true },
orderBy: { userId: "asc" },
});
const activeUserIds = memberships.map((membership) => membership.userId).sort();
if (activeUserIds.length !== expectedUserIds.length || activeUserIds.some((userId, index) => userId !== expectedUserIds[index])) {
throw new Error("Permission group contains a user outside the active tenant membership");
}
return await db.groupUser.createMany({
data: uniqueUserIds.map((userId) => ({
userId,
groupId,
})),
skipDuplicates: true,
});
}
export async function deleteUserGroup(userId: string, groupId: string) {
return await db.groupUser.deleteMany({
where: {
userId,
groupId,
},
});
}
export async function replaceGroupUsers(groupId: string, tenantId: string, userIds: string[]) {
export async function createPermissionGroupWithUsers(
tenantId: string,
input: PermissionGroupCreateInput,
userIds: string[]
) {
const uniqueUserIds = [...new Set(userIds)];
return await db.$transaction(async (tx) => {
return withTenantRLS(tenantId, async (tx) => {
await requireActiveTenantUsers(tx, tenantId, uniqueUserIds);
const group = await tx.group.create({
data: withTenantScope(tenantId, input),
});
if (uniqueUserIds.length > 0) {
await tx.groupUser.createMany({
data: uniqueUserIds.map((userId) => ({ userId, groupId: group.id })),
skipDuplicates: true,
});
}
return group;
});
}
export async function addGroupUsersAndSync(
groupId: string,
tenantId: string,
userIds: string[],
context: GroupMembershipSyncContext
) {
const uniqueUserIds = [...new Set(userIds)];
if (uniqueUserIds.length === 0) return { count: 0 };
return withTenantRLS(tenantId, async (tx) => {
await lockPermissionGroupsWithTx(tx, tenantId, [groupId]);
await requireTenantGroup(tx, tenantId, groupId);
await requireActiveTenantUsers(tx, tenantId, uniqueUserIds);
const result = await tx.groupUser.createMany({
data: uniqueUserIds.map((userId) => ({ userId, groupId })),
skipDuplicates: true,
});
if (result.count > 0) await syncGroupMembershipDependents(tx, tenantId, groupId, context);
return result;
});
}
export async function removeGroupUsersAndSync(
groupId: string,
tenantId: string,
userIds: string[],
context: GroupMembershipSyncContext
) {
const uniqueUserIds = [...new Set(userIds)];
if (uniqueUserIds.length === 0) return { count: 0 };
return withTenantRLS(tenantId, async (tx) => {
await lockPermissionGroupsWithTx(tx, tenantId, [groupId]);
await requireTenantGroup(tx, tenantId, groupId);
const result = await tx.groupUser.deleteMany({ where: { groupId, userId: { in: uniqueUserIds } } });
if (result.count > 0) await syncGroupMembershipDependents(tx, tenantId, groupId, context);
return result;
});
}
export async function replaceGroupUsers(
groupId: string,
tenantId: string,
userIds: string[],
context: GroupMembershipSyncContext
) {
const uniqueUserIds = [...new Set(userIds)];
return withTenantRLS(tenantId, async (tx) => {
await lockPermissionGroupsWithTx(tx, tenantId, [groupId]);
await requireTenantGroup(tx, tenantId, groupId);
await requireActiveTenantUsers(tx, tenantId, uniqueUserIds);
await tx.groupUser.deleteMany({
where: {
groupId,
group: { tenantId },
},
});
if (uniqueUserIds.length === 0) {
return { count: 0 };
}
return await tx.groupUser.createMany({
data: uniqueUserIds.map((userId) => ({
userId,
groupId,
})),
skipDuplicates: true,
});
const result =
uniqueUserIds.length === 0
? { count: 0 }
: await tx.groupUser.createMany({
data: uniqueUserIds.map((userId) => ({ userId, groupId })),
skipDuplicates: true,
});
await syncGroupMembershipDependents(tx, tenantId, groupId, context);
return result;
});
}
export async function deleteGroupUsers(groupId: string, tenantId: string) {
return await db.groupUser.deleteMany({
where: {
groupId,
group: { tenantId },
},
export async function deletePermissionGroupAndSync(
groupId: string,
tenantId: string,
context: GroupMembershipSyncContext
) {
return withTenantRLS(tenantId, async (tx) => {
await lockPermissionGroupsWithTx(tx, tenantId, [groupId]);
const group = await requireTenantGroup(tx, tenantId, groupId);
const projectMemberships = await tx.projektMitglied.findMany({
where: withTenantScope(tenantId, { groupId, archivedAt: null }),
select: { id: true, projektId: true, rolle: true },
orderBy: [{ projektId: "asc" }, { id: "asc" }],
});
// Empty the source first so both chat reconcilers revoke group-derived
// access while the Group row is still available to their tenant checks.
await tx.groupUser.deleteMany({ where: { groupId, group: { tenantId } } });
await syncGroupMembershipDependents(tx, tenantId, groupId, context);
// Chat source rows describe live configuration and become invalid with the
// group. Project-member rows are business history, so archive rather than
// hard-delete them and retain the bare group id as the historical source.
await tx.teamChatGroupSource.deleteMany({ where: withTenantScope(tenantId, { groupId }) });
const archivedAt = new Date();
if (projectMemberships.length > 0) {
await tx.projektMitglied.updateMany({
where: withTenantScope(tenantId, { groupId, archivedAt: null }),
data: { archivedAt },
});
for (const [projectId, memberships] of groupProjectMemberships(projectMemberships)) {
await logActivity(
{
tenantId,
actorUserId: context.actorUserId,
actorKind: "user",
activityType: "project_member_removed",
subjectType: "project",
subjectId: projectId,
summaryText: "activity.runtime.permissions.groupProjectMembershipArchived",
metadata: {
groupId,
groupName: group.name,
membershipIds: memberships.map(({ id }) => id),
roles: [...new Set(memberships.map(({ rolle }) => rolle))].sort(),
archivedAt: archivedAt.toISOString(),
reason: "permission_group_deleted",
},
},
{ client: tx }
);
}
}
await publishAuditEventViaOutbox(tx as unknown as OutboxPublisherTransaction, {
tenantId,
actorId: context.actorUserId,
actorType: "user",
action: "permissions.group.deleted",
targetType: "Group",
targetId: groupId,
requestId: context.requestId,
sourceModule: "permissions",
dataSensitivity: "internal",
metadata: {
groupName: group.name,
archivedProjectMembershipIds: projectMemberships.map(({ id }) => id),
affectedProjectIds: [...new Set(projectMemberships.map(({ projektId }) => projektId))].sort(),
},
summaryText: "Eine Berechtigungsgruppe wurde gelöscht; Projektzuordnungen bleiben archiviert erhalten.",
});
return tx.group.deleteMany({ where: withTenantScope(tenantId, { id: groupId }) });
});
}
function groupProjectMemberships<T extends Readonly<{ projektId: string }>>(rows: readonly T[]): ReadonlyMap<string, readonly T[]> {
const grouped = new Map<string, T[]>();
for (const row of rows) {
const memberships = grouped.get(row.projektId) ?? [];
memberships.push(row);
grouped.set(row.projektId, memberships);
}
return grouped;
}
@@ -0,0 +1,181 @@
// @vitest-environment node
import { createDbClient, getWriteDbClient } from "@hivegrid/db/client.server";
import { afterAll, beforeAll, describe, expect, it } from "vitest";
import {
addGroupUsersAndSync,
deletePermissionGroupAndSync,
removeGroupUsersAndSync,
} from "./userGroups.db.server";
const ADMIN_URL = process.env.RLS_TEST_DATABASE_URL;
const describeIfDatabase = ADMIN_URL ? describe : describe.skip;
const TENANT_A = "chat_group_sync_rls_tenant_a";
const TENANT_B = "chat_group_sync_rls_tenant_b";
const ACTOR_A = "chat_group_sync_rls_actor_a";
const MEMBER_A = "chat_group_sync_rls_member_a";
const ACTOR_B = "chat_group_sync_rls_actor_b";
const MEMBER_B = "chat_group_sync_rls_member_b";
const GROUP_A = "chat_group_sync_rls_group_a";
const GROUP_B = "chat_group_sync_rls_group_b";
const CHAT_A = "chat_group_sync_rls_chat_a";
const CHAT_B = "chat_group_sync_rls_chat_b";
const PROJECT_A = "chat_group_sync_rls_project_a";
const PROJECT_B = "chat_group_sync_rls_project_b";
describeIfDatabase("permission-group chat sync with the restricted app role", () => {
const admin = createDbClient({ connectionString: ADMIN_URL });
const app = getWriteDbClient();
beforeAll(async () => {
await cleanupFixtures(admin);
await admin.user.createMany({
data: [
{ id: ACTOR_A, email: "chat-group-sync-actor-a@example.test", firstName: "Actor", lastName: "A", active: true },
{ id: MEMBER_A, email: "chat-group-sync-member-a@example.test", firstName: "Member", lastName: "A", active: true },
{ id: ACTOR_B, email: "chat-group-sync-actor-b@example.test", firstName: "Actor", lastName: "B", active: true },
{ id: MEMBER_B, email: "chat-group-sync-member-b@example.test", firstName: "Member", lastName: "B", active: true },
],
});
await admin.tenant.createMany({
data: [
{ id: TENANT_A, slug: TENANT_A, name: "Group sync RLS tenant A", active: true },
{ id: TENANT_B, slug: TENANT_B, name: "Group sync RLS tenant B", active: true },
],
});
await admin.tenantUser.createMany({
data: [
{ id: `${TENANT_A}_actor`, tenantId: TENANT_A, userId: ACTOR_A, type: 0, joined: 1, status: 2 },
{ id: `${TENANT_A}_member`, tenantId: TENANT_A, userId: MEMBER_A, type: 0, joined: 1, status: 2 },
{ id: `${TENANT_B}_actor`, tenantId: TENANT_B, userId: ACTOR_B, type: 0, joined: 1, status: 2 },
{ id: `${TENANT_B}_member`, tenantId: TENANT_B, userId: MEMBER_B, type: 0, joined: 1, status: 2 },
],
});
await admin.group.createMany({
data: [
{ id: GROUP_A, tenantId: TENANT_A, createdByUserId: ACTOR_A, name: "Tenant A Dispatch", description: "A", color: 1 },
{ id: GROUP_B, tenantId: TENANT_B, createdByUserId: ACTOR_B, name: "Tenant B Dispatch", description: "B", color: 2 },
],
});
await admin.groupUser.create({ data: { id: `${GROUP_B}_member`, groupId: GROUP_B, userId: MEMBER_B } });
await admin.teamChat.createMany({
data: [
{ id: CHAT_A, tenantId: TENANT_A, createdByUserId: ACTOR_A, kind: "group", name: "A", isPrivate: true, eventStreamId: `${CHAT_A}_stream` },
{ id: CHAT_B, tenantId: TENANT_B, createdByUserId: ACTOR_B, kind: "group", name: "B", isPrivate: true, eventStreamId: `${CHAT_B}_stream` },
],
});
await admin.teamChatGroupSource.createMany({
data: [
{ id: `${CHAT_A}_source`, tenantId: TENANT_A, chatId: CHAT_A, groupId: GROUP_A, syncEnabled: true },
{ id: `${CHAT_B}_source`, tenantId: TENANT_B, chatId: CHAT_B, groupId: GROUP_B, syncEnabled: true },
],
});
await admin.teamChatMember.createMany({
data: [
{ id: `${CHAT_A}_actor`, tenantId: TENANT_A, chatId: CHAT_A, userId: ACTOR_A, roleInChat: "admin", notificationPref: "all_messages", isManualMember: true, manualRoleInChat: "admin" },
{ id: `${CHAT_B}_actor`, tenantId: TENANT_B, chatId: CHAT_B, userId: ACTOR_B, roleInChat: "admin", notificationPref: "all_messages", isManualMember: true, manualRoleInChat: "admin" },
{ id: `${CHAT_B}_member`, tenantId: TENANT_B, chatId: CHAT_B, userId: MEMBER_B, notificationPref: "all_messages", isManualMember: false, isGroupManaged: true },
],
});
await createProjectFixtures(admin);
});
afterAll(async () => {
await cleanupFixtures(admin);
await Promise.all([admin.$disconnect(), app.$disconnect()]);
});
it("adds, removes, and deletes only tenant-A group sources while preserving project history", async () => {
const currentRole = await app.$queryRaw<Array<{ currentUser: string }>>`SELECT current_user AS "currentUser"`;
expect(currentRole).toEqual([{ currentUser: "hivegrid_app" }]);
const rlsState = await app.$queryRaw<Array<{ tableName: string; enabled: boolean; forced: boolean }>>`
SELECT relname AS "tableName", relrowsecurity AS enabled, relforcerowsecurity AS forced
FROM pg_catalog.pg_class
WHERE relnamespace = 'public'::regnamespace
AND relname IN ('Group', 'GroupUser', 'ProjektMitglied', 'TeamChat', 'TeamChatGroupSource', 'TeamChatMember')
ORDER BY relname ASC
`;
expect(rlsState).toHaveLength(6);
expect(rlsState.every((table) => table.enabled && table.forced)).toBe(true);
await expect(app.group.findMany({ where: { id: GROUP_A }, select: { id: true } })).resolves.toEqual([]);
await addGroupUsersAndSync(GROUP_A, TENANT_A, [MEMBER_A], { actorUserId: ACTOR_A, requestId: "group-rls-add-a" });
await expect(admin.teamChatMember.findUnique({ where: { chatId_userId: { chatId: CHAT_A, userId: MEMBER_A } } })).resolves.toMatchObject({
isGroupManaged: true,
leftAt: null,
});
await removeGroupUsersAndSync(GROUP_A, TENANT_A, [MEMBER_A], { actorUserId: ACTOR_A, requestId: "group-rls-remove-a" });
await expect(admin.teamChatMember.findUnique({ where: { chatId_userId: { chatId: CHAT_A, userId: MEMBER_A } } })).resolves.toMatchObject({
isGroupManaged: false,
leftAt: expect.any(Date),
});
await addGroupUsersAndSync(GROUP_A, TENANT_A, [MEMBER_A], { actorUserId: ACTOR_A, requestId: "group-rls-readd-a" });
await deletePermissionGroupAndSync(GROUP_A, TENANT_A, { actorUserId: ACTOR_A, requestId: "group-rls-delete-a" });
await expect(admin.group.findUnique({ where: { id: GROUP_A } })).resolves.toBeNull();
await expect(admin.teamChatGroupSource.count({ where: { tenantId: TENANT_A, groupId: GROUP_A } })).resolves.toBe(0);
await expect(admin.projektMitglied.findUnique({ where: { id: `${PROJECT_A}_group_member` } })).resolves.toMatchObject({
groupId: GROUP_A,
archivedAt: expect.any(Date),
});
await expect(admin.activity.count({ where: { tenantId: TENANT_A, subjectType: "project", subjectId: PROJECT_A, activityType: "project_member_removed" } })).resolves.toBeGreaterThan(0);
await expect(admin.outboxEvent.count({ where: { tenantId: TENANT_A } })).resolves.toBeGreaterThan(0);
await expect(admin.group.findUnique({ where: { id: GROUP_B } })).resolves.toMatchObject({ tenantId: TENANT_B });
await expect(admin.groupUser.findUnique({ where: { group_user_membership_key: { groupId: GROUP_B, userId: MEMBER_B } } })).resolves.not.toBeNull();
await expect(admin.teamChatGroupSource.findUnique({ where: { chatId_groupId: { chatId: CHAT_B, groupId: GROUP_B } } })).resolves.toMatchObject({ tenantId: TENANT_B, syncEnabled: true });
await expect(admin.teamChatMember.findUnique({ where: { chatId_userId: { chatId: CHAT_B, userId: MEMBER_B } } })).resolves.toMatchObject({ isGroupManaged: true, leftAt: null });
await expect(admin.projektMitglied.findUnique({ where: { id: `${PROJECT_B}_group_member` } })).resolves.toMatchObject({ archivedAt: null });
});
});
async function createProjectFixtures(admin: ReturnType<typeof createDbClient>): Promise<void> {
await admin.pipeline.createMany({
data: [
{ id: `${PROJECT_A}_pipeline`, tenantId: TENANT_A, createdByUserId: ACTOR_A, name: "A Pipeline", typHint: "auftrag" },
{ id: `${PROJECT_B}_pipeline`, tenantId: TENANT_B, createdByUserId: ACTOR_B, name: "B Pipeline", typHint: "auftrag" },
],
});
await admin.pipelineStage.createMany({
data: [
{ id: `${PROJECT_A}_stage`, tenantId: TENANT_A, pipelineId: `${PROJECT_A}_pipeline`, name: "A Active", stageKind: "offen" },
{ id: `${PROJECT_B}_stage`, tenantId: TENANT_B, pipelineId: `${PROJECT_B}_pipeline`, name: "B Active", stageKind: "offen" },
],
});
await admin.projekt.createMany({
data: [
{ id: PROJECT_A, tenantId: TENANT_A, createdByUserId: ACTOR_A, projektNummer: "RLS-A", projektname: "RLS A", pipelineId: `${PROJECT_A}_pipeline`, stageId: `${PROJECT_A}_stage` },
{ id: PROJECT_B, tenantId: TENANT_B, createdByUserId: ACTOR_B, projektNummer: "RLS-B", projektname: "RLS B", pipelineId: `${PROJECT_B}_pipeline`, stageId: `${PROJECT_B}_stage` },
],
});
await admin.projektMitglied.createMany({
data: [
{ id: `${PROJECT_A}_group_member`, tenantId: TENANT_A, projektId: PROJECT_A, groupId: GROUP_A, rolle: "monteur", createdByUserId: ACTOR_A },
{ id: `${PROJECT_B}_group_member`, tenantId: TENANT_B, projektId: PROJECT_B, groupId: GROUP_B, rolle: "monteur", createdByUserId: ACTOR_B },
],
});
}
async function cleanupFixtures(admin: ReturnType<typeof createDbClient>): Promise<void> {
const tenantIds = [TENANT_A, TENANT_B];
await admin.teamChatMember.updateMany({ where: { tenantId: { in: tenantIds } }, data: { lastReadMessageId: null, lastReadAt: null } });
await admin.teamChatEvent.deleteMany({ where: { tenantId: { in: tenantIds } } });
await admin.teamChatMessage.deleteMany({ where: { tenantId: { in: tenantIds } } });
await admin.teamChatMember.deleteMany({ where: { tenantId: { in: tenantIds } } });
await admin.teamChatGroupSource.deleteMany({ where: { tenantId: { in: tenantIds } } });
await admin.teamChat.deleteMany({ where: { tenantId: { in: tenantIds } } });
await admin.activity.deleteMany({ where: { tenantId: { in: tenantIds } } });
await admin.outboxEvent.deleteMany({ where: { tenantId: { in: tenantIds } } });
await admin.projektMitglied.deleteMany({ where: { tenantId: { in: tenantIds } } });
await admin.projekt.deleteMany({ where: { tenantId: { in: tenantIds } } });
await admin.pipelineStage.deleteMany({ where: { tenantId: { in: tenantIds } } });
await admin.pipeline.deleteMany({ where: { tenantId: { in: tenantIds } } });
await admin.groupUser.deleteMany({ where: { groupId: { in: [GROUP_A, GROUP_B] } } });
await admin.group.deleteMany({ where: { id: { in: [GROUP_A, GROUP_B] } } });
await admin.tenantUser.deleteMany({ where: { tenantId: { in: tenantIds } } });
await admin.tenant.deleteMany({ where: { id: { in: tenantIds } } });
await admin.user.deleteMany({ where: { id: { in: [ACTOR_A, MEMBER_A, ACTOR_B, MEMBER_B] } } });
}
@@ -2,6 +2,13 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
import { TenantUserType } from "~/application/enums/tenants/TenantUserType";
const permissionCacheMock = vi.hoisted(() => ({
get: vi.fn(),
set: vi.fn(),
invalidate: vi.fn(),
invalidateScopes: vi.fn(),
}));
vi.mock("../../db.server", () => ({
db: {
permission: {
@@ -22,11 +29,25 @@ vi.mock("../../db.server", () => ({
},
}));
vi.mock("~/utils/cache.server", () => ({
cachified: vi.fn((options: { getFreshValue: () => unknown }) => options.getFreshValue()),
clearCacheKey: vi.fn(),
}));
vi.mock("./permission-cache.server", async () => {
const { clearCacheKey } = await import("~/utils/cache.server");
permissionCacheMock.invalidate.mockImplementation(async (userId: string, tenantId: string | null) => {
clearCacheKey(`userRoles:${userId}:${tenantId}`);
});
permissionCacheMock.invalidateScopes.mockImplementation(async (scopes: Array<{ userId: string; tenantId: string | null }>) => {
for (const scope of scopes) await permissionCacheMock.invalidate(scope.userId, scope.tenantId);
});
return {
getCachedPermissionNames: permissionCacheMock.get,
cachePermissionNames: permissionCacheMock.set,
invalidateUserPermissionCache: permissionCacheMock.invalidate,
invalidateUserPermissionCacheScopes: permissionCacheMock.invalidateScopes,
};
});
import { cachified, clearCacheKey } from "~/utils/cache.server";
import { clearCacheKey } from "~/utils/cache.server";
import { db } from "../../db.server";
import {
countUserPermission,
@@ -44,6 +65,7 @@ import {
getUserRoleInTenant,
getUserRoles,
getUsersRolesInTenant,
reconcileAdminUserRoleByName,
userHasPermission,
} from "./userRoles.db.server";
@@ -52,7 +74,8 @@ const dbMock = vi.mocked(db);
describe("user role persistence", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(cachified).mockImplementation((async (options: { getFreshValue: () => unknown }) => options.getFreshValue()) as never);
permissionCacheMock.get.mockResolvedValue(null);
permissionCacheMock.set.mockResolvedValue(false);
});
it("queries user-role relationships with tenant and admin scope", async () => {
@@ -71,7 +94,7 @@ describe("user role persistence", () => {
where: { userId: "user_1", role: { name: "Admin" }, tenantId: "tenant_1" },
});
expect(dbMock.userRole.findFirst).toHaveBeenNthCalledWith(3, {
where: { userId: "user_1", role: { name: "SuperAdmin" }, tenantId: null },
where: { userId: "user_1", role: { name: "SuperAdmin", type: "admin" }, tenantId: null },
});
expect(dbMock.userRole.findMany).toHaveBeenCalledWith(
expect.objectContaining({
@@ -99,12 +122,8 @@ describe("user role persistence", () => {
await expect(getPermissionsByUser("user_1", "tenant_1")).resolves.toEqual(["members.read", "settings.update"]);
expect(cachified).toHaveBeenCalledWith(
expect.objectContaining({
key: "userRoles:user_1:tenant_1",
ttl: 1000 * 60 * 60 * 24,
})
);
expect(permissionCacheMock.get).toHaveBeenCalledWith("user_1", "tenant_1");
expect(permissionCacheMock.set).toHaveBeenCalledWith("user_1", "tenant_1", ["members.read", "settings.update"]);
});
it("checks permission membership through the cached user-role expansion", async () => {
@@ -129,10 +148,29 @@ describe("user role persistence", () => {
await expect(userHasPermission("user_1", "tenant_1", "members.read")).resolves.toBe(true);
await expect(userHasPermission("user_1", "tenant_1", "settings.update")).resolves.toBe(false);
expect(cachified).toHaveBeenCalledWith(expect.objectContaining({ key: "userRoles:user_1:tenant_1" }));
expect(permissionCacheMock.get).toHaveBeenCalledWith("user_1", "tenant_1");
expect(dbMock.permission.count).not.toHaveBeenCalled();
});
it("does not repopulate a stale grant when revocation races a cache miss", async () => {
permissionCacheMock.set.mockResolvedValue(true);
vi.mocked(dbMock.userRole.findMany)
.mockResolvedValueOnce([
{
role: {
name: "Admin",
permissions: [{ permission: { name: "members.delete" } }],
},
},
] as never)
.mockResolvedValueOnce([] as never);
await expect(getPermissionsByUser("user_1", "tenant_1")).resolves.toEqual([]);
expect(permissionCacheMock.invalidate).toHaveBeenCalledWith("user_1", "tenant_1");
expect(permissionCacheMock.set).toHaveBeenLastCalledWith("user_1", "tenant_1", []);
});
it("returns the first matching permission name or null", async () => {
vi.mocked(dbMock.userRole.findMany)
.mockResolvedValueOnce([
@@ -273,7 +311,9 @@ describe("user role persistence", () => {
});
it("returns the concurrently-created user role when the unique assignment index wins the race", async () => {
vi.mocked(dbMock.userRole.findFirst).mockResolvedValueOnce(null).mockResolvedValueOnce({ id: "ur_concurrent" } as never);
vi.mocked(dbMock.userRole.findFirst)
.mockResolvedValueOnce(null)
.mockResolvedValueOnce({ id: "ur_concurrent" } as never);
vi.mocked(dbMock.userRole.create).mockRejectedValueOnce(Object.assign(new Error("Unique constraint failed"), { code: "P2002" }) as never);
await expect(createUserRole("user_1", "role_admin", null)).resolves.toEqual({ id: "ur_concurrent" });
@@ -301,22 +341,22 @@ describe("user role persistence", () => {
await expect(createUserRole("user_1", "role_1", null)).rejects.toBe(error);
});
it("does not grant an admin role by name when no matching admin role exists", async () => {
it("fails closed when a required admin role is not configured", async () => {
vi.mocked(dbMock.role.findFirst).mockResolvedValueOnce(null);
await expect(ensureAdminUserRoleByName("user_1", "SuperAdmin")).resolves.toBeUndefined();
await expect(ensureAdminUserRoleByName("user_1", "SuperAdmin")).rejects.toThrow("Required admin role is not configured");
expect(dbMock.role.findFirst).toHaveBeenCalledWith({
where: { name: "SuperAdmin", type: "admin" },
select: { id: true },
});
expect(dbMock.userRole.create).not.toHaveBeenCalled();
expect(clearCacheKey).not.toHaveBeenCalled();
expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:null");
});
it("grants a matching admin role by name with admin scope and invalidates the role cache", async () => {
vi.mocked(dbMock.role.findFirst).mockResolvedValueOnce({ id: "role_super_admin" } as never);
vi.mocked(dbMock.userRole.findFirst).mockResolvedValueOnce(null);
vi.mocked(dbMock.userRole.findFirst).mockResolvedValue(null);
vi.mocked(dbMock.userRole.create).mockResolvedValueOnce({ id: "ur_admin" } as never);
await expect(ensureAdminUserRoleByName("user_1", "SuperAdmin")).resolves.toBeUndefined();
@@ -327,6 +367,27 @@ describe("user role persistence", () => {
expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:null");
});
it("revokes SuperAdmin on an SSO staff downgrade and invalidates the role cache", async () => {
vi.mocked(dbMock.role.findFirst).mockResolvedValueOnce({ id: "role_super_admin" } as never);
vi.mocked(dbMock.userRole.deleteMany).mockResolvedValueOnce({ count: 1 } as never);
await expect(reconcileAdminUserRoleByName("user_1", "SuperAdmin", false)).resolves.toBe("revoked");
expect(dbMock.userRole.deleteMany).toHaveBeenCalledWith({
where: { userId: "user_1", roleId: "role_super_admin", tenantId: null },
});
expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:null");
});
it("keeps staff reconciliation safe when the SuperAdmin role is not configured", async () => {
vi.mocked(dbMock.role.findFirst).mockResolvedValueOnce(null);
await expect(reconcileAdminUserRoleByName("user_1", "SuperAdmin", false)).resolves.toBe("unchanged");
expect(dbMock.userRole.deleteMany).not.toHaveBeenCalled();
expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:null");
});
it("creates, bulk-creates, and deletes user roles while clearing tenant-specific caches", async () => {
vi.mocked(dbMock.userRole.findFirst).mockResolvedValueOnce(null);
vi.mocked(dbMock.userRole.create).mockResolvedValueOnce({ id: "ur_1" } as never);
@@ -1,7 +1,7 @@
import { Permission, Role, RolePermission, UserRole } from "@hivegrid/db/prisma-browser";
import { TenantUserType } from "~/application/enums/tenants/TenantUserType";
import { db } from "../../db.server";
import { cachified, clearCacheKey } from "~/utils/cache.server";
import { cachePermissionNames, getCachedPermissionNames, invalidateUserPermissionCache, invalidateUserPermissionCacheScopes } from "./permission-cache.server";
export type UserRoleWithPermission = UserRole & {
role: Role & { permissions: (RolePermission & { permission: Permission })[] };
@@ -21,8 +21,8 @@ function getUserRoleAssignmentKey(assignment: UserRoleAssignment): string {
return `${assignment.userId}:${assignment.roleId}:${normalizeTenantId(assignment.tenantId)}`;
}
function clearUserRoleCache(userId: string, tenantId: string | null): void {
clearCacheKey(`userRoles:${userId}:${tenantId}`);
async function clearUserRoleCache(userId: string, tenantId: string | null): Promise<void> {
await invalidateUserPermissionCache(userId, tenantId);
}
function isUniqueConstraintError(error: unknown): boolean {
@@ -57,6 +57,7 @@ export async function getUserRoleInAdmin(userId: string, roleName: string) {
userId,
role: {
name: roleName,
type: "admin",
},
tenantId: null,
},
@@ -89,33 +90,42 @@ export async function getUserRoles(userId: string, tenantId?: string | null): Pr
}
export async function getPermissionsByUser(userId: string, tenantId: string | null): Promise<string[]> {
const userRoles = await cachified({
key: `userRoles:${userId}:${tenantId}`,
ttl: 1000 * 60 * 60 * 24,
getFreshValue: () =>
db.userRole.findMany({
where: { userId, tenantId },
include: { role: { include: { permissions: { include: { permission: { select: { name: true } } } } } } },
}),
});
const roles: string[] = [];
const names: string[] = [];
userRoles.forEach((userRoles) => {
if (!roles.includes(userRoles.role.name)) {
roles.push(userRoles.role.name);
}
userRoles.role.permissions.forEach((permission) => {
if (!names.includes(permission.permission.name)) {
names.push(permission.permission.name);
}
const cached = await getCachedPermissionNames(userId, tenantId);
if (cached !== null) {
return cached;
}
const readPermissionNames = async (): Promise<string[]> => {
const userRoles = await db.userRole.findMany({
where: { userId, tenantId },
include: { role: { include: { permissions: { include: { permission: { select: { name: true } } } } } } },
});
});
// console.log({
// userId,
// tenantId,
// roles,
// permissions: names,
// });
const names: string[] = [];
userRoles.forEach((userRole) => {
userRole.role.permissions.forEach((permission) => {
if (!names.includes(permission.permission.name)) {
names.push(permission.permission.name);
}
});
});
return names;
};
const names = await readPermissionNames();
const cachedSuccessfully = await cachePermissionNames(userId, tenantId, names);
if (!cachedSuccessfully) {
return names;
}
// Close the cache-aside race: a revocation can commit and publish between
// the database read and cache write. Re-read after populating; a later
// revocation necessarily publishes after our write and purges it normally.
const confirmedNames = await readPermissionNames();
if (confirmedNames.length !== names.length || confirmedNames.some((name) => !names.includes(name))) {
await invalidateUserPermissionCache(userId, tenantId);
await cachePermissionNames(userId, tenantId, confirmedNames);
return confirmedNames;
}
return names;
}
@@ -235,7 +245,7 @@ export async function ensureTenantUserAppRoles({
missingRoles.map((role) => ({ id: role.id, tenantId }))
);
} else {
clearCacheKey(`userRoles:${userId}:${tenantId}`);
await clearUserRoleCache(userId, tenantId);
}
return { created: missingRoles.length, roleCount: roles.length };
@@ -254,7 +264,7 @@ export async function createUserRole(userId: string, roleId: string, tenantId: s
tenantId,
},
});
clearCacheKey(`userRoles:${userId}:${tenantId}`);
await clearUserRoleCache(userId, tenantId);
return item;
} catch (error) {
if (!isUniqueConstraintError(error)) {
@@ -272,18 +282,44 @@ export async function createUserRole(userId: string, roleId: string, tenantId: s
* Grants an admin-scoped RBAC role (e.g. "SuperAdmin") to a user by role name,
* idempotently. Used by the Admin-SSO callback to wire the JIT-provisioned
* `super_admin` identity to its concrete permission set. `createUserRole`
* invalidates the `userRoles:<userId>:null` cache, so the granted permissions
* are visible on the very next request — independent of the cache TTL.
* publishes through the shared permission cache, so every replica observes
* the grant or revocation on the next request.
*/
export async function ensureAdminUserRoleByName(userId: string, roleName: string): Promise<void> {
await reconcileAdminUserRoleByName(userId, roleName, true);
}
export type AdminRoleReconciliationResult = "granted" | "revoked" | "unchanged";
export async function reconcileAdminUserRoleByName(userId: string, roleName: string, shouldHaveRole: boolean): Promise<AdminRoleReconciliationResult> {
const role = await db.role.findFirst({
where: { name: roleName, type: "admin" },
select: { id: true },
});
if (!role) {
return;
await clearUserRoleCache(userId, null);
if (shouldHaveRole) {
throw new Error(`Required admin role is not configured: ${roleName}`);
}
return "unchanged";
}
await createUserRole(userId, role.id, null);
if (shouldHaveRole) {
const existing = await getUserRole(userId, role.id, null);
if (existing) {
await clearUserRoleCache(userId, null);
return "unchanged";
}
await createUserRole(userId, role.id, null);
await clearUserRoleCache(userId, null);
return "granted";
}
const revoked = await db.userRole.deleteMany({
where: { userId, roleId: role.id, tenantId: null },
});
await clearUserRoleCache(userId, null);
return revoked.count > 0 ? "revoked" : "unchanged";
}
export async function createUserRoles(userId: string, roles: { id: string; tenantId: string | null }[]) {
@@ -336,29 +372,28 @@ export async function createUserRoleAssignments(assignments: UserRoleAssignment[
})
: { count: 0 };
cacheScopes.forEach((scope) => {
clearUserRoleCache(scope.userId, scope.tenantId);
});
await invalidateUserPermissionCacheScopes(cacheScopes.map((scope) => ({ userId: scope.userId, tenantId: scope.tenantId })));
return result;
}
export async function deleteUserRole(userId: string, roleId: string, tenantId: string | null = null) {
return await db.userRole
.deleteMany({
where: {
userId,
roleId,
tenantId,
},
})
.then((item) => {
clearCacheKey(`userRoles:${userId}:${tenantId}`);
return item;
});
const item = await db.userRole.deleteMany({
where: {
userId,
roleId,
tenantId,
},
});
await clearUserRoleCache(userId, tenantId);
return item;
}
export async function deleteAllUserRoles(userId: string, type: string) {
return await db.userRole.deleteMany({
const assignments = await db.userRole.findMany({
where: { userId, role: { type } },
select: { tenantId: true },
});
const result = await db.userRole.deleteMany({
where: {
userId,
role: {
@@ -366,4 +401,6 @@ export async function deleteAllUserRoles(userId: string, type: string) {
},
},
});
await invalidateUserPermissionCacheScopes(assignments.map((assignment) => ({ userId, tenantId: assignment.tenantId })));
return result;
}