anote-server-libs 0.0.6 → 0.1.0

package/models/ApiCall.js

@@ -1,11 +1,14 @@
 "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, logger) {
-        super(pool, logger, 'api_call', 5, 'id=$1,"updatedOn"=$2,"responseCode"=$3,"responseJson"=$4,"expiresAt"=$5');
+    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) {
@@ -17,8 +20,18 @@ class ApiCallRepository extends ModelDao_1.ModelDao {
         q.expiresAt = q.expiresAt && new Date(q.expiresAt);
         return q;
     }
-    serialize(instance) {
-        return [instance.id, instance.updatedOn, instance.responseCode, instance.responseJson, instance.expiresAt];
+    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/ApiCall.ts

@@ -1,3 +1,4 @@
+import { ConnectionPool, DateTimeOffset, Request } from 'mssql';
 import {Pool} from 'pg';
 import {Logger} from 'winston';
 import {Model, ModelDao} from './repository/ModelDao';
@@ -9,8 +10,9 @@ export interface ApiCall extends Model<string> {
 }
 
 export class ApiCallRepository extends ModelDao<string, ApiCall> {
-    constructor(protected pool: Pool, protected logger: Logger) {
-        super(pool, logger, 'api_call', 5, 'id=$1,"updatedOn"=$2,"responseCode"=$3,"responseJson"=$4,"expiresAt"=$5');
+    constructor(protected pool: Pool, protected poolMssql: ConnectionPool, protected logger: 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');
     }
 
     buildObject(q: any): ApiCall {
@@ -22,7 +24,17 @@ export class ApiCallRepository extends ModelDao<string, ApiCall> {
         return q;
     }
 
-    serialize(instance: ApiCall): any[] {
-        return [instance.id, instance.updatedOn, instance.responseCode, instance.responseJson, instance.expiresAt];
+    serialize(instance: ApiCall, request?: Request) {
+        if(request) {
+            request.input('1', instance.id);
+            request.input('2', DateTimeOffset, instance.updatedOn);
+            request.input('3', instance.responseCode);
+            request.input('4', instance.responseJson);
+            request.input('5', DateTimeOffset, instance.expiresAt);
+            return undefined;
+        } else {
+            return [instance.id, instance.updatedOn, instance.responseCode, instance.responseJson, instance.expiresAt];
+        }
     }
+
 }

package/models/Migration.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MigrationRepository = void 0;
 const ModelDao_1 = require("./repository/ModelDao");
 class MigrationRepository extends ModelDao_1.ModelDao {
-    constructor(pool, logger) {
-        super(pool, logger, 'migration', 5, 'id=$1,hash=$2,"sqlUp"=$3,"sqlDown"=$4,state=$5');
+    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) {
@@ -16,8 +18,18 @@ class MigrationRepository extends ModelDao_1.ModelDao {
         q.state = parseInt(q.state, 10);
         return q;
     }
-    serialize(instance) {
-        return [instance.id, instance.hash, instance.sqlUp, instance.sqlDown, instance.state];
+    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/Migration.ts

@@ -1,3 +1,4 @@
+import { ConnectionPool, Request } from 'mssql';
 import {Pool} from 'pg';
 import {Logger} from 'winston';
 import {ModelDao} from './repository/ModelDao';
@@ -11,8 +12,9 @@ export interface Migration {
 }
 
 export class MigrationRepository extends ModelDao<number, Migration> {
-    constructor(protected pool: Pool, protected logger: Logger) {
-        super(pool, logger, 'migration', 5, 'id=$1,hash=$2,"sqlUp"=$3,"sqlDown"=$4,state=$5');
+    constructor(protected pool: Pool, protected poolMssql: ConnectionPool, protected logger: 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');
     }
 
     buildObject(q: any): Migration {
@@ -23,7 +25,16 @@ export class MigrationRepository extends ModelDao<number, Migration> {
         return q;
     }
 
-    serialize(instance: Migration): any[] {
-        return [instance.id, instance.hash, instance.sqlUp, instance.sqlDown, instance.state];
+    serialize(instance: Migration, request?: 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];
+        }
     }
 }

package/models/repository/BaseModelRepository.js

@@ -6,28 +6,37 @@ const node_forge_1 = require("node-forge");
 const ApiCall_1 = require("../ApiCall");
 const Migration_1 = require("../Migration");
 class BaseModelRepository {
-    constructor(db, dbSpare, logger, cache) {
+    constructor(db, dbSpare, dbMssql, logger, cache) {
         this.db = db;
         this.dbSpare = dbSpare;
+        this.dbMssql = dbMssql;
         this.logger = logger;
         this.cache = cache;
-        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, logger);
-        this.ApiCall = new ApiCall_1.ApiCallRepository(db, logger);
+        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.query('CREATE TABLE IF NOT EXISTS migration (' +
+        (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' +
-            ')').then(() => {
+            ')') : 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);
@@ -61,7 +70,9 @@ class BaseModelRepository {
         }, () => process.exit(2));
     }
     lockTables(tables, client) {
-        return Promise.all(tables.map(t => client.query('LOCK TABLE ' + t.table + ' IN EXCLUSIVE MODE')));
+        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)
@@ -78,13 +89,13 @@ class BaseModelRepository {
                 sqlDown: sqlParts[1],
                 state: 2
             }).then(() => {
-                this.db.query(sqlParts[0], (err) => {
+                (this.db || this.dbMssql).query(sqlParts[0], (err) => {
                     if (err) {
                         console.error(err);
                         reject(10);
                     }
                     else {
-                        this.db.query('UPDATE "migration" SET "state"=0 WHERE "id"=' + migration.id, (err2) => {
+                        (this.db || this.dbMssql).query('UPDATE "migration" SET "state"=0 WHERE "id"=' + migration.id, (err2) => {
                             if (err2)
                                 reject(11);
                             else
@@ -104,28 +115,34 @@ class BaseModelRepository {
     }
     applyDown(migration) {
         return new Promise((resolve, reject) => {
-            this.db.query('UPDATE "migration" SET "state"=1 WHERE "id"=' + migration.id, (err) => {
+            (this.db || this.dbMssql).query('UPDATE "migration" SET "state"=1 WHERE "id"=' + migration.id, (err) => {
                 if (err)
                     reject(6);
                 else
-                    this.db.query(migration.sqlDown, (err2) => {
+                    (this.db || this.dbMssql).query(migration.sqlDown, (err2) => {
                         if (err2) {
                             console.error(err2);
                             reject(7);
                         }
                         else
-                            this.db.query('DELETE FROM "migration" WHERE "id"=' + migration.id, (err3) => {
+                            (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.query('CREATE TABLE IF NOT EXISTS migration (' +
+                                        (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' +
-                                            ')').then(() => resolve(), reject);
+                                            ')') : 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();

package/models/repository/BaseModelRepository.ts

@@ -1,5 +1,6 @@
 import * as fs from 'fs';
 import * as Memcached from 'memcached';
+import {ConnectionPool, Transaction} from 'mssql';
 import {md} from 'node-forge';
 import {ClientBase, Pool} from 'pg';
 import {Logger} from 'winston';
@@ -11,25 +12,33 @@ export class BaseModelRepository {
     Migration: MigrationRepository;
     ApiCall: ApiCallRepository;
 
-    constructor(public db: Pool, public dbSpare: Pool, public logger: Logger, public cache: Memcached) {
-        const dbQuery = db.query.bind(db);
-        db.query = (function(text: any, values: any, cb: any) {
-            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 MigrationRepository(db, logger);
-        this.ApiCall = new ApiCallRepository(db, logger);
+    constructor(public db: Pool, public dbSpare: Pool, public dbMssql: ConnectionPool, public logger: Logger, public cache: Memcached) {
+        if(db && dbSpare) {
+            const dbQuery = db.query.bind(db);
+            db.query = (function(text: any, values: any, cb: any) {
+                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 MigrationRepository(db, dbMssql, logger);
+        this.ApiCall = new ApiCallRepository(db, dbMssql, logger);
     }
 
     migrate(migrationsPath: string, callback: (() => void)) {
-        this.db.query('CREATE TABLE IF NOT EXISTS migration (' +
+        (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' +
-            ')').then(() => {
+            ')') : 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: Migration[]) => {
                 if(migrations.find(migration => migration.state !== 0)) process.exit(4); // Have to fix manually
                 // Read the new ones
@@ -62,8 +71,10 @@ export class BaseModelRepository {
         }, () => process.exit(2));
     }
 
-    lockTables(tables: ModelRepr[], client: ClientBase): Promise<any> {
-        return Promise.all(tables.map(t => client.query('LOCK TABLE ' + t.table + ' IN EXCLUSIVE MODE')));
+    lockTables(tables: ModelRepr[], client: ClientBase | Transaction): Promise<any> {
+        if(this.db)
+            return Promise.all(tables.map(t => (<ClientBase>client).query('LOCK TABLE ' + t.table + ' IN EXCLUSIVE MODE')));
+        return Promise.all(tables.map(t => (<Transaction>client).request().query('SELECT id FROM ' + t.table + ' WITH (UPDLOCK)')));
     }
 
     private applyUpUntil(migrations: {id: number, content: string, hash: string}[], current: number, until: number): Promise<void> {
@@ -82,12 +93,12 @@ export class BaseModelRepository {
                 sqlDown: sqlParts[1],
                 state: 2
             }).then(() => {
-                this.db.query(sqlParts[0], (err: any) => {
+                (<any>(this.db|| this.dbMssql)).query(sqlParts[0], (err: any) => {
                     if(err) {
                         console.error(err);
                         reject(10);
                     } else {
-                        this.db.query('UPDATE "migration" SET "state"=0 WHERE "id"=' + migration.id, (err2: any) => {
+                        (<any>(this.db|| this.dbMssql)).query('UPDATE "migration" SET "state"=0 WHERE "id"=' + migration.id, (err2: any) => {
                             if(err2) reject(11); // No cleanup
                             else resolve();
                         });
@@ -107,24 +118,30 @@ export class BaseModelRepository {
 
     private applyDown(migration: Migration): Promise<void> {
         return new Promise((resolve, reject) => {
-            this.db.query('UPDATE "migration" SET "state"=1 WHERE "id"=' + migration.id, (err: any) => {
+            (<any>(this.db|| this.dbMssql)).query('UPDATE "migration" SET "state"=1 WHERE "id"=' + migration.id, (err: any) => {
                 if(err) reject(6); // No required change
-                else this.db.query(migration.sqlDown, (err2: any) => {
+                else (<any>(this.db|| this.dbMssql)).query(migration.sqlDown, (err2: any) => {
                     if(err2) {
                         console.error(err2);
                         reject(7);
                     } // No apply down
-                    else this.db.query('DELETE FROM "migration" WHERE "id"=' + migration.id, (err3: any) => {
+                    else (<any>(this.db|| this.dbMssql)).query('DELETE FROM "migration" WHERE "id"=' + migration.id, (err3: any) => {
                         if(err3 && migration.id !== 1) reject(8); // No cleanup for not base migration
                         else {
                             if(migration.id === 1) {
-                                this.db.query('CREATE TABLE IF NOT EXISTS migration (' +
+                                (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' +
-                                    ')').then(() => resolve(), reject);
+                                    ')') : 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();
                         }
                     });

package/models/repository/ModelDao.js

@@ -1,15 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelDao = void 0;
+exports.ModelDao = 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, logger, table, nFields, updateDefinition) {
+    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])] || [];
@@ -18,22 +59,49 @@ class Dao {
         return Object.getOwnPropertyNames(storage).map(k => storage[k]);
     }
     update(instance, client) {
+        if (instance.archivedOn)
+            return Promise.reject('Record archived!');
         instance.updatedOn = new Date();
-        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);
+        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.updatedOn = new Date();
-        const props = this.serialize(instance);
-        return (client || this.pool).query('INSERT INTO ' + this.table + '(' + this.updateDefinition.replace(/=\$\d+/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;
+    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);
         });
     }
+    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, '') + ')'
+                + ' 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([]);
@@ -51,30 +119,120 @@ class Dao {
 }
 class ModelDao extends Dao {
     get(id, client, lock = true) {
-        return (client || this.pool).query('SELECT * FROM ' + this.table + ' WHERE id=$1' + ((client && lock) ? ' FOR UPDATE' : ''), [id]).then(q => this.buildObject(q.rows[0]));
+        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) {
-        return (client || this.pool).query('SELECT count(*) AS cnt FROM ' + this.table + (where ? (' WHERE ' + where) : ''), inputs).then(q => parseInt(q.rows[0].cnt, 10));
+        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) {
-        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)));
+        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) {
-        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)));
+        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) {
-        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
-        }));
+        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');
+        }
     }
     delete(id, client) {
-        return client.query('DELETE FROM ' + this.table + ' WHERE id=$1', [id]);
+        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/models/repository/ModelDao.ts

@@ -1,11 +1,54 @@
+
+import { ConnectionPool, Request, Transaction } from 'mssql';
 import {ClientBase, Pool} from 'pg';
 import {Logger} from 'winston';
 
+declare const Promise: PromiseConstructor & {
+    allConcurrent: <T>(n: number) => ((promiseProxies: (() => Promise<T>)[]) => Promise<T[]>);
+};
+
+export function promiseAllStepN<T>(n: number, list: (() => Promise<T>)[]): Promise<T[]> {
+    if(!list || !list.length) return Promise.resolve([]);
+    const tail = list.splice(n);
+    const head = list;
+    const resolved: any[] = [];
+    let processed = 0;
+    return new Promise(resolve => {
+        head.forEach(x => {
+            const res = x();
+            resolved.push(res);
+            res.then((y: any) => {
+                runNext();
+                return y;
+            });
+        });
+        function runNext() {
+            if(processed === tail.length) {
+                resolve(Promise.all(resolved));
+            } else {
+                resolved.push(tail[processed]().then((x: any) => {
+                    runNext();
+                    return x;
+                }));
+                processed++;
+            }
+        }
+    });
+}
+Promise.allConcurrent = <T>(n: number) => (list: (() => Promise<T>)[]) => promiseAllStepN(n, list);
+
 export interface Model<T> {
     id?: T;
     updatedOn?: Date;
 }
 
+export interface ArchivedModel<T> extends Model<T> {
+    createdOn?: Date;
+    archivedOn?: Date;
+    replaced_id?: T;
+    replaced_by_id?: T;
+}
+
 export interface ModelRepr {
     table: string;
 }
@@ -16,11 +59,20 @@ export interface ViewCount<T> {
 }
 
 abstract class Dao<R, T extends Model<R>> implements ModelRepr {
-    constructor(protected pool: Pool, protected logger: Logger, public table: string, protected nFields: number,
+    constructor(protected pool: Pool, protected poolMssql: ConnectionPool, protected logger: Logger, public table: string, protected nFields: number,
                 protected updateDefinition: string) {
     }
 
-    groupResultSet(q: any[], key: (qs: any) => string): any[][] {
+    groupResultSet(q: any[], key: string): any[][] {
+        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: any[], key: (qs: any) => string): any[][] {
         const storage = {};
         for(let i = 0; i < q.length; i++) {
             storage[key(q[i])] = storage[key(q[i])] || [];
@@ -29,23 +81,47 @@ abstract class Dao<R, T extends Model<R>> implements ModelRepr {
         return Object.getOwnPropertyNames(storage).map(k => storage[k]);
     }
 
-    update(instance: T, client: ClientBase): Promise<R> {
+    update(instance: T, client: ClientBase | ConnectionPool | Transaction): Promise<R> {
+        if((<any>instance).archivedOn) return Promise.reject('Record archived!');
         instance.updatedOn = new Date();
-        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);
+        if(this.pool) {
+            const props = this.serialize(instance);
+            props.push(instance.id);
+            return (<ClientBase>client).query('UPDATE ' + this.table + ' SET ' + this.updateDefinition + ' WHERE id=$' + (this.nFields + 1), props).then(() => instance.id);
+        } else {
+            const request = (<ConnectionPool | Transaction>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: T, client?: ClientBase): Promise<R> {
-        instance.updatedOn = new Date();
-        const props = this.serialize(instance);
-        return (client || this.pool).query('INSERT INTO ' + this.table + '(' + this.updateDefinition.replace(/=\$\d+/g, '') + ')'
-            + ' VALUES(' + new Array(this.nFields).fill(undefined).map((_, i: number) => '$' + (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;
-            });
+    replace(this: ModelDao<R, T>, instance: T, client: ClientBase | Transaction): Promise<R> {
+        if((<any>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);
+        });
+    }
+
+    create(instance: T, client?: ClientBase | Transaction): Promise<R> {
+        (<any>instance).createdOn = instance.updatedOn = new Date();
+        if(this.pool) {
+            const props = this.serialize(instance);
+            return (<ClientBase | Pool>(client || this.pool)).query('INSERT INTO ' + this.table + '(' + this.updateDefinition.replace(/=\$\d+/g, '') + ')'
+                + ' VALUES(' + new Array(this.nFields).fill(undefined).map((_, i: number) => '$' + (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 = (<Transaction | ConnectionPool>(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: number) => '@' + (i + 1)).join(',') + '); SELECT SCOPE_IDENTITY() AS id').then(q => {
+                    return q.recordsets[0][0].id || instance.id;
+                });
+        }
     }
 
     createSeveral(instances: T[], client?: ClientBase): Promise<R[]> {
@@ -65,39 +141,119 @@ abstract class Dao<R, T extends Model<R>> implements ModelRepr {
 
     protected abstract buildObject(q: any): T;
 
-    protected abstract serialize(instance: T): any[];
+    protected abstract serialize(instance: T, request?: Request): any[];
 }
 
 export abstract class ModelDao<R, T extends Model<R>> extends Dao<R, T> {
-    get(id: R, client?: ClientBase, lock = true): Promise<T> {
-        return (client || this.pool).query('SELECT * FROM ' + this.table + ' WHERE id=$1' + ((client && lock) ? ' FOR UPDATE' : ''), [id]).then(q => this.buildObject(q.rows[0]));
+    get(id: R, client?: ClientBase | Transaction, lock = true): Promise<T> {
+        if(this.pool) {
+            return (<ClientBase | Pool>(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 = (<Transaction | ConnectionPool>(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?: string, inputs: any[] = [], client?: ClientBase): Promise<number> {
-        return (client || this.pool).query('SELECT count(*) AS cnt FROM ' + this.table + (where ? (' WHERE ' + where) : ''), inputs).then(q => parseInt(q.rows[0].cnt, 10));
+    count(where?: string, inputs: any[] = [], client?: ClientBase | Transaction): Promise<number> {
+        if(this.pool) {
+            return (<ClientBase | Pool>(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 = (<Transaction | ConnectionPool>(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: R[], client?: ClientBase, lock = true): Promise<T[]> {
-        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)));
+    getList(ids: R[], client?: ClientBase | Transaction, lock = true): Promise<T[]> {
+        if(this.pool) {
+            return (<ClientBase | Pool>(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 = (<Transaction | ConnectionPool>(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?: string, offset?: number, limit?: number, where?: string, inputs: any[] = [], client?: ClientBase, lock = true): Promise<T[]> {
-        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)));
+    getAllBy(order?: string, offset?: number, limit?: number, where?: string, inputs: any[] = [], client?: ClientBase | Transaction, lock = true): Promise<T[]> {
+        if(this.pool) {
+            return (<ClientBase | Pool>(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 = (<Transaction | ConnectionPool>(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?: string, offset?: number, limit?: number, where?: string, inputs: any[] = [], client?: ClientBase, lock = true): Promise<ViewCount<T>> {
-        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
+    getViewCountBy(order?: string, offset?: number, limit?: number, where?: string, inputs: any[] = [], client?: ClientBase | Transaction, lock = true): Promise<ViewCount<T>> {
+        if(this.pool) {
+            return (<ClientBase | Pool>(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 = (<Transaction | ConnectionPool>(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]: [any, any]) => ({
+                views: q1.recordsets[0].map((r: any) => this.buildObject(r)),
+                count: q2.recordsets.length ? q2.recordsets[0].reduce((p: number, n: any) => p + n.cnt, 0) : 0
             }));
+        }
     }
 
-    delete(id: R, client: ClientBase): Promise<any> {
-        return client.query('DELETE FROM ' + this.table + ' WHERE id=$1', [id]);
+    getRowsViewCountBy(rows: string[], order?: string, offset?: number, limit?: number, where?: string, inputs: any[] = [], client?: ClientBase | Transaction, lock = true): Promise<ViewCount<any>> {
+        if(this.pool) {
+            return (<ClientBase | Pool>(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 = (<Transaction | ConnectionPool>(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]: [any, any]) => ({
+                views: q1.recordsets[0].map((r: any) => this.buildObject(r)),
+                count: q2.recordsets.length ? q2.recordsets[0].reduce((p: number, n: any) => p + n.cnt, 0) : 0
+            }));
+        }
+    }
+
+    archive(id: R, replacedById: R, client: ClientBase | Transaction): Promise<any> {
+        if(this.pool) {
+            return (<ClientBase>client).query('UPDATE ' + this.table + ' SET "archivedOn"=now(),replaced_by_id=$1 WHERE id=$2', [replacedById, id]);
+        } else {
+            const request = (<Transaction>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');
+        }
+    }
+
+    delete(id: R, client: ClientBase | Transaction): Promise<any> {
+        if(this.pool) {
+            return (<ClientBase>client).query('DELETE FROM ' + this.table + ' WHERE id=$1', [id]);
+        } else {
+            const request = (<Transaction>client).request();
+            request.input('1', id);
+            return request.query('DELETE FROM ' + this.table + ' WHERE id=@1');
+        }
     }
 }

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "anote-server-libs",
-  "version": "0.0.6",
+  "version": "0.1.0",
   "description": "Helpers for express-TS servers",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc -p tsconfig.json"
   },
   "repository": {
     "type": "git",
@@ -17,12 +18,14 @@
   "dependencies": {
     "@types/express": "4.17.13",
     "@types/memcached": "2.2.7",
+    "@types/mssql": "7.1.4",
     "@types/node": "14.18.2",
     "@types/node-forge": "1.0.0",
     "@types/pg": "8.6.4",
     "express": "4.17.2",
     "jsonschema": "1.4.0",
     "memcached": "2.2.2",
+    "mssql": "8.0.2",
     "node-forge": "1.2.1",
     "pg": "8.7.3",
     "winston": "3.5.1"

package/services/WithTransaction.js

@@ -2,35 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withTransaction = void 0;
 const utils_1 = require("./utils");
-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;
-    });
-}
 function withTransaction(repo, logger, previousMethod, lock) {
     return function (req, res, next) {
         const endTerminator = res.end.bind(res);
         const jsonTerminator = (obj) => {
-            res.write(jsonStringify(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);
-        repo.db.connect().then(dbClient => {
+        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);
@@ -40,8 +27,9 @@ function withTransaction(repo, logger, previousMethod, lock) {
             res.locals.dbClientCommit = (cb) => {
                 if (!res.locals.dbClientCommited) {
                     res.locals.dbClientCommited = true;
-                    dbClient.query('COMMIT').catch(err => err).then((err) => {
-                        dbClient.release();
+                    (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]();
@@ -55,15 +43,16 @@ function withTransaction(repo, logger, previousMethod, lock) {
                 }
             };
             res.locals.dbClientOnCommit = [];
-            return dbClient.query('BEGIN').then(() => {
+            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);
                             }
-                            dbClient.query('ROLLBACK').catch(err => obj.error.additionalInfo2 = { message: err.message }).then(() => {
-                                dbClient.release();
+                            (repo.db ? dbClient.query('ROLLBACK') : dbClient.rollback()).catch((err) => obj.error.additionalInfo2 = { message: err.message }).then(() => {
+                                if (repo.db)
+                                    dbClient.release();
                                 jsonTerminator(obj);
                             });
                         }
@@ -89,8 +78,9 @@ function withTransaction(repo, logger, previousMethod, lock) {
                             if (logger && res.statusCode > 499) {
                                 logger.error('Uncaught 500 with no details...');
                             }
-                            dbClient.query('ROLLBACK').catch(() => undefined).then(() => {
-                                dbClient.release();
+                            (repo.db ? dbClient.query('ROLLBACK') : dbClient.rollback()).catch(() => undefined).then(() => {
+                                if (repo.db)
+                                    dbClient.release();
                                 endTerminator();
                             });
                         }
@@ -114,7 +104,7 @@ function withTransaction(repo, logger, previousMethod, lock) {
                     return previousMethod.call(this, req, res, next);
                 };
                 if (lock) {
-                    dbClient.query('SELECT pg_advisory_xact_lock(' + lock + ')').then(() => finish()).catch(err => {
+                    dbClient.query('SELECT pg_advisory_xact_lock(' + lock + ')').then(() => finish()).catch((err) => {
                         res.status(500).json({
                             error: {
                                 errorKey: 'internal.db',
@@ -127,8 +117,11 @@ function withTransaction(repo, logger, previousMethod, lock) {
                 else {
                     finish();
                 }
-            }).catch(err => {
-                dbClient.release();
+            }).catch((err) => {
+                if (repo.db)
+                    dbClient.release();
+                else
+                    dbClient.rollback();
                 throw err;
             });
         }).catch(err => {

package/services/WithTransaction.ts

@@ -1,30 +1,13 @@
 import {NextFunction, Request, Response} from 'express';
 import {Logger} from 'winston';
 import {BaseModelRepository} from '../models/repository/BaseModelRepository';
-import {utils} from './utils';
+import {jsonStringify, utils} from './utils';
 
 export const enum SystemLock {
     CHECK_CROSSING = 1,
     FLUSH_CALLS = 2
 }
 
-function jsonStringify(obj: any): string {
-    const cache: any = {};
-    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;
-    });
-}
-
 export function withTransaction(repo: BaseModelRepository, logger: Logger, previousMethod: (req: Request, res: Response, next: NextFunction) => void, lock?: SystemLock) {
     return function(req: Request, res: Response, next: NextFunction) {
         const endTerminator = res.end.bind(res);
@@ -37,7 +20,11 @@ export function withTransaction(repo: BaseModelRepository, logger: Logger, previ
             logger.error('Error timed out getting a client, exiting...');
             process.exit(22);
         }, 3000);
-        repo.db.connect().then(dbClient => {
+        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;
@@ -49,8 +36,8 @@ export function withTransaction(repo: BaseModelRepository, logger: Logger, previ
             res.locals.dbClientCommit = (cb: (err: any) => any) => {
                 if(!res.locals.dbClientCommited) {
                     res.locals.dbClientCommited = true;
-                    dbClient.query('COMMIT').catch(err => err).then((err: any) => {
-                        dbClient.release();
+                    (repo.db ? dbClient.query('COMMIT') : dbClient.commit()).catch((err: any) => err).then((err: any) => {
+                        if(repo.db) dbClient.release();
                         if(!(err instanceof Error)) {
                             for(let i = 0; i < res.locals.dbClientOnCommit.length; i++) {
                                 res.locals.dbClientOnCommit[i]();
@@ -63,15 +50,15 @@ export function withTransaction(repo: BaseModelRepository, logger: Logger, previ
                 }
             };
             res.locals.dbClientOnCommit = [];
-            return dbClient.query('BEGIN').then(() => {
+            return (repo.db ? dbClient.query('BEGIN') : dbClient.begin()).then(() => {
                 const finish = () => {
                     res.json = (obj: any) => {
                         if(res.statusCode > 303 && res.statusCode !== 412) {
                             if(logger && res.statusCode > 499) {
                                 logger.error('Uncaught 500: %j', obj.error.additionalInfo);
                             }
-                            dbClient.query('ROLLBACK').catch(err => obj.error.additionalInfo2 = {message: err.message}).then(() => {
-                                dbClient.release();
+                            (repo.db ? dbClient.query('ROLLBACK') : dbClient.rollback()).catch((err: any) => obj.error.additionalInfo2 = {message: err.message}).then(() => {
+                                if(repo.db) dbClient.release();
                                 jsonTerminator(obj);
                             });
                         } else {
@@ -94,8 +81,8 @@ export function withTransaction(repo: BaseModelRepository, logger: Logger, previ
                             if(logger && res.statusCode > 499) {
                                 logger.error('Uncaught 500 with no details...');
                             }
-                            dbClient.query('ROLLBACK').catch((): any => undefined).then(() => {
-                                dbClient.release();
+                            (repo.db ? dbClient.query('ROLLBACK') : dbClient.rollback()).catch((): any => undefined).then(() => {
+                                if(repo.db) dbClient.release();
                                 endTerminator();
                             });
                         } else {
@@ -117,7 +104,7 @@ export function withTransaction(repo: BaseModelRepository, logger: Logger, previ
                 };
 
                 if(lock) {
-                    dbClient.query('SELECT pg_advisory_xact_lock(' + lock + ')').then(() => finish()).catch(err => {
+                    dbClient.query('SELECT pg_advisory_xact_lock(' + lock + ')').then(() => finish()).catch((err: any) => {
                         res.status(500).json({
                             error: {
                                 errorKey: 'internal.db',
@@ -129,8 +116,9 @@ export function withTransaction(repo: BaseModelRepository, logger: Logger, previ
                 } else {
                     finish();
                 }
-            }).catch(err => {
-                dbClient.release();
+            }).catch((err: any) => {
+                if(repo.db) dbClient.release();
+                else dbClient.rollback();
                 throw err;
             });
         }).catch(err => {

package/services/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.digitize = exports.fpEuros = exports.sendSelfPostableMessage = exports.idempotent = exports.lcm = exports.gcd = exports.utils = exports.clientErrorHandle = exports.btoa = exports.atob = void 0;
+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');
 }
@@ -60,6 +60,24 @@ function lcm(values) {
     }
 }
 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');
@@ -73,7 +91,7 @@ function idempotent(repo, debug, logger) {
                         repo.ApiCall.create({
                             id: idempotenceKey,
                             responseCode: res.statusCode,
-                            responseJson: JSON.stringify(obj),
+                            responseJson: jsonStringify(obj),
                             expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000)
                         }).then(() => jsonTerminator(obj), err => {
                             if (err)

package/services/utils.ts

@@ -60,6 +60,23 @@ export function lcm(values: number[]): number {
     }
 }
 
+export function jsonStringify(obj: any): string {
+    const cache: any = {};
+    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;
+    });
+}
+
 export function idempotent(repo: BaseModelRepository, debug: boolean, logger: Logger) {
     return function(req: Request, res: Response, next: NextFunction) {
         let idempotenceKey = req.header('x-idempotent-key');
@@ -73,7 +90,7 @@ export function idempotent(repo: BaseModelRepository, debug: boolean, logger: Lo
                         repo.ApiCall.create({
                             id: idempotenceKey,
                             responseCode: res.statusCode,
-                            responseJson: JSON.stringify(obj),
+                            responseJson: jsonStringify(obj),
                             expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000)
                         }).then(() => jsonTerminator(obj), err => {
                             if(err) logger.warn('Cannot save idempotent key: %j', err);