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

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

@@ -1,11 +1,14 @@
-import { VuuModule } from "./VuuModule";
+import type { VuuModule } from "./VuuModule";
+type RegisteredVuuModule = VuuModule<any>;
 declare class ModuleContainer {
     #private;
     private constructor();
     static get instance(): ModuleContainer;
-    register(module: VuuModule<any>): void;
-    get(name: string): VuuModule<string>;
+    register(module: RegisteredVuuModule): void;
+    has(name: string): boolean;
+    get(name: string): RegisteredVuuModule;
     get moduleNames(): MapIterator<string>;
 }
 declare const _default: ModuleContainer;
 export default _default;
+export declare const ensureVuuModule: <T extends RegisteredVuuModule>(module: T) => T;

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;
@@ -38,6 +46,19 @@ export declare abstract class VuuModule<T extends string = string> implements IV
     protected abstract menuServices?: Record<T, RpcMenuService[] | undefined> | undefined;
     protected abstract services?: Record<T, RpcService[] | undefined> | undefined;
     protected abstract visualLinks?: Record<T, VuuLink[] | undefined>;
+    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;
@@ -51,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

@@ -1,13 +1,13 @@
-import { TableSchema } from "@vuu-ui/vuu-data-types";
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
 import { Table } from "../../Table";
-import { VuuRowDataItemType, VuuTable } from "@vuu-ui/vuu-protocol-types";
-import { ColumnMap } from "@vuu-ui/vuu-utils";
-import { UpdateGenerator } from "../../rowUpdates";
+import type { VuuRowDataItemType, VuuTable } from "@vuu-ui/vuu-protocol-types";
+import type { ColumnMap } from "@vuu-ui/vuu-utils";
+import type { UpdateGenerator } from "../../rowUpdates";
 declare class TableContainer {
     #private;
     private constructor();
     static get instance(): TableContainer;
-    createTable: (schema: TableSchema, data: Array<Array<VuuRowDataItemType | bigint>>, dataMap: ColumnMap, updateGenerator?: UpdateGenerator) => Table;
+    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;
     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,11 +1,18 @@
 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";
+export * from "./module-admin";
+export * from "./user-admin";
 export { buildDataColumnMap, buildDataColumnMapFromSchema, Table, type TableEvents, } from "./Table";
 export * from "./test";
 export * from "./TickingArrayDataSource";

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

@@ -0,0 +1,32 @@
+import { type ManagedModule } from "@heswell/module-admin/contracts";
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+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;
+    private readonly now;
+    constructor(snapshot?: ModuleAdminSnapshot, now?: () => number);
+    /** Current module state. */
+    get modules(): readonly ManagedModule[];
+    get menus(): {
+        modulePermissions: undefined;
+        modules: undefined;
+    };
+    protected get includeDefaultServices(): boolean;
+    get menuServices(): undefined;
+    get schemas(): Record<ModuleAdminTableName, Readonly<TableSchema>>;
+    private service;
+    get services(): Record<ModuleAdminTableName, RpcService[]>;
+    get tables(): ModuleAdminTables;
+    get visualLinks(): undefined;
+}
+export declare const moduleAdminModule: ModuleAdminModule;
+export {};

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

@@ -0,0 +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 { ManagedModule, ModuleAccessRole, ModuleConfig, ModuleDefinition, ModulePermissionRow, ModuleRow, } from "@heswell/module-admin/contracts";

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

@@ -0,0 +1,4 @@
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+export declare const MODULE_ADMIN_MODULE_NAME = "MODULE_DISCOVERY";
+export type ModuleAdminTableName = "modules" | "modulePermissions";
+export declare const MODULE_ADMIN_TABLE_SCHEMAS: Readonly<Record<ModuleAdminTableName, Readonly<TableSchema>>>;

package/types/module-admin/snapshot-projection.d.ts

@@ -0,0 +1,13 @@
+import { type ManagedModule } from "@heswell/module-admin/contracts";
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import type { Table } from "../Table";
+import type { ModuleAdminTableName } from "./module-admin-schemas";
+type Row = Array<bigint | VuuRowDataItemType>;
+type Tables = Record<ModuleAdminTableName, Table>;
+export type ModuleAdminSnapshot = {
+    modules: readonly ManagedModule[];
+};
+export declare const projectModuleAdminSnapshot: (snapshot: ModuleAdminSnapshot, tables: Tables) => Record<ModuleAdminTableName, Row[]>;
+/** Brings the tables into line with the snapshot, emitting row-level updates. */
+export declare const reconcileModuleAdminTables: (snapshot: ModuleAdminSnapshot, tables: Tables) => void;
+export {};

package/types/notifications/NotificationModule.d.ts

@@ -0,0 +1,60 @@
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import { type RpcService, VuuModule } from "../core/module/VuuModule";
+import type { PermissionFunction } from "../core/filter/PermissionFilter";
+import { type Table } from "../Table";
+import { type ColumnDefinition } from "./NotificationsSchema";
+export type NotificationsTableName = "notifications";
+/**
+ * Source of notifications. Started when the first dataSource is
+ * created for the notifications table, or explicitly via module.start().
+ */
+export interface NotificationsProvider {
+    start: () => void;
+    stop: () => void;
+}
+export type NotificationsProviderFactory = (table: Table) => NotificationsProvider;
+/**
+ * A notification to publish. Values are keyed by column name; columns not
+ * supplied are defaulted. `expiryTime` (epoch ms) schedules deletion of the row.
+ */
+export interface NotificationInput {
+    id?: string;
+    type?: string;
+    expiryTime?: number;
+    title?: string;
+    message?: string;
+    level?: string;
+    audience?: string;
+    [columnName: string]: VuuRowDataItemType | undefined;
+}
+export type NotificationsServiceFactory = (table: Table, module: NotificationModule) => RpcService[];
+/**
+ * A generic Notifications module, exposing a single 'notifications' table.
+ * The source of notifications (provider), the rows visible to each user
+ * (permissionFunction) and any rpc services (serviceFactory) are supplied
+ * by the consumer. Any additional columns are appended to the generic
+ * notification columns (see NotificationsSchema).
+ */
+export declare class NotificationModule extends VuuModule<NotificationsTableName> {
+    #private;
+    static readonly NAME = "NOTIFICATIONS";
+    static readonly TABLE_NAME: "notifications";
+    constructor(providerFactory: NotificationsProviderFactory, permissionFunction: PermissionFunction, serviceFactory: NotificationsServiceFactory, ...additionalColumns: ColumnDefinition[]);
+    protected beforeCreateDataSource(): void;
+    /**
+     * Inserts a notification row, as a server-side publisher would. Defaults:
+     * a random `id`, `type` "toast", `level` "INFO", `audience` "all" and
+     * empty strings for other string columns. Returns the row id.
+     */
+    publish(notification?: NotificationInput): string;
+    get isRunning(): boolean;
+    start(): void;
+    stop(): void;
+    get menus(): undefined;
+    get menuServices(): undefined;
+    get schemas(): Record<"notifications", TableSchema>;
+    get services(): Record<"notifications", RpcService[]>;
+    get tables(): Record<"notifications", Table>;
+    get visualLinks(): undefined;
+}

package/types/notifications/NotificationsSchema.d.ts

@@ -0,0 +1,20 @@
+import type { SchemaColumn } from "@vuu-ui/vuu-data-types";
+/**
+ * Accepts either a SchemaColumn or a column definition in the Scala server
+ * 'name:Type' format, e.g. "source:String", "priority:Int".
+ */
+export type ColumnDefinition = SchemaColumn | string;
+export declare const toColumn: (columnDefinition: ColumnDefinition) => SchemaColumn;
+export declare const NotificationsSchema: {
+    Id: string;
+    Type: string;
+    ExpiryTime: string;
+    Title: string;
+    Message: string;
+    Level: string;
+    Audience: string;
+    /**
+     * The generic notification columns, plus any additional columns.
+     */
+    allFrom: (...additionalColumns: ColumnDefinition[]) => SchemaColumn[];
+};

package/types/notifications/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./NotificationModule";
+export * from "./NotificationsSchema";
+export * from "./simulated/DismissNotificationRpcHandler";
+export * from "./simulated/SimulatedNotificationsModule";
+export * from "./simulated/SimulatedNotificationsProvider";
+export * from "./simulated/notificationsModule";

package/types/notifications/simulated/DismissNotificationRpcHandler.d.ts

@@ -0,0 +1,8 @@
+import type { RpcService } from "../../core/module/VuuModule";
+import type { Table } from "../../Table";
+import type { NotificationModule } from "../NotificationModule";
+/**
+ * Marks the notifications selected in the requesting viewport as dismissed
+ * by the user that owns the viewport.
+ */
+export declare const DismissNotificationRpcHandler: (table: Table, module: NotificationModule) => RpcService[];

package/types/notifications/simulated/SimulatedNotificationsModule.d.ts

@@ -0,0 +1,9 @@
+import { NotificationModule } from "../NotificationModule";
+export interface SimulatedNotificationsModuleOptions {
+    /**
+     * Generate random notifications. When false, notifications are only
+     * created by calls to `publish`. Default true.
+     */
+    simulate?: boolean;
+}
+export declare const SimulatedNotificationsModule: ({ simulate, }?: SimulatedNotificationsModuleOptions) => NotificationModule;

package/types/notifications/simulated/SimulatedNotificationsProvider.d.ts

@@ -0,0 +1,21 @@
+import type { Table } from "../../Table";
+import type { NotificationsProvider } from "../NotificationModule";
+/**
+ * Minimal implementation of the subset of Java String.format used by
+ * the message templates: %d, %0nd and %%. Args are consumed in order.
+ */
+export declare const formatMessage: (format: string, ...args: number[]) => string;
+/**
+ * Generates random notifications. Seeds an initial set of notifications on
+ * start then, on each cycle, deletes expired notifications and adds a new
+ * notification if fewer than the maximum are active.
+ */
+export declare class SimulatedNotificationsProvider implements NotificationsProvider {
+    #private;
+    constructor(table: Table);
+    start(): void;
+    stop(): void;
+    runOnce: () => void;
+    private generateRandomNotification;
+    private toDataRow;
+}

package/types/notifications/simulated/notificationsModule.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Simulated notifications. The provider starts generating notifications
+ * when the first dataSource is created for the notifications table.
+ */
+export declare const notificationsModule: import("..").NotificationModule;

package/types/schemas.d.ts

@@ -1,8 +1,10 @@
-import { TableSchema } from "@vuu-ui/vuu-data-types";
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
 import { type BasketsTableName } from "./basket/basket-schemas";
 import { type SimulTableName } from "./simul/simul-schemas";
-import { TestTableName } from "./test/TestModule";
-export type VuuTableName = BasketsTableName | SimulTableName | TestTableName;
+import { type TestTableName } from "./test/TestModule";
+import { type UserAdminTableName } from "@heswell/user-admin/contracts";
+import { type ModuleAdminTableName } from "./module-admin";
+export type VuuTableName = BasketsTableName | SimulTableName | TestTableName | UserAdminTableName | ModuleAdminTableName;
 export declare const schemas: Record<VuuTableName, TableSchema>;
 export declare const getAllSchemas: () => Record<VuuTableName, TableSchema>;
 export declare const getSchema: (tableName: VuuTableName) => Readonly<TableSchema>;

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

@@ -0,0 +1,54 @@
+import { type UserAdminSnapshot, type UserAdminTableName } from "@heswell/user-admin/contracts";
+import { InMemoryUserAdminStore } from "@heswell/user-admin/in-memory";
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+import { VuuModule, type RpcService } from "../core/module/VuuModule";
+import { Table } from "../Table";
+type UserAdminTables = Record<UserAdminTableName, Table>;
+export declare class UserAdminModule extends VuuModule<UserAdminTableName> {
+    #private;
+    readonly store: InMemoryUserAdminStore;
+    constructor(snapshot?: UserAdminSnapshot);
+    get schemas(): Record<UserAdminTableName, Readonly<TableSchema>>;
+    get tables(): UserAdminTables;
+    get menus(): {
+        clients: undefined;
+        group_roles: undefined;
+        groups: undefined;
+        roles: undefined;
+        user_group_roles: undefined;
+        user_groups: undefined;
+        users: undefined;
+    };
+    get visualLinks(): undefined;
+    get menuServices(): undefined;
+    get services(): Record<UserAdminTableName, RpcService[]>;
+    reconcile(): Promise<void>;
+    protected createSessionTable(sourceTable: Table, sessionTableName: string, editSessionMode: import("@vuu-ui/vuu-data-types").EditSessionMode | import("@vuu-ui/vuu-data-types").CopyOption, dataSource: import("../TickingArrayDataSource").TickingArrayDataSource, sessionType?: import("@vuu-ui/vuu-data-types").SessionType): Table;
+    protected beforeSessionSave(sourceTable: Table, sessionTable: Table): Promise<void>;
+    protected afterSessionSave(sourceTable: Table, sessionTable: Table): Promise<void>;
+    private saveGroupsFromSession;
+    private saveGroupRoleAssignments;
+    private resolveGroupRoleAssignments;
+    private saveClientRolesFromSession;
+    private mutation;
+    private addUser;
+    private updateUser;
+    private deleteUser;
+    private addGroup;
+    private updateGroup;
+    private deleteGroup;
+    private addClient;
+    private updateClient;
+    private addRole;
+    private addClientRole;
+    private updateRole;
+    private assignGroupRole;
+    private removeGroupRole;
+    private assignUserToGroup;
+    private removeUserFromGroup;
+    private getUserModuleAccessOptions;
+    private setUserModuleAccess;
+    private assertUsernameIsUnique;
+}
+export declare const userAdminModule: UserAdminModule;
+export {};

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

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

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

@@ -0,0 +1,2 @@
+import type { UserAdminSnapshot } from "@heswell/user-admin";
+export declare const USER_ADMIN_INITIAL_SNAPSHOT: UserAdminSnapshot;

package/types/user-admin/snapshot-projection.d.ts

@@ -0,0 +1,9 @@
+import type { UserAdminSnapshot, UserAdminTableName } from "@heswell/user-admin/contracts";
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import type { Table } from "../Table";
+type Row = Array<bigint | VuuRowDataItemType>;
+type Tables = Record<UserAdminTableName, Table>;
+export declare const resolveDisplayName: (name: string, configuredDisplayName?: string) => string;
+export declare const projectUserAdminSnapshot: (snapshot: UserAdminSnapshot, tables: Tables) => Record<UserAdminTableName, Row[]>;
+export declare const reconcileUserAdminTables: (snapshot: UserAdminSnapshot, tables: Tables) => void;
+export {};