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,77 @@
+import {
+  add,
+  decimalFromString,
+  formatDecimal,
+} from '../../../../common/decimal';
+
+import type { Money } from '../../../../common/money.types';
+
+const categoryTypes = ['STOCK', 'BOND', 'OTHER', 'CASH'] as const;
+
+// Build from positions and cash, never from totals (which already include cash).
+export function portfolioStructure(
+  positions: { type: string; currentValue: Money | null }[],
+  cash: Money[],
+) {
+  const currencies = new Map<
+    string,
+    {
+      values: ReturnType<typeof decimalFromString>[];
+      hasNegativeValues: boolean;
+    }
+  >();
+  const unvalued = new Map<string, number>();
+  const include = (type: string, money: Money) => {
+    const group = currencies.get(money.currency) ?? {
+      values: categoryTypes.map(() => decimalFromString('0')),
+      hasNegativeValues: false,
+    };
+    const index = categoryTypes.findIndex((category) => category === type);
+    const value = decimalFromString(money.value);
+    group.values[index] = add(group.values[index], value);
+    group.hasNegativeValues ||= value.value < 0n;
+    currencies.set(money.currency, group);
+  };
+  for (const position of positions) {
+    const type = ['STOCK', 'BOND'].includes(position.type)
+      ? position.type
+      : 'OTHER';
+    if (position.currentValue) include(type, position.currentValue);
+    else unvalued.set(type, (unvalued.get(type) ?? 0) + 1);
+  }
+  for (const amount of cash) include('CASH', amount);
+
+  return {
+    unvaluedCategories: [...unvalued].map(([type, count]) => ({ type, count })),
+    currencies: [...currencies]
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([currency, group]) => {
+        const total = group.values.reduce(add, decimalFromString('0'));
+        const canCalculateShares =
+          !unvalued.size && !group.hasNegativeValues && total.value > 0n;
+        const categories = group.values.map((value, index) => ({
+          type: categoryTypes[index],
+          value: formatDecimal(value),
+          // Rounded to six decimal places using integer arithmetic. Only the
+          // resulting dimensionless percentage is passed to chart geometry.
+          sharePercent: canCalculateShares
+            ? formatDecimal({
+                value:
+                  (value.value *
+                    10n ** BigInt(total.scale - value.scale) *
+                    100_000_000n +
+                    total.value / 2n) /
+                  total.value,
+                scale: 6,
+              })
+            : null,
+        }));
+        return {
+          currency,
+          totalValue: formatDecimal(total),
+          hasNegativeValues: group.hasNegativeValues,
+          categories,
+        };
+      }),
+  };
+}