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

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":["/**\n * Transaction service handles transaction lifecycle management.\n */\n\nimport { ServiceContext } from './service-context';\nimport { Transaction } from '../transaction';\nimport { TransactionInfo } from '../types';\nimport { promisifyCall } from '../services';\n\n/**\n * Transaction service for managing database transactions.\n */\nexport class TransactionService {\n  constructor(private ctx: ServiceContext) {}\n\n  /**\n   * Start a new transaction.\n   */\n  async beginTransaction(\n    graphName: string,\n    readOnly: boolean = false,\n    timeout: number = 0\n  ): Promise<Transaction> {\n    const session = this.ctx.sessions.getSession();\n    const request = {\n      session_id: session?.id?.toString() || '0',\n      graph_name: graphName,\n      read_only: readOnly,\n      timeout: Math.floor((timeout || this.ctx.config.timeout || 30000) / 1000), // Convert ms to seconds for gRPC\n    };\n\n    const metadata = this.ctx.getSessionMetadata();\n    const response: any = await promisifyCall(\n      this.ctx.clients.transactionService,\n      'Begin',\n      request,\n      metadata\n    );\n\n    const txId = parseInt(response.transaction_id || '0', 10);\n    const sessionId = session?.id || 0;\n    const timeoutMs = timeout || this.ctx.config.timeout || 30000;\n    const tx = this.ctx.txManager.begin(txId, sessionId, graphName, readOnly, timeoutMs);\n    return tx;\n  }\n\n  /**\n   * Commit a transaction.\n   */\n  async commit(transactionId: number): Promise<boolean> {\n    const session = this.ctx.sessions.getSession();\n    const request = {\n      session_id: session?.id?.toString() || '0',\n      transaction_id: transactionId.toString(),\n    };\n\n    const metadata = this.ctx.getSessionMetadata();\n    const response: any = await promisifyCall(\n      this.ctx.clients.transactionService,\n      'Commit',\n      request,\n      metadata\n    );\n\n    this.ctx.txManager.commit(transactionId);\n    return response.success || false;\n  }\n\n  /**\n   * Rollback a transaction.\n   */\n  async rollback(transactionId: number): Promise<boolean> {\n    const session = this.ctx.sessions.getSession();\n    const request = {\n      session_id: session?.id?.toString() || '0',\n      transaction_id: transactionId.toString(),\n    };\n\n    const metadata = this.ctx.getSessionMetadata();\n    const response: any = await promisifyCall(\n      this.ctx.clients.transactionService,\n      'Rollback',\n      request,\n      metadata\n    );\n\n    this.ctx.txManager.rollback(transactionId);\n    return response.success || false;\n  }\n\n  /**\n   * Return active transactions for the current session.\n   */\n  async listTransactions(): Promise<TransactionInfo[]> {\n    const session = this.ctx.sessions.getSession();\n    const request = {\n      session_id: session?.id?.toString() || '0',\n    };\n\n    const metadata = this.ctx.getSessionMetadata();\n    const response: any = await promisifyCall(\n      this.ctx.clients.transactionService,\n      'ListTransactions',\n      request,\n      metadata\n    );\n\n    return (response.transactions || []).map((t: any) => ({\n      transactionId: parseInt(t.transaction_id || '0', 10),\n      sessionId: parseInt(t.session_id || '0', 10),\n      graphName: t.graph_name || '',\n      readOnly: t.read_only || false,\n      createdAt: parseInt(t.created_at || '0', 10),\n      durationMs: parseInt(t.duration_ms || '0', 10),\n      internalTxId: t.internal_tx_id || '',\n    }));\n  }\n\n  /**\n   * Execute a function within a transaction.\n   */\n  async withTransaction<T>(\n    graphName: string,\n    fn: (txId: number) => Promise<T>,\n    readOnly: boolean = false\n  ): Promise<T> {\n    const tx = await this.beginTransaction(graphName, readOnly, this.ctx.config.timeout ?? 30000);\n    try {\n      const result = await fn(tx.id);\n      await this.commit(tx.id);\n      return result;\n    } catch (e) {\n      await this.rollback(tx.id);\n      throw e;\n    }\n  }\n}\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":["/**\n * gRPC service clients for GQLDB Node.js driver.\n * Uses @grpc/proto-loader for dynamic proto loading.\n */\n\nimport * as grpc from '@grpc/grpc-js';\nimport * as protoLoader from '@grpc/proto-loader';\nimport * as path from 'path';\n\n// Proto loading options\nconst PROTO_OPTIONS: protoLoader.Options = {\n  keepCase: true,\n  longs: String,\n  enums: String,\n  defaults: true,\n  oneofs: true,\n};\n\n// Load proto definition (bundled with the package)\nconst PROTO_PATH = path.resolve(__dirname, './proto/gqldb.proto');\n\nlet packageDefinition: protoLoader.PackageDefinition;\nlet grpcObject: grpc.GrpcObject;\nlet gqldbPackage: any;\n\n/**\n * Load the proto file and return the gqldb package.\n * Caches the result for subsequent calls.\n */\nfunction loadProto(): any {\n  if (!gqldbPackage) {\n    packageDefinition = protoLoader.loadSync(PROTO_PATH, PROTO_OPTIONS);\n    grpcObject = grpc.loadPackageDefinition(packageDefinition);\n    gqldbPackage = grpcObject.gqldb;\n  }\n  return gqldbPackage;\n}\n\n/** Service client types */\nexport interface ServiceClients {\n  sessionService: grpc.Client;\n  queryService: grpc.Client;\n  graphService: grpc.Client;\n  transactionService: grpc.Client;\n  dataService: grpc.Client;\n  healthService: grpc.Client;\n  adminService: grpc.Client;\n  bulkImportService: grpc.Client;\n}\n\n/**\n * Create all gRPC service clients for a given host.\n */\nexport function createServiceClients(\n  host: string,\n  credentials: grpc.ChannelCredentials,\n  options?: grpc.ChannelOptions\n): ServiceClients {\n  const proto = loadProto();\n\n  return {\n    sessionService: new proto.SessionService(host, credentials, options),\n    queryService: new proto.QueryService(host, credentials, options),\n    graphService: new proto.GraphService(host, credentials, options),\n    transactionService: new proto.TransactionService(host, credentials, options),\n    dataService: new proto.DataService(host, credentials, options),\n    healthService: new proto.Health(host, credentials, options),\n    adminService: new proto.AdminService(host, credentials, options),\n    bulkImportService: new proto.BulkImportService(host, credentials, options),\n  };\n}\n\n/**\n * Helper to promisify unary gRPC calls.\n */\nexport function promisifyCall<TRequest, TResponse>(\n  client: any,\n  method: string,\n  request: TRequest,\n  metadata?: grpc.Metadata\n): Promise<TResponse> {\n  return new Promise((resolve, reject) => {\n    const fn = client[method].bind(client);\n    const meta = metadata || new grpc.Metadata();\n\n    fn(request, meta, (error: grpc.ServiceError | null, response: TResponse) => {\n      if (error) {\n        reject(error);\n      } else {\n        resolve(response);\n      }\n    });\n  });\n}\n\n/**\n * Helper to promisify unary gRPC calls with deadline.\n */\nexport function promisifyCallWithDeadline<TRequest, TResponse>(\n  client: any,\n  method: string,\n  request: TRequest,\n  timeoutMs: number,\n  metadata?: grpc.Metadata\n): Promise<TResponse> {\n  return new Promise((resolve, reject) => {\n    const fn = client[method].bind(client);\n    const meta = metadata || new grpc.Metadata();\n    const deadline = new Date(Date.now() + timeoutMs);\n\n    fn(request, meta, { deadline }, (error: grpc.ServiceError | null, response: TResponse) => {\n      if (error) {\n        reject(error);\n      } else {\n        resolve(response);\n      }\n    });\n  });\n}\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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Vzc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9zZXNzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7R0FFRzs7O0FBZ0JILHNDQUFzQztBQUN0QyxNQUFhLGNBQWM7SUFDakIsT0FBTyxHQUFtQixJQUFJLENBQUM7SUFFdkMsMkJBQTJCO0lBQzNCLEtBQUssQ0FDSCxTQUFpQixFQUNqQixhQUFxQixFQUNyQixLQUFlLEVBQ2YsWUFBb0IsRUFDcEIsV0FBa0Y7UUFFbEYsSUFBSSxDQUFDLE9BQU8sR0FBRztZQUNiLEVBQUUsRUFBRSxTQUFTO1lBQ2IsYUFBYTtZQUNiLEtBQUs7WUFDTCxZQUFZO1lBQ1osU0FBUyxFQUFFLElBQUksQ0FBQyxHQUFHLEVBQUU7WUFDckIsWUFBWSxFQUFFLElBQUksQ0FBQyxHQUFHLEVBQUU7WUFDeEIsU0FBUyxFQUFFLFdBQVcsRUFBRSxTQUFTLElBQUksS0FBSztZQUMxQyxTQUFTLEVBQUUsV0FBVyxFQUFFLFNBQVMsSUFBSSxFQUFFO1lBQ3ZDLGNBQWMsRUFBRSxXQUFXLEVBQUUsY0FBYyxJQUFJLENBQUM7U0FDakQsQ0FBQztRQUNGLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQztJQUN0QixDQUFDO0lBRUQsZ0NBQWdDO0lBQ2hDLE1BQU07UUFDSixJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQztJQUN0QixDQUFDO0lBRUQsOEJBQThCO0lBQzlCLFVBQVU7UUFDUixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7SUFDdEIsQ0FBQztJQUVELGlDQUFpQztJQUNqQyxZQUFZO1FBQ1YsT0FBTyxJQUFJLENBQUMsT0FBTyxFQUFFLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFDL0IsQ0FBQztJQUVELDBDQUEwQztJQUMxQyxVQUFVO1FBQ1IsT0FBTyxJQUFJLENBQUMsT0FBTyxLQUFLLElBQUksQ0FBQztJQUMvQixDQUFDO0lBRUQsb0NBQW9DO0lBQ3BDLGNBQWM7UUFDWixJQUFJLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUNqQixJQUFJLENBQUMsT0FBTyxDQUFDLFlBQVksR0FBRyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDekMsQ0FBQztJQUNILENBQUM7SUFFRCw0Q0FBNEM7SUFDNUMsZUFBZSxDQUFDLEtBQWE7UUFDM0IsSUFBSSxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDakIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxZQUFZLEdBQUcsS0FBSyxDQUFDO1FBQ3BDLENBQUM7SUFDSCxDQUFDO0lBRUQsNENBQTRDO0lBQzVDLGVBQWU7UUFDYixPQUFPLElBQUksQ0FBQyxPQUFPLEVBQUUsWUFBWSxJQUFJLEVBQUUsQ0FBQztJQUMxQyxDQUFDO0lBRUQsK0NBQStDO0lBQy9DLE9BQU8sQ0FBQyxJQUFZO1FBQ2xCLE9BQU8sSUFBSSxDQUFDLE9BQU8sRUFBRSxLQUFLLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxJQUFJLEtBQUssQ0FBQztJQUNyRCxDQUFDO0lBRUQsNkRBQTZEO0lBQzdELFlBQVk7UUFDVixJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU87WUFBRSxPQUFPLENBQUMsQ0FBQztRQUM1QixPQUFPLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLFlBQVksQ0FBQztJQUNoRCxDQUFDO0lBRUQsK0RBQStEO0lBQy9ELEdBQUc7UUFDRCxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU87WUFBRSxPQUFPLENBQUMsQ0FBQztRQUM1QixPQUFPLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQztJQUM3QyxDQUFDO0NBQ0Y7QUFoRkQsd0NBZ0ZDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBTZXNzaW9uIG1hbmFnZW1lbnQgZm9yIEdRTERCIE5vZGUuanMgZHJpdmVyLlxuICovXG5cbi8qKiBSZXByZXNlbnRzIGFuIGF1dGhlbnRpY2F0ZWQgc2Vzc2lvbiAqL1xuZXhwb3J0IGludGVyZmFjZSBTZXNzaW9uIHtcbiAgaWQ6IG51bWJlcjtcbiAgc2VydmVyVmVyc2lvbjogc3RyaW5nO1xuICByb2xlczogc3RyaW5nW107XG4gIGRlZmF1bHRHcmFwaDogc3RyaW5nO1xuICBjcmVhdGVkQXQ6IG51bWJlcjtcbiAgbGFzdEFjdGl2aXR5OiBudW1iZXI7XG4gIC8vIENsdXN0ZXIgZXh0ZW5zaW9uc1xuICBpc0NsdXN0ZXI/OiBib29sZWFuO1xuICBjbHVzdGVySWQ/OiBzdHJpbmc7XG4gIHBhcnRpdGlvbkNvdW50PzogbnVtYmVyO1xufVxuXG4vKiogTWFuYWdlcyBzZXNzaW9ucyBmb3IgdGhlIGNsaWVudCAqL1xuZXhwb3J0IGNsYXNzIFNlc3Npb25NYW5hZ2VyIHtcbiAgcHJpdmF0ZSBzZXNzaW9uOiBTZXNzaW9uIHwgbnVsbCA9IG51bGw7XG5cbiAgLyoqIENyZWF0ZSBhIG5ldyBzZXNzaW9uICovXG4gIGxvZ2luKFxuICAgIHNlc3Npb25JZDogbnVtYmVyLFxuICAgIHNlcnZlclZlcnNpb246IHN0cmluZyxcbiAgICByb2xlczogc3RyaW5nW10sXG4gICAgZGVmYXVsdEdyYXBoOiBzdHJpbmcsXG4gICAgY2x1c3RlckluZm8/OiB7IGlzQ2x1c3Rlcj86IGJvb2xlYW47IGNsdXN0ZXJJZD86IHN0cmluZzsgcGFydGl0aW9uQ291bnQ/OiBudW1iZXIgfVxuICApOiBTZXNzaW9uIHtcbiAgICB0aGlzLnNlc3Npb24gPSB7XG4gICAgICBpZDogc2Vzc2lvbklkLFxuICAgICAgc2VydmVyVmVyc2lvbixcbiAgICAgIHJvbGVzLFxuICAgICAgZGVmYXVsdEdyYXBoLFxuICAgICAgY3JlYXRlZEF0OiBEYXRlLm5vdygpLFxuICAgICAgbGFzdEFjdGl2aXR5OiBEYXRlLm5vdygpLFxuICAgICAgaXNDbHVzdGVyOiBjbHVzdGVySW5mbz8uaXNDbHVzdGVyIHx8IGZhbHNlLFxuICAgICAgY2x1c3RlcklkOiBjbHVzdGVySW5mbz8uY2x1c3RlcklkIHx8ICcnLFxuICAgICAgcGFydGl0aW9uQ291bnQ6IGNsdXN0ZXJJbmZvPy5wYXJ0aXRpb25Db3VudCB8fCAwLFxuICAgIH07XG4gICAgcmV0dXJuIHRoaXMuc2Vzc2lvbjtcbiAgfVxuXG4gIC8qKiBDbGVhciB0aGUgY3VycmVudCBzZXNzaW9uICovXG4gIGxvZ291dCgpOiB2b2lkIHtcbiAgICB0aGlzLnNlc3Npb24gPSBudWxsO1xuICB9XG5cbiAgLyoqIEdldCB0aGUgY3VycmVudCBzZXNzaW9uICovXG4gIGdldFNlc3Npb24oKTogU2Vzc2lvbiB8IG51bGwge1xuICAgIHJldHVybiB0aGlzLnNlc3Npb247XG4gIH1cblxuICAvKiogR2V0IHRoZSBjdXJyZW50IHNlc3Npb24gSUQgKi9cbiAgZ2V0U2Vzc2lvbklkKCk6IG51bWJlciB7XG4gICAgcmV0dXJuIHRoaXMuc2Vzc2lvbj8uaWQgPz8gMDtcbiAgfVxuXG4gIC8qKiBDaGVjayBpZiB0aGVyZSBpcyBhbiBhY3RpdmUgc2Vzc2lvbiAqL1xuICBpc0xvZ2dlZEluKCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiB0aGlzLnNlc3Npb24gIT09IG51bGw7XG4gIH1cblxuICAvKiogVXBkYXRlIHRoZSBsYXN0IGFjdGl2aXR5IHRpbWUgKi9cbiAgdXBkYXRlQWN0aXZpdHkoKTogdm9pZCB7XG4gICAgaWYgKHRoaXMuc2Vzc2lvbikge1xuICAgICAgdGhpcy5zZXNzaW9uLmxhc3RBY3Rpdml0eSA9IERhdGUubm93KCk7XG4gICAgfVxuICB9XG5cbiAgLyoqIFNldCB0aGUgZGVmYXVsdCBncmFwaCBmb3IgdGhlIHNlc3Npb24gKi9cbiAgc2V0RGVmYXVsdEdyYXBoKGdyYXBoOiBzdHJpbmcpOiB2b2lkIHtcbiAgICBpZiAodGhpcy5zZXNzaW9uKSB7XG4gICAgICB0aGlzLnNlc3Npb24uZGVmYXVsdEdyYXBoID0gZ3JhcGg7XG4gICAgfVxuICB9XG5cbiAgLyoqIEdldCB0aGUgZGVmYXVsdCBncmFwaCBmb3IgdGhlIHNlc3Npb24gKi9cbiAgZ2V0RGVmYXVsdEdyYXBoKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuIHRoaXMuc2Vzc2lvbj8uZGVmYXVsdEdyYXBoID8/ICcnO1xuICB9XG5cbiAgLyoqIENoZWNrIGlmIHRoZSBzZXNzaW9uIGhhcyBhIHNwZWNpZmljIHJvbGUgKi9cbiAgaGFzUm9sZShyb2xlOiBzdHJpbmcpOiBib29sZWFuIHtcbiAgICByZXR1cm4gdGhpcy5zZXNzaW9uPy5yb2xlcy5pbmNsdWRlcyhyb2xlKSA/PyBmYWxzZTtcbiAgfVxuXG4gIC8qKiBHZXQgaG93IGxvbmcgdGhlIHNlc3Npb24gaGFzIGJlZW4gaWRsZSBpbiBtaWxsaXNlY29uZHMgKi9cbiAgaWRsZUR1cmF0aW9uKCk6IG51bWJlciB7XG4gICAgaWYgKCF0aGlzLnNlc3Npb24pIHJldHVybiAwO1xuICAgIHJldHVybiBEYXRlLm5vdygpIC0gdGhpcy5zZXNzaW9uLmxhc3RBY3Rpdml0eTtcbiAgfVxuXG4gIC8qKiBHZXQgaG93IGxvbmcgdGhlIHNlc3Npb24gaGFzIGJlZW4gYWN0aXZlIGluIG1pbGxpc2Vjb25kcyAqL1xuICBhZ2UoKTogbnVtYmVyIHtcbiAgICBpZiAoIXRoaXMuc2Vzc2lvbikgcmV0dXJuIDA7XG4gICAgcmV0dXJuIERhdGUubm93KCkgLSB0aGlzLnNlc3Npb24uY3JlYXRlZEF0O1xuICB9XG59XG4iXX0=

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;
+}