anote-server-libs 0.9.6 → 0.9.8

package/models/repository/BaseModelRepository.js

@@ -23,7 +23,7 @@ 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, onlyBelow) {
+    migrate(migrationsPath, callback, onlyAboveOrEquals, onlyBelow) {
         (this.db ? Promise.all([
             this.db.query(`CREATE TABLE IF NOT EXISTS migration (
 id integer PRIMARY KEY,
@@ -70,22 +70,23 @@ END`)
                             hash: crypto.createHash('sha256').update(content).digest('hex')
                         };
                     });
-                    migrations = migrations.filter(m => m.id >= onlyAboveOrEquals);
+                    const minAvailableId = migrationsAvailable.length > 0 ? migrationsAvailable[0].id : 0;
+                    const maxAvailableId = migrationsAvailable.length > 0 ? migrationsAvailable[migrationsAvailable.length - 1].id : Infinity;
+                    migrations = migrations.filter(m => m.id >= minAvailableId && m.id <= maxAvailableId);
+                    if (onlyAboveOrEquals)
+                        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]
+                    let highestCommon = onlyAboveOrEquals;
+                    while (highestCommon < migrations.length && highestCommon < migrationsAvailable.length
                         && 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);
+                    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));

package/models/repository/BaseModelRepository.ts

@@ -26,7 +26,7 @@ export class BaseModelRepository {
     }
 
     // TODO: alter table migration if exists without ok column
-    migrate(migrationsPath: string, callback: (() => void), onlyAboveOrEquals = 0, onlyBelow?: number) {
+    migrate(migrationsPath: string, callback: (() => void), onlyAboveOrEquals?: number, onlyBelow?: number) {
         (this.db ? Promise.all([
         this.db.query(`CREATE TABLE IF NOT EXISTS migration (
 id integer PRIMARY KEY,
@@ -71,19 +71,19 @@ END`)])).then(() => {
                                 hash: crypto.createHash('sha256').update(content).digest('hex')
                             };
                         });
-                    migrations = migrations.filter(m => m.id >= onlyAboveOrEquals);
+                    const minAvailableId = migrationsAvailable.length > 0 ? migrationsAvailable[0].id : 0;
+                    const maxAvailableId = migrationsAvailable.length > 0 ? migrationsAvailable[migrationsAvailable.length - 1].id : Infinity;
+                    migrations = migrations.filter(m => m.id >= minAvailableId && m.id <= maxAvailableId);
+                    if(onlyAboveOrEquals) 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)
+                    let highestCommon = onlyAboveOrEquals;
+                    while(highestCommon < migrations.length && highestCommon < migrationsAvailable.length
+                    && 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);
+                    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));
@@ -172,4 +172,4 @@ END`)])).then(() => {
             });
         });
     }
-}
+}

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/package.json

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