@vuu-ui/vuu-data-test 3.0.0 → 3.1.0-beta.1

package/src/basket/BasketModule.mjs

@@ -0,0 +1,272 @@
+import { VuuModule } from "../core/module/VuuModule.mjs";
+import TableContainer from "../core/table/TableContainer.mjs";
+import { schemas } from "./basket-schemas.mjs";
+import reference_data_constituents from "./reference-data/constituents.mjs";
+const { createTable: createTable } = TableContainer;
+let basketIncrement = 1;
+const createBasketTradingRow = (basketId, basketName, side = "BUY", status = "OFF MARKET")=>[
+        basketId,
+        basketName,
+        0,
+        1.25,
+        `steve-${basketIncrement++}`,
+        side,
+        status,
+        1000000,
+        1250000,
+        100
+    ];
+const undefinedTables = {
+    algoType: void 0,
+    basket: void 0,
+    basketTrading: void 0,
+    basketTradingConstituent: void 0,
+    basketConstituent: void 0,
+    basketTradingConstituentJoin: void 0,
+    priceStrategyType: void 0
+};
+const buildDataColumnMap = (tableName)=>Object.values(schemas[tableName].columns).reduce((map, col, index)=>{
+        map[col.name] = index;
+        return map;
+    }, {});
+const tableMaps = {
+    algoType: buildDataColumnMap("algoType"),
+    basket: buildDataColumnMap("basket"),
+    basketTrading: buildDataColumnMap("basketTrading"),
+    basketTradingConstituent: buildDataColumnMap("basketTradingConstituent"),
+    basketConstituent: buildDataColumnMap("basketConstituent"),
+    basketTradingConstituentJoin: buildDataColumnMap("basketTradingConstituentJoin"),
+    priceStrategyType: buildDataColumnMap("priceStrategyType")
+};
+const basketTradingConstituent = TableContainer.createTable(schemas.basketTradingConstituent, [], tableMaps.basketTradingConstituent);
+class BasketModule extends VuuModule {
+    #tables = {
+        algoType: createTable(schemas.algoType, [
+            [
+                "Sniper",
+                0
+            ],
+            [
+                "Dark Liquidity",
+                1
+            ],
+            [
+                "VWAP",
+                2
+            ],
+            [
+                "POV",
+                3
+            ],
+            [
+                "Dynamic Close",
+                4
+            ]
+        ], tableMaps.algoType),
+        basket: createTable(schemas.basket, [
+            [
+                ".NASDAQ100",
+                ".NASDAQ100",
+                0,
+                0
+            ],
+            [
+                ".HSI",
+                ".HSI",
+                0,
+                0
+            ],
+            [
+                ".FTSE100",
+                ".FTSE100",
+                0,
+                0
+            ],
+            [
+                ".SP500",
+                ".SP500",
+                0,
+                0
+            ]
+        ], tableMaps.basket),
+        basketConstituent: createTable(schemas.basketConstituent, reference_data_constituents, tableMaps.basketConstituent),
+        basketTrading: createTable(schemas.basketTrading, [], tableMaps.basketTrading),
+        basketTradingConstituent: basketTradingConstituent,
+        basketTradingConstituentJoin: TableContainer.createJoinTable({
+            module: "BASKET",
+            table: "basketTradingConstituentJoin"
+        }, {
+            module: "BASKET",
+            table: "basketTradingConstituent"
+        }, {
+            module: "SIMUL",
+            table: "prices"
+        }, "ric"),
+        priceStrategyType: createTable(schemas.priceStrategyType, [
+            [
+                "Peg to Near Touch",
+                0
+            ],
+            [
+                "Far Touch",
+                1
+            ],
+            [
+                "Limit",
+                2
+            ],
+            [
+                "Algo",
+                3
+            ]
+        ], tableMaps.priceStrategyType)
+    };
+    constructor(){
+        super("BASKET");
+    }
+    get menus() {
+        return {
+            ...undefinedTables,
+            basket: {
+                name: "ROOT",
+                menus: [
+                    {
+                        context: "selected-rows",
+                        filter: "",
+                        name: "Add Basket",
+                        rpcName: "CREATE_NEW_BASKET"
+                    }
+                ]
+            }
+        };
+    }
+    get schemas() {
+        return schemas;
+    }
+    get services() {
+        return {
+            ...undefinedTables,
+            basket: [
+                {
+                    rpcName: "createBasket",
+                    service: this.createNewBasket
+                }
+            ],
+            basketTrading: [
+                {
+                    rpcName: "sendToMarket",
+                    service: this.sendToMarket
+                },
+                {
+                    rpcName: "takeOffMarket",
+                    service: this.takeOffMarket
+                }
+            ],
+            basketTradingConstituentJoin: [
+                {
+                    rpcName: "addConstituent",
+                    service: this.addConstituent
+                }
+            ]
+        };
+    }
+    get menuServices() {
+        return {
+            ...undefinedTables
+        };
+    }
+    get tables() {
+        return this.#tables;
+    }
+    get visualLinks() {
+        return {
+            ...undefinedTables,
+            basketConstituent: [
+                {
+                    fromColumn: "basketId",
+                    toColumn: "id",
+                    toTable: "basket"
+                }
+            ]
+        };
+    }
+    createTradingBasket(basketId, basketName) {
+        const basketTradingRow = createBasketTradingRow(basketId, basketName);
+        this.tables.basketTrading.insert(basketTradingRow);
+        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);
+        });
+        return basketTradingRow[instanceId];
+    }
+    createNewBasket = async (rpcRequest)=>{
+        if ("VIEWPORT_CONTEXT" === rpcRequest.context.type) {
+            const { sourceBasketId, tradeBasketName } = rpcRequest.params;
+            const key = this.createTradingBasket(sourceBasketId, tradeBasketName);
+            return {
+                type: "SUCCESS_RESULT",
+                data: key
+            };
+        }
+        throw Error("[BasketModule] createNewBasket invalid request type");
+    };
+    sendToMarket = async (rpcRequest)=>{
+        if ("VIEWPORT_CONTEXT" === rpcRequest.context.type) {
+            const { basketInstanceId } = rpcRequest.params;
+            this.tables.basketTrading.update(basketInstanceId, "status", "ON_MARKET");
+            return {
+                type: "SUCCESS_RESULT",
+                data: void 0
+            };
+        }
+        throw Error("[BasketModule] createNewBasket invalid request type");
+    };
+    takeOffMarket = async (rpcRequest)=>{
+        if ("VIEWPORT_CONTEXT" === rpcRequest.context.type) {
+            const { basketInstanceId } = rpcRequest.params;
+            this.tables.basketTrading.update(basketInstanceId, "status", "OFF-MARKET");
+            return {
+                type: "SUCCESS_RESULT",
+                data: void 0
+            };
+        }
+        throw Error("[BasketModule] createNewBasket invalid request type");
+    };
+    addConstituent = async ()=>{
+        throw Error("addConstituent not implemented");
+    };
+}
+const basketModule = new BasketModule();
+export { BasketModule, basketModule, createBasketTradingRow };

package/src/basket/basket-schemas.mjs

@@ -0,0 +1,366 @@
+const DEFAULT_RANGE_LIMITS = {
+    maxRangeEnd: 1000000,
+    maxRangeWidth: 1000
+};
+const schemas = {
+    algoType: {
+        columns: [
+            {
+                name: "algoType",
+                serverDataType: "string"
+            },
+            {
+                name: "id",
+                serverDataType: "int"
+            }
+        ],
+        key: "id",
+        rangeLimits: DEFAULT_RANGE_LIMITS,
+        table: {
+            module: "BASKET",
+            table: "algoType"
+        }
+    },
+    basket: {
+        columns: [
+            {
+                name: "id",
+                serverDataType: "string"
+            },
+            {
+                name: "name",
+                serverDataType: "string"
+            },
+            {
+                name: "notionalValue",
+                serverDataType: "double"
+            },
+            {
+                name: "notionalValueUsd",
+                serverDataType: "double"
+            }
+        ],
+        key: "id",
+        rangeLimits: DEFAULT_RANGE_LIMITS,
+        table: {
+            module: "BASKET",
+            table: "basket"
+        }
+    },
+    basketConstituent: {
+        columns: [
+            {
+                name: "basketId",
+                serverDataType: "string"
+            },
+            {
+                name: "change",
+                serverDataType: "string"
+            },
+            {
+                name: "description",
+                serverDataType: "string"
+            },
+            {
+                name: "lastTrade",
+                serverDataType: "string"
+            },
+            {
+                name: "ric",
+                serverDataType: "string"
+            },
+            {
+                name: "ricBasketId",
+                serverDataType: "string"
+            },
+            {
+                name: "side",
+                serverDataType: "string"
+            },
+            {
+                name: "volume",
+                serverDataType: "string"
+            },
+            {
+                name: "weighting",
+                serverDataType: "double"
+            }
+        ],
+        key: "ricBasketId",
+        rangeLimits: DEFAULT_RANGE_LIMITS,
+        table: {
+            module: "BASKET",
+            table: "basketConstituent"
+        }
+    },
+    basketTrading: {
+        columns: [
+            {
+                name: "basketId",
+                serverDataType: "string"
+            },
+            {
+                name: "basketName",
+                serverDataType: "string"
+            },
+            {
+                name: "filledPct",
+                serverDataType: "double"
+            },
+            {
+                name: "fxRateToUsd",
+                serverDataType: "double"
+            },
+            {
+                name: "instanceId",
+                serverDataType: "string"
+            },
+            {
+                name: "side",
+                serverDataType: "string"
+            },
+            {
+                name: "status",
+                serverDataType: "string"
+            },
+            {
+                name: "totalNotional",
+                serverDataType: "double"
+            },
+            {
+                name: "totalNotionalUsd",
+                serverDataType: "double"
+            },
+            {
+                name: "units",
+                serverDataType: "int"
+            }
+        ],
+        key: "instanceId",
+        rangeLimits: DEFAULT_RANGE_LIMITS,
+        table: {
+            module: "BASKET",
+            table: "basketTrading"
+        }
+    },
+    basketTradingConstituent: {
+        columns: [
+            {
+                name: "algo",
+                serverDataType: "string"
+            },
+            {
+                name: "algoParams",
+                serverDataType: "string"
+            },
+            {
+                name: "basketId",
+                serverDataType: "string"
+            },
+            {
+                name: "description",
+                serverDataType: "string"
+            },
+            {
+                name: "instanceId",
+                serverDataType: "string"
+            },
+            {
+                name: "instanceIdRic",
+                serverDataType: "string"
+            },
+            {
+                name: "limitPrice",
+                serverDataType: "double"
+            },
+            {
+                name: "notionalLocal",
+                serverDataType: "double"
+            },
+            {
+                name: "notionalUsd",
+                serverDataType: "double"
+            },
+            {
+                name: "pctFilled",
+                serverDataType: "double"
+            },
+            {
+                name: "priceSpread",
+                serverDataType: "int"
+            },
+            {
+                name: "priceStrategyId",
+                serverDataType: "int"
+            },
+            {
+                name: "quantity",
+                serverDataType: "long"
+            },
+            {
+                name: "ric",
+                serverDataType: "string"
+            },
+            {
+                name: "side",
+                serverDataType: "string"
+            },
+            {
+                name: "status",
+                serverDataType: "string"
+            },
+            {
+                name: "venue",
+                serverDataType: "string"
+            },
+            {
+                name: "weighting",
+                serverDataType: "double"
+            }
+        ],
+        key: "instanceIdRic",
+        rangeLimits: DEFAULT_RANGE_LIMITS,
+        table: {
+            module: "BASKET",
+            table: "basketTradingConstituent"
+        }
+    },
+    basketTradingConstituentJoin: {
+        columns: [
+            {
+                name: "algo",
+                serverDataType: "string"
+            },
+            {
+                name: "algoParams",
+                serverDataType: "string"
+            },
+            {
+                name: "ask",
+                serverDataType: "double"
+            },
+            {
+                name: "askSize",
+                serverDataType: "double"
+            },
+            {
+                name: "basketId",
+                serverDataType: "string"
+            },
+            {
+                name: "bid",
+                serverDataType: "double"
+            },
+            {
+                name: "bidSize",
+                serverDataType: "double"
+            },
+            {
+                name: "close",
+                serverDataType: "double"
+            },
+            {
+                name: "description",
+                serverDataType: "string"
+            },
+            {
+                name: "instanceId",
+                serverDataType: "string"
+            },
+            {
+                name: "instanceIdRic",
+                serverDataType: "string"
+            },
+            {
+                name: "last",
+                serverDataType: "double"
+            },
+            {
+                name: "limitPrice",
+                serverDataType: "double"
+            },
+            {
+                name: "notionalLocal",
+                serverDataType: "double"
+            },
+            {
+                name: "notionalUsd",
+                serverDataType: "double"
+            },
+            {
+                name: "open",
+                serverDataType: "double"
+            },
+            {
+                name: "pctFilled",
+                serverDataType: "double"
+            },
+            {
+                name: "phase",
+                serverDataType: "string"
+            },
+            {
+                name: "priceSpread",
+                serverDataType: "int"
+            },
+            {
+                name: "priceStrategyId",
+                serverDataType: "int"
+            },
+            {
+                name: "quantity",
+                serverDataType: "long"
+            },
+            {
+                name: "ric",
+                serverDataType: "string"
+            },
+            {
+                name: "scenario",
+                serverDataType: "string"
+            },
+            {
+                name: "side",
+                serverDataType: "string"
+            },
+            {
+                name: "status",
+                serverDataType: "string"
+            },
+            {
+                name: "venue",
+                serverDataType: "string"
+            },
+            {
+                name: "weighting",
+                serverDataType: "double"
+            }
+        ],
+        key: "instanceIdRic",
+        rangeLimits: DEFAULT_RANGE_LIMITS,
+        table: {
+            module: "BASKET",
+            table: "basketTradingConstituentJoin"
+        }
+    },
+    priceStrategyType: {
+        columns: [
+            {
+                name: "priceStrategy",
+                serverDataType: "string"
+            },
+            {
+                name: "id",
+                serverDataType: "int"
+            }
+        ],
+        key: "",
+        rangeLimits: DEFAULT_RANGE_LIMITS,
+        table: {
+            module: "BASKET",
+            table: "priceStrategyType"
+        }
+    }
+};
+const isBasketTable = (table)=>"BASKET" === table.module;
+export { isBasketTable, schemas };

package/src/basket/index.mjs

@@ -0,0 +1,2 @@
+export { isBasketTable, schemas as basketSchemas } from "./basket-schemas.mjs";
+export { basketModule } from "./BasketModule.mjs";

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

@@ -0,0 +1,76 @@
+import ftse100 from "./ftse100.mjs";
+import nasdaq100 from "./nasdaq100.mjs";
+import sp500 from "./sp500.mjs";
+import hsi from "./hsi.mjs";
+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;