@ultipa-graph/ultipa-driver 5.1.4-s5.1 → 6.0.0

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

@@ -0,0 +1,40 @@
+/**
+ * Admin service handles administrative operations.
+ */
+import { ServiceContext } from './service-context';
+import { CacheStats, CacheType, Statistics, CompactResult, ComputeTopologyResult } 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>;
+    /**
+     * 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,115 @@
+"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 || '',
+        };
+    }
+    /**
+     * 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":["/**\r\n * Admin service handles administrative operations.\r\n */\r\n\r\nimport { ServiceContext } from './service-context';\r\nimport { CacheStats, CacheType, Statistics, CompactResult, ComputeTopologyResult } from '../types';\r\nimport { promisifyCall } from '../services';\r\nimport { cacheTypeToProto } from './converters';\r\n\r\n/**\r\n * Admin service for administrative operations.\r\n */\r\nexport class AdminService {\r\n  constructor(private ctx: ServiceContext) {}\r\n\r\n  /**\r\n   * Pre-allocate parser instances.\r\n   */\r\n  async warmupParser(count: number): Promise<void> {\r\n    const metadata = this.ctx.getSessionMetadata();\r\n    await promisifyCall(\r\n      this.ctx.clients.adminService,\r\n      'WarmupParser',\r\n      { count },\r\n      metadata\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Return cache statistics.\r\n   */\r\n  async getCacheStats(cacheType: CacheType = CacheType.ALL): Promise<CacheStats> {\r\n    const metadata = this.ctx.getSessionMetadata();\r\n    const response: any = await promisifyCall(\r\n      this.ctx.clients.adminService,\r\n      'GetCacheStats',\r\n      { cache_type: cacheTypeToProto(cacheType) },\r\n      metadata\r\n    );\r\n\r\n    return {\r\n      astStats: response.ast_stats\r\n        ? {\r\n            hits: parseInt(response.ast_stats.hits || '0', 10),\r\n            misses: parseInt(response.ast_stats.misses || '0', 10),\r\n            evictions: parseInt(response.ast_stats.evictions || '0', 10),\r\n            entries: response.ast_stats.entries || 0,\r\n            hitRate: response.ast_stats.hit_rate || 0,\r\n          }\r\n        : undefined,\r\n      planStats: response.plan_stats\r\n        ? {\r\n            size: response.plan_stats.size || 0,\r\n            capacity: response.plan_stats.capacity || 0,\r\n            hits: parseInt(response.plan_stats.hits || '0', 10),\r\n            misses: parseInt(response.plan_stats.misses || '0', 10),\r\n            hitRate: response.plan_stats.hit_rate || 0,\r\n          }\r\n        : undefined,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Clear the specified cache.\r\n   */\r\n  async clearCache(cacheType: CacheType = CacheType.ALL): Promise<void> {\r\n    const metadata = this.ctx.getSessionMetadata();\r\n    await promisifyCall(\r\n      this.ctx.clients.adminService,\r\n      'ClearCache',\r\n      { cache_type: cacheTypeToProto(cacheType) },\r\n      metadata\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Return database statistics.\r\n   */\r\n  async getStatistics(graphName: string = ''): Promise<Statistics> {\r\n    const metadata = this.ctx.getSessionMetadata();\r\n    const response: any = await promisifyCall(\r\n      this.ctx.clients.adminService,\r\n      'GetStatistics',\r\n      { graph_name: graphName },\r\n      metadata\r\n    );\r\n\r\n    const labelCounts: Record<string, number> = {};\r\n    const edgeLabelCounts: Record<string, number> = {};\r\n\r\n    if (response.label_counts) {\r\n      for (const [key, value] of Object.entries(response.label_counts)) {\r\n        labelCounts[key] = parseInt(value as string, 10);\r\n      }\r\n    }\r\n\r\n    if (response.edge_label_counts) {\r\n      for (const [key, value] of Object.entries(response.edge_label_counts)) {\r\n        edgeLabelCounts[key] = parseInt(value as string, 10);\r\n      }\r\n    }\r\n\r\n    return {\r\n      nodeCount: parseInt(response.node_count || '0', 10),\r\n      edgeCount: parseInt(response.edge_count || '0', 10),\r\n      labelCounts,\r\n      edgeLabelCounts,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Invalidate the RBAC permission cache.\r\n   */\r\n  async invalidatePermissionCache(username: string = ''): Promise<void> {\r\n    const metadata = this.ctx.getSessionMetadata();\r\n    await promisifyCall(\r\n      this.ctx.clients.adminService,\r\n      'InvalidatePermissionCache',\r\n      { username },\r\n      metadata\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Trigger manual compaction of the database storage.\r\n   */\r\n  async compact(): Promise<CompactResult> {\r\n    const metadata = this.ctx.getSessionMetadata();\r\n    const response: any = await promisifyCall(\r\n      this.ctx.clients.adminService,\r\n      'Compact',\r\n      {},\r\n      metadata\r\n    );\r\n    return {\r\n      success: response.success || false,\r\n      message: response.message || '',\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Wait for the computing engine topology to be ready.\r\n   */\r\n  async waitForComputeTopology(graphName: string, timeoutMs: number = 0): Promise<ComputeTopologyResult> {\r\n    const metadata = this.ctx.getSessionMetadata();\r\n    const response: any = await promisifyCall(\r\n      this.ctx.clients.adminService,\r\n      'WaitForComputeTopology',\r\n      { graph_name: graphName, timeout_ms: timeoutMs },\r\n      metadata\r\n    );\r\n    return {\r\n      ready: response.ready || false,\r\n      message: response.message || '',\r\n    };\r\n  }\r\n}\r\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,108 @@
+"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);
+        if (!response.success) {
+            throw new Error(`Start bulk import failed: ${response.message || 'unknown error'}`);
+        }
+        return {
+            success: true,
+            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":["/**\r\n * Bulk import service handles bulk import session management.\r\n */\r\n\r\nimport { ServiceContext } from './service-context';\r\nimport {\r\n  BulkImportOptions,\r\n  BulkImportSession,\r\n  CheckpointResult,\r\n  EndBulkImportResult,\r\n  AbortBulkImportResult,\r\n  BulkImportStatus,\r\n} from '../types';\r\nimport { promisifyCall } from '../services';\r\n\r\n/**\r\n * Bulk import service for managing bulk import sessions.\r\n */\r\nexport class BulkImportService {\r\n  constructor(private ctx: ServiceContext) {}\r\n\r\n  /**\r\n   * Start a bulk import session for optimized high-throughput inserts.\r\n   * @param graphName Target graph name\r\n   * @param options Optional bulk import configuration\r\n   */\r\n  async startBulkImport(graphName: string, options?: BulkImportOptions): Promise<BulkImportSession> {\r\n    const request: any = {\r\n      graph_name: graphName,\r\n    };\r\n\r\n    if (options) {\r\n      if (options.checkpointEvery !== undefined) {\r\n        request.checkpoint_every = options.checkpointEvery.toString();\r\n      }\r\n      if (options.estimatedNodes !== undefined) {\r\n        request.estimated_nodes = options.estimatedNodes.toString();\r\n      }\r\n      if (options.estimatedEdges !== undefined) {\r\n        request.estimated_edges = options.estimatedEdges.toString();\r\n      }\r\n    }\r\n\r\n    const metadata = this.ctx.getSessionMetadata();\r\n    const response: any = await promisifyCall(\r\n      this.ctx.clients.bulkImportService,\r\n      'StartBulkImport',\r\n      request,\r\n      metadata\r\n    );\r\n\r\n    if (!response.success) {\r\n      throw new Error(`Start bulk import failed: ${response.message || 'unknown error'}`);\r\n    }\r\n\r\n    return {\r\n      success: true,\r\n      sessionId: response.session_id || '',\r\n      message: response.message || '',\r\n    };\r\n  }\r\n\r\n  /** @deprecated Checkpoint is no longer needed. */\r\n  async checkpoint(sessionId: string): Promise<CheckpointResult> {\r\n    return {\r\n      success: true,\r\n      recordCount: 0,\r\n      lastCheckpointCount: 0,\r\n      message: 'Checkpoint has been removed; use endBulkImport which performs a final flush',\r\n    };\r\n  }\r\n\r\n  /**\r\n   * End the bulk import session with a final checkpoint.\r\n   * @param sessionId Bulk import session ID\r\n   */\r\n  async endBulkImport(sessionId: string): Promise<EndBulkImportResult> {\r\n    const request = {\r\n      session_id: sessionId,\r\n    };\r\n\r\n    const metadata = this.ctx.getSessionMetadata();\r\n    const response: any = await promisifyCall(\r\n      this.ctx.clients.bulkImportService,\r\n      'EndBulkImport',\r\n      request,\r\n      metadata\r\n    );\r\n\r\n    return {\r\n      success: response.success || false,\r\n      totalRecords: parseInt(response.total_records || '0', 10),\r\n      message: response.message || '',\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Cancel the bulk import session without final sync.\r\n   * @param sessionId Bulk import session ID\r\n   */\r\n  async abortBulkImport(sessionId: string): Promise<AbortBulkImportResult> {\r\n    const request = {\r\n      session_id: sessionId,\r\n    };\r\n\r\n    const metadata = this.ctx.getSessionMetadata();\r\n    const response: any = await promisifyCall(\r\n      this.ctx.clients.bulkImportService,\r\n      'AbortBulkImport',\r\n      request,\r\n      metadata\r\n    );\r\n\r\n    return {\r\n      success: response.success || false,\r\n      message: response.message || '',\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Return the current status of a bulk import session.\r\n   * @param sessionId Bulk import session ID\r\n   */\r\n  async getBulkImportStatus(sessionId: string): Promise<BulkImportStatus> {\r\n    const request = {\r\n      session_id: sessionId,\r\n    };\r\n\r\n    const metadata = this.ctx.getSessionMetadata();\r\n    const response: any = await promisifyCall(\r\n      this.ctx.clients.bulkImportService,\r\n      'GetBulkImportStatus',\r\n      request,\r\n      metadata\r\n    );\r\n\r\n    return {\r\n      isActive: response.is_active || false,\r\n      graphName: response.graph_name || '',\r\n      recordCount: parseInt(response.record_count || '0', 10),\r\n      lastCheckpointCount: parseInt(response.last_checkpoint_count || '0', 10),\r\n      createdAt: parseInt(response.created_at || '0', 10),\r\n      lastActivity: parseInt(response.last_activity || '0', 10),\r\n    };\r\n  }\r\n}\r\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;