@flusys/nestjs-email 7.1.0 → 8.0.0-beta.1

package/fesm/modules/email.module.js

@@ -1,112 +0,0 @@
-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;
-}
-import { CacheModule, UtilsModule, createModuleEventsProvider } from '@flusys/nestjs-shared/modules';
-import { Module } from '@nestjs/common';
-import { EMAIL_MODULE_OPTIONS } from '../config/email.constants';
-import { EmailConfigController, EmailSendController, EmailTemplateController } from '../controllers';
-import { EmailProviderTypeEnum } from '../enums';
-import { EmailFactoryService, EmailProviderRegistry, MailgunProvider, SendGridProvider, SmtpProvider } from '../providers';
-import { EmailConfigService, EmailDataSourceProvider, EmailProviderConfigService, EmailSendService, EmailTemplateService } from '../services';
-const CONTROLLERS = [
-    EmailConfigController,
-    EmailTemplateController,
-    EmailSendController
-];
-const EXPORTED_SERVICES = [
-    EmailConfigService,
-    EmailDataSourceProvider,
-    EmailProviderConfigService,
-    EmailTemplateService,
-    EmailSendService,
-    EmailFactoryService
-];
-EmailProviderRegistry.register(EmailProviderTypeEnum.SMTP, SmtpProvider);
-EmailProviderRegistry.register(EmailProviderTypeEnum.SENDGRID, SendGridProvider);
-EmailProviderRegistry.register(EmailProviderTypeEnum.MAILGUN, MailgunProvider);
-export class EmailModule {
-    static forRoot(options) {
-        return {
-            module: EmailModule,
-            global: options.global ?? false,
-            imports: [
-                CacheModule,
-                UtilsModule
-            ],
-            controllers: options.includeController !== false ? CONTROLLERS : [],
-            providers: this.buildProviders(options),
-            exports: EXPORTED_SERVICES
-        };
-    }
-    static forRootAsync(options) {
-        return {
-            module: EmailModule,
-            global: options.global ?? false,
-            imports: [
-                ...options.imports || [],
-                CacheModule,
-                UtilsModule
-            ],
-            controllers: options.includeController !== false ? CONTROLLERS : [],
-            providers: [
-                ...this.createAsyncProviders(options),
-                ...this.buildProviders()
-            ],
-            exports: EXPORTED_SERVICES
-        };
-    }
-    static buildProviders(options) {
-        const providers = [
-            ...EXPORTED_SERVICES
-        ];
-        if (options) {
-            providers.unshift({
-                provide: EMAIL_MODULE_OPTIONS,
-                useValue: options
-            });
-        }
-        providers.push(createModuleEventsProvider('email', EMAIL_MODULE_OPTIONS));
-        return providers;
-    }
-    static createAsyncProviders(options) {
-        if (options.useFactory) {
-            return [
-                {
-                    provide: EMAIL_MODULE_OPTIONS,
-                    useFactory: async (...args)=>({
-                            ...options,
-                            config: await options.useFactory(...args)
-                        }),
-                    inject: options.inject || []
-                }
-            ];
-        }
-        const factoryClass = options.useClass || options.useExisting;
-        if (!factoryClass) return [];
-        const providers = [
-            {
-                provide: EMAIL_MODULE_OPTIONS,
-                useFactory: async (factory)=>({
-                        ...options,
-                        config: await factory.createEmailOptions()
-                    }),
-                inject: [
-                    factoryClass
-                ]
-            }
-        ];
-        if (options.useClass) {
-            providers.push({
-                provide: options.useClass,
-                useClass: options.useClass
-            });
-        }
-        return providers;
-    }
-}
-EmailModule = _ts_decorate([
-    Module({})
-], EmailModule);

package/fesm/modules/email.module.spec.js

@@ -1,138 +0,0 @@
-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;
-}
-import { EmailModule } from './email.module';
-import { EMAIL_MODULE_OPTIONS } from '../config/email.constants';
-import { EmailConfigController, EmailSendController, EmailTemplateController } from '../controllers';
-function providerTokens(providers) {
-    return providers.map((p)=>typeof p === 'function' ? p : p.provide);
-}
-describe('EmailModule', ()=>{
-    describe('forRoot', ()=>{
-        it('should default to a non-global module with all controllers registered', ()=>{
-            const dynamicModule = EmailModule.forRoot({});
-            expect(dynamicModule.module).toBe(EmailModule);
-            expect(dynamicModule.global).toBe(false);
-            expect(dynamicModule.controllers).toEqual([
-                EmailConfigController,
-                EmailTemplateController,
-                EmailSendController
-            ]);
-        });
-        it('should respect global: true', ()=>{
-            expect(EmailModule.forRoot({
-                global: true
-            }).global).toBe(true);
-        });
-        it('should register no controllers when includeController is false', ()=>{
-            expect(EmailModule.forRoot({
-                includeController: false
-            }).controllers).toEqual([]);
-        });
-        it('should register a EMAIL_MODULE_OPTIONS provider carrying the given options', ()=>{
-            const options = {
-                bootstrapAppConfig: {
-                    enableCompanyFeature: true
-                }
-            };
-            const dynamicModule = EmailModule.forRoot(options);
-            const provider = dynamicModule.providers.find((p)=>p.provide === EMAIL_MODULE_OPTIONS);
-            expect(provider.useValue).toBe(options);
-        });
-        it('should always export the same fixed set of services', ()=>{
-            expect(EmailModule.forRoot({}).exports).toHaveLength(6);
-        });
-    });
-    describe('forRootAsync', ()=>{
-        it('should forward external imports alongside CacheModule/UtilsModule', ()=>{
-            let FakeImportedModule = class FakeImportedModule {
-            };
-            const dynamicModule = EmailModule.forRootAsync({
-                bootstrapAppConfig: {},
-                imports: [
-                    FakeImportedModule
-                ]
-            });
-            expect(dynamicModule.imports).toEqual(expect.arrayContaining([
-                FakeImportedModule
-            ]));
-        });
-        it('useFactory: builds an EMAIL_MODULE_OPTIONS provider that merges resolved config into the static options', async ()=>{
-            const useFactory = jest.fn().mockResolvedValue({
-                defaultFrom: 'noreply@flusys.io'
-            });
-            const dynamicModule = EmailModule.forRootAsync({
-                bootstrapAppConfig: {},
-                useFactory,
-                inject: [
-                    'SOME_TOKEN'
-                ]
-            });
-            const provider = dynamicModule.providers.find((p)=>p.provide === EMAIL_MODULE_OPTIONS);
-            expect(provider.inject).toEqual([
-                'SOME_TOKEN'
-            ]);
-            const resolved = await provider.useFactory('injected');
-            expect(useFactory).toHaveBeenCalledWith('injected');
-            expect(resolved.config).toEqual({
-                defaultFrom: 'noreply@flusys.io'
-            });
-        });
-        it('useClass: registers both the class provider and an options provider calling createEmailOptions()', async ()=>{
-            let MyOptionsFactory = class MyOptionsFactory {
-                constructor(){
-                    _define_property(this, "createEmailOptions", jest.fn().mockResolvedValue({
-                        defaultFrom: 'from-class@flusys.io'
-                    }));
-                }
-            };
-            const dynamicModule = EmailModule.forRootAsync({
-                bootstrapAppConfig: {},
-                useClass: MyOptionsFactory
-            });
-            const classProvider = dynamicModule.providers.find((p)=>p.provide === MyOptionsFactory);
-            expect(classProvider.useClass).toBe(MyOptionsFactory);
-            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === EMAIL_MODULE_OPTIONS);
-            const instance = new MyOptionsFactory();
-            const resolved = await optionsProvider.useFactory(instance);
-            expect(instance.createEmailOptions).toHaveBeenCalled();
-            expect(resolved.config).toEqual({
-                defaultFrom: 'from-class@flusys.io'
-            });
-        });
-        it('useExisting: registers a single options provider without a duplicate class registration', async ()=>{
-            let MyOptionsFactory = class MyOptionsFactory {
-                constructor(){
-                    _define_property(this, "createEmailOptions", jest.fn().mockResolvedValue({
-                        defaultFrom: 'from-existing@flusys.io'
-                    }));
-                }
-            };
-            const dynamicModule = EmailModule.forRootAsync({
-                bootstrapAppConfig: {},
-                useExisting: MyOptionsFactory
-            });
-            expect(dynamicModule.providers.filter((p)=>p.provide === MyOptionsFactory)).toHaveLength(0);
-            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === EMAIL_MODULE_OPTIONS);
-            expect(optionsProvider.inject).toEqual([
-                MyOptionsFactory
-            ]);
-        });
-        it('should register no EMAIL_MODULE_OPTIONS provider when neither useFactory, useClass, nor useExisting is given', ()=>{
-            const dynamicModule = EmailModule.forRootAsync({
-                bootstrapAppConfig: {}
-            });
-            expect(providerTokens(dynamicModule.providers)).not.toContain(EMAIL_MODULE_OPTIONS);
-        });
-    });
-});

package/fesm/providers/email-factory.service.js

@@ -1,103 +0,0 @@
-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 _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);
-}
-import { LogAction, SYSTEM_MESSAGES } from '@flusys/nestjs-shared';
-import { Injectable, InternalServerErrorException, NotFoundException } from '@nestjs/common';
-import { createHash } from 'crypto';
-import { EMAIL_SEND_MESSAGES } from '../config';
-import { IEmailProviderConfig } from '../interfaces';
-import { EmailProviderRegistry } from './email-provider.registry';
-export class EmailFactoryService {
-    // ─── Public API ─────────────────────────────────────────────────────────────
-    async createProvider(config) {
-        const cacheKey = this.generateCacheKey(config);
-        const cached = this.providerCache.get(cacheKey);
-        if (cached) return cached;
-        const ProviderClass = EmailProviderRegistry.get(config.provider);
-        if (!ProviderClass) {
-            throw new NotFoundException({
-                message: `Email provider '${config.provider}' is not registered`,
-                messageKey: EMAIL_SEND_MESSAGES.CONFIG_NOT_FOUND,
-                messageVariables: {
-                    provider: config.provider,
-                    available: EmailProviderRegistry.getAll().join(', ')
-                }
-            });
-        }
-        try {
-            const instance = new ProviderClass();
-            await instance.initialize?.(config.config);
-            this.providerCache.set(cacheKey, instance);
-            return instance;
-        } catch (error) {
-            throw new InternalServerErrorException({
-                message: `Email provider '${config.provider}' not initialized successfully: ${this.extractErrorMessage(error)}`,
-                messageKey: SYSTEM_MESSAGES.SERVICE_NOT_AVAILABLE,
-                messageVariables: {
-                    provider: config.provider,
-                    available: EmailProviderRegistry.getAll().join(', ')
-                }
-            });
-        }
-    }
-    // ─── Lifecycle ──────────────────────────────────────────────────────────────
-    async onModuleDestroy() {
-        const closePromises = Array.from(this.providerCache.entries()).map(([, provider])=>this.closeProvider(provider));
-        await Promise.allSettled(closePromises);
-        this.providerCache.clear();
-    }
-    // ─── Private Helpers ────────────────────────────────────────────────────────
-    generateCacheKey(config) {
-        const sortedKeys = Object.keys(config.config || {}).sort();
-        const configString = JSON.stringify(config.config, sortedKeys);
-        const hash = createHash('sha256').update(configString).digest('hex').substring(0, 16);
-        return `${config.provider}-${hash}`;
-    }
-    async closeProvider(provider) {
-        if (!provider.close) return;
-        try {
-            await provider.close();
-        } catch  {
-        // Silent failure
-        }
-    }
-    extractErrorMessage(error) {
-        return error instanceof Error ? error.message : 'Unknown error';
-    }
-    constructor(){
-        _define_property(this, "providerCache", new Map());
-    }
-}
-_ts_decorate([
-    LogAction({
-        action: 'email.createProvider',
-        module: 'email'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof IEmailProviderConfig === "undefined" ? Object : IEmailProviderConfig
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], EmailFactoryService.prototype, "createProvider", null);
-EmailFactoryService = _ts_decorate([
-    Injectable()
-], EmailFactoryService);

package/fesm/providers/email-factory.service.spec.js

@@ -1,238 +0,0 @@
-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;
-}
-import { InternalServerErrorException, NotFoundException } from '@nestjs/common';
-import { EmailFactoryService } from './email-factory.service';
-import { EmailProviderRegistry } from './email-provider.registry';
-let FakeSuccessProvider = class FakeSuccessProvider {
-    async initialize(_config) {
-        FakeSuccessProvider.initializeCalls += 1;
-    }
-    async sendEmail(_options) {
-        return {
-            success: true
-        };
-    }
-    async sendBulkEmails(_options) {
-        return [];
-    }
-    async healthCheck() {
-        return true;
-    }
-    async close() {
-        this.closeCalled = true;
-    }
-    constructor(){
-        _define_property(this, "closeCalled", false);
-        FakeSuccessProvider.instances.push(this);
-    }
-};
-_define_property(FakeSuccessProvider, "initializeCalls", 0);
-_define_property(FakeSuccessProvider, "instances", []);
-let FakeFailingInitProvider = class FakeFailingInitProvider {
-    async initialize(_config) {
-        throw new Error('boom during init');
-    }
-    async sendEmail(_options) {
-        return {
-            success: true
-        };
-    }
-    async sendBulkEmails(_options) {
-        return [];
-    }
-    async healthCheck() {
-        return true;
-    }
-};
-let FakeNoInitializeProvider = class FakeNoInitializeProvider {
-    async sendEmail(_options) {
-        return {
-            success: true
-        };
-    }
-    async sendBulkEmails(_options) {
-        return [];
-    }
-    async healthCheck() {
-        return true;
-    }
-};
-describe('EmailFactoryService', ()=>{
-    let service;
-    beforeEach(()=>{
-        service = new EmailFactoryService();
-        EmailProviderRegistry.clear();
-        FakeSuccessProvider.initializeCalls = 0;
-        FakeSuccessProvider.instances = [];
-    });
-    afterEach(()=>{
-        EmailProviderRegistry.clear();
-    });
-    describe('createProvider', ()=>{
-        it('throws NotFoundException when the provider is not registered', async ()=>{
-            const config = {
-                provider: 'unknown',
-                config: {}
-            };
-            await expect(service.createProvider(config)).rejects.toThrow(NotFoundException);
-        });
-        it('throws NotFoundException with the config-not-found messageKey and available list', async ()=>{
-            EmailProviderRegistry.register('smtp', FakeSuccessProvider);
-            const config = {
-                provider: 'unknown',
-                config: {}
-            };
-            try {
-                await service.createProvider(config);
-                fail('expected createProvider to throw');
-            } catch (error) {
-                expect(error).toBeInstanceOf(NotFoundException);
-                expect(error.getResponse()).toEqual(expect.objectContaining({
-                    messageKey: 'email.send.config.not.found'
-                }));
-            }
-        });
-        it('instantiates and initializes the provider on cache miss', async ()=>{
-            EmailProviderRegistry.register('smtp', FakeSuccessProvider);
-            const config = {
-                provider: 'smtp',
-                config: {
-                    host: 'localhost'
-                }
-            };
-            const provider = await service.createProvider(config);
-            expect(provider).toBeInstanceOf(FakeSuccessProvider);
-            expect(FakeSuccessProvider.initializeCalls).toBe(1);
-        });
-        it('returns the cached provider instance for an identical config (no re-initialization)', async ()=>{
-            EmailProviderRegistry.register('smtp', FakeSuccessProvider);
-            const config = {
-                provider: 'smtp',
-                config: {
-                    host: 'localhost'
-                }
-            };
-            const first = await service.createProvider(config);
-            const second = await service.createProvider(config);
-            expect(second).toBe(first);
-            expect(FakeSuccessProvider.initializeCalls).toBe(1);
-        });
-        it('creates a distinct cached instance for a different config on the same provider', async ()=>{
-            EmailProviderRegistry.register('smtp', FakeSuccessProvider);
-            const first = await service.createProvider({
-                provider: 'smtp',
-                config: {
-                    host: 'a'
-                }
-            });
-            const second = await service.createProvider({
-                provider: 'smtp',
-                config: {
-                    host: 'b'
-                }
-            });
-            expect(second).not.toBe(first);
-            expect(FakeSuccessProvider.initializeCalls).toBe(2);
-        });
-        it('is insensitive to key ordering when hashing the config for the cache key', async ()=>{
-            EmailProviderRegistry.register('smtp', FakeSuccessProvider);
-            const first = await service.createProvider({
-                provider: 'smtp',
-                config: {
-                    a: 1,
-                    b: 2
-                }
-            });
-            const second = await service.createProvider({
-                provider: 'smtp',
-                config: {
-                    b: 2,
-                    a: 1
-                }
-            });
-            expect(second).toBe(first);
-            expect(FakeSuccessProvider.initializeCalls).toBe(1);
-        });
-        it('does not call initialize when the provider class has no initialize method', async ()=>{
-            EmailProviderRegistry.register('smtp', FakeNoInitializeProvider);
-            const config = {
-                provider: 'smtp',
-                config: {}
-            };
-            const provider = await service.createProvider(config);
-            expect(provider).toBeInstanceOf(FakeNoInitializeProvider);
-        });
-        it('wraps initialize() failures in InternalServerErrorException with SDK_NOT_INSTALLED messageKey', async ()=>{
-            EmailProviderRegistry.register('mailgun', FakeFailingInitProvider);
-            const config = {
-                provider: 'mailgun',
-                config: {}
-            };
-            try {
-                await service.createProvider(config);
-                fail('expected createProvider to throw');
-            } catch (error) {
-                expect(error).toBeInstanceOf(InternalServerErrorException);
-                expect(error.getResponse()).toEqual(expect.objectContaining({
-                    messageKey: 'system.service.not.available'
-                }));
-                expect(error.getResponse().message).toContain('boom during init');
-            }
-        });
-        it('does not cache a provider that failed to initialize', async ()=>{
-            EmailProviderRegistry.register('mailgun', FakeFailingInitProvider);
-            const config = {
-                provider: 'mailgun',
-                config: {}
-            };
-            await expect(service.createProvider(config)).rejects.toThrow();
-            // second attempt should also go through the (still failing) initialization path
-            await expect(service.createProvider(config)).rejects.toThrow();
-        });
-    });
-    describe('onModuleDestroy', ()=>{
-        it('closes every cached provider and clears the cache', async ()=>{
-            EmailProviderRegistry.register('smtp', FakeSuccessProvider);
-            const provider = await service.createProvider({
-                provider: 'smtp',
-                config: {}
-            });
-            await service.onModuleDestroy();
-            expect(provider.closeCalled).toBe(true);
-            // cache cleared -> a subsequent createProvider call re-initializes
-            EmailProviderRegistry.register('smtp', FakeSuccessProvider);
-            await service.createProvider({
-                provider: 'smtp',
-                config: {}
-            });
-            expect(FakeSuccessProvider.initializeCalls).toBe(2);
-        });
-        it('does not throw when a provider close() call rejects', async ()=>{
-            let FakeThrowingCloseProvider = class FakeThrowingCloseProvider extends FakeSuccessProvider {
-                async close() {
-                    throw new Error('close failed');
-                }
-            };
-            EmailProviderRegistry.register('smtp', FakeThrowingCloseProvider);
-            await service.createProvider({
-                provider: 'smtp',
-                config: {}
-            });
-            await expect(service.onModuleDestroy()).resolves.toBeUndefined();
-        });
-        it('is a no-op when nothing has been cached', async ()=>{
-            await expect(service.onModuleDestroy()).resolves.toBeUndefined();
-        });
-    });
-});

package/fesm/providers/email-provider.registry.js

@@ -1,31 +0,0 @@
-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;
-}
-export class EmailProviderRegistry {
-    static register(providerName, providerClass) {
-        this.providers.set(providerName.toLowerCase(), providerClass);
-    }
-    static get(providerName) {
-        return this.providers.get(providerName.toLowerCase());
-    }
-    static has(providerName) {
-        return this.providers.has(providerName.toLowerCase());
-    }
-    static getAll() {
-        return Array.from(this.providers.keys());
-    }
-    static clear() {
-        this.providers.clear();
-    }
-}
-_define_property(EmailProviderRegistry, "providers", new Map());

package/fesm/providers/email-provider.registry.spec.js

@@ -1,54 +0,0 @@
-import { EmailProviderRegistry } from './email-provider.registry';
-let FakeProvider = class FakeProvider {
-    async sendEmail(_options) {
-        return {
-            success: true
-        };
-    }
-    async sendBulkEmails(_options) {
-        return [];
-    }
-    async healthCheck() {
-        return true;
-    }
-};
-describe('EmailProviderRegistry', ()=>{
-    afterEach(()=>{
-        EmailProviderRegistry.clear();
-    });
-    it('registers and retrieves a provider by exact name', ()=>{
-        EmailProviderRegistry.register('smtp', FakeProvider);
-        expect(EmailProviderRegistry.get('smtp')).toBe(FakeProvider);
-    });
-    it('normalizes provider names to lowercase on register and lookup', ()=>{
-        EmailProviderRegistry.register('SendGrid', FakeProvider);
-        expect(EmailProviderRegistry.get('sendgrid')).toBe(FakeProvider);
-        expect(EmailProviderRegistry.get('SENDGRID')).toBe(FakeProvider);
-        expect(EmailProviderRegistry.has('sendgrid')).toBe(true);
-    });
-    it('returns undefined for an unregistered provider', ()=>{
-        expect(EmailProviderRegistry.get('unknown-provider')).toBeUndefined();
-        expect(EmailProviderRegistry.has('unknown-provider')).toBe(false);
-    });
-    it('lists all registered provider names', ()=>{
-        EmailProviderRegistry.register('smtp', FakeProvider);
-        EmailProviderRegistry.register('mailgun', FakeProvider);
-        expect(EmailProviderRegistry.getAll().sort()).toEqual([
-            'mailgun',
-            'smtp'
-        ]);
-    });
-    it('clears all registered providers', ()=>{
-        EmailProviderRegistry.register('smtp', FakeProvider);
-        EmailProviderRegistry.clear();
-        expect(EmailProviderRegistry.getAll()).toEqual([]);
-        expect(EmailProviderRegistry.has('smtp')).toBe(false);
-    });
-    it('overwrites a previously registered provider for the same name', ()=>{
-        let OtherProvider = class OtherProvider extends FakeProvider {
-        };
-        EmailProviderRegistry.register('smtp', FakeProvider);
-        EmailProviderRegistry.register('smtp', OtherProvider);
-        expect(EmailProviderRegistry.get('smtp')).toBe(OtherProvider);
-    });
-});