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

package/src/user-admin/UserAdminModule.js

@@ -0,0 +1,412 @@
+import { USER_ADMIN_RPC_CONTRACT, USER_ADMIN_TABLE_SCHEMAS } from "@heswell/user-admin/contracts";
+import { InMemoryUserAdminStore } from "@heswell/user-admin/in-memory";
+import { VuuModule } from "../core/module/VuuModule.js";
+import TableContainer from "../core/table/TableContainer.js";
+import { Table, buildDataColumnMapFromSchema } from "../Table.js";
+import { USER_ADMIN_INITIAL_SNAPSHOT } from "./initialSnapshot.js";
+import { reconcileUserAdminTables, resolveDisplayName } from "./snapshot-projection.js";
+const createTables = ()=>({
+        clients: TableContainer.createTable(USER_ADMIN_TABLE_SCHEMAS.clients),
+        group_roles: TableContainer.createTable(USER_ADMIN_TABLE_SCHEMAS.group_roles),
+        groups: TableContainer.createTable(USER_ADMIN_TABLE_SCHEMAS.groups),
+        roles: TableContainer.createTable(USER_ADMIN_TABLE_SCHEMAS.roles),
+        user_group_roles: TableContainer.createTable(USER_ADMIN_TABLE_SCHEMAS.user_group_roles),
+        user_groups: TableContainer.createTable(USER_ADMIN_TABLE_SCHEMAS.user_groups),
+        users: TableContainer.createTable(USER_ADMIN_TABLE_SCHEMAS.users)
+    });
+const errorResult = (error)=>({
+        errorMessage: error instanceof Error ? error.message : "User admin request failed",
+        type: "ERROR_RESULT"
+    });
+const isRecord = (value)=>"object" == typeof value && null !== value && !Array.isArray(value);
+const readParams = (request, rpcName)=>{
+    if ("RPC_REQUEST" !== request.type || request.rpcName !== rpcName) throw new Error(`Expected ${rpcName} RPC request`);
+    if (!isRecord(request.params)) throw new Error(`${rpcName} requires named parameters`);
+    const allowed = new Set(USER_ADMIN_RPC_CONTRACT[rpcName]);
+    for (const name of Object.keys(request.params))if (!allowed.has(name)) throw new Error(`${rpcName} received an unsupported parameter: ${name}`);
+    return request.params;
+};
+const requiredString = (params, name)=>{
+    const value = params[name];
+    if ("string" != typeof value || 0 === value.length) throw new Error(`${name} must be a non-empty string`);
+    return value;
+};
+const optionalString = (params, name)=>{
+    const value = params[name];
+    if (void 0 !== value && "string" != typeof value) throw new Error(`${name} must be a string`);
+    return value;
+};
+const optionalBoolean = (params, name)=>{
+    const value = params[name];
+    if (void 0 !== value && "boolean" != typeof value) throw new Error(`${name} must be a boolean`);
+    return value;
+};
+const optionalStringArray = (params, name)=>{
+    const value = params[name];
+    if (void 0 !== value && (!Array.isArray(value) || value.some((item)=>"string" != typeof item))) throw new Error(`${name} must be an array of strings`);
+    return value;
+};
+const reference = (params, idName, name)=>{
+    const id = optionalString(params, idName);
+    const label = optionalString(params, name);
+    if (!id && !label) throw new Error(`${idName} or ${name} is required`);
+    return {
+        id,
+        label
+    };
+};
+const parseAssignments = (value)=>{
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    } catch  {
+        throw new Error("assignments must be valid JSON");
+    }
+    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 parseSessionPermissions = (value)=>{
+    if ("string" != typeof value) throw new Error("permissions must be a serialized array");
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    } catch  {
+        throw new Error("permissions must be valid JSON");
+    }
+    if (!Array.isArray(parsed)) throw new Error("permissions must contain application group assignments");
+    const accessRoles = new Set();
+    const permissions = parsed.map((application, index)=>{
+        if (!isRecord(application) || Object.keys(application).some((field)=>"clientIdentifier" !== field && "accessRole" !== field && "groupIds" !== field) || "string" != typeof application.clientIdentifier || 0 === application.clientIdentifier.length || "string" != typeof application.accessRole || 0 === application.accessRole.length || !Array.isArray(application.groupIds) || application.groupIds.some((groupId)=>"string" != typeof groupId || 0 === groupId.length)) throw new Error(`permissions[${index}] must contain clientIdentifier, accessRole, and groupIds`);
+        if (accessRoles.has(application.accessRole)) throw new Error(`permissions contains duplicate accessRole: ${application.accessRole}`);
+        const groupIds = application.groupIds;
+        if (new Set(groupIds).size !== groupIds.length) throw new Error(`permissions contains duplicate group IDs for: ${application.accessRole}`);
+        accessRoles.add(application.accessRole);
+        return {
+            clientIdentifier: application.clientIdentifier,
+            accessRole: application.accessRole,
+            groupIds
+        };
+    });
+    return permissions.flatMap(({ groupIds, accessRole })=>groupIds.map((groupId)=>({
+                accessRole,
+                groupId
+            })));
+};
+class UserAdminModule extends VuuModule {
+    #tables;
+    store;
+    constructor(snapshot = USER_ADMIN_INITIAL_SNAPSHOT){
+        super("USER_ADMIN");
+        this.store = new InMemoryUserAdminStore(snapshot);
+        this.#tables = createTables();
+        reconcileUserAdminTables(snapshot, this.#tables);
+    }
+    get schemas() {
+        return USER_ADMIN_TABLE_SCHEMAS;
+    }
+    get tables() {
+        return this.#tables;
+    }
+    get menus() {
+        return {
+            clients: void 0,
+            group_roles: void 0,
+            groups: void 0,
+            roles: void 0,
+            user_group_roles: void 0,
+            user_groups: void 0,
+            users: void 0
+        };
+    }
+    get visualLinks() {}
+    get menuServices() {}
+    get services() {
+        const services = [
+            {
+                rpcName: "addUser",
+                service: this.addUser
+            },
+            {
+                rpcName: "updateUser",
+                service: this.updateUser
+            },
+            {
+                rpcName: "deleteUser",
+                service: this.deleteUser
+            },
+            {
+                rpcName: "addGroup",
+                service: this.addGroup
+            },
+            {
+                rpcName: "updateGroup",
+                service: this.updateGroup
+            },
+            {
+                rpcName: "deleteGroup",
+                service: this.deleteGroup
+            },
+            {
+                rpcName: "addClient",
+                service: this.addClient
+            },
+            {
+                rpcName: "updateClient",
+                service: this.updateClient
+            },
+            {
+                rpcName: "addRole",
+                service: this.addRole
+            },
+            {
+                rpcName: "addClientRole",
+                service: this.addClientRole
+            },
+            {
+                rpcName: "updateRole",
+                service: this.updateRole
+            },
+            {
+                rpcName: "assignGroupRole",
+                service: this.assignGroupRole
+            },
+            {
+                rpcName: "removeGroupRole",
+                service: this.removeGroupRole
+            },
+            {
+                rpcName: "assignUserToGroup",
+                service: this.assignUserToGroup
+            },
+            {
+                rpcName: "removeUserFromGroup",
+                service: this.removeUserFromGroup
+            },
+            {
+                rpcName: "getUserModuleAccessOptions",
+                service: this.getUserModuleAccessOptions
+            },
+            {
+                rpcName: "setUserModuleAccess",
+                service: this.setUserModuleAccess
+            }
+        ];
+        return {
+            clients: services,
+            group_roles: services,
+            groups: services,
+            roles: services,
+            user_group_roles: services,
+            user_groups: services,
+            users: services
+        };
+    }
+    async reconcile() {
+        reconcileUserAdminTables(await this.store.snapshot(), this.#tables);
+    }
+    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({
+                name: "permissions",
+                serverDataType: "string"
+            })
+        };
+        return new Table(sessionSchema, sessionTable.data.map((row)=>row.concat("")), buildDataColumnMapFromSchema(sessionSchema));
+    }
+    async beforeSessionSave(sourceTable, sessionTable) {
+        if ("users" !== sourceTable.name) return;
+        const permissionsIndex = sessionTable.map.permissions;
+        const actionIndex = sessionTable.map.vuuAction;
+        const userIdIndex = sessionTable.map.user_id;
+        const usernameIndex = sessionTable.map.username;
+        for (const row of sessionTable.data){
+            if ("editCell" !== row[actionIndex]) continue;
+            const userId = String(row[userIdIndex]);
+            const sourceRow = sourceTable.findByKey(userId);
+            if (!sourceRow || sourceRow[sourceTable.map.username] !== row[usernameIndex]) throw new Error("username is read-only");
+            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();
+    }
+    mutation = (rpcName, mutate)=>async (request)=>{
+            try {
+                await mutate(readParams(request, rpcName));
+                await this.reconcile();
+                return {
+                    data: void 0,
+                    type: "SUCCESS_RESULT"
+                };
+            } catch (error) {
+                return errorResult(error);
+            }
+        };
+    addUser = this.mutation("addUser", async (params)=>{
+        const groupIds = optionalStringArray(params, "group_ids");
+        const username = requiredString(params, "username");
+        await this.assertUsernameIsUnique(username);
+        await this.store.addUser({
+            email: optionalString(params, "email"),
+            emailVerified: optionalBoolean(params, "emailVerified"),
+            enabled: optionalBoolean(params, "enabled"),
+            firstName: optionalString(params, "firstName"),
+            lastName: optionalString(params, "lastName"),
+            temporary_password: optionalString(params, "temporary_password"),
+            username
+        });
+        if (groupIds) {
+            const user = await this.store.findUserByUsername(requiredString(params, "username"));
+            if (!user) throw new Error("Created user could not be found");
+            await this.store.syncUserGroups(user.id, groupIds);
+        }
+    });
+    updateUser = this.mutation("updateUser", async (params)=>{
+        const groupIds = optionalStringArray(params, "group_ids");
+        const userId = requiredString(params, "userId");
+        const username = optionalString(params, "username");
+        if (username) await this.assertUsernameIsUnique(username, userId);
+        await this.store.updateUser({
+            email: optionalString(params, "email"),
+            emailVerified: optionalBoolean(params, "emailVerified"),
+            enabled: optionalBoolean(params, "enabled"),
+            firstName: optionalString(params, "firstName"),
+            lastName: optionalString(params, "lastName"),
+            temporary_password: optionalString(params, "temporary_password"),
+            userId,
+            username
+        });
+        if (groupIds) await this.store.syncUserGroups(userId, groupIds);
+    });
+    deleteUser = this.mutation("deleteUser", (params)=>this.store.deleteUser(requiredString(params, "userId")));
+    addGroup = this.mutation("addGroup", (params)=>this.store.addGroup({
+            name: requiredString(params, "name")
+        }));
+    updateGroup = this.mutation("updateGroup", (params)=>this.store.updateGroup(requiredString(params, "groupId"), {
+            name: requiredString(params, "name")
+        }));
+    deleteGroup = this.mutation("deleteGroup", (params)=>this.store.deleteGroup(requiredString(params, "groupId")));
+    addClient = this.mutation("addClient", (params)=>this.store.addClient({
+            clientId: requiredString(params, "clientId"),
+            description: optionalString(params, "description"),
+            enabled: optionalBoolean(params, "enabled"),
+            name: optionalString(params, "name")
+        }));
+    updateClient = this.mutation("updateClient", (params)=>this.store.updateClient(requiredString(params, "clientId"), {
+            description: optionalString(params, "description"),
+            enabled: optionalBoolean(params, "enabled"),
+            name: optionalString(params, "name")
+        }));
+    addRole = this.mutation("addRole", (params)=>this.store.addRole({
+            description: optionalString(params, "description"),
+            name: requiredString(params, "name")
+        }));
+    addClientRole = this.mutation("addClientRole", (params)=>this.store.addClientRole({
+            clientKey: requiredString(params, "clientId")
+        }, {
+            description: optionalString(params, "description"),
+            name: requiredString(params, "name")
+        }));
+    updateRole = this.mutation("updateRole", async (params)=>{
+        const clientId = optionalString(params, "clientId");
+        const changes = {
+            description: optionalString(params, "description"),
+            name: optionalString(params, "name")
+        };
+        if (clientId) await this.store.updateClientRole(clientId, requiredString(params, "roleName"), changes);
+        else await this.store.updateRealmRole(requiredString(params, "roleId"), changes);
+    });
+    assignGroupRole = this.mutation("assignGroupRole", (params)=>{
+        const group = reference(params, "groupId", "groupName");
+        const role = reference(params, "roleId", "roleName");
+        const clientId = optionalString(params, "clientId");
+        return this.store.addRoleToGroup({
+            groupId: group.id,
+            groupName: group.label
+        }, {
+            roleId: role.id,
+            roleName: role.label
+        }, clientId ? {
+            clientKey: clientId
+        } : void 0);
+    });
+    removeGroupRole = this.mutation("removeGroupRole", (params)=>{
+        const group = reference(params, "groupId", "groupName");
+        const role = reference(params, "roleId", "roleName");
+        const clientId = optionalString(params, "clientId");
+        return this.store.removeRoleFromGroup({
+            groupId: group.id,
+            groupName: group.label
+        }, {
+            roleId: role.id,
+            roleName: role.label
+        }, clientId ? {
+            clientKey: clientId
+        } : void 0);
+    });
+    assignUserToGroup = this.mutation("assignUserToGroup", (params)=>{
+        const user = reference(params, "userId", "username");
+        const group = reference(params, "groupId", "groupName");
+        return this.store.addUserToGroup({
+            userId: user.id,
+            username: user.label
+        }, {
+            groupId: group.id,
+            groupName: group.label
+        });
+    });
+    removeUserFromGroup = this.mutation("removeUserFromGroup", (params)=>{
+        const user = reference(params, "userId", "username");
+        const group = reference(params, "groupId", "groupName");
+        return this.store.removeUserFromGroup({
+            userId: user.id,
+            username: user.label
+        }, {
+            groupId: group.id,
+            groupName: group.label
+        });
+    });
+    getUserModuleAccessOptions = async (request)=>{
+        try {
+            const params = readParams(request, "getUserModuleAccessOptions");
+            const [options, snapshot] = await Promise.all([
+                this.store.getUserModuleAccessOptions(requiredString(params, "userId")),
+                this.store.snapshot()
+            ]);
+            const groupDisplayNames = new Map(snapshot.groups.map(({ groupDisplayName, id, name })=>[
+                    id,
+                    resolveDisplayName(name, groupDisplayName)
+                ]));
+            const roleDisplayNames = new Map(snapshot.clientRoles.map(({ role })=>[
+                    role.id,
+                    resolveDisplayName(role.name, role.roleDisplayName)
+                ]));
+            return {
+                data: {
+                    modules: options.modules.map(({ groups, ...module })=>({
+                            ...module,
+                            groups: groups.map((group)=>({
+                                    ...group,
+                                    groupDisplayName: groupDisplayNames.get(group.groupId) ?? resolveDisplayName(group.groupName),
+                                    roleDisplayName: roleDisplayNames.get(group.roleId) ?? resolveDisplayName(group.roleName)
+                                }))
+                        }))
+                },
+                type: "SUCCESS_RESULT"
+            };
+        } catch (error) {
+            return errorResult(error);
+        }
+    };
+    setUserModuleAccess = this.mutation("setUserModuleAccess", (params)=>this.store.setUserModuleAccess(requiredString(params, "userId"), parseAssignments(requiredString(params, "assignments"))));
+    async assertUsernameIsUnique(username, userId) {
+        const normalizedUsername = username.toLocaleLowerCase();
+        const existingUser = (await this.store.snapshot()).users.find((user)=>user.id !== userId && user.username.toLocaleLowerCase() === normalizedUsername);
+        if (existingUser) throw new Error("username must be unique");
+    }
+}
+const userAdminModule = new UserAdminModule();
+export { UserAdminModule, userAdminModule };

package/src/user-admin/index.js

@@ -0,0 +1,3 @@
+export { UserAdminModule, userAdminModule } from "./UserAdminModule.js";
+export { USER_ADMIN_INITIAL_SNAPSHOT } from "./initialSnapshot.js";
+export { projectUserAdminSnapshot, reconcileUserAdminTables } from "./snapshot-projection.js";