anote-server-libs 0.11.9 → 0.12.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anote-server-libs",
-  "version": "0.11.9",
+  "version": "0.12.1",
   "description": "Helpers for express-TS servers",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",

package/services/WithTransaction.js

@@ -1,14 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withTransactionConfig = void 0;
+exports.requestTransactionGate = requestTransactionGate;
+exports.releaseTransactionGate = releaseTransactionGate;
 exports.withTransaction = withTransaction;
 const utils_1 = require("./utils");
 exports.withTransactionConfig = {
     logQueries: false,
-    timeoutMillis: 15000
+    timeoutMillis: 15000,
+    activeCount: 0,
+    gateRequested: false,
+    gateActive: false,
+    gateQueue: [],
 };
-function withTransaction(repo, logger, previousMethod, lock, commitIfLost = true) {
+function requestTransactionGate() {
+    if (exports.withTransactionConfig.gateActive || exports.withTransactionConfig.gateRequested) {
+        return Promise.reject(new Error('Transaction gate already active or requested'));
+    }
+    exports.withTransactionConfig.gateRequested = true;
+    return new Promise((resolve, _reject) => {
+        const check = () => {
+            if (exports.withTransactionConfig.activeCount <= 1) {
+                exports.withTransactionConfig.gateActive = true;
+                exports.withTransactionConfig.gateRequested = false;
+                resolve();
+            }
+            else {
+                setTimeout(check, 100);
+            }
+        };
+        setTimeout(check, 50);
+    });
+}
+function releaseTransactionGate() {
+    exports.withTransactionConfig.gateActive = false;
+    exports.withTransactionConfig.gateRequested = false;
+    const queue = exports.withTransactionConfig.gateQueue.splice(0);
+    for (const entry of queue) {
+        entry.resolve();
+    }
+}
+function releaseAndDecrement(repo, dbClient) {
+    if (repo.db && dbClient) {
+        try {
+            dbClient.release();
+        }
+        catch (_) { }
+    }
+    exports.withTransactionConfig.activeCount = Math.max(0, exports.withTransactionConfig.activeCount - 1);
+}
+function withTransaction(repo, logger, previousMethod, lock, commitIfLost = true, idleInTransactionTimeout) {
     return function (req, res, next) {
+        if (exports.withTransactionConfig.gateActive) {
+            return new Promise((resolve, reject) => {
+                exports.withTransactionConfig.gateQueue.push({ resolve, reject });
+            }).then(() => {
+                return withTransaction(repo, logger, previousMethod, lock, commitIfLost)(req, res, next);
+            });
+        }
         let commit = true;
         if (!commitIfLost) {
             res.once('close', () => commit = false);
@@ -22,6 +71,7 @@ function withTransaction(repo, logger, previousMethod, lock, commitIfLost = true
             res.write((0, utils_1.jsonStringify)(obj) || '{}');
             endTerminator();
         };
+        exports.withTransactionConfig.activeCount++;
         const connectTimeoutHandler = setTimeout(() => {
             logger.error('Error timed out getting a client, exiting...');
             process.exit(22);
@@ -49,8 +99,7 @@ function withTransaction(repo, logger, previousMethod, lock, commitIfLost = true
                 if (!res.locals.dbClientCommited) {
                     res.locals.dbClientCommited = true;
                     (commit ? (repo.db ? dbClient.query('COMMIT') : dbClient.commit()) : Promise.reject(new Error('Client lost'))).catch((err) => err).then((err) => {
-                        if (repo.db)
-                            dbClient.release();
+                        releaseAndDecrement(repo, dbClient);
                         if (!(err instanceof Error)) {
                             for (let i = 0; i < res.locals.dbClientOnCommit.length; i++) {
                                 res.locals.dbClientOnCommit[i]();
@@ -64,7 +113,15 @@ function withTransaction(repo, logger, previousMethod, lock, commitIfLost = true
                 }
             };
             res.locals.dbClientOnCommit = [];
-            return (repo.db ? dbClient.query('BEGIN') : dbClient.begin()).then(() => {
+            const beginPromise = repo.db ? dbClient.query('BEGIN') : dbClient.begin();
+            const idleTimeoutMs = Math.max(idleInTransactionTimeout, exports.withTransactionConfig.timeoutMillis);
+            let setupPromise = beginPromise;
+            if (idleInTransactionTimeout && idleTimeoutMs > 0 && repo.db) {
+                setupPromise = setupPromise.then(() => {
+                    return dbClient.query(`SET LOCAL idle_in_transaction_session_timeout TO ${idleTimeoutMs}`);
+                });
+            }
+            return setupPromise.then(() => {
                 const finish = () => {
                     res.send = () => {
                         throw new Error('res.send() should not be used within transactions. Use res.json() instead.');
@@ -80,8 +137,7 @@ function withTransaction(repo, logger, previousMethod, lock, commitIfLost = true
                                 }
                             }
                             (repo.db ? dbClient.query('ROLLBACK') : dbClient.rollback()).catch((err) => obj && obj.error && (obj.error.additionalInfo2 = { message: err.message })).then(() => {
-                                if (repo.db)
-                                    dbClient.release();
+                                releaseAndDecrement(repo, dbClient);
                                 jsonTerminator(obj);
                             });
                         }
@@ -108,8 +164,7 @@ function withTransaction(repo, logger, previousMethod, lock, commitIfLost = true
                                 logger.error('Uncaught 500 with no details...');
                             }
                             (repo.db ? dbClient.query('ROLLBACK') : dbClient.rollback()).catch(() => undefined).then(() => {
-                                if (repo.db)
-                                    dbClient.release();
+                                releaseAndDecrement(repo, dbClient);
                                 endTerminator();
                             });
                         }
@@ -140,18 +195,25 @@ function withTransaction(repo, logger, previousMethod, lock, commitIfLost = true
                                 additionalInfo: { message: err.message }
                             }
                         });
-                        dbClient.release();
+                        releaseAndDecrement(repo, dbClient);
                     });
                 }
                 else {
                     finish();
                 }
             }).catch((err) => {
-                dbClient.release();
-                throw err;
+                releaseAndDecrement(repo, dbClient);
+                logger.error('Error beginning transaction: %j', err);
+                res.status(500).json({
+                    error: {
+                        errorKey: 'internal.db',
+                        additionalInfo: { message: err.message }
+                    }
+                });
             });
         }).catch(err => {
             clearTimeout(connectTimeoutHandler);
+            exports.withTransactionConfig.activeCount = Math.max(0, exports.withTransactionConfig.activeCount - 1);
             res.status(500).json({
                 error: {
                     errorKey: 'internal.db',

package/services/WithTransaction.ts

@@ -11,11 +11,88 @@ export const enum SystemLock {
 
 export const withTransactionConfig = {
     logQueries: false,
-    timeoutMillis: 15000
+    timeoutMillis: 15000,
+    // Number of currently active transactions tracked for gating.
+    activeCount: 0,
+    // Whether a gate has been requested (waiting for activeCount to reach 0).
+    gateRequested: false,
+    // Whether the gate is active (new transactions are queued).
+    gateActive: false,
+    // Queue of pending transactions waiting for the gate to release.
+    gateQueue: [] as Array<{resolve: () => void; reject: (err: Error) => void}>,
 };
 
-export function withTransaction(repo: BaseModelRepository, logger: Logger, previousMethod: (req: Request, res: Response, next: NextFunction) => void, lock?: SystemLock, commitIfLost = true) {
-    return function(req: Request, res: Response, next: NextFunction) {
+/**
+ * Request a transaction gate. Returns a Promise that resolves when all currently
+ * active transactions have completed (drained). While waiting and after resolution,
+ * new withTransaction calls will be queued until releaseTransactionGate() is called.
+ *
+ * Use this before starting a long-running operation to ensure no other transactions
+ * are killed by PostgreSQL's idle_in_transaction_session_timeout while the long
+ * operation holds locks or occupies the connection pool.
+ *
+ * @returns A Promise that resolves when the gate is acquired.
+ */
+export function requestTransactionGate(): Promise<void> {
+    if(withTransactionConfig.gateActive || withTransactionConfig.gateRequested) {
+        return Promise.reject(new Error('Transaction gate already active or requested'));
+    }
+    withTransactionConfig.gateRequested = true;
+    return new Promise<void>((resolve, _reject) => {
+        const check = () => {
+            // Allow the calling transaction to remain active (activeCount <= 1).
+            // When called from inside a withTransaction handler, the current
+            // transaction counts as 1. When called from outside (e.g. cron),
+            // activeCount may be 0.
+            if(withTransactionConfig.activeCount <= 1) {
+                withTransactionConfig.gateActive = true;
+                withTransactionConfig.gateRequested = false;
+                resolve();
+            } else {
+                // Poll every 100ms until other transactions drain
+                setTimeout(check, 100);
+            }
+        };
+        // Small initial delay to let in-flight transactions settle
+        setTimeout(check, 50);
+    });
+}
+
+/**
+ * Release the transaction gate, allowing all queued transactions to proceed.
+ * Must be called after the long-running operation completes, in both success
+ * and error paths.
+ */
+export function releaseTransactionGate(): void {
+    withTransactionConfig.gateActive = false;
+    withTransactionConfig.gateRequested = false;
+    // Drain the queue — resolve all pending waiters
+    const queue = withTransactionConfig.gateQueue.splice(0);
+    for(const entry of queue) {
+        entry.resolve();
+    }
+}
+
+function releaseAndDecrement(repo: BaseModelRepository, dbClient: any) {
+    if(repo.db && dbClient) {
+        try { dbClient.release(); } catch (_) { /* already released */ }
+    }
+    withTransactionConfig.activeCount = Math.max(0, withTransactionConfig.activeCount - 1);
+}
+
+export function withTransaction(repo: BaseModelRepository, logger: Logger, previousMethod: (req: Request, res: Response, next: NextFunction) => void,
+                                lock?: SystemLock, commitIfLost = true, idleInTransactionTimeout?: number): (req: Request, res: Response, next: NextFunction) => any {
+    return function(this: any, req: Request, res: Response, next: NextFunction): any {
+        // If gate is active, queue this request and retry when gate is released
+        if(withTransactionConfig.gateActive) {
+            return new Promise<void>((resolve, reject) => {
+                withTransactionConfig.gateQueue.push({ resolve, reject });
+            }).then(() => {
+                // Re-enter with gate now released
+                return withTransaction(repo, logger, previousMethod, lock, commitIfLost)(req, res, next);
+            });
+        }
+
         let commit = true;
         if(!commitIfLost) {
             res.once('close', () => commit = false);
@@ -26,6 +103,10 @@ export function withTransaction(repo: BaseModelRepository, logger: Logger, previ
             res.write(jsonStringify(obj) || '{}');
             endTerminator();
         };
+
+        // Increment activeCount before attempting to connect to the database
+        withTransactionConfig.activeCount++;
+
         const connectTimeoutHandler = setTimeout(() => {
             // Timed out getting a client, restart worker or process...
             logger.error('Error timed out getting a client, exiting...');
@@ -56,7 +137,7 @@ export function withTransaction(repo: BaseModelRepository, logger: Logger, previ
                 if(!res.locals.dbClientCommited) {
                     res.locals.dbClientCommited = true;
                     (commit ? (repo.db ? dbClient.query('COMMIT') : dbClient.commit()) : Promise.reject(new Error('Client lost'))).catch((err: any) => err).then((err: any) => {
-                        if(repo.db) dbClient.release();
+                        releaseAndDecrement(repo, dbClient);
                         if(!(err instanceof Error)) {
                             for(let i = 0; i < res.locals.dbClientOnCommit.length; i++) {
                                 res.locals.dbClientOnCommit[i]();
@@ -69,7 +150,18 @@ export function withTransaction(repo: BaseModelRepository, logger: Logger, previ
                 }
             };
             res.locals.dbClientOnCommit = [];
-            return (repo.db ? dbClient.query('BEGIN') : dbClient.begin()).then(() => {
+
+            // Build the BEGIN + idle_in_transaction_session_timeout setup
+            const beginPromise = repo.db ? dbClient.query('BEGIN') : dbClient.begin();
+            const idleTimeoutMs = Math.max(idleInTransactionTimeout, withTransactionConfig.timeoutMillis);
+            let setupPromise: Promise<any> = beginPromise;
+            if(idleInTransactionTimeout && idleTimeoutMs > 0 && repo.db) {
+                setupPromise = setupPromise.then(() => {
+                    return dbClient.query(`SET LOCAL idle_in_transaction_session_timeout TO ${idleTimeoutMs}`);
+                });
+            }
+
+            return setupPromise.then(() => {
                 const finish = () => {
                     res.send = () => {
                         throw new Error('res.send() should not be used within transactions. Use res.json() instead.');
@@ -84,7 +176,7 @@ export function withTransaction(repo: BaseModelRepository, logger: Logger, previ
                                 }
                             }
                             (repo.db ? dbClient.query('ROLLBACK') : dbClient.rollback()).catch((err: any) => obj && obj.error && (obj.error.additionalInfo2 = {message: err.message})).then(() => {
-                                if(repo.db) dbClient.release();
+                                releaseAndDecrement(repo, dbClient);
                                 jsonTerminator(obj);
                             });
                         } else {
@@ -108,7 +200,7 @@ export function withTransaction(repo: BaseModelRepository, logger: Logger, previ
                                 logger.error('Uncaught 500 with no details...');
                             }
                             (repo.db ? dbClient.query('ROLLBACK') : dbClient.rollback()).catch((): any => undefined).then(() => {
-                                if(repo.db) dbClient.release();
+                                releaseAndDecrement(repo, dbClient);
                                 endTerminator();
                             });
                         } else {
@@ -137,19 +229,26 @@ export function withTransaction(repo: BaseModelRepository, logger: Logger, previ
                                 additionalInfo: {message: err.message}
                             }
                         });
-                        dbClient.release();  // Lock acquisition failed, release will also rollback
+                        releaseAndDecrement(repo, dbClient);  // Lock acquisition failed, release will also rollback
                     });
                 } else {
                     finish();
                 }
             }).catch((err: any) => {
                 // Error beginning transaction
-                dbClient.release();
-                throw err;
+                releaseAndDecrement(repo, dbClient);
+                logger.error('Error beginning transaction: %j', err);
+                res.status(500).json({
+                    error: {
+                        errorKey: 'internal.db',
+                        additionalInfo: {message: err.message}
+                    }
+                });
             });
         }).catch(err => {
             // Error connecting to database for other reason than timeout or beginning transaction
             clearTimeout(connectTimeoutHandler);
+            withTransactionConfig.activeCount = Math.max(0, withTransactionConfig.activeCount - 1);
             res.status(500).json({
                 error: {
                     errorKey: 'internal.db',

package/services/utils.js

@@ -236,6 +236,7 @@ function getHtml(template, translationKeyValue) {
     const replacer = (_, key) => replacePlaceholders(translationKeyValue, key.split('.'), 0) ?? key;
     template = template.replace(pattern, replacer);
     template = template.replace(pattern, replacer);
+    template = template.replace(pattern, replacer);
     template = template.replace(new RegExp('\\[\\[\\s*([a-zA-Z._0-9:]+)\\s*\\]\\]', 'g'), (_, key) => {
         const keyParts = key.split(':');
         return (replacePlaceholders(translationKeyValue, keyParts[1].split('.'), 0) || [])

package/services/utils.ts

@@ -217,6 +217,7 @@ function getHtml(template: string, translationKeyValue: Record<string, any>): st
     const replacer = (_: string, key: string) => replacePlaceholders(translationKeyValue, key.split('.'), 0) ?? key;
     template = template.replace(pattern, replacer);
     template = template.replace(pattern, replacer);
+    template = template.replace(pattern, replacer);
     template = template.replace(new RegExp('\\[\\[\\s*([a-zA-Z._0-9:]+)\\s*\\]\\]', 'g'), (_, key) => {
         const keyParts = key.split(':');
         return (replacePlaceholders(translationKeyValue, keyParts[1].split('.'), 0) || [])