@hed-hog/core 0.0.4

package/src/mail/dto/create.dto.ts

@@ -0,0 +1,40 @@
+import { Type } from 'class-transformer';
+import {
+  IsArray,
+  IsNumber,
+  IsOptional,
+  IsString,
+  ValidateNested,
+} from 'class-validator';
+
+class MailLocaleDTO {
+  @IsNumber()
+  locale_id: number;
+
+  @IsString()
+  subject: string;
+
+  @IsString()
+  body: string;
+}
+
+class MailVarDTO {
+  [key: string]: string;
+}
+
+export class CreateDTO {
+  @IsString()
+  slug: string;
+
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => MailLocaleDTO)
+  @IsOptional()
+  mail_locale?: MailLocaleDTO[];
+
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => MailVarDTO)
+  @IsOptional()
+  mail_var?: MailVarDTO[];
+}

package/src/mail/dto/send.dto.ts

@@ -0,0 +1,14 @@
+import { IsNotEmpty, IsObject, IsString } from 'class-validator';
+
+export class SendTemplatedMailDTO {
+  @IsString()
+  @IsNotEmpty()
+  email: string;
+
+  @IsString()
+  @IsNotEmpty()
+  slug: string;
+
+  @IsObject()
+  variables: Record<string, string>;
+}

package/src/mail/dto/test-mail.dto.ts

@@ -0,0 +1,19 @@
+import { IsEmail, IsNotEmpty, IsObject, IsOptional, IsString } from 'class-validator';
+
+export class TestMailDTO {
+  @IsEmail()
+  @IsNotEmpty()
+  email: string;
+
+  @IsString()
+  @IsNotEmpty()
+  subject: string;
+
+  @IsString()
+  @IsNotEmpty()
+  body: string;
+
+  @IsObject()
+  @IsOptional()
+  variables?: Record<string, string>;
+}

package/src/mail/dto/update.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateDTO } from './create.dto';
+
+export class UpdateDTO extends PartialType(CreateDTO) {}

package/src/mail/mail.controller.ts

@@ -0,0 +1,67 @@
+import { DeleteDTO, Role } from '@hed-hog/api';
+import { Locale } from '@hed-hog/api-locale';
+import { Pagination } from '@hed-hog/api-pagination';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Inject,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Query,
+  forwardRef,
+} from '@nestjs/common';
+import { CreateDTO } from './dto/create.dto';
+import { TestMailDTO } from './dto/test-mail.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { MailService } from './mail.service';
+
+@Role()
+@Controller('mail')
+export class MailController {
+  constructor(
+    @Inject(forwardRef(() => MailService))
+    private readonly mailService: MailService,
+  ) {}
+
+  @Get()
+  async list(@Locale() locale, @Pagination() paginationParams) {
+    return this.mailService.list(locale, paginationParams);
+  }
+
+  @Get(':id')
+  async get(
+    @Param('id', ParseIntPipe) id: number,
+    @Query('locale') queryLocale?: string,
+    @Locale() decoratorLocale?: string,
+  ) {
+    const locale = queryLocale || decoratorLocale;
+    return this.mailService.get(locale, id);
+  }
+
+  @Post()
+  async create(@Body() data: CreateDTO) {
+    return this.mailService.create(data);
+  }
+
+  @Patch(':id')
+  async update(@Param('id', ParseIntPipe) id: number, @Body() data: UpdateDTO) {
+    return this.mailService.update({
+      id,
+      data,
+    });
+  }
+
+  @Delete()
+  async delete(@Body() data: DeleteDTO) {
+    return this.mailService.delete(data);
+  }
+
+  @Post('test')
+  async sendTestMail(@Body() data: TestMailDTO) {
+    return this.mailService.sendTestMail(data);
+  }
+}

package/src/mail/mail.module.ts

@@ -0,0 +1,107 @@
+import { LocaleModule } from '@hed-hog/api-locale';
+import { MailModule as MailMainModule, MailModuleOptions } from '@hed-hog/api-mail';
+import { PaginationModule } from '@hed-hog/api-pagination';
+import { PrismaModule, PrismaService } from '@hed-hog/api-prisma';
+import { BadRequestException, forwardRef, Module } from '@nestjs/common';
+import { MailSentModule } from '../mail-sent/mail-sent.module';
+import { SettingModule } from '../setting/setting.module';
+import { MailController } from './mail.controller';
+import { MailService } from './mail.service';
+
+@Module({
+  imports: [
+    forwardRef(() => MailMainModule.forRootAsync({
+      imports: [PrismaModule],
+      inject: [PrismaService],
+      useFactory: async (prisma: PrismaService) => {
+        try {
+          const mailSettings = await prisma.setting.findMany({
+            where: {
+              slug: {
+                in: [
+
+                  'mail-provider',
+                  'mail-from',
+                  'mail-gmail-client-id',
+                  'mail-gmail-client-secret',
+                  'mail-gmail-refresh-token',
+                  'mail-smtp-host',
+                  'mail-smtp-port',
+                  'mail-smtp-secure',
+                  'mail-client-secret',
+                  'mail-client-secret',
+                  'mail-aws-access-key-id',
+                  'mail-aws-secret-access-key',
+                  'mail-aws-region'
+                ]
+              }
+            },
+            select: {
+              slug: true,
+              value: true,
+            }
+          });
+
+          const settings = new Map<string, string>();
+
+          for (const setting of mailSettings) {
+            settings.set(setting.slug, setting.value);
+          }
+
+          const config: MailModuleOptions = {
+            global: true,
+          } as MailModuleOptions;
+
+          switch (settings.get('mail-provider')) {
+            case 'GMAIL':
+              Object.assign(config, {
+                type: 'GMAIL',
+                clientId: settings.get('mail-gmail-client-id'),
+                clientSecret: settings.get('mail-gmail-client-secret'),
+                refreshToken: settings.get('mail-gmail-refresh-token'),
+                from: settings.get('mail-from'),
+              });
+              break;
+            case 'SMTP':
+              Object.assign(config, {
+                type: 'SMTP',
+                host: settings.get('mail-smtp-host'),
+                port: Number(settings.get('mail-smtp-port')),
+                secure: settings.get('mail-smtp-secure') === 'true',
+                username: settings.get('mail-from'),
+                password: settings.get('mail-client-secret'),
+              });
+              break;
+            case 'SES':
+              Object.assign(config, {
+                type: 'SES',
+                region: settings.get('mail-aws-region'),
+                accessKeyId: settings.get('mail-aws-access-key-id'),
+                secretAccessKey: settings.get('mail-aws-secret-access-key'),
+                from: settings.get('mail-from'),
+              });
+              break;
+            default:
+              throw new BadRequestException(`Invalid mail provider: ${settings.get('mail-provider')}`);
+          }
+
+          return config;
+        }
+
+        catch (error) {
+          console.error('Error loading mail settings:', error);
+          throw error;
+        }
+      }
+    })),
+    forwardRef(() => MailSentModule),
+    forwardRef(() => PrismaModule),
+    forwardRef(() => PaginationModule),
+    forwardRef(() => LocaleModule),
+    forwardRef(() => SettingModule),
+  ],
+  controllers: [MailController],
+  providers: [MailService],
+  exports: [MailService],
+})
+export class MailModule { }

package/src/mail/mail.service.ts

@@ -0,0 +1,371 @@
+import { DeleteDTO } from '@hed-hog/api';
+import { LocaleService } from '@hed-hog/api-locale';
+import { MailService as MailMainService } from '@hed-hog/api-mail';
+import { PaginationDTO } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  BadRequestException,
+  Inject,
+  Injectable,
+  Logger,
+  OnModuleInit,
+  forwardRef,
+} from '@nestjs/common';
+import * as Handlebars from 'handlebars';
+import { MailSentService } from '../mail-sent/mail-sent.service';
+import { SettingService } from '../setting/setting.service';
+import { CreateDTO } from './dto/create.dto';
+import { SendTemplatedMailDTO } from './dto/send.dto';
+import { TestMailDTO } from './dto/test-mail.dto';
+import { UpdateDTO } from './dto/update.dto';
+
+@Injectable()
+export class MailService implements OnModuleInit {
+  private readonly logger = new Logger(MailService.name);
+  public settings: Record<string, any> = {};
+  private readonly modelName = 'mail';
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => MailMainService))
+    private readonly mailMainService: MailMainService,
+    @Inject(forwardRef(() => LocaleService))
+    private readonly localeService: LocaleService,
+    @Inject(forwardRef(() => MailSentService))
+    private readonly mailSentService: MailSentService,
+    @Inject(forwardRef(() => SettingService))
+    private readonly setting: SettingService,
+  ) { }
+
+  async onModuleInit() {
+    this.settings = await this.setting.getSettingValues([
+      'configured-mail',
+    ]);
+  }
+
+  async list(locale: string, paginationParams: PaginationDTO) {
+    const result = await this.localeService.listModelWithLocale(
+      locale,
+      this.modelName,
+      paginationParams,
+    );
+
+    if (result.data && Array.isArray(result.data)) {
+      const mailIds = result.data.map((item: any) => item.mail_id).filter(Boolean);
+      const mailVars = await this.prismaService.mail_var.findMany({
+        where: {
+          mail_id: {
+            in: mailIds,
+          },
+        },
+        select: {
+          id: true,
+          mail_id: true,
+          name: true,
+        },
+      });
+
+      const varsByMailId = mailVars.reduce((acc, mailVar) => {
+        if (!acc[mailVar.mail_id]) {
+          acc[mailVar.mail_id] = [];
+        }
+        acc[mailVar.mail_id].push(mailVar);
+        return acc;
+      }, {} as Record<number, any[]>);
+
+      result.data = result.data.map((item: any) => ({
+        ...item,
+        mail_var: varsByMailId[item.mail_id] || [],
+      }));
+    }
+
+    return result;
+  }
+
+  async get(locale: string, id: number) {
+    const localeRecord = await this.localeService.getByCode(locale);
+    const mail = await this.prismaService.mail.findUnique({
+      where: { id },
+      include: {
+        mail_locale: {
+          where: { locale_id: localeRecord.id },
+          include: { locale: { select: { code: true } } },
+        },
+        mail_var: {
+          select: {
+            id: true,
+            name: true,
+          },
+        },
+      },
+    });
+
+    if (!mail) {
+      return null;
+    }
+
+    const localeData = mail.mail_locale[0];
+    return {
+      id: mail.id,
+      slug: mail.slug,
+      locale_id: localeData?.locale_id,
+      mail_id: mail.id,
+      subject: localeData?.subject || '',
+      body: localeData?.body || '',
+      mail_var: mail.mail_var,
+      locale: localeData?.locale,
+      created_at: mail.created_at,
+      updated_at: mail.updated_at,
+    };
+  }
+
+  async create(data: CreateDTO) {
+    const { slug, mail_locale, mail_var } = data;
+    const existing = await this.prismaService.mail.findUnique({
+      where: { slug },
+    });
+
+    if (existing) {
+      throw new BadRequestException(`Template with slug "${slug}" already exists.`);
+    }
+
+    return this.prismaService.mail.create({
+      data: {
+        slug,
+        mail_locale: mail_locale
+          ? {
+              create: mail_locale.map((ml) => ({
+                locale_id: ml.locale_id,
+                subject: ml.subject,
+                body: ml.body,
+              })),
+            }
+          : undefined,
+        mail_var: mail_var
+          ? {
+              create: mail_var.map((mv) => ({
+                name: mv.name,
+              })),
+            }
+          : undefined,
+      },
+      include: {
+        mail_locale: true,
+        mail_var: true,
+      },
+    });
+  }
+
+  async update({ id, data }: { id: number; data: UpdateDTO }) {
+    const { slug, mail_locale, mail_var } = data;
+    const existingMail = await this.prismaService.mail.findUnique({
+      where: { id },
+    });
+
+    if (!existingMail) {
+      throw new BadRequestException(`Template with id ${id} not found.`);
+    }
+
+    if (slug && slug !== existingMail.slug) {
+      const slugExists = await this.prismaService.mail.findUnique({
+        where: { slug },
+      });
+
+      if (slugExists) {
+        throw new BadRequestException(`Template with slug "${slug}" already exists.`);
+      }
+
+      await this.prismaService.mail.update({
+        where: { id },
+        data: { slug },
+      });
+    }
+
+    if (mail_locale && mail_locale.length > 0) {
+      for (const ml of mail_locale) {
+        const existingLocale = await this.prismaService.mail_locale.findFirst({
+          where: {
+            mail_id: id,
+            locale_id: ml.locale_id,
+          },
+        });
+
+        if (existingLocale) {
+          await this.prismaService.mail_locale.update({
+            where: { id: existingLocale.id },
+            data: {
+              subject: ml.subject,
+              body: ml.body,
+            },
+          });
+        } else {
+          await this.prismaService.mail_locale.create({
+            data: {
+              mail_id: id,
+              locale_id: ml.locale_id,
+              subject: ml.subject,
+              body: ml.body,
+            },
+          });
+        }
+      }
+    }
+
+    if (mail_var !== undefined) {
+      await this.prismaService.mail_var.deleteMany({
+        where: { mail_id: id },
+      });
+
+      if (mail_var.length > 0) {
+        await this.prismaService.mail_var.createMany({
+          data: mail_var.map((mv) => ({
+            mail_id: id,
+            name: mv.name,
+          })),
+        });
+      }
+    }
+
+    return this.prismaService.mail.findUnique({
+      where: { id },
+      include: {
+        mail_locale: true,
+        mail_var: true,
+      },
+    });
+  }
+
+  async delete({ ids }: DeleteDTO): Promise<{ count: number }> {
+    if (ids == undefined || ids == null) {
+      throw new BadRequestException(
+        'You must select at least one item to delete.',
+      );
+    }
+    return this.prismaService.mail.deleteMany({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+    });
+  }
+
+  async sendTemplatedMail(
+    locale: string,
+    { email, slug, variables }: SendTemplatedMailDTO,
+  ) {
+
+    if (!this.settings['configured-mail']) {
+      this.logger.warn('Mail service is not configured. Aborting sending email.');
+      return;
+    }
+
+    try {
+
+      const localeRecord = await this.getLocaleRecord(locale);
+      const mail = await this.getMailTemplate(slug, localeRecord.id);
+      const { subject, body } = mail.mail_locale[0];
+      const parsedSubject = this.interpolateTemplate(subject, variables);
+      const parsedBody = this.interpolateTemplate(body, variables);
+
+      const { mail: mailSent } = await this.mailMainService.send({
+        to: email,
+        subject: parsedSubject,
+        body: parsedBody,
+      });
+
+      return this.mailSentService.create({
+        body: parsedBody,
+        subject: parsedSubject,
+        to: email,
+        from: mailSent.from,
+        cc: mailSent.cc as string,
+        bcc: mailSent.bcc as string,
+        mail_id: mail.id,
+      });
+
+    } catch (error) {
+      this.logger.error('Error sending templated mail:', error);
+      await this.setting.setValue('configured-mail', 'false');
+      this.onModuleInit();
+    }
+  }
+
+  private async getLocaleRecord(locale: string) {
+    const localeRecord = await this.prismaService.locale.findUnique({
+      where: { code: locale },
+    });
+
+    if (!localeRecord) {
+      throw new Error(`Locale "${locale}" not found`);
+    }
+
+    return localeRecord;
+  }
+
+  private async getMailTemplate(slug: string, localeId: number) {
+    const mail = await this.prismaService.mail.findUnique({
+      where: { slug },
+      include: {
+        mail_locale: {
+          where: { locale_id: localeId },
+          select: { subject: true, body: true },
+        },
+        mail_var: {
+          select: { name: true },
+        },
+      },
+    });
+
+    if (!mail) {
+      throw new Error(`Template "${slug}" not found for locale "${localeId}"`);
+    }
+
+    return mail;
+  }
+
+  private interpolateTemplate(
+    source: string,
+    data: any,
+  ): string {
+    try {
+      const template = Handlebars.compile(source.replace(/(\r\n|\n|\r)/g, '<br/>'));
+      return template(data);
+    } catch (error: any) {
+      this.logger.error('Handlebars template compilation error:', error);
+      throw new BadRequestException(
+        `Invalid template syntax: ${error.message}. Please use {{variable}} format for variables.`
+      );
+    }
+  }
+
+  async sendTestMail({
+    email,
+    subject,
+    body,
+    variables,
+  }: TestMailDTO) {
+    if (!this.settings['configured-mail']) {
+      throw new BadRequestException('Mail service is not configured.');
+    }
+
+    try {
+      const parsedSubject = variables
+        ? this.interpolateTemplate(subject, variables)
+        : subject;
+      const parsedBody = variables
+        ? this.interpolateTemplate(body, variables)
+        : body;
+
+      return this.mailMainService.send({
+        to: email,
+        subject: parsedSubject,
+        body: parsedBody,
+      });
+    } catch (error) {
+      this.logger.error('Error sending test mail:', error);
+      throw new BadRequestException('Failed to send test email');
+    }
+  }
+}

package/src/mail-sent/dto/create.dto.ts

@@ -0,0 +1,43 @@
+import { IsNumber, IsString, IsOptional } from 'class-validator';
+import { Transform } from 'class-transformer';
+
+export class CreateDTO {
+  @IsNumber()
+  mail_id: number;
+
+  @IsString()
+  subject: string;
+
+  @IsString()
+  from: string;
+
+  @IsOptional()
+  @IsString()
+  @Transform(({ value }) => {
+    if (value === null || value === undefined) return '';
+    if (Array.isArray(value)) return value.join(';');
+    return value;
+  })
+  to?: string;
+
+  @IsOptional()
+  @IsString()
+  @Transform(({ value }) => {
+    if (value === null || value === undefined) return '';
+    if (Array.isArray(value)) return value.join(';');
+    return value;
+  })
+  cc?: string;
+
+  @IsOptional()
+  @IsString()
+  @Transform(({ value }) => {
+    if (value === null || value === undefined) return '';
+    if (Array.isArray(value)) return value.join(';');
+    return value;
+  })
+  bcc?: string;
+
+  @IsString()
+  body: string;
+}

package/src/mail-sent/dto/update.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateDTO } from './create.dto';
+
+export class UpdateDTO extends PartialType(CreateDTO) {}