@vuu-ui/vuu-data-test 4.0.0-alpha.1 → 4.0.0-alpha.10

package/README.md

@@ -0,0 +1,8 @@
+# `@vuu-ui/vuu-data-test`
+
+## Admin test module dependencies
+
+The `USER_ADMIN` and `MODULE_DISCOVERY` test modules use the published
+`@heswell/user-admin` and `@heswell/module-admin` packages. Standard
+`npm install` setup is sufficient. Browser code imports only the browser-safe
+`contracts` subpath for module-admin.

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.0.0-alpha.1",
+  "version": "4.0.0-alpha.10",
   "main": "./src/index.js",
   "type": "module",
   "author": "heswell",
@@ -10,15 +10,16 @@
     "type-defs": "node ../../scripts/build-type-defs.mjs"
   },
   "dependencies": {
-    "@vuu-ui/vuu-data-editing": "4.0.0-alpha.1",
-    "@vuu-ui/vuu-data-local": "4.0.0-alpha.1",
-    "@vuu-ui/core": "4.0.0-alpha.1",
-    "@vuu-ui/vuu-utils": "4.0.0-alpha.1"
+    "@heswell/module-admin": "1.0.0",
+    "@heswell/user-admin": "1.0.1",
+    "@vuu-ui/vuu-data-editing": "4.0.0-alpha.10",
+    "@vuu-ui/vuu-data-local": "4.0.0-alpha.10",
+    "@vuu-ui/vuu-utils": "4.0.0-alpha.10"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.1",
-    "@vuu-ui/vuu-data-types": "4.0.0-alpha.1",
-    "@vuu-ui/vuu-table-types": "4.0.0-alpha.1"
+    "@vuu-ui/vuu-data-types": "4.0.0-alpha.10",
+    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.10",
+    "@vuu-ui/vuu-table-types": "4.0.0-alpha.10"
   },
   "sideEffects": false,
   "files": [
@@ -29,6 +30,7 @@
   "exports": {
     ".": {
       "import": "./src/index.js",
+      "default": "./src/index.js",
       "types": "./types/index.d.ts"
     }
   },

package/src/Table.js

@@ -20,7 +20,7 @@ class Table extends EventEmitter {
     }
     buildIndex() {
         for(let i = 0; i < this.#data.length; i++){
-            const key = this.#data[i][this.#indexOfKey];
+            const key = String(this.#data[i][this.#indexOfKey]);
             this.#index.set(key, i);
         }
     }
@@ -41,7 +41,7 @@ class Table extends EventEmitter {
         if (-1 !== index) {
             this.#index.delete(key);
             this.#data.splice(index, 1);
-            for(let i = index; i < this.#data.length; i++)this.#index.set(this.#data[i][this.#indexOfKey], i);
+            for(let i = index; i < this.#data.length; i++)this.#index.set(String(this.#data[i][this.#indexOfKey]), i);
             if (emitEvent) this.emit("delete", key);
         } else throw Error(`[Table] delete key ${key} not found`);
     }
@@ -51,7 +51,7 @@ class Table extends EventEmitter {
         row[this.#dataMap.vuuUpdatedTimestamp] = createdTime;
         row[this.#dataMap.vuuCreatedTimestamp] = createdTime;
         this.#data.push(row);
-        const key = row[this.#indexOfKey];
+        const key = String(row[this.#indexOfKey]);
         this.#index.set(key, index);
         if (emitEvent) this.emit("insert", row);
     }
@@ -60,7 +60,7 @@ class Table extends EventEmitter {
         return this.#data[index];
     }
     update(key, columnName, value) {
-        const rowIndex = this.#data.findIndex((row)=>row[this.#indexOfKey] === key);
+        const rowIndex = this.#data.findIndex((row)=>String(row[this.#indexOfKey]) === key);
         const colIndex = this.#dataMap[columnName];
         if (-1 !== rowIndex) {
             const row = this.#data[rowIndex];
@@ -77,7 +77,7 @@ class Table extends EventEmitter {
     }
     updateRow(row) {
         const key = row[this.#indexOfKey];
-        const rowIndex = this.#data.findIndex((row)=>row[this.#indexOfKey] === key);
+        const rowIndex = this.#data.findIndex((row)=>String(row[this.#indexOfKey]) === String(key));
         if (-1 !== rowIndex) {
             const tsIndex = this.#dataMap.vuuUpdatedTimestamp;
             const lastUpdated = Date.now();

package/src/TickingArrayDataSource.js

@@ -132,8 +132,10 @@ class TickingArrayDataSource extends ArrayDataSource {
                 data: rowData
             }
         });
-        if (isRpcSuccess(response)) return true;
-        return response?.errorMessage ?? "addRow failed";
+        return response ?? {
+            type: "ERROR_RESULT",
+            errorMessage: "addRow failed"
+        };
     };
     deleteRow = async (key, mode = "hard")=>{
         const response = await this.rpcRequest({

package/src/core/module/ModuleContainer.js

@@ -8,6 +8,9 @@ class ModuleContainer {
     register(module) {
         this.#modules.set(module.name, module);
     }
+    has(name) {
+        return this.#modules.has(name);
+    }
     get(name) {
         const module = this.#modules.get(name);
         if (module) return module;
@@ -18,4 +21,9 @@ class ModuleContainer {
     }
 }
 var module_ModuleContainer = ModuleContainer.instance;
+const ensureVuuModule = (module)=>{
+    if (!ModuleContainer.instance.has(module.name)) ModuleContainer.instance.register(module);
+    return module;
+};
 export default module_ModuleContainer;
+export { ensureVuuModule };

package/src/core/module/VuuModule.js

@@ -22,6 +22,11 @@ class VuuModule {
         this.#sessionTableMessageColumn = sessionTableMessageColumn;
         ModuleContainer.register(this);
     }
+    get includeDefaultServices() {
+        return true;
+    }
+    async beforeSessionSave(_sourceTable, _sessionTable) {}
+    async afterSessionSave(_sourceTable, _sessionTable) {}
     getTableSchema(tableName) {
         return this.schemas[tableName] ?? this.#sessionTableMap[tableName]?.schema;
     }
@@ -155,8 +160,9 @@ class VuuModule {
     };
     getServices(tableName) {
         const tableServices = this.services?.[tableName];
-        if (Array.isArray(tableServices)) return this.#moduleServices.concat(tableServices);
-        return this.#moduleServices;
+        const defaultServices = this.includeDefaultServices ? this.#moduleServices : [];
+        if (Array.isArray(tableServices)) return defaultServices.concat(tableServices);
+        return defaultServices;
     }
     getMenuServices(tableName) {
         const tableServices = this.menuServices?.[tableName];
@@ -212,13 +218,9 @@ class VuuModule {
             if (sessionTable) {
                 const { dataSource } = this.getSubscriptionByViewport(viewPortId);
                 const selectedRowIds = dataSource.getSelectedRowIds();
-                const deletedKeys = [];
                 if (selectedRowIds.length > 0) {
-                    for (const key of selectedRowIds){
-                        if ("soft" === mode) sessionTable.update(key, "vuuAction", "deleteRow");
-                        else sessionTable.delete(key);
-                        deletedKeys.push(key);
-                    }
+                    for (const key of selectedRowIds)if ("soft" === mode) sessionTable.update(key, "vuuAction", "deleteRow");
+                    else sessionTable.delete(key);
                     dataSource.select?.({
                         type: "DESELECT_ALL"
                     });
@@ -226,7 +228,7 @@ class VuuModule {
                 return {
                     type: "SUCCESS_RESULT",
                     data: {
-                        deletedKeys
+                        deletedKeys: selectedRowIds
                     }
                 };
             }
@@ -498,6 +500,14 @@ class VuuModule {
                     data: void 0
                 };
                 {
+                    try {
+                        await this.beforeSessionSave(sourceTable, sessionTable);
+                    } catch (error) {
+                        return {
+                            errorMessage: error instanceof Error ? error.message : "Unable to prepare session changes",
+                            type: "ERROR_RESULT"
+                        };
+                    }
                     let rejectedCount = 0;
                     const vuuMsgIdx = sessionTable.map[this.#sessionTableMessageColumn];
                     const actionIdx = sessionTable.map.vuuAction;
@@ -532,6 +542,14 @@ class VuuModule {
                         errorMessage: "stale update",
                         type: "ERROR_RESULT"
                     };
+                    try {
+                        await this.afterSessionSave(sourceTable, sessionTable);
+                    } catch (error) {
+                        return {
+                            errorMessage: error instanceof Error ? error.message : "Unable to finalize session changes",
+                            type: "ERROR_RESULT"
+                        };
+                    }
                     return {
                         type: "SUCCESS_RESULT",
                         data: void 0

package/src/core/table/TableContainer.js

@@ -10,7 +10,7 @@ class TableContainer {
         return TableContainer.#instance;
     }
     #tables = new Map();
-    createTable = (schema, data, dataMap, updateGenerator)=>{
+    createTable = (schema, data = [], dataMap = buildDataColumnMapFromSchema(schema), updateGenerator)=>{
         const table = new Table(schema, data, dataMap, updateGenerator);
         this.addTable(table);
         return table;

package/src/index.js

@@ -5,8 +5,11 @@ export * from "./makeSuggestions.js";
 export * from "./schemas.js";
 export * from "./simul/index.js";
 export * from "./basket/index.js";
+export * from "./module-admin/index.js";
+export * from "./user-admin/index.js";
 export * from "./test/index.js";
 export * from "./TickingArrayDataSource.js";
 export * from "./vuu-row-generator.js";
+export { ensureVuuModule } from "./core/module/ModuleContainer.js";
 export { default as tableContainer } from "./core/table/TableContainer.js";
 export { Table, buildDataColumnMap, buildDataColumnMapFromSchema } from "./Table.js";

package/src/module-admin/ModuleAdminModule.js

@@ -0,0 +1,60 @@
+import { DEFAULT_MODULE_DEFINITIONS } 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 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
+};
+class ModuleAdminModule extends VuuModule {
+    #tables;
+    constructor(snapshot = MODULE_ADMIN_INITIAL_SNAPSHOT){
+        super(MODULE_ADMIN_MODULE_NAME);
+        this.#tables = createTables();
+        reconcileModuleAdminTables(snapshot, this.#tables);
+    }
+    get menus() {
+        return {
+            modulePermissions: void 0,
+            modules: void 0
+        };
+    }
+    get includeDefaultServices() {
+        return false;
+    }
+    get menuServices() {}
+    get schemas() {
+        return MODULE_ADMIN_TABLE_SCHEMAS;
+    }
+    get 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,99 @@
+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: "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"
+            },
+            ...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,57 @@
+import { moduleDefinitionsToRows, modulePermissionsFor } 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)))
+    });
+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/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)=>{