🐸 Rybbit - open-source and privacy-friendly alternative to Google Analytics that is 10x more intuitive.
import { isSiteGrantRole, SITE_GRANT_ROLES } from "@rybbit/shared";
import { eq, and, inArray } from "drizzle-orm";
import { FastifyReply, FastifyRequest } from "fastify";
import { db } from "../../db/postgres/postgres.js";
import { team, teamMember, teamSiteAccess, member, sites } from "../../db/postgres/schema.js";
import { teamMembershipKey } from "../../lib/teamMembership.js";
import { invalidateSitesAccessCache } from "../../lib/auth-utils.js";
interface UpdateTeamBody {
name?: string;
memberUserIds?: string[];
siteIds?: number[];
/** Role the team's members get on its sites (editor, member or viewer); null for each member's organization role; omit to keep. */
siteRole?: string | null;
}
export async function updateTeam(
request: FastifyRequest<{
Params: { organizationId: string; teamId: string };
Body: UpdateTeamBody;
}>,
reply: FastifyReply
) {
const { organizationId, teamId } = request.params;
const { name, siteIds, siteRole } = request.body;
const memberUserIds = request.body.memberUserIds === undefined ? undefined : [...new Set(request.body.memberUserIds)];
if (siteRole !== undefined && siteRole !== null && !isSiteGrantRole(siteRole)) {
return reply.status(400).send({ error: `siteRole must be one of: ${SITE_GRANT_ROLES.join(", ")}` });
}
try {
// Verify team belongs to org
const teamRecord = await db
.select()
.from(team)
.where(and(eq(team.id, teamId), eq(team.organizationId, organizationId)))
.limit(1);
if (teamRecord.length === 0) {
return reply.status(404).send({ error: "Team not found" });
}
// Get existing members before update (for cache invalidation)
const existingMembers = await db
.select({ userId: teamMember.userId })
.from(teamMember)
.where(eq(teamMember.teamId, teamId));
const existingUserIds = existingMembers.map(m => m.userId);
// Validate memberUserIds are org members
if (memberUserIds && memberUserIds.length > 0) {
const orgMembers = await db
.select({ userId: member.userId })
.from(member)
.where(and(eq(member.organizationId, organizationId), inArray(member.userId, memberUserIds)));
const validUserIds = new Set(orgMembers.map(m => m.userId));
const invalidUserIds = memberUserIds.filter(id => !validUserIds.has(id));
if (invalidUserIds.length > 0) {
return reply.status(400).send({
error: `Users not in organization: ${invalidUserIds.join(", ")}`,
});
}
}
// Validate siteIds belong to org
if (siteIds && siteIds.length > 0) {
const orgSites = await db
.select({ siteId: sites.siteId })
.from(sites)
.where(and(eq(sites.organizationId, organizationId), inArray(sites.siteId, siteIds)));
const validSiteIds = new Set(orgSites.map(s => s.siteId));
const invalidSiteIds = siteIds.filter(id => !validSiteIds.has(id));
if (invalidSiteIds.length > 0) {
return reply.status(400).send({
error: `Sites not in organization: ${invalidSiteIds.join(", ")}`,
});
}
}
const now = new Date().toISOString();
await db.transaction(async tx => {
// Update team name
const updates: Record<string, string | number> = { updatedAt: now };
if (name !== undefined) {
updates.name = name.trim();
}
if (memberUserIds !== undefined) updates.memberCount = memberUserIds.length;
await tx.update(team).set(updates).where(eq(team.id, teamId));
// Replace members if provided
if (memberUserIds !== undefined) {
await tx.delete(teamMember).where(eq(teamMember.teamId, teamId));
if (memberUserIds.length > 0) {
await tx.insert(teamMember).values(
memberUserIds.map(userId => ({
id: crypto.randomUUID(),
teamId,
userId,
membershipKey: teamMembershipKey(teamId, userId),
createdAt: now,
}))
);
}
}
// Replace sites if provided, keeping the team's site role unless a new
// one was given.
if (siteIds !== undefined) {
let role: string | null = siteRole ?? null;
if (siteRole === undefined) {
const [current] = await tx
.select({ role: teamSiteAccess.role })
.from(teamSiteAccess)
.where(eq(teamSiteAccess.teamId, teamId))
.limit(1);
role = current?.role ?? null;
}
await tx.delete(teamSiteAccess).where(eq(teamSiteAccess.teamId, teamId));
if (siteIds.length > 0) {
await tx.insert(teamSiteAccess).values(
siteIds.map(siteId => ({
teamId,
siteId,
role,
}))
);
}
} else if (siteRole !== undefined) {
await tx.update(teamSiteAccess).set({ role: siteRole }).where(eq(teamSiteAccess.teamId, teamId));
}
});
// Invalidate cache for all affected users (old + new members)
const allAffectedUserIds = new Set([...existingUserIds, ...(memberUserIds || [])]);
for (const userId of allAffectedUserIds) {
invalidateSitesAccessCache(userId);
}
return reply.status(200).send({ success: true });
} catch (error) {
request.log.error({ err: error }, "Error updating team");
return reply.status(500).send({ error: "Failed to update team" });
}
}