Pro seat management and organization settings restructure

apps/web/actions/organization/get-subscription-details.ts

@@ -0,0 +1,74 @@
+"use server";
+
+import { db } from "@cap/database";
+import { getCurrentUser } from "@cap/database/auth/session";
+import { organizations, users } from "@cap/database/schema";
+import { stripe } from "@cap/utils";
+import type { Organisation } from "@cap/web-domain";
+import { eq } from "drizzle-orm";
+
+export type SubscriptionDetails = {
+	planName: string;
+	status: string;
+	billingInterval: "month" | "year";
+	pricePerSeat: number;
+	currentQuantity: number;
+	currentPeriodEnd: number;
+	currency: string;
+};
+
+export async function getSubscriptionDetails(
+	organizationId: Organisation.OrganisationId,
+): Promise<SubscriptionDetails | null> {
+	const user = await getCurrentUser();
+	if (!user) throw new Error("Unauthorized");
+
+	const [organization] = await db()
+		.select()
+		.from(organizations)
+		.where(eq(organizations.id, organizationId))
+		.limit(1);
+
+	if (!organization) throw new Error("Organization not found");
+	if (organization.ownerId !== user.id)
+		throw new Error("Only the owner can view subscription details");
+
+	const [owner] = await db()
+		.select({
+			stripeSubscriptionId: users.stripeSubscriptionId,
+		})
+		.from(users)
+		.where(eq(users.id, user.id))
+		.limit(1);
+
+	if (!owner?.stripeSubscriptionId) {
+		return null;
+	}
+
+	const subscription = await stripe().subscriptions.retrieve(
+		owner.stripeSubscriptionId,
+	);
+
+	if (subscription.status !== "active" && subscription.status !== "trialing") {
+		return null;
+	}
+
+	const item = subscription.items.data[0];
+	if (!item) return null;
+
+	const price = item.price;
+	const unitAmount = price.unit_amount ?? 0;
+	const interval = price.recurring?.interval === "year" ? "year" : "month";
+	const pricePerSeat =
+		interval === "year" ? unitAmount / 100 / 12 : unitAmount / 100;
+
+	return {
+		planName: "Cap Pro",
+		status: subscription.status,
+		billingInterval: interval,
+		pricePerSeat,
+		currentQuantity: item.quantity ?? 1,
+		currentPeriodEnd: subscription.current_period_end,
+		currency: price.currency,
+	};
+}

apps/web/actions/organization/send-invites.ts

@@ -5,10 +5,15 @@ import { getCurrentUser } from "@cap/database/auth/session";
 import { sendEmail } from "@cap/database/emails/config";
 import { OrganizationInvite } from "@cap/database/emails/organization-invite";
 import { nanoId } from "@cap/database/helpers";
-import { organizationInvites, organizations } from "@cap/database/schema";
+import {
+	organizationInvites,
+	organizationMembers,
+	organizations,
+	users,
+} from "@cap/database/schema";
 import { serverEnv } from "@cap/env";
 import type { Organisation } from "@cap/web-domain";
-import { eq } from "drizzle-orm";
+import { and, eq, inArray } from "drizzle-orm";
 import { revalidatePath } from "next/cache";
 
 export async function sendOrganizationInvites(
@@ -21,48 +26,136 @@ export async function sendOrganizationInvites(
 		throw new Error("Unauthorized");
 	}
 
-	const organization = await db()
+	const [organization] = await db()
 		.select()
 		.from(organizations)
 		.where(eq(organizations.id, organizationId));
 
-	if (!organization || organization.length === 0) {
+	if (!organization) {
 		throw new Error("Organization not found");
 	}
 
-	if (organization[0]?.ownerId !== user.id) {
-		throw new Error("Only the owner can send organization invites");
+	if (organization.ownerId !== user.id) {
+		throw new Error("Only the organization owner can send invites");
+	}
+
+	const MAX_INVITES = 50;
+	if (invitedEmails.length > MAX_INVITES) {
+		throw new Error(`Cannot send more than ${MAX_INVITES} invites at once`);
 	}
 
 	const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-	const validEmails = invitedEmails.filter((email) =>
-		emailRegex.test(email.trim()),
+	const validEmails = Array.from(
+		new Set(
+			invitedEmails
+				.map((email) => email.trim().toLowerCase())
+				.filter((email) => emailRegex.test(email)),
+		),
+	);
+
+	if (validEmails.length === 0) {
+		return { success: true, failedEmails: [] as string[] };
+	}
+
+	const inviteRecords = await db().transaction(async (tx) => {
+		const [existingInvites, existingMembers] = await Promise.all([
+			tx
+				.select({ invitedEmail: organizationInvites.invitedEmail })
+				.from(organizationInvites)
+				.where(
+					and(
+						eq(organizationInvites.organizationId, organizationId),
+						inArray(organizationInvites.invitedEmail, validEmails),
+					),
+				),
+			tx
+				.select({ email: users.email })
+				.from(organizationMembers)
+				.innerJoin(users, eq(organizationMembers.userId, users.id))
+				.where(
+					and(
+						eq(organizationMembers.organizationId, organizationId),
+						inArray(users.email, validEmails),
+					),
+				),
+		]);
+
+		const existingInviteEmails = new Set(
+			existingInvites.map((i) => i.invitedEmail.toLowerCase()),
+		);
+
+		const existingMemberEmails = new Set(
+			existingMembers.map((m) => m.email.toLowerCase()),
+		);
+
+		const emailsToInvite = validEmails.filter(
+			(email) =>
+				!existingInviteEmails.has(email) && !existingMemberEmails.has(email),
+		);
+
+		const records = emailsToInvite.map((email) => ({
+			id: nanoId(),
+			email,
+		}));
+
+		if (records.length > 0) {
+			await tx.insert(organizationInvites).values(
+				records.map((r) => ({
+					id: r.id,
+					organizationId: organizationId,
+					invitedEmail: r.email,
+					invitedByUserId: user.id,
+					role: "member" as const,
+				})),
+			);
+		}
+
+		return records;
+	});
+
+	const emailResults = await Promise.allSettled(
+		inviteRecords.map((record) => {
+			const inviteUrl = `${serverEnv().WEB_URL}/invite/${record.id}`;
+			return sendEmail({
+				email: record.email,
+				subject: `Invitation to join ${organization.name} on Cap`,
+				react: OrganizationInvite({
+					email: record.email,
+					url: inviteUrl,
+					organizationName: organization.name,
+				}),
+			});
+		}),
+	);
+
+	const failedInvites = inviteRecords.filter(
+		(_, i) => emailResults[i]?.status === "rejected",
 	);
+	const failedEmails = failedInvites.map((r) => r.email);
 
-	for (const email of validEmails) {
-		const inviteId = nanoId();
-		await db().insert(organizationInvites).values({
-			id: inviteId,
-			organizationId: organizationId,
-			invitedEmail: email.trim(),
-			invitedByUserId: user.id,
-			role: "member",
-		});
-
-		// Send invitation email
-		const inviteUrl = `${serverEnv().WEB_URL}/invite/${inviteId}`;
-		await sendEmail({
-			email: email.trim(),
-			subject: `Invitation to join ${organization[0].name} on Cap`,
-			react: OrganizationInvite({
-				email: email.trim(),
-				url: inviteUrl,
-				organizationName: organization[0].name,
-			}),
-		});
+	if (failedInvites.length > 0) {
+		try {
+			await db()
+				.delete(organizationInvites)
+				.where(
+					inArray(
+						organizationInvites.id,
+						failedInvites.map((r) => r.id),
+					),
+				);
+		} catch (cleanupError) {
+			console.error(
+				"Failed to clean up invite records after email delivery failure:",
+				{
+					failedInviteIds: failedInvites.map((r) => r.id),
+					failedEmails,
+					error: cleanupError,
+				},
+			);
+		}
 	}
 
 	revalidatePath("/dashboard/settings/organization");
 
-	return { success: true };
+	return { success: true, failedEmails };
 }