@ultipa-graph/ultipa-driver 5.1.5-s5.2 → 6.0.4

package/dist/printers.js

@@ -0,0 +1,312 @@
+"use strict";
+/**
+ * Pretty printers for GQLDB data types.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printNodes = printNodes;
+exports.printNodesWithoutSchema = printNodesWithoutSchema;
+exports.printEdges = printEdges;
+exports.printEdgesWithoutSchema = printEdgesWithoutSchema;
+exports.printPaths = printPaths;
+exports.printTable = printTable;
+exports.printAny = printAny;
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const types_1 = require("./types");
+/**
+ * Print nodes in tabular format grouped by schema.
+ */
+function printNodes(nodes, schemas) {
+    if (!nodes || nodes.length === 0) {
+        return 'No nodes found.';
+    }
+    const result = [];
+    let lastSchema = undefined;
+    let currentTable = null;
+    for (const node of nodes) {
+        if (!node)
+            continue;
+        const schemaName = node.labels.length > 0 ? node.labels[0] : '';
+        if (lastSchema === undefined || schemaName !== lastSchema) {
+            if (currentTable) {
+                result.push(currentTable.toString());
+                result.push('');
+            }
+            const headers = ['ID', 'Labels'];
+            if (schemas && schemas.has(schemaName)) {
+                for (const prop of schemas.get(schemaName).properties) {
+                    headers.push(prop.name);
+                }
+            }
+            else {
+                headers.push(...Object.keys(node.properties));
+            }
+            currentTable = new cli_table3_1.default({ head: headers });
+            lastSchema = schemaName;
+        }
+        const row = [node.id, formatLabels(node.labels)];
+        if (schemas && schemas.has(schemaName)) {
+            for (const prop of schemas.get(schemaName).properties) {
+                row.push(formatValue(node.properties[prop.name]));
+            }
+        }
+        else {
+            for (const key of Object.keys(node.properties)) {
+                row.push(formatValue(node.properties[key]));
+            }
+        }
+        currentTable.push(row);
+    }
+    if (currentTable) {
+        result.push(currentTable.toString());
+    }
+    result.push(`\n${nodes.length} node(s)`);
+    return result.join('\n');
+}
+/**
+ * Print nodes deriving schema from data.
+ */
+function printNodesWithoutSchema(nodes) {
+    if (!nodes || nodes.length === 0) {
+        return 'No nodes found.';
+    }
+    const schemas = new Map();
+    for (const node of nodes) {
+        if (!node)
+            continue;
+        for (const label of node.labels) {
+            if (!schemas.has(label)) {
+                schemas.set(label, buildSchemaFromNode(label, node));
+            }
+        }
+    }
+    return printNodes(nodes, schemas);
+}
+/**
+ * Print edges in tabular format grouped by schema.
+ */
+function printEdges(edges, schemas) {
+    if (!edges || edges.length === 0) {
+        return 'No edges found.';
+    }
+    const result = [];
+    let lastSchema = undefined;
+    let currentTable = null;
+    for (const edge of edges) {
+        if (!edge)
+            continue;
+        const schemaName = edge.label;
+        if (lastSchema === undefined || schemaName !== lastSchema) {
+            if (currentTable) {
+                result.push(currentTable.toString());
+                result.push('');
+            }
+            const headers = ['ID', 'FROM', 'TO', 'Label'];
+            if (schemas && schemas.has(schemaName)) {
+                for (const prop of schemas.get(schemaName).properties) {
+                    headers.push(prop.name);
+                }
+            }
+            else {
+                headers.push(...Object.keys(edge.properties));
+            }
+            currentTable = new cli_table3_1.default({ head: headers });
+            lastSchema = schemaName;
+        }
+        const row = [edge.id, edge.fromNodeId, edge.toNodeId, edge.label];
+        if (schemas && schemas.has(schemaName)) {
+            for (const prop of schemas.get(schemaName).properties) {
+                row.push(formatValue(edge.properties[prop.name]));
+            }
+        }
+        else {
+            for (const key of Object.keys(edge.properties)) {
+                row.push(formatValue(edge.properties[key]));
+            }
+        }
+        currentTable.push(row);
+    }
+    if (currentTable) {
+        result.push(currentTable.toString());
+    }
+    result.push(`\n${edges.length} edge(s)`);
+    return result.join('\n');
+}
+/**
+ * Print edges deriving schema from data.
+ */
+function printEdgesWithoutSchema(edges) {
+    if (!edges || edges.length === 0) {
+        return 'No edges found.';
+    }
+    const schemas = new Map();
+    for (const edge of edges) {
+        if (!edge)
+            continue;
+        if (edge.label && !schemas.has(edge.label)) {
+            schemas.set(edge.label, buildSchemaFromEdge(edge.label, edge));
+        }
+    }
+    return printEdges(edges, schemas);
+}
+/**
+ * Print paths with node-edge sequence notation.
+ */
+function printPaths(paths) {
+    if (!paths || paths.length === 0) {
+        return 'No paths found.';
+    }
+    const table = new cli_table3_1.default({ head: ['#', 'Path'] });
+    paths.forEach((path, i) => {
+        if (!path)
+            return;
+        table.push([String(i), formatPath(path)]);
+    });
+    return table.toString() + `\n${paths.length} path(s)`;
+}
+/**
+ * Print generic table data.
+ */
+function printTable(dataTable) {
+    if (!dataTable || !dataTable.headers || dataTable.headers.length === 0) {
+        return 'No table data.';
+    }
+    const headers = dataTable.headers.map((h) => h.name);
+    const cliTable = new cli_table3_1.default({ head: headers });
+    for (const row of dataTable.rows) {
+        cliTable.push(row.map((v) => formatValue(v)));
+    }
+    const result = [];
+    if (dataTable.name) {
+        result.push(`Table: ${dataTable.name}`);
+    }
+    result.push(cliTable.toString());
+    result.push(`\n${dataTable.rows.length} row(s)`);
+    return result.join('\n');
+}
+/**
+ * Auto-detect type from Response and print accordingly.
+ */
+function printAny(resp) {
+    if (!resp || resp.isEmpty()) {
+        return 'No data.';
+    }
+    // Try to auto-detect the type from the first column
+    if (resp.columns.length > 0) {
+        try {
+            const ar = resp.get(0);
+            // Try edges first
+            try {
+                const { edges, schemas } = ar.asEdges();
+                if (edges.length > 0) {
+                    return printEdges(edges, schemas);
+                }
+            }
+            catch (e) {
+                // Not edges, continue
+            }
+            // Try nodes
+            try {
+                const { nodes, schemas } = ar.asNodes();
+                if (nodes.length > 0) {
+                    return printNodes(nodes, schemas);
+                }
+            }
+            catch (e) {
+                // Not nodes, continue
+            }
+            // Try paths
+            try {
+                const paths = ar.asPaths();
+                if (paths.length > 0) {
+                    return printPaths(paths);
+                }
+            }
+            catch (e) {
+                // Not paths, continue
+            }
+        }
+        catch (e) {
+            // Fall through to table
+        }
+    }
+    // Fallback to table format (use deprecated method for multi-column display)
+    return printTable(resp.asTable());
+}
+// Helper functions
+function formatLabels(labels) {
+    if (!labels || labels.length === 0)
+        return '';
+    return '[' + labels.join(', ') + ']';
+}
+function formatValue(v) {
+    if (v === null || v === undefined)
+        return '<nil>';
+    if (Array.isArray(v)) {
+        return '[' + v.map(formatValue).join(', ') + ']';
+    }
+    if (typeof v === 'object') {
+        const parts = Object.entries(v).map(([k, val]) => `${k}: ${formatValue(val)}`);
+        return '{' + parts.join(', ') + '}';
+    }
+    return String(v);
+}
+function formatPath(path) {
+    if (!path)
+        return '<nil>';
+    const parts = [];
+    let nodeIdx = 0;
+    let edgeIdx = 0;
+    while (nodeIdx < path.nodes.length || edgeIdx < path.edges.length) {
+        if (nodeIdx < path.nodes.length) {
+            const node = path.nodes[nodeIdx];
+            const label = node.labels.length > 0 ? ':' + node.labels[0] : '';
+            parts.push(`(${node.id}${label})`);
+            nodeIdx++;
+        }
+        if (edgeIdx < path.edges.length) {
+            const edge = path.edges[edgeIdx];
+            parts.push(`-[${edge.id}:${edge.label}]->`);
+            edgeIdx++;
+        }
+    }
+    return parts.join(' ');
+}
+function containsAny(arr, ...items) {
+    return arr.some(s => items.includes(s));
+}
+function buildSchemaFromNode(label, node) {
+    const properties = Object.entries(node.properties).map(([name, value]) => ({
+        name,
+        type: inferPropertyType(value),
+    }));
+    return { name: label, properties };
+}
+function buildSchemaFromEdge(label, edge) {
+    const properties = Object.entries(edge.properties).map(([name, value]) => ({
+        name,
+        type: inferPropertyType(value),
+    }));
+    return { name: label, properties };
+}
+function inferPropertyType(value) {
+    if (value === null || value === undefined)
+        return types_1.PropertyType.NULL;
+    if (typeof value === 'boolean')
+        return types_1.PropertyType.BOOL;
+    if (typeof value === 'number') {
+        return Number.isInteger(value) ? types_1.PropertyType.INT64 : types_1.PropertyType.DOUBLE;
+    }
+    if (typeof value === 'string')
+        return types_1.PropertyType.STRING;
+    if (Buffer.isBuffer(value))
+        return types_1.PropertyType.BLOB;
+    if (Array.isArray(value))
+        return types_1.PropertyType.LIST;
+    if (typeof value === 'object')
+        return types_1.PropertyType.MAP;
+    return types_1.PropertyType.UNSET;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"printers.js","sourceRoot":"","sources":["../src/printers.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Pretty printers for GQLDB data types.\n */\n\nimport CliTable from 'cli-table3';\nimport { Schema, PropertyType, Table as DataTable } from './types';\nimport { Response, Node, Edge, Path } from './response';\n\n/**\n * Print nodes in tabular format grouped by schema.\n */\nexport function printNodes(nodes: Node[], schemas?: Map<string, Schema>): string {\n  if (!nodes || nodes.length === 0) {\n    return 'No nodes found.';\n  }\n\n  const result: string[] = [];\n  let lastSchema: string | undefined = undefined;\n  let currentTable: CliTable.Table | null = null;\n\n  for (const node of nodes) {\n    if (!node) continue;\n\n    const schemaName = node.labels.length > 0 ? node.labels[0] : '';\n\n    if (lastSchema === undefined || schemaName !== lastSchema) {\n      if (currentTable) {\n        result.push(currentTable.toString());\n        result.push('');\n      }\n\n      const headers = ['ID', 'Labels'];\n      if (schemas && schemas.has(schemaName)) {\n        for (const prop of schemas.get(schemaName)!.properties) {\n          headers.push(prop.name);\n        }\n      } else {\n        headers.push(...Object.keys(node.properties));\n      }\n\n      currentTable = new CliTable({ head: headers }) as CliTable.Table;\n      lastSchema = schemaName;\n    }\n\n    const row: string[] = [node.id, formatLabels(node.labels)];\n    if (schemas && schemas.has(schemaName)) {\n      for (const prop of schemas.get(schemaName)!.properties) {\n        row.push(formatValue(node.properties[prop.name]));\n      }\n    } else {\n      for (const key of Object.keys(node.properties)) {\n        row.push(formatValue(node.properties[key]));\n      }\n    }\n\n    currentTable!.push(row);\n  }\n\n  if (currentTable) {\n    result.push(currentTable.toString());\n  }\n\n  result.push(`\\n${nodes.length} node(s)`);\n  return result.join('\\n');\n}\n\n/**\n * Print nodes deriving schema from data.\n */\nexport function printNodesWithoutSchema(nodes: Node[]): string {\n  if (!nodes || nodes.length === 0) {\n    return 'No nodes found.';\n  }\n\n  const schemas = new Map<string, Schema>();\n  for (const node of nodes) {\n    if (!node) continue;\n    for (const label of node.labels) {\n      if (!schemas.has(label)) {\n        schemas.set(label, buildSchemaFromNode(label, node));\n      }\n    }\n  }\n\n  return printNodes(nodes, schemas);\n}\n\n/**\n * Print edges in tabular format grouped by schema.\n */\nexport function printEdges(edges: Edge[], schemas?: Map<string, Schema>): string {\n  if (!edges || edges.length === 0) {\n    return 'No edges found.';\n  }\n\n  const result: string[] = [];\n  let lastSchema: string | undefined = undefined;\n  let currentTable: CliTable.Table | null = null;\n\n  for (const edge of edges) {\n    if (!edge) continue;\n\n    const schemaName = edge.label;\n\n    if (lastSchema === undefined || schemaName !== lastSchema) {\n      if (currentTable) {\n        result.push(currentTable.toString());\n        result.push('');\n      }\n\n      const headers = ['ID', 'FROM', 'TO', 'Label'];\n      if (schemas && schemas.has(schemaName)) {\n        for (const prop of schemas.get(schemaName)!.properties) {\n          headers.push(prop.name);\n        }\n      } else {\n        headers.push(...Object.keys(edge.properties));\n      }\n\n      currentTable = new CliTable({ head: headers }) as CliTable.Table;\n      lastSchema = schemaName;\n    }\n\n    const row: string[] = [edge.id, edge.fromNodeId, edge.toNodeId, edge.label];\n    if (schemas && schemas.has(schemaName)) {\n      for (const prop of schemas.get(schemaName)!.properties) {\n        row.push(formatValue(edge.properties[prop.name]));\n      }\n    } else {\n      for (const key of Object.keys(edge.properties)) {\n        row.push(formatValue(edge.properties[key]));\n      }\n    }\n\n    currentTable!.push(row);\n  }\n\n  if (currentTable) {\n    result.push(currentTable.toString());\n  }\n\n  result.push(`\\n${edges.length} edge(s)`);\n  return result.join('\\n');\n}\n\n/**\n * Print edges deriving schema from data.\n */\nexport function printEdgesWithoutSchema(edges: Edge[]): string {\n  if (!edges || edges.length === 0) {\n    return 'No edges found.';\n  }\n\n  const schemas = new Map<string, Schema>();\n  for (const edge of edges) {\n    if (!edge) continue;\n    if (edge.label && !schemas.has(edge.label)) {\n      schemas.set(edge.label, buildSchemaFromEdge(edge.label, edge));\n    }\n  }\n\n  return printEdges(edges, schemas);\n}\n\n/**\n * Print paths with node-edge sequence notation.\n */\nexport function printPaths(paths: Path[]): string {\n  if (!paths || paths.length === 0) {\n    return 'No paths found.';\n  }\n\n  const table = new CliTable({ head: ['#', 'Path'] }) as CliTable.Table;\n\n  paths.forEach((path, i) => {\n    if (!path) return;\n    table.push([String(i), formatPath(path)]);\n  });\n\n  return table.toString() + `\\n${paths.length} path(s)`;\n}\n\n/**\n * Print generic table data.\n */\nexport function printTable(dataTable: DataTable): string {\n  if (!dataTable || !dataTable.headers || dataTable.headers.length === 0) {\n    return 'No table data.';\n  }\n\n  const headers = dataTable.headers.map((h: { name: string }) => h.name);\n  const cliTable = new CliTable({ head: headers }) as CliTable.Table;\n\n  for (const row of dataTable.rows) {\n    cliTable.push(row.map((v: unknown) => formatValue(v)));\n  }\n\n  const result: string[] = [];\n  if (dataTable.name) {\n    result.push(`Table: ${dataTable.name}`);\n  }\n  result.push(cliTable.toString());\n  result.push(`\\n${dataTable.rows.length} row(s)`);\n\n  return result.join('\\n');\n}\n\n/**\n * Auto-detect type from Response and print accordingly.\n */\nexport function printAny(resp: Response): string {\n  if (!resp || resp.isEmpty()) {\n    return 'No data.';\n  }\n\n  // Try to auto-detect the type from the first column\n  if (resp.columns.length > 0) {\n    try {\n      const ar = resp.get(0);\n\n      // Try edges first\n      try {\n        const { edges, schemas } = ar.asEdges();\n        if (edges.length > 0) {\n          return printEdges(edges, schemas);\n        }\n      } catch (e) {\n        // Not edges, continue\n      }\n\n      // Try nodes\n      try {\n        const { nodes, schemas } = ar.asNodes();\n        if (nodes.length > 0) {\n          return printNodes(nodes, schemas);\n        }\n      } catch (e) {\n        // Not nodes, continue\n      }\n\n      // Try paths\n      try {\n        const paths = ar.asPaths();\n        if (paths.length > 0) {\n          return printPaths(paths);\n        }\n      } catch (e) {\n        // Not paths, continue\n      }\n    } catch (e) {\n      // Fall through to table\n    }\n  }\n\n  // Fallback to table format (use deprecated method for multi-column display)\n  return printTable(resp.asTable());\n}\n\n// Helper functions\n\nfunction formatLabels(labels: string[]): string {\n  if (!labels || labels.length === 0) return '';\n  return '[' + labels.join(', ') + ']';\n}\n\nfunction formatValue(v: any): string {\n  if (v === null || v === undefined) return '<nil>';\n  if (Array.isArray(v)) {\n    return '[' + v.map(formatValue).join(', ') + ']';\n  }\n  if (typeof v === 'object') {\n    const parts = Object.entries(v).map(([k, val]) => `${k}: ${formatValue(val)}`);\n    return '{' + parts.join(', ') + '}';\n  }\n  return String(v);\n}\n\nfunction formatPath(path: Path): string {\n  if (!path) return '<nil>';\n\n  const parts: string[] = [];\n  let nodeIdx = 0;\n  let edgeIdx = 0;\n\n  while (nodeIdx < path.nodes.length || edgeIdx < path.edges.length) {\n    if (nodeIdx < path.nodes.length) {\n      const node = path.nodes[nodeIdx];\n      const label = node.labels.length > 0 ? ':' + node.labels[0] : '';\n      parts.push(`(${node.id}${label})`);\n      nodeIdx++;\n    }\n    if (edgeIdx < path.edges.length) {\n      const edge = path.edges[edgeIdx];\n      parts.push(`-[${edge.id}:${edge.label}]->`);\n      edgeIdx++;\n    }\n  }\n\n  return parts.join(' ');\n}\n\nfunction containsAny(arr: string[], ...items: string[]): boolean {\n  return arr.some(s => items.includes(s));\n}\n\nfunction buildSchemaFromNode(label: string, node: Node): Schema {\n  const properties = Object.entries(node.properties).map(([name, value]) => ({\n    name,\n    type: inferPropertyType(value),\n  }));\n  return { name: label, properties };\n}\n\nfunction buildSchemaFromEdge(label: string, edge: Edge): Schema {\n  const properties = Object.entries(edge.properties).map(([name, value]) => ({\n    name,\n    type: inferPropertyType(value),\n  }));\n  return { name: label, properties };\n}\n\nfunction inferPropertyType(value: any): PropertyType {\n  if (value === null || value === undefined) return PropertyType.NULL;\n  if (typeof value === 'boolean') return PropertyType.BOOL;\n  if (typeof value === 'number') {\n    return Number.isInteger(value) ? PropertyType.INT64 : PropertyType.DOUBLE;\n  }\n  if (typeof value === 'string') return PropertyType.STRING;\n  if (Buffer.isBuffer(value)) return PropertyType.BLOB;\n  if (Array.isArray(value)) return PropertyType.LIST;\n  if (typeof value === 'object') return PropertyType.MAP;\n  return PropertyType.UNSET;\n}\n"]}