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

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

@@ -1,808 +0,0 @@
-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 };