@resolveio/server-lib 22.3.221 → 22.3.222

package/src/managers/mongo.manager.ts

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