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

package/dist/services/graph-service.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * Graph service handles graph management operations.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphService = void 0;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const types_1 = require("../types");
+const services_1 = require("../services");
+const converters_1 = require("./converters");
+const errors_1 = require("../errors");
+/**
+ * Graph service for managing graphs.
+ */
+class GraphService {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /**
+     * Create a new graph.
+     */
+    async createGraph(name, graphType = types_1.GraphType.OPEN, description = '') {
+        const request = {
+            name,
+            graph_type: (0, converters_1.graphTypeToProto)(graphType),
+            description,
+        };
+        const metadata = this.ctx.getSessionMetadata();
+        await (0, services_1.promisifyCall)(this.ctx.clients.graphService, 'CreateGraph', request, metadata);
+    }
+    /**
+     * Delete a graph.
+     */
+    async dropGraph(name, ifExists = false) {
+        const request = {
+            name,
+            if_exists: ifExists,
+        };
+        const metadata = this.ctx.getSessionMetadata();
+        await (0, services_1.promisifyCall)(this.ctx.clients.graphService, 'DropGraph', request, metadata);
+    }
+    /**
+     * Set the current graph for the session.
+     */
+    async useGraph(name) {
+        const session = this.ctx.sessions.getSession();
+        const request = {
+            name,
+            session_id: session?.id?.toString() || '0',
+        };
+        const metadata = this.ctx.getSessionMetadata();
+        await (0, services_1.promisifyCall)(this.ctx.clients.graphService, 'UseGraph', request, metadata);
+        this.ctx.sessions.setDefaultGraph(name);
+    }
+    /**
+     * Return all available graphs.
+     */
+    async listGraphs() {
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.graphService, 'ListGraphs', {}, metadata);
+        return (response.graphs || []).map((g) => (0, converters_1.convertGraphInfo)(g));
+    }
+    /**
+     * Return information about a specific graph.
+     */
+    async getGraphInfo(name) {
+        const metadata = this.ctx.getSessionMetadata();
+        try {
+            const response = await (0, services_1.promisifyCall)(this.ctx.clients.graphService, 'GetGraphInfo', { name }, metadata);
+            if (!response.info) {
+                throw new errors_1.GraphNotFoundError(name);
+            }
+            const info = response.info;
+            return {
+                name: info.name || name,
+                graphType: info.graph_type,
+                nodeCount: parseInt(info.node_count || '0', 10),
+                edgeCount: parseInt(info.edge_count || '0', 10),
+                description: info.description || '',
+            };
+        }
+        catch (err) {
+            if (err instanceof errors_1.GraphNotFoundError)
+                throw err;
+            if (err?.code === grpc.status.NOT_FOUND) {
+                throw new errors_1.GraphNotFoundError(name);
+            }
+            throw err;
+        }
+    }
+}
+exports.GraphService = GraphService;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,50 @@
+/**
+ * Health service handles health check operations.
+ */
+import { EventEmitter } from 'events';
+import { ServiceContext } from './service-context';
+import { HealthStatus } from '../types';
+/**
+ * Health watcher interface for streaming health updates.
+ * Emits 'status' events with HealthStatus and 'error' events on failure.
+ */
+export interface HealthWatcher extends EventEmitter {
+    /** Stop watching health updates */
+    stop(): void;
+}
+/**
+ * Health service for checking service health.
+ */
+export declare class HealthService {
+    private ctx;
+    constructor(ctx: ServiceContext);
+    /**
+     * Check the health of a service.
+     */
+    healthCheck(service?: string): Promise<HealthStatus>;
+    /**
+     * Watch health status changes via server-side streaming.
+     * Returns a HealthWatcher that emits 'status' events with HealthStatus values.
+     * Call stop() to cancel the stream.
+     *
+     * @param service - Optional service name to watch
+     * @returns HealthWatcher - EventEmitter with stop() method
+     *
+     * @example
+     * ```typescript
+     * const watcher = healthService.watch();
+     * watcher.on('status', (status: HealthStatus) => {
+     *   console.log('Health status:', status);
+     * });
+     * watcher.on('error', (err) => {
+     *   console.error('Watch error:', err);
+     * });
+     * watcher.on('end', () => {
+     *   console.log('Watch stream ended');
+     * });
+     * // Later, to stop watching:
+     * watcher.stop();
+     * ```
+     */
+    watch(service?: string): HealthWatcher;
+}

package/dist/services/health-service.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * Health service handles health check operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthService = void 0;
+const events_1 = require("events");
+const services_1 = require("../services");
+const converters_1 = require("./converters");
+/**
+ * Health service for checking service health.
+ */
+class HealthService {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /**
+     * Check the health of a service.
+     */
+    async healthCheck(service = '') {
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.healthService, 'Check', { service }, metadata);
+        return (0, converters_1.protoToHealthStatus)(response.status);
+    }
+    /**
+     * Watch health status changes via server-side streaming.
+     * Returns a HealthWatcher that emits 'status' events with HealthStatus values.
+     * Call stop() to cancel the stream.
+     *
+     * @param service - Optional service name to watch
+     * @returns HealthWatcher - EventEmitter with stop() method
+     *
+     * @example
+     * ```typescript
+     * const watcher = healthService.watch();
+     * watcher.on('status', (status: HealthStatus) => {
+     *   console.log('Health status:', status);
+     * });
+     * watcher.on('error', (err) => {
+     *   console.error('Watch error:', err);
+     * });
+     * watcher.on('end', () => {
+     *   console.log('Watch stream ended');
+     * });
+     * // Later, to stop watching:
+     * watcher.stop();
+     * ```
+     */
+    watch(service = '') {
+        const emitter = new events_1.EventEmitter();
+        // Get the Watch method from the health service
+        const watchFn = this.ctx.clients.healthService.Watch.bind(this.ctx.clients.healthService);
+        // Start the streaming call with metadata
+        const metadata = this.ctx.getSessionMetadata();
+        const call = watchFn({ service }, metadata);
+        // Handle incoming data
+        call.on('data', (response) => {
+            const status = (0, converters_1.protoToHealthStatus)(response.status);
+            emitter.emit('status', status);
+        });
+        // Handle errors
+        call.on('error', (err) => {
+            emitter.emit('error', err);
+        });
+        // Handle stream end
+        call.on('end', () => {
+            emitter.emit('end');
+        });
+        // Add stop method to cancel the stream
+        emitter.stop = () => {
+            call.cancel();
+        };
+        return emitter;
+    }
+}
+exports.HealthService = HealthService;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/services/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Barrel export for all service classes.
+ */
+export * from './service-context';
+export * from './converters';
+export * from './session-service';
+export * from './query-service';
+export * from './graph-service';
+export * from './transaction-service';
+export * from './data-service';
+export * from './health-service';
+export * from './admin-service';
+export * from './bulk-import-service';

package/dist/services/index.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Barrel export for all service classes.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./service-context"), exports);
+__exportStar(require("./converters"), exports);
+__exportStar(require("./session-service"), exports);
+__exportStar(require("./query-service"), exports);
+__exportStar(require("./graph-service"), exports);
+__exportStar(require("./transaction-service"), exports);
+__exportStar(require("./data-service"), exports);
+__exportStar(require("./health-service"), exports);
+__exportStar(require("./admin-service"), exports);
+__exportStar(require("./bulk-import-service"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOztHQUVHOzs7Ozs7Ozs7Ozs7Ozs7O0FBRUgsb0RBQWtDO0FBQ2xDLCtDQUE2QjtBQUM3QixvREFBa0M7QUFDbEMsa0RBQWdDO0FBQ2hDLGtEQUFnQztBQUNoQyx3REFBc0M7QUFDdEMsaURBQStCO0FBQy9CLG1EQUFpQztBQUNqQyxrREFBZ0M7QUFDaEMsd0RBQXNDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBCYXJyZWwgZXhwb3J0IGZvciBhbGwgc2VydmljZSBjbGFzc2VzLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZS1jb250ZXh0JztcbmV4cG9ydCAqIGZyb20gJy4vY29udmVydGVycyc7XG5leHBvcnQgKiBmcm9tICcuL3Nlc3Npb24tc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3F1ZXJ5LXNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9ncmFwaC1zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vdHJhbnNhY3Rpb24tc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2RhdGEtc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2hlYWx0aC1zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vYWRtaW4tc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2J1bGstaW1wb3J0LXNlcnZpY2UnO1xuIl19

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

@@ -0,0 +1,39 @@
+/**
+ * Query service handles GQL query execution.
+ */
+import { ServiceContext } from './service-context';
+import { Response } from '../response';
+import { QueryConfig } from '../client';
+/**
+ * Query service for executing GQL queries.
+ */
+export declare class QueryService {
+    private ctx;
+    constructor(ctx: ServiceContext);
+    /**
+     * Calculate timeout with the following priority:
+     * 1. QueryConfig.timeout (highest priority) - explicitly specified timeout
+     * 2. Context deadline (medium priority) - remaining time from context deadline
+     * 3. client.config.timeout (default) - default timeout from client config
+     *
+     * @param config Optional query configuration
+     * @returns Timeout in milliseconds
+     */
+    private calculateTimeout;
+    /**
+     * Execute a GQL query and return the result.
+     */
+    gql(query: string, config?: QueryConfig): Promise<Response>;
+    /**
+     * Execute a GQL query and stream the results.
+     */
+    gqlStream(query: string, config?: QueryConfig, callback?: (response: Response) => void): Promise<void>;
+    /**
+     * Return the execution plan for a query.
+     */
+    explain(query: string, config?: QueryConfig): Promise<string>;
+    /**
+     * Execute a query with profiling and return statistics.
+     */
+    profile(query: string, config?: QueryConfig): Promise<string>;
+}

package/dist/services/query-service.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Query service handles GQL query execution.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryService = void 0;
+const errors_1 = require("../errors");
+const services_1 = require("../services");
+const converters_1 = require("./converters");
+/**
+ * Query service for executing GQL queries.
+ */
+class QueryService {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /**
+     * Calculate timeout with the following priority:
+     * 1. QueryConfig.timeout (highest priority) - explicitly specified timeout
+     * 2. Context deadline (medium priority) - remaining time from context deadline
+     * 3. client.config.timeout (default) - default timeout from client config
+     *
+     * @param config Optional query configuration
+     * @returns Timeout in milliseconds
+     */
+    calculateTimeout(config) {
+        // Priority 1: Use explicitly specified timeout from QueryConfig
+        if (config?.timeout && config.timeout > 0) {
+            return config.timeout;
+        }
+        // Priority 2: Context deadline support
+        // Note: Node.js SDK doesn't currently expose context deadline parameter
+        // This is left for future enhancement
+        // Priority 3: Use default timeout from client config
+        return this.ctx.config.timeout || 30000;
+    }
+    /**
+     * Execute a GQL query and return the result.
+     */
+    async gql(query, config) {
+        if (!query) {
+            throw new errors_1.EmptyQueryError();
+        }
+        const session = this.ctx.sessions.getSession();
+        const request = (0, converters_1.buildGqlRequest)(query, session, this.ctx.config, config);
+        const timeoutMs = this.calculateTimeout(config);
+        try {
+            const metadata = this.ctx.getSessionMetadata();
+            const response = await (0, services_1.promisifyCallWithDeadline)(this.ctx.clients.queryService, 'Gql', request, timeoutMs, metadata);
+            this.ctx.updateActivity();
+            return (0, converters_1.convertGqlResponse)(response);
+        }
+        catch (error) {
+            throw new errors_1.QueryFailedError(error.message || 'Query failed');
+        }
+    }
+    /**
+     * Execute a GQL query and stream the results.
+     */
+    async gqlStream(query, config, callback) {
+        if (!query) {
+            throw new errors_1.EmptyQueryError();
+        }
+        const session = this.ctx.sessions.getSession();
+        const request = (0, converters_1.buildGqlRequest)(query, session, this.ctx.config, config);
+        const metadata = this.ctx.getSessionMetadata();
+        const timeoutMs = this.calculateTimeout(config);
+        const deadline = new Date(Date.now() + timeoutMs);
+        return new Promise((resolve, reject) => {
+            const stream = this.ctx.clients.queryService.GqlStream(request, metadata, { deadline });
+            stream.on('data', (response) => {
+                this.ctx.updateActivity();
+                if (callback) {
+                    callback((0, converters_1.convertGqlResponse)(response));
+                }
+            });
+            stream.on('end', () => resolve());
+            stream.on('error', (error) => reject(new errors_1.QueryFailedError(error.message)));
+        });
+    }
+    /**
+     * Return the execution plan for a query.
+     */
+    async explain(query, config) {
+        if (!query) {
+            throw new errors_1.EmptyQueryError();
+        }
+        const session = this.ctx.sessions.getSession();
+        const request = (0, converters_1.buildGqlRequest)(query, session, this.ctx.config, config);
+        const metadata = this.ctx.getSessionMetadata();
+        const timeoutMs = this.calculateTimeout(config);
+        const response = await (0, services_1.promisifyCallWithDeadline)(this.ctx.clients.queryService, 'Explain', request, timeoutMs, metadata);
+        return response.plan || '';
+    }
+    /**
+     * Execute a query with profiling and return statistics.
+     */
+    async profile(query, config) {
+        if (!query) {
+            throw new errors_1.EmptyQueryError();
+        }
+        const session = this.ctx.sessions.getSession();
+        const request = (0, converters_1.buildGqlRequest)(query, session, this.ctx.config, config);
+        const metadata = this.ctx.getSessionMetadata();
+        const timeoutMs = this.calculateTimeout(config);
+        const response = await (0, services_1.promisifyCallWithDeadline)(this.ctx.clients.queryService, 'Profile', request, timeoutMs, metadata);
+        return response.profile || '';
+    }
+}
+exports.QueryService = QueryService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-service.js","sourceRoot":"","sources":["../../src/services/query-service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Query service handles GQL query execution.\n */\n\nimport { ServiceContext } from './service-context';\nimport { Response } from '../response';\nimport { EmptyQueryError, QueryFailedError } from '../errors';\nimport { promisifyCallWithDeadline } from '../services';\nimport {\n  buildGqlRequest,\n  convertGqlResponse,\n} from './converters';\nimport { QueryConfig } from '../client';\n\n/**\n * Query service for executing GQL queries.\n */\nexport class QueryService {\n  constructor(private ctx: ServiceContext) {}\n\n  /**\n   * Calculate timeout with the following priority:\n   * 1. QueryConfig.timeout (highest priority) - explicitly specified timeout\n   * 2. Context deadline (medium priority) - remaining time from context deadline\n   * 3. client.config.timeout (default) - default timeout from client config\n   *\n   * @param config Optional query configuration\n   * @returns Timeout in milliseconds\n   */\n  private calculateTimeout(config?: QueryConfig): number {\n    // Priority 1: Use explicitly specified timeout from QueryConfig\n    if (config?.timeout && config.timeout > 0) {\n      return config.timeout;\n    }\n\n    // Priority 2: Context deadline support\n    // Note: Node.js SDK doesn't currently expose context deadline parameter\n    // This is left for future enhancement\n\n    // Priority 3: Use default timeout from client config\n    return this.ctx.config.timeout || 30000;\n  }\n\n  /**\n   * Execute a GQL query and return the result.\n   */\n  async gql(query: string, config?: QueryConfig): Promise<Response> {\n    if (!query) {\n      throw new EmptyQueryError();\n    }\n\n    const session = this.ctx.sessions.getSession();\n    const request = buildGqlRequest(query, session, this.ctx.config, config);\n    const timeoutMs = this.calculateTimeout(config);\n\n    try {\n      const metadata = this.ctx.getSessionMetadata();\n      const response: any = await promisifyCallWithDeadline(\n        this.ctx.clients.queryService,\n        'Gql',\n        request,\n        timeoutMs,\n        metadata\n      );\n\n      this.ctx.updateActivity();\n      return convertGqlResponse(response);\n    } catch (error: any) {\n      throw new QueryFailedError(error.message || 'Query failed');\n    }\n  }\n\n  /**\n   * Execute a GQL query and stream the results.\n   */\n  async gqlStream(\n    query: string,\n    config?: QueryConfig,\n    callback?: (response: Response) => void\n  ): Promise<void> {\n    if (!query) {\n      throw new EmptyQueryError();\n    }\n\n    const session = this.ctx.sessions.getSession();\n    const request = buildGqlRequest(query, session, this.ctx.config, config);\n    const metadata = this.ctx.getSessionMetadata();\n    const timeoutMs = this.calculateTimeout(config);\n    const deadline = new Date(Date.now() + timeoutMs);\n\n    return new Promise((resolve, reject) => {\n      const stream = (this.ctx.clients.queryService as any).GqlStream(\n        request,\n        metadata,\n        { deadline }\n      );\n\n      stream.on('data', (response: any) => {\n        this.ctx.updateActivity();\n        if (callback) {\n          callback(convertGqlResponse(response));\n        }\n      });\n\n      stream.on('end', () => resolve());\n      stream.on('error', (error: any) => reject(new QueryFailedError(error.message)));\n    });\n  }\n\n  /**\n   * Return the execution plan for a query.\n   */\n  async explain(query: string, config?: QueryConfig): Promise<string> {\n    if (!query) {\n      throw new EmptyQueryError();\n    }\n\n    const session = this.ctx.sessions.getSession();\n    const request = buildGqlRequest(query, session, this.ctx.config, config);\n    const metadata = this.ctx.getSessionMetadata();\n    const timeoutMs = this.calculateTimeout(config);\n    const response: any = await promisifyCallWithDeadline(\n      this.ctx.clients.queryService,\n      'Explain',\n      request,\n      timeoutMs,\n      metadata\n    );\n\n    return response.plan || '';\n  }\n\n  /**\n   * Execute a query with profiling and return statistics.\n   */\n  async profile(query: string, config?: QueryConfig): Promise<string> {\n    if (!query) {\n      throw new EmptyQueryError();\n    }\n\n    const session = this.ctx.sessions.getSession();\n    const request = buildGqlRequest(query, session, this.ctx.config, config);\n    const metadata = this.ctx.getSessionMetadata();\n    const timeoutMs = this.calculateTimeout(config);\n    const response: any = await promisifyCallWithDeadline(\n      this.ctx.clients.queryService,\n      'Profile',\n      request,\n      timeoutMs,\n      metadata\n    );\n\n    return response.profile || '';\n  }\n}\n"]}

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

@@ -0,0 +1,39 @@
+/**
+ * Shared context for all service classes.
+ * Contains gRPC clients, managers, and configuration.
+ */
+import * as grpc from '@grpc/grpc-js';
+import { GqldbConfig } from '../config';
+import { SessionManager } from '../session';
+import { TransactionManager } from '../transaction';
+/**
+ * Service client types for gRPC communication.
+ */
+export interface ServiceClients {
+    sessionService: grpc.Client;
+    queryService: grpc.Client;
+    graphService: grpc.Client;
+    transactionService: grpc.Client;
+    dataService: grpc.Client;
+    healthService: grpc.Client;
+    adminService: grpc.Client;
+    bulkImportService: grpc.Client;
+}
+/**
+ * Service context holds shared dependencies for all service classes.
+ */
+export declare class ServiceContext {
+    readonly config: GqldbConfig;
+    readonly sessions: SessionManager;
+    readonly txManager: TransactionManager;
+    readonly clients: ServiceClients;
+    constructor(config: GqldbConfig, sessions: SessionManager, txManager: TransactionManager, clients: ServiceClients);
+    /**
+     * Get session metadata for authenticated requests.
+     */
+    getSessionMetadata(): grpc.Metadata;
+    /**
+     * Update session activity timestamp.
+     */
+    updateActivity(): void;
+}

package/dist/services/service-context.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Shared context for all service classes.
+ * Contains gRPC clients, managers, and configuration.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceContext = void 0;
+const grpc = __importStar(require("@grpc/grpc-js"));
+/**
+ * Service context holds shared dependencies for all service classes.
+ */
+class ServiceContext {
+    config;
+    sessions;
+    txManager;
+    clients;
+    constructor(config, sessions, txManager, clients) {
+        this.config = config;
+        this.sessions = sessions;
+        this.txManager = txManager;
+        this.clients = clients;
+    }
+    /**
+     * Get session metadata for authenticated requests.
+     */
+    getSessionMetadata() {
+        const metadata = new grpc.Metadata();
+        const session = this.sessions.getSession();
+        metadata.add('session-id', session?.id?.toString() || '0');
+        return metadata;
+    }
+    /**
+     * Update session activity timestamp.
+     */
+    updateActivity() {
+        this.sessions.updateActivity();
+    }
+}
+exports.ServiceContext = ServiceContext;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,24 @@
+/**
+ * Session service handles authentication and session lifecycle.
+ */
+import { ServiceContext } from './service-context';
+import { Session } from '../session';
+/**
+ * Session service for authentication and session management.
+ */
+export declare class SessionService {
+    private ctx;
+    constructor(ctx: ServiceContext);
+    /**
+     * Authenticate the user and create a session.
+     */
+    login(username: string, password: string, defaultGraph: string): Promise<Session>;
+    /**
+     * Terminate the current session.
+     */
+    logout(): Promise<void>;
+    /**
+     * Check the connection and return the latency in nanoseconds.
+     */
+    ping(): Promise<number>;
+}