@resolveio/server-lib 22.2.34 → 22.2.35

package/managers/method.manager.js

@@ -0,0 +1,1701 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodManager = exports.AWS = void 0;
+var client_s3_1 = require("@aws-sdk/client-s3");
+var client_sesv2_1 = require("@aws-sdk/client-sesv2");
+var events_1 = require("events");
+var fs = require("fs");
+var nodemailer = require("nodemailer");
+var path = require("path");
+var promises_1 = require("timers/promises");
+var email_history_collection_1 = require("../collections/email-history.collection");
+var flag_collection_1 = require("../collections/flag.collection");
+var log_collection_1 = require("../collections/log.collection");
+var cron_jobs_1 = require("../fixtures/cron-jobs");
+var init_1 = require("../fixtures/init");
+var accounts_1 = require("../methods/accounts");
+var app_settings_1 = require("../methods/app-settings");
+var aws_1 = require("../methods/aws");
+var ai_terminal_1 = require("../methods/ai-terminal");
+var collections_1 = require("../methods/collections");
+var customer_notifications_1 = require("../methods/customer-notifications");
+var counters_1 = require("../methods/counters");
+var cron_jobs_2 = require("../methods/cron-jobs");
+var diagnostics_1 = require("../methods/diagnostics");
+var flag_updates_1 = require("../methods/flag-updates");
+var flags_1 = require("../methods/flags");
+var logs_1 = require("../methods/logs");
+var monitor_1 = require("../methods/monitor");
+var mongo_explorer_1 = require("../methods/mongo-explorer");
+var publications_1 = require("../methods/publications");
+var pdf_1 = require("../methods/pdf");
+var report_builder_1 = require("../methods/report-builder");
+var support_1 = require("../methods/support");
+var resolveio_server_app_1 = require("../resolveio-server-app");
+var common_1 = require("../util/common");
+var error_reporter_1 = require("../util/error-reporter");
+var error_tracking_1 = require("../util/error-tracking");
+var communication_metric_manager_1 = require("./communication-metric.manager");
+function appendCorrelationIdToSubject(subject, correlationId) {
+    if (!correlationId) {
+        return subject;
+    }
+    var correlationTag = "[".concat(correlationId, "]");
+    if (subject && subject.includes(correlationTag)) {
+        return subject;
+    }
+    return "".concat(subject, " ").concat(correlationTag).trim();
+}
+function createEmailOccurrence(subject, text, html, meta) {
+    return {
+        _id: (0, common_1.objectIdHexString)(),
+        createdAt: new Date(),
+        subject: subject,
+        text: text,
+        html: html,
+        meta: meta
+    };
+}
+function formatGroupedEmailContent(correlationId, occurrences) {
+    var lines = [];
+    lines.push("Correlation ID: ".concat(correlationId));
+    occurrences.forEach(function (occurrence, index) {
+        var timestamp = occurrence.createdAt instanceof Date ? occurrence.createdAt.toISOString() : new Date(occurrence.createdAt).toISOString();
+        lines.push('');
+        lines.push("Occurrence #".concat(index + 1, " (").concat(timestamp, ")"));
+        lines.push("Subject: ".concat(occurrence.subject));
+        if (occurrence.text) {
+            lines.push(occurrence.text);
+        }
+    });
+    var htmlSections = occurrences.map(function (occurrence, index) {
+        var timestamp = occurrence.createdAt instanceof Date ? occurrence.createdAt.toISOString() : new Date(occurrence.createdAt).toISOString();
+        var escapedText = occurrence.text ? occurrence.text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;') : '';
+        return "<div><h4>Occurrence #".concat(index + 1, " (").concat(timestamp, ")</h4><p><strong>Subject:</strong> ").concat(occurrence.subject, "</p>").concat(escapedText ? "<pre>".concat(escapedText, "</pre>") : '', "</div>");
+    });
+    var html = __spreadArray([
+        "<p><strong>Correlation ID:</strong> ".concat(correlationId, "</p>")
+    ], __read(htmlSections), false).join('');
+    return {
+        text: lines.join('\n'),
+        html: html
+    };
+}
+function createNodeMailerSESV2Transport(sesClient) {
+    var _this = this;
+    var transport = {
+        name: 'resolveio-sesv2-transport',
+        version: '1.0.0',
+        send: function (mail, callback) {
+            var stream = mail.message.createReadStream();
+            var chunks = [];
+            var didFinish = false;
+            var finish = function (error, info) {
+                if (didFinish) {
+                    return;
+                }
+                didFinish = true;
+                callback(error, info);
+            };
+            stream.on('data', function (chunk) {
+                var chunkData = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                chunks.push(new Uint8Array(chunkData));
+            });
+            stream.on('error', function (error) {
+                finish(error);
+            });
+            stream.on('end', function () { return __awaiter(_this, void 0, void 0, function () {
+                var rawData, rawMessageData, envelope, fromEmailAddress, toAddresses, replyToAddresses, response, error_1;
+                var _a, _b;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            _c.trys.push([0, 2, , 3]);
+                            rawData = Buffer.concat(chunks);
+                            rawMessageData = new Uint8Array(rawData);
+                            envelope = typeof mail.message.getEnvelope === 'function' ? mail.message.getEnvelope() : (_a = mail.data) === null || _a === void 0 ? void 0 : _a.envelope;
+                            fromEmailAddress = (envelope === null || envelope === void 0 ? void 0 : envelope.from) || undefined;
+                            toAddresses = (envelope === null || envelope === void 0 ? void 0 : envelope.to)
+                                ? (Array.isArray(envelope.to) ? envelope.to : [envelope.to]).filter(Boolean)
+                                : [];
+                            replyToAddresses = ((_b = mail.data) === null || _b === void 0 ? void 0 : _b.replyTo)
+                                ? (Array.isArray(mail.data.replyTo) ? mail.data.replyTo : [mail.data.replyTo]).filter(Boolean)
+                                : undefined;
+                            return [4 /*yield*/, sesClient.send(new client_sesv2_1.SendEmailCommand({
+                                    FromEmailAddress: fromEmailAddress,
+                                    Destination: toAddresses.length ? { ToAddresses: toAddresses } : undefined,
+                                    ReplyToAddresses: replyToAddresses,
+                                    Content: {
+                                        Raw: {
+                                            Data: rawMessageData
+                                        }
+                                    }
+                                }))];
+                        case 1:
+                            response = _c.sent();
+                            finish(null, {
+                                envelope: envelope,
+                                messageId: response.MessageId,
+                                response: response.MessageId
+                            });
+                            return [3 /*break*/, 3];
+                        case 2:
+                            error_1 = _c.sent();
+                            finish(error_1);
+                            return [3 /*break*/, 3];
+                        case 3: return [2 /*return*/];
+                    }
+                });
+            }); });
+        }
+    };
+    return nodemailer.createTransport(transport);
+}
+var AWS = /** @class */ (function () {
+    function AWS() {
+        this._s3 = null;
+        this._s3USEast1 = null;
+    }
+    AWS.prototype.create = function () {
+        var aws = new AWS();
+        aws.initialize();
+        return aws;
+    };
+    AWS.prototype.initialize = function () {
+    };
+    AWS.prototype.s3 = function () {
+        if (this._s3) {
+            return this._s3;
+        }
+        this._s3 = new client_s3_1.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;
+    };
+    AWS.prototype.s3USEast1 = function () {
+        if (process.env.AWS_REGION === 'us-east-1') {
+            return this.s3();
+        }
+        else {
+            if (this._s3USEast1) {
+                return this._s3USEast1;
+            }
+            this._s3USEast1 = new client_s3_1.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;
+        }
+    };
+    return AWS;
+}());
+exports.AWS = AWS;
+var MethodManager = /** @class */ (function () {
+    function MethodManager() {
+        this._methods = {};
+        this._isWorkersEnabled = false;
+        this._isWorkerInstance = false;
+        this.emailQueue = new Set(); // Set to store pending email IDs
+        this.isEmailProcessing = false;
+        this._emailProcessingDelayMs = 5000;
+        this._debugcallMethodHits = 0;
+        this._debugCallMethodHits = 0;
+        this._debugCallMethodCronJobHits = 0;
+        this._debugSendQueueHits = 0;
+        this._enableDebug = false;
+        this._ready = false;
+        this._readyEmitter = new events_1.EventEmitter();
+        this._readyError = null;
+        this._localActiveCounts = new Map();
+        this._localWaitQueues = new Map();
+        this.clientDir = '';
+        this.serverConfig = {};
+    }
+    MethodManager.create = function (websocketManager, monitorManagerFunction, isWorkersEnabled, isWorkerInstance) {
+        var methodManager = new MethodManager();
+        methodManager.initialize(websocketManager, monitorManagerFunction, isWorkersEnabled, isWorkerInstance);
+        return methodManager;
+    };
+    MethodManager.prototype.initialize = function (websocketManager, monitorManagerFunction, isWorkersEnabled, isWorkerInstance) {
+        var _this = this;
+        this._websocketManager = websocketManager;
+        this._monitorManagerFunction = monitorManagerFunction;
+        this._isWorkersEnabled = isWorkersEnabled;
+        this._isWorkerInstance = isWorkerInstance;
+        this.clientDir = resolveio_server_app_1.ResolveIOServer.getClientDir();
+        this.serverConfig = resolveio_server_app_1.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(function () { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                console.log(new Date(), 'Start Server Fixture');
+                                return [4 /*yield*/, (0, init_1.loadServerInit)()];
+                            case 1:
+                                _a.sent();
+                                console.log(new Date(), 'End Server Fixture');
+                                return [2 /*return*/];
+                        }
+                    });
+                }); }, 5000);
+            }
+        }
+        setImmediate(function () { return __awaiter(_this, void 0, void 0, function () {
+            var flag, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 4, , 5]);
+                        // Methods
+                        return [4 /*yield*/, (0, cron_jobs_1.loadServerCronJobs)()];
+                    case 1:
+                        // Methods
+                        _a.sent();
+                        (0, accounts_1.loadAccountMethods)(this);
+                        (0, app_settings_1.loadAppSettingsMethods)(this);
+                        (0, aws_1.loadAWSMethods)(this);
+                        (0, ai_terminal_1.loadAiTerminalMethods)(this);
+                        (0, collections_1.loadCollectionMethods)(this);
+                        (0, customer_notifications_1.loadCustomerNotificationMethods)(this);
+                        (0, counters_1.loadCounterMethods)(this);
+                        (0, logs_1.loadLogMethods)(this);
+                        (0, pdf_1.loadPDFMethods)(this);
+                        (0, cron_jobs_2.loadCronJobMethods)(this);
+                        (0, flags_1.loadFlagMethods)(this);
+                        (0, flag_updates_1.loadFlagUpdatesMethods)(this);
+                        (0, report_builder_1.loadReportBuilderMethods)(this);
+                        (0, support_1.loadSupportMethods)(this);
+                        (0, monitor_1.loadMonitorMethods)(this);
+                        (0, mongo_explorer_1.loadMongoExplorerMethods)(this);
+                        (0, publications_1.loadPublicationMethods)(this);
+                        (0, diagnostics_1.loadDiagnosticMethods)(this);
+                        return [4 /*yield*/, flag_collection_1.Flags.findOne({ type: 'Enable Debug' })];
+                    case 2:
+                        flag = _a.sent();
+                        if (flag && flag.value) {
+                            this._enableDebug = true;
+                        }
+                        else {
+                            this._enableDebug = false;
+                        }
+                        return [4 /*yield*/, this.loadPendingEmails()];
+                    case 3:
+                        _a.sent();
+                        this.markReady();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        error_2 = _a.sent();
+                        console.error(new Date(), 'Method Manager init failed', error_2);
+                        this.markReadyFailure(error_2);
+                        return [3 /*break*/, 5];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        }); });
+        this._aws = new AWS();
+        var sesRegion = process.env.AWS_SES_REGION || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || 'us-east-1';
+        var 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 client_sesv2_1.SESv2Client({
+            region: sesRegion,
+            credentials: sesCredentials
+        }));
+        if (!resolveio_server_app_1.ResolveIOServer.getSESMail()) {
+            this._mailerCustom = nodemailer.createTransport({
+                host: resolveio_server_app_1.ResolveIOServer.getServerConfig()['MAIL_HOST'], // 'smtp.office365.com', // Office 365 server
+                port: resolveio_server_app_1.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: resolveio_server_app_1.ResolveIOServer.getServerConfig()['MAIL_USERNAME'],
+                    pass: resolveio_server_app_1.ResolveIOServer.getServerConfig()['MAIL_PASSWORD']
+                },
+                tls: {
+                    ciphers: 'SSLv3'
+                }
+            });
+        }
+        setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
+            var flag;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, flag_collection_1.Flags.findOne({ type: 'Enable Debug' })];
+                    case 1:
+                        flag = _a.sent();
+                        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;
+                        return [2 /*return*/];
+                }
+            });
+        }); }, 60000);
+        if (!this._isWorkersEnabled || this._isWorkerInstance) {
+            this.setupEmailWatcher();
+        }
+    };
+    MethodManager.prototype.markReady = function () {
+        if (this._ready) {
+            return;
+        }
+        this._ready = true;
+        this._readyEmitter.emit('ready');
+        this._readyEmitter.removeAllListeners('ready');
+        this._readyEmitter.removeAllListeners('readyError');
+    };
+    MethodManager.prototype.markReadyFailure = function (error) {
+        if (this._ready) {
+            return;
+        }
+        this._readyError = error;
+        this._readyEmitter.emit('readyError', error);
+        this._readyEmitter.removeAllListeners('ready');
+        this._readyEmitter.removeAllListeners('readyError');
+    };
+    MethodManager.prototype.onReady = function (callback) {
+        var _this = this;
+        if (this._ready) {
+            callback();
+            return function () { };
+        }
+        if (this._readyError) {
+            return function () { };
+        }
+        var handleReady = function () {
+            callback();
+        };
+        this._readyEmitter.once('ready', handleReady);
+        return function () {
+            _this._readyEmitter.removeListener('ready', handleReady);
+        };
+    };
+    MethodManager.prototype.waitForReadyEvent = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, events_1.once)(this._readyEmitter, 'ready')];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MethodManager.prototype.waitForReadyError = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, error;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, (0, events_1.once)(this._readyEmitter, 'readyError')];
+                    case 1:
+                        _a = __read.apply(void 0, [_b.sent(), 1]), error = _a[0];
+                        throw error || new Error('MethodManager failed to initialize');
+                }
+            });
+        });
+    };
+    MethodManager.prototype.waitForReadyTimeout = function (timeoutMs) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, promises_1.setTimeout)(timeoutMs)];
+                    case 1:
+                        _a.sent();
+                        throw new Error('MethodManager ready timeout');
+                }
+            });
+        });
+    };
+    MethodManager.prototype.isReady = function () {
+        return this._ready;
+    };
+    MethodManager.prototype.getReadyError = function () {
+        return this._readyError;
+    };
+    MethodManager.prototype.waitUntilReady = function () {
+        return __awaiter(this, arguments, void 0, function (timeoutMs) {
+            if (timeoutMs === void 0) { timeoutMs = 30000; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this._ready) {
+                            return [2 /*return*/];
+                        }
+                        if (this._readyError) {
+                            throw this._readyError;
+                        }
+                        if (!(!timeoutMs || timeoutMs <= 0)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, Promise.race([
+                                this.waitForReadyEvent(),
+                                this.waitForReadyError()
+                            ])];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 2: return [4 /*yield*/, Promise.race([
+                            this.waitForReadyEvent(),
+                            this.waitForReadyError(),
+                            this.waitForReadyTimeout(timeoutMs)
+                        ])];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MethodManager.prototype.getMethod = function (methodName) {
+        return this._methods[methodName];
+    };
+    // Add methods to private methods object
+    MethodManager.prototype.methods = function (method) {
+        this._methods = Object.assign(this._methods, method);
+    };
+    MethodManager.prototype.reportMethodError = function (subject, correlationId, context, meta, stack) {
+        return __awaiter(this, void 0, void 0, function () {
+            var metadata;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        metadata = Object.assign({}, meta || {});
+                        if (correlationId && !metadata.correlationId) {
+                            metadata.correlationId = correlationId;
+                        }
+                        return [4 /*yield*/, error_reporter_1.ErrorReporter.report({
+                                sourceApp: 'method-manager',
+                                message: subject,
+                                environment: (_a = this.serverConfig) === null || _a === void 0 ? void 0 : _a.ROOT_URL,
+                                clientSlug: resolveio_server_app_1.ResolveIOServer.getClientName(),
+                                clientName: (_b = this.serverConfig) === null || _b === void 0 ? void 0 : _b.CLIENT_NAME,
+                                severity: 'error',
+                                stack: stack,
+                                context: context,
+                                metadata: metadata,
+                                correlationId: correlationId
+                            })];
+                    case 1:
+                        _c.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MethodManager.prototype.callMethodCron = function (method) {
+        var methodData = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            methodData[_i - 1] = arguments[_i];
+        }
+        return __awaiter(this, void 0, void 0, function () {
+            var existingCorrelationId, correlationId, execute;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._debugCallMethodCronJobHits += 1;
+                        existingCorrelationId = (0, error_tracking_1.getCorrelationId)();
+                        correlationId = existingCorrelationId || (0, common_1.objectIdHexString)();
+                        execute = function () { return __awaiter(_this, void 0, void 0, function () {
+                            var cronMethod, valObj, valKeys, rootKeys, i, err_1, _a, normalizedError, resolvedCorrelationId, monitor, res, err_2, _b, normalizedError, resolvedCorrelationId;
+                            var _c;
+                            return __generator(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0:
+                                        cronMethod = this._methods[method];
+                                        if (!!cronMethod) return [3 /*break*/, 2];
+                                        console.log('No Method: ' + method);
+                                        return [4 /*yield*/, this.reportMethodError('SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'], correlationId, { message: 'No Method registered for cron execution', method: method }, { context: 'callMethodCron', method: method })];
+                                    case 1:
+                                        _d.sent();
+                                        throw new Error('No Method: ' + method);
+                                    case 2:
+                                        if (!((methodData.length > 1 || methodData[0]) && !cronMethod.skipValidation)) return [3 /*break*/, 10];
+                                        if (!!cronMethod.check) return [3 /*break*/, 4];
+                                        console.error(new Date(), 'No Check Function For Cron Method ' + method);
+                                        return [4 /*yield*/, this.reportMethodError('SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'], correlationId, { message: 'Missing check function for cron method', method: method }, { context: 'callMethodCron-validation', method: method })];
+                                    case 3:
+                                        _d.sent();
+                                        throw new Error('No Check Function For Cron Method ' + method);
+                                    case 4:
+                                        if (!!cronMethod.check._schema) return [3 /*break*/, 6];
+                                        console.error(new Date(), 'No Check Schema For Cron Method ' + method);
+                                        return [4 /*yield*/, this.reportMethodError('SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'], correlationId, { message: 'Missing check schema for cron method', method: method }, { context: 'callMethodCron-validation', method: method })];
+                                    case 5:
+                                        _d.sent();
+                                        throw new Error('No Check Schema For Cron Method ' + method);
+                                    case 6:
+                                        valObj = {};
+                                        valKeys = Object.keys(cronMethod.check._schema);
+                                        rootKeys = valKeys.filter(function (a) { return !a.includes('.'); });
+                                        for (i = 0; i < methodData.length; i++) {
+                                            valObj[rootKeys[i]] = methodData[i];
+                                        }
+                                        _d.label = 7;
+                                    case 7:
+                                        _d.trys.push([7, 8, , 10]);
+                                        cronMethod.check.validate(valObj);
+                                        return [3 /*break*/, 10];
+                                    case 8:
+                                        err_1 = _d.sent();
+                                        console.error(new Date(), 'Error in Cron Method Check (' + method + ')', err_1);
+                                        _a = (0, error_tracking_1.ensureErrorWithCorrelation)(err_1, correlationId), normalizedError = _a.error, resolvedCorrelationId = _a.correlationId;
+                                        return [4 /*yield*/, this.reportMethodError('SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'], resolvedCorrelationId, {
+                                                message: 'Match error on cron method',
+                                                method: method,
+                                                data: valObj,
+                                                validationError: normalizedError
+                                            }, { context: 'callMethodCron-validation-error', method: method }, normalizedError.stack)];
+                                    case 9:
+                                        _d.sent();
+                                        normalizedError.message = "".concat(new Date().toISOString(), " - Error in Cron Method Check (").concat(method, "): ").concat(normalizedError.message);
+                                        throw normalizedError;
+                                    case 10:
+                                        monitor = this._monitorManagerFunction.startMonitorFunction('Cron Method', method, '', '', methodData);
+                                        _d.label = 11;
+                                    case 11:
+                                        _d.trys.push([11, 13, 15, 17]);
+                                        return [4 /*yield*/, (_c = cronMethod.function).call.apply(_c, __spreadArray([Object.assign({}, this, MethodManager.prototype, { id_user: '', user: '', id_ws: '' })], __read(methodData), false))];
+                                    case 12:
+                                        res = _d.sent();
+                                        return [2 /*return*/, res];
+                                    case 13:
+                                        err_2 = _d.sent();
+                                        _b = (0, error_tracking_1.ensureErrorWithCorrelation)(err_2, correlationId), normalizedError = _b.error, resolvedCorrelationId = _b.correlationId;
+                                        return [4 /*yield*/, this.reportMethodError('SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'], resolvedCorrelationId, {
+                                                message: 'Error detected during cron method execution',
+                                                method: method,
+                                                data: methodData,
+                                                error: normalizedError
+                                            }, { context: 'callMethodCron-execution', method: method }, normalizedError.stack)];
+                                    case 14:
+                                        _d.sent();
+                                        normalizedError.message = "".concat(new Date().toISOString(), " - Error in Cron Method (").concat(method, "): ").concat(normalizedError.message);
+                                        throw normalizedError;
+                                    case 15: return [4 /*yield*/, this._monitorManagerFunction.finishMonitorFunction(monitor)];
+                                    case 16:
+                                        _d.sent();
+                                        return [7 /*endfinally*/];
+                                    case 17: return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        return [4 /*yield*/, (0, error_tracking_1.runWithCorrelationContext)(correlationId, execute)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // Call/run method internal (No Emit on Socket)
+    MethodManager.prototype.callMethod = function (methodName) {
+        var methodData = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            methodData[_i - 1] = arguments[_i];
+        }
+        return __awaiter(this, void 0, void 0, function () {
+            var existingCorrelationId, correlationId;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._debugcallMethodHits += 1;
+                        existingCorrelationId = (0, error_tracking_1.getCorrelationId)();
+                        correlationId = existingCorrelationId || (0, common_1.objectIdHexString)();
+                        return [4 /*yield*/, (0, error_tracking_1.runWithCorrelationContext)(correlationId, function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.callMethodInternal(correlationId, methodName, methodData)];
+                                    case 1: return [2 /*return*/, _a.sent()];
+                                }
+                            }); }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MethodManager.prototype.callMethodInternal = function (correlationId, methodName, methodData) {
+        return __awaiter(this, void 0, void 0, function () {
+            var method, shouldTrackTextMetric, textMetricProvider, releaseLocalConcurrency, methodCallback_1, functionMethodData_1, session, shouldStartTransaction, executeWithExistingSession_1, monitor_2;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        method = this.getMethod(methodName);
+                        if (!method) {
+                            console.log('No Method: ' + methodName);
+                            throw new Error("No Method: ".concat(methodName));
+                        }
+                        shouldTrackTextMetric = this.shouldTrackTextMessageMetric(methodName);
+                        textMetricProvider = shouldTrackTextMetric ? this.getTextMessageProvider() : undefined;
+                        return [4 /*yield*/, this.acquireLocalConcurrency(methodName, method.maxConcurrency)];
+                    case 1:
+                        releaseLocalConcurrency = _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, , 7, 8]);
+                        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: ".concat(methodName));
+                            }
+                            else if (!method.check._schema) {
+                                console.error(new Date(), 'No Check Schema For Method ' + methodName);
+                                throw new Error("No Check Schema For Method: ".concat(methodName));
+                            }
+                        }
+                        if (!(methodName !== 'insertSubscriptionLog' &&
+                            methodName !== 'getDataURIfromURL' &&
+                            methodName !== 'processAirdropDistribution' &&
+                            methodName !== 'incCounter' &&
+                            methodName !== 'supportCreateBillingUser' &&
+                            methodName !== 'countCollectionWithQuery' &&
+                            methodName !== 'countWithQuery' &&
+                            methodName !== 'qbFetchRequests' &&
+                            methodName !== 'qbHandleResponse')) return [3 /*break*/, 6];
+                        if (!resolveio_server_app_1.ResolveIOServer.shouldWriteLogsOffline()) return [3 /*break*/, 3];
+                        resolveio_server_app_1.ResolveIOServer.getLocalLogManager().writeLog({
+                            type: 'log',
+                            data: {
+                                _id: (0, common_1.objectIdHexString)(),
+                                createdAt: new Date(),
+                                type: 'callMethod',
+                                collection: '',
+                                id_document: '',
+                                payload: (0, common_1.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: correlationId
+                            }
+                        });
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, log_collection_1.Logs.insertOne({
+                            _id: (0, common_1.objectIdHexString)(),
+                            type: 'callMethod',
+                            collection: '',
+                            id_document: '',
+                            payload: (0, common_1.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: resolveio_server_app_1.ResolveIOServer.getInstanceHost(),
+                            instance_index: process.env.NODE_APP_INSTANCE || '0',
+                            correlationId: correlationId
+                        })];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5:
+                        ;
+                        _a.label = 6;
+                    case 6:
+                        methodCallback_1 = typeof (methodData[methodData.length - 1]) === 'function' ? methodData[methodData.length - 1] : null;
+                        functionMethodData_1 = methodCallback_1 ? methodData.slice(0, -1) : methodData;
+                        session = resolveio_server_app_1.ResolveIOServer.getMongoManager().getSession();
+                        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');
+                        executeWithExistingSession_1 = function () { return __awaiter(_this, void 0, void 0, function () {
+                            var monitor, res, error_3, err_3, _a, normalizedError, resolvedCorrelationId, error_4;
+                            var _b;
+                            return __generator(this, function (_c) {
+                                switch (_c.label) {
+                                    case 0:
+                                        monitor = this._monitorManagerFunction.startMonitorFunction('Method', methodName, this['user'] || '', '', functionMethodData_1);
+                                        _c.label = 1;
+                                    case 1:
+                                        _c.trys.push([1, 7, 15, 17]);
+                                        return [4 /*yield*/, (_b = method.function).call.apply(_b, __spreadArray([Object.assign({}, this, MethodManager.prototype)], __read(functionMethodData_1), false))];
+                                    case 2:
+                                        res = _c.sent();
+                                        if (methodCallback_1) {
+                                            methodCallback_1(null, res);
+                                        }
+                                        if (!shouldTrackTextMetric) return [3 /*break*/, 6];
+                                        _c.label = 3;
+                                    case 3:
+                                        _c.trys.push([3, 5, , 6]);
+                                        return [4 /*yield*/, (0, communication_metric_manager_1.recordTextMessageMetric)({
+                                                status: 'sent',
+                                                provider: textMetricProvider,
+                                                metadata: {
+                                                    method: methodName
+                                                }
+                                            })];
+                                    case 4:
+                                        _c.sent();
+                                        return [3 /*break*/, 6];
+                                    case 5:
+                                        error_3 = _c.sent();
+                                        console.error('Error recording text message metric:', error_3);
+                                        return [3 /*break*/, 6];
+                                    case 6: return [2 /*return*/, res];
+                                    case 7:
+                                        err_3 = _c.sent();
+                                        if (err_3.code === 112 || err_3.codeName === 'WriteConflict' || err_3.code === 251 || err_3.codeName === 'NoSuchTransaction') {
+                                            throw err_3; // Write error, retry
+                                        }
+                                        _a = (0, error_tracking_1.ensureErrorWithCorrelation)(err_3, correlationId), normalizedError = _a.error, resolvedCorrelationId = _a.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));
+                                        return [4 /*yield*/, 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: methodName }, normalizedError.stack)];
+                                    case 8:
+                                        _c.sent();
+                                        normalizedError.message = "".concat(new Date().toISOString(), " - Error in Method (").concat(methodName, ") - Existing Session: ").concat(normalizedError.message);
+                                        if (methodCallback_1) {
+                                            methodCallback_1(normalizedError, null);
+                                        }
+                                        if (!shouldTrackTextMetric) return [3 /*break*/, 12];
+                                        _c.label = 9;
+                                    case 9:
+                                        _c.trys.push([9, 11, , 12]);
+                                        return [4 /*yield*/, (0, communication_metric_manager_1.recordTextMessageMetric)({
+                                                status: 'failed',
+                                                provider: textMetricProvider,
+                                                metadata: {
+                                                    method: methodName
+                                                }
+                                            })];
+                                    case 10:
+                                        _c.sent();
+                                        return [3 /*break*/, 12];
+                                    case 11:
+                                        error_4 = _c.sent();
+                                        console.error('Error recording text message metric:', error_4);
+                                        return [3 /*break*/, 12];
+                                    case 12:
+                                        if (!!process.env.IS_WORKER_INSTANCE) return [3 /*break*/, 14];
+                                        return [4 /*yield*/, this.callMethod('insertErrorLog', "Error in Method: ".concat(methodName), {
+                                                method: methodName,
+                                                methodData: methodData,
+                                                error: {
+                                                    message: normalizedError.message,
+                                                    stack: normalizedError.stack,
+                                                    code: normalizedError.code,
+                                                    codeName: normalizedError.codeName
+                                                },
+                                                correlationId: resolvedCorrelationId
+                                            })];
+                                    case 13:
+                                        _c.sent();
+                                        _c.label = 14;
+                                    case 14: throw normalizedError;
+                                    case 15: return [4 /*yield*/, this._monitorManagerFunction.finishMonitorFunction(monitor)];
+                                    case 16:
+                                        _c.sent();
+                                        return [7 /*endfinally*/];
+                                    case 17: return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        if (shouldStartTransaction) {
+                            monitor_2 = null;
+                            return [2 /*return*/, resolveio_server_app_1.ResolveIOServer.getMongoManager().oneTimeTransaction(function () { return __awaiter(_this, void 0, void 0, function () {
+                                    var res, error_5, err_4, _a, normalizedError, resolvedCorrelationId, error_6;
+                                    var _b;
+                                    return __generator(this, function (_c) {
+                                        switch (_c.label) {
+                                            case 0:
+                                                // console.log(new Date(), 'Calling Method - New Session', methodName);
+                                                monitor_2 = this._monitorManagerFunction.startMonitorFunction('Method', methodName, this['user'] || '', '', functionMethodData_1);
+                                                _c.label = 1;
+                                            case 1:
+                                                _c.trys.push([1, 7, 15, 17]);
+                                                return [4 /*yield*/, (_b = method.function).call.apply(_b, __spreadArray([Object.assign({}, this, MethodManager.prototype)], __read(functionMethodData_1), false))];
+                                            case 2:
+                                                res = _c.sent();
+                                                if (methodCallback_1) {
+                                                    methodCallback_1(null, res);
+                                                }
+                                                if (!shouldTrackTextMetric) return [3 /*break*/, 6];
+                                                _c.label = 3;
+                                            case 3:
+                                                _c.trys.push([3, 5, , 6]);
+                                                return [4 /*yield*/, (0, communication_metric_manager_1.recordTextMessageMetric)({
+                                                        status: 'sent',
+                                                        provider: textMetricProvider,
+                                                        metadata: {
+                                                            method: methodName
+                                                        }
+                                                    })];
+                                            case 4:
+                                                _c.sent();
+                                                return [3 /*break*/, 6];
+                                            case 5:
+                                                error_5 = _c.sent();
+                                                console.error('Error recording text message metric:', error_5);
+                                                return [3 /*break*/, 6];
+                                            case 6: return [2 /*return*/, res];
+                                            case 7:
+                                                err_4 = _c.sent();
+                                                if (err_4.code === 112 || err_4.codeName === 'WriteConflict' || err_4.code === 251 || err_4.codeName === 'NoSuchTransaction') {
+                                                    throw err_4; // Write error, retry
+                                                }
+                                                _a = (0, error_tracking_1.ensureErrorWithCorrelation)(err_4, correlationId), normalizedError = _a.error, resolvedCorrelationId = _a.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));
+                                                return [4 /*yield*/, 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: methodName }, normalizedError.stack)];
+                                            case 8:
+                                                _c.sent();
+                                                normalizedError.message = "".concat(new Date().toISOString(), " - Error in Method With Session (").concat(methodName, ") - New Session: ").concat(normalizedError.message);
+                                                if (methodCallback_1) {
+                                                    methodCallback_1(normalizedError, null);
+                                                }
+                                                if (!shouldTrackTextMetric) return [3 /*break*/, 12];
+                                                _c.label = 9;
+                                            case 9:
+                                                _c.trys.push([9, 11, , 12]);
+                                                return [4 /*yield*/, (0, communication_metric_manager_1.recordTextMessageMetric)({
+                                                        status: 'failed',
+                                                        provider: textMetricProvider,
+                                                        metadata: {
+                                                            method: methodName
+                                                        }
+                                                    })];
+                                            case 10:
+                                                _c.sent();
+                                                return [3 /*break*/, 12];
+                                            case 11:
+                                                error_6 = _c.sent();
+                                                console.error('Error recording text message metric:', error_6);
+                                                return [3 /*break*/, 12];
+                                            case 12:
+                                                if (!!process.env.IS_WORKER_INSTANCE) return [3 /*break*/, 14];
+                                                return [4 /*yield*/, this.callMethod('insertErrorLog', "Error in Method: ".concat(methodName), {
+                                                        method: methodName,
+                                                        methodData: methodData,
+                                                        error: {
+                                                            message: normalizedError.message,
+                                                            stack: normalizedError.stack,
+                                                            code: normalizedError.code,
+                                                            codeName: normalizedError.codeName
+                                                        },
+                                                        correlationId: resolvedCorrelationId
+                                                    })];
+                                            case 13:
+                                                _c.sent();
+                                                _c.label = 14;
+                                            case 14: throw normalizedError;
+                                            case 15: return [4 /*yield*/, this._monitorManagerFunction.finishMonitorFunction(monitor_2)];
+                                            case 16:
+                                                _c.sent();
+                                                return [7 /*endfinally*/];
+                                            case 17: return [2 /*return*/];
+                                        }
+                                    });
+                                }); })];
+                        }
+                        else if (method.bypassSession && session) {
+                            return [2 /*return*/, resolveio_server_app_1.ResolveIOServer.getMongoManager().runWithoutSession(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, executeWithExistingSession_1()];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                }); }); })];
+                        }
+                        else {
+                            return [2 /*return*/, executeWithExistingSession_1()];
+                        }
+                        return [3 /*break*/, 8];
+                    case 7:
+                        releaseLocalConcurrency();
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MethodManager.prototype.acquireLocalConcurrency = function (methodName, maxConcurrency) {
+        return __awaiter(this, void 0, void 0, function () {
+            var current;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (!maxConcurrency || maxConcurrency < 1) {
+                    return [2 /*return*/, function () { }];
+                }
+                current = this._localActiveCounts.get(methodName) || 0;
+                if (current < maxConcurrency) {
+                    this._localActiveCounts.set(methodName, current + 1);
+                    return [2 /*return*/, this.createLocalRelease(methodName)];
+                }
+                // eslint-disable-next-line no-restricted-syntax
+                return [2 /*return*/, new Promise(function (resolve) {
+                        var queue = _this._localWaitQueues.get(methodName);
+                        if (!queue) {
+                            queue = [];
+                            _this._localWaitQueues.set(methodName, queue);
+                        }
+                        queue.push(function () {
+                            var curr = _this._localActiveCounts.get(methodName) || 0;
+                            _this._localActiveCounts.set(methodName, curr + 1);
+                            resolve(_this.createLocalRelease(methodName));
+                        });
+                    })];
+            });
+        });
+    };
+    MethodManager.prototype.createLocalRelease = function (methodName) {
+        var _this = this;
+        var released = false;
+        return function () {
+            if (released) {
+                return;
+            }
+            released = true;
+            var current = _this._localActiveCounts.get(methodName) || 0;
+            _this._localActiveCounts.set(methodName, current > 0 ? current - 1 : 0);
+            var queue = _this._localWaitQueues.get(methodName);
+            if (queue && queue.length) {
+                var next = queue.shift();
+                if (next) {
+                    next();
+                }
+            }
+        };
+    };
+    MethodManager.prototype.setupEmailWatcher = function () {
+        var _this = this;
+        var changeStream = email_history_collection_1.EmailHistories.watchCollection([]);
+        changeStream.on('change', function (change) { return __awaiter(_this, void 0, void 0, function () {
+            var updatedEmail;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(change.operationType === 'insert' && change.fullDocument && change.fullDocument.status === 'pending')) return [3 /*break*/, 2];
+                        this.emailQueue.add(change.fullDocument._id.toString());
+                        return [4 /*yield*/, this.tryProcessEmail()];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        if (change.operationType === 'update' || change.operationType === 'replace') {
+                            updatedEmail = change.fullDocument;
+                            if (updatedEmail && updatedEmail.status !== 'pending' && this.emailQueue.has(updatedEmail._id.toString())) {
+                                this.emailQueue.delete(updatedEmail._id.toString());
+                            }
+                        }
+                        _a.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); })
+            .on('error', function (err) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.error('Email history changestream error', err);
+                        return [4 /*yield*/, changeStream.close()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); })
+            .on('close', function () {
+            _this.setupEmailWatcher();
+        });
+    };
+    MethodManager.prototype.loadPendingEmails = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pendingEmails, pendingEmails_1, pendingEmails_1_1, email;
+            var e_1, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, email_history_collection_1.EmailHistories.find({ status: 'pending' }, { sort: { _id: 1 } })];
+                    case 1:
+                        pendingEmails = _b.sent();
+                        try {
+                            for (pendingEmails_1 = __values(pendingEmails), pendingEmails_1_1 = pendingEmails_1.next(); !pendingEmails_1_1.done; pendingEmails_1_1 = pendingEmails_1.next()) {
+                                email = pendingEmails_1_1.value;
+                                this.emailQueue.add(email._id.toString());
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (pendingEmails_1_1 && !pendingEmails_1_1.done && (_a = pendingEmails_1.return)) _a.call(pendingEmails_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        // Try to process emails
+                        return [4 /*yield*/, this.tryProcessEmail()];
+                    case 2:
+                        // Try to process emails
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MethodManager.prototype.tryProcessEmail = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _loop_1, this_1, err_5;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.isEmailProcessing || this.emailQueue.size === 0) {
+                            return [2 /*return*/];
+                        }
+                        this.isEmailProcessing = true;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 5, 6, 9]);
+                        _loop_1 = function () {
+                            var emailId, pendingEmail, queuedAt, timeSinceQueued, remainingDelay, emailHistory, validAttachments, attachmentError, _b, _c, att, response, arrayBuffer, buffer, maxSize, err_6, e_2_1, mailOptions, emailProvider;
+                            var e_2, _d;
+                            return __generator(this, function (_e) {
+                                switch (_e.label) {
+                                    case 0:
+                                        emailId = this_1.emailQueue.values().next().value;
+                                        this_1.emailQueue.delete(emailId);
+                                        return [4 /*yield*/, email_history_collection_1.EmailHistories.findOne({
+                                                _id: emailId,
+                                                status: 'pending',
+                                            })];
+                                    case 1:
+                                        pendingEmail = _e.sent();
+                                        if (!pendingEmail) {
+                                            return [2 /*return*/, "continue"];
+                                        }
+                                        queuedAt = void 0;
+                                        if (pendingEmail.date instanceof Date) {
+                                            queuedAt = pendingEmail.date;
+                                        }
+                                        else if (pendingEmail.createdAt instanceof Date) {
+                                            queuedAt = pendingEmail.createdAt;
+                                        }
+                                        else {
+                                            queuedAt = new Date();
+                                        }
+                                        timeSinceQueued = Date.now() - queuedAt.getTime();
+                                        remainingDelay = this_1._emailProcessingDelayMs - timeSinceQueued;
+                                        if (!(remainingDelay > 0)) return [3 /*break*/, 3];
+                                        // eslint-disable-next-line no-restricted-syntax
+                                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, remainingDelay); })];
+                                    case 2:
+                                        // eslint-disable-next-line no-restricted-syntax
+                                        _e.sent();
+                                        _e.label = 3;
+                                    case 3: return [4 /*yield*/, email_history_collection_1.EmailHistories.findOneAndUpdate({
+                                            _id: emailId,
+                                            status: 'pending',
+                                        }, {
+                                            $set: { status: 'processing', processingAt: new Date() },
+                                        })];
+                                    case 4:
+                                        emailHistory = _e.sent();
+                                        if (!emailHistory) {
+                                            return [2 /*return*/, "continue"];
+                                        }
+                                        if (!(emailHistory.attachments && emailHistory.attachments.length > 0)) return [3 /*break*/, 18];
+                                        validAttachments = [];
+                                        attachmentError = false;
+                                        _e.label = 5;
+                                    case 5:
+                                        _e.trys.push([5, 15, 16, 17]);
+                                        _b = (e_2 = void 0, __values(emailHistory.attachments)), _c = _b.next();
+                                        _e.label = 6;
+                                    case 6:
+                                        if (!!_c.done) return [3 /*break*/, 14];
+                                        att = _c.value;
+                                        if (!(att.path && att.path.startsWith('http'))) return [3 /*break*/, 12];
+                                        _e.label = 7;
+                                    case 7:
+                                        _e.trys.push([7, 10, , 11]);
+                                        return [4 /*yield*/, fetch(att.path)];
+                                    case 8:
+                                        response = _e.sent();
+                                        if (!response.ok) {
+                                            attachmentError = true;
+                                            return [3 /*break*/, 13];
+                                        }
+                                        return [4 /*yield*/, response.arrayBuffer()];
+                                    case 9:
+                                        arrayBuffer = _e.sent();
+                                        buffer = Buffer.from(arrayBuffer);
+                                        maxSize = 20 * 1024 * 1024;
+                                        if (buffer.length <= maxSize) {
+                                            // Attachment is within size limits, include it
+                                            att.content = buffer;
+                                            delete att.path;
+                                            validAttachments.push(att);
+                                        }
+                                        return [3 /*break*/, 11];
+                                    case 10:
+                                        err_6 = _e.sent();
+                                        console.error('Failed to fetch attachment:', err_6);
+                                        attachmentError = true;
+                                        return [3 /*break*/, 11];
+                                    case 11: return [3 /*break*/, 13];
+                                    case 12:
+                                        validAttachments.push(att);
+                                        _e.label = 13;
+                                    case 13:
+                                        _c = _b.next();
+                                        return [3 /*break*/, 6];
+                                    case 14: return [3 /*break*/, 17];
+                                    case 15:
+                                        e_2_1 = _e.sent();
+                                        e_2 = { error: e_2_1 };
+                                        return [3 /*break*/, 17];
+                                    case 16:
+                                        try {
+                                            if (_c && !_c.done && (_d = _b.return)) _d.call(_b);
+                                        }
+                                        finally { if (e_2) throw e_2.error; }
+                                        return [7 /*endfinally*/];
+                                    case 17:
+                                        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>';
+                                        }
+                                        _e.label = 18;
+                                    case 18:
+                                        mailOptions = {
+                                            replyTo: emailHistory.reply_to || (resolveio_server_app_1.ResolveIOServer.getServerConfig()['MAIL_REPLY_TO'] || undefined),
+                                            from: emailHistory.send_from || resolveio_server_app_1.ResolveIOServer.getServerConfig().MAIL_FROM,
+                                            to: emailHistory.email,
+                                            subject: (resolveio_server_app_1.ResolveIOServer.getServerConfig()['ROOT_URL'].match(/https:\/\/dev\./) ||
+                                                resolveio_server_app_1.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(function (att) {
+                                                var newAtt = __assign({}, 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;
+                                            });
+                                        }
+                                        emailProvider = (!mailOptions.force_ses && this_1._mailerCustom) ? 'custom' : 'ses';
+                                        (!mailOptions.force_ses && this_1._mailerCustom ? this_1._mailerCustom : this_1._mailerSES).sendMail(mailOptions, function (err) { return __awaiter(_this, void 0, void 0, function () {
+                                            var metricStatus, error_7, error_8;
+                                            return __generator(this, function (_a) {
+                                                switch (_a.label) {
+                                                    case 0:
+                                                        metricStatus = err ? 'failed' : 'sent';
+                                                        _a.label = 1;
+                                                    case 1:
+                                                        _a.trys.push([1, 8, 10, 14]);
+                                                        if (!err) return [3 /*break*/, 3];
+                                                        console.error('Failed to send email:', err);
+                                                        return [4 /*yield*/, email_history_collection_1.EmailHistories.updateOne({ _id: emailHistory._id }, {
+                                                                $set: {
+                                                                    status: 'failed',
+                                                                    error: typeof err === 'string' ? err : this.safeStringify(err),
+                                                                    completedAt: new Date(),
+                                                                },
+                                                            })];
+                                                    case 2:
+                                                        _a.sent();
+                                                        return [3 /*break*/, 7];
+                                                    case 3:
+                                                        if (!(emailHistory.email === 'dev@resolveio.com')) return [3 /*break*/, 5];
+                                                        return [4 /*yield*/, email_history_collection_1.EmailHistories.deleteOne({ _id: emailHistory._id })];
+                                                    case 4:
+                                                        _a.sent();
+                                                        return [3 /*break*/, 7];
+                                                    case 5: return [4 /*yield*/, email_history_collection_1.EmailHistories.updateOne({ _id: emailHistory._id }, {
+                                                            $set: {
+                                                                status: 'completed',
+                                                                completedAt: new Date(),
+                                                            },
+                                                        })];
+                                                    case 6:
+                                                        _a.sent();
+                                                        _a.label = 7;
+                                                    case 7: return [3 /*break*/, 14];
+                                                    case 8:
+                                                        error_7 = _a.sent();
+                                                        console.error('Error in sendMail callback:', error_7);
+                                                        return [4 /*yield*/, email_history_collection_1.EmailHistories.updateOne({ _id: emailHistory._id }, {
+                                                                $set: {
+                                                                    status: 'failed',
+                                                                    error: typeof error_7 === 'string' ? error_7 : this.safeStringify(error_7),
+                                                                    completedAt: new Date(),
+                                                                },
+                                                            })];
+                                                    case 9:
+                                                        _a.sent();
+                                                        return [3 /*break*/, 14];
+                                                    case 10:
+                                                        _a.trys.push([10, 12, , 13]);
+                                                        return [4 /*yield*/, (0, communication_metric_manager_1.recordEmailMetric)({
+                                                                status: metricStatus,
+                                                                provider: emailProvider,
+                                                                metadata: {
+                                                                    method: 'sendEmail'
+                                                                }
+                                                            })];
+                                                    case 11:
+                                                        _a.sent();
+                                                        return [3 /*break*/, 13];
+                                                    case 12:
+                                                        error_8 = _a.sent();
+                                                        console.error('Error recording email metric:', error_8);
+                                                        return [3 /*break*/, 13];
+                                                    case 13: return [7 /*endfinally*/];
+                                                    case 14: return [2 /*return*/];
+                                                }
+                                            });
+                                        }); });
+                                        // Wait for at least one second before sending the next email
+                                        // eslint-disable-next-line no-restricted-syntax
+                                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1000); })];
+                                    case 19:
+                                        // Wait for at least one second before sending the next email
+                                        // eslint-disable-next-line no-restricted-syntax
+                                        _e.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        _a.label = 2;
+                    case 2:
+                        if (!(this.emailQueue.size > 0)) return [3 /*break*/, 4];
+                        return [5 /*yield**/, _loop_1()];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 2];
+                    case 4: return [3 /*break*/, 9];
+                    case 5:
+                        err_5 = _a.sent();
+                        console.error('Error processing email queue:', err_5);
+                        return [3 /*break*/, 9];
+                    case 6:
+                        this.isEmailProcessing = false;
+                        if (!(this.emailQueue.size > 0)) return [3 /*break*/, 8];
+                        return [4 /*yield*/, this.tryProcessEmail()];
+                    case 7:
+                        _a.sent();
+                        _a.label = 8;
+                    case 8: return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MethodManager.prototype.shouldTrackTextMessageMetric = function (methodName) {
+        var normalized = String(methodName || '').trim().toLowerCase();
+        if (!normalized) {
+            return false;
+        }
+        return normalized.startsWith('sendsms') || normalized.startsWith('sendtext');
+    };
+    MethodManager.prototype.getTextMessageProvider = function () {
+        var _a, _b, _c;
+        var provider = ((_a = this.serverConfig) === null || _a === void 0 ? void 0 : _a['SMS_PROVIDER']) || '';
+        if (typeof provider === 'string' && provider.trim().length) {
+            return provider.trim().toLowerCase();
+        }
+        if (((_b = this.serverConfig) === null || _b === void 0 ? void 0 : _b['TWILIO_SID']) || ((_c = this.serverConfig) === null || _c === void 0 ? void 0 : _c['TWILIO_AUTH_TOKEN'])) {
+            return 'twilio';
+        }
+        return undefined;
+    };
+    MethodManager.prototype.safeStringify = function (obj) {
+        try {
+            return JSON.stringify(obj, this.getCircularReplacer());
+        }
+        catch (e) {
+            return "Error in JSON stringifying: ".concat(e.message);
+        }
+    };
+    MethodManager.prototype.getCircularReplacer = function () {
+        var seen = new WeakSet();
+        return function (key, value) {
+            if (typeof value === "object" && value !== null) {
+                if (seen.has(value)) {
+                    return "[Circular]";
+                }
+                seen.add(value);
+            }
+            return value;
+        };
+    };
+    MethodManager.prototype.tryMergeEmailOccurrence = function (email, subject, correlationId, occurrence, meta) {
+        return __awaiter(this, void 0, void 0, function () {
+            var existing, normalizedOccurrences, _a, aggregatedText, aggregatedHtml, updated;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, email_history_collection_1.EmailHistories.findOne({
+                            email: email,
+                            correlationId: correlationId,
+                            status: 'pending'
+                        }, { sort: { date: 1 } })];
+                    case 1:
+                        existing = _b.sent();
+                        if (!existing) {
+                            return [2 /*return*/, null];
+                        }
+                        normalizedOccurrences = Array.isArray(existing.occurrences) && existing.occurrences.length
+                            ? existing.occurrences.map(function (item) { return ({
+                                _id: item._id || (0, common_1.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);
+                        _a = formatGroupedEmailContent(correlationId, normalizedOccurrences), aggregatedText = _a.text, aggregatedHtml = _a.html;
+                        return [4 /*yield*/, email_history_collection_1.EmailHistories.findOneAndUpdate({
+                                _id: existing._id,
+                                status: 'pending'
+                            }, {
+                                $set: {
+                                    subject: subject,
+                                    text: aggregatedText,
+                                    html: aggregatedHtml,
+                                    occurrences: normalizedOccurrences,
+                                    meta: meta || existing.meta,
+                                    updatedAt: new Date()
+                                }
+                            }, { returnDocument: 'after' })];
+                    case 2:
+                        updated = _b.sent();
+                        return [2 /*return*/, updated || null];
+                }
+            });
+        });
+    };
+    MethodManager.prototype.sendEmail = function (sendTo_1, subject_1, text_1, html_1, attachments_1, send_from_1, reply_to_1) {
+        return __awaiter(this, arguments, void 0, function (sendTo, subject, text, html, attachments, send_from, reply_to, force_ses, local_override, options) {
+            var normalizedSubject, correlationId, finalSubject, groupByCorrelationId, normalizedText, normalizedHtml, occurrence, allowGrouping, normalizedAttachments, merged, emailHistory, _a, aggregatedText, aggregatedHtml, history_1, err_7;
+            if (force_ses === void 0) { force_ses = false; }
+            if (local_override === void 0) { local_override = false; }
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        // Modify sendTo in development environments
+                        if ((resolveio_server_app_1.ResolveIOServer.getServerConfig()['ROOT_URL'].match(/https:\/\/dev\./) ||
+                            resolveio_server_app_1.ResolveIOServer.getServerConfig()['ROOT_URL'].match(/https:\/\/www\.dev\./) ||
+                            resolveio_server_app_1.ResolveIOServer.getServerConfig()['ROOT_URL'] === 'http://localhost:4200') &&
+                            !sendTo.match(/\@resolveio\.com/)) {
+                            sendTo = 'dev@resolveio.com';
+                        }
+                        normalizedSubject = subject || '';
+                        correlationId = options === null || options === void 0 ? void 0 : options.correlationId;
+                        finalSubject = appendCorrelationIdToSubject(normalizedSubject, correlationId);
+                        groupByCorrelationId = !!correlationId;
+                        normalizedText = typeof text === 'string' ? text : '';
+                        normalizedHtml = typeof html === 'string' ? html : '';
+                        occurrence = groupByCorrelationId
+                            ? createEmailOccurrence(normalizedSubject, normalizedText, normalizedHtml, options === null || options === void 0 ? void 0 : options.meta)
+                            : null;
+                        allowGrouping = groupByCorrelationId;
+                        if (!sendTo) return [3 /*break*/, 9];
+                        if (!(resolveio_server_app_1.ResolveIOServer.getServerConfig()['ROOT_URL'] !== 'http://localhost:4200' ||
+                            local_override)) return [3 /*break*/, 7];
+                        normalizedAttachments = [];
+                        if (Array.isArray(attachments)) {
+                            normalizedAttachments = attachments.slice();
+                        }
+                        else if (attachments) {
+                            normalizedAttachments = [attachments];
+                        }
+                        normalizedAttachments = normalizedAttachments.map(function (att) {
+                            var newAtt = __assign({}, 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)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.tryMergeEmailOccurrence(sendTo, finalSubject, correlationId, occurrence, options === null || options === void 0 ? void 0 : options.meta)];
+                    case 1:
+                        merged = _b.sent();
+                        if (merged) {
+                            return [2 /*return*/, merged];
+                        }
+                        _b.label = 2;
+                    case 2:
+                        emailHistory = {
+                            _id: (0, common_1.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: force_ses
+                        };
+                        if (allowGrouping && occurrence && correlationId) {
+                            _a = formatGroupedEmailContent(correlationId, [occurrence]), aggregatedText = _a.text, aggregatedHtml = _a.html;
+                            emailHistory.text = aggregatedText;
+                            emailHistory.html = aggregatedHtml;
+                            emailHistory.occurrences = [occurrence];
+                            emailHistory.correlationId = correlationId;
+                            if (options === null || options === void 0 ? void 0 : options.meta) {
+                                emailHistory.meta = options.meta;
+                            }
+                        }
+                        else {
+                            if (correlationId) {
+                                emailHistory.correlationId = correlationId;
+                            }
+                            if (options === null || options === void 0 ? void 0 : options.meta) {
+                                emailHistory.meta = options.meta;
+                            }
+                        }
+                        _b.label = 3;
+                    case 3:
+                        _b.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, email_history_collection_1.EmailHistories.insertOne(emailHistory)];
+                    case 4:
+                        history_1 = _b.sent();
+                        return [2 /*return*/, history_1];
+                    case 5:
+                        err_7 = _b.sent();
+                        console.error('Failed to queue email:', err_7);
+                        err_7.message = "Failed to queue email: ".concat(err_7.message);
+                        throw err_7;
+                    case 6: return [3 /*break*/, 8];
+                    case 7:
+                        console.log('Send email', sendTo, finalSubject, normalizedText, normalizedHtml, attachments, send_from, force_ses, correlationId);
+                        return [2 /*return*/, true];
+                    case 8: return [3 /*break*/, 10];
+                    case 9: return [2 /*return*/, true];
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MethodManager.prototype.getAWS = function () {
+        return this._aws;
+    };
+    MethodManager.prototype.readFile = function (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: ".concat(err.message);
+                throw err;
+            }
+        }
+        else {
+            if (fs.existsSync(path.join(resolveio_server_app_1.ResolveIOServer.getClientDir(), ('./private/' + fileName)))) {
+                try {
+                    return fs.readFileSync(path.join(resolveio_server_app_1.ResolveIOServer.getClientDir(), ('./private/' + fileName)), 'utf-8');
+                }
+                catch (err) {
+                    err.message = "Error in readFile: ".concat(err.message);
+                    throw err;
+                }
+            }
+        }
+        throw new Error('Error in readFile: File Not Found');
+    };
+    MethodManager.prototype.readImage = function (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: ".concat(err.message);
+                throw err;
+            }
+        }
+        else {
+            if (fs.existsSync(path.join(resolveio_server_app_1.ResolveIOServer.getClientDir(), ('./private/' + fileName)))) {
+                try {
+                    return fs.readFileSync(path.join(resolveio_server_app_1.ResolveIOServer.getClientDir(), ('./private/' + fileName)), 'base64');
+                }
+                catch (err) {
+                    err.message = "Error in readImage: ".concat(err.message);
+                    throw err;
+                }
+            }
+        }
+        throw new Error('Error in readImage: File Not Found');
+    };
+    MethodManager.prototype.getEnableDebug = function () {
+        return this._enableDebug;
+    };
+    return MethodManager;
+}());
+exports.MethodManager = MethodManager;
+
+//# sourceMappingURL=method.manager.js.map