@vuu-ui/vuu-data-test 4.0.0-alpha.3 → 4.0.0-alpha.31

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/TickingArrayDataSource.d.ts

@@ -33,7 +33,7 @@ export declare class TickingArrayDataSource extends ArrayDataSource {
     undoRowChange: (key: string) => Promise<RpcResultSuccess | RpcResultError>;
     set columns(columns: string[]);
     get columns(): string[];
-    endEditSession(saveChanges?: boolean): Promise<void>;
+    endEditSession(saveChanges?: boolean, force?: boolean): Promise<void>;
     rpcRequest(rpcRequest: Omit<VuuRpcServiceRequest, "context">): Promise<RpcResultSuccess | RpcResultError>;
     menuRpcCall(rpcRequest: Omit<VuuRpcMenuRequest, "vpId">): Promise<VuuRpcMenuResponse>;
     getTypeaheadSuggestions(column: string, pattern?: string): Promise<string[]>;

package/types/basket/BasketModule.d.ts

@@ -47,9 +47,11 @@ export declare class BasketModule extends VuuModule<BasketsTableName> {
         }[];
     };
     private createTradingBasket;
+    private insertTradingConstituent;
     private createNewBasket;
     private sendToMarket;
     private takeOffMarket;
     private addConstituent;
+    private updateConstituentStatus;
 }
 export declare const basketModule: BasketModule;

package/types/basket/reference-data/constituents.d.ts

@@ -1,3 +1,3 @@
-import { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
-declare const _default: VuuRowDataItemType[][];
-export default _default;
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+declare const basketConstituentData: VuuRowDataItemType[][];
+export default basketConstituentData;

package/types/basket/reference-data/prices.d.ts

@@ -1,3 +1,4 @@
+import { Table } from "../../Table";
 export type ask = number;
 export type askSize = number;
 export type bid = number;
@@ -20,5 +21,5 @@ export type PricesDataRow = [
     ric,
     scenario
 ];
-declare const pricesTable: import("../..").Table;
+declare const pricesTable: Table;
 export default pricesTable;

package/types/core/filter/PermissionFilter.d.ts

@@ -0,0 +1,41 @@
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import type { VuuModuleUser } from "../user/CurrentUser";
+import type { ColumnMap } from "@vuu-ui/vuu-utils";
+import type tableContainer from "../table/TableContainer";
+export type TableRow = Array<bigint | VuuRowDataItemType>;
+export type RowPredicate = (row: TableRow) => boolean;
+/**
+ * Read access to a single row, by column name.
+ */
+export interface RowData {
+    get: (columnName: string) => bigint | VuuRowDataItemType | undefined;
+}
+/**
+ * Restricts the rows of a table visible through a viewport, typically
+ * based on the user that owns the viewport. Permission filters are applied
+ * in addition to any client filter.
+ */
+export interface PermissionFilter {
+    /**
+     * Bind this permission filter to the column layout of a table, returning a
+     * predicate that can be evaluated against raw table rows.
+     */
+    createPredicate: (columnMap: ColumnMap) => RowPredicate;
+}
+/**
+ * The subset of viewport state available to a PermissionFunction.
+ */
+export interface PermissionViewport {
+    id: string;
+    user: VuuModuleUser;
+}
+export type TableContainer = typeof tableContainer;
+/**
+ * Creates the PermissionFilter for a viewport. Configured per table on a VuuModule.
+ */
+export type PermissionFunction = (viewport: PermissionViewport, tableContainer: TableContainer) => PermissionFilter;
+export declare const AllowAllPermissionFilter: PermissionFilter;
+export declare const DenyAllPermissionFilter: PermissionFilter;
+export declare function PermissionFilter(rowPredicate: (row: RowData) => boolean): PermissionFilter;
+export declare function PermissionFilter(columnName: string, allowedValues: Set<string>): PermissionFilter;
+export declare function PermissionFilter(filters: Iterable<PermissionFilter>): PermissionFilter;

package/types/core/filter/PermissionFilteredTable.d.ts

@@ -0,0 +1,24 @@
+import { Table } from "../../Table";
+import type { RowPredicate } from "./PermissionFilter";
+/**
+ * A per-viewport view of a source table, containing only those rows that
+ * satisfy a permission predicate. Changes to the source table are mirrored,
+ * an update that moves a row into or out of the permitted set is emitted as
+ * an insert or delete.
+ */
+export declare class PermissionFilteredTable extends Table {
+    #private;
+    constructor(source: Table, predicate: RowPredicate);
+    get source(): Table;
+    /**
+     * Start mirroring changes from the source table. Invoked on construction,
+     * only needs to be called again following dispose.
+     */
+    attach(): void;
+    dispose(): void;
+    private contains;
+    private handleSourceInsert;
+    private handleSourceUpdate;
+    private handleSourceDelete;
+    private replaceRow;
+}

package/types/core/module/VuuModule.d.ts

@@ -2,6 +2,8 @@ import type { DataSourceBase, DataSourceConfig, DataSourceRowWithBigint, DataSou
 import type { VuuMenu, VuuLink, LinkDescriptorWithLabel, VuuRpcMenuResponse, VuuCreateVisualLink, VuuRemoveVisualLink, VuuRpcServiceRequest, RpcResultSuccess, RpcResultError, VuuRpcMenuRequest } from "@vuu-ui/vuu-protocol-types";
 import { Table } from "../../Table";
 import { TickingArrayDataSource } from "../../TickingArrayDataSource";
+import { type PermissionFunction } from "../filter/PermissionFilter";
+import { type VuuModuleUser } from "../user/CurrentUser";
 export interface IVuuModule<T extends string = string> {
     createDataSource: (tableName: T, viewport?: string, config?: DataSourceConfig & {
         session?: SessionDataSourceOverrides;
@@ -28,6 +30,12 @@ type Subscription = {
     dataSource: DataSourceBase<DataSourceRowWithBigint>;
     sessionTableName?: string;
     sourceTableName?: string;
+    /**
+     * The table viewed by this subscription. Where a permission filter applies,
+     * this will be a PermissionFilteredTable
+     */
+    table: Table;
+    user: VuuModuleUser;
 };
 export declare abstract class VuuModule<T extends string = string> implements IVuuModule<T> {
     #private;
@@ -41,6 +49,16 @@ export declare abstract class VuuModule<T extends string = string> implements IV
     protected get includeDefaultServices(): boolean;
     protected beforeSessionSave(_sourceTable: Table, _sessionTable: Table): Promise<void>;
     protected afterSessionSave(_sourceTable: Table, _sessionTable: Table): Promise<void>;
+    /**
+     * Optional, per table. Restricts the rows visible to each viewport, based on
+     * the viewport (and the user who owns it).
+     */
+    protected permissionFunctions?: Partial<Record<T, PermissionFunction>>;
+    /**
+     * Invoked before a dataSource is created. Can be used, for example, to
+     * lazily start a data provider.
+     */
+    protected beforeCreateDataSource?(tableName: T): void;
     getTableSchema(tableName: string): Record<T, Readonly<TableSchema>>[T];
     getTableList(): string[];
     protected handlePostSubscribeActivities: ({ clientViewportId, tableSchema, }: DataSourceSubscribedMessage) => void;
@@ -54,6 +72,7 @@ export declare abstract class VuuModule<T extends string = string> implements IV
     createDataSource: (tableName: T, viewport?: string, config?: DataSourceConfig & {
         session?: SessionDataSourceOverrides;
     }) => DataSourceBase<DataSourceRowWithBigint>;
+    private createPermissionFilteredTable;
     getServices(tableName: T): RpcService[];
     getMenuServices(tableName: T): RpcMenuService[];
     protected get sessionTableMap(): SessionTableMap;

package/types/core/table/TableContainer.d.ts

@@ -8,7 +8,7 @@ declare class TableContainer {
     private constructor();
     static get instance(): TableContainer;
     createTable: (schema: TableSchema, data?: Array<Array<VuuRowDataItemType | bigint>>, dataMap?: ColumnMap, updateGenerator?: UpdateGenerator) => Table;
-    createJoinTable(joinTable: VuuTable, { table: t1 }: VuuTable, { table: t2 }: VuuTable, joinColumn: string): Table;
+    createJoinTable(joinTable: VuuTable, source1: VuuTable | Table, source2: VuuTable | Table, joinColumn: string): Table;
     addTable(table: Table): void;
     getTable<T = Table>(tableName: string): NonNullable<T>;
 }

package/types/core/user/CurrentUser.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The user that owns a viewport, as seen by permission functions and
+ * rpc services.
+ */
+export interface VuuModuleUser {
+    authorizations: string[];
+    name: string;
+}
+export declare const getCurrentUser: () => VuuModuleUser;
+/**
+ * Applies to viewports created after the change. Pass undefined to restore
+ * the default user.
+ */
+export declare const setCurrentUser: (user?: string | VuuModuleUser) => void;

package/types/index.d.ts

@@ -1,9 +1,13 @@
 export * from "./ArrayProxy";
+export * from "./core/filter/PermissionFilter";
+export * from "./core/filter/PermissionFilteredTable";
 export * from "./core/module/VuuModule";
 export { ensureVuuModule } from "./core/module/ModuleContainer";
+export * from "./core/user/CurrentUser";
 export { default as tableContainer } from "./core/table/TableContainer";
 export * from "./local-datasource-provider/LocalDatasourceProvider";
 export * from "./makeSuggestions";
+export * from "./notifications";
 export * from "./schemas";
 export * from "./simul";
 export * from "./basket";

package/types/local-datasource-provider/LocalDatasourceProvider.d.ts

@@ -1,4 +1,20 @@
+import { type LocalVuuServer } from "@vuu-ui/core";
 import type { ReactNode } from "react";
-export declare const LocalDataSourceProvider: ({ children, }: {
+import type { VuuModule } from "../core/module/VuuModule";
+/** Data context covering every VuuModule registered in the browser. */
+export declare const LocalDataSourceProvider: ({ children }: {
     children: ReactNode;
-}) => import("react").JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;
+export interface LocalVuuServerOptions {
+    /** Matches the `vuu.connectionId` of the modules this server serves. */
+    connectionId: string;
+    modules: VuuModule<any>[];
+}
+/**
+ * Simulates a Vuu server in the browser, publishing the tables of the given
+ * modules. Module instances are resolved from this server, not by name from
+ * the global registry, so servers can each have their own instance of a
+ * module (e.g. NOTIFICATIONS). Pass the result to a local-mode `AuthenticationProvider` as one of
+ * its `localServers`.
+ */
+export declare const createLocalVuuServer: ({ connectionId, modules, }: LocalVuuServerOptions) => LocalVuuServer;

package/types/module-admin/ModuleAdminModule.d.ts

@@ -1,13 +1,21 @@
+import { type ManagedModule } from "@heswell/module-admin/contracts";
 import type { TableSchema } from "@vuu-ui/vuu-data-types";
-import { VuuModule } from "../core/module/VuuModule";
+import { VuuModule, type RpcService } from "../core/module/VuuModule";
 import { type Table } from "../Table";
 import { type ModuleAdminTableName } from "./module-admin-schemas";
 import { type ModuleAdminSnapshot } from "./snapshot-projection";
 type ModuleAdminTables = Record<ModuleAdminTableName, Table>;
 export declare const MODULE_ADMIN_INITIAL_SNAPSHOT: ModuleAdminSnapshot;
+/**
+ * In-browser MODULE_DISCOVERY server. Supports the module admin RPCs from
+ * `@heswell/module-admin/contracts` on both tables; state is held in memory.
+ */
 export declare class ModuleAdminModule extends VuuModule<ModuleAdminTableName> {
     #private;
-    constructor(snapshot?: ModuleAdminSnapshot);
+    private readonly now;
+    constructor(snapshot?: ModuleAdminSnapshot, now?: () => number);
+    /** Current module state. */
+    get modules(): readonly ManagedModule[];
     get menus(): {
         modulePermissions: undefined;
         modules: undefined;
@@ -15,7 +23,8 @@ export declare class ModuleAdminModule extends VuuModule<ModuleAdminTableName> {
     protected get includeDefaultServices(): boolean;
     get menuServices(): undefined;
     get schemas(): Record<ModuleAdminTableName, Readonly<TableSchema>>;
-    get services(): undefined;
+    private service;
+    get services(): Record<ModuleAdminTableName, RpcService[]>;
     get tables(): ModuleAdminTables;
     get visualLinks(): undefined;
 }

package/types/module-admin/index.d.ts

@@ -1,4 +1,4 @@
 export { ModuleAdminModule, MODULE_ADMIN_INITIAL_SNAPSHOT, moduleAdminModule, } from "./ModuleAdminModule";
 export { MODULE_ADMIN_MODULE_NAME, MODULE_ADMIN_TABLE_SCHEMAS, type ModuleAdminTableName, } from "./module-admin-schemas";
 export { projectModuleAdminSnapshot, reconcileModuleAdminTables, type ModuleAdminSnapshot, } from "./snapshot-projection";
-export type { ModuleAccessRole, ModuleDefinition, ModulePermissionRow, ModuleRow, } from "@heswell/module-admin/contracts";
+export type { ManagedModule, ModuleAccessRole, ModuleConfig, ModuleDefinition, ModulePermissionRow, ModuleRow, } from "@heswell/module-admin/contracts";