refactor: organize backend by business responsibility

src/integrations/tbank/tbank-access.service.ts

@@ -0,0 +1,107 @@
+import {
+  ConflictException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { createHash } from 'node:crypto';
+import { PrismaService } from '../../prisma/prisma.service';
+import {
+  SupportedTbankAccount,
+  accessibleTbankAccount,
+  supportedTbankAccounts,
+} from './tbank-account.policy';
+import { TbankTokenService } from './tbank-token.service';
+import { TbankAccount, TbankClient } from './tbank.client';
+
+export type TbankConnectionContext = {
+  token: string;
+  generation: string;
+};
+
+export type TbankAccountContext = TbankConnectionContext & {
+  account: TbankAccount;
+};
+
+@Injectable()
+export class TbankAccessService {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly tokens: TbankTokenService,
+    private readonly tbank: TbankClient,
+  ) {}
+
+  async listSupportedAccounts(
+    userId: string,
+  ): Promise<SupportedTbankAccount[]> {
+    return this.withSupportedAccounts(userId, ({ accounts }) => accounts);
+  }
+
+  async withSupportedAccounts<T>(
+    userId: string,
+    handler: (context: {
+      token: string;
+      generation: string;
+      accounts: SupportedTbankAccount[];
+    }) => Promise<T> | T,
+  ): Promise<T> {
+    return this.withConnection(userId, async ({ token, generation }) =>
+      handler({
+        token,
+        generation,
+        accounts: supportedTbankAccounts(
+          await this.tbank.getOpenAccounts(token),
+        ),
+      }),
+    );
+  }
+
+  async withConnection<T>(
+    userId: string,
+    handler: (context: TbankConnectionContext) => Promise<T> | T,
+  ): Promise<T> {
+    const connection = await this.connection(userId);
+    return this.tokens.translateInvalidToken(async () => handler(connection));
+  }
+
+  async withAccount<T>(
+    userId: string,
+    accountId: string,
+    handler: (context: TbankAccountContext) => Promise<T>,
+  ): Promise<T> {
+    return this.withConnection(userId, (connection) =>
+      this.withAccountForConnection(connection, accountId, handler),
+    );
+  }
+
+  async withAccountForConnection<T>(
+    connection: TbankConnectionContext,
+    accountId: string,
+    handler: (context: TbankAccountContext) => Promise<T>,
+  ): Promise<T> {
+    const { token, generation } = connection;
+    return this.tokens.translateInvalidToken(async () => {
+      const account = accessibleTbankAccount(
+        await this.tbank.getOpenAccounts(token),
+        accountId,
+      );
+      if (!account) throw new NotFoundException();
+      return handler({ token, generation, account });
+    });
+  }
+
+  private async connection(
+    userId: string,
+  ): Promise<{ token: string; generation: string }> {
+    const connection = await this.prisma.tbankConnection.findUnique({
+      where: { userId },
+    });
+    if (!connection)
+      throw new ConflictException({ code: 'TBANK_NOT_CONNECTED' });
+    return {
+      token: this.tokens.decrypt(connection.encryptedToken),
+      generation: createHash('sha256')
+        .update(connection.encryptedToken)
+        .digest('base64url'),
+    };
+  }
+}