anote-server-libs 0.9.5 → 0.10.0

package/models/repository/BaseModelRepository.js

@@ -23,34 +23,34 @@ class BaseModelRepository {
         this.Migration = new Migration_1.MigrationRepository(db, dbMssql, logger);
         this.ApiCall = new ApiCall_1.ApiCallRepository(db, dbMssql, logger);
     }
-    migrate(migrationsPath, callback, onlyAboveOrEquals = 0) {
+    migrate(migrationsPath, callback, onlyAboveOrEquals = 0, onlyBelow) {
         (this.db ? Promise.all([
-            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,
-skip boolean NOT NULL
+            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,
+skip boolean NOT NULL
 )`),
             this.db.query(`ALTER TABLE migration ADD COLUMN IF NOT EXISTS skip BOOLEAN NOT NULL DEFAULT FALSE`)
         ]) : Promise.all([
-            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,
-skip bit 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,
+skip bit NOT NULL
 )`),
-            this.dbMssql.query(`IF NOT EXISTS (
-    SELECT * 
-    FROM INFORMATION_SCHEMA.COLUMNS 
-    WHERE TABLE_NAME = 'migration' 
-      AND COLUMN_NAME = 'skip'
-)
-BEGIN
-    ALTER TABLE migration ADD skip BIT NOT NULL DEFAULT 0;
+            this.dbMssql.query(`IF NOT EXISTS (
+    SELECT * 
+    FROM INFORMATION_SCHEMA.COLUMNS 
+    WHERE TABLE_NAME = 'migration' 
+      AND COLUMN_NAME = 'skip'
+)
+BEGIN
+    ALTER TABLE migration ADD skip BIT NOT NULL DEFAULT 0;
 END`)
         ])).then(() => {
             this.Migration.getAllBy('id').then((migrations) => {
@@ -70,16 +70,22 @@ END`)
                             hash: crypto.createHash('sha256').update(content).digest('hex')
                         };
                     });
-                    if (migrationsAvailable.length === 0
-                        || migrationsAvailable.length
-                            !== migrationsAvailable[migrationsAvailable.length - 1].id)
+                    migrations = migrations.filter(m => m.id >= onlyAboveOrEquals);
+                    if (onlyBelow)
+                        migrations = migrations.filter(m => m.id < onlyBelow);
+                    if (migrationsAvailable.length === 0 && migrations.length === 0)
                         process.exit(5);
-                    let highestCommon = onlyAboveOrEquals;
-                    while (highestCommon < migrations.length && highestCommon < migrationsAvailable.length
+                    if (migrationsAvailable.length && migrationsAvailable.length !== (migrationsAvailable[migrationsAvailable.length - 1].id - migrationsAvailable[0].id + 1))
+                        process.exit(5);
+                    let highestCommon = 0;
+                    while (highestCommon < migrations.length
+                        && highestCommon < migrationsAvailable.length
+                        && migrations[highestCommon]
+                        && migrationsAvailable[highestCommon]
                         && migrations[highestCommon].hash === migrationsAvailable[highestCommon].hash)
                         highestCommon++;
-                    this.applyDownUntil(migrations, migrations.length, highestCommon).then(highestCommon => {
-                        this.applyUpUntil(migrationsAvailable, Math.min(highestCommon, migrations.length), migrationsAvailable.length).then(callback, process.exit);
+                    this.applyDownUntil(migrations, migrations.length, highestCommon).then(appliedId => {
+                        this.applyUpUntil(migrationsAvailable, Math.min(appliedId, migrations.length), migrationsAvailable.length).then(callback, process.exit);
                     }, process.exit);
                 });
             }, () => process.exit(3));
@@ -91,8 +97,10 @@ END`)
         return Promise.all(tables.map(t => client.request().query('SELECT id FROM ' + t.table + ' WITH (UPDLOCK)')));
     }
     applyUpUntil(migrations, current, until) {
-        if (current < until)
+        if (current < until) {
+            console.log('Applying migration ' + migrations[current].id);
             return this.applyUp(migrations[current]).then(() => this.applyUpUntil(migrations, current + 1, until));
+        }
         return Promise.resolve();
     }
     applyUp(migration) {
@@ -126,6 +134,7 @@ END`)
     applyDownUntil(migrations, current, until) {
         if (current > until && !migrations[current - 1]?.skip) {
             current--;
+            console.log('Reverting migration ' + migrations[current].id);
             return this.applyDown(migrations[current]).then(() => this.applyDownUntil(migrations, current, until));
         }
         return Promise.resolve(current);

package/models/repository/BaseModelRepository.ts

@@ -1,168 +1,175 @@
-import * as crypto from 'crypto';
-import * as fs from 'fs';
-import * as Memcached from 'memcached';
-import {ConnectionPool, Transaction} from 'mssql';
-import {ClientBase, Pool} from 'pg';
-import {Logger} from 'winston';
-import { ApiCallRepository } from '../ApiCall';
-import { Migration, MigrationRepository } from '../Migration';
-import {ModelRepr} from './ModelDao';
-
-export class BaseModelRepository {
-    Migration: MigrationRepository;
-    ApiCall: ApiCallRepository;
-
-    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);
-    }
-
-    // TODO: alter table migration if exists without ok column
-    migrate(migrationsPath: string, callback: (() => void), onlyAboveOrEquals = 0) {
-        (this.db ? Promise.all([
-        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,
-skip boolean NOT NULL
-)`),
-        this.db.query(`ALTER TABLE migration ADD COLUMN IF NOT EXISTS skip BOOLEAN NOT NULL DEFAULT FALSE`)]) : Promise.all([
-        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,
-skip bit NOT NULL
-)`),
-        this.dbMssql.query(`IF NOT EXISTS (
-    SELECT * 
-    FROM INFORMATION_SCHEMA.COLUMNS 
-    WHERE TABLE_NAME = 'migration' 
-      AND COLUMN_NAME = 'skip'
-)
-BEGIN
-    ALTER TABLE migration ADD skip BIT NOT NULL DEFAULT 0;
-END`)])).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
-                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: crypto.createHash('sha256').update(content).digest('hex')
-                            };
-                        });
-                    if(migrationsAvailable.length === 0
-                        || migrationsAvailable.length
-                        !== migrationsAvailable[migrationsAvailable.length - 1].id) process.exit(5); // Did not use OK files
-                    let highestCommon = onlyAboveOrEquals;
-                    while(highestCommon < migrations.length && highestCommon < migrationsAvailable.length
-                    && migrations[highestCommon].hash === migrationsAvailable[highestCommon].hash)
-                        highestCommon++;
-                    this.applyDownUntil(migrations, migrations.length, highestCommon).then(highestCommon => {
-                        this.applyUpUntil(migrationsAvailable, Math.min(highestCommon, migrations.length), migrationsAvailable.length).then(callback, process.exit);
-                    }, process.exit);
-                });
-            }, () => process.exit(3));
-        }, () => process.exit(2));
-    }
-
-    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> {
-        if(current < until)
-            return this.applyUp(migrations[current]).then(() => this.applyUpUntil(migrations, current + 1, until));
-        return Promise.resolve();
-    }
-
-    private applyUp(migration: {id: number, content: string, hash: string}): Promise<void> {
-        return new Promise((resolve, reject) => {
-            const sqlParts = migration.content.split(/-{4,}/);
-            this.Migration.create({
-                id: migration.id,
-                hash: migration.hash,
-                sqlUp: sqlParts[0],
-                sqlDown: sqlParts[1],
-                state: 2,
-                skip: false
-            }).then(() => {
-                (<any>(this.db|| this.dbMssql)).query(sqlParts[0], (err: any) => {
-                    if(err) {
-                        console.error(err);
-                        reject(10);
-                    } else {
-                        (<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();
-                        });
-                    }
-                });
-            }, () => process.exit(9));
-        });
-    }
-
-    private applyDownUntil(migrations: Migration[], current: number, until: number): Promise<number> {
-        if(current > until && !migrations[current - 1]?.skip) {
-            current--;
-            return this.applyDown(migrations[current]).then(() => this.applyDownUntil(migrations, current, until));
-        }
-        return Promise.resolve(current);
-    }
-
-    private applyDown(migration: Migration): Promise<void> {
-        return new Promise((resolve, reject) => {
-            (<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 (<any>(this.db|| this.dbMssql)).query(migration.sqlDown, (err2: any) => {
-                    if(err2) {
-                        console.error(err2);
-                        reject(7);
-                    } // No apply down
-                    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 ? 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();
-                        }
-                    });
-                });
-            });
-        });
-    }
-}
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as Memcached from 'memcached';
+import {ConnectionPool, Transaction} from 'mssql';
+import {ClientBase, Pool} from 'pg';
+import {Logger} from 'winston';
+import { ApiCallRepository } from '../ApiCall';
+import { Migration, MigrationRepository } from '../Migration';
+import {ModelRepr} from './ModelDao';
+
+export class BaseModelRepository {
+    Migration: MigrationRepository;
+    ApiCall: ApiCallRepository;
+
+    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);
+    }
+
+    // TODO: alter table migration if exists without ok column
+    migrate(migrationsPath: string, callback: (() => void), onlyAboveOrEquals = 0, onlyBelow?: number) {
+        (this.db ? Promise.all([
+        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,
+skip boolean NOT NULL
+)`),
+        this.db.query(`ALTER TABLE migration ADD COLUMN IF NOT EXISTS skip BOOLEAN NOT NULL DEFAULT FALSE`)]) : Promise.all([
+        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,
+skip bit NOT NULL
+)`),
+        this.dbMssql.query(`IF NOT EXISTS (
+    SELECT * 
+    FROM INFORMATION_SCHEMA.COLUMNS 
+    WHERE TABLE_NAME = 'migration' 
+      AND COLUMN_NAME = 'skip'
+)
+BEGIN
+    ALTER TABLE migration ADD skip BIT NOT NULL DEFAULT 0;
+END`)])).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
+                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: crypto.createHash('sha256').update(content).digest('hex')
+                            };
+                        });
+                    migrations = migrations.filter(m => m.id >= onlyAboveOrEquals);
+                    if(onlyBelow) migrations = migrations.filter(m => m.id < onlyBelow);
+                    if(migrationsAvailable.length === 0 && migrations.length === 0) process.exit(5);
+                    if(migrationsAvailable.length && migrationsAvailable.length !== (migrationsAvailable[migrationsAvailable.length - 1].id - migrationsAvailable[0].id + 1)) process.exit(5);
+                    let highestCommon = 0;
+                    while(highestCommon < migrations.length
+                        && highestCommon < migrationsAvailable.length
+                        && migrations[highestCommon] 
+                        && migrationsAvailable[highestCommon] 
+                        && migrations[highestCommon].hash === migrationsAvailable[highestCommon].hash)
+                        highestCommon++;
+                    this.applyDownUntil(migrations, migrations.length, highestCommon).then(appliedId => {
+                        this.applyUpUntil(migrationsAvailable, Math.min(appliedId, migrations.length), migrationsAvailable.length).then(callback, process.exit);
+                    }, process.exit);
+                });
+            }, () => process.exit(3));
+        }, () => process.exit(2));
+    }
+
+    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> {
+        if(current < until) {
+            console.log('Applying migration ' + migrations[current].id);
+            return this.applyUp(migrations[current]).then(() => this.applyUpUntil(migrations, current + 1, until));
+        }
+        return Promise.resolve();
+    }
+
+    private applyUp(migration: {id: number, content: string, hash: string}): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const sqlParts = migration.content.split(/-{4,}/);
+            this.Migration.create({
+                id: migration.id,
+                hash: migration.hash,
+                sqlUp: sqlParts[0],
+                sqlDown: sqlParts[1],
+                state: 2,
+                skip: false
+            }).then(() => {
+                (<any>(this.db|| this.dbMssql)).query(sqlParts[0], (err: any) => {
+                    if(err) {
+                        console.error(err);
+                        reject(10);
+                    } else {
+                        (<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();
+                        });
+                    }
+                });
+            }, () => process.exit(9));
+        });
+    }
+
+    private applyDownUntil(migrations: Migration[], current: number, until: number): Promise<number> {
+        if(current > until && !migrations[current - 1]?.skip) {
+            current--;
+            console.log('Reverting migration ' + migrations[current].id);
+            return this.applyDown(migrations[current]).then(() => this.applyDownUntil(migrations, current, until));
+        }
+        return Promise.resolve(current);
+    }
+
+    private applyDown(migration: Migration): Promise<void> {
+        return new Promise((resolve, reject) => {
+            (<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 (<any>(this.db|| this.dbMssql)).query(migration.sqlDown, (err2: any) => {
+                    if(err2) {
+                        console.error(err2);
+                        reject(7);
+                    } // No apply down
+                    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 ? 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();
+                        }
+                    });
+                });
+            });
+        });
+    }
+}

package/models/repository/CryptModelDao.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptModelDao = void 0;
+const crypto_1 = require("crypto");
+const util_1 = require("util");
+const ModelDao_1 = require("./ModelDao");
+const randomFillAsync = (0, util_1.promisify)(crypto_1.randomFill);
+class CryptModelDao extends ModelDao_1.ModelDao {
+    constructor(keyBase64, encryptedColumns, ...args) {
+        super(...args);
+        this.key = Buffer.from(keyBase64, 'base64');
+        this.encryptedColumns = encryptedColumns;
+    }
+    serializeWrapper(instance, request) {
+        const props = this.serialize(instance, request);
+        const encryptPromises = [];
+        this.encryptedColumns.forEach(col => {
+            const idx = this.updateDefinition.split(',').findIndex(def => def.trim().startsWith('"' + col + '"') || def.trim().startsWith(col + '='));
+            if (idx >= 0) {
+                const val = request ? request.parameters[idx] : props[idx];
+                if (val !== null && val !== undefined) {
+                    const encryptPromise = this.encrypt(String(val)).then(encrypted => {
+                        if (request)
+                            request.replaceInput(String(idx + 1), encrypted);
+                        else
+                            props[idx] = encrypted;
+                    });
+                    encryptPromises.push(encryptPromise);
+                }
+            }
+        });
+        if (encryptPromises.length > 0) {
+            return Promise.all(encryptPromises).then(() => props);
+        }
+        return props;
+    }
+    buildObjectWrapper(row) {
+        const decryptPromises = [];
+        this.encryptedColumns.forEach(col => {
+            if (row[col] !== null && row[col] !== undefined) {
+                const decryptPromise = this.decrypt(String(row[col])).then(decrypted => {
+                    row[col] = decrypted;
+                });
+                decryptPromises.push(decryptPromise);
+            }
+        });
+        if (decryptPromises.length > 0) {
+            return Promise.all(decryptPromises).then(() => this.buildObject(row));
+        }
+        return this.buildObject(row);
+    }
+    async encrypt(decrypted) {
+        const iv = new Uint8Array(16);
+        await randomFillAsync(iv);
+        const cipher = (0, crypto_1.createCipheriv)(CryptModelDao.ALGORITHM, this.key, iv);
+        let encrypted = '';
+        cipher.setEncoding('base64');
+        cipher.on('data', (chunk) => encrypted += chunk);
+        cipher.write(decrypted);
+        cipher.end();
+        return `$$enc$$:${Buffer.from(iv).toString('base64')}${encrypted}`;
+    }
+    async decrypt(encrypted) {
+        if (!encrypted.startsWith('$$enc$$:')) {
+            return encrypted;
+        }
+        encrypted = encrypted.slice(8);
+        const iv = new Uint8Array(Buffer.from(encrypted.slice(0, 24), 'base64'));
+        const decipher = (0, crypto_1.createDecipheriv)(CryptModelDao.ALGORITHM, this.key, iv);
+        let decrypted = '';
+        decipher.on('readable', () => {
+            for (let chunk = decipher.read(); chunk !== null; chunk = decipher.read()) {
+                decrypted += chunk.toString('base64');
+            }
+        });
+        decipher.write(encrypted.slice(24), 'base64');
+        decipher.end();
+        return Buffer.from(decrypted, 'base64').toString('utf8');
+    }
+}
+exports.CryptModelDao = CryptModelDao;
+CryptModelDao.ALGORITHM = 'aes-256-cbc';

package/models/repository/CryptModelDao.ts

@@ -0,0 +1,89 @@
+import {createCipheriv, createDecipheriv, randomFill} from 'crypto';
+import {promisify} from 'util';
+import {Model, ModelDao} from './ModelDao';
+import {Request} from 'mssql';
+
+const randomFillAsync = promisify(randomFill);
+
+export abstract class CryptModelDao<R, T extends Model<R>> extends ModelDao<R, T> {
+    private static readonly ALGORITHM = 'aes-256-cbc';
+
+    private key: Buffer;
+    private encryptedColumns: string[];
+
+    constructor(keyBase64: string, encryptedColumns: string[], ...args: ConstructorParameters<typeof ModelDao>) {
+        super(...args);
+        this.key = Buffer.from(keyBase64, 'base64');
+        this.encryptedColumns = encryptedColumns;
+    }
+
+    protected serializeWrapper(instance: T, request?: Request): Promise<any[]> | any[] {
+        const props = this.serialize(instance, request) as any[];
+        const encryptPromises: Promise<void>[] = [];
+        this.encryptedColumns.forEach(col => {
+            // Parse "protected updateDefinition: string" to find index
+            // e.g. updateDefinition = '"name"=$1,secret=$2,age=$3' -> secret
+            const idx = this.updateDefinition.split(',').findIndex(def => def.trim().startsWith('"' + col + '"') || def.trim().startsWith(col + '='));
+            if(idx >= 0) {
+                const val = request ? request.parameters[idx] : props[idx];
+                if(val !== null && val !== undefined) {
+                    const encryptPromise = this.encrypt(String(val)).then(encrypted => {
+                        if(request) request.replaceInput(String(idx + 1), encrypted);
+                        else props[idx] = encrypted;
+                    });
+                    encryptPromises.push(encryptPromise);
+                }
+            }
+        });
+        if(encryptPromises.length > 0) {
+            return Promise.all(encryptPromises).then(() => props);
+        }
+        return props;
+    }
+
+    protected buildObjectWrapper(row: any): T | Promise<T> {
+        const decryptPromises: Promise<void>[] = [];
+        this.encryptedColumns.forEach(col => {
+            if(row[col] !== null && row[col] !== undefined) {
+                const decryptPromise = this.decrypt(String(row[col])).then(decrypted => {
+                    row[col] = decrypted;
+                });
+                decryptPromises.push(decryptPromise);
+            }
+        });
+        if(decryptPromises.length > 0) {
+            return Promise.all(decryptPromises).then(() => this.buildObject(row));
+        }
+        return this.buildObject(row);
+    }
+
+    private async encrypt(decrypted: string): Promise<string> {
+        const iv = new Uint8Array(16);
+        await randomFillAsync(iv);
+        const cipher = createCipheriv(CryptModelDao.ALGORITHM, this.key, iv);
+        let encrypted = '';
+        cipher.setEncoding('base64');
+        cipher.on('data', (chunk) => encrypted += chunk);
+        cipher.write(decrypted);
+        cipher.end(); // Blocking
+        return `$$enc$$:${Buffer.from(iv).toString('base64')}${encrypted}`;
+    }
+
+    private async decrypt(encrypted: string): Promise<string> {
+        if(!encrypted.startsWith('$$enc$$:')) {
+            return encrypted;
+        }
+        encrypted = encrypted.slice(8);
+        const iv = new Uint8Array(Buffer.from(encrypted.slice(0, 24), 'base64'));
+        const decipher = createDecipheriv(CryptModelDao.ALGORITHM, this.key, iv);
+        let decrypted = '';
+        decipher.on('readable', () => {
+            for(let chunk = decipher.read(); chunk !== null; chunk = decipher.read()) {
+                decrypted += chunk.toString('base64');
+            }
+        });
+        decipher.write(encrypted.slice(24), 'base64');
+        decipher.end(); // Blocking
+        return Buffer.from(decrypted, 'base64').toString('utf8');
+    }
+}

package/models/repository/ModelDao.js

@@ -74,23 +74,33 @@ class Dao {
             return Promise.reject('Record archived!');
         instance.updatedOn = on || 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);
+            let props = this.serializeWrapper(instance);
+            if (!(props instanceof Promise))
+                props = Promise.resolve(props);
+            return props.then(resolvedProps => {
+                resolvedProps.push(instance.id);
+                return client.query('UPDATE ' + this.table + ' SET ' + this.updateDefinition + ' WHERE id=$' + (this.nFields + 1), resolvedProps).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);
+            let props = this.serializeWrapper(instance, request);
+            if (!(props instanceof Promise))
+                props = Promise.resolve(props);
+            return props.then(() => {
+                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, on) {
         instance.createdOn = instance.updatedOn = on || 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 => {
+            let props = this.serializeWrapper(instance);
+            if (!(props instanceof Promise))
+                props = Promise.resolve(props);
+            return props.then(resolvedProps => (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', resolvedProps)).then(q => {
                 const idNum = parseInt(q.rows[0].id, 10);
                 if (String(idNum) !== q.rows[0].id)
                     return q.rows[0].id;
@@ -99,9 +109,11 @@ class Dao {
         }
         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) => {
+            let props = this.serializeWrapper(instance, request);
+            if (!(props instanceof Promise))
+                props = Promise.resolve(props);
+            return props.then(() => 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;
             });
         }
@@ -111,26 +123,40 @@ class Dao {
             return Promise.resolve([]);
         const now = on || 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 props = instances.map(instance => {
+            let props = this.serializeWrapper(instance);
+            if (!(props instanceof Promise))
+                props = Promise.resolve(props);
+            return props;
+        });
+        return Promise.all(props).then(resolvedProps => {
+            resolvedProps = resolvedProps.reduce((p, n) => p.concat(n), []);
+            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', resolvedProps);
+        }).then(q => q.rows.map(r => {
             const idNum = parseInt(r.id, 10);
             if (String(idNum) !== q.rows[0].id)
                 return r.id;
             return idNum;
         }));
     }
+    buildObjectWrapper(q) {
+        return this.buildObject(q);
+    }
+    serializeWrapper(instance, request) {
+        return this.serialize(instance, request);
+    }
 }
 exports.Dao = Dao;
 class ModelDao extends Dao {
     get(id, client, lock = true) {
         if (this.pool) {
-            return (client || this.pool).query(this.selectDefinition + ' FROM ' + this.table + ' WHERE id=$1' + ((client && lock) ? ' FOR UPDATE' : ''), [id]).then(q => this.buildObject(q.rows[0]));
+            return (client || this.pool).query(this.selectDefinition + ' FROM ' + this.table + ' WHERE id=$1' + ((client && lock) ? ' FOR UPDATE' : ''), [id]).then(q => this.buildObjectWrapper(q.rows[0]));
         }
         else {
             const request = (client || this.poolMssql).request();
             request.input('1', id);
-            return request.query(this.selectDefinition + ' FROM ' + this.table + ((client && lock) ? ' WITH (UPDLOCK, ROWLOCK)' : '') + ' WHERE id=@1').then((q) => this.buildObject(q.recordsets[0][0]));
+            return request.query(this.selectDefinition + ' FROM ' + this.table + ((client && lock) ? ' WITH (UPDLOCK, ROWLOCK)' : '') + ' WHERE id=@1').then((q) => this.buildObjectWrapper(q.recordsets[0][0]));
         }
     }
     count(where, inputs = [], client) {
@@ -147,20 +173,20 @@ class ModelDao extends Dao {
     getList(ids, client, lock = true) {
         if (this.pool) {
             return (client || this.pool).query(this.selectDefinition + ' FROM ' + this.table + ' WHERE id=ANY($1)' + ((client && lock) ? ' FOR UPDATE' : ''), [ids])
-                .then(q => q.rows.map(r => this.buildObject(r)));
+                .then(q => Promise.all(q.rows.map(r => this.buildObjectWrapper(r))));
         }
         else {
             const request = (client || this.poolMssql).request();
             return request.query(this.selectDefinition + ' FROM ' + this.table + ((client && lock) ? ' WITH (UPDLOCK, 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)));
+                .then((q) => Promise.all(q.recordsets[0].map((r) => this.buildObjectWrapper(r))));
         }
     }
     getAllBy(order, offset, limit, where, inputs = [], client, lock = true) {
         if (this.pool) {
             return (client || this.pool).query(this.selectDefinition + ' 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)));
+                .then(q => Promise.all(q.rows.map(r => this.buildObjectWrapper(r))));
         }
         else {
             const request = (client || this.poolMssql).request();
@@ -168,16 +194,17 @@ class ModelDao extends Dao {
                 where.match(/(@\d+)/g).forEach((match, i) => request.input(match.substr(1), inputs[i]));
             return request.query(this.selectDefinition + ' FROM ' + this.table + ((client && lock) ? ' WITH (UPDLOCK, 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)));
+                .then((q) => Promise.all(q.recordsets[0].map((r) => this.buildObjectWrapper(r))));
         }
     }
     getViewCountBy(order, offset, limit, where, inputs = [], client, lock = true) {
         if (this.pool) {
             return (client || this.pool).query(this.selectDefinition + ', 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
+                .then(q => Promise.all([q.rows.length ? parseInt(q.rows[0].cnt, 10) : 0, Promise.all(q.rows.map(r => this.buildObjectWrapper(r)))]))
+                .then(([count, views]) => ({
+                views,
+                count
             }));
         }
         else {
@@ -188,9 +215,11 @@ class ModelDao extends Dao {
                 () => request.query(this.selectDefinition + ' FROM ' + this.table + ((client && lock) ? ' WITH (UPDLOCK, 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
+            ])
+                .then(([q1, q2]) => Promise.all([Promise.all(q1.recordsets[0].map((r) => this.buildObjectWrapper(r))), q2.recordsets.length ? q2.recordsets[0].reduce((p, n) => p + n.cnt, 0) : 0]))
+                .then(([views, count]) => ({
+                views,
+                count
             }));
         }
     }
@@ -198,9 +227,10 @@ class ModelDao extends Dao {
         if (this.pool) {
             return (client || this.pool).query('SELECT ' + cols.map(r => r.indexOf(' ') > -1 ? 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
+                .then(q => Promise.all([q.rows.length ? parseInt(q.rows[0].cnt, 10) : 0, Promise.all(q.rows.map(r => this.buildObjectWrapper(r)))]))
+                .then(([count, views]) => ({
+                views,
+                count
             }));
         }
         else {
@@ -212,9 +242,11 @@ class ModelDao extends Dao {
                     + ((client && lock) ? ' WITH (UPDLOCK, 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
+            ])
+                .then(([q1, q2]) => Promise.all([Promise.all(q1.recordsets[0].map((r) => this.buildObjectWrapper(r))), q2.recordsets.length ? q2.recordsets[0].reduce((p, n) => p + n.cnt, 0) : 0]))
+                .then(([views, count]) => ({
+                views,
+                count
             }));
         }
     }

package/models/repository/ModelDao.ts

@@ -94,33 +94,41 @@ export abstract class Dao<R, T extends Model<R>> implements ModelRepr {
         if((<any>instance).archivedOn) return Promise.reject('Record archived!');
         instance.updatedOn = on || new Date();
         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);
+            let props = this.serializeWrapper(instance);
+            if(!(props instanceof Promise)) props = Promise.resolve(props);
+            return props.then(resolvedProps => {
+                resolvedProps.push(instance.id);
+                return (<ClientBase>client).query('UPDATE ' + this.table + ' SET ' + this.updateDefinition + ' WHERE id=$' + (this.nFields + 1), resolvedProps).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);
+            let props = this.serializeWrapper(instance, request);
+            if(!(props instanceof Promise)) props = Promise.resolve(props);
+            return props.then(() => {
+                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 | Transaction, on?: Date): Promise<R> {
         (<any>instance).createdOn = instance.updatedOn = on || 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, '').replace(/=[^)]+\)/g, '') + ')'
+            let props = this.serializeWrapper(instance);
+            if(!(props instanceof Promise)) props = Promise.resolve(props);
+            return props.then(resolvedProps => (<ClientBase | Pool>(client || this.pool)).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(',') + ') RETURNING id',
-                props).then(q => {
+                resolvedProps)).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: any) => {
+            let props = this.serializeWrapper(instance, request);
+            if(!(props instanceof Promise)) props = Promise.resolve(props);
+            return props.then(() => 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: any) => {
                     return q.recordsets[0][0].id || instance.id;
                 });
         }
@@ -130,30 +138,45 @@ export abstract class Dao<R, T extends Model<R>> implements ModelRepr {
         if(!instances.length) return Promise.resolve([]);
         const now = on || 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: number) => '$' + (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;
-            }));
+        const props = instances.map(instance => {
+            let props = this.serializeWrapper(instance);
+            if(!(props instanceof Promise)) props = Promise.resolve(props);
+            return props;
+        });
+        return Promise.all(props).then(resolvedProps => {
+            resolvedProps = resolvedProps.reduce((p, n) => p.concat(n), []);
+            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: number) => '$' + (j * this.nFields + i + 1)).join(', ') + ')')).join(',') + ' RETURNING id',
+                resolvedProps);
+        }).then(q => q.rows.map(r => {
+            const idNum = parseInt(r.id, 10);
+            if(String(idNum) !== q.rows[0].id) return r.id;
+            return idNum;
+        }));
     }
 
-    protected abstract buildObject(q: any): T;
+    protected abstract buildObject(q: any): T | Promise<T>;
 
-    protected abstract serialize(instance: T, request?: Request): any[];
+    protected abstract serialize(instance: T, request?: Request): any[] | Promise<any[]>;
+
+    protected buildObjectWrapper(q: any): T | Promise<T> {
+        return this.buildObject(q);
+    }
+
+    protected serializeWrapper(instance: T, request?: Request): any[] | Promise<any[]> {
+        return this.serialize(instance, request);
+    }
 }
 
 export abstract class ModelDao<R, T extends Model<R>> extends Dao<R, T> {
     get(id: R, client?: ClientBase | Transaction, lock = true): Promise<T> {
         if(this.pool) {
-            return (<ClientBase | Pool>(client || this.pool)).query(this.selectDefinition + ' FROM ' + this.table + ' WHERE id=$1' + ((client && lock) ? ' FOR UPDATE' : ''), [id]).then(q => this.buildObject(q.rows[0]));
+            return (<ClientBase | Pool>(client || this.pool)).query(this.selectDefinition + ' FROM ' + this.table + ' WHERE id=$1' + ((client && lock) ? ' FOR UPDATE' : ''), [id]).then(q => this.buildObjectWrapper(q.rows[0]));
         } else {
             const request = (<Transaction | ConnectionPool>(client || this.poolMssql)).request();
             request.input('1', id);
-            return request.query(this.selectDefinition + ' FROM ' + this.table + ((client && lock) ? ' WITH (UPDLOCK, ROWLOCK)' : '') + ' WHERE id=@1').then((q: any) => this.buildObject(q.recordsets[0][0]));
+            return request.query(this.selectDefinition + ' FROM ' + this.table + ((client && lock) ? ' WITH (UPDLOCK, ROWLOCK)' : '') + ' WHERE id=@1').then((q: any) => this.buildObjectWrapper(q.recordsets[0][0]));
         }
     }
 
@@ -170,12 +193,12 @@ export abstract class ModelDao<R, T extends Model<R>> extends Dao<R, T> {
     getList(ids: R[], client?: ClientBase | Transaction, lock = true): Promise<T[]> {
         if(this.pool) {
             return (<ClientBase | Pool>(client || this.pool)).query(this.selectDefinition + ' FROM ' + this.table + ' WHERE id=ANY($1)' + ((client && lock) ? ' FOR UPDATE' : ''), [ids])
-                .then(q => q.rows.map(r => this.buildObject(r)));
+                .then(q => Promise.all(q.rows.map(r => this.buildObjectWrapper(r))));
         } else {
             const request = (<Transaction | ConnectionPool>(client || this.poolMssql)).request();
             return request.query(this.selectDefinition + ' FROM ' + this.table + ((client && lock) ? ' WITH (UPDLOCK, ROWLOCK)' : '') + ' WHERE id IN ('
                 + (ids.length > 0 ? (typeof ids[0] === 'string' ? '\'' + ids.join('\',\'') + '\'' : ids.join(',')) : '') + ')')
-                .then((q: any) => q.recordsets[0].map((r: any) => this.buildObject(r)));
+                .then((q: any) => Promise.all(q.recordsets[0].map((r: any) => this.buildObjectWrapper(r))));
         }
     }
 
@@ -183,13 +206,13 @@ export abstract class ModelDao<R, T extends Model<R>> extends Dao<R, T> {
         if(this.pool) {
             return (<ClientBase | Pool>(client || this.pool)).query(this.selectDefinition + ' 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)));
+                .then(q => Promise.all(q.rows.map(r => this.buildObjectWrapper(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(this.selectDefinition + ' FROM ' + this.table + ((client && lock) ? ' WITH (UPDLOCK, ROWLOCK)' : '') + (where ? (' WHERE ' + where) : '')
                 + (order ? (' ORDER BY ' + order) : '') + (offset !== undefined ? (' OFFSET ' + offset + ' ROWS') : '') + (limit !== undefined ? (' FETCH NEXT ' + limit + ' ROWS ONLY') : ''))
-                .then((q: any) => q.recordsets[0].map((r: any) => this.buildObject(r)));
+                .then((q: any) => Promise.all(q.recordsets[0].map((r: any) => this.buildObjectWrapper(r))));
         }
     }
 
@@ -197,9 +220,10 @@ export abstract class ModelDao<R, T extends Model<R>> extends Dao<R, T> {
         if(this.pool) {
             return (<ClientBase | Pool>(client || this.pool)).query(this.selectDefinition + ', 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
+                .then(q => Promise.all([q.rows.length ? parseInt(q.rows[0].cnt, 10) : 0, Promise.all(q.rows.map(r => this.buildObjectWrapper(r)))]))
+                .then(([count, views]) => ({
+                    views,
+                    count
                 }));
         } else {
             const request = (<Transaction | ConnectionPool>(client || this.poolMssql)).request();
@@ -208,9 +232,11 @@ export abstract class ModelDao<R, T extends Model<R>> extends Dao<R, T> {
                 () => request.query(this.selectDefinition + ' FROM ' + this.table + ((client && lock) ? ' WITH (UPDLOCK, 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
+            ])
+            .then(([q1, q2]: [any, any]) => Promise.all([Promise.all(q1.recordsets[0].map((r: any) => this.buildObjectWrapper(r))), q2.recordsets.length ? q2.recordsets[0].reduce((p: number, n: any) => p + n.cnt, 0) : 0]))
+            .then(([views, count]) => ({
+                views,
+                count
             }));
         }
     }
@@ -219,9 +245,10 @@ export abstract class ModelDao<R, T extends Model<R>> extends Dao<R, T> {
         if(this.pool) {
             return (<ClientBase | Pool>(client || this.pool)).query('SELECT ' + cols.map(r => r.indexOf(' ') > -1 ? 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
+                .then(q => Promise.all([q.rows.length ? parseInt(q.rows[0].cnt, 10) : 0, Promise.all(q.rows.map(r => this.buildObjectWrapper(r)))]))
+                .then(([count, views]) => ({
+                    views,
+                    count
                 }));
         } else {
             const request = (<Transaction | ConnectionPool>(client || this.poolMssql)).request();
@@ -231,9 +258,11 @@ export abstract class ModelDao<R, T extends Model<R>> extends Dao<R, T> {
                     + ((client && lock) ? ' WITH (UPDLOCK, 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
+            ])
+            .then(([q1, q2]: [any, any]) => Promise.all([Promise.all(q1.recordsets[0].map((r: any) => this.buildObjectWrapper(r))), q2.recordsets.length ? q2.recordsets[0].reduce((p: number, n: any) => p + n.cnt, 0) : 0]))
+            .then(([views, count]) => ({
+                views,
+                count
             }));
         }
     }

package/package.json

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