@resolveio/server-lib 22.3.219 → 22.3.221

package/src/managers/mongo.manager.ts

@@ -0,0 +1,4575 @@
+import { AggregateOptions, AggregationCursor, BulkWriteOptions, BulkWriteResult, ChangeStream, ChangeStreamOptions, Collection, CollectionInfo, CommandOperationOptions, CountDocumentsOptions, CreateCollectionOptions, CreateIndexesOptions, DeleteOptions, DeleteResult, FindCursor, FindOneAndDeleteOptions, FindOneAndReplaceOptions, FindOneAndUpdateOptions, FindOptions, IndexDescription, IndexDescriptionCompact, IndexInformationOptions, InsertOneOptions, ListIndexesCursor, ListIndexesOptions, OptionalUnlessRequiredId, RenameOptions, ReplaceOptions, UpdateOptions, UpdateResult } from 'mongodb';
+import * as NodeCache from 'node-cache';
+import SimpleSchema from 'simpl-schema';
+import { Users } from '../collections/user.collection';
+import { CollectionDocument, Document } from '../models/collection-document.model';
+import { LookupTables } from '../models/report-builder.model';
+import { UserModel } from '../models/user.model';
+import { ResolveIOServer } from '../resolveio-server-app';
+import { buildRbLookups, buildRbSchema, dateReviver, deepCopy, getBinarySize, getMongoMergeUpdatedDoc, objectIdHexString } from '../util/common';
+import { saveCustomerPortalPassword } from '../util/customer-portal-password';
+import { SlowQueryReporter } from '../util/slow-query-reporter';
+import { getPublicationContext, QueryMeta, recordAggregateDependencies, recordDependencyResult } from '../util/subscription-dependency-context';
+import { MonitorMongo } from './monitor.manager';
+const crypto = require('crypto');
+const scmp = require('scmp');
+const v8 = require('v8');
+const { AsyncLocalStorage } = require('async_hooks');
+const asyncLocalStorage = new AsyncLocalStorage();
+
+function resolveHeapLimitBytes(): number {
+	const stats = v8.getHeapStatistics();
+	if (stats && typeof stats.heap_size_limit === 'number') {
+		return stats.heap_size_limit;
+	}
+
+	if (stats && typeof stats.total_available_size === 'number') {
+		return stats.total_available_size;
+	}
+
+	return 0;
+}
+
+function buildQueryMetaFromFindOptions(options?: FindOptions): QueryMeta {
+	if (!options) {
+		return null;
+	}
+
+	const meta: QueryMeta = {};
+
+	if (typeof options.limit === 'number') {
+		meta.limit = options.limit;
+	}
+
+	if (typeof options.skip === 'number') {
+		meta.skip = options.skip;
+	}
+
+	if (options.sort) {
+		meta.sort = deepCopy(options.sort);
+	}
+
+	return Object.keys(meta).length ? meta : null;
+}
+
+type MongoManagerFindOptions = FindOptions;
+
+function stripManagedVersionFields(update: any): void {
+	if (!update) {
+		return;
+	}
+
+	for (const operator of ['$set', '$setOnInsert']) {
+		const modifier = update[operator];
+		if (modifier && typeof modifier === 'object' && '__v' in modifier) {
+			delete modifier.__v;
+			if (Object.keys(modifier).length === 0) {
+				delete update[operator];
+			}
+		}
+	}
+}
+
+// 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;
+	};
+	// eslint-disable-next-line no-unused-vars
+	$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> = {
+	// eslint-disable-next-line no-unused-vars
+	[P in keyof T]?: number | boolean;
+};
+
+export declare type MongoManagerIncFilter<T> = {
+	// eslint-disable-next-line no-unused-vars
+	[P in keyof T]?: number;
+};
+
+export declare type MongoManagerRenameFilter<T> = {
+	// eslint-disable-next-line no-unused-vars
+	[P in keyof T]?: string;
+};
+
+export declare type MongoManagerArrayFilter<T> = {
+	// eslint-disable-next-line no-unused-vars
+	[P in keyof T]?: any; // can refine if needed
+};
+
+export declare type MongoManagerCurrentDateFilter<T> = {
+	// eslint-disable-next-line no-unused-vars
+	[P in keyof T]?: true | { $type: 'date' | 'timestamp' };
+};
+
+export declare type MongoManagerUpdateFilter<T> = {
+	$set?: MongoManagerFilter<T> | Document;
+	$unset?: MongoManagerUnsetFilter<T> | Document;
+	$inc?: MongoManagerIncFilter<T> | Document;
+	$setOnInsert?: MongoManagerFilter<T> | Document;
+	$push?: MongoManagerArrayFilter<T> | Document;
+	$pull?: MongoManagerArrayFilter<T> | Document;
+	$addToSet?: MongoManagerArrayFilter<T> | Document;
+	$min?: MongoManagerIncFilter<T> | Document;
+	$max?: MongoManagerIncFilter<T> | Document;
+	$currentDate?: MongoManagerCurrentDateFilter<T> | Document;
+	$mul?: MongoManagerIncFilter<T> | Document;
+	$rename?: MongoManagerRenameFilter<T>;
+};
+
+export class MongoManager {
+	private _collections: MongoManagerCollection<CollectionDocument>[] = [];
+	private _nodeCache;
+	private _cacheMap: { collections: string[], key: string }[] = [];
+	private _operationInProgress: Map<string, { promise: Promise<any>, invalidatedDuringExecution: boolean, collections: string[] }> = new Map();
+	private _heapSize = resolveHeapLimitBytes();
+	private _heapLimit: number;
+	private _serverCollections: (CollectionInfo | Pick<CollectionInfo, 'name' | 'type'>)[] = [];
+	private _isWorkersEnabled = false;
+	private _isWorkerInstance = false;
+	private _watchedDatabases: string[] = [];
+	private _mainDatabaseName = '';
+	private _changeStream: ChangeStream | null = null;
+	private _changeStreamRestartTimeout: NodeJS.Timeout | null = null;
+
+	constructor() {}
+
+	static async create() {
+		const mongoManager = new MongoManager();
+		await mongoManager.initialize();
+		return mongoManager;
+	}
+
+	private async initialize() {
+		this._nodeCache = new NodeCache({ stdTTL: 0, checkperiod: 0 });
+
+		this._isWorkersEnabled = process.env.IS_WORKERS_ENABLED === 'true';
+		this._isWorkerInstance = process.env.IS_WORKER_INSTANCE === 'true';
+		this._mainDatabaseName = ResolveIOServer.getServerConfig() ? ResolveIOServer.getServerConfig()['DATABASE'] : '';
+		this._watchedDatabases = this.resolveWatchedDatabases();
+		this.setCacheLimit();
+
+		if (this._isWorkersEnabled && this._isWorkerInstance) {
+			await this.setupChangeStream();
+		}
+
+		let collections = await ResolveIOServer.getMainDB().listCollections().toArray();
+		this._serverCollections = collections;
+	}
+
+	private resolveWatchedDatabases(): string[] {
+		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
+		const watchSet = new Set<string>();
+
+		if (this._mainDatabaseName) {
+			watchSet.add(this._mainDatabaseName);
+		}
+
+		const configValue = config ? config['WATCH_DATABASES'] : null;
+
+		if (Array.isArray(configValue)) {
+			for (const value of configValue) {
+				if (typeof value === 'string' && value.trim()) {
+					watchSet.add(value.trim());
+				}
+			}
+		}
+		else if (typeof configValue === 'string' && configValue.trim()) {
+			configValue.split(',').map(a => a.trim()).filter(a => a.length).forEach(a => watchSet.add(a));
+		}
+
+		const envValue = process.env.MONGO_WATCH_DATABASES;
+		if (envValue) {
+			envValue.split(',').map(a => a.trim()).filter(a => a.length).forEach(a => watchSet.add(a));
+		}
+
+		return Array.from(watchSet.values());
+	}
+
+	public getWatchedDatabases(): string[] {
+		return this._watchedDatabases;
+	}
+
+	oneTimeTransaction<T>(fn: () => Promise<T>): Promise<T> {
+		return asyncLocalStorage.run({}, async () => {
+			let attempt = 0;
+			const maxRetries = 4;
+			while (true) {
+				const session = ResolveIOServer.getMongoConnection().startSession();
+				const store = asyncLocalStorage.getStore();
+				if (store) {
+					store.session = session;
+				}
+				try {
+					let result: T | undefined;
+					await session.withTransaction(async () => {
+						result = await fn();
+						return result;
+					});
+					return result as T;
+				}
+				catch (err) {
+					if (!this.shouldRetryTransactionError(err) || attempt >= maxRetries) {
+						throw err;
+					}
+					if (this.shouldRetryConnectionError(err)) {
+						try {
+							await ResolveIOServer.requestMongoReconnect('mongo-transaction-retry', err);
+						}
+						catch {}
+					}
+					attempt += 1;
+					const jitter = Math.floor(Math.random() * 60);
+					await this.delay((120 * attempt) + jitter);
+				}
+				finally {
+					try {
+						await session.endSession();
+					}
+					catch {}
+					const activeStore = asyncLocalStorage.getStore();
+					if (activeStore) {
+						delete activeStore.session;
+					}
+				}
+			}
+		});
+	}
+	
+	getSession() {
+		const store = asyncLocalStorage.getStore();
+		return store ? store.session : null;
+	}
+
+	runWithoutSession<T>(fn: () => Promise<T> | T): Promise<T> {
+		return asyncLocalStorage.run({}, async () => {
+			return await fn();
+		});
+	}
+
+	private setCacheLimit() {
+		if (this._isWorkersEnabled) {
+			this._heapLimit = this._isWorkerInstance ? this._heapSize * 0.8 : this._heapSize * 0.4;
+		}
+		else {
+			this._heapLimit = this._heapSize * 0.3;
+		}
+	}
+
+	getServerCollections() {
+		return this._serverCollections;
+	}
+
+	async 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')
+		) {
+			await ResolveIOServer.getMainDB().dropCollection(collection.collectionName);
+			await this.createCollection(collection);
+		}
+
+		this._collections.push(collection);
+	}
+
+	async createCollection(collection: MongoManagerCollection<CollectionDocument>) {
+		await ResolveIOServer.getMainDB().createCollection(collection.collectionName, collection.collectionOptions);
+	}
+
+	collections() {
+		return this._collections;
+	}
+
+	collection(collectionName: string): MongoManagerCollection<CollectionDocument> | MongoManagerUserCollection<CollectionDocument> {
+		return this._collections.find(a => a.collectionName === collectionName);
+	}
+
+	private async delay(ms: number) {
+		// eslint-disable-next-line no-restricted-syntax
+		return new Promise(resolve => setTimeout(resolve, ms));
+	}
+
+	private hasMongoErrorLabel(err: any, label: string): boolean {
+		if (!err || !label) {
+			return false;
+		}
+		if (typeof err.hasErrorLabel === 'function') {
+			try {
+				if (err.hasErrorLabel(label)) {
+					return true;
+				}
+			}
+			catch {}
+		}
+		if (Array.isArray(err.errorLabels) && err.errorLabels.includes(label)) {
+			return true;
+		}
+		return false;
+	}
+
+	private shouldRetryWriteConflict(err: any): boolean {
+		if (!err) {
+			return false;
+		}
+		if (err.code === 112 || err.codeName === 'WriteConflict') {
+			return true;
+		}
+		const message = String(err.message || '');
+		return /write conflict/i.test(message) || /yielding is disabled/i.test(message);
+	}
+
+	private shouldRetryTransactionError(err: any): boolean {
+		if (!err) {
+			return false;
+		}
+		if (this.shouldRetryWriteConflict(err) || this.shouldRetryWaitQueueTimeout(err) || this.shouldRetryConnectionError(err)) {
+			return true;
+		}
+		return this.hasMongoErrorLabel(err, 'TransientTransactionError')
+			|| this.hasMongoErrorLabel(err, 'UnknownTransactionCommitResult');
+	}
+
+	private shouldRetryWaitQueueTimeout(err: any): boolean {
+		if (!err) {
+			return false;
+		}
+
+		if (err.name === 'MongoWaitQueueTimeoutError' || err.codeName === 'MongoWaitQueueTimeoutError') {
+			return true;
+		}
+
+		return typeof err.message === 'string' && err.message.includes('Timed out while checking out a connection from connection pool');
+	}
+
+	private shouldRetryConnectionError(err: any): boolean {
+		if (!err) {
+			return false;
+		}
+
+		const name = String(err.name || err.codeName || '');
+		if (
+			name === 'MongoPoolClearedError'
+			|| name === 'MongoNetworkError'
+			|| name === 'MongoNetworkTimeoutError'
+			|| name === 'MongoServerSelectionError'
+			|| name === 'MongoTopologyClosedError'
+			|| name === 'MongoNotConnectedError'
+			|| name === 'MongoClientClosedError'
+		) {
+			return true;
+		}
+
+		const message = String(err.message || '');
+		return /connection pool .* was cleared/i.test(message)
+			|| /topology is closed/i.test(message)
+			|| /client was closed/i.test(message)
+			|| /not connected/i.test(message)
+			|| /server selection timed out/i.test(message)
+			|| /econnrefused|econnreset|etimedout|ehostunreach/i.test(message);
+	}
+
+	private async retryRead<TResult>(operation: () => Promise<TResult>, options?: { session?: any }): Promise<TResult> {
+		if (options && options.session && typeof options.session.inTransaction === 'function' && options.session.inTransaction()) {
+			return operation();
+		}
+
+		let attempt = 0;
+		const maxRetries = 2;
+
+		while (true) {
+			try {
+				return await operation();
+			}
+			catch (err) {
+				const shouldRetry = this.shouldRetryWaitQueueTimeout(err) || this.shouldRetryConnectionError(err);
+				if (!shouldRetry || attempt >= maxRetries) {
+					throw err;
+				}
+				if (this.shouldRetryConnectionError(err)) {
+					try {
+						await ResolveIOServer.requestMongoReconnect('mongo-read-retry', err);
+					}
+					catch {}
+				}
+
+				attempt += 1;
+				await this.delay(100 * attempt);
+			}
+		}
+	}
+
+	public async find<T extends CollectionDocument>(
+		collectionName: string,
+		filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {},
+		options?: MongoManagerFindOptions
+	): Promise<T[]> {
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+		const cacheKey = this.generateCacheKey([collectionName], 'find', [filter, safeOptions]);
+	let result = this.getFromCache(cacheKey);
+	if (result !== undefined) {
+		if (ResolveIOServer.getMainServer().getSubscriptionManager() && ResolveIOServer.getMainServer().getSubscriptionManager().getEnableDebug()) {
+			console.log(new Date(), 'Mongo Find - Cache', collectionName);
+		}
+		recordDependencyResult(collectionName, result, { filter, meta: buildQueryMetaFromFindOptions(safeOptions) });
+		return result;
+	}
+
+		if (this._operationInProgress.has(cacheKey)) {
+			if (ResolveIOServer.getMainServer().getSubscriptionManager() && ResolveIOServer.getMainServer().getSubscriptionManager().getEnableDebug()) {
+				console.log(new Date(), 'Mongo Find - Already running', collectionName);
+			}
+			return this._operationInProgress.get(cacheKey).promise;
+		}
+
+		if (ResolveIOServer.getMainServer().getSubscriptionManager() && ResolveIOServer.getMainServer().getSubscriptionManager().getEnableDebug()) {
+			console.log(new Date(), 'Mongo Find - Running', collectionName);
+		}
+
+		const operation = this.executeFind<T>(collectionName, filter, options, cacheKey);
+		this._operationInProgress.set(cacheKey, { 
+			promise: operation, 
+			invalidatedDuringExecution: false,
+			collections: [collectionName]
+		});
+
+		await operation.finally(() => {
+			if (ResolveIOServer.getMainServer().getSubscriptionManager() && ResolveIOServer.getMainServer().getSubscriptionManager().getEnableDebug()) {
+				console.log(new Date(), 'Mongo Find - Done', collectionName);
+			}
+
+			this._operationInProgress.delete(cacheKey);
+		});
+
+		return operation;
+	}
+
+	private async executeFind<T extends CollectionDocument>(
+		collectionName: string,
+		filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T>,
+		options: MongoManagerFindOptions | undefined,
+		cacheKey: string
+	): Promise<T[]> {
+		let result;
+		const collection = ResolveIOServer.getMainDB().collection(collectionName);
+
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+		const pubContext = getPublicationContext();
+		const monitor = MonitorMongo.create('find', collectionName, JSON.stringify([filter, safeOptions]));
+		const queryStart = Date.now();
+
+		try {
+			result = await this.retryRead(() => collection.find<T>(<any>filter, options).toArray(), options);
+		}
+		catch (err) {
+				console.log(JSON.stringify([new Date(), 'Error Execute Find', collectionName, filter, safeOptions, {
+					code: err.code,
+					codeName: err.codeName,
+					message: err.message,
+					stack: err.stack
+				}], null, 2));
+
+				err.message = `Error in Execute Find: ${collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+				throw err;
+			}
+		finally {
+			const durationMs = Date.now() - queryStart;
+			await monitor.finish();
+			SlowQueryReporter.reportSlowQueryFireAndForget({
+				collection: collectionName,
+				filter,
+				options: safeOptions,
+				durationMs,
+				queryType: 'find',
+				notes: 'MongoManager executeFind',
+				publication: pubContext.publication,
+				subscriptionData: pubContext.subscriptionData,
+				userId: pubContext.userId
+			});
+		}
+
+	recordDependencyResult(collectionName, result, { filter, meta: buildQueryMetaFromFindOptions(safeOptions) });
+
+		if (!this._operationInProgress.get(cacheKey).invalidatedDuringExecution) {
+			this.addToCache([collectionName], cacheKey, result);
+		}
+
+		return result;
+	}
+
+	// FindOne Operation
+	public async findOne<T extends CollectionDocument>(
+		collectionName: string,
+		filter: MongoManagerFilter<T> | MongoManagerFilterOperators<T> = {},
+		options?: MongoManagerFindOptions
+	): Promise<T> {
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+		const cacheKey = this.generateCacheKey([collectionName], 'findOne', [filter, safeOptions]);
+		let result = this.getFromCache(cacheKey);
+	if (result !== undefined) {
+		if (ResolveIOServer.getMainServer().getSubscriptionManager() && ResolveIOServer.getMainServer().getSubscriptionManager().getEnableDebug()) {
+			console.log(new Date(), 'Mongo FindOne - Cache', collectionName);
+		}
+
+		recordDependencyResult(collectionName, result, { filter, meta: buildQueryMetaFromFindOptions(safeOptions) });
+
+		return result;
+	}
+
+		if (this._operationInProgress.has(cacheKey)) {
+			if (ResolveIOServer.getMainServer().getSubscriptionManager() && ResolveIOServer.getMainServer().getSubscriptionManager().getEnableDebug()) {
+				console.log(new Date(), 'Mongo FindOne - Already running', collectionName);
+			}
+
+			return this._operationInProgress.get(cacheKey).promise;
+		}
+
+		if (ResolveIOServer.getMainServer().getSubscriptionManager() && ResolveIOServer.getMainServer().getSubscriptionManager().getEnableDebug()) {
+			console.log(new Date(), 'Mongo FindOne - Running', collectionName);
+		}
+
+		const operation = this.executeFindOne<T>(collectionName, filter, options, cacheKey);
+		this._operationInProgress.set(cacheKey, { 
+			promise: operation, 
+			invalidatedDuringExecution: false,
+			collections: [collectionName]
+		});
+
+		await operation.finally(() => {
+			if (ResolveIOServer.getMainServer().getSubscriptionManager() && ResolveIOServer.getMainServer().getSubscriptionManager().getEnableDebug()) {
+				console.log(new Date(), 'Mongo FindOne - Done', collectionName);
+			}
+
+			this._operationInProgress.delete(cacheKey);
+		});
+
+		return operation;
+	}
+
+	private async executeFindOne<T extends CollectionDocument>(
+		collectionName: string,
+		filter: MongoManagerFilter<T> | MongoManagerFilterOperators<T>,
+		options: MongoManagerFindOptions | undefined,
+		cacheKey: string
+	): Promise<T> {
+		let result;
+		const collection = ResolveIOServer.getMainDB().collection(collectionName);
+		
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+		const pubContext = getPublicationContext();
+		const monitor = MonitorMongo.create('findOne', collectionName, JSON.stringify([filter, safeOptions]));
+		const queryStart = Date.now();
+
+		try {
+			result = await this.retryRead(() => collection.findOne<T>(<any>filter, options || undefined), options);
+		}
+		catch (err) {
+			console.log(JSON.stringify([new Date(), 'Error Execute Find One', collectionName, filter, safeOptions, {
+				code: err.code,
+				codeName: err.codeName,
+				message: err.message,
+				stack: err.stack
+			}], null, 2));
+
+			err.message = `Error in Execute Find One: ${collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+			throw err;
+		}
+		finally {
+			const durationMs = Date.now() - queryStart;
+			await monitor.finish();
+			SlowQueryReporter.reportSlowQueryFireAndForget({
+				collection: collectionName,
+				filter,
+				options: safeOptions,
+				durationMs,
+				queryType: 'findOne',
+				notes: 'MongoManager executeFindOne',
+				publication: pubContext.publication,
+				subscriptionData: pubContext.subscriptionData,
+				userId: pubContext.userId
+			});
+		}
+	
+	recordDependencyResult(collectionName, result, { filter, meta: buildQueryMetaFromFindOptions(safeOptions) });
+
+		if (!this._operationInProgress.get(cacheKey).invalidatedDuringExecution) {
+			this.addToCache([collectionName], cacheKey, result);
+		}
+
+		return result;
+	}
+
+	// Aggregate Operation
+	public async aggregate<T extends CollectionDocument>(
+		collectionName: string,
+		pipeline: any[],
+		options?: AggregateOptions
+	): Promise<any[]> {
+		const collections = [collectionName, ...pipeline.flatMap(stage => stage.$lookup?.from ? [stage.$lookup.from] : [])];
+
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+		const cacheKey = this.generateCacheKey(collections, 'aggregate', [pipeline, safeOptions]);
+		let result = this.getFromCache(cacheKey);
+		if (result !== undefined) {
+			if (ResolveIOServer.getMainServer().getSubscriptionManager() && ResolveIOServer.getMainServer().getSubscriptionManager().getEnableDebug()) {
+				console.log(new Date(), 'Mongo Agg - Cache', collections);
+			}
+			recordAggregateDependencies(collectionName, pipeline, result);
+			return result;
+		}
+
+		if (this._operationInProgress.has(cacheKey)) {
+			if (ResolveIOServer.getMainServer().getSubscriptionManager() && ResolveIOServer.getMainServer().getSubscriptionManager().getEnableDebug()) {
+				console.log(new Date(), 'Mongo Agg - Already running', collections);
+			}
+
+			return this._operationInProgress.get(cacheKey).promise;
+		}
+
+		if (ResolveIOServer.getMainServer().getSubscriptionManager() && ResolveIOServer.getMainServer().getSubscriptionManager().getEnableDebug()) {
+			console.log(new Date(), 'Mongo Agg - Running', collections);
+		}
+
+		const operation = this.executeAggregate<T>(collectionName, pipeline, options, cacheKey, collections);
+		this._operationInProgress.set(cacheKey, { 
+			promise: operation, 
+			invalidatedDuringExecution: false,
+			collections: collections
+		});
+
+		await operation.finally(() => {
+			if (ResolveIOServer.getMainServer().getSubscriptionManager() && ResolveIOServer.getMainServer().getSubscriptionManager().getEnableDebug()) {
+				console.log(new Date(), 'Mongo Agg - Done', collections);
+			}
+
+			this._operationInProgress.delete(cacheKey);
+		});
+
+		return operation;
+	}
+
+	private async executeAggregate<T extends CollectionDocument>(
+		collectionName: string,
+		pipeline: any[],
+		options: AggregateOptions | undefined,
+		cacheKey: string,
+		collections: string[]
+	): Promise<any[]> {
+		let result;
+		const collection = ResolveIOServer.getMainDB().collection(collectionName);
+
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+		const pubContext = getPublicationContext();
+		const monitor = MonitorMongo.create('aggregate', collectionName, JSON.stringify([pipeline, safeOptions]));
+		const queryStart = Date.now();
+
+		try {
+			result = await this.retryRead(() => collection.aggregate<T>(pipeline, options).toArray(), options);
+		}
+		catch (err) {
+			console.log(JSON.stringify([new Date(), 'Error Execute Aggregate', collectionName, pipeline, collections, safeOptions, {
+				code: err.code,
+				codeName: err.codeName,
+				message: err.message,
+				stack: err.stack
+			}], null, 2));
+
+			err.message = `Error in Execute Aggregate: ${collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+			throw err;
+		}
+		finally {
+			const durationMs = Date.now() - queryStart;
+			await monitor.finish();
+			SlowQueryReporter.reportSlowQueryFireAndForget({
+				collection: collectionName,
+				pipeline,
+				options: safeOptions,
+				durationMs,
+				queryType: 'aggregate',
+				notes: 'MongoManager executeAggregate',
+				publication: pubContext.publication,
+				subscriptionData: pubContext.subscriptionData,
+				userId: pubContext.userId
+			});
+		}
+
+		recordAggregateDependencies(collectionName, pipeline, result);
+
+		if (!this._operationInProgress.get(cacheKey).invalidatedDuringExecution) {
+			this.addToCache(collections, cacheKey, result);
+		}
+		
+		return result;
+	}
+
+	public async countDocuments<T extends CollectionDocument>(
+		collectionName: string,
+		filter: MongoManagerFilter<T> | MongoManagerFilterOperators<T> = {},
+		options?: CountDocumentsOptions
+	): Promise<number> {
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+		const cacheKey = this.generateCacheKey([collectionName], 'countDocuments', [filter, safeOptions]);
+		let result = this.getFromCache(cacheKey);
+		if (result !== undefined) {
+			recordDependencyResult(collectionName, result, { filter });
+			return result;
+		}
+
+		if (this._operationInProgress.has(cacheKey)) {
+			return this._operationInProgress.get(cacheKey).promise;
+		}
+
+		const operation = this.executeCountDocuments<T>(collectionName, filter, options, cacheKey);
+		this._operationInProgress.set(cacheKey, { 
+			promise: operation, 
+			invalidatedDuringExecution: false,
+			collections: [collectionName]
+		});
+
+		await operation.finally(() => this._operationInProgress.delete(cacheKey));
+
+		return operation;
+	}
+
+	private async executeCountDocuments<T extends CollectionDocument>(
+		collectionName: string,
+		filter: MongoManagerFilter<T> | MongoManagerFilterOperators<T>,
+		options: CountDocumentsOptions,
+		cacheKey: string
+	): Promise<number> {
+		let result;
+		const collection = ResolveIOServer.getMainDB().collection(collectionName);
+
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+		const pubContext = getPublicationContext();
+		const monitor = MonitorMongo.create('countDocuments', collectionName, JSON.stringify([filter, safeOptions]));
+		const queryStart = Date.now();
+
+		try {
+			result = await this.retryRead(() => collection.countDocuments(<any>filter, options || undefined), options);
+		}
+		catch (err) {
+			console.log(JSON.stringify([new Date(), 'Error Execute Count Documents', collectionName, filter, safeOptions, {
+				code: err.code,
+				codeName: err.codeName,
+				message: err.message,
+				stack: err.stack
+			}], null, 2));
+
+			err.message = `Error in Execute Count Documents: ${collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+			throw err;
+		}
+		finally {
+			const durationMs = Date.now() - queryStart;
+			await monitor.finish();
+			SlowQueryReporter.reportSlowQueryFireAndForget({
+				collection: collectionName,
+				filter,
+				options: safeOptions,
+				durationMs,
+				queryType: 'countDocuments',
+				notes: 'MongoManager executeCountDocuments',
+				publication: pubContext.publication,
+				subscriptionData: pubContext.subscriptionData,
+				userId: pubContext.userId
+			});
+		}
+	
+		recordDependencyResult(collectionName, result, { filter });
+
+		if (!this._operationInProgress.get(cacheKey).invalidatedDuringExecution) {
+			this.addToCache([collectionName], cacheKey, result);
+		}
+
+		return result;
+	}
+
+	// Cache and Invalidation Setup
+	private generateCacheKey(collections: string[], functionName: string, args: any[]): string {
+		const keyString = JSON.stringify({ collections, functionName, args });
+		return crypto.createHash('sha256').update(keyString).digest('hex');
+	}
+
+	private getFromCache(cacheKey: string): any | undefined {
+		try {
+			const cachedData = this._nodeCache.get(cacheKey);
+			if (cachedData) {
+				return JSON.parse(cachedData, dateReviver);
+			}
+		} 
+		catch {
+			this._nodeCache.del(cacheKey);
+		}
+
+		return undefined;
+	}
+
+	private addToCache(collections: string[], cacheKey: string, data: any) {
+		if (getBinarySize(JSON.stringify(data)) < 1000000 && 
+			!collections.includes('logs') &&
+			!collections.find(a => a.endsWith('.versions')) &&
+			!collections.find(a => a.startsWith('monitor-'))
+		) {
+			let nodeCacheSize = this._nodeCache.getStats().vsize;
+
+			if (nodeCacheSize > this._heapLimit) {
+				let deleteCount = 0;
+				const keys = this._nodeCache.keys();
+
+				for (const key of keys) {
+					this._nodeCache.del(key);
+					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(cacheKey, JSON.stringify(data));
+			this._cacheMap.push({ collections, key: cacheKey });
+		}
+	}
+
+	public invalidateQueryCache(collection: string, bypassLocalOplog = false) {
+		const collectionCacheMap = this._cacheMap.filter(a => a.collections.includes(collection));
+
+		if (ResolveIOServer.getMainServer().getSubscriptionManager() && ResolveIOServer.getMainServer().getSubscriptionManager().getEnableDebug()) {
+			console.log(new Date(), 'Mongo Invalidate Cache', collection);
+		}
+
+		for (const cacheMap of collectionCacheMap) {
+			this._nodeCache.del(cacheMap.key);
+			
+			if (this._operationInProgress.has(cacheMap.key)) {
+				this._operationInProgress.get(cacheMap.key).invalidatedDuringExecution = true;
+
+				if (ResolveIOServer.getMainServer().getSubscriptionManager() && ResolveIOServer.getMainServer().getSubscriptionManager().getEnableDebug()) {
+					console.log(new Date(), 'Mongo Invalidated During Execution', cacheMap.collections);
+				}
+			}
+		}
+
+		// eslint-disable-next-line no-unused-vars
+		for (const [key, operation] of this._operationInProgress.entries()) {
+			if (operation.collections.includes(collection)) {
+				operation.invalidatedDuringExecution = true;
+		
+				if (ResolveIOServer.getMainServer().getSubscriptionManager() && ResolveIOServer.getMainServer().getSubscriptionManager().getEnableDebug()) {
+					console.log(new Date(), 'Mongo Invalidated During Execution (No cache)', operation.collections);
+				}
+			}
+		}
+
+		this._cacheMap = this._cacheMap.filter(a => !a.collections.includes(collection));
+
+		if (!bypassLocalOplog && ResolveIOServer.getMainServer().getSubscriptionManager() && ResolveIOServer.getMainServer().getSubscriptionManager().getUseLocalOplog()) {
+			ResolveIOServer.getMainServer().getSubscriptionManager().notifyLocalOplog(collection, 'update');
+		}
+	}
+
+	public clearQueryCache(reason?: string) {
+		if (ResolveIOServer.getMainServer().getSubscriptionManager() && ResolveIOServer.getMainServer().getSubscriptionManager().getEnableDebug()) {
+			console.log(new Date(), 'Mongo Clear Cache', reason || '');
+		}
+
+		try {
+			this._nodeCache.flushAll();
+		}
+		catch {
+			// ignore flush errors
+		}
+
+		this._cacheMap = [];
+
+		// Mark all in-flight ops invalidated so they don't repopulate cache with stale data.
+		// eslint-disable-next-line no-unused-vars
+		for (const [key, operation] of this._operationInProgress.entries()) {
+			operation.invalidatedDuringExecution = true;
+		}
+	}
+
+	public async handleMongoReconnect(reason: string): Promise<void> {
+		this.clearQueryCache(`mongo-reconnect:${reason}`);
+
+		if (this._isWorkersEnabled && this._isWorkerInstance) {
+			try {
+				await this.setupChangeStream();
+			}
+			catch (error) {
+				console.log(new Date(), 'Mongo handle reconnect: change stream restart failed', reason, error);
+				this.scheduleChangeStreamRestart();
+			}
+		}
+	}
+
+	private async setupChangeStream() {
+		if (!this._isWorkersEnabled || !this._isWorkerInstance) {
+			return;
+		}
+
+		if (this._changeStreamRestartTimeout) {
+			clearTimeout(this._changeStreamRestartTimeout);
+			this._changeStreamRestartTimeout = null;
+		}
+
+		await this.teardownChangeStream(true);
+
+		const client = ResolveIOServer.getMongoConnection();
+
+		if (!client) {
+			this.scheduleChangeStreamRestart();
+			return;
+		}
+
+		const watchDatabases = this._watchedDatabases.length ? this._watchedDatabases : (this._mainDatabaseName ? [this._mainDatabaseName] : []);
+
+		const pipeline = [
+			{
+				$match: {
+					$and: [
+						...(watchDatabases.length ? [{ 'ns.db': { $in: watchDatabases } }] : []),
+						{'ns.coll': { $nin: [
+							'log-method-latencies', 
+							'log-subscriptions', 
+							'logs', 
+							'counters', 
+							'cron-job-histories', 
+							'email-histories',
+							'qb-soap-request-histories', 
+							'qb-soap-request-responses', 
+							'qb-soap-requests',
+							'qb-soap-retries',
+							'subscription-manager-resume-tokens'
+						] }},
+						{'ns.coll': { $not: /.*\.versions$/ }},
+						{'ns.coll': { $not: /^monitor-/ }},
+					]
+				},
+			},
+		];
+
+		let changeStream: ChangeStream;
+
+		try {
+			changeStream = client.watch(pipeline, { fullDocument: 'updateLookup' });
+		}
+		catch (err) {
+			console.log(new Date(), 'Mongo change stream setup failed. Restarting...', err);
+			this.scheduleChangeStreamRestart();
+			return;
+		}
+
+		this._changeStream = changeStream;
+
+		changeStream.on('change', (change: any) => {
+			if (change['ns'] && change['ns'].coll) {
+				const collectionName = change['ns'].coll;
+				const collection = this.collection(collectionName);
+
+				if (collection) {
+					this.invalidateQueryCache(collectionName);
+				}
+			}
+		});
+
+		changeStream.on('error', async error => {
+			await this.handleChangeStreamFailure('error', error);
+		});
+
+		changeStream.on('close', async () => {
+			await this.handleChangeStreamFailure('close');
+		});
+	}
+
+	private async teardownChangeStream(forceClose: boolean) {
+		if (!this._changeStream) {
+			return;
+		}
+
+		const currentStream = this._changeStream;
+		this._changeStream = null;
+
+		currentStream.removeAllListeners();
+
+		if (forceClose) {
+			try {
+				await currentStream.close();
+			}
+			catch (err) {
+				console.log(new Date(), 'Mongo change stream close failed', err);
+			}
+		}
+	}
+
+	private async handleChangeStreamFailure(reason: 'error' | 'close', error?: unknown) {
+		if (reason === 'error') {
+			console.log(new Date(), 'Mongo change stream error. Restart...', error);
+			await this.teardownChangeStream(true);
+		}
+		else {
+			console.log(new Date(), 'Mongo change stream closed. Restarting...');
+			await this.teardownChangeStream(false);
+		}
+
+		this.scheduleChangeStreamRestart();
+	}
+
+	private scheduleChangeStreamRestart(delayMs = 5000) {
+		if (this._changeStreamRestartTimeout) {
+			return;
+		}
+
+		this._changeStreamRestartTimeout = setTimeout(async () => {
+			this._changeStreamRestartTimeout = null;
+
+			try {
+				await this.setupChangeStream();
+			}
+			catch (err) {
+				console.log(new Date(), 'Mongo change stream restart failed. Retrying...', err);
+				this.scheduleChangeStreamRestart(Math.min(delayMs * 2, 60000));
+			}
+		}, delayMs);
+	}
+}
+
+export class MongoManagerModel<T extends CollectionDocument> {
+	collection_main: MongoManagerCollection<T> | MongoManagerUserCollection<T> = null;
+	collection_version: MongoManagerCollection<T> | MongoManagerUserCollection<T> = null;
+
+	constructor() {}
+
+	static create<T>(options: MongoManagerCollectionOptions): MongoManagerModel<T> {
+		const mongoManagerModel = new MongoManagerModel<T>();
+		mongoManagerModel.initialize(options);
+		return mongoManagerModel;
+	}
+
+	private initialize(options: MongoManagerCollectionOptions) {
+		if (options.collectionName === 'users') {
+			this.collection_main = MongoManagerUserCollection.create(options) as MongoManagerUserCollection<T>;
+		}
+		else {
+			this.collection_main = MongoManagerCollection.create(options) as MongoManagerCollection<T>;
+		}
+
+		if (options.useVersionCollection) {
+			this.collection_main.useVersions = true;
+
+			let versionSchema = deepCopy(options.schema);
+			versionSchema._id = versionSchema._id || {};
+			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,
+				skipCache: true,
+				bypassSession: true
+			};
+
+			if (options.collectionName === 'users') {	
+				this.collection_version = MongoManagerUserCollection.create(versionOptions) as MongoManagerUserCollection<T>;
+			}
+			else {
+				this.collection_version = MongoManagerCollection.create(versionOptions) as MongoManagerCollection<T>;
+			}
+
+			setImmediate(async () => {
+				await 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;
+	skipCache?: boolean;
+	bypassSession?: boolean;
+	searchFields?: string[];
+}
+
+export class MongoManagerCollection<T extends CollectionDocument> {
+	collectionName = '';
+	checkSchema = false;
+	simplschema = null;
+	rbSchema = null;
+	timestamps = false;
+	useVersions = false;
+	versionCollection = '';
+	createLogs = true;
+	useRB = false;
+	collectionOptions: CreateCollectionOptions;
+	skipCache = false;
+	bypassSession = false;
+	
+	constructor() {}
+	
+	static create(options: MongoManagerCollectionOptions) {
+		const mongoManagerCollection = new MongoManagerCollection();
+		mongoManagerCollection.initialize(options);
+		return mongoManagerCollection;
+	}
+
+	initialize(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;
+		this.skipCache = options.skipCache || false;
+		this.bypassSession = options.bypassSession || false;
+
+		if (options.useReportBuilder) {
+			this.useRB = true;
+			let schemaCopy = deepCopy(options.schema);
+			let rbSchema = buildRbLookups(options.reportBuilderLookupTables, schemaCopy, []);
+			this.rbSchema = buildRbSchema(rbSchema);
+		}
+
+		const retryDelayMs = 250;
+		const registerWhenReady = async () => {
+			if (ResolveIOServer && ResolveIOServer.getMainServer() && ResolveIOServer.getMongoManager() && ResolveIOServer.getMongoManager().getServerCollections().length) {
+				await ResolveIOServer.getMongoManager().registerCollection(this);
+				return;
+			}
+			setTimeout(registerWhenReady, retryDelayMs);
+		};
+		setTimeout(registerWhenReady, retryDelayMs);
+	}
+
+	// Method to extract index name from error message
+	extractIndexNameFromError(errorMessage) {
+		let regexPattern = /Index already exists with a different name: (\S+)/;
+		let matches = errorMessage.match(regexPattern);
+	
+		if (!matches || matches.length <= 1) {
+			// If the first pattern doesn't match, try the second pattern
+			regexPattern = /existing index:.*name: "([^"]+)"/;
+			matches = errorMessage.match(regexPattern);
+		}
+
+		return matches && matches.length > 1 ? matches[1] : null;
+	}
+
+	private shouldRetryWriteConflict(err: any): boolean {
+		if (!err) {
+			return false;
+		}
+
+		if (err.code === 112 || err.codeName === 'WriteConflict') {
+			return true;
+		}
+
+		const message = String(err.message || '');
+		return /write conflict/i.test(message) || /yielding is disabled/i.test(message);
+	}
+
+	private shouldRetryWaitQueueTimeout(err: any): boolean {
+		if (!err) {
+			return false;
+		}
+
+		if (err.name === 'MongoWaitQueueTimeoutError' || err.codeName === 'MongoWaitQueueTimeoutError') {
+			return true;
+		}
+
+		return typeof err.message === 'string' && err.message.includes('Timed out while checking out a connection from connection pool');
+	}
+
+	private shouldRetryConnectionError(err: any): boolean {
+		if (!err) {
+			return false;
+		}
+
+		const name = String(err.name || err.codeName || '');
+		if (
+			name === 'MongoPoolClearedError'
+			|| name === 'MongoNetworkError'
+			|| name === 'MongoNetworkTimeoutError'
+			|| name === 'MongoServerSelectionError'
+			|| name === 'MongoTopologyClosedError'
+			|| name === 'MongoNotConnectedError'
+			|| name === 'MongoClientClosedError'
+		) {
+			return true;
+		}
+
+		const message = String(err.message || '');
+		return /connection pool .* was cleared/i.test(message)
+			|| /topology is closed/i.test(message)
+			|| /client was closed/i.test(message)
+			|| /not connected/i.test(message)
+			|| /server selection timed out/i.test(message)
+			|| /econnrefused|econnreset|etimedout|ehostunreach/i.test(message);
+	}
+
+	private async delay(ms: number) {
+		// eslint-disable-next-line no-restricted-syntax
+		return new Promise(resolve => setTimeout(resolve, ms));
+	}
+
+	private async retryWrite<TResult>(operation: () => Promise<TResult>, options?: { session?: any }): Promise<TResult> {
+		if (options && options.session && typeof options.session.inTransaction === 'function' && options.session.inTransaction()) {
+			return operation();
+		}
+
+		let attempt = 0;
+		const configuredMaxRetries = Number(process.env.MONGO_WRITE_RETRY_MAX || 8);
+		const maxRetries = Number.isFinite(configuredMaxRetries) && configuredMaxRetries >= 0
+			? Math.min(Math.floor(configuredMaxRetries), 20)
+			: 8;
+		const configuredBaseDelay = Number(process.env.MONGO_WRITE_RETRY_BASE_MS || 120);
+		const baseDelayMs = Number.isFinite(configuredBaseDelay) && configuredBaseDelay > 0
+			? Math.min(Math.floor(configuredBaseDelay), 5000)
+			: 120;
+
+		while (true) {
+			try {
+				return await operation();
+			}
+			catch (err) {
+				const shouldRetry = this.shouldRetryWriteConflict(err) || this.shouldRetryWaitQueueTimeout(err) || this.shouldRetryConnectionError(err);
+					if (!shouldRetry || attempt >= maxRetries) {
+						throw err;
+					}
+					if (this.shouldRetryConnectionError(err)) {
+						try {
+							await ResolveIOServer.requestMongoReconnect(`mongo-collection-write-retry:${this.collectionName}`, err);
+						}
+						catch {}
+					}
+
+					attempt += 1;
+					const backoff = Math.min(5000, baseDelayMs * (2 ** (attempt - 1)));
+					const jitter = Math.floor(Math.random() * 90);
+					await this.delay(backoff + jitter);
+				}
+			}
+		}
+
+	private async retryRead<TResult>(operation: () => Promise<TResult>, options?: { session?: any }): Promise<TResult> {
+		if (options && options.session && typeof options.session.inTransaction === 'function' && options.session.inTransaction()) {
+			return operation();
+		}
+
+		let attempt = 0;
+		const maxRetries = 2;
+
+		while (true) {
+			try {
+				return await operation();
+			}
+			catch (err) {
+				const shouldRetry = this.shouldRetryWaitQueueTimeout(err) || this.shouldRetryConnectionError(err);
+				if (!shouldRetry || attempt >= maxRetries) {
+					throw err;
+				}
+				if (this.shouldRetryConnectionError(err)) {
+					try {
+						await ResolveIOServer.requestMongoReconnect(`mongo-collection-read-retry:${this.collectionName}`, err);
+					}
+					catch {}
+				}
+
+				attempt += 1;
+				await this.delay(100 * attempt);
+			}
+		}
+	}
+
+	async aggregate(pipeline: object[], options?: AggregateOptions, skipCache = false, bypassSession = false) : Promise<any[]> {
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {
+					session: mongoSession
+				};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+		
+		if (!skipCache && !this.skipCache) {
+			return ResolveIOServer.getMongoManager().aggregate(this.collectionName, pipeline, options || undefined);
+		}
+		else {
+			// eslint-disable-next-line no-unused-vars
+			let { session, ...safeOptions } = options || {};
+			let monitor = MonitorMongo.create('aggregate', this.collectionName, JSON.stringify([pipeline, safeOptions]));
+
+			try {
+				let res = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).aggregate(pipeline, options).toArray();
+				recordAggregateDependencies(this.collectionName, pipeline, res);
+				return res;
+			}
+			catch (err) {
+				console.log(JSON.stringify([new Date(), 'Error Aggregate', this.collectionName, pipeline, safeOptions, {
+					code: err.code,
+					codeName: err.codeName,
+					message: err.message,
+					stack: err.stack
+				}], null, 2));
+	
+				err.message = `Error in Aggregate: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+				throw err;
+			}
+			finally {
+				await monitor.finish();
+			}
+		}
+	}
+
+	async aggregateCount(pipeline: object[], options?: AggregateOptions, bypassSession = false) : Promise<number> {
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {
+					session: mongoSession
+				};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+		let monitor = MonitorMongo.create('aggregateCount', this.collectionName, JSON.stringify([pipeline, safeOptions]));
+
+		try {
+			let res = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).aggregate(pipeline, options).toArray();
+			recordAggregateDependencies(this.collectionName, pipeline, res);
+			return res.length;
+		}
+		catch (err) {
+			console.log(JSON.stringify([new Date(), 'Error Aggregate Count', this.collectionName, pipeline, safeOptions, {
+				code: err.code,
+				codeName: err.codeName,
+				message: err.message,
+				stack: err.stack
+			}], null, 2));
+
+			err.message = `Error in Aggregate Count: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+			throw err;
+		}
+		finally {
+			await monitor.finish();
+		}
+	}
+
+	aggregateCursor(pipeline: object[], options?: AggregateOptions, bypassSession = false): AggregationCursor {
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {
+					session: mongoSession
+				};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+		let monitor = MonitorMongo.create('aggregateCursor', this.collectionName, JSON.stringify([pipeline, safeOptions]));
+		let cursor = ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).aggregate(pipeline, options || undefined);
+		cursor.on('close', async ev => {
+			await monitor.finish();
+			return ev;
+		});
+
+		return cursor;
+	}
+
+	aggregateStream(pipeline: object[], options?: AggregateOptions, streamOptions?: any, bypassSession = false) {
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {
+					session: mongoSession
+				};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+		let monitor = MonitorMongo.create('aggregateStream', this.collectionName, JSON.stringify([pipeline, safeOptions, streamOptions]));
+		let stream = ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).aggregate(pipeline, options).stream().on('close', async ev => {
+			await monitor.finish();
+			return ev;
+		});
+
+		return stream;
+	}
+
+	async bulkWrite(
+		operations: any[],
+		options?: BulkWriteOptions,
+		bypassCheckSchema = false,
+		bypassLogs = false,
+		bypassVersions = false, 
+		bypassSession = false
+	): Promise<BulkWriteResult> {
+		if (!operations.length) {
+			return null;
+		}
+	
+		const BATCH_SIZE = 1000;
+		let opIndex = 0;
+
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {session: mongoSession};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+
+		let { session, ...safeOptions } = options || {};
+	
+		while (opIndex < operations.length) {
+			const batchOps = operations.slice(opIndex, opIndex + BATCH_SIZE);
+	
+			// Initialize arrays for logs and version operations
+			const logs = [];
+			const versionOps = [];
+	
+			for (const op of batchOps) {
+				const opType = Object.keys(op)[0];
+				const doc = op[opType];
+	
+				// Skip validation if bypassCheckSchema is true
+				if (this.checkSchema && !bypassCheckSchema) {
+					const validationContext = this.simplschema.newContext();
+					let isValid: boolean;
+	
+					if (opType === 'insertOne') {
+						isValid = validationContext.validate(doc.document);
+					}
+					else if (opType === 'replaceOne') {
+						isValid = validationContext.validate(doc.replacement);
+					}
+					else if (opType === 'updateOne' || opType === 'updateMany') {
+						// For updates, validate the update modifier
+						isValid = validationContext.validate(doc.update, { modifier: true });
+					}
+					else if (opType === 'deleteOne' || opType === 'deleteMany') {
+						// No validation needed for deletes
+						isValid = true;
+					}
+					else {
+						throw new Error(`Unsupported operation type: ${opType}`);
+					}
+	
+					if (!isValid) {
+						throw new Error(
+							`Schema validation failed for ${opType}: ${JSON.stringify(validationContext.validationErrors(), null, 2)}`
+						);
+					}
+				}
+	
+				// Now proceed to process the operations
+	
+				if (opType === 'insertOne') {
+					// If this.timestamps is true, set createdAt and updatedAt
+					if (this.timestamps) {
+						if (!doc.document.createdAt) {
+							doc.document.createdAt = new Date();
+						}
+
+						if (!doc.document.updatedAt) {
+							doc.document.updatedAt = new Date();
+						}
+					}
+
+					// Prepare log entry
+					if (!bypassLogs && this.createLogs) {
+						logs.push({
+							_id: objectIdHexString(),
+							type: 'document',
+							collection: this.collectionName,
+							id_document: doc.document._id || objectIdHexString(),
+							payload:
+								getBinarySize(JSON.stringify(doc.document)) < 1000000
+									? JSON.stringify(doc.document, null, 2)
+									: 'Too Big',
+							method: 'insertOne',
+							id_user: '', // Add user info if available
+							user: '',
+							messageId: 0,
+							route: '',
+							createdAt: new Date(),
+						});
+					}
+	
+					// Since we might have modified doc.document, update the operation
+					op[opType].document = doc.document;
+				}
+				else if (opType === 'updateOne' || opType === 'updateMany') {
+					// If this.timestamps is true, add updatedAt
+					if (this.timestamps) {
+						if (!doc.update.$set) {
+							doc.update.$set = {};
+						}
+						doc.update.$set.updatedAt = new Date();
+					}
+	
+					// If this.useVersions is true, increment __v
+					if (!bypassVersions && this.useVersions) {
+						if (!doc.update.$inc) {
+							doc.update.$inc = {};
+						}
+						doc.update.$inc.__v = 1;
+					}
+	
+					// Prepare log entry
+					if (!bypassLogs && this.createLogs) {
+						logs.push({
+							_id: objectIdHexString(),
+							type: 'document',
+							collection: this.collectionName,
+							id_document: doc.filter._id || null,
+							payload:
+								getBinarySize(JSON.stringify(doc.update)) < 1000000
+									? JSON.stringify(doc.update, null, 2)
+									: 'Too Big',
+							method: opType,
+							id_user: '', // Add user info if available
+							user: '',
+							messageId: 0,
+							route: '',
+							instance_index: process.env.NODE_APP_INSTANCE || '0',
+							createdAt: new Date()
+						});
+					}
+	
+					// For versioning, store the filter to fetch the document later
+					if (!bypassVersions && this.useVersions) {
+						versionOps.push({
+							filter: doc.filter,
+						});
+					}
+	
+					// No need to modify the operation further
+				}
+				else if (opType === 'replaceOne') {
+					// If this.timestamps is true, set updatedAt
+					if (this.timestamps) {
+						doc.replacement.updatedAt = new Date();
+					}
+	
+					// If this.useVersions is true, increment __v
+					if (!bypassVersions && this.useVersions) {
+						doc.replacement.__v = (doc.replacement.__v || 0) + 1;
+					}
+	
+					// Prepare log entry
+					if (!bypassLogs && this.createLogs) {
+						logs.push({
+							_id: objectIdHexString(),
+							type: 'document',
+							collection: this.collectionName,
+							id_document: doc.filter._id || null,
+							payload:
+								getBinarySize(JSON.stringify(doc.replacement)) < 1000000
+									? JSON.stringify(doc.replacement, null, 2)
+									: 'Too Big',
+							method: 'replaceOne',
+							id_user: '', // Add user info if available
+							user: '',
+							messageId: 0,
+							route: '',
+							createdAt: new Date(),
+						});
+					}
+	
+					// For versioning, store the filter to fetch the document later
+					if (!bypassVersions && this.useVersions) {
+						versionOps.push({
+							filter: doc.filter,
+						});
+					}
+	
+					// Since we might have modified doc.replacement, update the operation
+					op[opType].replacement = doc.replacement;
+				}
+				else if (opType === 'deleteOne' || opType === 'deleteMany') {
+					// Prepare log entry
+					if (!bypassLogs && this.createLogs) {
+						logs.push({
+							_id: objectIdHexString(),
+							type: 'document',
+							collection: this.collectionName,
+							id_document: doc.filter._id || null,
+							payload:
+								getBinarySize(JSON.stringify(doc.filter)) < 1000000
+									? JSON.stringify(doc.filter, null, 2)
+									: 'Too Big',
+							method: opType,
+							id_user: '', // Add user info if available
+							user: '',
+							messageId: 0,
+							route: '',
+							createdAt: new Date(),
+						});
+					}
+	
+					// For versioning, store the filter to fetch the document later
+					if (!bypassVersions && this.useVersions) {
+						versionOps.push({
+							filter: doc.filter,
+						});
+					}
+	
+					// No need to modify the operation
+				}
+				else {
+					throw new Error(`Unsupported operation type: ${opType}`);
+				}
+			}
+
+			let affectedDocs = [];
+
+			// Handle versioning
+			if (!bypassVersions && this.useVersions && versionOps.length > 0) {
+				try {
+					// Fetch the affected documents
+					const versionFilters = versionOps.map((v) => v.filter);
+
+					if (versionFilters.length) {
+						affectedDocs = await ResolveIOServer.getMainDB().collection(this.collectionName).find({ $or: versionFilters }, {session}).toArray();
+					}
+		
+					// Prepare version documents
+					const versionInserts = affectedDocs.map((doc) => ({
+						insertOne: {
+							document: {
+								...doc,
+								_id: { _id: doc._id, __v: doc.__v },
+							},
+						},
+					}));
+		
+					// Insert versions in bulk
+					if (versionInserts.length > 0) {
+						try {
+							await ResolveIOServer.getMainDB().collection(this.versionCollection).bulkWrite(<any>versionInserts);
+						}
+						catch {}
+					}
+				}
+				catch {}
+			}
+
+			// Execute bulkWrite
+			const monitor = MonitorMongo.create('bulkWrite', this.collectionName, JSON.stringify([batchOps, safeOptions]));
+
+			try {
+				await this.retryWrite(
+					() => ResolveIOServer.getMainDB().collection(this.collectionName).bulkWrite(batchOps, options || undefined),
+					options
+				);
+			}
+			catch (err) {
+				console.log(JSON.stringify([new Date(), 'Error Bulk Write', this.collectionName, operations, safeOptions, {
+					code: err.code,
+					codeName: err.codeName,
+					message: err.message,
+					stack: err.stack
+				}], null, 2));
+	
+				err.message = `Error in Bulk Write: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+				throw err;
+			}
+			finally {
+				await monitor.finish();
+			}
+	
+			// Insert logs in bulk
+			if (!bypassLogs && this.createLogs && logs.length > 0) {
+				if (
+					ResolveIOServer.shouldWriteLogsOffline()
+				) {
+					ResolveIOServer.getLocalLogManager().writeLogs(logs.map(a => {
+						return {
+							type: 'log',
+							data: a
+						};
+					}));
+				}
+				else {
+					let bwOptions = null;
+					bwOptions = {session, ordered: false};
+
+					await ResolveIOServer.getMainDB().collection('logs').bulkWrite(logs.map(a => {
+						a.client = 'ResolveIO';
+						a.instance = ResolveIOServer.getInstanceHost();
+
+						return {
+							insertOne: {
+								document: a
+							}
+						};
+					}), bwOptions);
+				}
+			}
+
+			if (!bypassVersions && this.useVersions) {
+				try {
+					// Delete old versions beyond the latest 5
+					const affectedDocIds = affectedDocs.map((doc) => doc._id);
+
+					const pipeline = [
+						{
+							$match: { '_id._id': { $in: affectedDocIds } },
+						},
+						{
+							$sort: { '_id._id': 1, '_id.__v': -1 },
+						},
+						{
+							$group: {
+								_id: '$_id._id',
+								versions: { $push: '$_id' },
+							},
+						},
+						{
+							$project: {
+								versionsToDelete: { $slice: ['$versions', 5, { $size: '$versions' }] },
+							},
+						},
+						{ $unwind: '$versionsToDelete' },
+						{
+							$replaceRoot: { newRoot: { _id: '$versionsToDelete' } },
+						},
+					];
+				
+					const oldVersions = await ResolveIOServer.getMainDB().collection(this.versionCollection).aggregate(pipeline).toArray();
+
+					if (oldVersions.length > 0) {
+						await ResolveIOServer.getMainDB().collection(this.versionCollection).deleteMany({ _id: { $in: oldVersions.map((v) => v._id) } });
+					}
+				}
+				catch {}
+			}
+	
+			opIndex += BATCH_SIZE;
+	
+			// Yield to the event loop
+			// eslint-disable-next-line no-restricted-syntax
+			await new Promise((resolve) => setImmediate(resolve));
+	
+			// Invalidate cache
+			if (!this.skipCache) {
+				ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+			}
+		}
+	
+		return { ok: 1 } as BulkWriteResult; // Adjust return value as per your requirements
+	}
+
+	async countDocuments(
+		filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {},
+		options?: CountDocumentsOptions,
+		skipCache = false
+	): Promise<number> {
+		
+		// ********* COUNTS ARE NOT SUPPORTED IN MONGO SESSIONS! ***************
+
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+
+		// Check if the filter is empty
+		const isUnfiltered = Object.keys(filter).length === 0;
+
+		if (isUnfiltered) {
+			// Use collection stats for an unfiltered count
+			return ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).estimatedDocumentCount(safeOptions);
+		}
+		else if (!skipCache && !this.skipCache) {
+			// Use cached count if skipCache is false
+			return ResolveIOServer.getMongoManager().countDocuments(this.collectionName, filter, safeOptions);
+		}
+		else {
+			// Fallback to direct countDocuments call with monitoring if skipCache is true
+
+			let monitor = MonitorMongo.create('countDocuments', this.collectionName, JSON.stringify([filter, safeOptions]));
+
+			try {
+				let res = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).countDocuments(<any>filter, safeOptions);
+				return res;
+			}
+			catch (err) {
+				console.log(JSON.stringify([new Date(), 'Error Count Documents', this.collectionName, filter, safeOptions, {
+					code: err.code,
+					codeName: err.codeName,
+					message: err.message,
+					stack: err.stack
+				}], null, 2));
+	
+				err.message = `Error in Count Documents: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+				throw err;
+			}
+			finally {
+				await monitor.finish();
+			}
+		}
+	}
+
+	//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);
+	}
+
+	async createIndex(fieldOrSpec: any, options?: CreateIndexesOptions): Promise<string> {
+		// Check if index already exists based on the key
+
+		try {
+			const dbCollection = ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions);
+			const existingIndexes = await dbCollection.indexes();
+
+			// Check if an index with the same key already exists
+			const indexExists = existingIndexes.some(index => 
+				JSON.stringify(index.key) === JSON.stringify(fieldOrSpec)
+			);
+
+			if (indexExists) {
+				return 'Index already exists'; // Skip creation if index exists
+			}
+
+			return await dbCollection.createIndex(fieldOrSpec, options || undefined);
+		}
+		catch {}
+		
+		return 'Index creation queued';
+	}
+	
+	async createIndexes(indexSpecs: IndexDescription[], options?: CreateIndexesOptions): Promise<string[]> {
+		try {
+			const dbCollection = ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions);
+			const existingIndexes = await dbCollection.indexes();
+
+			// Filter out indexes that already exist based on the key
+			const indexesToCreate = indexSpecs.filter(indexSpec => 
+				!existingIndexes.some(existingIndex => 
+					JSON.stringify(existingIndex.key) === JSON.stringify(indexSpec.key)
+				)
+			);
+
+			// If no new indexes to create, resolve early
+			if (indexesToCreate.length === 0) {
+				return ['All indexes already exist'];
+			}
+
+			return await dbCollection.createIndexes(indexesToCreate, options || undefined);
+		}
+		catch {}
+
+		return ['Index creation queued'];
+	}
+	
+	async deleteMany(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {}, options?: DeleteOptions, bypassLogs = false, bypassSession = false): Promise<DeleteResult> {
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {session: mongoSession};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+		
+		let { session, ...safeOptions } = options || {};
+
+		if ((this.createLogs && !bypassLogs) || this.useVersions) {
+			let docs = await this.find(filter, {session});
+
+			for (let i = 0; i < docs.length; i++) {
+				let doc = docs[i];
+			
+				if (this.createLogs && !bypassLogs) {
+					if (
+						ResolveIOServer.shouldWriteLogsOffline()
+					) {
+						ResolveIOServer.getLocalLogManager().writeLog({
+							type: 'log',
+							data: {
+								_id: objectIdHexString(),
+								type: 'document',
+								collection: this.collectionName,
+								id_document: doc._id,
+								payload: getBinarySize(JSON.stringify([doc, filter, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, safeOptions], null, 2) : 'Too Big',
+								method: 'deleteMany',
+								id_user: '',
+								user: '',
+								messageId: 0,
+								route: '',
+								instance_index: process.env.NODE_APP_INSTANCE || '0',
+								createdAt: new Date()
+							}
+						});
+					}
+					else {
+						await ResolveIOServer.getMainDB().collection('logs').insertOne(<any>{
+							_id: objectIdHexString(),
+							type: 'document',
+							collection: this.collectionName,
+							id_document: doc._id,
+							payload: getBinarySize(JSON.stringify([doc, filter, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, safeOptions], null, 2) : 'Too Big',
+							method: 'deleteMany',
+							id_user: '',
+							user: '',
+							messageId: 0,
+							route: '',
+							client: 'ResolveIO',
+							instance: ResolveIOServer.getInstanceHost(),
+							instance_index: process.env.NODE_APP_INSTANCE || '0',
+							createdAt: new Date()
+						}, {session});
+					}
+				}
+
+				if (this.useVersions) {
+					try {
+						let versionDoc = deepCopy(doc);
+						versionDoc._id = {_id: doc._id, __v: doc.__v};
+
+						await ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne(<any>{_id: { _id: doc._id, __v: doc.__v}}, versionDoc, {upsert: true});
+						await ResolveIOServer.getMongoManager().collection(this.versionCollection).deleteMany(<any>{$and: [{'_id._id': doc._id}, {'_id.__v': {$lt: doc.__v - 1}}]});
+					}
+					catch {}
+				}
+			}
+		}
+
+		let monitor = MonitorMongo.create('deleteMany', this.collectionName, JSON.stringify([filter, safeOptions]));
+
+		try {
+			let res = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).deleteMany(<any>filter, options || undefined);
+			if (!this.skipCache) {
+				ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+			}
+
+			return res;
+		}
+		catch (err) {
+			console.log(JSON.stringify([new Date(), 'Error Delete Many', this.collectionName, filter, safeOptions, {
+				code: err.code,
+				codeName: err.codeName,
+				message: err.message,
+				stack: err.stack
+			}], null, 2));
+
+			err.message = `Error in Delete Many: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+			throw err;
+		}
+		finally {
+			await monitor.finish();
+		}
+	}
+
+	async deleteOne(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {}, options?: FindOneAndDeleteOptions, bypassLogs = false, bypassSession = false): Promise<DeleteResult> {
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {session: mongoSession};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+
+		let { session, ...safeOptions } = options || {};
+
+		if (this.createLogs && !bypassLogs) {
+			let monitor = MonitorMongo.create('findOneAndDelete', this.collectionName, JSON.stringify([filter, safeOptions]));
+			
+			try {
+				let res = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).deleteOne(<any>filter, options || undefined);
+				let doc = await this.findOne(filter, options || undefined);
+
+				if (doc) {
+					if (this.createLogs && !bypassLogs) {
+						if (
+							ResolveIOServer.shouldWriteLogsOffline()
+						) {
+							ResolveIOServer.getLocalLogManager().writeLog({
+								type: 'log',
+								data: {
+									_id: objectIdHexString(),
+									type: 'document',
+									collection: this.collectionName,
+									id_document: doc._id as string,
+									payload: getBinarySize(JSON.stringify([doc, filter, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, safeOptions], null, 2) : 'Too Big',
+									method: 'deleteOne',
+									id_user: '',
+									user: '',
+									messageId: 0,
+									route: '',
+									instance_index: process.env.NODE_APP_INSTANCE || '0',
+									createdAt: new Date()
+								}
+							});
+						}
+						else {
+							await ResolveIOServer.getMainDB().collection('logs').insertOne(<any>{
+								_id: objectIdHexString(),
+								type: 'document',
+								collection: this.collectionName,
+								id_document: doc._id as string,
+								payload: getBinarySize(JSON.stringify([doc, filter, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, safeOptions], null, 2) : 'Too Big',
+								method: 'deleteOne',
+								id_user: '',
+								user: '',
+								messageId: 0,
+								route: '',
+								client: 'ResolveIO',
+								instance: ResolveIOServer.getInstanceHost(),
+								instance_index: process.env.NODE_APP_INSTANCE || '0',
+								createdAt: new Date()
+							}, {session});
+						}
+					}
+
+					if (this.useVersions) {
+						try {
+							let versionDoc = deepCopy(doc);
+							versionDoc._id = {_id: doc._id, __v: doc.__v};
+
+							await ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne(<any>{_id: { _id: doc._id, __v: doc.__v}}, versionDoc, {upsert: true});
+							await ResolveIOServer.getMongoManager().collection(this.versionCollection).deleteMany(<any>{$and: [{'_id._id': doc._id}, {'_id.__v': {$lt: doc.__v - 1}}]});
+						}
+						catch {}
+					}
+
+					if (!this.skipCache) {
+						ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+					}
+				}
+
+				return res;
+			}
+			catch (err) {
+				console.log(JSON.stringify([new Date(), 'Error Delete One (Find One And Delete)', this.collectionName, filter, safeOptions, {
+					code: err.code,
+					codeName: err.codeName,
+					message: err.message,
+					stack: err.stack
+				}], null, 2));
+	
+				err.message = `Error in Delete One (Find One And Delete): ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+				throw err;
+			}
+			finally {
+				await monitor.finish();
+			}
+		}
+		else {
+			let monitor = MonitorMongo.create('deleteOne', this.collectionName, JSON.stringify([filter, safeOptions]));
+
+			try {
+				let res = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).deleteOne(<any>filter, options || undefined);
+				if (!this.skipCache) {
+					ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+				}
+				return res;
+			}
+			catch (err) {
+				console.log(JSON.stringify([new Date(), 'Error Delete One', this.collectionName, filter, safeOptions, {
+					code: err.code,
+					codeName: err.codeName,
+					message: err.message,
+					stack: err.stack
+				}], null, 2));
+	
+				err.message = `Error in Delete One: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+				throw err;
+			}
+			finally {
+				await monitor.finish();
+			}
+		}
+	}
+
+	async distinct(key: string, filter?: MongoManagerFilter<T> & MongoManagerFilterOperators<T>, options?: CommandOperationOptions, bypassSession = false): Promise<T[]> {
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {
+					session: mongoSession
+				};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+
+		let monitor = MonitorMongo.create('distinct', this.collectionName, JSON.stringify([key, filter, safeOptions]));
+
+		try {
+			let res = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).distinct(key, <any>filter, options || undefined);
+			return res;
+		}
+		catch (err) {
+			console.log(JSON.stringify([new Date(), 'Error Distinct', this.collectionName, filter, safeOptions, {
+				code: err.code,
+				codeName: err.codeName,
+				message: err.message,
+				stack: err.stack
+			}], null, 2));
+
+			err.message = `Error in Distinct: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+			throw err;
+		}
+		finally {
+			await monitor.finish();
+		}
+	}
+
+	async drop(options?: CommandOperationOptions, bypassSession = false): Promise<boolean> {
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {
+					session: mongoSession
+				};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+
+		let monitor = MonitorMongo.create('drop', this.collectionName, JSON.stringify([safeOptions]));
+
+		try {
+			let res = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).drop(options);
+			return res;
+		}
+		catch (err) {
+			console.log(JSON.stringify([new Date(), 'Error Drop Collection', this.collectionName, safeOptions, {
+				code: err.code,
+				codeName: err.codeName,
+				message: err.message,
+				stack: err.stack
+			}], null, 2));
+
+			err.message = `Error in Drop Collection: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+			throw err;
+		}
+		finally {
+			await monitor.finish();
+		}
+	}
+
+	async dropIndex(indexName: string, options?: CommandOperationOptions, bypassSession = false): Promise<Document> {
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {
+					session: mongoSession
+				};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+
+		let monitor = MonitorMongo.create('dropIndex', this.collectionName, JSON.stringify([indexName, safeOptions]));
+
+		try {
+			let res = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).dropIndex(indexName, options || undefined);
+			return <Document>res;
+		}
+		catch (err) {
+			console.log(JSON.stringify([new Date(), 'Error Drop Index', this.collectionName, indexName, safeOptions, {
+				code: err.code,
+				codeName: err.codeName,
+				message: err.message,
+				stack: err.stack
+			}], null, 2));
+
+			err.message = `Error in Drop Index: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+			throw err;
+		}
+		finally {
+			await monitor.finish();
+		}
+	}
+
+	async dropIndexes(options?: CommandOperationOptions, bypassSession = false): Promise<boolean> {
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {
+					session: mongoSession
+				};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+
+		let monitor = MonitorMongo.create('dropIndexes', this.collectionName, JSON.stringify([safeOptions]));
+
+		try {
+			let res = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).dropIndexes(options);
+			return res;
+		}
+		catch (err) {
+			console.log(JSON.stringify([new Date(), 'Error Drop Indexes', this.collectionName, safeOptions, {
+				code: err.code,
+				codeName: err.codeName,
+				message: err.message,
+				stack: err.stack
+			}], null, 2));
+
+			err.message = `Error in Drop Indexes: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+			throw err;
+		}
+		finally {
+			await monitor.finish();
+		}
+	}
+
+	async find(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {}, options?: MongoManagerFindOptions, skipCache = false, bypassSession = false): Promise<T[]> {
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {
+					session: mongoSession
+				};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+		 
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+
+		if (!skipCache && !this.skipCache) {
+			return ResolveIOServer.getMongoManager().find(this.collectionName, filter, options || undefined);
+		}
+		else {
+			let monitor = MonitorMongo.create('find', this.collectionName, JSON.stringify([filter, safeOptions]));
+
+		try {
+			let res = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).find<T>(<any>filter, options).toArray();
+			recordDependencyResult(this.collectionName, res, { filter, meta: buildQueryMetaFromFindOptions(safeOptions) });
+			return res;
+		}
+			catch (err) {
+				console.log(JSON.stringify([new Date(), 'Error Find', this.collectionName, filter, safeOptions, {
+					code: err.code,
+					codeName: err.codeName,
+					message: err.message,
+					stack: err.stack
+				}], null, 2));
+	
+				err.message = `Error in Find: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+				throw err;
+			}
+			finally {
+				await monitor.finish();
+			}
+		}
+	}
+
+	async findById(id: string, options?: MongoManagerFindOptions, skipCache = false, bypassSession = false): Promise<T> {
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {
+					session: mongoSession
+				};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+
+		if (!skipCache && !this.skipCache) {
+			return ResolveIOServer.getMongoManager().findOne<T>(this.collectionName, {_id: id}, options || undefined);
+		}
+		else {
+			let monitor = MonitorMongo.create('findById', this.collectionName, JSON.stringify([{_id: id}, safeOptions]));
+			
+		try {
+			let res = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).findOne<T>(<any>{_id: id}, options || undefined);
+			recordDependencyResult(this.collectionName, res, { filter: { _id: id }, meta: buildQueryMetaFromFindOptions(safeOptions) });
+			return res;
+		}
+			catch (err) {
+				console.log(JSON.stringify([new Date(), 'Error Find By ID', this.collectionName, id, safeOptions, {
+					code: err.code,
+					codeName: err.codeName,
+					message: err.message,
+					stack: err.stack
+				}], null, 2));
+	
+				err.message = `Error in Find By ID: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+				throw err;
+			}
+			finally {
+				await monitor.finish();
+			}
+		}
+	}
+
+	async findCount(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {}, options?: MongoManagerFindOptions, bypassSession = false): Promise<Number> {
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {
+					session: mongoSession
+				};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+
+		let monitor = MonitorMongo.create('findCount', this.collectionName, JSON.stringify([filter, safeOptions]));
+
+		try {
+			let res = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).find(<any>filter, options).count();
+			recordDependencyResult(this.collectionName, res, { filter });
+			return res;
+		}
+		catch (err) {
+			console.log(JSON.stringify([new Date(), 'Error Find Count', this.collectionName, filter, safeOptions, {
+				code: err.code,
+				codeName: err.codeName,
+				message: err.message,
+				stack: err.stack
+			}], null, 2));
+
+			err.message = `Error in Find Count: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+			throw err;
+		}
+		finally {
+			await monitor.finish();
+		}
+	}
+
+	findCursor(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {}, options?: MongoManagerFindOptions, bypassSession = false): FindCursor {
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {session: mongoSession};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+		
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+
+		let monitor = MonitorMongo.create('findCursor', this.collectionName, JSON.stringify([filter, safeOptions]));
+		let cursor = ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).find(<any>filter, options || undefined);
+		cursor.on('close', async ev => {
+			await monitor.finish();
+			cursor.removeAllListeners();
+			return ev;
+		});
+
+		return cursor;
+	}
+
+	findStream(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {}, options?: MongoManagerFindOptions, streamOptions?: any, bypassSession = false) {
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {session: mongoSession};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+		
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+		
+		let monitor = MonitorMongo.create('findStream', this.collectionName, JSON.stringify([filter, safeOptions, streamOptions]));
+		let stream = ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).find(<any>filter, options).stream().on('close', async ev => {
+			await monitor.finish();
+			return ev;
+		});
+
+		return stream;
+	}
+
+	async findOne(filter: MongoManagerFilter<T> | MongoManagerFilterOperators<T> = {}, options?: MongoManagerFindOptions, skipCache = false, bypassSession = false): Promise<T> {
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {
+					session: mongoSession
+				};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+
+		if (!skipCache && !this.skipCache) {
+			return ResolveIOServer.getMongoManager().findOne(this.collectionName, filter, options || undefined);
+		}
+		else {
+			// eslint-disable-next-line no-unused-vars
+			let { session, ...safeOptions } = options || {};
+
+			let monitor = MonitorMongo.create('findOne', this.collectionName, JSON.stringify([filter, safeOptions]));
+			
+			try {
+				let res = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).findOne<T>(<any>filter, options || undefined);
+				recordDependencyResult(this.collectionName, res, { filter });
+				return res;
+			}
+			catch (err) {
+				console.log(JSON.stringify([new Date(), 'Error Find One', this.collectionName, filter, safeOptions, {
+					code: err.code,
+					codeName: err.codeName,
+					message: err.message,
+					stack: err.stack
+				}], null, 2));
+	
+				err.message = `Error in Find One: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+				throw err;
+			}
+			finally {
+				await monitor.finish();
+			}
+		}
+	}
+
+	async findOneAndDelete(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {}, options?: FindOneAndDeleteOptions, bypassLogs = false, bypassSession = false): Promise<T> {
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {session: mongoSession};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+
+		let { session, ...safeOptions } = options || {};
+
+		let monitor = MonitorMongo.create('findOneAndDelete', this.collectionName, JSON.stringify([filter, safeOptions]));
+
+		try {
+			let doc = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).findOneAndDelete(<any>filter, options) as T;
+			
+			if (doc) {
+				if (this.createLogs && !bypassLogs) {
+					if (
+						ResolveIOServer.shouldWriteLogsOffline()
+					) {
+						ResolveIOServer.getLocalLogManager().writeLog({
+							type: 'log',
+							data: {
+								_id: objectIdHexString(),
+								type: 'document',
+								collection: this.collectionName,
+								id_document: doc._id as string,
+								payload: getBinarySize(JSON.stringify([doc, filter, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, safeOptions], null, 2) : 'Too Big',
+								method: 'findOneAndDelete',
+								id_user: '',
+								user: '',
+								messageId: 0,
+								route: '',
+								instance_index: process.env.NODE_APP_INSTANCE || '0',
+								createdAt: new Date()
+							}
+						});
+					}
+					else {
+						await ResolveIOServer.getMainDB().collection('logs').insertOne(<any>{
+							_id: objectIdHexString(),
+							type: 'document',
+							collection: this.collectionName,
+							id_document: doc._id as string,
+							payload: getBinarySize(JSON.stringify([doc, filter, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, safeOptions], null, 2) : 'Too Big',
+							method: 'findOneAndDelete',
+							id_user: '',
+							user: '',
+							messageId: 0,
+							route: '',
+							client: 'ResolveIO',
+							instance: ResolveIOServer.getInstanceHost(),
+							instance_index: process.env.NODE_APP_INSTANCE || '0',
+							createdAt: new Date()
+						}, {session});
+					}
+				}
+
+				if (this.useVersions) {
+					try {
+						let versionDoc = deepCopy(doc);
+						versionDoc._id = {_id: doc._id, __v: doc.__v};
+
+						await ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne(<any>{_id: { _id: doc._id, __v: doc.__v}}, versionDoc, {upsert: true});
+					}
+					catch {}
+				}
+
+				if (!this.skipCache) {
+					ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+				}
+
+				return <T>doc;
+			}
+			else {
+				return null;
+			}
+		}
+		catch (err) {
+			console.log(JSON.stringify([new Date(), 'Error Find One And Delete', this.collectionName, filter, safeOptions, {
+				code: err.code,
+				codeName: err.codeName,
+				message: err.message,
+				stack: err.stack
+			}], null, 2));
+
+			err.message = `Error in Find One And Delete: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+			throw err;
+		}
+		finally {
+			await monitor.finish();
+		}
+	}
+
+	async findOneAndReplace(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {}, replacement: T, options?: FindOneAndReplaceOptions, bypassLogs = false, bypassCheckSchema = false, bypassSession = false): Promise<T> {
+		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());
+				await ResolveIOServer.getMainServer().getMethodManager().callMethod('insertErrorLog', 'Schema Failed on findOneAndReplace - ' + this.collectionName, JSON.stringify([validation.validationErrors(), replacement], null, 2));
+				throw new Error(JSON.stringify(validation.validationErrors(), null, 2));
+			}
+		}
+		
+		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;
+			}
+		}
+
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {session: mongoSession};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+
+		let { session, ...safeOptions } = options || {};
+
+		let monitor = MonitorMongo.create('findOneAndReplace', this.collectionName, JSON.stringify([filter, replacement, safeOptions]));
+
+		try {
+			let doc = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).findOneAndReplace(<any>filter, replacement, options) as T;
+
+			if (doc) {
+				if (this.createLogs && !bypassLogs) {
+					if (
+						ResolveIOServer.shouldWriteLogsOffline()
+					) {
+						ResolveIOServer.getLocalLogManager().writeLog({
+							type: 'log',
+							data: {
+								_id: objectIdHexString(),
+								type: 'document',
+								collection: this.collectionName,
+								id_document: doc._id as string,
+								payload: getBinarySize(JSON.stringify([doc, filter, replacement, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, replacement, safeOptions], null, 2) : 'Too Big',
+								method: 'findOneAndReplace',
+								id_user: '',
+								user: '',
+								messageId: 0,
+								route: '',
+								instance_index: process.env.NODE_APP_INSTANCE || '0',
+								createdAt: new Date()
+							}
+						});
+					}
+					else {
+						await ResolveIOServer.getMainDB().collection('logs').insertOne(<any>{
+							_id: objectIdHexString(),
+							type: 'document',
+							collection: this.collectionName,
+							id_document: doc._id as string,
+							payload: getBinarySize(JSON.stringify([doc, filter, replacement, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, replacement, safeOptions], null, 2) : 'Too Big',
+							method: 'findOneAndReplace',
+							id_user: '',
+							user: '',
+							messageId: 0,
+							route: '',
+							client: 'ResolveIO',
+							instance: ResolveIOServer.getInstanceHost(),
+							instance_index: process.env.NODE_APP_INSTANCE || '0',
+							createdAt: new Date()
+						}, {session});
+					}
+				}
+
+				if (this.useVersions) {
+					try {
+						let versionDoc = deepCopy(doc);
+						versionDoc._id = {_id: doc._id, __v: doc.__v};
+
+						await ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne(<any>{_id: { _id: doc._id, __v: doc.__v}}, versionDoc, {upsert: true});
+					}
+					catch {}
+				}
+
+				if (!this.skipCache) {
+					ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+				}
+
+				return <T>doc;
+			}
+			else {
+				return null;
+			}
+		}
+		catch (err) {
+			console.log(JSON.stringify([new Date(), 'Error Find One And Replace', this.collectionName, filter, safeOptions, {
+				code: err.code,
+				codeName: err.codeName,
+				message: err.message,
+				stack: err.stack
+			}], null, 2));
+
+			err.message = `Error in Find One And Replace: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+			throw err;
+		}
+		finally {
+			await monitor.finish();
+		}
+	}
+
+	async findOneAndUpdate(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T> = {}, update: MongoManagerUpdateFilter<T>, options?: FindOneAndUpdateOptions, bypassLogs = false, bypassCheckSchema = false, bypassSession = false): Promise<T> {
+		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());
+				await ResolveIOServer.getMainServer().getMethodManager().callMethod('insertErrorLog', 'Schema Failed on findOneAndUpdate - ' + this.collectionName, JSON.stringify([validation.validationErrors(), update], null, 2));
+				throw new Error(JSON.stringify(validation.validationErrors(), null, 2));
+			}
+		}
+
+		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) {
+					update.$setOnInsert.createdAt = new Date();
+				}
+			}
+		}
+
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {session: mongoSession};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+
+		 
+		let { session, ...safeOptions } = options || {};
+
+		let monitor = MonitorMongo.create('findOneAndUpdate', this.collectionName, JSON.stringify([filter, update, safeOptions]));
+
+		try {
+			let doc = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).findOneAndUpdate(<any>filter, <any>update, options) as T;
+
+			if (doc) {
+				if (this.createLogs && !bypassLogs) {
+					if (
+						ResolveIOServer.shouldWriteLogsOffline()
+					) {	
+						ResolveIOServer.getLocalLogManager().writeLog({
+							type: 'log',
+							data: {
+								_id: objectIdHexString(),
+								type: 'document',
+								collection: this.collectionName,
+								id_document: <string>doc._id,
+								payload: getBinarySize(JSON.stringify([doc, filter, update, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, update, safeOptions], null, 2) : 'Too Big',
+								method: 'findOneAndUpdate',
+								id_user: '',
+								user: '',
+								messageId: 0,
+								route: '',
+								instance_index: process.env.NODE_APP_INSTANCE || '0',
+								createdAt: new Date()
+							}
+						});
+					}
+					else {
+						await ResolveIOServer.getMainDB().collection('logs').insertOne(<any>{
+							_id: objectIdHexString(),
+							type: 'document',
+							collection: this.collectionName,
+							id_document: <string>doc._id,
+							payload: getBinarySize(JSON.stringify([doc, filter, update, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, update, safeOptions], null, 2) : 'Too Big',
+							method: 'findOneAndUpdate',
+							id_user: '',
+							user: '',
+							messageId: 0,
+							route: '',
+							client: 'ResolveIO',
+							instance: ResolveIOServer.getInstanceHost(),
+							instance_index: process.env.NODE_APP_INSTANCE || '0',
+							createdAt: new Date()
+						}, {session});
+					}
+				}
+
+				if (this.useVersions) {
+					try {
+						let versionDoc = deepCopy(doc);
+						versionDoc._id = {_id: doc._id, __v: doc.__v};
+
+						await ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne(<any>{_id: { _id: doc._id, __v: doc.__v}}, versionDoc, {upsert: true});
+					}
+					catch {}
+				}
+
+				if (!this.skipCache) {
+					ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+				}
+				
+				return <T>doc;
+			}
+			else {
+				return null;
+			}
+		}
+		catch (err) {
+			console.log(JSON.stringify([new Date(), 'Error Find One And Update', this.collectionName, filter, safeOptions, {
+				code: err.code,
+				codeName: err.codeName,
+				message: err.message,
+				stack: err.stack
+			}], null, 2));
+
+			err.message = `Error in Find One And Update: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+			throw err;
+		}
+		finally {
+			await monitor.finish();
+		}
+	}
+
+	async indexes(options: IndexInformationOptions): Promise<IndexDescriptionCompact | IndexDescriptionCompact[]> {
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+
+		let monitor = MonitorMongo.create('indexes', this.collectionName, JSON.stringify([safeOptions]));
+
+		try {
+			let res = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).indexes(options);
+			return res;
+		}
+		catch (err) {
+			console.log(JSON.stringify([new Date(), 'Error Indexes', this.collectionName, safeOptions, {
+				code: err.code,
+				codeName: err.codeName,
+				message: err.message,
+				stack: err.stack
+			}], null, 2));
+
+			err.message = `Error in Indexes: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+			throw err;
+		}
+		finally {
+			await monitor.finish();
+		}
+	}
+
+	async indexExists(indexes: string | string[], options?: IndexInformationOptions): Promise<boolean> {
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+
+		let monitor = MonitorMongo.create('indexExists', this.collectionName, JSON.stringify([indexes, safeOptions]));
+
+		try {
+			let res = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).indexExists(indexes, options || undefined);
+			return res;
+		}
+		catch (err) {
+			console.log(JSON.stringify([new Date(), 'Error Index Exists', this.collectionName, indexes, safeOptions, {
+				code: err.code,
+				codeName: err.codeName,
+				message: err.message,
+				stack: err.stack
+			}], null, 2));
+
+			err.message = `Error in Index Exists: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+			throw err;
+		}
+		finally {
+			await monitor.finish();
+		}
+	}
+
+	async insertMany(docs: T[], options?: BulkWriteOptions, bypassLogs = false, bypassCheckSchema = false, bypassMonitor = false, bypassSession = false): Promise<T[]> {
+		if (!docs.length) {
+			return [];
+		}
+		
+		let validationResults = [];
+
+		if (this.checkSchema && !bypassCheckSchema) {
+			for (let doc of docs) {
+				const validation = this.simplschema.newContext();
+				const isValid = validation.validate(doc);
+
+				if (!isValid) {
+					console.log(new Date(), this.collectionName, 'Schema Errors - insertMany', validation.validationErrors());
+					await ResolveIOServer.getMainServer().getMethodManager().callMethod('insertErrorLog', 'Schema Failed on insertMany - ' + this.collectionName, JSON.stringify([validation.validationErrors(), doc], null, 2));
+					validationResults.push(false);
+				}
+				else {
+					validationResults.push(true);
+				}
+			}
+		}
+
+		let validDocs = this.checkSchema ? docs.filter((a, idx) => validationResults[idx]) : docs;
+
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {session: mongoSession};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+
+		 
+		let { session, ...safeOptions } = options || {};
+
+		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();
+
+				if (!doc.createdAt) {
+					doc.createdAt = date;
+				}
+
+				if (!doc.updatedAt) {
+					doc.updatedAt = date;
+				}
+			}
+
+			if (this.useVersions && !doc.hasOwnProperty('__v')) {
+				doc.__v = 0;
+			}
+
+			if (this.createLogs && !bypassLogs) {
+				if (
+					ResolveIOServer.shouldWriteLogsOffline()
+				) {
+					ResolveIOServer.getLocalLogManager().writeLog({
+						type: 'log',
+						data: {
+							_id: objectIdHexString(),
+							type: 'document',
+							collection: this.collectionName,
+							id_document: doc._id,
+							payload: getBinarySize(JSON.stringify([doc, safeOptions])) < 1000000 ? JSON.stringify([doc, safeOptions], null, 2) : 'Too Big',
+							method: 'insertMany',
+							id_user: '',
+							user: '',
+							messageId: 0,
+							route: '',
+							instance_index: process.env.NODE_APP_INSTANCE || '0',
+							createdAt: new Date()
+						}
+					});
+				}
+				else {
+					await ResolveIOServer.getMainDB().collection('logs').insertOne(<any>{
+						_id: objectIdHexString(),
+						type: 'document',
+						collection: this.collectionName,
+						id_document: doc._id,
+						payload: getBinarySize(JSON.stringify([doc, safeOptions])) < 1000000 ? JSON.stringify([doc, safeOptions], null, 2) : 'Too Big',
+						method: 'insertMany',
+						id_user: '',
+						user: '',
+						messageId: 0,
+						route: '',
+						client: 'ResolveIO',
+						instance: ResolveIOServer.getInstanceHost(),
+						instance_index: process.env.NODE_APP_INSTANCE || '0',
+						createdAt: new Date()
+					}, {session});
+				}
+			}
+		}
+
+		if (validDocs.length) {
+			let monitor = null;
+			
+			if (!bypassMonitor) {
+				monitor = MonitorMongo.create('insertMany', this.collectionName, JSON.stringify([validDocs, safeOptions]));
+			}
+			
+			try {
+				await this.retryWrite(() => ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).insertMany(<OptionalUnlessRequiredId<T>[]>validDocs, options || undefined), options);
+				if (!this.skipCache) {
+					ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+				}
+				return validDocs;
+			}
+			catch (err) {
+				console.log(JSON.stringify([new Date(), 'Error Insert Many', this.collectionName, docs, safeOptions, {
+					code: err.code,
+					codeName: err.codeName,
+					message: err.message,
+					stack: err.stack
+				}], null, 2));
+	
+				err.message = `Error in Insert Many: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+				throw err;
+			}
+			finally {
+				if (monitor) {
+					monitor.finish();
+				}
+			}
+		}
+
+		return [];
+	}
+
+	async insertOne(doc: T, options?: InsertOneOptions, bypassLogs = false, bypassCheckSchema = false, bypassSession = false): Promise<T> {
+		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());
+				await ResolveIOServer.getMainServer().getMethodManager().callMethod('insertErrorLog', 'Schema Failed on insertOne - ' + this.collectionName, JSON.stringify([validation.validationErrors(), doc], null, 2));
+				throw new Error(JSON.stringify(validation.validationErrors(), null, 2));
+			}
+		}
+
+		if (this.timestamps) {
+			let date = new Date();
+		
+			if (!doc.createdAt) {
+				doc.createdAt = date;
+			}
+
+			if (!doc.updatedAt) {
+				doc.updatedAt = date;
+			}
+		}
+
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {session: mongoSession};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+
+		 
+		let { session, ...safeOptions } = options || {};
+
+		if (this.createLogs && !bypassLogs) {
+			if (
+				ResolveIOServer.shouldWriteLogsOffline()
+			) {
+				ResolveIOServer.getLocalLogManager().writeLog({
+					type: 'log',
+					data: {
+						_id: objectIdHexString(),
+						type: 'document',
+						collection: this.collectionName,
+						id_document: doc._id,
+						payload: getBinarySize(JSON.stringify([doc, safeOptions])) < 1000000 ? JSON.stringify([doc, safeOptions], null, 2) : 'Too Big',
+						method: 'insertOne',
+						id_user: '',
+						user: '',
+						messageId: 0,
+						route: '',
+						instance_index: process.env.NODE_APP_INSTANCE || '0',
+						createdAt: new Date()
+					}
+				});
+			}
+			else {
+				await ResolveIOServer.getMainDB().collection('logs').insertOne(<any>{
+					_id: objectIdHexString(),
+					type: 'document',
+					collection: this.collectionName,
+					id_document: doc._id,
+					payload: getBinarySize(JSON.stringify([doc, safeOptions])) < 1000000 ? JSON.stringify([doc, safeOptions], null, 2) : 'Too Big',
+					method: 'insertOne',
+					id_user: '',
+					user: '',
+					messageId: 0,
+					route: '',
+					client: 'ResolveIO',
+					instance: ResolveIOServer.getInstanceHost(),
+					instance_index: process.env.NODE_APP_INSTANCE || '0',
+					createdAt: new Date()
+				}, {session});
+			}
+		}
+
+		if (this.useVersions && !doc.hasOwnProperty('__v')) {
+			doc.__v = 0;
+		}
+
+		let monitor = MonitorMongo.create('insertOne', this.collectionName, JSON.stringify([doc, safeOptions]));
+
+		try {
+			await this.retryWrite(() => ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).insertOne(<OptionalUnlessRequiredId<T>>doc, options || undefined), options);
+			if (!this.skipCache) {
+				ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+			}
+			
+			return doc;
+		}
+		catch(err) {
+			console.log(JSON.stringify([new Date(), 'Error Insert One', this.collectionName, doc, safeOptions, {
+				code: err.code,
+				codeName: err.codeName,
+				message: err.message,
+				stack: err.stack
+			}], null, 2));
+
+			err.message = `Error in Insert One: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+			throw err;
+		}
+		finally {
+			await monitor.finish();
+		}
+	}
+
+	listIndexes(options?: ListIndexesOptions, bypassSession = false): ListIndexesCursor {
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {session: mongoSession};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+		
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+
+		let monitor = MonitorMongo.create('listIndexes', this.collectionName, JSON.stringify([safeOptions]));
+		let cursor = ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).listIndexes(options);
+		cursor.on('close', async ev => {
+			await monitor.finish();
+			return ev;
+		});
+
+		return cursor;
+	}
+
+	async rename(newName: string, options?: RenameOptions, bypassSession = false): Promise<Collection<Document>> {
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {
+					session: mongoSession
+				};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+
+		// eslint-disable-next-line no-unused-vars
+		let { session, ...safeOptions } = options || {};
+
+		let monitor = MonitorMongo.create('rename', this.collectionName, JSON.stringify([newName, safeOptions]));
+		try {
+			let res = await ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).rename(newName, options || undefined);
+			return res;
+		}
+		catch (err) {
+			console.log(JSON.stringify([new Date(), 'Error Rename', this.collectionName, newName, safeOptions, {
+				code: err.code,
+				codeName: err.codeName,
+				message: err.message,
+				stack: err.stack
+			}], null, 2));
+
+			err.message = `Error in Rename: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+			throw err;
+		}
+		finally {
+			await monitor.finish();
+		}
+	}
+
+	async replaceOne(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T>, replacement: T, options?: ReplaceOptions, bypassLogs = false, bypassCheckSchema = false, doc: T = null, bypassSession = false) : Promise<UpdateResult> {
+		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());
+				await ResolveIOServer.getMainServer().getMethodManager().callMethod('insertErrorLog', 'Schema Failed on replaceOne - ' + this.collectionName, JSON.stringify([validation.validationErrors(), replacement], null, 2));
+				throw new Error(JSON.stringify(validation.validationErrors(), null, 2));
+			}
+		}
+		
+		let date = new Date();
+		
+		if (this.timestamps) {
+			replacement.updatedAt = date;
+		}
+
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {session: mongoSession};
+			}
+			else {
+				options.session = mongoSession;
+			}
+
+			// console.log('Replace One', 'Has Session', this.collectionName, JSON.stringify(filter, null, 2), JSON.stringify(replacement, null, 2));
+		}
+		else {
+			// console.log('Replace One', 'No Session', this.collectionName, JSON.stringify(filter, null, 2), JSON.stringify(replacement, null, 2));
+		}
+
+		 
+		let { session, ...safeOptions } = options || {};
+
+		if (this.useVersions) {
+			if (!doc) {
+				doc = await this.findOne(<any>filter, {session}, true);
+			}
+
+			if (doc) {
+				if (this.timestamps && !replacement.createdAt && doc.createdAt) {
+					replacement.createdAt = doc.createdAt;
+				}
+
+				if (doc.__v === replacement.__v) {
+					try {
+						replacement.__v += 1;
+
+						let versionDoc = deepCopy(doc);
+						versionDoc._id = {_id: doc._id, __v: doc.__v};
+
+						await ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne(<any>{_id: { _id: doc._id, __v: doc.__v}}, versionDoc, {upsert: true});
+
+						if (doc.__v >= 4) {
+							await ResolveIOServer.getMongoManager().collection(this.versionCollection).deleteMany(<any>{$and: [{'_id._id': doc._id}, {'_id.__v': {$lt: doc.__v - 4}}]});
+						}
+					}
+					catch {}
+
+					if (this.createLogs && !bypassLogs) {
+						if (
+							ResolveIOServer.shouldWriteLogsOffline()
+						) {
+							ResolveIOServer.getLocalLogManager().writeLog({
+								type: 'log',
+								data: {
+									_id: objectIdHexString(),
+									type: 'document',
+									collection: this.collectionName,
+									id_document: doc._id,
+									payload: getBinarySize(JSON.stringify([doc, filter, replacement, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, replacement, safeOptions], null, 2) : 'Too Big',
+									method: 'replaceOne',
+									id_user: '',
+									user: '',
+									messageId: 0,
+									route: '',
+									instance_index: process.env.NODE_APP_INSTANCE || '0',
+									createdAt: new Date()
+								}
+							});
+						}
+						else {
+							await ResolveIOServer.getMainDB().collection('logs').insertOne(<any>{
+								_id: objectIdHexString(),
+								type: 'document',
+								collection: this.collectionName,
+								id_document: doc._id,
+								payload: getBinarySize(JSON.stringify([doc, filter, replacement, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, replacement, safeOptions], null, 2) : 'Too Big',
+								method: 'replaceOne',
+								id_user: '',
+								user: '',
+								messageId: 0,
+								route: '',
+								client: 'ResolveIO',
+								instance: ResolveIOServer.getInstanceHost(),
+								instance_index: process.env.NODE_APP_INSTANCE || '0',
+								createdAt: new Date()
+							}, {session});
+						}
+					}
+					
+					let monitor = MonitorMongo.create('replaceOne', this.collectionName, JSON.stringify([filter, replacement, safeOptions]));
+
+					try {
+						let res = await this.retryWrite(() => ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).replaceOne(<any>filter, replacement, options), options);
+						if (!this.skipCache) {
+							ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+						}
+						return res;
+					}
+					catch (err) {
+						console.log(JSON.stringify([new Date(), 'Error Replace One', this.collectionName, filter, replacement, safeOptions, {
+							code: err.code,
+							codeName: err.codeName,
+							message: err.message,
+							stack: err.stack
+						}], null, 2));
+			
+						err.message = `Error in Replace One: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+						throw err;
+					}
+					finally {
+						await monitor.finish();
+					}
+				}
+				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) {
+							if (
+								ResolveIOServer.shouldWriteLogsOffline()
+							) {
+								ResolveIOServer.getLocalLogManager().writeLog({
+									type: 'log',
+									data: {
+										_id: objectIdHexString(),
+										type: 'document',
+										collection: this.collectionName,
+										id_document: docId,
+										payload: getBinarySize(JSON.stringify(['invalidVersion - merge', doc, filter, updatedDoc, safeOptions])) < 1000000 ? JSON.stringify(['invalidVersion - merge', doc, filter, updatedDoc, safeOptions], null, 2) : 'Too Big',
+										method: 'replaceOne',
+										id_user: '',
+										user: '',
+										messageId: 0,
+										route: '',
+										instance_index: process.env.NODE_APP_INSTANCE || '0',
+										createdAt: new Date()
+									}
+								});
+							}
+							else {
+								await ResolveIOServer.getMainDB().collection('logs').insertOne(<any>{
+									_id: objectIdHexString(),
+									type: 'document',
+									collection: this.collectionName,
+									id_document: docId,
+									payload: getBinarySize(JSON.stringify(['invalidVersion - merge', doc, filter, updatedDoc, safeOptions])) < 1000000 ? JSON.stringify(['invalidVersion - merge', doc, filter, updatedDoc, safeOptions], null, 2) : 'Too Big',
+									method: 'replaceOne',
+									id_user: '',
+									user: '',
+									messageId: 0,
+									route: '',
+									client: 'ResolveIO',
+									instance: ResolveIOServer.getInstanceHost(),
+									instance_index: process.env.NODE_APP_INSTANCE || '0',
+									createdAt: new Date()
+								}, {session});
+							}
+						}
+
+						let monitor = MonitorMongo.create('replaceOne', this.collectionName, JSON.stringify([filter, updatedDoc, safeOptions]));
+
+						try {
+							let res = await this.retryWrite(() => ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).replaceOne(<any>filter, updatedDoc, options), options);
+							if (!this.skipCache) {
+								ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+							}
+							return res;
+						}
+						catch (err) {
+							console.log(JSON.stringify([new Date(), 'Error Replace One', this.collectionName, filter, replacement, safeOptions, {
+								code: err.code,
+								codeName: err.codeName,
+								message: err.message,
+								stack: err.stack
+							}], null, 2));
+				
+							err.message = `Error in Replace One: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+							throw err;
+						}
+						finally {
+							await monitor.finish();
+						}
+					}
+					else {
+						throw new Error('Error in Replace One: 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) {
+					if (
+						ResolveIOServer.shouldWriteLogsOffline()
+					) {
+						ResolveIOServer.getLocalLogManager().writeLog({
+							type: 'log',
+							data: {
+								_id: objectIdHexString(),
+								type: 'document',
+								collection: this.collectionName,
+								id_document: replacement._id,
+								payload: getBinarySize(JSON.stringify(['upsert', filter, replacement, safeOptions])) < 1000000 ? JSON.stringify(['upsert', filter, replacement, safeOptions], null, 2) : 'Too Big',
+								method: 'replaceOne',
+								id_user: '',
+								user: '',
+								messageId: 0,
+								route: '',
+								instance_index: process.env.NODE_APP_INSTANCE || '0',
+								createdAt: new Date()
+							}
+						});
+					}
+					else {
+						await ResolveIOServer.getMainDB().collection('logs').insertOne(<any>{
+							_id: objectIdHexString(),
+							type: 'document',
+							collection: this.collectionName,
+							id_document: replacement._id,
+							payload: getBinarySize(JSON.stringify(['upsert', filter, replacement, safeOptions])) < 1000000 ? JSON.stringify(['upsert', filter, replacement, safeOptions], null, 2) : 'Too Big',
+							method: 'replaceOne',
+							id_user: '',
+							user: '',
+							messageId: 0,
+							route: '',
+							client: 'ResolveIO',
+							instance: ResolveIOServer.getInstanceHost(),
+							instance_index: process.env.NODE_APP_INSTANCE || '0',
+							createdAt: new Date()
+						}, {session});
+					}
+				}
+				
+				let monitor = MonitorMongo.create('replaceOne', this.collectionName, JSON.stringify([filter, replacement, safeOptions]));
+
+				try {
+					let res = await this.retryWrite(() => ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).replaceOne(<any>filter, replacement, options), options);
+					if (!this.skipCache) {
+						ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+					}
+					return res;
+				}
+				catch (err) {
+					console.log(JSON.stringify([new Date(), 'Error Replace One', this.collectionName, filter, replacement, safeOptions, {
+						code: err.code,
+						codeName: err.codeName,
+						message: err.message,
+						stack: err.stack
+					}], null, 2));
+		
+					err.message = `Error in Replace One: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+					throw err;
+				}
+				finally {
+					await monitor.finish();
+				}
+			}
+			else {
+				return {
+					acknowledged: false,
+					matchedCount: 0,
+					modifiedCount: 0,
+					upsertedCount: 0,
+					upsertedId: null
+				};
+			}
+		}
+		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 { session, ...safeOptions } = options || {};
+
+				let monitor = MonitorMongo.create('findOneAndReplace', this.collectionName, JSON.stringify([filter, replacement, safeOptions]));
+
+				try {
+					let res = await this.retryWrite(() => ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).replaceOne(<any>filter, replacement, options), options);
+
+					let doc = await this.findOne(filter, options || undefined);
+
+					if (doc) {
+						if (
+							ResolveIOServer.shouldWriteLogsOffline()
+						) {
+							ResolveIOServer.getLocalLogManager().writeLog({
+								type: 'log',
+								data: {
+									_id: objectIdHexString(),
+									type: 'document',
+									collection: this.collectionName,
+									id_document: <string>doc._id,
+									payload: getBinarySize(JSON.stringify([doc, filter, replacement, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, replacement, safeOptions], null, 2) : 'Too Big',
+									method: 'replaceOne',
+									id_user: '',
+									user: '',
+									messageId: 0,
+									route: '',
+									instance_index: process.env.NODE_APP_INSTANCE || '0',
+									createdAt: new Date()
+								}
+							});
+						}
+						else {
+							await ResolveIOServer.getMainDB().collection('logs').insertOne(<any>{
+								_id: objectIdHexString(),
+								type: 'document',
+								collection: this.collectionName,
+								id_document: <string>doc._id,
+								payload: getBinarySize(JSON.stringify([doc, filter, replacement, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, replacement, safeOptions], null, 2) : 'Too Big',
+								method: 'replaceOne',
+								id_user: '',
+								user: '',
+								messageId: 0,
+								route: '',
+								client: 'ResolveIO',
+								instance: ResolveIOServer.getInstanceHost(),
+								instance_index: process.env.NODE_APP_INSTANCE || '0',
+								createdAt: new Date()
+							}, {session});
+						}
+					}
+					else {
+						if (
+							ResolveIOServer.shouldWriteLogsOffline()
+						) {
+							ResolveIOServer.getLocalLogManager().writeLog({
+								type: 'log',
+								data: {
+									_id: objectIdHexString(),
+									type: 'document',
+									collection: this.collectionName,
+									id_document: replacement._id,
+									payload: getBinarySize(JSON.stringify(['upsert', filter, replacement, safeOptions])) < 1000000 ? JSON.stringify(['upsert', filter, replacement, safeOptions], null, 2) : 'Too Big',
+									method: 'replaceOne',
+									id_user: '',
+									user: '',
+									messageId: 0,
+									route: '',
+									instance_index: process.env.NODE_APP_INSTANCE || '0',
+									createdAt: new Date()
+								}
+							});
+						}
+						else {
+							await ResolveIOServer.getMainDB().collection('logs').insertOne(<any>{
+								_id: objectIdHexString(),
+								type: 'document',
+								collection: this.collectionName,
+								id_document: replacement._id,
+								payload: getBinarySize(JSON.stringify(['upsert', filter, replacement, safeOptions])) < 1000000 ? JSON.stringify(['upsert', filter, replacement, safeOptions], null, 2) : 'Too Big',
+								method: 'replaceOne',
+								id_user: '',
+								user: '',
+								messageId: 0,
+								route: '',
+								client: 'ResolveIO',
+								instance: ResolveIOServer.getInstanceHost(),
+								instance_index: process.env.NODE_APP_INSTANCE || '0',
+								createdAt: new Date()
+							}, {session});
+						}
+					}
+
+					if (!this.skipCache) {
+						ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+					}
+
+					return res;
+				}
+				catch (err) {
+					console.log(JSON.stringify([new Date(), 'Error Replace One (Find One And Replace)', this.collectionName, filter, safeOptions, {
+						code: err.code,
+						codeName: err.codeName,
+						message: err.message,
+						stack: err.stack
+					}], null, 2));
+		
+					err.message = `Error in Replace One (Find One And Replace): ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+					throw err;
+				}
+				finally {
+					await monitor.finish();
+				}
+			}
+			else {
+				let monitor = MonitorMongo.create('replaceOne', this.collectionName, JSON.stringify([filter, replacement, safeOptions]));
+
+				try {
+					let res = await this.retryWrite(() => ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).replaceOne(<any>filter, replacement, options), options);
+					if (!this.skipCache) {
+						ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+					}
+					return res;
+				}
+				catch (err) {
+					console.log(JSON.stringify([new Date(), 'Error Replace One', this.collectionName, filter, replacement, safeOptions, {
+						code: err.code,
+						codeName: err.codeName,
+						message: err.message,
+						stack: err.stack
+					}], null, 2));
+		
+					err.message = `Error in Replace One: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+					throw err;
+				}
+				finally {
+					await monitor.finish();
+				}
+			}
+		}
+	}
+
+	async updateMany(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T>, update: MongoManagerUpdateFilter<T>, options?: UpdateOptions, bypassLogs = false, bypassCheckSchema = false, bypassVersions = false, bypassSession = false) : Promise<UpdateResult> {
+		const isEmptyUpdate = !update.$set && !update.$unset && !update.$inc && !update.$setOnInsert && !update.$push && !update.$pull && !update.$addToSet && !update.$min && !update.$max && !update.$currentDate && !update.$mul && !update.$rename;
+
+		const allEmpty =
+			isEmptyUpdate ||
+			Object.values(update).every(op => {
+				if (!op) {
+					return true;
+				}
+
+				for (let key in op) {
+					if (Object.prototype.hasOwnProperty.call(op, key)) {
+						return false;
+					}
+				}
+
+				return true;
+			});
+
+		if (allEmpty) {
+			return {
+				acknowledged: false,
+				matchedCount: 0,
+				modifiedCount: 0,
+				upsertedCount: 0,
+				upsertedId: null
+			};
+		}
+		
+		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());
+				await ResolveIOServer.getMainServer().getMethodManager().callMethod('insertErrorLog', 'Schema Failed on updateMany - ' + this.collectionName, JSON.stringify([validation.validationErrors(), update], null, 2));
+				throw new Error(JSON.stringify(validation.validationErrors(), null, 2));
+			}
+		}
+
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {session: mongoSession};
+			}
+			else {
+				options.session = mongoSession;
+			}
+		}
+
+		 
+		let { session, ...safeOptions } = options || {};
+
+		if ((this.useVersions && !bypassVersions) || (this.createLogs && !bypassLogs)) {
+			let docs = await this.find(filter, {session});
+
+			for (let i = 0; i < docs.length; i++) {
+				let doc = docs[i];
+
+				if (this.createLogs && !bypassLogs) {
+					if (
+						ResolveIOServer.shouldWriteLogsOffline()
+					) {
+						ResolveIOServer.getLocalLogManager().writeLog({
+							type: 'log',
+							data: {
+								_id: objectIdHexString(),
+								type: 'document',
+								collection: this.collectionName,
+								id_document: doc._id,
+								payload: getBinarySize(JSON.stringify([doc, filter, update, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, update, safeOptions], null, 2) : 'Too Big',
+								method: 'updateMany',
+								id_user: '',
+								user: '',
+								messageId: 0,
+								route: '',
+								instance_index: process.env.NODE_APP_INSTANCE || '0',
+								createdAt: new Date()
+							}
+						});
+					}
+					else {
+						await ResolveIOServer.getMainDB().collection('logs').insertOne(<any>{
+							_id: objectIdHexString(),
+							type: 'document',
+							collection: this.collectionName,
+							id_document: doc._id,
+							payload: getBinarySize(JSON.stringify([doc, filter, update, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, update, safeOptions], null, 2) : 'Too Big',
+							method: 'updateMany',
+							id_user: '',
+							user: '',
+							messageId: 0,
+							route: '',
+							client: 'ResolveIO',
+							instance: ResolveIOServer.getInstanceHost(),
+							instance_index: process.env.NODE_APP_INSTANCE || '0',
+							createdAt: new Date()
+						}, {session});
+					}
+				}
+
+				if (this.useVersions) {
+					try {
+						let versionDoc = deepCopy(doc);
+						versionDoc._id = {_id: doc._id, __v: doc.__v};
+		
+						await ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne(<any>{_id: { _id: doc._id, __v: doc.__v}}, versionDoc, {upsert: true});
+						
+						if (doc.__v >= 4) {
+							await ResolveIOServer.getMongoManager().collection(this.versionCollection).deleteMany(<any>{$and: [{'_id._id': doc._id}, {'_id.__v': {$lt: doc.__v - 4}}]});
+						}
+					}
+					catch {}
+	
+					if (!update.$inc) {
+						update.$inc = {};
+					}
+					
+					if (typeof update.$inc.__v !== 'number') {
+						update.$inc.__v = 1;
+					}
+					
+					// Managed versioned collections own __v updates.
+					stripManagedVersionFields(update);
+				}
+			}
+		}
+
+		let monitor = MonitorMongo.create('updateMany', this.collectionName, JSON.stringify([filter, update, safeOptions]));
+
+		try {
+			let res = await this.retryWrite<UpdateResult>(() => ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).updateMany(<any>filter, <any>update, options), options);
+			if (!this.skipCache) {
+				ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+			}
+
+			return res;
+		}
+		catch (err) {
+			console.log(JSON.stringify([new Date(), 'Error Update Many', this.collectionName, filter, update, safeOptions, {
+				code: err.code,
+				codeName: err.codeName,
+				message: err.message,
+				stack: err.stack
+			}], null, 2));
+
+			err.message = `Error in Update Many: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+			throw err;
+		}
+		finally {
+			await monitor.finish();
+		}
+	}
+
+	async updateOne(filter: MongoManagerFilter<T> & MongoManagerFilterOperators<T>, update: MongoManagerUpdateFilter<T>, options?: UpdateOptions, bypassLogs = false, bypassCheckSchema = false, bypassSession = false) : Promise<UpdateResult> {
+		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());
+				await ResolveIOServer.getMainServer().getMethodManager().callMethod('insertErrorLog', 'Schema Failed on updateOne - ' + this.collectionName, JSON.stringify([validation.validationErrors(), update], null, 2));
+				throw new Error(JSON.stringify(validation.validationErrors(), null, 2));
+			}
+		}
+
+		const isEmptyUpdate = !update.$set && !update.$unset && !update.$inc && !update.$setOnInsert && !update.$push && !update.$pull && !update.$addToSet && !update.$min && !update.$max && !update.$currentDate && !update.$mul && !update.$rename;
+
+		const allEmpty =
+			isEmptyUpdate ||
+			Object.values(update).every(op => {
+				if (!op) {
+					return true;
+				}
+
+				for (let key in op) {
+					if (Object.prototype.hasOwnProperty.call(op, key)) {
+						return false;
+					}
+				}
+
+				return true;
+			});
+
+		if (allEmpty) {
+			return {
+				acknowledged: false,
+				matchedCount: 0,
+				modifiedCount: 0,
+				upsertedCount: 0,
+				upsertedId: null
+			};
+		}
+
+
+		let date = new Date();
+
+		if (this.timestamps) {
+			if (!update.$set) {
+				update.$set = <any>{updatedAt: date};
+			}
+			else {
+				update.$set.updatedAt = date;
+			}
+		}
+
+		const mongoSession = ResolveIOServer.getMongoManager().getSession();
+
+		if (mongoSession && !bypassSession && !this.bypassSession && (!options || ((!options.readPreference || options.readPreference === 'primary') && !options.session))) {
+			if (!options) {
+				options = {session: mongoSession};
+			}
+			else {
+				options.session = mongoSession;
+			}
+			// console.log('Update One', 'Has Session', this.collectionName, JSON.stringify(filter, null, 2), JSON.stringify(update, null, 2));
+		}
+		else {
+			// console.log('Update One', 'No Session', this.collectionName, JSON.stringify(filter, null, 2), JSON.stringify(update, null, 2));
+		}
+
+		let { session, ...safeOptions } = options || {};
+		
+		if (this.useVersions) {
+			let doc = await this.findOne(filter, {session}, true);
+
+			if (doc) {
+				if (this.createLogs && !bypassLogs) {
+					if (
+						ResolveIOServer.shouldWriteLogsOffline()
+					) {
+						ResolveIOServer.getLocalLogManager().writeLog({
+							type: 'log',
+							data: {
+								_id: objectIdHexString(),
+								type: 'document',
+								collection: this.collectionName,
+								id_document: doc._id,
+								payload: getBinarySize(JSON.stringify([doc, filter, update, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, update, safeOptions], null, 2) : 'Too Big',
+								method: 'updateOne',
+								id_user: '',
+								user: '',
+								messageId: 0,
+								route: '',
+								instance_index: process.env.NODE_APP_INSTANCE || '0',
+								createdAt: new Date()
+							}
+						});
+					}
+					else {
+						await ResolveIOServer.getMainDB().collection('logs').insertOne(<any>{
+							_id: objectIdHexString(),
+							type: 'document',
+							collection: this.collectionName,
+							id_document: doc._id,
+							payload: getBinarySize(JSON.stringify([doc, filter, update, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, update, safeOptions], null, 2) : 'Too Big',
+							method: 'updateOne',
+							id_user: '',
+							user: '',
+							messageId: 0,
+							route: '',
+							client: 'ResolveIO',
+							instance: ResolveIOServer.getInstanceHost(),
+							instance_index: process.env.NODE_APP_INSTANCE || '0',
+							createdAt: new Date()
+						}, {session});
+					}
+				}
+
+				try {
+					let versionDoc = deepCopy(doc);
+					versionDoc._id = {_id: doc._id, __v: doc.__v};
+
+					await ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne(<any>{_id: { _id: doc._id, __v: doc.__v}}, versionDoc, {upsert: true});
+					
+					if (doc.__v >= 4) {
+						await ResolveIOServer.getMongoManager().collection(this.versionCollection).deleteMany(<any>{$and: [{'_id._id': doc._id}, {'_id.__v': {$lt: doc.__v - 4}}]});
+					}
+				}
+				catch {}
+
+				if (!update.$inc) {
+					update.$inc = {};
+				}
+				
+				if (typeof update.$inc.__v !== 'number') {
+					update.$inc.__v = 1;
+				}
+				
+				// Managed versioned collections own __v updates.
+				stripManagedVersionFields(update);
+				
+				let monitor = MonitorMongo.create('updateOne', this.collectionName, JSON.stringify([filter, update, safeOptions]));
+
+				try {
+					let res = await this.retryWrite(() => ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).updateOne(<any>filter, <any>update, options || undefined), options);
+					if (!this.skipCache) {
+						ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+					}
+					return res;
+				}
+				catch (err) {
+					console.log(JSON.stringify([new Date(), 'Error Update One', this.collectionName, filter, update, safeOptions, {
+						code: err.code,
+						codeName: err.codeName,
+						message: err.message,
+						stack: err.stack
+					}], null, 2));
+		
+					err.message = `Error in Update One: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+					throw err;
+				}
+				finally {
+					await monitor.finish();
+				}
+			}
+			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) {
+						update.$setOnInsert.createdAt = new Date();
+					}
+				}
+
+				if (this.createLogs && !bypassLogs) {
+					if (
+						ResolveIOServer.shouldWriteLogsOffline()
+					) {
+						ResolveIOServer.getLocalLogManager().writeLog({
+							type: 'log',
+							data: {
+								_id: objectIdHexString(),
+								type: 'document',
+								collection: this.collectionName,
+								id_document: update.$setOnInsert._id,
+								payload: getBinarySize(JSON.stringify(['upsert', filter, update, safeOptions])) < 1000000 ? JSON.stringify(['upsert', filter, update, safeOptions], null, 2) : 'Too Big',
+								method: 'updateOne',
+								id_user: '',
+								user: '',
+								messageId: 0,
+								route: '',
+								instance_index: process.env.NODE_APP_INSTANCE || '0',
+								createdAt: new Date()
+							}
+						});
+					}
+					else {
+						await ResolveIOServer.getMainDB().collection('logs').insertOne(<any>{
+							_id: objectIdHexString(),
+							type: 'document',
+							collection: this.collectionName,
+							id_document: update.$setOnInsert._id,
+							payload: getBinarySize(JSON.stringify(['upsert', filter, update, safeOptions])) < 1000000 ? JSON.stringify(['upsert', filter, update, safeOptions], null, 2) : 'Too Big',
+							method: 'updateOne',
+							id_user: '',
+							user: '',
+							messageId: 0,
+							route: '',
+							client: 'ResolveIO',
+							instance: ResolveIOServer.getInstanceHost(),
+							instance_index: process.env.NODE_APP_INSTANCE || '0',
+							createdAt: new Date()
+						}, {session});
+					}
+				}
+				
+				let monitor = MonitorMongo.create('updateOne', this.collectionName, JSON.stringify([filter, update, safeOptions]));
+
+				try {
+					let res = await this.retryWrite(() => ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).updateOne(<any>filter, <any>update, options || undefined), options);
+					if (!this.skipCache) {
+						ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+					}
+					return res;
+				}
+				catch (err) {
+					console.log(JSON.stringify([new Date(), 'Error Update One', this.collectionName, filter, safeOptions, {
+						code: err.code,
+						codeName: err.codeName,
+						message: err.message,
+						stack: err.stack
+					}], null, 2));
+		
+					err.message = `Error in Update One: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+					throw err;
+				}
+				finally {
+					await monitor.finish();
+				}
+			}
+			else {
+				return {
+					acknowledged: false,
+					matchedCount: 0,
+					modifiedCount: 0,
+					upsertedCount: 0,
+					upsertedId: null
+				};
+			}
+		}
+		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) {
+						update.$setOnInsert.createdAt = new Date();
+					}
+				}
+			}
+
+			if (this.createLogs && !bypassLogs) {
+				if (!options) {
+					options = <FindOneAndUpdateOptions>{returnDocument: 'before'};
+				}
+				else {
+					(<FindOneAndUpdateOptions>options).returnDocument = 'before';
+				}
+
+				let monitor = MonitorMongo.create('findOneAndUpdate', this.collectionName, JSON.stringify([filter, update, safeOptions]));
+
+				try {
+					let res = await this.retryWrite(() => ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).updateOne(<any>filter, <any>update, options || undefined), options);
+
+					let doc = await this.findOne(filter, options || undefined);
+
+					if (doc) {
+						if (
+							ResolveIOServer.shouldWriteLogsOffline()
+						) {
+							ResolveIOServer.getLocalLogManager().writeLog({
+								type: 'log',
+								data: {
+									_id: objectIdHexString(),
+									type: 'document',
+									collection: this.collectionName,
+									id_document: <any>doc._id,
+									payload: getBinarySize(JSON.stringify([doc, filter, update, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, update, safeOptions], null, 2) : 'Too Big',
+									method: 'updateOne',
+									id_user: '',
+									user: '',
+									messageId: 0,
+									route: '',
+									instance_index: process.env.NODE_APP_INSTANCE || '0',
+									createdAt: new Date()
+								}
+							});
+						}
+						else {
+							await ResolveIOServer.getMainDB().collection('logs').insertOne(<any>{
+								_id: objectIdHexString(),
+								type: 'document',
+								collection: this.collectionName,
+								id_document: <any>doc._id,
+								payload: getBinarySize(JSON.stringify([doc, filter, update, safeOptions])) < 1000000 ? JSON.stringify([doc, filter, update, safeOptions], null, 2) : 'Too Big',
+								method: 'updateOne',
+								id_user: '',
+								user: '',
+								messageId: 0,
+								route: '',
+								client: 'ResolveIO',
+								instance: ResolveIOServer.getInstanceHost(),
+								instance_index: process.env.NODE_APP_INSTANCE || '0',
+								createdAt: new Date()
+							}, {session});
+						}
+
+						return res;
+					}
+					else if (update.$setOnInsert) {
+						if (
+							ResolveIOServer.shouldWriteLogsOffline()
+						) {
+							ResolveIOServer.getLocalLogManager().writeLog({
+								type: 'log',
+								data: {
+									_id: objectIdHexString(),
+									type: 'document',
+									collection: this.collectionName,
+									id_document: update.$setOnInsert._id,
+									payload: getBinarySize(JSON.stringify(['upsert', filter, update, safeOptions])) < 1000000 ? JSON.stringify(['upsert', filter, update, safeOptions], null, 2) : 'Too Big',
+									method: 'updateOne',
+									id_user: '',
+									user: '',
+									messageId: 0,
+									route: '',
+									instance_index: process.env.NODE_APP_INSTANCE || '0',
+									createdAt: new Date()
+								}
+							});
+						}
+						else {
+							await ResolveIOServer.getMainDB().collection('logs').insertOne(<any>{
+								_id: objectIdHexString(),
+								type: 'document',
+								collection: this.collectionName,
+								id_document: update.$setOnInsert._id,
+								payload: getBinarySize(JSON.stringify(['upsert', filter, update, safeOptions])) < 1000000 ? JSON.stringify(['upsert', filter, update, safeOptions], null, 2) : 'Too Big',
+								method: 'updateOne',
+								id_user: '',
+								user: '',
+								messageId: 0,
+								route: '',
+								client: 'ResolveIO',
+								instance: ResolveIOServer.getInstanceHost(),
+								instance_index: process.env.NODE_APP_INSTANCE || '0',
+								createdAt: new Date()
+							});
+						}
+
+						if (!this.skipCache) {
+							ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+						}
+					}
+					
+					return res;
+				}
+				catch (err) {
+					console.log(JSON.stringify([new Date(), 'Error Update One (Find One And Update)', this.collectionName, filter, safeOptions, {
+						code: err.code,
+						codeName: err.codeName,
+						message: err.message,
+						stack: err.stack
+					}], null, 2));
+		
+					err.message = `Error in Update One (Find One And Update): ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+					throw err;
+				}
+				finally {
+					await monitor.finish();
+				}
+			}
+			else {
+				let monitor = MonitorMongo.create('updateOne', this.collectionName, JSON.stringify([filter, update, safeOptions]));
+
+				try {
+					let res = await this.retryWrite(() => ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).updateOne(<any>filter, <any>update, options || undefined), options);
+					if (!this.skipCache) {
+						ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+					}
+					return res;
+				}
+				catch (err) {
+					console.log(JSON.stringify([new Date(), 'Error Update One', this.collectionName, filter, update, safeOptions, {
+						code: err.code,
+						codeName: err.codeName,
+						message: err.message,
+						stack: err.stack
+					}], null, 2));
+		
+					err.message = `Error in Update One: ${this.collectionName} => ${err.codeName || 'NoCodeName'} => ${err.message}`;
+					throw err;
+				}
+				finally {
+					await monitor.finish();
+				}
+			}
+		}
+	}
+	
+	watchCollection(pipeline = [], options?: ChangeStreamOptions, bypassSession = false): ChangeStream<T> {
+		const session = ResolveIOServer.getMongoManager().getSession();
+		if (session && !bypassSession && !this.bypassSession) {
+			if (!options) {
+				options = {session};
+			}
+			else {
+				options.session = session;
+			}
+		}
+		
+		let stream = ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).watch(pipeline, options || undefined);
+		return <ChangeStream<T>>stream;
+	}
+}
+
+export class MongoManagerUserCollection<T extends CollectionDocument> extends MongoManagerCollection<T> {
+	static create(options: MongoManagerCollectionOptions) {
+		const mongoManagerCollection = new MongoManagerUserCollection();
+		mongoManagerCollection.initialize(options);
+		return mongoManagerCollection;
+	}
+	
+	async authenticate(user: UserModel, password: string): Promise<{data: UserModel, error: string}> {
+		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}});
+				return {
+					data: null,
+					error: 'Attempt Too Soon'
+				};
+			}
+		}
+		else {
+			user.last = new Date();
+		}
+	
+		if (user.attempts >= 5) {
+			return {
+				data: null,
+				error: 'Too Many Attempts'
+			};
+		}
+		
+		if (!user.salt) {
+			return {
+				data: null,
+				error: 'No Salt Value Stored'
+			};
+		}
+
+		try {
+			let hashBuffer = await pbkdf2Promisified(password, user.salt, {
+				iterations: 25000,
+				keylen: 512,
+				digestAlgorithm: 'sha256'
+			});
+
+			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}});
+
+				return {
+					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) {
+					return {
+						data: null,
+						error: 'Too Many Attempts'
+					};
+				}
+				else {
+					return {
+						data: null,
+						error: 'Invalid Username And Password'
+					};
+				}
+			}
+		}
+		catch (err) {
+			err.message = `Error in User Authenticate: ${JSON.stringify(user, null, 2)} - ${err.message}`;
+			throw err;
+		}
+	}
+
+	serializeUser() {
+		return (user, cb) => {
+			cb(null, user.username);
+		};
+	}
+
+	deserializeUser() {
+		return async (username) => {
+			return Users.findOne({username: username});
+		};
+	}
+
+	async setPassword(user: UserModel, password: string) {
+		if (!user) {
+			throw new Error('Error In User Set Password: No User');
+		}
+		else if (!password) {
+			throw new Error('Error In User Set Password: No Password');
+		}
+		else {
+			let saltBuffer = await randomBytes(32);
+			let salt = saltBuffer.toString('hex');
+			try {
+				let hashRaw = await pbkdf2Promisified(password, salt, {
+					iterations: 25000,
+					keylen: 512,
+					digestAlgorithm: 'sha256'
+				});
+				let hash = Buffer.from(hashRaw, 'binary').toString('hex');
+
+				const res = await Users.updateOne({_id: user._id}, {$set: {hash: hash, salt: salt, services: {}, attempts: 0}});
+				await saveCustomerPortalPassword(user, password);
+				return res;
+			}
+			catch (err) {
+				err.message = `Error in User Set Password: ${JSON.stringify(user, null, 2)} - ${err.message}`;
+				throw err;
+			}
+		}
+	};
+
+	async changePassword(user, oldPassword, newPassword) {
+		if (!user) {
+			throw new Error('Error in User Change Password: Missing User');
+		}
+		else if (!oldPassword || !newPassword) {
+			throw new Error('Error in User Change Password: Missing Password');
+		}
+		else {
+			let authUser = await this.authenticate(user, oldPassword);
+
+			if (!authUser['data']) {
+				throw authUser['error'];
+			}
+			else {
+				return this.setPassword(user, newPassword);
+			}
+		}
+	}
+	
+	async register(user, password) {
+		if (!user.username) {
+			throw new Error('Error in User Register: Missing Username');
+		}
+		else {
+			let dbUser = await Users.findOne({username: user.username});
+			
+			if (dbUser) {
+				throw new Error('Error in User Register: Username Exists');
+			}
+			else {
+				dbUser = await Users.findOne({email: user.email});
+
+				if (dbUser) {
+					throw new Error('Error in User Register: Email Exists');
+				}
+				else {
+					user.setPassword(password);
+					return user;
+				}
+			}
+		}
+	}
+
+	resetAttempts(user: UserModel) {
+		return Users.updateOne({_id: user._id}, {$set: {attempts: 0}});
+	}
+}
+
+function pbkdf2(password, salt, options, callback) {
+	crypto.pbkdf2(password, salt, options.iterations, options.keylen, options.digestAlgorithm, callback);
+};
+
+function pbkdf2Promisified(password, salt, options): Promise<any> {
+	// eslint-disable-next-line no-restricted-syntax
+	return new Promise((resolve, reject) => pbkdf2(password, salt, options, (err, hashRaw) => (err ? reject(err) : resolve(hashRaw))));
+}
+
+function randomBytes(saltlen): Promise<Buffer> {
+	// eslint-disable-next-line no-restricted-syntax
+	return new Promise((resolve, reject) => crypto.randomBytes(saltlen, (err, saltBuffer) => (err ? reject(err) : resolve(saltBuffer))));
+}