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

package/src/authenticate.js

@@ -0,0 +1,50 @@
+const defaultAuthUrl = "api/authn";
+const isValidVuuUser = (response)=>"object" == typeof response && null !== response && "name" in response && "authorizations" in response && "string" == typeof response.name && Array.isArray(response.authorizations);
+const parseVuuUserFromToken = (token)=>{
+    const [base64EncodedVuuUser] = token.split(".");
+    const jsonString = atob(base64EncodedVuuUser);
+    const response = JSON.parse(jsonString);
+    if (isValidVuuUser(response)) return response;
+    throw Error("auth token does not containe VuuUser");
+};
+const getVuuAuthToken = async (authUrl, token)=>{
+    const response = await fetch(authUrl, {
+        headers: {
+            Authorization: `Bearer ${token}`
+        }
+    });
+    if (!response.ok) throw Error("Authentication error: Auth token failure");
+    const json = await response.json();
+    const vuuUser = parseVuuUserFromToken(json.token);
+    return {
+        authorizations: vuuUser.authorizations,
+        token: json.token
+    };
+};
+const authenticate = async (username, password, authUrl = defaultAuthUrl)=>fetch(authUrl, {
+        method: "POST",
+        credentials: "include",
+        headers: {
+            "Content-Type": "application/json",
+            "access-control-allow-origin": location.host
+        },
+        body: JSON.stringify({
+            username,
+            password
+        })
+    }).then((response)=>{
+        if (response.ok) {
+            const authToken = response.headers.get("vuu-auth-token");
+            if ("string" == typeof authToken && authToken.length > 0) try {
+                return {
+                    token: authToken,
+                    user: parseVuuUserFromToken(authToken)
+                };
+            } catch (e) {
+                throw Error("Authentication error:  vuu auth token decoding failed.");
+            }
+            throw Error("Authentication failed auth token not returned by server");
+        }
+        throw Error(`Authentication failed ${response.status} ${response.statusText}`);
+    });
+export { authenticate, getVuuAuthToken, parseVuuUserFromToken };

package/src/constants.js

@@ -0,0 +1,45 @@
+let _connectionId = 0;
+const connectionId = {
+    get nextValue () {
+        return _connectionId++;
+    }
+};
+const msgType = {
+    connect: "connect",
+    connectionStatus: "connection-status",
+    getFilterData: "GetFilterData",
+    rowData: "rowData",
+    rowSet: "rowset",
+    select: "select",
+    selectAll: "selectAll",
+    selectNone: "selectNone",
+    selected: "selected",
+    snapshot: "snapshot",
+    update: "update",
+    createLink: "createLink",
+    disable: "disable",
+    enable: "enable",
+    suspend: "suspend",
+    resume: "resume",
+    addSubscription: "AddSubscription",
+    closeTreeNode: "closeTreeNode",
+    columnList: "ColumnList",
+    data: "data",
+    openTreeNode: "openTreeNode",
+    aggregate: "aggregate",
+    filter: "filter",
+    filterQuery: "filterQuery",
+    filterData: "filterData",
+    getSearchData: "GetSearchData",
+    groupBy: "groupBy",
+    modifySubscription: "ModifySubscription",
+    searchData: "searchData",
+    setGroupState: "setGroupState",
+    size: "size",
+    sort: "sort",
+    subscribed: "Subscribed",
+    tableList: "TableList",
+    unsubscribe: "TerminateSubscription",
+    viewRangeChanged: "ViewRangeChanged"
+};
+export { connectionId, msgType };

package/src/data-source.js

@@ -0,0 +1,57 @@
+const isSizeOnly = (message)=>"viewport-update" === message.type && "size-only" === message.mode;
+const toDataSourceConfig = (message)=>{
+    switch(message.type){
+        case "aggregate":
+            return {
+                aggregations: message.aggregations
+            };
+        case "columns":
+            return {
+                columns: message.columns
+            };
+        case "filter":
+            return {
+                filterSpec: message.filter
+            };
+        case "groupBy":
+            return {
+                groupBy: message.groupBy
+            };
+        case "sort":
+            return {
+                sort: message.sort
+            };
+        case "config":
+            return message.config;
+    }
+};
+const datasourceMessages = [
+    "config",
+    "aggregate",
+    "viewport-clear",
+    "viewport-update",
+    "columns",
+    "debounce-begin",
+    "disabled",
+    "enabled",
+    "filter",
+    "groupBy",
+    "vuu-links",
+    "vuu-menu",
+    "sort",
+    "subscribed",
+    "subscribe-failed"
+];
+const shouldMessageBeRoutedToDataSource = (message)=>{
+    const type = message.type;
+    return datasourceMessages.includes(type);
+};
+const isDataSourceConfigMessage = (message)=>[
+        "config",
+        "aggregate",
+        "columns",
+        "filter",
+        "groupBy",
+        "sort"
+    ].includes(message.type);
+export { isDataSourceConfigMessage, isSizeOnly, shouldMessageBeRoutedToDataSource, toDataSourceConfig };

package/src/index.js

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

package/src/message-utils.js

@@ -0,0 +1,44 @@
+const hasRequestId = (message)=>"requestId" in message;
+const stripRequestId = ({ requestId, ...rest })=>[
+        requestId,
+        rest
+    ];
+const getFirstAndLastRows = (rows)=>{
+    let firstRow = rows.at(0);
+    if ("SIZE" === firstRow.updateType) if (1 === rows.length) return rows;
+    else firstRow = rows.at(1);
+    const lastRow = rows.at(-1);
+    return [
+        firstRow,
+        lastRow
+    ];
+};
+const insertRow = (rows, row)=>{
+    const lastRow = rows.at(-1);
+    if (void 0 === lastRow || row.rowIndex > lastRow.rowIndex) rows.push(row);
+    else {
+        for(let i = 0; i < rows.length; i++)if (row.rowIndex < rows[i].rowIndex) return void rows.splice(i, 0, row);
+        else if (row.rowIndex === rows[i].rowIndex) {
+            row.ts < rows[i].ts || (rows[i] = row);
+            return;
+        }
+        throw Error("don't expect to get this far");
+    }
+};
+const groupRowsByViewport = (rows)=>{
+    const result = {};
+    for (const row of rows){
+        const rowsForViewport = result[row.viewPortId] || (result[row.viewPortId] = []);
+        insertRow(rowsForViewport, row);
+    }
+    return result;
+};
+const createSchemaFromTableMetadata = ({ columns, dataTypes, key, table })=>({
+        table,
+        columns: columns.map((col, idx)=>({
+                name: col,
+                serverDataType: dataTypes[idx]
+            })),
+        key
+    });
+export { createSchemaFromTableMetadata, getFirstAndLastRows, groupRowsByViewport, hasRequestId, stripRequestId };

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

@@ -0,0 +1,172 @@
+import { WindowRange, logger } from "@vuu-ui/vuu-utils";
+const EMPTY_ARRAY = [];
+const log = logger("array-backed-moving-window");
+function dataIsUnchanged(newRow, existingRow) {
+    if (!existingRow) return false;
+    if (existingRow.data.length !== newRow.data.length) return false;
+    if (existingRow.sel !== newRow.sel) return false;
+    for(let i = 0; i < existingRow.data.length; i++)if (existingRow.data[i] !== newRow.data[i]) return false;
+    return true;
+}
+class ArrayBackedMovingWindow {
+    #range;
+    bufferSize;
+    internalData;
+    rowsWithinRange;
+    clientRange;
+    rowCount;
+    constructor({ from: clientFrom, to: clientTo }, { from, to }, bufferSize){
+        this.bufferSize = bufferSize;
+        this.clientRange = new WindowRange(clientFrom, clientTo);
+        this.#range = new WindowRange(from, to);
+        this.internalData = new Array(bufferSize);
+        this.rowsWithinRange = 0;
+        this.rowCount = 0;
+    }
+    get range() {
+        return this.#range;
+    }
+    outOfRange(firstIndex, lastIndex) {
+        const { from, to } = this.range;
+        if (lastIndex < from) return true;
+        if (firstIndex >= to) return true;
+    }
+    setRowCount = (rowCount)=>{
+        log.info?.(`setRowCount ${rowCount}`);
+        if (rowCount < this.internalData.length) this.internalData.length = rowCount;
+        if (rowCount < this.rowCount) {
+            this.rowsWithinRange = 0;
+            const end = Math.min(rowCount, this.clientRange.to);
+            for(let i = this.clientRange.from; i < end; i++){
+                const rowIndex = i - this.#range.from;
+                if (void 0 !== this.internalData[rowIndex]) this.rowsWithinRange += 1;
+            }
+        }
+        this.rowCount = rowCount;
+    };
+    setAtIndex(row) {
+        const { rowIndex: index } = row;
+        const internalIndex = index - this.#range.from;
+        if (dataIsUnchanged(row, this.internalData[internalIndex])) return false;
+        const isWithinClientRange = this.isWithinClientRange(index);
+        if (isWithinClientRange || this.isWithinRange(index)) {
+            if (!this.internalData[internalIndex] && isWithinClientRange) this.rowsWithinRange += 1;
+            this.internalData[internalIndex] = row;
+        }
+        return isWithinClientRange;
+    }
+    getAtIndex(index) {
+        return this.#range.isWithin(index) && null != this.internalData[index - this.#range.from] ? this.internalData[index - this.#range.from] : void 0;
+    }
+    isWithinRange(index) {
+        return this.#range.isWithin(index);
+    }
+    isWithinClientRange(index) {
+        return this.clientRange.isWithin(index);
+    }
+    setClientRange(from, to) {
+        log.debug?.(`setClientRange ${from} - ${to}`);
+        const currentFrom = this.clientRange.from;
+        const currentTo = Math.min(this.clientRange.to, this.rowCount);
+        if (from === currentFrom && to === currentTo) return [
+            false,
+            EMPTY_ARRAY
+        ];
+        const originalRange = this.clientRange.copy();
+        this.clientRange.from = from;
+        this.clientRange.to = to;
+        this.rowsWithinRange = 0;
+        for(let i = from; i < to; i++){
+            const internalIndex = i - this.#range.from;
+            if (this.internalData[internalIndex]) this.rowsWithinRange += 1;
+        }
+        const clientRows = [];
+        const offset = this.#range.from;
+        if (to > originalRange.to) {
+            const start = Math.max(from, originalRange.to);
+            for(let i = start - offset; i < to - offset; i++){
+                const row = this.internalData[i];
+                if (row) clientRows.push(row);
+            }
+        } else {
+            const end = Math.min(originalRange.from, to);
+            for(let i = from - offset; i < end - offset; i++){
+                const row = this.internalData[i];
+                if (row) clientRows.push(row);
+            }
+        }
+        const serverDataRequired = this.bufferBreakout(from, to);
+        return [
+            serverDataRequired,
+            clientRows
+        ];
+    }
+    setRange(from, to) {
+        if (from !== this.#range.from || to !== this.#range.to) {
+            log.debug?.(`setRange ${from} - ${to}`);
+            const [overlapFrom, overlapTo] = this.#range.overlap(from, to);
+            const newData = new Array(to - from);
+            this.rowsWithinRange = 0;
+            for(let i = overlapFrom; i < overlapTo; i++){
+                const row = this.getAtIndex(i);
+                if (row) {
+                    const index = i - from;
+                    newData[index] = row;
+                    if (this.isWithinClientRange(i)) this.rowsWithinRange += 1;
+                }
+            }
+            this.internalData = newData;
+            this.#range.from = from;
+            this.#range.to = to;
+        } else log.debug?.(`setRange ${from} - ${to} IGNORED because not changed`);
+    }
+    get data() {
+        return this.internalData;
+    }
+    bufferBreakout = (from, to)=>{
+        const bufferPerimeter = 0.25 * this.bufferSize;
+        if (this.#range.to - to < bufferPerimeter) return true;
+        if (this.#range.from > 0 && from - this.#range.from < bufferPerimeter) return true;
+        return false;
+    };
+    getData() {
+        const { from, to } = this.#range;
+        const { from: clientFrom, to: clientTo } = this.clientRange;
+        const startOffset = Math.max(0, clientFrom - from);
+        const endOffset = Math.min(to - from, to, clientTo - from, this.rowCount ?? to);
+        return this.internalData.slice(startOffset, endOffset);
+    }
+    clear() {
+        log.debug?.("clear");
+        this.internalData.length = 0;
+        this.rowsWithinRange = 0;
+        this.setRowCount(0);
+    }
+    getCurrentDataRange() {
+        const rows = this.internalData;
+        const len = rows.length;
+        let [firstRow] = this.internalData;
+        let lastRow = this.internalData[len - 1];
+        if (firstRow && lastRow) return [
+            firstRow.rowIndex,
+            lastRow.rowIndex
+        ];
+        for(let i = 0; i < len; i++)if (void 0 !== rows[i]) {
+            firstRow = rows[i];
+            break;
+        }
+        for(let i = len - 1; i >= 0; i--)if (void 0 !== rows[i]) {
+            lastRow = rows[i];
+            break;
+        }
+        if (firstRow && lastRow) return [
+            firstRow.rowIndex,
+            lastRow.rowIndex
+        ];
+        return [
+            -1,
+            -1
+        ];
+    }
+}
+export { ArrayBackedMovingWindow };

package/src/server-proxy/messages.js

@@ -0,0 +1,34 @@
+const CHANGE_VP_SUCCESS = "CHANGE_VP_SUCCESS";
+const CHANGE_VP_RANGE_SUCCESS = "CHANGE_VP_RANGE_SUCCESS";
+const CLOSE_TREE_NODE = "CLOSE_TREE_NODE";
+const CLOSE_TREE_SUCCESS = "CLOSE_TREE_SUCCESS";
+const CLOSE_TREE_REJECT = "CLOSE_TREE_REJECT";
+const CREATE_VISUAL_LINK = "CREATE_VISUAL_LINK";
+const CREATE_VP = "CREATE_VP";
+const DISABLE_VP = "DISABLE_VP";
+const DISABLE_VP_SUCCESS = "DISABLE_VP_SUCCESS";
+const DISABLE_VP_REJECT = "DISABLE_VP_REJECT";
+const ENABLE_VP = "ENABLE_VP";
+const ENABLE_VP_SUCCESS = "ENABLE_VP_SUCCESS";
+const ENABLE_VP_REJECT = "ENABLE_VP_REJECT";
+const GET_TABLE_META = "GET_TABLE_META";
+const GET_VP_VISUAL_LINKS = "GET_VP_VISUAL_LINKS";
+const GET_VIEW_PORT_MENUS = "GET_VIEW_PORT_MENUS";
+const VIEW_PORT_MENUS_SELECT_RPC = "VIEW_PORT_MENUS_SELECT_RPC";
+const VIEW_PORT_MENU_CELL_RPC = "VIEW_PORT_MENU_CELL_RPC";
+const VIEW_PORT_MENU_TABLE_RPC = "VIEW_PORT_MENU_TABLE_RPC";
+const VIEW_PORT_MENU_ROW_RPC = "VIEW_PORT_MENU_ROW_RPC";
+const VIEW_PORT_MENU_RESP = "VIEW_PORT_MENU_RESP";
+const VIEW_PORT_MENU_REJ = "VIEW_PORT_MENU_REJ";
+const HB = "HB";
+const HB_RESP = "HB_RESP";
+const OPEN_TREE_NODE = "OPEN_TREE_NODE";
+const OPEN_TREE_SUCCESS = "OPEN_TREE_SUCCESS";
+const OPEN_TREE_REJECT = "OPEN_TREE_REJECT";
+const REMOVE_VP = "REMOVE_VP";
+const REMOVE_VP_REJECT = "REMOVE_VP_REJECT";
+const MENU_RPC_RESP = "MENU_RPC_RESP";
+const TABLE_ROW = "TABLE_ROW";
+const SIZE = "SIZE";
+const UPDATE = "U";
+export { CHANGE_VP_RANGE_SUCCESS, CHANGE_VP_SUCCESS, CLOSE_TREE_NODE, CLOSE_TREE_REJECT, CLOSE_TREE_SUCCESS, CREATE_VISUAL_LINK, CREATE_VP, DISABLE_VP, DISABLE_VP_REJECT, DISABLE_VP_SUCCESS, ENABLE_VP, ENABLE_VP_REJECT, ENABLE_VP_SUCCESS, GET_TABLE_META, GET_VIEW_PORT_MENUS, GET_VP_VISUAL_LINKS, HB, HB_RESP, MENU_RPC_RESP, OPEN_TREE_NODE, OPEN_TREE_REJECT, OPEN_TREE_SUCCESS, REMOVE_VP, REMOVE_VP_REJECT, SIZE, TABLE_ROW, UPDATE, VIEW_PORT_MENUS_SELECT_RPC, VIEW_PORT_MENU_CELL_RPC, VIEW_PORT_MENU_REJ, VIEW_PORT_MENU_RESP, VIEW_PORT_MENU_ROW_RPC, VIEW_PORT_MENU_TABLE_RPC };