@decafhub/decaf-client-extras 0.0.4 → 0.1.0

package/src/commons/-id.ts

@@ -1,72 +1,167 @@
-import { NewTypeWithPhantom } from '@telostat/prelude';
+/**
+ * This module provides a collection of DECAF record identifier type
+ * definitions. It is not exhaustive and it will be improved on an ongoing
+ * basis.
+ *
+ * Typically, a DECAF record identifier is either number or string. Some DECAF
+ * API endoints can consume string values even though a number is expected. We
+ * are sticking here to the original type: No `number | string` definitions.
+ *
+ * Methodologically, we are using a type trick to emulate newtypes in this
+ * module: For example, DECAF artifact identifier type is defined as:
+ *
+ * ```ts
+ * export type DecafArtifactId = number & { readonly __tag: unique symbol };
+ * ```
+ *
+ * In runtime, there is only a number. The `& { readonly __tag: unique symbol }`
+ * is provided to the compiler to distinguish in between `number` identifier
+ * values  which are representing different DECAF record types.
+ *
+ * The construction and deconstruction of DECAF record identifiers are done via,
+ * respecively, `mkDecafRecordId` and `unDecafRecordId`:
+ *
+ * ```ts
+ * const exampleDecafArtifactIdValue: number = unDecafRecordId(exampleDecafArtifactId);
+ * const exampleDecafArtifactId: DecafArtifactId = mkDecafRecordId(42);
+ * expect(exampleDecafArtifactIdValue).toBe(42);
+ *
+ * const exampleDecafActionId: DecafActionId = mkDecafRecordId(42);
+ * const exampleDecafActionIdValue: number = unDecafRecordId(exampleDecafActionId);
+ * expect(exampleDecafActionIdValue).toBe(42);
+ *
+ * const exampleDecafArtifactTypeId: DecafArtifactTypeId = mkDecafRecordId('CCY');
+ * const exampleDecafArtifactTypeIdValue: string = unDecafRecordId(exampleDecafArtifactTypeId);
+ * expect(exampleDecafArtifactTypeIdValue).toBe('CCY');
+ * ```
+ *
+ * To re-iterate, the runtime representation is not affected by how DECAF record
+ * identifier types are defined:
+ *
+ * ```ts
+ * interface DecafArtifact {
+ *   id: DecafArtifactId;
+ *   type: DecafArtifactTypeId;
+ * }
+ *
+ * const exampleDecafArtifact: DecafArtifact = { id: mkDecafRecordId(10), type: mkDecafRecordId('CCY') };
+ * expect(exampleDecafArtifact).toStrictEqual({ id: 10, type: 'CCY' });
+ * ```
+ *
+ * @module
+ */
+
+/**
+ * Type definition covering all possible DECAF record identifiers based on
+ * `number` values.
+ *
+ * This type definition must be extended whenever there is a new DECAF record
+ * identifier is defined in this module.
+ */
+export type _DecafRecordIdFromNumber = DecafArtifactId | DecafActionId;
+
+/**
+ * Type definition covering all possible DECAF record identifiers based on
+ * `string` values.
+ *
+ * This type definition must be extended whenever there is a new DECAF record
+ * identifier is defined in this module.
+ */
+export type _DecafRecordIdFromString = DecafArtifactTypeId;
+
+/* Signature for overloaded `mkDecafRecordId` function consuming a `number`. */
+export function mkDecafRecordId<T extends _DecafRecordIdFromNumber>(x: number): T;
+
+/* Signature for overloaded `mkDecafRecordId` function consuming a `string`. */
+export function mkDecafRecordId<T extends _DecafRecordIdFromString>(x: string): T;
+
+/**
+ * Constructor for DECAF record identifiers.
+ *
+ * @param x Value to create DECAF record identifier from.
+ * @returns DECAF record identifier of type deduced from call-site usage.
+ */
+export function mkDecafRecordId<T>(x: any): T {
+  return x as T;
+}
+
+/* Signature for overloaded `unDecafRecordId` function producing a `number`. */
+export function unDecafRecordId<T extends _DecafRecordIdFromNumber>(x: T): number;
+
+/* Signature for overloaded `unDecafRecordId` function producing a `string`. */
+export function unDecafRecordId<K extends _DecafRecordIdFromString>(x: K): string;
 
 /**
- * Type definition for identifiers with value spaces discriminated over the
- * given phantom type.
+ * Deconstructor for DECAF record identifiers.
+ *
+ * @param x DECAF record identifier.
+ * @returns Value of the DECAF record identifier (deduced from call-site usage).
  */
-export type Id<P, V> = NewTypeWithPhantom<P, V>;
+export function unDecafRecordId<T>(x: T): any {
+  return x as unknown;
+}
 
 /**
  * Type definition for DECAF artifact identifiers.
  */
-export type ArtifactId = NewTypeWithPhantom<'DecafArtifact', string | number>;
+export type DecafArtifactId = number & { readonly __tag: unique symbol };
 
 /**
  * Type definition for DECAF artifact type identifiers.
  */
-export type ArtifactTypeId = NewTypeWithPhantom<'DecafArtifactType', string>;
+export type DecafArtifactTypeId = string & { readonly __tag: unique symbol };
 
 /**
  * Type definition for DECAF share class identifiers.
  */
-export type ShareClassId = NewTypeWithPhantom<'DecafShareClass', string | number>;
+export type DecafShareClassId = number & { readonly __tag: unique symbol };
 
 /**
  * Type definition for DECAF principal identifiers.
  */
-export type PrincipalId = NewTypeWithPhantom<'DecafPrincipal', string | number>;
+export type DecafPrincipalId = number & { readonly __tag: unique symbol };
 
 /**
  * Type definition for DECAF institution identifiers.
  */
-export type InstitutionId = NewTypeWithPhantom<'DecafInstitution', string | number>;
+export type DecafInstitutionId = number & { readonly __tag: unique symbol };
 
 /**
  * Type definition for DECAF team identifiers.
  */
-export type TeamId = NewTypeWithPhantom<'DecafTeam', string | number>;
+export type DecafTeamId = number & { readonly __tag: unique symbol };
 
 /**
  * Type definition for DECAF portfolio identifiers.
  */
-export type PortfolioId = NewTypeWithPhantom<'DecafPortfolio', string | number>;
+export type DecafPortfolioId = number & { readonly __tag: unique symbol };
 
 /**
  * Type definition for DECAF portfolio group identifiers.
  */
-export type PortfolioGroupId = NewTypeWithPhantom<'DecafPortfolioGroup', string | number>;
+export type DecafPortfolioGroupId = number & { readonly __tag: unique symbol };
 
 /**
  * Type definition for DECAF account identifiers.
  */
-export type AccountId = NewTypeWithPhantom<'DecafAccount', string | number>;
+export type DecafAccountId = number & { readonly __tag: unique symbol };
 
 /**
  * Type definition for DECAF OHLC series identifiers.
  */
-export type OhlcSeriesId = NewTypeWithPhantom<'DecafOhlcSeries', string | number>;
+export type DecafOhlcSeriesId = number & { readonly __tag: unique symbol };
 
 /**
  * Type definition for DECAF share class fee schedule identifiers.
  */
-export type ShareClassFeeScheduleId = NewTypeWithPhantom<'DecafShareClassFeeSchedule', string | number>;
+export type DecafShareClassFeeScheduleId = number & { readonly __tag: unique symbol };
 
 /**
  * Type definition for DECAF action identifiers.
  */
-export type ActionId = NewTypeWithPhantom<'DecafAction', string | number>;
+export type DecafActionId = number & { readonly __tag: unique symbol };
 
 /**
  * Type definition for DECAF external valuation identifiers.
  */
-export type ExternalValuationId = NewTypeWithPhantom<'DecafExternalValuation', string | number>;
+export type DecafExternalValuationId = number & { readonly __tag: unique symbol };

package/src/commons/index.ts

@@ -1,3 +1,6 @@
 export * from './-currency';
-export * from './-date-type';
+export * as currency from './-currency';
+export * from './-datetype';
+export * as datetype from './-datetype';
 export * from './-id';
+export * as id from './-id';

package/src/index.test.ts

@@ -1,8 +1,12 @@
 import { buildDecafClient, DecafClient, gql } from '@decafhub/decaf-client';
-import { mk, PDateTime } from '@telostat/prelude';
+import { PDateTime, safeDiv, zero } from '@telostat/prelude';
 import { fail } from 'assert';
-import { PortfolioId } from './commons';
-import { fetchRemotePortfolioValuationReport } from './reports/valuation/-remote-valuation-report-portfolio';
+import { DecafPortfolioId, mkCurrencyCodeError } from './commons';
+import { makeValuationReportHoldingsTree } from './reports/valuation/';
+import {
+  fetchPortfolioValuationReport,
+  fetchRemotePortfolioValuationReport,
+} from './reports/valuation/-remote-valuation-report-portfolio';
 
 const API_URL = process.env.TESTING_API_URL;
 const API_KEY = process.env.TESTING_API_KEY;
@@ -19,7 +23,7 @@ const FIRST_PORTFOLIO_QUERY = gql`
 
 describe('Main', () => {
   let client: DecafClient;
-  let portfolioId: PortfolioId;
+  let portfolioId: DecafPortfolioId;
 
   beforeAll(() => {
     jest.resetModules();
@@ -52,7 +56,7 @@ describe('Main', () => {
       portfolio: portfolioId,
       date: PDateTime(new Date()).format('YYYY-MM-DD'),
       dateType: 'settlement',
-      currency: mk('EUR'),
+      currency: mkCurrencyCodeError('EUR'),
     });
     eValue.caseOf({
       Left: (e) => fail('Error while fetching the remote portfolio report: ' + e.msg),
@@ -64,4 +68,29 @@ describe('Main', () => {
       },
     });
   });
+
+  test('get a portfolio report, check the tree', async () => {
+    const eValue = await fetchPortfolioValuationReport(client, {
+      portfolio: portfolioId,
+      date: PDateTime(new Date()).format('YYYY-MM-DD'),
+      dateType: 'settlement',
+      currency: mkCurrencyCodeError('EUR'),
+    });
+    eValue.caseOf({
+      Left: (e) => fail('Error while fetching the remote portfolio report: ' + e.msg),
+      Right: (value) => {
+        console.log(`Success! remote valuation for portfolio ID ${value.portfolio.id} is reported at ${value.asof}`);
+
+        expect(value).toBeDefined();
+
+        const nav = value.figures.nav;
+        const inv = value.figures.investment;
+        const holdings = value.holdings;
+        const tree = makeValuationReportHoldingsTree(nav, inv, holdings);
+
+        expect(tree).toBeDefined();
+        expect(safeDiv(tree.totals.netExposure, nav).orDefault(zero)).toEqual(tree.totals.netExposureRatio);
+      },
+    });
+  });
 });

package/src/reports/valuation/-remote-valuation-report-portfolio.ts

@@ -1,28 +1,28 @@
 import { DecafClient } from '@decafhub/decaf-client';
 import {
-  asDecimal,
   CustomError,
   customError,
+  decimalFromNullable,
   Either,
   Left,
   Maybe,
-  maybeDecimal,
   Right,
   sanitizedNonEmptyText,
   SDate,
   SDateTime,
+  unsafeDecimal,
   zero,
 } from '@telostat/prelude';
 import {
-  ActionId,
   CurrencyCode,
   DateType,
-  ExternalValuationId,
-  OhlcSeriesId,
-  PortfolioId,
-  PrincipalId,
-  ShareClassFeeScheduleId,
-  ShareClassId,
+  DecafActionId,
+  DecafExternalValuationId,
+  DecafOhlcSeriesId,
+  DecafPortfolioId,
+  DecafPrincipalId,
+  DecafShareClassFeeScheduleId,
+  DecafShareClassId,
 } from '../../commons';
 import { recompileBaseValuationReport, RemoteBaseValuationReport } from './-remote-valuation-report-shared';
 import { PortfolioValuationReport, PortfolioValuationReportShareClassValue } from './-valuation-report-portfolio';
@@ -50,7 +50,7 @@ export interface PortfolioValuationReportQuery {
   /**
    * Portfolio the valuation report is requested for.
    */
-  portfolio: PortfolioId;
+  portfolio: DecafPortfolioId;
 }
 
 /**
@@ -88,13 +88,13 @@ export interface RemoteValuationShareClassValue {
  * Type definition for share class on the remote portfolio valuation report.
  */
 export interface RemoteValuationShareClass {
-  id: ShareClassId;
+  id: DecafShareClassId;
   created: SDateTime;
-  creator: PrincipalId;
+  creator: DecafPrincipalId;
   updated: SDateTime;
-  updater: PrincipalId;
+  updater: DecafPrincipalId;
   guid: string;
-  portfolio: PortfolioId;
+  portfolio: DecafPortfolioId;
   name: string;
   currency: CurrencyCode;
   isin?: string;
@@ -106,11 +106,11 @@ export interface RemoteValuationShareClass {
   subredperiod?: string;
   freqmngt?: number;
   freqperf?: number;
-  benchmark?: OhlcSeriesId;
+  benchmark?: DecafOhlcSeriesId;
   description?: string;
-  feeschedules: ShareClassFeeScheduleId[];
-  effectivefeeschedule?: ShareClassFeeScheduleId;
-  subscriptions: ActionId[];
+  feeschedules: DecafShareClassFeeScheduleId[];
+  effectivefeeschedule?: DecafShareClassFeeScheduleId;
+  subscriptions: DecafActionId[];
   outstanding?: number;
 }
 
@@ -119,14 +119,14 @@ export interface RemoteValuationShareClass {
  * report.
  */
 export interface RemoteValuationExternalValue {
-  id: ExternalValuationId;
+  id: DecafExternalValuationId;
   created: SDateTime;
-  creator: PrincipalId;
+  creator: DecafPrincipalId;
   updated: SDateTime;
-  updater: PrincipalId;
+  updater: DecafPrincipalId;
   guid: string;
-  portfolio: PortfolioId;
-  shareclass?: ShareClassId;
+  portfolio: DecafPortfolioId;
+  shareclass?: DecafShareClassId;
   date: SDate;
   ccy: CurrencyCode;
   shares?: number;
@@ -203,7 +203,7 @@ export function toShareClassValue(x: RemoteValuationShareClassValue): PortfolioV
       feeScheduleIds: x.shareclass.feeschedules,
       effectiveFeeScheduleId: Maybe.fromNullable(x.shareclass.effectivefeeschedule),
       subscriptionIds: x.shareclass.subscriptions,
-      outstanding: maybeDecimal(x.shareclass.outstanding),
+      outstanding: decimalFromNullable(x.shareclass.outstanding),
     },
     external: Maybe.fromNullable(x.external).map((ev) => ({
       id: ev.id,
@@ -216,36 +216,36 @@ export function toShareClassValue(x: RemoteValuationShareClassValue): PortfolioV
       shareclass: Maybe.fromNullable(ev.shareclass),
       date: ev.date,
       ccy: ev.ccy,
-      shares: maybeDecimal(ev.shares),
-      price: maybeDecimal(ev.price),
-      nav: maybeDecimal(ev.nav),
-      aum: maybeDecimal(ev.aum),
-      hedgepnl: maybeDecimal(ev.hedgepnl),
-      feemngt: maybeDecimal(ev.feemngt),
-      feeperf: maybeDecimal(ev.feeperf),
-      otheraccrued: maybeDecimal(ev.otheraccrued),
-      totalaccrued: maybeDecimal(ev.totalaccrued),
-      subred: maybeDecimal(ev.subred),
-      perfdaily: maybeDecimal(ev.perfdaily),
-      perfweekly: maybeDecimal(ev.perfweekly),
-      perfmonthly: maybeDecimal(ev.perfmonthly),
-      perfytd: maybeDecimal(ev.perfytd),
-      perfstart: maybeDecimal(ev.perfstart),
-      coefficient: maybeDecimal(ev.coefficient),
+      shares: decimalFromNullable(ev.shares),
+      price: decimalFromNullable(ev.price),
+      nav: decimalFromNullable(ev.nav),
+      aum: decimalFromNullable(ev.aum),
+      hedgepnl: decimalFromNullable(ev.hedgepnl),
+      feemngt: decimalFromNullable(ev.feemngt),
+      feeperf: decimalFromNullable(ev.feeperf),
+      otheraccrued: decimalFromNullable(ev.otheraccrued),
+      totalaccrued: decimalFromNullable(ev.totalaccrued),
+      subred: decimalFromNullable(ev.subred),
+      perfdaily: decimalFromNullable(ev.perfdaily),
+      perfweekly: decimalFromNullable(ev.perfweekly),
+      perfmonthly: decimalFromNullable(ev.perfmonthly),
+      perfytd: decimalFromNullable(ev.perfytd),
+      perfstart: decimalFromNullable(ev.perfstart),
+      coefficient: decimalFromNullable(ev.coefficient),
     })),
-    nav: asDecimal(x.nav),
-    navAdjusted: asDecimal(x.nav_adjusted),
-    navAdjustedTotal: asDecimal(x.nav_adjusted_total),
-    coefficient: asDecimal(x.coefficient),
-    gavRefccy: asDecimal(x.gav_refccy),
-    gavClsccy: asDecimal(x.gav_clsccy),
-    sharecountPrev: asDecimal(x.sharecount_prev),
-    sharecountCurr: asDecimal(x.sharecount_curr),
-    sharecountDiff: asDecimal(x.sharecount_diff),
-    pxRefCcy: maybeDecimal(x.px_refccy),
-    pxClsCcy: maybeDecimal(x.px_clsccy),
-    ytdExt: maybeDecimal(x.ytdext),
-    ytdInt: maybeDecimal(x.ytdint),
+    nav: unsafeDecimal(x.nav),
+    navAdjusted: unsafeDecimal(x.nav_adjusted),
+    navAdjustedTotal: unsafeDecimal(x.nav_adjusted_total),
+    coefficient: unsafeDecimal(x.coefficient),
+    gavRefccy: unsafeDecimal(x.gav_refccy),
+    gavClsccy: unsafeDecimal(x.gav_clsccy),
+    sharecountPrev: unsafeDecimal(x.sharecount_prev),
+    sharecountCurr: unsafeDecimal(x.sharecount_curr),
+    sharecountDiff: unsafeDecimal(x.sharecount_diff),
+    pxRefCcy: decimalFromNullable(x.px_refccy),
+    pxClsCcy: decimalFromNullable(x.px_clsccy),
+    ytdExt: decimalFromNullable(x.ytdext),
+    ytdInt: decimalFromNullable(x.ytdint),
   };
 }
 
@@ -268,7 +268,7 @@ export function recompilePortfolioValuationReport(
     return {
       ...report,
       portfolio: x.portfolio,
-      subscriptions: maybeDecimal(x.subscriptions).orDefault(zero),
+      subscriptions: decimalFromNullable(x.subscriptions).orDefault(zero),
       shareClassValues: x.scvals.map(toShareClassValue),
     };
   });

package/src/reports/valuation/-remote-valuation-report-shared.ts

@@ -1,19 +1,19 @@
 import {
-  asDecimal,
   CustomError,
   Decimal,
+  decimalFromNullable,
   Either,
   Just,
   Maybe,
-  maybeDecimal,
   Right,
   safeDiv,
   sanitizedNonEmptyText,
   SDate,
   SDateTime,
+  unsafeDecimal,
   zero,
 } from '@telostat/prelude';
-import { ArtifactId, ArtifactTypeId, CurrencyCode, DateType } from '../../commons';
+import { CurrencyCode, DateType, DecafArtifactId, DecafArtifactTypeId } from '../../commons';
 import {
   BaseValuationReport,
   BaseValuationReportHolding,
@@ -124,9 +124,9 @@ export interface RemoteValuationReportChildHolding {
  * Valuation artifact.
  */
 export interface RemoteValuationReportArtifact {
-  id: ArtifactId;
+  id: DecafArtifactId;
   guid: string;
-  type: { id: ArtifactTypeId; name: string; order: number };
+  type: { id: DecafArtifactTypeId; name: string; order: number };
   stype?: string;
   symbol: string;
   name?: string;
@@ -140,7 +140,7 @@ export interface RemoteValuationReportArtifact {
   isin?: string;
   figi?: string;
   expiry?: SDate;
-  underlying_id?: ArtifactId;
+  underlying_id?: DecafArtifactId;
 }
 
 /**
@@ -179,7 +179,7 @@ export function toArtifact(x: RemoteValuationReportArtifact): ValuationReportArt
     symbol: x.symbol,
     name: sanitizedNonEmptyText(x.name),
     ccy: Maybe.fromNullable(x.ccy),
-    quantity: asDecimal(x.quantity),
+    quantity: unsafeDecimal(x.quantity),
     country: sanitizedNonEmptyText(x.country),
     issuer: sanitizedNonEmptyText(x.issuer),
     sector: sanitizedNonEmptyText(x.sector),
@@ -195,14 +195,17 @@ export function toArtifact(x: RemoteValuationReportArtifact): ValuationReportArt
 export function toAccrual(x: RemoteValuationReportAccrual): ValuationReportAccrual {
   return {
     name: x.name,
-    value: asDecimal(x.value),
+    value: unsafeDecimal(x.value),
     accounts: x.accounts.map((y) => ({
       account: y.account,
-      value: asDecimal(y.value),
+      value: unsafeDecimal(y.value),
       accruals: y.accruals.map((z) => ({
         artifact: toArtifact(z.artifact),
         ccy: z.ccy,
-        value: { org: asDecimal(z.value.org || 0), ref: asDecimal(z.value.ref || 0) },
+        value: {
+          org: decimalFromNullable(z.value.org).orDefault(zero),
+          ref: decimalFromNullable(z.value.ref).orDefault(zero),
+        },
       })),
     })),
   };
@@ -210,14 +213,14 @@ export function toAccrual(x: RemoteValuationReportAccrual): ValuationReportAccru
 
 export function toOrgRef(x: { org?: number; ref?: number }): ValuationReportFigureOrgRef {
   return {
-    org: maybeDecimal(x.org).orDefault(zero),
-    ref: maybeDecimal(x.ref).orDefault(zero),
+    org: decimalFromNullable(x.org).orDefault(zero),
+    ref: decimalFromNullable(x.ref).orDefault(zero),
   };
 }
 
 export function toMaybeOrgRef(x?: { org?: number; ref?: number }): Maybe<ValuationReportFigureOrgRef> {
   return Maybe.fromNullable(x).chain(({ org, ref }) =>
-    maybeDecimal(org).chain((o) => maybeDecimal(ref).chain((r) => Just({ org: o, ref: r })))
+    decimalFromNullable(org).chain((o) => decimalFromNullable(ref).chain((r) => Just({ org: o, ref: r })))
   );
 }
 
@@ -227,7 +230,7 @@ export function toBaseHolding(
 ): BaseValuationReportHolding {
   return {
     artifact: toArtifact(x.artifact),
-    quantity: asDecimal(x.quantity),
+    quantity: unsafeDecimal(x.quantity),
     investment: {
       px: toOrgRef(x.investment.px),
       txncosts: toMaybeOrgRef(x.investment.txncosts),
@@ -246,12 +249,12 @@ export function toBaseHolding(
         abs: toOrgRef(x.valuation.exposure.abs),
       },
     },
-    valuePercentage: safeDiv(maybeDecimal(x.valuation.value.net.ref).orDefault(zero), nav),
-    netExposurePercentage: safeDiv(maybeDecimal(x.valuation.exposure.net.ref).orDefault(zero), nav),
-    absExposurePercentage: safeDiv(maybeDecimal(x.valuation.exposure.abs.ref).orDefault(zero), nav),
-    change: maybeDecimal(x.change),
-    pnl: maybeDecimal(x.pnl).orDefault(zero),
-    pnlToInvestment: maybeDecimal(x.pnl_to_investment),
+    valuePercentage: safeDiv(decimalFromNullable(x.valuation.value.net.ref).orDefault(zero), nav),
+    netExposurePercentage: safeDiv(decimalFromNullable(x.valuation.exposure.net.ref).orDefault(zero), nav),
+    absExposurePercentage: safeDiv(decimalFromNullable(x.valuation.exposure.abs.ref).orDefault(zero), nav),
+    change: decimalFromNullable(x.change),
+    pnl: decimalFromNullable(x.pnl).orDefault(zero),
+    pnlToInvestment: decimalFromNullable(x.pnl_to_investment),
     opendate: x.opendate,
     lastdate: x.lastdate,
   };
@@ -282,7 +285,7 @@ export function toHolding(nav: Decimal, x: RemoteValuationReportHolding): Valuat
  * report.
  */
 export function recompileBaseValuationReport(x: RemoteBaseValuationReport): Either<CustomError, BaseValuationReport> {
-  const nav = maybeDecimal(x.nav).orDefault(zero);
+  const nav = decimalFromNullable(x.nav).orDefault(zero);
 
   const report: BaseValuationReport = {
     asof: x.reported,
@@ -292,20 +295,20 @@ export function recompileBaseValuationReport(x: RemoteBaseValuationReport): Eith
     accounts: x.accounts,
     holdings: x.holdings.map((rh) => toHolding(nav, rh)),
     accruals: x.accruals.map(toAccrual),
-    fxRates: x.fxrates.map((r) => ({ ccy1: r.ccy1, ccy2: r.ccy2, value: asDecimal(r.value), asof: r.asof })),
+    fxRates: x.fxrates.map((r) => ({ ccy1: r.ccy1, ccy2: r.ccy2, value: unsafeDecimal(r.value), asof: r.asof })),
     figures: {
-      investment: maybeDecimal(x.investment).orDefault(zero),
+      investment: decimalFromNullable(x.investment).orDefault(zero),
       valuation: {
-        net: maybeDecimal(x.valuation_net).orDefault(zero),
-        abs: maybeDecimal(x.valuation_abs).orDefault(zero),
+        net: decimalFromNullable(x.valuation_net).orDefault(zero),
+        abs: decimalFromNullable(x.valuation_abs).orDefault(zero),
       },
-      accrued: maybeDecimal(x.accrued).orDefault(zero),
-      liabilities: maybeDecimal(x.liabilities).orDefault(zero),
-      gav: maybeDecimal(x.gav).orDefault(zero),
+      accrued: decimalFromNullable(x.accrued).orDefault(zero),
+      liabilities: decimalFromNullable(x.liabilities).orDefault(zero),
+      gav: decimalFromNullable(x.gav).orDefault(zero),
       nav,
-      aum: maybeDecimal(x.aum).orDefault(zero),
-      pnl: maybeDecimal(x.pnl).orDefault(zero),
-      pnlToInvestment: maybeDecimal(x.pnl_to_investment),
+      aum: decimalFromNullable(x.aum).orDefault(zero),
+      pnl: decimalFromNullable(x.pnl).orDefault(zero),
+      pnlToInvestment: decimalFromNullable(x.pnl_to_investment),
     },
   };
 

package/src/reports/valuation/-valuation-report-holdings-tree/-machinery.ts

@@ -1,7 +1,6 @@
-import { Decimal, safeDiv, sumDecimals, Tuple, zero } from '@telostat/prelude';
-import { Just, Maybe, Nothing } from 'purify-ts';
-import { List } from 'purify-ts/List';
+import { Decimal, Just, List, Maybe, Nothing, safeDiv, sumDecimals, Tuple, zero } from '@telostat/prelude';
 import { ValuationReportHolding, ValuationReportHoldingClassification } from '../-valuation-report-shared';
+import { DecafArtifactTypeId } from '../../../commons';
 import { ValuationReportHoldingsTreeNode, ValuationReportHoldingsTreeNodeValue } from './-types';
 import { compareStringArrays } from './-utils';
 
@@ -36,10 +35,20 @@ export function updateTotals(
   const absValue = sumDecimals(holdings.map((x) => x.valuation.value.abs.ref)).add(
     sumDecimals(children.map((x) => x.totals.absValue))
   );
-  const netExposure = sumDecimals(holdings.map((x) => x.valuation.exposure.net.ref)).add(
+
+  const holdingsForExposure = holdings.filter(
+    (h) =>
+      !(
+        h.artifact.type.id === ('CCY' as unknown as DecafArtifactTypeId) ||
+        h.artifact.type.id === ('DEPO' as unknown as DecafArtifactTypeId) ||
+        h.artifact.type.id === ('LOAN' as unknown as DecafArtifactTypeId)
+      )
+  );
+
+  const netExposure = sumDecimals(holdingsForExposure.map((x) => x.valuation.exposure.net.ref)).add(
     sumDecimals(children.map((x) => x.totals.netExposure))
   );
-  const absExposure = sumDecimals(holdings.map((x) => x.valuation.exposure.abs.ref)).add(
+  const absExposure = sumDecimals(holdingsForExposure.map((x) => x.valuation.exposure.abs.ref)).add(
     sumDecimals(children.map((x) => x.totals.absExposure))
   );
   const pnl = sumDecimals(holdings.map((x) => x.pnl)).add(sumDecimals(children.map((x) => x.totals.pnl)));