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

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.2",
+  "version": "4.0.0-alpha.20",
   "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.2",
-    "@vuu-ui/vuu-data-local": "4.0.0-alpha.2",
-    "@vuu-ui/core": "4.0.0-alpha.2",
-    "@vuu-ui/vuu-utils": "4.0.0-alpha.2"
+    "@heswell/module-admin": "1.1.0",
+    "@heswell/user-admin": "1.0.1",
+    "@vuu-ui/vuu-data-editing": "4.0.0-alpha.20",
+    "@vuu-ui/vuu-data-local": "4.0.0-alpha.20",
+    "@vuu-ui/vuu-utils": "4.0.0-alpha.20"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.2",
-    "@vuu-ui/vuu-data-types": "4.0.0-alpha.2",
-    "@vuu-ui/vuu-table-types": "4.0.0-alpha.2"
+    "@vuu-ui/vuu-data-types": "4.0.0-alpha.20",
+    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.20",
+    "@vuu-ui/vuu-table-types": "4.0.0-alpha.20"
   },
   "sideEffects": false,
   "files": [
@@ -28,8 +29,9 @@
   ],
   "exports": {
     ".": {
+      "types": "./types/index.d.ts",
       "import": "./src/index.js",
-      "types": "./types/index.d.ts"
+      "default": "./src/index.js"
     }
   },
   "module": "./src/index.js",

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/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/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

@@ -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) ;
@@ -22,6 +26,12 @@ class VuuModule {
         this.#sessionTableMessageColumn = sessionTableMessageColumn;
         ModuleContainer.register(this);
     }
+    get includeDefaultServices() {
+        return true;
+    }
+    async beforeSessionSave(_sourceTable, _sessionTable) {}
+    async afterSessionSave(_sourceTable, _sessionTable) {}
+    permissionFunctions;
     getTableSchema(tableName) {
         return this.schemas[tableName] ?? this.#sessionTableMap[tableName]?.schema;
     }
@@ -121,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,
@@ -134,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, [
@@ -153,10 +177,16 @@ 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];
-        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];
@@ -221,7 +251,9 @@ class VuuModule {
                 }
                 return {
                     type: "SUCCESS_RESULT",
-                    data: void 0
+                    data: {
+                        deletedKeys: selectedRowIds
+                    }
                 };
             }
             return {
@@ -492,6 +524,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;
@@ -526,6 +566,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/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,12 +1,19 @@
 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";
+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/local-datasource-provider/LocalDatasourceProvider.js

@@ -1,50 +1,60 @@
 import { jsx } from "react/jsx-runtime";
 import { DataProvider } from "@vuu-ui/core";
 import { DataProvider as vuu_utils_DataProvider } from "@vuu-ui/vuu-utils";
-import ModuleContainer from "../core/module/ModuleContainer.js";
+import ModuleContainer, { ensureVuuModule } from "../core/module/ModuleContainer.js";
 import TableContainer from "../core/table/TableContainer.js";
-const serverAPI = {
-    getTableList: async ()=>{
-        const tables = ModuleContainer.moduleNames.reduce((tableList, moduleName)=>{
-            const moduleTables = ModuleContainer.get(moduleName).getTableList();
-            moduleTables.forEach((tableName)=>{
-                const table = TableContainer.getTable(tableName);
-                tableList.push(table.schema.table);
-            });
-            return tableList;
-        }, []);
-        return {
-            tables
-        };
-    },
-    getTableSchema: async ({ module, table })=>ModuleContainer.get(module).getTableSchema(table),
-    rpcCall: async ()=>{
-        throw Error("RpcCall no longer supported on LocalDataSourceProvider ServerAPI");
+const createLocalDataSourceProvider = (moduleNames)=>{
+    const getModule = (moduleName)=>{
+        if (moduleNames && !moduleNames.has(moduleName)) throw Error(`[LocalDataSourceProvider] module ${moduleName} is not available on this server`);
+        return ModuleContainer.get(moduleName);
+    };
+    const serverAPI = {
+        getTableList: async ()=>{
+            const tables = [];
+            for (const moduleName of moduleNames ?? ModuleContainer.moduleNames)for (const tableName of getModule(moduleName).getTableList())tables.push(TableContainer.getTable(tableName).schema.table);
+            return {
+                tables
+            };
+        },
+        getTableSchema: async ({ module, table })=>getModule(module).getTableSchema(table),
+        rpcCall: async ()=>{
+            throw Error("RpcCall no longer supported on LocalDataSourceProvider ServerAPI");
+        }
+    };
+    const getServerAPI = async ()=>serverAPI;
+    class VuuDataSource {
+        constructor({ aggregations, baseFilterSpec, columns, filterSpec, groupBy, session, sort, table, viewport, visualLink }){
+            const config = {
+                aggregations,
+                baseFilterSpec,
+                columns,
+                filterSpec,
+                groupBy,
+                session,
+                sort,
+                visualLink
+            };
+            const module = getModule(table.module);
+            return module.createDataSource(table.table, viewport, config);
+        }
     }
-};
-const getServerAPI = async ()=>serverAPI;
-class VuuDataSource {
-    constructor({ aggregations, columns, filterSpec, groupBy, session, sort, table, viewport, visualLink }){
-        const config = {
-            aggregations,
-            columns,
-            filterSpec,
-            groupBy,
-            session,
-            sort,
-            visualLink
-        };
-        const module = ModuleContainer.get(table.module);
-        return module.createDataSource(table.table, viewport, config);
-    }
-}
-const LocalDataSourceProvider = ({ children })=>/*#__PURE__*/ jsx(vuu_utils_DataProvider, {
-        VuuDataSource: VuuDataSource,
-        getServerAPI: getServerAPI,
-        children: /*#__PURE__*/ jsx(DataProvider, {
+    const DataSourceProvider = ({ children })=>/*#__PURE__*/ jsx(vuu_utils_DataProvider, {
             VuuDataSource: VuuDataSource,
             getServerAPI: getServerAPI,
-            children: children
-        })
-    });
-export { LocalDataSourceProvider };
+            children: /*#__PURE__*/ jsx(DataProvider, {
+                VuuDataSource: VuuDataSource,
+                getServerAPI: getServerAPI,
+                children: children
+            })
+        });
+    return DataSourceProvider;
+};
+const LocalDataSourceProvider = createLocalDataSourceProvider();
+const createLocalVuuServer = ({ connectionId, modules })=>{
+    modules.forEach(ensureVuuModule);
+    return {
+        connectionId,
+        DataSourceProvider: createLocalDataSourceProvider(new Set(modules.map(({ name })=>name)))
+    };
+};
+export { LocalDataSourceProvider, createLocalVuuServer };

package/src/module-admin/ModuleAdminModule.js

@@ -0,0 +1,124 @@
+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";
+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 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 = {
+    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, 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,
+            modules: void 0
+        };
+    }
+    get includeDefaultServices() {
+        return false;
+    }
+    get menuServices() {}
+    get schemas() {
+        return MODULE_ADMIN_TABLE_SCHEMAS;
+    }
+    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;
+    }
+    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";