Team Collaboration

// Source: lib/db/schema.ts
export type UserRole = "owner" | "admin" | "member";

export const user = pgTable("user", {
  id: text("id").primaryKey(),
  workspaceId: text("workspace_id"),
  role: text("role").notNull().default("member"),
});

// Source: lib/db/queries.ts
export async function getProjects(workspaceId: string) {
  // Returns ALL projects in workspace
  return await db
    .select()
    .from(project)
    .where(eq(project.workspaceId, workspaceId))
    .orderBy(desc(project.createdAt));
}

// Source: lib/db/schema.ts
export const project = pgTable("project", {
  id: text("id").primaryKey(),
  workspaceId: text("workspace_id").notNull(),
  userId: text("user_id").notNull(), // Project creator
  name: text("name").notNull(),
});

// Source: components/dashboard/project-card.tsx
<ProjectCard>
  <div className="flex items-center gap-2">
    <Avatar src={project.user.image} />
    <span>{project.user.name}</span>
    {project.userId === currentUser.id && (
      <Badge>You</Badge>
    )}
  </div>
</ProjectCard>

// Source: app/dashboard/page.tsx
export default async function DashboardPage() {
  const projects = await getProjects(workspace.id);
  const stats = await getProjectStats(workspace.id);
  
  return <DashboardContent projects={projects} stats={stats} />;
}

// Projects are isolated by ID
// No locking mechanism needed
// Each user's changes are independent

<ActivityFeed>
  <Activity
    user="John Doe"
    action="created project"
    target="Downtown Loft Photos"
    timestamp="2 minutes ago"
  />
  <Activity
    user="Jane Smith"
    action="completed processing"
    target="Suburban Home Video"
    timestamp="15 minutes ago"
  />
  <Activity
    user="Mike Johnson"
    action="invited member"
    target="[email protected]"
    timestamp="1 hour ago"
  />
</ActivityFeed>

// Source: lib/db/queries.ts
export async function getProjectStats(workspaceId: string) {
  const projects = await getProjects(workspaceId);
  
  return {
    totalProjects: projects.length,
    completedProjects: projects.filter(p => p.status === "completed").length,
    processingProjects: projects.filter(p => p.status === "processing").length,
    totalImages: projects.reduce((sum, p) => sum + p.imageCount, 0),
  };
}

<TeamMemberList>
  {members.map(member => (
    <MemberCard
      key={member.id}
      name={member.name}
      email={member.email}
      role={member.role}
      avatar={member.image}
      joinedAt={member.createdAt}
      onChangeRole={(newRole) => updateMemberRole(member.id, newRole)}
      onRemove={() => removeMember(member.id)}
    />
  ))}
</TeamMemberList>

// Source: lib/actions.ts
export async function updateMemberRole(
  userId: string,
  newRole: UserRole
) {
  // Verify permissions
  const currentUser = await getCurrentUser();
  if (currentUser.role !== "owner" && currentUser.role !== "admin") {
    throw new Error("Insufficient permissions");
  }
  
  // Cannot demote last owner
  if (newRole !== "owner") {
    const owners = await getWorkspaceOwners(currentUser.workspaceId);
    if (owners.length === 1 && owners[0].id === userId) {
      throw new Error("Cannot remove last owner");
    }
  }
  
  // Update role
  await db
    .update(user)
    .set({ role: newRole })
    .where(eq(user.id, userId));
}

export async function removeMember(userId: string) {
  const member = await getUserById(userId);
  
  // Transfer or delete member's projects
  const memberProjects = await getUserProjects(userId);
  
  if (memberProjects.length > 0) {
    // Option 1: Transfer to workspace owner
    const owner = await getWorkspaceOwner(member.workspaceId);
    await transferProjects(memberProjects, owner.id);
    
    // Option 2: Delete projects
    // await deleteProjects(memberProjects);
  }
  
  // Remove user from workspace
  await db
    .update(user)
    .set({ workspaceId: null, role: "member" })
    .where(eq(user.id, userId));
}