@hed-hog/core 0.0.356 → 0.0.359

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

@@ -1,160 +0,0 @@
-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();
-  }
-}