@vuu-ui/vuu-data-test 4.0.0-alpha.21 → 4.0.0-alpha.23

package/README.md

@@ -1,5 +1,41 @@
 # `@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/constituents.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 `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

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.0.0-alpha.21",
+  "version": "4.0.0-alpha.23",
   "main": "./src/index.js",
   "type": "module",
   "author": "heswell",
@@ -12,14 +12,14 @@
   "dependencies": {
     "@heswell/module-admin": "1.1.0",
     "@heswell/user-admin": "1.0.1",
-    "@vuu-ui/vuu-data-editing": "4.0.0-alpha.21",
-    "@vuu-ui/vuu-data-local": "4.0.0-alpha.21",
-    "@vuu-ui/vuu-utils": "4.0.0-alpha.21"
+    "@vuu-ui/vuu-data-editing": "4.0.0-alpha.23",
+    "@vuu-ui/vuu-data-local": "4.0.0-alpha.23",
+    "@vuu-ui/vuu-utils": "4.0.0-alpha.23"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-data-types": "4.0.0-alpha.21",
-    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.21",
-    "@vuu-ui/vuu-table-types": "4.0.0-alpha.21"
+    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.23",
+    "@vuu-ui/vuu-data-types": "4.0.0-alpha.23",
+    "@vuu-ui/vuu-table-types": "4.0.0-alpha.23"
   },
   "sideEffects": false,
   "files": [

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",

package/src/basket/reference-data/constituents.js

@@ -1,76 +1,8 @@
-import ftse100 from "./ftse100.js";
-import nasdaq100 from "./nasdaq100.js";
-import sp500 from "./sp500.js";
-import hsi from "./hsi.js";
-const basketConstituentData = [];
-for (const row of ftse100){
-    const [ric, name, lastTrade, change, volume] = row;
-    const basketId = ".FTSE100";
-    const side = "BUY";
-    const weighting = 1;
-    basketConstituentData.push([
-        basketId,
-        change,
-        name,
-        lastTrade,
-        ric,
-        `${ric}-${basketId}`,
-        side,
-        volume,
-        weighting
-    ]);
-}
-for (const row of hsi){
-    const [name, ric, lastTrade, change, , volume] = row;
-    const basketId = ".HSI";
-    const side = "BUY";
-    const weighting = 1;
-    basketConstituentData.push([
-        basketId,
-        change,
-        name,
-        lastTrade,
-        ric,
-        `${ric}-${basketId}`,
-        side,
-        volume,
-        weighting
-    ]);
-}
-for (const row of nasdaq100){
-    const [name, ric, weighting, lastTrade, change] = row;
-    const basketId = ".NASDAQ100";
-    const side = "BUY";
-    const volume = 1000;
-    basketConstituentData.push([
-        basketId,
-        change,
-        name,
-        lastTrade,
-        ric,
-        `${ric}-${basketId}`,
-        side,
-        volume,
-        weighting
-    ]);
-}
-for (const row of sp500){
-    const [name, ric, weighting, , change] = row;
-    const basketId = ".SP500";
-    const side = "BUY";
-    const volume = 1000;
-    const lastTrade = 0;
-    basketConstituentData.push([
-        basketId,
-        change,
-        name,
-        lastTrade,
-        ric,
-        `${ric}-${basketId}`,
-        side,
-        volume,
-        weighting
-    ]);
-}
-var constituents = basketConstituentData;
-export default constituents;
+import constituents from "./constituents.js";
+import { schemas } from "../basket-schemas.js";
+const basketConstituentData = constituents.map((constituent)=>{
+    const values = constituent;
+    return schemas.basketConstituent.columns.map(({ name })=>values[name]);
+});
+var reference_data_constituents = basketConstituentData;
+export default reference_data_constituents;

package/src/basket/reference-data/prices.js

@@ -1,9 +1,8 @@
-import { buildDataColumnMap } from "../../Table.js";
+import { Table, buildDataColumnMap } from "../../Table.js";
 import { BaseUpdateGenerator } from "../../UpdateGenerator.js";
 import { schemas } from "../../simul/simul-schemas.js";
 import constituents from "./constituents.js";
 import { initBidAsk, nextRandomDouble, random } from "../../data-utils.js";
-import TableContainer from "../../core/table/TableContainer.js";
 const { bid: prices_bid, bidSize: prices_bidSize, ask: prices_ask, askSize: prices_askSize, last: prices_last } = buildDataColumnMap(schemas, "prices");
 const pricesUpdateGenerator = new BaseUpdateGenerator({
     bid: prices_bid,
@@ -13,9 +12,12 @@ const pricesUpdateGenerator = new BaseUpdateGenerator({
     last: prices_last
 });
 const prices = [];
+const seen = new Set();
 for (const [, , , lastTrade, ric] of constituents){
+    if (seen.has(String(ric))) continue;
     const priceSeed = parseFloat(String(lastTrade));
     if (!isNaN(priceSeed)) {
+        seen.add(String(ric));
         const [bid, ask] = initBidAsk(5, nextRandomDouble);
         const askSize = random(1000, 3000);
         const bidSize = random(1000, 3000);
@@ -38,6 +40,10 @@ for (const [, , , lastTrade, ric] of constituents){
         ]);
     }
 }
-const pricesTable = TableContainer.createTable(schemas.prices, prices, buildDataColumnMap(schemas, "prices"), pricesUpdateGenerator);
+const pricesTable = new Table(schemas.prices, prices, buildDataColumnMap(schemas, "prices"), pricesUpdateGenerator);
+pricesUpdateGenerator.setRange({
+    from: 0,
+    to: prices.length
+});
 var reference_data_prices = pricesTable;
 export default reference_data_prices;

package/src/core/table/TableContainer.js

@@ -15,9 +15,9 @@ class TableContainer {
         this.addTable(table);
         return table;
     };
-    createJoinTable(joinTable, { table: t1 }, { table: t2 }, joinColumn) {
-        const table1 = this.getTable(t1);
-        const table2 = this.getTable(t2);
+    createJoinTable(joinTable, source1, source2, joinColumn) {
+        const table1 = source1 instanceof Table ? source1 : this.getTable(source1.table);
+        const table2 = source2 instanceof Table ? source2 : this.getTable(source2.table);
         const { map: m1, schema: schema1 } = table1;
         const { map: m2, schema: schema2 } = table2;
         const k1 = m1[joinColumn];
@@ -27,7 +27,7 @@ class TableContainer {
             ...schema2.columns
         ].map((col)=>col.name).sort());
         const combinedSchema = {
-            key: joinColumn,
+            key: schema1.key,
             table: joinTable,
             rangeLimits: DEFAULT_RANGE_LIMITS,
             columns: Array.from(combinedColumns).map((columnName)=>({
@@ -53,6 +53,18 @@ class TableContainer {
             }
         }
         const newTable = new Table(combinedSchema, data, combinedColumnMap);
+        const joinedKeys = new Map();
+        const indexJoinedRow = (row)=>{
+            const value = String(row[combinedColumnMap[joinColumn]]);
+            const key = String(row[combinedColumnMap[schema1.key]]);
+            let keys = joinedKeys.get(value);
+            if (!keys) {
+                keys = new Set();
+                joinedKeys.set(value, keys);
+            }
+            keys.add(key);
+        };
+        data.forEach(indexJoinedRow);
         table1.on("insert", (row)=>{
             const row2 = table2.findByKey(String(row[k1]));
             if (row2) {
@@ -65,18 +77,49 @@ class TableContainer {
                     const value = row2[m2[column.name]];
                     out[combinedColumnMap[column.name]] = value;
                 }
+                indexJoinedRow(out);
                 newTable.insert(out);
             }
         });
-        table2.on("update", (row)=>{
-            const keyValue = row[k2];
-            const targetRow = newTable.findByKey(keyValue);
+        table1.on("update", (row)=>{
+            const key = String(row[m1[schema1.key]]);
+            const targetRow = newTable.findByKey(key);
             if (targetRow) {
                 const updatedRow = targetRow.slice();
-                for (const { name } of table2.schema.columns)if (row[m2[name]] !== updatedRow[combinedColumnMap[name]]) updatedRow[combinedColumnMap[name]] = row[m2[name]];
+                for (const { name } of schema1.columns)updatedRow[combinedColumnMap[name]] = row[m1[name]];
+                newTable.updateRow(updatedRow);
+            }
+        });
+        table1.on("delete", (key)=>{
+            const row = newTable.findByKey(key);
+            if (row) {
+                const value = String(row[combinedColumnMap[joinColumn]]);
+                const keys = joinedKeys.get(value);
+                keys?.delete(key);
+                if (keys?.size === 0) joinedKeys.delete(value);
+                newTable.delete(key);
+            }
+        });
+        table2.on("update", (row)=>{
+            const keyValue = String(row[k2]);
+            for (const key of joinedKeys.get(keyValue) ?? []){
+                const targetRow = newTable.findByKey(key);
+                if (!targetRow) continue;
+                const updatedRow = targetRow.slice();
+                for (const { name } of table2.schema.columns)if (!(name in m1)) {
+                    if (row[m2[name]] !== updatedRow[combinedColumnMap[name]]) updatedRow[combinedColumnMap[name]] = row[m2[name]];
+                }
                 newTable.updateRow(updatedRow);
             }
         });
+        newTable.update = (key, columnName, value)=>{
+            const row = newTable.findByKey(key);
+            if (!row) throw Error(`[TableContainer] join row ${key} not found`);
+            if (columnName === schema1.key || columnName === joinColumn) throw Error(`[TableContainer] cannot edit join key ${columnName}`);
+            if (columnName in m1) table1.update(key, columnName, value);
+            else if (columnName in m2) table2.update(String(row[combinedColumnMap[schema2.key]]), columnName, value);
+            else throw Error(`[TableContainer] unknown join column ${columnName}`);
+        };
         this.addTable(newTable);
         return newTable;
     }

package/types/basket/BasketModule.d.ts

@@ -47,9 +47,11 @@ export declare class BasketModule extends VuuModule<BasketsTableName> {
         }[];
     };
     private createTradingBasket;
+    private insertTradingConstituent;
     private createNewBasket;
     private sendToMarket;
     private takeOffMarket;
     private addConstituent;
+    private updateConstituentStatus;
 }
 export declare const basketModule: BasketModule;

package/types/basket/reference-data/constituents.d.ts

@@ -1,3 +1,3 @@
-import { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
-declare const _default: VuuRowDataItemType[][];
-export default _default;
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+declare const basketConstituentData: VuuRowDataItemType[][];
+export default basketConstituentData;

package/types/basket/reference-data/prices.d.ts

@@ -1,3 +1,4 @@
+import { Table } from "../../Table";
 export type ask = number;
 export type askSize = number;
 export type bid = number;
@@ -20,5 +21,5 @@ export type PricesDataRow = [
     ric,
     scenario
 ];
-declare const pricesTable: import("../..").Table;
+declare const pricesTable: Table;
 export default pricesTable;

package/types/core/table/TableContainer.d.ts

@@ -8,7 +8,7 @@ declare class TableContainer {
     private constructor();
     static get instance(): TableContainer;
     createTable: (schema: TableSchema, data?: Array<Array<VuuRowDataItemType | bigint>>, dataMap?: ColumnMap, updateGenerator?: UpdateGenerator) => Table;
-    createJoinTable(joinTable: VuuTable, { table: t1 }: VuuTable, { table: t2 }: VuuTable, joinColumn: string): Table;
+    createJoinTable(joinTable: VuuTable, source1: VuuTable | Table, source2: VuuTable | Table, joinColumn: string): Table;
     addTable(table: Table): void;
     getTable<T = Table>(tableName: string): NonNullable<T>;
 }