@ultipa-graph/ultipa-driver 5.0.0-s5.0

package/dist/utils/format.js

@@ -0,0 +1,990 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatResponse = exports.FormatType = exports.mergeQueryResponse = void 0;
+const ultipa_pb_1 = require("../proto/ultipa_pb");
+const types_1 = require("../types");
+const lodash_1 = __importDefault(require("lodash"));
+const index_1 = require("../utils/index");
+/**
+ let a = "123"
+let aBuffer = new DataView(new ArrayBuffer(4))
+aBuffer.setInt32(0, parseInt(a))
+let aValue = new DataView(aBuffer.buffer).getInt32(aBuffer.byteOffset)
+
+console.log(
+    a, aBuffer, aValue
+)
+console.log(new ArrayBuffer(4))
+
+let b = "!@3鼎折覆餗"
+let bBuffer = Buffer.from(b, 'utf8');
+let bString = new TextDecoder("utf-8").decode(bBuffer);
+console.log({
+    b, bBuffer, bString
+})
+ */
+let ULITPA_PRIVATE_KEYS = {
+    id: "_id",
+    from: "_from",
+    to: "_to",
+    uuid: "_uuid",
+    from_uuid: "_from_uuid",
+    to_uuid: "_to_uuid",
+};
+const _mapValues = (values, types, timeZone) => {
+    let result = new Map;
+    values.forEach((v, index) => {
+        let pty = types[index];
+        result.set(pty.getPropertyName(), index_1.DESERIALIZE.deserialize(v, pty.getPropertyType(), pty.getSubTypesList(), timeZone));
+        // [pty.getPropertyName()] = DESERIALIZE.deserialize(v, pty.getPropertyType(), pty.getSubTypesList(), timeZone);
+    });
+    // console.log(result)
+    return result;
+};
+const DataMerge = {
+    arrayDiff: (arr1, arr2) => {
+        let diff = [];
+        arr2.forEach((s) => {
+            if (!arr1.includes(s)) {
+                diff.push(s);
+            }
+        });
+        return diff;
+    },
+    merge: (o1, o2, ignoreKeys) => {
+        if (!o2) {
+            return o1;
+        }
+        function customizer(objValue, srcValue, key) {
+            if (ignoreKeys && ignoreKeys.includes(key)) {
+                return srcValue;
+            }
+            if (lodash_1.default.isArray(srcValue)) {
+                return srcValue.concat(objValue);
+            }
+        }
+        return lodash_1.default.mergeWith(o2, o1, customizer);
+    },
+    concat: (arr1, arr2, byKey, ignoreKeys) => {
+        if (!(arr2 === null || arr2 === void 0 ? void 0 : arr2.length)) {
+            return arr1;
+        }
+        if (byKey) {
+            let newArray = [...arr1];
+            let diff = DataMerge.arrayDiff(arr1.map((o) => o[byKey]), arr2.map((o) => o[byKey]));
+            diff.forEach((k) => newArray.push({
+                [byKey]: k,
+            }));
+            let results = [];
+            newArray.forEach((o) => {
+                let newObj = o;
+                let finds = arr2.filter((o2) => {
+                    return o2[byKey] == o[byKey];
+                });
+                finds.forEach((f) => {
+                    newObj = DataMerge.merge(newObj, f, ignoreKeys);
+                });
+                results.push(newObj);
+            });
+            return results;
+        }
+        return [...arr1, ...arr2];
+    },
+};
+const mergeQueryResponse = (res1, res2) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    res1.status = res2.status;
+    if (!(res2 === null || res2 === void 0 ? void 0 : res2.data)) {
+        return res1;
+    }
+    // res1.data.results = DataMerge.concat(res1.data?.results, res2.data?.results);
+    res1.data.paths = DataMerge.concat((_a = res1.data) === null || _a === void 0 ? void 0 : _a.paths, (_b = res2.data) === null || _b === void 0 ? void 0 : _b.paths, "alias");
+    res1.data.nodes = DataMerge.concat((_c = res1.data) === null || _c === void 0 ? void 0 : _c.nodes, (_d = res2.data) === null || _d === void 0 ? void 0 : _d.nodes, "alias");
+    res1.data.edges = DataMerge.concat((_e = res1.data) === null || _e === void 0 ? void 0 : _e.edges, (_f = res2.data) === null || _f === void 0 ? void 0 : _f.edges, "alias");
+    res1.data.attrs = DataMerge.concat((_g = res1.data) === null || _g === void 0 ? void 0 : _g.attrs, (_h = res2.data) === null || _h === void 0 ? void 0 : _h.attrs, "alias");
+    res1.data.tables = DataMerge.concat((_j = res1.data) === null || _j === void 0 ? void 0 : _j.tables, (_k = res2.data) === null || _k === void 0 ? void 0 : _k.tables, "name", ["headers"]);
+    if (res2 === null || res2 === void 0 ? void 0 : res2.statistics) {
+        res1.statistics = res2.statistics;
+        res1.data.statistics = res2.statistics;
+        res1.data.total_time_cost = res2.statistics.totalCost;
+        res1.data.engine_time_cost = res2.statistics.engineCost;
+    }
+    return res1;
+};
+exports.mergeQueryResponse = mergeQueryResponse;
+exports.FormatType = {
+    queryResponse: (res, timeZone) => {
+        var _a, _b;
+        // console.log(JSON.stringify(res.toObject()))
+        let response = new types_1.ULTIPA.QueryBaseResponse();
+        response.status = exports.FormatType.status(res.getStatus());
+        let statistics = (_b = (_a = exports.FormatType.table(res.getStatistics(), timeZone)) === null || _a === void 0 ? void 0 : _a.toKV()) === null || _b === void 0 ? void 0 : _b[0];
+        if (statistics) {
+            statistics = {
+                totalCost: +statistics.total_time_cost || 0,
+                engineCost: +statistics.engine_time_cost || 0,
+                nodeAffected: +statistics.node_affected || 0,
+                edgeAffected: +statistics.edge_affected || 0,
+            };
+        }
+        let attrs = exports.FormatType.attrAliases(res.getAttrsList(), timeZone);
+        let attrs_map = {};
+        let attrs_format = [];
+        let addAttrMap = (alias, type, values, p) => {
+            if (!attrs_map[alias]) {
+                if (p.has_attr_data) {
+                    type = types_1.ULTIPA.ResultType.RESULT_TYPE_ATTR;
+                }
+                let v = {
+                    alias,
+                    type: type,
+                    type_desc: types_1.ULTIPA.ResultType[type],
+                    values: [],
+                };
+                attrs_map[alias] = v;
+                attrs_format.push(v);
+            }
+            if (type === types_1.ULTIPA.ResultType.RESULT_TYPE_ATTR && p.only_attr_list) {
+                attrs_map[alias].values = values;
+            }
+            else {
+                attrs_map[alias].values.push(values);
+            }
+        };
+        attrs === null || attrs === void 0 ? void 0 : attrs.forEach(attrAlias => {
+            var _a;
+            let alias = attrAlias.alias;
+            let { has_attr_data, has_ultipa_data, } = attrAlias.attr;
+            let only_attr_list = has_attr_data && !has_ultipa_data;
+            let p = {
+                only_attr_list,
+                has_attr_data,
+                has_ultipa_data,
+            };
+            if (attrAlias.attr.type == types_1.ULTIPA.PropertyType.PROPERTY_LIST) {
+                if (only_attr_list) {
+                    addAttrMap(alias, types_1.ULTIPA.ResultType.RESULT_TYPE_ATTR, attrAlias.attr.values, p);
+                    return;
+                }
+                (_a = attrAlias.attr.values) === null || _a === void 0 ? void 0 : _a.forEach(o => {
+                    if (!o || !o.type) {
+                        addAttrMap(alias, types_1.ULTIPA.ResultType.RESULT_TYPE_ATTR, o, p);
+                        return;
+                    }
+                    switch (o.type) {
+                        case types_1.ULTIPA.ResultType.RESULT_TYPE_EDGE:
+                            {
+                                addAttrMap(alias, o.type, o.edges, p);
+                            }
+                            break;
+                        case types_1.ULTIPA.ResultType.RESULT_TYPE_NODE:
+                            {
+                                addAttrMap(alias, o.type, o.nodes, p);
+                            }
+                            break;
+                        case types_1.ULTIPA.ResultType.RESULT_TYPE_PATH:
+                            {
+                                addAttrMap(alias, o.type, o.paths, p);
+                            }
+                            break;
+                    }
+                });
+            }
+            else {
+                addAttrMap(alias, types_1.ULTIPA.ResultType.RESULT_TYPE_ATTR, attrAlias.attr.values, p);
+            }
+        });
+        response.data = {
+            total_time_cost: res.getTotalTimeCost(),
+            engine_time_cost: res.getEngineTimeCost(),
+            results: exports.FormatType.resultAliases(res.getAliasList()),
+            paths: exports.FormatType.pathAliases(res.getPathsList()),
+            nodes: exports.FormatType.nodeAliases(res.getNodesList(), timeZone),
+            edges: exports.FormatType.edgeAliases(res.getEdgesList(), timeZone),
+            graph: exports.FormatType.graphAliases(res.getPathsList(), timeZone),
+            attrs: attrs_format,
+            tables: exports.FormatType.tables(res.getTablesList(), timeZone),
+            statistics,
+            explainPlans: exports.FormatType.explainPlan(res.getExplainPlan()),
+        };
+        response.statistics = response.data.statistics;
+        response.explainPlans = response.data.explainPlans;
+        return response;
+    },
+    status: (statusData, p) => {
+        let status = {
+            code: types_1.ULTIPA.Code.SUCCESS,
+            message: "",
+        };
+        if (statusData) {
+            status.code = statusData.getErrorCode();
+            status.message = statusData.getMsg();
+        }
+        status.code_desc = types_1.ULTIPA.Code[status.code];
+        return status;
+    },
+    keyValue: (keyValuesData) => {
+        if (!keyValuesData || keyValuesData.length == 0) {
+            return {};
+        }
+        let keyValue = {};
+        keyValuesData.forEach((kv) => {
+            keyValue[kv.getKey()] = kv.getValue();
+        });
+        return keyValue;
+    },
+    paths: (paths) => {
+        let newPaths = [];
+        paths.forEach(o => {
+            let p = new types_1.ULTIPA.Path();
+            p.nodeUUIDs = exports.FormatType.uuids(o.getNodeTable());
+            p.edgeUUIDs = exports.FormatType.uuids(o.getEdgeTable());
+            // p.length = p.edges.length  
+            newPaths.push(p);
+        });
+        return newPaths;
+    },
+    pathAliases: (pathsData) => {
+        if (!pathsData || pathsData.length == 0) {
+            return [];
+        }
+        let pathAliases = [];
+        pathsData.forEach((pathData) => {
+            let pathAlias = {
+                alias: pathData.getAlias(),
+                paths: exports.FormatType.paths(pathData.getPathsList())
+            };
+            pathAliases.push(pathAlias);
+        });
+        return pathAliases;
+    },
+    graph: (paths, timeZone) => {
+        var _a, _b;
+        let graph = new types_1.ULTIPA.Graph();
+        graph.paths = exports.FormatType.paths(paths);
+        (_a = graph.nodes) !== null && _a !== void 0 ? _a : (graph.nodes = new Map());
+        (_b = graph.edges) !== null && _b !== void 0 ? _b : (graph.edges = new Map());
+        paths.forEach(o => {
+            let nodes = exports.FormatType.nodeTable(o.getNodeTable(), timeZone);
+            nodes.forEach(n => {
+                graph.nodes.set(n._uuid, n);
+            });
+            let edges = exports.FormatType.edgeTable(o.getEdgeTable(), timeZone);
+            edges.forEach(e => {
+                graph.edges.set(e._uuid, e);
+            });
+        });
+        return graph;
+    },
+    graphAliases: (pathsData, timezone) => {
+        if (!pathsData || pathsData.length == 0) {
+            return [];
+        }
+        let graphAliases = [];
+        pathsData.forEach((pathdata => {
+            let graphAlias = {
+                alias: pathdata.getAlias(),
+                graph: exports.FormatType.graph(pathdata.getPathsList(), timezone)
+            };
+            graphAliases.push(graphAlias);
+        }));
+        return graphAliases;
+    },
+    explainPlan: (data) => {
+        if (!data) {
+            return null;
+        }
+        let explainPlan = {
+            plan_nodes: []
+        };
+        let planNodes = [];
+        data.getPlanNodesList().forEach(plan => {
+            let one = {
+                alias: plan.getAlias(),
+                children_num: plan.getChildrenNum(),
+                infos: plan.getInfos(),
+                query_text: plan.getQueryText(),
+            };
+            planNodes.push(one);
+        });
+        explainPlan.plan_nodes = planNodes;
+        return explainPlan;
+    },
+    table: (tableData, timeZone) => {
+        if (!tableData) {
+            return null;
+        }
+        let tableRows = [];
+        let tableHeaders = [];
+        tableData.getHeadersList().forEach(h => {
+            tableHeaders.push({
+                name: h.getPropertyName(),
+                type: h.getPropertyType(),
+            });
+        });
+        tableData.getTableRowsList().forEach((tableRowData) => {
+            let values = [];
+            tableRowData.getValuesList_asU8().forEach((v, i) => {
+                let header = tableHeaders[i];
+                values.push(index_1.DESERIALIZE.deserialize(v, header.type, header.subTypes, timeZone));
+            });
+            tableRows.push(values);
+        });
+        let t = new types_1.ULTIPA.Table();
+        t.name = tableData.getTableName();
+        t.alias = t.name;
+        t.headers = tableHeaders.map(o => o.name);
+        t.rows = tableRows;
+        return t;
+    },
+    tables: (tablesData, timeZone) => {
+        if (!tablesData || tablesData.length == 0) {
+            return [];
+        }
+        let tables = [];
+        tablesData.forEach((tableData) => {
+            tables.push(exports.FormatType.table(tableData, timeZone));
+        });
+        return tables;
+    },
+    resultAliases: (resultAliases) => {
+        if (!resultAliases || resultAliases.length == 0) {
+            return [];
+        }
+        let rs = [];
+        resultAliases.forEach(one => {
+            rs.push({
+                alias: one.getAlias(),
+                result_type: one.getResultType()
+            });
+        });
+        return rs;
+    },
+    // arrayAliases: (arrayAliases: ArrayAlias[], timeZone: ULTIPA.TimeZone) => {
+    //   if (!arrayAliases || arrayAliases.length == 0) {
+    //     return [];
+    //   }
+    //   let rs :ULTIPA.ArrayAliases = []
+    //   arrayAliases.forEach(one => {
+    //       let eles = [] 
+    //       let type = one.getPropertyType()
+    //       one.getElementsList().map(o => {
+    //         let rs = []
+    //         o.getValuesList_asU8().map(o1 => {
+    //           rs.push(DESERIALIZE.base(o1, type, timeZone))
+    //         })
+    //         eles.push(rs)
+    //       })
+    //       rs.push({
+    //         alias: one.getAlias(),
+    //         elements: eles,
+    //       })
+    //   })
+    //   return rs
+    // },
+    nodeAliases: (nodesListData, timeZone) => {
+        if (!nodesListData || nodesListData.length == 0) {
+            return [];
+        }
+        let nodeAliases = [];
+        nodesListData.forEach((nodeData) => {
+            nodeAliases.push({
+                alias: nodeData.getAlias(),
+                nodes: exports.FormatType.nodeTable(nodeData.getNodeTable(), timeZone),
+            });
+        });
+        return nodeAliases;
+    },
+    edgeAliases: (edgesListData, timeZone) => {
+        if (!edgesListData || edgesListData.length == 0) {
+            return [];
+        }
+        let nodeAliases = [];
+        edgesListData.forEach((nodeData) => {
+            nodeAliases.push({
+                alias: nodeData.getAlias(),
+                edges: exports.FormatType.edgeTable(nodeData.getEdgeTable(), timeZone),
+            });
+        });
+        return nodeAliases;
+    },
+    toEdgeTable: (propertyTypeObject, schemaName, headers, rows, timeZone) => {
+        let edgeTable = new ultipa_pb_1.EntityTable();
+        let handles = [ULITPA_PRIVATE_KEYS.uuid, ULITPA_PRIVATE_KEYS.from, ULITPA_PRIVATE_KEYS.to, ULITPA_PRIVATE_KEYS.from_uuid, ULITPA_PRIVATE_KEYS.to_uuid];
+        let schemaHeaders = [];
+        let schemaHeader = new ultipa_pb_1.Schema();
+        schemaHeader.setSchemaName(schemaName);
+        let headerList = [];
+        headers.forEach((h) => {
+            if (handles.includes(h)) {
+                return;
+            }
+            let header = new ultipa_pb_1.Property();
+            header.setPropertyName(h);
+            let typeCfg = index_1.PropertyUtils.GetPropertyType(propertyTypeObject[h]);
+            header.setPropertyType(typeCfg.type);
+            if (typeCfg.subTypes) {
+                header.setSubTypesList(typeCfg.subTypes);
+            }
+            headerList.push(header);
+        });
+        schemaHeader.setPropertiesList(headerList);
+        schemaHeaders.push(schemaHeader);
+        edgeTable.setSchemasList(schemaHeaders);
+        let edgeRowsList = [];
+        rows.forEach(rowsObj => {
+            let edgeRow = new ultipa_pb_1.EntityRow();
+            if (!rowsObj) {
+                edgeRow.setIsNull(true);
+                edgeRowsList.push(edgeRow);
+                return;
+            }
+            edgeRow.setSchemaName(schemaName);
+            let rowValues = rowsObj;
+            let values = [];
+            headers.forEach((h, index) => {
+                if (h === ULITPA_PRIVATE_KEYS.from) {
+                    edgeRow.setFromId(rowValues[index]);
+                    return;
+                }
+                if (h === ULITPA_PRIVATE_KEYS.to) {
+                    edgeRow.setToId(rowValues[index]);
+                    return;
+                }
+                if (h === ULITPA_PRIVATE_KEYS.uuid) {
+                    let uuid = rowValues[index];
+                    if (uuid) {
+                        uuid += "";
+                    }
+                    edgeRow.setUuid(uuid);
+                    return;
+                }
+                if (h === ULITPA_PRIVATE_KEYS.from_uuid) {
+                    edgeRow.setFromUuid(rowValues[index]);
+                    return;
+                }
+                if (h === ULITPA_PRIVATE_KEYS.to_uuid) {
+                    edgeRow.setToUuid(rowValues[index]);
+                    return;
+                }
+                let typeCfg = index_1.PropertyUtils.GetPropertyType(propertyTypeObject[h]);
+                values.push(index_1.SERIALIZE.serialize(rowValues[index], typeCfg.type, typeCfg.subTypes, timeZone));
+            });
+            edgeRow.setValuesList(values);
+            edgeRowsList.push(edgeRow);
+        });
+        edgeTable.setEntityRowsList(edgeRowsList);
+        return edgeTable;
+    },
+    toPropertyTypeObject: (properties) => {
+        let object = {};
+        properties.forEach(p => {
+            object[p.name] = p.type;
+        });
+        return object;
+    },
+    toNodeTable: (propertyTypeObject, schemaName, headers, rows, timeZone) => {
+        let nodeTable = new ultipa_pb_1.EntityTable();
+        let handles = [ULITPA_PRIVATE_KEYS.id, ULITPA_PRIVATE_KEYS.uuid];
+        let schemaHeaders = [];
+        let schemaHeader = new ultipa_pb_1.Schema();
+        schemaHeader.setSchemaName(schemaName);
+        let headerList = [];
+        headers.forEach((h) => {
+            if (handles.includes(h)) {
+                return;
+            }
+            let header = new ultipa_pb_1.Property();
+            header.setPropertyName(h);
+            let typeCfg = index_1.PropertyUtils.GetPropertyType(propertyTypeObject[h]);
+            header.setPropertyType(typeCfg.type);
+            if (typeCfg.subTypes) {
+                header.setSubTypesList(typeCfg.subTypes);
+            }
+            headerList.push(header);
+        });
+        schemaHeader.setPropertiesList(headerList);
+        schemaHeaders.push(schemaHeader);
+        nodeTable.setSchemasList(schemaHeaders);
+        let nodeRowsList = [];
+        rows.forEach(rowObj => {
+            let nodeRow = new ultipa_pb_1.EntityRow();
+            if (!rowObj) {
+                nodeRow.setIsNull(true);
+                nodeRowsList.push(nodeRow);
+                return;
+            }
+            nodeRow.setSchemaName(schemaName);
+            let values = [];
+            let rowValues = rowObj;
+            headers.forEach((h, index) => {
+                if (h === ULITPA_PRIVATE_KEYS.id) {
+                    nodeRow.setId(rowValues[index]);
+                    return;
+                }
+                if (h === ULITPA_PRIVATE_KEYS.uuid) {
+                    let uuid = rowValues[index];
+                    if (uuid) {
+                        uuid += "";
+                    }
+                    nodeRow.setUuid(uuid);
+                    return;
+                }
+                let typeCfg = index_1.PropertyUtils.GetPropertyType(propertyTypeObject[h]);
+                values.push(index_1.SERIALIZE.serialize(rowValues[index], typeCfg.type, typeCfg.subTypes, timeZone));
+            });
+            nodeRow.setValuesList(values);
+            nodeRowsList.push(nodeRow);
+        });
+        nodeTable.setEntityRowsList(nodeRowsList);
+        return nodeTable;
+    },
+    toEdgeTableWithSchema: (schema, rows, timeZone) => {
+        let table = new ultipa_pb_1.EntityTable();
+        let handles = [ULITPA_PRIVATE_KEYS.uuid, ULITPA_PRIVATE_KEYS.from, ULITPA_PRIVATE_KEYS.to, ULITPA_PRIVATE_KEYS.from_uuid, ULITPA_PRIVATE_KEYS.to_uuid];
+        let schemaHeaders = [];
+        let schemaHeader = new ultipa_pb_1.Schema();
+        schemaHeader.setSchemaName(schema.name);
+        let headerList = [];
+        schema.properties.forEach((o) => {
+            let { name, type, subTypes } = o;
+            if (handles.includes(name)) {
+                return;
+            }
+            let header = new ultipa_pb_1.Property();
+            header.setPropertyName(name);
+            header.setPropertyType(type);
+            if (subTypes) {
+                header.setSubTypesList(subTypes);
+            }
+            headerList.push(header);
+        });
+        schemaHeader.setPropertiesList(headerList);
+        schemaHeaders.push(schemaHeader);
+        table.setSchemasList(schemaHeaders);
+        let rowList = [];
+        rows.forEach(rowObj => {
+            let row = new ultipa_pb_1.EntityRow();
+            if (!rowObj) {
+                row.setIsNull(true);
+                rowList.push(row);
+                return;
+            }
+            row.setSchemaName(schema.name);
+            if (!!rowObj._uuid) {
+                row.setUuid(rowObj._uuid);
+            }
+            if (!!rowObj._from) {
+                row.setFromId(rowObj._from);
+            }
+            if (!!rowObj._to) {
+                row.setToId(rowObj._to);
+            }
+            let values = [];
+            let rowValues = rowObj.values || new Map();
+            headerList.forEach((o, index) => {
+                let name = o.getPropertyName();
+                let type = o.getPropertyType();
+                let subTypes = o.getSubTypesList();
+                values.push(index_1.SERIALIZE.serialize(rowValues.get(name), type, subTypes, timeZone));
+            });
+            row.setValuesList(values);
+            rowList.push(row);
+        });
+        table.setEntityRowsList(rowList);
+        return table;
+    },
+    toNodeTableWithSchema: (schema, rows, timeZone) => {
+        let nodeTable = new ultipa_pb_1.EntityTable();
+        let handles = [ULITPA_PRIVATE_KEYS.id, ULITPA_PRIVATE_KEYS.uuid];
+        let schemaHeaders = [];
+        let schemaHeader = new ultipa_pb_1.Schema();
+        schemaHeader.setSchemaName(schema.name);
+        let headerList = [];
+        schema.properties.forEach((o) => {
+            let { name, type, subTypes } = o;
+            if (handles.includes(name)) {
+                return;
+            }
+            let header = new ultipa_pb_1.Property();
+            header.setPropertyName(name);
+            header.setPropertyType(type);
+            if (subTypes) {
+                header.setSubTypesList(subTypes);
+            }
+            headerList.push(header);
+        });
+        schemaHeader.setPropertiesList(headerList);
+        schemaHeaders.push(schemaHeader);
+        nodeTable.setSchemasList(schemaHeaders);
+        let nodeRowsList = [];
+        rows.forEach(rowObj => {
+            let nodeRow = new ultipa_pb_1.EntityRow();
+            if (!rowObj) {
+                nodeRow.setIsNull(true);
+                nodeRowsList.push(nodeRow);
+                return;
+            }
+            if (!!rowObj._id) {
+                nodeRow.setId(rowObj._id);
+            }
+            if (!!rowObj._uuid) {
+                nodeRow.setUuid(rowObj._uuid);
+            }
+            nodeRow.setSchemaName(schema.name);
+            let values = [];
+            let rowValues = rowObj.values || new Map();
+            headerList.forEach((o, index) => {
+                let name = o.getPropertyName();
+                let type = o.getPropertyType();
+                let subTypes = o.getSubTypesList();
+                values.push(index_1.SERIALIZE.serialize(rowValues.get(name), type, subTypes, timeZone));
+            });
+            nodeRow.setValuesList(values);
+            nodeRowsList.push(nodeRow);
+        });
+        nodeTable.setEntityRowsList(nodeRowsList);
+        return nodeTable;
+    },
+    uuids: (tableData) => {
+        if (!tableData) {
+            return [];
+        }
+        let rowsData = tableData.getEntityRowsList();
+        let uuids = [];
+        rowsData.forEach((data) => {
+            uuids.push(data.getUuid());
+        });
+        return uuids;
+    },
+    nodeTable: (nodeTableData, timeZone) => {
+        let tables = [];
+        if (!nodeTableData) {
+            return tables;
+        }
+        let headerMap = {};
+        nodeTableData.getSchemasList().forEach((sh) => {
+            let schema = sh.getSchemaName();
+            headerMap[schema] = sh.getPropertiesList();
+        });
+        let nodeRowsData = nodeTableData.getEntityRowsList();
+        nodeRowsData.forEach((nodeRowData) => {
+            if (nodeRowData.getIsNull()) {
+                tables.push(null);
+                return;
+            }
+            let schema = nodeRowData.getSchemaName();
+            let ptys = headerMap[schema];
+            let values = nodeRowData.getValuesList_asU8();
+            let _v = _mapValues(values, ptys, timeZone);
+            let nodeRow = new types_1.ULTIPA.Node();
+            nodeRow._id = nodeRowData.getId(),
+                nodeRow._uuid = nodeRowData.getUuid(),
+                nodeRow.schema = schema,
+                nodeRow.values = _v,
+                tables.push(nodeRow);
+        });
+        return tables;
+    },
+    edgeTable: (edgeTableData, timeZone) => {
+        let tables = [];
+        if (!edgeTableData) {
+            return tables;
+        }
+        let headerMap = {};
+        edgeTableData.getSchemasList().forEach((sh) => {
+            let schema = sh.getSchemaName();
+            headerMap[schema] = sh.getPropertiesList();
+        });
+        edgeTableData.getSchemasList().forEach((sh) => {
+            let schema = sh.getSchemaName();
+            headerMap[schema] = sh.getPropertiesList();
+        });
+        let edgeRowsData = edgeTableData.getEntityRowsList();
+        edgeRowsData.forEach((rowData) => {
+            if (rowData.getIsNull()) {
+                tables.push(null);
+                return;
+            }
+            let schema = rowData.getSchemaName();
+            let ptys = headerMap[schema];
+            let values = rowData.getValuesList_asU8();
+            let _v = _mapValues(values, ptys, timeZone);
+            let edgeRow = new types_1.ULTIPA.Edge();
+            // id: rowData.getId(),
+            edgeRow._from = rowData.getFromId();
+            edgeRow._to = rowData.getToId();
+            edgeRow._uuid = rowData.getUuid();
+            edgeRow.schema = schema;
+            edgeRow.values = _v;
+            tables.push(edgeRow);
+        });
+        return tables;
+    },
+    attr(attr, timeZone) {
+        let type = attr.getValueType();
+        let result = {
+            type,
+            type_desc: index_1.PropertyUtils.propertyGet(type),
+            values: null,
+            has_attr_data: false,
+            has_ultipa_data: false,
+        };
+        result.values = [];
+        attr.getValuesList_asU8().forEach((v) => {
+            if (type == types_1.ULTIPA.PropertyType.PROPERTY_NULL) {
+                result.has_attr_data = true;
+                return result.values.push(null);
+            }
+            if (type == types_1.ULTIPA.PropertyType.PROPERTY_LIST) {
+                let attrListData = ultipa_pb_1.AttrListData.deserializeBinary(v);
+                if (attrListData.getIsNull()) {
+                    return result.values.push(null);
+                }
+                let result_type = attrListData.getType();
+                switch (result_type) {
+                    case ultipa_pb_1.ResultType.RESULT_TYPE_NODE:
+                        {
+                            let v = {
+                                type: result_type,
+                                type_desc: types_1.ULTIPA.ResultType[result_type],
+                                nodes: exports.FormatType.nodeTable(attrListData.getNodes(), timeZone)
+                            };
+                            result.has_ultipa_data = true;
+                            result.values.push(v);
+                        }
+                        break;
+                    case ultipa_pb_1.ResultType.RESULT_TYPE_EDGE:
+                        {
+                            let v = {
+                                type: result_type,
+                                type_desc: types_1.ULTIPA.ResultType[result_type],
+                                edges: exports.FormatType.edgeTable(attrListData.getEdges(), timeZone)
+                            };
+                            result.has_ultipa_data = true;
+                            result.values.push(v);
+                        }
+                        break;
+                    case ultipa_pb_1.ResultType.RESULT_TYPE_PATH:
+                        {
+                            let v = {
+                                type: result_type,
+                                type_desc: types_1.ULTIPA.ResultType[result_type],
+                                paths: exports.FormatType.paths(attrListData.getPathsList())
+                            };
+                            result.has_ultipa_data = true;
+                            result.values.push(v);
+                        }
+                        break;
+                    case ultipa_pb_1.ResultType.RESULT_TYPE_ATTR: {
+                        {
+                            let attrs = [];
+                            attrListData.getAttrsList().forEach(o => {
+                                let attr = exports.FormatType.attr(o, timeZone);
+                                if (!attr.values) {
+                                    attrs.push(attr.values);
+                                }
+                                else {
+                                    attrs.push(...attr.values);
+                                }
+                            });
+                            // let v: ULTIPA.AttrListData = {
+                            //   type: result_type,
+                            //   type_desc: ULTIPA.ResultType[result_type],
+                            //   attrs: attrs,
+                            // }
+                            if (attrs.length != 0) {
+                                result.has_attr_data = true;
+                            }
+                            result.values.push(attrs);
+                        }
+                        break;
+                    }
+                }
+            }
+            else {
+                let v1 = index_1.DESERIALIZE.base(v, type, timeZone);
+                result.has_attr_data = true;
+                result.values.push(v1);
+            }
+        });
+        return result;
+    },
+    attrAliases: (attrAliasesData, timeZone) => {
+        if (!attrAliasesData || attrAliasesData.length == 0) {
+            return [];
+        }
+        let attrAliases = [];
+        attrAliasesData.forEach((attrAliasData) => {
+            let v = exports.FormatType.attr(attrAliasData.getAttr(), timeZone);
+            attrAliases.push({
+                alias: attrAliasData.getAlias(),
+                attr: v,
+            });
+        });
+        return attrAliases;
+    },
+    graphPrivileges(graphPrivileges) {
+        let new_graphPrivileges = [];
+        if (graphPrivileges) {
+            graphPrivileges.forEach((graphPrivilege) => {
+                let new_graphPrivilege = Object.assign({}, graphPrivilege);
+                Object.keys(new_graphPrivilege).forEach((key) => {
+                    new_graphPrivilege["name"] = key;
+                    new_graphPrivilege["values"] = new_graphPrivilege[key];
+                    delete new_graphPrivilege[key];
+                });
+                new_graphPrivileges.push(new_graphPrivilege);
+            });
+        }
+        return new_graphPrivileges;
+    },
+};
+exports.FormatResponse = {
+    tableToArray: (table) => {
+        let res = [];
+        if (table) {
+            try {
+                table.rows.forEach((row) => {
+                    let item = {};
+                    row.forEach((value, index) => {
+                        let header = table.headers[index];
+                        item[header] = value;
+                    });
+                    res.push(item);
+                });
+            }
+            catch (error) {
+                console.log(error);
+            }
+        }
+        return res;
+    },
+    formatObjects: (objs, keysFormat) => {
+        if (!keysFormat) {
+            return objs;
+        }
+        let newObjs = [];
+        if ((objs === null || objs === void 0 ? void 0 : objs.length) > 0) {
+            objs.forEach((obj) => {
+                newObjs.push(exports.FormatResponse.formatObject(obj, keysFormat));
+            });
+        }
+        return newObjs;
+    },
+    formatObject: (_obj, keysFormat) => {
+        if (!keysFormat) {
+            return _obj;
+        }
+        let obj = Object.assign({}, _obj);
+        if (keysFormat === null || keysFormat === void 0 ? void 0 : keysFormat.jsonKeys) {
+            keysFormat.jsonKeys.forEach((k) => {
+                try {
+                    if (obj[k]) {
+                        obj[k] = JSON.parse(obj[k]);
+                    }
+                }
+                catch (error) {
+                    console.log(error, k, obj);
+                }
+            });
+        }
+        if (keysFormat === null || keysFormat === void 0 ? void 0 : keysFormat.boolKeys) {
+            keysFormat.boolKeys.forEach((k) => {
+                try {
+                    if (obj[k]) {
+                        obj[k] = obj[k] == "true";
+                    }
+                }
+                catch (error) {
+                    console.log(error, k, obj);
+                }
+            });
+        }
+        if (keysFormat === null || keysFormat === void 0 ? void 0 : keysFormat.keyReplace) {
+            Object.keys(keysFormat.keyReplace).forEach((k) => {
+                if (obj[k]) {
+                    obj[keysFormat.keyReplace[k]] = obj[k];
+                    delete obj[k];
+                }
+            });
+        }
+        if (keysFormat === null || keysFormat === void 0 ? void 0 : keysFormat.dataFormat) {
+            obj = keysFormat.dataFormat(obj);
+        }
+        return obj;
+    },
+    // formatData: (objs :object[] | object, keysFormat?: ResponseKeyFormat) => {
+    //     if (objs && keysFormat) {
+    //         let array = Array.isArray(objs) ? objs : [objs]
+    //         array.forEach(obj => {
+    //             if (keysFormat.jsonKeys) {
+    //                 keysFormat.jsonKeys.forEach(k => {
+    //                     try {
+    //                         if (obj[k]) {
+    //                             obj[k] = JSON.parse(obj[k])
+    //                         }
+    //                     } catch (error) {
+    //                         console.log(error, k, obj)
+    //                     }
+    //                 })
+    //             }
+    //             if (keysFormat.boolKeys) {
+    //                 keysFormat.boolKeys.forEach(k => {
+    //                     try {
+    //                         if (obj[k]) {
+    //                             obj[k] = obj[k] == "true"
+    //                         }
+    //                     } catch (error) {
+    //                         console.log(error, k, obj)
+    //                     }
+    //                 })
+    //             }
+    //             if (keysFormat.keyReplace) {
+    //                 Object.keys(keysFormat.keyReplace).forEach(k => {
+    //                     if (obj[k]) {
+    //                         obj[keysFormat.keyReplace[k]] = obj[k]
+    //                         delete obj[k]
+    //                     }
+    //                 })
+    //             }
+    //             if (keysFormat.dataFormat) {
+    //                 keysFormat.dataFormat(obj)
+    //             }
+    //         })
+    //     }
+    // },
+    successStatus: () => {
+        return {
+            code: types_1.ULTIPA.Code.SUCCESS,
+            code_desc: types_1.ULTIPA.Code[types_1.ULTIPA.Code.SUCCESS],
+            message: "ok",
+        };
+    },
+    statisticsSum: (one, sumOne) => {
+        return {
+            totalCost: ((one === null || one === void 0 ? void 0 : one.totalCost) || 0) + ((sumOne === null || sumOne === void 0 ? void 0 : sumOne.totalCost) || 0),
+            engineCost: ((one === null || one === void 0 ? void 0 : one.engineCost) || 0) + ((sumOne === null || sumOne === void 0 ? void 0 : sumOne.engineCost) || 0),
+            nodeAffected: ((one === null || one === void 0 ? void 0 : one.nodeAffected) || 0) + ((sumOne === null || sumOne === void 0 ? void 0 : sumOne.nodeAffected) || 0),
+            edgeAffected: ((one === null || one === void 0 ? void 0 : one.edgeAffected) || 0) + ((sumOne === null || sumOne === void 0 ? void 0 : sumOne.edgeAffected) || 0),
+        };
+    },
+    unknownError: (err, res) => {
+        res.status = {
+            code: types_1.ULTIPA.Code.UNKNOWN_ERROR,
+            code_desc: types_1.ULTIPA.Code[types_1.ULTIPA.Code.UNKNOWN_ERROR],
+            message: err.message || err.detail,
+        };
+        return res;
+    },
+    catchUltipaUqlError: (error) => {
+        let response = new types_1.ULTIPA.QueryBaseResponse();
+        response = exports.FormatResponse.unknownError(error, response);
+        let res = types_1.ULTIPA.formatBaseResponse(response);
+        return res;
+    },
+};
+//# sourceMappingURL=format.js.map