ultipa 6.0.0

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":["/**\r\n * Type conversion utilities between gRPC proto types and JavaScript types.\r\n */\r\n\r\nimport { Response, Row } from '../response';\r\nimport {\r\n  GraphType,\r\n  HealthStatus,\r\n  CacheType,\r\n  GraphInfo,\r\n  createTypedValue,\r\n  PropertyType,\r\n  typedValueToJS,\r\n} from '../types';\r\nimport { GqldbConfig } from '../config';\r\nimport { Session } from '../session';\r\nimport { QueryConfig } from '../client';\r\n\r\n/**\r\n * Build a GQL request from config.\r\n */\r\nexport function buildGqlRequest(\r\n  query: string,\r\n  session: Session | null,\r\n  config: GqldbConfig,\r\n  queryConfig?: QueryConfig\r\n): any {\r\n  return {\r\n    gql: query,\r\n    graph_name: queryConfig?.graphName || session?.defaultGraph || config.defaultGraph || '',\r\n    parameters: buildParameters(queryConfig?.parameters),\r\n    session_id: session?.id?.toString() || '0',\r\n    transaction_id: queryConfig?.transactionId?.toString() || '0',\r\n    timeout: Math.floor((queryConfig?.timeout || config.timeout || 30000) / 1000), // Convert ms to seconds for gRPC\r\n    read_only: queryConfig?.readOnly || false,\r\n    max_path_results: queryConfig?.maxPathResults || 0,\r\n  };\r\n}\r\n\r\n/**\r\n * Build parameters array for gRPC.\r\n */\r\nexport function buildParameters(params?: Record<string, any>): any[] {\r\n  if (!params) return [];\r\n  return Object.entries(params).map(([name, value]) => ({\r\n    name,\r\n    value: createTypedValue(value),\r\n  }));\r\n}\r\n\r\n/**\r\n * Convert gRPC response to Response object.\r\n */\r\nexport function convertGqlResponse(grpcResponse: any): Response {\r\n  const columns = grpcResponse.columns || [];\r\n  const rows: Row[] = (grpcResponse.rows || []).map((row: any) => {\r\n    const rawValues = row.values || [];\r\n    const values = rawValues.map((tv: any) => convertTypedValue(tv));\r\n    const types = rawValues.map((tv: any) => protoTypeToEnum(tv?.type));\r\n    return new Row(values, types);\r\n  });\r\n  return new Response(\r\n    columns,\r\n    rows,\r\n    parseInt(grpcResponse.row_count || '0', 10),\r\n    grpcResponse.has_more || false,\r\n    grpcResponse.warnings || [],\r\n    parseInt(grpcResponse.rows_affected || '0', 10)\r\n  );\r\n}\r\n\r\n/**\r\n * Map proto type string or number to PropertyType enum.\r\n * Handles both string enum names (e.g., 'PROPERTY_TYPE_STRING') and numeric values.\r\n */\r\nfunction protoTypeToEnum(protoType: string | number): PropertyType {\r\n  // Handle numeric enum values directly\r\n  if (typeof protoType === 'number') {\r\n    // If it's already a valid PropertyType number, return it directly\r\n    // PropertyType ranges from UNSET(0) to EDGE(33)\r\n    if (protoType >= PropertyType.UNSET && protoType <= PropertyType.EDGE) {\r\n      return protoType as PropertyType;\r\n    }\r\n    return PropertyType.NULL;\r\n  }\r\n\r\n  const typeMap: Record<string, PropertyType> = {\r\n    'PROPERTY_TYPE_NULL': PropertyType.NULL,\r\n    'PROPERTY_TYPE_UNSET': PropertyType.UNSET,\r\n    'PROPERTY_TYPE_BOOL': PropertyType.BOOL,\r\n    'PROPERTY_TYPE_INT32': PropertyType.INT32,\r\n    'PROPERTY_TYPE_UINT32': PropertyType.UINT32,\r\n    'PROPERTY_TYPE_INT64': PropertyType.INT64,\r\n    'PROPERTY_TYPE_UINT64': PropertyType.UINT64,\r\n    'PROPERTY_TYPE_FLOAT': PropertyType.FLOAT,\r\n    'PROPERTY_TYPE_DOUBLE': PropertyType.DOUBLE,\r\n    'PROPERTY_TYPE_STRING': PropertyType.STRING,\r\n    'PROPERTY_TYPE_TEXT': PropertyType.TEXT,\r\n    'PROPERTY_TYPE_BLOB': PropertyType.BLOB,\r\n    'PROPERTY_TYPE_TIMESTAMP': PropertyType.TIMESTAMP,\r\n    'PROPERTY_TYPE_DATETIME': PropertyType.DATETIME,\r\n    'PROPERTY_TYPE_DATE': PropertyType.DATE,\r\n    'PROPERTY_TYPE_LOCAL_DATETIME': PropertyType.LOCAL_DATETIME,\r\n    'PROPERTY_TYPE_ZONED_DATETIME': PropertyType.ZONED_DATETIME,\r\n    'PROPERTY_TYPE_LOCAL_TIME': PropertyType.LOCAL_TIME,\r\n    'PROPERTY_TYPE_ZONED_TIME': PropertyType.ZONED_TIME,\r\n    'PROPERTY_TYPE_YEAR_TO_MONTH': PropertyType.YEAR_TO_MONTH,\r\n    'PROPERTY_TYPE_DAY_TO_SECOND': PropertyType.DAY_TO_SECOND,\r\n    'PROPERTY_TYPE_DECIMAL': PropertyType.DECIMAL,\r\n    'PROPERTY_TYPE_POINT': PropertyType.POINT,\r\n    'PROPERTY_TYPE_POINT3D': PropertyType.POINT3D,\r\n    'PROPERTY_TYPE_VECTOR': PropertyType.VECTOR,\r\n    'PROPERTY_TYPE_LIST': PropertyType.LIST,\r\n    'PROPERTY_TYPE_SET': PropertyType.SET,\r\n    'PROPERTY_TYPE_MAP': PropertyType.MAP,\r\n    'PROPERTY_TYPE_NODE': PropertyType.NODE,\r\n    'PROPERTY_TYPE_EDGE': PropertyType.EDGE,\r\n    'PROPERTY_TYPE_PATH': PropertyType.PATH,\r\n    'PROPERTY_TYPE_RECORD': PropertyType.RECORD,\r\n    'PROPERTY_TYPE_TABLE': PropertyType.TABLE,\r\n    'PROPERTY_TYPE_ERROR': PropertyType.ERROR,\r\n  };\r\n  return typeMap[protoType] ?? PropertyType.NULL;\r\n}\r\n\r\n/**\r\n * Convert gRPC TypedValue to JS value.\r\n * Uses the same decoding logic as typedValueToJS for consistency.\r\n */\r\nexport function convertTypedValue(tv: any): any {\r\n  if (!tv || tv.is_null || tv.isNull) return null;\r\n\r\n  const data = tv.data;\r\n  const protoType = tv.type;\r\n\r\n  // Handle null types (both string and numeric enum values)\r\n  if (protoType === 'PROPERTY_TYPE_NULL' || protoType === 'PROPERTY_TYPE_UNSET' ||\r\n      protoType === PropertyType.NULL || protoType === PropertyType.UNSET) {\r\n    return null;\r\n  }\r\n\r\n  // Handle empty data - but STRING type with empty data should return \"\"\r\n  if (!data || data.length === 0) {\r\n    const isStringType = protoType === 'PROPERTY_TYPE_STRING' || protoType === 'PROPERTY_TYPE_TEXT' ||\r\n                         protoType === PropertyType.STRING || protoType === PropertyType.TEXT;\r\n    const isBlobType = protoType === 'PROPERTY_TYPE_BLOB' || protoType === PropertyType.BLOB;\r\n\r\n    if (isStringType) {\r\n      return '';\r\n    }\r\n    if (isBlobType) {\r\n      return Buffer.alloc(0);\r\n    }\r\n    return null;\r\n  }\r\n\r\n  const buf = Buffer.from(data);\r\n  const enumType = protoTypeToEnum(protoType);\r\n\r\n  // Use typedValueToJS for consistent decoding\r\n  return typedValueToJS({ type: enumType, data: buf, isNull: false });\r\n}\r\n\r\n/**\r\n * Convert proto properties map to JS object.\r\n */\r\nexport function convertProtoProperties(protoProps: Record<string, any>): Record<string, any> {\r\n  const result: Record<string, any> = {};\r\n  for (const [key, tv] of Object.entries(protoProps)) {\r\n    result[key] = convertTypedValue(tv);\r\n  }\r\n  return result;\r\n}\r\n\r\n/**\r\n * Convert GraphInfo from proto to JS object.\r\n */\r\nexport function convertGraphInfo(g: any): GraphInfo {\r\n  return {\r\n    name: g.name || '',\r\n    graphType: protoToGraphType(g.graph_type),\r\n    nodeCount: parseInt(g.node_count || '0', 10),\r\n    edgeCount: parseInt(g.edge_count || '0', 10),\r\n    description: g.description || '',\r\n  };\r\n}\r\n\r\n/**\r\n * Map GraphType enum to proto string.\r\n */\r\nexport function graphTypeToProto(graphType: GraphType): string {\r\n  switch (graphType) {\r\n    case GraphType.OPEN:\r\n      return 'GRAPH_TYPE_OPEN';\r\n    case GraphType.CLOSED:\r\n      return 'GRAPH_TYPE_CLOSED';\r\n    case GraphType.ONTOLOGY:\r\n      return 'GRAPH_TYPE_ONTOLOGY';\r\n    default:\r\n      return 'GRAPH_TYPE_OPEN';\r\n  }\r\n}\r\n\r\n/**\r\n * Map proto string to GraphType enum.\r\n */\r\nexport function protoToGraphType(proto: string): GraphType {\r\n  switch (proto) {\r\n    case 'GRAPH_TYPE_CLOSED':\r\n      return GraphType.CLOSED;\r\n    case 'GRAPH_TYPE_ONTOLOGY':\r\n      return GraphType.ONTOLOGY;\r\n    default:\r\n      return GraphType.OPEN;\r\n  }\r\n}\r\n\r\n/**\r\n * Map proto HealthStatus to enum.\r\n */\r\nexport function protoToHealthStatus(proto: string): HealthStatus {\r\n  switch (proto) {\r\n    case 'HEALTH_STATUS_SERVING':\r\n      return HealthStatus.SERVING;\r\n    case 'HEALTH_STATUS_NOT_SERVING':\r\n      return HealthStatus.NOT_SERVING;\r\n    case 'HEALTH_STATUS_SERVICE_UNKNOWN':\r\n      return HealthStatus.SERVICE_UNKNOWN;\r\n    default:\r\n      return HealthStatus.UNKNOWN;\r\n  }\r\n}\r\n\r\n/**\r\n * Map CacheType to proto string.\r\n */\r\nexport function cacheTypeToProto(cacheType: CacheType): string {\r\n  switch (cacheType) {\r\n    case CacheType.AST:\r\n      return 'CACHE_TYPE_AST';\r\n    case CacheType.PLAN:\r\n      return 'CACHE_TYPE_PLAN';\r\n    default:\r\n      return 'CACHE_TYPE_ALL';\r\n  }\r\n}\r\n\r\n/**\r\n * Convert NodeData to proto format.\r\n */\r\nexport function nodeDataToProto(node: any): any {\r\n  const properties: Record<string, any> = {};\r\n  if (node.properties) {\r\n    for (const [key, value] of Object.entries(node.properties)) {\r\n      properties[key] = createTypedValue(value);\r\n    }\r\n  }\r\n  return {\r\n    id: node.id || '',\r\n    labels: node.labels || [],\r\n    properties,\r\n  };\r\n}\r\n\r\n/**\r\n * Convert EdgeData to proto format.\r\n */\r\nexport function edgeDataToProto(edge: any): any {\r\n  const properties: Record<string, any> = {};\r\n  if (edge.properties) {\r\n    for (const [key, value] of Object.entries(edge.properties)) {\r\n      properties[key] = createTypedValue(value);\r\n    }\r\n  }\r\n  return {\r\n    label: edge.label || '',\r\n    from_node_id: edge.fromNodeId || '',\r\n    to_node_id: edge.toNodeId || '',\r\n    properties,\r\n  };\r\n}\r\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":";AAAA;;GAEG;;;AAcH,0CAA4C;AAC5C,6CAAwF;AAGxF;;GAEG;AACH,MAAa,WAAW;IACF;IAApB,YAAoB,GAAmB;QAAnB,QAAG,GAAH,GAAG,CAAgB;IAAG,CAAC;IAE3C;;OAEG;IACH,KAAK,CAAC,WAAW,CACf,SAAiB,EACjB,KAAiB,EACjB,MAA0B;QAE1B,MAAM,OAAO,GAAQ;YACnB,UAAU,EAAE,SAAS;YACrB,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAA,4BAAe,EAAC,CAAC,CAAC,CAAC;SAC5C,CAAC;QAEF,qFAAqF;QACrF,OAAO,CAAC,OAAO,GAAG,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,IAAI,KAAK,EAAE,CAAC;QAErE,IAAI,MAAM,EAAE,mBAAmB,EAAE,CAAC;YAChC,OAAO,CAAC,sBAAsB,GAAG,MAAM,CAAC,mBAAmB,CAAC;QAC9D,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,kBAAkB,EAAE,CAAC;QAC/C,MAAM,QAAQ,GAAQ,MAAM,IAAA,wBAAa,EACvC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,EAC5B,aAAa,EACb,OAAO,EACP,QAAQ,CACT,CAAC;QAEF,OAAO;YACL,OAAO,EAAE,QAAQ,CAAC,OAAO,IAAI,KAAK;YAClC,OAAO,EAAE,QAAQ,CAAC,QAAQ,IAAI,EAAE;YAChC,SAAS,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,IAAI,GAAG,EAAE,EAAE,CAAC;YACnD,OAAO,EAAE,QAAQ,CAAC,OAAO,IAAI,EAAE;SAChC,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,WAAW,CACf,SAAiB,EACjB,KAAiB,EACjB,MAA0B;QAE1B,MAAM,OAAO,GAAQ;YACnB,UAAU,EAAE,SAAS;YACrB,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAA,4BAAe,EAAC,CAAC,CAAC,CAAC;SAC5C,CAAC;QAEF,qFAAqF;QACrF,OAAO,CAAC,OAAO,GAAG;YAChB,kBAAkB,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,IAAI,KAAK;SAC/D,CAAC;QAEF,IAAI,MAAM,EAAE,mBAAmB,EAAE,CAAC;YAChC,OAAO,CAAC,sBAAsB,GAAG,MAAM,CAAC,mBAAmB,CAAC;QAC9D,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,kBAAkB,EAAE,CAAC;QAC/C,MAAM,QAAQ,GAAQ,MAAM,IAAA,wBAAa,EACvC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,EAC5B,aAAa,EACb,OAAO,EACP,QAAQ,CACT,CAAC;QAEF,OAAO;YACL,OAAO,EAAE,QAAQ,CAAC,OAAO,IAAI,KAAK;YAClC,OAAO,EAAE,QAAQ,CAAC,QAAQ,IAAI,EAAE;YAChC,SAAS,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,IAAI,GAAG,EAAE,EAAE,CAAC;YACnD,OAAO,EAAE,QAAQ,CAAC,OAAO,IAAI,EAAE;YAC/B,YAAY,EAAE,QAAQ,CAAC,QAAQ,CAAC,aAAa,IAAI,GAAG,EAAE,EAAE,CAAC;SAC1D,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,WAAW,CACf,SAAiB,EACjB,OAAkB,EAClB,MAAiB,EACjB,KAAc;QAEd,MAAM,OAAO,GAAG;YACd,UAAU,EAAE,SAAS;YACrB,QAAQ,EAAE,OAAO,IAAI,EAAE;YACvB,MAAM,EAAE,MAAM,IAAI,EAAE;YACpB,KAAK,EAAE,KAAK,IAAI,EAAE;SACnB,CAAC;QAEF,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,kBAAkB,EAAE,CAAC;QAC/C,MAAM,QAAQ,GAAQ,MAAM,IAAA,wBAAa,EACvC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,EAC5B,aAAa,EACb,OAAO,EACP,QAAQ,CACT,CAAC;QAEF,OAAO;YACL,OAAO,EAAE,QAAQ,CAAC,OAAO,IAAI,KAAK;YAClC,YAAY,EAAE,QAAQ,CAAC,QAAQ,CAAC,aAAa,IAAI,GAAG,EAAE,EAAE,CAAC;YACzD,OAAO,EAAE,QAAQ,CAAC,OAAO,IAAI,EAAE;SAChC,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,WAAW,CACf,SAAiB,EACjB,OAAkB,EAClB,KAAc,EACd,KAAc;QAEd,MAAM,OAAO,GAAG;YACd,UAAU,EAAE,SAAS;YACrB,QAAQ,EAAE,OAAO,IAAI,EAAE;YACvB,KAAK,EAAE,KAAK,IAAI,EAAE;YAClB,KAAK,EAAE,KAAK,IAAI,EAAE;SACnB,CAAC;QAEF,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,kBAAkB,EAAE,CAAC;QAC/C,MAAM,QAAQ,GAAQ,MAAM,IAAA,wBAAa,EACvC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,EAC5B,aAAa,EACb,OAAO,EACP,QAAQ,CACT,CAAC;QAEF,OAAO;YACL,OAAO,EAAE,QAAQ,CAAC,OAAO,IAAI,KAAK;YAClC,YAAY,EAAE,QAAQ,CAAC,QAAQ,CAAC,aAAa,IAAI,GAAG,EAAE,EAAE,CAAC;YACzD,OAAO,EAAE,QAAQ,CAAC,OAAO,IAAI,EAAE;SAChC,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CACV,MAAoB,EACpB,QAAuC;QAEvC,MAAM,OAAO,GAAG;YACd,UAAU,EAAE,MAAM,CAAC,SAAS;YAC5B,UAAU,EAAE,MAAM,CAAC,SAAS,IAAI,CAAC;YACjC,YAAY,EAAE,MAAM,CAAC,WAAW,KAAK,KAAK;YAC1C,YAAY,EAAE,MAAM,CAAC,WAAW,KAAK,KAAK;YAC1C,WAAW,EAAE,MAAM,CAAC,UAAU,IAAI,EAAE;YACpC,WAAW,EAAE,MAAM,CAAC,UAAU,IAAI,EAAE;YACpC,gBAAgB,EAAE,MAAM,CAAC,eAAe,IAAI,KAAK;SAClD,CAAC;QAEF,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,kBAAkB,EAAE,CAAC;QAE/C,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,MAAM,MAAM,GAAI,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,WAAmB,CAAC,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;YAE/E,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,QAAa,EAAE,EAAE;gBAClC,IAAI,QAAQ,EAAE,CAAC;oBACb,IAAI,KAA8B,CAAC;oBACnC,IAAI,QAAQ,CAAC,KAAK,EAAE,CAAC;wBACnB,KAAK,GAAG;4BACN,aAAa,EAAE,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,IAAI,GAAG,EAAE,EAAE,CAAC;4BACjE,aAAa,EAAE,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,IAAI,GAAG,EAAE,EAAE,CAAC;4BACjE,YAAY,EAAE,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,aAAa,IAAI,GAAG,EAAE,EAAE,CAAC;4BAC/D,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,IAAI,GAAG,EAAE,EAAE,CAAC;yBAC5D,CAAC;oBACJ,CAAC;oBAED,MAAM,KAAK,GAAgB;wBACzB,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE,CAAC;wBACtC,OAAO,EAAE,QAAQ,CAAC,QAAQ,IAAI,KAAK;wBACnC,KAAK;qBACN,CAAC;oBAEF,QAAQ,CAAC,KAAK,CAAC,CAAC;gBAClB,CAAC;gBAED,IAAI,QAAQ,CAAC,QAAQ,EAAE,CAAC;oBACtB,MAAM,CAAC,MAAM,EAAE,CAAC;gBAClB,CAAC;YACH,CAAC,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC;YAClC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAU,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,WAAW,CACf,SAAiB,EACjB,MAAiB,EACjB,QAAgB,CAAC,EACjB,QAA8C;QAE9C,OAAO,CAAC,IAAI,CAAC,mEAAmE,CAAC,CAAC;QAElF,MAAM,OAAO,GAAG;YACd,UAAU,EAAE,SAAS;YACrB,MAAM,EAAE,MAAM,IAAI,EAAE;YACpB,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE;SACxB,CAAC;QAEF,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,kBAAkB,EAAE,CAAC;QAE/C,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,MAAM,MAAM,GAAI,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,WAAmB,CAAC,WAAW,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;YAEpF,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,QAAa,EAAE,EAAE;gBAClC,IAAI,QAAQ,EAAE,CAAC;oBACb,QAAQ,CAAC;wBACP,KAAK,EAAE,CAAC,QAAQ,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC;4BAC7C,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE;4BACd,MAAM,EAAE,CAAC,CAAC,MAAM,IAAI,EAAE;4BACtB,UAAU,EAAE,IAAA,mCAAsB,EAAC,CAAC,CAAC,UAAU,IAAI,EAAE,CAAC;yBACvD,CAAC,CAAC;wBACH,OAAO,EAAE,QAAQ,CAAC,QAAQ,IAAI,KAAK;qBACpC,CAAC,CAAC;gBACL,CAAC;YACH,CAAC,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC;YAClC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAU,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,WAAW,CACf,SAAiB,EACjB,MAAiB,EACjB,QAAgB,CAAC,EACjB,QAA8C;QAE9C,OAAO,CAAC,IAAI,CAAC,mEAAmE,CAAC,CAAC;QAElF,MAAM,OAAO,GAAG;YACd,UAAU,EAAE,SAAS;YACrB,MAAM,EAAE,MAAM,IAAI,EAAE;YACpB,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE;SACxB,CAAC;QAEF,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,kBAAkB,EAAE,CAAC;QAE/C,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,MAAM,MAAM,GAAI,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,WAAmB,CAAC,WAAW,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;YAEpF,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,QAAa,EAAE,EAAE;gBAClC,IAAI,QAAQ,EAAE,CAAC;oBACb,QAAQ,CAAC;wBACP,KAAK,EAAE,CAAC,QAAQ,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC;4BAC7C,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE;4BACd,KAAK,EAAE,CAAC,CAAC,KAAK,IAAI,EAAE;4BACpB,UAAU,EAAE,CAAC,CAAC,YAAY,IAAI,EAAE;4BAChC,QAAQ,EAAE,CAAC,CAAC,UAAU,IAAI,EAAE;4BAC5B,UAAU,EAAE,IAAA,mCAAsB,EAAC,CAAC,CAAC,UAAU,IAAI,EAAE,CAAC;yBACvD,CAAC,CAAC;wBACH,OAAO,EAAE,QAAQ,CAAC,QAAQ,IAAI,KAAK;qBACpC,CAAC,CAAC;gBACL,CAAC;YACH,CAAC,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC;YAClC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAU,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AApRD,kCAoRC","sourcesContent":["/**\r\n * Data service handles node and edge insert/delete/export operations.\r\n */\r\n\r\nimport { ServiceContext } from './service-context';\r\nimport {\r\n  InsertNodesResult,\r\n  InsertEdgesResult,\r\n  DeleteResult,\r\n  ExportNodesResult,\r\n  ExportEdgesResult,\r\n  ExportConfig,\r\n  ExportChunk,\r\n  ExportStats,\r\n} from '../response';\r\nimport { NodeData, EdgeData } from '../types';\r\nimport { promisifyCall } from '../services';\r\nimport { nodeDataToProto, edgeDataToProto, convertProtoProperties } from './converters';\r\nimport { InsertNodesConfig, InsertEdgesConfig } from '../client';\r\n\r\n/**\r\n * Data service for inserting, deleting, and exporting graph data.\r\n */\r\nexport class DataService {\r\n  constructor(private ctx: ServiceContext) {}\r\n\r\n  /**\r\n   * Insert multiple nodes into a graph.\r\n   */\r\n  async insertNodes(\r\n    graphName: string,\r\n    nodes: NodeData[],\r\n    config?: InsertNodesConfig\r\n  ): Promise<InsertNodesResult> {\r\n    const request: any = {\r\n      graph_name: graphName,\r\n      nodes: nodes.map((n) => nodeDataToProto(n)),\r\n    };\r\n\r\n    // ALWAYS set options (even when undefined) to avoid deprecated bulk operations error\r\n    request.options = { overwrite: config?.options?.overwrite || false };\r\n\r\n    if (config?.bulkImportSessionId) {\r\n      request.bulk_import_session_id = config.bulkImportSessionId;\r\n    }\r\n\r\n    const metadata = this.ctx.getSessionMetadata();\r\n    const response: any = await promisifyCall(\r\n      this.ctx.clients.dataService,\r\n      'InsertNodes',\r\n      request,\r\n      metadata\r\n    );\r\n\r\n    return {\r\n      success: response.success || false,\r\n      nodeIds: response.node_ids || [],\r\n      nodeCount: parseInt(response.node_count || '0', 10),\r\n      message: response.message || '',\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Insert multiple edges into a graph.\r\n   */\r\n  async insertEdges(\r\n    graphName: string,\r\n    edges: EdgeData[],\r\n    config?: InsertEdgesConfig\r\n  ): Promise<InsertEdgesResult> {\r\n    const request: any = {\r\n      graph_name: graphName,\r\n      edges: edges.map((e) => edgeDataToProto(e)),\r\n    };\r\n\r\n    // ALWAYS set options (even when undefined) to avoid deprecated bulk operations error\r\n    request.options = {\r\n      skip_invalid_nodes: config?.options?.skipInvalidNodes || false,\r\n    };\r\n\r\n    if (config?.bulkImportSessionId) {\r\n      request.bulk_import_session_id = config.bulkImportSessionId;\r\n    }\r\n\r\n    const metadata = this.ctx.getSessionMetadata();\r\n    const response: any = await promisifyCall(\r\n      this.ctx.clients.dataService,\r\n      'InsertEdges',\r\n      request,\r\n      metadata\r\n    );\r\n\r\n    return {\r\n      success: response.success || false,\r\n      edgeIds: response.edge_ids || [],\r\n      edgeCount: parseInt(response.edge_count || '0', 10),\r\n      message: response.message || '',\r\n      skippedCount: parseInt(response.skipped_count || '0', 10),\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Delete nodes from a graph.\r\n   */\r\n  async deleteNodes(\r\n    graphName: string,\r\n    nodeIds?: string[],\r\n    labels?: string[],\r\n    where?: string\r\n  ): Promise<DeleteResult> {\r\n    const request = {\r\n      graph_name: graphName,\r\n      node_ids: nodeIds || [],\r\n      labels: labels || [],\r\n      where: where || '',\r\n    };\r\n\r\n    const metadata = this.ctx.getSessionMetadata();\r\n    const response: any = await promisifyCall(\r\n      this.ctx.clients.dataService,\r\n      'DeleteNodes',\r\n      request,\r\n      metadata\r\n    );\r\n\r\n    return {\r\n      success: response.success || false,\r\n      deletedCount: parseInt(response.deleted_count || '0', 10),\r\n      message: response.message || '',\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Delete edges from a graph.\r\n   */\r\n  async deleteEdges(\r\n    graphName: string,\r\n    edgeIds?: string[],\r\n    label?: string,\r\n    where?: string\r\n  ): Promise<DeleteResult> {\r\n    const request = {\r\n      graph_name: graphName,\r\n      edge_ids: edgeIds || [],\r\n      label: label || '',\r\n      where: where || '',\r\n    };\r\n\r\n    const metadata = this.ctx.getSessionMetadata();\r\n    const response: any = await promisifyCall(\r\n      this.ctx.clients.dataService,\r\n      'DeleteEdges',\r\n      request,\r\n      metadata\r\n    );\r\n\r\n    return {\r\n      success: response.success || false,\r\n      deletedCount: parseInt(response.deleted_count || '0', 10),\r\n      message: response.message || '',\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Export graph data in JSON Lines format (streaming).\r\n   */\r\n  async export(\r\n    config: ExportConfig,\r\n    callback?: (chunk: ExportChunk) => void\r\n  ): Promise<void> {\r\n    const request = {\r\n      graph_name: config.graphName,\r\n      batch_size: config.batchSize || 0,\r\n      export_nodes: config.exportNodes !== false,\r\n      export_edges: config.exportEdges !== false,\r\n      node_labels: config.nodeLabels || [],\r\n      edge_labels: config.edgeLabels || [],\r\n      include_metadata: config.includeMetadata || false,\r\n    };\r\n\r\n    const metadata = this.ctx.getSessionMetadata();\r\n\r\n    return new Promise((resolve, reject) => {\r\n      const stream = (this.ctx.clients.dataService as any).Export(request, metadata);\r\n\r\n      stream.on('data', (response: any) => {\r\n        if (callback) {\r\n          let stats: ExportStats | undefined;\r\n          if (response.stats) {\r\n            stats = {\r\n              nodesExported: parseInt(response.stats.nodes_exported || '0', 10),\r\n              edgesExported: parseInt(response.stats.edges_exported || '0', 10),\r\n              bytesWritten: parseInt(response.stats.bytes_written || '0', 10),\r\n              durationMs: parseInt(response.stats.duration_ms || '0', 10),\r\n            };\r\n          }\r\n\r\n          const chunk: ExportChunk = {\r\n            data: Buffer.from(response.data || []),\r\n            isFinal: response.is_final || false,\r\n            stats,\r\n          };\r\n\r\n          callback(chunk);\r\n        }\r\n\r\n        if (response.is_final) {\r\n          stream.cancel();\r\n        }\r\n      });\r\n\r\n      stream.on('end', () => resolve());\r\n      stream.on('error', (error: any) => reject(error));\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Stream nodes from a graph.\r\n   * @deprecated Use export() with ExportConfig instead\r\n   */\r\n  async exportNodes(\r\n    graphName: string,\r\n    labels?: string[],\r\n    limit: number = 0,\r\n    callback?: (result: ExportNodesResult) => void\r\n  ): Promise<void> {\r\n    console.warn('exportNodes is deprecated, use export() with ExportConfig instead');\r\n\r\n    const request = {\r\n      graph_name: graphName,\r\n      labels: labels || [],\r\n      limit: limit.toString(),\r\n    };\r\n\r\n    const metadata = this.ctx.getSessionMetadata();\r\n\r\n    return new Promise((resolve, reject) => {\r\n      const stream = (this.ctx.clients.dataService as any).ExportNodes(request, metadata);\r\n\r\n      stream.on('data', (response: any) => {\r\n        if (callback) {\r\n          callback({\r\n            nodes: (response.nodes || []).map((n: any) => ({\r\n              id: n.id || '',\r\n              labels: n.labels || [],\r\n              properties: convertProtoProperties(n.properties || {}),\r\n            })),\r\n            hasMore: response.has_more || false,\r\n          });\r\n        }\r\n      });\r\n\r\n      stream.on('end', () => resolve());\r\n      stream.on('error', (error: any) => reject(error));\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Stream edges from a graph.\r\n   * @deprecated Use export() with ExportConfig instead\r\n   */\r\n  async exportEdges(\r\n    graphName: string,\r\n    labels?: string[],\r\n    limit: number = 0,\r\n    callback?: (result: ExportEdgesResult) => void\r\n  ): Promise<void> {\r\n    console.warn('exportEdges is deprecated, use export() with ExportConfig instead');\r\n\r\n    const request = {\r\n      graph_name: graphName,\r\n      labels: labels || [],\r\n      limit: limit.toString(),\r\n    };\r\n\r\n    const metadata = this.ctx.getSessionMetadata();\r\n\r\n    return new Promise((resolve, reject) => {\r\n      const stream = (this.ctx.clients.dataService as any).ExportEdges(request, metadata);\r\n\r\n      stream.on('data', (response: any) => {\r\n        if (callback) {\r\n          callback({\r\n            edges: (response.edges || []).map((e: any) => ({\r\n              id: e.id || '',\r\n              label: e.label || '',\r\n              fromNodeId: e.from_node_id || '',\r\n              toNodeId: e.to_node_id || '',\r\n              properties: convertProtoProperties(e.properties || {}),\r\n            })),\r\n            hasMore: response.has_more || false,\r\n          });\r\n        }\r\n      });\r\n\r\n      stream.on('end', () => resolve());\r\n      stream.on('error', (error: any) => reject(error));\r\n    });\r\n  }\r\n}\r\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>;
+}