@resolveio/server-lib 22.2.34 → 22.2.36

package/src/managers/method.manager.ts

@@ -1,1557 +0,0 @@
-import { S3 } from '@aws-sdk/client-s3';
-import { SESv2Client, SendEmailCommand } from '@aws-sdk/client-sesv2';
-import { EventEmitter, once } from 'events';
-import * as fs from 'fs';
-import * as nodemailer from 'nodemailer';
-import * as path from 'path';
-import { setTimeout as delay } from 'timers/promises';
-import { EmailHistories } from '../collections/email-history.collection';
-import { Flags } from '../collections/flag.collection';
-import { Logs } from '../collections/log.collection';
-import { loadServerCronJobs } from '../fixtures/cron-jobs';
-import { loadServerInit } from '../fixtures/init';
-import { loadAccountMethods } from '../methods/accounts';
-import { loadAppSettingsMethods } from '../methods/app-settings';
-import { loadAWSMethods } from '../methods/aws';
-import { loadAiTerminalMethods } from '../methods/ai-terminal';
-import { loadCollectionMethods } from '../methods/collections';
-import { loadCustomerNotificationMethods } from '../methods/customer-notifications';
-import { loadCounterMethods } from '../methods/counters';
-import { loadCronJobMethods } from '../methods/cron-jobs';
-import { loadDiagnosticMethods } from '../methods/diagnostics';
-import { loadFlagUpdatesMethods } from '../methods/flag-updates';
-import { loadFlagMethods } from '../methods/flags';
-import { loadLogMethods } from '../methods/logs';
-import { loadMonitorMethods } from '../methods/monitor';
-import { loadMongoExplorerMethods } from '../methods/mongo-explorer';
-import { loadPublicationMethods } from '../methods/publications';
-import { loadPDFMethods } from '../methods/pdf';
-import { loadReportBuilderMethods } from '../methods/report-builder';
-import { loadSupportMethods } from '../methods/support';
-import { EmailHistoryModel, EmailHistoryOccurrence } from '../models/email-history.model';
-import { MethodAllModel, MethodModel } from '../models/method.model';
-import { ResolveIOServer } from '../resolveio-server-app';
-import { getBinarySize, objectIdHexString } from '../util/common';
-import { ErrorReporter } from '../util/error-reporter';
-import { ensureErrorWithCorrelation, getCorrelationId, runWithCorrelationContext } from '../util/error-tracking';
-import { MonitorManagerFunction } from './monitor.manager';
-import { WebSocketManager } from './websocket.manager';
-import { recordEmailMetric, recordTextMessageMetric } from './communication-metric.manager';
-
-interface SendEmailOptions {
-	correlationId?: string;
-	meta?: Record<string, any>;
-}
-
-function appendCorrelationIdToSubject(subject: string, correlationId?: string): string {
-	if (!correlationId) {
-		return subject;
-	}
-
-	const correlationTag = `[${correlationId}]`;
-
-	if (subject && subject.includes(correlationTag)) {
-		return subject;
-	}
-
-	return `${subject} ${correlationTag}`.trim();
-}
-
-function createEmailOccurrence(subject: string, text?: string, html?: string, meta?: Record<string, any>): EmailHistoryOccurrence {
-	return {
-		_id: objectIdHexString(),
-		createdAt: new Date(),
-		subject,
-		text,
-		html,
-		meta
-	};
-}
-
-function formatGroupedEmailContent(correlationId: string, occurrences: EmailHistoryOccurrence[]): { text: string; html: string } {
-	const lines: string[] = [];
-	lines.push(`Correlation ID: ${correlationId}`);
-
-	occurrences.forEach((occurrence, index) => {
-		const timestamp = occurrence.createdAt instanceof Date ? occurrence.createdAt.toISOString() : new Date(occurrence.createdAt).toISOString();
-		lines.push('');
-		lines.push(`Occurrence #${index + 1} (${timestamp})`);
-		lines.push(`Subject: ${occurrence.subject}`);
-		if (occurrence.text) {
-			lines.push(occurrence.text);
-		}
-	});
-
-	const htmlSections = occurrences.map((occurrence, index) => {
-		const timestamp = occurrence.createdAt instanceof Date ? occurrence.createdAt.toISOString() : new Date(occurrence.createdAt).toISOString();
-		const escapedText = occurrence.text ? occurrence.text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;') : '';
-		return `<div><h4>Occurrence #${index + 1} (${timestamp})</h4><p><strong>Subject:</strong> ${occurrence.subject}</p>${escapedText ? `<pre>${escapedText}</pre>` : ''}</div>`;
-	});
-
-	const html = [
-		`<p><strong>Correlation ID:</strong> ${correlationId}</p>`,
-		...htmlSections
-	].join('');
-
-	return {
-		text: lines.join('\n'),
-		html
-	};
-}
-
-function createNodeMailerSESV2Transport(sesClient: SESv2Client): nodemailer.Transporter {
-	const transport: any = {
-		name: 'resolveio-sesv2-transport',
-		version: '1.0.0',
-		send: (mail: any, callback: any) => {
-			const stream = mail.message.createReadStream();
-			const chunks: Uint8Array[] = [];
-			let didFinish = false;
-
-			const finish = (error: any, info?: any) => {
-				if (didFinish) {
-					return;
-				}
-
-				didFinish = true;
-				callback(error, info);
-			};
-
-			stream.on('data', (chunk) => {
-				const chunkData = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-				chunks.push(new Uint8Array(chunkData));
-			});
-
-			stream.on('error', (error) => {
-				finish(error);
-			});
-
-			stream.on('end', async () => {
-				try {
-					const rawData = Buffer.concat(chunks);
-					const rawMessageData = new Uint8Array(rawData);
-					const envelope = typeof mail.message.getEnvelope === 'function' ? mail.message.getEnvelope() : mail.data?.envelope;
-
-					const fromEmailAddress = envelope?.from || undefined;
-					const toAddresses = envelope?.to
-						? (Array.isArray(envelope.to) ? envelope.to : [envelope.to]).filter(Boolean)
-						: [];
-
-					const replyToAddresses = mail.data?.replyTo
-						? (Array.isArray(mail.data.replyTo) ? mail.data.replyTo : [mail.data.replyTo]).filter(Boolean)
-						: undefined;
-
-					const response = await sesClient.send(new SendEmailCommand({
-						FromEmailAddress: fromEmailAddress,
-						Destination: toAddresses.length ? { ToAddresses: toAddresses } : undefined,
-						ReplyToAddresses: replyToAddresses,
-							Content: {
-								Raw: {
-									Data: rawMessageData
-								}
-							}
-						}));
-
-					finish(null, {
-						envelope,
-						messageId: response.MessageId,
-						response: response.MessageId
-					});
-				}
-				catch (error) {
-					finish(error);
-				}
-			});
-		}
-	};
-
-	return nodemailer.createTransport(transport);
-}
-
-export class AWS {
-	private _s3: S3 = null;
-	private _s3USEast1: S3 = null;
-
-	constructor() {}
-
-	public create() {
-		const aws = new AWS();
-		aws.initialize();
-		return aws;
-	}
-
-	private initialize() {
-
-	}
-
-	public s3(): S3 {
-		if (this._s3) {
-			return this._s3;
-		}
-
-		this._s3 = new S3({
-			credentials: {
-				accessKeyId: process.env.AWS_ACCESS_KEY,
-				secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
-			},
-			region: process.env.AWS_REGION,
-			apiVersion: '2006-03-01'
-		});
-
-		return this._s3;
-	}
-
-	public s3USEast1(): S3 {
-		if (process.env.AWS_REGION === 'us-east-1') {
-			return this.s3();
-		}
-		else {
-			if (this._s3USEast1) {
-				return this._s3USEast1;
-			}
-			
-			this._s3USEast1 = new S3({
-				credentials: {
-					accessKeyId: process.env.AWS_ACCESS_KEY,
-					secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
-				},
-				region: 'us-east-1',
-				apiVersion: '2006-03-01'
-			});
-	
-			return this._s3USEast1;
-		}
-	}
-}
-
-export class MethodManager {
-	private _websocketManager: WebSocketManager;
-	public _methods: MethodModel = {};
-	private _mailerSES: nodemailer.Transporter;
-	private _mailerCustom: nodemailer.Transporter;
-	private _aws: AWS;
-	private _monitorManagerFunction: MonitorManagerFunction;
-	private _isWorkersEnabled = false;
-	private _isWorkerInstance = false;
-
-	private emailQueue: Set<string> = new Set(); // Set to store pending email IDs
-	private isEmailProcessing = false;
-	private readonly _emailProcessingDelayMs = 5000;
-
-	private _debugcallMethodHits = 0;
-	private _debugCallMethodHits = 0;
-	private _debugCallMethodCronJobHits = 0;
-	private _debugSendQueueHits = 0;
-	private _enableDebug = false;
-	private _ready = false;
-	private _readyEmitter = new EventEmitter();
-	private _readyError: any = null;
-
-	private _localActiveCounts: Map<string, number> = new Map();
-	private _localWaitQueues: Map<string, Array<() => void>> = new Map();
-
-	public clientDir = '';
-	public serverConfig: Record<string, any> = {};
-
-	constructor() {}
-
-	static create(websocketManager: WebSocketManager, monitorManagerFunction: MonitorManagerFunction, isWorkersEnabled, isWorkerInstance) {
-		const methodManager = new MethodManager();
-		methodManager.initialize(websocketManager, monitorManagerFunction, isWorkersEnabled, isWorkerInstance);
-		return methodManager;
-	}
-
-	private initialize(websocketManager: WebSocketManager, monitorManagerFunction: MonitorManagerFunction, isWorkersEnabled, isWorkerInstance) {
-		this._websocketManager = websocketManager;
-		this._monitorManagerFunction = monitorManagerFunction;
-		this._isWorkersEnabled = isWorkersEnabled;
-		this._isWorkerInstance = isWorkerInstance;
-		
-		this.clientDir = ResolveIOServer.getClientDir();
-		this.serverConfig = ResolveIOServer.getServerConfig();
-
-		// Fixtures
-		if (!process.env.IS_WORKERS_ENABLED || process.env.IS_WORKERS_ENABLED === 'false' || (process.env.IS_WORKER_INSTANCE === 'true' && process.env.WORKER_INDEX === '0')) {
-			if (process.env.IS_WORKERS_ENABLED === 'false' || process.env.NODE_APP_INSTANCE === '1') {
-				setTimeout(async () => {
-					console.log(new Date(), 'Start Server Fixture');
-					await loadServerInit();
-					console.log(new Date(), 'End Server Fixture');
-				}, 5000);
-			}
-		}
-		
-		setImmediate(async () => {
-			try {
-				// Methods
-				await loadServerCronJobs();
-
-				loadAccountMethods(this);
-				loadAppSettingsMethods(this);
-				loadAWSMethods(this);
-				loadAiTerminalMethods(this);
-				loadCollectionMethods(this);
-				loadCustomerNotificationMethods(this);
-				loadCounterMethods(this);
-				loadLogMethods(this);
-				loadPDFMethods(this);
-				loadCronJobMethods(this);
-				loadFlagMethods(this);
-				loadFlagUpdatesMethods(this);
-				loadReportBuilderMethods(this);
-				loadSupportMethods(this);
-				loadMonitorMethods(this);
-				loadMongoExplorerMethods(this);
-				loadPublicationMethods(this);
-				loadDiagnosticMethods(this);
-
-				let flag = await Flags.findOne({type: 'Enable Debug'});
-		
-				if (flag && flag.value) {
-					this._enableDebug = true;
-				}
-				else {
-					this._enableDebug = false;
-				}
-
-				await this.loadPendingEmails();
-				this.markReady();
-			}
-			catch (error) {
-				console.error(new Date(), 'Method Manager init failed', error);
-				this.markReadyFailure(error);
-			}
-		});
-			
-			this._aws = new AWS();
-
-			const sesRegion = process.env.AWS_SES_REGION || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || 'us-east-1';
-			const sesCredentials = process.env.AWS_ACCESS_KEY && process.env.AWS_SECRET_ACCESS_KEY ? {
-				accessKeyId: process.env.AWS_ACCESS_KEY,
-				secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-				sessionToken: process.env.AWS_SESSION_TOKEN
-			} : undefined;
-
-			this._mailerSES = createNodeMailerSESV2Transport(new SESv2Client({
-				region: sesRegion,
-				credentials: sesCredentials
-			}));
-			
-			if (!ResolveIOServer.getSESMail()) {
-				this._mailerCustom = nodemailer.createTransport({
-					host: ResolveIOServer.getServerConfig()['MAIL_HOST'], // 'smtp.office365.com', // Office 365 server
-					port: ResolveIOServer.getServerConfig()['MAIL_PORT'], //587,     // secure SMTP
-				secure: false, // false for TLS - as a boolean not string - but the default is false so just remove this completely
-				auth: {
-					user: ResolveIOServer.getServerConfig()['MAIL_USERNAME'],
-					pass: ResolveIOServer.getServerConfig()['MAIL_PASSWORD']
-				},
-				tls: {
-					ciphers: 'SSLv3'
-				}
-			});
-		}
-
-		setInterval(async () => {
-			let flag = await Flags.findOne({type: 'Enable Debug'});
-	
-			if (flag && flag.value) {
-				this._enableDebug = true;
-			}
-			else {
-				this._enableDebug = false;
-			}
-
-			if (this._enableDebug) {
-				console.log(new Date(), 'Method Manager', 'Send Queue Hits', this._debugSendQueueHits);
-				console.log(new Date(), 'Method Manager', 'Call Method Internal Hits', this._debugcallMethodHits);
-				console.log(new Date(), 'Method Manager', 'Call Method Hits', this._debugCallMethodHits);
-				console.log(new Date(), 'Method Manager', 'Call Method Cron Hits', this._debugCallMethodCronJobHits);
-			}
-
-			this._debugcallMethodHits = 0;
-			this._debugCallMethodHits = 0;
-			this._debugCallMethodCronJobHits = 0;
-			this._debugSendQueueHits = 0;
-		}, 60000);
-
-		if (!this._isWorkersEnabled || this._isWorkerInstance) {
-			this.setupEmailWatcher();
-		}
-	}
-
-	private markReady(): void {
-		if (this._ready) {
-			return;
-		}
-		this._ready = true;
-		this._readyEmitter.emit('ready');
-		this._readyEmitter.removeAllListeners('ready');
-		this._readyEmitter.removeAllListeners('readyError');
-	}
-
-	private markReadyFailure(error: any): void {
-		if (this._ready) {
-			return;
-		}
-		this._readyError = error;
-		this._readyEmitter.emit('readyError', error);
-		this._readyEmitter.removeAllListeners('ready');
-		this._readyEmitter.removeAllListeners('readyError');
-	}
-
-	public onReady(callback: () => void): () => void {
-		if (this._ready) {
-			callback();
-			return () => {};
-		}
-		if (this._readyError) {
-			return () => {};
-		}
-
-		const handleReady = () => {
-			callback();
-		};
-
-		this._readyEmitter.once('ready', handleReady);
-
-		return () => {
-			this._readyEmitter.removeListener('ready', handleReady);
-		};
-	}
-
-	private async waitForReadyEvent(): Promise<void> {
-		await once(this._readyEmitter, 'ready');
-	}
-
-	private async waitForReadyError(): Promise<void> {
-		const [error] = await once(this._readyEmitter, 'readyError');
-		throw error || new Error('MethodManager failed to initialize');
-	}
-
-	private async waitForReadyTimeout(timeoutMs: number): Promise<void> {
-		await delay(timeoutMs);
-		throw new Error('MethodManager ready timeout');
-	}
-
-	public isReady(): boolean {
-		return this._ready;
-	}
-
-	public getReadyError(): any {
-		return this._readyError;
-	}
-
-	public async waitUntilReady(timeoutMs: number = 30000): Promise<void> {
-		if (this._ready) {
-			return;
-		}
-		if (this._readyError) {
-			throw this._readyError;
-		}
-		if (!timeoutMs || timeoutMs <= 0) {
-			await Promise.race([
-				this.waitForReadyEvent(),
-				this.waitForReadyError()
-			]);
-			return;
-		}
-		await Promise.race([
-			this.waitForReadyEvent(),
-			this.waitForReadyError(),
-			this.waitForReadyTimeout(timeoutMs)
-		]);
-	}
-
-	public getMethod(methodName: string): MethodAllModel {
-		return this._methods[methodName];
-	}
-
-	// Add methods to private methods object
-	public methods(method: MethodModel) {
-		this._methods = Object.assign(this._methods, method);
-	}
-
-	private async reportMethodError(
-		subject: string,
-		correlationId: string,
-		context: Record<string, any> | string,
-		meta: Record<string, any>,
-		stack?: string
-	) {
-		const metadata = Object.assign({}, meta || {});
-		if (correlationId && !metadata.correlationId) {
-			metadata.correlationId = correlationId;
-		}
-
-		await ErrorReporter.report({
-			sourceApp: 'method-manager',
-			message: subject,
-			environment: this.serverConfig?.ROOT_URL,
-			clientSlug: ResolveIOServer.getClientName(),
-			clientName: this.serverConfig?.CLIENT_NAME,
-			severity: 'error',
-			stack,
-			context,
-			metadata,
-			correlationId
-		});
-	}
-
-	public async callMethodCron(method: string, ...methodData: any[]) {
-		this._debugCallMethodCronJobHits += 1;
-
-		const existingCorrelationId = getCorrelationId();
-		const correlationId = existingCorrelationId || objectIdHexString();
-
-		const execute = async () => {
-			const cronMethod = this._methods[method];
-
-			if (!cronMethod) {
-				console.log('No Method: ' + method);
-
-				await this.reportMethodError(
-					'SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'],
-					correlationId,
-					{ message: 'No Method registered for cron execution', method },
-					{ context: 'callMethodCron', method }
-				);
-
-				throw new Error('No Method: ' + method);
-			}
-			
-			if ((methodData.length > 1 || methodData[0]) && !cronMethod.skipValidation) {
-				if (!cronMethod.check) {
-					console.error(new Date(), 'No Check Function For Cron Method ' + method);
-
-					await this.reportMethodError(
-						'SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'],
-						correlationId,
-						{ message: 'Missing check function for cron method', method },
-						{ context: 'callMethodCron-validation', method }
-					);
-		
-					throw new Error('No Check Function For Cron Method ' + method);
-				}
-				else if (!cronMethod.check._schema) {
-					console.error(new Date(), 'No Check Schema For Cron Method ' + method);
-
-					await this.reportMethodError(
-						'SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'],
-						correlationId,
-						{ message: 'Missing check schema for cron method', method },
-						{ context: 'callMethodCron-validation', method }
-					);
-		
-					throw new Error('No Check Schema For Cron Method ' + method);
-				}
-				else {
-					const valObj = {};
-					const valKeys = Object.keys(cronMethod.check._schema);
-
-					const rootKeys = valKeys.filter(a => !a.includes('.'));
-					
-					for (let i = 0; i < methodData.length; i++) {
-						valObj[rootKeys[i]] = methodData[i];
-					}
-
-					try {
-						cronMethod.check.validate(valObj);
-					}
-					catch (err) {
-						console.error(new Date(), 'Error in Cron Method Check (' + method + ')', err);
-
-						const { error: normalizedError, correlationId: resolvedCorrelationId } = ensureErrorWithCorrelation(err, correlationId);
-
-						await this.reportMethodError(
-							'SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'],
-							resolvedCorrelationId,
-							{
-								message: 'Match error on cron method',
-								method,
-								data: valObj,
-								validationError: normalizedError
-							},
-							{ context: 'callMethodCron-validation-error', method },
-							normalizedError.stack
-						);
-						normalizedError.message = `${new Date().toISOString()} - Error in Cron Method Check (${method}): ${normalizedError.message}`;
-
-						throw normalizedError;
-					}
-				}
-			}
-
-			const monitor = this._monitorManagerFunction.startMonitorFunction('Cron Method', method, '', '', methodData);
-
-			try {
-				const res = await cronMethod.function.call(Object.assign({}, this, MethodManager.prototype, {id_user: '', user: '', id_ws: ''}), ...methodData);
-				return res;
-			}
-			catch (err) {
-				const { error: normalizedError, correlationId: resolvedCorrelationId } = ensureErrorWithCorrelation(err, correlationId);
-
-				await this.reportMethodError(
-					'SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'],
-					resolvedCorrelationId,
-					{
-						message: 'Error detected during cron method execution',
-						method,
-						data: methodData,
-						error: normalizedError
-					},
-					{ context: 'callMethodCron-execution', method },
-					normalizedError.stack
-				);
-				
-				normalizedError.message = `${new Date().toISOString()} - Error in Cron Method (${method}): ${normalizedError.message}`;
-				
-				throw normalizedError;
-			}
-			finally {
-				await this._monitorManagerFunction.finishMonitorFunction(monitor);
-			}
-		};
-
-		return await runWithCorrelationContext(correlationId, execute);
-	}
-
-	// Call/run method internal (No Emit on Socket)
-	public async callMethod(methodName: string, ...methodData: any[]): Promise<any> {
-		this._debugcallMethodHits += 1;
-
-		const existingCorrelationId = getCorrelationId();
-		const correlationId = existingCorrelationId || objectIdHexString();
-
-		return await runWithCorrelationContext(correlationId, async () => await this.callMethodInternal(correlationId, methodName, methodData));
-	}
-
-	private async callMethodInternal(correlationId: string, methodName: string, methodData: any[]): Promise<any> {
-		const method = this.getMethod(methodName);
-
-		if (!method) {
-			console.log('No Method: ' + methodName);
-			throw new Error(`No Method: ${methodName}`);
-		}
-
-		const shouldTrackTextMetric = this.shouldTrackTextMessageMetric(methodName);
-		const textMetricProvider = shouldTrackTextMetric ? this.getTextMessageProvider() : undefined;
-
-		let releaseLocalConcurrency = await this.acquireLocalConcurrency(methodName, method.maxConcurrency);
-
-		try {
-			if ((methodData.length > 1 || (methodData[0] && typeof methodData[0] !== 'function')) && !method.skipValidation) {
-				if (!method.check) {
-					console.error(new Date(), 'No Check Function For Method ' + methodName);
-					throw new Error(`No Check Function For Method: ${methodName}`);
-				}
-				else if (!method.check._schema) {
-					console.error(new Date(), 'No Check Schema For Method ' + methodName);
-					throw new Error(`No Check Schema For Method: ${methodName}`);
-				}
-			}
-
-			if (methodName !== 'insertSubscriptionLog' && 
-				methodName !== 'getDataURIfromURL' && 
-				methodName !== 'processAirdropDistribution' && 
-				methodName !== 'incCounter' && 
-				methodName !== 'supportCreateBillingUser' && 
-				methodName !== 'countCollectionWithQuery' &&
-				methodName !== 'countWithQuery' &&
-				methodName !== 'qbFetchRequests' &&
-				methodName !== 'qbHandleResponse'
-			) {
-				if (
-					ResolveIOServer.shouldWriteLogsOffline()
-				) {
-							ResolveIOServer.getLocalLogManager().writeLog({
-								type: 'log',
-								data: {
-									_id: objectIdHexString(),
-									createdAt: new Date(),
-									type: 'callMethod',
-									collection: '',
-									id_document: '',
-									payload: getBinarySize(JSON.stringify([methodData])) < 1000000 ? JSON.stringify([methodData], null, 2) : 'Too Big',
-									method: methodName,
-									id_user: this['id_user'] || '',
-									user: this['user'] || '', 
-									messageId: 0,
-									route: '',
-									instance_index: process.env.NODE_APP_INSTANCE || '0',
-									correlationId
-								}
-							});
-				}
-				else {
-					await Logs.insertOne({
-						_id: objectIdHexString(),
-						type: 'callMethod',
-						collection: '',
-						id_document: '',
-						payload: getBinarySize(JSON.stringify([methodData])) < 1000000 ? JSON.stringify([methodData], null, 2) : 'Too Big',
-						method: methodName,
-						id_user: this['id_user'] || '',
-						user: this['user'] || '',
-						messageId: 0,
-						route: '',
-						client: 'ResolveIO',
-						instance: ResolveIOServer.getInstanceHost(),
-						instance_index: process.env.NODE_APP_INSTANCE || '0',
-						correlationId
-					})
-				};
-			}
-
-			const methodCallback = typeof(methodData[methodData.length - 1]) === 'function' ? methodData[methodData.length - 1] : null;
-			const functionMethodData = methodCallback ? methodData.slice(0, -1) : methodData;
-
-			const session = ResolveIOServer.getMongoManager().getSession();
-			const shouldStartTransaction = !method.bypassSession &&
-				!session && 
-				![
-					'insertErrorLog', // CIRCULAR LOOP - DO NOT REMOVE
-					'countWithQuery', // MONGO SESSIONS/TRANSACTIONS DONT WORK WITH COUNTS
-					'sendEmail' // ALWAYS SEND SO ALWAYS HAVE RECORD - DONT ROLL BACK - BYPASS SESSION
-				].includes(methodName) &&
-				!methodName.startsWith('monitor-') &&
-				!methodName.startsWith('log');
-
-			const executeWithExistingSession = async () => {
-				// console.log(new Date(), 'Calling Method - Existing Session', methodName);
-				let monitor = this._monitorManagerFunction.startMonitorFunction('Method', methodName, this['user'] || '', '', functionMethodData);
-
-				try {
-					let res = await method.function.call(Object.assign({}, this, MethodManager.prototype), ...functionMethodData);
-
-					if (methodCallback) {
-						methodCallback(null, res);
-					}
-
-					if (shouldTrackTextMetric) {
-						try {
-							await recordTextMessageMetric({
-								status: 'sent',
-								provider: textMetricProvider,
-								metadata: {
-									method: methodName
-								}
-							});
-						}
-						catch (error) {
-							console.error('Error recording text message metric:', error);
-						}
-					}
-
-					return res;
-				}
-				catch (err) {
-					if (err.code === 112 || err.codeName === 'WriteConflict' || err.code === 251 || err.codeName === 'NoSuchTransaction') {
-						throw err; // Write error, retry
-					}
-
-					const { error: normalizedError, correlationId: resolvedCorrelationId } = ensureErrorWithCorrelation(err, correlationId);
-
-					console.log(JSON.stringify([new Date(), 'Error Method Manager - Run Method - Existing Session', methodName, {
-						code: normalizedError.code,
-						codeName: normalizedError.codeName,
-						message: normalizedError.message,
-						stack: normalizedError.stack,
-						correlationId: resolvedCorrelationId
-					}], null, 2));
-
-					await this.reportMethodError(
-						'SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'],
-						resolvedCorrelationId,
-						{
-							message: 'Error detected during method execution (existing session)',
-							method: methodName,
-							data: methodData,
-							error: normalizedError
-						},
-						{ context: 'callMethod-existing-session', methodName },
-						normalizedError.stack
-					);
-					normalizedError.message = `${new Date().toISOString()} - Error in Method (${methodName}) - Existing Session: ${normalizedError.message}`;
-
-					if (methodCallback) {
-						methodCallback(normalizedError, null);
-					}
-
-					if (shouldTrackTextMetric) {
-						try {
-							await recordTextMessageMetric({
-								status: 'failed',
-								provider: textMetricProvider,
-								metadata: {
-									method: methodName
-								}
-							});
-						}
-						catch (error) {
-							console.error('Error recording text message metric:', error);
-						}
-					}
-
-					if (!process.env.IS_WORKER_INSTANCE) {
-						await this.callMethod(
-							'insertErrorLog',
-							`Error in Method: ${methodName}`,
-							{
-								method: methodName,
-								methodData,
-								error: {
-									message: normalizedError.message,
-									stack: normalizedError.stack,
-									code: normalizedError.code,
-									codeName: normalizedError.codeName
-								},
-								correlationId: resolvedCorrelationId
-							}
-						);
-					}
-					
-					throw normalizedError;
-				}
-				finally {
-					await this._monitorManagerFunction.finishMonitorFunction(monitor);
-				}
-			};
-
-			if (shouldStartTransaction) {
-				let monitor = null;
-				
-				return ResolveIOServer.getMongoManager().oneTimeTransaction(async () => {
-					// console.log(new Date(), 'Calling Method - New Session', methodName);
-
-					monitor = this._monitorManagerFunction.startMonitorFunction('Method', methodName, this['user'] || '', '', functionMethodData);
-					
-					try {
-						let res = await method.function.call(Object.assign({}, this, MethodManager.prototype), ...functionMethodData);
-
-						if (methodCallback) {
-							methodCallback(null, res);
-						}
-
-						if (shouldTrackTextMetric) {
-							try {
-								await recordTextMessageMetric({
-									status: 'sent',
-									provider: textMetricProvider,
-									metadata: {
-										method: methodName
-									}
-								});
-							}
-							catch (error) {
-								console.error('Error recording text message metric:', error);
-							}
-						}
-
-						return res;
-					}
-					catch (err) {
-						if (err.code === 112 || err.codeName === 'WriteConflict' || err.code === 251 || err.codeName === 'NoSuchTransaction') {
-							throw err; // Write error, retry
-						}
-
-						const { error: normalizedError, correlationId: resolvedCorrelationId } = ensureErrorWithCorrelation(err, correlationId);
-
-						console.log(JSON.stringify([new Date(), 'Error Method Manager - Run Method - New Session', methodName, {
-							code: normalizedError.code,
-							codeName: normalizedError.codeName,
-							message: normalizedError.message,
-							stack: normalizedError.stack,
-							correlationId: resolvedCorrelationId
-						}], null, 2));
-
-						await this.reportMethodError(
-							'SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'],
-							resolvedCorrelationId,
-							{
-								message: 'Error detected during method execution (new session)',
-								method: methodName,
-								data: methodData,
-								error: normalizedError
-							},
-							{ context: 'callMethod-new-session', methodName },
-							normalizedError.stack
-						);
-						normalizedError.message = `${new Date().toISOString()} - Error in Method With Session (${methodName}) - New Session: ${normalizedError.message}`;
-
-						if (methodCallback) {
-							methodCallback(normalizedError, null);
-						}
-
-						if (shouldTrackTextMetric) {
-							try {
-								await recordTextMessageMetric({
-									status: 'failed',
-									provider: textMetricProvider,
-									metadata: {
-										method: methodName
-									}
-								});
-							}
-							catch (error) {
-								console.error('Error recording text message metric:', error);
-							}
-						}
-
-						if (!process.env.IS_WORKER_INSTANCE) {
-							await this.callMethod(
-								'insertErrorLog',
-								`Error in Method: ${methodName}`,
-								{
-									method: methodName,
-									methodData,
-									error: {
-										message: normalizedError.message,
-										stack: normalizedError.stack,
-										code: normalizedError.code,
-										codeName: normalizedError.codeName
-									},
-									correlationId: resolvedCorrelationId
-								}
-							);
-						}
-
-						throw normalizedError;
-					}
-					finally {
-						await this._monitorManagerFunction.finishMonitorFunction(monitor);
-					}
-				});
-			}
-			else if (method.bypassSession && session) {
-				return ResolveIOServer.getMongoManager().runWithoutSession(async () => await executeWithExistingSession());
-			}
-			else {
-				return executeWithExistingSession();
-			}
-		}
-		finally {
-			releaseLocalConcurrency();
-		}
-	}
-
-	private async acquireLocalConcurrency(methodName: string, maxConcurrency?: number): Promise<() => void> {
-		if (!maxConcurrency || maxConcurrency < 1) {
-			return () => {};
-		}
-
-		let current = this._localActiveCounts.get(methodName) || 0;
-
-		if (current < maxConcurrency) {
-			this._localActiveCounts.set(methodName, current + 1);
-			return this.createLocalRelease(methodName);
-		}
-
-		// eslint-disable-next-line no-restricted-syntax
-		return new Promise((resolve) => {
-			let queue = this._localWaitQueues.get(methodName);
-
-			if (!queue) {
-				queue = [];
-				this._localWaitQueues.set(methodName, queue);
-			}
-
-			queue.push(() => {
-				let curr = this._localActiveCounts.get(methodName) || 0;
-				this._localActiveCounts.set(methodName, curr + 1);
-				resolve(this.createLocalRelease(methodName));
-			});
-		});
-	}
-
-	private createLocalRelease(methodName: string): () => void {
-		let released = false;
-
-		return () => {
-			if (released) {
-				return;
-			}
-
-			released = true;
-
-			let current = this._localActiveCounts.get(methodName) || 0;
-			this._localActiveCounts.set(methodName, current > 0 ? current - 1 : 0);
-
-			let queue = this._localWaitQueues.get(methodName);
-
-			if (queue && queue.length) {
-				let next = queue.shift();
-
-				if (next) {
-					next();
-				}
-			}
-		};
-	}
-
-	setupEmailWatcher() {
-		const changeStream = EmailHistories.watchCollection([]);
-
-		changeStream.on('change', async (change) => {
-			if (change.operationType === 'insert' && change.fullDocument && change.fullDocument.status === 'pending') {
-				this.emailQueue.add(change.fullDocument._id.toString());
-				await this.tryProcessEmail();
-			}
-			else if (change.operationType === 'update' || change.operationType === 'replace') {
-				const updatedEmail = change.fullDocument;
-				if (updatedEmail && updatedEmail.status !== 'pending' && this.emailQueue.has(updatedEmail._id.toString())) {
-					this.emailQueue.delete(updatedEmail._id.toString());
-				}
-			}
-		})
-		.on('error', async err => {
-			console.error('Email history changestream error', err);
-			await changeStream.close();
-		})
-		.on('close', () => {
-			this.setupEmailWatcher();
-		});
-	}
-
-	async loadPendingEmails() {
-		// Load any pending emails on startup
-		const pendingEmails = await EmailHistories.find({ status: 'pending' }, {sort: {_id: 1}});
-		for (const email of pendingEmails) {
-			this.emailQueue.add(email._id.toString());
-		}
-		// Try to process emails
-		await this.tryProcessEmail();
-	}
-
-	async tryProcessEmail() {
-		if (this.isEmailProcessing || this.emailQueue.size === 0) {
-			return;
-		}
-	
-		this.isEmailProcessing = true;
-	
-		try {
-			while (this.emailQueue.size > 0) {
-				const emailId = this.emailQueue.values().next().value;
-				this.emailQueue.delete(emailId);
-	
-				const pendingEmail = await EmailHistories.findOne(
-					{
-						_id: emailId,
-						status: 'pending',
-					}
-				);
-
-				if (!pendingEmail) {
-					continue;
-				}
-
-				let queuedAt: Date;
-				if (pendingEmail.date instanceof Date) {
-					queuedAt = pendingEmail.date;
-				}
-				else if (pendingEmail.createdAt instanceof Date) {
-					queuedAt = pendingEmail.createdAt;
-				}
-				else {
-					queuedAt = new Date();
-				}
-
-				const timeSinceQueued = Date.now() - queuedAt.getTime();
-				const remainingDelay = this._emailProcessingDelayMs - timeSinceQueued;
-
-				if (remainingDelay > 0) {
-					// eslint-disable-next-line no-restricted-syntax
-					await new Promise(resolve => setTimeout(resolve, remainingDelay));
-				}
-
-				const emailHistory = await EmailHistories.findOneAndUpdate(
-					{
-						_id: emailId,
-						status: 'pending',
-					},
-					{
-						$set: { status: 'processing', processingAt: new Date() },
-					}
-				);
-	
-				if (!emailHistory) {
-					continue;
-				}
-	
-				// Fetch and process attachments
-                if (emailHistory.attachments && emailHistory.attachments.length > 0) {
-					const validAttachments: any[] = [];
-					let attachmentError = false;
-
-					for (const att of emailHistory.attachments) {
-						if (att.path && att.path.startsWith('http')) {
-							try {
-								const response = await fetch(att.path);
-								if (!response.ok) {
-									attachmentError = true;
-									continue;
-								}
-								const arrayBuffer = await response.arrayBuffer();
-								const buffer = Buffer.from(arrayBuffer);
-
-								// Check the size of the attachment
-								const maxSize = 20 * 1024 * 1024; // 20MB in bytes
-								if (buffer.length <= maxSize) {
-									// Attachment is within size limits, include it
-									att.content = buffer;
-									delete att.path;
-									validAttachments.push(att);
-								}
-							}
-							catch (err) {
-								console.error('Failed to fetch attachment:', err);
-								attachmentError = true;
-							}
-						}
-						else {
-							validAttachments.push(att);
-						}
-					}
-
-					emailHistory.attachments = validAttachments;
-					if (attachmentError) {
-							emailHistory.text =
-									(typeof emailHistory.text === 'string' ? emailHistory.text : '') +
-									'\n\nCould not load attachments.';
-							emailHistory.html =
-									(typeof emailHistory.html === 'string' ? emailHistory.html : '') +
-									'<p>Could not load attachments.</p>';
-					}
-                }
-	
-				// Prepare email options
-				const mailOptions: any = {
-					replyTo: emailHistory.reply_to || (ResolveIOServer.getServerConfig()['MAIL_REPLY_TO'] || undefined),
-					from: emailHistory.send_from || ResolveIOServer.getServerConfig().MAIL_FROM,
-					to: emailHistory.email,
-					subject:
-						(ResolveIOServer.getServerConfig()['ROOT_URL'].match(/https:\/\/dev\./) ||
-						ResolveIOServer.getServerConfig()['ROOT_URL'].match(/https:\/\/www\.dev\./)
-							? '(DEV SERVER) - '
-							: '') + emailHistory.subject,
-					text: typeof emailHistory.text === 'string' ? emailHistory.text : '',
-					html: typeof emailHistory.html === 'string' ? emailHistory.html : '',
-					attachments: emailHistory.attachments || [],
-					force_ses: emailHistory.force_ses
-				};
-	
-				// Process attachments before sending
-				if (mailOptions.attachments && mailOptions.attachments.length > 0) {
-					mailOptions.attachments = mailOptions.attachments.map((att) => {
-						const newAtt = { ...att };
-						// Handle attachments stored as BinData or Buffer
-						if (newAtt.content && typeof newAtt.content === 'object' && !(newAtt.content instanceof Buffer)) {
-							// Convert MongoDB's Binary data to Buffer
-							if (newAtt.content._bsontype === 'Binary' && newAtt.content.sub_type === 0) {
-								newAtt.content = Buffer.from(newAtt.content.buffer);
-							}
-							else {
-								// Handle other types if necessary
-								newAtt.content = Buffer.from(newAtt.content);
-							}
-						}
-						// Handle attachments stored as Base64 strings
-						else if (typeof newAtt.content === 'string' && newAtt.encoding === 'base64') {
-							newAtt.content = Buffer.from(newAtt.content, 'base64');
-							delete newAtt.encoding;
-						}
-						// Ensure the content is a Buffer
-						else if (typeof newAtt.content === 'string') {
-							newAtt.content = Buffer.from(newAtt.content);
-						}
-						return newAtt;
-					});
-				}
-	
-				// Send the email
-				const emailProvider = (!mailOptions.force_ses && this._mailerCustom) ? 'custom' : 'ses';
-				(!mailOptions.force_ses && this._mailerCustom ? this._mailerCustom : this._mailerSES).sendMail(mailOptions, async err => {
-					const metricStatus = err ? 'failed' : 'sent';
-
-					try {
-						if (err) {
-							console.error('Failed to send email:', err);
-							await EmailHistories.updateOne(
-								{ _id: emailHistory._id },
-								{
-									$set: {
-										status: 'failed',
-										error: typeof err === 'string' ? err : this.safeStringify(err),
-										completedAt: new Date(),
-									},
-								}
-							);
-						}
-						else {
-							if (emailHistory.email === 'dev@resolveio.com') {
-								await EmailHistories.deleteOne({ _id: emailHistory._id });
-							}
-							else {
-								await EmailHistories.updateOne(
-									{ _id: emailHistory._id },
-									{
-										$set: {
-											status: 'completed',
-											completedAt: new Date(),
-										},
-									}
-								);
-							}
-						}
-					}
-					catch (error) {
-						console.error('Error in sendMail callback:', error);
-						await EmailHistories.updateOne(
-							{ _id: emailHistory._id },
-							{
-								$set: {
-									status: 'failed',
-									error: typeof error === 'string' ? error : this.safeStringify(error),
-									completedAt: new Date(),
-								},
-							}
-						);
-					}
-					finally {
-						try {
-							await recordEmailMetric({
-								status: metricStatus,
-								provider: emailProvider,
-								metadata: {
-									method: 'sendEmail'
-								}
-							});
-						}
-						catch (error) {
-							console.error('Error recording email metric:', error);
-						}
-					}
-				});
-	
-				// Wait for at least one second before sending the next email
-				// eslint-disable-next-line no-restricted-syntax
-				await new Promise((resolve) => setTimeout(resolve, 1000));
-			}
-		}
-		catch (err) {
-			console.error('Error processing email queue:', err);
-		}
-		finally {
-			this.isEmailProcessing = false;
-			// Check if new emails arrived while processing
-			if (this.emailQueue.size > 0) {
-				await this.tryProcessEmail();
-			}
-		}
-	}
-
-	private shouldTrackTextMessageMetric(methodName: string): boolean {
-		const normalized = String(methodName || '').trim().toLowerCase();
-		if (!normalized) {
-			return false;
-		}
-
-		return normalized.startsWith('sendsms') || normalized.startsWith('sendtext');
-	}
-
-	private getTextMessageProvider(): string | undefined {
-		const provider = this.serverConfig?.['SMS_PROVIDER'] || '';
-		if (typeof provider === 'string' && provider.trim().length) {
-			return provider.trim().toLowerCase();
-		}
-
-		if (this.serverConfig?.['TWILIO_SID'] || this.serverConfig?.['TWILIO_AUTH_TOKEN']) {
-			return 'twilio';
-		}
-
-		return undefined;
-	}
-
-	safeStringify(obj)
-	{
-		try
-		{
-			return JSON.stringify(obj, this.getCircularReplacer());
-		}
-		catch (e)
-		{
-			return `Error in JSON stringifying: ${e.message}`;
-		}
-	}
-
-	getCircularReplacer()
-	{
-		const seen = new WeakSet();
-		return (key, value) =>
-		{
-			if (typeof value === "object" && value !== null)
-			{
-				if (seen.has(value))
-				{
-					return "[Circular]";
-				}
-				seen.add(value);
-			}
-			return value;
-		};
-	}
-
-	private async tryMergeEmailOccurrence(
-		email: string,
-		subject: string,
-		correlationId: string,
-		occurrence: EmailHistoryOccurrence,
-		meta?: Record<string, any>
-	): Promise<EmailHistoryModel | null> {
-		const existing = await EmailHistories.findOne(
-			{
-				email,
-				correlationId,
-				status: 'pending'
-			},
-			{ sort: { date: 1 } }
-		);
-
-		if (!existing) {
-			return null;
-		}
-
-		const normalizedOccurrences: EmailHistoryOccurrence[] = Array.isArray(existing.occurrences) && existing.occurrences.length
-			? existing.occurrences.map((item: EmailHistoryOccurrence) => ({
-				_id: item._id || objectIdHexString(),
-				createdAt: item.createdAt instanceof Date ? item.createdAt : new Date(item.createdAt),
-				subject: item.subject || existing.subject || '',
-				text: item.text,
-				html: item.html,
-				meta: item.meta
-			}))
-			: [createEmailOccurrence(
-				existing.subject || '',
-				typeof existing.text === 'string' ? existing.text : undefined,
-				typeof existing.html === 'string' ? existing.html : undefined,
-				existing.meta
-			)];
-
-		normalizedOccurrences.push(occurrence);
-
-		const { text: aggregatedText, html: aggregatedHtml } = formatGroupedEmailContent(correlationId, normalizedOccurrences);
-
-		const updated = await EmailHistories.findOneAndUpdate(
-			{
-				_id: existing._id,
-				status: 'pending'
-			},
-			{
-				$set: {
-					subject,
-					text: aggregatedText,
-					html: aggregatedHtml,
-					occurrences: normalizedOccurrences,
-					meta: meta || existing.meta,
-					updatedAt: new Date()
-				}
-			},
-			{ returnDocument: 'after' }
-		);
-
-		return updated || null;
-	}
-
-	public async sendEmail(
-		sendTo: string,
-		subject: string,
-		text?: string | null,
-		html?: string | null,
-		attachments?: any[] | null,
-		send_from?: string | null,
-		reply_to?: string | null,
-		force_ses = false,
-		local_override = false,
-		options?: SendEmailOptions
-	) {
-		// Modify sendTo in development environments
-		if (
-			(ResolveIOServer.getServerConfig()['ROOT_URL'].match(/https:\/\/dev\./) ||
-				ResolveIOServer.getServerConfig()['ROOT_URL'].match(/https:\/\/www\.dev\./) ||
-				ResolveIOServer.getServerConfig()['ROOT_URL'] === 'http://localhost:4200') &&
-			!sendTo.match(/\@resolveio\.com/)
-		) {
-			sendTo = 'dev@resolveio.com';
-		}
-
-		const normalizedSubject = subject || '';
-		const correlationId = options?.correlationId;
-		const finalSubject = appendCorrelationIdToSubject(normalizedSubject, correlationId);
-		const groupByCorrelationId = !!correlationId;
-		const normalizedText = typeof text === 'string' ? text : '';
-		const normalizedHtml = typeof html === 'string' ? html : '';
-		const occurrence = groupByCorrelationId
-			? createEmailOccurrence(normalizedSubject, normalizedText, normalizedHtml, options?.meta)
-			: null;
-		let allowGrouping = groupByCorrelationId;
-
-		if (sendTo) {
-			if (
-				ResolveIOServer.getServerConfig()['ROOT_URL'] !== 'http://localhost:4200' ||
-				local_override
-			) {
-				let normalizedAttachments: any[] = [];
-				if (Array.isArray(attachments)) {
-					normalizedAttachments = attachments.slice();
-				}
-				else if (attachments) {
-					normalizedAttachments = [attachments];
-				}
-
-				normalizedAttachments = normalizedAttachments.map(att => {
-					const newAtt = { ...att };
-					if (Buffer.isBuffer(newAtt.content)) {
-						newAtt.content = newAtt.content.toString('base64');
-						newAtt.encoding = 'base64';
-					}
-					return newAtt;
-				});
-
-				if (normalizedAttachments.length > 0) {
-					allowGrouping = false;
-				}
-
-				if (allowGrouping && occurrence && correlationId) {
-					const merged = await this.tryMergeEmailOccurrence(sendTo, finalSubject, correlationId, occurrence, options?.meta);
-					if (merged) {
-						return merged;
-					}
-				}
-
-				const emailHistory: EmailHistoryModel = {
-					_id: objectIdHexString(),
-					__v: 0,
-					date: new Date(),
-					id_user: this['id_user'] || '',
-					user: this['user'] || '',
-					email: sendTo,
-					subject: finalSubject,
-					text: normalizedText,
-					html: normalizedHtml,
-					attachments: normalizedAttachments,
-					send_from: send_from || '',
-					reply_to: reply_to || '',
-					status: 'pending',
-					error: '',
-					force_ses
-				};
-
-				if (allowGrouping && occurrence && correlationId) {
-					const { text: aggregatedText, html: aggregatedHtml } = formatGroupedEmailContent(correlationId, [occurrence]);
-					emailHistory.text = aggregatedText;
-					emailHistory.html = aggregatedHtml;
-					emailHistory.occurrences = [occurrence];
-					emailHistory.correlationId = correlationId;
-					if (options?.meta) {
-						emailHistory.meta = options.meta;
-					}
-				}
-				else {
-					if (correlationId) {
-						emailHistory.correlationId = correlationId;
-					}
-					if (options?.meta) {
-						emailHistory.meta = options.meta;
-					}
-				}
-
-				try {
-					let history = await EmailHistories.insertOne(emailHistory);
-					return history;
-				}
-				catch (err) {
-					console.error('Failed to queue email:', err);
-					err.message = `Failed to queue email: ${err.message}`;
-					throw err;
-				}
-			}
-			else {
-				console.log(
-					'Send email',
-					sendTo,
-					finalSubject,
-					normalizedText,
-					normalizedHtml,
-					attachments,
-					send_from,
-					force_ses,
-					correlationId
-				);
-				
-				return true;
-			}
-		}
-		else {
-			return true;
-		}
-	}
-
-	public getAWS(): AWS {
-		return this._aws;
-	}
-
-	public readFile(fileName) {
-		if (fs.existsSync(path.join(__dirname, ('../private/' + fileName)))) {
-			try {
-				return fs.readFileSync(path.join(__dirname, ('../private/' + fileName)), 'utf-8');
-			}
-			catch (err) {
-				err.message = `Error in readFile: ${err.message}`;
-				throw err;
-			}
-		}
-		else {
-			if (fs.existsSync(path.join(ResolveIOServer.getClientDir(), ('./private/' + fileName)))) {
-				try {
-					return fs.readFileSync(path.join(ResolveIOServer.getClientDir(), ('./private/' + fileName)), 'utf-8');
-				}
-				catch (err) {
-					err.message = `Error in readFile: ${err.message}`;
-					throw err;
-				}
-			}
-		}
-
-		throw new Error ('Error in readFile: File Not Found');
-	}
-
-	public readImage(fileName) {
-		if (fs.existsSync(path.join(__dirname, ('../private/' + fileName)))) {
-			try {
-				return fs.readFileSync(path.join(__dirname, ('../private/' + fileName)), 'base64');
-			}
-			catch (err) {
-				err.message = `Error in readImage: ${err.message}`;
-				throw err;
-			}
-		}
-		else {
-			if (fs.existsSync(path.join(ResolveIOServer.getClientDir(), ('./private/' + fileName)))) {
-				try {
-					return fs.readFileSync(path.join(ResolveIOServer.getClientDir(), ('./private/' + fileName)), 'base64');
-				}
-				catch (err) {
-					err.message = `Error in readImage: ${err.message}`;
-					throw err;
-				}
-			}
-		}
-
-		throw new Error ('Error in readImage: File Not Found');
-	}
-
-	public getEnableDebug() {
-		return this._enableDebug;
-	}
-}