@vuu-ui/vuu-data-test 4.0.0-alpha.2 → 4.0.0-alpha.20

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

@@ -0,0 +1,107 @@
+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: "vuuConnectionId",
+                serverDataType: "string"
+            },
+            {
+                name: "vuuWebsocketUrl",
+                serverDataType: "string"
+            },
+            {
+                name: "vuuRestUrl",
+                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,93 @@
+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;
+    #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() {
+        this.start();
+    }
+    get isRunning() {
+        return this.#running;
+    }
+    start() {
+        if (!this.#running) {
+            this.#running = true;
+            this.#provider.start();
+        }
+    }
+    stop() {
+        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,14 @@
+import { PermissionFilter } from "../../core/filter/PermissionFilter.js";
+import { NotificationModule } from "../NotificationModule.js";
+import { DismissNotificationRpcHandler } from "./DismissNotificationRpcHandler.js";
+import { SimulatedNotificationsProvider } from "./SimulatedNotificationsProvider.js";
+const SimulatedNotificationsModule = ()=>new NotificationModule((table)=>new SimulatedNotificationsProvider(table), (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)=>{