feat: add stock screener

2026-10-11 11:18:21 +03:00
parent bc631e72de
commit 7d10ef8adf
15 changed files with 901 additions and 1 deletions
@@ -0,0 +1,106 @@
+import { NotFoundException, ServiceUnavailableException } from '@nestjs/common';
+
+import type { TbankShare } from '../../../../../integrations/tbank/tbank.api';
+
+import { StockScreenerService } from './stock-screener.service';
+
+const token = 'secret-token';
+const revision = 'revision-1';
+const pageSize = 30;
+
+function share(index: number, overrides: Partial<TbankShare> = {}): TbankShare {
+  return {
+    apiTradeAvailableFlag: true,
+    buyAvailableFlag: true,
+    currency: 'RUB',
+    lot: 1,
+    name: `Share ${index}`,
+    ticker: `T${String(index).padStart(2, '0')}`,
+    uid: `e6123145-9665-43e0-8413-cd61b8aa${String(index).padStart(4, '0')}`,
+    ...overrides,
+  };
+}
+
+describe('StockScreenerService', () => {
+  const access = { current: jest.fn(), local: jest.fn() };
+  const client = { getAllShares: jest.fn() };
+  const logger = { event: jest.fn() };
+  let service: StockScreenerService;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    access.current.mockResolvedValue({ revision, token });
+    access.local.mockResolvedValue({ revision });
+    client.getAllShares.mockResolvedValue(
+      Array.from({ length: pageSize + 1 }, (_, index) => share(index)),
+    );
+    service = new StockScreenerService(access, client as never, logger as never);
+  });
+
+  it('stores the full selected catalog and returns stable non-overlapping pages', async () => {
+    const first = await service.search('user-1', {});
+    const second = await service.page('user-1', first.searchId, 2);
+
+    expect(first.items).toHaveLength(pageSize);
+    expect(first.hasNext).toBe(true);
+    expect(second).toMatchObject({ asOf: first.asOf, hasNext: false, page: 2, searchId: first.searchId });
+    expect(second.items).toEqual([expect.objectContaining({ ticker: 'T30' })]);
+    expect(client.getAllShares).toHaveBeenCalledTimes(1);
+  });
+
+  it('creates a fresh result for every search and preserves a successful empty result', async () => {
+    client.getAllShares.mockResolvedValueOnce([share(1, { sector: 'energy' })]).mockResolvedValueOnce([share(2, { sector: 'energy' })]);
+
+    const first = await service.search('user-1', { sector: 'finance' });
+    const second = await service.search('user-1', { sector: 'finance' });
+
+    expect(first).toMatchObject({ hasNext: false, items: [], page: 1 });
+    expect(second).toMatchObject({ hasNext: false, items: [], page: 1 });
+    expect(second.searchId).not.toBe(first.searchId);
+    expect(client.getAllShares).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not store a result when the catalog source fails', async () => {
+    client.getAllShares.mockRejectedValueOnce(new ServiceUnavailableException());
+
+    await expect(service.search('user-1', {})).rejects.toBeInstanceOf(ServiceUnavailableException);
+  });
+
+  it('denies missing, foreign, stale, and out-of-range pages without fetching', async () => {
+    const first = await service.search('user-1', {});
+    access.local.mockResolvedValueOnce({ revision: 'revision-2' });
+
+    await expect(service.page('user-1', first.searchId, 1)).rejects.toBeInstanceOf(NotFoundException);
+    await expect(service.page('user-2', first.searchId, 1)).rejects.toBeInstanceOf(NotFoundException);
+    await expect(service.page('user-1', 'missing', 1)).rejects.toBeInstanceOf(NotFoundException);
+    await expect(service.page('user-1', first.searchId, 3)).rejects.toMatchObject({ status: 400 });
+    expect(client.getAllShares).toHaveBeenCalledTimes(1);
+  });
+
+  it('null-normalizes optional source fields and rejects malformed required fields', async () => {
+    client.getAllShares.mockResolvedValueOnce([
+      share(1, {
+        countryOfRisk: undefined,
+        currency: undefined,
+        isin: undefined,
+        realExchange: undefined,
+        sector: undefined,
+        shareType: undefined,
+        ticker: undefined,
+      }),
+    ]);
+    const result = await service.search('user-1', {});
+    expect(result.items[0]).toEqual(expect.objectContaining({ countryOfRisk: null, currency: null, isin: null, logoName: null, ticker: null }));
+
+    client.getAllShares.mockResolvedValueOnce([share(2, { name: ' ' })]);
+    await expect(service.search('user-1', {})).rejects.toBeInstanceOf(ServiceUnavailableException);
+  });
+
+  it('preserves the catalog logo name in screener results', async () => {
+    client.getAllShares.mockResolvedValueOnce([share(1, { brand: { logoName: 'sber.png' } })]);
+
+    const result = await service.search('user-1', {});
+
+    expect(result.items).toEqual([expect.objectContaining({ logoName: 'sber.png' })]);
+  });
+});
@@ -0,0 +1,140 @@
+import {
+  BadRequestException,
+  Inject,
+  Injectable,
+  NotFoundException,
+  ServiceUnavailableException,
+} from '@nestjs/common';
+import { randomUUID } from 'node:crypto';
+
+import type { TbankShare } from '../../../../../integrations/tbank/tbank-market.types';
+
+import { StructuredLogger } from '../../../../../common/logging/structured-logger.service';
+import { TbankClient } from '../../../../../integrations/tbank/tbank.client';
+import {
+  selectStockScreenerInstruments,
+  type StockScreenerConditions,
+} from '../domain/stock-screener-selection.rules';
+
+const MAX_SNAPSHOTS = 100;
+const PAGE_SIZE = 30;
+const MIN_PAGE = 1;
+const MINIMUM_SNAPSHOT_COUNT = 1;
+const SECONDS_PER_MINUTE = 60;
+const SNAPSHOT_TTL_MINUTES = 5;
+const MILLISECONDS_PER_SECOND = 1_000;
+const SNAPSHOT_TTL_MS = SNAPSHOT_TTL_MINUTES * SECONDS_PER_MINUTE * MILLISECONDS_PER_SECOND;
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+type StockScreenerItem = {
+  countryOfRisk: null | string;
+  currency: null | string;
+  instrumentUid: string;
+  isin: null | string;
+  logoName: null | string;
+  lot: null | number;
+  name: string;
+  realExchange: null | string;
+  sector: null | string;
+  shareType: null | string;
+  ticker: null | string;
+};
+type StockScreenerPage = {
+  asOf: string;
+  hasNext: boolean;
+  items: StockScreenerItem[];
+  page: number;
+  searchId: string;
+};
+type Snapshot = { asOf: string; expiresAt: number; items: StockScreenerItem[]; revision: string; userId: string };
+type TbankAccess = {
+  current(userId: string): Promise<{ revision: string; token: string }>;
+  local(userId: string): Promise<{ revision: string }>;
+};
+
+@Injectable()
+export class StockScreenerService {
+  private readonly snapshots = new Map<string, Snapshot>();
+
+  constructor(
+    @Inject('TBANK_ACCESS') private readonly access: TbankAccess,
+    private readonly client: TbankClient,
+    private readonly logger: StructuredLogger,
+  ) {}
+
+  async search(userId: string, conditions: StockScreenerConditions): Promise<StockScreenerPage> {
+    const connection = await this.access.current(userId);
+    const instruments = await this.client.getAllShares(connection.token);
+    const asOf = new Date().toISOString();
+    const selected = selectStockScreenerInstruments({ asOf: new Date(asOf), instruments }, conditions)
+      .instruments.map((instrument) => this.item(instrument));
+    const searchId = randomUUID();
+    this.evict();
+    this.snapshots.set(searchId, {
+      asOf,
+      expiresAt: Date.now() + SNAPSHOT_TTL_MS,
+      items: selected,
+      revision: connection.revision,
+      userId,
+    });
+    this.logger.event('info', 'stock.screener.search.completed', { asOf, count: selected.length, operation: 'stock-screener-search' });
+    return this.result(searchId, this.snapshots.get(searchId) as Snapshot, MIN_PAGE);
+  }
+
+  async page(userId: string, searchId: string, page: number): Promise<StockScreenerPage> {
+    const snapshot = this.snapshots.get(searchId);
+    if (!snapshot || snapshot.expiresAt <= Date.now()) {
+      this.snapshots.delete(searchId);
+      this.logger.event('info', 'stock.screener.result.missing', { operation: 'stock-screener-read' });
+      throw new NotFoundException();
+    }
+    if (snapshot.userId !== userId) {
+      this.logger.event('warn', 'stock.screener.result.rejected', { operation: 'stock-screener-read' });
+      throw new NotFoundException();
+    }
+    const current = await this.access.local(userId);
+    if (snapshot.revision !== current.revision) {
+      this.logger.event('warn', 'stock.screener.result.rejected', { operation: 'stock-screener-read' });
+      throw new NotFoundException();
+    }
+    return this.result(searchId, snapshot, page);
+  }
+
+  private result(searchId: string, snapshot: Snapshot, page: number): StockScreenerPage {
+    const start = (page - MIN_PAGE) * PAGE_SIZE;
+    if (!Number.isInteger(page) || page < MIN_PAGE || (start >= snapshot.items.length && !(page === MIN_PAGE && !snapshot.items.length))) {
+      throw new BadRequestException();
+    }
+    const items = snapshot.items.slice(start, start + PAGE_SIZE);
+    return { asOf: snapshot.asOf, hasNext: start + PAGE_SIZE < snapshot.items.length, items, page, searchId };
+  }
+
+  private item(instrument: TbankShare): StockScreenerItem {
+    if (!instrument.uid || !UUID_PATTERN.test(instrument.uid) || !instrument.name?.trim()) {
+      throw new ServiceUnavailableException();
+    }
+    return {
+      countryOfRisk: instrument.countryOfRisk ?? null,
+      currency: instrument.currency ?? null,
+      instrumentUid: instrument.uid,
+      isin: instrument.isin ?? null,
+      lot: instrument.lot ?? null,
+      logoName: instrument.brand?.logoName?.trim() || null,
+      name: instrument.name,
+      realExchange: instrument.realExchange ?? null,
+      sector: instrument.sector ?? null,
+      shareType: instrument.shareType ?? null,
+      ticker: instrument.ticker ?? null,
+    };
+  }
+
+  private evict(): void {
+    for (const [searchId, snapshot] of this.snapshots) {
+      if (snapshot.expiresAt <= Date.now()) this.snapshots.delete(searchId);
+    }
+    while (this.snapshots.size >= MAX_SNAPSHOTS) {
+      const searchId = this.snapshots.keys().next().value;
+      if (searchId && this.snapshots.size >= MINIMUM_SNAPSHOT_COUNT) this.snapshots.delete(searchId);
+    }
+  }
+}