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

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

@@ -0,0 +1,808 @@
+import { hasViewPortContext, isCreateVpSuccess, isErrorMessage, isOpenDialogAction, isRpcServiceRequest, isSelectRequest, isSessionTable, isSessionTableActionMessage, isViewportMessage, isVisualLinkMessage, isVuuMenuRpcRequest, logger, partition } from "@vuu-ui/vuu-utils";
+import { createSchemaFromTableMetadata, groupRowsByViewport, hasRequestId, stripRequestId } from "../message-utils.js";
+import { NO_DATA_UPDATE, Viewport } from "./viewport.js";
+import { isLoginRejectedMessage } from "../WebSocketConnection.js";
+import * as __rspack_external__messages_js_85065717 from "./messages.js";
+let _requestId = 1;
+const TEST_setRequestId = (id)=>_requestId = id;
+const { debug: debug, debugEnabled: debugEnabled, error: server_proxy_error, info: info, infoEnabled: infoEnabled, warn: warn } = logger("ServerProxy");
+const nextRequestId = ()=>`${_requestId++}`;
+const DEFAULT_OPTIONS = {};
+const isActiveViewport = (viewPort)=>true !== viewPort.disabled && true !== viewPort.suspended;
+const addTitleToLinks = (links, serverViewportId, label)=>links.map((link)=>link.parentVpId === serverViewportId ? {
+            ...link,
+            label
+        } : link);
+function addLabelsToLinks(links, viewports) {
+    return links.map((linkDescriptor)=>{
+        const { parentVpId } = linkDescriptor;
+        const viewport = viewports.get(parentVpId);
+        if (viewport) return {
+            ...linkDescriptor,
+            parentClientVpId: viewport.clientViewportId,
+            label: viewport.title
+        };
+        throw Error("addLabelsToLinks viewport not found");
+    });
+}
+class ServerProxy {
+    connection;
+    postMessageToClient;
+    viewports;
+    mapClientToServerViewport;
+    authToken = "";
+    pendingLogin;
+    pendingRequests = new Map();
+    sessionId;
+    queuedRequests = [];
+    cachedTableMetaRequests = new Map();
+    cachedTableSchemas = new Map();
+    tableList;
+    constructor(connection, callback){
+        this.connection = connection;
+        this.postMessageToClient = callback;
+        this.viewports = new Map();
+        this.mapClientToServerViewport = new Map();
+        connection.on("connection-status", this.connectionStatusChanged);
+    }
+    connectionStatusChanged = (status)=>{
+        if ("disconnected" === status) {
+            this.sessionId = void 0;
+            this.clearAllViewports();
+        } else if ("reconnected" === status) this.reconnect();
+    };
+    reconnect = async ()=>{
+        const [activeViewports, inactiveViewports] = partition(Array.from(this.viewports.values()), isActiveViewport);
+        this.viewports.clear();
+        this.mapClientToServerViewport.clear();
+        const reconnectViewports = (viewports)=>{
+            viewports.forEach((viewport)=>{
+                const { clientViewportId } = viewport;
+                this.awaitResponseToMessage(viewport.subscribe(), clientViewportId).then((msg)=>{
+                    if ("CREATE_VP_SUCCESS" === msg.type) {
+                        this.mapClientToServerViewport.set(clientViewportId, msg.viewPortId);
+                        this.viewports.set(msg.viewPortId, viewport);
+                        viewport.status = "subscribed";
+                        viewport.serverViewportId = msg.viewPortId;
+                    }
+                });
+            });
+        };
+        reconnectViewports(activeViewports);
+        setTimeout(()=>{
+            reconnectViewports(inactiveViewports);
+        }, 2000);
+    };
+    async login(authToken) {
+        if (authToken) {
+            this.authToken = authToken;
+            return new Promise((resolve, reject)=>{
+                this.sendMessageToServer({
+                    type: "LOGIN",
+                    token: this.authToken
+                }, "");
+                this.pendingLogin = {
+                    resolve,
+                    reject
+                };
+            });
+        }
+        if ("" === this.authToken) server_proxy_error("login, cannot login until auth token has been obtained");
+    }
+    clearAllViewports() {
+        this.viewports.forEach((viewport)=>{
+            viewport.clearCache();
+        });
+    }
+    disconnect() {
+        this.viewports.forEach((viewport)=>{
+            const { clientViewportId } = viewport;
+            this.unsubscribe(clientViewportId);
+            this.postMessageToClient({
+                clientViewportId,
+                type: "viewport-clear"
+            });
+        });
+    }
+    async subscribe(message) {
+        if (this.mapClientToServerViewport.has(message.viewport)) server_proxy_error(`spurious subscribe call ${message.viewport}`);
+        else {
+            const pendingTableSchema = this.getTableMeta(message.table);
+            const viewport = new Viewport(message, this.postMessageToClient);
+            this.viewports.set(message.viewport, viewport);
+            const pendingSubscription = this.awaitResponseToMessage(viewport.subscribe(), message.viewport);
+            const [subscribeResponse, tableSchema] = await Promise.all([
+                pendingSubscription,
+                pendingTableSchema
+            ]);
+            if (isErrorMessage(tableSchema)) this.postMessageToClient({
+                clientViewportId: message.viewport,
+                type: "subscribe-failed",
+                msg: `failed to fetch schema for table ${message.table.table}: ${tableSchema.msg}`
+            });
+            else if (isCreateVpSuccess(subscribeResponse)) {
+                const { viewPortId: serverViewportId } = subscribeResponse;
+                const { status: previousViewportStatus } = viewport;
+                if (message.viewport !== serverViewportId) {
+                    this.viewports.delete(message.viewport);
+                    this.viewports.set(serverViewportId, viewport);
+                }
+                this.mapClientToServerViewport.set(message.viewport, serverViewportId);
+                const clientResponse = viewport.handleSubscribed(subscribeResponse, tableSchema);
+                if (clientResponse) {
+                    this.postMessageToClient(clientResponse);
+                    if (debugEnabled) debug(`post DataSourceSubscribedMessage to client: ${JSON.stringify(clientResponse)}`);
+                }
+                if (viewport.disabled) this.disableViewport(viewport);
+                if (this.queuedRequests.length > 0) this.processQueuedRequests();
+                if ("subscribing" === previousViewportStatus && !isSessionTable(viewport.table)) {
+                    this.sendMessageToServer({
+                        type: __rspack_external__messages_js_85065717.GET_VP_VISUAL_LINKS,
+                        vpId: serverViewportId
+                    });
+                    this.sendMessageToServer({
+                        type: __rspack_external__messages_js_85065717.GET_VIEW_PORT_MENUS,
+                        vpId: serverViewportId
+                    });
+                    Array.from(this.viewports.entries()).filter(([id, { disabled, status }])=>id !== serverViewportId && !disabled && "subscribed" === status).forEach(([vpId])=>{
+                        this.sendMessageToServer({
+                            type: __rspack_external__messages_js_85065717.GET_VP_VISUAL_LINKS,
+                            vpId
+                        });
+                    });
+                }
+            } else this.postMessageToClient({
+                clientViewportId: message.viewport,
+                type: "subscribe-failed",
+                msg: `failed to open subscription on table ${message.table.table}: ${subscribeResponse.msg}`
+            });
+        }
+    }
+    addRequestToQueue(queuedRequest) {
+        const isDifferentTypeViewport = (qr)=>qr.clientViewportId !== queuedRequest.clientViewportId || queuedRequest.message.type !== qr.message.type;
+        if (!this.queuedRequests.every(isDifferentTypeViewport)) this.queuedRequests = this.queuedRequests.filter(isDifferentTypeViewport);
+        this.queuedRequests.push(queuedRequest);
+    }
+    processQueuedRequests() {
+        const newQueue = [];
+        for (const queuedRequest of this.queuedRequests){
+            const { clientViewportId, message, requestId } = queuedRequest;
+            const serverViewportId = this.mapClientToServerViewport.get(clientViewportId);
+            if (serverViewportId) this.sendMessageToServer({
+                ...message,
+                viewPortId: serverViewportId
+            }, requestId);
+            else if (this.viewports.has(clientViewportId)) newQueue.push(queuedRequest);
+            else console.warn(`ServerProxy processQueuedRequests, ${message.type} request not found ${clientViewportId}`);
+        }
+        this.queuedRequests = newQueue;
+    }
+    unsubscribe(clientViewportId) {
+        const serverViewportId = this.mapClientToServerViewport.get(clientViewportId);
+        if (serverViewportId) {
+            info?.(`Unsubscribe Message (Client to Server):
+        ${serverViewportId}`);
+            this.sendMessageToServer({
+                type: __rspack_external__messages_js_85065717.REMOVE_VP,
+                viewPortId: serverViewportId
+            });
+        } else server_proxy_error(`failed to unsubscribe client viewport ${clientViewportId}, viewport not found`);
+    }
+    getViewportForClient(clientViewportId, throws = true) {
+        const serverViewportId = this.mapClientToServerViewport.get(clientViewportId);
+        if (serverViewportId) {
+            const viewport = this.viewports.get(serverViewportId);
+            if (viewport) return viewport;
+            if (!throws) return null;
+            throw Error(`Viewport not found for client viewport ${clientViewportId}`);
+        }
+        if (this.viewports.has(clientViewportId)) return this.viewports.get(clientViewportId);
+        if (!throws) return null;
+        throw Error(`Viewport server id not found for client viewport ${clientViewportId}`);
+    }
+    setViewRange(viewport, message) {
+        const requestId = nextRequestId();
+        infoEnabled && info(`setViewRange (${message.range.from}:${message.range.to})`);
+        const [serverRequest, rows, debounceRequest] = viewport.rangeRequest(requestId, message.range);
+        if ("subscribed" === viewport.status) {
+            info?.(`setViewRange ${message.range.from} - ${message.range.to}`);
+            if (serverRequest) {
+                if ("development" === process.env.NODE_ENV) info?.(`CHANGE_VP_RANGE (${message.range.from}-${message.range.to}) => (${serverRequest.from}-${serverRequest.to})`);
+                infoEnabled && info(`setViewRange send CHANGE_VP_RANGE<#${requestId}> (${serverRequest.from}-${serverRequest.to})`);
+                this.sendMessageToServer(serverRequest, requestId);
+            }
+            if (rows) {
+                info?.(`setViewRange ${rows.length} rows returned from cache`);
+                this.postMessageToClient({
+                    mode: "update",
+                    type: "viewport-update",
+                    clientViewportId: viewport.clientViewportId,
+                    range: message.range,
+                    rows
+                });
+            } else if (debounceRequest) this.postMessageToClient(debounceRequest);
+        } else if (serverRequest) this.addRequestToQueue({
+            clientViewportId: message.viewport,
+            message: serverRequest,
+            requestId
+        });
+    }
+    setConfig(viewport, message) {
+        const requestId = nextRequestId();
+        const request = viewport.setConfig(requestId, message.config);
+        this.sendIfReady(request, requestId, "subscribed" === viewport.status);
+    }
+    setTitle(viewport, message) {
+        if (viewport) {
+            viewport.title = message.title;
+            this.updateTitleOnVisualLinks(viewport);
+        }
+    }
+    select(viewport, message) {
+        const [requestId, selectRequest] = stripRequestId(message);
+        const request = viewport.selectRequest(selectRequest);
+        this.sendMessageToServer(request, requestId);
+    }
+    disableAllActiveViewports() {
+        console.log("[ServerProxy] disableAllActiveViewports");
+        this.viewports.forEach((vp)=>{
+            if (isActiveViewport(vp)) this.disableViewport(vp, true);
+        });
+    }
+    enableAllActiveViewports() {
+        this.viewports.forEach((vp)=>{
+            if (vp.disabledActive) this.enableViewport(vp);
+        });
+    }
+    disableViewport(viewport, disableActive = false) {
+        const requestId = nextRequestId();
+        const request = viewport.disable(requestId, disableActive);
+        this.sendIfReady(request, requestId, "subscribed" === viewport.status);
+    }
+    enableViewport(viewport) {
+        if (viewport.disabled) {
+            const requestId = nextRequestId();
+            const request = viewport.enable(requestId);
+            this.sendIfReady(request, requestId, "subscribed" === viewport.status);
+        }
+    }
+    freezeViewport(viewport) {
+        const requestId = nextRequestId();
+        const request = viewport.freeze(requestId);
+        this.sendIfReady(request, requestId, "subscribed" === viewport.status);
+    }
+    unfreezeViewport(viewport) {
+        if (viewport.frozen) {
+            const requestId = nextRequestId();
+            const request = viewport.unfreeze(requestId);
+            this.sendIfReady(request, requestId, "subscribed" === viewport.status);
+        }
+    }
+    suspendViewport(viewport, escalateToDisable = true, escalateDelay = 3000) {
+        viewport.suspend();
+        if (escalateToDisable) viewport.suspendTimer = setTimeout(()=>{
+            info?.("suspendTimer expired, escalate suspend to disable");
+            this.disableViewport(viewport);
+        }, escalateDelay);
+    }
+    resumeViewport(viewport) {
+        if (viewport.suspendTimer) {
+            debug?.("clear suspend timer");
+            clearTimeout(viewport.suspendTimer);
+            viewport.suspendTimer = null;
+        }
+        const [size, rows] = viewport.resume();
+        debug?.(`resumeViewport size ${size}, ${rows.length} rows sent to client`);
+        this.postMessageToClient({
+            clientViewportId: viewport.clientViewportId,
+            mode: "update",
+            rows,
+            size,
+            type: "viewport-update"
+        });
+    }
+    openTreeNode(viewport, message) {
+        if (viewport.serverViewportId) {
+            const requestId = nextRequestId();
+            this.sendIfReady(viewport.openTreeNode(requestId, message), requestId, "subscribed" === viewport.status);
+        }
+    }
+    closeTreeNode(viewport, message) {
+        if (viewport.serverViewportId) {
+            const requestId = nextRequestId();
+            this.sendIfReady(viewport.closeTreeNode(requestId, message), requestId, "subscribed" === viewport.status);
+        }
+    }
+    createLink(viewport, message) {
+        const [requestId, visualLinkRequest] = stripRequestId(message);
+        const parentVpId = this.mapClientToServerViewport.get(message.parentVpId);
+        if (parentVpId) {
+            const request = viewport.createLink(requestId, {
+                ...visualLinkRequest,
+                parentVpId
+            });
+            this.sendMessageToServer(request, requestId);
+        } else throw Error(`createLink parent viewport not found ${message.parentVpId}`);
+    }
+    removeLink(viewport, message) {
+        const { requestId } = message;
+        const request = viewport.removeLink(requestId);
+        this.sendMessageToServer(request, requestId);
+    }
+    updateTitleOnVisualLinks(viewport) {
+        const { serverViewportId, title } = viewport;
+        for (const vp of this.viewports.values())if (vp !== viewport && vp.links && serverViewportId && title) {
+            if (vp.links?.some((link)=>link.parentVpId === serverViewportId)) {
+                const [messageToClient] = vp.setLinks(addTitleToLinks(vp.links, serverViewportId, title));
+                this.postMessageToClient(messageToClient);
+            }
+        }
+    }
+    removeViewportFromVisualLinks(serverViewportId) {
+        for (const vp of this.viewports.values())if (vp.links?.some(({ parentVpId })=>parentVpId === serverViewportId)) {
+            const [messageToClient] = vp.setLinks(vp.links.filter(({ parentVpId })=>parentVpId !== serverViewportId));
+            this.postMessageToClient(messageToClient);
+        }
+    }
+    menuRpcCall(message) {
+        const viewport = this.getViewportForClient(message.vpId, false);
+        if (viewport?.serverViewportId) {
+            const [requestId, rpcRequest] = stripRequestId(message);
+            this.sendMessageToServer({
+                ...rpcRequest,
+                vpId: viewport.serverViewportId
+            }, requestId);
+        }
+    }
+    rpcRequest(message) {
+        if (hasViewPortContext(message)) {
+            const viewport = this.getViewportForClient(message.context.viewPortId, false);
+            if (viewport?.serverViewportId) {
+                const [requestId, rpcRequest] = stripRequestId(message);
+                this.sendMessageToServer({
+                    ...rpcRequest,
+                    context: {
+                        type: "VIEWPORT_CONTEXT",
+                        viewPortId: viewport.serverViewportId
+                    }
+                }, requestId);
+            }
+        } else throw Error("[ServerProxy] rpcRequest only supports VIEWPORT_CONTEXT at present");
+    }
+    handleMessageFromClient(message) {
+        if (isViewportMessage(message) || isVisualLinkMessage(message)) if ("disable" === message.type) {
+            const viewport = this.getViewportForClient(message.viewport, false);
+            if (null !== viewport) return this.disableViewport(viewport);
+            return;
+        } else {
+            const viewport = isVisualLinkMessage(message) ? this.getViewportForClient(message.childVpId) : this.getViewportForClient(message.viewport);
+            switch(message.type){
+                case "setViewRange":
+                    return this.setViewRange(viewport, message);
+                case "config":
+                    return this.setConfig(viewport, message);
+                case "suspend":
+                    {
+                        const { escalateToDisable, escalateDelay } = message;
+                        return this.suspendViewport(viewport, escalateToDisable, escalateDelay);
+                    }
+                case "resume":
+                    return this.resumeViewport(viewport);
+                case "enable":
+                    return this.enableViewport(viewport);
+                case "FREEZE_VP":
+                    return this.freezeViewport(viewport);
+                case "UNFREEZE_VP":
+                    return this.unfreezeViewport(viewport);
+                case "openTreeNode":
+                    return this.openTreeNode(viewport, message);
+                case "closeTreeNode":
+                    return this.closeTreeNode(viewport, message);
+                case "CREATE_VISUAL_LINK":
+                    return this.createLink(viewport, message);
+                case "REMOVE_VISUAL_LINK":
+                    return this.removeLink(viewport, message);
+                case "setTitle":
+                    return this.setTitle(viewport, message);
+                default:
+            }
+        }
+        if (isSelectRequest(message)) if (hasRequestId(message)) {
+            const viewport = this.getViewportForClient(message.vpId);
+            return this.select(viewport, message);
+        } else console.warn("selectRequest must have requestId");
+        else {
+            if (isRpcServiceRequest(message)) return this.rpcRequest(message);
+            if (isVuuMenuRpcRequest(message)) return this.menuRpcCall(message);
+            if ("disconnect" === message.type) return this.disconnect();
+            if ("disable-all-active" === message.type) return this.disableAllActiveViewports();
+            if ("enable-all-active" === message.type) return this.enableAllActiveViewports();
+            const { type, requestId } = message;
+            switch(type){
+                case "GET_TABLE_LIST":
+                    this.tableList ??= this.awaitResponseToMessage({
+                        type
+                    }, requestId);
+                    this.tableList.then((response)=>{
+                        this.postMessageToClient({
+                            type: "TABLE_LIST_RESP",
+                            tables: response.tables,
+                            requestId
+                        });
+                    });
+                    return;
+                case "GET_TABLE_META":
+                    return void this.getTableMeta(message.table, requestId).then((tableSchema)=>{
+                        if (isErrorMessage(tableSchema)) ;
+                        else if (tableSchema) this.postMessageToClient({
+                            type: "TABLE_META_RESP",
+                            tableSchema,
+                            requestId
+                        });
+                    });
+                default:
+            }
+        }
+        server_proxy_error(`Vuu ServerProxy Unexpected message from client ${JSON.stringify(message)}`);
+    }
+    getTableMeta(table, requestId = nextRequestId()) {
+        if (isSessionTable(table)) return this.awaitResponseToMessage({
+            type: "GET_TABLE_META",
+            table
+        }, requestId).then((resp)=>isErrorMessage(resp) ? resp : createSchemaFromTableMetadata(resp));
+        const key = `${table.module}:${table.table}`;
+        let tableMetaRequest = this.cachedTableMetaRequests.get(key);
+        if (!tableMetaRequest) {
+            tableMetaRequest = this.awaitResponseToMessage({
+                type: "GET_TABLE_META",
+                table
+            }, requestId);
+            this.cachedTableMetaRequests.set(key, tableMetaRequest);
+        }
+        return tableMetaRequest?.then((response)=>{
+            if (isErrorMessage(response)) return response;
+            return this.cacheTableMeta(response);
+        });
+    }
+    awaitResponseToMessage(message, requestId = nextRequestId()) {
+        return new Promise((resolve, reject)=>{
+            this.sendMessageToServer(message, requestId);
+            this.pendingRequests.set(requestId, {
+                reject,
+                resolve
+            });
+        });
+    }
+    sendIfReady(message, requestId, isReady = true) {
+        if (isReady) this.sendMessageToServer(message, requestId);
+        return isReady;
+    }
+    sendMessageToServer(body, requestId = `${_requestId++}`, options = DEFAULT_OPTIONS) {
+        const { module = "CORE" } = options;
+        if (this.authToken) this.connection.send({
+            requestId,
+            sessionId: this.sessionId,
+            module,
+            body
+        });
+    }
+    handleMessageFromServer(message) {
+        if (isLoginRejectedMessage(message)) {
+            if (this.pendingLogin) {
+                this.pendingLogin.reject(message.reason);
+                this.pendingLogin = void 0;
+                this.authToken = "";
+            }
+            return;
+        }
+        const { body, requestId, sessionId } = message;
+        const pendingRequest = this.pendingRequests.get(requestId);
+        if (pendingRequest) {
+            const { resolve } = pendingRequest;
+            this.pendingRequests.delete(requestId);
+            resolve(body);
+            return;
+        }
+        const { viewports } = this;
+        switch(body.type){
+            case __rspack_external__messages_js_85065717.HB:
+                this.sendMessageToServer({
+                    type: __rspack_external__messages_js_85065717.HB_RESP,
+                    ts: +new Date()
+                }, "NA");
+                break;
+            case "LOGIN_SUCCESS":
+                if (sessionId) {
+                    this.sessionId = sessionId;
+                    this.pendingLogin?.resolve(sessionId);
+                    this.pendingLogin = void 0;
+                    this.postMessageToClient({
+                        ...body,
+                        sessionId
+                    });
+                } else throw Error("LOGIN_SUCCESS did not provide sessionId");
+                break;
+            case "REMOVE_VP_SUCCESS":
+                {
+                    const viewport = viewports.get(body.viewPortId);
+                    if (viewport) {
+                        this.mapClientToServerViewport.delete(viewport.clientViewportId);
+                        viewports.delete(body.viewPortId);
+                        this.removeViewportFromVisualLinks(body.viewPortId);
+                    }
+                }
+                break;
+            case "SELECT_ALL_SUCCESS":
+            case "SELECT_ROW_SUCCESS":
+            case "SELECT_ROW_RANGE_SUCCESS":
+            case "DESELECT_ROW_SUCCESS":
+                {
+                    const { type, selectedRowCount } = body;
+                    this.postMessageToClient({
+                        requestId,
+                        type,
+                        selectedRowCount
+                    });
+                    break;
+                }
+            case "DESELECT_ALL_SUCCESS":
+                {
+                    const { type } = body;
+                    this.postMessageToClient({
+                        requestId,
+                        type,
+                        selectedRowCount: 0
+                    });
+                    break;
+                }
+            case "SELECT_ROW_REJECT":
+            case "DESELECT_ROW_REJECT":
+            case "SELECT_ROW_RANGE_REJECT":
+            case "SELECT_ALL_REJECT":
+            case "DESELECT_ALL_REJECT":
+                console.warn(`select error ${body.type} ${body.errorMsg}`);
+                break;
+            case __rspack_external__messages_js_85065717.CHANGE_VP_SUCCESS:
+            case __rspack_external__messages_js_85065717.DISABLE_VP_SUCCESS:
+                if (viewports.has(body.viewPortId)) {
+                    const viewport = this.viewports.get(body.viewPortId);
+                    if (viewport) {
+                        const response = viewport.completeOperation(requestId);
+                        if (void 0 !== response) {
+                            this.postMessageToClient(response);
+                            if (debugEnabled) debug(`postMessageToClient ${JSON.stringify(response)}`);
+                        }
+                    }
+                }
+                break;
+            case __rspack_external__messages_js_85065717.ENABLE_VP_SUCCESS:
+                {
+                    const viewport = this.viewports.get(body.viewPortId);
+                    if (viewport) {
+                        const response = viewport.completeOperation(requestId);
+                        if (response) {
+                            this.postMessageToClient(response);
+                            const [size, rows] = viewport.resume();
+                            this.postMessageToClient({
+                                clientViewportId: viewport.clientViewportId,
+                                mode: "update",
+                                rows,
+                                size,
+                                type: "viewport-update"
+                            });
+                        }
+                    }
+                }
+                break;
+            case "FREEZE_VP_SUCCESS":
+                {
+                    const viewport = this.viewports.get(body.viewPortId);
+                    if (viewport) {
+                        const response = viewport.completeOperation(requestId);
+                        if (response) this.postMessageToClient(response);
+                    }
+                }
+                break;
+            case "UNFREEZE_VP_SUCCESS":
+                {
+                    const viewport = this.viewports.get(body.viewPortId);
+                    if (viewport) {
+                        const response = viewport.completeOperation(requestId);
+                        if (response) this.postMessageToClient(response);
+                    }
+                }
+                break;
+            case "TABLE_ROW":
+                {
+                    const viewportRowMap = groupRowsByViewport(body.rows);
+                    if ("development" === process.env.NODE_ENV && debugEnabled) {
+                        const [firstRow] = body.rows;
+                        if (0 === body.rows.length) infoEnabled && info("<=== TABLE_ROW 0 rows");
+                        else if (firstRow?.rowIndex === -1) if (1 === body.rows.length) if ("SIZE" === firstRow.updateType) infoEnabled && info(`<=== [${firstRow.viewPortId}] TABLE_ROW SIZE ONLY ${firstRow.vpSize}`);
+                        else infoEnabled && info(`<=== [${firstRow.viewPortId}] TABLE_ROW SIZE ${firstRow.vpSize} rowIdx ${firstRow.rowIndex}`);
+                        else infoEnabled && info(`<=== TABLE_ROW ${body.rows.length} rows, SIZE ${firstRow.vpSize}, [${body.rows.map((r)=>r.rowIndex).join(",")}]`);
+                        else infoEnabled && info(`<=== TABLE_ROW ${body.rows.length} rows [${body.rows.map((r)=>r.rowIndex).join(",")}]`);
+                    }
+                    for (const [viewportId, rows] of Object.entries(viewportRowMap)){
+                        const viewport = viewports.get(viewportId);
+                        if (viewport) viewport.updateRows(rows);
+                        else warn?.(`TABLE_ROW message received for non registered viewport ${viewportId}`);
+                    }
+                    this.processUpdates();
+                }
+                break;
+            case "CHANGE_VP_RANGE_SUCCESS":
+                {
+                    const viewport = this.viewports.get(body.viewPortId);
+                    if (viewport) {
+                        const { from, to } = body;
+                        infoEnabled && info(`<=== CHANGE_VP_RANGE_SUCCESS<#${requestId}> ${from} - ${to}`);
+                        viewport.completeOperation(requestId, from, to);
+                    }
+                }
+                break;
+            case __rspack_external__messages_js_85065717.OPEN_TREE_SUCCESS:
+            case __rspack_external__messages_js_85065717.CLOSE_TREE_SUCCESS:
+                break;
+            case "CREATE_VISUAL_LINK_SUCCESS":
+                {
+                    const viewport = this.viewports.get(body.childVpId);
+                    const parentViewport = this.viewports.get(body.parentVpId);
+                    if (viewport && parentViewport) {
+                        const { childColumnName, parentColumnName } = body;
+                        const response = viewport.completeOperation(requestId, childColumnName, parentViewport.clientViewportId, parentColumnName);
+                        if (response) this.postMessageToClient(response);
+                    }
+                }
+                break;
+            case "REMOVE_VISUAL_LINK_SUCCESS":
+                {
+                    const viewport = this.viewports.get(body.childVpId);
+                    if (viewport) {
+                        const response = viewport.completeOperation(requestId);
+                        if (response) this.postMessageToClient(response);
+                    }
+                }
+                break;
+            case "VP_VISUAL_LINKS_RESP":
+                {
+                    const activeLinkDescriptors = this.getActiveLinks(body.links);
+                    const viewport = this.viewports.get(body.vpId);
+                    if (activeLinkDescriptors.length && viewport) {
+                        const linkDescriptorsWithLabels = addLabelsToLinks(activeLinkDescriptors, this.viewports);
+                        const [clientMessage, pendingLink] = viewport.setLinks(linkDescriptorsWithLabels);
+                        this.postMessageToClient(clientMessage);
+                        if (pendingLink) {
+                            const { link, parentClientVpId } = pendingLink;
+                            const requestId = nextRequestId();
+                            const parentVpId = this.mapClientToServerViewport.get(parentClientVpId);
+                            if (parentVpId) {
+                                const message = viewport.createLink(requestId, {
+                                    childVpId: body.vpId,
+                                    childColumnName: link.fromColumn,
+                                    parentColumnName: link.toColumn,
+                                    parentVpId,
+                                    type: "CREATE_VISUAL_LINK"
+                                });
+                                this.sendMessageToServer(message, requestId);
+                            }
+                        }
+                    }
+                }
+                break;
+            case "VIEW_PORT_MENUS_RESP":
+                if (body.menu?.name) {
+                    const viewport = this.viewports.get(body.vpId);
+                    if (viewport) {
+                        const clientMessage = viewport.setMenu(body.menu);
+                        this.postMessageToClient(clientMessage);
+                    }
+                }
+                break;
+            case "VIEW_PORT_MENU_REJ":
+                {
+                    const { error, rpcName, vpId } = body;
+                    const viewport = this.viewports.get(vpId);
+                    if (viewport) this.postMessageToClient({
+                        clientViewportId: viewport.clientViewportId,
+                        error,
+                        rpcName,
+                        type: "VIEW_PORT_MENU_REJ",
+                        requestId
+                    });
+                    break;
+                }
+            case "VIEW_PORT_MENU_RESP":
+                if (isSessionTableActionMessage(body)) {
+                    const { action, rpcName } = body;
+                    this.awaitResponseToMessage({
+                        type: "GET_TABLE_META",
+                        table: action.table
+                    }).then((response)=>{
+                        const tableSchema = createSchemaFromTableMetadata(response);
+                        this.postMessageToClient({
+                            rpcName,
+                            type: "VIEW_PORT_MENU_RESP",
+                            action: {
+                                ...action,
+                                tableSchema
+                            },
+                            tableAlreadyOpen: this.isTableOpen(action.table),
+                            requestId
+                        });
+                    });
+                } else {
+                    const { action, rpcName } = body;
+                    this.postMessageToClient({
+                        action,
+                        rpcName,
+                        requestId,
+                        tableAlreadyOpen: isOpenDialogAction(action) && this.isTableOpen(action.table),
+                        type: "VIEW_PORT_MENU_RESP"
+                    });
+                }
+                break;
+            case "RPC_RESPONSE":
+                {
+                    const { action, error, result } = body;
+                    this.postMessageToClient({
+                        action,
+                        type: "RPC_RESPONSE",
+                        error,
+                        result,
+                        requestId
+                    });
+                }
+                break;
+            case "ERROR":
+                server_proxy_error(body.msg);
+                break;
+            default:
+                infoEnabled && info(`<=== ${body["type"]}.`);
+        }
+    }
+    cacheTableMeta(messageBody) {
+        const { module, table } = messageBody.table;
+        const key = `${module}:${table}`;
+        let tableSchema = this.cachedTableSchemas.get(key);
+        if (!tableSchema) {
+            tableSchema = createSchemaFromTableMetadata(messageBody);
+            this.cachedTableSchemas.set(key, tableSchema);
+        }
+        return tableSchema;
+    }
+    isTableOpen(table) {
+        if (table) {
+            const tableName = table.table;
+            for (const viewport of this.viewports.values())if (!viewport.suspended && viewport.table.table === tableName) return true;
+        }
+    }
+    getActiveLinks(linkDescriptors) {
+        return linkDescriptors.filter((linkDescriptor)=>{
+            const viewport = this.viewports.get(linkDescriptor.parentVpId);
+            return viewport && !viewport.suspended;
+        });
+    }
+    processUpdates() {
+        this.viewports.forEach((viewport)=>{
+            if (viewport.hasUpdatesToProcess) {
+                const result = viewport.getClientRows();
+                if (result !== NO_DATA_UPDATE) {
+                    const [rows, mode] = result;
+                    const size = viewport.getNewRowCount();
+                    if (void 0 !== size || rows && rows.length > 0) {
+                        debugEnabled && debug(`===> #${viewport.clientViewportId} viewport-update ${mode}, ${rows?.length ?? "no"} rows, size ${size}`);
+                        if (mode) this.postMessageToClient({
+                            clientViewportId: viewport.clientViewportId,
+                            mode,
+                            rows,
+                            size,
+                            type: "viewport-update"
+                        });
+                    }
+                }
+            }
+        });
+    }
+}
+export { ServerProxy, TEST_setRequestId };