Refresh HiveGrid Cloud reference snapshot
This commit is contained in:
1 parent
5e99e14772
commit
7f88026f79
5955 files changed
+1177325
-188362
No files matched your search
+196
@@ -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.");
|
||||
});
|
||||
});
|
||||
+142
@@ -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;
|
||||
}
|
||||
+23
-19
@@ -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"]);
|
||||
});
|
||||
});
|
||||
+12
-22
@@ -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;
|
||||
}
|
||||
+29
-19
@@ -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 },
|
||||
});
|
||||
});
|
||||
});
|
||||
+27
-21
@@ -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;
|
||||
}
|
||||
+26
-7
@@ -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" }]);
|
||||
});
|
||||
});
|
||||
+9
-8
@@ -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;
|
||||
}
|
||||
+110
@@ -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 });
|
||||
});
|
||||
});
|
||||
+70
@@ -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;
|
||||
}
|
||||
+185
-23
@@ -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();
|
||||
});
|
||||
});
|
||||
+226
-45
@@ -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;
|
||||
}
|
||||
+181
@@ -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] } } });
|
||||
}
|
||||
+77
-16
@@ -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);
|
||||
|
||||
+88
-51
@@ -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;
|
||||
}
|
||||
Reference in new issue
Block a user