@vuu-ui/vuu-data-test 4.0.0-alpha.17 → 4.0.0-alpha.19

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.0.0-alpha.17",
+  "version": "4.0.0-alpha.19",
   "main": "./src/index.js",
   "type": "module",
   "author": "heswell",
@@ -10,16 +10,16 @@
     "type-defs": "node ../../scripts/build-type-defs.mjs"
   },
   "dependencies": {
-    "@heswell/module-admin": "1.0.0",
+    "@heswell/module-admin": "1.1.0",
     "@heswell/user-admin": "1.0.1",
-    "@vuu-ui/vuu-data-editing": "4.0.0-alpha.17",
-    "@vuu-ui/vuu-data-local": "4.0.0-alpha.17",
-    "@vuu-ui/vuu-utils": "4.0.0-alpha.17"
+    "@vuu-ui/vuu-data-editing": "4.0.0-alpha.19",
+    "@vuu-ui/vuu-data-local": "4.0.0-alpha.19",
+    "@vuu-ui/vuu-utils": "4.0.0-alpha.19"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-data-types": "4.0.0-alpha.17",
-    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.17",
-    "@vuu-ui/vuu-table-types": "4.0.0-alpha.17"
+    "@vuu-ui/vuu-data-types": "4.0.0-alpha.19",
+    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.19",
+    "@vuu-ui/vuu-table-types": "4.0.0-alpha.19"
   },
   "sideEffects": false,
   "files": [

package/src/core/filter/PermissionFilter.js

@@ -0,0 +1,60 @@
+const allowAll = ()=>true;
+const denyAll = ()=>false;
+const AllowAllPermissionFilter = {
+    createPredicate: ()=>allowAll
+};
+const DenyAllPermissionFilter = {
+    createPredicate: ()=>denyAll
+};
+class RowPermissionFilter {
+    rowPredicate;
+    constructor(rowPredicate){
+        this.rowPredicate = rowPredicate;
+    }
+    createPredicate(columnMap) {
+        let currentRow = [];
+        const rowData = {
+            get: (columnName)=>{
+                const idx = columnMap[columnName];
+                return void 0 === idx ? void 0 : currentRow[idx];
+            }
+        };
+        return (row)=>{
+            currentRow = row;
+            return this.rowPredicate(rowData);
+        };
+    }
+}
+class ContainsPermissionFilter {
+    columnName;
+    allowedValues;
+    constructor(columnName, allowedValues){
+        this.columnName = columnName;
+        this.allowedValues = allowedValues;
+    }
+    createPredicate(columnMap) {
+        const idx = columnMap[this.columnName];
+        if (void 0 === idx || 0 === this.allowedValues.size) return denyAll;
+        const { allowedValues } = this;
+        return (row)=>{
+            const value = row[idx];
+            return null != value && allowedValues.has(String(value));
+        };
+    }
+}
+class PermissionFilterChain {
+    filters;
+    constructor(filters){
+        this.filters = filters;
+    }
+    createPredicate(columnMap) {
+        const predicates = this.filters.map((f)=>f.createPredicate(columnMap));
+        return (row)=>predicates.every((predicate)=>predicate(row));
+    }
+}
+function PermissionFilter(arg, allowedValues) {
+    if ("function" == typeof arg) return new RowPermissionFilter(arg);
+    if ("string" == typeof arg) return new ContainsPermissionFilter(arg, allowedValues ?? new Set());
+    return new PermissionFilterChain(Array.from(arg));
+}
+export { AllowAllPermissionFilter, DenyAllPermissionFilter, PermissionFilter };

package/src/core/filter/PermissionFilteredTable.js

@@ -0,0 +1,59 @@
+import { Table } from "../../Table.js";
+class PermissionFilteredTable extends Table {
+    #attached = false;
+    #indexOfKey;
+    #predicate;
+    #source;
+    constructor(source, predicate){
+        super(source.schema, source.data.filter(predicate), source.map);
+        this.#indexOfKey = source.map[source.schema.key];
+        this.#predicate = predicate;
+        this.#source = source;
+        this.attach();
+    }
+    get source() {
+        return this.#source;
+    }
+    attach() {
+        if (!this.#attached) {
+            this.#source.on("insert", this.handleSourceInsert);
+            this.#source.on("update", this.handleSourceUpdate);
+            this.#source.on("delete", this.handleSourceDelete);
+            this.#attached = true;
+        }
+    }
+    dispose() {
+        if (this.#attached) {
+            this.#source.removeListener("insert", this.handleSourceInsert);
+            this.#source.removeListener("update", this.handleSourceUpdate);
+            this.#source.removeListener("delete", this.handleSourceDelete);
+            this.#attached = false;
+        }
+    }
+    contains(key) {
+        return void 0 !== this.findByKey(key);
+    }
+    handleSourceInsert = (row)=>{
+        if (this.#predicate(row)) this.insert(row);
+    };
+    handleSourceUpdate = (row)=>{
+        const key = row[this.#indexOfKey];
+        const isMember = this.contains(key);
+        const isPermitted = this.#predicate(row);
+        if (isMember && isPermitted) this.replaceRow(row);
+        else if (isMember) this.delete(key);
+        else if (isPermitted) this.insert(row);
+    };
+    handleSourceDelete = (key)=>{
+        if (this.contains(key)) this.delete(key);
+    };
+    replaceRow(row) {
+        const key = row[this.#indexOfKey];
+        const rowIndex = this.data.findIndex((r)=>r[this.#indexOfKey] === key);
+        if (-1 !== rowIndex) {
+            this.data[rowIndex] = row;
+            this.emit("update", row);
+        }
+    }
+}
+export { PermissionFilteredTable };

package/src/core/module/VuuModule.js

@@ -4,6 +4,10 @@ import { TickingArrayDataSource } from "../../TickingArrayDataSource.js";
 import { RuntimeVisualLink } from "../../RuntimeVisualLink.js";
 import ModuleContainer from "./ModuleContainer.js";
 import { sessionTableRow, sessionTableSchema } from "../../session-table-utils.js";
+import { AllowAllPermissionFilter } from "../filter/PermissionFilter.js";
+import { PermissionFilteredTable } from "../filter/PermissionFilteredTable.js";
+import { getCurrentUser } from "../user/CurrentUser.js";
+import TableContainer from "../table/TableContainer.js";
 const assertUpdateIsValid = (schema, column, _data)=>{
     const col = schema.columns.find((col)=>col.name === column);
     if (col) ;
@@ -27,6 +31,7 @@ class VuuModule {
     }
     async beforeSessionSave(_sourceTable, _sessionTable) {}
     async afterSessionSave(_sourceTable, _sessionTable) {}
+    permissionFunctions;
     getTableSchema(tableName) {
         return this.schemas[tableName] ?? this.#sessionTableMap[tableName]?.schema;
     }
@@ -126,9 +131,17 @@ class VuuModule {
         return void 0 === linksForTable ? void 0 : this.getLinks(this.#subscriptionMap, linksForTable);
     };
     createDataSource = (tableName, viewport, config)=>{
+        this.beforeCreateDataSource?.(tableName);
         const columnDescriptors = this.getColumnDescriptors(tableName);
-        const table = this.tables[tableName];
         const sessionTable = this.#sessionTableMap[tableName];
+        const user = getCurrentUser();
+        const permissionFunction = sessionTable ? void 0 : this.permissionFunctions?.[tableName];
+        const viewportId = permissionFunction ? viewport ?? uuid() : viewport;
+        const permissionFilteredTable = permissionFunction ? this.createPermissionFilteredTable(this.tables[tableName], permissionFunction, {
+            id: viewportId,
+            user
+        }) : void 0;
+        const table = permissionFilteredTable ?? this.tables[tableName];
         const vuuModule = this;
         const dataSource = new TickingArrayDataSource({
             ...config,
@@ -139,18 +152,24 @@ class VuuModule {
             menu: this.menus?.[tableName],
             rpcServices: this.getServices(tableName),
             rpcMenuServices: this.getMenuServices(tableName),
-            viewport,
+            viewport: viewportId,
             visualLinkService: this.visualLinkService,
             vuuModule
         });
         dataSource.on("subscribed", this.handlePostSubscribeActivities);
         dataSource.on("unsubscribed", this.unregisterViewport);
+        if (permissionFilteredTable) {
+            dataSource.on("subscribed", ()=>permissionFilteredTable.attach());
+            dataSource.on("unsubscribed", ()=>permissionFilteredTable.dispose());
+        }
         const existingSubscriptions = this.#subscriptionMap.get(tableName);
         const subscription = {
             viewportId: dataSource.viewport,
             dataSource,
             sessionTableName: sessionTable ? tableName : void 0,
-            sourceTableName: this.#sessionSourceTableMap[tableName]
+            sourceTableName: this.#sessionSourceTableMap[tableName],
+            table: table || sessionTable,
+            user
         };
         if (existingSubscriptions) existingSubscriptions.push(subscription);
         else this.#subscriptionMap.set(tableName, [
@@ -158,6 +177,11 @@ class VuuModule {
         ]);
         return dataSource;
     };
+    createPermissionFilteredTable(table, permissionFunction, viewport) {
+        const permissionFilter = permissionFunction(viewport, TableContainer);
+        if (permissionFilter === AllowAllPermissionFilter) return;
+        return new PermissionFilteredTable(table, permissionFilter.createPredicate(table.map));
+    }
     getServices(tableName) {
         const tableServices = this.services?.[tableName];
         const defaultServices = this.includeDefaultServices ? this.#moduleServices : [];

package/src/core/user/CurrentUser.js

@@ -0,0 +1,13 @@
+const DEFAULT_USER = {
+    name: "user",
+    authorizations: []
+};
+let currentUser = DEFAULT_USER;
+const getCurrentUser = ()=>currentUser;
+const setCurrentUser = (user)=>{
+    currentUser = void 0 === user ? DEFAULT_USER : "string" == typeof user ? {
+        name: user,
+        authorizations: []
+    } : user;
+};
+export { getCurrentUser, setCurrentUser };

package/src/index.js

@@ -1,7 +1,11 @@
 export * from "./ArrayProxy.js";
+export * from "./core/filter/PermissionFilter.js";
+export * from "./core/filter/PermissionFilteredTable.js";
 export * from "./core/module/VuuModule.js";
+export * from "./core/user/CurrentUser.js";
 export * from "./local-datasource-provider/LocalDatasourceProvider.js";
 export * from "./makeSuggestions.js";
+export * from "./notifications/index.js";
 export * from "./schemas.js";
 export * from "./simul/index.js";
 export * from "./basket/index.js";

package/src/local-datasource-provider/LocalDatasourceProvider.js

@@ -23,9 +23,10 @@ const createLocalDataSourceProvider = (moduleNames)=>{
     };
     const getServerAPI = async ()=>serverAPI;
     class VuuDataSource {
-        constructor({ aggregations, columns, filterSpec, groupBy, session, sort, table, viewport, visualLink }){
+        constructor({ aggregations, baseFilterSpec, columns, filterSpec, groupBy, session, sort, table, viewport, visualLink }){
             const config = {
                 aggregations,
+                baseFilterSpec,
                 columns,
                 filterSpec,
                 groupBy,

package/src/module-admin/ModuleAdminModule.js

@@ -1,4 +1,4 @@
-import { DEFAULT_MODULE_DEFINITIONS } from "@heswell/module-admin/contracts";
+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";
@@ -12,31 +12,67 @@ 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: "orders",
+        vuuWebsocketUrl: "wss://localhost:8095/websocket-orders",
+        vuuRestUrl: "https://localhost:8447/api/authn",
+        accessRole: "",
+        created: INITIAL_TIMESTAMP,
+        updated: INITIAL_TIMESTAMP
+    }
+];
 const MODULE_ADMIN_INITIAL_SNAPSHOT = {
-    moduleAccessRoles: [
-        {
-            moduleName: "moduleAdmin",
-            role: "module-admin-access"
-        },
-        {
-            moduleName: "userAdmin",
-            role: "user-admin-access"
-        },
-        {
-            moduleName: "basket-trading",
-            role: "basket-trading-access"
-        }
-    ],
-    modules: DEFAULT_MODULE_DEFINITIONS,
-    timestamp: 1710000000000
+    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){
-        super(MODULE_ADMIN_MODULE_NAME);
+    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,
@@ -50,7 +86,35 @@ class ModuleAdminModule extends VuuModule {
     get schemas() {
         return MODULE_ADMIN_TABLE_SCHEMAS;
     }
-    get services() {}
+    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;
     }

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

@@ -11,6 +11,10 @@ const MODULE_ADMIN_TABLE_SCHEMAS = {
                 name: "id",
                 serverDataType: "int"
             },
+            {
+                name: "parentModuleId",
+                serverDataType: "int"
+            },
             {
                 name: "name",
                 serverDataType: "string"
@@ -63,6 +67,10 @@ const MODULE_ADMIN_TABLE_SCHEMAS = {
                 name: "vuuRestUrl",
                 serverDataType: "string"
             },
+            {
+                name: "navIconUrl",
+                serverDataType: "string"
+            },
             ...VUU_DEFAULT_COLUMNS
         ],
         key: "id",

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

@@ -1,37 +1,9 @@
-import { moduleDefinitionsToRows, modulePermissionsFor } from "@heswell/module-admin/contracts";
+import { managedModuleColumnValues, managedModulePermissionValues } from "@heswell/module-admin/contracts";
 const rowsEqual = (left, right)=>left.length === right.length && left.every((value, index)=>value === right[index]);
-const systemValues = (timestamp)=>({
-        vuuCreatedTimestamp: timestamp,
-        vuuMsg: "",
-        vuuUpdatedTimestamp: timestamp
-    });
 const toRow = (table, values)=>table.schema.columns.map(({ name })=>values[name] ?? "");
-const moduleValues = ([id, name, title, description, version, enabled, location, path, mfComponent, mfScope, mfUrl, vuuConnectionId, vuuWebsocketUrl, vuuRestUrl], timestamp)=>({
-        ...systemValues(timestamp),
-        description,
-        enabled,
-        id,
-        location,
-        mfComponent,
-        mfScope,
-        mfUrl,
-        name,
-        path,
-        title,
-        version,
-        vuuConnectionId,
-        vuuRestUrl,
-        vuuWebsocketUrl
-    });
-const permissionValues = ([id, moduleId, role], timestamp)=>({
-        ...systemValues(timestamp),
-        id,
-        module_id: moduleId,
-        role
-    });
 const projectModuleAdminSnapshot = (snapshot, tables)=>({
-        modulePermissions: modulePermissionsFor(snapshot.modules, snapshot.moduleAccessRoles).map((row)=>toRow(tables.modulePermissions, permissionValues(row, snapshot.timestamp))),
-        modules: moduleDefinitionsToRows(snapshot.modules).map((row)=>toRow(tables.modules, moduleValues(row, snapshot.timestamp)))
+        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);

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/types/core/filter/PermissionFilter.d.ts

@@ -0,0 +1,41 @@
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import type { VuuModuleUser } from "../user/CurrentUser";
+import type { ColumnMap } from "@vuu-ui/vuu-utils";
+import type tableContainer from "../table/TableContainer";
+export type TableRow = Array<bigint | VuuRowDataItemType>;
+export type RowPredicate = (row: TableRow) => boolean;
+/**
+ * Read access to a single row, by column name.
+ */
+export interface RowData {
+    get: (columnName: string) => bigint | VuuRowDataItemType | undefined;
+}
+/**
+ * Restricts the rows of a table visible through a viewport, typically
+ * based on the user that owns the viewport. Permission filters are applied
+ * in addition to any client filter.
+ */
+export interface PermissionFilter {
+    /**
+     * Bind this permission filter to the column layout of a table, returning a
+     * predicate that can be evaluated against raw table rows.
+     */
+    createPredicate: (columnMap: ColumnMap) => RowPredicate;
+}
+/**
+ * The subset of viewport state available to a PermissionFunction.
+ */
+export interface PermissionViewport {
+    id: string;
+    user: VuuModuleUser;
+}
+export type TableContainer = typeof tableContainer;
+/**
+ * Creates the PermissionFilter for a viewport. Configured per table on a VuuModule.
+ */
+export type PermissionFunction = (viewport: PermissionViewport, tableContainer: TableContainer) => PermissionFilter;
+export declare const AllowAllPermissionFilter: PermissionFilter;
+export declare const DenyAllPermissionFilter: PermissionFilter;
+export declare function PermissionFilter(rowPredicate: (row: RowData) => boolean): PermissionFilter;
+export declare function PermissionFilter(columnName: string, allowedValues: Set<string>): PermissionFilter;
+export declare function PermissionFilter(filters: Iterable<PermissionFilter>): PermissionFilter;

package/types/core/filter/PermissionFilteredTable.d.ts

@@ -0,0 +1,24 @@
+import { Table } from "../../Table";
+import type { RowPredicate } from "./PermissionFilter";
+/**
+ * A per-viewport view of a source table, containing only those rows that
+ * satisfy a permission predicate. Changes to the source table are mirrored,
+ * an update that moves a row into or out of the permitted set is emitted as
+ * an insert or delete.
+ */
+export declare class PermissionFilteredTable extends Table {
+    #private;
+    constructor(source: Table, predicate: RowPredicate);
+    get source(): Table;
+    /**
+     * Start mirroring changes from the source table. Invoked on construction,
+     * only needs to be called again following dispose.
+     */
+    attach(): void;
+    dispose(): void;
+    private contains;
+    private handleSourceInsert;
+    private handleSourceUpdate;
+    private handleSourceDelete;
+    private replaceRow;
+}

package/types/core/module/VuuModule.d.ts

@@ -2,6 +2,8 @@ import type { DataSourceBase, DataSourceConfig, DataSourceRowWithBigint, DataSou
 import type { VuuMenu, VuuLink, LinkDescriptorWithLabel, VuuRpcMenuResponse, VuuCreateVisualLink, VuuRemoveVisualLink, VuuRpcServiceRequest, RpcResultSuccess, RpcResultError, VuuRpcMenuRequest } from "@vuu-ui/vuu-protocol-types";
 import { Table } from "../../Table";
 import { TickingArrayDataSource } from "../../TickingArrayDataSource";
+import { type PermissionFunction } from "../filter/PermissionFilter";
+import { type VuuModuleUser } from "../user/CurrentUser";
 export interface IVuuModule<T extends string = string> {
     createDataSource: (tableName: T, viewport?: string, config?: DataSourceConfig & {
         session?: SessionDataSourceOverrides;
@@ -28,6 +30,12 @@ type Subscription = {
     dataSource: DataSourceBase<DataSourceRowWithBigint>;
     sessionTableName?: string;
     sourceTableName?: string;
+    /**
+     * The table viewed by this subscription. Where a permission filter applies,
+     * this will be a PermissionFilteredTable
+     */
+    table: Table;
+    user: VuuModuleUser;
 };
 export declare abstract class VuuModule<T extends string = string> implements IVuuModule<T> {
     #private;
@@ -41,6 +49,16 @@ export declare abstract class VuuModule<T extends string = string> implements IV
     protected get includeDefaultServices(): boolean;
     protected beforeSessionSave(_sourceTable: Table, _sessionTable: Table): Promise<void>;
     protected afterSessionSave(_sourceTable: Table, _sessionTable: Table): Promise<void>;
+    /**
+     * Optional, per table. Restricts the rows visible to each viewport, based on
+     * the viewport (and the user who owns it).
+     */
+    protected permissionFunctions?: Partial<Record<T, PermissionFunction>>;
+    /**
+     * Invoked before a dataSource is created. Can be used, for example, to
+     * lazily start a data provider.
+     */
+    protected beforeCreateDataSource?(tableName: T): void;
     getTableSchema(tableName: string): Record<T, Readonly<TableSchema>>[T];
     getTableList(): string[];
     protected handlePostSubscribeActivities: ({ clientViewportId, tableSchema, }: DataSourceSubscribedMessage) => void;
@@ -54,6 +72,7 @@ export declare abstract class VuuModule<T extends string = string> implements IV
     createDataSource: (tableName: T, viewport?: string, config?: DataSourceConfig & {
         session?: SessionDataSourceOverrides;
     }) => DataSourceBase<DataSourceRowWithBigint>;
+    private createPermissionFilteredTable;
     getServices(tableName: T): RpcService[];
     getMenuServices(tableName: T): RpcMenuService[];
     protected get sessionTableMap(): SessionTableMap;

package/types/core/user/CurrentUser.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The user that owns a viewport, as seen by permission functions and
+ * rpc services.
+ */
+export interface VuuModuleUser {
+    authorizations: string[];
+    name: string;
+}
+export declare const getCurrentUser: () => VuuModuleUser;
+/**
+ * Applies to viewports created after the change. Pass undefined to restore
+ * the default user.
+ */
+export declare const setCurrentUser: (user?: string | VuuModuleUser) => void;

package/types/index.d.ts

@@ -1,9 +1,13 @@
 export * from "./ArrayProxy";
+export * from "./core/filter/PermissionFilter";
+export * from "./core/filter/PermissionFilteredTable";
 export * from "./core/module/VuuModule";
 export { ensureVuuModule } from "./core/module/ModuleContainer";
+export * from "./core/user/CurrentUser";
 export { default as tableContainer } from "./core/table/TableContainer";
 export * from "./local-datasource-provider/LocalDatasourceProvider";
 export * from "./makeSuggestions";
+export * from "./notifications";
 export * from "./schemas";
 export * from "./simul";
 export * from "./basket";

package/types/module-admin/ModuleAdminModule.d.ts

@@ -1,13 +1,21 @@
+import { type ManagedModule } from "@heswell/module-admin/contracts";
 import type { TableSchema } from "@vuu-ui/vuu-data-types";
-import { VuuModule } from "../core/module/VuuModule";
+import { VuuModule, type RpcService } from "../core/module/VuuModule";
 import { type Table } from "../Table";
 import { type ModuleAdminTableName } from "./module-admin-schemas";
 import { type ModuleAdminSnapshot } from "./snapshot-projection";
 type ModuleAdminTables = Record<ModuleAdminTableName, Table>;
 export declare const MODULE_ADMIN_INITIAL_SNAPSHOT: ModuleAdminSnapshot;
+/**
+ * In-browser MODULE_DISCOVERY server. Supports the module admin RPCs from
+ * `@heswell/module-admin/contracts` on both tables; state is held in memory.
+ */
 export declare class ModuleAdminModule extends VuuModule<ModuleAdminTableName> {
     #private;
-    constructor(snapshot?: ModuleAdminSnapshot);
+    private readonly now;
+    constructor(snapshot?: ModuleAdminSnapshot, now?: () => number);
+    /** Current module state. */
+    get modules(): readonly ManagedModule[];
     get menus(): {
         modulePermissions: undefined;
         modules: undefined;
@@ -15,7 +23,8 @@ export declare class ModuleAdminModule extends VuuModule<ModuleAdminTableName> {
     protected get includeDefaultServices(): boolean;
     get menuServices(): undefined;
     get schemas(): Record<ModuleAdminTableName, Readonly<TableSchema>>;
-    get services(): undefined;
+    private service;
+    get services(): Record<ModuleAdminTableName, RpcService[]>;
     get tables(): ModuleAdminTables;
     get visualLinks(): undefined;
 }

package/types/module-admin/index.d.ts

@@ -1,4 +1,4 @@
 export { ModuleAdminModule, MODULE_ADMIN_INITIAL_SNAPSHOT, moduleAdminModule, } from "./ModuleAdminModule";
 export { MODULE_ADMIN_MODULE_NAME, MODULE_ADMIN_TABLE_SCHEMAS, type ModuleAdminTableName, } from "./module-admin-schemas";
 export { projectModuleAdminSnapshot, reconcileModuleAdminTables, type ModuleAdminSnapshot, } from "./snapshot-projection";
-export type { ModuleAccessRole, ModuleDefinition, ModulePermissionRow, ModuleRow, } from "@heswell/module-admin/contracts";
+export type { ManagedModule, ModuleAccessRole, ModuleConfig, ModuleDefinition, ModulePermissionRow, ModuleRow, } from "@heswell/module-admin/contracts";

package/types/module-admin/snapshot-projection.d.ts

@@ -1,14 +1,13 @@
-import { type ModuleAccessRole, type ModuleDefinition } from "@heswell/module-admin/contracts";
+import { type ManagedModule } from "@heswell/module-admin/contracts";
 import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
 import type { Table } from "../Table";
 import type { ModuleAdminTableName } from "./module-admin-schemas";
 type Row = Array<bigint | VuuRowDataItemType>;
 type Tables = Record<ModuleAdminTableName, Table>;
 export type ModuleAdminSnapshot = {
-    moduleAccessRoles: readonly ModuleAccessRole[];
-    modules: readonly ModuleDefinition[];
-    timestamp: number;
+    modules: readonly ManagedModule[];
 };
 export declare const projectModuleAdminSnapshot: (snapshot: ModuleAdminSnapshot, tables: Tables) => Record<ModuleAdminTableName, Row[]>;
+/** Brings the tables into line with the snapshot, emitting row-level updates. */
 export declare const reconcileModuleAdminTables: (snapshot: ModuleAdminSnapshot, tables: Tables) => void;
 export {};

package/types/notifications/NotificationModule.d.ts

@@ -0,0 +1,39 @@
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+import { type RpcService, VuuModule } from "../core/module/VuuModule";
+import type { PermissionFunction } from "../core/filter/PermissionFilter";
+import { type Table } from "../Table";
+import { type ColumnDefinition } from "./NotificationsSchema";
+export type NotificationsTableName = "notifications";
+/**
+ * Source of notifications. Started when the first dataSource is
+ * created for the notifications table, or explicitly via module.start().
+ */
+export interface NotificationsProvider {
+    start: () => void;
+    stop: () => void;
+}
+export type NotificationsProviderFactory = (table: Table) => NotificationsProvider;
+export type NotificationsServiceFactory = (table: Table, module: NotificationModule) => RpcService[];
+/**
+ * A generic Notifications module, exposing a single 'notifications' table.
+ * The source of notifications (provider), the rows visible to each user
+ * (permissionFunction) and any rpc services (serviceFactory) are supplied
+ * by the consumer. Any additional columns are appended to the generic
+ * notification columns (see NotificationsSchema).
+ */
+export declare class NotificationModule extends VuuModule<NotificationsTableName> {
+    #private;
+    static readonly NAME = "NOTIFICATIONS";
+    static readonly TABLE_NAME: "notifications";
+    constructor(providerFactory: NotificationsProviderFactory, permissionFunction: PermissionFunction, serviceFactory: NotificationsServiceFactory, ...additionalColumns: ColumnDefinition[]);
+    protected beforeCreateDataSource(): void;
+    get isRunning(): boolean;
+    start(): void;
+    stop(): void;
+    get menus(): undefined;
+    get menuServices(): undefined;
+    get schemas(): Record<"notifications", TableSchema>;
+    get services(): Record<"notifications", RpcService[]>;
+    get tables(): Record<"notifications", Table>;
+    get visualLinks(): undefined;
+}

package/types/notifications/NotificationsSchema.d.ts

@@ -0,0 +1,20 @@
+import type { SchemaColumn } from "@vuu-ui/vuu-data-types";
+/**
+ * Accepts either a SchemaColumn or a column definition in the Scala server
+ * 'name:Type' format, e.g. "source:String", "priority:Int".
+ */
+export type ColumnDefinition = SchemaColumn | string;
+export declare const toColumn: (columnDefinition: ColumnDefinition) => SchemaColumn;
+export declare const NotificationsSchema: {
+    Id: string;
+    Type: string;
+    ExpiryTime: string;
+    Title: string;
+    Message: string;
+    Level: string;
+    Audience: string;
+    /**
+     * The generic notification columns, plus any additional columns.
+     */
+    allFrom: (...additionalColumns: ColumnDefinition[]) => SchemaColumn[];
+};

package/types/notifications/index.d.ts

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

package/types/notifications/simulated/DismissNotificationRpcHandler.d.ts

@@ -0,0 +1,8 @@
+import type { RpcService } from "../../core/module/VuuModule";
+import type { Table } from "../../Table";
+import type { NotificationModule } from "../NotificationModule";
+/**
+ * Marks the notifications selected in the requesting viewport as dismissed
+ * by the user that owns the viewport.
+ */
+export declare const DismissNotificationRpcHandler: (table: Table, module: NotificationModule) => RpcService[];

package/types/notifications/simulated/SimulatedNotificationsModule.d.ts

@@ -0,0 +1,2 @@
+import { NotificationModule } from "../NotificationModule";
+export declare const SimulatedNotificationsModule: () => NotificationModule;

package/types/notifications/simulated/SimulatedNotificationsProvider.d.ts

@@ -0,0 +1,21 @@
+import type { Table } from "../../Table";
+import type { NotificationsProvider } from "../NotificationModule";
+/**
+ * Minimal implementation of the subset of Java String.format used by
+ * the message templates: %d, %0nd and %%. Args are consumed in order.
+ */
+export declare const formatMessage: (format: string, ...args: number[]) => string;
+/**
+ * Generates random notifications. Seeds an initial set of notifications on
+ * start then, on each cycle, deletes expired notifications and adds a new
+ * notification if fewer than the maximum are active.
+ */
+export declare class SimulatedNotificationsProvider implements NotificationsProvider {
+    #private;
+    constructor(table: Table);
+    start(): void;
+    stop(): void;
+    runOnce: () => void;
+    private generateRandomNotification;
+    private toDataRow;
+}

package/types/notifications/simulated/notificationsModule.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Simulated notifications. The provider starts generating notifications
+ * when the first dataSource is created for the notifications table.
+ */
+export declare const notificationsModule: import("..").NotificationModule;