@vuu-ui/vuu-data-test 4.1.0 → 5.0.0-alpha.1

package/README.md

@@ -0,0 +1,46 @@
+# `@vuu-ui/vuu-data-test`
+
+## Local basket trading
+
+Constituent reference data is generated from the server's four CSV files in
+`example/main/src/main/resources/static/`. From `vuu-ui`, run
+`npm run generate:basket-data` after editing those files and commit the resulting
+`src/basket/reference-data/constituent-data.json`. Use
+`npm run generate:basket-data -- --check` to verify it is up to date.
+The converter preserves source weights (without normalizing their units),
+maps the differing price/change column names, and rejects invalid CSV records.
+The browser loads only the generated JSON, not the CSV parser.
+The JSON and its `constituents.ts` adapter use different basenames so their
+JavaScript build outputs cannot collide.
+
+The `BASKET` module provides its own simulated constituent prices, including
+updates for all basket instruments. Its constituent join retains
+`instanceIdRic` as the row key, so multiple trading baskets can contain the
+same instrument. Direct edits through the join update the underlying
+constituent table; subsequent price ticks preserve those edits.
+Changing the basket side flips each constituent's current side, preserving
+mixed BUY/SELL positions, as on the Scala server. Unchanged side edits do
+nothing, and other basket instances are unaffected.
+Editing basket units recalculates its constituent quantities as
+`weighting * units`, truncated to whole units, matching the Scala service.
+
+New baskets retain the `basketTradeName` supplied by the creation dialog.
+Constituents default to the Limit price strategy (`priceStrategyId = 2`),
+matching the Scala server.
+Dropping an instrument from the Add constituent context panel adds it to the
+requested basket instance. Manually added constituents start with weight `0.1`,
+BUY side and Limit strategy; quantity is calculated from the current basket
+units. Unknown instruments, duplicates, missing baskets and on-market baskets
+are rejected without changing existing rows.
+The Add constituent list excludes RICs already in the active basket using a
+separate full-membership subscription, including rows outside the visible grid.
+Sending a basket to market and taking it off market update its constituent
+statuses; live rows include `orderStatus` and an initially zero `filledQty`.
+Execution fills are not simulated.
+
+## Admin test module dependencies
+
+The `USER_ADMIN` and `MODULE_DISCOVERY` test modules use the published
+`@heswell/user-admin` and `@heswell/module-admin` packages. Standard
+`npm install` setup is sufficient. Browser code imports only the browser-safe
+`contracts` subpath for module-admin.

package/package.json

@@ -1,21 +1,24 @@
 {
-  "version": "4.1.0",
+  "version": "5.0.0-alpha.1",
   "main": "./src/index.js",
+  "type": "module",
   "author": "heswell",
   "license": "Apache-2.0",
   "scripts": {
-    "build:dev": "node ../../scripts/run-build.mjs",
     "build": "node ../../scripts/run-build-rslib.ts",
     "type-defs": "node ../../scripts/build-type-defs.mjs"
   },
   "dependencies": {
-    "@vuu-ui/vuu-data-local": "4.1.0",
-    "@vuu-ui/vuu-utils": "4.1.0"
+    "@vuu-ui/vuu-data-local": "5.0.0-alpha.1",
+    "@vuu-ui/vuu-utils": "5.0.0-alpha.1",
+    "@heswell/module-admin": "1.1.0",
+    "@heswell/user-admin": "1.0.1",
+    "@vuu-ui/vuu-data-editing": "5.0.0-alpha.1"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-protocol-types": "4.1.0",
-    "@vuu-ui/vuu-data-types": "4.1.0",
-    "@vuu-ui/vuu-table-types": "4.1.0"
+    "@vuu-ui/vuu-protocol-types": "5.0.0-alpha.1",
+    "@vuu-ui/vuu-data-types": "5.0.0-alpha.1",
+    "@vuu-ui/vuu-table-types": "5.0.0-alpha.1"
   },
   "sideEffects": false,
   "files": [
@@ -25,13 +28,12 @@
   ],
   "exports": {
     ".": {
+      "types": "./types/index.d.ts",
       "import": "./src/index.js",
-      "default": "./src/index.js",
-      "types": "./types/index.d.ts"
+      "default": "./src/index.js"
     }
   },
   "module": "./src/index.js",
   "name": "@vuu-ui/vuu-data-test",
-  "type": "module",
   "types": "types/index.d.ts"
 }

package/src/Table.js

@@ -20,7 +20,7 @@ class Table extends EventEmitter {
     }
     buildIndex() {
         for(let i = 0; i < this.#data.length; i++){
-            const key = this.#data[i][this.#indexOfKey];
+            const key = String(this.#data[i][this.#indexOfKey]);
             this.#index.set(key, i);
         }
     }
@@ -41,14 +41,17 @@ class Table extends EventEmitter {
         if (-1 !== index) {
             this.#index.delete(key);
             this.#data.splice(index, 1);
-            for(let i = index; i < this.#data.length; i++)this.#index.set(this.#data[i][this.#indexOfKey], i);
+            for(let i = index; i < this.#data.length; i++)this.#index.set(String(this.#data[i][this.#indexOfKey]), i);
             if (emitEvent) this.emit("delete", key);
         } else throw Error(`[Table] delete key ${key} not found`);
     }
     insert(row, emitEvent = true) {
         const index = this.#data.length;
+        const createdTime = Date.now();
+        row[this.#dataMap.vuuUpdatedTimestamp] = createdTime;
+        row[this.#dataMap.vuuCreatedTimestamp] = createdTime;
         this.#data.push(row);
-        const key = row[this.#indexOfKey];
+        const key = String(row[this.#indexOfKey]);
         this.#index.set(key, index);
         if (emitEvent) this.emit("insert", row);
     }
@@ -57,7 +60,7 @@ class Table extends EventEmitter {
         return this.#data[index];
     }
     update(key, columnName, value) {
-        const rowIndex = this.#data.findIndex((row)=>row[this.#indexOfKey] === key);
+        const rowIndex = this.#data.findIndex((row)=>String(row[this.#indexOfKey]) === key);
         const colIndex = this.#dataMap[columnName];
         if (-1 !== rowIndex) {
             const row = this.#data[rowIndex];
@@ -74,7 +77,7 @@ class Table extends EventEmitter {
     }
     updateRow(row) {
         const key = row[this.#indexOfKey];
-        const rowIndex = this.#data.findIndex((row)=>row[this.#indexOfKey] === key);
+        const rowIndex = this.#data.findIndex((row)=>String(row[this.#indexOfKey]) === String(key));
         if (-1 !== rowIndex) {
             const tsIndex = this.#dataMap.vuuUpdatedTimestamp;
             const lastUpdated = Date.now();

package/src/basket/BasketModule.js

@@ -2,6 +2,7 @@ import { VuuModule } from "../core/module/VuuModule.js";
 import TableContainer from "../core/table/TableContainer.js";
 import { schemas } from "./basket-schemas.js";
 import reference_data_constituents from "./reference-data/constituents.js";
+import prices from "./reference-data/prices.js";
 const { createTable: createTable } = TableContainer;
 let basketIncrement = 1;
 const createBasketTradingRow = (basketId, basketName, side = "BUY", status = "OFF MARKET")=>[
@@ -98,10 +99,7 @@ class BasketModule extends VuuModule {
         }, {
             module: "BASKET",
             table: "basketTradingConstituent"
-        }, {
-            module: "SIMUL",
-            table: "prices"
-        }, "ric"),
+        }, prices, "ric"),
         priceStrategyType: createTable(schemas.priceStrategyType, [
             [
                 "Peg to Near Touch",
@@ -123,6 +121,22 @@ class BasketModule extends VuuModule {
     };
     constructor(){
         super("BASKET");
+        const table = this.tables.basketTrading;
+        const update = table.update.bind(table);
+        table.update = (key, column, value)=>{
+            if ("side" !== column && "units" !== column) return update(key, column, value);
+            const basket = table.findByKey(key);
+            if (!basket) throw Error(`[BasketModule] basket ${key} not found`);
+            if (basket[table.map[column]] === value) return;
+            if ("units" === column && ("number" != typeof value || !Number.isInteger(value))) throw Error("[BasketModule] units must be an integer");
+            update(key, column, value);
+            const constituents = this.tables.basketTradingConstituent;
+            for (const row of constituents.data)if (row[constituents.map.instanceId] === key) {
+                const constituentKey = String(row[constituents.map.instanceIdRic]);
+                if ("side" === column) constituents.update(constituentKey, "side", "BUY" === row[constituents.map.side] ? "SELL" : "BUY");
+                else if ("number" == typeof value) constituents.update(constituentKey, "quantity", Math.trunc(Number(row[constituents.map.weighting]) * value));
+            }
+        };
     }
     get menus() {
         return {
@@ -196,45 +210,55 @@ class BasketModule extends VuuModule {
         const { basketId: key } = buildDataColumnMap("basketConstituent");
         const constituents = this.tables.basketConstituent.data.filter((c)=>c[key] === basketId);
         const { instanceId } = tableMaps.basketTrading;
-        constituents.forEach(([, , description, , ric, , , quantity, weighting])=>{
-            const algo = "";
-            const algoParams = "";
-            const limitPrice = 95;
-            const notionalLocal = 0;
-            const notionalUsd = 0;
-            const pctFilled = 0;
-            const priceSpread = 0;
-            const priceStrategyId = "";
-            const side = "BUY";
-            const venue = "venue";
-            const basketInstanceId = basketTradingRow[instanceId];
-            const basketTradingConstituentRow = [
-                algo,
-                algoParams,
-                basketId,
-                description,
-                basketInstanceId,
-                `${basketInstanceId}-${ric}`,
-                limitPrice,
-                notionalLocal,
-                notionalUsd,
-                pctFilled,
-                priceSpread,
-                priceStrategyId,
-                quantity,
-                ric,
-                side,
-                venue,
-                weighting
-            ];
-            basketTradingConstituent.insert(basketTradingConstituentRow);
+        constituents.forEach(([, , description, , ric, , , , weighting])=>{
+            this.insertTradingConstituent(basketTradingRow, String(ric), String(description), Number(weighting));
         });
         return basketTradingRow[instanceId];
     }
+    insertTradingConstituent(basketTradingRow, ric, description, weighting) {
+        const { basketId, instanceId } = tableMaps.basketTrading;
+        const quantity = Math.trunc(Number(weighting) * Number(basketTradingRow[tableMaps.basketTrading.units]));
+        const algo = "";
+        const algoParams = "";
+        const limitPrice = 95;
+        const notionalLocal = 0;
+        const notionalUsd = 0;
+        const pctFilled = 0;
+        const priceSpread = 0;
+        const priceStrategyId = 2;
+        const side = "BUY";
+        const status = "OFF-MARKET";
+        const venue = "venue";
+        const basketInstanceId = basketTradingRow[instanceId];
+        const basketTradingConstituentRow = [
+            algo,
+            algoParams,
+            basketTradingRow[basketId],
+            description,
+            basketInstanceId,
+            `${basketInstanceId}-${ric}`,
+            limitPrice,
+            notionalLocal,
+            notionalUsd,
+            pctFilled,
+            priceSpread,
+            priceStrategyId,
+            quantity,
+            ric,
+            side,
+            status,
+            venue,
+            weighting,
+            "PENDING",
+            0
+        ];
+        basketTradingConstituent.insert(basketTradingConstituentRow);
+        return `${basketInstanceId}-${ric}`;
+    }
     createNewBasket = async (rpcRequest)=>{
         if ("VIEWPORT_CONTEXT" === rpcRequest.context.type) {
-            const { sourceBasketId, tradeBasketName } = rpcRequest.params;
-            const key = this.createTradingBasket(sourceBasketId, tradeBasketName);
+            const { sourceBasketId, basketTradeName } = rpcRequest.params;
+            const key = this.createTradingBasket(sourceBasketId, basketTradeName);
             return {
                 type: "SUCCESS_RESULT",
                 data: key
@@ -246,6 +270,7 @@ class BasketModule extends VuuModule {
         if ("VIEWPORT_CONTEXT" === rpcRequest.context.type) {
             const { basketInstanceId } = rpcRequest.params;
             this.tables.basketTrading.update(basketInstanceId, "status", "ON_MARKET");
+            this.updateConstituentStatus(basketInstanceId, "ON_MARKET", "ACKED");
             return {
                 type: "SUCCESS_RESULT",
                 data: void 0
@@ -257,6 +282,7 @@ class BasketModule extends VuuModule {
         if ("VIEWPORT_CONTEXT" === rpcRequest.context.type) {
             const { basketInstanceId } = rpcRequest.params;
             this.tables.basketTrading.update(basketInstanceId, "status", "OFF-MARKET");
+            this.updateConstituentStatus(basketInstanceId, "OFF-MARKET", "CANCELLED");
             return {
                 type: "SUCCESS_RESULT",
                 data: void 0
@@ -264,9 +290,48 @@ class BasketModule extends VuuModule {
         }
         throw Error("[BasketModule] createNewBasket invalid request type");
     };
-    addConstituent = async ()=>{
-        throw Error("addConstituent not implemented");
+    addConstituent = async (request)=>{
+        const { params } = request;
+        const ric = "ric" in params ? params.ric : void 0;
+        const basketInstanceId = "basketInstanceId" in params ? params.basketInstanceId : void 0;
+        if ("VIEWPORT_CONTEXT" !== request.context.type || "string" != typeof ric || "string" != typeof basketInstanceId) return {
+            type: "ERROR_RESULT",
+            errorMessage: "Invalid add constituent request"
+        };
+        const basket = this.tables.basketTrading.findByKey(basketInstanceId);
+        if (!basket) return {
+            type: "ERROR_RESULT",
+            errorMessage: "Basket not found"
+        };
+        if ("ON_MARKET" === basket[tableMaps.basketTrading.status]) return {
+            type: "ERROR_RESULT",
+            errorMessage: "Take the basket off market before adding constituents"
+        };
+        const source = this.tables.basketConstituent;
+        const reference = source.data.find((row)=>row[source.map.ric] === ric);
+        if (!reference) return {
+            type: "ERROR_RESULT",
+            errorMessage: `Unknown constituent ${ric}`
+        };
+        const key = `${basketInstanceId}-${ric}`;
+        if (this.tables.basketTradingConstituent.findByKey(key)) return {
+            type: "ERROR_RESULT",
+            errorMessage: `${ric} is already in this basket`
+        };
+        this.insertTradingConstituent(basket, ric, String(reference[source.map.description]), 0.1);
+        return {
+            type: "SUCCESS_RESULT",
+            data: key
+        };
     };
+    updateConstituentStatus(basketInstanceId, status, orderStatus) {
+        const table = this.tables.basketTradingConstituent;
+        for (const row of table.data)if (row[table.map.instanceId] === basketInstanceId) {
+            const key = String(row[table.map.instanceIdRic]);
+            table.update(key, "status", status);
+            table.update(key, "orderStatus", orderStatus);
+        }
+    }
 }
 const basketModule = new BasketModule();
 export { BasketModule, basketModule, createBasketTradingRow };

package/src/basket/basket-schemas.js

@@ -216,6 +216,14 @@ const schemas = {
             {
                 name: "weighting",
                 serverDataType: "double"
+            },
+            {
+                name: "orderStatus",
+                serverDataType: "string"
+            },
+            {
+                name: "filledQty",
+                serverDataType: "long"
             }
         ],
         key: "instanceIdRic",
@@ -334,6 +342,14 @@ const schemas = {
             {
                 name: "weighting",
                 serverDataType: "double"
+            },
+            {
+                name: "orderStatus",
+                serverDataType: "string"
+            },
+            {
+                name: "filledQty",
+                serverDataType: "long"
             }
         ],
         key: "instanceIdRic",