feat: implement account management features and repositories

- Introduced AccountProvider interface for managing email accounts, including methods for creating, deleting, and updating accounts and addresses.
- Added AccountService to handle business logic for account operations, including address management and primary address setting.
- Created repositories for account, address, and domain management, integrating with Sequelize for data persistence.
- Defined domain models for MailAccount, MailAddress, and MailDomain to structure account-related data.
- Updated .env.template to include new configuration parameters for Stalwart account management.

Author: jzunigax2

.env.template

@@ -11,7 +11,8 @@ RDS_PASSWORD=example
 # Stalwart
 STALWART_JMAP_URL=http://localhost:8085
 STALWART_ADMIN_URL=http://localhost:8085
-STALWART_ADMIN_TOKEN=
+STALWART_ADMIN_USER=
+STALWART_ADMIN_SECRET=
 
 # Auth
 JWT_SECRET=

…c/modules/email/account-provider.port.ts …modules/account/account-provider.port.tssrc/modules/email/account-provider.port.ts renamed to src/modules/account/account-provider.port.ts src/modules/email/account-provider.port.ts renamed to src/modules/account/account-provider.port.ts

@@ -10,7 +10,4 @@ export abstract class AccountProvider {
     currentName: string,
     newPrimaryAddress: string,
   ): Promise<void>;
-  abstract updateQuota(name: string, bytes: number): Promise<void>;
-  abstract createDomain(domain: string): Promise<void>;
-  abstract deleteDomain(domain: string): Promise<void>;
 }

src/modules/account/account.module.ts

@@ -1,11 +1,16 @@
 import { Module } from '@nestjs/common';
 import { SequelizeModule } from '@nestjs/sequelize';
+import { StalwartModule } from '../infrastructure/stalwart/stalwart.module.js';
+import { AccountService } from './account.service.js';
 import {
   MailAccountModel,
   MailAddressModel,
   MailDomainModel,
   MailProviderAccountModel,
 } from './models/index.js';
+import { AccountRepository } from './repositories/account.repository.js';
+import { AddressRepository } from './repositories/address.repository.js';
+import { DomainRepository } from './repositories/domain.repository.js';
 
 @Module({
   imports: [
@@ -15,7 +20,14 @@ import {
       MailDomainModel,
       MailProviderAccountModel,
     ]),
+    StalwartModule,
   ],
-  exports: [SequelizeModule],
+  providers: [
+    AccountRepository,
+    AddressRepository,
+    DomainRepository,
+    AccountService,
+  ],
+  exports: [AccountService],
 })
 export class AccountModule {}

src/modules/account/account.service.ts

@@ -0,0 +1,167 @@
+import {
+  ConflictException,
+  Injectable,
+  Logger,
+  NotFoundException,
+  UnprocessableEntityException,
+} from '@nestjs/common';
+import { AccountProvider } from './account-provider.port.js';
+import { MailAccount } from './domain/mail-account.domain.js';
+import { AccountRepository } from './repositories/account.repository.js';
+import { AddressRepository } from './repositories/address.repository.js';
+import { DomainRepository } from './repositories/domain.repository.js';
+
+@Injectable()
+export class AccountService {
+  private readonly logger = new Logger(AccountService.name);
+
+  constructor(
+    private readonly provider: AccountProvider,
+    private readonly accounts: AccountRepository,
+    private readonly addresses: AddressRepository,
+    private readonly domains: DomainRepository,
+  ) {}
+
+  async getAccount(driveUserUuid: string): Promise<MailAccount> {
+    return this.getAccountOrFail(driveUserUuid);
+  }
+
+  async deleteAccount(driveUserUuid: string): Promise<void> {
+    const account = await this.getAccountOrFail(driveUserUuid);
+
+    if (account.principalName) {
+      await this.provider.deleteAccount(account.principalName);
+    }
+
+    await this.accounts.delete(account.id);
+    this.logger.log(`Deleted account for drive user '${driveUserUuid}'`);
+  }
+
+  async addAddress(
+    driveUserUuid: string,
+    address: string,
+    domainName: string,
+  ): Promise<void> {
+    const [account, domain, existing] = await Promise.all([
+      this.accounts.findByDriveUserUuid(driveUserUuid),
+      this.domains.findByDomain(domainName),
+      this.addresses.findByAddress(address),
+    ]);
+
+    if (!account) {
+      throw new NotFoundException(
+        `No mail account for drive user '${driveUserUuid}'`,
+      );
+    }
+    const principalName = this.requirePrincipalName(account);
+
+    if (!domain) {
+      throw new NotFoundException(`Domain '${domainName}' not found`);
+    }
+    if (existing) {
+      throw new ConflictException(`Address '${address}' already exists`);
+    }
+
+    const newAddress = await this.addresses.create({
+      mailAccountId: account.id,
+      address,
+      domainId: domain.id,
+      isDefault: false,
+    });
+
+    try {
+      await this.provider.addAddress(principalName, address);
+    } catch (error) {
+      await this.addresses.delete(newAddress.id);
+      throw error;
+    }
+
+    await this.addresses.createProviderLink({
+      mailAddressId: newAddress.id,
+      provider: 'stalwart',
+      externalId: principalName,
+    });
+
+    this.logger.log(`Added address '${address}' to account '${driveUserUuid}'`);
+  }
+
+  async removeAddress(driveUserUuid: string, address: string): Promise<void> {
+    const account = await this.getAccountOrFail(driveUserUuid);
+
+    const addressRecord = account.addresses.find((a) => a.address === address);
+    if (!addressRecord) {
+      throw new NotFoundException(
+        `Address '${address}' not found for this account`,
+      );
+    }
+
+    if (addressRecord.isDefault) {
+      throw new UnprocessableEntityException(
+        'Cannot remove the default address',
+      );
+    }
+
+    const principalName = this.requirePrincipalName(account);
+
+    await this.provider.removeAddress(principalName, address);
+    await Promise.all([
+      this.addresses.deleteProviderLink(addressRecord.id),
+      this.addresses.delete(addressRecord.id),
+    ]);
+
+    this.logger.log(
+      `Removed address '${address}' from account '${driveUserUuid}'`,
+    );
+  }
+
+  async setPrimaryAddress(
+    driveUserUuid: string,
+    newAddress: string,
+  ): Promise<void> {
+    const account = await this.getAccountOrFail(driveUserUuid);
+
+    const addressRecord = account.addresses.find(
+      (a) => a.address === newAddress,
+    );
+    if (!addressRecord) {
+      throw new NotFoundException(
+        `Address '${newAddress}' not found for this account`,
+      );
+    }
+
+    if (addressRecord.isDefault) return;
+
+    const oldPrincipalName = this.requirePrincipalName(account);
+
+    await this.provider.setPrimaryAddress(oldPrincipalName, newAddress);
+
+    await Promise.all([
+      this.addresses.setDefault(addressRecord.id, account.id),
+      this.addresses.updateAllProviderExternalIds(account.id, newAddress),
+    ]);
+
+    this.logger.log(
+      `Set primary address to '${newAddress}' for account '${driveUserUuid}'`,
+    );
+  }
+
+  private async getAccountOrFail(driveUserUuid: string): Promise<MailAccount> {
+    const account = await this.accounts.findByDriveUserUuid(driveUserUuid);
+    if (!account) {
+      throw new NotFoundException(
+        `No mail account for drive user '${driveUserUuid}'`,
+      );
+    }
+    return account;
+  }
+
+  private requirePrincipalName(account: MailAccount): string {
+    const name = account.principalName;
+    if (!name) {
+      throw new UnprocessableEntityException(
+        'Account has no primary address with a provider link',
+      );
+    }
+    return name;
+  }
+}

src/modules/email/account.types.ts src/modules/account/account.types.tssrc/modules/email/account.types.ts renamed to src/modules/account/account.types.ts

@@ -0,0 +1,37 @@
+import {
+  MailAddress,
+  type MailAddressAttributes,
+} from './mail-address.domain.js';
+
+export interface MailAccountAttributes {
+  id: string;
+  driveUserUuid: string;
+  addresses: MailAddressAttributes[];
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export class MailAccount {
+  readonly id!: string;
+  readonly driveUserUuid!: string;
+  readonly addresses!: MailAddress[];
+  readonly createdAt!: Date;
+  readonly updatedAt!: Date;
+
+  private constructor(attributes: MailAccountAttributes) {
+    Object.assign(this, attributes);
+    this.addresses = attributes.addresses.map((a) => MailAddress.build(a));
+  }
+
+  static build(attributes: MailAccountAttributes): MailAccount {
+    return new MailAccount(attributes);
+  }
+
+  get defaultAddress(): MailAddress | undefined {
+    return this.addresses.find((a) => a.isDefault);
+  }
+
+  get principalName(): string | null {
+    return this.defaultAddress?.providerExternalId ?? null;
+  }
+}

src/modules/account/domain/mail-account.domain.ts

@@ -0,0 +1,29 @@
+export interface MailAddressAttributes {
+  id: string;
+  mailAccountId: string;
+  address: string;
+  domainId: string;
+  isDefault: boolean;
+  providerExternalId: string | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export class MailAddress {
+  readonly id!: string;
+  readonly mailAccountId!: string;
+  readonly address!: string;
+  readonly domainId!: string;
+  readonly isDefault!: boolean;
+  readonly providerExternalId!: string | null;
+  readonly createdAt!: Date;
+  readonly updatedAt!: Date;
+
+  private constructor(attributes: MailAddressAttributes) {
+    Object.assign(this, attributes);
+  }
+
+  static build(attributes: MailAddressAttributes): MailAddress {
+    return new MailAddress(attributes);
+  }
+}

src/modules/account/domain/mail-address.domain.ts

@@ -0,0 +1,23 @@
+export interface MailDomainAttributes {
+  id: string;
+  domain: string;
+  status: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export class MailDomain {
+  readonly id!: string;
+  readonly domain!: string;
+  readonly status!: string;
+  readonly createdAt!: Date;
+  readonly updatedAt!: Date;
+
+  private constructor(attributes: MailDomainAttributes) {
+    Object.assign(this, attributes);
+  }
+
+  static build(attributes: MailDomainAttributes): MailDomain {
+    return new MailDomain(attributes);
+  }
+}

src/modules/account/domain/mail-domain.domain.ts

@@ -0,0 +1,43 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/sequelize';
+import { MailAccount } from '../domain/mail-account.domain.js';
+import { MailAccountModel } from '../models/mail-account.model.js';
+import { MailAddressModel } from '../models/mail-address.model.js';
+import { MailProviderAccountModel } from '../models/mail-provider-account.model.js';
+import { toAddressAttributes } from './address.repository.js';
+
+@Injectable()
+export class AccountRepository {
+  constructor(
+    @InjectModel(MailAccountModel)
+    private readonly accountModel: typeof MailAccountModel,
+  ) {}
+
+  async findByDriveUserUuid(uuid: string): Promise<MailAccount | null> {
+    const model = await this.accountModel.findOne({
+      where: { driveUserUuid: uuid },
+      include: [
+        {
+          model: MailAddressModel,
+          include: [MailProviderAccountModel],
+        },
+      ],
+    });
+
+    return model ? this.toDomain(model) : null;
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.accountModel.destroy({ where: { id } });
+  }
+
+  private toDomain(model: MailAccountModel): MailAccount {
+    return MailAccount.build({
+      id: model.id,
+      driveUserUuid: model.driveUserUuid,
+      createdAt: model.createdAt as Date,
+      updatedAt: model.updatedAt as Date,
+      addresses: (model.addresses ?? []).map(toAddressAttributes),
+    });
+  }
+}