anote-server-libs 0.11.2 → 0.11.4

package/.vscode/settings.json

@@ -1,3 +1,3 @@
-{
-    "typescript.tsdk": "node_modules\\typescript\\lib"
+{
+    "js/ts.tsdk.path": "node_modules/typescript/lib"
 }

package/models/ApiCall.ts

@@ -1,40 +1,40 @@
-import { ConnectionPool, DateTimeOffset, Request } from 'mssql';
-import {Pool} from 'pg';
-import {Logger} from 'winston';
-import {Model, ModelDao} from './repository/ModelDao';
-
-export interface ApiCall extends Model<string> {
-    responseCode: number;
-    responseJson: string;
-    expiresAt: Date;
-}
-
-export class ApiCallRepository extends ModelDao<string, ApiCall> {
-    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 {
-        if(!q) return undefined;
-        q.id = q.id.trim();
-        q.updatedOn = q.updatedOn && new Date(q.updatedOn);
-        q.responseCode = parseInt(q.responseCode, 10);
-        q.expiresAt = q.expiresAt && new Date(q.expiresAt);
-        return q;
-    }
-
-    serialize(instance: 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];
-        }
-    }
-
-}
+import { ConnectionPool, DateTimeOffset, Request } from 'mssql';
+import {Pool} from 'pg';
+import {Logger} from 'winston';
+import {Model, ModelDao} from './repository/ModelDao';
+
+export interface ApiCall extends Model<string> {
+    responseCode: number;
+    responseJson: string;
+    expiresAt: Date;
+}
+
+export class ApiCallRepository extends ModelDao<string, ApiCall> {
+    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 {
+        if(!q) return undefined;
+        q.id = q.id.trim();
+        q.updatedOn = q.updatedOn && new Date(q.updatedOn);
+        q.responseCode = parseInt(q.responseCode, 10);
+        q.expiresAt = q.expiresAt && new Date(q.expiresAt);
+        return q;
+    }
+
+    serialize(instance: 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.ts

@@ -1,43 +1,43 @@
-import { ConnectionPool, Request } from 'mssql';
-import {Pool} from 'pg';
-import {Logger} from 'winston';
-import {ModelDao} from './repository/ModelDao';
-
-export interface Migration {
-    id: number;
-    hash: string;
-    sqlUp: string;
-    sqlDown: string;
-    state: number;
-    skip: boolean;
-}
-
-export class MigrationRepository extends ModelDao<number, Migration> {
-    constructor(protected pool: Pool, protected poolMssql: ConnectionPool, protected logger: Logger) {
-        super(pool, poolMssql, logger, 'migration', 6, pool ? 'id=$1,hash=$2,"sqlUp"=$3,"sqlDown"=$4,state=$5,skip=$6' :
-            'id=@1,hash=@2,"sqlUp"=@3,"sqlDown"=@4,state=@5,skip=@6');
-    }
-
-    buildObject(q: any): Migration {
-        if(!q) return undefined;
-        q.id = parseInt(q.id, 10);
-        q.hash = q.hash.trim();
-        q.state = parseInt(q.state, 10);
-        q.skip = q.skip ? true : false;
-        return q;
-    }
-
-    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);
-            request.input('6', instance.skip ? 1 : 0);
-            return undefined;
-        } else {
-            return [instance.id, instance.hash, instance.sqlUp, instance.sqlDown, instance.state, instance.skip];
-        }
-    }
-}
+import { ConnectionPool, Request } from 'mssql';
+import {Pool} from 'pg';
+import {Logger} from 'winston';
+import {ModelDao} from './repository/ModelDao';
+
+export interface Migration {
+    id: number;
+    hash: string;
+    sqlUp: string;
+    sqlDown: string;
+    state: number;
+    skip: boolean;
+}
+
+export class MigrationRepository extends ModelDao<number, Migration> {
+    constructor(protected pool: Pool, protected poolMssql: ConnectionPool, protected logger: Logger) {
+        super(pool, poolMssql, logger, 'migration', 6, pool ? 'id=$1,hash=$2,"sqlUp"=$3,"sqlDown"=$4,state=$5,skip=$6' :
+            'id=@1,hash=@2,"sqlUp"=@3,"sqlDown"=@4,state=@5,skip=@6');
+    }
+
+    buildObject(q: any): Migration {
+        if(!q) return undefined;
+        q.id = parseInt(q.id, 10);
+        q.hash = q.hash.trim();
+        q.state = parseInt(q.state, 10);
+        q.skip = q.skip ? true : false;
+        return q;
+    }
+
+    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);
+            request.input('6', instance.skip ? 1 : 0);
+            return undefined;
+        } else {
+            return [instance.id, instance.hash, instance.sqlUp, instance.sqlDown, instance.state, instance.skip];
+        }
+    }
+}

package/models/repository/BaseModelRepository.js

@@ -57,7 +57,7 @@ END`)
                 if (migrations.find(migration => migration.state !== 0))
                     process.exit(4);
                 fs.readdir(migrationsPath, (_, files) => {
-                    const migrationsAvailable = files
+                    let migrationsAvailable = files
                         .filter(file => /[0-9]+\.sql/.test(file))
                         .map(file => parseInt(file.split('.sql')[0], 10))
                         .filter(file => file > 0)
@@ -73,15 +73,19 @@ END`)
                     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)
+                    if (onlyAboveOrEquals) {
                         migrations = migrations.filter(m => m.id >= onlyAboveOrEquals);
-                    if (onlyBelow)
+                        migrationsAvailable = migrationsAvailable.filter(m => m.id >= onlyAboveOrEquals);
+                    }
+                    if (onlyBelow) {
                         migrations = migrations.filter(m => m.id < onlyBelow);
+                        migrationsAvailable = migrationsAvailable.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 = onlyAboveOrEquals;
+                    let highestCommon = 0;
                     while (highestCommon < migrations.length && highestCommon < migrationsAvailable.length
                         && migrations[highestCommon].hash === migrationsAvailable[highestCommon].hash)
                         highestCommon++;

package/models/repository/BaseModelRepository.ts

@@ -58,7 +58,7 @@ END`)])).then(() => {
                 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
+                    let migrationsAvailable = files
                         .filter(file => /[0-9]+\.sql/.test(file))
                         .map(file => parseInt(file.split('.sql')[0], 10))
                         .filter(file => file > 0)
@@ -74,11 +74,11 @@ END`)])).then(() => {
                     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(onlyAboveOrEquals) { migrations = migrations.filter(m => m.id >= onlyAboveOrEquals); migrationsAvailable = migrationsAvailable.filter(m => m.id >= onlyAboveOrEquals); }
+                    if(onlyBelow) { migrations = migrations.filter(m => m.id < onlyBelow); migrationsAvailable = migrationsAvailable.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 = onlyAboveOrEquals;
+                    let highestCommon = 0;
                     while(highestCommon < migrations.length && highestCommon < migrationsAvailable.length
                     && migrations[highestCommon].hash === migrationsAvailable[highestCommon].hash)
                         highestCommon++;

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/MemoryCache.ts

@@ -1,87 +1,87 @@
-import * as Memcached from 'memcached';
-
-export class MemoryCache<T> {
-
-    private localCache: {[id: string]: any} = {};
-
-    constructor(private localKey: string, private cache?: Memcached) {
-    }
-
-    list(): Promise<T[]> {
-        if(this.cache) return new Promise(resolve => {
-            let pending = true;
-            setTimeout(() => {
-                if(pending) {
-                    pending = false;
-                    resolve([]);
-                }
-            }, 250);
-            this.cache.items((_, data) => {
-                if(pending) {
-                    pending = false;
-                    resolve(data.map(s => {
-                        const value = <string>s[Object.getOwnPropertyNames(s).find(sname => sname.startsWith(this.localKey))];
-                        return value && JSON.parse(value);
-                    }).filter(x => x));
-                }
-            });
-        });
-        else return Promise.resolve(Object.getOwnPropertyNames(this.localCache).map(key => this.localCache[key]));
-    }
-
-    get(key: string | number): Promise<T> {
-        if(this.cache) return new Promise(resolve => {
-            let pending = true;
-            setTimeout(() => {
-                if(pending) {
-                    pending = false;
-                    resolve(undefined);
-                }
-            }, 250);
-            this.cache.get(this.localKey + key, (_, data) => {
-                if(pending) {
-                    pending = false;
-                    resolve(data && JSON.parse(data));
-                }
-            });
-        });
-        else return Promise.resolve(this.localCache[key]);
-    }
-
-    set(key: string | number, val: T, time = 15 * 60): Promise<void> {
-        if(this.cache) return new Promise(resolve => this.cache.set(this.localKey + key, JSON.stringify(val), time, resolve));
-        else {
-            this.localCache[key] = val;
-            return Promise.resolve();
-        }
-    }
-
-    delete(key: string | number): Promise<void> {
-        if(this.cache) {
-            return new Promise(resolve => {
-                let fired = false;
-                const handler = setTimeout(() => {
-                    fired = true;
-                    resolve();
-                }, 50);
-                this.cache.del(this.localKey + key, () => {
-                    if(!fired) {
-                        clearTimeout(handler);
-                        resolve();
-                    }
-                });
-            });
-        } else {
-            this.localCache[key] = undefined;
-            return Promise.resolve();
-        }
-    }
-
-    clear() {
-        if(this.cache) {
-            this.localKey = this.localKey + '_';
-            if(this.localKey.length > 40)
-                this.localKey = this.localKey.replace(/_+$/, '');
-        } else this.localCache = {};
-    }
-}
+import * as Memcached from 'memcached';
+
+export class MemoryCache<T> {
+
+    private localCache: {[id: string]: any} = {};
+
+    constructor(private localKey: string, private cache?: Memcached) {
+    }
+
+    list(): Promise<T[]> {
+        if(this.cache) return new Promise(resolve => {
+            let pending = true;
+            setTimeout(() => {
+                if(pending) {
+                    pending = false;
+                    resolve([]);
+                }
+            }, 250);
+            this.cache.items((_, data) => {
+                if(pending) {
+                    pending = false;
+                    resolve(data.map(s => {
+                        const value = <string>s[Object.getOwnPropertyNames(s).find(sname => sname.startsWith(this.localKey))];
+                        return value && JSON.parse(value);
+                    }).filter(x => x));
+                }
+            });
+        });
+        else return Promise.resolve(Object.getOwnPropertyNames(this.localCache).map(key => this.localCache[key]));
+    }
+
+    get(key: string | number): Promise<T> {
+        if(this.cache) return new Promise(resolve => {
+            let pending = true;
+            setTimeout(() => {
+                if(pending) {
+                    pending = false;
+                    resolve(undefined);
+                }
+            }, 250);
+            this.cache.get(this.localKey + key, (_, data) => {
+                if(pending) {
+                    pending = false;
+                    resolve(data && JSON.parse(data));
+                }
+            });
+        });
+        else return Promise.resolve(this.localCache[key]);
+    }
+
+    set(key: string | number, val: T, time = 15 * 60): Promise<void> {
+        if(this.cache) return new Promise(resolve => this.cache.set(this.localKey + key, JSON.stringify(val), time, resolve));
+        else {
+            this.localCache[key] = val;
+            return Promise.resolve();
+        }
+    }
+
+    delete(key: string | number): Promise<void> {
+        if(this.cache) {
+            return new Promise(resolve => {
+                let fired = false;
+                const handler = setTimeout(() => {
+                    fired = true;
+                    resolve();
+                }, 50);
+                this.cache.del(this.localKey + key, () => {
+                    if(!fired) {
+                        clearTimeout(handler);
+                        resolve();
+                    }
+                });
+            });
+        } else {
+            this.localCache[key] = undefined;
+            return Promise.resolve();
+        }
+    }
+
+    clear() {
+        if(this.cache) {
+            this.localKey = this.localKey + '_';
+            if(this.localKey.length > 40)
+                this.localKey = this.localKey.replace(/_+$/, '');
+        } else this.localCache = {};
+    }
+}