@resolveio/server-lib 22.3.41 → 22.3.42

package/src/managers/method.manager.ts

@@ -0,0 +1,1827 @@
+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>;
+	headers?: Record<string, string>;
+	waitForCompletion?: boolean;
+	waitForCompletionTimeoutMs?: number;
+	waitForCompletionPollMs?: number;
+}
+
+const CALL_METHOD_LOG_SKIP_LIST = new Set([
+	'countQuery',
+	'getSignedUrls',
+	'getSignedUrl',
+	'getSignedUrlWithId',
+	'getSignedUrlsAndFilesWithId',
+	'updateDocumentProps',
+	'insertDocument',
+	'updateDocument',
+	'uploadFileAndSave'
+]);
+
+function shouldWriteCallMethodLog(methodName: string, method?: MethodAllModel): boolean {
+	if (method?.bypassLog || method?.bypassLogs) {
+		return false;
+	}
+
+	if (CALL_METHOD_LOG_SKIP_LIST.has(methodName)) {
+		return false;
+	}
+
+	return true;
+}
+
+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
+	};
+}
+
+const EMAIL_HISTORY_TEXT_MAX_CHARS = 12000;
+const EMAIL_HISTORY_HTML_MAX_CHARS = 20000;
+const EMAIL_HISTORY_ERROR_MAX_CHARS = 8000;
+const EMAIL_HISTORY_META_MAX_CHARS = 6000;
+const EMAIL_HISTORY_ATTACHMENT_MAX_COUNT = 10;
+const EMAIL_HISTORY_ATTACHMENT_FIELD_MAX_CHARS = 1024;
+const EMAIL_HISTORY_OCCURRENCE_MAX_COUNT = 20;
+const EMAIL_HISTORY_OCCURRENCE_TEXT_MAX_CHARS = 4000;
+const EMAIL_HISTORY_OCCURRENCE_HTML_MAX_CHARS = 6000;
+
+function truncateTextForHistory(value: unknown, maxChars: number): string {
+	if (typeof value !== 'string') {
+		return '';
+	}
+
+	if (value.length <= maxChars) {
+		return value;
+	}
+
+	const suffix = '...[truncated]';
+	const keepLength = Math.max(0, maxChars - suffix.length);
+	return `${value.slice(0, keepLength)}${suffix}`;
+}
+
+function sanitizeMetaForHistory(meta?: Record<string, any>): Record<string, any> | undefined {
+	if (!meta || typeof meta !== 'object') {
+		return undefined;
+	}
+
+	try {
+		const serialized = JSON.stringify(meta);
+		if (!serialized) {
+			return undefined;
+		}
+
+		if (serialized.length <= EMAIL_HISTORY_META_MAX_CHARS) {
+			return JSON.parse(serialized);
+		}
+
+		return {
+			truncated: true,
+			originalSize: serialized.length,
+			preview: truncateTextForHistory(serialized, EMAIL_HISTORY_META_MAX_CHARS)
+		};
+	}
+	catch {
+		return {
+			truncated: true,
+			preview: '[unserializable meta]'
+		};
+	}
+}
+
+function estimateAttachmentContentLength(content: any, encoding?: string): number | undefined {
+	if (Buffer.isBuffer(content)) {
+		return content.length;
+	}
+
+	if (content instanceof Uint8Array) {
+		return content.byteLength;
+	}
+
+	if (content && typeof content === 'object') {
+		if (content._bsontype === 'Binary' && content.buffer && typeof content.buffer.length === 'number') {
+			return content.buffer.length;
+		}
+
+		if (Array.isArray(content.data)) {
+			return content.data.length;
+		}
+	}
+
+	if (typeof content === 'string') {
+		if (encoding === 'base64') {
+			const normalized = content.replace(/\s/g, '');
+			const padding = normalized.endsWith('==') ? 2 : normalized.endsWith('=') ? 1 : 0;
+			return Math.max(0, Math.floor((normalized.length * 3) / 4) - padding);
+		}
+
+		return Buffer.byteLength(content, 'utf8');
+	}
+
+	return undefined;
+}
+
+function sanitizeAttachmentForHistory(attachment: any): Record<string, any> {
+	const source = attachment && typeof attachment === 'object' ? attachment : {};
+	const summary: Record<string, any> = {
+		contentStored: false
+	};
+
+	if (typeof source.filename === 'string') {
+		summary.filename = truncateTextForHistory(source.filename, EMAIL_HISTORY_ATTACHMENT_FIELD_MAX_CHARS);
+	}
+	if (typeof source.contentType === 'string') {
+		summary.contentType = truncateTextForHistory(source.contentType, EMAIL_HISTORY_ATTACHMENT_FIELD_MAX_CHARS);
+	}
+	if (typeof source.contentDisposition === 'string') {
+		summary.contentDisposition = truncateTextForHistory(source.contentDisposition, EMAIL_HISTORY_ATTACHMENT_FIELD_MAX_CHARS);
+	}
+	if (typeof source.cid === 'string') {
+		summary.cid = truncateTextForHistory(source.cid, EMAIL_HISTORY_ATTACHMENT_FIELD_MAX_CHARS);
+	}
+	if (typeof source.path === 'string') {
+		summary.path = truncateTextForHistory(source.path, EMAIL_HISTORY_ATTACHMENT_FIELD_MAX_CHARS);
+	}
+	if (typeof source.href === 'string') {
+		summary.href = truncateTextForHistory(source.href, EMAIL_HISTORY_ATTACHMENT_FIELD_MAX_CHARS);
+	}
+	if (typeof source.encoding === 'string') {
+		summary.encoding = truncateTextForHistory(source.encoding, EMAIL_HISTORY_ATTACHMENT_FIELD_MAX_CHARS);
+	}
+
+	const contentLength = typeof source.size === 'number'
+		? source.size
+		: estimateAttachmentContentLength(source.content, source.encoding);
+	if (typeof contentLength === 'number' && Number.isFinite(contentLength) && contentLength >= 0) {
+		summary.contentLength = contentLength;
+	}
+
+	return summary;
+}
+
+function sanitizeAttachmentsForHistory(attachments: any[]): Record<string, any>[] {
+	if (!Array.isArray(attachments) || !attachments.length) {
+		return [];
+	}
+
+	const summarized = attachments
+		.slice(0, EMAIL_HISTORY_ATTACHMENT_MAX_COUNT)
+		.map((attachment) => sanitizeAttachmentForHistory(attachment));
+
+	if (attachments.length > EMAIL_HISTORY_ATTACHMENT_MAX_COUNT) {
+		summarized.push({
+			contentStored: false,
+			omittedCount: attachments.length - EMAIL_HISTORY_ATTACHMENT_MAX_COUNT
+		});
+	}
+
+	return summarized;
+}
+
+function sanitizeOccurrencesForHistory(occurrences?: EmailHistoryOccurrence[]): EmailHistoryOccurrence[] | undefined {
+	if (!Array.isArray(occurrences) || !occurrences.length) {
+		return undefined;
+	}
+
+	return occurrences.slice(-EMAIL_HISTORY_OCCURRENCE_MAX_COUNT).map((occurrence) => {
+		const createdAtCandidate = occurrence.createdAt instanceof Date ? occurrence.createdAt : new Date(occurrence.createdAt);
+		const createdAt = Number.isNaN(createdAtCandidate.getTime()) ? new Date() : createdAtCandidate;
+		const sanitized: EmailHistoryOccurrence = {
+			_id: occurrence._id || objectIdHexString(),
+			createdAt,
+			subject: truncateTextForHistory(occurrence.subject || '', EMAIL_HISTORY_ATTACHMENT_FIELD_MAX_CHARS)
+		};
+
+		if (typeof occurrence.text === 'string' && occurrence.text.length > 0) {
+			sanitized.text = truncateTextForHistory(occurrence.text, EMAIL_HISTORY_OCCURRENCE_TEXT_MAX_CHARS);
+		}
+		if (typeof occurrence.html === 'string' && occurrence.html.length > 0) {
+			sanitized.html = truncateTextForHistory(occurrence.html, EMAIL_HISTORY_OCCURRENCE_HTML_MAX_CHARS);
+		}
+
+		const sanitizedMeta = sanitizeMetaForHistory(occurrence.meta);
+		if (sanitizedMeta) {
+			sanitized.meta = sanitizedMeta;
+		}
+
+		return sanitized;
+	});
+}
+
+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
+				|| this.serverConfig?.AWS_SES_REGION
+				|| this.serverConfig?.AWSSES_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 (shouldWriteCallMethodLog(methodName, method)) {
+				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 || [],
+					headers: emailHistory.headers || undefined,
+					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 this.finalizeEmailHistoryStorage(
+								emailHistory,
+								'failed',
+								typeof err === 'string' ? err : this.safeStringify(err)
+							);
+						}
+						else {
+							if (emailHistory.email === 'dev@resolveio.com') {
+								await EmailHistories.deleteOne({ _id: emailHistory._id });
+							}
+							else {
+								await this.finalizeEmailHistoryStorage(emailHistory, 'completed');
+							}
+						}
+					}
+					catch (error) {
+						console.error('Error in sendMail callback:', error);
+						await this.finalizeEmailHistoryStorage(
+							emailHistory,
+							'failed',
+							typeof error === 'string' ? error : this.safeStringify(error)
+						);
+					}
+					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 finalizeEmailHistoryStorage(
+		emailHistory: EmailHistoryModel,
+		status: 'completed' | 'failed',
+		error?: string
+	): Promise<void> {
+		const setValues: Record<string, any> = {
+			status,
+			text: truncateTextForHistory(emailHistory.text, EMAIL_HISTORY_TEXT_MAX_CHARS),
+			html: truncateTextForHistory(emailHistory.html, EMAIL_HISTORY_HTML_MAX_CHARS),
+			attachments: sanitizeAttachmentsForHistory(emailHistory.attachments),
+			completedAt: new Date()
+		};
+
+		const sanitizedOccurrences = sanitizeOccurrencesForHistory(emailHistory.occurrences);
+		if (sanitizedOccurrences) {
+			setValues.occurrences = sanitizedOccurrences;
+		}
+
+		if (status === 'failed') {
+			setValues.error = truncateTextForHistory(error || '', EMAIL_HISTORY_ERROR_MAX_CHARS);
+		}
+		else {
+			setValues.error = '';
+		}
+
+		await EmailHistories.updateOne(
+			{ _id: emailHistory._id },
+			{
+				$set: setValues
+			}
+		);
+	}
+
+	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;
+	}
+
+	private async waitForEmailCompletion(emailHistory: EmailHistoryModel, options?: SendEmailOptions): Promise<EmailHistoryModel> {
+		const timeoutMs = Math.max(1000, Number(options?.waitForCompletionTimeoutMs) || 30000);
+		const pollMs = Math.max(100, Number(options?.waitForCompletionPollMs) || 250);
+		const deadline = Date.now() + timeoutMs;
+
+		while (Date.now() <= deadline) {
+			const latest = await EmailHistories.findOne({_id: emailHistory._id}, {
+				projection: {
+					status: 1,
+					error: 1,
+					date: 1,
+					id_user: 1,
+					user: 1,
+					email: 1,
+					subject: 1,
+					text: 1,
+					html: 1,
+					attachments: 1,
+					send_from: 1,
+					reply_to: 1,
+					force_ses: 1,
+					headers: 1,
+					correlationId: 1,
+					meta: 1,
+					occurrences: 1,
+					processingAt: 1,
+					completedAt: 1
+				}
+			});
+
+			if (!latest) {
+				return {
+					...emailHistory,
+					status: 'completed',
+					error: '',
+					completedAt: new Date()
+				};
+			}
+
+			if (latest.status === 'completed') {
+				return latest;
+			}
+
+			if (latest.status === 'failed') {
+				throw new Error(latest.error || `Email failed to send: ${latest.subject}`);
+			}
+
+			// eslint-disable-next-line no-restricted-syntax
+			await new Promise(resolve => setTimeout(resolve, pollMs));
+		}
+
+		throw new Error(`Email send timed out waiting for completion: ${emailHistory.subject}`);
+	}
+
+	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,
+					headers: options?.headers
+				};
+
+				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);
+					if (options?.waitForCompletion) {
+						return await this.waitForEmailCompletion(history, options);
+					}
+					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;
+	}
+}