Remove team account related services and actions

Removed services and actions related to team account deletion as well as updated paths within other dependent files, better reflecting their new locations. Also, added a new service titled 'AccountBillingService' for handling billing-related operations and restructured the form layout and handled translation in 'team-account-danger-zone' component.

packages/features/team-accounts/src/server/actions/create-team-account-server-actions.ts

@@ -0,0 +1,58 @@
+'use server';
+
+import { redirect } from 'next/navigation';
+
+import { z } from 'zod';
+
+import { Logger } from '@kit/shared/logger';
+import { requireAuth } from '@kit/supabase/require-auth';
+import { getSupabaseServerActionClient } from '@kit/supabase/server-actions-client';
+
+import { CreateTeamSchema } from '../../schema/create-team.schema';
+import { CreateTeamAccountService } from '../services/create-team-account.service';
+
+const TEAM_ACCOUNTS_HOME_PATH = z
+  .string({
+    required_error: 'variable TEAM_ACCOUNTS_HOME_PATH is required',
+  })
+  .min(1)
+  .parse(process.env.TEAM_ACCOUNTS_HOME_PATH);
+
+export async function createOrganizationAccountAction(
+  params: z.infer<typeof CreateTeamSchema>,
+) {
+  const { name: accountName } = CreateTeamSchema.parse(params);
+
+  const client = getSupabaseServerActionClient();
+  const service = new CreateTeamAccountService(client);
+  const session = await requireAuth(client);
+
+  if (session.error) {
+    redirect(session.redirectTo);
+  }
+
+  const userId = session.data.user.id;
+
+  const createAccountResponse = await service.createNewOrganizationAccount({
+    name: accountName,
+    userId,
+  });
+
+  if (createAccountResponse.error) {
+    Logger.error(
+      {
+        userId,
+        error: createAccountResponse.error,
+        name: 'accounts',
+      },
+      `Error creating team account`,
+    );
+
+    throw new Error('Error creating team account');
+  }
+
+  const accountHomePath =
+    TEAM_ACCOUNTS_HOME_PATH + '/' + createAccountResponse.data.slug;
+
+  redirect(accountHomePath);
+}

packages/features/team-accounts/src/server/actions/delete-team-account-server-actions.ts

@@ -0,0 +1,60 @@
+'use server';
+
+import { redirect } from 'next/navigation';
+
+import { SupabaseClient } from '@supabase/supabase-js';
+
+import { Database } from '@kit/supabase/database';
+import { requireAuth } from '@kit/supabase/require-auth';
+import { getSupabaseServerActionClient } from '@kit/supabase/server-actions-client';
+
+import { DeleteTeamAccountSchema } from '../../schema/delete-team-account.schema';
+import { DeleteTeamAccountService } from '../services/delete-team-account.service';
+
+export async function deleteTeamAccountAction(formData: FormData) {
+  const params = DeleteTeamAccountSchema.parse(
+    Object.fromEntries(formData.entries()),
+  );
+
+  const client = getSupabaseServerActionClient();
+
+  // Check if the user has the necessary permissions to delete the team account
+  await assertUserPermissionsToDeleteTeamAccount(client, params.accountId);
+
+  // Get the Supabase client and create a new service instance.
+  const service = new DeleteTeamAccountService();
+
+  // Delete the team account and all associated data.
+  await service.deleteTeamAccount(
+    getSupabaseServerActionClient({
+      admin: true,
+    }),
+    params,
+  );
+
+  return redirect('/home');
+}
+
+async function assertUserPermissionsToDeleteTeamAccount(
+  client: SupabaseClient<Database>,
+  accountId: string,
+) {
+  const auth = await requireAuth(client);
+
+  if (auth.error ?? !auth.data.user.id) {
+    throw new Error('Authentication required');
+  }
+
+  const userId = auth.data.user.id;
+
+  const { data, error } = await client
+    .from('accounts')
+    .select('id')
+    .eq('primary_owner_user_id', userId)
+    .eq('is_personal_account', false)
+    .eq('id', accountId);
+
+  if (error ?? !data) {
+    throw new Error('Account not found');
+  }
+}

packages/features/team-accounts/src/server/actions/leave-team-account-server-actions.ts

@@ -0,0 +1,16 @@
+'use server';
+
+import { getSupabaseServerActionClient } from '@kit/supabase/server-actions-client';
+
+import { LeaveTeamAccountSchema } from '../../schema/leave-team-account.schema';
+import { LeaveAccountService } from '../services/leave-account.service';
+
+export async function leaveTeamAccountAction(formData: FormData) {
+  const body = Object.fromEntries(formData.entries());
+  const params = LeaveTeamAccountSchema.parse(body);
+  const service = new LeaveAccountService(getSupabaseServerActionClient());
+
+  await service.leaveTeamAccount(params);
+
+  return { success: true };
+}

packages/features/team-accounts/src/server/actions/team-details-server-actions.ts

@@ -0,0 +1,39 @@
+'use server';
+
+import { redirect } from 'next/navigation';
+
+import { getSupabaseServerComponentClient } from '@kit/supabase/server-component-client';
+
+export async function updateTeamAccountName(params: {
+  name: string;
+  slug: string;
+  path: string;
+}) {
+  const client = getSupabaseServerComponentClient();
+
+  const { error, data } = await client
+    .from('accounts')
+    .update({
+      name: params.name,
+      slug: params.slug,
+    })
+    .match({
+      slug: params.slug,
+    })
+    .select('slug')
+    .single();
+
+  if (error) {
+    throw error;
+  }
+
+  const newSlug = data.slug;
+
+  if (newSlug) {
+    const path = params.path.replace('[account]', newSlug);
+
+    redirect(path);
+  }
+
+  return { success: true };
+}

packages/features/team-accounts/src/server/actions/team-invitations-server-actions.ts

@@ -0,0 +1,89 @@
+'use server';
+
+import { revalidatePath } from 'next/cache';
+
+import { SupabaseClient } from '@supabase/supabase-js';
+
+import { z } from 'zod';
+
+import { Database } from '@kit/supabase/database';
+import { getSupabaseServerActionClient } from '@kit/supabase/server-actions-client';
+
+import { DeleteInvitationSchema } from '../../schema/delete-invitation.schema';
+import { InviteMembersSchema } from '../../schema/invite-members.schema';
+import { UpdateInvitationSchema } from '../../schema/update-invitation-schema';
+import { AccountInvitationsService } from '../services/account-invitations.service';
+
+/**
+ * Creates invitations for inviting members.
+ */
+export async function createInvitationsAction(params: {
+  account: string;
+  invitations: z.infer<typeof InviteMembersSchema>['invitations'];
+}) {
+  const client = getSupabaseServerActionClient();
+
+  await assertSession(client);
+
+  const { invitations } = InviteMembersSchema.parse({
+    invitations: params.invitations,
+  });
+
+  const service = new AccountInvitationsService(client);
+
+  await service.sendInvitations({ invitations, account: params.account });
+
+  revalidatePath('/home/[account]/members', 'page');
+
+  return { success: true };
+}
+
+/**
+ * Deletes an invitation specified by the invitation ID.
+ *
+ * @param {Object} params - The parameters for the method.
+ * @param {string} params.invitationId - The ID of the invitation to be deleted.
+ *
+ * @return {Object} - The result of the delete operation.
+ */
+export async function deleteInvitationAction(
+  params: z.infer<typeof DeleteInvitationSchema>,
+) {
+  const invitation = DeleteInvitationSchema.parse(params);
+
+  const client = getSupabaseServerActionClient();
+  const { data, error } = await client.auth.getUser();
+
+  if (error ?? !data.user) {
+    throw new Error(`Authentication required`);
+  }
+
+  const service = new AccountInvitationsService(client);
+
+  await service.deleteInvitation(invitation);
+
+  return { success: true };
+}
+
+export async function updateInvitationAction(
+  params: z.infer<typeof UpdateInvitationSchema>,
+) {
+  const client = getSupabaseServerActionClient();
+  const invitation = UpdateInvitationSchema.parse(params);
+
+  await assertSession(client);
+
+  const service = new AccountInvitationsService(client);
+
+  await service.updateInvitation(invitation);
+
+  return { success: true };
+}
+
+async function assertSession(client: SupabaseClient<Database>) {
+  const { data, error } = await client.auth.getUser();
+
+  if (error ?? !data.user) {
+    throw new Error(`Authentication required`);
+  }
+}

packages/features/team-accounts/src/server/actions/team-members-server-actions.ts

@@ -0,0 +1,75 @@
+'use server';
+
+import { SupabaseClient } from '@supabase/supabase-js';
+
+import { Database } from '@kit/supabase/database';
+import { getSupabaseServerActionClient } from '@kit/supabase/server-actions-client';
+
+import { AccountMembersService } from '../services/account-members.service';
+
+export async function removeMemberFromAccountAction(params: {
+  accountId: string;
+  userId: string;
+}) {
+  const client = getSupabaseServerActionClient();
+  const { data, error } = await client.auth.getUser();
+
+  if (error ?? !data.user) {
+    throw new Error(`Authentication required`);
+  }
+
+  const service = new AccountMembersService(client);
+
+  await service.removeMemberFromAccount({
+    accountId: params.accountId,
+    userId: params.userId,
+  });
+
+  return { success: true };
+}
+
+export async function updateMemberRoleAction(params: {
+  accountId: string;
+  userId: string;
+  role: Database['public']['Enums']['account_role'];
+}) {
+  const client = getSupabaseServerActionClient();
+
+  await assertSession(client);
+
+  const service = new AccountMembersService(client);
+
+  await service.updateMemberRole({
+    accountId: params.accountId,
+    userId: params.userId,
+    role: params.role,
+  });
+
+  return { success: true };
+}
+
+export async function transferOwnershipAction(params: {
+  accountId: string;
+  userId: string;
+}) {
+  const client = getSupabaseServerActionClient();
+
+  await assertSession(client);
+
+  const service = new AccountMembersService(client);
+
+  await service.transferOwnership({
+    accountId: params.accountId,
+    userId: params.userId,
+  });
+
+  return { success: true };
+}
+
+async function assertSession(client: SupabaseClient<Database>) {
+  const { data, error } = await client.auth.getUser();
+
+  if (error ?? !data.user) {
+    throw new Error(`Authentication required`);
+  }
+}

packages/features/team-accounts/src/server/services/account-invitations.service.ts

@@ -0,0 +1,222 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+
+import 'server-only';
+import { z } from 'zod';
+
+import { Mailer } from '@kit/mailers';
+import { Logger } from '@kit/shared/logger';
+import { Database } from '@kit/supabase/database';
+
+import { DeleteInvitationSchema } from '../../schema/delete-invitation.schema';
+import { InviteMembersSchema } from '../../schema/invite-members.schema';
+import { UpdateInvitationSchema } from '../../schema/update-invitation-schema';
+
+const invitePath = process.env.INVITATION_PAGE_PATH;
+const siteURL = process.env.NEXT_PUBLIC_SITE_URL;
+const productName = process.env.NEXT_PUBLIC_PRODUCT_NAME ?? '';
+const emailSender = process.env.EMAIL_SENDER;
+
+const env = z
+  .object({
+    invitePath: z.string().min(1),
+    siteURL: z.string().min(1),
+    productName: z.string(),
+    emailSender: z.string().email(),
+  })
+  .parse({
+    invitePath,
+    siteURL,
+    productName,
+    emailSender,
+  });
+
+export class AccountInvitationsService {
+  private namespace = 'accounts.invitations';
+
+  constructor(private readonly client: SupabaseClient<Database>) {}
+
+  async deleteInvitation(params: z.infer<typeof DeleteInvitationSchema>) {
+    Logger.info('Removing invitation', {
+      name: this.namespace,
+      ...params,
+    });
+
+    const { data, error } = await this.client
+      .from('invitations')
+      .delete()
+      .match({
+        id: params.invitationId,
+      });
+
+    if (error) {
+      throw error;
+    }
+
+    Logger.info('Invitation successfully removed', {
+      ...params,
+      name: this.namespace,
+    });
+
+    return data;
+  }
+
+  async updateInvitation(params: z.infer<typeof UpdateInvitationSchema>) {
+    Logger.info('Updating invitation', {
+      ...params,
+      name: this.namespace,
+    });
+
+    const { data, error } = await this.client
+      .from('invitations')
+      .update({
+        role: params.role,
+      })
+      .match({
+        id: params.invitationId,
+      });
+
+    if (error) {
+      throw error;
+    }
+
+    Logger.info('Invitation successfully updated', {
+      ...params,
+      name: this.namespace,
+    });
+
+    return data;
+  }
+
+  async sendInvitations({
+    account,
+    invitations,
+  }: {
+    invitations: z.infer<typeof InviteMembersSchema>['invitations'];
+    account: string;
+  }) {
+    Logger.info(
+      { account, invitations, name: this.namespace },
+      'Storing invitations',
+    );
+
+    const mailer = new Mailer();
+
+    const { user } = await this.getUser();
+
+    const accountResponse = await this.client
+      .from('accounts')
+      .select('name')
+      .eq('slug', account)
+      .single();
+
+    if (!accountResponse.data) {
+      throw new Error('Account not found');
+    }
+
+    const response = await this.client.rpc('add_invitations_to_account', {
+      invitations,
+      account_slug: account,
+    });
+
+    if (response.error) {
+      throw response.error;
+    }
+
+    const promises = [];
+
+    const responseInvitations = Array.isArray(response.data)
+      ? response.data
+      : [response.data];
+
+    Logger.info(
+      {
+        account,
+        count: responseInvitations.length,
+        name: this.namespace,
+      },
+      'Invitations added to account',
+    );
+
+    Logger.info(
+      {
+        account,
+        count: responseInvitations.length,
+        name: this.namespace,
+      },
+      'Sending invitation emails...',
+    );
+
+    for (const invitation of responseInvitations) {
+      const promise = async () => {
+        try {
+          const { renderInviteEmail } = await import('@kit/email-templates');
+
+          const html = renderInviteEmail({
+            link: this.getInvitationLink(invitation.invite_token),
+            invitedUserEmail: invitation.email,
+            inviter: user.email,
+            productName: env.productName,
+            teamName: accountResponse.data.name,
+          });
+
+          await mailer.sendEmail({
+            from: env.emailSender,
+            to: invitation.email,
+            subject: 'You have been invited to join a team',
+            html,
+          });
+
+          Logger.info('Invitation email sent', {
+            email: invitation.email,
+            account,
+            name: this.namespace,
+          });
+
+          return {
+            success: true,
+          };
+        } catch (error) {
+          console.error(error);
+          Logger.warn(
+            { account, error, name: this.namespace },
+            'Failed to send invitation email',
+          );
+
+          return {
+            error,
+            success: false,
+          };
+        }
+      };
+
+      promises.push(promise);
+    }
+
+    const responses = await Promise.all(promises.map((promise) => promise()));
+    const success = responses.filter((response) => response.success).length;
+
+    Logger.info(
+      {
+        name: this.namespace,
+        account,
+        success,
+        failed: responses.length - success,
+      },
+      `Invitations processed`,
+    );
+  }
+
+  private async getUser() {
+    const { data, error } = await this.client.auth.getUser();
+
+    if (error ?? !data) {
+      throw new Error('Authentication required');
+    }
+
+    return data;
+  }
+
+  private getInvitationLink(token: string) {
+    return new URL(env.invitePath, env.siteURL).href + `?token=${token}`;
+  }
+}

packages/features/team-accounts/src/server/services/account-members.service.ts

@@ -0,0 +1,65 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+
+import 'server-only';
+
+import { Database } from '@kit/supabase/database';
+
+export class AccountMembersService {
+  constructor(private readonly client: SupabaseClient<Database>) {}
+
+  async removeMemberFromAccount(params: { accountId: string; userId: string }) {
+    const { data, error } = await this.client
+      .from('accounts_memberships')
+      .delete()
+      .match({
+        id: params.accountId,
+        user_id: params.userId,
+      });
+
+    if (error) {
+      throw error;
+    }
+
+    return data;
+  }
+
+  async updateMemberRole(params: {
+    accountId: string;
+    userId: string;
+    role: Database['public']['Enums']['account_role'];
+  }) {
+    const { data, error } = await this.client
+      .from('accounts_memberships')
+      .update({
+        account_role: params.role,
+      })
+      .match({
+        account_id: params.accountId,
+        user_id: params.userId,
+      });
+
+    if (error) {
+      throw error;
+    }
+
+    return data;
+  }
+
+  async transferOwnership(params: { accountId: string; userId: string }) {
+    const { data, error } = await this.client
+      .from('accounts')
+      .update({
+        primary_owner_user_id: params.userId,
+      })
+      .match({
+        id: params.accountId,
+        user_id: params.userId,
+      });
+
+    if (error) {
+      throw error;
+    }
+
+    return data;
+  }
+}

packages/features/team-accounts/src/server/services/create-team-account.service.ts

@@ -0,0 +1,21 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+
+import { Logger } from '@kit/shared/logger';
+import { Database } from '@kit/supabase/database';
+
+export class CreateTeamAccountService {
+  private readonly namespace = 'accounts.create-team-account';
+
+  constructor(private readonly client: SupabaseClient<Database>) {}
+
+  createNewOrganizationAccount(params: { name: string; userId: string }) {
+    Logger.info(
+      { ...params, namespace: this.namespace },
+      `Creating new team account...`,
+    );
+
+    return this.client.rpc('create_account', {
+      account_name: params.name,
+    });
+  }
+}

packages/features/team-accounts/src/server/services/delete-team-account.service.ts

@@ -0,0 +1,73 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+
+import 'server-only';
+
+import { AccountBillingService } from '@kit/billing-gateway';
+import { Logger } from '@kit/shared/logger';
+import { Database } from '@kit/supabase/database';
+
+export class DeleteTeamAccountService {
+  private readonly namespace = 'accounts.delete';
+
+  /**
+   * Deletes a team account. Permissions are not checked here, as they are
+   * checked in the server action.
+   *
+   * USE WITH CAUTION. THE USER MUST HAVE THE NECESSARY PERMISSIONS.
+   *
+   * @param adminClient
+   * @param params
+   */
+  async deleteTeamAccount(
+    adminClient: SupabaseClient<Database>,
+    params: { accountId: string },
+  ) {
+    Logger.info(
+      {
+        name: this.namespace,
+        accountId: params.accountId,
+      },
+      `Requested team account deletion. Processing...`,
+    );
+
+    Logger.info(
+      {
+        name: this.namespace,
+        accountId: params.accountId,
+      },
+      `Deleting all account subscriptions...`,
+    );
+
+    // First - we want to cancel all Stripe active subscriptions
+    const billingService = new AccountBillingService(adminClient);
+
+    await billingService.cancelAllAccountSubscriptions(params.accountId);
+
+    // now we can use the admin client to delete the account.
+    const { error } = await adminClient
+      .from('accounts')
+      .delete()
+      .eq('id', params.accountId);
+
+    if (error) {
+      Logger.error(
+        {
+          name: this.namespace,
+          accountId: params.accountId,
+          error,
+        },
+        'Failed to delete team account',
+      );
+
+      throw new Error('Failed to delete team account');
+    }
+
+    Logger.info(
+      {
+        name: this.namespace,
+        accountId: params.accountId,
+      },
+      'Successfully deleted team account',
+    );
+  }
+}

packages/features/team-accounts/src/server/services/leave-account.service.ts

@@ -0,0 +1,14 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+
+import 'server-only';
+
+import { Database } from '@kit/supabase/database';
+
+export class LeaveAccountService {
+  constructor(private readonly client: SupabaseClient<Database>) {}
+
+  async leaveTeamAccount(params: { accountId: string; userId: string }) {
+    // TODO
+    // implement this method
+  }
+}