ultipa 6.0.0

package/dist/services/session-service.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Session service handles authentication and session lifecycle.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionService = void 0;
+const errors_1 = require("../errors");
+const services_1 = require("../services");
+/**
+ * Session service for authentication and session management.
+ */
+class SessionService {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /**
+     * Authenticate the user and create a session.
+     */
+    async login(username, password, defaultGraph) {
+        const request = {
+            username,
+            password,
+            default_graph: defaultGraph || '',
+        };
+        try {
+            const response = await (0, services_1.promisifyCall)(this.ctx.clients.sessionService, 'Login', request);
+            const session = this.ctx.sessions.login(parseInt(response.session_id || '0', 10), response.server_version || '', response.roles || [], defaultGraph || '', {
+                isCluster: response.is_cluster || false,
+                clusterId: response.cluster_id || '',
+                partitionCount: response.partition_count || 0,
+            });
+            return session;
+        }
+        catch (error) {
+            throw new errors_1.LoginFailedError(error.message || 'Login failed');
+        }
+    }
+    /**
+     * Terminate the current session.
+     */
+    async logout() {
+        if (!this.ctx.sessions.isLoggedIn())
+            return;
+        try {
+            const metadata = this.ctx.getSessionMetadata();
+            await (0, services_1.promisifyCall)(this.ctx.clients.sessionService, 'Logout', {}, metadata);
+        }
+        catch (e) {
+            // Ignore logout errors
+        }
+        this.ctx.txManager.clearAll();
+        this.ctx.sessions.logout();
+    }
+    /**
+     * Check the connection and return the latency in nanoseconds.
+     */
+    async ping() {
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.sessionService, 'Ping', {}, metadata);
+        this.ctx.updateActivity();
+        return parseInt(response.latency_ns || '0', 10);
+    }
+}
+exports.SessionService = SessionService;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,33 @@
+/**
+ * Transaction service handles transaction lifecycle management.
+ */
+import { ServiceContext } from './service-context';
+import { Transaction } from '../transaction';
+import { TransactionInfo } from '../types';
+/**
+ * Transaction service for managing database transactions.
+ */
+export declare class TransactionService {
+    private ctx;
+    constructor(ctx: ServiceContext);
+    /**
+     * Start a new transaction.
+     */
+    beginTransaction(graphName: string, readOnly?: boolean, timeout?: number): Promise<Transaction>;
+    /**
+     * Commit a transaction.
+     */
+    commit(transactionId: number): Promise<boolean>;
+    /**
+     * Rollback a transaction.
+     */
+    rollback(transactionId: number): Promise<boolean>;
+    /**
+     * Return active transactions for the current session.
+     */
+    listTransactions(): Promise<TransactionInfo[]>;
+    /**
+     * Execute a function within a transaction.
+     */
+    withTransaction<T>(graphName: string, fn: (txId: number) => Promise<T>, readOnly?: boolean): Promise<T>;
+}

package/dist/services/transaction-service.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Transaction service handles transaction lifecycle management.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionService = void 0;
+const services_1 = require("../services");
+/**
+ * Transaction service for managing database transactions.
+ */
+class TransactionService {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /**
+     * Start a new transaction.
+     */
+    async beginTransaction(graphName, readOnly = false, timeout = 0) {
+        const session = this.ctx.sessions.getSession();
+        const request = {
+            session_id: session?.id?.toString() || '0',
+            graph_name: graphName,
+            read_only: readOnly,
+            timeout: Math.floor((timeout || this.ctx.config.timeout || 30000) / 1000), // Convert ms to seconds for gRPC
+        };
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.transactionService, 'Begin', request, metadata);
+        const txId = parseInt(response.transaction_id || '0', 10);
+        const sessionId = session?.id || 0;
+        const timeoutMs = timeout || this.ctx.config.timeout || 30000;
+        const tx = this.ctx.txManager.begin(txId, sessionId, graphName, readOnly, timeoutMs);
+        return tx;
+    }
+    /**
+     * Commit a transaction.
+     */
+    async commit(transactionId) {
+        const session = this.ctx.sessions.getSession();
+        const request = {
+            session_id: session?.id?.toString() || '0',
+            transaction_id: transactionId.toString(),
+        };
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.transactionService, 'Commit', request, metadata);
+        this.ctx.txManager.commit(transactionId);
+        return response.success || false;
+    }
+    /**
+     * Rollback a transaction.
+     */
+    async rollback(transactionId) {
+        const session = this.ctx.sessions.getSession();
+        const request = {
+            session_id: session?.id?.toString() || '0',
+            transaction_id: transactionId.toString(),
+        };
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.transactionService, 'Rollback', request, metadata);
+        this.ctx.txManager.rollback(transactionId);
+        return response.success || false;
+    }
+    /**
+     * Return active transactions for the current session.
+     */
+    async listTransactions() {
+        const session = this.ctx.sessions.getSession();
+        const request = {
+            session_id: session?.id?.toString() || '0',
+        };
+        const metadata = this.ctx.getSessionMetadata();
+        const response = await (0, services_1.promisifyCall)(this.ctx.clients.transactionService, 'ListTransactions', request, metadata);
+        return (response.transactions || []).map((t) => ({
+            transactionId: parseInt(t.transaction_id || '0', 10),
+            sessionId: parseInt(t.session_id || '0', 10),
+            graphName: t.graph_name || '',
+            readOnly: t.read_only || false,
+            createdAt: parseInt(t.created_at || '0', 10),
+            durationMs: parseInt(t.duration_ms || '0', 10),
+            internalTxId: t.internal_tx_id || '',
+        }));
+    }
+    /**
+     * Execute a function within a transaction.
+     */
+    async withTransaction(graphName, fn, readOnly = false) {
+        const tx = await this.beginTransaction(graphName, readOnly, this.ctx.config.timeout ?? 30000);
+        try {
+            const result = await fn(tx.id);
+            await this.commit(tx.id);
+            return result;
+        }
+        catch (e) {
+            await this.rollback(tx.id);
+            throw e;
+        }
+    }
+}
+exports.TransactionService = TransactionService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction-service.js","sourceRoot":"","sources":["../../src/services/transaction-service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Transaction service handles transaction lifecycle management.\r\n */\r\n\r\nimport { ServiceContext } from './service-context';\r\nimport { Transaction } from '../transaction';\r\nimport { TransactionInfo } from '../types';\r\nimport { promisifyCall } from '../services';\r\n\r\n/**\r\n * Transaction service for managing database transactions.\r\n */\r\nexport class TransactionService {\r\n  constructor(private ctx: ServiceContext) {}\r\n\r\n  /**\r\n   * Start a new transaction.\r\n   */\r\n  async beginTransaction(\r\n    graphName: string,\r\n    readOnly: boolean = false,\r\n    timeout: number = 0\r\n  ): Promise<Transaction> {\r\n    const session = this.ctx.sessions.getSession();\r\n    const request = {\r\n      session_id: session?.id?.toString() || '0',\r\n      graph_name: graphName,\r\n      read_only: readOnly,\r\n      timeout: Math.floor((timeout || this.ctx.config.timeout || 30000) / 1000), // Convert ms to seconds for gRPC\r\n    };\r\n\r\n    const metadata = this.ctx.getSessionMetadata();\r\n    const response: any = await promisifyCall(\r\n      this.ctx.clients.transactionService,\r\n      'Begin',\r\n      request,\r\n      metadata\r\n    );\r\n\r\n    const txId = parseInt(response.transaction_id || '0', 10);\r\n    const sessionId = session?.id || 0;\r\n    const timeoutMs = timeout || this.ctx.config.timeout || 30000;\r\n    const tx = this.ctx.txManager.begin(txId, sessionId, graphName, readOnly, timeoutMs);\r\n    return tx;\r\n  }\r\n\r\n  /**\r\n   * Commit a transaction.\r\n   */\r\n  async commit(transactionId: number): Promise<boolean> {\r\n    const session = this.ctx.sessions.getSession();\r\n    const request = {\r\n      session_id: session?.id?.toString() || '0',\r\n      transaction_id: transactionId.toString(),\r\n    };\r\n\r\n    const metadata = this.ctx.getSessionMetadata();\r\n    const response: any = await promisifyCall(\r\n      this.ctx.clients.transactionService,\r\n      'Commit',\r\n      request,\r\n      metadata\r\n    );\r\n\r\n    this.ctx.txManager.commit(transactionId);\r\n    return response.success || false;\r\n  }\r\n\r\n  /**\r\n   * Rollback a transaction.\r\n   */\r\n  async rollback(transactionId: number): Promise<boolean> {\r\n    const session = this.ctx.sessions.getSession();\r\n    const request = {\r\n      session_id: session?.id?.toString() || '0',\r\n      transaction_id: transactionId.toString(),\r\n    };\r\n\r\n    const metadata = this.ctx.getSessionMetadata();\r\n    const response: any = await promisifyCall(\r\n      this.ctx.clients.transactionService,\r\n      'Rollback',\r\n      request,\r\n      metadata\r\n    );\r\n\r\n    this.ctx.txManager.rollback(transactionId);\r\n    return response.success || false;\r\n  }\r\n\r\n  /**\r\n   * Return active transactions for the current session.\r\n   */\r\n  async listTransactions(): Promise<TransactionInfo[]> {\r\n    const session = this.ctx.sessions.getSession();\r\n    const request = {\r\n      session_id: session?.id?.toString() || '0',\r\n    };\r\n\r\n    const metadata = this.ctx.getSessionMetadata();\r\n    const response: any = await promisifyCall(\r\n      this.ctx.clients.transactionService,\r\n      'ListTransactions',\r\n      request,\r\n      metadata\r\n    );\r\n\r\n    return (response.transactions || []).map((t: any) => ({\r\n      transactionId: parseInt(t.transaction_id || '0', 10),\r\n      sessionId: parseInt(t.session_id || '0', 10),\r\n      graphName: t.graph_name || '',\r\n      readOnly: t.read_only || false,\r\n      createdAt: parseInt(t.created_at || '0', 10),\r\n      durationMs: parseInt(t.duration_ms || '0', 10),\r\n      internalTxId: t.internal_tx_id || '',\r\n    }));\r\n  }\r\n\r\n  /**\r\n   * Execute a function within a transaction.\r\n   */\r\n  async withTransaction<T>(\r\n    graphName: string,\r\n    fn: (txId: number) => Promise<T>,\r\n    readOnly: boolean = false\r\n  ): Promise<T> {\r\n    const tx = await this.beginTransaction(graphName, readOnly, this.ctx.config.timeout ?? 30000);\r\n    try {\r\n      const result = await fn(tx.id);\r\n      await this.commit(tx.id);\r\n      return result;\r\n    } catch (e) {\r\n      await this.rollback(tx.id);\r\n      throw e;\r\n    }\r\n  }\r\n}\r\n"]}

package/dist/services.d.ts

@@ -0,0 +1,28 @@
+/**
+ * gRPC service clients for GQLDB Node.js driver.
+ * Uses @grpc/proto-loader for dynamic proto loading.
+ */
+import * as grpc from '@grpc/grpc-js';
+/** Service client types */
+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;
+}
+/**
+ * Create all gRPC service clients for a given host.
+ */
+export declare function createServiceClients(host: string, credentials: grpc.ChannelCredentials, options?: grpc.ChannelOptions): ServiceClients;
+/**
+ * Helper to promisify unary gRPC calls.
+ */
+export declare function promisifyCall<TRequest, TResponse>(client: any, method: string, request: TRequest, metadata?: grpc.Metadata): Promise<TResponse>;
+/**
+ * Helper to promisify unary gRPC calls with deadline.
+ */
+export declare function promisifyCallWithDeadline<TRequest, TResponse>(client: any, method: string, request: TRequest, timeoutMs: number, metadata?: grpc.Metadata): Promise<TResponse>;

package/dist/services.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * gRPC service clients for GQLDB Node.js driver.
+ * Uses @grpc/proto-loader for dynamic proto loading.
+ */
+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.createServiceClients = createServiceClients;
+exports.promisifyCall = promisifyCall;
+exports.promisifyCallWithDeadline = promisifyCallWithDeadline;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const protoLoader = __importStar(require("@grpc/proto-loader"));
+const path = __importStar(require("path"));
+// Proto loading options
+const PROTO_OPTIONS = {
+    keepCase: true,
+    longs: String,
+    enums: String,
+    defaults: true,
+    oneofs: true,
+};
+// Load proto definition (bundled with the package)
+const PROTO_PATH = path.resolve(__dirname, './proto/gqldb.proto');
+let packageDefinition;
+let grpcObject;
+let gqldbPackage;
+/**
+ * Load the proto file and return the gqldb package.
+ * Caches the result for subsequent calls.
+ */
+function loadProto() {
+    if (!gqldbPackage) {
+        packageDefinition = protoLoader.loadSync(PROTO_PATH, PROTO_OPTIONS);
+        grpcObject = grpc.loadPackageDefinition(packageDefinition);
+        gqldbPackage = grpcObject.gqldb;
+    }
+    return gqldbPackage;
+}
+/**
+ * Create all gRPC service clients for a given host.
+ */
+function createServiceClients(host, credentials, options) {
+    const proto = loadProto();
+    return {
+        sessionService: new proto.SessionService(host, credentials, options),
+        queryService: new proto.QueryService(host, credentials, options),
+        graphService: new proto.GraphService(host, credentials, options),
+        transactionService: new proto.TransactionService(host, credentials, options),
+        dataService: new proto.DataService(host, credentials, options),
+        healthService: new proto.Health(host, credentials, options),
+        adminService: new proto.AdminService(host, credentials, options),
+        bulkImportService: new proto.BulkImportService(host, credentials, options),
+    };
+}
+/**
+ * Helper to promisify unary gRPC calls.
+ */
+function promisifyCall(client, method, request, metadata) {
+    return new Promise((resolve, reject) => {
+        const fn = client[method].bind(client);
+        const meta = metadata || new grpc.Metadata();
+        fn(request, meta, (error, response) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(response);
+            }
+        });
+    });
+}
+/**
+ * Helper to promisify unary gRPC calls with deadline.
+ */
+function promisifyCallWithDeadline(client, method, request, timeoutMs, metadata) {
+    return new Promise((resolve, reject) => {
+        const fn = client[method].bind(client);
+        const meta = metadata || new grpc.Metadata();
+        const deadline = new Date(Date.now() + timeoutMs);
+        fn(request, meta, { deadline }, (error, response) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(response);
+            }
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"services.js","sourceRoot":"","sources":["../src/services.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * gRPC service clients for GQLDB Node.js driver.\r\n * Uses @grpc/proto-loader for dynamic proto loading.\r\n */\r\n\r\nimport * as grpc from '@grpc/grpc-js';\r\nimport * as protoLoader from '@grpc/proto-loader';\r\nimport * as path from 'path';\r\n\r\n// Proto loading options\r\nconst PROTO_OPTIONS: protoLoader.Options = {\r\n  keepCase: true,\r\n  longs: String,\r\n  enums: String,\r\n  defaults: true,\r\n  oneofs: true,\r\n};\r\n\r\n// Load proto definition (bundled with the package)\r\nconst PROTO_PATH = path.resolve(__dirname, './proto/gqldb.proto');\r\n\r\nlet packageDefinition: protoLoader.PackageDefinition;\r\nlet grpcObject: grpc.GrpcObject;\r\nlet gqldbPackage: any;\r\n\r\n/**\r\n * Load the proto file and return the gqldb package.\r\n * Caches the result for subsequent calls.\r\n */\r\nfunction loadProto(): any {\r\n  if (!gqldbPackage) {\r\n    packageDefinition = protoLoader.loadSync(PROTO_PATH, PROTO_OPTIONS);\r\n    grpcObject = grpc.loadPackageDefinition(packageDefinition);\r\n    gqldbPackage = grpcObject.gqldb;\r\n  }\r\n  return gqldbPackage;\r\n}\r\n\r\n/** Service client types */\r\nexport interface ServiceClients {\r\n  sessionService: grpc.Client;\r\n  queryService: grpc.Client;\r\n  graphService: grpc.Client;\r\n  transactionService: grpc.Client;\r\n  dataService: grpc.Client;\r\n  healthService: grpc.Client;\r\n  adminService: grpc.Client;\r\n  bulkImportService: grpc.Client;\r\n}\r\n\r\n/**\r\n * Create all gRPC service clients for a given host.\r\n */\r\nexport function createServiceClients(\r\n  host: string,\r\n  credentials: grpc.ChannelCredentials,\r\n  options?: grpc.ChannelOptions\r\n): ServiceClients {\r\n  const proto = loadProto();\r\n\r\n  return {\r\n    sessionService: new proto.SessionService(host, credentials, options),\r\n    queryService: new proto.QueryService(host, credentials, options),\r\n    graphService: new proto.GraphService(host, credentials, options),\r\n    transactionService: new proto.TransactionService(host, credentials, options),\r\n    dataService: new proto.DataService(host, credentials, options),\r\n    healthService: new proto.Health(host, credentials, options),\r\n    adminService: new proto.AdminService(host, credentials, options),\r\n    bulkImportService: new proto.BulkImportService(host, credentials, options),\r\n  };\r\n}\r\n\r\n/**\r\n * Helper to promisify unary gRPC calls.\r\n */\r\nexport function promisifyCall<TRequest, TResponse>(\r\n  client: any,\r\n  method: string,\r\n  request: TRequest,\r\n  metadata?: grpc.Metadata\r\n): Promise<TResponse> {\r\n  return new Promise((resolve, reject) => {\r\n    const fn = client[method].bind(client);\r\n    const meta = metadata || new grpc.Metadata();\r\n\r\n    fn(request, meta, (error: grpc.ServiceError | null, response: TResponse) => {\r\n      if (error) {\r\n        reject(error);\r\n      } else {\r\n        resolve(response);\r\n      }\r\n    });\r\n  });\r\n}\r\n\r\n/**\r\n * Helper to promisify unary gRPC calls with deadline.\r\n */\r\nexport function promisifyCallWithDeadline<TRequest, TResponse>(\r\n  client: any,\r\n  method: string,\r\n  request: TRequest,\r\n  timeoutMs: number,\r\n  metadata?: grpc.Metadata\r\n): Promise<TResponse> {\r\n  return new Promise((resolve, reject) => {\r\n    const fn = client[method].bind(client);\r\n    const meta = metadata || new grpc.Metadata();\r\n    const deadline = new Date(Date.now() + timeoutMs);\r\n\r\n    fn(request, meta, { deadline }, (error: grpc.ServiceError | null, response: TResponse) => {\r\n      if (error) {\r\n        reject(error);\r\n      } else {\r\n        resolve(response);\r\n      }\r\n    });\r\n  });\r\n}\r\n"]}

package/dist/session.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Session management for GQLDB Node.js driver.
+ */
+/** Represents an authenticated session */
+export interface Session {
+    id: number;
+    serverVersion: string;
+    roles: string[];
+    defaultGraph: string;
+    createdAt: number;
+    lastActivity: number;
+    isCluster?: boolean;
+    clusterId?: string;
+    partitionCount?: number;
+}
+/** Manages sessions for the client */
+export declare class SessionManager {
+    private session;
+    /** Create a new session */
+    login(sessionId: number, serverVersion: string, roles: string[], defaultGraph: string, clusterInfo?: {
+        isCluster?: boolean;
+        clusterId?: string;
+        partitionCount?: number;
+    }): Session;
+    /** Clear the current session */
+    logout(): void;
+    /** Get the current session */
+    getSession(): Session | null;
+    /** Get the current session ID */
+    getSessionId(): number;
+    /** Check if there is an active session */
+    isLoggedIn(): boolean;
+    /** Update the last activity time */
+    updateActivity(): void;
+    /** Set the default graph for the session */
+    setDefaultGraph(graph: string): void;
+    /** Get the default graph for the session */
+    getDefaultGraph(): string;
+    /** Check if the session has a specific role */
+    hasRole(role: string): boolean;
+    /** Get how long the session has been idle in milliseconds */
+    idleDuration(): number;
+    /** Get how long the session has been active in milliseconds */
+    age(): number;
+}

package/dist/session.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Session management for GQLDB Node.js driver.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+/** Manages sessions for the client */
+class SessionManager {
+    session = null;
+    /** Create a new session */
+    login(sessionId, serverVersion, roles, defaultGraph, clusterInfo) {
+        this.session = {
+            id: sessionId,
+            serverVersion,
+            roles,
+            defaultGraph,
+            createdAt: Date.now(),
+            lastActivity: Date.now(),
+            isCluster: clusterInfo?.isCluster || false,
+            clusterId: clusterInfo?.clusterId || '',
+            partitionCount: clusterInfo?.partitionCount || 0,
+        };
+        return this.session;
+    }
+    /** Clear the current session */
+    logout() {
+        this.session = null;
+    }
+    /** Get the current session */
+    getSession() {
+        return this.session;
+    }
+    /** Get the current session ID */
+    getSessionId() {
+        return this.session?.id ?? 0;
+    }
+    /** Check if there is an active session */
+    isLoggedIn() {
+        return this.session !== null;
+    }
+    /** Update the last activity time */
+    updateActivity() {
+        if (this.session) {
+            this.session.lastActivity = Date.now();
+        }
+    }
+    /** Set the default graph for the session */
+    setDefaultGraph(graph) {
+        if (this.session) {
+            this.session.defaultGraph = graph;
+        }
+    }
+    /** Get the default graph for the session */
+    getDefaultGraph() {
+        return this.session?.defaultGraph ?? '';
+    }
+    /** Check if the session has a specific role */
+    hasRole(role) {
+        return this.session?.roles.includes(role) ?? false;
+    }
+    /** Get how long the session has been idle in milliseconds */
+    idleDuration() {
+        if (!this.session)
+            return 0;
+        return Date.now() - this.session.lastActivity;
+    }
+    /** Get how long the session has been active in milliseconds */
+    age() {
+        if (!this.session)
+            return 0;
+        return Date.now() - this.session.createdAt;
+    }
+}
+exports.SessionManager = SessionManager;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/transaction.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Transaction management for GQLDB Node.js driver.
+ */
+/** Represents an active database transaction */
+export interface Transaction {
+    id: number;
+    sessionId: number;
+    graphName: string;
+    readOnly: boolean;
+    createdAt: number;
+    timeout: number;
+    committed: boolean;
+    rolledBack: boolean;
+}
+/** Manages transactions for the client */
+export declare class TransactionManager {
+    private transactions;
+    /** Create a new transaction */
+    begin(txId: number, sessionId: number, graphName: string, readOnly: boolean, timeout: number): Transaction;
+    /** Mark a transaction as committed */
+    commit(txId: number): void;
+    /** Mark a transaction as rolled back */
+    rollback(txId: number): void;
+    /** Get a transaction by ID */
+    get(txId: number): Transaction | undefined;
+    /** Get all active transactions */
+    getActive(): Transaction[];
+    /** Get all active transactions for a session */
+    getActiveForSession(sessionId: number): Transaction[];
+    /** Check if there are any active transactions */
+    hasActive(): boolean;
+    /** Get the number of active transactions */
+    count(): number;
+    /** Clear all transactions */
+    clearAll(): void;
+    /** Check if a transaction is active */
+    isActive(txId: number): boolean;
+    /** Check if a transaction has expired */
+    isExpired(txId: number): boolean;
+    /** Get transaction age in milliseconds */
+    age(txId: number): number;
+}