anote-server-libs 0.12.2 → 0.12.4

package/services/WithTransaction.ts

@@ -1,271 +1,271 @@
-import {NextFunction, Request, Response} from 'express';
-import {Logger} from 'winston';
-import {BaseModelRepository} from '../models/repository/BaseModelRepository';
-import {jsonStringify, utils} from './utils';
-
-export const enum SystemLock {
-    CHECK_CROSSING = 1,
-    FLUSH_CALLS = 2,
-    TX_CHECK = 3
-}
-
-export const withTransactionConfig = {
-    logQueries: false,
-    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}>,
-};
-
-/**
- * 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 (err) {
-            const log = utils.logger;
-            if(log) log.error('Error releasing dbClient: %j', {err, stack: new Error().stack});
-        }
-    }
-    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);
-        }
-        const endTerminator = res.end.bind(res);
-        const jsonTerminator = (obj: any) => {
-            try { res.set('Content-Type', 'application/json'); } catch(_) {}
-            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... stack: %s', new Error().stack);
-            process.exit(22);
-        }, withTransactionConfig.timeoutMillis);
-        Promise.all([
-            repo.db ? repo.db.connect() : Promise.resolve(undefined),
-            repo.dbMssql ? Promise.resolve(repo.dbMssql.transaction()) : Promise.resolve(undefined)
-        ]).then(([c1, c2]) => {
-            const dbClient = c1 || c2;
-            clearTimeout(connectTimeoutHandler);
-            // On error, will rollback...
-            utils.logger = logger;
-            if(withTransactionConfig.logQueries && !dbClient.queryPatched) {
-                const originalQuery = dbClient.query.bind(dbClient);
-                dbClient.query = (...args: any[]) => {
-                    logger.debug('SQL [Client %d] QUERY: %s', dbClient.processID, args[0]);
-                    return originalQuery(...args);
-                };
-                dbClient.queryPatched = true;
-            }
-            dbClient.removeAllListeners('error');
-            dbClient.on('error', (err: any) => {
-                if(utils.clientErrorHandler) {
-                    utils.clientErrorHandler(err, dbClient);
-                } else {
-                    logger.error('SQL [Client %d] ERROR (no handler): %j', dbClient?.processID, {err, stack: new Error().stack});
-                }
-            });
-
-            res.locals.dbClient = dbClient;
-            res.locals.dbClientCommited = false;
-            res.locals.dbClientCommit = (cb: (err: any) => any) => {
-                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) => {
-                        releaseAndDecrement(repo, dbClient);
-                        if(!(err instanceof Error)) {
-                            for(let i = 0; i < res.locals.dbClientOnCommit.length; i++) {
-                                res.locals.dbClientOnCommit[i]();
-                            }
-                        }
-                        cb(err instanceof Error ? err : undefined);
-                    });
-                } else {
-                    cb(undefined);
-                }
-            };
-            res.locals.dbClientOnCommit = [];
-
-            // 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.');
-                    };
-                    res.json = (obj: any) => {
-                        if(res.statusCode > 303 && res.statusCode !== 412) {
-                            if(logger) {
-                                if(res.statusCode > 499) {
-                                    logger.error('Uncaught 500 at %s %s: %j', req.method, req.originalUrl, {body: obj, stack: new Error().stack});
-                                } else {
-                                    logger.warn('Client error 4XX at %s %s: %j', req.method, req.originalUrl, {body: obj, stack: new Error().stack});
-                                }
-                            }
-                            (repo.db ? dbClient.query('ROLLBACK') : dbClient.rollback()).catch((err: any) => obj && obj.error && (obj.error.additionalInfo2 = {message: err.message})).then(() => {
-                                releaseAndDecrement(repo, dbClient);
-                                jsonTerminator(obj);
-                            });
-                        } else {
-                            res.locals.dbClientCommit((err: any) => {
-                                if(err && commitIfLost) {
-                                    res.status(500);
-                                    jsonTerminator({
-                                        error: {
-                                            errorKey: 'internal.db',
-                                            additionalInfo: {message: err.message}
-                                        }
-                                    });
-                                } else jsonTerminator(obj);
-                            });
-                        }
-                        return res;
-                    };
-                    res.end = () => {
-                        if(res.statusCode > 303 && res.statusCode !== 412) {
-                            if(logger && res.statusCode > 499) {
-                                logger.error('Uncaught 500 with no details at %s %s: %j', req.method, req.originalUrl, {stack: new Error().stack});
-                            }
-                            (repo.db ? dbClient.query('ROLLBACK') : dbClient.rollback()).catch((): any => undefined).then(() => {
-                                releaseAndDecrement(repo, dbClient);
-                                endTerminator();
-                            });
-                        } else {
-                            res.locals.dbClientCommit((err: any) => {
-                                if(err && commitIfLost) {
-                                    res.status(500);
-                                    jsonTerminator({
-                                        error: {
-                                            errorKey: 'internal.db',
-                                            additionalInfo: {message: err.message}
-                                        }
-                                    });
-                                } else endTerminator();
-                            });
-                        }
-                        return res;
-                    };
-                    return previousMethod.call(this, req, res, next);
-                };
-
-                if(lock) {
-                    dbClient.query('SELECT pg_advisory_xact_lock(' + lock + ')').then(() => finish()).catch((err: any) => {
-                        logger.error('Error acquiring advisory lock %d at %s %s: %j', lock, req.method, req.originalUrl, {err, stack: new Error().stack});
-                        res.status(500).json({
-                            error: {
-                                errorKey: 'internal.db',
-                                additionalInfo: {message: err.message}
-                            }
-                        });
-                        releaseAndDecrement(repo, dbClient);  // Lock acquisition failed, release will also rollback
-                    });
-                } else {
-                    finish();
-                }
-            }).catch((err: any) => {
-                // Error beginning transaction
-                releaseAndDecrement(repo, dbClient);
-                logger.error('Error beginning transaction at %s %s: %j', req.method, req.originalUrl, {err, stack: new Error().stack});
-                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);
-            logger.error('Error connecting to database at %s %s: %j', req.method, req.originalUrl, {err, stack: new Error().stack});
-            withTransactionConfig.activeCount = Math.max(0, withTransactionConfig.activeCount - 1);
-            res.status(500).json({
-                error: {
-                    errorKey: 'internal.db',
-                    additionalInfo: {message: err.message}
-                }
-            });
-        });
-    };
-}
+import {NextFunction, Request, Response} from 'express';
+import {Logger} from 'winston';
+import {BaseModelRepository} from '../models/repository/BaseModelRepository';
+import {jsonStringify, utils} from './utils';
+
+export const enum SystemLock {
+    CHECK_CROSSING = 1,
+    FLUSH_CALLS = 2,
+    TX_CHECK = 3
+}
+
+export const withTransactionConfig = {
+    logQueries: false,
+    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}>,
+};
+
+/**
+ * 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 (err) {
+            const log = utils.logger;
+            if(log) log.error('Error releasing dbClient: %j', {err, stack: new Error().stack});
+        }
+    }
+    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, idleInTransactionTimeout).call(this, req, res, next);
+            });
+        }
+
+        let commit = true;
+        if(!commitIfLost) {
+            res.once('close', () => commit = false);
+        }
+        const endTerminator = res.end.bind(res);
+        const jsonTerminator = (obj: any) => {
+            try { res.set('Content-Type', 'application/json'); } catch(_) {}
+            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... stack: %s', new Error().stack);
+            process.exit(22);
+        }, withTransactionConfig.timeoutMillis);
+        Promise.all([
+            repo.db ? repo.db.connect() : Promise.resolve(undefined),
+            repo.dbMssql ? Promise.resolve(repo.dbMssql.transaction()) : Promise.resolve(undefined)
+        ]).then(([c1, c2]) => {
+            const dbClient = c1 || c2;
+            clearTimeout(connectTimeoutHandler);
+            // On error, will rollback...
+            utils.logger = logger;
+            if(withTransactionConfig.logQueries && !dbClient.queryPatched) {
+                const originalQuery = dbClient.query.bind(dbClient);
+                dbClient.query = (...args: any[]) => {
+                    logger.debug('SQL [Client %d] QUERY: %s', dbClient.processID, args[0]);
+                    return originalQuery(...args);
+                };
+                dbClient.queryPatched = true;
+            }
+            dbClient.removeAllListeners('error');
+            dbClient.on('error', (err: any) => {
+                if(utils.clientErrorHandler) {
+                    utils.clientErrorHandler(err, dbClient);
+                } else {
+                    logger.error('SQL [Client %d] ERROR (no handler): %j', dbClient?.processID, {err, stack: new Error().stack});
+                }
+            });
+
+            res.locals.dbClient = dbClient;
+            res.locals.dbClientCommited = false;
+            res.locals.dbClientCommit = (cb: (err: any) => any) => {
+                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) => {
+                        releaseAndDecrement(repo, dbClient);
+                        if(!(err instanceof Error)) {
+                            for(let i = 0; i < res.locals.dbClientOnCommit.length; i++) {
+                                res.locals.dbClientOnCommit[i]();
+                            }
+                        }
+                        cb(err instanceof Error ? err : undefined);
+                    });
+                } else {
+                    cb(undefined);
+                }
+            };
+            res.locals.dbClientOnCommit = [];
+
+            // 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.');
+                    };
+                    res.json = (obj: any) => {
+                        if(res.statusCode > 303 && res.statusCode !== 412) {
+                            if(logger) {
+                                if(res.statusCode > 499) {
+                                    logger.error('Uncaught 500 at %s %s: %j', req?.method, req?.originalUrl, {body: obj, stack: new Error().stack});
+                                } else {
+                                    logger.warn('Client error 4XX at %s %s: %j', req?.method, req?.originalUrl, {body: obj, stack: new Error().stack});
+                                }
+                            }
+                            (repo.db ? dbClient.query('ROLLBACK') : dbClient.rollback()).catch((err: any) => obj && obj.error && (obj.error.additionalInfo2 = {message: err.message})).then(() => {
+                                releaseAndDecrement(repo, dbClient);
+                                jsonTerminator(obj);
+                            });
+                        } else {
+                            res.locals.dbClientCommit((err: any) => {
+                                if(err && commitIfLost) {
+                                    res.status(500);
+                                    jsonTerminator({
+                                        error: {
+                                            errorKey: 'internal.db',
+                                            additionalInfo: {message: err.message}
+                                        }
+                                    });
+                                } else jsonTerminator(obj);
+                            });
+                        }
+                        return res;
+                    };
+                    res.end = () => {
+                        if(res.statusCode > 303 && res.statusCode !== 412) {
+                            if(logger && res.statusCode > 499) {
+                                logger.error('Uncaught 500 with no details at %s %s: %j', req?.method, req?.originalUrl, {stack: new Error().stack});
+                            }
+                            (repo.db ? dbClient.query('ROLLBACK') : dbClient.rollback()).catch((): any => undefined).then(() => {
+                                releaseAndDecrement(repo, dbClient);
+                                endTerminator();
+                            });
+                        } else {
+                            res.locals.dbClientCommit((err: any) => {
+                                if(err && commitIfLost) {
+                                    res.status(500);
+                                    jsonTerminator({
+                                        error: {
+                                            errorKey: 'internal.db',
+                                            additionalInfo: {message: err.message}
+                                        }
+                                    });
+                                } else endTerminator();
+                            });
+                        }
+                        return res;
+                    };
+                    return previousMethod.call(this, req, res, next);
+                };
+
+                if(lock) {
+                    dbClient.query('SELECT pg_advisory_xact_lock(' + lock + ')').then(() => finish()).catch((err: any) => {
+                        logger.error('Error acquiring advisory lock %d at %s %s: %j', lock, req?.method, req?.originalUrl, {err, stack: new Error().stack});
+                        res.status(500).json({
+                            error: {
+                                errorKey: 'internal.db',
+                                additionalInfo: {message: err.message}
+                            }
+                        });
+                        releaseAndDecrement(repo, dbClient);  // Lock acquisition failed, release will also rollback
+                    });
+                } else {
+                    finish();
+                }
+            }).catch((err: any) => {
+                // Error beginning transaction
+                releaseAndDecrement(repo, dbClient);
+                logger.error('Error beginning transaction at %s %s: %j', req?.method, req?.originalUrl, {err, stack: new Error().stack});
+                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);
+            logger.error('Error connecting to database at %s %s: %j', req?.method, req?.originalUrl, {err, stack: new Error().stack});
+            withTransactionConfig.activeCount = Math.max(0, withTransactionConfig.activeCount - 1);
+            res.status(500).json({
+                error: {
+                    errorKey: 'internal.db',
+                    additionalInfo: {message: err.message}
+                }
+            });
+        });
+    };
+}

package/services/utils.js

@@ -147,22 +147,22 @@ function idempotent(repo, debug, logger) {
     };
 }
 function sendSelfPostableMessage(res, code, messageType, err) {
-    res.type('text/html').status(code).write(`
-<!DOCTYPE HTML>
-<html>
-<head>
-    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
-</head>
-<body>
-<script type="text/javascript">
-    window.parent.postMessage({
-        type: '${messageType}',
-        confirm: ${!err},
-        error: JSON.parse('${JSON.stringify(err) || 'null'}')
-    }, '*');
-</script>
-</body>
-</html>
+    res.type('text/html').status(code).write(`
+<!DOCTYPE HTML>
+<html>
+<head>
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
+</head>
+<body>
+<script type="text/javascript">
+    window.parent.postMessage({
+        type: '${messageType}',
+        confirm: ${!err},
+        error: JSON.parse('${JSON.stringify(err) || 'null'}')
+    }, '*');
+</script>
+</body>
+</html>
     `);
     res.end();
 }
@@ -262,15 +262,15 @@ function getHtmlReplaced(config, templates, key, lang, translations, data = {},
     };
     let html = getHtml(templates[key], merged);
     if (newPage) {
-        html = html.replace('</head>', `<style>
-@media print {
-    .new-page {
-        page-break-before: always;
-    }
-}
-</style>
+        html = html.replace('</head>', `<style>
+@media print {
+    .new-page {
+        page-break-before: always;
+    }
+}
+</style>
 </head>`);
-        html = html.replace('</body>', `<p class="new-page">Provided by Satoris</p>
+        html = html.replace('</body>', `<p class="new-page">Provided by Satoris</p>
 </body>`);
     }
     return html;