@resolveio/server-lib 12.5.53 → 12.5.54

package/src/managers/mongo.manager.ts

@@ -0,0 +1,2282 @@
+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;
+}