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

package/dist/response.js

@@ -0,0 +1,723 @@
+"use strict";
+/**
+ * Response handling for GQLDB Node.js driver.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Response = exports.AliasResult = exports.Row = void 0;
+const types_1 = require("./types");
+/** Represents a single row in the query result */
+class Row {
+    values;
+    types;
+    constructor(values, types = []) {
+        this.values = values;
+        this.types = types;
+    }
+    /** Get the value at the given column index */
+    get(index) {
+        if (index < 0 || index >= this.values.length) {
+            throw new Error(`Column index out of range: ${index}`);
+        }
+        const value = this.values[index];
+        // If value is a TypedValue object, convert it
+        if (value && typeof value === 'object' && 'type' in value && 'data' in value && 'isNull' in value) {
+            return (0, types_1.typedValueToJS)(value);
+        }
+        return value;
+    }
+    /** Get the PropertyType at the given column index */
+    getType(index) {
+        if (index < 0 || index >= this.types.length) {
+            return types_1.PropertyType.UNSET;
+        }
+        return this.types[index];
+    }
+    /** Get the value at the given column index as a string */
+    getString(index) {
+        const val = this.get(index);
+        if (val === null || val === undefined)
+            return '';
+        if (typeof val === 'string')
+            return val;
+        return String(val);
+    }
+    /** Get the value at the given column index as a number */
+    getNumber(index) {
+        const val = this.get(index);
+        if (val === null || val === undefined)
+            return 0;
+        if (typeof val === 'number')
+            return val;
+        const num = Number(val);
+        if (isNaN(num))
+            throw new Error(`Cannot convert ${typeof val} to number`);
+        return num;
+    }
+    /** Get the value at the given column index as a boolean */
+    getBoolean(index) {
+        const val = this.get(index);
+        if (val === null || val === undefined)
+            return false;
+        if (typeof val === 'boolean')
+            return val;
+        throw new Error(`Cannot convert ${typeof val} to boolean`);
+    }
+}
+exports.Row = Row;
+/**
+ * Represents a single column's data from the response.
+ * Allows chaining operations like resp.alias("n").asNodes() or resp.get(0).asNodes().
+ */
+class AliasResult {
+    aliasName;
+    columnIdx;
+    response;
+    constructor(aliasName, columnIdx, response) {
+        this.aliasName = aliasName;
+        this.columnIdx = columnIdx;
+        this.response = response;
+    }
+    /** Get the alias name */
+    get alias() {
+        return this.aliasName;
+    }
+    /** Get the column index */
+    get columnIndex() {
+        return this.columnIdx;
+    }
+    /**
+     * Extract nodes from the aliased column with schema info.
+     * Throws TypeError if the column contains non-NODE types.
+     */
+    collectNode(val, nodes, schemas) {
+        if (val && typeof val.id === 'string' && 'labels' in val) {
+            const node = {
+                id: val.id,
+                labels: val.labels || [],
+                properties: val.properties || {},
+            };
+            nodes.push(node);
+            for (const label of node.labels) {
+                if (!schemas.has(label)) {
+                    schemas.set(label, this.buildSchemaFromNode(label, node));
+                }
+            }
+        }
+    }
+    collectEdge(val, edges, schemas) {
+        if (val && typeof val.id === 'string' && 'label' in val) {
+            const edge = {
+                id: val.id,
+                label: val.label || '',
+                fromNodeId: val.fromNodeId || '',
+                toNodeId: val.toNodeId || '',
+                properties: val.properties || {},
+            };
+            edges.push(edge);
+            if (edge.label && !schemas.has(edge.label)) {
+                schemas.set(edge.label, this.buildSchemaFromEdge(edge.label, edge));
+            }
+        }
+    }
+    /**
+     * Extract nodes from the aliased column with schema info.
+     * Supports both direct NODE columns and LIST of NODE columns
+     * (e.g., group variables from quantified patterns).
+     */
+    asNodes() {
+        const nodes = [];
+        const schemas = new Map();
+        for (const row of this.response.rows) {
+            if (this.columnIdx >= row.values.length) {
+                continue;
+            }
+            let itemType = row.getType(this.columnIdx);
+            const rawValue = row.values[this.columnIdx];
+            if (itemType === types_1.PropertyType.UNSET && rawValue && typeof rawValue === 'object' && 'type' in rawValue) {
+                itemType = rawValue.type;
+            }
+            if (!rawValue || (typeof rawValue === 'object' && 'isNull' in rawValue && rawValue.isNull)) {
+                continue;
+            }
+            if (itemType === types_1.PropertyType.NODE) {
+                this.collectNode(row.get(this.columnIdx), nodes, schemas);
+            }
+            else if (itemType === types_1.PropertyType.LIST) {
+                // LIST of NODE (group variable from quantified pattern)
+                const list = row.get(this.columnIdx);
+                if (Array.isArray(list)) {
+                    for (const item of list) {
+                        this.collectNode(item, nodes, schemas);
+                    }
+                }
+            }
+            else {
+                throw new TypeError(`Type mismatch: column '${this.aliasName}' (index ${this.columnIdx}) contains ${types_1.PropertyType[itemType]}, expected NODE or LIST of NODE`);
+            }
+        }
+        return { nodes, schemas };
+    }
+    /**
+     * Extract edges from the aliased column with schema info.
+     * Supports both direct EDGE columns and LIST of EDGE columns
+     * (e.g., group variables from quantified patterns).
+     */
+    asEdges() {
+        const edges = [];
+        const schemas = new Map();
+        for (const row of this.response.rows) {
+            if (this.columnIdx >= row.values.length) {
+                continue;
+            }
+            let itemType = row.getType(this.columnIdx);
+            const rawValue = row.values[this.columnIdx];
+            if (itemType === types_1.PropertyType.UNSET && rawValue && typeof rawValue === 'object' && 'type' in rawValue) {
+                itemType = rawValue.type;
+            }
+            if (!rawValue || (typeof rawValue === 'object' && 'isNull' in rawValue && rawValue.isNull)) {
+                continue;
+            }
+            if (itemType === types_1.PropertyType.EDGE) {
+                this.collectEdge(row.get(this.columnIdx), edges, schemas);
+            }
+            else if (itemType === types_1.PropertyType.LIST) {
+                // LIST of EDGE (group variable from quantified pattern)
+                const list = row.get(this.columnIdx);
+                if (Array.isArray(list)) {
+                    for (const item of list) {
+                        this.collectEdge(item, edges, schemas);
+                    }
+                }
+            }
+            else {
+                throw new TypeError(`Type mismatch: column '${this.aliasName}' (index ${this.columnIdx}) contains ${types_1.PropertyType[itemType]}, expected EDGE or LIST of EDGE`);
+            }
+        }
+        return { edges, schemas };
+    }
+    /**
+     * Extract paths from the aliased column.
+     * Throws TypeError if the column contains non-PATH types.
+     */
+    asPaths() {
+        const paths = [];
+        for (const row of this.response.rows) {
+            if (this.columnIdx >= row.values.length) {
+                continue;
+            }
+            // Check type from types array or from TypedValue object
+            let itemType = row.getType(this.columnIdx);
+            const rawValue = row.values[this.columnIdx];
+            if (itemType === types_1.PropertyType.UNSET && rawValue && typeof rawValue === 'object' && 'type' in rawValue) {
+                itemType = rawValue.type;
+            }
+            // Skip null values
+            if (!rawValue || (typeof rawValue === 'object' && 'isNull' in rawValue && rawValue.isNull)) {
+                continue;
+            }
+            // Type checking: must be PATH type
+            if (itemType !== types_1.PropertyType.PATH) {
+                throw new TypeError(`Type mismatch: column '${this.aliasName}' (index ${this.columnIdx}) contains ${types_1.PropertyType[itemType]}, expected PATH`);
+            }
+            // Convert TypedValue to GqldbPath
+            const val = row.get(this.columnIdx);
+            if (val && Array.isArray(val.nodes)) {
+                // Convert GqldbNode/GqldbEdge to Node/Edge
+                const nodes = (val.nodes || []).map((n) => ({
+                    id: n.id || '',
+                    labels: n.labels || [],
+                    properties: n.properties || {},
+                }));
+                const edges = (val.edges || []).map((e) => ({
+                    id: e.id || '',
+                    label: e.label || '',
+                    fromNodeId: e.fromNodeId || '',
+                    toNodeId: e.toNodeId || '',
+                    properties: e.properties || {},
+                }));
+                paths.push({ nodes, edges });
+            }
+        }
+        return paths;
+    }
+    /** Convert the aliased column to a single-column table */
+    asTable() {
+        // Check if first non-null value is a GqldbTable — if so, unwrap it
+        for (const row of this.response.rows) {
+            if (this.columnIdx < row.values.length) {
+                const itemType = row.getType(this.columnIdx);
+                if (itemType === types_1.PropertyType.TABLE) {
+                    const val = row.get(this.columnIdx);
+                    if (val && 'columns' in val && 'rows' in val) {
+                        return this.unwrapGqldbTable(val);
+                    }
+                }
+            }
+            break; // only check first row
+        }
+        // Fallback: generic single-column table
+        const headers = [{
+                name: this.aliasName,
+                type: types_1.PropertyType.UNSET,
+            }];
+        if (this.response.rows.length > 0) {
+            for (const row of this.response.rows) {
+                if (this.columnIdx < row.values.length) {
+                    const type = row.getType(this.columnIdx);
+                    if (type !== types_1.PropertyType.UNSET) {
+                        headers[0].type = type;
+                        break;
+                    }
+                }
+            }
+        }
+        const tableRows = this.response.rows.map(row => {
+            if (this.columnIdx < row.values.length) {
+                return [row.get(this.columnIdx)];
+            }
+            return [null];
+        });
+        return { name: '', headers, rows: tableRows };
+    }
+    unwrapGqldbTable(gt) {
+        const headers = gt.columns.map((col, i) => {
+            let colType = types_1.PropertyType.UNSET;
+            if (gt.rows.length > 0 && i < gt.rows[0].length) {
+                const v = gt.rows[0][i];
+                if (typeof v === 'number')
+                    colType = Number.isInteger(v) ? types_1.PropertyType.INT64 : types_1.PropertyType.DOUBLE;
+                else if (typeof v === 'string')
+                    colType = types_1.PropertyType.STRING;
+                else if (typeof v === 'boolean')
+                    colType = types_1.PropertyType.BOOL;
+            }
+            return { name: col, type: colType };
+        });
+        return { name: this.aliasName, headers, rows: gt.rows };
+    }
+    /** Extract scalar or list attribute values from the aliased column */
+    asAttr() {
+        const values = [];
+        let attrType = types_1.PropertyType.UNSET;
+        for (const row of this.response.rows) {
+            if (this.columnIdx < row.values.length) {
+                // Try to get type from row.types first, then from TypedValue object
+                if (attrType === types_1.PropertyType.UNSET) {
+                    attrType = row.getType(this.columnIdx);
+                    if (attrType === types_1.PropertyType.UNSET) {
+                        const rawValue = row.values[this.columnIdx];
+                        if (rawValue && typeof rawValue === 'object' && 'type' in rawValue) {
+                            attrType = rawValue.type;
+                        }
+                    }
+                }
+                const value = row.get(this.columnIdx); // Use get() to convert TypedValue
+                values.push(value);
+            }
+        }
+        return { name: this.aliasName, type: attrType, values };
+    }
+    /** Extract raw JavaScript values from the aliased column */
+    asValues() {
+        const values = [];
+        for (const row of this.response.rows) {
+            if (this.columnIdx < row.values.length) {
+                values.push(row.get(this.columnIdx));
+            }
+        }
+        return values;
+    }
+    // Helper methods
+    buildSchemaFromNode(label, node) {
+        const properties = Object.entries(node.properties).map(([name, value]) => ({
+            name,
+            type: this.inferPropertyType(value),
+        }));
+        return { name: label, properties };
+    }
+    buildSchemaFromEdge(label, edge) {
+        const properties = Object.entries(edge.properties).map(([name, value]) => ({
+            name,
+            type: this.inferPropertyType(value),
+        }));
+        return { name: label, properties };
+    }
+    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;
+    }
+}
+exports.AliasResult = AliasResult;
+/** Represents the result of a GQL query */
+class Response {
+    columns;
+    rows;
+    rowCount;
+    hasMore;
+    warnings;
+    rowsAffected;
+    constructor(columns, rows, rowCount, hasMore, warnings, rowsAffected = 0) {
+        this.columns = columns;
+        this.rows = rows;
+        this.rowCount = rowCount;
+        this.hasMore = hasMore;
+        this.warnings = warnings;
+        this.rowsAffected = rowsAffected;
+    }
+    /** Check if the response has no rows */
+    isEmpty() {
+        return this.rows.length === 0;
+    }
+    /** Get the first row */
+    first() {
+        return this.rows[0];
+    }
+    /** Get the last row */
+    last() {
+        return this.rows[this.rows.length - 1];
+    }
+    /** Get the value for a column by name */
+    getByName(row, columnName) {
+        const index = this.columns.indexOf(columnName);
+        if (index === -1) {
+            throw new Error(`Column not found: ${columnName}`);
+        }
+        return row.get(index);
+    }
+    /** Iterate over all rows with a callback */
+    forEach(fn) {
+        this.rows.forEach(fn);
+    }
+    /** Transform each row using a callback */
+    map(fn) {
+        return this.rows.map(fn);
+    }
+    /** Convert the response to an array of objects */
+    toObjects() {
+        return this.rows.map(row => {
+            const obj = {};
+            this.columns.forEach((col, i) => {
+                // Add boundary check to handle mismatched columns/values
+                obj[col] = i < row.values.length ? row.get(i) : null;
+            });
+            return obj;
+        });
+    }
+    /** Convert the response to JSON */
+    toJSON() {
+        return JSON.stringify(this.toObjects());
+    }
+    /** Get the single value from a single-row, single-column response */
+    singleValue() {
+        if (this.rows.length === 0)
+            return null;
+        if (this.rows.length > 1) {
+            throw new Error(`Expected single row, got ${this.rows.length}`);
+        }
+        if (this.rows[0].values.length === 0)
+            return null;
+        if (this.rows[0].values.length > 1) {
+            throw new Error(`Expected single column, got ${this.rows[0].values.length}`);
+        }
+        return this.rows[0].get(0);
+    }
+    /** Get the single number value */
+    singleNumber() {
+        const val = this.singleValue();
+        if (val === null || val === undefined)
+            return 0;
+        if (typeof val === 'number')
+            return val;
+        const num = Number(val);
+        if (isNaN(num))
+            throw new Error(`Cannot convert ${typeof val} to number`);
+        return num;
+    }
+    /** Get the single string value */
+    singleString() {
+        const val = this.singleValue();
+        if (val === null || val === undefined)
+            return '';
+        if (typeof val === 'string')
+            return val;
+        return String(val);
+    }
+    /** Iterator support */
+    [Symbol.iterator]() {
+        return this.rows[Symbol.iterator]();
+    }
+    /** Get the number of rows */
+    get length() {
+        return this.rows.length;
+    }
+    /**
+     * Get an AliasResult for the specified column name.
+     * Use this to extract data from a specific column by name.
+     * Example: resp.alias("n").asNodes()
+     */
+    alias(columnName) {
+        const colIdx = this.columns.indexOf(columnName);
+        if (colIdx === -1) {
+            throw new Error(`Column alias not found: ${columnName}`);
+        }
+        return new AliasResult(columnName, colIdx, this);
+    }
+    /**
+     * Get an AliasResult for the column at the specified index.
+     * Use this to extract data from a specific column by index.
+     * Example: resp.get(0).asNodes()
+     */
+    get(index) {
+        if (index < 0 || index >= this.columns.length) {
+            throw new Error(`Column index out of range: ${index} (total: ${this.columns.length})`);
+        }
+        return new AliasResult(this.columns[index], index, this);
+    }
+    /**
+     * @deprecated Use alias() or get() instead. This method will be removed in a future version.
+     * Extract nodes from response with schema info.
+     * Supports both NODE and LIST of NODE columns.
+     */
+    asNodes() {
+        const nodes = [];
+        const schemas = new Map();
+        const collectNode = (val) => {
+            if (val && typeof val.id === 'string' && 'labels' in val) {
+                const node = {
+                    id: val.id,
+                    labels: val.labels || [],
+                    properties: val.properties || {},
+                };
+                nodes.push(node);
+                for (const label of node.labels) {
+                    if (!schemas.has(label)) {
+                        schemas.set(label, this.buildSchemaFromNode(label, node));
+                    }
+                }
+            }
+        };
+        for (const row of this.rows) {
+            for (let i = 0; i < row.values.length; i++) {
+                let itemType = row.getType(i);
+                const rawValue = row.values[i];
+                if (itemType === types_1.PropertyType.UNSET && rawValue && typeof rawValue === 'object' && 'type' in rawValue) {
+                    itemType = rawValue.type;
+                }
+                if (itemType === types_1.PropertyType.NODE) {
+                    collectNode(row.get(i));
+                }
+                else if (itemType === types_1.PropertyType.LIST) {
+                    const list = row.get(i);
+                    if (Array.isArray(list)) {
+                        for (const item of list) {
+                            collectNode(item);
+                        }
+                    }
+                }
+            }
+        }
+        return { nodes, schemas };
+    }
+    /**
+     * @deprecated Use alias() or get() instead. This method will be removed in a future version.
+     * Extract edges from response with schema info.
+     * Supports both EDGE and LIST of EDGE columns.
+     */
+    asEdges() {
+        const edges = [];
+        const schemas = new Map();
+        const collectEdge = (val) => {
+            if (val && typeof val.id === 'string' && 'label' in val) {
+                const edge = {
+                    id: val.id,
+                    label: val.label || '',
+                    fromNodeId: val.fromNodeId || '',
+                    toNodeId: val.toNodeId || '',
+                    properties: val.properties || {},
+                };
+                edges.push(edge);
+                if (edge.label && !schemas.has(edge.label)) {
+                    schemas.set(edge.label, this.buildSchemaFromEdge(edge.label, edge));
+                }
+            }
+        };
+        for (const row of this.rows) {
+            for (let i = 0; i < row.values.length; i++) {
+                let itemType = row.getType(i);
+                const rawValue = row.values[i];
+                if (itemType === types_1.PropertyType.UNSET && rawValue && typeof rawValue === 'object' && 'type' in rawValue) {
+                    itemType = rawValue.type;
+                }
+                if (itemType === types_1.PropertyType.EDGE) {
+                    collectEdge(row.get(i));
+                }
+                else if (itemType === types_1.PropertyType.LIST) {
+                    const list = row.get(i);
+                    if (Array.isArray(list)) {
+                        for (const item of list) {
+                            collectEdge(item);
+                        }
+                    }
+                }
+            }
+        }
+        return { edges, schemas };
+    }
+    /**
+     * @deprecated Use alias() or get() instead. This method will be removed in a future version.
+     * Extract paths from response.
+     * Paths are identified by PropertyType.PATH type in the TypedValue.
+     */
+    asPaths() {
+        const paths = [];
+        for (const row of this.rows) {
+            for (let i = 0; i < row.values.length; i++) {
+                // Check type from types array or from TypedValue object
+                let itemType = row.getType(i);
+                const rawValue = row.values[i];
+                if (itemType === types_1.PropertyType.UNSET && rawValue && typeof rawValue === 'object' && 'type' in rawValue) {
+                    itemType = rawValue.type;
+                }
+                if (itemType === types_1.PropertyType.PATH) {
+                    // Convert TypedValue to GqldbPath
+                    const val = row.get(i);
+                    if (val && Array.isArray(val.nodes)) {
+                        // Convert GqldbNode/GqldbEdge to Node/Edge
+                        const nodes = (val.nodes || []).map((n) => ({
+                            id: n.id || '',
+                            labels: n.labels || [],
+                            properties: n.properties || {},
+                        }));
+                        const edges = (val.edges || []).map((e) => ({
+                            id: e.id || '',
+                            label: e.label || '',
+                            fromNodeId: e.fromNodeId || '',
+                            toNodeId: e.toNodeId || '',
+                            properties: e.properties || {},
+                        }));
+                        paths.push({ nodes, edges });
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    /**
+     * @deprecated Use alias() or get() instead. This method will be removed in a future version.
+     * Return response as generic table.
+     * If response is a single TABLE column, unwraps the GqldbTable into proper headers/rows.
+     */
+    asTable() {
+        // If single column of TABLE type, unwrap GqldbTable
+        if (this.columns.length === 1 && this.rows.length > 0) {
+            const itemType = this.rows[0].getType(0);
+            if (itemType === types_1.PropertyType.TABLE) {
+                const val = this.rows[0].get(0);
+                if (val && 'columns' in val && 'rows' in val) {
+                    const gt = val;
+                    const headers = gt.columns.map((col, i) => {
+                        let colType = types_1.PropertyType.UNSET;
+                        if (gt.rows.length > 0 && i < gt.rows[0].length) {
+                            const v = gt.rows[0][i];
+                            if (typeof v === 'number')
+                                colType = Number.isInteger(v) ? types_1.PropertyType.INT64 : types_1.PropertyType.DOUBLE;
+                            else if (typeof v === 'string')
+                                colType = types_1.PropertyType.STRING;
+                            else if (typeof v === 'boolean')
+                                colType = types_1.PropertyType.BOOL;
+                        }
+                        return { name: col, type: colType };
+                    });
+                    return { name: this.columns[0], headers, rows: gt.rows };
+                }
+            }
+        }
+        // Fallback: generic multi-column table
+        const headers = this.columns.map(col => ({
+            name: col,
+            type: types_1.PropertyType.UNSET,
+        }));
+        const tableRows = this.rows.map(row => {
+            return this.columns.map((_, i) => (i < row.values.length ? row.get(i) : null));
+        });
+        return { name: '', headers, rows: tableRows };
+    }
+    /**
+     * @deprecated Use alias() or get() instead. This method will be removed in a future version.
+     * Extract scalar or list attribute values
+     */
+    asAttr(columnName) {
+        const colIndex = this.columns.indexOf(columnName);
+        if (colIndex === -1) {
+            throw new Error(`Column not found: ${columnName}`);
+        }
+        const values = [];
+        let attrType = types_1.PropertyType.UNSET;
+        for (const row of this.rows) {
+            if (colIndex < row.values.length) {
+                // Try to get type from row.types first, then from TypedValue object
+                if (attrType === types_1.PropertyType.UNSET) {
+                    attrType = row.getType(colIndex);
+                    if (attrType === types_1.PropertyType.UNSET) {
+                        const rawValue = row.values[colIndex];
+                        if (rawValue && typeof rawValue === 'object' && 'type' in rawValue) {
+                            attrType = rawValue.type;
+                        }
+                    }
+                }
+                const value = row.get(colIndex); // Use get() to convert TypedValue
+                values.push(value);
+            }
+        }
+        return { name: columnName, type: attrType, values };
+    }
+    // Helper methods
+    buildSchemaFromNode(label, node) {
+        const properties = Object.entries(node.properties).map(([name, value]) => ({
+            name,
+            type: this.inferPropertyType(value),
+        }));
+        return { name: label, properties };
+    }
+    buildSchemaFromEdge(label, edge) {
+        const properties = Object.entries(edge.properties).map(([name, value]) => ({
+            name,
+            type: this.inferPropertyType(value),
+        }));
+        return { name: label, properties };
+    }
+    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;
+    }
+}
+exports.Response = Response;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"response.js","sourceRoot":"","sources":["../src/response.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Response handling for GQLDB Node.js driver.\n */\n\nimport { TypedValue, typedValueToJS, PropertyType, Schema, PropertyDef, Table, Header, Attr, GqldbNode, GqldbEdge, GqldbPath } from './types';\n\n/** Represents a single row in the query result */\nexport class Row {\n  constructor(\n    public readonly values: any[],\n    public readonly types: PropertyType[] = []\n  ) {}\n\n  /** Get the value at the given column index */\n  get(index: number): any {\n    if (index < 0 || index >= this.values.length) {\n      throw new Error(`Column index out of range: ${index}`);\n    }\n    const value = this.values[index];\n    // If value is a TypedValue object, convert it\n    if (value && typeof value === 'object' && 'type' in value && 'data' in value && 'isNull' in value) {\n      return typedValueToJS(value as TypedValue);\n    }\n    return value;\n  }\n\n  /** Get the PropertyType at the given column index */\n  getType(index: number): PropertyType {\n    if (index < 0 || index >= this.types.length) {\n      return PropertyType.UNSET;\n    }\n    return this.types[index];\n  }\n\n  /** Get the value at the given column index as a string */\n  getString(index: number): string {\n    const val = this.get(index);\n    if (val === null || val === undefined) return '';\n    if (typeof val === 'string') return val;\n    return String(val);\n  }\n\n  /** Get the value at the given column index as a number */\n  getNumber(index: number): number {\n    const val = this.get(index);\n    if (val === null || val === undefined) return 0;\n    if (typeof val === 'number') return val;\n    const num = Number(val);\n    if (isNaN(num)) throw new Error(`Cannot convert ${typeof val} to number`);\n    return num;\n  }\n\n  /** Get the value at the given column index as a boolean */\n  getBoolean(index: number): boolean {\n    const val = this.get(index);\n    if (val === null || val === undefined) return false;\n    if (typeof val === 'boolean') return val;\n    throw new Error(`Cannot convert ${typeof val} to boolean`);\n  }\n}\n\n/**\n * Represents a single column's data from the response.\n * Allows chaining operations like resp.alias(\"n\").asNodes() or resp.get(0).asNodes().\n */\nexport class AliasResult {\n  constructor(\n    private readonly aliasName: string,\n    private readonly columnIdx: number,\n    private readonly response: Response\n  ) {}\n\n  /** Get the alias name */\n  get alias(): string {\n    return this.aliasName;\n  }\n\n  /** Get the column index */\n  get columnIndex(): number {\n    return this.columnIdx;\n  }\n\n  /**\n   * Extract nodes from the aliased column with schema info.\n   * Throws TypeError if the column contains non-NODE types.\n   */\n  private collectNode(val: any, nodes: Node[], schemas: Map<string, Schema>): void {\n    if (val && typeof val.id === 'string' && 'labels' in val) {\n      const node: Node = {\n        id: val.id,\n        labels: val.labels || [],\n        properties: val.properties || {},\n      };\n      nodes.push(node);\n      for (const label of node.labels) {\n        if (!schemas.has(label)) {\n          schemas.set(label, this.buildSchemaFromNode(label, node));\n        }\n      }\n    }\n  }\n\n  private collectEdge(val: any, edges: Edge[], schemas: Map<string, Schema>): void {\n    if (val && typeof val.id === 'string' && 'label' in val) {\n      const edge: Edge = {\n        id: val.id,\n        label: val.label || '',\n        fromNodeId: val.fromNodeId || '',\n        toNodeId: val.toNodeId || '',\n        properties: val.properties || {},\n      };\n      edges.push(edge);\n      if (edge.label && !schemas.has(edge.label)) {\n        schemas.set(edge.label, this.buildSchemaFromEdge(edge.label, edge));\n      }\n    }\n  }\n\n  /**\n   * Extract nodes from the aliased column with schema info.\n   * Supports both direct NODE columns and LIST of NODE columns\n   * (e.g., group variables from quantified patterns).\n   */\n  asNodes(): NodeResult {\n    const nodes: Node[] = [];\n    const schemas = new Map<string, Schema>();\n\n    for (const row of this.response.rows) {\n      if (this.columnIdx >= row.values.length) {\n        continue;\n      }\n\n      let itemType = row.getType(this.columnIdx);\n      const rawValue = row.values[this.columnIdx];\n      if (itemType === PropertyType.UNSET && rawValue && typeof rawValue === 'object' && 'type' in rawValue) {\n        itemType = rawValue.type;\n      }\n\n      if (!rawValue || (typeof rawValue === 'object' && 'isNull' in rawValue && rawValue.isNull)) {\n        continue;\n      }\n\n      if (itemType === PropertyType.NODE) {\n        this.collectNode(row.get(this.columnIdx), nodes, schemas);\n      } else if (itemType === PropertyType.LIST) {\n        // LIST of NODE (group variable from quantified pattern)\n        const list = row.get(this.columnIdx);\n        if (Array.isArray(list)) {\n          for (const item of list) {\n            this.collectNode(item, nodes, schemas);\n          }\n        }\n      } else {\n        throw new TypeError(\n          `Type mismatch: column '${this.aliasName}' (index ${this.columnIdx}) contains ${PropertyType[itemType]}, expected NODE or LIST of NODE`\n        );\n      }\n    }\n\n    return { nodes, schemas };\n  }\n\n  /**\n   * Extract edges from the aliased column with schema info.\n   * Supports both direct EDGE columns and LIST of EDGE columns\n   * (e.g., group variables from quantified patterns).\n   */\n  asEdges(): EdgeResult {\n    const edges: Edge[] = [];\n    const schemas = new Map<string, Schema>();\n\n    for (const row of this.response.rows) {\n      if (this.columnIdx >= row.values.length) {\n        continue;\n      }\n\n      let itemType = row.getType(this.columnIdx);\n      const rawValue = row.values[this.columnIdx];\n      if (itemType === PropertyType.UNSET && rawValue && typeof rawValue === 'object' && 'type' in rawValue) {\n        itemType = rawValue.type;\n      }\n\n      if (!rawValue || (typeof rawValue === 'object' && 'isNull' in rawValue && rawValue.isNull)) {\n        continue;\n      }\n\n      if (itemType === PropertyType.EDGE) {\n        this.collectEdge(row.get(this.columnIdx), edges, schemas);\n      } else if (itemType === PropertyType.LIST) {\n        // LIST of EDGE (group variable from quantified pattern)\n        const list = row.get(this.columnIdx);\n        if (Array.isArray(list)) {\n          for (const item of list) {\n            this.collectEdge(item, edges, schemas);\n          }\n        }\n      } else {\n        throw new TypeError(\n          `Type mismatch: column '${this.aliasName}' (index ${this.columnIdx}) contains ${PropertyType[itemType]}, expected EDGE or LIST of EDGE`\n        );\n      }\n    }\n\n    return { edges, schemas };\n  }\n\n  /**\n   * Extract paths from the aliased column.\n   * Throws TypeError if the column contains non-PATH types.\n   */\n  asPaths(): Path[] {\n    const paths: Path[] = [];\n\n    for (const row of this.response.rows) {\n      if (this.columnIdx >= row.values.length) {\n        continue;\n      }\n\n      // Check type from types array or from TypedValue object\n      let itemType = row.getType(this.columnIdx);\n      const rawValue = row.values[this.columnIdx];\n      if (itemType === PropertyType.UNSET && rawValue && typeof rawValue === 'object' && 'type' in rawValue) {\n        itemType = rawValue.type;\n      }\n\n      // Skip null values\n      if (!rawValue || (typeof rawValue === 'object' && 'isNull' in rawValue && rawValue.isNull)) {\n        continue;\n      }\n\n      // Type checking: must be PATH type\n      if (itemType !== PropertyType.PATH) {\n        throw new TypeError(\n          `Type mismatch: column '${this.aliasName}' (index ${this.columnIdx}) contains ${PropertyType[itemType]}, expected PATH`\n        );\n      }\n\n      // Convert TypedValue to GqldbPath\n      const val = row.get(this.columnIdx) as GqldbPath;\n      if (val && Array.isArray(val.nodes)) {\n        // Convert GqldbNode/GqldbEdge to Node/Edge\n        const nodes: Node[] = (val.nodes || []).map((n: GqldbNode) => ({\n          id: n.id || '',\n          labels: n.labels || [],\n          properties: n.properties || {},\n        }));\n        const edges: Edge[] = (val.edges || []).map((e: GqldbEdge) => ({\n          id: e.id || '',\n          label: e.label || '',\n          fromNodeId: e.fromNodeId || '',\n          toNodeId: e.toNodeId || '',\n          properties: e.properties || {},\n        }));\n        paths.push({ nodes, edges });\n      }\n    }\n\n    return paths;\n  }\n\n  /** Convert the aliased column to a single-column table */\n  asTable(): Table {\n    // Check if first non-null value is a GqldbTable — if so, unwrap it\n    for (const row of this.response.rows) {\n      if (this.columnIdx < row.values.length) {\n        const itemType = row.getType(this.columnIdx);\n        if (itemType === PropertyType.TABLE) {\n          const val = row.get(this.columnIdx) as any;\n          if (val && 'columns' in val && 'rows' in val) {\n            return this.unwrapGqldbTable(val);\n          }\n        }\n      }\n      break; // only check first row\n    }\n\n    // Fallback: generic single-column table\n    const headers: Header[] = [{\n      name: this.aliasName,\n      type: PropertyType.UNSET,\n    }];\n\n    if (this.response.rows.length > 0) {\n      for (const row of this.response.rows) {\n        if (this.columnIdx < row.values.length) {\n          const type = row.getType(this.columnIdx);\n          if (type !== PropertyType.UNSET) {\n            headers[0].type = type;\n            break;\n          }\n        }\n      }\n    }\n\n    const tableRows: any[][] = this.response.rows.map(row => {\n      if (this.columnIdx < row.values.length) {\n        return [row.get(this.columnIdx)];\n      }\n      return [null];\n    });\n\n    return { name: '', headers, rows: tableRows };\n  }\n\n  private unwrapGqldbTable(gt: { columns: string[]; rows: any[][] }): Table {\n    const headers: Header[] = gt.columns.map((col, i) => {\n      let colType = PropertyType.UNSET;\n      if (gt.rows.length > 0 && i < gt.rows[0].length) {\n        const v = gt.rows[0][i];\n        if (typeof v === 'number') colType = Number.isInteger(v) ? PropertyType.INT64 : PropertyType.DOUBLE;\n        else if (typeof v === 'string') colType = PropertyType.STRING;\n        else if (typeof v === 'boolean') colType = PropertyType.BOOL;\n      }\n      return { name: col, type: colType };\n    });\n    return { name: this.aliasName, headers, rows: gt.rows };\n  }\n\n  /** Extract scalar or list attribute values from the aliased column */\n  asAttr(): Attr {\n    const values: any[] = [];\n    let attrType = PropertyType.UNSET;\n\n    for (const row of this.response.rows) {\n      if (this.columnIdx < row.values.length) {\n        // Try to get type from row.types first, then from TypedValue object\n        if (attrType === PropertyType.UNSET) {\n          attrType = row.getType(this.columnIdx);\n          if (attrType === PropertyType.UNSET) {\n            const rawValue = row.values[this.columnIdx];\n            if (rawValue && typeof rawValue === 'object' && 'type' in rawValue) {\n              attrType = rawValue.type;\n            }\n          }\n        }\n        const value = row.get(this.columnIdx);  // Use get() to convert TypedValue\n        values.push(value);\n      }\n    }\n\n    return { name: this.aliasName, type: attrType, values };\n  }\n\n  /** Extract raw JavaScript values from the aliased column */\n  asValues(): any[] {\n    const values: any[] = [];\n\n    for (const row of this.response.rows) {\n      if (this.columnIdx < row.values.length) {\n        values.push(row.get(this.columnIdx));\n      }\n    }\n\n    return values;\n  }\n\n  // Helper methods\n\n  private buildSchemaFromNode(label: string, node: Node): Schema {\n    const properties: PropertyDef[] = Object.entries(node.properties).map(([name, value]) => ({\n      name,\n      type: this.inferPropertyType(value),\n    }));\n    return { name: label, properties };\n  }\n\n  private buildSchemaFromEdge(label: string, edge: Edge): Schema {\n    const properties: PropertyDef[] = Object.entries(edge.properties).map(([name, value]) => ({\n      name,\n      type: this.inferPropertyType(value),\n    }));\n    return { name: label, properties };\n  }\n\n  private 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}\n\n/** Represents the result of a GQL query */\nexport class Response {\n  constructor(\n    public readonly columns: string[],\n    public readonly rows: Row[],\n    public readonly rowCount: number,\n    public readonly hasMore: boolean,\n    public readonly warnings: string[],\n    public readonly rowsAffected: number = 0\n  ) {}\n\n  /** Check if the response has no rows */\n  isEmpty(): boolean {\n    return this.rows.length === 0;\n  }\n\n  /** Get the first row */\n  first(): Row | undefined {\n    return this.rows[0];\n  }\n\n  /** Get the last row */\n  last(): Row | undefined {\n    return this.rows[this.rows.length - 1];\n  }\n\n  /** Get the value for a column by name */\n  getByName(row: Row, columnName: string): any {\n    const index = this.columns.indexOf(columnName);\n    if (index === -1) {\n      throw new Error(`Column not found: ${columnName}`);\n    }\n    return row.get(index);\n  }\n\n  /** Iterate over all rows with a callback */\n  forEach(fn: (row: Row, index: number) => void): void {\n    this.rows.forEach(fn);\n  }\n\n  /** Transform each row using a callback */\n  map<T>(fn: (row: Row) => T): T[] {\n    return this.rows.map(fn);\n  }\n\n  /** Convert the response to an array of objects */\n  toObjects(): Record<string, any>[] {\n    return this.rows.map(row => {\n      const obj: Record<string, any> = {};\n      this.columns.forEach((col, i) => {\n        // Add boundary check to handle mismatched columns/values\n        obj[col] = i < row.values.length ? row.get(i) : null;\n      });\n      return obj;\n    });\n  }\n\n  /** Convert the response to JSON */\n  toJSON(): string {\n    return JSON.stringify(this.toObjects());\n  }\n\n  /** Get the single value from a single-row, single-column response */\n  singleValue(): any {\n    if (this.rows.length === 0) return null;\n    if (this.rows.length > 1) {\n      throw new Error(`Expected single row, got ${this.rows.length}`);\n    }\n    if (this.rows[0].values.length === 0) return null;\n    if (this.rows[0].values.length > 1) {\n      throw new Error(`Expected single column, got ${this.rows[0].values.length}`);\n    }\n    return this.rows[0].get(0);\n  }\n\n  /** Get the single number value */\n  singleNumber(): number {\n    const val = this.singleValue();\n    if (val === null || val === undefined) return 0;\n    if (typeof val === 'number') return val;\n    const num = Number(val);\n    if (isNaN(num)) throw new Error(`Cannot convert ${typeof val} to number`);\n    return num;\n  }\n\n  /** Get the single string value */\n  singleString(): string {\n    const val = this.singleValue();\n    if (val === null || val === undefined) return '';\n    if (typeof val === 'string') return val;\n    return String(val);\n  }\n\n  /** Iterator support */\n  [Symbol.iterator](): Iterator<Row> {\n    return this.rows[Symbol.iterator]();\n  }\n\n  /** Get the number of rows */\n  get length(): number {\n    return this.rows.length;\n  }\n\n  /**\n   * Get an AliasResult for the specified column name.\n   * Use this to extract data from a specific column by name.\n   * Example: resp.alias(\"n\").asNodes()\n   */\n  alias(columnName: string): AliasResult {\n    const colIdx = this.columns.indexOf(columnName);\n    if (colIdx === -1) {\n      throw new Error(`Column alias not found: ${columnName}`);\n    }\n    return new AliasResult(columnName, colIdx, this);\n  }\n\n  /**\n   * Get an AliasResult for the column at the specified index.\n   * Use this to extract data from a specific column by index.\n   * Example: resp.get(0).asNodes()\n   */\n  get(index: number): AliasResult {\n    if (index < 0 || index >= this.columns.length) {\n      throw new Error(`Column index out of range: ${index} (total: ${this.columns.length})`);\n    }\n    return new AliasResult(this.columns[index], index, this);\n  }\n\n  /**\n   * @deprecated Use alias() or get() instead. This method will be removed in a future version.\n   * Extract nodes from response with schema info.\n   * Supports both NODE and LIST of NODE columns.\n   */\n  asNodes(): NodeResult {\n    const nodes: Node[] = [];\n    const schemas = new Map<string, Schema>();\n\n    const collectNode = (val: any) => {\n      if (val && typeof val.id === 'string' && 'labels' in val) {\n        const node: Node = {\n          id: val.id,\n          labels: val.labels || [],\n          properties: val.properties || {},\n        };\n        nodes.push(node);\n        for (const label of node.labels) {\n          if (!schemas.has(label)) {\n            schemas.set(label, this.buildSchemaFromNode(label, node));\n          }\n        }\n      }\n    };\n\n    for (const row of this.rows) {\n      for (let i = 0; i < row.values.length; i++) {\n        let itemType = row.getType(i);\n        const rawValue = row.values[i];\n        if (itemType === PropertyType.UNSET && rawValue && typeof rawValue === 'object' && 'type' in rawValue) {\n          itemType = rawValue.type;\n        }\n\n        if (itemType === PropertyType.NODE) {\n          collectNode(row.get(i));\n        } else if (itemType === PropertyType.LIST) {\n          const list = row.get(i);\n          if (Array.isArray(list)) {\n            for (const item of list) {\n              collectNode(item);\n            }\n          }\n        }\n      }\n    }\n\n    return { nodes, schemas };\n  }\n\n  /**\n   * @deprecated Use alias() or get() instead. This method will be removed in a future version.\n   * Extract edges from response with schema info.\n   * Supports both EDGE and LIST of EDGE columns.\n   */\n  asEdges(): EdgeResult {\n    const edges: Edge[] = [];\n    const schemas = new Map<string, Schema>();\n\n    const collectEdge = (val: any) => {\n      if (val && typeof val.id === 'string' && 'label' in val) {\n        const edge: Edge = {\n          id: val.id,\n          label: val.label || '',\n          fromNodeId: val.fromNodeId || '',\n          toNodeId: val.toNodeId || '',\n          properties: val.properties || {},\n        };\n        edges.push(edge);\n        if (edge.label && !schemas.has(edge.label)) {\n          schemas.set(edge.label, this.buildSchemaFromEdge(edge.label, edge));\n        }\n      }\n    };\n\n    for (const row of this.rows) {\n      for (let i = 0; i < row.values.length; i++) {\n        let itemType = row.getType(i);\n        const rawValue = row.values[i];\n        if (itemType === PropertyType.UNSET && rawValue && typeof rawValue === 'object' && 'type' in rawValue) {\n          itemType = rawValue.type;\n        }\n\n        if (itemType === PropertyType.EDGE) {\n          collectEdge(row.get(i));\n        } else if (itemType === PropertyType.LIST) {\n          const list = row.get(i);\n          if (Array.isArray(list)) {\n            for (const item of list) {\n              collectEdge(item);\n            }\n          }\n        }\n      }\n    }\n\n    return { edges, schemas };\n  }\n\n  /**\n   * @deprecated Use alias() or get() instead. This method will be removed in a future version.\n   * Extract paths from response.\n   * Paths are identified by PropertyType.PATH type in the TypedValue.\n   */\n  asPaths(): Path[] {\n    const paths: Path[] = [];\n\n    for (const row of this.rows) {\n      for (let i = 0; i < row.values.length; i++) {\n        // Check type from types array or from TypedValue object\n        let itemType = row.getType(i);\n        const rawValue = row.values[i];\n        if (itemType === PropertyType.UNSET && rawValue && typeof rawValue === 'object' && 'type' in rawValue) {\n          itemType = rawValue.type;\n        }\n\n        if (itemType === PropertyType.PATH) {\n          // Convert TypedValue to GqldbPath\n          const val = row.get(i) as GqldbPath;\n          if (val && Array.isArray(val.nodes)) {\n            // Convert GqldbNode/GqldbEdge to Node/Edge\n            const nodes: Node[] = (val.nodes || []).map((n: GqldbNode) => ({\n              id: n.id || '',\n              labels: n.labels || [],\n              properties: n.properties || {},\n            }));\n            const edges: Edge[] = (val.edges || []).map((e: GqldbEdge) => ({\n              id: e.id || '',\n              label: e.label || '',\n              fromNodeId: e.fromNodeId || '',\n              toNodeId: e.toNodeId || '',\n              properties: e.properties || {},\n            }));\n            paths.push({ nodes, edges });\n          }\n        }\n      }\n    }\n\n    return paths;\n  }\n\n  /**\n   * @deprecated Use alias() or get() instead. This method will be removed in a future version.\n   * Return response as generic table.\n   * If response is a single TABLE column, unwraps the GqldbTable into proper headers/rows.\n   */\n  asTable(): Table {\n    // If single column of TABLE type, unwrap GqldbTable\n    if (this.columns.length === 1 && this.rows.length > 0) {\n      const itemType = this.rows[0].getType(0);\n      if (itemType === PropertyType.TABLE) {\n        const val = this.rows[0].get(0) as any;\n        if (val && 'columns' in val && 'rows' in val) {\n          const gt = val as { columns: string[]; rows: any[][] };\n          const headers: Header[] = gt.columns.map((col: string, i: number) => {\n            let colType = PropertyType.UNSET;\n            if (gt.rows.length > 0 && i < gt.rows[0].length) {\n              const v = gt.rows[0][i];\n              if (typeof v === 'number') colType = Number.isInteger(v) ? PropertyType.INT64 : PropertyType.DOUBLE;\n              else if (typeof v === 'string') colType = PropertyType.STRING;\n              else if (typeof v === 'boolean') colType = PropertyType.BOOL;\n            }\n            return { name: col, type: colType };\n          });\n          return { name: this.columns[0], headers, rows: gt.rows };\n        }\n      }\n    }\n\n    // Fallback: generic multi-column table\n    const headers: Header[] = this.columns.map(col => ({\n      name: col,\n      type: PropertyType.UNSET,\n    }));\n\n    const tableRows: any[][] = this.rows.map(row => {\n      return this.columns.map((_, i) => (i < row.values.length ? row.get(i) : null));\n    });\n\n    return { name: '', headers, rows: tableRows };\n  }\n\n  /**\n   * @deprecated Use alias() or get() instead. This method will be removed in a future version.\n   * Extract scalar or list attribute values\n   */\n  asAttr(columnName: string): Attr {\n    const colIndex = this.columns.indexOf(columnName);\n    if (colIndex === -1) {\n      throw new Error(`Column not found: ${columnName}`);\n    }\n\n    const values: any[] = [];\n    let attrType = PropertyType.UNSET;\n\n    for (const row of this.rows) {\n      if (colIndex < row.values.length) {\n        // Try to get type from row.types first, then from TypedValue object\n        if (attrType === PropertyType.UNSET) {\n          attrType = row.getType(colIndex);\n          if (attrType === PropertyType.UNSET) {\n            const rawValue = row.values[colIndex];\n            if (rawValue && typeof rawValue === 'object' && 'type' in rawValue) {\n              attrType = rawValue.type;\n            }\n          }\n        }\n        const value = row.get(colIndex);  // Use get() to convert TypedValue\n        values.push(value);\n      }\n    }\n\n    return { name: columnName, type: attrType, values };\n  }\n\n  // Helper methods\n\n  private buildSchemaFromNode(label: string, node: Node): Schema {\n    const properties: PropertyDef[] = Object.entries(node.properties).map(([name, value]) => ({\n      name,\n      type: this.inferPropertyType(value),\n    }));\n    return { name: label, properties };\n  }\n\n  private buildSchemaFromEdge(label: string, edge: Edge): Schema {\n    const properties: PropertyDef[] = Object.entries(edge.properties).map(([name, value]) => ({\n      name,\n      type: this.inferPropertyType(value),\n    }));\n    return { name: label, properties };\n  }\n\n  private 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}\n\n/** Result of an insert nodes operation */\nexport interface InsertNodesResult {\n  success: boolean;\n  nodeIds: string[];\n  nodeCount: number;\n  message: string;\n}\n\n/** Result of an insert edges operation */\nexport interface InsertEdgesResult {\n  success: boolean;\n  edgeIds: string[];\n  edgeCount: number;\n  message: string;\n  skippedCount: number;\n}\n\n/** Result of a delete operation */\nexport interface DeleteResult {\n  success: boolean;\n  deletedCount: number;\n  message: string;\n}\n\n/** Configuration for the unified Export operation */\nexport interface ExportConfig {\n  graphName: string;\n  batchSize?: number;\n  exportNodes?: boolean;\n  exportEdges?: boolean;\n  nodeLabels?: string[];\n  edgeLabels?: string[];\n  includeMetadata?: boolean;\n}\n\n/** Statistics for an export operation */\nexport interface ExportStats {\n  nodesExported: number;\n  edgesExported: number;\n  bytesWritten: number;\n  durationMs: number;\n}\n\n/** A chunk of exported data in JSON Lines format */\nexport interface ExportChunk {\n  data: Buffer;\n  isFinal: boolean;\n  stats?: ExportStats;\n}\n\n/**\n * A batch of exported nodes\n * @deprecated Use export() with ExportConfig instead\n */\nexport interface ExportNodesResult {\n  nodes: ExportedNode[];\n  hasMore: boolean;\n}\n\n/**\n * A batch of exported edges\n * @deprecated Use export() with ExportConfig instead\n */\nexport interface ExportEdgesResult {\n  edges: ExportedEdge[];\n  hasMore: boolean;\n}\n\n/**\n * A node exported from the database\n * @deprecated Use export() with ExportConfig instead\n */\nexport interface ExportedNode {\n  id: string;\n  labels: string[];\n  properties: Record<string, any>;\n}\n\n/**\n * An edge exported from the database\n * @deprecated Use export() with ExportConfig instead\n */\nexport interface ExportedEdge {\n  id: string;\n  label: string;\n  fromNodeId: string;\n  toNodeId: string;\n  properties: Record<string, any>;\n}\n\n/** Represents a node in the graph database */\nexport interface Node {\n  id: string;\n  labels: string[];\n  properties: Record<string, any>;\n}\n\n/** Represents an edge in the graph database */\nexport interface Edge {\n  id: string;\n  label: string;\n  fromNodeId: string;\n  toNodeId: string;\n  properties: Record<string, any>;\n}\n\n/** Represents a path in the graph database */\nexport interface Path {\n  nodes: Node[];\n  edges: Edge[];\n}\n\n/** Result wrapper for nodes with schema information */\nexport interface NodeResult {\n  nodes: Node[];\n  schemas: Map<string, Schema>;\n}\n\n/** Result wrapper for edges with schema information */\nexport interface EdgeResult {\n  edges: Edge[];\n  schemas: Map<string, Schema>;\n}\n"]}