feat(portfolio): store and publish instrument sector and issuer (WealthLedger/main#48)

2026-11-01 12:24:28 +03:00
parent 5e84e1e5f1
commit 5680f2655c
16 changed files with 452 additions and 11 deletions
@@ -0,0 +1,192 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+
+import { StructuredLogger } from '../../../../common/logging/structured-logger.service';
+import { MILLISECONDS_PER_DAY } from '../../../../common/time';
+import { isTbankErrorCode, TbankErrorCode } from '../../../../integrations/tbank/tbank-error-code';
+import { InstrumentIdType } from '../../../../integrations/tbank/tbank-protocol';
+import { metadataKey, TbankClient, type TbankPortfolio } from '../../../../integrations/tbank/tbank.api';
+import { PositionClassificationRepository } from '../infrastructure/position-classification.repository';
+
+export type Classification = { issuer: null | { id: string; name: string }; sector: null | string };
+type Position = NonNullable<TbankPortfolio['positions']>[number];
+type Instrument = { assetUid?: string; figi?: string; sector?: string; uid?: string };
+type Row = NonNullable<Awaited<ReturnType<PositionClassificationRepository['read']>>>;
+
+const dayMs = MILLISECONDS_PER_DAY;
+type Update = Parameters<PositionClassificationRepository['save']>[1];
+
+@Injectable()
+export class PositionClassificationService {
+  private readonly instruments = new Map<string, Promise<null | { found: Instrument; id: string; idType: InstrumentIdType }>>();
+  private readonly assets = new Map<string, Promise<null | { assetUid?: string; brand?: { name?: string; uid?: string } }>>();
+
+  constructor(
+    private readonly tbank: TbankClient,
+    private readonly repository: PositionClassificationRepository,
+    private readonly logger: StructuredLogger,
+  ) {}
+
+  async refresh(token: string, positions: Position[], walkStartedAt: Date): Promise<Map<string, Classification>> {
+    const result = new Map<string, Classification>();
+    const assets = new Map<string, ReturnType<TbankClient['getAssetBrand']>>();
+    for (const position of positions) {
+      if (!['bond', 'etf', 'share'].includes(position.instrumentType ?? '')) continue;
+      const key = metadataKey(position);
+      if (result.has(key)) continue;
+      result.set(key, await this.refreshOne(token, position, key, walkStartedAt, assets));
+    }
+    return result;
+  }
+
+  private async refreshOne(token: string, position: Position, key: string, startedAt: Date,
+    assets: Map<string, ReturnType<TbankClient['getAssetBrand']>>): Promise<Classification> {
+    let saved: null | Row = null;
+    try {
+      saved = await this.repository.read(key);
+      const update: Update = {};
+      const due = (at: Date | null | undefined, value: null | string | undefined) =>
+        !value || !at || startedAt.valueOf() - at.valueOf() >= dayMs;
+      const sectorDue = due(saved?.sectorFetchedAt, saved?.sector);
+      const brandDue = due(saved?.brandFetchedAt, saved?.brandUid && saved.brandName);
+      const assetUid = sectorDue || (brandDue && !saved?.assetUid)
+        ? await this.refreshInstrument(token, position, key, sectorDue, saved?.assetUid ?? null, update)
+        : saved?.assetUid ?? null;
+      const assetChanged = 'assetUid' in update && update.assetUid !== saved?.assetUid;
+      if (assetChanged) {
+        update.brandUid = null;
+        update.brandName = null;
+        update.brandFetchedAt = new Date();
+      }
+      if (brandDue || assetChanged) {
+        await this.refreshBrand(token, assetUid, update, assets);
+      }
+      if (Object.keys(update).length) saved = await this.repository.save(key, update);
+    } catch (error) {
+      if (this.invalidToken(error)) throw error;
+      this.failed();
+    }
+    return {
+      issuer: saved?.brandUid && saved.brandName ? { id: saved.brandUid, name: saved.brandName } : null,
+      sector: saved?.sector ?? null,
+    };
+  }
+
+  private async refreshInstrument(token: string, position: Position, key: string, sectorDue: boolean, savedUid: null | string, update: Update) {
+    try {
+      const lookup = await this.instrument(token, position, key);
+      if (lookup && !this.matches(lookup)) return savedUid;
+      if (lookup) return this.acceptInstrument(lookup.found, savedUid, sectorDue, update);
+      if (sectorDue) this.clearSector(update);
+    } catch (error) {
+      if (this.invalidToken(error)) throw error;
+      if (error instanceof NotFoundException) {
+        if (sectorDue) this.clearSector(update);
+      } else this.failed();
+    }
+    return savedUid;
+  }
+
+  private clearSector(update: Update) {
+    update.sector = null;
+    update.sectorFetchedAt = new Date();
+  }
+
+  private acceptInstrument(found: Instrument, savedUid: null | string, sectorDue: boolean, update: Update) {
+    const assetUid = found.assetUid?.trim() || null;
+    if (assetUid !== savedUid) update.assetUid = assetUid;
+    if (sectorDue) this.setSector(update, found.sector);
+    return assetUid;
+  }
+
+  private setSector(update: Update, sector: string | undefined) {
+    update.sector = sector?.trim() || null;
+    update.sectorFetchedAt = new Date();
+  }
+
+  private async refreshBrand(token: string, assetUid: null | string, update: Update,
+    assets: Map<string, ReturnType<TbankClient['getAssetBrand']>>) {
+    if (!assetUid) {
+      if ('assetUid' in update || 'sectorFetchedAt' in update) this.clearBrand(update);
+      return;
+    }
+    try {
+      const asset = await this.cachedAsset(token, assetUid, assets);
+      if (asset && asset.assetUid !== assetUid) return;
+      const uid = asset?.brand?.uid?.trim() || null;
+      const name = asset?.brand?.name?.trim() || null;
+      update.brandUid = uid && name ? uid : null;
+      update.brandName = uid && name ? name : null;
+      update.brandFetchedAt = new Date();
+    } catch (error) {
+      if (this.invalidToken(error)) throw error;
+      if (error instanceof NotFoundException) this.clearBrand(update);
+      else this.failed();
+    }
+  }
+
+  private clearBrand(update: Update) {
+    update.brandUid = null;
+    update.brandName = null;
+    update.brandFetchedAt = new Date();
+  }
+
+  private matches(lookup: { found: Instrument; id: string; idType: InstrumentIdType }) {
+    return (lookup.idType === InstrumentIdType.Uid ? lookup.found.uid : lookup.found.figi) === lookup.id;
+  }
+
+  private invalidToken(error: unknown) {
+    return error instanceof Error && isTbankErrorCode(error.message, TbankErrorCode.InvalidToken);
+  }
+
+  private async instrument(token: string, position: Position, key: string) {
+    return this.inFlight(this.instruments, key, async () => {
+      const lookup = (id: string, type: InstrumentIdType) => {
+        switch (position.instrumentType) {
+          case 'bond': return this.tbank.getBond(token, id, type, true);
+          case 'share': return this.tbank.getShare(token, id, type, true);
+          default: return this.tbank.getEtf(token, id, type, true);
+        }
+      };
+      const uid = position.instrumentUid?.trim();
+      const figi = position.figi?.trim();
+      if (uid) {
+        try {
+          const found = await lookup(uid, InstrumentIdType.Uid);
+          if (found) return { found, id: uid, idType: InstrumentIdType.Uid };
+        } catch (error) {
+          if (!(error instanceof NotFoundException)) throw error;
+        }
+      }
+      if (figi) {
+        const found = await lookup(figi, InstrumentIdType.Figi);
+        return found ? { found, id: figi, idType: InstrumentIdType.Figi } : null;
+      }
+      return null;
+    });
+  }
+
+  private asset(token: string, uid: string) {
+    return this.inFlight(this.assets, uid, () => this.tbank.getAssetBrand(token, uid));
+  }
+
+  private cachedAsset(token: string, uid: string, assets: Map<string, ReturnType<TbankClient['getAssetBrand']>>) {
+    let pending = assets.get(uid);
+    if (!pending) {
+      pending = this.asset(token, uid);
+      assets.set(uid, pending);
+    }
+    return pending;
+  }
+
+  private inFlight<T>(map: Map<string, Promise<T>>, key: string, run: () => Promise<T>): Promise<T> {
+    const pending = map.get(key);
+    if (pending) return pending;
+    const promise = run().finally(() => map.delete(key));
+    map.set(key, promise);
+    return promise;
+  }
+
+  private failed() {
+    this.logger.event('warn', 'portfolio.classification.failed', { code: TbankErrorCode.Unavailable });
+  }
+}