anote-server-libs 0.2.8 → 0.2.9

package/models/ApiCall.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiCallRepository = void 0;
+const mssql_1 = require("mssql");
+const ModelDao_1 = require("./repository/ModelDao");
+class ApiCallRepository extends ModelDao_1.ModelDao {
+    constructor(pool, poolMssql, logger) {
+        super(pool, poolMssql, logger, 'api_call', 5, pool ? 'id=$1,"updatedOn"=$2,"responseCode"=$3,"responseJson"=$4,"expiresAt"=$5' :
+            'id=@1,"updatedOn"=@2,"responseCode"=@3,"responseJson"=@4,"expiresAt"=@5');
+        this.pool = pool;
+        this.poolMssql = poolMssql;
+        this.logger = logger;
+    }
+    buildObject(q) {
+        if (!q)
+            return undefined;
+        q.id = q.id.trim();
+        q.updatedOn = q.updatedOn && new Date(q.updatedOn);
+        q.responseCode = parseInt(q.responseCode, 10);
+        q.expiresAt = q.expiresAt && new Date(q.expiresAt);
+        return q;
+    }
+    serialize(instance, request) {
+        if (request) {
+            request.input('1', instance.id);
+            request.input('2', mssql_1.DateTimeOffset, instance.updatedOn);
+            request.input('3', instance.responseCode);
+            request.input('4', instance.responseJson);
+            request.input('5', mssql_1.DateTimeOffset, instance.expiresAt);
+            return undefined;
+        }
+        else {
+            return [instance.id, instance.updatedOn, instance.responseCode, instance.responseJson, instance.expiresAt];
+        }
+    }
+}
+exports.ApiCallRepository = ApiCallRepository;

package/models/Migration.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationRepository = void 0;
+const ModelDao_1 = require("./repository/ModelDao");
+class MigrationRepository extends ModelDao_1.ModelDao {
+    constructor(pool, poolMssql, logger) {
+        super(pool, poolMssql, logger, 'migration', 5, pool ? 'id=$1,hash=$2,"sqlUp"=$3,"sqlDown"=$4,state=$5' :
+            'id=@1,hash=@2,"sqlUp"=@3,"sqlDown"=@4,state=@5');
+        this.pool = pool;
+        this.poolMssql = poolMssql;
+        this.logger = logger;
+    }
+    buildObject(q) {
+        if (!q)
+            return undefined;
+        q.id = parseInt(q.id, 10);
+        q.hash = q.hash.trim();
+        q.state = parseInt(q.state, 10);
+        return q;
+    }
+    serialize(instance, request) {
+        if (request) {
+            request.input('1', instance.id);
+            request.input('2', instance.hash);
+            request.input('3', instance.sqlUp);
+            request.input('4', instance.sqlDown);
+            request.input('5', instance.state);
+            return undefined;
+        }
+        else {
+            return [instance.id, instance.hash, instance.sqlUp, instance.sqlDown, instance.state];
+        }
+    }
+}
+exports.MigrationRepository = MigrationRepository;

package/models/repository/BaseModelRepository.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseModelRepository = void 0;
+const fs = require("fs");
+const node_forge_1 = require("node-forge");
+const ApiCall_1 = require("../ApiCall");
+const Migration_1 = require("../Migration");
+class BaseModelRepository {
+    constructor(db, dbSpare, dbMssql, logger, cache) {
+        this.db = db;
+        this.dbSpare = dbSpare;
+        this.dbMssql = dbMssql;
+        this.logger = logger;
+        this.cache = cache;
+        if (db && dbSpare) {
+            const dbQuery = db.query.bind(db);
+            db.query = (function (text, values, cb) {
+                if ((this.idleCount + this.waitingCount) >= this.totalCount && this.totalCount === this.options.max)
+                    return dbSpare.query(text, values, cb);
+                return dbQuery(text, values, cb);
+            }).bind(db);
+        }
+        this.Migration = new Migration_1.MigrationRepository(db, dbMssql, logger);
+        this.ApiCall = new ApiCall_1.ApiCallRepository(db, dbMssql, logger);
+    }
+    migrate(migrationsPath, callback) {
+        (this.db ? this.db.query('CREATE TABLE IF NOT EXISTS migration (' +
+            'id integer PRIMARY KEY,' +
+            'hash text NOT NULL,' +
+            '"sqlUp" text NOT NULL,' +
+            '"sqlDown" text NOT NULL,' +
+            'state integer NOT NULL' +
+            ')') : this.dbMssql.query('if not exists (select * from sysobjects where name=\'migration\' and xtype=\'U\') CREATE TABLE migration (' +
+            'id int PRIMARY KEY,' +
+            'hash text NOT NULL,' +
+            '"sqlUp" text NOT NULL,' +
+            '"sqlDown" text NOT NULL,' +
+            'state int NOT NULL' +
+            ')')).then(() => {
+            this.Migration.getAllBy('id').then((migrations) => {
+                if (migrations.find(migration => migration.state !== 0))
+                    process.exit(4);
+                fs.readdir(migrationsPath, (_, files) => {
+                    const migrationsAvailable = files
+                        .filter(file => /[0-9]+\.sql/.test(file))
+                        .map(file => parseInt(file.split('.sql')[0], 10))
+                        .filter(file => file > 0)
+                        .sort((a, b) => a - b)
+                        .map(file => {
+                        const content = fs.readFileSync(migrationsPath + file + '.sql', 'utf-8');
+                        return {
+                            id: file,
+                            content: content,
+                            hash: node_forge_1.md.sha256.create().update(content).digest().toHex()
+                        };
+                    });
+                    if (migrationsAvailable.length === 0
+                        || migrationsAvailable.length
+                            !== migrationsAvailable[migrationsAvailable.length - 1].id)
+                        process.exit(5);
+                    let highestCommon = 0;
+                    while (highestCommon < migrations.length && highestCommon < migrationsAvailable.length
+                        && migrations[highestCommon].hash === migrationsAvailable[highestCommon].hash)
+                        highestCommon++;
+                    this.applyDownUntil(migrations, migrations.length, highestCommon).then(() => {
+                        this.applyUpUntil(migrationsAvailable, highestCommon, migrationsAvailable.length).then(callback, process.exit);
+                    }, process.exit);
+                });
+            }, () => process.exit(3));
+        }, () => process.exit(2));
+    }
+    lockTables(tables, client) {
+        if (this.db)
+            return Promise.all(tables.map(t => client.query('LOCK TABLE ' + t.table + ' IN EXCLUSIVE MODE')));
+        return Promise.all(tables.map(t => client.request().query('SELECT id FROM ' + t.table + ' WITH (UPDLOCK)')));
+    }
+    applyUpUntil(migrations, current, until) {
+        if (current < until)
+            return this.applyUp(migrations[current]).then(() => this.applyUpUntil(migrations, current + 1, until));
+        return Promise.resolve();
+    }
+    applyUp(migration) {
+        return new Promise((resolve, reject) => {
+            const sqlParts = migration.content.split('----');
+            this.Migration.create({
+                id: migration.id,
+                hash: migration.hash,
+                sqlUp: sqlParts[0],
+                sqlDown: sqlParts[1],
+                state: 2
+            }).then(() => {
+                (this.db || this.dbMssql).query(sqlParts[0], (err) => {
+                    if (err) {
+                        console.error(err);
+                        reject(10);
+                    }
+                    else {
+                        (this.db || this.dbMssql).query('UPDATE "migration" SET "state"=0 WHERE "id"=' + migration.id, (err2) => {
+                            if (err2)
+                                reject(11);
+                            else
+                                resolve();
+                        });
+                    }
+                });
+            }, () => process.exit(9));
+        });
+    }
+    applyDownUntil(migrations, current, until) {
+        if (current > until) {
+            current--;
+            return this.applyDown(migrations[current]).then(() => this.applyDownUntil(migrations, current, until));
+        }
+        return Promise.resolve();
+    }
+    applyDown(migration) {
+        return new Promise((resolve, reject) => {
+            (this.db || this.dbMssql).query('UPDATE "migration" SET "state"=1 WHERE "id"=' + migration.id, (err) => {
+                if (err)
+                    reject(6);
+                else
+                    (this.db || this.dbMssql).query(migration.sqlDown, (err2) => {
+                        if (err2) {
+                            console.error(err2);
+                            reject(7);
+                        }
+                        else
+                            (this.db || this.dbMssql).query('DELETE FROM "migration" WHERE "id"=' + migration.id, (err3) => {
+                                if (err3 && migration.id !== 1)
+                                    reject(8);
+                                else {
+                                    if (migration.id === 1) {
+                                        (this.db ? this.db.query('CREATE TABLE IF NOT EXISTS migration (' +
+                                            'id integer PRIMARY KEY,' +
+                                            'hash text NOT NULL,' +
+                                            '"sqlUp" text NOT NULL,' +
+                                            '"sqlDown" text NOT NULL,' +
+                                            'state integer NOT NULL' +
+                                            ')') : this.dbMssql.query('if not exists (select * from sysobjects where name=\'migration\' and xtype=\'U\') CREATE TABLE migration (' +
+                                            'id int PRIMARY KEY,' +
+                                            'hash text NOT NULL,' +
+                                            '"sqlUp" text NOT NULL,' +
+                                            '"sqlDown" text NOT NULL,' +
+                                            'state int NOT NULL' +
+                                            ')')).then(() => resolve(), reject);
+                                    }
+                                    else
+                                        resolve();
+                                }
+                            });
+                    });
+            });
+        });
+    }
+}
+exports.BaseModelRepository = BaseModelRepository;

package/models/repository/MemoryCache.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryCache = void 0;
+class MemoryCache {
+    constructor(localKey, cache) {
+        this.localKey = localKey;
+        this.cache = cache;
+        this.localCache = {};
+    }
+    list() {
+        if (this.cache)
+            return new Promise(resolve => {
+                let pending = true;
+                setTimeout(() => {
+                    if (pending) {
+                        pending = false;
+                        resolve([]);
+                    }
+                }, 250);
+                this.cache.items((_, data) => {
+                    if (pending) {
+                        pending = false;
+                        resolve(data.map(s => {
+                            const value = s[Object.getOwnPropertyNames(s).find(sname => sname.startsWith(this.localKey))];
+                            return value && JSON.parse(value);
+                        }).filter(x => x));
+                    }
+                });
+            });
+        else
+            return Promise.resolve(Object.getOwnPropertyNames(this.localCache).map(key => this.localCache[key]));
+    }
+    get(key) {
+        if (this.cache)
+            return new Promise(resolve => {
+                let pending = true;
+                setTimeout(() => {
+                    if (pending) {
+                        pending = false;
+                        resolve(undefined);
+                    }
+                }, 250);
+                this.cache.get(this.localKey + key, (_, data) => {
+                    if (pending) {
+                        pending = false;
+                        resolve(data && JSON.parse(data));
+                    }
+                });
+            });
+        else
+            return Promise.resolve(this.localCache[key]);
+    }
+    set(key, val) {
+        if (this.cache)
+            return new Promise(resolve => this.cache.add(this.localKey + key, JSON.stringify(val), 15 * 60, resolve));
+        else {
+            this.localCache[key] = val;
+            return Promise.resolve();
+        }
+    }
+    delete(key) {
+        if (this.cache) {
+            return new Promise(resolve => {
+                let fired = false;
+                const handler = setTimeout(() => {
+                    fired = true;
+                    resolve();
+                }, 50);
+                this.cache.del(this.localKey + key, () => {
+                    if (!fired) {
+                        clearTimeout(handler);
+                        resolve();
+                    }
+                });
+            });
+        }
+        else {
+            this.localCache[key] = undefined;
+            return Promise.resolve();
+        }
+    }
+    clear() {
+        if (this.cache) {
+            this.localKey = this.localKey + '_';
+            if (this.localKey.length > 40)
+                this.localKey = this.localKey.replace(/_+$/, '');
+        }
+        else
+            this.localCache = {};
+    }
+}
+exports.MemoryCache = MemoryCache;

package/models/repository/ModelDao.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelDao = exports.Dao = exports.promiseAllStepN = void 0;
+function promiseAllStepN(n, list) {
+    if (!list || !list.length)
+        return Promise.resolve([]);
+    const tail = list.splice(n);
+    const head = list;
+    const resolved = [];
+    let processed = 0;
+    return new Promise(resolve => {
+        head.forEach(x => {
+            const res = x();
+            resolved.push(res);
+            res.then((y) => {
+                runNext();
+                return y;
+            });
+        });
+        function runNext() {
+            if (processed === tail.length) {
+                resolve(Promise.all(resolved));
+            }
+            else {
+                resolved.push(tail[processed]().then((x) => {
+                    runNext();
+                    return x;
+                }));
+                processed++;
+            }
+        }
+    });
+}
+exports.promiseAllStepN = promiseAllStepN;
+Promise.allConcurrent = (n) => (list) => promiseAllStepN(n, list);
+class Dao {
+    constructor(pool, poolMssql, logger, table, nFields, updateDefinition) {
+        this.pool = pool;
+        this.poolMssql = poolMssql;
+        this.logger = logger;
+        this.table = table;
+        this.nFields = nFields;
+        this.updateDefinition = updateDefinition;
+    }
+    groupResultSet(q, key) {
+        const storage = {};
+        for (let i = 0; i < q.length; i++) {
+            storage[q[i][key]] = storage[q[i][key]] || [];
+            storage[q[i][key]].push(q[i]);
+        }
+        return Object.getOwnPropertyNames(storage).map(k => storage[k]);
+    }
+    groupResultSetBy(q, key) {
+        const storage = {};
+        for (let i = 0; i < q.length; i++) {
+            storage[key(q[i])] = storage[key(q[i])] || [];
+            storage[key(q[i])].push(q[i]);
+        }
+        return Object.getOwnPropertyNames(storage).map(k => storage[k]);
+    }
+    update(instance, client) {
+        if (instance.archivedOn)
+            return Promise.reject('Record archived!');
+        instance.updatedOn = new Date();
+        if (this.pool) {
+            const props = this.serialize(instance);
+            props.push(instance.id);
+            return client.query('UPDATE ' + this.table + ' SET ' + this.updateDefinition + ' WHERE id=$' + (this.nFields + 1), props).then(() => instance.id);
+        }
+        else {
+            const request = client.request();
+            this.serialize(instance, request);
+            request.input(String(this.nFields + 1), instance.id);
+            return request.query('UPDATE ' + this.table + ' SET ' + this.updateDefinition + ' WHERE id=@' + (this.nFields + 1)).then(() => instance.id);
+        }
+    }
+    create(instance, client) {
+        instance.createdOn = instance.updatedOn = new Date();
+        if (this.pool) {
+            const props = this.serialize(instance);
+            return (client || this.pool).query('INSERT INTO ' + this.table + '(' + this.updateDefinition.replace(/=\$\d+/g, '').replace(/=[^)]+\)/g, '') + ')'
+                + ' VALUES(' + new Array(this.nFields).fill(undefined).map((_, i) => '$' + (i + 1)).join(',') + ') RETURNING id', props).then(q => {
+                const idNum = parseInt(q.rows[0].id, 10);
+                if (String(idNum) !== q.rows[0].id)
+                    return q.rows[0].id;
+                return idNum;
+            });
+        }
+        else {
+            const request = (client || this.poolMssql).request();
+            this.serialize(instance, request);
+            return request.query('INSERT INTO ' + this.table + '(' + this.updateDefinition.replace(/=@\d+/g, '').replace(/=[^)]+\)/g, '') + ')'
+                + ' VALUES(' + new Array(this.nFields).fill(undefined).map((_, i) => '@' + (i + 1)).join(',') + '); SELECT SCOPE_IDENTITY() AS id').then(q => {
+                return q.recordsets[0][0].id || instance.id;
+            });
+        }
+    }
+    createSeveral(instances, client) {
+        if (!instances.length)
+            return Promise.resolve([]);
+        const now = new Date();
+        instances.forEach(instance => instance.updatedOn = now);
+        const props = [].concat.apply([], instances.map(instance => this.serialize(instance)));
+        return (client || this.pool).query('INSERT INTO ' + this.table + '(' + this.updateDefinition.replace(/=\$\d+/g, '').replace(/=[^)]+\)/g, '') + ')'
+            + ' VALUES' + instances.map((_, j) => ('(' + new Array(this.nFields).fill(undefined).map((__, i) => '$' + (j * this.nFields + i + 1)).join(', ') + ')')).join(',') + ' RETURNING id', props).then(q => q.rows.map(r => {
+            const idNum = parseInt(r.id, 10);
+            if (String(idNum) !== q.rows[0].id)
+                return r.id;
+            return idNum;
+        }));
+    }
+}
+exports.Dao = Dao;
+class ModelDao extends Dao {
+    get(id, client, lock = true) {
+        if (this.pool) {
+            return (client || this.pool).query('SELECT * FROM ' + this.table + ' WHERE id=$1' + ((client && lock) ? ' FOR UPDATE' : ''), [id]).then(q => this.buildObject(q.rows[0]));
+        }
+        else {
+            const request = (client || this.poolMssql).request();
+            request.input('1', id);
+            return request.query('SELECT * FROM ' + this.table + ((client && lock) ? ' WITH (ROWLOCK)' : '') + ' WHERE id=@1').then(q => this.buildObject(q.recordsets[0][0]));
+        }
+    }
+    count(where, inputs = [], client) {
+        if (this.pool) {
+            return (client || this.pool).query('SELECT count(*) AS cnt FROM ' + this.table + (where ? (' WHERE ' + where) : ''), inputs).then(q => parseInt(q.rows[0].cnt, 10));
+        }
+        else {
+            const request = (client || this.poolMssql).request();
+            if (where)
+                where.match(/(@\d+)/g).forEach((match, i) => request.input(match.substr(1), inputs[i]));
+            return request.query('SELECT count(*) AS cnt FROM ' + this.table + (where ? (' WHERE ' + where) : '')).then(q => q.recordsets[0][0].cnt);
+        }
+    }
+    getList(ids, client, lock = true) {
+        if (this.pool) {
+            return (client || this.pool).query('SELECT * FROM ' + this.table + ' WHERE id=ANY($1)' + ((client && lock) ? ' FOR UPDATE' : ''), [ids])
+                .then(q => q.rows.map(r => this.buildObject(r)));
+        }
+        else {
+            const request = (client || this.poolMssql).request();
+            return request.query('SELECT * FROM ' + this.table + ((client && lock) ? ' WITH (ROWLOCK)' : '') + ' WHERE id IN ('
+                + (ids.length > 0 ? (typeof ids[0] === 'string' ? '\'' + ids.join('\',\'') + '\'' : ids.join(',')) : '') + ')')
+                .then(q => q.recordsets[0].map(r => this.buildObject(r)));
+        }
+    }
+    getAllBy(order, offset, limit, where, inputs = [], client, lock = true) {
+        if (this.pool) {
+            return (client || this.pool).query('SELECT * FROM ' + this.table + (where ? (' WHERE ' + where) : '') + (order ? (' ORDER BY ' + order) : '')
+                + (offset ? (' OFFSET ' + offset) : '') + (limit !== undefined ? (' LIMIT ' + limit) : '') + ((client && lock) ? ' FOR UPDATE' : ''), inputs)
+                .then(q => q.rows.map(r => this.buildObject(r)));
+        }
+        else {
+            const request = (client || this.poolMssql).request();
+            if (where)
+                where.match(/(@\d+)/g).forEach((match, i) => request.input(match.substr(1), inputs[i]));
+            return request.query('SELECT * FROM ' + this.table + ((client && lock) ? ' WITH (ROWLOCK)' : '') + (where ? (' WHERE ' + where) : '')
+                + (order ? (' ORDER BY ' + order) : '') + (offset !== undefined ? (' OFFSET ' + offset + ' ROWS') : '') + (limit !== undefined ? (' FETCH NEXT ' + limit + ' ROWS ONLY') : ''))
+                .then(q => q.recordsets[0].map(r => this.buildObject(r)));
+        }
+    }
+    getViewCountBy(order, offset, limit, where, inputs = [], client, lock = true) {
+        if (this.pool) {
+            return (client || this.pool).query('SELECT *, COUNT(*) OVER() AS cnt FROM ' + this.table + (where ? (' WHERE ' + where) : '') + (order ? (' ORDER BY ' + order) : '')
+                + (offset ? (' OFFSET ' + offset) : '') + (limit !== undefined ? (' LIMIT ' + limit) : '') + ((client && lock) ? ' FOR UPDATE' : ''), inputs)
+                .then(q => ({
+                views: q.rows.map(r => this.buildObject(r)),
+                count: q.rows.length ? parseInt(q.rows[0].cnt, 10) : 0
+            }));
+        }
+        else {
+            const request = (client || this.poolMssql).request();
+            if (where)
+                where.match(/(@\d+)/g).forEach((match, i) => request.input(match.substr(1), inputs[i]));
+            return Promise.allConcurrent(1)([
+                () => request.query('SELECT * FROM ' + this.table + ((client && lock) ? ' WITH (ROWLOCK)' : '') + (where ? (' WHERE ' + where) : '')
+                    + (order ? (' ORDER BY ' + order) : '') + (offset !== undefined ? (' OFFSET ' + offset + ' ROWS') : '') + (limit !== undefined ? (' FETCH NEXT ' + limit + ' ROWS ONLY') : '')),
+                () => request.query('SELECT COUNT(DISTINCT id) AS cnt FROM ' + this.table + (where ? (' WHERE ' + where) : ''))
+            ]).then(([q1, q2]) => ({
+                views: q1.recordsets[0].map((r) => this.buildObject(r)),
+                count: q2.recordsets.length ? q2.recordsets[0].reduce((p, n) => p + n.cnt, 0) : 0
+            }));
+        }
+    }
+    getRowsViewCountBy(rows, order, offset, limit, where, inputs = [], client, lock = true) {
+        if (this.pool) {
+            return (client || this.pool).query('SELECT ' + rows.map(r => '"' + r + '"').join(',') + ', COUNT(*) OVER() AS cnt FROM ' + this.table + (where ? (' WHERE ' + where) : '') + (order ? (' ORDER BY ' + order) : '')
+                + (offset ? (' OFFSET ' + offset) : '') + (limit !== undefined ? (' LIMIT ' + limit) : '') + ((client && lock) ? ' FOR UPDATE' : ''), inputs)
+                .then(q => ({
+                views: q.rows.map(r => this.buildObject(r)),
+                count: q.rows.length ? parseInt(q.rows[0].cnt, 10) : 0
+            }));
+        }
+        else {
+            const request = (client || this.poolMssql).request();
+            if (where)
+                where.match(/(@\d+)/g).forEach((match, i) => request.input(match.substr(1), inputs[i]));
+            return Promise.allConcurrent(1)([
+                () => request.query('SELECT ' + rows.map(r => '"' + r + '"').join(',') + ' FROM ' + this.table
+                    + ((client && lock) ? ' WITH (ROWLOCK)' : '') + (where ? (' WHERE ' + where) : '') + (order ? (' ORDER BY ' + order) : '')
+                    + (offset !== undefined ? (' OFFSET ' + offset + ' ROWS') : '') + (limit !== undefined ? (' FETCH NEXT ' + limit + ' ROWS ONLY') : '')),
+                () => request.query('SELECT COUNT(DISTINCT id) AS cnt FROM ' + this.table + (where ? (' WHERE ' + where) : ''))
+            ]).then(([q1, q2]) => ({
+                views: q1.recordsets[0].map((r) => this.buildObject(r)),
+                count: q2.recordsets.length ? q2.recordsets[0].reduce((p, n) => p + n.cnt, 0) : 0
+            }));
+        }
+    }
+    archive(id, replacedById, client) {
+        if (this.pool) {
+            return client.query('UPDATE ' + this.table + ' SET "archivedOn"=now(),replaced_by_id=$1 WHERE id=$2', [replacedById, id]);
+        }
+        else {
+            const request = client.request();
+            request.input('1', replacedById);
+            request.input('2', id);
+            return request.query('UPDATE ' + this.table + ' SET "archivedOn"=now(),replaced_by_id=@1 WHERE id=@2');
+        }
+    }
+    replace(instance, client) {
+        if (instance.archivedOn)
+            return Promise.reject('Record archived!');
+        return this.create({ ...instance, replaced_id: instance.id }, client).then(id => {
+            return this.archive(instance.id, id, client).then(() => id);
+        });
+    }
+    delete(id, client) {
+        if (this.pool) {
+            return client.query('DELETE FROM ' + this.table + ' WHERE id=$1', [id]);
+        }
+        else {
+            const request = client.request();
+            request.input('1', id);
+            return request.query('DELETE FROM ' + this.table + ' WHERE id=@1');
+        }
+    }
+}
+exports.ModelDao = ModelDao;

package/package.json

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

package/services/WithBody.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithBody = void 0;
+const jsonschema_1 = require("jsonschema");
+function WithBody(schema) {
+    const validator = new jsonschema_1.Validator();
+    validator.attributes.maxDigits = (instance, sc) => {
+        if (typeof instance !== 'number')
+            return undefined;
+        if (typeof sc.maxDigits !== 'number' || Math.floor(sc.maxDigits) !== sc.maxDigits) {
+            throw new jsonschema_1.SchemaError('"maxDigits" expects an integer', sc);
+        }
+        if (Math.round(instance * 10 ** sc.maxDigits) / (10 ** sc.maxDigits) !== instance) {
+            return 'has more precision than ' + sc.maxDigits + ' digits';
+        }
+        return undefined;
+    };
+    return function (_, __, descriptor) {
+        if (typeof descriptor.value === 'function') {
+            const previousMethod = descriptor.value;
+            descriptor.value = function (req, res) {
+                const keys = Object.getOwnPropertyNames(schema.properties);
+                keys.forEach(key => {
+                    if (typeof schema.properties[key] === 'string') {
+                        schema.properties[key] = this.config.app.endpointsSchemas[schema.properties[key]];
+                    }
+                });
+                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 {
+                    const result = validator.validate(req.body, schema);
+                    if (result.valid) {
+                        return previousMethod.call(this, req, res);
+                    }
+                    else {
+                        res.status(400).json({
+                            error: {
+                                errorKey: 'client.body.missing',
+                                additionalInfo: 'client.extended.badPayload',
+                                detailedInfo: result.errors
+                            }
+                        });
+                    }
+                }
+            };
+            return descriptor;
+        }
+        return undefined;
+    };
+}
+exports.WithBody = WithBody;

package/services/WithTransaction.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTransaction = void 0;
+const utils_1 = require("./utils");
+function withTransaction(repo, logger, previousMethod, lock) {
+    return function (req, res, next) {
+        const endTerminator = res.end.bind(res);
+        const jsonTerminator = (obj) => {
+            res.write((0, utils_1.jsonStringify)(obj) || '{}');
+            endTerminator();
+        };
+        const connectTimeoutHandler = setTimeout(() => {
+            logger.error('Error timed out getting a client, exiting...');
+            process.exit(22);
+        }, 3000);
+        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);
+            utils_1.utils.logger = logger;
+            dbClient.removeListener('error', utils_1.utils.clientErrorHandler);
+            dbClient.on('error', utils_1.utils.clientErrorHandler);
+            res.locals.dbClient = dbClient;
+            res.locals.dbClientCommited = false;
+            res.locals.dbClientCommit = (cb) => {
+                if (!res.locals.dbClientCommited) {
+                    res.locals.dbClientCommited = true;
+                    (repo.db ? dbClient.query('COMMIT') : dbClient.commit()).catch((err) => err).then((err) => {
+                        if (repo.db)
+                            dbClient.release();
+                        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 = [];
+            return (repo.db ? dbClient.query('BEGIN') : dbClient.begin()).then(() => {
+                const finish = () => {
+                    res.json = (obj) => {
+                        if (res.statusCode > 303 && res.statusCode !== 412) {
+                            if (logger && res.statusCode > 499) {
+                                logger.error('Uncaught 500: %j', obj.error.additionalInfo);
+                            }
+                            (repo.db ? dbClient.query('ROLLBACK') : dbClient.rollback()).catch((err) => obj.error.additionalInfo2 = { message: err.message }).then(() => {
+                                if (repo.db)
+                                    dbClient.release();
+                                jsonTerminator(obj);
+                            });
+                        }
+                        else {
+                            res.locals.dbClientCommit((err) => {
+                                if (err) {
+                                    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...');
+                            }
+                            (repo.db ? dbClient.query('ROLLBACK') : dbClient.rollback()).catch(() => undefined).then(() => {
+                                if (repo.db)
+                                    dbClient.release();
+                                endTerminator();
+                            });
+                        }
+                        else {
+                            res.locals.dbClientCommit((err) => {
+                                if (err) {
+                                    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) => {
+                        res.status(500).json({
+                            error: {
+                                errorKey: 'internal.db',
+                                additionalInfo: { message: err.message }
+                            }
+                        });
+                        dbClient.release();
+                    });
+                }
+                else {
+                    finish();
+                }
+            });
+        }).catch(err => {
+            res.status(500).json({
+                error: {
+                    errorKey: 'internal.db',
+                    additionalInfo: { message: err.message }
+                }
+            });
+        });
+    };
+}
+exports.withTransaction = withTransaction;

package/services/utils.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.digitize = exports.fpEuros = exports.sendSelfPostableMessage = exports.idempotent = exports.jsonStringify = exports.lcm = exports.gcd = exports.utils = exports.clientErrorHandle = exports.btoa = exports.atob = void 0;
+function atob(str) {
+    return Buffer.from(str, 'base64').toString('binary');
+}
+exports.atob = atob;
+function btoa(str) {
+    return Buffer.from(str).toString('base64');
+}
+exports.btoa = btoa;
+function clientErrorHandle(err) {
+    this.error('Error on DB client: %j', err);
+}
+exports.clientErrorHandle = clientErrorHandle;
+exports.utils = {
+    clientErrorHandler: undefined
+};
+function gcdTwo(a, b) {
+    if (a === 0)
+        return b;
+    return gcdTwo(b % a, a);
+}
+function gcd(values) {
+    let result = values[0];
+    for (let i = 1; i < values.length; i++)
+        result = gcdTwo(values[i], result);
+    return result;
+}
+exports.gcd = gcd;
+function lcm(values) {
+    let l = 1, divisor = 2;
+    while (true) {
+        let counter = 0;
+        let divisible = false;
+        for (let i = 0; i < values.length; i++) {
+            if (values[i] === 0) {
+                return 0;
+            }
+            else if (values[i] < 0) {
+                values[i] = values[i] * (-1);
+            }
+            if (values[i] === 1) {
+                counter++;
+            }
+            if (values[i] % divisor === 0) {
+                divisible = true;
+                values[i] = values[i] / divisor;
+            }
+        }
+        if (divisible) {
+            l = l * divisor;
+        }
+        else {
+            divisor++;
+        }
+        if (counter === values.length) {
+            return l;
+        }
+    }
+}
+exports.lcm = lcm;
+function jsonStringify(obj) {
+    const cache = {};
+    return JSON.stringify(obj, function (_, value) {
+        if (typeof value === 'object' && value !== null) {
+            if (cache[value] !== -1) {
+                try {
+                    return JSON.parse(JSON.stringify(value));
+                }
+                catch (error) {
+                    return;
+                }
+            }
+            cache[value] = true;
+        }
+        return value;
+    });
+}
+exports.jsonStringify = jsonStringify;
+function idempotent(repo, debug, logger) {
+    return function (req, res, next) {
+        let idempotenceKey = req.header('x-idempotent-key');
+        if (idempotenceKey) {
+            idempotenceKey = idempotenceKey.substring(0, 40);
+            repo.ApiCall.get(idempotenceKey).then(call => {
+                if (!call) {
+                    const jsonTerminator = res.json;
+                    const endTerminator = res.end;
+                    const writeTerminator = res.write;
+                    let response = '';
+                    res.json = (function (obj) {
+                        repo.ApiCall.create({
+                            id: idempotenceKey,
+                            responseCode: res.statusCode,
+                            responseJson: jsonStringify(obj),
+                            expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000)
+                        }).then(() => jsonTerminator.call(res, obj), err => {
+                            if (err)
+                                logger.warn('Cannot save idempotent key: %j', err);
+                            jsonTerminator.call(res, obj);
+                        });
+                    }).bind(res);
+                    res.end = (function (buf) {
+                        if (buf)
+                            response = response + buf.toString();
+                        repo.ApiCall.create({
+                            id: idempotenceKey,
+                            responseCode: res.statusCode,
+                            responseJson: response,
+                            expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000)
+                        }).then(() => endTerminator.call(res, buf), err => {
+                            if (err)
+                                logger.warn('Cannot save idempotent key: %j', err);
+                            endTerminator.call(res, buf);
+                        });
+                    }).bind(res);
+                    res.write = (function (buf) {
+                        if (buf)
+                            response = response + buf.toString();
+                        writeTerminator.call(res, buf);
+                    }).bind(res);
+                    next();
+                }
+                else
+                    res.status(417).json({
+                        responseCode: call.responseCode,
+                        responseBody: call.responseJson
+                    });
+            }, err => res.status(500).json({
+                error: {
+                    errorKey: 'internal.db',
+                    additionalInfo: { message: err.message, stack: debug && err.stack }
+                }
+            }));
+        }
+        else
+            next();
+    };
+}
+exports.idempotent = idempotent;
+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.end();
+}
+exports.sendSelfPostableMessage = sendSelfPostableMessage;
+function fpEuros(n) {
+    return Math.round(n * 100) / 100;
+}
+exports.fpEuros = fpEuros;
+function digitize(value, opts) {
+    if (value === undefined || value === null)
+        return 'undefined';
+    if (typeof value === 'number') {
+        if (isNaN(value))
+            return '-';
+        if (!isFinite(value))
+            return 'Infinite';
+        value = String(value);
+    }
+    else if (typeof value === 'string')
+        return value;
+    const parts = value.split('.');
+    const initialLength = parts[0].length;
+    for (let i = initialLength - 3; i > 0; i -= 3) {
+        parts[0] = parts[0].slice(0, i) + ',' + parts[0].slice(i);
+    }
+    if (parts[0].startsWith('-,'))
+        parts[0] = '-' + parts[0].slice(2);
+    if (parts[1]) {
+        const expDecimals = parts[1].split(/[eE]-/);
+        if (expDecimals.length > 1 && parseInt(expDecimals[1], 10) > 2)
+            return '0.00';
+        let decimals = fpEuros(parseFloat('0.' + parts[1])).toString().substr(2, 2);
+        if (decimals.length === 1)
+            decimals += '0';
+        return parts[0] + '.' + decimals;
+    }
+    return (opts && opts.currency) ? (parts[0] + '.00') : parts[0];
+}
+exports.digitize = digitize;