relq 1.0.65 → 1.0.66

package/dist/cjs/core/relq-client.cjs

@@ -83,6 +83,8 @@ class Relq {
     initialized = false;
     initPromise;
     isClosed = false;
+    clientConnected = false;
+    connectPromise;
     environment;
     poolErrorHandler;
     poolConnectHandler;
@@ -487,8 +489,14 @@ class Relq {
                     connectionString: this.config.connectionString,
                     ssl
                 });
-                this.client.on('end', () => this.emitter.emit('end'));
-                this.client.on('error', (err) => this.emitter.emit('error', err));
+                this.client.on('end', () => {
+                    this.clientConnected = false;
+                    this.emitter.emit('end');
+                });
+                this.client.on('error', (err) => {
+                    this.clientConnected = false;
+                    this.emitter.emit('error', err);
+                });
                 this.client.on('notice', (msg) => this.emitter.emit('notice', msg));
                 this.client.on('notification', (msg) => this.emitter.emit('notification', msg));
             }
@@ -527,9 +535,85 @@ class Relq {
         await this.initialize();
         if (!this.usePooling && this.client) {
             await this.client.connect();
+            this.clientConnected = true;
             this.emitter.emit('connect', this.client);
         }
     }
+    async ensureConnection() {
+        if (this.usePooling || !this.client)
+            return;
+        if (this.clientConnected)
+            return;
+        if (this.connectPromise) {
+            return this.connectPromise;
+        }
+        this.connectPromise = (async () => {
+            try {
+                if (this.client && !this.clientConnected) {
+                    try {
+                        await this.client.connect();
+                        this.clientConnected = true;
+                        this.emitter.emit('connect', this.client);
+                    }
+                    catch (err) {
+                        if (err.message?.includes('already been connected') ||
+                            err.code === 'ECONNRESET' ||
+                            err.code === 'ETIMEDOUT' ||
+                            err.code === 'EPIPE' ||
+                            err.message?.includes('Connection terminated')) {
+                            this.client.removeAllListeners();
+                            try {
+                                await this.client.end();
+                            }
+                            catch { }
+                            await this.recreateClient();
+                        }
+                        else {
+                            throw err;
+                        }
+                    }
+                }
+            }
+            finally {
+                this.connectPromise = undefined;
+            }
+        })();
+        return this.connectPromise;
+    }
+    async recreateClient() {
+        const { Client: PgClientClass } = await loadPg();
+        let resolvedPassword = this.config.password;
+        const isAws = (0, config_types_1.isAwsDsqlConfig)(this.config);
+        if (isAws) {
+            resolvedPassword = await (0, aws_dsql_1.getAwsDsqlToken)(this.config.aws);
+        }
+        const host = isAws ? this.config.aws.hostname : (this.config.host || 'localhost');
+        const port = this.config.aws?.port ?? this.config.port ?? 5432;
+        const user = this.config.aws?.user ?? this.config.user ?? (isAws ? 'admin' : undefined);
+        const ssl = isAws ? (this.config.aws.ssl ?? true) : this.config.ssl;
+        this.client = new PgClientClass({
+            host,
+            port,
+            database: this.config.database,
+            user,
+            password: resolvedPassword,
+            connectionString: this.config.connectionString,
+            ssl
+        });
+        this.client.on('end', () => {
+            this.clientConnected = false;
+            this.emitter.emit('end');
+        });
+        this.client.on('error', (err) => {
+            this.clientConnected = false;
+            this.emitter.emit('error', err);
+        });
+        this.client.on('notice', (msg) => this.emitter.emit('notice', msg));
+        this.client.on('notification', (msg) => this.emitter.emit('notification', msg));
+        await this.client.connect();
+        this.clientConnected = true;
+        this.emitter.emit('connect', this.client);
+    }
     async subscribe(channel, callback) {
         if (!this.listener) {
             this.listener = new listener_connection_1.ListenerConnection({
@@ -576,6 +660,7 @@ class Relq {
             else if (this.client) {
                 this.client.removeAllListeners();
                 await this.client.end();
+                this.clientConnected = false;
             }
             this.isClosed = true;
             activeRelqInstances.delete(this);
@@ -601,26 +686,52 @@ class Relq {
         return this;
     }
     async _executeQuery(sql) {
-        try {
-            if (!sql || typeof sql !== 'string' || sql.trim() === '') {
-                throw new relq_errors_1.RelqConfigError(`Invalid SQL query: ${sql === null ? 'null' : sql === undefined ? 'undefined' : 'empty string'}`);
-            }
-            await this.initialize();
-            const startTime = performance.now();
-            let result;
+        if (!sql || typeof sql !== 'string' || sql.trim() === '') {
+            throw new relq_errors_1.RelqConfigError(`Invalid SQL query: ${sql === null ? 'null' : sql === undefined ? 'undefined' : 'empty string'}`);
+        }
+        await this.initialize();
+        const executeQuery = async () => {
             if (this.pool) {
-                result = await this.pool.query(sql);
+                return await this.pool.query(sql);
             }
             else if (this.client) {
-                result = await this.client.query(sql);
+                await this.ensureConnection();
+                return await this.client.query(sql);
             }
             else {
                 throw new relq_errors_1.RelqConfigError('No database connection available');
             }
+        };
+        try {
+            const startTime = performance.now();
+            const result = await executeQuery();
             const duration = performance.now() - startTime;
             return { result, duration };
         }
         catch (error) {
+            const isConnectionError = error.code === 'ECONNRESET' ||
+                error.code === 'ETIMEDOUT' ||
+                error.code === 'EPIPE' ||
+                error.code === 'ENOTCONN' ||
+                error.code === '57P01' ||
+                error.code === '57P02' ||
+                error.code === '57P03' ||
+                error.message?.includes('Connection terminated') ||
+                error.message?.includes('connection is closed') ||
+                error.message?.includes('Client has encountered a connection error');
+            if (isConnectionError && !this.usePooling && this.client) {
+                this.clientConnected = false;
+                try {
+                    await this.ensureConnection();
+                    const startTime = performance.now();
+                    const result = await this.client.query(sql);
+                    const duration = performance.now() - startTime;
+                    return { result, duration };
+                }
+                catch (retryError) {
+                    throw (0, relq_errors_1.parsePostgresError)(error, sql);
+                }
+            }
             throw (0, relq_errors_1.parsePostgresError)(error, sql);
         }
     }

package/dist/esm/core/relq-client.js

@@ -47,6 +47,8 @@ export class Relq {
     initialized = false;
     initPromise;
     isClosed = false;
+    clientConnected = false;
+    connectPromise;
     environment;
     poolErrorHandler;
     poolConnectHandler;
@@ -451,8 +453,14 @@ export class Relq {
                     connectionString: this.config.connectionString,
                     ssl
                 });
-                this.client.on('end', () => this.emitter.emit('end'));
-                this.client.on('error', (err) => this.emitter.emit('error', err));
+                this.client.on('end', () => {
+                    this.clientConnected = false;
+                    this.emitter.emit('end');
+                });
+                this.client.on('error', (err) => {
+                    this.clientConnected = false;
+                    this.emitter.emit('error', err);
+                });
                 this.client.on('notice', (msg) => this.emitter.emit('notice', msg));
                 this.client.on('notification', (msg) => this.emitter.emit('notification', msg));
             }
@@ -491,9 +499,85 @@ export class Relq {
         await this.initialize();
         if (!this.usePooling && this.client) {
             await this.client.connect();
+            this.clientConnected = true;
             this.emitter.emit('connect', this.client);
         }
     }
+    async ensureConnection() {
+        if (this.usePooling || !this.client)
+            return;
+        if (this.clientConnected)
+            return;
+        if (this.connectPromise) {
+            return this.connectPromise;
+        }
+        this.connectPromise = (async () => {
+            try {
+                if (this.client && !this.clientConnected) {
+                    try {
+                        await this.client.connect();
+                        this.clientConnected = true;
+                        this.emitter.emit('connect', this.client);
+                    }
+                    catch (err) {
+                        if (err.message?.includes('already been connected') ||
+                            err.code === 'ECONNRESET' ||
+                            err.code === 'ETIMEDOUT' ||
+                            err.code === 'EPIPE' ||
+                            err.message?.includes('Connection terminated')) {
+                            this.client.removeAllListeners();
+                            try {
+                                await this.client.end();
+                            }
+                            catch { }
+                            await this.recreateClient();
+                        }
+                        else {
+                            throw err;
+                        }
+                    }
+                }
+            }
+            finally {
+                this.connectPromise = undefined;
+            }
+        })();
+        return this.connectPromise;
+    }
+    async recreateClient() {
+        const { Client: PgClientClass } = await loadPg();
+        let resolvedPassword = this.config.password;
+        const isAws = isAwsDsqlConfig(this.config);
+        if (isAws) {
+            resolvedPassword = await getAwsDsqlToken(this.config.aws);
+        }
+        const host = isAws ? this.config.aws.hostname : (this.config.host || 'localhost');
+        const port = this.config.aws?.port ?? this.config.port ?? 5432;
+        const user = this.config.aws?.user ?? this.config.user ?? (isAws ? 'admin' : undefined);
+        const ssl = isAws ? (this.config.aws.ssl ?? true) : this.config.ssl;
+        this.client = new PgClientClass({
+            host,
+            port,
+            database: this.config.database,
+            user,
+            password: resolvedPassword,
+            connectionString: this.config.connectionString,
+            ssl
+        });
+        this.client.on('end', () => {
+            this.clientConnected = false;
+            this.emitter.emit('end');
+        });
+        this.client.on('error', (err) => {
+            this.clientConnected = false;
+            this.emitter.emit('error', err);
+        });
+        this.client.on('notice', (msg) => this.emitter.emit('notice', msg));
+        this.client.on('notification', (msg) => this.emitter.emit('notification', msg));
+        await this.client.connect();
+        this.clientConnected = true;
+        this.emitter.emit('connect', this.client);
+    }
     async subscribe(channel, callback) {
         if (!this.listener) {
             this.listener = new ListenerConnection({
@@ -540,6 +624,7 @@ export class Relq {
             else if (this.client) {
                 this.client.removeAllListeners();
                 await this.client.end();
+                this.clientConnected = false;
             }
             this.isClosed = true;
             activeRelqInstances.delete(this);
@@ -565,26 +650,52 @@ export class Relq {
         return this;
     }
     async _executeQuery(sql) {
-        try {
-            if (!sql || typeof sql !== 'string' || sql.trim() === '') {
-                throw new RelqConfigError(`Invalid SQL query: ${sql === null ? 'null' : sql === undefined ? 'undefined' : 'empty string'}`);
-            }
-            await this.initialize();
-            const startTime = performance.now();
-            let result;
+        if (!sql || typeof sql !== 'string' || sql.trim() === '') {
+            throw new RelqConfigError(`Invalid SQL query: ${sql === null ? 'null' : sql === undefined ? 'undefined' : 'empty string'}`);
+        }
+        await this.initialize();
+        const executeQuery = async () => {
             if (this.pool) {
-                result = await this.pool.query(sql);
+                return await this.pool.query(sql);
             }
             else if (this.client) {
-                result = await this.client.query(sql);
+                await this.ensureConnection();
+                return await this.client.query(sql);
             }
             else {
                 throw new RelqConfigError('No database connection available');
             }
+        };
+        try {
+            const startTime = performance.now();
+            const result = await executeQuery();
             const duration = performance.now() - startTime;
             return { result, duration };
         }
         catch (error) {
+            const isConnectionError = error.code === 'ECONNRESET' ||
+                error.code === 'ETIMEDOUT' ||
+                error.code === 'EPIPE' ||
+                error.code === 'ENOTCONN' ||
+                error.code === '57P01' ||
+                error.code === '57P02' ||
+                error.code === '57P03' ||
+                error.message?.includes('Connection terminated') ||
+                error.message?.includes('connection is closed') ||
+                error.message?.includes('Client has encountered a connection error');
+            if (isConnectionError && !this.usePooling && this.client) {
+                this.clientConnected = false;
+                try {
+                    await this.ensureConnection();
+                    const startTime = performance.now();
+                    const result = await this.client.query(sql);
+                    const duration = performance.now() - startTime;
+                    return { result, duration };
+                }
+                catch (retryError) {
+                    throw parsePostgresError(error, sql);
+                }
+            }
             throw parsePostgresError(error, sql);
         }
     }

package/dist/index.d.ts

@@ -8347,6 +8347,8 @@ export declare class Relq<TSchema = any> {
 	private initialized;
 	private initPromise?;
 	private isClosed;
+	private clientConnected;
+	private connectPromise?;
 	private environment;
 	private poolErrorHandler?;
 	private poolConnectHandler?;
@@ -8494,6 +8496,17 @@ export declare class Relq<TSchema = any> {
 	 * @internal
 	 */
 	private connect;
+	/**
+	 * Ensure single client is connected, with auto-reconnect on failure
+	 * Handles concurrent calls by reusing the same connect promise
+	 * @internal
+	 */
+	private ensureConnection;
+	/**
+	 * Recreate the client after connection loss
+	 * @internal
+	 */
+	private recreateClient;
 	/**
 	 * Subscribe to a PostgreSQL NOTIFY channel
 	 *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relq",
-  "version": "1.0.65",
+  "version": "1.0.66",
   "description": "The Fully-Typed PostgreSQL ORM for TypeScript",
   "author": "Olajide Mathew O. <olajide.mathew@yuniq.solutions>",
   "license": "MIT",