@resolveio/server-lib 12.5.54 → 12.5.55

package/src/managers/mongo.manager.ts

@@ -1,2282 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { AggregateOptions, AggregationCursor, BulkWriteOptions, ChangeStream, ChangeStreamOptions, CollStats, CollStatsOptions, CommandOperationOptions, CountDocumentsOptions, CreateCollectionOptions, CreateIndexesOptions, CursorStreamOptions, DeleteOptions, Filter, FindCursor, FindOneAndDeleteOptions, FindOneAndReplaceOptions, FindOneAndUpdateOptions, FindOptions, IndexDescription, IndexInformationOptions, InsertOneOptions, ListIndexesCursor, ListIndexesOptions, ObjectId, RenameOptions, ReplaceOptions, UpdateOptions, OptionalId, Collection, CollectionInfo, OptionalUnlessRequiredId, AnyBulkWriteOperation, BulkWriteResult } from 'mongodb';
-import { LookupTables } from '../models/report-builder.model';
-import { ResolveIOServer } from '../index';
-import { Users } from '../collections/user.collection';
-import { buildRbLookups, buildRbSchema, dateReviver, deepCopy, getBinarySize, getMongoMergeUpdatedDoc } from '../util/common';
-import { UserModel } from '../models/user.model';
-import { Logs } from '../collections/log.collection';
-import * as NodeCache from 'node-cache';
-const crypto = require('crypto');
-const scmp = require('scmp');
-import { MonitorMongo } from './monitor.manager';
-import { CollectionDocument, Document } from '../models/collection-document.model';
-import { cpus } from 'os';
-const numCPUs = cpus().length;
-const v8 = require('v8');
-
-interface MongoQueueModel {
-	_id: number,
-	name_collection: string;
-	lookup_collections: string[];
-	name_function: string;
-	data_function: any[];
-	name_function_addt: string;
-	data_function_addt: any[];
-	cbs: Function[];
-	cbs_next: Function[];
-	running: boolean;
-	cacheId: number;
-	invalidateFlag: boolean;
-	invalidateCount: number;
-}
-
-// export declare interface MongoManagerFilterOperators<T> extends Document {
-export declare interface MongoManagerFilterParamaterOperators<P> {
-	$eq?: P;
-    $gt?: P;
-    $gte?: P;
-    $in?: P extends Array<any> ? P : P[];
-    $lt?: P;
-    $lte?: P;
-    $ne?: P;
-    $nin?: P extends Array<any> ? P : P[];
-    $not?: P extends string ? MongoManagerFilterParamaterOperators<P> | RegExpConstructor : MongoManagerFilterParamaterOperators<P>;
-    $exists?: boolean;
-    $expr?: any[]
-    $regex?: P extends string ? RegExpConstructor | string : never;
-    $options?: P extends string ? string : never;
-    $geoIntersects?: {
-        $geometry: Document;
-    };
-    $geoWithin?: Document;
-    $near?: Document;
-    $nearSphere?: Document;
-    $maxDistance?: number;
-    $all?: any[];
-    $elemMatch?: Document;
-    $size?: P extends any[] ? number : never;
-}
-
-export declare interface MongoManagerFilterOperators<T> extends Document {  //TODO: Remove extends document when I get answer on S.O.
-    $and?: MongoManagerFilter<T>[] | MongoManagerFilterOperators<T>;
-    $nor?: MongoManagerFilter<T>[] | MongoManagerFilterOperators<T>;
-    $or?: MongoManagerFilter<T>[] | MongoManagerFilterOperators<T>;
-    $text?: {
-        $search: string;
-        $language?: string;
-        $caseSensitive?: boolean;
-        $diacriticSensitive?: boolean;
-    };
-    $where?: string | ((this: T) => boolean);
-    $comment?: string | Document;
-}
-
-// function isDotStringRegExp(obj: Object, dotKey: string): boolean {
-// 	let keyData = dotKey.split('.');
-// 	let objData = obj;
-	
-// 	for (let i = 0; i < keyData.length; i++) {
-// 		let key = keyData[i];
-// 		if (objData.hasOwnProperty(key)) {
-// 			objData = objData[key];
-			
-// 			if (i === keyData.length - 1) {
-// 				return true;
-// 			}
-// 		}
-// 		else {
-// 			return false;
-// 		}
-// 	}
-// }
-
-// export declare type MongoManagerDotStringFilter<T> = {
-// 	[key: string]: (isDotStringRegExp(T, key) ? any : never);
-// };
-
-export declare type MongoManagerFilter<T> = {
-	[P in keyof T]?: T[P] | MongoManagerFilterParamaterOperators<T[P]>;
-};
-
-export declare type MongoManagerUnsetFilter<T> = {
-	[P in keyof T]?: number | boolean;
-};
-
-export declare type MongoManagerIncFilter<T> = {
-	[P in keyof T]?: number;
-};
-
-export declare type MongoManagerUpdateFilter<T> = {
-    $inc?: MongoManagerIncFilter<T> | Document;
-    $set?: MongoManagerFilter<T> | Document;
-    $setOnInsert?: MongoManagerFilter<T> | Document;
-    $unset?: MongoManagerUnsetFilter<T> | Document;
-};
-
-export class MongoManager {
-	private _collections: MongoManagerCollection<CollectionDocument>[] = [];
-	private _mongoQueue: MongoQueueModel[] = [];
-	private _mongoQueueId = 0;
-	private _mongoQueueRunning = false;
-
-	private _nodeCache;
-	private _mongoQueueCacheId = 1;
-
-	private _heapStats = v8.getHeapStatistics();
-	private _heapLimit = this._heapStats.heap_size_limit / numCPUs / 8;
-
-	private _serverCollections: (CollectionInfo | Pick<CollectionInfo, "name" | "type">)[] = [];
-
-	private _debugMongoQueueHits = 0;
-	private _debugRemoveCacheHits = 0;
-	private _debugMongoQueueCollections = [];
-
-	constructor() {
-		this._nodeCache = new NodeCache( { stdTTL: 0, checkperiod: 0 } );
-
-		setInterval(() => {
-			if (ResolveIOServer.getMainServer().getSubscriptionManager().getEnableDebug()) {
-				console.log(new Date(), 'Mongo Manager', 'Collections', this._collections.length);
-				console.log(new Date(), 'Mongo Manager', 'Mongo Queue', this._mongoQueue.length, JSON.stringify(this._mongoQueue.sort((a, b) => a.name_collection.localeCompare(b.name_collection)), null, 2));
-				console.log(new Date(), 'Mongo Manager', 'Server Collections', this._serverCollections.length);
-				console.log(new Date(), 'Mongo Manager', 'Mongo Queue Hits', this._debugMongoQueueHits);
-				console.log(new Date(), 'Mongo Manager', 'Mongo Queue Collections', this._debugMongoQueueCollections.sort((a, b) => a.collection.localeCompare(b.collection) || a.function.localeCompare(b.function)));
-				console.log(new Date(), 'Mongo Manager', 'Cache Cleanup Hits', JSON.stringify(this._debugRemoveCacheHits, null, 2));
-			}
-				
-			this._debugMongoQueueHits = 0;
-			this._debugRemoveCacheHits = 0;
-			this._debugMongoQueueCollections = [];
-		}, 60000);
-
-		this.initServerCollections();
-
-		this.runQueue();
-	}
-
-	async initServerCollections() {
-		let collections = await ResolveIOServer.getMainDB().listCollections().toArray();
-		this._serverCollections = collections;
-	}
-
-	getServerCollections() {
-		return this._serverCollections;
-	}
-
-	registerCollection(collection: MongoManagerCollection<CollectionDocument>) {
-		if (collection.collectionOptions && collection.collectionOptions.timeseries && collection.collectionOptions.timeseries.timeField && this._serverCollections.some(a => a.name === collection.collectionName && a.type === 'collection')) {
-			ResolveIOServer.getMainDB().dropCollection(collection.collectionName).then(() => {
-				this.createCollection(collection);
-			});
-		}
-	
-		this._collections.push(collection);
-	}
-
-	createCollection(collection: MongoManagerCollection<CollectionDocument>) {
-		ResolveIOServer.getMainDB().createCollection<CollectionDocument>(collection.collectionName, collection.collectionOptions);
-	}
-
-	collections() {
-		return this._collections;
-	}
-
-	collection(collectionName: string): MongoManagerCollection<CollectionDocument> | MongoManagerUserCollection<CollectionDocument> {
-		return this._collections.filter(a => a.collectionName === collectionName)[0];
-	}
-
-	addToQueue(mongoQueue: MongoQueueModel) {
-		let _mongoQueue = this._mongoQueue.filter(a => a.name_collection === mongoQueue.name_collection && a.name_function === mongoQueue.name_function && a.name_function_addt === mongoQueue.name_function_addt && JSON.stringify(a.data_function) === JSON.stringify(mongoQueue.data_function) && JSON.stringify(a.data_function_addt) === JSON.stringify(mongoQueue.data_function_addt))[0];
-		
-		if (_mongoQueue) {
-			if (!_mongoQueue.running) {
-				_mongoQueue.cbs.push(mongoQueue.cbs[0]);
-			}
-			else {
-				_mongoQueue.cbs_next.push(mongoQueue.cbs[0]);
-			}
-		}
-		else {
-			mongoQueue._id = this._mongoQueueId;
-			this._mongoQueueId += 1;
-
-			this._mongoQueue.splice(0, 0, mongoQueue);
-		}
-	}
-
-	private async runQueue() {
-		setInterval(() => {
-			if (!this._mongoQueueRunning) {
-				const queueArr = this._mongoQueue.filter(a => !a.running && a.cbs.length);
-				if (queueArr.length) {
-					this._mongoQueueRunning = true;
-					
-					for (let i = queueArr.length - 1; i >= 0; i--) {
-						this._debugMongoQueueHits += 1;
-
-						let mongoQueue = queueArr[i];
-
-						if (!this._debugMongoQueueCollections.some(a => a.collection === mongoQueue.name_collection && a.function === mongoQueue.name_function)) {
-							this._debugMongoQueueCollections.push({
-								collection: mongoQueue.name_collection,
-								function: mongoQueue.name_function,
-								hits: 1
-							});
-						}
-						else {
-							this._debugMongoQueueCollections.filter(a => a.collection === mongoQueue.name_collection && a.function === mongoQueue.name_function)[0].hits += 1;
-						}
-
-						mongoQueue.running = true;
-						mongoQueue.invalidateFlag = false;
-
-						if (mongoQueue.cacheId) {
-							try {
-								let res = JSON.parse(this._nodeCache.get(mongoQueue.cacheId), dateReviver);
-
-								mongoQueue.cbs.forEach(cb => {
-									cb(null, res, true);
-								});
-
-								mongoQueue.cbs = [];
-								mongoQueue.running = false;
-							}
-							catch {
-								mongoQueue.cacheId = 0;
-							}
-						}
-						
-						if (!mongoQueue.cacheId) {
-							if (!mongoQueue.name_function_addt) {
-								let monitor = new MonitorMongo(mongoQueue.name_function, mongoQueue.name_collection, JSON.stringify(mongoQueue.data_function));
-								ResolveIOServer.getMainDB().collection(mongoQueue.name_collection)[mongoQueue.name_function](...mongoQueue.data_function).then(res => {
-									monitor.finish();
-									if (!mongoQueue.invalidateFlag) {
-										mongoQueue.invalidateCount = 0;
-
-										let stringifyLength = 0;
-										let stringifyFail = false;
-
-										try {
-											let stringify = JSON.stringify(res).replace(/[\[\]\,\"]/g,'');
-											stringifyLength	 = stringify.length;
-										}
-										catch(e) {
-											stringifyFail = true;
-										}
-
-										if (!stringifyFail && res !== null && res !== undefined && (!Array.isArray(res) || res.length) && stringifyLength < 10000000) {
-											mongoQueue.cacheId = this._mongoQueueCacheId;
-											this._mongoQueueCacheId += 1;
-
-											this.addToCache(mongoQueue.cacheId, res);
-										}
-										else {
-											mongoQueue.cacheId = 0;
-										}
-
-										mongoQueue.cbs.forEach(cb => {
-											cb(null, res, false);
-										});
-
-										if (mongoQueue.cbs_next.length) {
-											mongoQueue.cbs = mongoQueue.cbs_next;
-											mongoQueue.cbs_next = [];
-										}
-										else {
-											mongoQueue.cbs = [];
-										}
-									}
-									else {
-										if (mongoQueue.invalidateCount >= 5) {
-											mongoQueue.invalidateCount = 0;
-
-											mongoQueue.cbs.forEach(cb => {
-												cb(null, res, false);
-											});
-										}
-
-										mongoQueue.cbs = mongoQueue.cbs.concat(mongoQueue.cbs_next);
-										mongoQueue.cbs_next = [];
-									}
-
-									mongoQueue.running = false;
-								}, err => {
-									monitor.finish();
-
-									console.log(new Date(), 'Error ' + mongoQueue.name_function, mongoQueue.name_collection, ...mongoQueue.data_function, err);
-
-									mongoQueue.cbs.forEach(cb => {
-										cb(err, null, false);
-									});
-				
-									mongoQueue.cbs_next.forEach(cb => {
-										cb(err, null, false);
-									});
-									
-									if (this._mongoQueue.map(a => a._id).indexOf(mongoQueue._id) >= 0) {
-										this._mongoQueue.splice(this._mongoQueue.map(a => a._id).indexOf(mongoQueue._id), 1);
-									}
-								});
-							}
-							else {
-								let monitor = new MonitorMongo(mongoQueue.name_function, mongoQueue.name_collection, JSON.stringify([...mongoQueue.data_function, mongoQueue.name_function_addt, ...mongoQueue.data_function_addt]));
-								ResolveIOServer.getMainDB().collection(mongoQueue.name_collection)[mongoQueue.name_function](...mongoQueue.data_function)[mongoQueue.name_function_addt](...mongoQueue.data_function_addt).then(res => {
-									monitor.finish();
-									if (!mongoQueue.invalidateFlag) {
-										mongoQueue.invalidateCount = 0;
-
-										let stringifyLength = 0;
-										let stringifyFail = false;
-
-										try {
-											let stringify = JSON.stringify(res).replace(/[\[\]\,\"]/g,'');
-											stringifyLength	 = stringify.length;
-										}
-										catch(e) {
-											stringifyFail = true;
-										}
-										
-										if (!stringifyFail && res !== null && res !== undefined && (!Array.isArray(res) || res.length) && stringifyLength < 10000000) {
-											mongoQueue.cacheId = this._mongoQueueCacheId;
-											this._mongoQueueCacheId += 1;
-											this.addToCache(mongoQueue.cacheId, res);
-										}
-										else {
-											mongoQueue.cacheId = 0;
-										}
-
-										mongoQueue.cbs.forEach(cb => {
-											cb(null, res, false);
-										});
-
-										if (mongoQueue.cbs_next.length) {
-											mongoQueue.cbs = mongoQueue.cbs_next;
-											mongoQueue.cbs_next = [];
-										}
-										else {
-											mongoQueue.cbs = [];
-										}
-									}
-									else {
-										if (mongoQueue.invalidateCount >= 5) {
-											mongoQueue.invalidateCount = 0;
-											
-											mongoQueue.cbs.forEach(cb => {
-												cb(null, res, false);
-											});
-										}
-
-										mongoQueue.cbs = mongoQueue.cbs.concat(mongoQueue.cbs_next);
-										mongoQueue.cbs_next = [];
-									}
-
-									mongoQueue.running = false;
-								}, err => {
-									monitor.finish();
-									
-									mongoQueue.cbs.forEach(cb => {
-										cb(err, null, false);
-									});
-				
-									mongoQueue.cbs_next.forEach(cb => {
-										cb(err, null, false);
-									});
-				
-									if (this._mongoQueue.map(a => a._id).indexOf(mongoQueue._id) >= 0) {
-										this._mongoQueue.splice(this._mongoQueue.map(a => a._id).indexOf(mongoQueue._id), 1);
-									}
-								});
-							}
-						}
-					}
-
-					this._mongoQueueRunning = false;
-				}
-			}
-		}, 25);
-	}
-
-	private addToCache(id, data) {
-		let nodeCacheSize = this._nodeCache.getStats().vsize;
-						
-		if (nodeCacheSize > this._heapLimit) {
-			let deleteCount = 0;
-
-			const queueArr = this._mongoQueue.filter(a => a.cacheId && !a.running && !a.cbs.length);
-
-			for (let zz = queueArr.length - 1; zz >= 0; zz--) {
-				this._debugRemoveCacheHits += 1;
-
-				let queue = queueArr[zz];
-
-				this._nodeCache.del(queue.cacheId);
-				queue.cacheId = 0;
-
-				if (this._mongoQueue.map(a => a._id).indexOf(queue._id) >= 0) {
-					this._mongoQueue.splice(this._mongoQueue.map(a => a._id).indexOf(queue._id), 1);
-				}
-
-				deleteCount += 1;
-
-				nodeCacheSize = this._nodeCache.getStats().vsize;
-
-				if (nodeCacheSize < this._heapLimit * 0.75) {
-					break;
-				}
-			}
-			
-			console.log('Query Cache: ' + 'Too Big, - Deleted: ' + deleteCount + ' - ' + nodeCacheSize);
-		}
-
-		this._nodeCache.set(id, JSON.stringify(data));
-	}
-
-	public invalidateQueryCache(collection: string) {
-		let queueArr = this._mongoQueue.filter(a => (a.name_collection === collection || a.lookup_collections.includes(collection)));
-		for (let i = queueArr.length - 1; i >= 0; i--) {
-			let queue = queueArr[i];			
-			if (queue.cacheId) {
-				this._nodeCache.del(queue.cacheId);
-				queue.cacheId = 0;
-			}
-
-			if (queue.running) {
-				queue.invalidateFlag = true;
-				queue.invalidateCount += 1;
-			}
-			else if (!queue.cbs.length) {
-				if (this._mongoQueue.map(a => a._id).indexOf(queue._id) >= 0) {
-					this._mongoQueue.splice(this._mongoQueue.map(a => a._id).indexOf(queue._id), 1);
-				}
-			}
-		}
-	}
-}
-
-export class MongoManagerModel<T extends CollectionDocument> {
-	collection_main: MongoManagerCollection<T> | MongoManagerUserCollection<T> = null;
-	collection_version: MongoManagerCollection<T> | MongoManagerUserCollection<T> = null;
-
-	constructor(options: MongoManagerCollectionOptions) {
-		if (options.collectionName === 'users') {
-			this.collection_main = new MongoManagerUserCollection<T>(options);
-		}
-		else {
-			this.collection_main = new MongoManagerCollection<T>(options);
-		}
-
-		if (options.useVersionCollection) {
-			this.collection_main.useVersions = true;
-			
-			let versionSchema = deepCopy(options.schema);
-			versionSchema._id.type = 'Object';
-			versionSchema._id.blackbox = true;
-
-			let versionOptions: MongoManagerCollectionOptions = {
-				collectionName: options.collectionName + '.versions',
-				schema: versionSchema,
-				useVersionCollection: false,
-				useReportBuilder: false,
-				reportBuilderLookupTables: [],
-				timestamps: true,
-				createLogs: false,
-				checkSchema: false,
-				collectionOptions: null
-			};
-
-			if (options.collectionName === 'users') {	
-				this.collection_version = new MongoManagerUserCollection<T>(versionOptions);
-			}
-			else {
-				this.collection_version = new MongoManagerCollection<T>(versionOptions);
-			}
-
-			this.collection_version.createIndex({'_id._id': 1, '_id.__v': 1});
-			this.collection_main.versionCollection = options.collectionName + '.versions';
-		}
-	}
-}
-
-export interface MongoManagerCollectionOptions {
-	collectionName: string;
-	schema: object;
-	useVersionCollection: boolean;
-	useReportBuilder: boolean;
-	reportBuilderLookupTables: LookupTables[]
-	timestamps: boolean;
-	createLogs: boolean;
-	checkSchema: boolean;
-	collectionOptions: CreateCollectionOptions;
-}
-
-export class MongoManagerCollection<T extends CollectionDocument> {
-	collectionName = '';
-	checkSchema = false;
-	simplschema = null;
-	rbSchema = null;
-	timestamps = false;
-	useVersions = false;
-	versionCollection = '';
-	createLogs = true;
-	useRB = false;
-	collectionOptions: CreateCollectionOptions;
-	
-	constructor(options: MongoManagerCollectionOptions) {
-		this.collectionName = options.collectionName;
-		this.simplschema = new SimpleSchema(options.schema);
-		this.timestamps = options.timestamps;
-		this.createLogs = options.createLogs;
-		this.checkSchema = options.checkSchema;
-		this.collectionOptions = options.collectionOptions;
-
-		if (options.useReportBuilder) {
-			this.useRB = true;
-			let schemaCopy = deepCopy(options.schema);
-			let rbSchema = buildRbLookups(options.reportBuilderLookupTables, schemaCopy, []);
-			this.rbSchema = buildRbSchema(rbSchema);
-		}
-
-		let interval = setInterval(() => {
-			if (ResolveIOServer && ResolveIOServer.getMainServer() && ResolveIOServer.getMongoManager() && ResolveIOServer.getMongoManager().getServerCollections().length) {
-				ResolveIOServer.getMongoManager().registerCollection(this);
-				clearInterval(interval);
-			}
-		}, 1);
-	}
-
-	aggregate(pipeline: object[], options?: AggregateOptions, skipCache = false) : Promise<any[]> {
-		return new Promise((resolve, reject) => {
-			// if (!skipCache) {
-			// 	ResolveIOServer.getMongoManager().addToQueue({
-			// 		_id: 0,
-			// 		name_collection: this.collectionName,
-			// 		name_function: 'aggregate',
-			// 		name_function_addt: 'toArray',
-			// 		data_function: [pipeline, options],
-			// 		data_function_addt: [],
-			// 		cbs: [(err, res, cached) => {
-			// 			if (err) {
-			// 				reject(err);
-			// 			}
-			// 			else {
-			// 				resolve(res);
-			// 			}
-			// 		}],
-			// 		cbs_next: [],
-			// 		running: false,
-			// 		cacheId: 0,
-			// 		lookup_collections: pipeline.filter(a => a['$lookup'] && a['$lookup'].from).map(a => a['$lookup'].from).filter((elem, index, self) => {
-			// 			return index === self.indexOf(elem);
-			// 		}),
-			// 		invalidateFlag: false,
-			// 		invalidateCount: 0
-			// 	});
-			// }
-			// else {
-			// 	let monitor = new MonitorMongo('aggregate', this.collectionName, JSON.stringify([pipeline, options]));
-			// 	ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).aggregate(pipeline, options).toArray().then(res => {
-			// 		monitor.finish();
-			// 		resolve(res);
-			// 	}, err => {
-			// 		monitor.finish();
-			// 		console.log(new Date(), 'Error Aggregate', this.collectionName, pipeline, options, err);
-			// 		reject(err);
-			// 	});
-			// }
-
-			let monitor = new MonitorMongo('aggregate', this.collectionName, JSON.stringify([pipeline, options]));
-			ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).aggregate(pipeline, options).toArray().then(res => {
-				monitor.finish();
-				resolve(res);
-			}, err => {
-				monitor.finish();
-				console.log(new Date(), 'Error Aggregate', this.collectionName, pipeline, options, err);
-				reject(err);
-			});
-		});
-	}
-
-	aggregateCount(pipeline: object[], options?: AggregateOptions) : Promise<number> {
-		return new Promise((resolve, reject) => {
-			ResolveIOServer.getMongoManager().addToQueue({
-				_id: 0,
-				name_collection: this.collectionName,
-				name_function: 'aggregate',
-				name_function_addt: 'count',
-				data_function: [pipeline, options],
-				data_function_addt: [],
-				cbs: [(err, res, cached) => {
-					if (err) {
-						reject(err);
-					}
-					else {
-						resolve(res);
-					}
-				}],
-				cbs_next: [],
-				running: false,
-				cacheId: 0,
-				lookup_collections: pipeline.filter(a => a['$lookup'] && a['$lookup'].from).map(a => a['$lookup'].from).filter((elem, index, self) => {
-					return index === self.indexOf(elem);
-				}),
-				invalidateFlag: false,
-				invalidateCount: 0
-			});
-		});
-	}
-
-	aggregateCursor(pipeline: object[], options?: AggregateOptions): AggregationCursor {
-		let monitor = new MonitorMongo('aggregateCursor', this.collectionName, JSON.stringify([pipeline, options]));
-		let cursor = ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).aggregate(pipeline, options);
-		cursor.on('close', ev => {
-			monitor.finish();
-			return ev;
-		});
-
-		return cursor;
-	}
-
-	aggregateStream(pipeline: object[], options?: AggregateOptions, streamOptions?: CursorStreamOptions) {
-		let monitor = new MonitorMongo('aggregateStream', this.collectionName, JSON.stringify([pipeline, options, streamOptions]));
-		let stream = ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).aggregate(pipeline, options).stream(streamOptions);
-		stream.on('end', ev => {
-			monitor.finish();
-			return ev;
-		});
-
-		return stream;
-	}
-
-	// bulkWrite(operations: AnyBulkWriteOperation<T>[], options: BulkWriteOptions): Promise<BulkWriteResult> {
-	bulkWrite(operations: any[], options?: BulkWriteOptions): Promise<BulkWriteResult> {
-		return new Promise((resolve, reject) => {
-			let monitor = new MonitorMongo('bulkWrite', this.collectionName, JSON.stringify([operations.slice(-100), options]));
-			ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).bulkWrite(operations, options).then(res => {
-				monitor.finish();
-				resolve(res);
-			}, err => {
-				monitor.finish();
-				console.log(new Date(), 'Error Bulk Write', this.collectionName, operations.slice(-100), options, err);
-				reject(err);
-			});
-		});
-	}
-
-	countDocuments(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {}, options?: CountDocumentsOptions): Promise<number> {
-		return new Promise((resolve, reject) => {
-			let monitor = new MonitorMongo('countDocuments', this.collectionName, JSON.stringify([filter, options]));
-			ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).countDocuments(<any>filter, options).then(res => {
-				monitor.finish();
-				resolve(res);
-			}, err => {
-				monitor.finish();
-				console.log(new Date(), 'Error Count Documents', this.collectionName, filter, options, err);
-				reject(err);
-			});
-		});
-	}
-
-	//Helper Function (1 or Many) - Not Real Mongo Function
-	create(f_docs: T | T[], options?: InsertOneOptions | BulkWriteOptions): Promise<T | T[]> {
-		if (!Array.isArray(f_docs)) {
-			return this.insertOne(f_docs, <InsertOneOptions>options);
-		}
-		else if (f_docs.length === 1) {
-			return this.insertOne(f_docs[0], <InsertOneOptions>options);
-		}
-
-		return this.insertMany(f_docs, <BulkWriteOptions>options);
-	}
-
-	createIndex(fieldOrSpec: any, options?: CreateIndexesOptions): Promise<string> {
-		return new Promise((resolve, reject) => {
-			if (ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions)) {
-				let monitor = new MonitorMongo('createIndex', this.collectionName, JSON.stringify([fieldOrSpec, options]));
-				ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).createIndex(fieldOrSpec, options).then(res => {
-					monitor.finish();
-					resolve(res);
-				}, err => {
-					monitor.finish();
-					console.log(new Date(), 'Error Setting Up Index for Collection', this.collectionName, fieldOrSpec, options, err);
-					reject(err);
-				});
-			}
-		});
-	}
-
-	createIndexes(indexSpecs: IndexDescription[], options?: CreateIndexesOptions): Promise<string[]> {
-		return new Promise((resolve, reject) => {
-			if (ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions)) {
-				let monitor = new MonitorMongo('createIndexes', this.collectionName, JSON.stringify([indexSpecs, options]));
-				ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).createIndexes(indexSpecs, options).then(res => {
-					monitor.finish();
-					resolve(res);
-				}, err => {
-					monitor.finish();
-					console.log(new Date(), 'Error Setting Up Indexes for Collection', this.collectionName, indexSpecs, options, err);
-					reject(err);
-				});
-			}
-		});
-	}
-
-	deleteMany(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {}, options?: DeleteOptions, bypassLogs = false): Promise<number> {
-		return new Promise(async (resolve, reject) => {
-			if (this.createLogs && !bypassLogs) {
-				let docs = await this.find(filter);
-
-				for (let i = 0; i < docs.length; i++) {
-					let doc = docs[i];
-				
-					Logs.insertOne({
-						_id: objectIdHexString(),
-						type: 'document',
-						collection: this.collectionName,
-						id_document: doc._id,
-						payload: getBinarySize(JSON.stringify([doc, filter, options])) < 200000 ? JSON.stringify([doc, filter, options], null, 2) : 'Too Big',
-						method: 'deleteMany',
-						id_user: '',
-						user: '',
-						messageId: 0,
-						route: ''
-					});
-
-					if (this.useVersions) {
-						let versionDoc = deepCopy(doc);
-						versionDoc._id = {_id: doc._id, __v: doc.__v};
-
-						ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne(<any>{_id: { _id: doc._id, __v: doc.__v}}, versionDoc, {upsert: true});
-						ResolveIOServer.getMongoManager().collection(this.versionCollection).deleteMany(<any>{$and: [{'_id._id': doc._id}, {'_id.__v': {$lt: doc.__v - 1}}]});
-					}
-				}
-			}
-
-			let monitor = new MonitorMongo('deleteMany', this.collectionName, JSON.stringify([filter, options]));
-			ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).deleteMany(<any>filter, options).then(res => {
-				monitor.finish();
-				if (res.acknowledged) {
-					ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-					resolve(res.deletedCount);
-				}
-				else {
-					reject(res.acknowledged);
-				}
-			}, err => {
-				monitor.finish();
-				console.log(new Date(), 'Error Delete Many', this.collectionName, filter, options, err);
-				reject(err)
-			});
-		});
-	}
-
-	deleteOne(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {}, options?: FindOneAndDeleteOptions, bypassLogs = false): Promise<number> {
-		return new Promise(async (resolve, reject) => {
-			if (this.createLogs && !bypassLogs) {
-				let monitor = new MonitorMongo('findOneAndDelete', this.collectionName, JSON.stringify([filter, options]));
-				ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).findOneAndDelete(<any>filter, options).then(async returnVal => {
-					monitor.finish();
-					let doc = returnVal.value;
-
-					if (doc) {
-						if (this.createLogs && !bypassLogs) {
-							Logs.insertOne({
-								_id: objectIdHexString(),
-								type: 'document',
-								collection: this.collectionName,
-								id_document: doc._id,
-								payload: getBinarySize(JSON.stringify([doc, filter, options])) < 200000 ? JSON.stringify([doc, filter, options], null, 2) : 'Too Big',
-								method: 'deleteOne',
-								id_user: '',
-								user: '',
-								messageId: 0,
-								route: ''
-							});
-						}
-	
-						if (this.useVersions) {
-							let versionDoc = deepCopy(doc);
-							versionDoc._id = {_id: doc._id, __v: doc.__v};
-	
-							ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne(<any>{_id: { _id: doc._id, __v: doc.__v}}, versionDoc, {upsert: true});
-							ResolveIOServer.getMongoManager().collection(this.versionCollection).deleteMany(<any>{$and: [{'_id._id': doc._id}, {'_id.__v': {$lt: doc.__v - 1}}]});
-						}
-
-						ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-
-						resolve(1);
-					}
-					else {
-						resolve(0);
-					}
-				}, err => {
-					monitor.finish();
-					console.log(new Date(), 'Error Find One And Delete', this.collectionName, filter, options, err);
-					reject(err);
-				});
-			}
-			else {
-				let monitor = new MonitorMongo('deleteOne', this.collectionName, JSON.stringify([filter, options]));
-				ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).deleteOne(<any>filter, options).then(res => {
-					monitor.finish();
-					if (res.acknowledged) {
-						ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-						resolve(res.deletedCount);
-					}
-					else {
-						reject(res.acknowledged);
-					}
-				}, err => {
-					monitor.finish();
-					console.log(new Date(), 'Error Delete One', this.collectionName, filter, options, err);
-					reject(err);
-				});
-			}			
-		});
-	}
-
-	distinct(key: string, filter?: MongoManagerFilter<T> & MongoManagerFilterOperators<T>, options?: CommandOperationOptions): Promise<T[]> {
-		return new Promise((resolve, reject) => {
-			let monitor = new MonitorMongo('distinct', this.collectionName, JSON.stringify([key, filter, options]));
-			ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).distinct(key, <any>filter, options).then(res => {
-				monitor.finish();
-				resolve(res);
-			}, err => {
-				monitor.finish();
-				console.log(new Date(), 'Error Distinct', this.collectionName, filter, options, err);
-				reject(err);
-			});
-		});
-	}
-
-	drop(options?: CommandOperationOptions): Promise<boolean> {
-		return new Promise((resolve, reject) => {
-			let monitor = new MonitorMongo('drop', this.collectionName, JSON.stringify([options]));
-			ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).drop(options).then(res => {
-				monitor.finish();
-				resolve(res);
-			}, err => {
-				monitor.finish();
-				console.log(new Date(), 'Error Count Documents', this.collectionName, options, err);
-				reject(err);
-			});
-		});
-	}
-
-	dropIndex(indexName: string, options?: CommandOperationOptions): Promise<Document> {
-		return new Promise((resolve, reject) => {
-			let monitor = new MonitorMongo('dropIndex', this.collectionName, JSON.stringify([indexName, options]));
-			ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).dropIndex(indexName, options).then(res => {
-				monitor.finish();
-				resolve(<Document>res);
-			}, err => {
-				monitor.finish();
-				console.log(new Date(), 'Error Drop Index', this.collectionName, indexName, options, err);
-				reject(err);
-			});
-		});
-	}
-
-	dropIndexes(options?: CommandOperationOptions): Promise<Document> {
-		return new Promise((resolve, reject) => {
-			let monitor = new MonitorMongo('dropIndexes', this.collectionName, JSON.stringify([options]));
-			ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).dropIndexes(options).then(res => {
-				monitor.finish();
-				resolve(<Document>res);
-			}, err => {
-				monitor.finish();
-				console.log(new Date(), 'Error Drop Indexes', this.collectionName, options, err);
-				reject(err);
-			});
-		});
-	}
-
-	find(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {}, options?: FindOptions<T>, skipCache = false): Promise<T[]> {
-		return new Promise(async (resolve, reject) => {
-			if (!skipCache) {
-				ResolveIOServer.getMongoManager().addToQueue({
-					_id: 0,
-					name_collection: this.collectionName,
-					name_function: 'find',
-					name_function_addt: 'toArray',
-					data_function: [filter, options],
-					data_function_addt: [],
-					cbs: [(err, res, cached) => {					
-						if (err) {
-							reject(err);
-						}
-						else {
-							resolve(res);
-						}
-					}],
-					cbs_next: [],
-					running: false,
-					cacheId: 0,
-					lookup_collections: [],
-					invalidateFlag: false,
-					invalidateCount: 0
-				});
-			}
-			else {
-				let monitor = new MonitorMongo('find', this.collectionName, JSON.stringify([filter, options]));
-				ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).find<T>(<any>filter, options).toArray().then(res => {
-					monitor.finish();
-					resolve(res);
-				}, err => {
-					monitor.finish();
-					console.log(new Date(), 'Error Find', this.collectionName, filter, options, err);
-					reject(err);
-				});
-			}
-		});
-	}
-
-	findById(id: string, options?: FindOptions<T>): Promise<T> {
-		return new Promise((resolve, reject) => {
-			let monitor = new MonitorMongo('findById', this.collectionName, JSON.stringify([{_id: id}, options]));
-			ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).findOne<T>(<any>{_id: id}, options).then(res => {
-				monitor.finish();
-				resolve(res);
-			}, err => {
-				monitor.finish();
-				console.log(new Date(), 'Error Find By Id', this.collectionName, {_id: id}, options, err);
-				reject(err);
-			});
-		});
-	}
-
-	findCount(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {}, options?: FindOptions<T>): Promise<Number> {
-		return new Promise((resolve, reject) => {
-			let monitor = new MonitorMongo('findCount', this.collectionName, JSON.stringify([filter, options]));
-			ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).find(<any>filter, options).count().then(res => {
-				monitor.finish();
-				resolve(res);
-			}, err => {
-				monitor.finish();
-				console.log(new Date(), 'Error Find Count', this.collectionName, filter, options, err);
-				reject(err);
-			});
-		});
-	}
-
-	findCursor(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {}, options?: FindOptions<T>): FindCursor {
-		let monitor = new MonitorMongo('findCursor', this.collectionName, JSON.stringify([filter, options]));
-		let cursor = ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).find(<any>filter, options);
-		cursor.on('close', ev => {
-			monitor.finish();
-			return ev;
-		});
-		return cursor;
-	}
-
-	findStream(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {}, options?: FindOptions<T>, streamOptions?: CursorStreamOptions) {
-		let monitor = new MonitorMongo('findStream', this.collectionName, JSON.stringify([filter, options, streamOptions]));
-		let stream = ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).find(<any>filter, options).stream(streamOptions);
-		stream.on('end', ev => {
-			monitor.finish();
-			return ev;
-		});
-		return stream;
-	}
-
-	findOne(filter: MongoManagerFilter<T> | MongoManagerFilterOperators<T> = {}, options?: FindOptions<T>, skipCache = false): Promise<T> {
-		return new Promise((resolve, reject) => {
-			if (!skipCache) {
-				ResolveIOServer.getMongoManager().addToQueue({
-					_id: 0,
-					name_collection: this.collectionName,
-					name_function: 'findOne',
-					name_function_addt: '',
-					data_function: [filter, options],
-					data_function_addt: [],
-					cbs: [(err, res, cached) => {
-						if (err) {
-							reject(err);
-						}
-						else {
-							resolve(res);
-						}
-					}],
-					cbs_next: [],
-					running: false,
-					cacheId: 0,
-					lookup_collections: [],
-					invalidateFlag: false,
-					invalidateCount: 0
-				});
-			}
-			else {
-				let monitor = new MonitorMongo('findOne', this.collectionName, JSON.stringify([filter, options]));
-				ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).findOne<T>(<any>filter, options).then(res => {
-					monitor.finish();
-					resolve(res);
-				}, err => {
-					monitor.finish();
-					console.log(new Date(), 'Error Find One', this.collectionName, filter, options, err);
-					reject(err)
-				});
-			}
-		});
-	}
-
-	findOneAndDelete(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {}, options?: FindOneAndDeleteOptions, bypassLogs = false): Promise<T> {
-		return new Promise(async (resolve, reject) => {
-			let monitor = new MonitorMongo('findOneAndDelete', this.collectionName, JSON.stringify([filter, options]));
-			ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).findOneAndDelete(<any>filter, options).then(res => {
-				monitor.finish();
-				let doc = res.value;
-				
-				if (doc) {
-					if (this.createLogs && !bypassLogs) {
-						Logs.insertOne({
-							_id: objectIdHexString(),
-							type: 'document',
-							collection: this.collectionName,
-							id_document: doc._id,
-							payload: getBinarySize(JSON.stringify([doc, filter, options])) < 200000 ? JSON.stringify([doc, filter, options], null, 2) : 'Too Big',
-							method: 'findOneAndDelete',
-							id_user: '',
-							user: '',
-							messageId: 0,
-							route: ''
-						});
-					}
-
-					if (this.useVersions) {
-						let versionDoc = deepCopy(doc);
-						versionDoc._id = {_id: doc._id, __v: doc.__v};
-
-						ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne(<any>{_id: { _id: doc._id, __v: doc.__v}}, versionDoc, {upsert: true});
-					}
-
-					ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-
-					resolve(<T>doc);
-				}
-				else {
-					resolve(null);
-				}
-			}, err => {
-				monitor.finish();
-				console.log(new Date(), 'Error Find One And Delete', this.collectionName, filter, options, err);
-				reject(err)
-			});
-		});
-	}
-
-	findOneAndReplace(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {}, replacement: T, options?: FindOneAndReplaceOptions, bypassLogs = false, bypassCheckSchema = false): Promise<T> {
-		return new Promise(async (resolve, reject) => {
-			if (this.checkSchema && !bypassCheckSchema) {
-				const validation = this.simplschema.newContext();
-				const isValid = validation.validate(replacement);
-
-				if (!isValid) {
-					console.log(new Date(), this.collectionName, 'Schema Errors - findOneAndReplace', validation.validationErrors());
-					ResolveIOServer.getMainServer().getMethodManager().callMethodInternal.call(ResolveIOServer.getMainServer().getMethodManager(), 'insertErrorLog', 'Schema Failed on findOneAndReplace - ' + this.collectionName, [validation.validationErrors(), replacement]);
-					
-					reject(validation.validationErrors());
-					return;
-				}
-			}
-			
-			let date = new Date();
-
-			if (this.timestamps) {
-				replacement.updatedAt = date;
-			}
-
-			if (options && options.upsert) {
-				if (!replacement._id) {
-					replacement._id = objectIdHexString();
-				}
-
-				if (this.useVersions) {
-					replacement.__v = 0;
-				}
-
-				if (this.timestamps && !replacement.createdAt) {
-					replacement.createdAt = date;
-				}
-			}
-
-			let monitor = new MonitorMongo('findOneAndReplace', this.collectionName, JSON.stringify([filter, replacement, options]));
-			ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).findOneAndReplace(<any>filter, replacement, options).then(res => {
-				monitor.finish();
-				let doc = res.value
-
-				if (doc) {
-					if (this.createLogs && !bypassLogs) {
-						Logs.insertOne({
-							_id: objectIdHexString(),
-							type: 'document',
-							collection: this.collectionName,
-							id_document: doc._id,
-							payload: getBinarySize(JSON.stringify([doc, filter, replacement, options])) < 200000 ? JSON.stringify([doc, filter, replacement, options], null, 2) : 'Too Big',
-							method: 'findOneAndReplace',
-							id_user: '',
-							user: '',
-							messageId: 0,
-							route: ''
-						});
-					}
-
-					if (this.useVersions) {
-						let versionDoc = deepCopy(doc);
-						versionDoc._id = {_id: doc._id, __v: doc.__v};
-
-						ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne(<any>{_id: { _id: doc._id, __v: doc.__v}}, versionDoc, {upsert: true});
-					}
-
-					ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-
-					resolve(<T>doc);
-				}
-				else {
-					resolve(null);
-				}
-			}, err => {
-				monitor.finish();
-				console.log(new Date(), 'Error Find One And Replace', this.collectionName, filter, options, err);
-				reject(err)
-			});
-		});
-	}
-
-	findOneAndUpdate(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {}, update: MongoManagerUpdateFilter<T>, options?: FindOneAndUpdateOptions, bypassLogs = false, bypassCheckSchema = false): Promise<T> {
-		return new Promise(async (resolve, reject) => {
-			if (this.checkSchema && !bypassCheckSchema) {
-				const validation = this.simplschema.newContext();
-				const isValid = validation.validate(update, {modifier: true});
-
-				if (!isValid) {
-					console.log(new Date(), this.collectionName, 'Schema Errors - findOneAndUpdate', validation.validationErrors());
-					ResolveIOServer.getMainServer().getMethodManager().callMethodInternal.call(ResolveIOServer.getMainServer().getMethodManager(), 'insertErrorLog', 'Schema Failed on findOneAndUpdate - ' + this.collectionName, [validation.validationErrors(), update]);
-					reject(validation.validationErrors());
-					return;
-				}
-			}
-
-			if (this.timestamps) {
-				let date = new Date(); 
-				
-				if (!update.$set) {
-					update.$set = <any>{updatedAt: date};
-				}
-				else {
-					update.$set.updatedAt = date;
-				}
-			}
-
-			if (options && options.upsert) {
-				if (!update.$setOnInsert) {
-					if (this.timestamps) {
-						update.$setOnInsert = <any>{
-							_id: objectIdHexString(),
-							createdAt: new Date()
-						};
-					}
-					else {
-						update.$setOnInsert = <any>{
-							_id: objectIdHexString()
-						};
-					}
-				}
-				else {
-					if (!update.$setOnInsert._id) {
-						update.$setOnInsert._id = objectIdHexString();
-					}
-
-					if (this.timestamps) {
-						update.$setOnInsert.createdAt = new Date();
-					}
-				}
-			}
-
-			let monitor = new MonitorMongo('findOneAndUpdate', this.collectionName, JSON.stringify([filter, update, options]));
-			ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).findOneAndUpdate(<any>filter, <any>update, options).then(res => {
-				monitor.finish();
-				let doc = res.value;
-
-				if (doc) {
-					if (this.createLogs && !bypassLogs) {	
-						Logs.insertOne({
-							_id: objectIdHexString(),
-							type: 'document',
-							collection: this.collectionName,
-							id_document: doc._id,
-							payload: getBinarySize(JSON.stringify([doc, filter, update, options])) < 200000 ? JSON.stringify([doc, filter, update, options], null, 2) : 'Too Big',
-							method: 'findOneAndUpdate',
-							id_user: '',
-							user: '',
-							messageId: 0,
-							route: ''
-						});
-					}
-
-					if (this.useVersions) {
-						let versionDoc = deepCopy(doc);
-						versionDoc._id = {_id: doc._id, __v: doc.__v};
-
-						ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne(<any>{_id: { _id: doc._id, __v: doc.__v}}, versionDoc, {upsert: true});
-					}
-
-					ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-					
-					resolve(<T>doc);
-				}
-				else {
-					resolve(null);
-				}
-			}, err => {
-				monitor.finish();
-				console.log(new Date(), 'Error Find One And Update', this.collectionName, filter, options, err);
-				reject(err);
-			});
-		});
-	}
-
-	indexes(options: IndexInformationOptions): Promise<any[]> {
-		return new Promise((resolve, reject) => {
-			let monitor = new MonitorMongo('indexes', this.collectionName, JSON.stringify([options]));
-			ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).indexes(options).then(res => {
-				monitor.finish();
-				resolve(res);
-			}, err => {
-				monitor.finish();
-				console.log(new Date(), 'Error Indexes', this.collectionName, options, err);
-				reject(err);
-			});
-		});
-	}
-
-	indexExists(indexes: string | string[], options?: IndexInformationOptions): Promise<boolean> {
-		return new Promise((resolve, reject) => {
-			let monitor = new MonitorMongo('indexExists', this.collectionName, JSON.stringify([indexes, options]));
-			ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).indexExists(indexes, options).then(res => {
-				monitor.finish();
-				resolve(res);
-			}, err => {
-				monitor.finish();
-				console.log(new Date(), 'Error Index Exists', this.collectionName, indexes, options, err);
-				reject(err);
-			});
-		});
-	}
-
-	insertMany(docs: T[], options?: BulkWriteOptions, bypassLogs = false, bypassCheckSchema = false, bypassMonitor = false): Promise<T[]> {
-		return new Promise(async (resolve, reject) => {
-			if (!docs.length) {
-				resolve([]);
-				return;
-			}
-			
-			let validationResults = [];
-
-			if (this.checkSchema && !bypassCheckSchema) {
-				docs.forEach(doc => {
-					const validation = this.simplschema.newContext();
-					const isValid = validation.validate(doc);
-
-					if (!isValid) {
-						console.log(new Date(), this.collectionName, 'Schema Errors - insertMany', validation.validationErrors());
-						ResolveIOServer.getMainServer().getMethodManager().callMethodInternal.call(ResolveIOServer.getMainServer().getMethodManager(), 'insertErrorLog', 'Schema Failed on insertMany - ' + this.collectionName, [validation.validationErrors(), doc]);
-						validationResults.push(false);
-					}
-					else {
-						validationResults.push(true);
-					}
-				});
-			}
-
-			let validDocs = this.checkSchema ? docs.filter((a, idx) => validationResults[idx]) : docs;
-
-			for (let i = 0; i < validDocs.length; i++) {
-				let doc = validDocs[i];
-
-				if (!doc._id) {
-					doc._id = objectIdHexString();
-				}
-
-				if (this.timestamps) {
-					let date = new Date();
-					doc.createdAt = date;
-					doc.updatedAt = date;
-				}
-
-				if (this.createLogs && !bypassLogs) {
-					Logs.insertOne({
-						_id: objectIdHexString(),
-						type: 'document',
-						collection: this.collectionName,
-						id_document: doc._id,
-						payload: getBinarySize(JSON.stringify([doc, options])) < 200000 ? JSON.stringify([doc, options], null, 2) : 'Too Big',
-						method: 'insertMany',
-						id_user: '',
-						user: '',
-						messageId: 0,
-						route: ''
-					});
-				}
-			}
-
-			if (validDocs.length) {
-				let monitor = null;
-				
-				if (!bypassMonitor) {
-					monitor = new MonitorMongo('insertMany', this.collectionName, JSON.stringify([validDocs, options]));
-				}
-				ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).insertMany(<OptionalUnlessRequiredId<T>[]>validDocs, options).then(res => {
-					if (monitor) {
-						monitor.finish();
-					}
-					if (res.acknowledged) {
-						ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-						resolve(validDocs);
-					}
-					else {
-						reject(res.acknowledged);
-					}
-				}, err => {
-					if (monitor) {
-						monitor.finish();
-					}
-					console.log(new Date(), 'Error Insert Many', this.collectionName, validDocs, options, err);
-					reject(err);
-				});
-			}
-		});
-	}
-
-	insertOne(doc: T, options?: InsertOneOptions, bypassLogs = false, bypassCheckSchema = false): Promise<T> {
-		return new Promise(async (resolve, reject) => {
-			if (!doc._id) {
-				doc._id = objectIdHexString();
-			}
-
-			if (this.checkSchema && !bypassCheckSchema) {
-				const validation = this.simplschema.newContext();
-				const isValid = validation.validate(doc);
-
-				if (!isValid) {
-					console.log(new Date(), this.collectionName, 'Schema Errors - insertOne', validation.validationErrors());
-					ResolveIOServer.getMainServer().getMethodManager().callMethodInternal.call(ResolveIOServer.getMainServer().getMethodManager(), 'insertErrorLog', 'Schema Failed on insertOne - ' + this.collectionName, [validation.validationErrors(), doc]);
-					reject(validation.validationErrors());
-					return;
-				}
-			}
-
-			if (this.timestamps) {
-				let date = new Date();
-				doc.createdAt = date;
-				doc.updatedAt = date;
-			}
-
-			if (this.createLogs && !bypassLogs) {
-				Logs.insertOne({
-					_id: objectIdHexString(),
-					type: 'document',
-					collection: this.collectionName,
-					id_document: doc._id,
-					payload: getBinarySize(JSON.stringify([doc, options])) < 200000 ? JSON.stringify([doc, options], null, 2) : 'Too Big',
-					method: 'insertOne',
-					id_user: '',
-					user: '',
-					messageId: 0,
-					route: ''
-				});
-			}
-
-			if (this.useVersions && !doc.hasOwnProperty('__v')) {
-				doc.__v = 0;
-			}
-
-			let monitor = new MonitorMongo('insertOne', this.collectionName, JSON.stringify([doc, options]));
-			ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).insertOne(<OptionalUnlessRequiredId<T>>doc, options).then(res => {
-				monitor.finish();
-				if (res.acknowledged) {
-					ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-					resolve(doc);
-				}
-				else {
-					reject(res.acknowledged);
-				}
-			}, err => {
-				monitor.finish();
-				console.log(new Date(), 'Error Insert One', this.collectionName, doc, options, err);
-				reject(err);
-			});
-		});
-	}
-
-	listIndexes(options?: ListIndexesOptions): ListIndexesCursor {
-		let monitor = new MonitorMongo('listIndexes', this.collectionName, JSON.stringify([options]));
-		let cursor = ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).listIndexes(options);
-		cursor.on('close', ev => {
-			monitor.finish();
-			return ev;
-		});
-		return cursor;
-	}
-
-	rename(newName: string, options?: RenameOptions): Promise<Collection<Document>> {
-		return new Promise((resolve, reject) => {
-			let monitor = new MonitorMongo('rename', this.collectionName, JSON.stringify([newName, options]));
-			ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).rename(newName, options).then(res => {
-				monitor.finish();
-				resolve(res);
-			}, err => {
-				monitor.finish();
-				console.log(new Date(), 'Error Rename', this.collectionName, newName, options, err);
-				reject(err);
-			});
-		});
-	}
-
-	replaceOne(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T>, replacement: T, options?: ReplaceOptions, bypassLogs = false, bypassCheckSchema = false, doc: T = null) : Promise<number> {
-		return new Promise(async (resolve, reject) => {
-			if (this.checkSchema && !bypassCheckSchema) {
-				const validation = this.simplschema.newContext();
-				const isValid = validation.validate(replacement);
-
-				if (!isValid) {
-					console.log(new Date(), this.collectionName, 'Schema Errors - replaceOne', validation.validationErrors());
-					ResolveIOServer.getMainServer().getMethodManager().callMethodInternal.call(ResolveIOServer.getMainServer().getMethodManager(), 'insertErrorLog', 'Schema Failed on replaceOne - ' + this.collectionName, [validation.validationErrors(), replacement]);
-					reject(validation.validationErrors());
-					return;
-				}
-			}
-			
-			let date = new Date();
-			
-			if (this.timestamps) {
-				replacement.updatedAt = date;
-			}
-
-			if (this.useVersions) {
-				if (!doc) {
-					doc = await this.findOne(<any>filter, null, true);
-				}
-
-				if (doc) {
-					if (this.timestamps && !replacement.createdAt && doc.createdAt) {
-						replacement.createdAt = doc.createdAt;
-					}
-
-					if (doc.__v === replacement.__v) {
-						replacement.__v += 1;
-
-						let versionDoc = deepCopy(doc);
-						versionDoc._id = {_id: doc._id, __v: doc.__v};
-
-						ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne(<any>{_id: { _id: doc._id, __v: doc.__v}}, versionDoc, {upsert: true});
-
-						if (doc.__v >= 4) {
-							ResolveIOServer.getMongoManager().collection(this.versionCollection).deleteMany(<any>{$and: [{'_id._id': doc._id}, {'_id.__v': {$lt: doc.__v - 4}}]});
-						}
-
-						if (this.createLogs && !bypassLogs) {
-							Logs.insertOne({
-								_id: objectIdHexString(),
-								type: 'document',
-								collection: this.collectionName,
-								id_document: doc._id,
-								payload: getBinarySize(JSON.stringify([doc, filter, replacement, options])) < 200000 ? JSON.stringify([doc, filter, replacement, options], null, 2) : 'Too Big',
-								method: 'replaceOne',
-								id_user: '',
-								user: '',
-								messageId: 0,
-								route: ''
-							});
-						}
-						
-						let monitor = new MonitorMongo('replaceOne', this.collectionName, JSON.stringify([filter, replacement, options]));
-						ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).replaceOne(<any>filter, replacement, options).then(res => {
-							monitor.finish();
-							if (res.acknowledged) {
-								ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-								resolve(res.modifiedCount);
-							}
-							else {
-								reject(res.acknowledged);
-							}
-						}, err => {
-							monitor.finish();
-							console.log(new Date(), 'Error Replace One', this.collectionName, filter, replacement, options, err);
-							reject(err);
-						});
-					}
-					else {
-						console.log('invalid version - ' + this.collectionName, doc.__v, replacement.__v);
-
-						let prevDoc = await ResolveIOServer.getMongoManager().collection(this.versionCollection).findOne({
-							_id: <any>{
-								_id: doc._id,
-								__v: replacement.__v
-							}
-						}, null, true);
-
-						if (prevDoc) {
-							let docId = doc._id;
-							let docVersion = doc.__v;
-							let updatedDoc: T = getMongoMergeUpdatedDoc(replacement, doc, prevDoc);
-							updatedDoc._id = docId;
-							updatedDoc.__v = docVersion + 1;
-
-							if (this.createLogs && !bypassLogs) {
-								Logs.insertOne({
-									_id: objectIdHexString(),
-									type: 'document',
-									collection: this.collectionName,
-									id_document: docId,
-									payload: getBinarySize(JSON.stringify(['invalidVersion - merge', doc, filter, updatedDoc, options])) < 200000 ? JSON.stringify(['invalidVersion - merge', doc, filter, updatedDoc, options], null, 2) : 'Too Big',
-									method: 'replaceOne',
-									id_user: '',
-									user: '',
-									messageId: 0,
-									route: ''
-								});
-							}
-
-							let monitor = new MonitorMongo('replaceOne', this.collectionName, JSON.stringify([filter, updatedDoc, options]));
-							ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).replaceOne(<any>filter, updatedDoc, options).then(res => {
-								monitor.finish();
-								if (res.acknowledged) {
-									ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-									resolve(res.modifiedCount);
-								}
-								else {
-									reject(res.acknowledged);
-								}
-							}, err => {
-								monitor.finish();
-								console.log(new Date(), 'Error Replace One', this.collectionName, filter, updatedDoc, options, err);
-								reject(err);
-							});
-						}
-						else {
-							reject('Invalid Version And Could Not Find History - DB: ' + doc.__v + ', Trying to update with :' + replacement.__v);
-						}
-					}
-				}
-				else if (options && options.upsert) {
-					if (this.timestamps) {
-						replacement.createdAt = date;
-					}
-
-					if (!replacement._id) {
-						replacement._id = objectIdHexString();
-					}
-
-					replacement.__v = 0;
-
-					if (this.createLogs && !bypassLogs) {
-						Logs.insertOne({
-							_id: objectIdHexString(),
-							type: 'document',
-							collection: this.collectionName,
-							id_document: replacement._id,
-							payload: getBinarySize(JSON.stringify(['upsert', filter, replacement, options])) < 200000 ? JSON.stringify(['upsert', filter, replacement, options], null, 2) : 'Too Big',
-							method: 'replaceOne',
-							id_user: '',
-							user: '',
-							messageId: 0,
-							route: ''
-						});
-					}
-					
-					let monitor = new MonitorMongo('replaceOne', this.collectionName, JSON.stringify([filter, replacement, options]));
-					ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).replaceOne(<any>filter, replacement, options).then(res => {
-						monitor.finish();
-						if (res.acknowledged) {
-							ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-							resolve(res.modifiedCount);
-						}
-						else {
-							reject(res.acknowledged);
-						}
-					}, err => {
-						monitor.finish();
-						console.log(new Date(), 'Error Replace One', this.collectionName, filter, replacement, options, err);
-						reject(err);
-					});
-				}
-				else {
-					reject('No Document');
-				}
-			}
-			else {
-				if (options && options.upsert) {
-					if (this.timestamps && !replacement.createdAt) {
-						replacement.createdAt = date;
-					}
-
-					if (!replacement._id) {
-						replacement._id = objectIdHexString();
-					}
-
-					replacement.__v = 0;
-				}
-
-				if (this.createLogs && !bypassLogs) {
-					if (!options) {
-						options = <FindOneAndReplaceOptions>{returnDocument: 'before'};
-					}
-					else {
-						(<FindOneAndReplaceOptions>options).returnDocument = 'before';
-					}
-
-					let monitor = new MonitorMongo('findOneAndReplace', this.collectionName, JSON.stringify([filter, replacement, options]));
-					ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).findOneAndReplace(<any>filter, replacement, <FindOneAndReplaceOptions>options).then(res => {
-						monitor.finish();
-						let doc = res.value;
-
-						if (doc) {
-							Logs.insertOne({
-								_id: objectIdHexString(),
-								type: 'document',
-								collection: this.collectionName,
-								id_document: doc._id,
-								payload: getBinarySize(JSON.stringify([doc, filter, replacement, options])) < 200000 ? JSON.stringify([doc, filter, replacement, options], null, 2) : 'Too Big',
-								method: 'replaceOne',
-								id_user: '',
-								user: '',
-								messageId: 0,
-								route: ''
-							});
-						}
-						else {
-							Logs.insertOne({
-								_id: objectIdHexString(),
-								type: 'document',
-								collection: this.collectionName,
-								id_document: replacement._id,
-								payload: getBinarySize(JSON.stringify(['upsert', filter, replacement, options])) < 200000 ? JSON.stringify(['upsert', filter, replacement, options], null, 2) : 'Too Big',
-								method: 'replaceOne',
-								id_user: '',
-								user: '',
-								messageId: 0,
-								route: ''
-							});
-						}
-
-						ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-						resolve(res.ok);
-					}, err => {
-						monitor.finish();
-						console.log(new Date(), 'Error Find One And Replace', this.collectionName, filter, replacement, options, err);
-						reject(err);
-					});
-				}
-				else {
-					let monitor = new MonitorMongo('replaceOne', this.collectionName, JSON.stringify([filter, replacement, options]));
-					ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).replaceOne(<any>filter, replacement, options).then(res => {
-						monitor.finish();
-						if (res.acknowledged) {
-							ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-							resolve(res.modifiedCount);
-						}
-						else {
-							reject(res.acknowledged);
-						}
-					}, err => {
-						monitor.finish();
-						console.log(new Date(), 'Error Replace One', this.collectionName, filter, replacement, options, err);
-						reject(err);
-					});
-				}
-			}
-		});
-	}
-
-	stats(options?: CollStatsOptions): Promise<CollStats> {
-		return new Promise((resolve, reject) => {
-			let monitor = new MonitorMongo('stats', this.collectionName, JSON.stringify([options]));
-			ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).stats(options).then(res => {
-				monitor.finish();
-				resolve(res);
-			}, err => {
-				monitor.finish();
-				console.log(new Date(), 'Error Stats', this.collectionName, options, err);
-				reject(err);
-			});
-		});
-	}
-
-	updateMany(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T>, update: MongoManagerUpdateFilter<T>, options?: UpdateOptions, bypassLogs = false, bypassCheckSchema = false, bypassVersions = false) : Promise<number> {
-		return new Promise(async (resolve, reject) => {
-			if ((!update.$inc || JSON.stringify(update.$inc) === '{}') && (!update.$set || JSON.stringify(update.$set) === '{}') && (!update.$setOnInsert || JSON.stringify(update.$setOnInsert) === '{}') && (!update.$unset || JSON.stringify(update.$unset) === '{}')) {
-				resolve(1);
-				return;
-			}
-			
-			if (this.timestamps) {
-				let date = new Date();
-
-				if (!update.$set) {
-					update.$set = <any>{updatedAt: date};
-				}
-				else {
-					update.$set.updatedAt = date;
-				}
-			}
-
-			if (this.checkSchema && !bypassCheckSchema) {
-				const validation = this.simplschema.newContext();
-				const isValid = validation.validate(update, {modifier: true});
-
-				if (!isValid) {
-					console.log(new Date(), this.collectionName, 'Schema Errors - updateMany', validation.validationErrors());
-					ResolveIOServer.getMainServer().getMethodManager().callMethodInternal.call(ResolveIOServer.getMainServer().getMethodManager(), 'insertErrorLog', 'Schema Failed on updateMany - ' + this.collectionName, [validation.validationErrors(), update]);
-					reject(validation.validationErrors());
-					return;
-				}
-			}
-
-			if ((this.useVersions && !bypassVersions) || (this.createLogs && !bypassLogs)) {
-				let docs = await this.find(filter);
-	
-				for (let i = 0; i < docs.length; i++) {
-					let doc = docs[i];
-
-					if (this.createLogs && !bypassLogs) {
-						Logs.insertOne({
-							_id: objectIdHexString(),
-							type: 'document',
-							collection: this.collectionName,
-							id_document: doc._id,
-							payload: getBinarySize(JSON.stringify([doc, filter, update, options])) < 200000 ? JSON.stringify([doc, filter, update, options], null, 2) : 'Too Big',
-							method: 'updateMany',
-							id_user: '',
-							user: '',
-							messageId: 0,
-							route: ''
-						});
-					}
-
-					if (this.useVersions) {
-						let versionDoc = deepCopy(doc);
-						versionDoc._id = {_id: doc._id, __v: doc.__v};
-		
-						ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne(<any>{_id: { _id: doc._id, __v: doc.__v}}, versionDoc, {upsert: true});
-						
-						if (doc.__v >= 4) {
-							ResolveIOServer.getMongoManager().collection(this.versionCollection).deleteMany(<any>{$and: [{'_id._id': doc._id}, {'_id.__v': {$lt: doc.__v - 4}}]});
-						}
-		
-						if (!objectContainsPropertyDeep(update, '__v')) {
-							if (!update.$inc) {
-								update.$inc = {__v: 1};
-							}
-							else if (!update.$inc.__v) {
-								update.$inc.__v = 1;
-							}
-						}
-					}
-				}
-			}
-
-			let monitor = new MonitorMongo('updateMany', this.collectionName, JSON.stringify([filter, update, options]));
-			ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).updateMany(<any>filter, update, options).then(res => {
-				monitor.finish();
-				if (res.acknowledged) {
-					ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-					resolve(res.modifiedCount);
-				}
-				else {
-					reject(res.acknowledged);
-				}
-			}, err => {
-				monitor.finish();
-				console.log(new Date(), 'Error Update Many', this.collectionName, filter, update, options, err);
-				reject(err)
-			});
-		});
-	}
-
-	updateOne(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T>, update: MongoManagerUpdateFilter<T>, options?: UpdateOptions, bypassLogs = false, bypassCheckSchema = false) : Promise<number> {
-		return new Promise(async (resolve, reject) => {
-			if (this.checkSchema && !bypassCheckSchema) {
-				const validation = this.simplschema.newContext();			
-				const isValid = validation.validate(update, {modifier: true});
-
-				if (!isValid) {
-					console.log(new Date(), this.collectionName, 'Schema Errors - updateOne', validation.validationErrors());
-					ResolveIOServer.getMainServer().getMethodManager().callMethodInternal.call(ResolveIOServer.getMainServer().getMethodManager(), 'insertErrorLog', 'Schema Failed on updateOne - ' + this.collectionName, [validation.validationErrors(), update]);
-					reject(validation.validationErrors());
-					return;
-				}
-			}
-
-			if ((!update.$inc || JSON.stringify(update.$inc) === '{}') && (!update.$set || JSON.stringify(update.$set) === '{}') && (!update.$setOnInsert || JSON.stringify(update.$setOnInsert) === '{}') && (!update.$unset || JSON.stringify(update.$unset) === '{}')) {
-				resolve(1);
-				return;
-			}
-
-			let date = new Date();
-
-			if (this.timestamps) {
-				if (!update.$set) {
-					update.$set = <any>{updatedAt: date};
-				}
-				else {
-					update.$set.updatedAt = date;
-				}
-			}
-			
-			if (this.useVersions) {
-				let doc = await this.findOne(filter, null, true);
-
-				if (doc) {
-					if (this.createLogs && !bypassLogs) {
-						Logs.insertOne({
-							_id: objectIdHexString(),
-							type: 'document',
-							collection: this.collectionName,
-							id_document: doc._id,
-							payload: getBinarySize(JSON.stringify([doc, filter, update, options])) < 200000 ? JSON.stringify([doc, filter, update, options], null, 2) : 'Too Big',
-							method: 'updateOne',
-							id_user: '',
-							user: '',
-							messageId: 0,
-							route: ''
-						});
-					}
-
-					let versionDoc = deepCopy(doc);
-					versionDoc._id = {_id: doc._id, __v: doc.__v};
-	
-					ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne(<any>{_id: { _id: doc._id, __v: doc.__v}}, versionDoc, {upsert: true});
-					
-					if (doc.__v >= 4) {
-						ResolveIOServer.getMongoManager().collection(this.versionCollection).deleteMany(<any>{$and: [{'_id._id': doc._id}, {'_id.__v': {$lt: doc.__v - 4}}]});
-					}
-	
-					if (!objectContainsPropertyDeep(update, '__v')) {
-						if (!update.$inc) {
-							update.$inc = {__v: 1};
-						}
-						else if (!update.$inc.__v) {
-							update.$inc.__v = 1;
-						}
-					}
-					
-					let monitor = new MonitorMongo('updateOne', this.collectionName, JSON.stringify([filter, update, options]));
-					ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).updateOne(<any>filter, update, options).then(res => {
-						monitor.finish();
-						if (res.acknowledged) {
-							ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-							resolve(res.modifiedCount);
-						}
-						else {
-							reject(res.acknowledged);
-						}
-					}, err => {
-						monitor.finish();
-						console.log(new Date(), 'Error Update One', this.collectionName, filter, update, options, err);
-						reject(err);
-					});
-				}
-				else if (options && options.upsert) {
-					if (!update.$setOnInsert) {
-						if (this.timestamps) {
-							update.$setOnInsert = <any>{
-								_id: objectIdHexString(),
-								__v: 0,
-								createdAt: new Date()
-							};
-						}
-						else {
-							update.$setOnInsert = <any>{
-								_id: objectIdHexString(),
-								__v: 0
-							};
-						}
-					}
-					else {
-						if (!update.$setOnInsert._id) {
-							update.$setOnInsert._id = objectIdHexString();
-						}
-	
-						if (this.timestamps) {
-							update.$setOnInsert.createdAt = new Date();
-						}
-					}
-	
-					if (this.createLogs && !bypassLogs) {
-						Logs.insertOne({
-							_id: objectIdHexString(),
-							type: 'document',
-							collection: this.collectionName,
-							id_document: update.$setOnInsert._id,
-							payload: getBinarySize(JSON.stringify(['upsert', filter, update, options])) < 200000 ? JSON.stringify(['upsert', filter, update, options], null, 2) : 'Too Big',
-							method: 'updateOne',
-							id_user: '',
-							user: '',
-							messageId: 0,
-							route: ''
-						});
-					}
-					
-					let monitor = new MonitorMongo('updateOne', this.collectionName, JSON.stringify([filter, update, options]));
-					ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).updateOne(<any>filter, update, options).then(res => {
-						monitor.finish();
-						if (res.acknowledged) {
-							ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-							resolve(res.modifiedCount);
-						}
-						else {
-							reject(res.acknowledged);
-						}
-					}, err => {
-						monitor.finish();
-						console.log(new Date(), 'Error Update One', this.collectionName, filter, update, options, err);
-						reject(err);
-					});
-				}
-				else {
-					reject('No Document');
-				}
-			}
-			else {
-				if (options && options.upsert) {
-					if (!update.$setOnInsert) {
-						if (this.timestamps) {
-							update.$setOnInsert = <any>{
-								_id: objectIdHexString(),
-								createdAt: new Date()
-							};
-						}
-						else {
-							update.$setOnInsert = <any>{
-								_id: objectIdHexString()
-							};
-						}
-					}
-					else {
-						if (!update.$setOnInsert._id) {
-							update.$setOnInsert._id = objectIdHexString();
-						}
-	
-						if (this.timestamps) {
-							update.$setOnInsert.createdAt = new Date();
-						}
-					}
-				}
-
-				if (this.createLogs && !bypassLogs) {
-					if (!options) {
-						options = <FindOneAndUpdateOptions>{returnDocument: 'before'};
-					}
-					else {
-						(<FindOneAndUpdateOptions>options).returnDocument = 'before';
-					}
-
-					let monitor = new MonitorMongo('findOneAndUpdate', this.collectionName, JSON.stringify([filter, update, options]));
-					ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).findOneAndUpdate(<any>filter, update, <FindOneAndUpdateOptions>options).then(res => {
-						monitor.finish();
-						let doc = res.value;
-
-						if (doc) {
-							Logs.insertOne({
-								_id: objectIdHexString(),
-								type: 'document',
-								collection: this.collectionName,
-								id_document: <any>doc._id,
-								payload: getBinarySize(JSON.stringify([doc, filter, update, options])) < 200000 ? JSON.stringify([doc, filter, update, options], null, 2) : 'Too Big',
-								method: 'updateOne',
-								id_user: '',
-								user: '',
-								messageId: 0,
-								route: ''
-							});
-
-							resolve(res.ok);
-						}
-						else if (update.$setOnInsert) {
-							Logs.insertOne({
-								_id: objectIdHexString(),
-								type: 'document',
-								collection: this.collectionName,
-								id_document: update.$setOnInsert._id,
-								payload: getBinarySize(JSON.stringify(['upsert', filter, update, options])) < 200000 ? JSON.stringify(['upsert', filter, update, options], null, 2) : 'Too Big',
-								method: 'updateOne',
-								id_user: '',
-								user: '',
-								messageId: 0,
-								route: ''
-							});
-
-							ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-
-							resolve(res.ok);
-						}
-						else {
-							resolve(0);
-						}
-					}, err => {
-						monitor.finish();
-						console.log(new Date(), 'Error Find One And Update', this.collectionName, filter, update, options, err);
-						reject(err)
-					});
-				}
-				else {
-					let monitor = new MonitorMongo('updateOne', this.collectionName, JSON.stringify([filter, update, options]));
-					ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).updateOne(<any>filter, update, options).then(res => {
-						monitor.finish();
-						if (res.acknowledged) {
-							ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-							resolve(res.modifiedCount);
-						}
-						else {
-							reject(res.acknowledged);
-						}
-					}, err => {
-						monitor.finish();
-						console.log(new Date(), 'Error Update One', this.collectionName, filter, update, options, err);
-						reject(err);
-					});
-				}
-			}
-		});
-	}
-	
-	watchCollection(pipeline = [], options?: ChangeStreamOptions): ChangeStream<T> {
-		let stream = ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).watch(pipeline, options);
-		stream.on('change', evData => {
-			ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-			return evData;
-		});
-		return <ChangeStream<T>>stream;
-	}
-
-	watchCollectionWithAggregate(pipeline = [], options?: ChangeStreamOptions): ChangeStream<T> {
-		let stream = ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).watch(pipeline, options);
-		stream.on('change', evData => {
-			ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
-			return evData;
-		});
-		return <ChangeStream<T>>stream;
-	}
-}
-
-export class MongoManagerUserCollection<T extends CollectionDocument> extends MongoManagerCollection<T> {
-	authenticateStrategy() {
-		return async (username, password, cb) => {
-			let user = await Users.findOne({username: username});
-			this.authenticate(user, password).then(authUser => {
-				if (authUser.data) {
-					cb(null, user, null);
-				}
-				else {
-					cb(null, null, authUser.error);
-				}
-			}, err => {
-				cb(err, null, null);
-			})
-		};
-	}
-
-	authenticate(user: UserModel, password: string): Promise<{data: UserModel, error: string}> {
-		return new Promise(async (resolve, reject) => {
-			const attemptsInterval = Math.pow(100, Math.log(user.attempts + 1));
-			const calculatedInterval = attemptsInterval < 300000 ? attemptsInterval : 300000;
-		
-			if (user.last) {
-				if (Date.now() - user.last.getTime() < calculatedInterval) {
-					user.last = new Date();
-					await Users.updateOne({_id: user._id}, {$set: {last: user.last}});
-					resolve({
-						data: null,
-						error: 'Attempt Too Soon'
-					});
-
-					return;
-				}
-			}
-			else {
-				user.last = new Date();
-			}
-		
-			if (user.attempts >= 5) {
-				resolve({
-					data: null,
-					error: 'Too Many Attempts'
-				});
-
-				return;
-			}
-			
-			if (!user.salt) {
-				resolve({
-					data: null,
-					error: 'No Salt Value Stored'
-				});
-
-				return;
-			}
-			
-			pbkdf2(password, user.salt, {
-				iterations: 25000,
-				keylen: 512,
-				digestAlgorithm: 'sha256'
-			}, async (err, hashBuffer) => {
-				if (err) {
-					return reject(err);
-				}
-			
-				if (scmp(hashBuffer, Buffer.from(user.hash, 'hex'))) {
-					user.last = new Date();
-					user.attempts = 0;
-					await Users.updateOne({_id: user._id}, {$set: {last: user.last, attempts: user.attempts}});
-
-					resolve({
-						data: user,
-						error: ''
-					});
-				}
-				else {
-					user.last = new Date();
-					user.attempts = user.attempts + 1;
-					await Users.updateOne({_id: user._id}, {$set: {last: user.last, attempts: user.attempts}});
-
-					if (user.attempts >= 5) {
-						resolve({
-							data: null,
-							error: 'Too Many Attempts'
-						});
-					}
-					else {
-						resolve({
-							data: null,
-							error: 'Invalid Username And Password'
-						});
-					}
-				} 
-			});
-		});
-	}
-
-	serializeUser() {
-		return (user, cb) => {
-			cb(null, user.username);
-		};
-	}
-
-	deserializeUser() {
-		return (username, cb) => {
-			Users.findOne({username: username}).then(res => {
-				cb(null, res);
-			}, err => {
-				cb(err, null);
-			});
-		};
-	}
-
-	setPassword(user: UserModel, password: string) {
-		return new Promise(async (resolve, reject) => {
-			if (!user) {
-				reject('No User');
-			}
-			else if (!password) {
-				reject('No Password');
-			}
-			else {
-				let saltBuffer = await randomBytes(32);
-				let salt = saltBuffer.toString('hex');
-				let hashRaw = await pbkdf2Promisified(password, salt, {
-					iterations: 25000,
-					keylen: 512,
-					digestAlgorithm: 'sha256'
-				});
-				let hash = Buffer.from(hashRaw, 'binary').toString('hex');
-				Users.updateOne({_id: user._id}, {$set: {hash: hash, salt: salt, services: {}, attempts: 0}}).then(res => resolve(res), rej => reject(rej));
-			}
-		});
-	};
-
-	changePassword(user, oldPassword, newPassword) {
-		return new Promise(async (resolve, reject) => {
-			if (!user) {
-				reject('Missing User');
-			}
-			else if (!oldPassword || !newPassword) {
-				reject('Missing Password');
-			}
-			else {
-				let authUser = await this.authenticate(user, oldPassword);
-
-				if (!authUser['data']) {
-					reject(authUser['error']);
-				}
-				else {
-					this.setPassword(user, newPassword).then(res => resolve(res), rej => reject(rej));
-				}
-			}
-		});
-	}
-	
-	register(user, password) {
-		return new Promise(async (resolve, reject) => {
-			if (!user.username) {
-				reject('Missing Username');
-			}
-			else {
-				let dbUser = await Users.findOne({username: user.username});
-				
-				if (dbUser) {
-					reject('Username Exists');
-				}
-				else {
-					dbUser = await Users.findOne({email: user.email});
-
-					if (dbUser) {
-						reject('Email Exists');
-					}
-					else {
-						user.setPassword(password);
-						resolve(user);
-					}
-				}
-			}
-		});
-	}
-
-	resetAttempts(user: UserModel) {
-		return Users.updateOne({_id: user._id}, {$set: {attempts: 0}});
-	}
-}
-
-export function objectIdHexString() {
-	let objectId = new ObjectId();
-	return objectId.toHexString();
-}
-
-function pbkdf2(password, salt, options, callback) {
-	crypto.pbkdf2(password, salt, options.iterations, options.keylen, options.digestAlgorithm, callback);
-};
-
-function pbkdf2Promisified(password, salt, options): Promise<any> {
-	return new Promise((resolve, reject) => pbkdf2(password, salt, options, (err, hashRaw) => (err ? reject(err) : resolve(hashRaw))));
-}
-
-function randomBytes(saltlen): Promise<Buffer> {
-	return new Promise((resolve, reject) => crypto.randomBytes(saltlen, (err, saltBuffer) => (err ? reject(err) : resolve(saltBuffer))));
-}
-
-function objectContainsPropertyDeep(obj: Object, prop: string) {
-	let keys = Object.keys(obj);
-
-	if (keys.some(a => a === prop)) {
-		return true;
-	}
-	
-	for (let i = 0; i < keys.length; i++) {
-		let key = keys[i];
-		if (obj[key] && typeof obj[key] === 'object' && objectContainsPropertyDeep(obj[key], prop)) {
-			return true;
-		}
-	}
-
-	return false;
-}