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

package/package.json

@@ -1,24 +1,25 @@
 {
-  "version": "4.0.1",
+  "version": "5.0.0-alpha.1",
   "main": "./src/index.js",
   "author": "heswell",
   "license": "Apache-2.0",
+  "type": "module",
   "scripts": {
     "build": "node ../../scripts/build-worker.ts && node ../../scripts/run-build-rslib.ts",
-    "build:dev": "node ../../scripts/build-worker.ts &&  node ../../scripts/run-build.mjs -- --dev",
     "build:worker": "node ../../scripts/build-worker.ts",
     "test": "vitest run",
     "type-defs": "node ../../scripts/build-type-defs.mjs"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-data-types": "4.0.1",
-    "@vuu-ui/vuu-table-types": "4.0.1",
-    "@vuu-ui/vuu-filter-types": "4.0.1",
-    "@vuu-ui/vuu-protocol-types": "4.0.1"
+    "@vuu-ui/vuu-data-types": "5.0.0-alpha.1",
+    "@vuu-ui/vuu-table-types": "5.0.0-alpha.1",
+    "@vuu-ui/vuu-filter-types": "5.0.0-alpha.1",
+    "@vuu-ui/vuu-protocol-types": "5.0.0-alpha.1"
   },
   "dependencies": {
-    "@vuu-ui/vuu-filter-parser": "4.0.1",
-    "@vuu-ui/vuu-utils": "4.0.1"
+    "@vuu-ui/vuu-filter-parser": "5.0.0-alpha.1",
+    "@vuu-ui/vuu-utils": "5.0.0-alpha.1",
+    "@vuu-ui/vuu-data-editing": "5.0.0-alpha.1"
   },
   "files": [
     "README.md",
@@ -27,13 +28,12 @@
   ],
   "exports": {
     ".": {
+      "types": "./types/index.d.ts",
       "import": "./src/index.js",
-      "default": "./src/index.js",
-      "types": "./types/index.d.ts"
+      "default": "./src/index.js"
     }
   },
   "module": "./src/index.js",
   "name": "@vuu-ui/vuu-data-remote",
-  "type": "module",
   "types": "types/index.d.ts"
 }

package/src/ConnectionManager.js

@@ -2,20 +2,62 @@ import { DeferredPromise, EventEmitter, isConnectionQualityMetrics, isRequestRes
 import { isWebSocketConnectionStatus } from "./WebSocketConnection.js";
 import { DedicatedWorker } from "./DedicatedWorker.js";
 import { shouldMessageBeRoutedToDataSource } from "./data-source.js";
-class ConnectionManager extends EventEmitter {
-    static #instance;
+const DEFAULT_CONNECTION_ID = "portal";
+const MAX_CLOSED_VIEWPORTS = 500;
+class ConnectionChannel {
+    onConnectionStatus;
+    onConnectionMetrics;
     #connectionStatus = "closed";
     #deferredServerAPI = new DeferredPromise();
     #pendingRequests = new Map();
     #viewports = new Map();
+    #closedViewports = new Set();
     #worker;
-    constructor(){
-        super();
+    #serverAPI;
+    constructor(onConnectionStatus, onConnectionMetrics){
+        this.onConnectionStatus = onConnectionStatus;
+        this.onConnectionMetrics = onConnectionMetrics;
         this.#worker = new DedicatedWorker(this.handleMessageFromWorker);
-    }
-    static get instance() {
-        if (!ConnectionManager.#instance) ConnectionManager.#instance = new ConnectionManager();
-        return ConnectionManager.#instance;
+        this.#serverAPI = {
+            subscribe: (message, callback)=>{
+                if (this.#viewports.get(message.viewport)) throw Error("ConnectionManager attempting to subscribe with an existing viewport id");
+                this.#closedViewports.delete(message.viewport);
+                this.#viewports.set(message.viewport, {
+                    status: "subscribing",
+                    request: message,
+                    postMessageToClientDataSource: callback
+                });
+                this.#worker.send({
+                    type: "subscribe",
+                    ...message
+                });
+            },
+            unsubscribe: (viewport)=>{
+                this.#markClosed(viewport);
+                this.#worker.send({
+                    type: "unsubscribe",
+                    viewport
+                });
+            },
+            send: (message)=>{
+                this.#worker.send(message);
+            },
+            destroy: (viewportId)=>{
+                if (viewportId && this.#viewports.has(viewportId)) {
+                    this.#viewports.delete(viewportId);
+                    this.#markClosed(viewportId);
+                }
+            },
+            rpcCall: async (message)=>this.asyncRequest(message),
+            select: async (selectRequest)=>this.asyncRequest(selectRequest),
+            getTableList: async ()=>this.asyncRequest({
+                    type: "GET_TABLE_LIST"
+                }),
+            getTableSchema: async (table)=>this.asyncRequest({
+                    type: "GET_TABLE_META",
+                    table
+                })
+        };
     }
     get connectionStatus() {
         return this.#connectionStatus;
@@ -23,37 +65,62 @@ class ConnectionManager extends EventEmitter {
     get connected() {
         return "connected" === this.#connectionStatus || "reconnected" === this.#connectionStatus;
     }
+    get serverAPI() {
+        return this.#deferredServerAPI.promise;
+    }
     async connect(options, throwOnRejected = false) {
         try {
             const result = await this.#worker.connect(options);
-            if ("connected" === result) this.#deferredServerAPI.resolve(this.connectedServerAPI);
+            if ("connected" === result.status || "reconnected" === result.status) this.#deferredServerAPI.resolve(this.#serverAPI);
             return result;
         } catch (err) {
-            if (!throwOnRejected) return "connection-failed";
-            throw err;
+            if (throwOnRejected) throw err;
+            return {
+                status: "rejected"
+            };
         }
     }
     disableActiveSubscriptions() {
-        console.log("[ConnectionManager] disableActiveSubscriptions");
         this.#worker.send({
             type: "disable-all-active"
         });
     }
     enableActiveSubscriptions() {
-        console.log("[ConnectionManager] enableActiveSubscriptions");
         this.#worker.send({
             type: "enable-all-active"
         });
     }
+    async disconnect() {
+        try {
+            this.#worker.send({
+                type: "disconnect"
+            });
+            this.#deferredServerAPI = new DeferredPromise();
+            return "disconnected";
+        } catch  {
+            return "rejected";
+        }
+    }
+    destroy() {
+        this.#worker.terminate();
+    }
+    #markClosed(viewportId) {
+        this.#closedViewports.delete(viewportId);
+        this.#closedViewports.add(viewportId);
+        if (this.#closedViewports.size > MAX_CLOSED_VIEWPORTS) {
+            const [oldest] = this.#closedViewports;
+            this.#closedViewports.delete(oldest);
+        }
+    }
     handleMessageFromWorker = (message)=>{
         if (shouldMessageBeRoutedToDataSource(message)) {
             const viewport = this.#viewports.get(message.clientViewportId);
             if (viewport) viewport.postMessageToClientDataSource(message);
-            else console.error(`[ConnectionManager] ${message.type} message received, viewport not found`);
+            else this.#closedViewports.has(message.clientViewportId) || console.error("[ConnectionManager] %s message received, viewport not found", message.type);
         } else if (isWebSocketConnectionStatus(message)) {
             this.#connectionStatus = message;
-            this.emit("connection-status", message);
-        } else if (isConnectionQualityMetrics(message)) this.emit("connection-metrics", message);
+            this.onConnectionStatus(message);
+        } else if (isConnectionQualityMetrics(message)) this.onConnectionMetrics(message);
         else if (isRequestResponse(message)) {
             const { requestId } = message;
             if (this.#pendingRequests.has(requestId)) {
@@ -64,71 +131,112 @@ class ConnectionManager extends EventEmitter {
             } else console.warn("%cConnectionManager Unexpected message from the worker", "color:red;font-weight:bold;");
         }
     };
-    get serverAPI() {
-        return this.#deferredServerAPI.promise;
-    }
-    connectedServerAPI = {
-        subscribe: (message, callback)=>{
-            if (this.#viewports.get(message.viewport)) throw Error("ConnectionManager attempting to subscribe with an existing viewport id");
-            this.#viewports.set(message.viewport, {
-                status: "subscribing",
-                request: message,
-                postMessageToClientDataSource: callback
-            });
-            this.#worker.send({
-                type: "subscribe",
-                ...message
-            });
-        },
-        unsubscribe: (viewport)=>{
-            this.#worker.send({
-                type: "unsubscribe",
-                viewport
-            });
-        },
-        send: (message)=>{
-            this.#worker.send(message);
-        },
-        destroy: (viewportId)=>{
-            if (viewportId && this.#viewports.has(viewportId)) this.#viewports.delete(viewportId);
-        },
-        rpcCall: async (message)=>this.asyncRequest(message),
-        select: async (selectRequest)=>this.asyncRequest(selectRequest),
-        getTableList: async ()=>this.asyncRequest({
-                type: "GET_TABLE_LIST"
-            }),
-        getTableSchema: async (table)=>this.asyncRequest({
-                type: "GET_TABLE_META",
-                table
-            })
-    };
     asyncRequest = (msg)=>{
         const requestId = uuid();
         this.#worker.send({
             requestId,
             ...msg
         });
-        return new Promise((resolve, reject)=>{
+        return new Promise((resolve)=>{
             this.#pendingRequests.set(requestId, {
-                resolve,
-                reject
+                resolve: (value)=>resolve(value)
             });
         });
     };
+}
+class ConnectionManager extends EventEmitter {
+    static #instance;
+    #connections = new Map();
+    #connectionStatusListeners = new Map();
+    constructor(){
+        super();
+    }
+    static get instance() {
+        if (!ConnectionManager.#instance) ConnectionManager.#instance = new ConnectionManager();
+        return ConnectionManager.#instance;
+    }
+    getConnection(connectionId = DEFAULT_CONNECTION_ID) {
+        const existing = this.#connections.get(connectionId);
+        if (existing) return existing;
+        const connection = new ConnectionChannel((status)=>{
+            this.#connectionStatusListeners.get(connectionId)?.forEach((listener)=>listener(status));
+            if (connectionId === DEFAULT_CONNECTION_ID) this.emit("connection-status", status);
+        }, (metrics)=>{
+            if (connectionId === DEFAULT_CONNECTION_ID) this.emit("connection-metrics", metrics);
+        });
+        this.#connections.set(connectionId, connection);
+        return connection;
+    }
+    get connectionStatus() {
+        return this.connectionStatusFor(DEFAULT_CONNECTION_ID);
+    }
+    get connected() {
+        return this.connectedFor(DEFAULT_CONNECTION_ID);
+    }
+    connectionStatusFor(connectionId) {
+        return this.getConnection(connectionId).connectionStatus;
+    }
+    connectedFor(connectionId) {
+        return this.getConnection(connectionId).connected;
+    }
+    onConnectionStatus(connectionId, listener) {
+        const listeners = this.#connectionStatusListeners.get(connectionId) ?? new Set();
+        listeners.add(listener);
+        this.#connectionStatusListeners.set(connectionId, listeners);
+        return ()=>{
+            listeners.delete(listener);
+            if (0 === listeners.size) this.#connectionStatusListeners.delete(connectionId);
+        };
+    }
+    async connect(options, throwOnRejected = false) {
+        return this.connectTo(DEFAULT_CONNECTION_ID, options, throwOnRejected);
+    }
+    async connectTo(connectionId, options, throwOnRejected = false) {
+        const result = await this.connectWithLoginResponseTo(connectionId, options, throwOnRejected);
+        return "rejected" === result.status ? "connection-failed" : result.status;
+    }
+    async connectWithLoginResponseTo(connectionId, options, throwOnRejected = false) {
+        return this.getConnection(connectionId).connect(options, throwOnRejected);
+    }
+    disableActiveSubscriptions() {
+        for (const connection of this.#connections.values())connection.disableActiveSubscriptions();
+    }
+    enableActiveSubscriptions() {
+        for (const connection of this.#connections.values())connection.enableActiveSubscriptions();
+    }
+    disableActiveSubscriptionsFor(connectionId) {
+        this.getConnection(connectionId).disableActiveSubscriptions();
+    }
+    enableActiveSubscriptionsFor(connectionId) {
+        this.getConnection(connectionId).enableActiveSubscriptions();
+    }
+    get serverAPI() {
+        return this.serverAPIFor(DEFAULT_CONNECTION_ID);
+    }
+    serverAPIFor(connectionId) {
+        return this.getConnection(connectionId).serverAPI;
+    }
     async disconnect() {
-        try {
-            this.#worker.send({
-                type: "disconnect"
-            });
-            this.#deferredServerAPI = new DeferredPromise();
-            return "disconnected";
-        } catch (err) {
-            return "rejected";
+        return this.disconnectFrom(DEFAULT_CONNECTION_ID);
+    }
+    async disconnectFrom(connectionId) {
+        return this.getConnection(connectionId).disconnect();
+    }
+    async destroyConnection(connectionId) {
+        const connection = this.#connections.get(connectionId);
+        if (connection) {
+            await connection.disconnect();
+            connection.destroy();
+            this.#connections.delete(connectionId);
         }
+        this.#connectionStatusListeners.delete(connectionId);
     }
     destroy() {
-        this.#worker.terminate();
+        for (const connection of this.#connections.values())connection.destroy();
+        this.#connections.clear();
+        this.#connectionStatusListeners.clear();
     }
 }
-var src_ConnectionManager = ConnectionManager.instance;
+const src_ConnectionManager = ConnectionManager.instance;
 export default src_ConnectionManager;
+export { DEFAULT_CONNECTION_ID };

package/src/DedicatedWorker.js

@@ -21,8 +21,11 @@ class DedicatedWorker {
             if ("ready" === message.type) {
                 window.clearTimeout(timer);
                 deferredWorker.resolve(worker);
-            } else if ("connected" === message.type) this.#deferredConnection?.resolve("connected");
-            else if ("connection-failed" === message.type) this.#deferredConnection?.reject(message.reason);
+            } else if ("connected" === message.type) this.#deferredConnection?.resolve({
+                loginResponse: message.loginResponse,
+                status: "connected"
+            });
+            else if ("connection-failed" === message.type) this.#deferredConnection?.reject(Error(message.reason));
             else onMessage(message);
         };
     }

package/src/VuuDataSource.js

@@ -13,6 +13,7 @@ class VuuDataSource extends BaseDataSource {
     bufferSize;
     server = null;
     rangeRequest;
+    #connectionId;
     #autosubscribeColumns = [];
     #pendingVisualLink;
     #links;
@@ -28,7 +29,7 @@ class VuuDataSource extends BaseDataSource {
     #tableSchema;
     isRemote = true;
     table;
-    constructor({ autosubscribeColumns, columns, session, sessionTableMessageColumn, ...props }){
+    constructor({ autosubscribeColumns, columns, session, connectionId = "portal", sessionTableMessageColumn, ...props }){
         super({
             ...props,
             columns: autosubscribeColumns ? combineColumnsWithAutosubscribeColumns(columns ?? [], autosubscribeColumns) : columns
@@ -37,6 +38,7 @@ class VuuDataSource extends BaseDataSource {
         if (!table) throw Error("RemoteDataSource constructor called without table");
         this.bufferSize = bufferSize;
         this.table = table;
+        this.#connectionId = connectionId;
         this.#pendingVisualLink = visualLink;
         this.#session = session;
         this.#sessionTableMessageColumn = sessionTableMessageColumn;
@@ -48,11 +50,15 @@ class VuuDataSource extends BaseDataSource {
             ...subscribeProps,
             columns: combineColumnsWithAutosubscribeColumns(subscribeProps.columns, this.#autosubscribeColumns)
         } : subscribeProps, callback);
-        const { viewport = this.viewport || (this.viewport = uuid()) } = subscribeProps;
+        let viewport = subscribeProps.viewport ?? this.viewport;
+        if (!viewport) {
+            viewport = uuid();
+            this.viewport = viewport;
+        }
         if ("disabled" === this.#status || "disabling" === this.#status || "enabling" === this.#status) return void this.enable(callback);
         if ("initialising" !== this.#status && "unsubscribed" !== this.#status) throw Error(`[VuuDataSource] invalid status ${this.#status} for subscribe`);
         this.#status = "subscribing";
-        this.server = await ConnectionManager.serverAPI;
+        this.server = await ConnectionManager.serverAPIFor(this.#connectionId);
         const { bufferSize } = this;
         const { columns, ...dataSourceConfig } = combineFilters(this.config);
         this.server?.subscribe({
@@ -430,6 +436,7 @@ class VuuDataSource extends BaseDataSource {
             assertExpectedSessionTable(sessionTable, effectiveOverrides?.table);
             const sessionDataSource = new VuuDataSource({
                 ...sessionDataSourceConfig(this.config, effectiveOverrides?.columns),
+                connectionId: this.#connectionId,
                 table: sessionTable,
                 viewport: sessionTable.table
             });

package/src/WebSocketConnection.js

@@ -1,4 +1,4 @@
-import { DeferredPromise, EventEmitter, isLoginErrorMessage, logger } from "@vuu-ui/vuu-utils";
+import { DeferredPromise, EventEmitter, INVALID_SESSION, INVALID_TOKEN, SESSION_LIMIT_EXCEEDED, isLoginErrorMessage, logger } from "@vuu-ui/vuu-utils";
 const isInvalidTokenReason = (text)=>"Invalid token" === text || "Token has expired" === text;
 const isInvalidSessionReason = (text)=>"Invalid session" === text || "User session limit exceeded" === text;
 const { debug: debug, debugEnabled: debugEnabled, info: info } = logger("WebSocketConnection");
@@ -10,11 +10,24 @@ const isWebSocketConnectionStatus = (msg)=>"string" == typeof msg && [
         "reconnected",
         "disconnected",
         "closed",
-        "failed"
+        "failed",
+        "session-evicted"
     ].includes(msg);
 const isConnected = (status)=>"connected" === status || "reconnected" === status;
 const isLoginRejectedMessage = (message)=>null !== message && "type" in message && "LOGIN_REJECTED" === message.type;
 const DEFAULT_CONNECTION_TIMEOUT = 10000;
+const VuuCloseCode = {
+    SessionEvicted: 4001,
+    InvalidSession: 4002,
+    SessionLimitReached: 4003,
+    LoginFailed: 4004
+};
+const loginRefusalReasons = {
+    [VuuCloseCode.InvalidSession]: INVALID_SESSION,
+    [VuuCloseCode.SessionLimitReached]: SESSION_LIMIT_EXCEEDED,
+    [VuuCloseCode.LoginFailed]: INVALID_TOKEN
+};
+const looksLikeJson = (data)=>"string" == typeof data && data.trimStart().startsWith("{");
 const parseWebSocketMessage = (message)=>{
     try {
         return JSON.parse(message);
@@ -81,7 +94,14 @@ class WebSocketConnection extends EventEmitter {
         const timer = setTimeout(()=>{
             throw Error(`Failed to open WebSocket connection to ${url}, timed out after ${connectionTimeout}ms`);
         }, connectionTimeout);
-        const ws = this.#ws = new WebSocket(url, protocols);
+        console.log(`create websocket ${url} ${protocols}`);
+        try {
+            this.#ws = new WebSocket(url, protocols);
+        } catch (e) {
+            console.error(e);
+            return;
+        }
+        const ws = this.#ws;
         ws.onopen = ()=>{
             this.connectionStatus = "websocket-open";
             clearTimeout(timer);
@@ -93,7 +113,23 @@ class WebSocketConnection extends EventEmitter {
         ws.onerror = ()=>{
             clearTimeout(timer);
         };
-        ws.onclose = ()=>{
+        ws.onclose = (evt)=>{
+            const code = evt?.code;
+            if (!this.isClosed && code === VuuCloseCode.SessionEvicted) {
+                this.confirmedOpen = false;
+                this.connectionStatus = "session-evicted";
+                this.close("failure");
+                return;
+            }
+            const refusal = void 0 === code ? void 0 : loginRefusalReasons[code];
+            if (!this.isClosed && !this.confirmedOpen && refusal) {
+                this.#callback({
+                    type: "LOGIN_REJECTED",
+                    reason: refusal
+                });
+                this.close(refusal);
+                return;
+            }
             if (!this.isClosed) {
                 this.confirmedOpen = false;
                 this.connectionStatus = "disconnected";
@@ -114,7 +150,7 @@ class WebSocketConnection extends EventEmitter {
                 reason: evt.data
             });
             this.close(evt.data);
-        } else {
+        } else if (this.confirmedOpen || looksLikeJson(evt.data)) {
             const vuuMessageFromServer = parseWebSocketMessage(evt.data);
             if (debugEnabled) {
                 if ("HB" !== vuuMessageFromServer.body.type) {
@@ -129,7 +165,7 @@ class WebSocketConnection extends EventEmitter {
                     this.confirmedOpen = true;
                 }
             }
-        }
+        } else console.warn(`[WebSocketConnection] login refused: ${evt.data}`);
     };
     send = (msg)=>{
         if ("CHANGE_VP_RANGE" === msg.body.type) info?.(`===> CHANGE_VP_RANGE<#${msg.requestId}> ${msg.body.from}-${msg.body.to}`);
@@ -139,11 +175,11 @@ class WebSocketConnection extends EventEmitter {
         this.connectionStatus = "closed";
         if ("failure" === reason) {
             if (this.#deferredOpen) {
-                this.#deferredOpen.reject(Error("connection failed"));
+                this.#deferredOpen.reject(Error(`Unable to connect to VUU server at ${this.#url}`));
                 this.#deferredOpen = void 0;
             }
         } else this.#ws?.close();
         this.#ws = void 0;
     }
 }
-export { WebSocketConnection, isConnected, isInvalidSessionReason, isInvalidTokenReason, isLoginRejectedMessage, isWebSocketConnectionStatus };
+export { VuuCloseCode, WebSocketConnection, isConnected, isInvalidSessionReason, isInvalidTokenReason, isLoginRejectedMessage, isWebSocketConnectionStatus };

package/src/index.js

@@ -3,9 +3,5 @@ export * from "./constants.js";
 export * from "./data-source.js";
 export * from "./message-utils.js";
 export * from "./VuuDataSource.js";
-export { authenticate, getVuuAuthToken, parseVuuUserFromToken } from "./authenticate.js";
 export { default as ConnectionManager } from "./ConnectionManager.js";
-export { LostConnectionHandler, RetryOptions } from "./LostConnectionHandler.js";
-export { VuuAuthTokenIssuePolicy, VuuAuthenticator } from "./VuuAuthenticator.js";
-export { VuuAuthProvider } from "./VuuAuthProvider.js";
 export { isConnected } from "./WebSocketConnection.js";