@flusys/nestjs-email 1.1.0-beta

package/fesm/services/email-template.service.js

@@ -0,0 +1,176 @@
+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);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { RequestScopedApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { Inject, Injectable, Scope } from '@nestjs/common';
+import { EmailConfigService } from '../config';
+import { EmailTemplate, EmailTemplateWithCompany } from '../entities';
+import { EmailDataSourceProvider } from './email-datasource.provider';
+export class EmailTemplateService extends RequestScopedApiService {
+    /**
+   * Resolve entity class for this service
+   */ resolveEntity() {
+        const enableCompanyFeature = this.emailConfig.isCompanyFeatureEnabled();
+        return enableCompanyFeature ? EmailTemplateWithCompany : EmailTemplate;
+    }
+    /**
+   * Get DataSource provider for this service
+   */ getDataSourceProvider() {
+        return this.dataSourceProvider;
+    }
+    async convertSingleDtoToEntity(dto, user) {
+        // For updates, fetch existing template to handle versioning
+        const updateDto = dto;
+        if (updateDto.id) {
+            await this.ensureRepositoryInitialized();
+            const existing = await this.repository.findOne({
+                where: {
+                    id: updateDto.id
+                }
+            });
+            if (existing) {
+                // Auto-increment schema version if schema changed
+                if (dto.schema && JSON.stringify(dto.schema) !== JSON.stringify(existing.schema)) {
+                    dto.schemaVersion = existing.schemaVersion + 1;
+                    this.logger.log(`Schema changed for template ${updateDto.id}, incrementing version from ${existing.schemaVersion} to ${dto.schemaVersion}`);
+                }
+            }
+        }
+        let templateEntity = {
+            ...dto
+        };
+        // Set company fields if company feature is enabled
+        if (this.emailConfig.isCompanyFeatureEnabled()) {
+            templateEntity.companyId = user?.companyId ?? null;
+        }
+        return templateEntity;
+    }
+    async getSelectQuery(query, _user, select) {
+        if (!select || !select.length) {
+            select = [
+                'id',
+                'name',
+                'slug',
+                'description',
+                'subject',
+                'schema',
+                'htmlContent',
+                'textContent',
+                'schemaVersion',
+                'isActive',
+                'isHtml',
+                'metadata',
+                'createdAt',
+                'updatedAt'
+            ];
+            if (this.emailConfig.isCompanyFeatureEnabled()) {
+                select.push('companyId');
+            }
+        }
+        const selectFields = select.map((field)=>`${this.entityName}.${field}`);
+        query.select(selectFields);
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    /**
+   * Override: Extra query manipulation - Auto-filter by user's company
+   */ async getExtraManipulateQuery(query, filterDto, user) {
+        const result = await super.getExtraManipulateQuery(query, filterDto, user);
+        const enableCompanyFeature = this.emailConfig.isCompanyFeatureEnabled();
+        if (enableCompanyFeature && user?.companyId) {
+            query.andWhere('emailTemplate.companyId = :companyId', {
+                companyId: user.companyId
+            });
+        }
+        query.orderBy(`${this.entityName}.createdAt`, 'DESC');
+        return result;
+    }
+    /**
+   * Find template by ID directly (bypasses company filtering)
+   */ async findByIdDirect(id) {
+        await this.ensureRepositoryInitialized();
+        return await this.repository.findOne({
+            where: {
+                id
+            }
+        });
+    }
+    /**
+   * Find template by slug (scoped to user's company if enabled)
+   */ async findBySlug(slug, user) {
+        await this.ensureRepositoryInitialized();
+        const where = {
+            slug,
+            isActive: true
+        };
+        if (this.emailConfig.isCompanyFeatureEnabled() && user?.companyId) {
+            where.companyId = user.companyId;
+        }
+        return await this.repository.findOne({
+            where
+        });
+    }
+    /**
+   * Get all active templates (scoped to user's company if enabled)
+   */ async getActiveTemplates(user) {
+        await this.ensureRepositoryInitialized();
+        const where = {
+            isActive: true
+        };
+        if (this.emailConfig.isCompanyFeatureEnabled() && user?.companyId) {
+            where.companyId = user.companyId;
+        }
+        return await this.repository.find({
+            where,
+            order: {
+                name: 'ASC'
+            }
+        });
+    }
+    constructor(cacheManager, utilsService, emailConfig, dataSourceProvider){
+        super('emailTemplate', null, cacheManager, utilsService, EmailTemplateService.name, true), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "emailConfig", void 0), _define_property(this, "dataSourceProvider", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.emailConfig = emailConfig, this.dataSourceProvider = dataSourceProvider;
+    }
+}
+EmailTemplateService = _ts_decorate([
+    Injectable({
+        scope: Scope.REQUEST
+    }),
+    _ts_param(0, Inject('CACHE_INSTANCE')),
+    _ts_param(1, Inject(UtilsService)),
+    _ts_param(2, Inject(EmailConfigService)),
+    _ts_param(3, Inject(EmailDataSourceProvider)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof HybridCache === "undefined" ? Object : HybridCache,
+        typeof UtilsService === "undefined" ? Object : UtilsService,
+        typeof EmailConfigService === "undefined" ? Object : EmailConfigService,
+        typeof EmailDataSourceProvider === "undefined" ? Object : EmailDataSourceProvider
+    ])
+], EmailTemplateService);

package/fesm/services/index.js

@@ -0,0 +1,4 @@
+export * from './email-datasource.provider';
+export * from './email-provider-config.service';
+export * from './email-template.service';
+export * from './email-send.service';

package/index.d.ts

@@ -0,0 +1,9 @@
+export * from './controllers';
+export * from './services';
+export * from './entities';
+export * from './modules';
+export * from './config';
+export * from './dtos';
+export * from './enums';
+export * from './interfaces';
+export * from './providers';

package/interfaces/email-config.interface.d.ts

@@ -0,0 +1,28 @@
+import { IIdentity } from '@flusys/nestjs-shared/interfaces';
+import { EmailProviderTypeEnum } from '../enums';
+export interface IEmailConfig extends IIdentity {
+    name: string;
+    provider: EmailProviderTypeEnum;
+    config: Record<string, any>;
+    fromEmail: string | null;
+    fromName: string | null;
+    isActive: boolean;
+    companyId?: string | null;
+}
+export interface ISmtpConfig {
+    host: string;
+    port: number;
+    secure?: boolean;
+    auth?: {
+        user: string;
+        pass: string;
+    };
+}
+export interface ISendGridConfig {
+    apiKey: string;
+}
+export interface IMailgunConfig {
+    apiKey: string;
+    domain: string;
+    region?: 'us' | 'eu';
+}

package/interfaces/email-module-options.interface.d.ts

@@ -0,0 +1,26 @@
+import { IBootstrapAppConfig, IDataSourceServiceOptions, IDynamicModuleConfig, IModuleOptionsFactory } from '@flusys/nestjs-core';
+import { ModuleMetadata, Type } from '@nestjs/common';
+export interface IEmailModuleConfig extends IDataSourceServiceOptions {
+    defaultProvider?: string;
+    rateLimitPerMinute?: number;
+    enableLogging?: boolean;
+}
+export interface IEmailModuleConfigFull {
+    bootstrapAppConfig?: IBootstrapAppConfig;
+    config?: IEmailModuleConfig;
+}
+export interface EmailModuleOptions extends IDynamicModuleConfig {
+    bootstrapAppConfig?: IBootstrapAppConfig;
+    config?: IEmailModuleConfig;
+}
+export interface EmailOptionsFactory extends IModuleOptionsFactory<IEmailModuleConfig> {
+    createEmailOptions(): Promise<IEmailModuleConfig> | IEmailModuleConfig;
+    createOptions(): Promise<IEmailModuleConfig> | IEmailModuleConfig;
+}
+export interface EmailModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'>, IDynamicModuleConfig {
+    bootstrapAppConfig: IBootstrapAppConfig;
+    useFactory?: (...args: any[]) => Promise<IEmailModuleConfig> | IEmailModuleConfig;
+    inject?: any[];
+    useClass?: Type<EmailOptionsFactory>;
+    useExisting?: Type<EmailOptionsFactory>;
+}

package/interfaces/email-provider.interface.d.ts

@@ -0,0 +1,34 @@
+export interface IEmailProviderConfig {
+    provider: string;
+    config: Record<string, any>;
+}
+export interface IEmailAttachment {
+    filename: string;
+    content: Buffer | string;
+    contentType?: string;
+    encoding?: string;
+}
+export interface IEmailSendOptions {
+    to: string | string[];
+    cc?: string | string[];
+    bcc?: string | string[];
+    subject: string;
+    html?: string;
+    text?: string;
+    from?: string;
+    fromName?: string;
+    replyTo?: string;
+    attachments?: IEmailAttachment[];
+}
+export interface IEmailSendResult {
+    success: boolean;
+    messageId?: string;
+    error?: string;
+}
+export interface IEmailProvider {
+    sendEmail(options: IEmailSendOptions): Promise<IEmailSendResult>;
+    sendBulkEmails(options: IEmailSendOptions[]): Promise<IEmailSendResult[]>;
+    healthCheck(): Promise<boolean>;
+    initialize?(config: any): Promise<void>;
+    close?(): Promise<void>;
+}

package/interfaces/email-template.interface.d.ts

@@ -0,0 +1,64 @@
+import { IIdentity } from '@flusys/nestjs-shared/interfaces';
+export interface IEmailTemplateVariable {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'date';
+    required?: boolean;
+    defaultValue?: string;
+    description?: string;
+}
+export interface IEmailTemplate extends IIdentity {
+    name: string;
+    slug: string;
+    description: string | null;
+    subject: string;
+    schema: Record<string, unknown>;
+    htmlContent: string;
+    textContent: string | null;
+    schemaVersion: number;
+    isActive: boolean;
+    isHtml: boolean;
+    metadata: Record<string, unknown> | null;
+    companyId?: string | null;
+}
+export interface IEmailSection {
+    id: string;
+    type: 'header' | 'body' | 'footer';
+    name: string;
+    blocks: IEmailBlock[];
+    order: number;
+    style?: IEmailSectionStyle;
+}
+export interface IEmailSectionStyle {
+    backgroundColor?: string;
+    padding?: string;
+    maxWidth?: string;
+}
+export interface IEmailBlock {
+    id: string;
+    type: 'text' | 'image' | 'button' | 'divider' | 'html';
+    order: number;
+    content: Record<string, any>;
+    style?: IEmailBlockStyle;
+}
+export interface IEmailBlockStyle {
+    textAlign?: 'left' | 'center' | 'right';
+    padding?: string;
+    margin?: string;
+    backgroundColor?: string;
+}
+export interface IEmailSettings {
+    maxWidth?: string;
+    backgroundColor?: string;
+    fontFamily?: string;
+    baseTextColor?: string;
+}
+export interface IEmailSchema {
+    id: string;
+    version: string;
+    name: string;
+    subject: string;
+    preheader?: string;
+    sections: IEmailSection[];
+    variables?: IEmailTemplateVariable[];
+    settings?: IEmailSettings;
+}

package/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from './email-provider.interface';
+export * from './email-module-options.interface';
+export * from './email-config.interface';
+export * from './email-template.interface';

package/modules/email.module.d.ts

@@ -0,0 +1,9 @@
+import { DynamicModule } from '@nestjs/common';
+import { EmailModuleAsyncOptions, EmailModuleOptions } from '../interfaces';
+export declare class EmailModule {
+    static forRoot(options: EmailModuleOptions): DynamicModule;
+    static forRootAsync(options: EmailModuleAsyncOptions): DynamicModule;
+    private static getControllers;
+    private static getProviders;
+    private static createAsyncProviders;
+}

package/modules/index.d.ts

@@ -0,0 +1 @@
+export * from './email.module';

package/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "@flusys/nestjs-email",
+  "version": "1.1.0-beta",
+  "description": "Modular email package with SMTP, SendGrid, and Mailgun providers",
+  "main": "cjs/index.js",
+  "module": "fesm/index.js",
+  "types": "index.d.ts",
+  "sideEffects": false,
+  "keywords": [
+    "nestjs",
+    "email",
+    "smtp",
+    "sendgrid",
+    "mailgun",
+    "template",
+    "@flusys"
+  ],
+  "license": "UNLICENSED",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./fesm/index.js",
+      "require": "./cjs/index.js"
+    },
+    "./config": {
+      "types": "./config/index.d.ts",
+      "import": "./fesm/config/index.js",
+      "require": "./cjs/config/index.js"
+    },
+    "./controllers": {
+      "types": "./controllers/index.d.ts",
+      "import": "./fesm/controllers/index.js",
+      "require": "./cjs/controllers/index.js"
+    },
+    "./dtos": {
+      "types": "./dtos/index.d.ts",
+      "import": "./fesm/dtos/index.js",
+      "require": "./cjs/dtos/index.js"
+    },
+    "./entities": {
+      "types": "./entities/index.d.ts",
+      "import": "./fesm/entities/index.js",
+      "require": "./cjs/entities/index.js"
+    },
+    "./enums": {
+      "types": "./enums/index.d.ts",
+      "import": "./fesm/enums/index.js",
+      "require": "./cjs/enums/index.js"
+    },
+    "./interfaces": {
+      "types": "./interfaces/index.d.ts",
+      "import": "./fesm/interfaces/index.js",
+      "require": "./cjs/interfaces/index.js"
+    },
+    "./modules": {
+      "types": "./modules/index.d.ts",
+      "import": "./fesm/modules/index.js",
+      "require": "./cjs/modules/index.js"
+    },
+    "./providers": {
+      "types": "./providers/index.d.ts",
+      "import": "./fesm/providers/index.js",
+      "require": "./cjs/providers/index.js"
+    },
+    "./services": {
+      "types": "./services/index.d.ts",
+      "import": "./fesm/services/index.js",
+      "require": "./cjs/services/index.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "import": "./*.js",
+      "require": "./*.js"
+    }
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "@nestjs/config": "^3.0.0 || ^4.0.0",
+    "@nestjs/core": "^10.0.0 || ^11.0.0",
+    "@nestjs/platform-express": "^10.0.0 || ^11.0.0",
+    "@nestjs/swagger": "^7.0.0 || ^11.0.0",
+    "@nestjs/typeorm": "^10.0.0 || ^11.0.0",
+    "class-transformer": "^0.5.0",
+    "class-validator": "^0.14.0",
+    "typeorm": "^0.3.0",
+    "nodemailer": "^6.9.0",
+    "@sendgrid/mail": "^8.0.0",
+    "mailgun.js": "^10.0.0"
+  },
+  "peerDependenciesMeta": {
+    "nodemailer": {
+      "optional": false
+    },
+    "@sendgrid/mail": {
+      "optional": true
+    },
+    "mailgun.js": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@flusys/nestjs-core": "1.1.0-beta",
+    "@flusys/nestjs-shared": "1.1.0-beta"
+  }
+}

package/providers/email-factory.service.d.ts

@@ -0,0 +1,14 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import { EmailConfigService } from '../config/email-config.service';
+import { IEmailProvider, IEmailProviderConfig } from '../interfaces';
+export declare class EmailFactoryService implements OnModuleDestroy {
+    private readonly emailConfigService;
+    private readonly logger;
+    private providerCache;
+    constructor(emailConfigService: EmailConfigService);
+    private generateCacheKey;
+    createProvider(config: IEmailProviderConfig): Promise<IEmailProvider>;
+    isProviderAvailable(providerName: string): boolean;
+    getAvailableProviders(): string[];
+    onModuleDestroy(): Promise<void>;
+}

package/providers/email-provider.registry.d.ts

@@ -0,0 +1,10 @@
+import { Type } from '@nestjs/common';
+import { IEmailProvider } from '../interfaces';
+export declare class EmailProviderRegistry {
+    private static providers;
+    static register(providerName: string, providerClass: Type<IEmailProvider>): void;
+    static get(providerName: string): Type<IEmailProvider> | undefined;
+    static has(providerName: string): boolean;
+    static getAll(): string[];
+    static clear(): void;
+}

package/providers/index.d.ts

@@ -0,0 +1,5 @@
+export * from './email-provider.registry';
+export * from './email-factory.service';
+export * from './smtp-provider';
+export * from './sendgrid-provider';
+export * from './mailgun-provider';

package/providers/mailgun-provider.d.ts

@@ -0,0 +1,11 @@
+import { IEmailProvider, IEmailSendOptions, IEmailSendResult, IMailgunConfig } from '../interfaces';
+export declare class MailgunProvider implements IEmailProvider {
+    private logger;
+    private client;
+    private config;
+    initialize(config: IMailgunConfig): Promise<void>;
+    sendEmail(options: IEmailSendOptions): Promise<IEmailSendResult>;
+    sendBulkEmails(options: IEmailSendOptions[]): Promise<IEmailSendResult[]>;
+    healthCheck(): Promise<boolean>;
+    close(): Promise<void>;
+}

package/providers/sendgrid-provider.d.ts

@@ -0,0 +1,11 @@
+import { IEmailProvider, IEmailSendOptions, IEmailSendResult, ISendGridConfig } from '../interfaces';
+export declare class SendGridProvider implements IEmailProvider {
+    private logger;
+    private sgMail;
+    private config;
+    initialize(config: ISendGridConfig): Promise<void>;
+    sendEmail(options: IEmailSendOptions): Promise<IEmailSendResult>;
+    sendBulkEmails(options: IEmailSendOptions[]): Promise<IEmailSendResult[]>;
+    healthCheck(): Promise<boolean>;
+    close(): Promise<void>;
+}

package/providers/smtp-provider.d.ts

@@ -0,0 +1,11 @@
+import { IEmailProvider, IEmailSendOptions, IEmailSendResult, ISmtpConfig } from '../interfaces';
+export declare class SmtpProvider implements IEmailProvider {
+    private logger;
+    private transporter;
+    private config;
+    initialize(config: ISmtpConfig): Promise<void>;
+    sendEmail(options: IEmailSendOptions): Promise<IEmailSendResult>;
+    sendBulkEmails(options: IEmailSendOptions[]): Promise<IEmailSendResult[]>;
+    healthCheck(): Promise<boolean>;
+    close(): Promise<void>;
+}

package/services/email-datasource.provider.d.ts

@@ -0,0 +1,25 @@
+import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
+import { IDatabaseConfig, ITenantDatabaseConfig } from '@flusys/nestjs-core';
+import { Logger } from '@nestjs/common';
+import { Request } from 'express';
+import { DataSource } from 'typeorm';
+import { EmailModuleOptions } from '../interfaces';
+export declare class EmailDataSourceProvider extends MultiTenantDataSourceService {
+    private readonly emailOptions;
+    protected readonly logger: Logger;
+    protected static readonly tenantConnections: Map<string, DataSource>;
+    protected static singleDataSource: DataSource | null;
+    protected static readonly tenantsRegistry: Map<string, ITenantDatabaseConfig>;
+    protected static initialized: boolean;
+    protected static readonly connectionLocks: Map<string, Promise<DataSource>>;
+    protected static singleConnectionLock: Promise<DataSource> | null;
+    constructor(emailOptions: EmailModuleOptions, request?: Request);
+    private static buildParentOptions;
+    getEnableCompanyFeature(): boolean;
+    getEnableCompanyFeatureForTenant(tenant?: ITenantDatabaseConfig): boolean;
+    getEnableCompanyFeatureForCurrentTenant(): boolean;
+    getEmailEntities(enableCompanyFeature?: boolean): Promise<any[]>;
+    protected createDataSourceFromConfig(config: IDatabaseConfig): Promise<DataSource>;
+    protected getSingleDataSource(): Promise<DataSource>;
+    protected getOrCreateTenantConnection(tenant: ITenantDatabaseConfig): Promise<DataSource>;
+}

package/services/email-provider-config.service.d.ts

@@ -0,0 +1,32 @@
+import { RequestScopedApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { FilterAndPaginationDto } from '@flusys/nestjs-shared/dtos';
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { EntityTarget, Repository, SelectQueryBuilder } from 'typeorm';
+import { EmailConfigService } from '../config';
+import { CreateEmailConfigDto, UpdateEmailConfigDto } from '../dtos';
+import { EmailConfigBase } from '../entities';
+import { EmailProviderTypeEnum } from '../enums';
+import { IEmailConfig } from '../interfaces';
+import { EmailDataSourceProvider } from './email-datasource.provider';
+export declare class EmailProviderConfigService extends RequestScopedApiService<CreateEmailConfigDto, UpdateEmailConfigDto, IEmailConfig, EmailConfigBase, Repository<EmailConfigBase>> {
+    protected cacheManager: HybridCache;
+    protected utilsService: UtilsService;
+    private readonly emailConfig;
+    private readonly dataSourceProvider;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, emailConfig: EmailConfigService, dataSourceProvider: EmailDataSourceProvider);
+    protected resolveEntity(): EntityTarget<EmailConfigBase>;
+    protected getDataSourceProvider(): EmailDataSourceProvider;
+    convertSingleDtoToEntity(dto: CreateEmailConfigDto | UpdateEmailConfigDto, user: ILoggedUserInfo | null): Promise<EmailConfigBase>;
+    getSelectQuery(query: SelectQueryBuilder<EmailConfigBase>, _user: ILoggedUserInfo | null, select?: string[]): Promise<{
+        query: SelectQueryBuilder<EmailConfigBase>;
+        isRaw: boolean;
+    }>;
+    protected getExtraManipulateQuery(query: SelectQueryBuilder<EmailConfigBase>, filterDto: FilterAndPaginationDto, user: ILoggedUserInfo | null): Promise<{
+        query: SelectQueryBuilder<EmailConfigBase>;
+        isRaw: boolean;
+    }>;
+    findByIdDirect(id: string): Promise<EmailConfigBase | null>;
+    getDefaultConfig(user?: ILoggedUserInfo): Promise<EmailConfigBase | null>;
+    getConfigByProvider(provider: EmailProviderTypeEnum, user?: ILoggedUserInfo): Promise<EmailConfigBase[]>;
+}

package/services/email-send.service.d.ts

@@ -0,0 +1,20 @@
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { EmailConfigService } from '../config';
+import { SendEmailDto, SendTemplateEmailDto } from '../dtos';
+import { IEmailSendResult } from '../interfaces';
+import { EmailFactoryService } from '../providers';
+import { EmailProviderConfigService } from './email-provider-config.service';
+import { EmailTemplateService } from './email-template.service';
+export declare class EmailSendService {
+    private readonly emailFactory;
+    private readonly emailConfigService;
+    private readonly emailProviderConfigService;
+    private readonly emailTemplateService;
+    private readonly logger;
+    constructor(emailFactory: EmailFactoryService, emailConfigService: EmailConfigService, emailProviderConfigService: EmailProviderConfigService, emailTemplateService: EmailTemplateService);
+    private getEmailProviderWithConfig;
+    private interpolateVariables;
+    sendEmail(dto: SendEmailDto, user?: ILoggedUserInfo): Promise<IEmailSendResult>;
+    sendTemplateEmail(dto: SendTemplateEmailDto, user?: ILoggedUserInfo): Promise<IEmailSendResult>;
+    sendTestEmail(emailConfigId: string, recipient: string, user?: ILoggedUserInfo): Promise<IEmailSendResult>;
+}

package/services/email-template.service.d.ts

@@ -0,0 +1,31 @@
+import { RequestScopedApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { FilterAndPaginationDto } from '@flusys/nestjs-shared/dtos';
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { EntityTarget, Repository, SelectQueryBuilder } from 'typeorm';
+import { EmailConfigService } from '../config';
+import { CreateEmailTemplateDto, UpdateEmailTemplateDto } from '../dtos';
+import { EmailTemplateBase } from '../entities';
+import { IEmailTemplate } from '../interfaces';
+import { EmailDataSourceProvider } from './email-datasource.provider';
+export declare class EmailTemplateService extends RequestScopedApiService<CreateEmailTemplateDto, UpdateEmailTemplateDto, IEmailTemplate, EmailTemplateBase, Repository<EmailTemplateBase>> {
+    protected cacheManager: HybridCache;
+    protected utilsService: UtilsService;
+    private readonly emailConfig;
+    private readonly dataSourceProvider;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, emailConfig: EmailConfigService, dataSourceProvider: EmailDataSourceProvider);
+    protected resolveEntity(): EntityTarget<EmailTemplateBase>;
+    protected getDataSourceProvider(): EmailDataSourceProvider;
+    convertSingleDtoToEntity(dto: CreateEmailTemplateDto | UpdateEmailTemplateDto, user: ILoggedUserInfo | null): Promise<EmailTemplateBase>;
+    getSelectQuery(query: SelectQueryBuilder<EmailTemplateBase>, _user: ILoggedUserInfo | null, select?: string[]): Promise<{
+        query: SelectQueryBuilder<EmailTemplateBase>;
+        isRaw: boolean;
+    }>;
+    protected getExtraManipulateQuery(query: SelectQueryBuilder<EmailTemplateBase>, filterDto: FilterAndPaginationDto, user: ILoggedUserInfo | null): Promise<{
+        query: SelectQueryBuilder<EmailTemplateBase>;
+        isRaw: boolean;
+    }>;
+    findByIdDirect(id: string): Promise<EmailTemplateBase | null>;
+    findBySlug(slug: string, user?: ILoggedUserInfo): Promise<EmailTemplateBase | null>;
+    getActiveTemplates(user?: ILoggedUserInfo): Promise<EmailTemplateBase[]>;
+}

package/services/index.d.ts

@@ -0,0 +1,4 @@
+export * from './email-datasource.provider';
+export * from './email-provider-config.service';
+export * from './email-template.service';
+export * from './email-send.service';