Feature/draw the performance chart of the current day, week and month from intraday prices

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- Added the endpoint `GET api/v1/portfolio/intraday` to draw the performance chart of the current day (5 minutes), week (15 minutes) and month (60 minutes) on the overview page from the intraday prices of _Yahoo Finance_, including the pre-market and the post-market
 - Added a time axis to the performance chart on the overview page which only contains the trading days, spans the whole current year and uses hours, days, months or years as unit according to the selected date range
 - Added a link to the holdings tab in the holdings table on the overview tab of the home page (experimental)
 

apps/api/src/app/portfolio/get-intraday.dto.ts

@@ -0,0 +1,22 @@
+import { Transform, TransformFnParams } from 'class-transformer';
+import { IsArray, IsIn, IsOptional, IsString } from 'class-validator';
+
+import type { IntradayDateRange } from './intraday/intraday.helper';
+
+export class GetIntradayDto {
+  /** Comma-separated ids of the asset profiles of the benchmarks */
+  @IsArray()
+  @IsOptional()
+  @IsString({ each: true })
+  @Transform(({ value }: TransformFnParams) => {
+    return typeof value === 'string'
+      ? value.split(',').filter((id) => {
+          return id.length > 0;
+        })
+      : value;
+  })
+  benchmarks?: string[];
+
+  @IsIn(['1d', 'mtd', 'wtd'] as IntradayDateRange[])
+  range: IntradayDateRange;
+}

apps/api/src/app/portfolio/intraday/intraday.helper.spec.ts

@@ -0,0 +1,246 @@
+import {
+  getBaselinePrice,
+  getInstrumentIntradayItems,
+  getIntradayGrid,
+  getIntradaySessions,
+  getPortfolioIntradayItems,
+  getPriceAt,
+  IntradayInstrument,
+  isAnyMarketOpen
+} from './intraday.helper';
+
+const MINUTE = 60 * 1000;
+const time = (aIso: string) => {
+  return Date.parse(aIso);
+};
+
+// Thursday, 22 October 2026
+const europe: IntradayInstrument = {
+  prices: [
+    { price: 100, time: time('2026-10-21T15:29:00Z') },
+    { price: 101, time: time('2026-10-22T07:00:00Z') },
+    { price: 102, time: time('2026-10-22T08:00:00Z') }
+  ],
+  tradingPeriods: [
+    {
+      end: time('2026-10-21T15:30:00Z'),
+      start: time('2026-10-21T07:00:00Z'),
+      type: 'regular'
+    },
+    {
+      end: time('2026-10-22T15:30:00Z'),
+      start: time('2026-10-22T07:00:00Z'),
+      type: 'regular'
+    }
+  ]
+};
+
+const unitedStates: IntradayInstrument = {
+  prices: [
+    { price: 50, time: time('2026-10-21T19:59:00Z') },
+    // Post-market of the previous day
+    { price: 55, time: time('2026-10-21T23:00:00Z') },
+    // Pre-market
+    { price: 51, time: time('2026-10-22T08:30:00Z') }
+  ],
+  tradingPeriods: [
+    {
+      end: time('2026-10-21T20:00:00Z'),
+      start: time('2026-10-21T13:30:00Z'),
+      type: 'regular'
+    },
+    {
+      end: time('2026-10-22T00:00:00Z'),
+      start: time('2026-10-21T20:00:00Z'),
+      type: 'post'
+    },
+    {
+      end: time('2026-10-22T13:30:00Z'),
+      start: time('2026-10-22T08:00:00Z'),
+      type: 'pre'
+    },
+    {
+      end: time('2026-10-22T20:00:00Z'),
+      start: time('2026-10-22T13:30:00Z'),
+      type: 'regular'
+    },
+    {
+      end: time('2026-10-23T00:00:00Z'),
+      start: time('2026-10-22T20:00:00Z'),
+      type: 'post'
+    }
+  ]
+};
+
+describe('intraday helper', () => {
+  const now = time('2026-10-22T09:00:00Z');
+
+  it('spans the trading sessions of the day including the pre-market and the post-market', () => {
+    expect(
+      getIntradaySessions({
+        now,
+        dateRange: '1d',
+        instruments: [europe, unitedStates]
+      })
+    ).toEqual([
+      {
+        end: time('2026-10-23T00:00:00Z'),
+        start: time('2026-10-22T07:00:00Z')
+      }
+    ]);
+  });
+
+  it('uses the previous trading day before the first session has started', () => {
+    expect(
+      getIntradaySessions({
+        dateRange: '1d',
+        instruments: [europe],
+        now: time('2026-10-22T05:00:00Z')
+      })
+    ).toEqual([
+      {
+        end: time('2026-10-21T15:30:00Z'),
+        start: time('2026-10-21T07:00:00Z')
+      }
+    ]);
+  });
+
+  it('spans the trading sessions of the whole week', () => {
+    const sessions = getIntradaySessions({
+      now,
+      dateRange: 'wtd',
+      instruments: [europe]
+    });
+
+    // Wednesday and Thursday are known, Friday is projected
+    expect(sessions.map(({ start }) => new Date(start).toISOString())).toEqual([
+      '2026-10-21T07:00:00.000Z',
+      '2026-10-22T07:00:00.000Z',
+      '2026-10-23T07:00:00.000Z'
+    ]);
+  });
+
+  it('builds a grid of the intervals of the sessions', () => {
+    const grid = getIntradayGrid({
+      intervalInMs: 30 * MINUTE,
+      sessions: [
+        {
+          end: time('2026-10-22T08:00:00Z'),
+          start: time('2026-10-22T07:00:00Z')
+        }
+      ]
+    });
+
+    expect(grid).toEqual([
+      time('2026-10-22T07:00:00Z'),
+      time('2026-10-22T07:30:00Z')
+    ]);
+  });
+
+  it('takes the last price at or before a time', () => {
+    expect(
+      getPriceAt({ prices: europe.prices, time: time('2026-10-22T07:59:00Z') })
+    ).toBe(101);
+    expect(
+      getPriceAt({ prices: europe.prices, time: time('2026-10-20T00:00:00Z') })
+    ).toBeUndefined();
+  });
+
+  it('takes the close of the regular session as baseline, not the post-market', () => {
+    expect(
+      getBaselinePrice({
+        instrument: unitedStates,
+        start: time('2026-10-22T07:00:00Z')
+      })
+    ).toBe(50);
+  });
+
+  it('computes the change of an instrument while it is traded', () => {
+    const grid = [
+      time('2026-10-22T06:00:00Z'),
+      time('2026-10-22T07:00:00Z'),
+      time('2026-10-22T08:00:00Z'),
+      time('2026-10-22T08:30:00Z'),
+      time('2026-10-22T10:00:00Z')
+    ];
+
+    const items = getInstrumentIntradayItems({
+      grid,
+      now,
+      instrument: europe,
+      intervalInMs: MINUTE,
+      start: time('2026-10-22T07:00:00Z')
+    });
+
+    // Not drawn before the first and after the last price
+    expect(items.map(({ value }) => value)).toEqual([
+      null,
+      expect.closeTo(0.01, 10),
+      expect.closeTo(0.02, 10),
+      null,
+      null
+    ]);
+  });
+
+  it('computes the change of the portfolio adjusted for a buy', () => {
+    const start = time('2026-10-22T07:00:00Z');
+
+    const items = getPortfolioIntradayItems({
+      now,
+      start,
+      cashFlows: [{ amount: 102, time: time('2026-10-22T08:00:00Z') }],
+      grid: [start, time('2026-10-22T08:00:00Z')],
+      holdings: [
+        {
+          ...europe,
+          exchangeRate: 1,
+          // One share bought at 08:00 for 102
+          quantity: 2,
+          quantityChanges: [{ quantity: 1, time: time('2026-10-22T08:00:00Z') }]
+        }
+      ],
+      intervalInMs: MINUTE
+    });
+
+    // 07:00: 1 share from 100 to 101
+    expect(items[0].value).toBeCloseTo(0.01);
+
+    // 08:00: 2 shares at 102 (204) - 100 - 102 = 2 on an investment of 202
+    expect(items[1].value).toBeCloseTo(2 / 202);
+  });
+
+  it('detects an open market including the pre-market', () => {
+    expect(
+      isAnyMarketOpen({
+        instruments: [unitedStates],
+        now: time('2026-10-22T09:00:00Z')
+      })
+    ).toBe(true);
+
+    expect(
+      isAnyMarketOpen({
+        instruments: [unitedStates],
+        now: time('2026-10-22T05:00:00Z')
+      })
+    ).toBe(false);
+  });
+});
+
+describe('intraday helper with several trading days', () => {
+  it('leaves a gap while the market of an instrument is closed', () => {
+    const items = getInstrumentIntradayItems({
+      grid: [
+        time('2026-10-21T15:00:00Z'),
+        time('2026-10-21T20:00:00Z'),
+        time('2026-10-22T07:00:00Z')
+      ],
+      instrument: europe,
+      intervalInMs: MINUTE,
+      now: time('2026-10-22T09:00:00Z'),
+      start: time('2026-10-21T07:00:00Z')
+    });
+
+    expect(items[1].value).toBeNull();
+    expect(items[2].value).not.toBeNull();
+  });
+});

apps/api/src/app/portfolio/intraday/intraday.helper.ts

@@ -0,0 +1,457 @@
+import type { PortfolioIntradayItem } from '@ghostfolio/common/interfaces';
+
+export type IntradayDateRange = '1d' | 'mtd' | 'wtd';
+
+export interface IntradayPeriod {
+  end: number;
+  start: number;
+  type: 'post' | 'pre' | 'regular';
+}
+
+export interface IntradayInstrument {
+  /** Realtime price, used for the interval which contains the current time */
+  livePrice?: number;
+
+  /** Sorted by time */
+  prices: { price: number; time: number }[];
+
+  tradingPeriods: IntradayPeriod[];
+}
+
+export interface IntradayHolding extends IntradayInstrument {
+  /** Exchange rate from the currency of the holding to the base currency */
+  exchangeRate: number;
+
+  /** Current quantity */
+  quantity: number;
+
+  /** Quantity bought (positive) or sold (negative) per time */
+  quantityChanges: { quantity: number; time: number }[];
+}
+
+export interface IntradayCashFlow {
+  /** Positive for a buy, negative for a sell (in the base currency) */
+  amount: number;
+  time: number;
+}
+
+const DAY_IN_MS = 24 * 60 * 60 * 1000;
+
+export const INTRADAY_INTERVALS: Record<
+  IntradayDateRange,
+  { interval: '5m' | '15m' | '60m'; intervalInMs: number }
+> = {
+  // About 200 to 400 points per chart, as on the charts of the brokers
+  '1d': { interval: '5m', intervalInMs: 5 * 60 * 1000 },
+  mtd: { interval: '60m', intervalInMs: 60 * 60 * 1000 },
+  wtd: { interval: '15m', intervalInMs: 15 * 60 * 1000 }
+};
+
+function getDayKey(aTime: number) {
+  return new Date(aTime).toISOString().slice(0, 10);
+}
+
+function getTimeOfDayKey(aDayKey: string) {
+  return Date.parse(`${aDayKey}T00:00:00.000Z`);
+}
+
+/**
+ * Returns the merged trading sessions (including the pre-market and the
+ * post-market) of the date range. The sessions of the remaining days of the
+ * week or month are projected from the latest known trading day.
+ */
+export function getIntradaySessions({
+  dateRange,
+  instruments,
+  now
+}: {
+  dateRange: IntradayDateRange;
+  instruments: IntradayInstrument[];
+  now: number;
+}): { end: number; start: number }[] {
+  const periodsByDay = new Map<string, IntradayPeriod[]>();
+
+  for (const { tradingPeriods } of instruments) {
+    for (const period of tradingPeriods) {
+      const key = getDayKey(period.start);
+
+      if (!periodsByDay.has(key)) {
+        periodsByDay.set(key, []);
+      }
+
+      periodsByDay.get(key).push(period);
+    }
+  }
+
+  const startedDays = [...periodsByDay.keys()]
+    .filter((key) => {
+      return (
+        Math.min(...periodsByDay.get(key).map(({ start }) => start)) <= now
+      );
+    })
+    .sort();
+
+  if (startedDays.length === 0) {
+    return [];
+  }
+
+  const latestStartedDay = startedDays.at(-1);
+  let days: string[];
+
+  if (dateRange === '1d') {
+    days = [latestStartedDay];
+  } else {
+    const today = new Date(now);
+    let firstDay: Date;
+    let lastDay: Date;
+
+    if (dateRange === 'wtd') {
+      // Monday to Friday of the current week
+      const weekday = (today.getUTCDay() + 6) % 7;
+      firstDay = new Date(
+        getTimeOfDayKey(getDayKey(now)) - weekday * DAY_IN_MS
+      );
+      lastDay = new Date(firstDay.getTime() + 4 * DAY_IN_MS);
+    } else {
+      firstDay = new Date(
+        Date.UTC(today.getUTCFullYear(), today.getUTCMonth(), 1)
+      );
+      lastDay = new Date(
+        Date.UTC(today.getUTCFullYear(), today.getUTCMonth() + 1, 0)
+      );
+    }
+
+    const firstKey = getDayKey(firstDay.getTime());
+    const lastKey = getDayKey(lastDay.getTime());
+
+    days = startedDays.filter((key) => {
+      return key >= firstKey && key <= lastKey;
+    });
+
+    // Project the trading sessions of the remaining weekdays
+    const pattern = periodsByDay.get([...periodsByDay.keys()].sort().at(-1));
+    const patternDay = getTimeOfDayKey(getDayKey(pattern[0].start));
+
+    for (
+      let time = getTimeOfDayKey(latestStartedDay) + DAY_IN_MS;
+      getDayKey(time) <= lastKey;
+      time += DAY_IN_MS
+    ) {
+      const weekday = new Date(time).getUTCDay();
+
+      if (weekday === 0 || weekday === 6) {
+        continue;
+      }
+
+      const key = getDayKey(time);
+
+      if (!periodsByDay.has(key)) {
+        periodsByDay.set(
+          key,
+          pattern.map((period) => {
+            return {
+              ...period,
+              end: period.end + (time - patternDay),
+              start: period.start + (time - patternDay)
+            };
+          })
+        );
+      }
+
+      days.push(key);
+    }
+
+    if (days.length === 0) {
+      days = [latestStartedDay];
+    }
+  }
+
+  const periods = days
+    .flatMap((key) => {
+      return periodsByDay.get(key);
+    })
+    .filter(({ end, start }) => {
+      return end > start;
+    })
+    .sort((a, b) => {
+      return a.start - b.start;
+    });
+
+  const sessions: { end: number; start: number }[] = [];
+
+  for (const { end, start } of periods) {
+    const last = sessions.at(-1);
+
+    if (last && start <= last.end) {
+      last.end = Math.max(last.end, end);
+    } else {
+      sessions.push({ end, start });
+    }
+  }
+
+  return sessions;
+}
+
+/**
+ * Returns the start times of the intervals of the trading sessions
+ */
+export function getIntradayGrid({
+  intervalInMs,
+  sessions
+}: {
+  intervalInMs: number;
+  sessions: { end: number; start: number }[];
+}) {
+  const grid = new Set<number>();
+
+  for (const { end, start } of sessions) {
+    for (
+      let time = Math.floor(start / intervalInMs) * intervalInMs;
+      time < end;
+      time += intervalInMs
+    ) {
+      grid.add(time);
+    }
+  }
+
+  return [...grid].sort((a, b) => {
+    return a - b;
+  });
+}
+
+/**
+ * Returns the closing price before the start of the date range, preferring
+ * the close of the regular session over the post-market
+ */
+export function getBaselinePrice({
+  instrument: { livePrice, prices, tradingPeriods },
+  start
+}: {
+  instrument: IntradayInstrument;
+  start: number;
+}) {
+  const lastRegularEnd = Math.max(
+    ...tradingPeriods
+      .filter(({ end, type }) => {
+        return type === 'regular' && end <= start;
+      })
+      .map(({ end }) => {
+        return end;
+      })
+  );
+
+  const limit = Number.isFinite(lastRegularEnd) ? lastRegularEnd : start;
+
+  return (
+    getPriceAt({ prices, time: limit - 1 }) ??
+    getPriceAt({ prices, time: start - 1 }) ??
+    prices[0]?.price ??
+    livePrice
+  );
+}
+
+/**
+ * Returns the last price at or before the given time
+ */
+export function getPriceAt({
+  prices,
+  time
+}: {
+  prices: IntradayInstrument['prices'];
+  time: number;
+}) {
+  let low = 0;
+  let high = prices.length - 1;
+  let result: number | undefined;
+
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2);
+
+    if (prices[middle].time <= time) {
+      result = prices[middle].price;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+
+  return result;
+}
+
+function getPriceOfInterval({
+  baseline,
+  instrument,
+  intervalInMs,
+  now,
+  time
+}: {
+  baseline: number;
+  instrument: IntradayInstrument;
+  intervalInMs: number;
+  now: number;
+  time: number;
+}) {
+  if (
+    instrument.livePrice !== undefined &&
+    now >= time &&
+    now < time + intervalInMs
+  ) {
+    return instrument.livePrice;
+  }
+
+  return (
+    getPriceAt({ prices: instrument.prices, time: time + intervalInMs - 1 }) ??
+    baseline
+  );
+}
+
+/**
+ * Returns the change of the value of the holdings since the start of the date
+ * range per interval, adjusted for the buys and sells in the date range
+ */
+export function getPortfolioIntradayItems({
+  cashFlows,
+  grid,
+  holdings,
+  intervalInMs,
+  now,
+  start
+}: {
+  cashFlows: IntradayCashFlow[];
+  grid: number[];
+  holdings: IntradayHolding[];
+  intervalInMs: number;
+  now: number;
+  start: number;
+}): PortfolioIntradayItem[] {
+  const getQuantityAt = (aHolding: IntradayHolding, aTime: number) => {
+    // Revert the changes after the given time
+    return aHolding.quantityChanges.reduce((quantity, change) => {
+      return change.time > aTime ? quantity - change.quantity : quantity;
+    }, aHolding.quantity);
+  };
+
+  const baselines = holdings.map((holding) => {
+    return getBaselinePrice({ start, instrument: holding }) ?? 0;
+  });
+
+  const startValue = holdings.reduce((sum, holding, index) => {
+    return (
+      sum +
+      getQuantityAt(holding, start) * baselines[index] * holding.exchangeRate
+    );
+  }, 0);
+
+  return grid.map((time) => {
+    if (time > now) {
+      return { date: new Date(time).toISOString(), value: null };
+    }
+
+    const value = holdings.reduce((sum, holding, index) => {
+      return (
+        sum +
+        getQuantityAt(holding, time + intervalInMs - 1) *
+          getPriceOfInterval({
+            intervalInMs,
+            now,
+            time,
+            baseline: baselines[index],
+            instrument: holding
+          }) *
+          holding.exchangeRate
+      );
+    }, 0);
+
+    const cashFlow = cashFlows.reduce((sum, { amount, time: flowTime }) => {
+      return flowTime >= start && flowTime < time + intervalInMs
+        ? sum + amount
+        : sum;
+    }, 0);
+
+    const investment = startValue + Math.max(cashFlow, 0);
+
+    return {
+      date: new Date(time).toISOString(),
+      value: investment > 0 ? (value - startValue - cashFlow) / investment : 0
+    };
+  });
+}
+
+/**
+ * Returns the change of the price of an instrument since the start of the
+ * date range per interval
+ */
+export function getInstrumentIntradayItems({
+  grid,
+  instrument,
+  intervalInMs,
+  now,
+  start
+}: {
+  grid: number[];
+  instrument: IntradayInstrument;
+  intervalInMs: number;
+  now: number;
+  start: number;
+}): PortfolioIntradayItem[] {
+  const baseline = getBaselinePrice({ instrument, start });
+
+  // The line of an instrument is only drawn while it is traded
+  const pricesInRange = instrument.prices.filter(({ time }) => {
+    return time >= start;
+  });
+  const firstTime = pricesInRange[0]?.time ?? Number.POSITIVE_INFINITY;
+  const lastTime = Math.max(
+    pricesInRange.at(-1)?.time ?? Number.NEGATIVE_INFINITY,
+    instrument.livePrice !== undefined ? now : Number.NEGATIVE_INFINITY
+  );
+
+  const isTraded = (aTime: number) => {
+    return (
+      instrument.tradingPeriods.length === 0 ||
+      instrument.tradingPeriods.some(({ end, start }) => {
+        return aTime + intervalInMs > start && aTime < end;
+      })
+    );
+  };
+
+  return grid.map((time) => {
+    if (
+      time > now ||
+      !baseline ||
+      time + intervalInMs <= firstTime ||
+      time > lastTime ||
+      !isTraded(time)
+    ) {
+      return { date: new Date(time).toISOString(), value: null };
+    }
+
+    const price = getPriceOfInterval({
+      baseline,
+      instrument,
+      intervalInMs,
+      now,
+      time
+    });
+
+    return { date: new Date(time).toISOString(), value: price / baseline - 1 };
+  });
+}
+
+/**
+ * Whether the current time is in a trading period (including the pre-market
+ * and the post-market) of one of the instruments
+ */
+export function isAnyMarketOpen({
+  instruments,
+  now
+}: {
+  instruments: IntradayInstrument[];
+  now: number;
+}) {
+  return instruments.some(({ tradingPeriods }) => {
+    return tradingPeriods.some(({ end, start }) => {
+      return now >= start && now < end;
+    });
+  });
+}

apps/api/src/app/portfolio/intraday/intraday.service.ts

@@ -0,0 +1,251 @@
+import { ActivitiesService } from '@ghostfolio/api/app/activities/activities.service';
+import { YahooFinanceService } from '@ghostfolio/api/services/data-provider/yahoo-finance/yahoo-finance.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.service';
+import { RedisCacheService } from '@ghostfolio/api/services/redis-cache/redis-cache.service';
+import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile/symbol-profile.service';
+import { DEFAULT_CURRENCY } from '@ghostfolio/common/config';
+import { PortfolioIntradayResponse } from '@ghostfolio/common/interfaces';
+
+import { Injectable, Logger } from '@nestjs/common';
+import { AssetSubClass, DataSource } from '@prisma/client';
+import { startOfMonth, startOfWeek, subDays } from 'date-fns';
+
+import { PortfolioService } from '../portfolio.service';
+import {
+  getInstrumentIntradayItems,
+  getIntradayGrid,
+  getIntradaySessions,
+  getPortfolioIntradayItems,
+  INTRADAY_INTERVALS,
+  IntradayDateRange,
+  IntradayHolding,
+  IntradayInstrument,
+  isAnyMarketOpen
+} from './intraday.helper';
+
+@Injectable()
+export class IntradayService {
+  private static readonly CACHE_TTL_IN_MS = 60 * 1000;
+
+  private readonly logger = new Logger(IntradayService.name);
+
+  public constructor(
+    private readonly activitiesService: ActivitiesService,
+    private readonly exchangeRateDataService: ExchangeRateDataService,
+    private readonly portfolioService: PortfolioService,
+    private readonly redisCacheService: RedisCacheService,
+    private readonly symbolProfileService: SymbolProfileService,
+    private readonly yahooFinanceService: YahooFinanceService
+  ) {}
+
+  public async getIntraday({
+    benchmarkIds = [],
+    dateRange,
+    userCurrency = DEFAULT_CURRENCY,
+    userId
+  }: {
+    benchmarkIds?: string[];
+    dateRange: IntradayDateRange;
+    userCurrency?: string;
+    userId: string;
+  }): Promise<PortfolioIntradayResponse> {
+    const now = Date.now();
+    const { interval, intervalInMs } = INTRADAY_INTERVALS[dateRange];
+    const from = this.getFrom(dateRange);
+
+    const [{ holdings }, benchmarkProfiles] = await Promise.all([
+      this.portfolioService.getDetails({
+        userId,
+        filters: [{ id: 'ACTIVE', type: 'HOLDING_TYPE' }]
+      }),
+      benchmarkIds.length > 0
+        ? this.symbolProfileService.getSymbolProfilesByIds(benchmarkIds)
+        : Promise.resolve([])
+    ]);
+
+    const positions = Object.values(holdings).filter(({ assetProfile }) => {
+      return assetProfile.assetSubClass !== AssetSubClass.CASH;
+    });
+
+    const { activities } = await this.activitiesService.getActivities({
+      userCurrency,
+      userId,
+      startDate: subDays(from, 1),
+      types: ['BUY', 'SELL']
+    });
+
+    const intradayHoldings: IntradayHolding[] = await Promise.all(
+      positions.map(async ({ assetProfile, marketPrice, quantity }) => {
+        const instrument = await this.getInstrument({
+          from,
+          interval,
+          dataSource: assetProfile.dataSource,
+          symbol: assetProfile.symbol
+        });
+
+        const activitiesOfHolding = activities.filter(
+          ({ assetProfile: { dataSource, symbol } }) => {
+            return (
+              dataSource === assetProfile.dataSource &&
+              symbol === assetProfile.symbol
+            );
+          }
+        );
+
+        return {
+          ...instrument,
+          quantity,
+          exchangeRate: this.exchangeRateDataService.toCurrency(
+            1,
+            assetProfile.currency,
+            userCurrency
+          ),
+          livePrice: marketPrice,
+          quantityChanges: activitiesOfHolding.map(
+            ({ date, quantity: activityQuantity, type }) => {
+              return {
+                quantity:
+                  type === 'SELL' ? -activityQuantity : activityQuantity,
+                time: new Date(date).getTime()
+              };
+            }
+          )
+        };
+      })
+    );
+
+    const benchmarks = await Promise.all(
+      benchmarkProfiles.map(async ({ dataSource, id, symbol }) => {
+        return {
+          id,
+          instrument: await this.getInstrument({
+            dataSource,
+            from,
+            interval,
+            symbol
+          })
+        };
+      })
+    );
+
+    const sessions = getIntradaySessions({
+      dateRange,
+      now,
+      instruments: [
+        ...intradayHoldings,
+        ...benchmarks.map(({ instrument }) => {
+          return instrument;
+        })
+      ]
+    });
+
+    const grid = getIntradayGrid({ intervalInMs, sessions });
+    const start = sessions[0]?.start ?? now;
+
+    return {
+      interval,
+      benchmarks: benchmarks.map(({ id, instrument }) => {
+        return {
+          id,
+          items: getInstrumentIntradayItems({
+            grid,
+            instrument,
+            intervalInMs,
+            now,
+            start
+          })
+        };
+      }),
+      chart: getPortfolioIntradayItems({
+        grid,
+        intervalInMs,
+        now,
+        start,
+        cashFlows: activities.map(
+          ({ date, feeInBaseCurrency, type, valueInBaseCurrency }) => {
+            return {
+              amount:
+                type === 'SELL'
+                  ? -(valueInBaseCurrency - feeInBaseCurrency)
+                  : valueInBaseCurrency + feeInBaseCurrency,
+              time: new Date(date).getTime()
+            };
+          }
+        ),
+        holdings: intradayHoldings
+      }),
+      isMarketOpen: isAnyMarketOpen({ now, instruments: intradayHoldings })
+    };
+  }
+
+  private getFrom(aDateRange: IntradayDateRange) {
+    const today = new Date();
+
+    // A few days more to get the close before the start of the date range
+    switch (aDateRange) {
+      case '1d':
+        return subDays(today, 5);
+      case 'mtd':
+        return subDays(startOfMonth(today), 5);
+      case 'wtd':
+        return subDays(startOfWeek(today, { weekStartsOn: 1 }), 5);
+    }
+  }
+
+  private async getInstrument({
+    dataSource,
+    from,
+    interval,
+    symbol
+  }: {
+    dataSource: DataSource;
+    from: Date;
+    interval: '5m' | '15m' | '60m';
+    symbol: string;
+  }): Promise<IntradayInstrument> {
+    if (dataSource !== DataSource.YAHOO) {
+      // No intraday data: the value is constant
+      return { prices: [], tradingPeriods: [] };
+    }
+
+    const key = `intraday-${dataSource}-${symbol}-${interval}-${from
+      .toISOString()
+      .slice(0, 10)}`;
+
+    try {
+      const cached = await this.redisCacheService.get(key);
+
+      if (cached) {
+        return JSON.parse(cached) as IntradayInstrument;
+      }
+    } catch {}
+
+    try {
+      const { prices, tradingPeriods } =
+        await this.yahooFinanceService.getIntraday({ from, interval, symbol });
+
+      const instrument: IntradayInstrument = {
+        prices: prices.map(({ date, price }) => {
+          return { price, time: new Date(date).getTime() };
+        }),
+        tradingPeriods: tradingPeriods.map(({ end, start, type }) => {
+          return { type, end: end.getTime(), start: start.getTime() };
+        })
+      };
+
+      await this.redisCacheService.set(
+        key,
+        JSON.stringify(instrument),
+        IntradayService.CACHE_TTL_IN_MS
+      );
+
+      return instrument;
+    } catch (error) {
+      this.logger.warn(
+        `Could not get the intraday prices of ${symbol} (${dataSource}): ${error?.message}`
+      );
+
+      return { prices: [], tradingPeriods: [] };
+    }
+  }
+}

apps/api/src/app/portfolio/portfolio.controller.ts

@@ -23,6 +23,7 @@ import {
   PortfolioDividendsResponse,
   PortfolioHoldingResponse,
   PortfolioHoldingsResponse,
+  PortfolioIntradayResponse,
   PortfolioInvestmentsResponse,
   PortfolioPerformanceResponse,
   PortfolioReportResponse
@@ -54,8 +55,10 @@ import { StatusCodes, getReasonPhrase } from 'http-status-codes';
 import { GetDetailsDto } from './get-details.dto';
 import { GetDividendsDto } from './get-dividends.dto';
 import { GetHoldingsDto } from './get-holdings.dto';
+import { GetIntradayDto } from './get-intraday.dto';
 import { GetInvestmentsDto } from './get-investments.dto';
 import { GetPerformanceDto } from './get-performance.dto';
+import { IntradayService } from './intraday/intraday.service';
 import { PortfolioService } from './portfolio.service';
 import { UpdateHoldingTagsDto } from './update-holding-tags.dto';
 
@@ -65,6 +68,7 @@ export class PortfolioController {
     private readonly activitiesService: ActivitiesService,
     private readonly apiService: ApiService,
     private readonly configurationService: ConfigurationService,
+    private readonly intradayService: IntradayService,
     private readonly portfolioService: PortfolioService,
     @Inject(REQUEST) private readonly request: RequestWithUser
   ) {}
@@ -410,6 +414,21 @@ export class PortfolioController {
     return { holdings };
   }
 
+  @Get('intraday')
+  @RequiresScope(scopes.portfolioRead)
+  @UseInterceptors(PerformanceLoggingInterceptor)
+  public async getIntraday(
+    @Impersonation() { userId }: ImpersonationContext,
+    @Query() { benchmarks, range }: GetIntradayDto
+  ): Promise<PortfolioIntradayResponse> {
+    return this.intradayService.getIntraday({
+      userId,
+      benchmarkIds: benchmarks,
+      dateRange: range,
+      userCurrency: this.request.user.settings.settings.baseCurrency
+    });
+  }
+
   @Get('investments')
   @RequiresScope(scopes.portfolioRead)
   @UseInterceptors(TransformDataSourceInRequestInterceptor)

apps/api/src/app/portfolio/portfolio.module.ts

@@ -26,6 +26,7 @@ import { Module } from '@nestjs/common';
 
 import { PortfolioCalculatorFactory } from './calculator/portfolio-calculator.factory';
 import { CurrentRateService } from './current-rate.service';
+import { IntradayService } from './intraday/intraday.service';
 import { PortfolioController } from './portfolio.controller';
 import { PortfolioService } from './portfolio.service';
 import { RulesService } from './rules.service';
@@ -60,6 +61,7 @@ import { RulesService } from './rules.service';
     AccountBalanceService,
     AccountService,
     CurrentRateService,
+    IntradayService,
     PortfolioCalculatorFactory,
     PortfolioService,
     RulesService

apps/api/src/services/data-provider/yahoo-finance/yahoo-finance.service.ts

@@ -38,6 +38,12 @@ import type {
 } from 'yahoo-finance2/modules/quoteSummary';
 import type { SearchQuoteNonYahoo } from 'yahoo-finance2/modules/search';
 
+export interface IntradayTradingPeriod {
+  end: Date;
+  start: Date;
+  type: 'post' | 'pre' | 'regular';
+}
+
 @Injectable()
 export class YahooFinanceService implements DataProviderInterface {
   private static readonly DELISTED_ERROR_MESSAGE =
@@ -196,6 +202,100 @@ export class YahooFinanceService implements DataProviderInterface {
     }
   }
 
+  /**
+   * Returns the intraday prices (including the pre-market and the
+   * post-market) and the trading periods of a symbol
+   */
+  public async getIntraday({
+    from,
+    interval,
+    symbol
+  }: {
+    from: Date;
+    interval: '5m' | '15m' | '60m';
+    symbol: string;
+  }): Promise<{
+    prices: { date: Date; price: number }[];
+    tradingPeriods: IntradayTradingPeriod[];
+  }> {
+    const { meta, quotes } = await this.yahooFinance.chart(
+      this.yahooFinanceDataEnhancerService.convertToYahooFinanceSymbol(symbol),
+      { interval, includePrePost: true, period1: from }
+    );
+
+    const prices = quotes
+      .filter(({ close }) => {
+        return typeof close === 'number' && Number.isFinite(close);
+      })
+      .map(({ close, date }) => {
+        return { date, price: close };
+      });
+
+    // Depending on the exchange, the times are dates or Unix timestamps
+    const toDate = (aTime: unknown) => {
+      return typeof aTime === 'number'
+        ? new Date(aTime < 1e12 ? aTime * 1000 : aTime)
+        : new Date(aTime as Date | string);
+    };
+
+    const toPeriod = (aPeriod?: { end: unknown; start: unknown }) => {
+      return aPeriod?.start && aPeriod?.end
+        ? { end: toDate(aPeriod.end), start: toDate(aPeriod.start) }
+        : undefined;
+    };
+
+    // The trading periods are an array of days (each an array of regular
+    // periods), or an object with the arrays of the pre-market, regular and
+    // post-market periods
+    const tradingPeriods: IntradayTradingPeriod[] = [];
+
+    const collect = (
+      aValue: unknown,
+      aType: IntradayTradingPeriod['type'] = 'regular'
+    ) => {
+      if (Array.isArray(aValue)) {
+        for (const item of aValue) {
+          collect(item, aType);
+        }
+      } else if (aValue && typeof aValue === 'object') {
+        const period = toPeriod(aValue as { end: unknown; start: unknown });
+
+        if (period) {
+          tradingPeriods.push({ ...period, type: aType });
+        } else {
+          for (const [key, item] of Object.entries(aValue)) {
+            collect(item, key === 'pre' || key === 'post' ? key : 'regular');
+          }
+        }
+      }
+    };
+
+    collect(meta.tradingPeriods);
+
+    // The trading periods of the current (or next) trading day
+    for (const [type, period] of Object.entries(
+      meta.currentTradingPeriod ?? {}
+    )) {
+      const currentPeriod = toPeriod(
+        period as { end: unknown; start: unknown }
+      );
+
+      if (
+        currentPeriod &&
+        !tradingPeriods.some(({ start }) => {
+          return start.getTime() === currentPeriod.start.getTime();
+        })
+      ) {
+        tradingPeriods.push({
+          ...currentPeriod,
+          type: type === 'pre' || type === 'post' ? type : 'regular'
+        });
+      }
+    }
+
+    return { prices, tradingPeriods };
+  }
+
   public getMaxNumberOfSymbolsPerRequest() {
     return 50;
   }

apps/client/src/app/components/home-overview/home-overview.component.ts

@@ -9,7 +9,7 @@ import {
   DEFAULT_LOCALE,
   NUMERICAL_PRECISION_THRESHOLD_6_FIGURES
 } from '@ghostfolio/common/config';
-import { isCashPosition } from '@ghostfolio/common/helper';
+import { isCashPosition, isIntradayDateRange } from '@ghostfolio/common/helper';
 import {
   AssetProfileIdentifier,
   HistoricalDataItem,
@@ -43,6 +43,7 @@ import { IonIcon } from '@ionic/angular/standalone';
 import { addIcons } from 'ionicons';
 import { arrowForwardOutline } from 'ionicons/icons';
 import { DeviceDetectorService } from 'ngx-device-detector';
+import { catchError, forkJoin, map, Observable, of } from 'rxjs';
 
 const MINIMUM_CHART_ITEMS = 3;
 
@@ -75,7 +76,10 @@ export class GfHomeOverviewComponent implements OnInit {
     return (
       (this.historicalDataItems() ?? []).filter(({ value }) => {
         return value !== null;
-      }).length >= MINIMUM_CHART_ITEMS
+      }).length >=
+      (isIntradayDateRange(this.user()?.settings?.dateRange)
+        ? 1
+        : MINIMUM_CHART_ITEMS)
     );
   });
   protected readonly holdings = signal<PortfolioPosition[] | undefined>(
@@ -189,6 +193,29 @@ export class GfHomeOverviewComponent implements OnInit {
     }
   }
 
+  /**
+   * The current day, week and month are drawn from intraday prices, with a
+   * fallback to the daily chart
+   */
+  private fetchIntradayChartItems(
+    aDateRange: DateRange
+  ): Observable<NullableLineChartItem[] | null> {
+    if (!isIntradayDateRange(aDateRange)) {
+      return of(null);
+    }
+
+    return this.dataService.fetchPortfolioIntraday({ range: aDateRange }).pipe(
+      map(({ chart }) => {
+        return chart.map(({ date, value }) => {
+          return { date, value: value === null ? null : value * 100 };
+        });
+      }),
+      catchError(() => {
+        return of(null);
+      })
+    );
+  }
+
   private setChartItems({
     chart,
     dateRange
@@ -243,28 +270,38 @@ export class GfHomeOverviewComponent implements OnInit {
         });
     }
 
-    this.dataService
+    const dateRange = userSettings?.dateRange ?? DEFAULT_DATE_RANGE;
-      .fetchPortfolioPerformance({
+
-        range: userSettings?.dateRange ?? DEFAULT_DATE_RANGE
+    forkJoin({
+      intradayChart: this.fetchIntradayChartItems(dateRange),
+      response: this.dataService.fetchPortfolioPerformance({
+        range: dateRange
       })
+    })
       .pipe(takeUntilDestroyed(this.destroyRef))
-      .subscribe(({ chart, errors, performance }) => {
+      .subscribe(
-        this.errors.set(errors ?? []);
+        ({ intradayChart, response: { chart, errors, performance } }) => {
-        this.performance.set(performance);
+          this.errors.set(errors ?? []);
-
+          this.performance.set(performance);
-        this.setChartItems({ chart, dateRange: userSettings?.dateRange });
+
-
+          if (intradayChart) {
-        this.precision.set(2);
+            this.historicalDataItems.set(intradayChart);
-
+          } else {
-        if (
+            this.setChartItems({ chart, dateRange });
-          this.deviceType() === 'mobile' &&
+          }
-          performance.currentValueInBaseCurrency >=
+
-            NUMERICAL_PRECISION_THRESHOLD_6_FIGURES
+          this.precision.set(2);
-        ) {
+
-          this.precision.set(0);
+          if (
+            this.deviceType() === 'mobile' &&
+            performance.currentValueInBaseCurrency >=
+              NUMERICAL_PRECISION_THRESHOLD_6_FIGURES
+          ) {
+            this.precision.set(0);
+          }
+
+          this.isLoadingPerformance.set(false);
         }
-
+      );
-        this.isLoadingPerformance.set(false);
-      });
   }
 }

libs/common/src/lib/helper.spec.ts

@@ -13,6 +13,7 @@ import {
   getStringOrNull,
   getStringOrUndefined,
   isAccountBalanceInFuture,
+  isIntradayDateRange,
   isAccountExcluded,
   isCurrency,
   isCurrencySymbol,
@@ -857,3 +858,16 @@ describe('Helper', () => {
     });
   });
 });
+
+describe('isIntradayDateRange', () => {
+  it.each([
+    ['1d', true],
+    ['wtd', true],
+    ['mtd', true],
+    ['ytd', false],
+    ['max', false],
+    [undefined, false]
+  ] as const)('returns %s for %s', (dateRange, expected) => {
+    expect(isIntradayDateRange(dateRange)).toBe(expected);
+  });
+});

libs/common/src/lib/helper.ts

@@ -63,7 +63,7 @@ import {
   PortfolioPosition,
   UserSettings
 } from './interfaces';
-import { BenchmarkTrend, ColorScheme } from './types';
+import { BenchmarkTrend, ColorScheme, DateRange } from './types';
 
 export const DATE_FORMAT = 'yyyy-MM-dd';
 export const DATE_FORMAT_MONTHLY = 'MMMM yyyy';
@@ -880,3 +880,14 @@ export function resolveUserSettings({
     )
   };
 }
+
+/**
+ * Whether the date range is drawn from intraday prices (5 minutes for the
+ * current day, 15 minutes for the current week, 60 minutes for the current
+ * month) instead of daily prices
+ */
+export function isIntradayDateRange(
+  aDateRange?: DateRange
+): aDateRange is '1d' | 'mtd' | 'wtd' {
+  return aDateRange === '1d' || aDateRange === 'mtd' || aDateRange === 'wtd';
+}

libs/common/src/lib/interfaces/index.ts

@@ -81,6 +81,10 @@ import type { PlatformsResponse } from './responses/platforms-response.interface
 import type { PortfolioDividendsResponse } from './responses/portfolio-dividends-response.interface';
 import type { PortfolioHoldingResponse } from './responses/portfolio-holding-response.interface';
 import type { PortfolioHoldingsResponse } from './responses/portfolio-holdings-response.interface';
+import type {
+  PortfolioIntradayItem,
+  PortfolioIntradayResponse
+} from './responses/portfolio-intraday-response.interface';
 import type { PortfolioInvestmentsResponse } from './responses/portfolio-investments.interface';
 import type { PortfolioPerformanceResponse } from './responses/portfolio-performance-response.interface';
 import type { PortfolioReportResponse } from './responses/portfolio-report.interface';
@@ -180,6 +184,8 @@ export {
   PortfolioDividendsResponse,
   PortfolioHoldingResponse,
   PortfolioHoldingsResponse,
+  PortfolioIntradayItem,
+  PortfolioIntradayResponse,
   PortfolioInvestmentsResponse,
   PortfolioPerformance,
   PortfolioPerformanceResponse,

libs/common/src/lib/interfaces/responses/portfolio-intraday-response.interface.ts

@@ -0,0 +1,22 @@
+export interface PortfolioIntradayItem {
+  /** Start of the interval (ISO 8601) */
+  date: string;
+
+  /** Change since the start of the date range, `null` for the future */
+  value: number | null;
+}
+
+export interface PortfolioIntradayResponse {
+  benchmarks: {
+    id: string;
+    items: PortfolioIntradayItem[];
+  }[];
+
+  /** Change of the portfolio since the start of the date range */
+  chart: PortfolioIntradayItem[];
+
+  interval: '5m' | '15m' | '60m';
+
+  /** Whether a market (including the pre-market and the post-market) of a holding is open */
+  isMarketOpen: boolean;
+}

libs/ui/src/lib/line-chart/line-chart.component.ts

@@ -6,7 +6,11 @@ import {
   getVerticalHoverLinePlugin
 } from '@ghostfolio/common/chart-helper';
 import { primaryColorRgb, secondaryColorRgb } from '@ghostfolio/common/config';
-import { getBackgroundColor, getLocale } from '@ghostfolio/common/helper';
+import {
+  getBackgroundColor,
+  getLocale,
+  isIntradayDateRange
+} from '@ghostfolio/common/helper';
 import { NullableLineChartItem } from '@ghostfolio/common/interfaces';
 import { ColorScheme, DateRange } from '@ghostfolio/common/types';
 
@@ -295,7 +299,8 @@ export class GfLineChartComponent
       locale: this.locale,
       // Equidistant points: the closed markets (nights, weekends) are skipped
       type: this.dateRange ? 'timeseries' : 'time',
-      unit: getTimeAxisUnit(this.dateRange)
+      unit: getTimeAxisUnit(this.dateRange),
+      withTime: isIntradayDateRange(this.dateRange)
     });
   }
 

libs/ui/src/lib/services/data.service.ts

@@ -53,6 +53,7 @@ import {
   PortfolioDividendsResponse,
   PortfolioHoldingResponse,
   PortfolioHoldingsResponse,
+  PortfolioIntradayResponse,
   PortfolioInvestmentsResponse,
   PortfolioPerformanceResponse,
   PortfolioReportResponse,
@@ -721,6 +722,25 @@ export class DataService {
       );
   }
 
+  public fetchPortfolioIntraday({
+    benchmarks = [],
+    range
+  }: {
+    benchmarks?: string[];
+    range: '1d' | 'mtd' | 'wtd';
+  }) {
+    let params = new HttpParams().append('range', range);
+
+    if (benchmarks.length > 0) {
+      params = params.append('benchmarks', benchmarks.join(','));
+    }
+
+    return this.http.get<PortfolioIntradayResponse>(
+      '/api/v1/portfolio/intraday',
+      { params }
+    );
+  }
+
   public fetchPortfolioPerformance({
     filters,
     groupBy,