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

package/dist/services/converters.js

@@ -0,0 +1,254 @@
+"use strict";
+/**
+ * Type conversion utilities between gRPC proto types and JavaScript types.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGqlRequest = buildGqlRequest;
+exports.buildParameters = buildParameters;
+exports.convertGqlResponse = convertGqlResponse;
+exports.convertTypedValue = convertTypedValue;
+exports.convertProtoProperties = convertProtoProperties;
+exports.convertGraphInfo = convertGraphInfo;
+exports.graphTypeToProto = graphTypeToProto;
+exports.protoToGraphType = protoToGraphType;
+exports.protoToHealthStatus = protoToHealthStatus;
+exports.cacheTypeToProto = cacheTypeToProto;
+exports.nodeDataToProto = nodeDataToProto;
+exports.edgeDataToProto = edgeDataToProto;
+const response_1 = require("../response");
+const types_1 = require("../types");
+/**
+ * Build a GQL request from config.
+ */
+function buildGqlRequest(query, session, config, queryConfig) {
+    return {
+        gql: query,
+        graph_name: queryConfig?.graphName || session?.defaultGraph || config.defaultGraph || '',
+        parameters: buildParameters(queryConfig?.parameters),
+        session_id: session?.id?.toString() || '0',
+        transaction_id: queryConfig?.transactionId?.toString() || '0',
+        timeout: Math.floor((queryConfig?.timeout || config.timeout || 30000) / 1000), // Convert ms to seconds for gRPC
+        read_only: queryConfig?.readOnly || false,
+        max_path_results: queryConfig?.maxPathResults || 0,
+    };
+}
+/**
+ * Build parameters array for gRPC.
+ */
+function buildParameters(params) {
+    if (!params)
+        return [];
+    return Object.entries(params).map(([name, value]) => ({
+        name,
+        value: (0, types_1.createTypedValue)(value),
+    }));
+}
+/**
+ * Convert gRPC response to Response object.
+ */
+function convertGqlResponse(grpcResponse) {
+    const columns = grpcResponse.columns || [];
+    const rows = (grpcResponse.rows || []).map((row) => {
+        const rawValues = row.values || [];
+        const values = rawValues.map((tv) => convertTypedValue(tv));
+        const types = rawValues.map((tv) => protoTypeToEnum(tv?.type));
+        return new response_1.Row(values, types);
+    });
+    return new response_1.Response(columns, rows, parseInt(grpcResponse.row_count || '0', 10), grpcResponse.has_more || false, grpcResponse.warnings || [], parseInt(grpcResponse.rows_affected || '0', 10));
+}
+/**
+ * Map proto type string or number to PropertyType enum.
+ * Handles both string enum names (e.g., 'PROPERTY_TYPE_STRING') and numeric values.
+ */
+function protoTypeToEnum(protoType) {
+    // Handle numeric enum values directly
+    if (typeof protoType === 'number') {
+        // If it's already a valid PropertyType number, return it directly
+        // PropertyType ranges from UNSET(0) to EDGE(33)
+        if (protoType >= types_1.PropertyType.UNSET && protoType <= types_1.PropertyType.EDGE) {
+            return protoType;
+        }
+        return types_1.PropertyType.NULL;
+    }
+    const typeMap = {
+        'PROPERTY_TYPE_NULL': types_1.PropertyType.NULL,
+        'PROPERTY_TYPE_UNSET': types_1.PropertyType.UNSET,
+        'PROPERTY_TYPE_BOOL': types_1.PropertyType.BOOL,
+        'PROPERTY_TYPE_INT32': types_1.PropertyType.INT32,
+        'PROPERTY_TYPE_UINT32': types_1.PropertyType.UINT32,
+        'PROPERTY_TYPE_INT64': types_1.PropertyType.INT64,
+        'PROPERTY_TYPE_UINT64': types_1.PropertyType.UINT64,
+        'PROPERTY_TYPE_FLOAT': types_1.PropertyType.FLOAT,
+        'PROPERTY_TYPE_DOUBLE': types_1.PropertyType.DOUBLE,
+        'PROPERTY_TYPE_STRING': types_1.PropertyType.STRING,
+        'PROPERTY_TYPE_TEXT': types_1.PropertyType.TEXT,
+        'PROPERTY_TYPE_BLOB': types_1.PropertyType.BLOB,
+        'PROPERTY_TYPE_TIMESTAMP': types_1.PropertyType.TIMESTAMP,
+        'PROPERTY_TYPE_DATETIME': types_1.PropertyType.DATETIME,
+        'PROPERTY_TYPE_DATE': types_1.PropertyType.DATE,
+        'PROPERTY_TYPE_LOCAL_DATETIME': types_1.PropertyType.LOCAL_DATETIME,
+        'PROPERTY_TYPE_ZONED_DATETIME': types_1.PropertyType.ZONED_DATETIME,
+        'PROPERTY_TYPE_LOCAL_TIME': types_1.PropertyType.LOCAL_TIME,
+        'PROPERTY_TYPE_ZONED_TIME': types_1.PropertyType.ZONED_TIME,
+        'PROPERTY_TYPE_YEAR_TO_MONTH': types_1.PropertyType.YEAR_TO_MONTH,
+        'PROPERTY_TYPE_DAY_TO_SECOND': types_1.PropertyType.DAY_TO_SECOND,
+        'PROPERTY_TYPE_DECIMAL': types_1.PropertyType.DECIMAL,
+        'PROPERTY_TYPE_POINT': types_1.PropertyType.POINT,
+        'PROPERTY_TYPE_POINT3D': types_1.PropertyType.POINT3D,
+        'PROPERTY_TYPE_VECTOR': types_1.PropertyType.VECTOR,
+        'PROPERTY_TYPE_LIST': types_1.PropertyType.LIST,
+        'PROPERTY_TYPE_SET': types_1.PropertyType.SET,
+        'PROPERTY_TYPE_MAP': types_1.PropertyType.MAP,
+        'PROPERTY_TYPE_NODE': types_1.PropertyType.NODE,
+        'PROPERTY_TYPE_EDGE': types_1.PropertyType.EDGE,
+        'PROPERTY_TYPE_PATH': types_1.PropertyType.PATH,
+        'PROPERTY_TYPE_RECORD': types_1.PropertyType.RECORD,
+        'PROPERTY_TYPE_TABLE': types_1.PropertyType.TABLE,
+        'PROPERTY_TYPE_ERROR': types_1.PropertyType.ERROR,
+    };
+    return typeMap[protoType] ?? types_1.PropertyType.NULL;
+}
+/**
+ * Convert gRPC TypedValue to JS value.
+ * Uses the same decoding logic as typedValueToJS for consistency.
+ */
+function convertTypedValue(tv) {
+    if (!tv || tv.is_null || tv.isNull)
+        return null;
+    const data = tv.data;
+    const protoType = tv.type;
+    // Handle null types (both string and numeric enum values)
+    if (protoType === 'PROPERTY_TYPE_NULL' || protoType === 'PROPERTY_TYPE_UNSET' ||
+        protoType === types_1.PropertyType.NULL || protoType === types_1.PropertyType.UNSET) {
+        return null;
+    }
+    // Handle empty data - but STRING type with empty data should return ""
+    if (!data || data.length === 0) {
+        const isStringType = protoType === 'PROPERTY_TYPE_STRING' || protoType === 'PROPERTY_TYPE_TEXT' ||
+            protoType === types_1.PropertyType.STRING || protoType === types_1.PropertyType.TEXT;
+        const isBlobType = protoType === 'PROPERTY_TYPE_BLOB' || protoType === types_1.PropertyType.BLOB;
+        if (isStringType) {
+            return '';
+        }
+        if (isBlobType) {
+            return Buffer.alloc(0);
+        }
+        return null;
+    }
+    const buf = Buffer.from(data);
+    const enumType = protoTypeToEnum(protoType);
+    // Use typedValueToJS for consistent decoding
+    return (0, types_1.typedValueToJS)({ type: enumType, data: buf, isNull: false });
+}
+/**
+ * Convert proto properties map to JS object.
+ */
+function convertProtoProperties(protoProps) {
+    const result = {};
+    for (const [key, tv] of Object.entries(protoProps)) {
+        result[key] = convertTypedValue(tv);
+    }
+    return result;
+}
+/**
+ * Convert GraphInfo from proto to JS object.
+ */
+function convertGraphInfo(g) {
+    return {
+        name: g.name || '',
+        graphType: protoToGraphType(g.graph_type),
+        nodeCount: parseInt(g.node_count || '0', 10),
+        edgeCount: parseInt(g.edge_count || '0', 10),
+        description: g.description || '',
+    };
+}
+/**
+ * Map GraphType enum to proto string.
+ */
+function graphTypeToProto(graphType) {
+    switch (graphType) {
+        case types_1.GraphType.OPEN:
+            return 'GRAPH_TYPE_OPEN';
+        case types_1.GraphType.CLOSED:
+            return 'GRAPH_TYPE_CLOSED';
+        case types_1.GraphType.ONTOLOGY:
+            return 'GRAPH_TYPE_ONTOLOGY';
+        default:
+            return 'GRAPH_TYPE_OPEN';
+    }
+}
+/**
+ * Map proto string to GraphType enum.
+ */
+function protoToGraphType(proto) {
+    switch (proto) {
+        case 'GRAPH_TYPE_CLOSED':
+            return types_1.GraphType.CLOSED;
+        case 'GRAPH_TYPE_ONTOLOGY':
+            return types_1.GraphType.ONTOLOGY;
+        default:
+            return types_1.GraphType.OPEN;
+    }
+}
+/**
+ * Map proto HealthStatus to enum.
+ */
+function protoToHealthStatus(proto) {
+    switch (proto) {
+        case 'HEALTH_STATUS_SERVING':
+            return types_1.HealthStatus.SERVING;
+        case 'HEALTH_STATUS_NOT_SERVING':
+            return types_1.HealthStatus.NOT_SERVING;
+        case 'HEALTH_STATUS_SERVICE_UNKNOWN':
+            return types_1.HealthStatus.SERVICE_UNKNOWN;
+        default:
+            return types_1.HealthStatus.UNKNOWN;
+    }
+}
+/**
+ * Map CacheType to proto string.
+ */
+function cacheTypeToProto(cacheType) {
+    switch (cacheType) {
+        case types_1.CacheType.AST:
+            return 'CACHE_TYPE_AST';
+        case types_1.CacheType.PLAN:
+            return 'CACHE_TYPE_PLAN';
+        default:
+            return 'CACHE_TYPE_ALL';
+    }
+}
+/**
+ * Convert NodeData to proto format.
+ */
+function nodeDataToProto(node) {
+    const properties = {};
+    if (node.properties) {
+        for (const [key, value] of Object.entries(node.properties)) {
+            properties[key] = (0, types_1.createTypedValue)(value);
+        }
+    }
+    return {
+        id: node.id || '',
+        labels: node.labels || [],
+        properties,
+    };
+}
+/**
+ * Convert EdgeData to proto format.
+ */
+function edgeDataToProto(edge) {
+    const properties = {};
+    if (edge.properties) {
+        for (const [key, value] of Object.entries(edge.properties)) {
+            properties[key] = (0, types_1.createTypedValue)(value);
+        }
+    }
+    return {
+        label: edge.label || '',
+        from_node_id: edge.fromNodeId || '',
+        to_node_id: edge.toNodeId || '',
+        properties,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"converters.js","sourceRoot":"","sources":["../../src/services/converters.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Type conversion utilities between gRPC proto types and JavaScript types.\n */\n\nimport { Response, Row } from '../response';\nimport {\n  GraphType,\n  HealthStatus,\n  CacheType,\n  GraphInfo,\n  createTypedValue,\n  PropertyType,\n  typedValueToJS,\n} from '../types';\nimport { GqldbConfig } from '../config';\nimport { Session } from '../session';\nimport { QueryConfig } from '../client';\n\n/**\n * Build a GQL request from config.\n */\nexport function buildGqlRequest(\n  query: string,\n  session: Session | null,\n  config: GqldbConfig,\n  queryConfig?: QueryConfig\n): any {\n  return {\n    gql: query,\n    graph_name: queryConfig?.graphName || session?.defaultGraph || config.defaultGraph || '',\n    parameters: buildParameters(queryConfig?.parameters),\n    session_id: session?.id?.toString() || '0',\n    transaction_id: queryConfig?.transactionId?.toString() || '0',\n    timeout: Math.floor((queryConfig?.timeout || config.timeout || 30000) / 1000), // Convert ms to seconds for gRPC\n    read_only: queryConfig?.readOnly || false,\n    max_path_results: queryConfig?.maxPathResults || 0,\n  };\n}\n\n/**\n * Build parameters array for gRPC.\n */\nexport function buildParameters(params?: Record<string, any>): any[] {\n  if (!params) return [];\n  return Object.entries(params).map(([name, value]) => ({\n    name,\n    value: createTypedValue(value),\n  }));\n}\n\n/**\n * Convert gRPC response to Response object.\n */\nexport function convertGqlResponse(grpcResponse: any): Response {\n  const columns = grpcResponse.columns || [];\n  const rows: Row[] = (grpcResponse.rows || []).map((row: any) => {\n    const rawValues = row.values || [];\n    const values = rawValues.map((tv: any) => convertTypedValue(tv));\n    const types = rawValues.map((tv: any) => protoTypeToEnum(tv?.type));\n    return new Row(values, types);\n  });\n  return new Response(\n    columns,\n    rows,\n    parseInt(grpcResponse.row_count || '0', 10),\n    grpcResponse.has_more || false,\n    grpcResponse.warnings || [],\n    parseInt(grpcResponse.rows_affected || '0', 10)\n  );\n}\n\n/**\n * Map proto type string or number to PropertyType enum.\n * Handles both string enum names (e.g., 'PROPERTY_TYPE_STRING') and numeric values.\n */\nfunction protoTypeToEnum(protoType: string | number): PropertyType {\n  // Handle numeric enum values directly\n  if (typeof protoType === 'number') {\n    // If it's already a valid PropertyType number, return it directly\n    // PropertyType ranges from UNSET(0) to EDGE(33)\n    if (protoType >= PropertyType.UNSET && protoType <= PropertyType.EDGE) {\n      return protoType as PropertyType;\n    }\n    return PropertyType.NULL;\n  }\n\n  const typeMap: Record<string, PropertyType> = {\n    'PROPERTY_TYPE_NULL': PropertyType.NULL,\n    'PROPERTY_TYPE_UNSET': PropertyType.UNSET,\n    'PROPERTY_TYPE_BOOL': PropertyType.BOOL,\n    'PROPERTY_TYPE_INT32': PropertyType.INT32,\n    'PROPERTY_TYPE_UINT32': PropertyType.UINT32,\n    'PROPERTY_TYPE_INT64': PropertyType.INT64,\n    'PROPERTY_TYPE_UINT64': PropertyType.UINT64,\n    'PROPERTY_TYPE_FLOAT': PropertyType.FLOAT,\n    'PROPERTY_TYPE_DOUBLE': PropertyType.DOUBLE,\n    'PROPERTY_TYPE_STRING': PropertyType.STRING,\n    'PROPERTY_TYPE_TEXT': PropertyType.TEXT,\n    'PROPERTY_TYPE_BLOB': PropertyType.BLOB,\n    'PROPERTY_TYPE_TIMESTAMP': PropertyType.TIMESTAMP,\n    'PROPERTY_TYPE_DATETIME': PropertyType.DATETIME,\n    'PROPERTY_TYPE_DATE': PropertyType.DATE,\n    'PROPERTY_TYPE_LOCAL_DATETIME': PropertyType.LOCAL_DATETIME,\n    'PROPERTY_TYPE_ZONED_DATETIME': PropertyType.ZONED_DATETIME,\n    'PROPERTY_TYPE_LOCAL_TIME': PropertyType.LOCAL_TIME,\n    'PROPERTY_TYPE_ZONED_TIME': PropertyType.ZONED_TIME,\n    'PROPERTY_TYPE_YEAR_TO_MONTH': PropertyType.YEAR_TO_MONTH,\n    'PROPERTY_TYPE_DAY_TO_SECOND': PropertyType.DAY_TO_SECOND,\n    'PROPERTY_TYPE_DECIMAL': PropertyType.DECIMAL,\n    'PROPERTY_TYPE_POINT': PropertyType.POINT,\n    'PROPERTY_TYPE_POINT3D': PropertyType.POINT3D,\n    'PROPERTY_TYPE_VECTOR': PropertyType.VECTOR,\n    'PROPERTY_TYPE_LIST': PropertyType.LIST,\n    'PROPERTY_TYPE_SET': PropertyType.SET,\n    'PROPERTY_TYPE_MAP': PropertyType.MAP,\n    'PROPERTY_TYPE_NODE': PropertyType.NODE,\n    'PROPERTY_TYPE_EDGE': PropertyType.EDGE,\n    'PROPERTY_TYPE_PATH': PropertyType.PATH,\n    'PROPERTY_TYPE_RECORD': PropertyType.RECORD,\n    'PROPERTY_TYPE_TABLE': PropertyType.TABLE,\n    'PROPERTY_TYPE_ERROR': PropertyType.ERROR,\n  };\n  return typeMap[protoType] ?? PropertyType.NULL;\n}\n\n/**\n * Convert gRPC TypedValue to JS value.\n * Uses the same decoding logic as typedValueToJS for consistency.\n */\nexport function convertTypedValue(tv: any): any {\n  if (!tv || tv.is_null || tv.isNull) return null;\n\n  const data = tv.data;\n  const protoType = tv.type;\n\n  // Handle null types (both string and numeric enum values)\n  if (protoType === 'PROPERTY_TYPE_NULL' || protoType === 'PROPERTY_TYPE_UNSET' ||\n      protoType === PropertyType.NULL || protoType === PropertyType.UNSET) {\n    return null;\n  }\n\n  // Handle empty data - but STRING type with empty data should return \"\"\n  if (!data || data.length === 0) {\n    const isStringType = protoType === 'PROPERTY_TYPE_STRING' || protoType === 'PROPERTY_TYPE_TEXT' ||\n                         protoType === PropertyType.STRING || protoType === PropertyType.TEXT;\n    const isBlobType = protoType === 'PROPERTY_TYPE_BLOB' || protoType === PropertyType.BLOB;\n\n    if (isStringType) {\n      return '';\n    }\n    if (isBlobType) {\n      return Buffer.alloc(0);\n    }\n    return null;\n  }\n\n  const buf = Buffer.from(data);\n  const enumType = protoTypeToEnum(protoType);\n\n  // Use typedValueToJS for consistent decoding\n  return typedValueToJS({ type: enumType, data: buf, isNull: false });\n}\n\n/**\n * Convert proto properties map to JS object.\n */\nexport function convertProtoProperties(protoProps: Record<string, any>): Record<string, any> {\n  const result: Record<string, any> = {};\n  for (const [key, tv] of Object.entries(protoProps)) {\n    result[key] = convertTypedValue(tv);\n  }\n  return result;\n}\n\n/**\n * Convert GraphInfo from proto to JS object.\n */\nexport function convertGraphInfo(g: any): GraphInfo {\n  return {\n    name: g.name || '',\n    graphType: protoToGraphType(g.graph_type),\n    nodeCount: parseInt(g.node_count || '0', 10),\n    edgeCount: parseInt(g.edge_count || '0', 10),\n    description: g.description || '',\n  };\n}\n\n/**\n * Map GraphType enum to proto string.\n */\nexport function graphTypeToProto(graphType: GraphType): string {\n  switch (graphType) {\n    case GraphType.OPEN:\n      return 'GRAPH_TYPE_OPEN';\n    case GraphType.CLOSED:\n      return 'GRAPH_TYPE_CLOSED';\n    case GraphType.ONTOLOGY:\n      return 'GRAPH_TYPE_ONTOLOGY';\n    default:\n      return 'GRAPH_TYPE_OPEN';\n  }\n}\n\n/**\n * Map proto string to GraphType enum.\n */\nexport function protoToGraphType(proto: string): GraphType {\n  switch (proto) {\n    case 'GRAPH_TYPE_CLOSED':\n      return GraphType.CLOSED;\n    case 'GRAPH_TYPE_ONTOLOGY':\n      return GraphType.ONTOLOGY;\n    default:\n      return GraphType.OPEN;\n  }\n}\n\n/**\n * Map proto HealthStatus to enum.\n */\nexport function protoToHealthStatus(proto: string): HealthStatus {\n  switch (proto) {\n    case 'HEALTH_STATUS_SERVING':\n      return HealthStatus.SERVING;\n    case 'HEALTH_STATUS_NOT_SERVING':\n      return HealthStatus.NOT_SERVING;\n    case 'HEALTH_STATUS_SERVICE_UNKNOWN':\n      return HealthStatus.SERVICE_UNKNOWN;\n    default:\n      return HealthStatus.UNKNOWN;\n  }\n}\n\n/**\n * Map CacheType to proto string.\n */\nexport function cacheTypeToProto(cacheType: CacheType): string {\n  switch (cacheType) {\n    case CacheType.AST:\n      return 'CACHE_TYPE_AST';\n    case CacheType.PLAN:\n      return 'CACHE_TYPE_PLAN';\n    default:\n      return 'CACHE_TYPE_ALL';\n  }\n}\n\n/**\n * Convert NodeData to proto format.\n */\nexport function nodeDataToProto(node: any): any {\n  const properties: Record<string, any> = {};\n  if (node.properties) {\n    for (const [key, value] of Object.entries(node.properties)) {\n      properties[key] = createTypedValue(value);\n    }\n  }\n  return {\n    id: node.id || '',\n    labels: node.labels || [],\n    properties,\n  };\n}\n\n/**\n * Convert EdgeData to proto format.\n */\nexport function edgeDataToProto(edge: any): any {\n  const properties: Record<string, any> = {};\n  if (edge.properties) {\n    for (const [key, value] of Object.entries(edge.properties)) {\n      properties[key] = createTypedValue(value);\n    }\n  }\n  return {\n    label: edge.label || '',\n    from_node_id: edge.fromNodeId || '',\n    to_node_id: edge.toNodeId || '',\n    properties,\n  };\n}\n"]}

package/dist/services/data-service.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Data service handles node and edge insert/delete/export operations.
+ */
+import { ServiceContext } from './service-context';
+import { InsertNodesResult, InsertEdgesResult, DeleteResult, ExportNodesResult, ExportEdgesResult, ExportConfig, ExportChunk } from '../response';
+import { NodeData, EdgeData } from '../types';
+import { InsertNodesConfig, InsertEdgesConfig } from '../client';
+/**
+ * Data service for inserting, deleting, and exporting graph data.
+ */
+export declare class DataService {
+    private ctx;
+    constructor(ctx: ServiceContext);
+    /**
+     * Insert multiple nodes into a graph.
+     */
+    insertNodes(graphName: string, nodes: NodeData[], config?: InsertNodesConfig): Promise<InsertNodesResult>;
+    /**
+     * Insert multiple edges into a graph.
+     */
+    insertEdges(graphName: string, edges: EdgeData[], config?: InsertEdgesConfig): Promise<InsertEdgesResult>;
+    /**
+     * Delete nodes from a graph.
+     */
+    deleteNodes(graphName: string, nodeIds?: string[], labels?: string[], where?: string): Promise<DeleteResult>;
+    /**
+     * Delete edges from a graph.
+     */
+    deleteEdges(graphName: string, edgeIds?: string[], label?: string, where?: string): Promise<DeleteResult>;
+    /**
+     * Export graph data in JSON Lines format (streaming).
+     */
+    export(config: ExportConfig, callback?: (chunk: ExportChunk) => void): Promise<void>;
+    /**
+     * Stream nodes from a graph.
+     * @deprecated Use export() with ExportConfig instead
+     */
+    exportNodes(graphName: string, labels?: string[], limit?: number, callback?: (result: ExportNodesResult) => void): Promise<void>;
+    /**
+     * Stream edges from a graph.
+     * @deprecated Use export() with ExportConfig instead
+     */
+    exportEdges(graphName: string, labels?: string[], limit?: number, callback?: (result: ExportEdgesResult) => void): Promise<void>;
+}

package/dist/services/data-service.js

@@ -0,0 +1,206 @@
+"use strict";
+/**
+ * Data service handles node and edge insert/delete/export operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataService = void 0;
+const services_1 = require("../services");
+const converters_1 = require("./converters");
+/**
+ * Data service for inserting, deleting, and exporting graph data.
+ */
+class DataService {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /**
+     * Insert multiple nodes into a graph.
+     */
+    async insertNodes(graphName, nodes, config) {
+        const request = {
+            graph_name: graphName,
+            nodes: nodes.map((n) => (0, converters_1.nodeDataToProto)(n)),
+        };
+        // ALWAYS set options (even when undefined) to avoid deprecated bulk operations error
+        request.options = { overwrite: config?.options?.overwrite || false };
+        if (config?.bulkImportSessionId) {
+            request.bulk_import_session_id = config.bulkImportSessionId;
+        }
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.dataService, 'InsertNodes', request, metadata);
+        return {
+            success: response.success || false,
+            nodeIds: response.node_ids || [],
+            nodeCount: parseInt(response.node_count || '0', 10),
+            message: response.message || '',
+        };
+    }
+    /**
+     * Insert multiple edges into a graph.
+     */
+    async insertEdges(graphName, edges, config) {
+        const request = {
+            graph_name: graphName,
+            edges: edges.map((e) => (0, converters_1.edgeDataToProto)(e)),
+        };
+        // ALWAYS set options (even when undefined) to avoid deprecated bulk operations error
+        request.options = {
+            skip_invalid_nodes: config?.options?.skipInvalidNodes || false,
+        };
+        if (config?.bulkImportSessionId) {
+            request.bulk_import_session_id = config.bulkImportSessionId;
+        }
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.dataService, 'InsertEdges', request, metadata);
+        return {
+            success: response.success || false,
+            edgeIds: response.edge_ids || [],
+            edgeCount: parseInt(response.edge_count || '0', 10),
+            message: response.message || '',
+            skippedCount: parseInt(response.skipped_count || '0', 10),
+        };
+    }
+    /**
+     * Delete nodes from a graph.
+     */
+    async deleteNodes(graphName, nodeIds, labels, where) {
+        const request = {
+            graph_name: graphName,
+            node_ids: nodeIds || [],
+            labels: labels || [],
+            where: where || '',
+        };
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.dataService, 'DeleteNodes', request, metadata);
+        return {
+            success: response.success || false,
+            deletedCount: parseInt(response.deleted_count || '0', 10),
+            message: response.message || '',
+        };
+    }
+    /**
+     * Delete edges from a graph.
+     */
+    async deleteEdges(graphName, edgeIds, label, where) {
+        const request = {
+            graph_name: graphName,
+            edge_ids: edgeIds || [],
+            label: label || '',
+            where: where || '',
+        };
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.dataService, 'DeleteEdges', request, metadata);
+        return {
+            success: response.success || false,
+            deletedCount: parseInt(response.deleted_count || '0', 10),
+            message: response.message || '',
+        };
+    }
+    /**
+     * Export graph data in JSON Lines format (streaming).
+     */
+    async export(config, callback) {
+        const request = {
+            graph_name: config.graphName,
+            batch_size: config.batchSize || 0,
+            export_nodes: config.exportNodes !== false,
+            export_edges: config.exportEdges !== false,
+            node_labels: config.nodeLabels || [],
+            edge_labels: config.edgeLabels || [],
+            include_metadata: config.includeMetadata || false,
+        };
+        const metadata = this.ctx.getSessionMetadata();
+        return new Promise((resolve, reject) => {
+            const stream = this.ctx.clients.dataService.Export(request, metadata);
+            stream.on('data', (response) => {
+                if (callback) {
+                    let stats;
+                    if (response.stats) {
+                        stats = {
+                            nodesExported: parseInt(response.stats.nodes_exported || '0', 10),
+                            edgesExported: parseInt(response.stats.edges_exported || '0', 10),
+                            bytesWritten: parseInt(response.stats.bytes_written || '0', 10),
+                            durationMs: parseInt(response.stats.duration_ms || '0', 10),
+                        };
+                    }
+                    const chunk = {
+                        data: Buffer.from(response.data || []),
+                        isFinal: response.is_final || false,
+                        stats,
+                    };
+                    callback(chunk);
+                }
+                if (response.is_final) {
+                    stream.cancel();
+                }
+            });
+            stream.on('end', () => resolve());
+            stream.on('error', (error) => reject(error));
+        });
+    }
+    /**
+     * Stream nodes from a graph.
+     * @deprecated Use export() with ExportConfig instead
+     */
+    async exportNodes(graphName, labels, limit = 0, callback) {
+        console.warn('exportNodes is deprecated, use export() with ExportConfig instead');
+        const request = {
+            graph_name: graphName,
+            labels: labels || [],
+            limit: limit.toString(),
+        };
+        const metadata = this.ctx.getSessionMetadata();
+        return new Promise((resolve, reject) => {
+            const stream = this.ctx.clients.dataService.ExportNodes(request, metadata);
+            stream.on('data', (response) => {
+                if (callback) {
+                    callback({
+                        nodes: (response.nodes || []).map((n) => ({
+                            id: n.id || '',
+                            labels: n.labels || [],
+                            properties: (0, converters_1.convertProtoProperties)(n.properties || {}),
+                        })),
+                        hasMore: response.has_more || false,
+                    });
+                }
+            });
+            stream.on('end', () => resolve());
+            stream.on('error', (error) => reject(error));
+        });
+    }
+    /**
+     * Stream edges from a graph.
+     * @deprecated Use export() with ExportConfig instead
+     */
+    async exportEdges(graphName, labels, limit = 0, callback) {
+        console.warn('exportEdges is deprecated, use export() with ExportConfig instead');
+        const request = {
+            graph_name: graphName,
+            labels: labels || [],
+            limit: limit.toString(),
+        };
+        const metadata = this.ctx.getSessionMetadata();
+        return new Promise((resolve, reject) => {
+            const stream = this.ctx.clients.dataService.ExportEdges(request, metadata);
+            stream.on('data', (response) => {
+                if (callback) {
+                    callback({
+                        edges: (response.edges || []).map((e) => ({
+                            id: e.id || '',
+                            label: e.label || '',
+                            fromNodeId: e.from_node_id || '',
+                            toNodeId: e.to_node_id || '',
+                            properties: (0, converters_1.convertProtoProperties)(e.properties || {}),
+                        })),
+                        hasMore: response.has_more || false,
+                    });
+                }
+            });
+            stream.on('end', () => resolve());
+            stream.on('error', (error) => reject(error));
+        });
+    }
+}
+exports.DataService = DataService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-service.js","sourceRoot":"","sources":["../../src/services/data-service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Data service handles node and edge insert/delete/export operations.\n */\n\nimport { ServiceContext } from './service-context';\nimport {\n  InsertNodesResult,\n  InsertEdgesResult,\n  DeleteResult,\n  ExportNodesResult,\n  ExportEdgesResult,\n  ExportConfig,\n  ExportChunk,\n  ExportStats,\n} from '../response';\nimport { NodeData, EdgeData } from '../types';\nimport { promisifyCall } from '../services';\nimport { nodeDataToProto, edgeDataToProto, convertProtoProperties } from './converters';\nimport { InsertNodesConfig, InsertEdgesConfig } from '../client';\n\n/**\n * Data service for inserting, deleting, and exporting graph data.\n */\nexport class DataService {\n  constructor(private ctx: ServiceContext) {}\n\n  /**\n   * Insert multiple nodes into a graph.\n   */\n  async insertNodes(\n    graphName: string,\n    nodes: NodeData[],\n    config?: InsertNodesConfig\n  ): Promise<InsertNodesResult> {\n    const request: any = {\n      graph_name: graphName,\n      nodes: nodes.map((n) => nodeDataToProto(n)),\n    };\n\n    // ALWAYS set options (even when undefined) to avoid deprecated bulk operations error\n    request.options = { overwrite: config?.options?.overwrite || false };\n\n    if (config?.bulkImportSessionId) {\n      request.bulk_import_session_id = config.bulkImportSessionId;\n    }\n\n    const metadata = this.ctx.getSessionMetadata();\n    const response: any = await promisifyCall(\n      this.ctx.clients.dataService,\n      'InsertNodes',\n      request,\n      metadata\n    );\n\n    return {\n      success: response.success || false,\n      nodeIds: response.node_ids || [],\n      nodeCount: parseInt(response.node_count || '0', 10),\n      message: response.message || '',\n    };\n  }\n\n  /**\n   * Insert multiple edges into a graph.\n   */\n  async insertEdges(\n    graphName: string,\n    edges: EdgeData[],\n    config?: InsertEdgesConfig\n  ): Promise<InsertEdgesResult> {\n    const request: any = {\n      graph_name: graphName,\n      edges: edges.map((e) => edgeDataToProto(e)),\n    };\n\n    // ALWAYS set options (even when undefined) to avoid deprecated bulk operations error\n    request.options = {\n      skip_invalid_nodes: config?.options?.skipInvalidNodes || false,\n    };\n\n    if (config?.bulkImportSessionId) {\n      request.bulk_import_session_id = config.bulkImportSessionId;\n    }\n\n    const metadata = this.ctx.getSessionMetadata();\n    const response: any = await promisifyCall(\n      this.ctx.clients.dataService,\n      'InsertEdges',\n      request,\n      metadata\n    );\n\n    return {\n      success: response.success || false,\n      edgeIds: response.edge_ids || [],\n      edgeCount: parseInt(response.edge_count || '0', 10),\n      message: response.message || '',\n      skippedCount: parseInt(response.skipped_count || '0', 10),\n    };\n  }\n\n  /**\n   * Delete nodes from a graph.\n   */\n  async deleteNodes(\n    graphName: string,\n    nodeIds?: string[],\n    labels?: string[],\n    where?: string\n  ): Promise<DeleteResult> {\n    const request = {\n      graph_name: graphName,\n      node_ids: nodeIds || [],\n      labels: labels || [],\n      where: where || '',\n    };\n\n    const metadata = this.ctx.getSessionMetadata();\n    const response: any = await promisifyCall(\n      this.ctx.clients.dataService,\n      'DeleteNodes',\n      request,\n      metadata\n    );\n\n    return {\n      success: response.success || false,\n      deletedCount: parseInt(response.deleted_count || '0', 10),\n      message: response.message || '',\n    };\n  }\n\n  /**\n   * Delete edges from a graph.\n   */\n  async deleteEdges(\n    graphName: string,\n    edgeIds?: string[],\n    label?: string,\n    where?: string\n  ): Promise<DeleteResult> {\n    const request = {\n      graph_name: graphName,\n      edge_ids: edgeIds || [],\n      label: label || '',\n      where: where || '',\n    };\n\n    const metadata = this.ctx.getSessionMetadata();\n    const response: any = await promisifyCall(\n      this.ctx.clients.dataService,\n      'DeleteEdges',\n      request,\n      metadata\n    );\n\n    return {\n      success: response.success || false,\n      deletedCount: parseInt(response.deleted_count || '0', 10),\n      message: response.message || '',\n    };\n  }\n\n  /**\n   * Export graph data in JSON Lines format (streaming).\n   */\n  async export(\n    config: ExportConfig,\n    callback?: (chunk: ExportChunk) => void\n  ): Promise<void> {\n    const request = {\n      graph_name: config.graphName,\n      batch_size: config.batchSize || 0,\n      export_nodes: config.exportNodes !== false,\n      export_edges: config.exportEdges !== false,\n      node_labels: config.nodeLabels || [],\n      edge_labels: config.edgeLabels || [],\n      include_metadata: config.includeMetadata || false,\n    };\n\n    const metadata = this.ctx.getSessionMetadata();\n\n    return new Promise((resolve, reject) => {\n      const stream = (this.ctx.clients.dataService as any).Export(request, metadata);\n\n      stream.on('data', (response: any) => {\n        if (callback) {\n          let stats: ExportStats | undefined;\n          if (response.stats) {\n            stats = {\n              nodesExported: parseInt(response.stats.nodes_exported || '0', 10),\n              edgesExported: parseInt(response.stats.edges_exported || '0', 10),\n              bytesWritten: parseInt(response.stats.bytes_written || '0', 10),\n              durationMs: parseInt(response.stats.duration_ms || '0', 10),\n            };\n          }\n\n          const chunk: ExportChunk = {\n            data: Buffer.from(response.data || []),\n            isFinal: response.is_final || false,\n            stats,\n          };\n\n          callback(chunk);\n        }\n\n        if (response.is_final) {\n          stream.cancel();\n        }\n      });\n\n      stream.on('end', () => resolve());\n      stream.on('error', (error: any) => reject(error));\n    });\n  }\n\n  /**\n   * Stream nodes from a graph.\n   * @deprecated Use export() with ExportConfig instead\n   */\n  async exportNodes(\n    graphName: string,\n    labels?: string[],\n    limit: number = 0,\n    callback?: (result: ExportNodesResult) => void\n  ): Promise<void> {\n    console.warn('exportNodes is deprecated, use export() with ExportConfig instead');\n\n    const request = {\n      graph_name: graphName,\n      labels: labels || [],\n      limit: limit.toString(),\n    };\n\n    const metadata = this.ctx.getSessionMetadata();\n\n    return new Promise((resolve, reject) => {\n      const stream = (this.ctx.clients.dataService as any).ExportNodes(request, metadata);\n\n      stream.on('data', (response: any) => {\n        if (callback) {\n          callback({\n            nodes: (response.nodes || []).map((n: any) => ({\n              id: n.id || '',\n              labels: n.labels || [],\n              properties: convertProtoProperties(n.properties || {}),\n            })),\n            hasMore: response.has_more || false,\n          });\n        }\n      });\n\n      stream.on('end', () => resolve());\n      stream.on('error', (error: any) => reject(error));\n    });\n  }\n\n  /**\n   * Stream edges from a graph.\n   * @deprecated Use export() with ExportConfig instead\n   */\n  async exportEdges(\n    graphName: string,\n    labels?: string[],\n    limit: number = 0,\n    callback?: (result: ExportEdgesResult) => void\n  ): Promise<void> {\n    console.warn('exportEdges is deprecated, use export() with ExportConfig instead');\n\n    const request = {\n      graph_name: graphName,\n      labels: labels || [],\n      limit: limit.toString(),\n    };\n\n    const metadata = this.ctx.getSessionMetadata();\n\n    return new Promise((resolve, reject) => {\n      const stream = (this.ctx.clients.dataService as any).ExportEdges(request, metadata);\n\n      stream.on('data', (response: any) => {\n        if (callback) {\n          callback({\n            edges: (response.edges || []).map((e: any) => ({\n              id: e.id || '',\n              label: e.label || '',\n              fromNodeId: e.from_node_id || '',\n              toNodeId: e.to_node_id || '',\n              properties: convertProtoProperties(e.properties || {}),\n            })),\n            hasMore: response.has_more || false,\n          });\n        }\n      });\n\n      stream.on('end', () => resolve());\n      stream.on('error', (error: any) => reject(error));\n    });\n  }\n}\n"]}

package/dist/services/graph-service.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Graph service handles graph management operations.
+ */
+import { ServiceContext } from './service-context';
+import { GraphInfo, GraphType } from '../types';
+/**
+ * Graph service for managing graphs.
+ */
+export declare class GraphService {
+    private ctx;
+    constructor(ctx: ServiceContext);
+    /**
+     * Create a new graph.
+     */
+    createGraph(name: string, graphType?: GraphType, description?: string): Promise<void>;
+    /**
+     * Delete a graph.
+     */
+    dropGraph(name: string, ifExists?: boolean): Promise<void>;
+    /**
+     * Set the current graph for the session.
+     */
+    useGraph(name: string): Promise<void>;
+    /**
+     * Return all available graphs.
+     */
+    listGraphs(): Promise<GraphInfo[]>;
+    /**
+     * Return information about a specific graph.
+     */
+    getGraphInfo(name: string): Promise<GraphInfo>;
+}