@fintekkers/ledger-models 0.4.26 → 0.4.28

package/node/wrappers/models/position/position_matcher.d.ts

@@ -0,0 +1,27 @@
+import { FieldProto } from '../../../fintekkers/models/position/field_pb';
+import { PositionFilterOperator } from '../../../fintekkers/models/position/position_util_pb';
+/** A single filter clause: the field, operator and filter value. */
+export interface FilterSpec {
+    field: FieldProto;
+    operator: PositionFilterOperator;
+    value: any;
+}
+/** A row the matcher can read: the Security and Position wrappers qualify. */
+export interface FilterableRow {
+    getField(field: FieldProto): any;
+}
+/**
+ * Single-field evaluator (LM-281), mirroring Java's PositionFilter.matches:
+ * ASSET_CLASS with EQUALS / NOT_EQUALS uses the shared assetClassMatches
+ * rule, so a group code such as FIXED_INCOME matches its members and labels;
+ * every other field compares exactly. A null or undefined stored value never
+ * throws: EQUALS and the ordering operators drop the row, NOT_EQUALS keeps
+ * it. An unknown operator matches nothing. Errors raised by row.getField
+ * propagate (a row represents an absent value by returning null).
+ */
+export declare function matches(field: FieldProto, operator: PositionFilterOperator, filterValue: any, storedValue: any): boolean;
+/**
+ * Keep the rows matching every clause in `filters` (AND semantics, input
+ * order preserved).
+ */
+export declare function filterRows<T extends FilterableRow>(rows: T[], filters: FilterSpec[]): T[];

package/node/wrappers/models/position/position_matcher.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterRows = exports.matches = void 0;
+const field_pb_1 = require("../../../fintekkers/models/position/field_pb");
+const position_util_pb_1 = require("../../../fintekkers/models/position/position_util_pb");
+const product_hierarchy_1 = require("../security/product_hierarchy");
+/**
+ * Single-field evaluator (LM-281), mirroring Java's PositionFilter.matches:
+ * ASSET_CLASS with EQUALS / NOT_EQUALS uses the shared assetClassMatches
+ * rule, so a group code such as FIXED_INCOME matches its members and labels;
+ * every other field compares exactly. A null or undefined stored value never
+ * throws: EQUALS and the ordering operators drop the row, NOT_EQUALS keeps
+ * it. An unknown operator matches nothing. Errors raised by row.getField
+ * propagate (a row represents an absent value by returning null).
+ */
+function matches(field, operator, filterValue, storedValue) {
+    if (storedValue === null || storedValue === undefined) {
+        return operator === position_util_pb_1.PositionFilterOperator.NOT_EQUALS;
+    }
+    if (field === field_pb_1.FieldProto.ASSET_CLASS &&
+        (operator === position_util_pb_1.PositionFilterOperator.EQUALS ||
+            operator === position_util_pb_1.PositionFilterOperator.NOT_EQUALS)) {
+        const equals = (0, product_hierarchy_1.assetClassMatches)(filterValue, storedValue);
+        return operator === position_util_pb_1.PositionFilterOperator.EQUALS ? equals : !equals;
+    }
+    switch (operator) {
+        case position_util_pb_1.PositionFilterOperator.EQUALS:
+            return storedValue === filterValue;
+        case position_util_pb_1.PositionFilterOperator.NOT_EQUALS:
+            return storedValue !== filterValue;
+        case position_util_pb_1.PositionFilterOperator.LESS_THAN:
+            return storedValue < filterValue;
+        case position_util_pb_1.PositionFilterOperator.LESS_THAN_OR_EQUALS:
+            return storedValue <= filterValue;
+        case position_util_pb_1.PositionFilterOperator.MORE_THAN:
+            return storedValue > filterValue;
+        case position_util_pb_1.PositionFilterOperator.MORE_THAN_OR_EQUALS:
+            return storedValue >= filterValue;
+        default:
+            return false;
+    }
+}
+exports.matches = matches;
+/**
+ * Keep the rows matching every clause in `filters` (AND semantics, input
+ * order preserved).
+ */
+function filterRows(rows, filters) {
+    return rows.filter((row) => {
+        return filters.every((spec) => matches(spec.field, spec.operator, spec.value, row.getField(spec.field)));
+    });
+}
+exports.filterRows = filterRows;

package/node/wrappers/models/position/position_matcher.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node/wrappers/models/position/position_matcher.test.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * LM-281: the JS filter helper matches Java's PositionFilter row for row.
+ *
+ * ASSET_CLASS EQUALS / NOT_EQUALS use the shared assetClassMatches rule;
+ * every other field compares exactly. A null stored value never throws.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const field_pb_1 = require("../../../fintekkers/models/position/field_pb");
+const position_util_pb_1 = require("../../../fintekkers/models/position/position_util_pb");
+const security_pb_1 = require("../../../fintekkers/models/security/security_pb");
+const security_1 = __importDefault(require("../security/security"));
+const position_matcher_1 = require("./position_matcher");
+function securityRow(assetClass) {
+    const proto = new security_pb_1.SecurityProto();
+    proto.setAssetClass(assetClass);
+    return new security_1.default(proto);
+}
+function stubRow(assetClass) {
+    return {
+        getField: (_field) => assetClass,
+    };
+}
+function assetClasses(rows) {
+    return rows.map((row) => row.getField(field_pb_1.FieldProto.ASSET_CLASS));
+}
+function assetClassFilter(operator) {
+    return [{ field: field_pb_1.FieldProto.ASSET_CLASS, operator, value: 'FIXED_INCOME' }];
+}
+describe('position_matcher', () => {
+    test('ASSET_CLASS EQUALS FIXED_INCOME matches group members', () => {
+        const rows = ['RATES', 'CREDIT', 'Fixed Income', 'EQUITY'].map(securityRow);
+        const result = (0, position_matcher_1.filterRows)(rows, assetClassFilter(position_util_pb_1.PositionFilterOperator.EQUALS));
+        expect(assetClasses(result)).toEqual(['RATES', 'CREDIT', 'Fixed Income']);
+    });
+    test('ASSET_CLASS NOT_EQUALS FIXED_INCOME keeps only non-members', () => {
+        const rows = ['RATES', 'CREDIT', 'Fixed Income', 'EQUITY'].map(securityRow);
+        const result = (0, position_matcher_1.filterRows)(rows, assetClassFilter(position_util_pb_1.PositionFilterOperator.NOT_EQUALS));
+        expect(assetClasses(result)).toEqual(['EQUITY']);
+    });
+    test('null, empty and unknown stored values never throw', () => {
+        const rows = [stubRow(null), securityRow(''), securityRow('NOT_A_CLASS')];
+        const equals = assetClassFilter(position_util_pb_1.PositionFilterOperator.EQUALS);
+        const notEquals = assetClassFilter(position_util_pb_1.PositionFilterOperator.NOT_EQUALS);
+        expect(() => (0, position_matcher_1.filterRows)(rows, equals)).not.toThrow();
+        expect((0, position_matcher_1.filterRows)(rows, equals)).toEqual([]);
+        expect(() => (0, position_matcher_1.filterRows)(rows, notEquals)).not.toThrow();
+        expect(assetClasses((0, position_matcher_1.filterRows)(rows, notEquals))).toEqual([null, '', 'NOT_A_CLASS']);
+    });
+    test('other fields compare exactly', () => {
+        expect((0, position_matcher_1.matches)(field_pb_1.FieldProto.PORTFOLIO_NAME, position_util_pb_1.PositionFilterOperator.EQUALS, 'a', 'a')).toBe(true);
+        expect((0, position_matcher_1.matches)(field_pb_1.FieldProto.PORTFOLIO_NAME, position_util_pb_1.PositionFilterOperator.EQUALS, 'a', 'b')).toBe(false);
+        expect((0, position_matcher_1.matches)(field_pb_1.FieldProto.PORTFOLIO_NAME, position_util_pb_1.PositionFilterOperator.NOT_EQUALS, 'a', 'b')).toBe(true);
+        expect((0, position_matcher_1.matches)(field_pb_1.FieldProto.PORTFOLIO_NAME, position_util_pb_1.PositionFilterOperator.NOT_EQUALS, 'a', 'a')).toBe(false);
+        expect((0, position_matcher_1.matches)(field_pb_1.FieldProto.MATURITY_DATE, position_util_pb_1.PositionFilterOperator.MORE_THAN, 1, 2)).toBe(true);
+        expect((0, position_matcher_1.matches)(field_pb_1.FieldProto.MATURITY_DATE, position_util_pb_1.PositionFilterOperator.MORE_THAN, 2, 1)).toBe(false);
+        expect((0, position_matcher_1.matches)(field_pb_1.FieldProto.PORTFOLIO_NAME, position_util_pb_1.PositionFilterOperator.EQUALS, 'a', null)).toBe(false);
+        expect((0, position_matcher_1.matches)(field_pb_1.FieldProto.PORTFOLIO_NAME, position_util_pb_1.PositionFilterOperator.NOT_EQUALS, 'a', null)).toBe(true);
+    });
+});
+describe('the published (compiled) position_matcher.js', () => {
+    // npm publish runs no tsc: the tracked .js is what consumers get.
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const compiled = require('./position_matcher.js');
+    test('exports working matches and filterRows', () => {
+        expect(typeof compiled.matches).toBe('function');
+        expect(typeof compiled.filterRows).toBe('function');
+        expect(compiled.matches(field_pb_1.FieldProto.ASSET_CLASS, position_util_pb_1.PositionFilterOperator.EQUALS, 'FIXED_INCOME', 'RATES')).toBe(true);
+        expect(compiled.matches(field_pb_1.FieldProto.ASSET_CLASS, position_util_pb_1.PositionFilterOperator.NOT_EQUALS, 'FIXED_INCOME', 'EQUITY')).toBe(true);
+        const rows = ['RATES', 'EQUITY'].map(securityRow);
+        const kept = compiled.filterRows(rows, assetClassFilter(position_util_pb_1.PositionFilterOperator.EQUALS));
+        expect(assetClasses(kept)).toEqual(['RATES']);
+    });
+});

package/node/wrappers/models/position/position_matcher.test.ts

@@ -0,0 +1,96 @@
+/**
+ * LM-281: the JS filter helper matches Java's PositionFilter row for row.
+ *
+ * ASSET_CLASS EQUALS / NOT_EQUALS use the shared assetClassMatches rule;
+ * every other field compares exactly. A null stored value never throws.
+ */
+import { FieldProto } from '../../../fintekkers/models/position/field_pb';
+import { PositionFilterOperator } from '../../../fintekkers/models/position/position_util_pb';
+import { SecurityProto } from '../../../fintekkers/models/security/security_pb';
+import Security from '../security/security';
+import { FilterableRow, FilterSpec, filterRows, matches } from './position_matcher';
+
+function securityRow(assetClass: string): Security {
+  const proto = new SecurityProto();
+  proto.setAssetClass(assetClass);
+  return new Security(proto);
+}
+
+function stubRow(assetClass: string | null): FilterableRow {
+  return {
+    getField: (_field: FieldProto) => assetClass,
+  };
+}
+
+function assetClasses(rows: FilterableRow[]): Array<string | null> {
+  return rows.map((row) => row.getField(FieldProto.ASSET_CLASS));
+}
+
+function assetClassFilter(operator: PositionFilterOperator): FilterSpec[] {
+  return [{ field: FieldProto.ASSET_CLASS, operator, value: 'FIXED_INCOME' }];
+}
+
+describe('position_matcher', () => {
+  test('ASSET_CLASS EQUALS FIXED_INCOME matches group members', () => {
+    const rows = ['RATES', 'CREDIT', 'Fixed Income', 'EQUITY'].map(securityRow);
+    const result = filterRows(rows, assetClassFilter(PositionFilterOperator.EQUALS));
+    expect(assetClasses(result)).toEqual(['RATES', 'CREDIT', 'Fixed Income']);
+  });
+
+  test('ASSET_CLASS NOT_EQUALS FIXED_INCOME keeps only non-members', () => {
+    const rows = ['RATES', 'CREDIT', 'Fixed Income', 'EQUITY'].map(securityRow);
+    const result = filterRows(rows, assetClassFilter(PositionFilterOperator.NOT_EQUALS));
+    expect(assetClasses(result)).toEqual(['EQUITY']);
+  });
+
+  test('null, empty and unknown stored values never throw', () => {
+    const rows = [stubRow(null), securityRow(''), securityRow('NOT_A_CLASS')];
+    const equals = assetClassFilter(PositionFilterOperator.EQUALS);
+    const notEquals = assetClassFilter(PositionFilterOperator.NOT_EQUALS);
+    expect(() => filterRows(rows, equals)).not.toThrow();
+    expect(filterRows(rows, equals)).toEqual([]);
+    expect(() => filterRows(rows, notEquals)).not.toThrow();
+    expect(assetClasses(filterRows(rows, notEquals))).toEqual([null, '', 'NOT_A_CLASS']);
+  });
+
+  test('other fields compare exactly', () => {
+    expect(matches(FieldProto.PORTFOLIO_NAME, PositionFilterOperator.EQUALS, 'a', 'a')).toBe(true);
+    expect(matches(FieldProto.PORTFOLIO_NAME, PositionFilterOperator.EQUALS, 'a', 'b')).toBe(false);
+    expect(matches(FieldProto.PORTFOLIO_NAME, PositionFilterOperator.NOT_EQUALS, 'a', 'b')).toBe(true);
+    expect(matches(FieldProto.PORTFOLIO_NAME, PositionFilterOperator.NOT_EQUALS, 'a', 'a')).toBe(false);
+    expect(matches(FieldProto.MATURITY_DATE, PositionFilterOperator.MORE_THAN, 1, 2)).toBe(true);
+    expect(matches(FieldProto.MATURITY_DATE, PositionFilterOperator.MORE_THAN, 2, 1)).toBe(false);
+    expect(matches(FieldProto.PORTFOLIO_NAME, PositionFilterOperator.EQUALS, 'a', null)).toBe(false);
+    expect(matches(FieldProto.PORTFOLIO_NAME, PositionFilterOperator.NOT_EQUALS, 'a', null)).toBe(true);
+  });
+});
+
+describe('the published (compiled) position_matcher.js', () => {
+  // npm publish runs no tsc: the tracked .js is what consumers get.
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const compiled = require('./position_matcher.js');
+
+  test('exports working matches and filterRows', () => {
+    expect(typeof compiled.matches).toBe('function');
+    expect(typeof compiled.filterRows).toBe('function');
+    expect(
+      compiled.matches(
+        FieldProto.ASSET_CLASS,
+        PositionFilterOperator.EQUALS,
+        'FIXED_INCOME',
+        'RATES',
+      ),
+    ).toBe(true);
+    expect(
+      compiled.matches(
+        FieldProto.ASSET_CLASS,
+        PositionFilterOperator.NOT_EQUALS,
+        'FIXED_INCOME',
+        'EQUITY',
+      ),
+    ).toBe(true);
+    const rows = ['RATES', 'EQUITY'].map(securityRow);
+    const kept = compiled.filterRows(rows, assetClassFilter(PositionFilterOperator.EQUALS));
+    expect(assetClasses(kept)).toEqual(['RATES']);
+  });
+});

package/node/wrappers/models/position/position_matcher.ts

@@ -0,0 +1,71 @@
+import { FieldProto } from '../../../fintekkers/models/position/field_pb';
+import { PositionFilterOperator } from '../../../fintekkers/models/position/position_util_pb';
+import { assetClassMatches } from '../security/product_hierarchy';
+
+/** A single filter clause: the field, operator and filter value. */
+export interface FilterSpec {
+  field: FieldProto;
+  operator: PositionFilterOperator;
+  value: any;
+}
+
+/** A row the matcher can read: the Security and Position wrappers qualify. */
+export interface FilterableRow {
+  getField(field: FieldProto): any;
+}
+
+/**
+ * Single-field evaluator (LM-281), mirroring Java's PositionFilter.matches:
+ * ASSET_CLASS with EQUALS / NOT_EQUALS uses the shared assetClassMatches
+ * rule, so a group code such as FIXED_INCOME matches its members and labels;
+ * every other field compares exactly. A null or undefined stored value never
+ * throws: EQUALS and the ordering operators drop the row, NOT_EQUALS keeps
+ * it. An unknown operator matches nothing. Errors raised by row.getField
+ * propagate (a row represents an absent value by returning null).
+ */
+export function matches(
+  field: FieldProto,
+  operator: PositionFilterOperator,
+  filterValue: any,
+  storedValue: any,
+): boolean {
+  if (storedValue === null || storedValue === undefined) {
+    return operator === PositionFilterOperator.NOT_EQUALS;
+  }
+  if (
+    field === FieldProto.ASSET_CLASS &&
+    (operator === PositionFilterOperator.EQUALS ||
+      operator === PositionFilterOperator.NOT_EQUALS)
+  ) {
+    const equals = assetClassMatches(filterValue, storedValue);
+    return operator === PositionFilterOperator.EQUALS ? equals : !equals;
+  }
+  switch (operator) {
+    case PositionFilterOperator.EQUALS:
+      return storedValue === filterValue;
+    case PositionFilterOperator.NOT_EQUALS:
+      return storedValue !== filterValue;
+    case PositionFilterOperator.LESS_THAN:
+      return storedValue < filterValue;
+    case PositionFilterOperator.LESS_THAN_OR_EQUALS:
+      return storedValue <= filterValue;
+    case PositionFilterOperator.MORE_THAN:
+      return storedValue > filterValue;
+    case PositionFilterOperator.MORE_THAN_OR_EQUALS:
+      return storedValue >= filterValue;
+    default:
+      return false;
+  }
+}
+
+/**
+ * Keep the rows matching every clause in `filters` (AND semantics, input
+ * order preserved).
+ */
+export function filterRows<T extends FilterableRow>(rows: T[], filters: FilterSpec[]): T[] {
+  return rows.filter((row) => {
+    return filters.every((spec) =>
+      matches(spec.field, spec.operator, spec.value, row.getField(spec.field)),
+    );
+  });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fintekkers/ledger-models",
   "todo": "Replace the version with build script version number",
-  "version": "0.4.26",
+  "version": "0.4.28",
   "description": "ledger model protos ",
   "authors": [
     "David Doherty",