Fix portfolio calculation for holdings with activities before first known historical market price

apps/api/src/app/portfolio/calculator/roai/portfolio-calculator-manual-buy-before-first-market-price.spec.ts

@@ -0,0 +1,151 @@
+import {
+  activityDummyData,
+  assetProfileDummyData,
+  userDummyData
+} from '@ghostfolio/api/app/portfolio/calculator/portfolio-calculator-test-utils';
+import { PortfolioCalculatorFactory } from '@ghostfolio/api/app/portfolio/calculator/portfolio-calculator.factory';
+import { CurrentRateService } from '@ghostfolio/api/app/portfolio/current-rate.service';
+import { CurrentRateServiceMock } from '@ghostfolio/api/app/portfolio/current-rate.service.mock';
+import { RedisCacheService } from '@ghostfolio/api/app/redis-cache/redis-cache.service';
+import { RedisCacheServiceMock } from '@ghostfolio/api/app/redis-cache/redis-cache.service.mock';
+import { ConfigurationService } from '@ghostfolio/api/services/configuration/configuration.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.service';
+import { PortfolioSnapshotService } from '@ghostfolio/api/services/queues/portfolio-snapshot/portfolio-snapshot.service';
+import { PortfolioSnapshotServiceMock } from '@ghostfolio/api/services/queues/portfolio-snapshot/portfolio-snapshot.service.mock';
+import { parseDate } from '@ghostfolio/common/helper';
+import { Activity } from '@ghostfolio/common/interfaces';
+import { PerformanceCalculationType } from '@ghostfolio/common/types/performance-calculation-type.type';
+
+jest.mock('@ghostfolio/api/app/portfolio/current-rate.service', () => {
+  return {
+    CurrentRateService: jest.fn().mockImplementation(() => {
+      return CurrentRateServiceMock;
+    })
+  };
+});
+
+jest.mock(
+  '@ghostfolio/api/services/queues/portfolio-snapshot/portfolio-snapshot.service',
+  () => {
+    return {
+      PortfolioSnapshotService: jest.fn().mockImplementation(() => {
+        return PortfolioSnapshotServiceMock;
+      })
+    };
+  }
+);
+
+jest.mock('@ghostfolio/api/app/redis-cache/redis-cache.service', () => {
+  return {
+    RedisCacheService: jest.fn().mockImplementation(() => {
+      return RedisCacheServiceMock;
+    })
+  };
+});
+
+describe('PortfolioCalculator', () => {
+  let configurationService: ConfigurationService;
+  let currentRateService: CurrentRateService;
+  let exchangeRateDataService: ExchangeRateDataService;
+  let portfolioCalculatorFactory: PortfolioCalculatorFactory;
+  let portfolioSnapshotService: PortfolioSnapshotService;
+  let redisCacheService: RedisCacheService;
+
+  beforeEach(() => {
+    PortfolioSnapshotServiceMock.reset();
+    RedisCacheServiceMock.reset();
+
+    configurationService = new ConfigurationService();
+
+    currentRateService = new CurrentRateService(null, null, null, null);
+
+    exchangeRateDataService = new ExchangeRateDataService(
+      null,
+      null,
+      null,
+      null
+    );
+
+    portfolioSnapshotService = new PortfolioSnapshotService(null, null);
+
+    redisCacheService = new RedisCacheService(null, null);
+
+    portfolioCalculatorFactory = new PortfolioCalculatorFactory(
+      configurationService,
+      currentRateService,
+      exchangeRateDataService,
+      portfolioSnapshotService,
+      redisCacheService
+    );
+  });
+
+  describe('get current positions', () => {
+    it.only('with MANUAL buy before the first known market price', async () => {
+      jest.useFakeTimers().setSystemTime(parseDate('2022-01-31').getTime());
+
+      const activities: Activity[] = [
+        {
+          ...activityDummyData,
+          assetProfile: {
+            ...assetProfileDummyData,
+            currency: 'USD',
+            dataSource: 'MANUAL',
+            name: 'Private Investment',
+            symbol: '55196015-1365-4560-aa60-8751ae6d18f8'
+          },
+          date: parseDate('2021-01-01'),
+          feeInAssetProfileCurrency: 0,
+          feeInBaseCurrency: 0,
+          quantity: 1,
+          type: 'BUY',
+          unitPriceInAssetProfileCurrency: 100
+        }
+      ];
+
+      const portfolioCalculator = portfolioCalculatorFactory.createCalculator({
+        activities,
+        calculationType: PerformanceCalculationType.ROAI,
+        currency: 'USD',
+        userId: userDummyData.id
+      });
+
+      const portfolioSnapshot = await portfolioCalculator.computeSnapshot();
+
+      const historicalDataByDate = Object.fromEntries(
+        portfolioSnapshot.historicalData.map((historicalDataItem) => {
+          return [historicalDataItem.date, historicalDataItem];
+        })
+      );
+
+      /**
+       * The only known market price is on 2022-01-31. The chart dates before it
+       * must not be valued with a future price, hence they use the unit price
+       * of the activity: 100
+       */
+      expect(historicalDataByDate['2021-01-01']).toMatchObject({
+        netPerformance: 0, // 1 * (100 - 100) = 0
+        netPerformanceInPercentage: 0,
+        totalInvestment: 100,
+        value: 100 // 1 * 100 = 100
+      });
+
+      expect(historicalDataByDate['2022-01-30']).toMatchObject({
+        netPerformance: 0, // 1 * (100 - 100) = 0
+        netPerformanceInPercentage: 0,
+        totalInvestment: 100,
+        value: 100 // 1 * 100 = 100
+      });
+
+      /**
+       * Closing price on 2022-01-31: 3000
+       */
+      expect(portfolioSnapshot.historicalData.at(-1)).toMatchObject({
+        date: '2022-01-31',
+        netPerformance: 2900, // 1 * (3000 - 100) = 2900
+        netPerformanceInPercentage: 29, // 2900 ÷ 100 = 29
+        totalInvestment: 100,
+        value: 3000 // 1 * 3000 = 3000
+      });
+    });
+  });
+});

apps/api/src/app/portfolio/calculator/roai/portfolio-calculator.ts

@@ -383,8 +383,8 @@ export class RoaiPortfolioCalculator extends PortfolioCalculator {
 
     // Fall back to the unit price of the most recent BUY / SELL activity for
     // the chart dates before the first known market price of the symbol
-    let lastActivityUnitPrice: Big;
-    let lastMarketPrice: Big;
+    let lastActivityUnitPrice: Big | undefined;
+    let lastMarketPrice: Big | undefined;
 
     const ordersByDate: { [date: string]: PortfolioOrderItem[] } = {};
 
@@ -416,7 +416,11 @@ export class RoaiPortfolioCalculator extends PortfolioCalculator {
 
       const marketPrice = marketSymbolMap[dateString]?.[assetProfileIdentifier];
 
-      const unitPrice = marketPrice ?? lastMarketPrice ?? lastActivityUnitPrice;
+      const unitPrice =
+        marketPrice ??
+        lastMarketPrice ??
+        lastActivityUnitPrice ??
+        unitPriceAtEndDate;
 
       if (ordersOfDate?.length > 0) {
         for (const order of ordersOfDate) {