Skip to content

🐸 Rybbit - open-source and privacy-friendly alternative to Google Analytics that is 10x more intuitive.

5.3 KB
Raw Blame
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" });
  }
}