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

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

@@ -0,0 +1,44 @@
+/**
+ * Admin service handles administrative operations.
+ */
+import { ServiceContext } from './service-context';
+import { CacheStats, CacheType, Statistics, CompactResult, ComputeTopologyResult, SystemMetrics } from '../types';
+/**
+ * Admin service for administrative operations.
+ */
+export declare class AdminService {
+    private ctx;
+    constructor(ctx: ServiceContext);
+    /**
+     * Pre-allocate parser instances.
+     */
+    warmupParser(count: number): Promise<void>;
+    /**
+     * Return cache statistics.
+     */
+    getCacheStats(cacheType?: CacheType): Promise<CacheStats>;
+    /**
+     * Clear the specified cache.
+     */
+    clearCache(cacheType?: CacheType): Promise<void>;
+    /**
+     * Return database statistics.
+     */
+    getStatistics(graphName?: string): Promise<Statistics>;
+    /**
+     * Invalidate the RBAC permission cache.
+     */
+    invalidatePermissionCache(username?: string): Promise<void>;
+    /**
+     * Trigger manual compaction of the database storage.
+     */
+    compact(): Promise<CompactResult>;
+    /**
+     * Return system-level metrics (CPU, memory, disk I/O, storage, network).
+     */
+    getSystemMetrics(): Promise<SystemMetrics>;
+    /**
+     * Wait for the computing engine topology to be ready.
+     */
+    waitForComputeTopology(graphName: string, timeoutMs?: number): Promise<ComputeTopologyResult>;
+}

package/dist/services/admin-service.js

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * Admin service handles administrative operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminService = void 0;
+const types_1 = require("../types");
+const services_1 = require("../services");
+const converters_1 = require("./converters");
+/**
+ * Admin service for administrative operations.
+ */
+class AdminService {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /**
+     * Pre-allocate parser instances.
+     */
+    async warmupParser(count) {
+        const metadata = this.ctx.getSessionMetadata();
+        await (0, services_1.promisifyCall)(this.ctx.clients.adminService, 'WarmupParser', { count }, metadata);
+    }
+    /**
+     * Return cache statistics.
+     */
+    async getCacheStats(cacheType = types_1.CacheType.ALL) {
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.adminService, 'GetCacheStats', { cache_type: (0, converters_1.cacheTypeToProto)(cacheType) }, metadata);
+        return {
+            astStats: response.ast_stats
+                ? {
+                    hits: parseInt(response.ast_stats.hits || '0', 10),
+                    misses: parseInt(response.ast_stats.misses || '0', 10),
+                    evictions: parseInt(response.ast_stats.evictions || '0', 10),
+                    entries: response.ast_stats.entries || 0,
+                    hitRate: response.ast_stats.hit_rate || 0,
+                }
+                : undefined,
+            planStats: response.plan_stats
+                ? {
+                    size: response.plan_stats.size || 0,
+                    capacity: response.plan_stats.capacity || 0,
+                    hits: parseInt(response.plan_stats.hits || '0', 10),
+                    misses: parseInt(response.plan_stats.misses || '0', 10),
+                    hitRate: response.plan_stats.hit_rate || 0,
+                }
+                : undefined,
+        };
+    }
+    /**
+     * Clear the specified cache.
+     */
+    async clearCache(cacheType = types_1.CacheType.ALL) {
+        const metadata = this.ctx.getSessionMetadata();
+        await (0, services_1.promisifyCall)(this.ctx.clients.adminService, 'ClearCache', { cache_type: (0, converters_1.cacheTypeToProto)(cacheType) }, metadata);
+    }
+    /**
+     * Return database statistics.
+     */
+    async getStatistics(graphName = '') {
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.adminService, 'GetStatistics', { graph_name: graphName }, metadata);
+        const labelCounts = {};
+        const edgeLabelCounts = {};
+        if (response.label_counts) {
+            for (const [key, value] of Object.entries(response.label_counts)) {
+                labelCounts[key] = parseInt(value, 10);
+            }
+        }
+        if (response.edge_label_counts) {
+            for (const [key, value] of Object.entries(response.edge_label_counts)) {
+                edgeLabelCounts[key] = parseInt(value, 10);
+            }
+        }
+        return {
+            nodeCount: parseInt(response.node_count || '0', 10),
+            edgeCount: parseInt(response.edge_count || '0', 10),
+            labelCounts,
+            edgeLabelCounts,
+        };
+    }
+    /**
+     * Invalidate the RBAC permission cache.
+     */
+    async invalidatePermissionCache(username = '') {
+        const metadata = this.ctx.getSessionMetadata();
+        await (0, services_1.promisifyCall)(this.ctx.clients.adminService, 'InvalidatePermissionCache', { username }, metadata);
+    }
+    /**
+     * Trigger manual compaction of the database storage.
+     */
+    async compact() {
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.adminService, 'Compact', {}, metadata);
+        return {
+            success: response.success || false,
+            message: response.message || '',
+        };
+    }
+    /**
+     * Return system-level metrics (CPU, memory, disk I/O, storage, network).
+     */
+    async getSystemMetrics() {
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.adminService, 'GetSystemMetrics', {}, metadata);
+        return {
+            cpu: response.cpu
+                ? {
+                    processPercent: response.cpu.process_percent || 0,
+                    systemPercent: response.cpu.system_percent || 0,
+                    numCores: response.cpu.num_cores || 0,
+                }
+                : undefined,
+            memory: response.memory
+                ? {
+                    processRss: parseInt(response.memory.process_rss || '0', 10),
+                    heapAlloc: parseInt(response.memory.heap_alloc || '0', 10),
+                    heapSys: parseInt(response.memory.heap_sys || '0', 10),
+                    stackInUse: parseInt(response.memory.stack_in_use || '0', 10),
+                    systemTotal: parseInt(response.memory.system_total || '0', 10),
+                    systemAvailable: parseInt(response.memory.system_available || '0', 10),
+                    systemUsed: parseInt(response.memory.system_used || '0', 10),
+                    systemUsedPercent: response.memory.system_used_percent || 0,
+                }
+                : undefined,
+            diskIO: response.disk_io
+                ? {
+                    readBytes: parseInt(response.disk_io.read_bytes || '0', 10),
+                    writeBytes: parseInt(response.disk_io.write_bytes || '0', 10),
+                    readCount: parseInt(response.disk_io.read_count || '0', 10),
+                    writeCount: parseInt(response.disk_io.write_count || '0', 10),
+                }
+                : undefined,
+            storage: response.storage
+                ? {
+                    dbPath: response.storage.db_path || '',
+                    dbSizeBytes: parseInt(response.storage.db_size_bytes || '0', 10),
+                    volumeTotal: parseInt(response.storage.volume_total || '0', 10),
+                    volumeFree: parseInt(response.storage.volume_free || '0', 10),
+                    volumeUsed: parseInt(response.storage.volume_used || '0', 10),
+                }
+                : undefined,
+            network: response.network
+                ? {
+                    bytesSent: parseInt(response.network.bytes_sent || '0', 10),
+                    bytesRecv: parseInt(response.network.bytes_recv || '0', 10),
+                    packetsSent: parseInt(response.network.packets_sent || '0', 10),
+                    packetsRecv: parseInt(response.network.packets_recv || '0', 10),
+                }
+                : undefined,
+        };
+    }
+    /**
+     * Wait for the computing engine topology to be ready.
+     */
+    async waitForComputeTopology(graphName, timeoutMs = 0) {
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.adminService, 'WaitForComputeTopology', { graph_name: graphName, timeout_ms: timeoutMs }, metadata);
+        return {
+            ready: response.ready || false,
+            message: response.message || '',
+        };
+    }
+}
+exports.AdminService = AdminService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"admin-service.js","sourceRoot":"","sources":["../../src/services/admin-service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Admin service handles administrative operations.\n */\n\nimport { ServiceContext } from './service-context';\nimport { CacheStats, CacheType, Statistics, CompactResult, ComputeTopologyResult, SystemMetrics } from '../types';\nimport { promisifyCall } from '../services';\nimport { cacheTypeToProto } from './converters';\n\n/**\n * Admin service for administrative operations.\n */\nexport class AdminService {\n  constructor(private ctx: ServiceContext) {}\n\n  /**\n   * Pre-allocate parser instances.\n   */\n  async warmupParser(count: number): Promise<void> {\n    const metadata = this.ctx.getSessionMetadata();\n    await promisifyCall(\n      this.ctx.clients.adminService,\n      'WarmupParser',\n      { count },\n      metadata\n    );\n  }\n\n  /**\n   * Return cache statistics.\n   */\n  async getCacheStats(cacheType: CacheType = CacheType.ALL): Promise<CacheStats> {\n    const metadata = this.ctx.getSessionMetadata();\n    const response: any = await promisifyCall(\n      this.ctx.clients.adminService,\n      'GetCacheStats',\n      { cache_type: cacheTypeToProto(cacheType) },\n      metadata\n    );\n\n    return {\n      astStats: response.ast_stats\n        ? {\n            hits: parseInt(response.ast_stats.hits || '0', 10),\n            misses: parseInt(response.ast_stats.misses || '0', 10),\n            evictions: parseInt(response.ast_stats.evictions || '0', 10),\n            entries: response.ast_stats.entries || 0,\n            hitRate: response.ast_stats.hit_rate || 0,\n          }\n        : undefined,\n      planStats: response.plan_stats\n        ? {\n            size: response.plan_stats.size || 0,\n            capacity: response.plan_stats.capacity || 0,\n            hits: parseInt(response.plan_stats.hits || '0', 10),\n            misses: parseInt(response.plan_stats.misses || '0', 10),\n            hitRate: response.plan_stats.hit_rate || 0,\n          }\n        : undefined,\n    };\n  }\n\n  /**\n   * Clear the specified cache.\n   */\n  async clearCache(cacheType: CacheType = CacheType.ALL): Promise<void> {\n    const metadata = this.ctx.getSessionMetadata();\n    await promisifyCall(\n      this.ctx.clients.adminService,\n      'ClearCache',\n      { cache_type: cacheTypeToProto(cacheType) },\n      metadata\n    );\n  }\n\n  /**\n   * Return database statistics.\n   */\n  async getStatistics(graphName: string = ''): Promise<Statistics> {\n    const metadata = this.ctx.getSessionMetadata();\n    const response: any = await promisifyCall(\n      this.ctx.clients.adminService,\n      'GetStatistics',\n      { graph_name: graphName },\n      metadata\n    );\n\n    const labelCounts: Record<string, number> = {};\n    const edgeLabelCounts: Record<string, number> = {};\n\n    if (response.label_counts) {\n      for (const [key, value] of Object.entries(response.label_counts)) {\n        labelCounts[key] = parseInt(value as string, 10);\n      }\n    }\n\n    if (response.edge_label_counts) {\n      for (const [key, value] of Object.entries(response.edge_label_counts)) {\n        edgeLabelCounts[key] = parseInt(value as string, 10);\n      }\n    }\n\n    return {\n      nodeCount: parseInt(response.node_count || '0', 10),\n      edgeCount: parseInt(response.edge_count || '0', 10),\n      labelCounts,\n      edgeLabelCounts,\n    };\n  }\n\n  /**\n   * Invalidate the RBAC permission cache.\n   */\n  async invalidatePermissionCache(username: string = ''): Promise<void> {\n    const metadata = this.ctx.getSessionMetadata();\n    await promisifyCall(\n      this.ctx.clients.adminService,\n      'InvalidatePermissionCache',\n      { username },\n      metadata\n    );\n  }\n\n  /**\n   * Trigger manual compaction of the database storage.\n   */\n  async compact(): Promise<CompactResult> {\n    const metadata = this.ctx.getSessionMetadata();\n    const response: any = await promisifyCall(\n      this.ctx.clients.adminService,\n      'Compact',\n      {},\n      metadata\n    );\n    return {\n      success: response.success || false,\n      message: response.message || '',\n    };\n  }\n\n  /**\n   * Return system-level metrics (CPU, memory, disk I/O, storage, network).\n   */\n  async getSystemMetrics(): Promise<SystemMetrics> {\n    const metadata = this.ctx.getSessionMetadata();\n    const response: any = await promisifyCall(\n      this.ctx.clients.adminService,\n      'GetSystemMetrics',\n      {},\n      metadata\n    );\n\n    return {\n      cpu: response.cpu\n        ? {\n            processPercent: response.cpu.process_percent || 0,\n            systemPercent: response.cpu.system_percent || 0,\n            numCores: response.cpu.num_cores || 0,\n          }\n        : undefined,\n      memory: response.memory\n        ? {\n            processRss: parseInt(response.memory.process_rss || '0', 10),\n            heapAlloc: parseInt(response.memory.heap_alloc || '0', 10),\n            heapSys: parseInt(response.memory.heap_sys || '0', 10),\n            stackInUse: parseInt(response.memory.stack_in_use || '0', 10),\n            systemTotal: parseInt(response.memory.system_total || '0', 10),\n            systemAvailable: parseInt(response.memory.system_available || '0', 10),\n            systemUsed: parseInt(response.memory.system_used || '0', 10),\n            systemUsedPercent: response.memory.system_used_percent || 0,\n          }\n        : undefined,\n      diskIO: response.disk_io\n        ? {\n            readBytes: parseInt(response.disk_io.read_bytes || '0', 10),\n            writeBytes: parseInt(response.disk_io.write_bytes || '0', 10),\n            readCount: parseInt(response.disk_io.read_count || '0', 10),\n            writeCount: parseInt(response.disk_io.write_count || '0', 10),\n          }\n        : undefined,\n      storage: response.storage\n        ? {\n            dbPath: response.storage.db_path || '',\n            dbSizeBytes: parseInt(response.storage.db_size_bytes || '0', 10),\n            volumeTotal: parseInt(response.storage.volume_total || '0', 10),\n            volumeFree: parseInt(response.storage.volume_free || '0', 10),\n            volumeUsed: parseInt(response.storage.volume_used || '0', 10),\n          }\n        : undefined,\n      network: response.network\n        ? {\n            bytesSent: parseInt(response.network.bytes_sent || '0', 10),\n            bytesRecv: parseInt(response.network.bytes_recv || '0', 10),\n            packetsSent: parseInt(response.network.packets_sent || '0', 10),\n            packetsRecv: parseInt(response.network.packets_recv || '0', 10),\n          }\n        : undefined,\n    };\n  }\n\n  /**\n   * Wait for the computing engine topology to be ready.\n   */\n  async waitForComputeTopology(graphName: string, timeoutMs: number = 0): Promise<ComputeTopologyResult> {\n    const metadata = this.ctx.getSessionMetadata();\n    const response: any = await promisifyCall(\n      this.ctx.clients.adminService,\n      'WaitForComputeTopology',\n      { graph_name: graphName, timeout_ms: timeoutMs },\n      metadata\n    );\n    return {\n      ready: response.ready || false,\n      message: response.message || '',\n    };\n  }\n}\n"]}

package/dist/services/bulk-import-service.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Bulk import service handles bulk import session management.
+ */
+import { ServiceContext } from './service-context';
+import { BulkImportOptions, BulkImportSession, CheckpointResult, EndBulkImportResult, AbortBulkImportResult, BulkImportStatus } from '../types';
+/**
+ * Bulk import service for managing bulk import sessions.
+ */
+export declare class BulkImportService {
+    private ctx;
+    constructor(ctx: ServiceContext);
+    /**
+     * Start a bulk import session for optimized high-throughput inserts.
+     * @param graphName Target graph name
+     * @param options Optional bulk import configuration
+     */
+    startBulkImport(graphName: string, options?: BulkImportOptions): Promise<BulkImportSession>;
+    /** @deprecated Checkpoint is no longer needed. */
+    checkpoint(sessionId: string): Promise<CheckpointResult>;
+    /**
+     * End the bulk import session with a final checkpoint.
+     * @param sessionId Bulk import session ID
+     */
+    endBulkImport(sessionId: string): Promise<EndBulkImportResult>;
+    /**
+     * Cancel the bulk import session without final sync.
+     * @param sessionId Bulk import session ID
+     */
+    abortBulkImport(sessionId: string): Promise<AbortBulkImportResult>;
+    /**
+     * Return the current status of a bulk import session.
+     * @param sessionId Bulk import session ID
+     */
+    getBulkImportStatus(sessionId: string): Promise<BulkImportStatus>;
+}

package/dist/services/bulk-import-service.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * Bulk import service handles bulk import session management.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkImportService = void 0;
+const services_1 = require("../services");
+/**
+ * Bulk import service for managing bulk import sessions.
+ */
+class BulkImportService {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /**
+     * Start a bulk import session for optimized high-throughput inserts.
+     * @param graphName Target graph name
+     * @param options Optional bulk import configuration
+     */
+    async startBulkImport(graphName, options) {
+        const request = {
+            graph_name: graphName,
+        };
+        if (options) {
+            if (options.checkpointEvery !== undefined) {
+                request.checkpoint_every = options.checkpointEvery.toString();
+            }
+            if (options.estimatedNodes !== undefined) {
+                request.estimated_nodes = options.estimatedNodes.toString();
+            }
+            if (options.estimatedEdges !== undefined) {
+                request.estimated_edges = options.estimatedEdges.toString();
+            }
+        }
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.bulkImportService, 'StartBulkImport', request, metadata);
+        return {
+            success: response.success || false,
+            sessionId: response.session_id || '',
+            message: response.message || '',
+        };
+    }
+    /** @deprecated Checkpoint is no longer needed. */
+    async checkpoint(sessionId) {
+        return {
+            success: true,
+            recordCount: 0,
+            lastCheckpointCount: 0,
+            message: 'Checkpoint has been removed; use endBulkImport which performs a final flush',
+        };
+    }
+    /**
+     * End the bulk import session with a final checkpoint.
+     * @param sessionId Bulk import session ID
+     */
+    async endBulkImport(sessionId) {
+        const request = {
+            session_id: sessionId,
+        };
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.bulkImportService, 'EndBulkImport', request, metadata);
+        return {
+            success: response.success || false,
+            totalRecords: parseInt(response.total_records || '0', 10),
+            message: response.message || '',
+        };
+    }
+    /**
+     * Cancel the bulk import session without final sync.
+     * @param sessionId Bulk import session ID
+     */
+    async abortBulkImport(sessionId) {
+        const request = {
+            session_id: sessionId,
+        };
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.bulkImportService, 'AbortBulkImport', request, metadata);
+        return {
+            success: response.success || false,
+            message: response.message || '',
+        };
+    }
+    /**
+     * Return the current status of a bulk import session.
+     * @param sessionId Bulk import session ID
+     */
+    async getBulkImportStatus(sessionId) {
+        const request = {
+            session_id: sessionId,
+        };
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.bulkImportService, 'GetBulkImportStatus', request, metadata);
+        return {
+            isActive: response.is_active || false,
+            graphName: response.graph_name || '',
+            recordCount: parseInt(response.record_count || '0', 10),
+            lastCheckpointCount: parseInt(response.last_checkpoint_count || '0', 10),
+            createdAt: parseInt(response.created_at || '0', 10),
+            lastActivity: parseInt(response.last_activity || '0', 10),
+        };
+    }
+}
+exports.BulkImportService = BulkImportService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bulk-import-service.js","sourceRoot":"","sources":["../../src/services/bulk-import-service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Bulk import service handles bulk import session management.\n */\n\nimport { ServiceContext } from './service-context';\nimport {\n  BulkImportOptions,\n  BulkImportSession,\n  CheckpointResult,\n  EndBulkImportResult,\n  AbortBulkImportResult,\n  BulkImportStatus,\n} from '../types';\nimport { promisifyCall } from '../services';\n\n/**\n * Bulk import service for managing bulk import sessions.\n */\nexport class BulkImportService {\n  constructor(private ctx: ServiceContext) {}\n\n  /**\n   * Start a bulk import session for optimized high-throughput inserts.\n   * @param graphName Target graph name\n   * @param options Optional bulk import configuration\n   */\n  async startBulkImport(graphName: string, options?: BulkImportOptions): Promise<BulkImportSession> {\n    const request: any = {\n      graph_name: graphName,\n    };\n\n    if (options) {\n      if (options.checkpointEvery !== undefined) {\n        request.checkpoint_every = options.checkpointEvery.toString();\n      }\n      if (options.estimatedNodes !== undefined) {\n        request.estimated_nodes = options.estimatedNodes.toString();\n      }\n      if (options.estimatedEdges !== undefined) {\n        request.estimated_edges = options.estimatedEdges.toString();\n      }\n    }\n\n    const metadata = this.ctx.getSessionMetadata();\n    const response: any = await promisifyCall(\n      this.ctx.clients.bulkImportService,\n      'StartBulkImport',\n      request,\n      metadata\n    );\n\n    return {\n      success: response.success || false,\n      sessionId: response.session_id || '',\n      message: response.message || '',\n    };\n  }\n\n  /** @deprecated Checkpoint is no longer needed. */\n  async checkpoint(sessionId: string): Promise<CheckpointResult> {\n    return {\n      success: true,\n      recordCount: 0,\n      lastCheckpointCount: 0,\n      message: 'Checkpoint has been removed; use endBulkImport which performs a final flush',\n    };\n  }\n\n  /**\n   * End the bulk import session with a final checkpoint.\n   * @param sessionId Bulk import session ID\n   */\n  async endBulkImport(sessionId: string): Promise<EndBulkImportResult> {\n    const request = {\n      session_id: sessionId,\n    };\n\n    const metadata = this.ctx.getSessionMetadata();\n    const response: any = await promisifyCall(\n      this.ctx.clients.bulkImportService,\n      'EndBulkImport',\n      request,\n      metadata\n    );\n\n    return {\n      success: response.success || false,\n      totalRecords: parseInt(response.total_records || '0', 10),\n      message: response.message || '',\n    };\n  }\n\n  /**\n   * Cancel the bulk import session without final sync.\n   * @param sessionId Bulk import session ID\n   */\n  async abortBulkImport(sessionId: string): Promise<AbortBulkImportResult> {\n    const request = {\n      session_id: sessionId,\n    };\n\n    const metadata = this.ctx.getSessionMetadata();\n    const response: any = await promisifyCall(\n      this.ctx.clients.bulkImportService,\n      'AbortBulkImport',\n      request,\n      metadata\n    );\n\n    return {\n      success: response.success || false,\n      message: response.message || '',\n    };\n  }\n\n  /**\n   * Return the current status of a bulk import session.\n   * @param sessionId Bulk import session ID\n   */\n  async getBulkImportStatus(sessionId: string): Promise<BulkImportStatus> {\n    const request = {\n      session_id: sessionId,\n    };\n\n    const metadata = this.ctx.getSessionMetadata();\n    const response: any = await promisifyCall(\n      this.ctx.clients.bulkImportService,\n      'GetBulkImportStatus',\n      request,\n      metadata\n    );\n\n    return {\n      isActive: response.is_active || false,\n      graphName: response.graph_name || '',\n      recordCount: parseInt(response.record_count || '0', 10),\n      lastCheckpointCount: parseInt(response.last_checkpoint_count || '0', 10),\n      createdAt: parseInt(response.created_at || '0', 10),\n      lastActivity: parseInt(response.last_activity || '0', 10),\n    };\n  }\n}\n"]}

package/dist/services/converters.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Type conversion utilities between gRPC proto types and JavaScript types.
+ */
+import { Response } from '../response';
+import { GraphType, HealthStatus, CacheType, GraphInfo } from '../types';
+import { GqldbConfig } from '../config';
+import { Session } from '../session';
+import { QueryConfig } from '../client';
+/**
+ * Build a GQL request from config.
+ */
+export declare function buildGqlRequest(query: string, session: Session | null, config: GqldbConfig, queryConfig?: QueryConfig): any;
+/**
+ * Build parameters array for gRPC.
+ */
+export declare function buildParameters(params?: Record<string, any>): any[];
+/**
+ * Convert gRPC response to Response object.
+ */
+export declare function convertGqlResponse(grpcResponse: any): Response;
+/**
+ * Convert gRPC TypedValue to JS value.
+ * Uses the same decoding logic as typedValueToJS for consistency.
+ */
+export declare function convertTypedValue(tv: any): any;
+/**
+ * Convert proto properties map to JS object.
+ */
+export declare function convertProtoProperties(protoProps: Record<string, any>): Record<string, any>;
+/**
+ * Convert GraphInfo from proto to JS object.
+ */
+export declare function convertGraphInfo(g: any): GraphInfo;
+/**
+ * Map GraphType enum to proto string.
+ */
+export declare function graphTypeToProto(graphType: GraphType): string;
+/**
+ * Map proto string to GraphType enum.
+ */
+export declare function protoToGraphType(proto: string): GraphType;
+/**
+ * Map proto HealthStatus to enum.
+ */
+export declare function protoToHealthStatus(proto: string): HealthStatus;
+/**
+ * Map CacheType to proto string.
+ */
+export declare function cacheTypeToProto(cacheType: CacheType): string;
+/**
+ * Convert NodeData to proto format.
+ */
+export declare function nodeDataToProto(node: any): any;
+/**
+ * Convert EdgeData to proto format.
+ */
+export declare function edgeDataToProto(edge: any): any;