Track HiveGrid Cloud planning reference
This commit is contained in:
1 parent
b3d5ea6764
commit
e341c5938a
5784 files changed
+1104929
-3
No files matched your search
@@ -0,0 +1,133 @@
|
||||
// @vitest-environment node
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
|
||||
vi.mock("../../db.server", () => ({
|
||||
db: {
|
||||
group: {
|
||||
create: vi.fn(),
|
||||
delete: vi.fn(),
|
||||
deleteMany: vi.fn(),
|
||||
findFirst: vi.fn(),
|
||||
findMany: vi.fn(),
|
||||
update: vi.fn(),
|
||||
updateMany: vi.fn(),
|
||||
},
|
||||
groupUser: {
|
||||
createMany: vi.fn(),
|
||||
deleteMany: vi.fn(),
|
||||
},
|
||||
},
|
||||
}));
|
||||
|
||||
import { db } from "../../db.server";
|
||||
import { addUsersToGroup, createGroup, deleteGroup, getAllGroups, getGroup, getGroups, getMyGroups, removeUsersFromGroup, updateGroup } from "./groups.db.server";
|
||||
|
||||
const dbMock = vi.mocked(db);
|
||||
|
||||
describe("group persistence", () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
});
|
||||
|
||||
it("lists tenant groups and selected groups with users included", async () => {
|
||||
vi.mocked(dbMock.group.findMany).mockResolvedValue([] as never);
|
||||
|
||||
await getAllGroups("tenant_1");
|
||||
await getGroups("tenant_1", ["group_1", "group_2"]);
|
||||
|
||||
expect(dbMock.group.findMany).toHaveBeenNthCalledWith(
|
||||
1,
|
||||
expect.objectContaining({
|
||||
where: { tenantId: "tenant_1" },
|
||||
include: expect.objectContaining({ users: expect.any(Object) }),
|
||||
orderBy: [{ name: "asc" }],
|
||||
})
|
||||
);
|
||||
expect(dbMock.group.findMany).toHaveBeenNthCalledWith(
|
||||
2,
|
||||
expect.objectContaining({
|
||||
where: { tenantId: "tenant_1", id: { in: ["group_1", "group_2"] } },
|
||||
include: expect.objectContaining({ users: expect.any(Object) }),
|
||||
orderBy: [{ name: "asc" }],
|
||||
})
|
||||
);
|
||||
});
|
||||
|
||||
it("limits my-groups lookup to created or joined groups in the tenant", async () => {
|
||||
vi.mocked(dbMock.group.findMany).mockResolvedValueOnce([] as never);
|
||||
|
||||
await getMyGroups("user_1", "tenant_1");
|
||||
|
||||
expect(dbMock.group.findMany).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
where: {
|
||||
tenantId: "tenant_1",
|
||||
OR: [{ createdByUserId: "user_1" }, { users: { some: { userId: "user_1" } } }],
|
||||
},
|
||||
include: expect.objectContaining({ users: expect.any(Object) }),
|
||||
orderBy: [{ name: "asc" }],
|
||||
})
|
||||
);
|
||||
});
|
||||
|
||||
it("gets groups with optional tenant scope", async () => {
|
||||
vi.mocked(dbMock.group.findFirst).mockResolvedValue({ id: "group_1" } as never);
|
||||
|
||||
await getGroup("group_1");
|
||||
await getGroup("group_1", "tenant_1");
|
||||
|
||||
expect(dbMock.group.findFirst).toHaveBeenNthCalledWith(1, expect.objectContaining({ where: { id: "group_1" } }));
|
||||
expect(dbMock.group.findFirst).toHaveBeenNthCalledWith(2, expect.objectContaining({ where: { id: "group_1", tenantId: "tenant_1" } }));
|
||||
});
|
||||
|
||||
it("creates and mutates groups with tenant-scoped bulk operations when a tenant is provided", async () => {
|
||||
vi.mocked(dbMock.group.create).mockResolvedValueOnce({ id: "group_1" } as never);
|
||||
vi.mocked(dbMock.group.updateMany).mockResolvedValueOnce({ count: 1 } as never);
|
||||
vi.mocked(dbMock.group.update).mockResolvedValueOnce({ id: "group_1" } as never);
|
||||
vi.mocked(dbMock.group.deleteMany).mockResolvedValueOnce({ count: 1 } as never);
|
||||
vi.mocked(dbMock.group.delete).mockResolvedValueOnce({ id: "group_1" } as never);
|
||||
|
||||
const data = { createdByUserId: "user_1", tenantId: "tenant_1", name: "Team", description: "Core team", color: 1 };
|
||||
await createGroup(data);
|
||||
await updateGroup("group_1", { name: "Ops", description: "Ops team", color: 2 }, "tenant_1");
|
||||
await updateGroup("group_1", { name: "Ops", description: "Ops team", color: 2 });
|
||||
await deleteGroup("group_1", "tenant_1");
|
||||
await deleteGroup("group_1");
|
||||
|
||||
expect(dbMock.group.create).toHaveBeenCalledWith({ data });
|
||||
expect(dbMock.group.updateMany).toHaveBeenCalledWith({
|
||||
where: { id: "group_1", tenantId: "tenant_1" },
|
||||
data: { name: "Ops", description: "Ops team", color: 2 },
|
||||
});
|
||||
expect(dbMock.group.update).toHaveBeenCalledWith({
|
||||
where: { id: "group_1" },
|
||||
data: { name: "Ops", description: "Ops team", color: 2 },
|
||||
});
|
||||
expect(dbMock.group.deleteMany).toHaveBeenCalledWith({ where: { id: "group_1", tenantId: "tenant_1" } });
|
||||
expect(dbMock.group.delete).toHaveBeenCalledWith({ where: { id: "group_1" } });
|
||||
});
|
||||
|
||||
it("adds users to a group idempotently (skipDuplicates) and removes them in bulk", async () => {
|
||||
vi.mocked(dbMock.groupUser.createMany).mockResolvedValueOnce({ count: 2 } as never);
|
||||
vi.mocked(dbMock.groupUser.deleteMany).mockResolvedValueOnce({ count: 1 } as never);
|
||||
|
||||
await addUsersToGroup("group_1", ["user_1", "user_2"]);
|
||||
await removeUsersFromGroup("group_1", ["user_1"]);
|
||||
|
||||
expect(dbMock.groupUser.createMany).toHaveBeenCalledWith({
|
||||
data: [
|
||||
{ groupId: "group_1", userId: "user_1" },
|
||||
{ groupId: "group_1", userId: "user_2" },
|
||||
],
|
||||
skipDuplicates: true,
|
||||
});
|
||||
expect(dbMock.groupUser.deleteMany).toHaveBeenCalledWith({ where: { groupId: "group_1", userId: { in: ["user_1"] } } });
|
||||
});
|
||||
|
||||
it("short-circuits bulk membership ops on an empty user list", async () => {
|
||||
expect(await addUsersToGroup("group_1", [])).toEqual({ count: 0 });
|
||||
expect(await removeUsersFromGroup("group_1", [])).toEqual({ count: 0 });
|
||||
expect(dbMock.groupUser.createMany).not.toHaveBeenCalled();
|
||||
expect(dbMock.groupUser.deleteMany).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,160 @@
|
||||
import { Group, GroupUser } from "@toolctrl/db/prisma-browser";
|
||||
import { db } from "~/utils/db.server";
|
||||
import { UserSimple } from "../users.db.server";
|
||||
import UserModelHelper from "~/utils/helpers/models/UserModelHelper";
|
||||
|
||||
export type GroupWithDetails = Group & {
|
||||
users: (GroupUser & { user: UserSimple })[];
|
||||
};
|
||||
|
||||
export async function getAllGroups(tenantId: string | null): Promise<GroupWithDetails[]> {
|
||||
return await db.group.findMany({
|
||||
where: {
|
||||
tenantId,
|
||||
},
|
||||
include: {
|
||||
users: {
|
||||
include: {
|
||||
...UserModelHelper.includeSimpleUser,
|
||||
},
|
||||
},
|
||||
},
|
||||
orderBy: [
|
||||
{
|
||||
name: "asc",
|
||||
},
|
||||
],
|
||||
});
|
||||
}
|
||||
|
||||
export async function getGroups(tenantId: string | null, ids: string[]): Promise<GroupWithDetails[]> {
|
||||
return await db.group.findMany({
|
||||
where: {
|
||||
tenantId,
|
||||
id: {
|
||||
in: ids,
|
||||
},
|
||||
},
|
||||
include: {
|
||||
users: {
|
||||
include: {
|
||||
...UserModelHelper.includeSimpleUser,
|
||||
},
|
||||
},
|
||||
},
|
||||
orderBy: [
|
||||
{
|
||||
name: "asc",
|
||||
},
|
||||
],
|
||||
});
|
||||
}
|
||||
|
||||
export async function getMyGroups(userId: string, tenantId: string | null): Promise<GroupWithDetails[]> {
|
||||
return await db.group.findMany({
|
||||
where: {
|
||||
tenantId,
|
||||
OR: [
|
||||
{
|
||||
createdByUserId: userId,
|
||||
},
|
||||
{
|
||||
users: {
|
||||
some: {
|
||||
userId,
|
||||
},
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
include: {
|
||||
users: {
|
||||
include: {
|
||||
...UserModelHelper.includeSimpleUser,
|
||||
},
|
||||
},
|
||||
},
|
||||
orderBy: [
|
||||
{
|
||||
name: "asc",
|
||||
},
|
||||
],
|
||||
});
|
||||
}
|
||||
|
||||
export async function getGroup(id: string, tenantId?: string | null): Promise<GroupWithDetails | null> {
|
||||
return await db.group.findFirst({
|
||||
where: {
|
||||
id,
|
||||
...(tenantId !== undefined ? { tenantId } : {}),
|
||||
},
|
||||
include: {
|
||||
users: {
|
||||
include: {
|
||||
...UserModelHelper.includeSimpleUser,
|
||||
},
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function createGroup(data: { createdByUserId: string; tenantId: string | null; name: string; description: string; color: number }) {
|
||||
return await db.group.create({
|
||||
data,
|
||||
});
|
||||
}
|
||||
|
||||
export async function updateGroup(id: string, data: { name: string; description: string; color: number }, tenantId?: string | null) {
|
||||
if (tenantId !== undefined) {
|
||||
return await db.group.updateMany({
|
||||
where: {
|
||||
id,
|
||||
tenantId,
|
||||
},
|
||||
data,
|
||||
});
|
||||
}
|
||||
return await db.group.update({
|
||||
where: {
|
||||
id,
|
||||
},
|
||||
data,
|
||||
});
|
||||
}
|
||||
|
||||
export async function deleteGroup(id: string, tenantId?: string | null) {
|
||||
if (tenantId !== undefined) {
|
||||
return await db.group.deleteMany({
|
||||
where: {
|
||||
id,
|
||||
tenantId,
|
||||
},
|
||||
});
|
||||
}
|
||||
return await db.group.delete({
|
||||
where: {
|
||||
id,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
// R-P2b — Gruppen-Bulk-Ops (N:M). Idempotent: createMany skipDuplicates stuetzt sich auf den
|
||||
// Unique-Index [groupId, userId], doppelte Mitgliedschaften werden uebersprungen.
|
||||
export async function addUsersToGroup(groupId: string, userIds: string[]) {
|
||||
if (userIds.length === 0) {
|
||||
return { count: 0 };
|
||||
}
|
||||
return await db.groupUser.createMany({
|
||||
data: userIds.map((userId) => ({ groupId, userId })),
|
||||
skipDuplicates: true,
|
||||
});
|
||||
}
|
||||
|
||||
export async function removeUsersFromGroup(groupId: string, userIds: string[]) {
|
||||
if (userIds.length === 0) {
|
||||
return { count: 0 };
|
||||
}
|
||||
return await db.groupUser.deleteMany({
|
||||
where: { groupId, userId: { in: userIds } },
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,207 @@
|
||||
// @vitest-environment node
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
|
||||
vi.mock("../../db.server", () => ({
|
||||
db: {
|
||||
permission: {
|
||||
aggregate: vi.fn(),
|
||||
delete: vi.fn(),
|
||||
deleteMany: vi.fn(),
|
||||
findMany: vi.fn(),
|
||||
findUnique: vi.fn(),
|
||||
create: vi.fn(),
|
||||
update: 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("~/utils/cache.server", () => ({ cachified: vi.fn(), clearCacheKey: vi.fn() }));
|
||||
vi.mock("~/utils/helpers/PermissionsHelper", () => ({ getEntityPermissions: vi.fn() }));
|
||||
vi.mock("~/utils/helpers/RowFiltersHelper", () => ({ default: { getFiltersCondition: vi.fn() } }));
|
||||
|
||||
import { cachified, clearCacheKey } from "~/utils/cache.server";
|
||||
import { getEntityPermissions } from "~/utils/helpers/PermissionsHelper";
|
||||
import RowFiltersHelper from "~/utils/helpers/RowFiltersHelper";
|
||||
import { db } from "../../db.server";
|
||||
import { createRolePermission, getAllRolePermissions } from "./rolePermissions.db.server";
|
||||
import { getAllRolesNames, getRoleByName } from "./roles.db.server";
|
||||
import {
|
||||
createEntityPermissions,
|
||||
createPermissions,
|
||||
deleteEntityPermissions,
|
||||
deletePermission,
|
||||
getAllPermissions,
|
||||
getAllPermissionsIdsAndNames,
|
||||
getNextPermissionsOrder,
|
||||
getPermission,
|
||||
getPermissionByName,
|
||||
getPermissionByNames,
|
||||
getPermissionName,
|
||||
updatePermission,
|
||||
} from "./permissions.db.server";
|
||||
|
||||
describe("permission persistence", () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
vi.mocked(cachified).mockImplementation((async (options: { getFreshValue: () => unknown }) =>
|
||||
options.getFreshValue()) as never);
|
||||
});
|
||||
|
||||
it("lists permissions with filters, role filters, and type constraints", async () => {
|
||||
vi.mocked(RowFiltersHelper.getFiltersCondition).mockReturnValue({ name: { contains: "admin" } } as never);
|
||||
vi.mocked(db.permission.findMany).mockResolvedValueOnce([] as never);
|
||||
|
||||
await getAllPermissions("admin", {
|
||||
properties: [{ name: "roleId", value: "role_1" }],
|
||||
} as never);
|
||||
|
||||
expect(db.permission.findMany).toHaveBeenCalledWith({
|
||||
where: {
|
||||
AND: ["admin", { OR: [{ name: { contains: "admin" } }, { inRoles: { some: { roleId: "role_1" } } }] }],
|
||||
},
|
||||
include: { inRoles: { include: { role: true } } },
|
||||
orderBy: [{ type: "asc" }, { name: "asc" }],
|
||||
});
|
||||
});
|
||||
|
||||
it("queries permission lookup variants and cached permission names", async () => {
|
||||
vi.mocked(db.permission.findMany).mockResolvedValue([] as never);
|
||||
vi.mocked(db.permission.findUnique).mockResolvedValue({ id: "permission_1" } as never);
|
||||
|
||||
await getAllPermissionsIdsAndNames();
|
||||
await getPermission("permission_1");
|
||||
await getPermissionByName("admin.users.view");
|
||||
await getPermissionName("admin.users.view");
|
||||
await getPermissionByNames(["admin.users.view", "admin.users.edit"]);
|
||||
|
||||
expect(db.permission.findMany).toHaveBeenNthCalledWith(1, {
|
||||
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(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"] } } })
|
||||
);
|
||||
});
|
||||
|
||||
it("calculates the next permission order with and without a type filter", async () => {
|
||||
vi.mocked(db.permission.aggregate)
|
||||
.mockResolvedValueOnce({ _max: { order: 4 } } as never)
|
||||
.mockResolvedValueOnce({ _max: { order: null } } as never);
|
||||
|
||||
await expect(getNextPermissionsOrder("admin")).resolves.toBe(5);
|
||||
await expect(getNextPermissionsOrder()).resolves.toBe(1);
|
||||
|
||||
expect(db.permission.aggregate).toHaveBeenNthCalledWith(1, { where: { type: "admin" }, _max: { order: true } });
|
||||
expect(db.permission.aggregate).toHaveBeenNthCalledWith(2, { where: {}, _max: { order: true } });
|
||||
});
|
||||
|
||||
it("repairs role links for existing permissions instead of returning early", async () => {
|
||||
vi.mocked(db.permission.findMany).mockResolvedValue([{ id: "permission_1", name: "admin.users.view" }] as never);
|
||||
vi.mocked(getAllRolePermissions).mockResolvedValue([]);
|
||||
vi.mocked(getRoleByName).mockResolvedValue({ id: "role_1", name: "SuperAdmin" } as never);
|
||||
vi.mocked(createRolePermission).mockResolvedValue({ id: "role_permission_1" } as never);
|
||||
|
||||
await createPermissions([{ name: "admin.users.view", description: "View users", type: "admin", inRoles: ["SuperAdmin"] }]);
|
||||
|
||||
expect(db.permission.create).not.toHaveBeenCalled();
|
||||
expect(createRolePermission).toHaveBeenCalledWith({ permissionId: "permission_1", roleId: "role_1" });
|
||||
});
|
||||
|
||||
it("clears the permission lookup cache after creating a previously missing permission", async () => {
|
||||
vi.mocked(db.permission.findMany).mockResolvedValue([]);
|
||||
vi.mocked(db.permission.create).mockResolvedValue({ id: "permission_1", name: "admin.users.view" } as never);
|
||||
vi.mocked(getAllRolePermissions).mockResolvedValue([]);
|
||||
vi.mocked(getRoleByName).mockResolvedValue({ id: "role_1", name: "SuperAdmin" } as never);
|
||||
vi.mocked(createRolePermission).mockResolvedValue({ id: "role_permission_1" } as never);
|
||||
|
||||
await createPermissions([{ name: "admin.users.view", description: "View users", type: "admin", inRoles: ["SuperAdmin"] }]);
|
||||
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("permission:admin.users.view");
|
||||
expect(createRolePermission).toHaveBeenCalledWith({ permissionId: "permission_1", roleId: "role_1" });
|
||||
});
|
||||
|
||||
it("skips duplicate permission inputs after creating the first instance", async () => {
|
||||
vi.mocked(db.permission.findMany).mockResolvedValue([]);
|
||||
vi.mocked(db.permission.create).mockResolvedValue({ id: "permission_1", name: "admin.users.view" } as never);
|
||||
vi.mocked(getAllRolePermissions).mockResolvedValue([]);
|
||||
vi.mocked(getRoleByName).mockResolvedValue({ id: "role_1", name: "SuperAdmin" } as never);
|
||||
|
||||
await createPermissions([
|
||||
{ name: "admin.users.view", description: "View users", type: "admin", inRoles: ["SuperAdmin"] },
|
||||
{ name: "admin.users.view", description: "View users", type: "admin", inRoles: ["SuperAdmin"] },
|
||||
]);
|
||||
|
||||
expect(db.permission.create).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it("throws when a requested role link cannot be resolved", async () => {
|
||||
vi.mocked(db.permission.findMany).mockResolvedValue([]);
|
||||
vi.mocked(db.permission.create).mockResolvedValue({ id: "permission_1", name: "admin.users.view" } as never);
|
||||
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");
|
||||
});
|
||||
|
||||
it("updates and deletes permissions while clearing the permission cache", async () => {
|
||||
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);
|
||||
|
||||
await updatePermission("permission_1", { name: "admin.users.view" });
|
||||
await deletePermission("permission_1");
|
||||
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("permission:admin.users.view");
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("permission:admin.users.delete");
|
||||
});
|
||||
|
||||
it("deletes entity permissions only when generated permission names exist", async () => {
|
||||
vi.mocked(getEntityPermissions)
|
||||
.mockResolvedValueOnce([{ name: "entity.view" }, { name: "entity.edit" }] as never)
|
||||
.mockResolvedValueOnce([] as never);
|
||||
vi.mocked(db.permission.deleteMany).mockResolvedValueOnce({ count: 2 } as never);
|
||||
|
||||
await expect(deleteEntityPermissions({ id: "entity_1" } as never)).resolves.toEqual({ count: 2 });
|
||||
await expect(deleteEntityPermissions({ id: "entity_1" } as never)).resolves.toBeUndefined();
|
||||
|
||||
expect(db.permission.deleteMany).toHaveBeenCalledTimes(1);
|
||||
expect(db.permission.deleteMany).toHaveBeenCalledWith({
|
||||
where: { name: { in: ["entity.view", "entity.edit"] } },
|
||||
});
|
||||
});
|
||||
|
||||
it("creates entity permissions for every generated permission and all app roles", async () => {
|
||||
vi.mocked(getAllRolesNames).mockResolvedValue([{ id: "role_1", name: "Member" }] as never);
|
||||
vi.mocked(getEntityPermissions).mockResolvedValue([{ name: "entity.view", description: "View entity" }] as never);
|
||||
vi.mocked(getAllRolePermissions).mockResolvedValue([]);
|
||||
vi.mocked(db.permission.findMany).mockResolvedValue([]);
|
||||
vi.mocked(db.permission.create).mockResolvedValue({ id: "permission_1", name: "entity.view" } as never);
|
||||
vi.mocked(getRoleByName).mockResolvedValue({ id: "role_1", name: "Member" } as never);
|
||||
|
||||
await createEntityPermissions({ id: "entity_1" } as never);
|
||||
|
||||
expect(db.permission.create).toHaveBeenCalledWith({
|
||||
data: {
|
||||
order: 2,
|
||||
name: "entity.view",
|
||||
description: "View entity",
|
||||
type: "app",
|
||||
isDefault: true,
|
||||
entityId: "entity_1",
|
||||
},
|
||||
});
|
||||
expect(createRolePermission).toHaveBeenCalledWith({ permissionId: "permission_1", roleId: "role_1" });
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,254 @@
|
||||
import { db } from "../../db.server";
|
||||
import { Entity, Permission, Role, RolePermission } from "@toolctrl/db/prisma-browser";
|
||||
import { getAllRolesNames, getRoleByName } from "./roles.db.server";
|
||||
import { createRolePermission, getAllRolePermissions } from "./rolePermissions.db.server";
|
||||
import RowFiltersHelper from "~/utils/helpers/RowFiltersHelper";
|
||||
import { FiltersDto } from "~/application/dtos/data/FiltersDto";
|
||||
import { getEntityPermissions } from "~/utils/helpers/PermissionsHelper";
|
||||
import { cachified, clearCacheKey } from "~/utils/cache.server";
|
||||
import { createScopedLogger } from "~/utils/logger.server";
|
||||
|
||||
const permissionsLogger = createScopedLogger("db.permissions");
|
||||
|
||||
export type PermissionWithRoles = Permission & {
|
||||
inRoles: (RolePermission & { role: Role })[];
|
||||
};
|
||||
|
||||
export async function getAllPermissions(type?: string, filters?: FiltersDto): Promise<PermissionWithRoles[]> {
|
||||
let where: any = {
|
||||
type,
|
||||
};
|
||||
if (filters) {
|
||||
where = RowFiltersHelper.getFiltersCondition(filters);
|
||||
const roleId = filters?.properties.find((f) => f.name === "roleId")?.value;
|
||||
if (roleId) {
|
||||
where = {
|
||||
OR: [where, { inRoles: { some: { roleId } } }],
|
||||
};
|
||||
}
|
||||
if (type !== undefined) {
|
||||
where = {
|
||||
AND: [type, where],
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
return await db.permission.findMany({
|
||||
where,
|
||||
include: {
|
||||
inRoles: {
|
||||
include: {
|
||||
role: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
orderBy: [{ type: "asc" }, { name: "asc" }],
|
||||
});
|
||||
}
|
||||
|
||||
export async function getAllPermissionsIdsAndNames(): Promise<{ id: string; name: string }[]> {
|
||||
return await db.permission.findMany({
|
||||
select: { id: true, name: true },
|
||||
orderBy: { name: "asc" },
|
||||
});
|
||||
}
|
||||
|
||||
export async function getPermission(id: string): Promise<PermissionWithRoles | null> {
|
||||
return await db.permission.findUnique({
|
||||
where: {
|
||||
id,
|
||||
},
|
||||
include: {
|
||||
inRoles: {
|
||||
include: {
|
||||
role: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function getPermissionByName(name: string): Promise<PermissionWithRoles | null> {
|
||||
return await db.permission.findUnique({
|
||||
where: {
|
||||
name,
|
||||
},
|
||||
include: {
|
||||
inRoles: {
|
||||
include: {
|
||||
role: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function getPermissionName(name: string): Promise<{ id: string; name: string; description: string } | null> {
|
||||
return await cachified({
|
||||
key: `permission:${name}`,
|
||||
ttl: 1000 * 60 * 60 * 24,
|
||||
getFreshValue: () =>
|
||||
db.permission.findUnique({
|
||||
where: {
|
||||
name,
|
||||
},
|
||||
select: { id: true, name: true, description: true },
|
||||
}),
|
||||
});
|
||||
}
|
||||
|
||||
export async function getPermissionByNames(names: string[]): Promise<PermissionWithRoles[]> {
|
||||
return await db.permission.findMany({
|
||||
where: {
|
||||
name: {
|
||||
in: names,
|
||||
},
|
||||
},
|
||||
include: {
|
||||
inRoles: {
|
||||
include: {
|
||||
role: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function getNextPermissionsOrder(type?: string): Promise<number> {
|
||||
let where = {};
|
||||
if (type !== undefined) {
|
||||
where = {
|
||||
type,
|
||||
};
|
||||
}
|
||||
return (
|
||||
((
|
||||
await db.permission.aggregate({
|
||||
where,
|
||||
_max: {
|
||||
order: true,
|
||||
},
|
||||
})
|
||||
)._max.order ?? 0) + 1
|
||||
);
|
||||
}
|
||||
|
||||
export async function createPermissions(
|
||||
permissions: { inRoles: string[]; name: string; description: string; type: string; entityId?: string | null }[],
|
||||
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]));
|
||||
const createdPermissionNames = new Set<string>();
|
||||
for (const [idx, data] of permissions.entries()) {
|
||||
const existing = permissionByName.get(data.name);
|
||||
if (createdPermissionNames.has(data.name)) {
|
||||
permissionsLogger.info({ permission: data.name }, "Permission already exists");
|
||||
continue;
|
||||
}
|
||||
const permission =
|
||||
existing ??
|
||||
(await createPermission({
|
||||
order: fromOrder + idx + 1,
|
||||
name: data.name,
|
||||
description: data.description,
|
||||
type: data.type,
|
||||
isDefault: true,
|
||||
entityId: data.entityId ?? null,
|
||||
}));
|
||||
createdPermissionNames.add(permission.name);
|
||||
if (existing) {
|
||||
permissionsLogger.info({ permission: data.name }, "Permission already exists");
|
||||
} else {
|
||||
permissionByName.set(permission.name, permission);
|
||||
clearCacheKey(`permission:${permission.name}`);
|
||||
}
|
||||
|
||||
await Promise.all(
|
||||
data.inRoles.map(async (inRole) => {
|
||||
const role = await getRoleByName(inRole);
|
||||
if (!role) {
|
||||
throw new Error("Role required: " + inRole);
|
||||
}
|
||||
const existing = allRolePermissions.find((p) => p.roleId === role.id && p.permission.name === permission.name);
|
||||
if (existing) {
|
||||
return existing;
|
||||
}
|
||||
return await createRolePermission({
|
||||
permissionId: permission.id,
|
||||
roleId: role.id,
|
||||
});
|
||||
})
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
export async function createPermission(data: { order: number; name: string; description: string; type: string; isDefault: boolean; entityId: string | null }) {
|
||||
return await db.permission.create({
|
||||
data,
|
||||
});
|
||||
}
|
||||
|
||||
export async function updatePermission(
|
||||
id: string,
|
||||
data: {
|
||||
name?: string;
|
||||
description?: string;
|
||||
type?: string;
|
||||
order?: number;
|
||||
}
|
||||
) {
|
||||
return await db.permission
|
||||
.update({
|
||||
where: { id },
|
||||
data,
|
||||
})
|
||||
.then((item) => {
|
||||
clearCacheKey(`permission:${item.name}`);
|
||||
return item;
|
||||
});
|
||||
}
|
||||
|
||||
export async function deletePermission(id: string) {
|
||||
return await db.permission
|
||||
.delete({
|
||||
where: { id },
|
||||
})
|
||||
.then((item) => {
|
||||
clearCacheKey(`permission:${item.name}`);
|
||||
return item;
|
||||
});
|
||||
}
|
||||
|
||||
export async function deleteEntityPermissions(entity: Entity) {
|
||||
const entityPermissions = await getEntityPermissions(entity);
|
||||
const names = entityPermissions.map((p) => p.name);
|
||||
if (names.length > 0) {
|
||||
return await db.permission.deleteMany({
|
||||
where: {
|
||||
name: {
|
||||
in: names,
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
export async function createEntityPermissions(entity: Entity) {
|
||||
const allUserRoles = await getAllRolesNames();
|
||||
// const assignToAllUserRoles = allUserRoles.filter((f) => f.assignToNewUsers);
|
||||
const entityPermissions = await getEntityPermissions(entity);
|
||||
await Promise.all(
|
||||
entityPermissions.map(async (permission, idx) => {
|
||||
const entityPermission = {
|
||||
inRoles: allUserRoles.map((f) => f.name),
|
||||
name: permission.name,
|
||||
description: permission.description,
|
||||
type: "app",
|
||||
entityId: entity.id,
|
||||
};
|
||||
return await createPermissions([entityPermission], allUserRoles.length + idx);
|
||||
})
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,157 @@
|
||||
// @vitest-environment node
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
|
||||
vi.mock("../../db.server", () => ({
|
||||
db: {
|
||||
role: {
|
||||
findUnique: vi.fn(),
|
||||
findMany: vi.fn(),
|
||||
},
|
||||
permission: {
|
||||
findMany: vi.fn(),
|
||||
},
|
||||
rolePermission: {
|
||||
create: vi.fn(),
|
||||
createMany: vi.fn(),
|
||||
delete: vi.fn(),
|
||||
deleteMany: vi.fn(),
|
||||
findFirst: vi.fn(),
|
||||
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() }));
|
||||
|
||||
import { clearCacheKey } from "~/utils/cache.server";
|
||||
import { adminGetAllTenants } from "../tenants.db.server";
|
||||
import { adminGetAllUsersNames } from "../users.db.server";
|
||||
import { db } from "../../db.server";
|
||||
import {
|
||||
createRolePermission,
|
||||
deleteRolePermission,
|
||||
deleteRolePermissionById,
|
||||
getAllRolePermissions,
|
||||
setPermissionRoles,
|
||||
setRolePermissions,
|
||||
} from "./rolePermissions.db.server";
|
||||
|
||||
describe("role permission persistence", () => {
|
||||
const dbMock = vi.mocked(db);
|
||||
const findRoleByIdMock = vi.mocked(dbMock.role.findUnique);
|
||||
const findPermissionsMock = vi.mocked(dbMock.permission.findMany);
|
||||
const findRolesMock = vi.mocked(dbMock.role.findMany);
|
||||
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
dbMock.$transaction.mockImplementation(async (callback: (tx: typeof dbMock) => Promise<unknown>) => callback(dbMock));
|
||||
vi.mocked(adminGetAllTenants).mockResolvedValue([]);
|
||||
vi.mocked(adminGetAllUsersNames).mockResolvedValue([]);
|
||||
});
|
||||
|
||||
it("sets role permissions inside one awaited transaction before clearing caches", async () => {
|
||||
findRoleByIdMock.mockResolvedValue({ id: "role_1", name: "Editor", type: "app" } as never);
|
||||
findPermissionsMock.mockResolvedValue([{ id: "permission_a" }, { id: "permission_b" }] as never);
|
||||
|
||||
await setRolePermissions("role_1", ["settings.update", "settings.update", "members.read"]);
|
||||
|
||||
expect(dbMock.permission.findMany).toHaveBeenCalledWith({
|
||||
where: { name: { in: ["settings.update", "members.read"] } },
|
||||
select: { id: true },
|
||||
});
|
||||
expect(dbMock.$transaction).toHaveBeenCalledTimes(1);
|
||||
expect(dbMock.rolePermission.deleteMany).toHaveBeenCalledWith({ where: { roleId: "role_1" } });
|
||||
expect(dbMock.rolePermission.createMany).toHaveBeenCalledWith({
|
||||
data: [
|
||||
{ roleId: "role_1", permissionId: "permission_a" },
|
||||
{ roleId: "role_1", permissionId: "permission_b" },
|
||||
],
|
||||
});
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("roles:app");
|
||||
});
|
||||
|
||||
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.create.mockResolvedValueOnce({ id: "rp_created" } as never);
|
||||
|
||||
await expect(getAllRolePermissions()).resolves.toEqual([{ id: "rp_1" }]);
|
||||
await expect(createRolePermission({ roleId: "role_1", permissionId: "permission_1" })).resolves.toEqual({ id: "rp_existing" });
|
||||
await expect(createRolePermission({ roleId: "role_1", permissionId: "permission_2" })).resolves.toEqual({ id: "rp_created" });
|
||||
|
||||
expect(dbMock.rolePermission.create).toHaveBeenCalledTimes(1);
|
||||
expect(dbMock.rolePermission.create).toHaveBeenCalledWith({ data: { roleId: "role_1", permissionId: "permission_2" } });
|
||||
});
|
||||
|
||||
it("returns early when setting permissions for a missing role", async () => {
|
||||
findRoleByIdMock.mockResolvedValueOnce(null);
|
||||
|
||||
await setRolePermissions("role_missing", ["settings.update"]);
|
||||
|
||||
expect(dbMock.permission.findMany).not.toHaveBeenCalled();
|
||||
expect(dbMock.$transaction).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("clears app role user caches across tenants and user-role lookup caches", 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" }] },
|
||||
] 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");
|
||||
});
|
||||
|
||||
it("sets permission roles inside one awaited transaction", async () => {
|
||||
findRolesMock.mockResolvedValue([{ id: "role_a" }, { id: "role_b" }] as never);
|
||||
|
||||
await setPermissionRoles("permission_1", ["Admin", "Admin", "Member"]);
|
||||
|
||||
expect(dbMock.role.findMany).toHaveBeenCalledWith({
|
||||
where: { name: { in: ["Admin", "Member"] } },
|
||||
select: { id: true },
|
||||
});
|
||||
expect(dbMock.$transaction).toHaveBeenCalledTimes(1);
|
||||
expect(dbMock.rolePermission.deleteMany).toHaveBeenCalledWith({ where: { permissionId: "permission_1" } });
|
||||
expect(dbMock.rolePermission.createMany).toHaveBeenCalledWith({
|
||||
data: [
|
||||
{ roleId: "role_a", permissionId: "permission_1" },
|
||||
{ roleId: "role_b", permissionId: "permission_1" },
|
||||
],
|
||||
});
|
||||
});
|
||||
|
||||
it("clears permission role links without creating rows when role list is empty", async () => {
|
||||
await setPermissionRoles("permission_1", []);
|
||||
|
||||
expect(dbMock.role.findMany).not.toHaveBeenCalled();
|
||||
expect(dbMock.$transaction).toHaveBeenCalledTimes(1);
|
||||
expect(dbMock.rolePermission.deleteMany).toHaveBeenCalledWith({ where: { permissionId: "permission_1" } });
|
||||
expect(dbMock.rolePermission.createMany).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("deletes role-permission links by composite keys or id", async () => {
|
||||
dbMock.rolePermission.deleteMany.mockResolvedValueOnce({ count: 1 } as never);
|
||||
dbMock.rolePermission.delete.mockResolvedValueOnce({ id: "rp_1" } as never);
|
||||
|
||||
await expect(deleteRolePermission("role_1", "permission_1")).resolves.toEqual({ count: 1 });
|
||||
await expect(deleteRolePermissionById("rp_1")).resolves.toEqual({ id: "rp_1" });
|
||||
|
||||
expect(dbMock.rolePermission.deleteMany).toHaveBeenCalledWith({ where: { roleId: "role_1", permissionId: "permission_1" } });
|
||||
expect(dbMock.rolePermission.delete).toHaveBeenCalledWith({ where: { id: "rp_1" } });
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,113 @@
|
||||
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";
|
||||
|
||||
const rolePermissionsLogger = createScopedLogger("db.rolePermissions");
|
||||
|
||||
export async function getAllRolePermissions() {
|
||||
return await db.rolePermission.findMany({
|
||||
include: {
|
||||
permission: true,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function createRolePermission(data: { roleId: string; permissionId: string }) {
|
||||
const existing = await db.rolePermission.findFirst({
|
||||
where: {
|
||||
roleId: data.roleId,
|
||||
permissionId: data.permissionId,
|
||||
},
|
||||
});
|
||||
if (existing) {
|
||||
return existing;
|
||||
}
|
||||
return await db.rolePermission.create({
|
||||
data,
|
||||
});
|
||||
}
|
||||
|
||||
export async function setRolePermissions(roleId: string, permissionNames: string[]) {
|
||||
const role = await db.role.findUnique({ where: { id: roleId } });
|
||||
if (!role) {
|
||||
return;
|
||||
}
|
||||
|
||||
const uniquePermissionNames = [...new Set(permissionNames)];
|
||||
const permissions = uniquePermissionNames.length
|
||||
? await db.permission.findMany({
|
||||
where: { name: { in: uniquePermissionNames } },
|
||||
select: { id: true },
|
||||
})
|
||||
: [];
|
||||
|
||||
await db.$transaction(async (tx) => {
|
||||
await tx.rolePermission.deleteMany({
|
||||
where: { roleId },
|
||||
});
|
||||
|
||||
if (permissions.length > 0) {
|
||||
await tx.rolePermission.createMany({
|
||||
data: permissions.map((permission) => ({
|
||||
roleId,
|
||||
permissionId: permission.id,
|
||||
})),
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
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}`);
|
||||
}
|
||||
}
|
||||
|
||||
export async function setPermissionRoles(permissionId: string, roleNames: string[]) {
|
||||
const uniqueRoleNames = [...new Set(roleNames)];
|
||||
const roles = uniqueRoleNames.length
|
||||
? await db.role.findMany({
|
||||
where: { name: { in: uniqueRoleNames } },
|
||||
select: { id: true },
|
||||
})
|
||||
: [];
|
||||
|
||||
await db.$transaction(async (tx) => {
|
||||
await tx.rolePermission.deleteMany({
|
||||
where: { permissionId },
|
||||
});
|
||||
|
||||
if (roles.length > 0) {
|
||||
await tx.rolePermission.createMany({
|
||||
data: roles.map((role) => ({
|
||||
roleId: role.id,
|
||||
permissionId,
|
||||
})),
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
export async function deleteRolePermission(roleId: string, permissionId: string) {
|
||||
return await db.rolePermission.deleteMany({
|
||||
where: { roleId, permissionId },
|
||||
});
|
||||
}
|
||||
|
||||
export async function deleteRolePermissionById(id: string) {
|
||||
return await db.rolePermission.delete({
|
||||
where: { id },
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,215 @@
|
||||
// @vitest-environment node
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
|
||||
vi.mock("../../db.server", () => ({
|
||||
db: {
|
||||
role: {
|
||||
aggregate: vi.fn(),
|
||||
create: vi.fn(),
|
||||
delete: vi.fn(),
|
||||
findFirst: vi.fn(),
|
||||
findMany: vi.fn(),
|
||||
findUnique: vi.fn(),
|
||||
update: 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 {
|
||||
createRole,
|
||||
deleteRole,
|
||||
getAllRoles,
|
||||
getAllRolesNames,
|
||||
getAllRolesWithoutPermissions,
|
||||
getAllRolesWithUsers,
|
||||
getNextRolesOrder,
|
||||
getRole,
|
||||
getRoleByName,
|
||||
getRoles,
|
||||
getRolesByName,
|
||||
getTenantAppRoleByName,
|
||||
getTenantAssignableAppRole,
|
||||
getTenantMutableAppRole,
|
||||
updateRole,
|
||||
} from "./roles.db.server";
|
||||
|
||||
const dbMock = vi.mocked(db);
|
||||
|
||||
describe("role persistence", () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
vi.mocked(cachified).mockImplementation((async (options: { getFreshValue: () => unknown }) =>
|
||||
options.getFreshValue()) as never);
|
||||
});
|
||||
|
||||
it("lists global roles with permissions and supports type filtering", async () => {
|
||||
vi.mocked(dbMock.role.findMany).mockResolvedValue([] as never);
|
||||
|
||||
await getAllRoles();
|
||||
await getAllRoles("admin");
|
||||
await getAllRolesNames();
|
||||
|
||||
expect(dbMock.role.findMany).toHaveBeenNthCalledWith(
|
||||
1,
|
||||
expect.objectContaining({
|
||||
where: {},
|
||||
include: { permissions: { include: { permission: true }, orderBy: { permission: { name: "asc" } } } },
|
||||
orderBy: [{ type: "asc" }, { order: "asc" }],
|
||||
})
|
||||
);
|
||||
expect(dbMock.role.findMany).toHaveBeenNthCalledWith(
|
||||
2,
|
||||
expect.objectContaining({
|
||||
where: { type: "admin", tenantId: null },
|
||||
include: { permissions: { include: { permission: true }, orderBy: { permission: { name: "asc" } } } },
|
||||
})
|
||||
);
|
||||
expect(dbMock.role.findMany).toHaveBeenNthCalledWith(3, { select: { id: true, name: true }, orderBy: [{ type: "asc" }, { order: "asc" }] });
|
||||
});
|
||||
|
||||
it("caches role lists without permissions", async () => {
|
||||
vi.mocked(dbMock.role.findMany).mockResolvedValue([{ id: "role_1" }] as never);
|
||||
|
||||
await expect(getAllRolesWithoutPermissions("app")).resolves.toEqual([{ id: "role_1" }]);
|
||||
await expect(getAllRolesWithoutPermissions()).resolves.toEqual([{ id: "role_1" }]);
|
||||
|
||||
expect(cachified).toHaveBeenNthCalledWith(1, expect.objectContaining({ key: "roles:app", ttl: 1000 * 60 * 60 * 24 }));
|
||||
expect(cachified).toHaveBeenNthCalledWith(2, expect.objectContaining({ key: "roles:undefined", ttl: 1000 * 60 * 60 * 24 }));
|
||||
expect(dbMock.role.findMany).toHaveBeenNthCalledWith(1, {
|
||||
where: { type: "app", tenantId: null },
|
||||
orderBy: [{ type: "asc" }, { order: "asc" }],
|
||||
});
|
||||
expect(dbMock.role.findMany).toHaveBeenNthCalledWith(2, {
|
||||
where: {},
|
||||
orderBy: [{ type: "asc" }, { order: "asc" }],
|
||||
});
|
||||
});
|
||||
|
||||
it("lists roles with users using tenant scope and permission filters", async () => {
|
||||
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"
|
||||
);
|
||||
|
||||
expect(dbMock.role.findMany).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
where: {
|
||||
AND: [
|
||||
{ type: "app", OR: [{ tenantId: null }, { tenantId: "tenant_1" }] },
|
||||
{ OR: [{ name: { contains: "editor" } }, { permissions: { some: { permissionId: "permission_1" } } }] },
|
||||
],
|
||||
},
|
||||
include: expect.objectContaining({
|
||||
permissions: { include: { permission: true }, orderBy: { permission: { name: "asc" } } },
|
||||
users: expect.objectContaining({ where: { tenantId: "tenant_1" } }),
|
||||
}),
|
||||
orderBy: [{ type: "asc" }, { order: "asc" }],
|
||||
})
|
||||
);
|
||||
});
|
||||
|
||||
it("lists global roles with users when filters do not target a permission", async () => {
|
||||
vi.mocked(RowFiltersHelper.getFiltersCondition).mockReturnValue({ name: { contains: "member" } } as never);
|
||||
vi.mocked(dbMock.role.findMany).mockResolvedValueOnce([] as never);
|
||||
|
||||
await getAllRolesWithUsers("app", { properties: [{ name: "name", value: "member" }] } as never);
|
||||
|
||||
expect(dbMock.role.findMany).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
where: {
|
||||
AND: [{ type: "app", tenantId: null }, { name: { contains: "member" } }],
|
||||
},
|
||||
include: expect.objectContaining({
|
||||
users: expect.not.objectContaining({ where: expect.anything() }),
|
||||
}),
|
||||
})
|
||||
);
|
||||
});
|
||||
|
||||
it("queries role lookup variants with permission and user details", async () => {
|
||||
vi.mocked(dbMock.role.findMany).mockResolvedValue([] as never);
|
||||
vi.mocked(dbMock.role.findUnique).mockResolvedValue({ id: "role_1" } as never);
|
||||
vi.mocked(dbMock.role.findFirst).mockResolvedValue({ id: "role_1" } as never);
|
||||
|
||||
await getRoles(["role_1"]);
|
||||
await getRolesByName(["Admin", "Member"]);
|
||||
await getRole("role_1");
|
||||
await getTenantAssignableAppRole("role_1", "tenant_1");
|
||||
await getTenantMutableAppRole("role_1", "tenant_1");
|
||||
await getRoleByName("Admin");
|
||||
await getTenantAppRoleByName("Support", "tenant_1");
|
||||
|
||||
expect(dbMock.role.findMany).toHaveBeenNthCalledWith(1, expect.objectContaining({ where: { id: { in: ["role_1"] } } }));
|
||||
expect(dbMock.role.findMany).toHaveBeenNthCalledWith(2, expect.objectContaining({ where: { name: { in: ["Admin", "Member"] } } }));
|
||||
expect(dbMock.role.findUnique).toHaveBeenCalledWith(expect.objectContaining({ where: { id: "role_1" } }));
|
||||
expect(dbMock.role.findFirst).toHaveBeenNthCalledWith(
|
||||
1,
|
||||
expect.objectContaining({ where: { id: "role_1", type: "app", OR: [{ isDefault: true, tenantId: null }, { tenantId: "tenant_1" }] } })
|
||||
);
|
||||
expect(dbMock.role.findFirst).toHaveBeenNthCalledWith(
|
||||
2,
|
||||
expect.objectContaining({ where: { id: "role_1", type: "app", isDefault: false, tenantId: "tenant_1" } })
|
||||
);
|
||||
expect(dbMock.role.findFirst).toHaveBeenNthCalledWith(3, expect.objectContaining({ where: { name: "Admin", tenantId: null } }));
|
||||
expect(dbMock.role.findFirst).toHaveBeenNthCalledWith(4, expect.objectContaining({ where: { name: "Support", tenantId: "tenant_1", type: "app" } }));
|
||||
});
|
||||
|
||||
it("calculates next role order for global and tenant-scoped roles", async () => {
|
||||
vi.mocked(dbMock.role.aggregate)
|
||||
.mockResolvedValueOnce({ _max: { order: 4 } } as never)
|
||||
.mockResolvedValueOnce({ _max: { order: null } } as never);
|
||||
|
||||
await expect(getNextRolesOrder("app", "tenant_1")).resolves.toBe(5);
|
||||
await expect(getNextRolesOrder()).resolves.toBe(1);
|
||||
|
||||
expect(dbMock.role.aggregate).toHaveBeenNthCalledWith(1, { where: { type: "app", tenantId: "tenant_1" }, _max: { order: true } });
|
||||
expect(dbMock.role.aggregate).toHaveBeenNthCalledWith(2, { where: {}, _max: { order: true } });
|
||||
});
|
||||
|
||||
it("clears role-list caches after create, update, and delete mutations", async () => {
|
||||
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);
|
||||
|
||||
await createRole({
|
||||
order: 1,
|
||||
name: "Support",
|
||||
description: "Support role",
|
||||
type: "app",
|
||||
assignToNewUsers: false,
|
||||
isDefault: false,
|
||||
tenantId: "tenant_1",
|
||||
});
|
||||
await updateRole("role_1", { name: "Admin", description: "Admin role", type: "admin", assignToNewUsers: true });
|
||||
await deleteRole("role_1");
|
||||
|
||||
expect(dbMock.role.create).toHaveBeenCalledWith({
|
||||
data: {
|
||||
order: 1,
|
||||
name: "Support",
|
||||
description: "Support role",
|
||||
type: "app",
|
||||
assignToNewUsers: false,
|
||||
isDefault: false,
|
||||
tenantId: "tenant_1",
|
||||
},
|
||||
});
|
||||
expect(dbMock.role.update).toHaveBeenCalledWith({
|
||||
where: { id: "role_1" },
|
||||
data: { name: "Admin", description: "Admin role", type: "admin", assignToNewUsers: true },
|
||||
});
|
||||
expect(dbMock.role.delete).toHaveBeenCalledWith({ where: { id: "role_1" } });
|
||||
expect(clearCacheKey).toHaveBeenNthCalledWith(1, "roles:app");
|
||||
expect(clearCacheKey).toHaveBeenNthCalledWith(2, "roles:admin");
|
||||
expect(clearCacheKey).toHaveBeenNthCalledWith(3, "roles:app");
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,316 @@
|
||||
import { db } from "../../db.server";
|
||||
import { Permission, Role, RolePermission, UserRole } from "@toolctrl/db/prisma-browser";
|
||||
import { FiltersDto } from "~/application/dtos/data/FiltersDto";
|
||||
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";
|
||||
|
||||
export type RoleWithPermissions = Role & {
|
||||
permissions: (RolePermission & { permission: Permission })[];
|
||||
};
|
||||
|
||||
export type RoleWithPermissionsAndUsers = RoleWithPermissions & {
|
||||
users: (UserRole & { user: UserSimple })[];
|
||||
};
|
||||
|
||||
export async function getAllRoles(type?: "admin" | "app"): Promise<RoleWithPermissions[]> {
|
||||
let where = {};
|
||||
if (type !== undefined) {
|
||||
where = {
|
||||
type,
|
||||
tenantId: null,
|
||||
};
|
||||
}
|
||||
|
||||
return await db.role.findMany({
|
||||
where,
|
||||
include: {
|
||||
permissions: {
|
||||
include: {
|
||||
permission: true,
|
||||
},
|
||||
orderBy: { permission: { name: "asc" } },
|
||||
},
|
||||
},
|
||||
orderBy: [
|
||||
{
|
||||
type: "asc",
|
||||
},
|
||||
{
|
||||
order: "asc",
|
||||
},
|
||||
],
|
||||
});
|
||||
}
|
||||
|
||||
export async function getAllRolesNames(): Promise<{ id: string; name: string }[]> {
|
||||
return await db.role.findMany({
|
||||
select: { id: true, name: true },
|
||||
orderBy: [{ type: "asc" }, { order: "asc" }],
|
||||
});
|
||||
}
|
||||
|
||||
export async function getAllRolesWithoutPermissions(type?: "admin" | "app"): Promise<Role[]> {
|
||||
let where = {};
|
||||
if (type !== undefined) {
|
||||
where = {
|
||||
type,
|
||||
tenantId: null,
|
||||
};
|
||||
}
|
||||
|
||||
return await cachified({
|
||||
key: `roles:${type}`,
|
||||
ttl: 1000 * 60 * 60 * 24,
|
||||
getFreshValue: () =>
|
||||
db.role.findMany({
|
||||
where,
|
||||
orderBy: [
|
||||
{
|
||||
type: "asc",
|
||||
},
|
||||
{
|
||||
order: "asc",
|
||||
},
|
||||
],
|
||||
}),
|
||||
});
|
||||
}
|
||||
|
||||
export async function getAllRolesWithUsers(type?: "admin" | "app", filters?: FiltersDto, tenantId?: string | null): Promise<RoleWithPermissionsAndUsers[]> {
|
||||
const scopeWhere: any = {
|
||||
...(type !== undefined ? { type } : {}),
|
||||
...(tenantId !== undefined ? { OR: [{ tenantId: null }, { tenantId }] } : { tenantId: null }),
|
||||
};
|
||||
let where: any = scopeWhere;
|
||||
if (filters !== undefined) {
|
||||
const filterWhere = RowFiltersHelper.getFiltersCondition(filters);
|
||||
const permissionId = filters?.properties.find((f) => f.name === "permissionId")?.value;
|
||||
const permissionWhere = permissionId ? { OR: [filterWhere, { permissions: { some: { permissionId } } }] } : filterWhere;
|
||||
where = {
|
||||
AND: [scopeWhere, permissionWhere],
|
||||
};
|
||||
}
|
||||
return await db.role.findMany({
|
||||
where,
|
||||
include: {
|
||||
permissions: {
|
||||
include: {
|
||||
permission: true,
|
||||
},
|
||||
orderBy: { permission: { name: "asc" } },
|
||||
},
|
||||
users: {
|
||||
...(tenantId !== undefined ? { where: { tenantId } } : {}),
|
||||
include: {
|
||||
...UserModelHelper.includeSimpleUser,
|
||||
},
|
||||
},
|
||||
},
|
||||
orderBy: [
|
||||
{
|
||||
type: "asc",
|
||||
},
|
||||
{
|
||||
order: "asc",
|
||||
},
|
||||
],
|
||||
});
|
||||
}
|
||||
|
||||
export async function getRoles(ids: string[]): Promise<RoleWithPermissionsAndUsers[]> {
|
||||
return await db.role.findMany({
|
||||
where: {
|
||||
id: {
|
||||
in: ids,
|
||||
},
|
||||
},
|
||||
include: {
|
||||
permissions: {
|
||||
include: {
|
||||
permission: true,
|
||||
},
|
||||
orderBy: { permission: { name: "asc" } },
|
||||
},
|
||||
users: {
|
||||
include: {
|
||||
...UserModelHelper.includeSimpleUser,
|
||||
},
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function getRolesByName(names: string[]): Promise<RoleWithPermissionsAndUsers[]> {
|
||||
return await db.role.findMany({
|
||||
where: {
|
||||
name: {
|
||||
in: names,
|
||||
},
|
||||
},
|
||||
include: {
|
||||
permissions: {
|
||||
include: {
|
||||
permission: true,
|
||||
},
|
||||
orderBy: { permission: { name: "asc" } },
|
||||
},
|
||||
users: {
|
||||
include: {
|
||||
...UserModelHelper.includeSimpleUser,
|
||||
},
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function getRole(id: string): Promise<RoleWithPermissions | null> {
|
||||
return await db.role.findUnique({
|
||||
where: {
|
||||
id,
|
||||
},
|
||||
include: {
|
||||
permissions: {
|
||||
include: {
|
||||
permission: true,
|
||||
},
|
||||
orderBy: { permission: { name: "asc" } },
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function getTenantAssignableAppRole(id: string, tenantId: string): Promise<RoleWithPermissions | null> {
|
||||
return await db.role.findFirst({
|
||||
where: {
|
||||
id,
|
||||
type: "app",
|
||||
OR: [{ isDefault: true, tenantId: null }, { tenantId }],
|
||||
},
|
||||
include: {
|
||||
permissions: {
|
||||
include: {
|
||||
permission: true,
|
||||
},
|
||||
orderBy: { permission: { name: "asc" } },
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function getTenantMutableAppRole(id: string, tenantId: string): Promise<RoleWithPermissions | null> {
|
||||
return await db.role.findFirst({
|
||||
where: {
|
||||
id,
|
||||
type: "app",
|
||||
isDefault: false,
|
||||
tenantId,
|
||||
},
|
||||
include: {
|
||||
permissions: {
|
||||
include: {
|
||||
permission: true,
|
||||
},
|
||||
orderBy: { permission: { name: "asc" } },
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function getRoleByName(name: string): Promise<RoleWithPermissions | null> {
|
||||
return await db.role.findFirst({
|
||||
where: {
|
||||
name,
|
||||
tenantId: null,
|
||||
},
|
||||
include: {
|
||||
permissions: {
|
||||
include: {
|
||||
permission: true,
|
||||
},
|
||||
orderBy: { permission: { name: "asc" } },
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function getTenantAppRoleByName(name: string, tenantId: string): Promise<RoleWithPermissions | null> {
|
||||
return await db.role.findFirst({
|
||||
where: {
|
||||
name,
|
||||
tenantId,
|
||||
type: "app",
|
||||
},
|
||||
include: {
|
||||
permissions: {
|
||||
include: {
|
||||
permission: true,
|
||||
},
|
||||
orderBy: { permission: { name: "asc" } },
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function getNextRolesOrder(type?: "admin" | "app", tenantId?: string | null): Promise<number> {
|
||||
let where = {};
|
||||
if (type !== undefined) {
|
||||
where = {
|
||||
type,
|
||||
tenantId: tenantId ?? null,
|
||||
};
|
||||
}
|
||||
return (
|
||||
((
|
||||
await db.role.aggregate({
|
||||
where,
|
||||
_max: {
|
||||
order: true,
|
||||
},
|
||||
})
|
||||
)._max.order ?? 0) + 1
|
||||
);
|
||||
}
|
||||
|
||||
export async function createRole(data: {
|
||||
order: number;
|
||||
name: string;
|
||||
description: string;
|
||||
type: "admin" | "app";
|
||||
assignToNewUsers: boolean;
|
||||
isDefault: boolean;
|
||||
tenantId?: string | null;
|
||||
}) {
|
||||
return await db.role
|
||||
.create({
|
||||
data,
|
||||
})
|
||||
.then((item) => {
|
||||
clearCacheKey(`roles:${data.type}`);
|
||||
return item;
|
||||
});
|
||||
}
|
||||
|
||||
export async function updateRole(id: string, data: { name: string; description: string; type: "admin" | "app"; assignToNewUsers: boolean }) {
|
||||
return await db.role
|
||||
.update({
|
||||
where: { id },
|
||||
data,
|
||||
})
|
||||
.then((item) => {
|
||||
clearCacheKey(`roles:${item.type}`);
|
||||
return item;
|
||||
});
|
||||
}
|
||||
|
||||
export async function deleteRole(id: string) {
|
||||
return await db.role
|
||||
.delete({
|
||||
where: { id },
|
||||
})
|
||||
.then((item) => {
|
||||
clearCacheKey(`roles:${item.type}`);
|
||||
return item;
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
// @vitest-environment node
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
|
||||
vi.mock("../../db.server", () => ({
|
||||
db: {
|
||||
rowPermission: {
|
||||
create: vi.fn(),
|
||||
deleteMany: vi.fn(),
|
||||
findFirst: vi.fn(),
|
||||
findMany: vi.fn(),
|
||||
updateMany: vi.fn(),
|
||||
},
|
||||
},
|
||||
}));
|
||||
|
||||
import { db } from "../../db.server";
|
||||
import {
|
||||
createRowPermission,
|
||||
deleteRowPermission,
|
||||
deleteRowPermissionByIdForRow,
|
||||
getRowPermissionByGroups,
|
||||
getRowPermissionByRoles,
|
||||
getRowPermissionByTenant,
|
||||
getRowPermissionByUsers,
|
||||
getRowPermissions,
|
||||
updateRowPermissionForRow,
|
||||
} from "./rowPermissions.db.server";
|
||||
|
||||
const dbMock = vi.mocked(db);
|
||||
|
||||
describe("row permission persistence", () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
});
|
||||
|
||||
it("lists row permissions with tenant, role, group, and user display details", async () => {
|
||||
vi.mocked(dbMock.rowPermission.findMany).mockResolvedValueOnce([{ id: "rp_1" }] as never);
|
||||
|
||||
await expect(getRowPermissions("row_1")).resolves.toEqual([{ id: "rp_1" }]);
|
||||
|
||||
expect(dbMock.rowPermission.findMany).toHaveBeenCalledWith({
|
||||
where: { rowId: "row_1" },
|
||||
include: {
|
||||
tenant: { select: { id: true, name: true } },
|
||||
role: { select: { id: true, name: true } },
|
||||
group: { select: { id: true, name: true } },
|
||||
user: { select: { id: true, email: true } },
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
it("looks up row permissions by scoped principals", async () => {
|
||||
vi.mocked(dbMock.rowPermission.findFirst).mockResolvedValue({ id: "rp_1" } as never);
|
||||
|
||||
await getRowPermissionByTenant("row_1", "tenant_1");
|
||||
await getRowPermissionByGroups("row_1", ["group_1", "group_2"]);
|
||||
await getRowPermissionByRoles("row_1", ["role_1"]);
|
||||
await getRowPermissionByUsers("row_1", ["user_1"]);
|
||||
|
||||
expect(dbMock.rowPermission.findFirst).toHaveBeenNthCalledWith(1, { where: { rowId: "row_1", tenantId: "tenant_1" } });
|
||||
expect(dbMock.rowPermission.findFirst).toHaveBeenNthCalledWith(2, { where: { rowId: "row_1", groupId: { in: ["group_1", "group_2"] } } });
|
||||
expect(dbMock.rowPermission.findFirst).toHaveBeenNthCalledWith(3, { where: { rowId: "row_1", roleId: { in: ["role_1"] } } });
|
||||
expect(dbMock.rowPermission.findFirst).toHaveBeenNthCalledWith(4, { where: { rowId: "row_1", userId: { in: ["user_1"] } } });
|
||||
});
|
||||
|
||||
it("creates, updates, and deletes row permissions through row-scoped predicates", async () => {
|
||||
vi.mocked(dbMock.rowPermission.create).mockResolvedValueOnce({ id: "rp_1" } as never);
|
||||
vi.mocked(dbMock.rowPermission.updateMany).mockResolvedValueOnce({ count: 1 } as never);
|
||||
vi.mocked(dbMock.rowPermission.deleteMany).mockResolvedValue({ count: 1 } as never);
|
||||
|
||||
await expect(createRowPermission({ rowId: "row_1", tenantId: "tenant_1", access: "view" })).resolves.toEqual({ id: "rp_1" });
|
||||
await expect(updateRowPermissionForRow("row_1", "rp_1", { access: "edit" })).resolves.toEqual({ count: 1 });
|
||||
await expect(deleteRowPermission("row_1")).resolves.toEqual({ count: 1 });
|
||||
await expect(deleteRowPermissionByIdForRow("row_1", "rp_1")).resolves.toEqual({ count: 1 });
|
||||
|
||||
expect(dbMock.rowPermission.create).toHaveBeenCalledWith({ data: { rowId: "row_1", tenantId: "tenant_1", access: "view" } });
|
||||
expect(dbMock.rowPermission.updateMany).toHaveBeenCalledWith({ where: { id: "rp_1", rowId: "row_1" }, data: { access: "edit" } });
|
||||
expect(dbMock.rowPermission.deleteMany).toHaveBeenNthCalledWith(1, { where: { rowId: "row_1" } });
|
||||
expect(dbMock.rowPermission.deleteMany).toHaveBeenNthCalledWith(2, { where: { id: "rp_1", rowId: "row_1" } });
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,102 @@
|
||||
import { RowPermission } from "@toolctrl/db/prisma-browser";
|
||||
import { db } from "~/utils/db.server";
|
||||
|
||||
export type RowPermissionsWithDetails = RowPermission & {
|
||||
tenant: { id: string; name: string } | null;
|
||||
role?: { id: string; name: string } | null;
|
||||
group?: { id: string; name: string } | null;
|
||||
user?: { id: string; email: string } | null;
|
||||
};
|
||||
export async function getRowPermissions(rowId: string): Promise<RowPermissionsWithDetails[]> {
|
||||
return await db.rowPermission.findMany({
|
||||
where: {
|
||||
rowId,
|
||||
},
|
||||
include: {
|
||||
tenant: { select: { id: true, name: true } },
|
||||
role: { select: { id: true, name: true } },
|
||||
group: { select: { id: true, name: true } },
|
||||
user: { select: { id: true, email: true } },
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function getRowPermissionByTenant(rowId: string, tenantId?: string | null) {
|
||||
return await db.rowPermission.findFirst({
|
||||
where: {
|
||||
rowId,
|
||||
tenantId,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function getRowPermissionByGroups(rowId: string, groups: string[]) {
|
||||
return await db.rowPermission.findFirst({
|
||||
where: {
|
||||
rowId,
|
||||
groupId: {
|
||||
in: groups,
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function getRowPermissionByRoles(rowId: string, roles: string[]) {
|
||||
return await db.rowPermission.findFirst({
|
||||
where: {
|
||||
rowId,
|
||||
roleId: {
|
||||
in: roles,
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function getRowPermissionByUsers(rowId: string, users: string[]) {
|
||||
return await db.rowPermission.findFirst({
|
||||
where: {
|
||||
rowId,
|
||||
userId: {
|
||||
in: users,
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function createRowPermission(data: {
|
||||
rowId: string;
|
||||
tenantId?: string | null;
|
||||
roleId?: string | null;
|
||||
groupId?: string | null;
|
||||
userId?: string | null;
|
||||
public?: boolean | null;
|
||||
access: string;
|
||||
}) {
|
||||
return await db.rowPermission.create({
|
||||
data,
|
||||
});
|
||||
}
|
||||
|
||||
export async function updateRowPermissionForRow(rowId: string, id: string, data: { access: string }) {
|
||||
return await db.rowPermission.updateMany({
|
||||
where: { id, rowId },
|
||||
data,
|
||||
});
|
||||
}
|
||||
|
||||
export async function deleteRowPermission(rowId: string) {
|
||||
return await db.rowPermission.deleteMany({
|
||||
where: {
|
||||
rowId,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function deleteRowPermissionByIdForRow(rowId: string, id: string) {
|
||||
return await db.rowPermission.deleteMany({
|
||||
where: {
|
||||
id,
|
||||
rowId,
|
||||
},
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
// @vitest-environment node
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
|
||||
vi.mock("../../db.server", () => ({
|
||||
db: {
|
||||
groupUser: {
|
||||
create: vi.fn(),
|
||||
createMany: vi.fn(),
|
||||
deleteMany: vi.fn(),
|
||||
},
|
||||
$transaction: vi.fn(),
|
||||
},
|
||||
}));
|
||||
|
||||
import { db } from "../../db.server";
|
||||
import { createUserGroup, createUserGroups, deleteGroupUsers, deleteUserGroup, replaceGroupUsers } from "./userGroups.db.server";
|
||||
|
||||
const dbMock = vi.mocked(db);
|
||||
|
||||
describe("user group persistence", () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
vi.mocked(dbMock.$transaction).mockImplementation((async (callback: (tx: typeof dbMock) => Promise<unknown>) => callback(dbMock)) as never);
|
||||
});
|
||||
|
||||
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 () => {
|
||||
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 });
|
||||
|
||||
expect(dbMock.groupUser.createMany).toHaveBeenCalledWith({
|
||||
data: [
|
||||
{ userId: "user_1", groupId: "group_1" },
|
||||
{ userId: "user_2", groupId: "group_1" },
|
||||
],
|
||||
skipDuplicates: true,
|
||||
});
|
||||
});
|
||||
|
||||
it("skips bulk membership writes when no users are selected", async () => {
|
||||
await expect(createUserGroups("group_1", [])).resolves.toEqual({ count: 0 });
|
||||
|
||||
expect(dbMock.groupUser.createMany).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
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 });
|
||||
|
||||
expect(dbMock.$transaction).toHaveBeenCalledTimes(1);
|
||||
expect(dbMock.groupUser.deleteMany).toHaveBeenCalledWith({ where: { groupId: "group_1", group: { tenantId: "tenant_1" } } });
|
||||
expect(dbMock.groupUser.createMany).toHaveBeenCalledWith({
|
||||
data: [
|
||||
{ userId: "user_1", groupId: "group_1" },
|
||||
{ userId: "user_2", groupId: "group_1" },
|
||||
],
|
||||
skipDuplicates: true,
|
||||
});
|
||||
});
|
||||
|
||||
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 });
|
||||
|
||||
expect(dbMock.$transaction).toHaveBeenCalledTimes(1);
|
||||
expect(dbMock.groupUser.deleteMany).toHaveBeenCalledWith({ where: { groupId: "group_1", group: { tenantId: "tenant_1" } } });
|
||||
expect(dbMock.groupUser.createMany).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,64 @@
|
||||
import { db } from "~/utils/db.server";
|
||||
|
||||
export async function createUserGroup(userId: string, groupId: string) {
|
||||
return await db.groupUser.create({
|
||||
data: {
|
||||
userId,
|
||||
groupId,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function createUserGroups(groupId: string, userIds: string[]) {
|
||||
const uniqueUserIds = [...new Set(userIds)];
|
||||
if (uniqueUserIds.length === 0) {
|
||||
return { count: 0 };
|
||||
}
|
||||
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[]) {
|
||||
const uniqueUserIds = [...new Set(userIds)];
|
||||
return await db.$transaction(async (tx) => {
|
||||
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,
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
export async function deleteGroupUsers(groupId: string, tenantId: string) {
|
||||
return await db.groupUser.deleteMany({
|
||||
where: {
|
||||
groupId,
|
||||
group: { tenantId },
|
||||
},
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,342 @@
|
||||
// @vitest-environment node
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import { TenantUserType } from "~/application/enums/tenants/TenantUserType";
|
||||
|
||||
vi.mock("../../db.server", () => ({
|
||||
db: {
|
||||
permission: {
|
||||
count: vi.fn(),
|
||||
},
|
||||
role: {
|
||||
findMany: vi.fn(),
|
||||
},
|
||||
userRole: {
|
||||
count: vi.fn(),
|
||||
create: vi.fn(),
|
||||
createMany: vi.fn(),
|
||||
deleteMany: vi.fn(),
|
||||
findFirst: vi.fn(),
|
||||
findMany: vi.fn(),
|
||||
},
|
||||
},
|
||||
}));
|
||||
vi.mock("~/utils/cache.server", () => ({
|
||||
cachified: vi.fn((options: { getFreshValue: () => unknown }) => options.getFreshValue()),
|
||||
clearCacheKey: vi.fn(),
|
||||
}));
|
||||
|
||||
import { cachified, clearCacheKey } from "~/utils/cache.server";
|
||||
import { db } from "../../db.server";
|
||||
import {
|
||||
countUserPermission,
|
||||
createUserRole,
|
||||
createUserRoles,
|
||||
deleteAllUserRoles,
|
||||
deleteUserRole,
|
||||
ensureTenantUserAppRoles,
|
||||
findPermissionByUser,
|
||||
findUserRolesByIds,
|
||||
getPermissionsByUser,
|
||||
getUserRole,
|
||||
getUserRoleInAdmin,
|
||||
getUserRoleInTenant,
|
||||
getUserRoles,
|
||||
getUsersRolesInTenant,
|
||||
userHasPermission,
|
||||
} from "./userRoles.db.server";
|
||||
|
||||
const dbMock = vi.mocked(db);
|
||||
|
||||
describe("user role persistence", () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
vi.mocked(cachified).mockImplementation((async (options: { getFreshValue: () => unknown }) => options.getFreshValue()) as never);
|
||||
});
|
||||
|
||||
it("queries user-role relationships with tenant and admin scope", async () => {
|
||||
vi.mocked(dbMock.userRole.findFirst).mockResolvedValue({ id: "ur_1" } as never);
|
||||
vi.mocked(dbMock.userRole.findMany).mockResolvedValue([] as never);
|
||||
|
||||
await getUserRole("user_1", "role_1", "tenant_1");
|
||||
await getUserRoleInTenant("user_1", "tenant_1", "Admin");
|
||||
await getUserRoleInAdmin("user_1", "SuperAdmin");
|
||||
await getUserRoles("user_1", "tenant_1");
|
||||
|
||||
expect(dbMock.userRole.findFirst).toHaveBeenNthCalledWith(1, {
|
||||
where: { userId: "user_1", roleId: "role_1", tenantId: "tenant_1" },
|
||||
});
|
||||
expect(dbMock.userRole.findFirst).toHaveBeenNthCalledWith(2, {
|
||||
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 },
|
||||
});
|
||||
expect(dbMock.userRole.findMany).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
where: { userId: "user_1", tenantId: "tenant_1" },
|
||||
orderBy: { role: { order: "asc" } },
|
||||
})
|
||||
);
|
||||
});
|
||||
|
||||
it("deduplicates permissions returned from cached user-role expansion", async () => {
|
||||
vi.mocked(dbMock.userRole.findMany).mockResolvedValueOnce([
|
||||
{
|
||||
role: {
|
||||
name: "Admin",
|
||||
permissions: [{ permission: { name: "members.read" } }, { permission: { name: "members.read" } }],
|
||||
},
|
||||
},
|
||||
{
|
||||
role: {
|
||||
name: "Member",
|
||||
permissions: [{ permission: { name: "settings.update" } }],
|
||||
},
|
||||
},
|
||||
] as never);
|
||||
|
||||
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,
|
||||
})
|
||||
);
|
||||
});
|
||||
|
||||
it("checks permission membership through the cached user-role expansion", async () => {
|
||||
vi.mocked(dbMock.userRole.findMany)
|
||||
.mockResolvedValueOnce([
|
||||
{
|
||||
role: {
|
||||
name: "Admin",
|
||||
permissions: [{ permission: { name: "members.read" } }],
|
||||
},
|
||||
},
|
||||
] as never)
|
||||
.mockResolvedValueOnce([
|
||||
{
|
||||
role: {
|
||||
name: "Admin",
|
||||
permissions: [{ permission: { name: "members.read" } }],
|
||||
},
|
||||
},
|
||||
] as never);
|
||||
|
||||
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(dbMock.permission.count).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("returns the first matching permission name or null", async () => {
|
||||
vi.mocked(dbMock.userRole.findMany)
|
||||
.mockResolvedValueOnce([
|
||||
{
|
||||
role: {
|
||||
name: "Admin",
|
||||
permissions: [{ permission: { name: "members.read" } }],
|
||||
},
|
||||
},
|
||||
] as never)
|
||||
.mockResolvedValueOnce([] as never);
|
||||
|
||||
await expect(findPermissionByUser("members.read", "user_1", "tenant_1")).resolves.toBe("members.read");
|
||||
await expect(findPermissionByUser("members.read", "user_1", "tenant_1")).resolves.toBeNull();
|
||||
|
||||
expect(dbMock.userRole.findMany).toHaveBeenNthCalledWith(
|
||||
1,
|
||||
expect.objectContaining({
|
||||
where: {
|
||||
userId: "user_1",
|
||||
tenantId: "tenant_1",
|
||||
role: { permissions: { some: { permission: { name: "members.read" } } } },
|
||||
},
|
||||
})
|
||||
);
|
||||
});
|
||||
|
||||
it("counts direct role permission matches and returns zero when none exist", async () => {
|
||||
vi.mocked(dbMock.permission.count).mockResolvedValueOnce(2).mockResolvedValueOnce(0);
|
||||
|
||||
await expect(countUserPermission("user_1", "tenant_1", "members.read")).resolves.toBe(2);
|
||||
await expect(countUserPermission("user_1", "tenant_1", "members.read")).resolves.toBe(0);
|
||||
|
||||
expect(dbMock.permission.count).toHaveBeenCalledWith({
|
||||
where: {
|
||||
name: "members.read",
|
||||
inRoles: { some: { role: { users: { some: { userId: "user_1", tenantId: "tenant_1" } } } } },
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
it("queries bulk role helpers by ids, tenant, and type", async () => {
|
||||
vi.mocked(dbMock.userRole.findMany).mockResolvedValue([] as never);
|
||||
vi.mocked(dbMock.userRole.deleteMany).mockResolvedValue({ count: 2 } as never);
|
||||
|
||||
await findUserRolesByIds("user_1", "tenant_1", ["role_1", "role_2"]);
|
||||
await getUsersRolesInTenant("tenant_1");
|
||||
await deleteAllUserRoles("user_1", "app");
|
||||
|
||||
expect(dbMock.userRole.findMany).toHaveBeenNthCalledWith(1, {
|
||||
where: { userId: "user_1", tenantId: "tenant_1", roleId: { in: ["role_1", "role_2"] } },
|
||||
});
|
||||
expect(dbMock.userRole.findMany).toHaveBeenNthCalledWith(2, {
|
||||
where: { tenantId: "tenant_1" },
|
||||
include: { role: true, user: true },
|
||||
});
|
||||
expect(dbMock.userRole.deleteMany).toHaveBeenCalledWith({
|
||||
where: { userId: "user_1", role: { type: "app" } },
|
||||
});
|
||||
});
|
||||
|
||||
it("returns early from app-role repair when the user already has tenant app roles", async () => {
|
||||
vi.mocked(dbMock.userRole.count).mockResolvedValueOnce(2);
|
||||
|
||||
await expect(ensureTenantUserAppRoles({ userId: "user_1", tenantId: "tenant_1", tenantUserType: TenantUserType.MEMBER })).resolves.toEqual({
|
||||
created: 0,
|
||||
roleCount: 2,
|
||||
});
|
||||
|
||||
expect(dbMock.role.findMany).not.toHaveBeenCalled();
|
||||
expect(clearCacheKey).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("grants all scoped app roles to tenant owners and skips already assigned roles", async () => {
|
||||
vi.mocked(dbMock.userRole.count).mockResolvedValueOnce(0);
|
||||
vi.mocked(dbMock.role.findMany).mockResolvedValueOnce([{ id: "role_1" }, { id: "role_2" }] as never);
|
||||
vi.mocked(dbMock.userRole.findMany)
|
||||
.mockResolvedValueOnce([{ id: "existing_role_2", roleId: "role_2" }] as never)
|
||||
.mockResolvedValueOnce([] as never);
|
||||
vi.mocked(dbMock.userRole.createMany).mockResolvedValueOnce({ count: 1 } as never);
|
||||
|
||||
await expect(ensureTenantUserAppRoles({ userId: "user_1", tenantId: "tenant_1", tenantUserType: TenantUserType.OWNER })).resolves.toEqual({
|
||||
created: 1,
|
||||
roleCount: 2,
|
||||
});
|
||||
|
||||
expect(dbMock.role.findMany).toHaveBeenCalledWith({
|
||||
where: { type: "app", OR: [{ tenantId: null }, { tenantId: "tenant_1" }] },
|
||||
orderBy: { order: "asc" },
|
||||
});
|
||||
expect(dbMock.userRole.findMany).toHaveBeenCalledWith({
|
||||
where: { userId: "user_1", tenantId: "tenant_1", roleId: { in: ["role_1", "role_2"] } },
|
||||
});
|
||||
expect(dbMock.userRole.createMany).toHaveBeenCalledWith({
|
||||
data: [{ userId: "user_1", roleId: "role_1", tenantId: "tenant_1" }],
|
||||
skipDuplicates: true,
|
||||
});
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:tenant_1");
|
||||
});
|
||||
|
||||
it("clears role cache when every scoped app role is already assigned", async () => {
|
||||
vi.mocked(dbMock.userRole.count).mockResolvedValueOnce(0);
|
||||
vi.mocked(dbMock.role.findMany).mockResolvedValueOnce([{ id: "role_1" }] as never);
|
||||
vi.mocked(dbMock.userRole.findMany).mockResolvedValueOnce([{ id: "existing_role_1", roleId: "role_1" }] as never);
|
||||
|
||||
await expect(ensureTenantUserAppRoles({ userId: "user_1", tenantId: "tenant_1", tenantUserType: TenantUserType.ADMIN })).resolves.toEqual({
|
||||
created: 0,
|
||||
roleCount: 1,
|
||||
});
|
||||
|
||||
expect(dbMock.userRole.createMany).not.toHaveBeenCalled();
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:tenant_1");
|
||||
});
|
||||
|
||||
it("grants only assign-to-new-users app roles to regular members", async () => {
|
||||
vi.mocked(dbMock.userRole.count).mockResolvedValueOnce(0);
|
||||
vi.mocked(dbMock.role.findMany).mockResolvedValueOnce([] as never);
|
||||
|
||||
await ensureTenantUserAppRoles({ userId: "user_1", tenantId: "tenant_1", tenantUserType: TenantUserType.MEMBER });
|
||||
|
||||
expect(dbMock.role.findMany).toHaveBeenCalledWith({
|
||||
where: {
|
||||
type: "app",
|
||||
OR: [{ tenantId: null }, { tenantId: "tenant_1" }],
|
||||
assignToNewUsers: true,
|
||||
},
|
||||
orderBy: { order: "asc" },
|
||||
});
|
||||
});
|
||||
|
||||
it("does not duplicate an existing user role", async () => {
|
||||
vi.mocked(dbMock.userRole.findFirst).mockResolvedValueOnce({ id: "ur_existing" } as never);
|
||||
|
||||
await expect(createUserRole("user_1", "role_1", "tenant_1")).resolves.toEqual({ id: "ur_existing" });
|
||||
|
||||
expect(dbMock.userRole.create).not.toHaveBeenCalled();
|
||||
expect(clearCacheKey).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
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.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" });
|
||||
|
||||
expect(dbMock.userRole.create).toHaveBeenCalledWith({ data: { userId: "user_1", roleId: "role_admin", tenantId: null } });
|
||||
expect(dbMock.userRole.findFirst).toHaveBeenNthCalledWith(2, {
|
||||
where: { userId: "user_1", roleId: "role_admin", tenantId: null },
|
||||
});
|
||||
expect(clearCacheKey).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("rethrows failed user-role creation when the error is not a recoverable unique race", async () => {
|
||||
const error = new Error("database down");
|
||||
vi.mocked(dbMock.userRole.findFirst).mockResolvedValueOnce(null);
|
||||
vi.mocked(dbMock.userRole.create).mockRejectedValueOnce(error as never);
|
||||
|
||||
await expect(createUserRole("user_1", "role_1", "tenant_1")).rejects.toBe(error);
|
||||
});
|
||||
|
||||
it("rethrows unique user-role creation races when the assignment cannot be found afterward", async () => {
|
||||
const error = Object.assign(new Error("Unique constraint failed"), { code: "P2002" });
|
||||
vi.mocked(dbMock.userRole.findFirst).mockResolvedValueOnce(null).mockResolvedValueOnce(null);
|
||||
vi.mocked(dbMock.userRole.create).mockRejectedValueOnce(error as never);
|
||||
|
||||
await expect(createUserRole("user_1", "role_1", null)).rejects.toBe(error);
|
||||
});
|
||||
|
||||
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);
|
||||
vi.mocked(dbMock.userRole.findMany).mockResolvedValueOnce([] as never);
|
||||
vi.mocked(dbMock.userRole.createMany).mockResolvedValueOnce({ count: 3 } as never);
|
||||
vi.mocked(dbMock.userRole.deleteMany).mockResolvedValueOnce({ count: 1 } as never);
|
||||
|
||||
await createUserRole("user_1", "role_1", "tenant_1");
|
||||
await createUserRoles("user_1", [
|
||||
{ id: "role_1", tenantId: "tenant_1" },
|
||||
{ id: "role_2", tenantId: "tenant_1" },
|
||||
{ id: "role_admin", tenantId: null },
|
||||
]);
|
||||
await deleteUserRole("user_1", "role_1", "tenant_1");
|
||||
|
||||
expect(dbMock.userRole.create).toHaveBeenCalledWith({ data: { userId: "user_1", roleId: "role_1", tenantId: "tenant_1" } });
|
||||
expect(dbMock.userRole.createMany).toHaveBeenCalledWith({
|
||||
data: [
|
||||
{ userId: "user_1", roleId: "role_1", tenantId: "tenant_1" },
|
||||
{ userId: "user_1", roleId: "role_2", tenantId: "tenant_1" },
|
||||
{ userId: "user_1", roleId: "role_admin", tenantId: null },
|
||||
],
|
||||
skipDuplicates: true,
|
||||
});
|
||||
expect(dbMock.userRole.deleteMany).toHaveBeenCalledWith({
|
||||
where: { userId: "user_1", roleId: "role_1", tenantId: "tenant_1" },
|
||||
});
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:tenant_1");
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:null");
|
||||
});
|
||||
|
||||
it("handles empty and already-existing bulk role assignments without writes", async () => {
|
||||
await expect(createUserRoles("user_1", [])).resolves.toEqual({ count: 0 });
|
||||
|
||||
vi.mocked(dbMock.userRole.findMany).mockResolvedValueOnce([{ userId: "user_1", roleId: "role_1", tenantId: null }] as never);
|
||||
await expect(createUserRoles("user_1", [{ id: "role_1", tenantId: null }])).resolves.toEqual({ count: 0 });
|
||||
|
||||
expect(dbMock.userRole.createMany).not.toHaveBeenCalled();
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:null");
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,369 @@
|
||||
import { Permission, Role, RolePermission, UserRole } from "@toolctrl/db/prisma-browser";
|
||||
import { TenantUserType } from "~/application/enums/tenants/TenantUserType";
|
||||
import { db } from "../../db.server";
|
||||
import { cachified, clearCacheKey } from "~/utils/cache.server";
|
||||
|
||||
export type UserRoleWithPermission = UserRole & {
|
||||
role: Role & { permissions: (RolePermission & { permission: Permission })[] };
|
||||
};
|
||||
|
||||
export type UserRoleAssignment = {
|
||||
userId: string;
|
||||
roleId: string;
|
||||
tenantId?: string | null;
|
||||
};
|
||||
|
||||
function normalizeTenantId(tenantId: string | null | undefined): string | null {
|
||||
return tenantId ?? null;
|
||||
}
|
||||
|
||||
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}`);
|
||||
}
|
||||
|
||||
function isUniqueConstraintError(error: unknown): boolean {
|
||||
return Boolean(error && typeof error === "object" && "code" in error && error.code === "P2002");
|
||||
}
|
||||
|
||||
export async function getUserRole(userId: string, roleId: string, tenantId?: string | null) {
|
||||
return await db.userRole.findFirst({
|
||||
where: {
|
||||
userId,
|
||||
roleId,
|
||||
tenantId,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function getUserRoleInTenant(userId: string, tenantId: string, roleName: string) {
|
||||
return await db.userRole.findFirst({
|
||||
where: {
|
||||
userId,
|
||||
role: {
|
||||
name: roleName,
|
||||
},
|
||||
tenantId,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function getUserRoleInAdmin(userId: string, roleName: string) {
|
||||
return await db.userRole.findFirst({
|
||||
where: {
|
||||
userId,
|
||||
role: {
|
||||
name: roleName,
|
||||
},
|
||||
tenantId: null,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function getUserRoles(userId: string, tenantId?: string | null): Promise<UserRoleWithPermission[]> {
|
||||
return await db.userRole.findMany({
|
||||
where: {
|
||||
userId,
|
||||
tenantId,
|
||||
},
|
||||
include: {
|
||||
role: {
|
||||
include: {
|
||||
permissions: {
|
||||
include: {
|
||||
permission: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
orderBy: {
|
||||
role: {
|
||||
order: "asc",
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
});
|
||||
});
|
||||
// console.log({
|
||||
// userId,
|
||||
// tenantId,
|
||||
// roles,
|
||||
// permissions: names,
|
||||
// });
|
||||
return names;
|
||||
}
|
||||
|
||||
export async function userHasPermission(userId: string, tenantId: string | null, permissionName: string): Promise<boolean> {
|
||||
const permissions = await getPermissionsByUser(userId, tenantId);
|
||||
return permissions.includes(permissionName);
|
||||
}
|
||||
|
||||
export async function findPermissionByUser(persmissionName: string, userId: string, tenantId?: string | null): Promise<string | null> {
|
||||
const userRoles = await db.userRole.findMany({
|
||||
where: { userId, tenantId, role: { permissions: { some: { permission: { name: persmissionName } } } } },
|
||||
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);
|
||||
}
|
||||
});
|
||||
});
|
||||
// console.log({
|
||||
// userId,
|
||||
// tenantId,
|
||||
// roles,
|
||||
// permissions: names,
|
||||
// });
|
||||
return names.length > 0 ? names[0] : null;
|
||||
}
|
||||
|
||||
export async function countUserPermission(userId: string, tenantId: string | null, permissionName: string): Promise<number> {
|
||||
const normal = await db.permission.count({
|
||||
where: {
|
||||
name: permissionName,
|
||||
inRoles: { some: { role: { users: { some: { userId, tenantId } } } } },
|
||||
},
|
||||
});
|
||||
if (normal > 0) {
|
||||
return normal;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
export async function findUserRolesByIds(userId: string, tenantId: string | null, roleIds: string[]): Promise<UserRole[]> {
|
||||
return await db.userRole.findMany({
|
||||
where: {
|
||||
userId,
|
||||
tenantId,
|
||||
roleId: {
|
||||
in: roleIds,
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function getUsersRolesInTenant(tenantId: string) {
|
||||
return await db.userRole.findMany({
|
||||
where: {
|
||||
tenantId,
|
||||
},
|
||||
include: {
|
||||
role: true,
|
||||
user: true,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function ensureTenantUserAppRoles({
|
||||
userId,
|
||||
tenantId,
|
||||
tenantUserType,
|
||||
}: {
|
||||
userId: string;
|
||||
tenantId: string;
|
||||
tenantUserType: number;
|
||||
}): Promise<{ created: number; roleCount: number }> {
|
||||
const existingRoleCount = await db.userRole.count({
|
||||
where: {
|
||||
userId,
|
||||
tenantId,
|
||||
role: {
|
||||
type: "app",
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
if (existingRoleCount > 0) {
|
||||
return { created: 0, roleCount: existingRoleCount };
|
||||
}
|
||||
|
||||
const shouldGrantAllAppRoles = tenantUserType === TenantUserType.OWNER || tenantUserType === TenantUserType.ADMIN;
|
||||
const roles = await db.role.findMany({
|
||||
where: {
|
||||
type: "app",
|
||||
OR: [{ tenantId: null }, { tenantId }],
|
||||
...(shouldGrantAllAppRoles ? {} : { assignToNewUsers: true }),
|
||||
},
|
||||
orderBy: {
|
||||
order: "asc",
|
||||
},
|
||||
});
|
||||
|
||||
const existingRoles = await findUserRolesByIds(
|
||||
userId,
|
||||
tenantId,
|
||||
roles.map((role) => role.id)
|
||||
);
|
||||
const existingRoleIds = new Set(existingRoles.map((role) => role.roleId));
|
||||
const missingRoles = roles.filter((role) => !existingRoleIds.has(role.id));
|
||||
if (missingRoles.length > 0) {
|
||||
await createUserRoles(
|
||||
userId,
|
||||
missingRoles.map((role) => ({ id: role.id, tenantId }))
|
||||
);
|
||||
} else {
|
||||
clearCacheKey(`userRoles:${userId}:${tenantId}`);
|
||||
}
|
||||
|
||||
return { created: missingRoles.length, roleCount: roles.length };
|
||||
}
|
||||
|
||||
export async function createUserRole(userId: string, roleId: string, tenantId: string | null = null) {
|
||||
const existing = await getUserRole(userId, roleId, tenantId);
|
||||
if (existing) {
|
||||
return existing;
|
||||
}
|
||||
try {
|
||||
const item = await db.userRole.create({
|
||||
data: {
|
||||
userId,
|
||||
roleId,
|
||||
tenantId,
|
||||
},
|
||||
});
|
||||
clearCacheKey(`userRoles:${userId}:${tenantId}`);
|
||||
return item;
|
||||
} catch (error) {
|
||||
if (!isUniqueConstraintError(error)) {
|
||||
throw error;
|
||||
}
|
||||
const createdByConcurrentRequest = await getUserRole(userId, roleId, tenantId);
|
||||
if (!createdByConcurrentRequest) {
|
||||
throw error;
|
||||
}
|
||||
return createdByConcurrentRequest;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
export async function ensureAdminUserRoleByName(userId: string, roleName: string): Promise<void> {
|
||||
const role = await db.role.findFirst({
|
||||
where: { name: roleName, type: "admin" },
|
||||
select: { id: true },
|
||||
});
|
||||
if (!role) {
|
||||
return;
|
||||
}
|
||||
await createUserRole(userId, role.id, null);
|
||||
}
|
||||
|
||||
export async function createUserRoles(userId: string, roles: { id: string; tenantId: string | null }[]) {
|
||||
return await createUserRoleAssignments(roles.map((role) => ({ userId, roleId: role.id, tenantId: role.tenantId })));
|
||||
}
|
||||
|
||||
export async function createUserRoleAssignments(assignments: UserRoleAssignment[]) {
|
||||
const uniqueAssignments = [...new Map(assignments.map((assignment) => [getUserRoleAssignmentKey(assignment), assignment])).values()].map((assignment) => ({
|
||||
userId: assignment.userId,
|
||||
roleId: assignment.roleId,
|
||||
tenantId: normalizeTenantId(assignment.tenantId),
|
||||
}));
|
||||
const cacheScopes = [...new Map(uniqueAssignments.map((assignment) => [`${assignment.userId}:${assignment.tenantId}`, assignment])).values()];
|
||||
|
||||
if (uniqueAssignments.length === 0) {
|
||||
return { count: 0 };
|
||||
}
|
||||
|
||||
const userIds = [...new Set(uniqueAssignments.map((assignment) => assignment.userId))];
|
||||
const roleIds = [...new Set(uniqueAssignments.map((assignment) => assignment.roleId))];
|
||||
const tenantIds = [...new Set(uniqueAssignments.map((assignment) => assignment.tenantId))];
|
||||
const nonNullTenantIds = tenantIds.filter((tenantId): tenantId is string => tenantId !== null);
|
||||
const tenantWhere =
|
||||
tenantIds.includes(null) && nonNullTenantIds.length > 0
|
||||
? { OR: [{ tenantId: null }, { tenantId: { in: nonNullTenantIds } }] }
|
||||
: tenantIds.includes(null)
|
||||
? { tenantId: null }
|
||||
: { tenantId: { in: nonNullTenantIds } };
|
||||
|
||||
const existingAssignments = await db.userRole.findMany({
|
||||
where: {
|
||||
userId: { in: userIds },
|
||||
roleId: { in: roleIds },
|
||||
...tenantWhere,
|
||||
},
|
||||
select: {
|
||||
userId: true,
|
||||
roleId: true,
|
||||
tenantId: true,
|
||||
},
|
||||
});
|
||||
const existingAssignmentKeys = new Set(existingAssignments.map((assignment) => getUserRoleAssignmentKey(assignment)));
|
||||
const missingAssignments = uniqueAssignments.filter((assignment) => !existingAssignmentKeys.has(getUserRoleAssignmentKey(assignment)));
|
||||
|
||||
const result =
|
||||
missingAssignments.length > 0
|
||||
? await db.userRole.createMany({
|
||||
data: missingAssignments,
|
||||
skipDuplicates: true,
|
||||
})
|
||||
: { count: 0 };
|
||||
|
||||
cacheScopes.forEach((scope) => {
|
||||
clearUserRoleCache(scope.userId, 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;
|
||||
});
|
||||
}
|
||||
|
||||
export async function deleteAllUserRoles(userId: string, type: string) {
|
||||
return await db.userRole.deleteMany({
|
||||
where: {
|
||||
userId,
|
||||
role: {
|
||||
type,
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
Reference in new issue
Block a user