@flusys/nestjs-email 1.1.0-beta

package/cjs/providers/mailgun-provider.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MailgunProvider", {
+    enumerable: true,
+    get: function() {
+        return MailgunProvider;
+    }
+});
+const _common = require("@nestjs/common");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+let MailgunProvider = class MailgunProvider {
+    /**
+   * Initialize the Mailgun provider with configuration
+   */ async initialize(config) {
+        this.config = config;
+        try {
+            // Dynamic import mailgun.js and form-data - use eval to bypass TypeScript module resolution
+            // eslint-disable-next-line @typescript-eslint/no-implied-eval
+            const Mailgun = (await new Function('return import("mailgun.js")')()).default;
+            const FormData = (await new Function('return import("form-data")')()).default;
+            const mailgun = new Mailgun(FormData);
+            // Determine API URL based on region
+            const url = config.region === 'eu' ? 'https://api.eu.mailgun.net' : 'https://api.mailgun.net';
+            this.client = mailgun.client({
+                username: 'api',
+                key: config.apiKey,
+                url
+            });
+            this.logger.log(`Mailgun Provider initialized for domain: ${config.domain}`);
+        } catch (error) {
+            this.logger.error('Failed to initialize Mailgun:', error.message);
+            throw new Error('Mailgun initialization failed. Make sure mailgun.js and form-data are installed: npm install mailgun.js form-data');
+        }
+    }
+    /**
+   * Send a single email
+   */ async sendEmail(options) {
+        if (!this.client || !this.config) {
+            return {
+                success: false,
+                error: 'Mailgun provider not initialized'
+            };
+        }
+        try {
+            const to = Array.isArray(options.to) ? options.to.join(', ') : options.to;
+            const cc = options.cc ? Array.isArray(options.cc) ? options.cc.join(', ') : options.cc : undefined;
+            const bcc = options.bcc ? Array.isArray(options.bcc) ? options.bcc.join(', ') : options.bcc : undefined;
+            const messageData = {
+                from: options.fromName ? `${options.fromName} <${options.from}>` : options.from,
+                to,
+                subject: options.subject
+            };
+            // Only include html/text if they have values (required for plain text templates)
+            if (options.html) messageData.html = options.html;
+            if (options.text) messageData.text = options.text;
+            // Optional fields
+            if (cc) messageData.cc = cc;
+            if (bcc) messageData.bcc = bcc;
+            if (options.replyTo) messageData['h:Reply-To'] = options.replyTo;
+            // Handle attachments
+            if (options.attachments && options.attachments.length > 0) {
+                messageData.attachment = options.attachments.map((a)=>({
+                        filename: a.filename,
+                        data: typeof a.content === 'string' ? Buffer.from(a.content, 'base64') : a.content,
+                        contentType: a.contentType
+                    }));
+            }
+            const result = await this.client.messages.create(this.config.domain, messageData);
+            this.logger.log(`Email sent via Mailgun: ${result.id}`);
+            return {
+                success: true,
+                messageId: result.id
+            };
+        } catch (error) {
+            this.logger.error('Mailgun send failed:', error);
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+    /**
+   * Send multiple emails (batch)
+   */ async sendBulkEmails(options) {
+        // Mailgun supports batch sending with recipient variables
+        // For simplicity, we send individually here
+        return Promise.all(options.map((opt)=>this.sendEmail(opt)));
+    }
+    /**
+   * Health check for the provider
+   */ async healthCheck() {
+        if (!this.client || !this.config) return false;
+        try {
+            // Verify domain exists
+            await this.client.domains.get(this.config.domain);
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    /**
+   * Cleanup
+   */ async close() {
+        this.client = null;
+    }
+    constructor(){
+        _define_property(this, "logger", new _common.Logger(MailgunProvider.name));
+        _define_property(this, "client", null);
+        _define_property(this, "config", null);
+    }
+};

package/cjs/providers/sendgrid-provider.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SendGridProvider", {
+    enumerable: true,
+    get: function() {
+        return SendGridProvider;
+    }
+});
+const _common = require("@nestjs/common");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+let SendGridProvider = class SendGridProvider {
+    /**
+   * Initialize the SendGrid provider with configuration
+   */ async initialize(config) {
+        this.config = config;
+        try {
+            // Dynamic import @sendgrid/mail - use eval to bypass TypeScript module resolution
+            // eslint-disable-next-line @typescript-eslint/no-implied-eval
+            const sgMailModule = await new Function('return import("@sendgrid/mail")')();
+            this.sgMail = sgMailModule.default || sgMailModule;
+            this.sgMail.setApiKey(config.apiKey);
+            this.logger.log('SendGrid Provider initialized');
+        } catch (error) {
+            this.logger.error('Failed to initialize SendGrid:', error.message);
+            throw new Error('SendGrid initialization failed. Make sure @sendgrid/mail is installed: npm install @sendgrid/mail');
+        }
+    }
+    /**
+   * Send a single email
+   */ async sendEmail(options) {
+        if (!this.sgMail) {
+            return {
+                success: false,
+                error: 'SendGrid provider not initialized'
+            };
+        }
+        try {
+            const msg = {
+                to: Array.isArray(options.to) ? options.to : [
+                    options.to
+                ],
+                from: options.fromName ? {
+                    email: options.from,
+                    name: options.fromName
+                } : options.from,
+                subject: options.subject
+            };
+            // Only include html/text if they have values (required for plain text templates)
+            if (options.html) msg.html = options.html;
+            if (options.text) msg.text = options.text;
+            // Optional fields
+            if (options.cc) {
+                msg.cc = Array.isArray(options.cc) ? options.cc : [
+                    options.cc
+                ];
+            }
+            if (options.bcc) {
+                msg.bcc = Array.isArray(options.bcc) ? options.bcc : [
+                    options.bcc
+                ];
+            }
+            if (options.replyTo) msg.replyTo = options.replyTo;
+            if (options.attachments?.length) {
+                msg.attachments = options.attachments.map((a)=>({
+                        filename: a.filename,
+                        content: typeof a.content === 'string' ? a.content : a.content.toString('base64'),
+                        type: a.contentType,
+                        disposition: 'attachment'
+                    }));
+            }
+            const [response] = await this.sgMail.send(msg);
+            const messageId = response.headers['x-message-id'] || response.headers['X-Message-Id'];
+            this.logger.log(`Email sent via SendGrid: ${messageId}`);
+            return {
+                success: true,
+                messageId
+            };
+        } catch (error) {
+            this.logger.error('SendGrid send failed:', error);
+            const errorMessage = error.response?.body?.errors?.[0]?.message || error.message;
+            return {
+                success: false,
+                error: errorMessage
+            };
+        }
+    }
+    /**
+   * Send multiple emails (batch)
+   */ async sendBulkEmails(options) {
+        if (!this.sgMail) {
+            return options.map(()=>({
+                    success: false,
+                    error: 'SendGrid provider not initialized'
+                }));
+        }
+        // SendGrid supports batch sending with sendMultiple
+        const messages = options.map((opt)=>{
+            const msg = {
+                to: Array.isArray(opt.to) ? opt.to : [
+                    opt.to
+                ],
+                from: opt.fromName ? {
+                    email: opt.from,
+                    name: opt.fromName
+                } : opt.from,
+                subject: opt.subject
+            };
+            if (opt.html) msg.html = opt.html;
+            if (opt.text) msg.text = opt.text;
+            return msg;
+        });
+        try {
+            await this.sgMail.send(messages);
+            return options.map(()=>({
+                    success: true
+                }));
+        } catch (error) {
+            this.logger.error('SendGrid bulk send failed:', error);
+            return options.map(()=>({
+                    success: false,
+                    error: error.message
+                }));
+        }
+    }
+    /**
+   * Health check for the provider
+   */ async healthCheck() {
+        // SendGrid doesn't have a direct health check API
+        // We verify the API key format is valid
+        return !!(this.sgMail && this.config?.apiKey?.startsWith('SG.'));
+    }
+    /**
+   * Cleanup (no-op for SendGrid)
+   */ async close() {
+        this.sgMail = null;
+    }
+    constructor(){
+        _define_property(this, "logger", new _common.Logger(SendGridProvider.name));
+        _define_property(this, "sgMail", null);
+        _define_property(this, "config", null);
+    }
+};

package/cjs/providers/smtp-provider.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SmtpProvider", {
+    enumerable: true,
+    get: function() {
+        return SmtpProvider;
+    }
+});
+const _common = require("@nestjs/common");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+let SmtpProvider = class SmtpProvider {
+    /**
+   * Initialize the SMTP provider with configuration
+   */ async initialize(config) {
+        this.config = config;
+        this.logger.log(`Initializing SMTP: host=${config.host}, port=${config.port}, secure=${config.secure}, user=${config.auth?.user}`);
+        // Dynamic import nodemailer
+        const nodemailer = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("nodemailer")));
+        // Determine secure mode: port 465 = implicit TLS, port 587 = STARTTLS
+        const isSecure = config.secure ?? config.port === 465;
+        this.transporter = nodemailer.createTransport({
+            host: config.host,
+            port: config.port,
+            secure: isSecure,
+            auth: config.auth,
+            // Timeout settings to prevent hanging
+            connectionTimeout: 10000,
+            greetingTimeout: 10000,
+            socketTimeout: 30000,
+            // TLS options for better compatibility
+            tls: {
+                rejectUnauthorized: false,
+                minVersion: 'TLSv1.2'
+            }
+        });
+        this.logger.log(`SMTP transporter created with secure=${isSecure}`);
+        // Verify connection with timeout
+        try {
+            const verifyPromise = this.transporter.verify();
+            const timeoutPromise = new Promise((_, reject)=>setTimeout(()=>reject(new Error('SMTP verification timeout')), 10000));
+            await Promise.race([
+                verifyPromise,
+                timeoutPromise
+            ]);
+            this.logger.log(`SMTP Provider verified successfully: ${config.host}:${config.port}`);
+        } catch (error) {
+            this.logger.warn(`SMTP verification failed: ${error.message}`);
+        // Don't throw - allow initialization even if verification fails
+        // Connection will be retried on send
+        }
+    }
+    /**
+   * Send a single email
+   */ async sendEmail(options) {
+        if (!this.transporter) {
+            return {
+                success: false,
+                error: 'SMTP provider not initialized'
+            };
+        }
+        const toAddress = Array.isArray(options.to) ? options.to.join(', ') : options.to;
+        this.logger.log(`Sending email to: ${toAddress}, subject: ${options.subject}`);
+        try {
+            const mailOptions = {
+                from: options.fromName ? `"${options.fromName}" <${options.from}>` : options.from,
+                to: toAddress,
+                cc: options.cc ? Array.isArray(options.cc) ? options.cc.join(', ') : options.cc : undefined,
+                bcc: options.bcc ? Array.isArray(options.bcc) ? options.bcc.join(', ') : options.bcc : undefined,
+                subject: options.subject,
+                text: options.text,
+                html: options.html,
+                replyTo: options.replyTo,
+                attachments: options.attachments?.map((a)=>({
+                        filename: a.filename,
+                        content: a.content,
+                        contentType: a.contentType,
+                        encoding: a.encoding
+                    }))
+            };
+            this.logger.log(`Mail options: from=${mailOptions.from}, to=${mailOptions.to}`);
+            // Send with timeout
+            const sendPromise = this.transporter.sendMail(mailOptions);
+            const timeoutPromise = new Promise((_, reject)=>setTimeout(()=>reject(new Error('SMTP send timeout after 30 seconds')), 30000));
+            const info = await Promise.race([
+                sendPromise,
+                timeoutPromise
+            ]);
+            this.logger.log(`Email sent via SMTP: ${info.messageId}`);
+            return {
+                success: true,
+                messageId: info.messageId
+            };
+        } catch (error) {
+            this.logger.error(`SMTP send failed: ${error.message}`, error.stack);
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+    /**
+   * Send multiple emails (batch)
+   */ async sendBulkEmails(options) {
+        return Promise.all(options.map((opt)=>this.sendEmail(opt)));
+    }
+    /**
+   * Health check for the provider
+   */ async healthCheck() {
+        if (!this.transporter) return false;
+        try {
+            await this.transporter.verify();
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    /**
+   * Close the transporter
+   */ async close() {
+        if (this.transporter) {
+            this.transporter.close();
+            this.transporter = null;
+        }
+    }
+    constructor(){
+        _define_property(this, "logger", new _common.Logger(SmtpProvider.name));
+        _define_property(this, "transporter", null);
+        _define_property(this, "config", null);
+    }
+};

package/cjs/services/email-datasource.provider.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EmailDataSourceProvider", {
+    enumerable: true,
+    get: function() {
+        return EmailDataSourceProvider;
+    }
+});
+const _modules = require("@flusys/nestjs-shared/modules");
+const _common = require("@nestjs/common");
+const _core = require("@nestjs/core");
+const _express = require("express");
+const _interfaces = require("../interfaces");
+const _emailconstants = require("../config/email.constants");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+let EmailDataSourceProvider = class EmailDataSourceProvider extends _modules.MultiTenantDataSourceService {
+    // ==================== Factory Methods ====================
+    /**
+   * Build parent options from EmailModuleOptions
+   */ static buildParentOptions(options) {
+        return {
+            bootstrapAppConfig: options.bootstrapAppConfig,
+            defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
+            tenantDefaultDatabaseConfig: options.config?.tenantDefaultDatabaseConfig,
+            tenants: options.config?.tenants
+        };
+    }
+    // ==================== Feature Flags ====================
+    /**
+   * Get global enable company feature flag
+   */ getEnableCompanyFeature() {
+        return this.emailOptions.bootstrapAppConfig?.enableCompanyFeature ?? false;
+    }
+    /**
+   * Get enable company feature for specific tenant
+   * Falls back to global setting if not specified per-tenant
+   */ getEnableCompanyFeatureForTenant(tenant) {
+        return tenant?.enableCompanyFeature ?? this.getEnableCompanyFeature();
+    }
+    /**
+   * Get enable company feature for current request context
+   */ getEnableCompanyFeatureForCurrentTenant() {
+        return this.getEnableCompanyFeatureForTenant(this.getCurrentTenant() ?? undefined);
+    }
+    // ==================== Entity Management ====================
+    /**
+   * Get email entities for migrations based on company feature flag
+   */ async getEmailEntities(enableCompanyFeature) {
+        const enable = enableCompanyFeature ?? this.getEnableCompanyFeature();
+        const { EmailConfig, EmailTemplate } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../entities")));
+        if (enable) {
+            const { EmailConfigWithCompany, EmailTemplateWithCompany } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../entities")));
+            return [
+                EmailConfigWithCompany,
+                EmailTemplateWithCompany
+            ];
+        }
+        return [
+            EmailConfig,
+            EmailTemplate
+        ];
+    }
+    // ==================== Overrides ====================
+    /**
+   * Override to dynamically set entities based on tenant config
+   */ async createDataSourceFromConfig(config) {
+        const currentTenant = this.getCurrentTenant();
+        const enableCompanyFeature = this.getEnableCompanyFeatureForTenant(currentTenant ?? undefined);
+        const entities = await this.getEmailEntities(enableCompanyFeature);
+        return super.createDataSourceFromConfig(config, entities);
+    }
+    /**
+   * Override to use Email-specific static cache
+   */ async getSingleDataSource() {
+        // Return existing initialized connection from Email-specific cache
+        if (EmailDataSourceProvider.singleDataSource?.isInitialized) {
+            return EmailDataSourceProvider.singleDataSource;
+        }
+        // If another request is creating the connection, wait for it
+        if (EmailDataSourceProvider.singleConnectionLock) {
+            return EmailDataSourceProvider.singleConnectionLock;
+        }
+        const config = this.getDefaultDatabaseConfig();
+        if (!config) {
+            throw new Error('No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.');
+        }
+        // Create connection with lock to prevent race conditions
+        const connectionPromise = this.createDataSourceFromConfig(config);
+        EmailDataSourceProvider.singleConnectionLock = connectionPromise;
+        try {
+            const dataSource = await connectionPromise;
+            EmailDataSourceProvider.singleDataSource = dataSource;
+            return dataSource;
+        } finally{
+            EmailDataSourceProvider.singleConnectionLock = null;
+        }
+    }
+    /**
+   * Override to use Email-specific static cache for tenant connections
+   */ async getOrCreateTenantConnection(tenant) {
+        // Return existing initialized connection from Email-specific cache
+        const existing = EmailDataSourceProvider.tenantConnections.get(tenant.id);
+        if (existing?.isInitialized) {
+            return existing;
+        }
+        // If another request is creating this tenant's connection, wait for it
+        const pendingConnection = EmailDataSourceProvider.connectionLocks.get(tenant.id);
+        if (pendingConnection) {
+            return pendingConnection;
+        }
+        // Create connection with lock to prevent race conditions
+        const config = this.buildTenantDatabaseConfig(tenant);
+        const connectionPromise = this.createDataSourceFromConfig(config);
+        EmailDataSourceProvider.connectionLocks.set(tenant.id, connectionPromise);
+        try {
+            const dataSource = await connectionPromise;
+            EmailDataSourceProvider.tenantConnections.set(tenant.id, dataSource);
+            return dataSource;
+        } finally{
+            EmailDataSourceProvider.connectionLocks.delete(tenant.id);
+        }
+    }
+    constructor(emailOptions, request){
+        super(EmailDataSourceProvider.buildParentOptions(emailOptions), request), _define_property(this, "emailOptions", void 0), _define_property(this, "logger", void 0), this.emailOptions = emailOptions, this.logger = new _common.Logger(EmailDataSourceProvider.name);
+    }
+};
+// Override parent's static properties to have Email-specific cache
+_define_property(EmailDataSourceProvider, "tenantConnections", new Map());
+_define_property(EmailDataSourceProvider, "singleDataSource", null);
+_define_property(EmailDataSourceProvider, "tenantsRegistry", new Map());
+_define_property(EmailDataSourceProvider, "initialized", false);
+_define_property(EmailDataSourceProvider, "connectionLocks", new Map());
+_define_property(EmailDataSourceProvider, "singleConnectionLock", null);
+EmailDataSourceProvider = _ts_decorate([
+    (0, _common.Injectable)({
+        scope: _common.Scope.REQUEST
+    }),
+    _ts_param(0, (0, _common.Inject)(_emailconstants.EMAIL_MODULE_OPTIONS)),
+    _ts_param(1, (0, _common.Optional)()),
+    _ts_param(1, (0, _common.Inject)(_core.REQUEST)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _interfaces.EmailModuleOptions === "undefined" ? Object : _interfaces.EmailModuleOptions,
+        typeof _express.Request === "undefined" ? Object : _express.Request
+    ])
+], EmailDataSourceProvider);