🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.
TypeScript analyticsautogenevaluationlangchainlarge-language-modelsllama-indexllmllm-evaluationllm-observabilityllmopsmonitoringobservabilityopen-sourceopenaiplaygroundprompt-engineeringprompt-managementself-hostedycombinator
import {
SystemRole,
type Prisma,
type RoleAssignment as StoredRoleAssignment,
} from "@prisma/client";
import { InvalidRequestError } from "../../errors/InvalidRequestError";
import { NotImplementedError } from "../../errors/NotImplementedError";
import { withTransaction } from "../../server/utils/withTransaction";
import {
hasApiKeyKind,
hasOrganizationKind,
hasSystemRoleKind,
untag,
type PrincipalId,
type OwnerId,
type RoleAssignment,
type RoleId,
type TenantId,
} from "./types";
/** getRoleAssignmentsForPrincipal loads a principal's stored assignments. */
export async function getRoleAssignmentsForPrincipal(
tx: Prisma.TransactionClient,
principalId: PrincipalId,
): Promise<StoredRoleAssignment[]> {
return await tx.roleAssignment.findMany({
where: { principalId },
});
}
/** assignRole persists a system-role assignment in the supplied tenant. */
export async function assignRole(
prisma: Prisma.TransactionClient,
ra: Omit<RoleAssignment, "id" | "createdAt" | "updatedAt">,
): Promise<StoredRoleAssignment> {
const roleFields = validateRole(ra.roleId);
return await withTransaction(prisma, async (tx) => {
const ownerAndTenantFields = await validateTenancy(
tx,
ra.tenantId,
ra.ownerId,
);
return await tx.roleAssignment.create({
data: {
...ownerAndTenantFields,
...principalFields(ra.principalId),
...roleFields,
},
});
});
}
/** transferRoleAssignments moves a transferred project's api-key assignments to the destination organization and drops its user assignments, mirroring the membership wipe. */
export async function transferRoleAssignments(
prisma: Prisma.TransactionClient,
projectId: string,
targetOrgId: string,
): Promise<void> {
await withTransaction(prisma, async (tx) => {
await tx.roleAssignment.updateMany({
where: { projectId, apiKeyId: { not: null } },
data: { orgId: targetOrgId },
});
await tx.roleAssignment.deleteMany({
where: { projectId, userId: { not: null } },
});
});
}
/** validateTenancy holds project ownership stable until the transaction ends. */
async function validateTenancy(
tx: Prisma.TransactionClient,
tenantId: TenantId,
ownerId: OwnerId,
) {
const orgId = untag(tenantId);
if (hasOrganizationKind(ownerId)) {
if (ownerId !== tenantId) {
throw new InvalidRequestError(
"Role assignment owner must belong to its tenant",
);
}
return { orgId, ownerId, projectId: null };
}
const projectId = untag(ownerId);
const projects = await tx.$queryRaw<{ id: string }[]>`
SELECT id FROM projects
WHERE id = ${projectId} AND org_id = ${orgId}
FOR SHARE
`;
if (projects.length === 0) {
throw new InvalidRequestError(
"Role assignment owner must belong to its tenant",
);
}
return { orgId, ownerId, projectId };
}
/** principalFields pairs a tagged principal with its foreign key. */
function principalFields(principalId: PrincipalId) {
return hasApiKeyKind(principalId)
? { principalId, apiKeyId: untag(principalId) }
: { principalId, userId: untag(principalId) };
}
/** validateRole rejects unsupported roles and returns their storage fields. */
function validateRole(roleId: RoleId) {
if (!hasSystemRoleKind(roleId)) {
throw new NotImplementedError("custom roles not yet supported");
}
const systemRole = Object.values(SystemRole).find(
(role) => role === untag(roleId),
);
if (systemRole === undefined) {
throw new InvalidRequestError("Unknown system role");
}
return { roleId, systemRole };
}