@hed-hog/core 0.0.354 → 0.0.356

package/src/webhook-integration/webhook-integration.controller.ts

@@ -61,6 +61,11 @@ export class WebhookIntegrationController {
     return this.service.regenerateToken(id);
   }
 
+  @Post(':id/duplicate')
+  duplicate(@Param('id', ParseIntPipe) id: number) {
+    return this.service.duplicate(id);
+  }
+
   @Get(':id/action')
   listActions(@Param('id', ParseIntPipe) id: number) {
     return this.service.listActions(id);

package/src/webhook-integration/webhook-integration.service.ts

@@ -12,6 +12,11 @@ import {
 import { EventEmitter } from 'events';
 import { Request, Response } from 'express';
 import { firstValueFrom } from 'rxjs';
+import {
+  buildMailConfigFromIntegration,
+  getFromAddress,
+  getReplyToAddress,
+} from '../integration-profile/integration-profile.utils';
 import { MailService } from '../mail/mail.service';
 import { SettingService } from '../setting/setting.service';
 import {
@@ -203,6 +208,66 @@ export class WebhookIntegrationService {
     };
   }
 
+  async duplicate(id: number) {
+    const original = await this.get(id);
+
+    const newSlug = await this.generateUniqueSlug(original.slug, this.integrations);
+
+    let plainToken: string | null = null;
+    let tokenHash: string | null = null;
+    if (original.require_token) {
+      plainToken = createPlainToken();
+      tokenHash = hashToken(plainToken);
+    }
+
+    const record = await this.integrations.create({
+      data: {
+        slug: newSlug,
+        name: `${original.name} (copy)`,
+        description: original.description,
+        public_uuid: createPublicUuid(),
+        status: original.status,
+        require_token: original.require_token,
+        token_hash: tokenHash,
+        allowed_ips: original.allowed_ips,
+        body_schema: original.body_schema,
+        webhook_action: {
+          create: (original.webhook_action ?? []).map((a: any) => ({
+            type: a.type,
+            name: a.name,
+            order: a.order,
+            status: a.status,
+            mail_profile_id: a.mail_profile_id,
+            mail_id: a.mail_id,
+            email_to: a.email_to,
+            email_cc: a.email_cc,
+            email_bcc: a.email_bcc,
+            whatsapp_target_type: a.whatsapp_target_type,
+            whatsapp_target: a.whatsapp_target,
+            whatsapp_template: a.whatsapp_template,
+            whatsapp_instance: a.whatsapp_instance,
+            whatsapp_base_url: a.whatsapp_base_url,
+            whatsapp_token: a.whatsapp_token,
+          })),
+        },
+      },
+    });
+
+    return { ...(await this.withPublicUrl(record)), plainToken };
+  }
+
+  private async generateUniqueSlug(base: string, table: any): Promise<string> {
+    const candidate = `${base}-copy`;
+    const existing = await table.findUnique({ where: { slug: candidate } });
+    if (!existing) return candidate;
+
+    for (let i = 2; ; i++) {
+      const next = `${base}-copy-${i}`;
+      const taken = await table.findUnique({ where: { slug: next } });
+      if (!taken) return next;
+    }
+  }
+
   private async getApplicationBaseUrl() {
     const settings = await this.settingService.getSettingValues([
       'api-url',
@@ -539,8 +604,9 @@ export class WebhookIntegrationService {
   private async executeEmailAction(action: any, body: any) {
     this.validateActionConfiguration(action);
 
-    const profile = await (this.prisma as any).mail_profile.findUnique({
+    const profile = await (this.prisma as any).integration_profile.findUnique({
       where: { id: Number(action.mail_profile_id) },
+      include: { integration_provider: { select: { slug: true } } },
     });
     const mail = await (this.prisma as any).mail.findUnique({
       where: { id: Number(action.mail_id) },
@@ -558,15 +624,12 @@ export class WebhookIntegrationService {
     }
 
     const template = mail.mail_locale[0];
-    const config = this.buildMailConfig(profile);
-    const sender = profile.from_name
-      ? `${profile.from_name} <${profile.from_email}>`
-      : profile.from_email;
-    const replyTo = profile.reply_to_email
-      ? profile.reply_to_name
-        ? `${profile.reply_to_name} <${profile.reply_to_email}>`
-        : profile.reply_to_email
-      : undefined;
+    const config = buildMailConfigFromIntegration(
+      profile.integration_provider.slug,
+      profile.config,
+    );
+    const sender = getFromAddress(profile.config);
+    const replyTo = getReplyToAddress(profile.config);
 
     const renderedTo = String(renderTemplate(action.email_to, body) ?? '').trim();
     const renderedCc = action.email_cc
@@ -1098,40 +1161,5 @@ export class WebhookIntegrationService {
     return Number(value);
   }
 
-  private buildMailConfig(profile: any) {
-    switch (profile.provider) {
-      case 'SMTP':
-        return {
-          global: true,
-          type: 'SMTP',
-          host: profile.smtp_host,
-          port: Number(profile.smtp_port || 587),
-          secure: Boolean(profile.smtp_secure),
-          username: profile.smtp_username || '',
-          password: profile.smtp_password || '',
-        };
-      case 'GMAIL':
-        return {
-          global: true,
-          type: 'GMAIL',
-          clientId: profile.gmail_client_id,
-          clientSecret: profile.gmail_client_secret,
-          refreshToken: profile.gmail_refresh_token,
-          from: profile.from_email,
-        };
-      case 'SES':
-        return {
-          global: true,
-          type: 'SES',
-          region: profile.ses_region,
-          accessKeyId: profile.ses_access_key_id,
-          secretAccessKey: profile.ses_secret_access_key,
-          from: profile.from_email,
-        };
-      default:
-        throw new BadRequestException(
-          `Invalid mail profile provider: ${profile.provider}`,
-        );
-    }
-  }
 }
+

package/src/whatsapp-profile/dto/create.dto.ts

@@ -0,0 +1,36 @@
+import { getLocaleText } from '@hed-hog/api-locale';
+import { Transform } from 'class-transformer';
+import { IsIn, IsString, MaxLength } from 'class-validator';
+
+const providerOptions = ['WHATSAPP_API'] as const;
+
+export class CreateDTO {
+  @IsString({ message: (args) => getLocaleText('validation.stringRequired', args.value) })
+  @MaxLength(127)
+  @Transform(({ value }) => String(value ?? '').trim())
+  slug: string;
+
+  @IsString({ message: (args) => getLocaleText('validation.stringRequired', args.value) })
+  @MaxLength(127)
+  @Transform(({ value }) => String(value ?? '').trim())
+  name: string;
+
+  @IsIn(providerOptions)
+  @Transform(({ value }) => String(value ?? '').trim().toUpperCase())
+  provider: (typeof providerOptions)[number];
+
+  @IsString({ message: (args) => getLocaleText('validation.stringRequired', args.value) })
+  @MaxLength(255)
+  @Transform(({ value }) => String(value ?? '').trim())
+  host: string;
+
+  @IsString({ message: (args) => getLocaleText('validation.stringRequired', args.value) })
+  @MaxLength(255)
+  @Transform(({ value }) => String(value ?? '').trim())
+  token: string;
+
+  @IsString({ message: (args) => getLocaleText('validation.stringRequired', args.value) })
+  @MaxLength(127)
+  @Transform(({ value }) => String(value ?? '').trim())
+  instance_name: string;
+}

package/src/whatsapp-profile/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/whatsapp-profile/whatsapp-profile.controller.ts

@@ -0,0 +1,51 @@
+import { DeleteDTO, Role } from '@hed-hog/api';
+import { Pagination } from '@hed-hog/api-pagination';
+import {
+    Body,
+    Controller,
+    Delete,
+    Get,
+    Inject,
+    Param,
+    ParseIntPipe,
+    Patch,
+    Post,
+    forwardRef,
+} from '@nestjs/common';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { WhatsAppProfileService } from './whatsapp-profile.service';
+
+@Role()
+@Controller('whatsapp-profile')
+export class WhatsAppProfileController {
+  constructor(
+    @Inject(forwardRef(() => WhatsAppProfileService))
+    private readonly whatsappProfileService: WhatsAppProfileService,
+  ) {}
+
+  @Get()
+  async list(@Pagination() paginationParams) {
+    return this.whatsappProfileService.list(paginationParams);
+  }
+
+  @Get(':id')
+  async get(@Param('id', ParseIntPipe) id: number) {
+    return this.whatsappProfileService.get(id);
+  }
+
+  @Post()
+  async create(@Body() data: CreateDTO) {
+    return this.whatsappProfileService.create(data);
+  }
+
+  @Patch(':id')
+  async update(@Param('id', ParseIntPipe) id: number, @Body() data: UpdateDTO) {
+    return this.whatsappProfileService.update({ id, data });
+  }
+
+  @Delete()
+  async delete(@Body() data: DeleteDTO) {
+    return this.whatsappProfileService.delete(data);
+  }
+}

package/src/whatsapp-profile/whatsapp-profile.module.ts

@@ -0,0 +1,13 @@
+import { PaginationModule } from '@hed-hog/api-pagination';
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Module } from '@nestjs/common';
+import { WhatsAppProfileController } from './whatsapp-profile.controller';
+import { WhatsAppProfileService } from './whatsapp-profile.service';
+
+@Module({
+  imports: [forwardRef(() => PrismaModule), forwardRef(() => PaginationModule)],
+  controllers: [WhatsAppProfileController],
+  providers: [WhatsAppProfileService],
+  exports: [WhatsAppProfileService],
+})
+export class WhatsAppProfileModule {}

package/src/whatsapp-profile/whatsapp-profile.service.ts

@@ -0,0 +1,160 @@
+import { DeleteDTO } from '@hed-hog/api';
+import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+    BadRequestException,
+    Inject,
+    Injectable,
+    NotFoundException,
+    forwardRef,
+} from '@nestjs/common';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+
+@Injectable()
+export class WhatsAppProfileService {
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly paginationService: PaginationService,
+  ) {}
+
+  async list(paginationParams: PaginationDTO) {
+    const fields = ['slug', 'name', 'host', 'instance_name'];
+    const OR = this.prismaService.createInsensitiveSearch(fields, paginationParams);
+
+    return this.paginationService.paginate(
+      this.prismaService.whatsapp_profile,
+      paginationParams,
+      {
+        where: OR.length > 0 ? { OR } : {},
+        select: {
+          id: true,
+          slug: true,
+          name: true,
+          provider: true,
+          host: true,
+          token: true,
+          instance_name: true,
+          created_at: true,
+          updated_at: true,
+        },
+        orderBy: [{ updated_at: 'desc' }, { id: 'desc' }],
+      },
+    );
+  }
+
+  async get(id: number) {
+    const profile = await this.prismaService.whatsapp_profile.findUnique({
+      where: { id },
+    });
+
+    if (!profile) {
+      throw new NotFoundException(`WhatsApp profile with id ${id} not found.`);
+    }
+
+    return profile;
+  }
+
+  async create(data: CreateDTO) {
+    await this.ensureSlugIsAvailable(data.slug);
+    this.validateProviderFields(data as unknown as Record<string, unknown>);
+
+    return this.prismaService.whatsapp_profile.create({
+      data: this.normalizeData(data as unknown as Record<string, unknown>) as any,
+    });
+  }
+
+  async update({ id, data }: { id: number; data: UpdateDTO }) {
+    const existing = await this.prismaService.whatsapp_profile.findUnique({
+      where: { id },
+    });
+
+    if (!existing) {
+      throw new NotFoundException(`WhatsApp profile with id ${id} not found.`);
+    }
+
+    if (data.slug && data.slug !== existing.slug) {
+      await this.ensureSlugIsAvailable(data.slug);
+    }
+
+    const merged = {
+      ...existing,
+      ...data,
+    } satisfies Record<string, unknown>;
+
+    this.validateProviderFields(merged);
+
+    return this.prismaService.whatsapp_profile.update({
+      where: { id },
+      data: this.normalizeData(merged) as any,
+    });
+  }
+
+  async delete({ ids }: DeleteDTO): Promise<{ count: number }> {
+    if (!ids?.length) {
+      throw new BadRequestException('You must select at least one item to delete.');
+    }
+
+    return this.prismaService.whatsapp_profile.deleteMany({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+    });
+  }
+
+  private async ensureSlugIsAvailable(slug: string) {
+    const existing = await this.prismaService.whatsapp_profile.findUnique({
+      where: { slug },
+      select: { id: true },
+    });
+
+    if (existing) {
+      throw new BadRequestException(
+        `WhatsApp profile with slug "${slug}" already exists.`,
+      );
+    }
+  }
+
+  private validateProviderFields(input: Record<string, unknown>) {
+    const provider = String(input.provider ?? '').toUpperCase();
+
+    if (!provider) {
+      throw new BadRequestException('Provider is required.');
+    }
+
+    if (provider !== 'WHATSAPP_API') {
+      throw new BadRequestException(`Invalid provider: ${provider}`);
+    }
+
+    if (!String(input.host ?? '').trim()) {
+      throw new BadRequestException('WhatsApp host is required.');
+    }
+
+    if (!String(input.token ?? '').trim()) {
+      throw new BadRequestException('WhatsApp token is required.');
+    }
+
+    if (!String(input.instance_name ?? '').trim()) {
+      throw new BadRequestException('WhatsApp instance name is required.');
+    }
+  }
+
+  private normalizeData(input: Record<string, unknown>) {
+    return {
+      slug: this.normalizeString(input.slug),
+      name: this.normalizeString(input.name),
+      provider: 'WHATSAPP_API',
+      host: this.normalizeString(input.host),
+      token: this.normalizeString(input.token),
+      instance_name: this.normalizeString(input.instance_name),
+    };
+  }
+
+  private normalizeString(value: unknown) {
+    return String(value ?? '').trim();
+  }
+}