@decafhub/decaf-client-extras 0.0.5 → 0.1.1

package/es/commons/-id.d.ts

@@ -1,58 +1,150 @@
-import { NewTypeWithPhantom } from '@telostat/prelude';
 /**
- * Type definition for identifiers with value spaces discriminated over the
- * given phantom type.
+ * 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
  */
-export type Id<P, V> = NewTypeWithPhantom<P, V>;
+/**
+ * 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;
+export declare function mkDecafRecordId<T extends _DecafRecordIdFromNumber>(x: number): T;
+export declare function mkDecafRecordId<T extends _DecafRecordIdFromString>(x: string): T;
+export declare function unDecafRecordId<T extends _DecafRecordIdFromNumber>(x: T): number;
+export declare function unDecafRecordId<K extends _DecafRecordIdFromString>(x: K): string;
 /**
  * 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/es/commons/-id.js

@@ -1 +1,70 @@
-export {};
+/**
+ * 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
+ */
+/**
+ * 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(x) {
+    return x;
+}
+/**
+ * Deconstructor for DECAF record identifiers.
+ *
+ * @param x DECAF record identifier.
+ * @returns Value of the DECAF record identifier (deduced from call-site usage).
+ */
+export function unDecafRecordId(x) {
+    return x;
+}

package/es/commons/index.d.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/es/commons/index.js

@@ -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/es/reports/valuation/-remote-valuation-report-portfolio.d.ts

@@ -1,6 +1,6 @@
 import { DecafClient } from '@decafhub/decaf-client';
 import { CustomError, Either, SDate, SDateTime } from '@telostat/prelude';
-import { ActionId, CurrencyCode, DateType, ExternalValuationId, OhlcSeriesId, PortfolioId, PrincipalId, ShareClassFeeScheduleId, ShareClassId } from '../../commons';
+import { CurrencyCode, DateType, DecafActionId, DecafExternalValuationId, DecafOhlcSeriesId, DecafPortfolioId, DecafPrincipalId, DecafShareClassFeeScheduleId, DecafShareClassId } from '../../commons';
 import { RemoteBaseValuationReport } from './-remote-valuation-report-shared';
 import { PortfolioValuationReport, PortfolioValuationReportShareClassValue } from './-valuation-report-portfolio';
 import { ValuationReportPortfolio } from './-valuation-report-shared';
@@ -23,7 +23,7 @@ export interface PortfolioValuationReportQuery {
     /**
      * Portfolio the valuation report is requested for.
      */
-    portfolio: PortfolioId;
+    portfolio: DecafPortfolioId;
 }
 /**
  * Type definition for the remote (raw) portfolio valuation report data.
@@ -58,13 +58,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;
@@ -76,11 +76,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;
 }
 /**
@@ -88,14 +88,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;

package/es/reports/valuation/-remote-valuation-report-portfolio.js

@@ -1,4 +1,4 @@
-import { asDecimal, customError, Left, Maybe, maybeDecimal, Right, sanitizedNonEmptyText, zero, } from '@telostat/prelude';
+import { customError, decimalFromNullable, Left, Maybe, Right, sanitizedNonEmptyText, unsafeDecimal, zero, } from '@telostat/prelude';
 import { recompileBaseValuationReport } from './-remote-valuation-report-shared';
 /**
  * Attempts to retrieve remote portfolio valuation report.
@@ -52,7 +52,7 @@ export function toShareClassValue(x) {
             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,
@@ -65,36 +65,36 @@ export function toShareClassValue(x) {
             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),
     };
 }
 /**
@@ -113,7 +113,7 @@ export function recompilePortfolioValuationReport(x) {
         return {
             ...report,
             portfolio: x.portfolio,
-            subscriptions: maybeDecimal(x.subscriptions).orDefault(zero),
+            subscriptions: decimalFromNullable(x.subscriptions).orDefault(zero),
             shareClassValues: x.scvals.map(toShareClassValue),
         };
     });

package/es/reports/valuation/-remote-valuation-report-shared.d.ts

@@ -1,5 +1,5 @@
 import { CustomError, Decimal, Either, Maybe, SDate, SDateTime } from '@telostat/prelude';
-import { ArtifactId, ArtifactTypeId, CurrencyCode, DateType } from '../../commons';
+import { CurrencyCode, DateType, DecafArtifactId, DecafArtifactTypeId } from '../../commons';
 import { BaseValuationReport, BaseValuationReportHolding, ValuationReportAccount, ValuationReportAccounts, ValuationReportAccrual, ValuationReportArtifact, ValuationReportFigureOrgRef, ValuationReportHolding } from './-valuation-report-shared';
 export interface RemoteBaseValuationReport {
     reported: SDateTime;
@@ -161,10 +161,10 @@ export interface RemoteValuationReportChildHolding {
  * Valuation artifact.
  */
 export interface RemoteValuationReportArtifact {
-    id: ArtifactId;
+    id: DecafArtifactId;
     guid: string;
     type: {
-        id: ArtifactTypeId;
+        id: DecafArtifactTypeId;
         name: string;
         order: number;
     };
@@ -181,7 +181,7 @@ export interface RemoteValuationReportArtifact {
     isin?: string;
     figi?: string;
     expiry?: SDate;
-    underlying_id?: ArtifactId;
+    underlying_id?: DecafArtifactId;
 }
 /**
  * Valuation accrual.

package/es/reports/valuation/-remote-valuation-report-shared.js

@@ -1,4 +1,4 @@
-import { asDecimal, Just, Maybe, maybeDecimal, Right, safeDiv, sanitizedNonEmptyText, zero, } from '@telostat/prelude';
+import { decimalFromNullable, Just, Maybe, Right, safeDiv, sanitizedNonEmptyText, unsafeDecimal, zero, } from '@telostat/prelude';
 export function toArtifact(x) {
     return {
         id: x.id,
@@ -8,7 +8,7 @@ export function toArtifact(x) {
         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),
@@ -23,31 +23,34 @@ export function toArtifact(x) {
 export function toAccrual(x) {
     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),
+                },
             })),
         })),
     };
 }
 export function toOrgRef(x) {
     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) {
-    return Maybe.fromNullable(x).chain(({ org, ref }) => maybeDecimal(org).chain((o) => maybeDecimal(ref).chain((r) => Just({ org: o, ref: r }))));
+    return Maybe.fromNullable(x).chain(({ org, ref }) => decimalFromNullable(org).chain((o) => decimalFromNullable(ref).chain((r) => Just({ org: o, ref: r }))));
 }
 export function toBaseHolding(nav, x) {
     return {
         artifact: toArtifact(x.artifact),
-        quantity: asDecimal(x.quantity),
+        quantity: unsafeDecimal(x.quantity),
         investment: {
             px: toOrgRef(x.investment.px),
             txncosts: toMaybeOrgRef(x.investment.txncosts),
@@ -66,12 +69,12 @@ export function toBaseHolding(nav, x) {
                 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,
     };
@@ -98,7 +101,7 @@ export function toHolding(nav, x) {
  * report.
  */
 export function recompileBaseValuationReport(x) {
-    const nav = maybeDecimal(x.nav).orDefault(zero);
+    const nav = decimalFromNullable(x.nav).orDefault(zero);
     const report = {
         asof: x.reported,
         date: x.asof,
@@ -107,20 +110,20 @@ export function recompileBaseValuationReport(x) {
         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),
         },
     };
     return Right(report);

package/es/reports/valuation/-valuation-report-holdings-tree/-machinery.js

@@ -1,6 +1,4 @@
-import { safeDiv, sumDecimals, Tuple, zero } from '@telostat/prelude';
-import { Just, Maybe, Nothing } from 'purify-ts';
-import { List } from 'purify-ts/List';
+import { Just, List, Maybe, Nothing, safeDiv, sumDecimals, Tuple, zero } from '@telostat/prelude';
 import { compareStringArrays } from './-utils';
 export function makeValuationReportHoldingsTreeNodeValue() {
     return {

package/es/reports/valuation/-valuation-report-portfolio.d.ts

@@ -1,5 +1,5 @@
 import { Decimal, Maybe, SDate, SDateTime } from '@telostat/prelude';
-import { ActionId, CurrencyCode, ExternalValuationId, OhlcSeriesId, PortfolioId, PrincipalId, ShareClassFeeScheduleId, ShareClassId } from '../../commons';
+import { DecafActionId, CurrencyCode, DecafExternalValuationId, DecafOhlcSeriesId, DecafPortfolioId, DecafPrincipalId, DecafShareClassFeeScheduleId, DecafShareClassId } from '../../commons';
 import { BaseValuationReport, ValuationReportPortfolio } from './-valuation-report-shared';
 export interface PortfolioValuationReport extends BaseValuationReport {
     portfolio: ValuationReportPortfolio;
@@ -24,13 +24,13 @@ export interface PortfolioValuationReportShareClassValue {
     ytdInt: Maybe<Decimal>;
 }
 export interface PortfolioValuationReportShareClass {
-    id: ShareClassId;
+    id: DecafShareClassId;
     created: SDateTime;
-    creator: Maybe<PrincipalId>;
+    creator: Maybe<DecafPrincipalId>;
     updated: SDateTime;
-    updater: Maybe<PrincipalId>;
+    updater: Maybe<DecafPrincipalId>;
     guid: string;
-    portfolio: PortfolioId;
+    portfolio: DecafPortfolioId;
     name: string;
     currency: CurrencyCode;
     isin: Maybe<string>;
@@ -42,22 +42,22 @@ export interface PortfolioValuationReportShareClass {
     subscriptionRedemptionPeriod: Maybe<string>;
     managementFeeFrequency: Maybe<number>;
     performanceFeeFrequency: Maybe<number>;
-    benchmark: Maybe<OhlcSeriesId>;
+    benchmark: Maybe<DecafOhlcSeriesId>;
     description: Maybe<string>;
-    feeScheduleIds: ShareClassFeeScheduleId[];
-    effectiveFeeScheduleId: Maybe<ShareClassFeeScheduleId>;
-    subscriptionIds: ActionId[];
+    feeScheduleIds: DecafShareClassFeeScheduleId[];
+    effectiveFeeScheduleId: Maybe<DecafShareClassFeeScheduleId>;
+    subscriptionIds: DecafActionId[];
     outstanding: Maybe<Decimal>;
 }
 export interface PortfolioValuationReportExternalValue {
-    id: ExternalValuationId;
+    id: DecafExternalValuationId;
     created: SDateTime;
-    creator: Maybe<PrincipalId>;
+    creator: Maybe<DecafPrincipalId>;
     updated: SDateTime;
-    updater: Maybe<PrincipalId>;
+    updater: Maybe<DecafPrincipalId>;
     guid: string;
-    portfolio: PortfolioId;
-    shareclass: Maybe<ShareClassId>;
+    portfolio: DecafPortfolioId;
+    shareclass: Maybe<DecafShareClassId>;
     date: SDate;
     ccy: CurrencyCode;
     shares: Maybe<Decimal>;