@decafhub/decaf-client-extras 0.4.0 → 0.5.0

package/reports/valuation/-remote-valuation-report-account.js

@@ -0,0 +1,196 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAccountValuationReport = exports.recompileAccountValuationReport = exports.toShareClassValue = exports.fetchRemoteAccountValuationReport = void 0;
+var prelude_1 = require("@telostat/prelude");
+var _remote_valuation_report_shared_1 = require("./-remote-valuation-report-shared");
+/**
+ * Attempts to retrieve remote account valuation report.
+ *
+ * @param client DECAF Barista client.
+ * @param query Remote account valuation report endpoint query parameters.
+ * @returns Remote (raw) account valuation report data.
+ */
+function fetchRemoteAccountValuationReport(client, query) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, client.barista
+                    .get('/reports/valuation/account/', {
+                    params: {
+                        ccy: query.currency,
+                        date: query.date,
+                        type: query.dateType,
+                        account: "".concat(query.account),
+                    },
+                })
+                    .then(function (x) { return (0, prelude_1.Right)(x.data); })
+                    .catch(function (err) { return (0, prelude_1.Left)((0, prelude_1.customError)('Error while attempting to fetch remote account valuation report', err)); })];
+        });
+    });
+}
+exports.fetchRemoteAccountValuationReport = fetchRemoteAccountValuationReport;
+/**
+ * Attempts to recompile remote valuation report share class value.
+ *
+ * @param x remote valuation report share class value object.
+ * @return Recompiled valuation report share class value object.
+ */
+function toShareClassValue(s) {
+    var shareclass = prelude_1.Maybe.fromNullable(s.shareclass).map(function (x) { return ({
+        id: x.id,
+        created: x.created,
+        creator: prelude_1.Maybe.fromNullable(x.creator),
+        updated: x.updated,
+        updater: prelude_1.Maybe.fromNullable(x.updater),
+        guid: x.guid,
+        portfolio: x.portfolio,
+        name: x.name,
+        currency: x.currency,
+        isin: (0, prelude_1.sanitizedNonEmptyText)(x.isin),
+        bbgticker: (0, prelude_1.sanitizedNonEmptyText)(x.bbgticker),
+        liquidity: (0, prelude_1.sanitizedNonEmptyText)(x.liquidity),
+        jurisdiction: (0, prelude_1.sanitizedNonEmptyText)(x.jurisdiction),
+        administrator: (0, prelude_1.sanitizedNonEmptyText)(x.administrator),
+        minimumInvestment: prelude_1.Maybe.fromNullable(x.mininvestment),
+        subscriptionRedemptionPeriod: (0, prelude_1.sanitizedNonEmptyText)(x.subredperiod),
+        managementFeeFrequency: prelude_1.Maybe.fromNullable(x.freqmngt),
+        performanceFeeFrequency: prelude_1.Maybe.fromNullable(x.freqperf),
+        benchmark: prelude_1.Maybe.fromNullable(x.benchmark),
+        description: (0, prelude_1.sanitizedNonEmptyText)(x.description),
+        feeScheduleIds: x.feeschedules,
+        effectiveFeeScheduleId: prelude_1.Maybe.fromNullable(x.effectivefeeschedule),
+        subscriptionIds: x.subscriptions,
+        outstanding: (0, prelude_1.decimalFromNullable)(x.outstanding),
+    }); });
+    return {
+        shareclass: shareclass,
+        external: prelude_1.Maybe.fromNullable(s.external).map(function (ev) { return ({
+            id: ev.id,
+            created: ev.created,
+            creator: prelude_1.Maybe.fromNullable(ev.updater),
+            updated: ev.updated,
+            updater: prelude_1.Maybe.fromNullable(ev.updater),
+            guid: ev.guid,
+            portfolio: ev.portfolio,
+            shareclass: prelude_1.Maybe.fromNullable(ev.shareclass),
+            date: ev.date,
+            ccy: ev.ccy,
+            shares: (0, prelude_1.decimalFromNullable)(ev.shares),
+            price: (0, prelude_1.decimalFromNullable)(ev.price),
+            nav: (0, prelude_1.decimalFromNullable)(ev.nav),
+            aum: (0, prelude_1.decimalFromNullable)(ev.aum),
+            hedgepnl: (0, prelude_1.decimalFromNullable)(ev.hedgepnl),
+            feemngt: (0, prelude_1.decimalFromNullable)(ev.feemngt),
+            feeperf: (0, prelude_1.decimalFromNullable)(ev.feeperf),
+            otheraccrued: (0, prelude_1.decimalFromNullable)(ev.otheraccrued),
+            totalaccrued: (0, prelude_1.decimalFromNullable)(ev.totalaccrued),
+            subred: (0, prelude_1.decimalFromNullable)(ev.subred),
+            perfdaily: (0, prelude_1.decimalFromNullable)(ev.perfdaily),
+            perfweekly: (0, prelude_1.decimalFromNullable)(ev.perfweekly),
+            perfmonthly: (0, prelude_1.decimalFromNullable)(ev.perfmonthly),
+            perfytd: (0, prelude_1.decimalFromNullable)(ev.perfytd),
+            perfstart: (0, prelude_1.decimalFromNullable)(ev.perfstart),
+            coefficient: (0, prelude_1.decimalFromNullable)(ev.coefficient),
+        }); }),
+        nav: (0, prelude_1.unsafeDecimal)(s.nav),
+        navAdjusted: (0, prelude_1.unsafeDecimal)(s.nav_adjusted),
+        navAdjustedTotal: (0, prelude_1.unsafeDecimal)(s.nav_adjusted_total),
+        coefficient: (0, prelude_1.unsafeDecimal)(s.coefficient),
+        gavRefccy: (0, prelude_1.unsafeDecimal)(s.gav_refccy),
+        gavClsccy: (0, prelude_1.unsafeDecimal)(s.gav_clsccy),
+        sharecountPrev: prelude_1.Maybe.fromNullable(s.sharecount_prev).map(prelude_1.unsafeDecimal),
+        sharecountCurr: prelude_1.Maybe.fromNullable(s.sharecount_curr).map(prelude_1.unsafeDecimal),
+        sharecountDiff: prelude_1.Maybe.fromNullable(s.sharecount_diff).map(prelude_1.unsafeDecimal),
+        pxRefCcy: (0, prelude_1.decimalFromNullable)(s.px_refccy),
+        pxClsCcy: (0, prelude_1.decimalFromNullable)(s.px_clsccy),
+        ytdExt: (0, prelude_1.decimalFromNullable)(s.ytdext),
+        ytdInt: (0, prelude_1.decimalFromNullable)(s.ytdint),
+    };
+}
+exports.toShareClassValue = toShareClassValue;
+/**
+ * Attempts to re-compile the raw, remote account valuation report and
+ * return it.
+ *
+ * @param x Raw, remote account valuation report.
+ * @returns Either of an error message or the re-compiled account valuation
+ * report.
+ */
+function recompileAccountValuationReport(x) {
+    // Attempt to get the base valuation report:
+    var baseReport = (0, _remote_valuation_report_shared_1.recompileBaseValuationReport)(x);
+    // Add consolidated valuation report specific fields and return:
+    return baseReport.map(function (report) {
+        return __assign(__assign({}, report), { account: x.account, subscriptions: (0, prelude_1.decimalFromNullable)(x.subscriptions).orDefault(prelude_1.zero), shareClassValues: x.scvals.map(toShareClassValue) });
+    });
+}
+exports.recompileAccountValuationReport = recompileAccountValuationReport;
+/**
+ * Attempts to retrieve remote account valuation report, compiles it to
+ * {@link AccountValuationReport} and return it.
+ *
+ * @param client DECAF Barista client.
+ * @param query Remote account valuation report endpoint query parameters.
+ * @returns Recompiled account valuation report data.
+ */
+function fetchAccountValuationReport(client, query) {
+    return __awaiter(this, void 0, void 0, function () {
+        var rawReport;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, fetchRemoteAccountValuationReport(client, query)];
+                case 1:
+                    rawReport = _a.sent();
+                    // Attempt to recompile the report (if any) and return:
+                    return [2 /*return*/, rawReport.chain(recompileAccountValuationReport)];
+            }
+        });
+    });
+}
+exports.fetchAccountValuationReport = fetchAccountValuationReport;

package/reports/valuation/-valuation-report-account.d.ts

@@ -0,0 +1,79 @@
+import { Decimal, Maybe, SDate, SDateTime } from '@telostat/prelude';
+import { DecafActionId, CurrencyCode, DecafExternalValuationId, DecafOhlcSeriesId, DecafPortfolioId, DecafPrincipalId, DecafShareClassFeeScheduleId, DecafShareClassId } from '../../commons';
+import { BaseValuationReport, ValuationReportAccount } from './-valuation-report-shared';
+export interface AccountValuationReport extends BaseValuationReport {
+    account: ValuationReportAccount;
+    subscriptions: Decimal;
+    shareClassValues: AccountValuationReportShareClassValue[];
+}
+export interface AccountValuationReportShareClassValue {
+    shareclass: Maybe<AccountValuationReportShareClass>;
+    external: Maybe<AccountValuationReportExternalValue>;
+    nav: Decimal;
+    navAdjusted: Decimal;
+    navAdjustedTotal: Decimal;
+    coefficient: Decimal;
+    gavRefccy: Decimal;
+    gavClsccy: Decimal;
+    sharecountPrev: Maybe<Decimal>;
+    sharecountCurr: Maybe<Decimal>;
+    sharecountDiff: Maybe<Decimal>;
+    pxRefCcy: Maybe<Decimal>;
+    pxClsCcy: Maybe<Decimal>;
+    ytdExt: Maybe<Decimal>;
+    ytdInt: Maybe<Decimal>;
+}
+export interface AccountValuationReportShareClass {
+    id: DecafShareClassId;
+    created: SDateTime;
+    creator: Maybe<DecafPrincipalId>;
+    updated: SDateTime;
+    updater: Maybe<DecafPrincipalId>;
+    guid: string;
+    portfolio: DecafPortfolioId;
+    name: string;
+    currency: CurrencyCode;
+    isin: Maybe<string>;
+    bbgticker: Maybe<string>;
+    liquidity: Maybe<string>;
+    jurisdiction: Maybe<string>;
+    administrator: Maybe<string>;
+    minimumInvestment: Maybe<number>;
+    subscriptionRedemptionPeriod: Maybe<string>;
+    managementFeeFrequency: Maybe<number>;
+    performanceFeeFrequency: Maybe<number>;
+    benchmark: Maybe<DecafOhlcSeriesId>;
+    description: Maybe<string>;
+    feeScheduleIds: DecafShareClassFeeScheduleId[];
+    effectiveFeeScheduleId: Maybe<DecafShareClassFeeScheduleId>;
+    subscriptionIds: DecafActionId[];
+    outstanding: Maybe<Decimal>;
+}
+export interface AccountValuationReportExternalValue {
+    id: DecafExternalValuationId;
+    created: SDateTime;
+    creator: Maybe<DecafPrincipalId>;
+    updated: SDateTime;
+    updater: Maybe<DecafPrincipalId>;
+    guid: string;
+    portfolio: DecafPortfolioId;
+    shareclass: Maybe<DecafShareClassId>;
+    date: SDate;
+    ccy: CurrencyCode;
+    shares: Maybe<Decimal>;
+    price: Maybe<Decimal>;
+    nav: Maybe<Decimal>;
+    aum: Maybe<Decimal>;
+    hedgepnl: Maybe<Decimal>;
+    feemngt: Maybe<Decimal>;
+    feeperf: Maybe<Decimal>;
+    otheraccrued: Maybe<Decimal>;
+    totalaccrued: Maybe<Decimal>;
+    subred: Maybe<Decimal>;
+    perfdaily: Maybe<Decimal>;
+    perfweekly: Maybe<Decimal>;
+    perfmonthly: Maybe<Decimal>;
+    perfytd: Maybe<Decimal>;
+    perfstart: Maybe<Decimal>;
+    coefficient: Maybe<Decimal>;
+}

package/reports/valuation/-valuation-report-account.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/reports/valuation/index.d.ts

@@ -2,7 +2,10 @@ export { fetchConsolidatedValuationReport } from './-remote-valuation-report-con
 export type { ConsolidatedValuationReportQuery } from './-remote-valuation-report-consolidated';
 export { fetchPortfolioValuationReport } from './-remote-valuation-report-portfolio';
 export type { PortfolioValuationReportQuery } from './-remote-valuation-report-portfolio';
+export { fetchAccountValuationReport } from './-remote-valuation-report-account';
+export type { AccountValuationReportQuery } from './-remote-valuation-report-account';
 export * from './-valuation-report-consolidated';
 export * from './-valuation-report-holdings-tree';
 export * from './-valuation-report-portfolio';
 export * from './-valuation-report-shared';
+export * from './-valuation-report-account';

package/reports/valuation/index.js

@@ -14,12 +14,15 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchPortfolioValuationReport = exports.fetchConsolidatedValuationReport = void 0;
+exports.fetchAccountValuationReport = exports.fetchPortfolioValuationReport = exports.fetchConsolidatedValuationReport = void 0;
 var _remote_valuation_report_consolidated_1 = require("./-remote-valuation-report-consolidated");
 Object.defineProperty(exports, "fetchConsolidatedValuationReport", { enumerable: true, get: function () { return _remote_valuation_report_consolidated_1.fetchConsolidatedValuationReport; } });
 var _remote_valuation_report_portfolio_1 = require("./-remote-valuation-report-portfolio");
 Object.defineProperty(exports, "fetchPortfolioValuationReport", { enumerable: true, get: function () { return _remote_valuation_report_portfolio_1.fetchPortfolioValuationReport; } });
+var _remote_valuation_report_account_1 = require("./-remote-valuation-report-account");
+Object.defineProperty(exports, "fetchAccountValuationReport", { enumerable: true, get: function () { return _remote_valuation_report_account_1.fetchAccountValuationReport; } });
 __exportStar(require("./-valuation-report-consolidated"), exports);
 __exportStar(require("./-valuation-report-holdings-tree"), exports);
 __exportStar(require("./-valuation-report-portfolio"), exports);
 __exportStar(require("./-valuation-report-shared"), exports);
+__exportStar(require("./-valuation-report-account"), exports);

package/src/{index.test.ts → reports/index.test.ts}

@@ -2,12 +2,16 @@ import { buildDecafClient, DecafClient, gql } from '@decafhub/decaf-client';
 import { safeDiv, zero } from '@telostat/prelude';
 import { fail } from 'assert';
 import dayjs from 'dayjs';
-import { DecafPortfolioId, mkCurrencyCodeError } from './commons';
-import { makeValuationReportHoldingsTree } from './reports/valuation/';
+import { DecafAccountId, DecafPortfolioId, mkCurrencyCodeError } from '../commons';
+import { makeValuationReportHoldingsTree } from './valuation';
 import {
   fetchPortfolioValuationReport,
   fetchRemotePortfolioValuationReport,
-} from './reports/valuation/-remote-valuation-report-portfolio';
+} from './valuation/-remote-valuation-report-portfolio';
+import {
+  fetchAccountValuationReport,
+  fetchRemoteAccountValuationReport,
+} from './valuation/-remote-valuation-report-account';
 
 const API_URL = process.env.TESTING_API_URL;
 const API_KEY = process.env.TESTING_API_KEY;
@@ -22,9 +26,19 @@ const FIRST_PORTFOLIO_QUERY = gql`
   }
 `;
 
-describe('Main', () => {
+const FIRST_ACCOUNT_QUERY = gql`
+  query GetFirstAccount {
+    account(limit: 1) {
+      id
+      name
+    }
+  }
+`;
+
+describe('Reports', () => {
   let client: DecafClient;
   let portfolioId: DecafPortfolioId;
+  let accountId: DecafAccountId;
 
   beforeAll(() => {
     jest.resetModules();
@@ -52,6 +66,16 @@ describe('Main', () => {
     }
   });
 
+  test('take the first account', async () => {
+    try {
+      const { data } = await client.microlot.query({ query: FIRST_ACCOUNT_QUERY });
+      accountId = data?.account?.[0].id;
+      expect(accountId).toBeDefined();
+    } catch (e) {
+      fail('Error while fetching the first account');
+    }
+  });
+
   test('get a remote portfolio report successfuly', async () => {
     const eValue = await fetchRemotePortfolioValuationReport(client, {
       portfolio: portfolioId,
@@ -66,6 +90,7 @@ describe('Main', () => {
           `Success! remote valuation for portfolio ID ${value.portfolio.id} is reported at ${value.reported}`
         );
         expect(value).toBeDefined();
+        expect(value.portfolio.id).toEqual(portfolioId);
       },
     });
   });
@@ -94,4 +119,45 @@ describe('Main', () => {
       },
     });
   });
+
+  test('get a remote account report successfuly', async () => {
+    const eValue = await fetchRemoteAccountValuationReport(client, {
+      account: accountId,
+      date: dayjs(new Date()).format('YYYY-MM-DD'),
+      dateType: 'settlement',
+      currency: mkCurrencyCodeError('EUR'),
+    });
+    eValue.caseOf({
+      Left: (e) => fail('Error while fetching the remote account report: ' + e.msg),
+      Right: (value) => {
+        console.log(`Success! remote valuation for account ID ${value.account.id} is reported at ${value.reported}`);
+        expect(value).toBeDefined();
+        expect(value.account.id).toEqual(accountId);
+      },
+    });
+  });
+
+  test('get an account report, check the tree', async () => {
+    const eValue = await fetchAccountValuationReport(client, {
+      account: accountId,
+      date: dayjs(new Date()).format('YYYY-MM-DD'),
+      dateType: 'settlement',
+      currency: mkCurrencyCodeError('EUR'),
+    });
+    eValue.caseOf({
+      Left: (e) => fail('Error while fetching the remote account report: ' + String(e)),
+      Right: (value) => {
+        console.log(`Success! remote valuation for account ID ${value.account.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);
+      },
+    });
+  });
 });