@vuu-ui/vuu-data-test 4.0.1 → 5.0.0-alpha.1

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,14 +1,14 @@
-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;
-    createJoinTable(joinTable: VuuTable, { table: t1 }: VuuTable, { table: t2 }: VuuTable, joinColumn: string): Table;
+    createTable: (schema: TableSchema, data?: Array<Array<VuuRowDataItemType | bigint>>, dataMap?: ColumnMap, updateGenerator?: UpdateGenerator) => 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/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 { ReactNode } from "react";
-export declare const LocalDataSourceProvider: ({ children, }: {
+import { type LocalVuuServer } from "@vuu-ui/core";
+import type { ReactNode } from "react";
+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-runtime").JSX.Element;
+}) => import("react").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/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/vuu-row-generator.d.ts

@@ -1,6 +1,6 @@
 import type { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
 import type { VuuRowDataItemType, VuuTable } from "@vuu-ui/vuu-protocol-types";
-import { UpdateGenerator } from "./rowUpdates";
+import type { UpdateGenerator } from "./rowUpdates";
 type GenerateRowFunc = (index: number) => VuuRowDataItemType[];
 export type RowGeneratorFactory = (columns: string[]) => GenerateRowFunc;
 export type ColumnGeneratorFn = (columns?: number | string[], columnConfig?: {