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

package/src/user-admin/UserAdminModule.js

@@ -0,0 +1,567 @@
+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 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;
+    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);
+        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(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;
+        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, 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 {
+                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";