anote-server-libs 0.11.8 → 0.12.0

package/services/WithBody.ts

@@ -1,65 +1,65 @@
-import {Request, Response} from 'express';
-import Ajv, {_} from 'ajv';
-
-export const ajv = new Ajv();
-ajv.addKeyword({
-    keyword: 'maxDigits',
-    type: 'number',
-    schemaType: 'number',
-    validate: (schema: number, data: any) => typeof data === 'number' && Math.round(data * 10 ** schema) / (10 ** schema) === data
-});
-
-export function WithBody(schema: any, collapseTopLevelNulls = true) {
-    if(schema.type === 'object') {
-        const required: string[] = [];
-        const keys = Object.getOwnPropertyNames(schema.properties);
-        keys.forEach(key => {
-            if(schema.properties[key].required === true) {
-                required.push(key);
-            }
-            if(schema.properties[key].required === true || schema.properties[key].required === false) {
-                delete schema.properties[key].required;
-            }
-        });
-        schema.required = required;
-    }
-    const validate = ajv.compile(schema);
-    return function(_: any, __: string, descriptor: PropertyDescriptor) {
-        if(typeof descriptor.value === 'function') {
-            const previousMethod = descriptor.value;
-            descriptor.value = function(this: any, req: Request, res: Response) {
-                if(req.method.toUpperCase() !== 'POST' && req.method.toUpperCase() !== 'PUT') {
-                    return previousMethod.call(this, req, res);
-                }
-                if(!req.body) {
-                    res.status(400).json({
-                        error: {
-                            errorKey: 'client.body.missing',
-                            additionalInfo: 'client.extended.badPayload'
-                        }
-                    });
-                } else {
-                    if(collapseTopLevelNulls) {
-                        Object.keys(req.body).forEach(k => {
-                            if(req.body[k] === null) delete req.body[k];
-                        });
-                    }
-                    const valid = validate(req.body);
-                    if(valid) {
-                        return previousMethod.call(this, req, res);
-                    } else {
-                        res.status(400).json({
-                            error: {
-                                errorKey: 'client.body.missing',
-                                additionalInfo: 'client.extended.badPayload',
-                                detailedInfo: validate.errors
-                            }
-                        });
-                    }
-                }
-            };
-            return descriptor;
-        }
-        return undefined;
-    };
-}
+import {Request, Response} from 'express';
+import Ajv, {_} from 'ajv';
+
+export const ajv = new Ajv();
+ajv.addKeyword({
+    keyword: 'maxDigits',
+    type: 'number',
+    schemaType: 'number',
+    validate: (schema: number, data: any) => typeof data === 'number' && Math.round(data * 10 ** schema) / (10 ** schema) === data
+});
+
+export function WithBody(schema: any, collapseTopLevelNulls = true) {
+    if(schema.type === 'object') {
+        const required: string[] = [];
+        const keys = Object.getOwnPropertyNames(schema.properties);
+        keys.forEach(key => {
+            if(schema.properties[key].required === true) {
+                required.push(key);
+            }
+            if(schema.properties[key].required === true || schema.properties[key].required === false) {
+                delete schema.properties[key].required;
+            }
+        });
+        schema.required = required;
+    }
+    const validate = ajv.compile(schema);
+    return function(_: any, __: string, descriptor: PropertyDescriptor) {
+        if(typeof descriptor.value === 'function') {
+            const previousMethod = descriptor.value;
+            descriptor.value = function(this: any, req: Request, res: Response) {
+                if(req.method.toUpperCase() !== 'POST' && req.method.toUpperCase() !== 'PUT') {
+                    return previousMethod.call(this, req, res);
+                }
+                if(!req.body) {
+                    res.status(400).json({
+                        error: {
+                            errorKey: 'client.body.missing',
+                            additionalInfo: 'client.extended.badPayload'
+                        }
+                    });
+                } else {
+                    if(collapseTopLevelNulls) {
+                        Object.keys(req.body).forEach(k => {
+                            if(req.body[k] === null) delete req.body[k];
+                        });
+                    }
+                    const valid = validate(req.body);
+                    if(valid) {
+                        return previousMethod.call(this, req, res);
+                    } else {
+                        res.status(400).json({
+                            error: {
+                                errorKey: 'client.body.missing',
+                                additionalInfo: 'client.extended.badPayload',
+                                detailedInfo: validate.errors
+                            }
+                        });
+                    }
+                }
+            };
+            return descriptor;
+        }
+        return undefined;
+    };
+}

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',