anote-server-libs 0.6.0 → 0.6.2

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "typescript.tsdk": "node_modules\\typescript\\lib"
+}

package/models/ApiCall.js

@@ -4,6 +4,9 @@ exports.ApiCallRepository = void 0;
 const mssql_1 = require("mssql");
 const ModelDao_1 = require("./repository/ModelDao");
 class ApiCallRepository extends ModelDao_1.ModelDao {
+    pool;
+    poolMssql;
+    logger;
     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');

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.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MigrationRepository = void 0;
 const ModelDao_1 = require("./repository/ModelDao");
 class MigrationRepository extends ModelDao_1.ModelDao {
+    pool;
+    poolMssql;
+    logger;
     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');

package/models/Migration.ts

@@ -1,40 +1,40 @@
-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;
-}
-
-export class MigrationRepository extends ModelDao<number, Migration> {
-    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 {
-        if(!q) return undefined;
-        q.id = parseInt(q.id, 10);
-        q.hash = q.hash.trim();
-        q.state = parseInt(q.state, 10);
-        return q;
-    }
-
-    serialize(instance: 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];
-        }
-    }
-}
+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;
+}
+
+export class MigrationRepository extends ModelDao<number, Migration> {
+    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 {
+        if(!q) return undefined;
+        q.id = parseInt(q.id, 10);
+        q.hash = q.hash.trim();
+        q.state = parseInt(q.state, 10);
+        return q;
+    }
+
+    serialize(instance: 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,6 +6,13 @@ const fs = require("fs");
 const ApiCall_1 = require("../ApiCall");
 const Migration_1 = require("../Migration");
 class BaseModelRepository {
+    db;
+    dbSpare;
+    dbMssql;
+    logger;
+    cache;
+    Migration;
+    ApiCall;
     constructor(db, dbSpare, dbMssql, logger, cache) {
         this.db = db;
         this.dbSpare = dbSpare;

package/models/repository/BaseModelRepository.ts

@@ -1,152 +1,152 @@
-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);
-    }
-
-    migrate(migrationsPath: string, callback: (() => void), onlyAboveOrEquals = 0) {
-        (this.db ? this.db.query('CREATE TABLE IF NOT EXISTS migration (' +
-            'id integer PRIMARY KEY,' +
-            'hash text NOT NULL,' +
-            '"sqlUp" text NOT NULL,' +
-            '"sqlDown" text NOT NULL,' +
-            'state integer NOT NULL' +
-            ')') : this.dbMssql.query('if not exists (select * from sysobjects where name=\'migration\' and xtype=\'U\') CREATE TABLE migration (' +
-            'id int PRIMARY KEY,' +
-            'hash text NOT NULL,' +
-            '"sqlUp" text NOT NULL,' +
-            '"sqlDown" text NOT NULL,' +
-            'state int NOT NULL' +
-            ')')).then(() => {
-            this.Migration.getAllBy('id').then((migrations: 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(() => {
-                        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('----');
-            this.Migration.create({
-                id: migration.id,
-                hash: migration.hash,
-                sqlUp: sqlParts[0],
-                sqlDown: sqlParts[1],
-                state: 2
-            }).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<void> {
-        if(current > until) {
-            current--;
-            return this.applyDown(migrations[current]).then(() => this.applyDownUntil(migrations, current, until));
-        }
-        return Promise.resolve();
-    }
-
-    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);
+    }
+
+    migrate(migrationsPath: string, callback: (() => void), onlyAboveOrEquals = 0) {
+        (this.db ? this.db.query('CREATE TABLE IF NOT EXISTS migration (' +
+            'id integer PRIMARY KEY,' +
+            'hash text NOT NULL,' +
+            '"sqlUp" text NOT NULL,' +
+            '"sqlDown" text NOT NULL,' +
+            'state integer NOT NULL' +
+            ')') : this.dbMssql.query('if not exists (select * from sysobjects where name=\'migration\' and xtype=\'U\') CREATE TABLE migration (' +
+            'id int PRIMARY KEY,' +
+            'hash text NOT NULL,' +
+            '"sqlUp" text NOT NULL,' +
+            '"sqlDown" text NOT NULL,' +
+            'state int NOT NULL' +
+            ')')).then(() => {
+            this.Migration.getAllBy('id').then((migrations: 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(() => {
+                        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('----');
+            this.Migration.create({
+                id: migration.id,
+                hash: migration.hash,
+                sqlUp: sqlParts[0],
+                sqlDown: sqlParts[1],
+                state: 2
+            }).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<void> {
+        if(current > until) {
+            current--;
+            return this.applyDown(migrations[current]).then(() => this.applyDownUntil(migrations, current, until));
+        }
+        return Promise.resolve();
+    }
+
+    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/MemoryCache.js

@@ -2,10 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryCache = void 0;
 class MemoryCache {
+    localKey;
+    cache;
+    localCache = {};
     constructor(localKey, cache) {
         this.localKey = localKey;
         this.cache = cache;
-        this.localCache = {};
     }
     list() {
         if (this.cache)