@vuu-ui/vuu-data-remote 4.0.0-alpha.8 → 4.0.0-beta.1

package/src/server-proxy/array-backed-moving-window.js

@@ -33,7 +33,8 @@ class ArrayBackedMovingWindow {
     }
     setRowCount = (rowCount)=>{
         log.info?.(`setRowCount ${rowCount}`);
-        if (rowCount < this.internalData.length) this.internalData.length = rowCount;
+        const dataLength = Math.max(0, rowCount - this.#range.from);
+        if (dataLength < this.internalData.length) this.internalData.length = dataLength;
         if (rowCount < this.rowCount) {
             this.rowsWithinRange = 0;
             const end = Math.min(rowCount, this.clientRange.to);
@@ -68,10 +69,13 @@ class ArrayBackedMovingWindow {
         log.debug?.(`setClientRange ${from} - ${to}`);
         const currentFrom = this.clientRange.from;
         const currentTo = Math.min(this.clientRange.to, this.rowCount);
-        if (from === currentFrom && to === currentTo) return [
-            false,
-            EMPTY_ARRAY
-        ];
+        if (from === currentFrom && to === currentTo) {
+            this.clientRange.to = to;
+            return [
+                false,
+                EMPTY_ARRAY
+            ];
+        }
         const originalRange = this.clientRange.copy();
         this.clientRange.from = from;
         this.clientRange.to = to;
@@ -82,18 +86,9 @@ class ArrayBackedMovingWindow {
         }
         const clientRows = [];
         const offset = this.#range.from;
-        if (to > originalRange.to) {
-            const start = Math.max(from, originalRange.to);
-            for(let i = start - offset; i < to - offset; i++){
-                const row = this.internalData[i];
-                if (row) clientRows.push(row);
-            }
-        } else {
-            const end = Math.min(originalRange.from, to);
-            for(let i = from - offset; i < end - offset; i++){
-                const row = this.internalData[i];
-                if (row) clientRows.push(row);
-            }
+        for(let i = from; i < to; i++)if (i < originalRange.from || i >= originalRange.to) {
+            const row = this.internalData[i - offset];
+            if (row) clientRows.push(row);
         }
         const serverDataRequired = this.bufferBreakout(from, to);
         return [

package/src/server-proxy/server-proxy.js

@@ -180,8 +180,6 @@ class ServerProxy {
     unsubscribe(clientViewportId) {
         const serverViewportId = this.mapClientToServerViewport.get(clientViewportId);
         if (serverViewportId) {
-            this.mapClientToServerViewport.delete(clientViewportId);
-            this.viewports.delete(serverViewportId);
             info?.(`Unsubscribe Message (Client to Server):
         ${serverViewportId}`);
             this.sendMessageToServer({
@@ -516,13 +514,12 @@ class ServerProxy {
             case "LOGIN_SUCCESS":
                 if (sessionId) {
                     this.sessionId = sessionId;
-                    const loginResponse = {
+                    this.pendingLogin?.resolve(sessionId);
+                    this.pendingLogin = void 0;
+                    this.postMessageToClient({
                         ...body,
                         sessionId
-                    };
-                    this.pendingLogin?.resolve(loginResponse);
-                    this.pendingLogin = void 0;
-                    this.postMessageToClient(loginResponse);
+                    });
                 } else throw Error("LOGIN_SUCCESS did not provide sessionId");
                 break;
             case "REMOVE_VP_SUCCESS":

package/src/worker.js

@@ -30,11 +30,10 @@ const handleMessageFromClient = async ({ data: message })=>{
     switch(message.type){
         case "connect":
             try {
-                const loginResponse = await connectToServer(message.url, message.protocol, message.token);
-                if (!loginResponse) throw Error("VUU server did not return a LOGIN_SUCCESS response");
+                const sessionId = await connectToServer(message.url, message.protocol, message.token);
                 postMessage({
                     type: "connected",
-                    loginResponse
+                    sessionId
                 });
             } catch (err) {
                 postMessage({

package/types/ConnectionManager.d.ts

@@ -1,63 +1,35 @@
-import type { ConnectOptions, DataSourceCallbackMessage, ServerAPI } from "@vuu-ui/vuu-data-types";
-import type { VuuLoginSuccessResponse } from "@vuu-ui/vuu-protocol-types";
+import { ConnectOptions, DataSourceCallbackMessage, ServerAPI } from "@vuu-ui/vuu-data-types";
 import { EventEmitter } from "@vuu-ui/vuu-utils";
-import type { ConnectionQualityMetrics } from "@vuu-ui/vuu-data-types";
-import type { ConnectionStatus, WebSocketConnectionEvents } from "./WebSocketConnection";
-export declare const DEFAULT_CONNECTION_ID = "portal";
+import { ConnectionStatus, WebSocketConnectionEvents } from "./WebSocketConnection";
+import { ConnectionQualityMetrics } from "@vuu-ui/vuu-data-types";
 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;
-    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";
-    }>;
+    /**
+     * 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">;
     disableActiveSubscriptions(): void;
     enableActiveSubscriptions(): void;
-    disableActiveSubscriptionsFor(connectionId: string): void;
-    enableActiveSubscriptionsFor(connectionId: string): void;
+    private handleMessageFromWorker;
     get serverAPI(): Promise<ServerAPI>;
-    serverAPIFor(connectionId: string): Promise<ServerAPI>;
+    private connectedServerAPI;
+    private asyncRequest;
     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,16 +1,9 @@
-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";
+import { ConnectOptions, VuuUIMessageIn, VuuUIMessageOut, WithRequestId } from "@vuu-ui/vuu-data-types";
+import { SelectRequest, VuuCreateVisualLink, VuuRemoveVisualLink, VuuRpcMenuRequest, VuuRpcServiceRequest } from "@vuu-ui/vuu-protocol-types";
 export declare class DedicatedWorker {
     #private;
     constructor(onMessage: (msg: VuuUIMessageIn) => void);
-    connect(options: ConnectOptions): Promise<{
-        loginResponse: VuuLoginSuccessResponse & {
-            sessionId: string;
-        };
-        status: "connected" | "reconnected";
-    } | {
-        status: "rejected";
-    }>;
+    connect(options: ConnectOptions): Promise<"connected" | "reconnected" | "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({ session, connectionId, sessionTableMessageColumn, ...props }: DataSourceConstructorProps);
+    constructor({ session, 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,10 @@
-import type { WebSocketProtocol } from "@vuu-ui/vuu-data-types";
-import type { InvalidSessionReason, InvalidTokenReason, LoginErrorMessage, VuuClientMessage, VuuServerMessage } from "@vuu-ui/vuu-protocol-types";
+import { WebSocketProtocol } from "@vuu-ui/vuu-data-types";
+import { 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" | "connection-failed" | "inactive";
+export type ConnectionStatus = ConnectingStatus | ConnectedStatus | "closed" | "websocket-open" | "disconnected" | "failed" | "inactive";
 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;

package/types/index.d.ts

@@ -1,7 +1,11 @@
+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";