refactor: organize backend by business responsibility

2026-09-13 13:52:57 +03:00
parent 7fde3ece6e
commit 8ba005346d
145 changed files with 3027 additions and 2346 deletions
@@ -0,0 +1,183 @@
+import { Injectable, ServiceUnavailableException } from '@nestjs/common';
+import {
+  add,
+  decimalFromString,
+  divide,
+  formatDecimal,
+  multiply,
+  subtract,
+} from '../../../../../common/decimal';
+import { TbankClient } from '../../../../../integrations/tbank/tbank.api';
+import { decimal } from '../../../../../integrations/tbank/decimal';
+import {
+  optional,
+  previousClose,
+  timestamp,
+} from '../../application/instrument-market';
+import {
+  BondCandlesDto,
+  BondCandlesQueryDto,
+  BondQuoteDto,
+} from '../presentation/bond.dto';
+
+const dayMs = 86_400_000;
+
+import { money } from '../infrastructure/bond-money.mapper';
+import { BondCatalogService } from './bond-catalog.service';
+@Injectable()
+export class BondMarketService {
+  constructor(
+    private readonly catalog: BondCatalogService,
+    private readonly tbank: TbankClient,
+  ) {}
+  quote(userId: string, uid: string): Promise<BondQuoteDto> {
+    return this.catalog.cached(userId, `quote:${uid}`, async (connection) => {
+      const { token } = connection;
+      const instrument = await this.catalog.bond(userId, connection, uid);
+      const unavailable: string[] = [];
+      const [last, tradingStatus] = await Promise.all([
+        optional(
+          () => this.tbank.getLastPrice(token, uid),
+          'price',
+          unavailable,
+        ),
+        optional(
+          () => this.tbank.getTradingStatus(token, uid),
+          'status',
+          unavailable,
+        ),
+      ]);
+      const priceAt = timestamp(last?.time);
+      const pricePercent = last?.price
+        ? formatDecimal(decimal(last.price))
+        : null;
+      const nominal = money(instrument.nominal);
+      const aci = money(instrument.aciValue);
+      const cleanPrice =
+        pricePercent !== null &&
+        nominal &&
+        decimalFromString(nominal.value).value > 0n
+          ? {
+              currency: nominal.currency,
+              value: formatDecimal(
+                divide(
+                  multiply(
+                    decimalFromString(pricePercent),
+                    decimalFromString(nominal.value),
+                  ),
+                  decimalFromString('100'),
+                  9,
+                ),
+              ),
+            }
+          : null;
+      const dirtyPrice =
+        cleanPrice && aci && aci.currency === cleanPrice.currency
+          ? {
+              currency: cleanPrice.currency,
+              value: formatDecimal(
+                add(
+                  decimalFromString(cleanPrice.value),
+                  decimalFromString(aci.value),
+                ),
+              ),
+            }
+          : null;
+      const previous = priceAt
+        ? await optional(
+            async () =>
+              previousClose(
+                await this.tbank.getCandles(
+                  token,
+                  uid,
+                  new Date(Date.parse(priceAt) - 20 * dayMs),
+                  new Date(priceAt),
+                ),
+                priceAt,
+              ),
+            'comparison',
+            unavailable,
+          )
+        : null;
+      return {
+        pricePercent,
+        cleanPrice,
+        aci,
+        dirtyPrice,
+        priceAt,
+        tradingStatus,
+        changePercentagePoints:
+          last?.price && previous?.close
+            ? formatDecimal(
+                subtract(decimal(last.price), decimal(previous.close)),
+              )
+            : null,
+        previousCloseDate: timestamp(previous?.time)?.slice(0, 10) ?? null,
+        unavailable,
+        observedAt: new Date().toISOString(),
+      };
+    });
+  }
+  candles(
+    userId: string,
+    uid: string,
+    period: BondCandlesQueryDto['period'] = 'month',
+  ): Promise<BondCandlesDto> {
+    return this.catalog.cached(
+      userId,
+      `candles:${uid}:${period}`,
+      async (connection) => {
+        const { token } = connection;
+        const bond = await this.catalog.bond(userId, connection, uid);
+        const historyFrom = timestamp(bond.first_1dayCandleDate);
+        const to = new Date();
+        const from = new Date(to);
+        from.setUTCMonth(
+          from.getUTCMonth() -
+            (period === 'month' ? 1 : period === 'halfYear' ? 6 : 12),
+        );
+        if (period === 'all') {
+          if (!historyFrom)
+            throw new ServiceUnavailableException({
+              code: 'BOND_HISTORY_START_UNAVAILABLE',
+            });
+          from.setTime(Date.parse(historyFrom));
+        } else if (historyFrom && Date.parse(historyFrom) > from.valueOf())
+          from.setTime(Date.parse(historyFrom));
+        const collected = new Map<string, BondCandlesDto['candles'][number]>();
+        // Conservative one-year windows also work with older deployed RPC limits.
+        for (let start = from.valueOf(); start < to.valueOf();) {
+          const end = Math.min(start + 365 * dayMs, to.valueOf());
+          for (const candle of await this.tbank.getCandles(
+            token,
+            uid,
+            new Date(start),
+            new Date(end),
+          )) {
+            const time = timestamp(candle.time);
+            if (
+              time &&
+              candle.close &&
+              Date.parse(time) >= from.valueOf() - dayMs &&
+              Date.parse(time) <= to.valueOf()
+            )
+              collected.set(time, {
+                time,
+                close: formatDecimal(decimal(candle.close)),
+                isComplete: candle.isComplete === true,
+              });
+          }
+          start = end;
+        }
+        return {
+          candles: [...collected.values()].sort((a, b) =>
+            a.time.localeCompare(b.time),
+          ),
+          currency: null,
+          historyFrom,
+          observedAt: new Date().toISOString(),
+        };
+      },
+    );
+  }
+}