@vuu-ui/vuu-data-remote 2.1.19-beta.1 → 2.1.19-beta.2

package/package.json

@@ -1,27 +1,26 @@
 {
-  "version": "2.1.19-beta.1",
+  "version": "2.1.19-beta.2",
   "author": "heswell",
   "license": "Apache-2.0",
   "type": "module",
   "devDependencies": {
-    "@vuu-ui/vuu-data-types": "2.1.19-beta.1",
-    "@vuu-ui/vuu-table-types": "2.1.19-beta.1",
-    "@vuu-ui/vuu-filter-types": "2.1.19-beta.1",
-    "@vuu-ui/vuu-protocol-types": "2.1.19-beta.1"
+    "@vuu-ui/vuu-data-types": "2.1.19-beta.2",
+    "@vuu-ui/vuu-table-types": "2.1.19-beta.2",
+    "@vuu-ui/vuu-filter-types": "2.1.19-beta.2",
+    "@vuu-ui/vuu-protocol-types": "2.1.19-beta.2"
   },
   "dependencies": {
-    "@vuu-ui/vuu-filter-parser": "2.1.19-beta.1",
-    "@vuu-ui/vuu-utils": "2.1.19-beta.1"
+    "@vuu-ui/vuu-filter-parser": "2.1.19-beta.2",
+    "@vuu-ui/vuu-utils": "2.1.19-beta.2"
   },
   "files": [
     "README.md",
-    "esm",
-    "cjs",
+    "src",
     "/types"
   ],
   "exports": {
     ".": {
-      "import": "./index.js",
+      "import": "./src/index.js",
       "types": "./types/index.d.ts"
     }
   },

package/src/ConnectionManager.js

@@ -0,0 +1,134 @@
+import { DeferredPromise, EventEmitter, isConnectionQualityMetrics, isRequestResponse, isTableSchemaMessage, messageHasResult, uuid } from "@vuu-ui/vuu-utils";
+import { isWebSocketConnectionStatus } from "./WebSocketConnection.js";
+import { DedicatedWorker } from "./DedicatedWorker.js";
+import { shouldMessageBeRoutedToDataSource } from "./data-source.js";
+class ConnectionManager extends EventEmitter {
+    static #instance;
+    #connectionStatus = "closed";
+    #deferredServerAPI = new DeferredPromise();
+    #pendingRequests = new Map();
+    #viewports = new Map();
+    #worker;
+    constructor(){
+        super();
+        this.#worker = new DedicatedWorker(this.handleMessageFromWorker);
+    }
+    static get instance() {
+        if (!ConnectionManager.#instance) ConnectionManager.#instance = new ConnectionManager();
+        return ConnectionManager.#instance;
+    }
+    get connectionStatus() {
+        return this.#connectionStatus;
+    }
+    get connected() {
+        return "connected" === this.#connectionStatus || "reconnected" === this.#connectionStatus;
+    }
+    async connect(options, throwOnRejected = false) {
+        try {
+            const result = await this.#worker.connect(options);
+            if ("connected" === result) this.#deferredServerAPI.resolve(this.connectedServerAPI);
+            return result;
+        } catch (err) {
+            if (!throwOnRejected) return "connection-failed";
+            throw err;
+        }
+    }
+    disableActiveSubscriptions() {
+        console.log("[ConnectionManager] disableActiveSubscriptions");
+        this.#worker.send({
+            type: "disable-all-active"
+        });
+    }
+    enableActiveSubscriptions() {
+        console.log("[ConnectionManager] enableActiveSubscriptions");
+        this.#worker.send({
+            type: "enable-all-active"
+        });
+    }
+    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 if (isWebSocketConnectionStatus(message)) {
+            this.#connectionStatus = message;
+            this.emit("connection-status", message);
+        } else if (isConnectionQualityMetrics(message)) this.emit("connection-metrics", message);
+        else if (isRequestResponse(message)) {
+            const { requestId } = message;
+            if (this.#pendingRequests.has(requestId)) {
+                const { resolve } = this.#pendingRequests.get(requestId);
+                this.#pendingRequests.delete(requestId);
+                const { requestId: _, ...messageWithoutRequestId } = message;
+                resolve(messageHasResult(message) ? message.result : isTableSchemaMessage(message) ? message.tableSchema : messageWithoutRequestId);
+            } 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)=>{
+            this.#pendingRequests.set(requestId, {
+                resolve,
+                reject
+            });
+        });
+    };
+    async disconnect() {
+        try {
+            this.#worker.send({
+                type: "disconnect"
+            });
+            this.#deferredServerAPI = new DeferredPromise();
+            return "disconnected";
+        } catch (err) {
+            return "rejected";
+        }
+    }
+    destroy() {
+        this.#worker.terminate();
+    }
+}
+var src_ConnectionManager = ConnectionManager.instance;
+export default src_ConnectionManager;

package/src/DedicatedWorker.js

@@ -0,0 +1,44 @@
+import { DeferredPromise, getLoggingConfigForWorker } from "@vuu-ui/vuu-utils";
+import { workerSourceCode } from "./inlined-worker.js";
+const workerBlob = new Blob([
+    getLoggingConfigForWorker() + workerSourceCode
+], {
+    type: "text/javascript"
+});
+const workerBlobUrl = URL.createObjectURL(workerBlob);
+class DedicatedWorker {
+    #deferredConnection;
+    #worker;
+    constructor(onMessage){
+        const deferredWorker = new DeferredPromise();
+        this.#worker = deferredWorker.promise;
+        const worker = new Worker(workerBlobUrl);
+        const timer = window.setTimeout(()=>{
+            console.warn("timed out waiting for worker to load");
+        }, 1000);
+        worker.onmessage = (msg)=>{
+            const { data: message } = msg;
+            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 onMessage(message);
+        };
+    }
+    async connect(options) {
+        this.#deferredConnection = new DeferredPromise();
+        this.send({
+            ...options,
+            type: "connect"
+        });
+        return this.#deferredConnection.promise;
+    }
+    async send(message) {
+        (await this.#worker).postMessage(message);
+    }
+    async terminate() {
+        (await this.#worker).terminate();
+    }
+}
+export { DedicatedWorker };

package/src/LostConnectionHandler.js

@@ -0,0 +1,89 @@
+function _to_primitive(input, hint) {
+    if ("object" !== _type_of(input) || null === input) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (void 0 !== prim) {
+        var res = prim.call(input, hint || "default");
+        if ("object" !== _type_of(res)) return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === hint ? String : Number)(input);
+}
+function _to_property_key(arg) {
+    var key = _to_primitive(arg, "string");
+    return "symbol" === _type_of(key) ? key : String(key);
+}
+function _type_of(obj) {
+    return obj && "u" > typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+let _computedKey;
+class RetryOptionsImpl {
+    retryIntervals;
+    ind = 0;
+    constructor(retryIntervals){
+        this.retryIntervals = retryIntervals;
+        console.log("[RetryOptionsImpl] constructor");
+    }
+    next() {
+        this.ind = Math.min(this.retryIntervals.length, this.ind + 1);
+    }
+    get remaining() {
+        return this.retryIntervals.length - this.ind;
+    }
+    get interval() {
+        if (this.ind === this.retryIntervals.length) return -1;
+        return 1000 * this.retryIntervals[this.ind];
+    }
+}
+function RetryOptions(retryIntervals) {
+    if (Array.isArray(retryIntervals)) return new RetryOptionsImpl(retryIntervals);
+    throw Error("[lostConnectionHandler] RetryOptions, invalid retryIntervals");
+}
+const defaultRetryIntervals = [
+    1,
+    2,
+    3,
+    5,
+    10,
+    30,
+    60,
+    120
+];
+_computedKey = _to_property_key(Symbol.asyncIterator);
+class RetryGenerator {
+    vuuAuth;
+    options;
+    constructor(vuuAuth, options){
+        this.vuuAuth = vuuAuth;
+        this.options = options;
+        console.log("[RetryGenerator] constructor");
+    }
+    async *[_computedKey]() {
+        let connected = false;
+        do {
+            await new Promise((resolve)=>setTimeout(resolve, this.options.interval));
+            try {
+                await this.vuuAuth.login();
+                connected = true;
+                yield "connected";
+            } catch (err) {}
+            this.options.next();
+        }while (!connected && -1 !== this.options.interval)
+        if (!connected) yield "connection-failed";
+    }
+}
+class LostConnectionHandler {
+    vuuAuth;
+    retryIntervals;
+    constructor(vuuAuth, retryIntervals = defaultRetryIntervals){
+        this.vuuAuth = vuuAuth;
+        this.retryIntervals = retryIntervals;
+    }
+    async reconnect() {
+        for await (const result of new RetryGenerator(this.vuuAuth, RetryOptions(this.retryIntervals))){
+            console.log(`  ... async iterator result = ${result}`);
+            if ("connected" === result) return result;
+        }
+        return "connection-failed";
+    }
+}
+export { LostConnectionHandler, RetryGenerator, RetryOptions };

package/src/VuuAuthProvider.js

@@ -0,0 +1,78 @@
+import { getCookieValue } from "@vuu-ui/vuu-utils";
+import { parseVuuUserFromToken } from "./authenticate.js";
+class VuuAuthProvider {
+    authEndpoint;
+    constructor(authEndpoint){
+        this.authEndpoint = authEndpoint;
+    }
+    login = async (username, password)=>{
+        const date = new Date();
+        const days = 1;
+        date.setTime(date.getTime() + 24 * days * 3600000);
+        if (username && password) {
+            const { token } = await this.getVuuTokenWithUsernameAndPassword(username, password);
+            document.cookie = `vuu-auth-user=${username};expires=${date.toUTCString()};path=/`;
+            document.cookie = `vuu-auth-password=${password};expires=${date.toUTCString()};path=/`;
+            document.cookie = `vuu-auth-token=${token};expires=${date.toUTCString()};path=/`;
+            return this.redirectToApplication();
+        }
+        {
+            const userName = getCookieValue("vuu-auth-user");
+            const password = getCookieValue("vuu-auth-password");
+            if (!userName || !password) return this.redirectToLoginPage();
+            {
+                const { authorizations, token } = await this.getVuuTokenWithUsernameAndPassword(userName, password);
+                document.cookie = `vuu-auth-token=${token};expires=${date.toUTCString()};path=/`;
+                return {
+                    authorizations,
+                    user: {
+                        userName
+                    },
+                    token
+                };
+            }
+        }
+    };
+    async getVuuTokenWithUsernameAndPassword(username, password) {
+        const response = await fetch(this.authEndpoint, {
+            method: "POST",
+            credentials: "include",
+            headers: {
+                "Content-Type": "application/json",
+                "access-control-allow-origin": location.host
+            },
+            body: JSON.stringify({
+                username,
+                password
+            })
+        });
+        if (response.ok) {
+            const vuuAuthToken = response.headers.get("vuu-auth-token");
+            if ("string" == typeof vuuAuthToken && vuuAuthToken.length > 0) {
+                const { authorizations } = parseVuuUserFromToken(vuuAuthToken);
+                return {
+                    authorizations,
+                    token: vuuAuthToken
+                };
+            }
+            throw Error("Authentication failed auth token not returned by server");
+        }
+        throw Error(`Authentication failed, ${response.status}`);
+    }
+    clear() {
+        document.cookie = "vuu-auth-user= ; expires = Thu, 01 Jan 1970 00:00:00 GMT";
+        document.cookie = "vuu-auth-password= ; expires = Thu, 01 Jan 1970 00:00:00 GMT";
+        document.cookie = "vuu-auth-token= ; expires = Thu, 01 Jan 1970 00:00:00 GMT";
+    }
+    redirectToLoginPage() {
+        window.location.href = "login.html";
+    }
+    redirectToApplication() {
+        window.location.href = "index.html";
+    }
+    logout() {
+        this.clear();
+        this.redirectToLoginPage();
+    }
+}
+export { VuuAuthProvider };

package/src/VuuAuthenticator.js

@@ -0,0 +1,36 @@
+import ConnectionManager from "./ConnectionManager.js";
+const VuuAuthTokenIssuePolicy = {
+    BearerToken: "bearer-token",
+    UsernamePassword: "username-password"
+};
+class VuuAuthenticator {
+    authProvider;
+    authTokenIssuePolicy;
+    websocketUrl;
+    constructor({ authProvider, authTokenIssuePolicy = VuuAuthTokenIssuePolicy.BearerToken, websocketUrl }){
+        this.authProvider = authProvider;
+        this.authTokenIssuePolicy = authTokenIssuePolicy;
+        this.websocketUrl = websocketUrl;
+    }
+    openWebsocketConnection = async (vuuToken)=>{
+        await ConnectionManager.connect({
+            url: this.websocketUrl,
+            token: vuuToken
+        }, true);
+    };
+    login = async ()=>{
+        const { authorizations, user, token, websocket = true } = await this.authProvider.login();
+        if (token && user) {
+            if (websocket) await this.openWebsocketConnection(token);
+            return [
+                user,
+                authorizations
+            ];
+        }
+        throw Error("[VuuAuthenticator] login failed");
+    };
+    logout = ()=>{
+        this.authProvider.logout();
+    };
+}
+export { VuuAuthTokenIssuePolicy, VuuAuthenticator };