@decafhub/decaf-client-extras 0.0.1

package/reports/valuation/-valuation-report-holdings-tree/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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.makeValuationReportHoldingsTree = void 0;
+var _machinery_1 = require("./-machinery");
+Object.defineProperty(exports, "makeValuationReportHoldingsTree", { enumerable: true, get: function () { return _machinery_1.makeValuationReportHoldingsTree; } });
+__exportStar(require("./-types"), exports);

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

@@ -0,0 +1,79 @@
+import { Decimal, Maybe, SDate, SDateTime } from '@telostat/prelude';
+import { ActionId, CurrencyCode, ExternalValuationId, OhlcSeriesId, PortfolioId, PrincipalId, ShareClassFeeScheduleId, ShareClassId } from '../../commons';
+import { BaseValuationReport, ValuationReportPortfolio } from './-valuation-report-shared';
+export interface PortfolioValuationReport extends BaseValuationReport {
+    portfolio: ValuationReportPortfolio;
+    subscriptions: Decimal;
+    shareClassValues: PortfolioValuationReportShareClassValue[];
+}
+export interface PortfolioValuationReportShareClassValue {
+    shareclass: PortfolioValuationReportShareClass;
+    external: Maybe<PortfolioValuationReportExternalValue>;
+    nav: Decimal;
+    navAdjusted: Decimal;
+    navAdjustedTotal: Decimal;
+    coefficient: Decimal;
+    gavRefccy: Decimal;
+    gavClsccy: Decimal;
+    sharecountPrev: Decimal;
+    sharecountCurr: Decimal;
+    sharecountDiff: Decimal;
+    pxRefCcy: Decimal;
+    pxClsCcy: Decimal;
+    ytdExt: Maybe<Decimal>;
+    ytdInt: Maybe<Decimal>;
+}
+export interface PortfolioValuationReportShareClass {
+    id: ShareClassId;
+    created: SDateTime;
+    creator: Maybe<PrincipalId>;
+    updated: SDateTime;
+    updater: Maybe<PrincipalId>;
+    guid: string;
+    portfolio: PortfolioId;
+    name: string;
+    currency: CurrencyCode;
+    isin: Maybe<string>;
+    bbgticker: Maybe<string>;
+    liquidity: Maybe<string>;
+    jurisdiction: Maybe<string>;
+    administrator: Maybe<string>;
+    minimumInvestment: Maybe<string>;
+    subscriptionRedemptionPeriod: Maybe<string>;
+    managementFeeFrequency: Maybe<number>;
+    performanceFeeFrequency: Maybe<number>;
+    benchmark: Maybe<OhlcSeriesId>;
+    description: Maybe<string>;
+    feeScheduleIds: ShareClassFeeScheduleId[];
+    effectiveFeeScheduleId: Maybe<ShareClassFeeScheduleId>;
+    subscriptionIds: ActionId[];
+    outstanding: Maybe<Decimal>;
+}
+export interface PortfolioValuationReportExternalValue {
+    id: ExternalValuationId;
+    created: SDateTime;
+    creator: Maybe<PrincipalId>;
+    updated: SDateTime;
+    updater: Maybe<PrincipalId>;
+    guid: string;
+    portfolio: PortfolioId;
+    shareclass: Maybe<ShareClassId>;
+    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-portfolio.js

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

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

@@ -0,0 +1,189 @@
+import { Decimal, Maybe, SDate, SDateTime } from '@telostat/prelude';
+import { AccountId, ArtifactId, ArtifactTypeId, CurrencyCode, DateType, PortfolioId } from '../../commons';
+/**
+ * Type definition for base valuation report.
+ */
+export interface BaseValuationReport {
+    asof: SDateTime;
+    date: SDate;
+    dateType: DateType;
+    currency: CurrencyCode;
+    accounts: ValuationReportAccounts;
+    holdings: ValuationReportHolding[];
+    accruals: ValuationReportAccrual[];
+    fxRates: ValuationReportFxRate[];
+    figures: {
+        investment: Decimal;
+        valuation: {
+            net: Decimal;
+            abs: Decimal;
+        };
+        accrued: Decimal;
+        liabilities: Decimal;
+        gav: Decimal;
+        nav: Decimal;
+        aum: Decimal;
+        pnl: Decimal;
+        pnlToInvestment?: Maybe<Decimal>;
+    };
+}
+/**
+ * Type definition for account reference in valuation reports.
+ */
+export interface ValuationReportAccount {
+    id: AccountId;
+    guid: string;
+    name: string;
+}
+/**
+ * Type definition for portfolio reference in valuation reports.
+ */
+export interface ValuationReportPortfolio {
+    id: PortfolioId;
+    guid: string;
+    name: string;
+}
+/**
+ * Type definition for accounts which valuation report is compiled from.
+ */
+export interface ValuationReportAccounts {
+    custody: ValuationReportAccount[];
+    journal: ValuationReportAccount[];
+}
+/**
+ * The definition for valuation report holding classification.
+ */
+export declare type ValuationReportHoldingClassification = ValuationReportHoldingClassificationNode[];
+/**
+ * Type definition for valuation report holding classification node.
+ */
+export interface ValuationReportHoldingClassificationNode {
+    name: string;
+    order: string | number;
+}
+/**
+ * Type definition for base valuation report holding (shared by
+ * [[ValuationReportHolding]] and [[ValuationReportChildHolding]]).
+ */
+export interface BaseValuationReportHolding {
+    artifact: ValuationReportArtifact;
+    quantity: Decimal;
+    investment: ValuationReportHoldingFiguresInvestment;
+    valuation: ValuationReportHoldingFiguresValuation;
+    valuePercentage: Maybe<Decimal>;
+    netExposurePercentage: Maybe<Decimal>;
+    absExposurePercentage: Maybe<Decimal>;
+    change: Maybe<Decimal>;
+    pnl: Decimal;
+    pnlToInvestment: Maybe<Decimal>;
+    opendate: SDate;
+    lastdate: SDate;
+}
+/**
+ * Type definition for valuation report holding investment figures.
+ */
+export interface ValuationReportHoldingFiguresInvestment {
+    px: ValuationReportFigureOrgRef;
+    txncosts: Maybe<ValuationReportFigureOrgRef>;
+    accrued: Maybe<ValuationReportFigureOrgRef>;
+    value: ValuationReportFigureOrgRef;
+}
+/**
+ * Type definition for valuation report holding valuation figures.
+ */
+export interface ValuationReportHoldingFiguresValuation {
+    px: ValuationReportFigureOrgRef;
+    accrued: Maybe<ValuationReportFigureOrgRef>;
+    value: {
+        net: ValuationReportFigureOrgRef;
+        abs: ValuationReportFigureOrgRef;
+    };
+    exposure: {
+        net: ValuationReportFigureOrgRef;
+        abs: ValuationReportFigureOrgRef;
+    };
+}
+/**
+ * Type definition for valuation report figure value that is reported both in
+ * original currency and reference currency.
+ */
+export interface ValuationReportFigureOrgRef {
+    org: Decimal;
+    ref: Decimal;
+}
+/**
+ * Type definition for a valuation holding.
+ */
+export interface ValuationReportHolding extends BaseValuationReportHolding {
+    classification: ValuationReportHoldingClassification;
+    accounts: ValuationReportAccount[];
+    children: Maybe<ValuationReportChildHolding[]>;
+}
+/**
+ * Type definition for a valuation holding child.
+ */
+export interface ValuationReportChildHolding extends BaseValuationReportHolding {
+    account: ValuationReportAccount;
+}
+export declare function isValuationHolding(x: ValuationReportHolding | ValuationReportChildHolding): x is ValuationReportHolding;
+export declare function isValuationChildHolding(x: ValuationReportHolding | ValuationReportChildHolding): x is ValuationReportChildHolding;
+/**
+ * Valuation accrual.
+ */
+export interface ValuationReportAccrual {
+    name: string;
+    value: Decimal;
+    accounts: ValuationReportAccrualByAccount[];
+}
+/**
+ * Valuation accrual by account.
+ */
+export interface ValuationReportAccrualByAccount {
+    account: ValuationReportAccount;
+    value: Decimal;
+    accruals: ValuationReportAccrualByCurrency[];
+}
+/**
+ * Valuation accrual by account by currency.
+ */
+export interface ValuationReportAccrualByCurrency {
+    artifact: ValuationReportArtifact;
+    ccy: CurrencyCode;
+    value: ValuationReportFigureOrgRef;
+}
+/**
+ * Type definition of the FINREA artifact type.
+ */
+export interface ValuationReportArtifactType {
+    id: ArtifactTypeId;
+    name: string;
+    order: number;
+}
+/**
+ * Type definition for the artifact as reported in the valuation.
+ */
+export interface ValuationReportArtifact {
+    id: ArtifactId;
+    guid: string;
+    type: ValuationReportArtifactType;
+    stype: Maybe<string>;
+    symbol: string;
+    name: Maybe<string>;
+    ccy: Maybe<CurrencyCode>;
+    quantity: Decimal;
+    country: Maybe<string>;
+    issuer: Maybe<string>;
+    sector: Maybe<string>;
+    mic: Maybe<string>;
+    ticker: Maybe<string>;
+    isin: Maybe<string>;
+    figi: Maybe<string>;
+    expiry: Maybe<SDate>;
+    underlyingId: Maybe<ArtifactId>;
+}
+export interface ValuationReportFxRate {
+    ccy1: CurrencyCode;
+    ccy2: CurrencyCode;
+    value: Decimal;
+    asof: SDate;
+}

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValuationChildHolding = exports.isValuationHolding = void 0;
+function isValuationHolding(x) {
+    return 'accounts' in x;
+}
+exports.isValuationHolding = isValuationHolding;
+function isValuationChildHolding(x) {
+    return 'account' in x;
+}
+exports.isValuationChildHolding = isValuationChildHolding;

package/reports/valuation/index.d.ts

@@ -0,0 +1,8 @@
+export { fetchConsolidatedValuationReport } from './-remote-valuation-report-consolidated';
+export type { ConsolidatedValuationReportQuery } from './-remote-valuation-report-consolidated';
+export { fetchPortfolioValuationReport } from './-remote-valuation-report-portfolio';
+export type { PortfolioValuationReportQuery } from './-remote-valuation-report-portfolio';
+export * from './-valuation-report-consolidated';
+export * from './-valuation-report-holdings-tree';
+export * from './-valuation-report-portfolio';
+export * from './-valuation-report-shared';

package/reports/valuation/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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;
+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; } });
+__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);

package/shell.nix

@@ -0,0 +1,21 @@
+with import (fetchTarball https://github.com/NixOS/nixpkgs/archive/22.05.tar.gz) { };
+
+stdenv.mkDerivation {
+  name = "decaf-client-javascript-extras";
+
+  buildInputs = with pkgs; [
+    git
+    nodejs-16_x
+    yarn
+
+    figlet
+    lolcat
+  ];
+
+  shellHook = ''
+    ## Greet:
+    figlet -w 999 -f standard "DECAF CLIENT EXTRAS DEV SHELL" | lolcat -S 179
+  '';
+
+  DECAF_JS_SKIP_POSTINSTALL = "TRUE";
+}

package/src/commons/-currency.ts

@@ -0,0 +1,55 @@
+/**
+ * This module provides currency related definitions.
+ *
+ * @module
+ */
+
+import { Just, Maybe, mkPhantom, NewTypeWithPhantom, Nothing, unPhantom } from '@telostat/prelude';
+
+/**
+ * Type encoding for currency code values.
+ *
+ * A currency code is (typically) defined as all-uppercase, three letters.
+ */
+export type CurrencyCode = NewTypeWithPhantom<'CurrencyCode', string>;
+
+/**
+ * Attempts to create a [[CurrencyCode]] value with the given currency code.
+ *
+ * This function returns a `Maybe` value. For the version that throws an
+ * error, see [[mkCurrencyCodeError]].
+ *
+ * @param x A currency code represented as string.
+ * @returns If the argument has leading or trailing spaces OR it is empty,
+ * `Nothing` is retured, `Just` [[CurrencyCode]] otherwise.
+ */
+export function mkCurrencyCode(x: string): Maybe<CurrencyCode> {
+  return x !== x.trim() || x === '' ? Nothing : Just(mkPhantom(x));
+}
+
+/**
+ * (Unsafely) attempts to create a [[CurrencyCode]] value with the given
+ * currency code.
+ *
+ * This function may throw an error if the given argument is not a valid
+ * currency code. For the monadic version, see [[mkCurrencyCode]].
+ *
+ * @param x A currency code represented as string.
+ * @returns If the argument has leading or trailing spaces OR it is empty, an
+ * error is thrown, [[CurrencyCode]] is returned otherwise.
+ */
+export function mkCurrencyCodeError(x: string): CurrencyCode {
+  return mkCurrencyCode(x).orDefaultLazy(() => {
+    throw new Error(`Invalid currency code: "${x}"`);
+  });
+}
+
+/**
+ * Return the currency code as a string value.
+ *
+ * @param x [[CurrencyCode]] to be extracted string from.
+ * @returns Currency code as a string.
+ */
+export function unCurrencyCode(x: CurrencyCode): string {
+  return unPhantom(x);
+}

package/src/commons/-date-type.ts

@@ -0,0 +1,12 @@
+/**
+ * DECAF FINREA action date type type definition.
+ */
+export type DateType = 'commitment' | 'settlement';
+
+/**
+ * Translation table for DECAF FINREA action date types.
+ */
+export const dateTypes: { label: string; value: DateType }[] = [
+  { label: 'Trade Date', value: 'commitment' },
+  { label: 'Value Date', value: 'settlement' },
+];

package/src/commons/-id.ts

@@ -0,0 +1,72 @@
+import { NewTypeWithPhantom } from '@telostat/prelude';
+
+/**
+ * Type definition for identifiers with value spaces discriminated over the
+ * given phantom type.
+ */
+export type Id<P, V> = NewTypeWithPhantom<P, V>;
+
+/**
+ * Type definition for DECAF artifact identifiers.
+ */
+export type ArtifactId = NewTypeWithPhantom<'DecafArtifact', string | number>;
+
+/**
+ * Type definition for DECAF artifact type identifiers.
+ */
+export type ArtifactTypeId = NewTypeWithPhantom<'DecafArtifactType', string>;
+
+/**
+ * Type definition for DECAF share class identifiers.
+ */
+export type ShareClassId = NewTypeWithPhantom<'DecafShareClass', string | number>;
+
+/**
+ * Type definition for DECAF principal identifiers.
+ */
+export type PrincipalId = NewTypeWithPhantom<'DecafPrincipal', string | number>;
+
+/**
+ * Type definition for DECAF institution identifiers.
+ */
+export type InstitutionId = NewTypeWithPhantom<'DecafInstitution', string | number>;
+
+/**
+ * Type definition for DECAF team identifiers.
+ */
+export type TeamId = NewTypeWithPhantom<'DecafTeam', string | number>;
+
+/**
+ * Type definition for DECAF portfolio identifiers.
+ */
+export type PortfolioId = NewTypeWithPhantom<'DecafPortfolio', string | number>;
+
+/**
+ * Type definition for DECAF portfolio group identifiers.
+ */
+export type PortfolioGroupId = NewTypeWithPhantom<'DecafPortfolioGroup', string | number>;
+
+/**
+ * Type definition for DECAF account identifiers.
+ */
+export type AccountId = NewTypeWithPhantom<'DecafAccount', string | number>;
+
+/**
+ * Type definition for DECAF OHLC series identifiers.
+ */
+export type OhlcSeriesId = NewTypeWithPhantom<'DecafOhlcSeries', string | number>;
+
+/**
+ * Type definition for DECAF share class fee schedule identifiers.
+ */
+export type ShareClassFeeScheduleId = NewTypeWithPhantom<'DecafShareClassFeeSchedule', string | number>;
+
+/**
+ * Type definition for DECAF action identifiers.
+ */
+export type ActionId = NewTypeWithPhantom<'DecafAction', string | number>;
+
+/**
+ * Type definition for DECAF external valuation identifiers.
+ */
+export type ExternalValuationId = NewTypeWithPhantom<'DecafExternalValuation', string | number>;

package/src/commons/index.ts

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

package/src/index.test.ts

@@ -0,0 +1,67 @@
+import { buildDecafClient, DecafClient, gql } from '@decafhub/decaf-client';
+import { mk, PDateTime } from '@telostat/prelude';
+import { fail } from 'assert';
+import { PortfolioId } from './commons';
+import { fetchRemotePortfolioValuationReport } from './reports/valuation/-remote-valuation-report-portfolio';
+
+const API_URL = process.env.TESTING_API_URL;
+const API_KEY = process.env.TESTING_API_KEY;
+const API_SECRET = process.env.TESTING_API_SECRET;
+
+const FIRST_PORTFOLIO_QUERY = gql`
+  query GetFirstPortfolio {
+    portfolio(limit: 1) {
+      id
+      name
+    }
+  }
+`;
+
+describe('Main', () => {
+  let client: DecafClient;
+  let portfolioId: PortfolioId;
+
+  beforeAll(() => {
+    jest.resetModules();
+    if (!API_URL || !API_KEY || !API_SECRET) {
+      throw new Error('Environment variables TESTING_API_URL, TESTING_API_KEY, TESTING_API_SECRET must be set');
+    }
+    client = buildDecafClient(API_URL, {
+      key: API_KEY,
+      secret: API_SECRET,
+    });
+  });
+
+  test('build a valid and authenticated decaf client', async () => {
+    const { status } = await client.barista.head('/me/');
+    expect(status).toBe(200);
+  });
+
+  test('take the first portfolio', async () => {
+    try {
+      const { data } = await client.microlot.query({ query: FIRST_PORTFOLIO_QUERY });
+      portfolioId = data?.portfolio?.[0].id;
+      expect(portfolioId).toBeDefined();
+    } catch (e) {
+      fail('Error while fetching the first portfolio');
+    }
+  });
+
+  test('get a remote portfolio report successfuly', async () => {
+    const eValue = await fetchRemotePortfolioValuationReport(client, {
+      portfolio: portfolioId,
+      date: PDateTime(new Date()).format('YYYY-MM-DD'),
+      dateType: 'settlement',
+      currency: mk('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.reported}`
+        );
+        expect(value).toBeDefined();
+      },
+    });
+  });
+});

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './commons';
+export * as commons from './commons';
+export * as reports from './reports';

package/src/reports/index.ts

@@ -0,0 +1 @@
+export * as valuation from './valuation';