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

package/types/ConnectionManager.d.ts

@@ -1,35 +1,63 @@
-import { ConnectOptions, DataSourceCallbackMessage, ServerAPI } from "@vuu-ui/vuu-data-types";
+import type { ConnectOptions, DataSourceCallbackMessage, ServerAPI } from "@vuu-ui/vuu-data-types";
+import type { VuuLoginSuccessResponse } from "@vuu-ui/vuu-protocol-types";
 import { EventEmitter } from "@vuu-ui/vuu-utils";
-import { ConnectionStatus, WebSocketConnectionEvents } from "./WebSocketConnection";
-import { ConnectionQualityMetrics } from "@vuu-ui/vuu-data-types";
+import type { ConnectionQualityMetrics } from "@vuu-ui/vuu-data-types";
+import type { ConnectionStatus, WebSocketConnectionEvents } from "./WebSocketConnection";
+export declare const DEFAULT_CONNECTION_ID = "portal";
 export type PostMessageToClientCallback = (msg: DataSourceCallbackMessage) => void;
 export type ConnectionEvents = WebSocketConnectionEvents & {
     "connection-metrics": (message: ConnectionQualityMetrics) => void;
 };
+export type ConnectionStatusListener = (status: ConnectionStatus) => void;
+export type VuuConnectionResult = {
+    loginResponse: VuuLoginSuccessResponse & {
+        sessionId: string;
+    };
+    status: "connected" | "reconnected";
+} | {
+    status: "rejected";
+};
+/**
+ * Process-wide registry for VUU server connections.
+ *
+ * Consumers use the exported singleton to connect, obtain a deferred
+ * `ServerAPI`, and control subscriptions. The unscoped methods operate on the
+ * legacy `portal` connection, while the `*To` and `*For` methods select an
+ * independent connection by ID. This allows remote modules to share the manager
+ * without sharing authentication, worker state, or viewport subscriptions.
+ *
+ * Connection status and metrics events are emitted for the default connection
+ * to preserve the existing application-level monitoring API.
+ */
 declare class ConnectionManager extends EventEmitter<ConnectionEvents> {
     #private;
     private constructor();
     static get instance(): ConnectionManager;
+    private getConnection;
     get connectionStatus(): ConnectionStatus;
     get connected(): boolean;
-    /**
-     * Open a connection to the VuuServer. This method opens the websocket connection
-     * and logs in. It can be called from whichever client code has access to the auth
-     * token (eg. the login page, or just a hardcoded login script in a sample).
-     * This will unblock any DataSources which may have already tried to subscribe to data,
-     * but lacked access to the auth token.
-     *
-     * @param serverUrl
-     * @param token
-     */
-    connect(options: ConnectOptions, throwOnRejected?: boolean): Promise<"connected" | "connection-failed" | "reconnected" | "rejected">;
+    connectionStatusFor(connectionId: string): ConnectionStatus;
+    connectedFor(connectionId: string): boolean;
+    onConnectionStatus(connectionId: string, listener: ConnectionStatusListener): () => void;
+    connect(options: ConnectOptions, throwOnRejected?: boolean): Promise<"connected" | "connection-failed" | "reconnected">;
+    connectTo(connectionId: string, options: ConnectOptions, throwOnRejected?: boolean): Promise<"connected" | "connection-failed" | "reconnected">;
+    connectWithLoginResponseTo(connectionId: string, options: ConnectOptions, throwOnRejected?: boolean): Promise<{
+        loginResponse: VuuLoginSuccessResponse & {
+            sessionId: string;
+        };
+        status: "connected" | "reconnected";
+    } | {
+        readonly status: "rejected";
+    }>;
     disableActiveSubscriptions(): void;
     enableActiveSubscriptions(): void;
-    private handleMessageFromWorker;
+    disableActiveSubscriptionsFor(connectionId: string): void;
+    enableActiveSubscriptionsFor(connectionId: string): void;
     get serverAPI(): Promise<ServerAPI>;
-    private connectedServerAPI;
-    private asyncRequest;
+    serverAPIFor(connectionId: string): Promise<ServerAPI>;
     disconnect(): Promise<"disconnected" | "rejected">;
+    disconnectFrom(connectionId: string): Promise<"disconnected" | "rejected">;
+    destroyConnection(connectionId: string): Promise<void>;
     destroy(): void;
 }
 declare const _default: ConnectionManager;

package/types/DedicatedWorker.d.ts

@@ -1,9 +1,16 @@
-import { ConnectOptions, VuuUIMessageIn, VuuUIMessageOut, WithRequestId } from "@vuu-ui/vuu-data-types";
-import { SelectRequest, VuuCreateVisualLink, VuuRemoveVisualLink, VuuRpcMenuRequest, VuuRpcServiceRequest } from "@vuu-ui/vuu-protocol-types";
+import type { ConnectOptions, VuuUIMessageIn, VuuUIMessageOut, WithRequestId } from "@vuu-ui/vuu-data-types";
+import type { SelectRequest, VuuLoginSuccessResponse, VuuCreateVisualLink, VuuRemoveVisualLink, VuuRpcMenuRequest, VuuRpcServiceRequest } from "@vuu-ui/vuu-protocol-types";
 export declare class DedicatedWorker {
     #private;
     constructor(onMessage: (msg: VuuUIMessageIn) => void);
-    connect(options: ConnectOptions): Promise<"connected" | "reconnected" | "rejected">;
+    connect(options: ConnectOptions): Promise<{
+        loginResponse: VuuLoginSuccessResponse & {
+            sessionId: string;
+        };
+        status: "connected" | "reconnected";
+    } | {
+        status: "rejected";
+    }>;
     send(message: VuuUIMessageOut | WithRequestId<VuuCreateVisualLink | VuuRemoveVisualLink | VuuRpcServiceRequest | VuuRpcMenuRequest | SelectRequest>): Promise<void>;
     terminate(): Promise<void>;
 }

package/types/VuuDataSource.d.ts

@@ -10,7 +10,7 @@ export declare class VuuDataSource extends BaseDataSource implements DataSourceB
     rangeRequest: RangeRequest;
     readonly isRemote = true;
     table: VuuTable;
-    constructor({ autosubscribeColumns, columns, session, sessionTableMessageColumn, ...props }: DataSourceConstructorProps);
+    constructor({ autosubscribeColumns, columns, session, connectionId, sessionTableMessageColumn, ...props }: DataSourceConstructorProps);
     subscribe(subscribeProps: DataSourceSubscribeProps, callback: DataSourceSubscribeCallback): Promise<void>;
     handleMessageFromServer: (message: DataSourceCallbackMessage) => void;
     handleSessionMessageFromServer: (msg: DataSourceCallbackMessage) => void;

package/types/WebSocketConnection.d.ts

@@ -1,10 +1,15 @@
-import { WebSocketProtocol } from "@vuu-ui/vuu-data-types";
-import { InvalidSessionReason, InvalidTokenReason, LoginErrorMessage, VuuClientMessage, VuuServerMessage } from "@vuu-ui/vuu-protocol-types";
+import type { WebSocketProtocol } from "@vuu-ui/vuu-data-types";
+import type { InvalidSessionReason, InvalidTokenReason, LoginErrorMessage, VuuClientMessage, VuuServerMessage } from "@vuu-ui/vuu-protocol-types";
 import { EventEmitter } from "@vuu-ui/vuu-utils";
 export type ConnectionPhase = "initial-connection" | "post-disconnect-reconnection";
 export type ConnectingStatus = "connecting" | "reconnecting";
 export type ConnectedStatus = "connected" | "reconnected";
-export type ConnectionStatus = ConnectingStatus | ConnectedStatus | "closed" | "websocket-open" | "disconnected" | "failed" | "inactive";
+export type ConnectionStatus = ConnectingStatus | ConnectedStatus | "closed" | "websocket-open" | "disconnected" | "failed" | "connection-failed" | "inactive"
+/**
+ * The server ended the session because the user logged in again
+ * elsewhere. Not reconnected: that would evict the other session.
+ */
+ | "session-evicted";
 export declare const isInvalidTokenReason: (text: string) => text is InvalidTokenReason;
 export declare const isInvalidSessionReason: (text: string) => text is InvalidSessionReason;
 export declare const isWebSocketConnectionStatus: (msg: unknown) => msg is ConnectionStatus;
@@ -21,6 +26,16 @@ export type WebSocketConnectionConfig = {
     callback: VuuServerMessageCallback;
     connectionTimeout?: number;
 };
+/** WebSocket close codes a Vuu server uses to end or refuse a session. */
+export declare const VuuCloseCode: {
+    /** The user logged in again and this (oldest) session was evicted. */
+    readonly SessionEvicted: 4001;
+    readonly InvalidSession: 4002;
+    /** Login refused, the user already has maxSessionsPerUser sessions. */
+    readonly SessionLimitReached: 4003;
+    /** Login refused, e.g. an invalid or expired token. */
+    readonly LoginFailed: 4004;
+};
 export type WebSocketConnectionCloseReason = LoginErrorMessage | "failure" | "shutdown";
 export type WebSocketConnectionEvents = {
     "connection-status": (status: ConnectionStatus) => void;

package/types/index.d.ts

@@ -1,11 +1,7 @@
-export { authenticate, getVuuAuthToken, parseVuuUserFromToken, } from "./authenticate";
 export * from "./ConnectionManager";
 export { default as ConnectionManager } from "./ConnectionManager";
 export * from "./constants";
 export * from "./data-source";
-export { LostConnectionHandler, RetryOptions } from "./LostConnectionHandler";
 export * from "./message-utils";
-export { VuuAuthenticator, VuuAuthTokenIssuePolicy } from "./VuuAuthenticator";
-export { VuuAuthProvider, type AuthProvider } from "./VuuAuthProvider";
 export * from "./VuuDataSource";
 export { isConnected, type ConnectionStatus } from "./WebSocketConnection";