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

package/dist/config.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * Configuration for GQLDB Node.js driver.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigBuilder = exports.DEFAULT_CONFIG = void 0;
+exports.validateConfig = validateConfig;
+exports.createConfig = createConfig;
+/** Default configuration values */
+exports.DEFAULT_CONFIG = {
+    hosts: ['localhost:9000'],
+    timeout: 30000, // 30 seconds (in milliseconds)
+    maxRecvSize: 64 * 1024 * 1024, // 64MB
+    poolSize: 10,
+    healthCheckInterval: 30000, // 30 seconds (in milliseconds)
+    retryCount: 3,
+    retryDelay: 100, // 100ms
+};
+/** Builder for creating GqldbConfig */
+class ConfigBuilder {
+    config = {};
+    /** Set the server hosts */
+    hosts(...hosts) {
+        this.config.hosts = hosts;
+        return this;
+    }
+    /** Set the username for authentication */
+    username(username) {
+        this.config.username = username;
+        return this;
+    }
+    /** Set the password for authentication */
+    password(password) {
+        this.config.password = password;
+        return this;
+    }
+    /** Set the default graph */
+    defaultGraph(graph) {
+        this.config.defaultGraph = graph;
+        return this;
+    }
+    /** Set the query timeout in milliseconds */
+    timeout(ms) {
+        this.config.timeout = ms;
+        return this;
+    }
+    /** Set the query timeout in seconds (convenience method) */
+    timeoutSeconds(seconds) {
+        this.config.timeout = seconds * 1000;
+        return this;
+    }
+    /** Set the maximum receive message size */
+    maxRecvSize(bytes) {
+        this.config.maxRecvSize = bytes;
+        return this;
+    }
+    /** Set TLS options */
+    tls(options) {
+        this.config.tlsOptions = options;
+        return this;
+    }
+    /** Set the connection pool size per host */
+    poolSize(size) {
+        this.config.poolSize = size;
+        return this;
+    }
+    /** Set the health check interval in milliseconds */
+    healthCheckInterval(ms) {
+        this.config.healthCheckInterval = ms;
+        return this;
+    }
+    /** Set the number of retries */
+    retryCount(count) {
+        this.config.retryCount = count;
+        return this;
+    }
+    /** Set the delay between retries in milliseconds */
+    retryDelay(ms) {
+        this.config.retryDelay = ms;
+        return this;
+    }
+    /** Build and return the configuration */
+    build() {
+        const config = {
+            hosts: this.config.hosts ?? exports.DEFAULT_CONFIG.hosts,
+            username: this.config.username,
+            password: this.config.password,
+            defaultGraph: this.config.defaultGraph,
+            timeout: this.config.timeout ?? exports.DEFAULT_CONFIG.timeout,
+            maxRecvSize: this.config.maxRecvSize ?? exports.DEFAULT_CONFIG.maxRecvSize,
+            tlsOptions: this.config.tlsOptions,
+            poolSize: this.config.poolSize ?? exports.DEFAULT_CONFIG.poolSize,
+            healthCheckInterval: this.config.healthCheckInterval ?? exports.DEFAULT_CONFIG.healthCheckInterval,
+            retryCount: this.config.retryCount ?? exports.DEFAULT_CONFIG.retryCount,
+            retryDelay: this.config.retryDelay ?? exports.DEFAULT_CONFIG.retryDelay,
+        };
+        validateConfig(config);
+        return config;
+    }
+}
+exports.ConfigBuilder = ConfigBuilder;
+/** Validate the configuration */
+function validateConfig(config) {
+    if (!config.hosts || config.hosts.length === 0) {
+        throw new Error('No hosts configured');
+    }
+    if (config.timeout !== undefined && config.timeout < 0) {
+        throw new Error('Invalid timeout value');
+    }
+    if (config.maxRecvSize !== undefined && config.maxRecvSize <= 0) {
+        config.maxRecvSize = exports.DEFAULT_CONFIG.maxRecvSize;
+    }
+    if (config.poolSize !== undefined && config.poolSize <= 0) {
+        config.poolSize = exports.DEFAULT_CONFIG.poolSize;
+    }
+}
+/** Create a configuration with defaults */
+function createConfig(options = {}) {
+    const config = {
+        hosts: options.hosts ?? exports.DEFAULT_CONFIG.hosts,
+        username: options.username,
+        password: options.password,
+        defaultGraph: options.defaultGraph,
+        timeout: options.timeout ?? exports.DEFAULT_CONFIG.timeout,
+        maxRecvSize: options.maxRecvSize ?? exports.DEFAULT_CONFIG.maxRecvSize,
+        tlsOptions: options.tlsOptions,
+        poolSize: options.poolSize ?? exports.DEFAULT_CONFIG.poolSize,
+        healthCheckInterval: options.healthCheckInterval ?? exports.DEFAULT_CONFIG.healthCheckInterval,
+        retryCount: options.retryCount ?? exports.DEFAULT_CONFIG.retryCount,
+        retryDelay: options.retryDelay ?? exports.DEFAULT_CONFIG.retryDelay,
+    };
+    validateConfig(config);
+    return config;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Configuration for GQLDB Node.js driver.\r\n */\r\n\r\nimport * as tls from 'tls';\r\n\r\n/** Configuration options for GqldbClient */\r\nexport interface GqldbConfig {\r\n  /** Server hosts in format \"host:port\" */\r\n  hosts: string[];\r\n  /** Username for authentication */\r\n  username?: string;\r\n  /** Password for authentication */\r\n  password?: string;\r\n  /** Default graph to use */\r\n  defaultGraph?: string;\r\n  /** Query timeout in milliseconds (default 30000ms = 30s) */\r\n  timeout?: number;\r\n  /** Maximum receive message size in bytes (default 64MB) */\r\n  maxRecvSize?: number;\r\n  /** TLS options for secure connections */\r\n  tlsOptions?: tls.ConnectionOptions;\r\n  /** Connection pool size per host */\r\n  poolSize?: number;\r\n  /** Health check interval in milliseconds (default 30000ms = 30s) */\r\n  healthCheckInterval?: number;\r\n  /** Number of retries for failed requests */\r\n  retryCount?: number;\r\n  /** Delay between retries in milliseconds (default 100ms) */\r\n  retryDelay?: number;\r\n}\r\n\r\n/** Default configuration values */\r\nexport const DEFAULT_CONFIG: Required<Omit<GqldbConfig, 'username' | 'password' | 'defaultGraph' | 'tlsOptions'>> = {\r\n  hosts: ['localhost:9000'],\r\n  timeout: 30000, // 30 seconds (in milliseconds)\r\n  maxRecvSize: 64 * 1024 * 1024, // 64MB\r\n  poolSize: 10,\r\n  healthCheckInterval: 30000, // 30 seconds (in milliseconds)\r\n  retryCount: 3,\r\n  retryDelay: 100, // 100ms\r\n};\r\n\r\n/** Builder for creating GqldbConfig */\r\nexport class ConfigBuilder {\r\n  private config: Partial<GqldbConfig> = {};\r\n\r\n  /** Set the server hosts */\r\n  hosts(...hosts: string[]): this {\r\n    this.config.hosts = hosts;\r\n    return this;\r\n  }\r\n\r\n  /** Set the username for authentication */\r\n  username(username: string): this {\r\n    this.config.username = username;\r\n    return this;\r\n  }\r\n\r\n  /** Set the password for authentication */\r\n  password(password: string): this {\r\n    this.config.password = password;\r\n    return this;\r\n  }\r\n\r\n  /** Set the default graph */\r\n  defaultGraph(graph: string): this {\r\n    this.config.defaultGraph = graph;\r\n    return this;\r\n  }\r\n\r\n  /** Set the query timeout in milliseconds */\r\n  timeout(ms: number): this {\r\n    this.config.timeout = ms;\r\n    return this;\r\n  }\r\n\r\n  /** Set the query timeout in seconds (convenience method) */\r\n  timeoutSeconds(seconds: number): this {\r\n    this.config.timeout = seconds * 1000;\r\n    return this;\r\n  }\r\n\r\n  /** Set the maximum receive message size */\r\n  maxRecvSize(bytes: number): this {\r\n    this.config.maxRecvSize = bytes;\r\n    return this;\r\n  }\r\n\r\n  /** Set TLS options */\r\n  tls(options: tls.ConnectionOptions): this {\r\n    this.config.tlsOptions = options;\r\n    return this;\r\n  }\r\n\r\n  /** Set the connection pool size per host */\r\n  poolSize(size: number): this {\r\n    this.config.poolSize = size;\r\n    return this;\r\n  }\r\n\r\n  /** Set the health check interval in milliseconds */\r\n  healthCheckInterval(ms: number): this {\r\n    this.config.healthCheckInterval = ms;\r\n    return this;\r\n  }\r\n\r\n  /** Set the number of retries */\r\n  retryCount(count: number): this {\r\n    this.config.retryCount = count;\r\n    return this;\r\n  }\r\n\r\n  /** Set the delay between retries in milliseconds */\r\n  retryDelay(ms: number): this {\r\n    this.config.retryDelay = ms;\r\n    return this;\r\n  }\r\n\r\n  /** Build and return the configuration */\r\n  build(): GqldbConfig {\r\n    const config: GqldbConfig = {\r\n      hosts: this.config.hosts ?? DEFAULT_CONFIG.hosts,\r\n      username: this.config.username,\r\n      password: this.config.password,\r\n      defaultGraph: this.config.defaultGraph,\r\n      timeout: this.config.timeout ?? DEFAULT_CONFIG.timeout,\r\n      maxRecvSize: this.config.maxRecvSize ?? DEFAULT_CONFIG.maxRecvSize,\r\n      tlsOptions: this.config.tlsOptions,\r\n      poolSize: this.config.poolSize ?? DEFAULT_CONFIG.poolSize,\r\n      healthCheckInterval: this.config.healthCheckInterval ?? DEFAULT_CONFIG.healthCheckInterval,\r\n      retryCount: this.config.retryCount ?? DEFAULT_CONFIG.retryCount,\r\n      retryDelay: this.config.retryDelay ?? DEFAULT_CONFIG.retryDelay,\r\n    };\r\n\r\n    validateConfig(config);\r\n    return config;\r\n  }\r\n}\r\n\r\n/** Validate the configuration */\r\nexport function validateConfig(config: GqldbConfig): void {\r\n  if (!config.hosts || config.hosts.length === 0) {\r\n    throw new Error('No hosts configured');\r\n  }\r\n\r\n  if (config.timeout !== undefined && config.timeout < 0) {\r\n    throw new Error('Invalid timeout value');\r\n  }\r\n\r\n  if (config.maxRecvSize !== undefined && config.maxRecvSize <= 0) {\r\n    config.maxRecvSize = DEFAULT_CONFIG.maxRecvSize;\r\n  }\r\n\r\n  if (config.poolSize !== undefined && config.poolSize <= 0) {\r\n    config.poolSize = DEFAULT_CONFIG.poolSize;\r\n  }\r\n}\r\n\r\n/** Create a configuration with defaults */\r\nexport function createConfig(options: Partial<GqldbConfig> = {}): GqldbConfig {\r\n  const config: GqldbConfig = {\r\n    hosts: options.hosts ?? DEFAULT_CONFIG.hosts,\r\n    username: options.username,\r\n    password: options.password,\r\n    defaultGraph: options.defaultGraph,\r\n    timeout: options.timeout ?? DEFAULT_CONFIG.timeout,\r\n    maxRecvSize: options.maxRecvSize ?? DEFAULT_CONFIG.maxRecvSize,\r\n    tlsOptions: options.tlsOptions,\r\n    poolSize: options.poolSize ?? DEFAULT_CONFIG.poolSize,\r\n    healthCheckInterval: options.healthCheckInterval ?? DEFAULT_CONFIG.healthCheckInterval,\r\n    retryCount: options.retryCount ?? DEFAULT_CONFIG.retryCount,\r\n    retryDelay: options.retryDelay ?? DEFAULT_CONFIG.retryDelay,\r\n  };\r\n\r\n  validateConfig(config);\r\n  return config;\r\n}\r\n"]}

package/dist/connection.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Connection management for GQLDB Node.js driver.
+ */
+import * as grpc from '@grpc/grpc-js';
+import { GqldbConfig } from './config';
+/** Manages a pool of connections to GQLDB servers */
+export declare class ConnectionPool {
+    private config;
+    private connections;
+    private closed;
+    private healthCheckTimer?;
+    constructor(config: GqldbConfig);
+    private initConnections;
+    private createConnection;
+    /** Get a healthy connection from the pool */
+    getConnection(): grpc.Client;
+    /** Get a connection for a specific host */
+    getConnectionForHost(host: string): grpc.Client;
+    private startHealthCheck;
+    private checkHealth;
+    private reconnect;
+    /** Close all connections in the pool */
+    close(): void;
+    /** Get the number of healthy hosts */
+    healthyHostCount(): number;
+    /** Get the list of configured hosts */
+    hosts(): string[];
+    /** Check if the pool is closed */
+    isClosed(): boolean;
+}

package/dist/connection.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * Connection management for GQLDB Node.js driver.
+ */
+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.ConnectionPool = void 0;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const errors_1 = require("./errors");
+/** Manages a pool of connections to GQLDB servers */
+class ConnectionPool {
+    config;
+    connections = new Map();
+    closed = false;
+    healthCheckTimer;
+    constructor(config) {
+        this.config = config;
+        this.initConnections();
+        this.startHealthCheck();
+    }
+    initConnections() {
+        for (const host of this.config.hosts) {
+            try {
+                const conn = this.createConnection(host);
+                this.connections.set(host, conn);
+            }
+            catch (e) {
+                // Continue with other hosts
+                console.error(`Failed to connect to ${host}:`, e);
+            }
+        }
+        if (this.connections.size === 0) {
+            throw new errors_1.AllHostsFailedError();
+        }
+    }
+    createConnection(host) {
+        let credentials;
+        if (this.config.tlsOptions) {
+            credentials = grpc.credentials.createSsl();
+        }
+        else {
+            credentials = grpc.credentials.createInsecure();
+        }
+        const options = {
+            'grpc.max_receive_message_length': this.config.maxRecvSize ?? 4 * 1024 * 1024,
+            'grpc.keepalive_time_ms': 30000,
+            'grpc.keepalive_timeout_ms': 10000,
+            'grpc.keepalive_permit_without_calls': 1,
+        };
+        // Create a generic client for the channel
+        const client = new grpc.Client(host, credentials, options);
+        return {
+            host,
+            client,
+            healthy: true,
+            lastPing: Date.now(),
+        };
+    }
+    /** Get a healthy connection from the pool */
+    getConnection() {
+        if (this.closed) {
+            throw new errors_1.ConnectionClosedError();
+        }
+        for (const conn of this.connections.values()) {
+            if (conn.healthy) {
+                return conn.client;
+            }
+        }
+        throw new errors_1.NoConnectionError();
+    }
+    /** Get a connection for a specific host */
+    getConnectionForHost(host) {
+        const conn = this.connections.get(host);
+        if (!conn || !conn.healthy) {
+            throw new errors_1.NoConnectionError();
+        }
+        return conn.client;
+    }
+    startHealthCheck() {
+        const interval = this.config.healthCheckInterval ?? 30000;
+        if (interval > 0) {
+            this.healthCheckTimer = setInterval(() => this.checkHealth(), interval);
+        }
+    }
+    checkHealth() {
+        for (const [host, conn] of this.connections) {
+            const state = conn.client.getChannel().getConnectivityState(false);
+            const healthy = state === grpc.connectivityState.READY ||
+                state === grpc.connectivityState.IDLE;
+            conn.healthy = healthy;
+            if (healthy) {
+                conn.lastPing = Date.now();
+            }
+            else {
+                this.reconnect(host);
+            }
+        }
+    }
+    async reconnect(host) {
+        if (this.closed)
+            return;
+        const oldConn = this.connections.get(host);
+        if (oldConn) {
+            try {
+                oldConn.client.close();
+            }
+            catch (e) {
+                // Ignore
+            }
+            this.connections.delete(host);
+        }
+        try {
+            const newConn = this.createConnection(host);
+            this.connections.set(host, newConn);
+        }
+        catch (e) {
+            // Log and continue
+            console.error(`Failed to reconnect to ${host}:`, e);
+        }
+    }
+    /** Close all connections in the pool */
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.healthCheckTimer) {
+            clearInterval(this.healthCheckTimer);
+        }
+        for (const conn of this.connections.values()) {
+            try {
+                conn.client.close();
+            }
+            catch (e) {
+                // Ignore
+            }
+        }
+        this.connections.clear();
+    }
+    /** Get the number of healthy hosts */
+    healthyHostCount() {
+        let count = 0;
+        for (const conn of this.connections.values()) {
+            if (conn.healthy)
+                count++;
+        }
+        return count;
+    }
+    /** Get the list of configured hosts */
+    hosts() {
+        return Array.from(this.connections.keys());
+    }
+    /** Check if the pool is closed */
+    isClosed() {
+        return this.closed;
+    }
+}
+exports.ConnectionPool = ConnectionPool;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connection.js","sourceRoot":"","sources":["../src/connection.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Connection management for GQLDB Node.js driver.\r\n */\r\n\r\nimport * as grpc from '@grpc/grpc-js';\r\nimport { GqldbConfig } from './config';\r\nimport { AllHostsFailedError, ConnectionClosedError, NoConnectionError } from './errors';\r\n\r\n/** Represents a single gRPC connection */\r\ninterface Connection {\r\n  host: string;\r\n  client: grpc.Client;\r\n  healthy: boolean;\r\n  lastPing: number;\r\n}\r\n\r\n/** Manages a pool of connections to GQLDB servers */\r\nexport class ConnectionPool {\r\n  private config: GqldbConfig;\r\n  private connections: Map<string, Connection> = new Map();\r\n  private closed = false;\r\n  private healthCheckTimer?: NodeJS.Timeout;\r\n\r\n  constructor(config: GqldbConfig) {\r\n    this.config = config;\r\n    this.initConnections();\r\n    this.startHealthCheck();\r\n  }\r\n\r\n  private initConnections(): void {\r\n    for (const host of this.config.hosts) {\r\n      try {\r\n        const conn = this.createConnection(host);\r\n        this.connections.set(host, conn);\r\n      } catch (e) {\r\n        // Continue with other hosts\r\n        console.error(`Failed to connect to ${host}:`, e);\r\n      }\r\n    }\r\n\r\n    if (this.connections.size === 0) {\r\n      throw new AllHostsFailedError();\r\n    }\r\n  }\r\n\r\n  private createConnection(host: string): Connection {\r\n    let credentials: grpc.ChannelCredentials;\r\n\r\n    if (this.config.tlsOptions) {\r\n      credentials = grpc.credentials.createSsl();\r\n    } else {\r\n      credentials = grpc.credentials.createInsecure();\r\n    }\r\n\r\n    const options: grpc.ChannelOptions = {\r\n      'grpc.max_receive_message_length': this.config.maxRecvSize ?? 4 * 1024 * 1024,\r\n      'grpc.keepalive_time_ms': 30000,\r\n      'grpc.keepalive_timeout_ms': 10000,\r\n      'grpc.keepalive_permit_without_calls': 1,\r\n    };\r\n\r\n    // Create a generic client for the channel\r\n    const client = new grpc.Client(host, credentials, options);\r\n\r\n    return {\r\n      host,\r\n      client,\r\n      healthy: true,\r\n      lastPing: Date.now(),\r\n    };\r\n  }\r\n\r\n  /** Get a healthy connection from the pool */\r\n  getConnection(): grpc.Client {\r\n    if (this.closed) {\r\n      throw new ConnectionClosedError();\r\n    }\r\n\r\n    for (const conn of this.connections.values()) {\r\n      if (conn.healthy) {\r\n        return conn.client;\r\n      }\r\n    }\r\n\r\n    throw new NoConnectionError();\r\n  }\r\n\r\n  /** Get a connection for a specific host */\r\n  getConnectionForHost(host: string): grpc.Client {\r\n    const conn = this.connections.get(host);\r\n    if (!conn || !conn.healthy) {\r\n      throw new NoConnectionError();\r\n    }\r\n    return conn.client;\r\n  }\r\n\r\n  private startHealthCheck(): void {\r\n    const interval = this.config.healthCheckInterval ?? 30000;\r\n    if (interval > 0) {\r\n      this.healthCheckTimer = setInterval(() => this.checkHealth(), interval);\r\n    }\r\n  }\r\n\r\n  private checkHealth(): void {\r\n    for (const [host, conn] of this.connections) {\r\n      const state = conn.client.getChannel().getConnectivityState(false);\r\n      const healthy = state === grpc.connectivityState.READY ||\r\n                     state === grpc.connectivityState.IDLE;\r\n\r\n      conn.healthy = healthy;\r\n      if (healthy) {\r\n        conn.lastPing = Date.now();\r\n      } else {\r\n        this.reconnect(host);\r\n      }\r\n    }\r\n  }\r\n\r\n  private async reconnect(host: string): Promise<void> {\r\n    if (this.closed) return;\r\n\r\n    const oldConn = this.connections.get(host);\r\n    if (oldConn) {\r\n      try {\r\n        oldConn.client.close();\r\n      } catch (e) {\r\n        // Ignore\r\n      }\r\n      this.connections.delete(host);\r\n    }\r\n\r\n    try {\r\n      const newConn = this.createConnection(host);\r\n      this.connections.set(host, newConn);\r\n    } catch (e) {\r\n      // Log and continue\r\n      console.error(`Failed to reconnect to ${host}:`, e);\r\n    }\r\n  }\r\n\r\n  /** Close all connections in the pool */\r\n  close(): void {\r\n    if (this.closed) return;\r\n\r\n    this.closed = true;\r\n\r\n    if (this.healthCheckTimer) {\r\n      clearInterval(this.healthCheckTimer);\r\n    }\r\n\r\n    for (const conn of this.connections.values()) {\r\n      try {\r\n        conn.client.close();\r\n      } catch (e) {\r\n        // Ignore\r\n      }\r\n    }\r\n\r\n    this.connections.clear();\r\n  }\r\n\r\n  /** Get the number of healthy hosts */\r\n  healthyHostCount(): number {\r\n    let count = 0;\r\n    for (const conn of this.connections.values()) {\r\n      if (conn.healthy) count++;\r\n    }\r\n    return count;\r\n  }\r\n\r\n  /** Get the list of configured hosts */\r\n  hosts(): string[] {\r\n    return Array.from(this.connections.keys());\r\n  }\r\n\r\n  /** Check if the pool is closed */\r\n  isClosed(): boolean {\r\n    return this.closed;\r\n  }\r\n}\r\n"]}

package/dist/errors.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Error definitions for GQLDB Node.js driver.
+ */
+/** Base error class for GQLDB errors */
+export declare class GqldbError extends Error {
+    readonly code: number;
+    readonly cause?: Error | undefined;
+    constructor(message: string, code?: number, cause?: Error | undefined);
+}
+export declare class NoHostsError extends GqldbError {
+    constructor();
+}
+export declare class InvalidTimeoutError extends GqldbError {
+    constructor();
+}
+export declare class NoConnectionError extends GqldbError {
+    constructor();
+}
+export declare class ConnectionClosedError extends GqldbError {
+    constructor();
+}
+export declare class ConnectionFailedError extends GqldbError {
+    constructor(message?: string, cause?: Error);
+}
+export declare class AllHostsFailedError extends GqldbError {
+    constructor();
+}
+export declare class HealthCheckFailedError extends GqldbError {
+    constructor();
+}
+export declare class NotLoggedInError extends GqldbError {
+    constructor();
+}
+export declare class LoginFailedError extends GqldbError {
+    constructor(message?: string, cause?: Error);
+}
+export declare class LogoutFailedError extends GqldbError {
+    constructor(message?: string, cause?: Error);
+}
+export declare class SessionExpiredError extends GqldbError {
+    constructor();
+}
+export declare class InvalidSessionError extends GqldbError {
+    constructor();
+}
+export declare class NoTransactionError extends GqldbError {
+    constructor();
+}
+export declare class TransactionFailedError extends GqldbError {
+    constructor(message?: string, cause?: Error);
+}
+export declare class TransactionNotFoundError extends GqldbError {
+    constructor();
+}
+export declare class TransactionAlreadyOpenError extends GqldbError {
+    constructor();
+}
+export declare class QueryFailedError extends GqldbError {
+    constructor(message?: string, cause?: Error);
+}
+export declare class QueryTimeoutError extends GqldbError {
+    constructor();
+}
+export declare class InvalidQueryError extends GqldbError {
+    constructor(message?: string);
+}
+export declare class EmptyQueryError extends GqldbError {
+    constructor();
+}
+export declare class GraphNotFoundError extends GqldbError {
+    constructor(graphName?: string);
+}
+export declare class GraphExistsError extends GqldbError {
+    constructor(graphName?: string);
+}
+export declare class CreateGraphFailedError extends GqldbError {
+    constructor(message?: string, cause?: Error);
+}
+export declare class DropGraphFailedError extends GqldbError {
+    constructor(message?: string, cause?: Error);
+}
+export declare class InsertFailedError extends GqldbError {
+    constructor(message?: string, cause?: Error);
+}
+export declare class DeleteFailedError extends GqldbError {
+    constructor(message?: string, cause?: Error);
+}
+export declare class ExportFailedError extends GqldbError {
+    constructor(message?: string, cause?: Error);
+}
+export declare class InvalidTypeError extends GqldbError {
+    constructor(message?: string);
+}
+export declare class TypeConversionError extends GqldbError {
+    constructor(message?: string);
+}
+export declare class UnsupportedTypeError extends GqldbError {
+    constructor(typeName?: string);
+}