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

package/src/module-admin/ModuleAdminModule.js

@@ -0,0 +1,124 @@
+import { DEFAULT_MODULE_DEFINITIONS, MODULE_ADMIN_RPC, MODULE_NAV_ICONS, executeModuleAdminRpc, toManagedModules } from "@heswell/module-admin/contracts";
+import { VuuModule } from "../core/module/VuuModule.js";
+import TableContainer from "../core/table/TableContainer.js";
+import { buildDataColumnMapFromSchema } from "../Table.js";
+import { MODULE_ADMIN_MODULE_NAME, MODULE_ADMIN_TABLE_SCHEMAS } from "./module-admin-schemas.js";
+import { reconcileModuleAdminTables } from "./snapshot-projection.js";
+const createTable = (tableName)=>{
+    const schema = MODULE_ADMIN_TABLE_SCHEMAS[tableName];
+    return TableContainer.createTable(schema, [], buildDataColumnMapFromSchema(schema));
+};
+const createTables = ()=>({
+        modulePermissions: createTable("modulePermissions"),
+        modules: createTable("modules")
+    });
+const INITIAL_TIMESTAMP = 1710000000000;
+const INITIAL_ACCESS_ROLES = [
+    {
+        moduleName: "moduleAdmin",
+        role: "module-admin-access"
+    },
+    {
+        moduleName: "userAdmin",
+        role: "user-admin-access"
+    },
+    {
+        moduleName: "basket-trading",
+        role: "basket-trading-access"
+    },
+    {
+        moduleName: "vuu-table-browser",
+        role: "vuu-table-browser-access"
+    }
+];
+const EXAMPLE_MODULES = [
+    {
+        id: 6,
+        parentModuleId: 0,
+        name: "order-blotter",
+        title: "Order blotter",
+        description: "Monitor parent and child orders across all desks.",
+        version: 3,
+        enabled: false,
+        location: "/Trading/Orders",
+        path: "/trading/orders",
+        mfComponent: "OrderBlotter",
+        mfScope: "orderBlotter",
+        mfUrl: "http://localhost:5009",
+        navIconUrl: MODULE_NAV_ICONS.tables,
+        vuuConnectionId: "",
+        vuuWebsocketUrl: "",
+        vuuRestUrl: "",
+        accessRole: "",
+        created: INITIAL_TIMESTAMP,
+        updated: INITIAL_TIMESTAMP
+    }
+];
+const MODULE_ADMIN_INITIAL_SNAPSHOT = {
+    modules: [
+        ...toManagedModules(DEFAULT_MODULE_DEFINITIONS, INITIAL_ACCESS_ROLES, INITIAL_TIMESTAMP),
+        ...EXAMPLE_MODULES
+    ]
+};
+class ModuleAdminModule extends VuuModule {
+    now;
+    #modules;
+    #tables;
+    constructor(snapshot = MODULE_ADMIN_INITIAL_SNAPSHOT, now = Date.now){
+        super(MODULE_ADMIN_MODULE_NAME), this.now = now;
+        this.#modules = snapshot.modules;
+        this.#tables = createTables();
+        reconcileModuleAdminTables(snapshot, this.#tables);
+    }
+    get modules() {
+        return this.#modules;
+    }
+    get menus() {
+        return {
+            modulePermissions: void 0,
+            modules: void 0
+        };
+    }
+    get includeDefaultServices() {
+        return false;
+    }
+    get menuServices() {}
+    get schemas() {
+        return MODULE_ADMIN_TABLE_SCHEMAS;
+    }
+    service = (rpcName)=>async (request)=>{
+            try {
+                if ("RPC_REQUEST" !== request.type || request.rpcName !== rpcName) throw new Error(`Expected ${rpcName} RPC request`);
+                const { modules, result } = executeModuleAdminRpc(this.#modules, rpcName, request.params, this.now);
+                this.#modules = modules;
+                reconcileModuleAdminTables({
+                    modules
+                }, this.#tables);
+                return {
+                    data: result,
+                    type: "SUCCESS_RESULT"
+                };
+            } catch (error) {
+                return {
+                    errorMessage: error instanceof Error ? error.message : "Module admin request failed",
+                    type: "ERROR_RESULT"
+                };
+            }
+        };
+    get services() {
+        const services = Object.keys(MODULE_ADMIN_RPC).map((rpcName)=>({
+                rpcName,
+                service: this.service(rpcName)
+            }));
+        return {
+            modulePermissions: services,
+            modules: services
+        };
+    }
+    get tables() {
+        return this.#tables;
+    }
+    get visualLinks() {}
+}
+const moduleAdminModule = new ModuleAdminModule();
+export { MODULE_ADMIN_INITIAL_SNAPSHOT, ModuleAdminModule, moduleAdminModule };

package/src/module-admin/index.js

@@ -0,0 +1,3 @@
+export { MODULE_ADMIN_INITIAL_SNAPSHOT, ModuleAdminModule, moduleAdminModule } from "./ModuleAdminModule.js";
+export { MODULE_ADMIN_MODULE_NAME, MODULE_ADMIN_TABLE_SCHEMAS } from "./module-admin-schemas.js";
+export { projectModuleAdminSnapshot, reconcileModuleAdminTables } from "./snapshot-projection.js";

package/src/module-admin/module-admin-schemas.js

@@ -0,0 +1,95 @@
+import { VUU_DEFAULT_COLUMNS } from "../default-column-definitions.js";
+const DEFAULT_RANGE_LIMITS = {
+    maxRangeEnd: 1000000,
+    maxRangeWidth: 1000
+};
+const MODULE_ADMIN_MODULE_NAME = "MODULE_DISCOVERY";
+const MODULE_ADMIN_TABLE_SCHEMAS = {
+    modules: {
+        columns: [
+            {
+                name: "id",
+                serverDataType: "int"
+            },
+            {
+                name: "parentModuleId",
+                serverDataType: "int"
+            },
+            {
+                name: "name",
+                serverDataType: "string"
+            },
+            {
+                name: "title",
+                serverDataType: "string"
+            },
+            {
+                name: "description",
+                serverDataType: "string"
+            },
+            {
+                name: "version",
+                serverDataType: "int"
+            },
+            {
+                name: "enabled",
+                serverDataType: "boolean"
+            },
+            {
+                name: "location",
+                serverDataType: "string"
+            },
+            {
+                name: "path",
+                serverDataType: "string"
+            },
+            {
+                name: "mfComponent",
+                serverDataType: "string"
+            },
+            {
+                name: "mfScope",
+                serverDataType: "string"
+            },
+            {
+                name: "mfUrl",
+                serverDataType: "string"
+            },
+            {
+                name: "navIconUrl",
+                serverDataType: "string"
+            },
+            ...VUU_DEFAULT_COLUMNS
+        ],
+        key: "id",
+        rangeLimits: DEFAULT_RANGE_LIMITS,
+        table: {
+            module: MODULE_ADMIN_MODULE_NAME,
+            table: "modules"
+        }
+    },
+    modulePermissions: {
+        columns: [
+            {
+                name: "id",
+                serverDataType: "int"
+            },
+            {
+                name: "module_id",
+                serverDataType: "int"
+            },
+            {
+                name: "role",
+                serverDataType: "string"
+            },
+            ...VUU_DEFAULT_COLUMNS
+        ],
+        key: "id",
+        rangeLimits: DEFAULT_RANGE_LIMITS,
+        table: {
+            module: MODULE_ADMIN_MODULE_NAME,
+            table: "modulePermissions"
+        }
+    }
+};
+export { MODULE_ADMIN_MODULE_NAME, MODULE_ADMIN_TABLE_SCHEMAS };

package/src/module-admin/snapshot-projection.js

@@ -0,0 +1,29 @@
+import { managedModuleColumnValues, managedModulePermissionValues } from "@heswell/module-admin/contracts";
+const rowsEqual = (left, right)=>left.length === right.length && left.every((value, index)=>value === right[index]);
+const toRow = (table, values)=>table.schema.columns.map(({ name })=>values[name] ?? "");
+const projectModuleAdminSnapshot = (snapshot, tables)=>({
+        modulePermissions: managedModulePermissionValues(snapshot.modules).map((values)=>toRow(tables.modulePermissions, values)),
+        modules: snapshot.modules.map((module)=>toRow(tables.modules, managedModuleColumnValues(module)))
+    });
+const reconcileModuleAdminTables = (snapshot, tables)=>{
+    const projected = projectModuleAdminSnapshot(snapshot, tables);
+    for (const tableName of Object.keys(tables)){
+        const table = tables[tableName];
+        const desiredRows = projected[tableName];
+        const keyIndex = table.map[table.schema.key];
+        const desiredKeys = new Set(desiredRows.map((row)=>String(row[keyIndex])));
+        for (const existingRow of [
+            ...table.data
+        ]){
+            const key = String(existingRow[keyIndex]);
+            if (!desiredKeys.has(key)) table.delete(key);
+        }
+        for (const row of desiredRows){
+            const key = String(row[keyIndex]);
+            const existingRow = table.findByKey(key);
+            if (void 0 === existingRow) table.insert(row);
+            else if (!rowsEqual(existingRow, row)) table.updateRow(row);
+        }
+    }
+};
+export { projectModuleAdminSnapshot, reconcileModuleAdminTables };

package/src/notifications/NotificationModule.js

@@ -0,0 +1,131 @@
+import { VuuModule } from "../core/module/VuuModule.js";
+import TableContainer from "../core/table/TableContainer.js";
+import { buildDataColumnMapFromSchema } from "../Table.js";
+import { NotificationsSchema } from "./NotificationsSchema.js";
+const NAME = "NOTIFICATIONS";
+const TABLE_NAME = "notifications";
+const DEFAULT_RANGE_LIMITS = {
+    maxRangeEnd: 1000000,
+    maxRangeWidth: 1000
+};
+const VUU_DEFAULT_COLUMNS = [
+    {
+        name: "vuuCreatedTimestamp",
+        serverDataType: "epochtimestamp"
+    },
+    {
+        name: "vuuUpdatedTimestamp",
+        serverDataType: "epochtimestamp"
+    },
+    {
+        name: "vuuMsg",
+        serverDataType: "string"
+    }
+];
+class NotificationModule extends VuuModule {
+    static NAME = NAME;
+    static TABLE_NAME = TABLE_NAME;
+    #autoStarted = false;
+    #expiryTimers = new Map();
+    #provider;
+    #running = false;
+    #schemas;
+    #services;
+    #tables;
+    constructor(providerFactory, permissionFunction, serviceFactory, ...additionalColumns){
+        super(NAME);
+        const schema = {
+            columns: [
+                ...NotificationsSchema.allFrom(...additionalColumns),
+                ...VUU_DEFAULT_COLUMNS
+            ],
+            key: "id",
+            rangeLimits: DEFAULT_RANGE_LIMITS,
+            table: {
+                module: NAME,
+                table: TABLE_NAME
+            }
+        };
+        const table = TableContainer.createTable(schema, [], buildDataColumnMapFromSchema(schema));
+        this.#schemas = {
+            [TABLE_NAME]: schema
+        };
+        this.#tables = {
+            [TABLE_NAME]: table
+        };
+        this.permissionFunctions = {
+            [TABLE_NAME]: permissionFunction
+        };
+        this.#provider = providerFactory(table);
+        this.#services = {
+            [TABLE_NAME]: serviceFactory(table, this)
+        };
+    }
+    beforeCreateDataSource() {
+        if (!this.#autoStarted) {
+            this.#autoStarted = true;
+            this.start();
+        }
+    }
+    publish(notification = {}) {
+        const table = this.#tables[TABLE_NAME];
+        const { map, schema } = table;
+        const id = notification.id ?? crypto.randomUUID();
+        const values = {
+            type: "toast",
+            title: "Notification",
+            message: "",
+            level: "INFO",
+            audience: "all",
+            ...notification,
+            id
+        };
+        const row = schema.columns.map(({ serverDataType })=>"string" === serverDataType ? "" : "boolean" === serverDataType ? false : 0);
+        for (const [name, value] of Object.entries(values)){
+            const idx = map[name];
+            if (void 0 !== idx && void 0 !== value) row[idx] = value;
+        }
+        const existingRow = table.findByKey(id);
+        if (existingRow) {
+            row[map.vuuCreatedTimestamp] = existingRow[map.vuuCreatedTimestamp];
+            table.updateRow(row);
+        } else table.insert(row);
+        clearTimeout(this.#expiryTimers.get(id));
+        this.#expiryTimers.delete(id);
+        const { expiryTime } = values;
+        if ("number" == typeof expiryTime && expiryTime > 0) this.#expiryTimers.set(id, setTimeout(()=>{
+            this.#expiryTimers.delete(id);
+            if (table.findByKey(id)) table.delete(id);
+        }, Math.max(0, expiryTime - Date.now())));
+        return id;
+    }
+    get isRunning() {
+        return this.#running;
+    }
+    start() {
+        if (!this.#running) {
+            this.#running = true;
+            this.#provider.start();
+        }
+    }
+    stop() {
+        this.#autoStarted = true;
+        if (this.#running) {
+            this.#running = false;
+            this.#provider.stop();
+        }
+    }
+    get menus() {}
+    get menuServices() {}
+    get schemas() {
+        return this.#schemas;
+    }
+    get services() {
+        return this.#services;
+    }
+    get tables() {
+        return this.#tables;
+    }
+    get visualLinks() {}
+}
+export { NotificationModule };

package/src/notifications/NotificationsSchema.js

@@ -0,0 +1,52 @@
+const VuuColumnDataTypes = {
+    boolean: "boolean",
+    char: "char",
+    double: "double",
+    epochtimestamp: "epochtimestamp",
+    epochtimestampnano: "epochtimestampnano",
+    int: "int",
+    long: "long",
+    string: "string"
+};
+const toColumn = (columnDefinition)=>{
+    if ("string" == typeof columnDefinition) {
+        const [name, dataType = ""] = columnDefinition.split(":");
+        const serverDataType = VuuColumnDataTypes[dataType.toLowerCase()];
+        if (name && serverDataType) return {
+            name,
+            serverDataType
+        };
+        throw Error(`[NotificationsSchema] invalid column definition '${columnDefinition}'`);
+    }
+    return columnDefinition;
+};
+const Id = "id:String";
+const Type = "type:String";
+const ExpiryTime = "expiryTime:EpochTimestamp";
+const Title = "title:String";
+const Message = "message:String";
+const Level = "level:String";
+const Audience = "audience:String";
+const genericColumns = [
+    Id,
+    Type,
+    ExpiryTime,
+    Title,
+    Message,
+    Level,
+    Audience
+];
+const NotificationsSchema = {
+    Id: Id,
+    Type: Type,
+    ExpiryTime: ExpiryTime,
+    Title: Title,
+    Message: Message,
+    Level: Level,
+    Audience: Audience,
+    allFrom: (...additionalColumns)=>[
+            ...genericColumns,
+            ...additionalColumns
+        ].map(toColumn)
+};
+export { NotificationsSchema, toColumn };

package/src/notifications/index.js

@@ -0,0 +1,6 @@
+export * from "./NotificationModule.js";
+export * from "./NotificationsSchema.js";
+export * from "./simulated/DismissNotificationRpcHandler.js";
+export * from "./simulated/SimulatedNotificationsModule.js";
+export * from "./simulated/SimulatedNotificationsProvider.js";
+export * from "./simulated/notificationsModule.js";

package/src/notifications/simulated/DismissNotificationRpcHandler.js

@@ -0,0 +1,36 @@
+const errorResult = (errorMessage)=>({
+        type: "ERROR_RESULT",
+        errorMessage
+    });
+const DismissNotificationRpcHandler = (table, module)=>{
+    const dismissNotification = async (rpcRequest)=>{
+        if ("VIEWPORT_CONTEXT" !== rpcRequest.context.type) return errorResult("dismissNotification requires a viewport context");
+        const { dataSource, table: viewportTable, user } = module.getSubscriptionByViewport(rpcRequest.context.viewPortId);
+        const selectedRowIds = dataSource.getSelectedRowIds();
+        const selection = selectedRowIds.includes("*") ? viewportTable.data.map((row)=>row[viewportTable.map[viewportTable.schema.key]]) : selectedRowIds;
+        const { map } = table;
+        for (const rowKey of selection){
+            const row = table.findByKey(rowKey);
+            if (row) {
+                const updatedRow = row.slice();
+                updatedRow[map.status] = "dismissed";
+                updatedRow[map.dismissedBy] = user.name;
+                table.updateRow(updatedRow);
+            }
+        }
+        return {
+            type: "SUCCESS_RESULT",
+            data: {
+                success: true,
+                dismissedCount: selection.length
+            }
+        };
+    };
+    return [
+        {
+            rpcName: "dismissNotification",
+            service: dismissNotification
+        }
+    ];
+};
+export { DismissNotificationRpcHandler };

package/src/notifications/simulated/SimulatedNotificationsModule.js

@@ -0,0 +1,18 @@
+import { PermissionFilter } from "../../core/filter/PermissionFilter.js";
+import { NotificationModule } from "../NotificationModule.js";
+import { DismissNotificationRpcHandler } from "./DismissNotificationRpcHandler.js";
+import { SimulatedNotificationsProvider } from "./SimulatedNotificationsProvider.js";
+const noSimulation = {
+    start: ()=>void 0,
+    stop: ()=>void 0
+};
+const SimulatedNotificationsModule = ({ simulate = true } = {})=>new NotificationModule((table)=>simulate ? new SimulatedNotificationsProvider(table) : noSimulation, (viewport)=>{
+        const currentUser = viewport.user.name;
+        return PermissionFilter("audience", new Set([
+            "all",
+            currentUser,
+            "admin",
+            "trader"
+        ]));
+    }, DismissNotificationRpcHandler, "source:String", "priority:Int", "status:String", "dismissedBy:String");
+export { SimulatedNotificationsModule };

package/src/notifications/simulated/SimulatedNotificationsProvider.js

@@ -0,0 +1,151 @@
+const sampleTemplates = [
+    [
+        "toast",
+        "Order Execution",
+        "Order #%04d filled %d shares of AAPL at $%d.%02d",
+        "INFO",
+        12000,
+        "OMS",
+        2,
+        "trader"
+    ],
+    [
+        "toast",
+        "Risk Limit Alert",
+        "Account ACC-%04d exceeded intraday VaR limit by %d%%",
+        "WARNING",
+        15000,
+        "RISK",
+        5,
+        "risk_manager"
+    ],
+    [
+        "toast",
+        "Feed Synchronization",
+        "Connected to pricing feed NYC-%02d with latency %dms",
+        "INFO",
+        10000,
+        "PRICING",
+        1,
+        "admin"
+    ],
+    [
+        "toast",
+        "Connection Warning",
+        "Intermittent packet loss detected on gateway LDN-%02d",
+        "WARNING",
+        14000,
+        "GATEWAY",
+        3,
+        "admin"
+    ],
+    [
+        "toast",
+        "Order Rejection",
+        "Order #%04d rejected by exchange: Insufficient margin",
+        "ERROR",
+        18000,
+        "OMS",
+        10,
+        "all"
+    ],
+    [
+        "banner",
+        "System Maintenance",
+        "Scheduled system maintenance will begin in %d minutes",
+        "WARNING",
+        45000,
+        "SYSTEM",
+        5,
+        "all"
+    ],
+    [
+        "banner",
+        "Market Status",
+        "US Equity markets are now OPEN. Trading session #%d active",
+        "INFO",
+        60000,
+        "SYSTEM",
+        1,
+        "all"
+    ]
+];
+const MAX_ACTIVE_NOTIFICATIONS = 8;
+const INITIAL_NOTIFICATIONS = 3;
+const CYCLE_TIME_MS = 4000;
+const randomInt = (bound)=>Math.floor(Math.random() * bound);
+const formatMessage = (format, ...args)=>{
+    let argIndex = 0;
+    return format.replace(/%(0(\d+))?d|%%/g, (match, _, width)=>{
+        if ("%%" === match) return "%";
+        const value = String(args[argIndex++]);
+        return width ? value.padStart(Number(width), "0") : value;
+    });
+};
+class SimulatedNotificationsProvider {
+    #activeNotifications = new Map();
+    #table;
+    #timer;
+    constructor(table){
+        this.#table = table;
+    }
+    start() {
+        if (void 0 === this.#timer) {
+            for(let i = 0; i < INITIAL_NOTIFICATIONS; i++)this.generateRandomNotification();
+            this.#timer = setInterval(this.runOnce, CYCLE_TIME_MS);
+        }
+    }
+    stop() {
+        if (void 0 !== this.#timer) {
+            clearInterval(this.#timer);
+            this.#timer = void 0;
+        }
+    }
+    runOnce = ()=>{
+        try {
+            const now = Date.now();
+            for (const [id, expiryTime] of Array.from(this.#activeNotifications))if (expiryTime < now) {
+                this.#table.delete(id);
+                this.#activeNotifications.delete(id);
+            }
+            if (this.#activeNotifications.size < MAX_ACTIVE_NOTIFICATIONS) this.generateRandomNotification();
+        } catch (e) {
+            console.error("Error occurred in SimulatedNotificationsProvider runOnce", e);
+        }
+    };
+    generateRandomNotification() {
+        const id = crypto.randomUUID();
+        const now = Date.now();
+        const [type, title, messageFormat, level, duration, source, priority, audience] = sampleTemplates[randomInt(sampleTemplates.length)];
+        const expiryTime = now + duration;
+        const message = messageFormat.includes("%") ? formatMessage(messageFormat, randomInt(9000) + 1000, 10 * randomInt(90) + 100, randomInt(200) + 50, randomInt(99)) : messageFormat;
+        const rowData = {
+            id,
+            type,
+            expiryTime,
+            title,
+            message,
+            level,
+            audience,
+            source,
+            priority,
+            status: "",
+            dismissedBy: "",
+            vuuCreatedTimestamp: now,
+            vuuUpdatedTimestamp: now,
+            vuuMsg: ""
+        };
+        this.#table.insert(this.toDataRow(rowData));
+        this.#activeNotifications.set(id, expiryTime);
+    }
+    toDataRow(rowData) {
+        const { map, schema } = this.#table;
+        const row = Array(schema.columns.length);
+        for (const [name, value] of Object.entries(rowData)){
+            const idx = map[name];
+            if (void 0 !== idx) row[idx] = value;
+        }
+        return row;
+    }
+}
+export { SimulatedNotificationsProvider, formatMessage };

package/src/notifications/simulated/notificationsModule.js

@@ -0,0 +1,3 @@
+import { SimulatedNotificationsModule } from "./SimulatedNotificationsModule.js";
+const notificationsModule = SimulatedNotificationsModule();
+export { notificationsModule };

package/src/schemas.js

@@ -1,15 +1,21 @@
 import { schemas } from "./basket/basket-schemas.js";
 import { schemas as simul_schemas_js_schemas } from "./simul/simul-schemas.js";
 import { testModule } from "./test/TestModule.js";
+import { USER_ADMIN_TABLE_SCHEMAS } from "@heswell/user-admin/contracts";
+import { MODULE_ADMIN_TABLE_SCHEMAS } from "./module-admin/index.js";
 const schemas_schemas = {
     ...schemas,
     ...simul_schemas_js_schemas,
-    ...testModule.schemas
+    ...testModule.schemas,
+    ...USER_ADMIN_TABLE_SCHEMAS,
+    ...MODULE_ADMIN_TABLE_SCHEMAS
 };
 const allSchemas = {
     ...schemas,
     ...simul_schemas_js_schemas,
-    ...testModule.schemas
+    ...testModule.schemas,
+    ...USER_ADMIN_TABLE_SCHEMAS,
+    ...MODULE_ADMIN_TABLE_SCHEMAS
 };
 const getAllSchemas = ()=>schemas_schemas;
 const getSchema = (tableName)=>{