@hed-hog/core 0.0.106 → 0.0.108

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hed-hog/core",
-  "version": "0.0.106",
+  "version": "0.0.108",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
@@ -31,10 +31,10 @@
     "uuid": "^11.1.0",
     "@hed-hog/types": "0.0.1",
     "@hed-hog/api-pagination": "0.0.4",
-    "@hed-hog/api": "0.0.3",
     "@hed-hog/api-mail": "0.0.7",
-    "@hed-hog/api-locale": "0.0.10",
-    "@hed-hog/api-prisma": "0.0.4"
+    "@hed-hog/api": "0.0.3",
+    "@hed-hog/api-prisma": "0.0.4",
+    "@hed-hog/api-locale": "0.0.10"
   },
   "exports": {
     ".": {

package/src/auth/auth.service.ts

@@ -122,7 +122,7 @@ export class AuthService {
       locale,
       {
         email,
-        slug: 'auth-sign-up-confirm-email',
+        slug: 'auth-email-verification-code',
         variables: {
           code,
           name: user.name,
@@ -179,7 +179,7 @@ export class AuthService {
       locale,
       {
         email,
-        slug: 'auth-sign-up-confirm-email',
+        slug: 'auth-email-verification-code',
         variables: {
           code,
           name: user.name,

package/src/challenge/challenge.service.ts

@@ -71,7 +71,7 @@ export class ChallengeService {
       locale,
       {
         email,
-        slug: 'auth-sign-up-confirm-email',
+        slug: 'auth-email-verification-code',
         variables: {
           code,
           name: user.name,

package/src/mail/dto/import.dto.ts

@@ -0,0 +1,62 @@
+import { getLocaleText } from '@hed-hog/api-locale';
+import { Type } from 'class-transformer';
+import {
+    IsArray,
+    IsBoolean,
+    IsOptional,
+    IsString,
+    ValidateNested,
+} from 'class-validator';
+
+class ImportTranslationDTO {
+  @IsString({
+    message: (args) => getLocaleText('validation.stringRequired', args.value),
+  })
+  code: string;
+
+  @IsString({
+    message: (args) => getLocaleText('validation.stringRequired', args.value),
+  })
+  subject: string;
+
+  @IsString({
+    message: (args) => getLocaleText('validation.stringRequired', args.value),
+  })
+  body: string;
+}
+
+class ImportTemplateDTO {
+  @IsString({
+    message: (args) => getLocaleText('validation.stringRequired', args.value),
+  })
+  slug: string;
+
+  @IsArray({
+    message: (args) => getLocaleText('validation.arrayRequired', args.value),
+  })
+  @ValidateNested({ each: true })
+  @Type(() => ImportTranslationDTO)
+  translations: ImportTranslationDTO[];
+
+  @IsArray({
+    message: (args) => getLocaleText('validation.arrayRequired', args.value),
+  })
+  @IsString({ each: true })
+  @IsOptional()
+  variables?: string[];
+}
+
+export class ImportDTO {
+  @IsArray({
+    message: (args) => getLocaleText('validation.arrayRequired', args.value),
+  })
+  @ValidateNested({ each: true })
+  @Type(() => ImportTemplateDTO)
+  data: ImportTemplateDTO[];
+
+  @IsBoolean({
+    message: (args) => getLocaleText('validation.booleanRequired', args.value),
+  })
+  @IsOptional()
+  overwrite?: boolean;
+}

package/src/mail/mail.controller.ts

@@ -2,22 +2,23 @@ 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,
-  Header,
-  Inject,
-  Param,
-  ParseIntPipe,
-  Patch,
-  Post,
-  Query,
-  Res,
-  forwardRef,
+    Body,
+    Controller,
+    Delete,
+    Get,
+    Header,
+    Inject,
+    Param,
+    ParseIntPipe,
+    Patch,
+    Post,
+    Query,
+    Res,
+    forwardRef,
 } from '@nestjs/common';
 import { Response } from 'express';
 import { CreateDTO } from './dto/create.dto';
+import { ImportDTO } from './dto/import.dto';
 import { TestMailDTO } from './dto/test-mail.dto';
 import { UpdateDTO } from './dto/update.dto';
 import { MailService } from './mail.service';
@@ -116,4 +117,9 @@ export class MailController {
   async sendTestMail(@Locale() locale: string, @Body() data: TestMailDTO) {
     return this.mailService.sendTestMail(locale, data);
   }
+
+  @Post('import')
+  async import(@Body() data: ImportDTO) {
+    return this.mailService.importTemplates(data);
+  }
 }

package/src/mail/mail.service.ts

@@ -13,6 +13,7 @@ import {
 import * as Handlebars from 'handlebars';
 import { SettingService } from '../setting/setting.service';
 import { CreateDTO } from './dto/create.dto';
+import { ImportDTO } from './dto/import.dto';
 import { SendTemplatedMailDTO } from './dto/send.dto';
 import { TestMailDTO } from './dto/test-mail.dto';
 import { UpdateDTO } from './dto/update.dto';
@@ -461,4 +462,109 @@ export class MailService {
       throw new BadRequestException('Failed to send test email');
     }
   }
+
+  async importTemplates({ data, overwrite }: ImportDTO) {
+    const conflicts: string[] = [];
+
+    if (!overwrite) {
+      for (const template of data) {
+        const existing = await this.prismaService.mail.findUnique({
+          where: { slug: template.slug },
+        });
+
+        if (existing) {
+          conflicts.push(template.slug);
+        }
+      }
+
+      if (conflicts.length > 0) {
+        return { conflicts };
+      }
+    }
+
+    const imported: any[] = [];
+    for (const template of data) {
+      try {
+        const locales = await this.prismaService.locale.findMany({
+          where: {
+            code: {
+              in: template.translations.map((t) => t.code),
+            },
+          },
+        });
+
+        const localeMap = new Map(
+          locales.map((locale) => [locale.code, locale.id])
+        );
+
+        const existing = await this.prismaService.mail.findUnique({
+          where: { slug: template.slug },
+        });
+
+        if (existing && overwrite) {
+          await this.prismaService.mail_locale.deleteMany({
+            where: { mail_id: existing.id },
+          });
+
+          await this.prismaService.mail_var.deleteMany({
+            where: { mail_id: existing.id },
+          });
+
+          await this.prismaService.mail_locale.createMany({
+            data: template.translations.map((translation) => ({
+              mail_id: existing.id,
+              locale_id: localeMap.get(translation.code)!,
+              subject: translation.subject,
+              body: translation.body,
+            })),
+          });
+
+          if (template.variables && template.variables.length > 0) {
+            await this.prismaService.mail_var.createMany({
+              data: template.variables.map((variable) => ({
+                mail_id: existing.id,
+                name: variable,
+              })),
+            });
+          }
+
+          imported.push(existing.id);
+        } else if (!existing) {
+          const newMail = await this.prismaService.mail.create({
+            data: {
+              slug: template.slug,
+              mail_locale: {
+                create: template.translations.map((translation) => ({
+                  locale_id: localeMap.get(translation.code)!,
+                  subject: translation.subject,
+                  body: translation.body,
+                })),
+              },
+              mail_var: template.variables
+                ? {
+                    create: template.variables.map((variable) => ({
+                      name: variable,
+                    })),
+                  }
+                : undefined,
+            },
+          });
+
+          imported.push(newMail.id);
+        }
+      } catch (error) {
+        this.logger.error(`Error importing template ${template.slug}:`, error);
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new BadRequestException(
+          `Failed to import template "${template.slug}": ${message}`
+        );
+      }
+    }
+
+    return {
+      success: true,
+      imported: imported.length,
+      templates: imported,
+    };
+  }
 }

package/src/profile/profile.controller.ts

@@ -1,6 +1,6 @@
 import { Role, User } from '@hed-hog/api';
 import { Locale } from '@hed-hog/api-locale';
-import { Body, Controller, Delete, Get, Param, ParseIntPipe, Post, Put, UploadedFile, UseInterceptors } from '@nestjs/common';
+import { Body, Controller, Delete, Get, Headers, Ip, Param, ParseIntPipe, Post, Put, UploadedFile, UseInterceptors } from '@nestjs/common';
 import { FileInterceptor } from '@nestjs/platform-express';
 import { ChangeEmailDto } from './dto/change-email.dto';
 import { ChangePasswordDto } from './dto/change-password.dto';
@@ -196,8 +196,14 @@ export class ProfileController {
   }
 
   @Put('change-password')
-  changePassword(@User() {id}, @Body() body: ChangePasswordDto, @Locale() locale: string) {
-    return this.profileService.changePassword(locale, id, body);
+  changePassword(
+    @User() {id}, 
+    @Body() body: ChangePasswordDto, 
+    @Locale() locale: string,
+    @Ip() ipAddress: string,
+    @Headers('user-agent') userAgent: string
+  ) {
+    return this.profileService.changePassword(locale, id, body, ipAddress, userAgent);
   }
 
   @Put('change-email')

package/src/profile/profile.service.ts

@@ -4,18 +4,19 @@ import { User } from '@hed-hog/types';
 import { BadRequestException, forwardRef, Inject, Injectable, NotFoundException } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 import type {
-  VerifiedAuthenticationResponse,
-  VerifiedRegistrationResponse,
+    VerifiedAuthenticationResponse,
+    VerifiedRegistrationResponse,
 } from '@simplewebauthn/server';
 import {
-  generateAuthenticationOptions,
-  generateRegistrationOptions,
-  verifyAuthenticationResponse,
-  verifyRegistrationResponse,
+    generateAuthenticationOptions,
+    generateRegistrationOptions,
+    verifyAuthenticationResponse,
+    verifyRegistrationResponse,
 } from '@simplewebauthn/server';
 import * as qrcode from 'qrcode';
 import * as speakeasy from 'speakeasy';
 import { ChallengeService } from '../challenge/challenge.service';
+import { MailService } from '../mail/mail.service';
 import { SecurityService } from '../security/security.service';
 import { SettingService } from '../setting/setting.service';
 import { TokenService } from '../token/token.service';
@@ -41,6 +42,8 @@ export class ProfileService {
     private readonly challenge: ChallengeService,
     @Inject(forwardRef(() => TokenService))
     private readonly token: TokenService,
+    @Inject(forwardRef(() => MailService))
+    private readonly mail: MailService,
   ) {}
 
   async changeEmail(locale: string, userId: number, { email, password, pin }: ChangeEmailDto) {
@@ -335,7 +338,7 @@ export class ProfileService {
     return this.user.changeAvatar(locale, userId, file);   
   }
 
-  async changePassword(locale:string, userId: number, {currentPassword, newPassword}: ChangePasswordDto) {
+  async changePassword(locale:string, userId: number, {currentPassword, newPassword}: ChangePasswordDto, ipAddress?: string, userAgent?: string) {
     const credential =  await this.prisma.user_credential.findFirst({
       where: { user_id: userId, type: 'password' },
     });
@@ -355,6 +358,32 @@ export class ProfileService {
       data: { hash: passwordHash },
     });
 
+    // Get user data and email for notification
+    const user = await this.prisma.user.findUnique({
+      where: { id: userId },
+      include: {
+        user_identifier: {
+          where: { type: 'email', enabled: true, verified_at: { not: null } },
+          select: { value: true },
+        },
+      },
+    });
+
+    if (user?.user_identifier?.[0]?.value) {
+      this.mail.sendTemplatedMail(locale, {
+        email: user.user_identifier[0].value,
+        slug: 'auth-change-password-notification',
+        variables: {
+          name: user.name,
+          userAgent: userAgent || 'Unknown',
+          ipAddress: ipAddress || 'Unknown',
+          location: 'Unknown',
+        },
+      }).catch(error => {
+        console.error('Failed to send password change notification:', error);
+      });
+    }
+
     return { success: true };
   }