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

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.0.0-alpha.10",
+  "version": "4.0.0-alpha.11",
   "main": "./src/index.js",
   "type": "module",
   "author": "heswell",
@@ -12,14 +12,14 @@
   "dependencies": {
     "@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"
+    "@vuu-ui/vuu-data-editing": "4.0.0-alpha.11",
+    "@vuu-ui/vuu-data-local": "4.0.0-alpha.11",
+    "@vuu-ui/vuu-utils": "4.0.0-alpha.11"
   },
   "devDependencies": {
-    "@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"
+    "@vuu-ui/vuu-data-types": "4.0.0-alpha.11",
+    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.11",
+    "@vuu-ui/vuu-table-types": "4.0.0-alpha.11"
   },
   "sideEffects": false,
   "files": [

package/src/user-admin/UserAdminModule.js

@@ -65,6 +65,19 @@ const parseAssignments = (value)=>{
     if (!Array.isArray(parsed) || parsed.some((assignment)=>!isRecord(assignment) || "string" != typeof assignment.accessRole || 0 === assignment.accessRole.length || "string" != typeof assignment.groupId || 0 === assignment.groupId.length || Object.keys(assignment).some((name)=>"accessRole" !== name && "groupId" !== name))) throw new Error("assignments must be a JSON array of accessRole and groupId strings");
     return parsed;
 };
+const parseSessionRoleAssignments = (value)=>{
+    if ("string" != typeof value) throw new Error("role_assignments must be a serialized array");
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    } catch  {
+        throw new Error("role_assignments must be a valid JSON array");
+    }
+    if (!Array.isArray(parsed) || parsed.some((roleId)=>"string" != typeof roleId || !roleId)) throw new Error("role_assignments must be an array of role ID strings");
+    return [
+        ...new Set(parsed)
+    ];
+};
 const parseSessionPermissions = (value)=>{
     if ("string" != typeof value) throw new Error("permissions must be a serialized array");
     let parsed;
@@ -206,17 +219,32 @@ class UserAdminModule extends VuuModule {
     }
     createSessionTable(sourceTable, sessionTableName, editSessionMode, dataSource, sessionType) {
         const sessionTable = super.createSessionTable(sourceTable, sessionTableName, editSessionMode, dataSource, sessionType);
-        if ("users" !== sourceTable.name) return sessionTable;
-        const sessionSchema = {
-            ...sessionTable.schema,
-            columns: sessionTable.schema.columns.concat({
+        const extraColumns = "users" === sourceTable.name ? [
+            {
                 name: "permissions",
                 serverDataType: "string"
-            })
+            }
+        ] : "groups" === sourceTable.name ? [
+            {
+                name: "group_name",
+                serverDataType: "string"
+            },
+            {
+                name: "role_assignments",
+                serverDataType: "string"
+            }
+        ] : [];
+        const columnsToAdd = extraColumns.filter(({ name })=>!sessionTable.schema.columns.some((column)=>column.name === name));
+        if (0 === columnsToAdd.length) return sessionTable;
+        const sessionSchema = {
+            ...sessionTable.schema,
+            columns: sessionTable.schema.columns.concat(columnsToAdd)
         };
-        return new Table(sessionSchema, sessionTable.data.map((row)=>row.concat("")), buildDataColumnMapFromSchema(sessionSchema));
+        return new Table(sessionSchema, sessionTable.data.map((row)=>row.concat(columnsToAdd.map(()=>""))), buildDataColumnMapFromSchema(sessionSchema));
     }
     async beforeSessionSave(sourceTable, sessionTable) {
+        if ("roles" === sourceTable.name) return void await this.saveClientRolesFromSession(sessionTable);
+        if ("groups" === sourceTable.name) return void await this.saveGroupsFromSession(sessionTable);
         if ("users" !== sourceTable.name) return;
         const permissionsIndex = sessionTable.map.permissions;
         const actionIndex = sessionTable.map.vuuAction;
@@ -230,8 +258,135 @@ class UserAdminModule extends VuuModule {
             if ("string" == typeof row[permissionsIndex] && "" !== row[permissionsIndex]) await this.store.setUserModuleAccess(userId, parseSessionPermissions(row[permissionsIndex]));
         }
     }
-    async afterSessionSave(sourceTable) {
-        if ("users" === sourceTable.name) await this.reconcile();
+    async afterSessionSave(sourceTable, sessionTable) {
+        const roleCreationSaved = "roles" === sourceTable.name && sessionTable.data.some((row)=>"addRow" === row[sessionTable.map.vuuAction] && "client role created" === row[sessionTable.map.vuuMsg]);
+        const groupChangesSaved = "groups" === sourceTable.name && sessionTable.data.some((row)=>"group created" === row[sessionTable.map.vuuMsg] || "group roles updated" === row[sessionTable.map.vuuMsg]);
+        if ("users" === sourceTable.name || roleCreationSaved || groupChangesSaved) await this.reconcile();
+    }
+    async saveGroupsFromSession(sessionTable) {
+        const actionIndex = sessionTable.map.vuuAction;
+        const messageIndex = sessionTable.map.vuuMsg;
+        const keyIndex = sessionTable.map[sessionTable.schema.key];
+        const groupIdIndex = sessionTable.map.group_id;
+        const groupNameIndex = sessionTable.map.group_name;
+        const roleAssignmentsIndex = sessionTable.map.role_assignments;
+        for (const row of sessionTable.data)if ("addRow" !== row[actionIndex] || row[messageIndex]) {
+            if ("editCell" === row[actionIndex] && "string" == typeof row[roleAssignmentsIndex] && "" !== row[roleAssignmentsIndex]) {
+                const groupId = requiredString({
+                    group_id: row[groupIdIndex]
+                }, "group_id");
+                const roleIds = parseSessionRoleAssignments(row[roleAssignmentsIndex]);
+                await this.saveGroupRoleAssignments(groupId, roleIds, await this.store.snapshot());
+                sessionTable.update(String(row[keyIndex]), "vuuMsg", "group roles updated");
+            }
+        } else {
+            const name = requiredString({
+                group_name: row[groupNameIndex]
+            }, "group_name").trim();
+            if (!name) throw new Error("group_name must be a non-empty string");
+            const roleIds = parseSessionRoleAssignments(row[roleAssignmentsIndex]);
+            const before = await this.store.snapshot();
+            this.resolveGroupRoleAssignments(roleIds, before);
+            const existingGroupIds = new Set(before.groups.map(({ id })=>id));
+            await this.store.addGroup({
+                name
+            });
+            const snapshot = await this.store.snapshot();
+            const group = snapshot.groups.find(({ id, name: groupName })=>!existingGroupIds.has(id) && groupName === name);
+            if (!group) throw new Error("Created group could not be found");
+            await this.saveGroupRoleAssignments(group.id, roleIds, snapshot);
+            sessionTable.update(String(row[keyIndex]), "vuuMsg", "group created");
+        }
+    }
+    async saveGroupRoleAssignments(groupId, desiredRoleIds, snapshot) {
+        if (!snapshot.groups.some(({ id })=>id === groupId)) throw new Error(`User admin group not found: ${groupId}`);
+        const groupRoles = snapshot.groupRoles.filter(({ group })=>group.id === groupId);
+        const roleAssignmentsById = new Map(snapshot.clientRoles.map((assignment)=>[
+                assignment.role.id,
+                assignment
+            ]));
+        const desiredRoleSet = new Set(desiredRoleIds);
+        const currentAssignments = groupRoles.map(({ role })=>{
+            const assignment = roleAssignmentsById.get(role.id);
+            if (!assignment) throw new Error(`Assigned user admin role no longer exists: ${role.id}`);
+            return assignment;
+        });
+        const currentRoleSet = new Set(groupRoles.map(({ role })=>role.id));
+        const desiredAssignments = this.resolveGroupRoleAssignments(desiredRoleIds, snapshot);
+        for (const assignment of currentAssignments)if (!desiredRoleSet.has(assignment.role.id)) {
+            const clientRef = assignment.role.clientRole && assignment.client?.clientId ? {
+                clientKey: assignment.client.clientId
+            } : void 0;
+            await this.store.removeRoleFromGroup({
+                groupId
+            }, {
+                roleId: assignment.role.id
+            }, clientRef);
+        }
+        for (const assignment of desiredAssignments)if (!currentRoleSet.has(assignment.role.id)) {
+            const clientRef = assignment.role.clientRole && assignment.client?.clientId ? {
+                clientKey: assignment.client.clientId
+            } : void 0;
+            await this.store.addRoleToGroup({
+                groupId
+            }, {
+                roleId: assignment.role.id
+            }, clientRef);
+        }
+    }
+    resolveGroupRoleAssignments(roleIds, snapshot) {
+        const roleAssignmentsById = new Map(snapshot.clientRoles.map((assignment)=>[
+                assignment.role.id,
+                assignment
+            ]));
+        return roleIds.map((roleId)=>{
+            const assignment = roleAssignmentsById.get(roleId);
+            if (!assignment) throw new Error(`User admin role not found: ${roleId}`);
+            if (assignment.role.clientRole && !assignment.client?.clientId) throw new Error(`User admin client role has no owning client: ${roleId}`);
+            return assignment;
+        });
+    }
+    async saveClientRolesFromSession(sessionTable) {
+        const actionIndex = sessionTable.map.vuuAction;
+        const messageIndex = sessionTable.map.vuuMsg;
+        const keyIndex = sessionTable.map[sessionTable.schema.key];
+        const snapshot = await this.store.snapshot();
+        const clientsById = new Map(snapshot.clients.map((client)=>[
+                client.id,
+                client
+            ]));
+        const pendingRoles = [
+            ...sessionTable.data
+        ].flatMap((row)=>{
+            if ("addRow" !== row[actionIndex] || row[messageIndex]) return [];
+            const params = Object.fromEntries(sessionTable.schema.columns.map(({ name })=>[
+                    name,
+                    row[sessionTable.map[name]]
+                ]));
+            const roleName = requiredString(params, "role_name").trim();
+            if (!roleName) throw new Error("role_name must be a non-empty string");
+            const clientId = requiredString(params, "client_id");
+            const clientIdentifier = requiredString(params, "client_identifier");
+            const client = clientsById.get(clientId);
+            if (!client || client.clientId !== clientIdentifier) throw new Error("client_id and client_identifier must identify the same client");
+            return [
+                {
+                    client,
+                    description: optionalString(params, "description") ?? "",
+                    roleName,
+                    row
+                }
+            ];
+        });
+        for (const { client, description, roleName, row } of pendingRoles){
+            await this.store.addClientRole({
+                clientKey: client.clientId
+            }, {
+                description,
+                name: roleName
+            });
+            sessionTable.update(String(row[keyIndex]), "vuuMsg", "client role created");
+        }
     }
     mutation = (rpcName, mutate)=>async (request)=>{
             try {

package/src/user-admin/initialSnapshot.js

@@ -6,6 +6,34 @@ const USER_ADMIN_INITIAL_SNAPSHOT = {
             enabled: true,
             id: "client-portal",
             name: "VUU Portal"
+        },
+        {
+            clientId: "vuu-user-admin",
+            description: "User administration",
+            enabled: true,
+            id: "client-user-admin",
+            name: "User Admin"
+        },
+        {
+            clientId: "vuu-basket-trading",
+            description: "Basket trading",
+            enabled: true,
+            id: "client-basket-trading",
+            name: "Basket Trading"
+        },
+        {
+            clientId: "vuu-module-admin",
+            description: "Module administration",
+            enabled: true,
+            id: "client-module-admin",
+            name: "Module Admin"
+        },
+        {
+            clientId: "vuu-feature-filter-table",
+            description: "Instrument tables",
+            enabled: true,
+            id: "client-feature-filter-table",
+            name: "Instruments"
         }
     ],
     clientRoles: [
@@ -67,13 +95,13 @@ const USER_ADMIN_INITIAL_SNAPSHOT = {
         },
         {
             client: {
-                clientId: "vuu-portal",
-                id: "client-portal",
-                name: "VUU Portal"
+                clientId: "vuu-user-admin",
+                id: "client-user-admin",
+                name: "User Admin"
             },
             role: {
                 clientRole: true,
-                containerId: "client-portal",
+                containerId: "client-user-admin",
                 id: "role-user-admin-admin",
                 name: "user-admin-admin",
                 roleDisplayName: "admin"
@@ -81,13 +109,13 @@ const USER_ADMIN_INITIAL_SNAPSHOT = {
         },
         {
             client: {
-                clientId: "vuu-portal",
-                id: "client-portal",
-                name: "VUU Portal"
+                clientId: "vuu-module-admin",
+                id: "client-module-admin",
+                name: "Module Admin"
             },
             role: {
                 clientRole: true,
-                containerId: "client-portal",
+                containerId: "client-module-admin",
                 id: "role-module-admin-admin",
                 name: "module-admin-admin",
                 roleDisplayName: "admin"
@@ -95,29 +123,17 @@ const USER_ADMIN_INITIAL_SNAPSHOT = {
         },
         {
             client: {
-                clientId: "vuu-portal",
-                id: "client-portal",
-                name: "VUU Portal"
+                clientId: "vuu-basket-trading",
+                id: "client-basket-trading",
+                name: "Basket Trading"
             },
             role: {
                 clientRole: true,
-                containerId: "client-portal",
+                containerId: "client-basket-trading",
                 id: "role-basket-trading-trade",
                 name: "basket-trading-trade",
                 roleDisplayName: "trade"
             }
-        },
-        {
-            client: {
-                clientId: "realm",
-                id: "realm",
-                name: "Realm"
-            },
-            role: {
-                id: "role-admin",
-                name: "admin",
-                roleDisplayName: "admin"
-            }
         }
     ],
     groupRoles: [
@@ -225,9 +241,9 @@ const USER_ADMIN_INITIAL_SNAPSHOT = {
         },
         {
             client: {
-                clientId: "vuu-portal",
-                id: "client-portal",
-                name: "VUU Portal"
+                clientId: "vuu-user-admin",
+                id: "client-user-admin",
+                name: "User Admin"
             },
             group: {
                 id: "group-user-admin-admin",
@@ -261,9 +277,9 @@ const USER_ADMIN_INITIAL_SNAPSHOT = {
         },
         {
             client: {
-                clientId: "vuu-portal",
-                id: "client-portal",
-                name: "VUU Portal"
+                clientId: "vuu-module-admin",
+                id: "client-module-admin",
+                name: "Module Admin"
             },
             group: {
                 id: "group-module-admin-admin",
@@ -297,9 +313,9 @@ const USER_ADMIN_INITIAL_SNAPSHOT = {
         },
         {
             client: {
-                clientId: "vuu-portal",
-                id: "client-portal",
-                name: "VUU Portal"
+                clientId: "vuu-basket-trading",
+                id: "client-basket-trading",
+                name: "Basket Trading"
             },
             group: {
                 id: "group-basket-trading-trade",
@@ -312,19 +328,6 @@ const USER_ADMIN_INITIAL_SNAPSHOT = {
                 name: "basket-trading-trade",
                 roleDisplayName: "trade"
             }
-        },
-        {
-            group: {
-                id: "group-admins",
-                name: "administrators",
-                groupDisplayName: "administrators",
-                path: "/vuu/administrators"
-            },
-            role: {
-                id: "role-admin",
-                name: "admin",
-                roleDisplayName: "admin"
-            }
         }
     ],
     groups: [
@@ -381,12 +384,6 @@ const USER_ADMIN_INITIAL_SNAPSHOT = {
             name: "basket-trading-trade",
             groupDisplayName: "trade",
             path: "/vuu/basket-trading-trade"
-        },
-        {
-            id: "group-admins",
-            name: "administrators",
-            groupDisplayName: "administrators",
-            path: "/vuu/administrators"
         }
     ],
     timestamp: 1710000000000,
@@ -438,19 +435,6 @@ const USER_ADMIN_INITIAL_SNAPSHOT = {
                 id: "user-alice",
                 username: "alice"
             }
-        },
-        {
-            group: {
-                id: "group-admins",
-                name: "administrators",
-                groupDisplayName: "administrators",
-                path: "/vuu/administrators"
-            },
-            user: {
-                email: "alice@example.com",
-                id: "user-alice",
-                username: "alice"
-            }
         }
     ],
     users: [

package/types/user-admin/UserAdminModule.d.ts

@@ -25,7 +25,11 @@ export declare class UserAdminModule extends VuuModule<UserAdminTableName> {
     reconcile(): Promise<void>;
     protected createSessionTable(sourceTable: Table, sessionTableName: string, editSessionMode: import("@vuu-ui/vuu-data-types").EditSessionMode | import("@vuu-ui/vuu-data-types").CopyOption, dataSource: import("../TickingArrayDataSource").TickingArrayDataSource, sessionType?: import("@vuu-ui/vuu-data-types").SessionType): Table;
     protected beforeSessionSave(sourceTable: Table, sessionTable: Table): Promise<void>;
-    protected afterSessionSave(sourceTable: Table): Promise<void>;
+    protected afterSessionSave(sourceTable: Table, sessionTable: Table): Promise<void>;
+    private saveGroupsFromSession;
+    private saveGroupRoleAssignments;
+    private resolveGroupRoleAssignments;
+    private saveClientRolesFromSession;
     private mutation;
     private addUser;
     private updateUser;