feat!: persist T-Bank data and synchronize reads

Store account membership, portfolio, operations, forecasts and market sources in SQLite.
Coalesce scoped refreshes, fence connection revisions, preserve complete financial
snapshots and stabilize operation period state.

BREAKING CHANGE: investment reads return data/meta resource envelopes and locally
persisted snapshots; consumers must use the matching OpenAPI contract and explicit
synchronization endpoints.

src/modules/investments/tbank-sync/tbank-sync.repository.ts

@@ -0,0 +1,121 @@
+import { Injectable } from '@nestjs/common';
+import { createHash, randomUUID } from 'node:crypto';
+import type { Prisma } from '../../../../generated/prisma/client';
+import { PrismaService } from '../../../prisma/prisma.service';
+import type { TbankSyncAttempt } from '../../../integrations/tbank/tbank-access.service';
+import type { InvestmentScreenDto } from './tbank-sync.dto';
+export type ScreenIntent = { scope: InvestmentScreenDto; now: string };
+export type ScreenProgress = {
+  children: string[];
+  attempts?: Record<string, string>;
+  dispatched: boolean;
+};
+@Injectable()
+export class TbankSyncRepository {
+  constructor(private readonly prisma: PrismaService) {}
+  reserve(
+    userId: string,
+    revision: string,
+    scope: InvestmentScreenDto,
+    runId: string,
+  ) {
+    return this.prisma.$transaction(async (tx) => {
+      const valid = await tx.tbankConnection.updateMany({
+        where: { userId, revision, invalidToken: false },
+        data: { membershipRevision: { increment: 0 } },
+      });
+      if (!valid.count) return null;
+      const scopeKey = `screen:${createHash('sha256').update(JSON.stringify(scope)).digest('hex')}`;
+      const key = { userId, revision, scopeKey };
+      const previous = await tx.tbankSyncWork.findUnique({
+        where: { userId_revision_scopeKey: key },
+      });
+      if (previous?.state === 'running' && previous.processRunId === runId) {
+        const progress = previous.progress as ScreenProgress;
+        const children = progress.children ?? [];
+        if (
+          !progress.dispatched ||
+          (await tx.tbankSyncWork.count({
+            where: { userId, revision, id: { in: children }, state: 'running' },
+          }))
+        )
+          return { work: previous, launch: false };
+      }
+      const data = {
+        attemptId: randomUUID(),
+        processRunId: runId,
+        state: 'running',
+        priority: 0,
+        intent: JSON.parse(
+          JSON.stringify({ scope, now: new Date().toISOString() }),
+        ) as Prisma.InputJsonObject,
+        progress: { children: [], dispatched: false },
+        errorCode: null,
+      };
+      const work = await tx.tbankSyncWork.upsert({
+        where: { userId_revision_scopeKey: key },
+        create: { ...key, ...data, id: randomUUID() },
+        update: { ...data, id: randomUUID() },
+      });
+      return { work, launch: true };
+    });
+  }
+  read(userId: string, revision: string, id: string) {
+    return this.prisma.$transaction(async (tx) => {
+      const work = await tx.tbankSyncWork.findFirst({
+        where: { userId, revision, id },
+      });
+      if (!work) return null;
+      const progress = work.progress as ScreenProgress;
+      const children = await tx.tbankSyncWork.findMany({
+        where: { userId, revision, id: { in: progress.children ?? [] } },
+        select: { id: true, attemptId: true, state: true, errorCode: true },
+      });
+      return {
+        work,
+        children: children.map((child) =>
+          progress.attempts?.[child.id] &&
+          progress.attempts[child.id] !== child.attemptId
+            ? { ...child, state: 'cancelled', errorCode: null }
+            : child,
+        ),
+        progress,
+      };
+    });
+  }
+  async progress(
+    attempt: TbankSyncAttempt,
+    children: string[],
+    dispatched: boolean,
+    errorCode: string | null = null,
+  ) {
+    return this.prisma.$transaction(async (tx) => {
+      const previous = await tx.tbankSyncWork.findFirst({ where: attempt });
+      if (!previous) return { count: 0 };
+      const old = previous.progress as ScreenProgress;
+      const rows = await tx.tbankSyncWork.findMany({
+        where: {
+          userId: attempt.userId,
+          revision: attempt.revision,
+          id: { in: children },
+        },
+        select: { id: true, attemptId: true },
+      });
+      const attempts = {
+        ...Object.fromEntries(rows.map((row) => [row.id, row.attemptId])),
+        ...old.attempts,
+      };
+      return tx.tbankSyncWork.updateMany({
+        where: {
+          ...attempt,
+          state: 'running',
+          connection: { invalidToken: false },
+        },
+        data: {
+          progress: { children: [...new Set(children)], attempts, dispatched },
+          ...(errorCode ? { state: 'failed', errorCode } : {}),
+        },
+      });
+    });
+  }
+}