@hed-hog/contact 0.0.301 → 0.0.302

package/src/person/person.service.ts

@@ -4,39 +4,40 @@ import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
 import { Prisma, PrismaService } from '@hed-hog/api-prisma';
 import { FileService, SettingService } from '@hed-hog/core';
 import {
-  BadRequestException,
-  Inject,
-  Injectable,
-  NotFoundException,
-  forwardRef,
+    BadRequestException,
+    Inject,
+    Injectable,
+    Logger,
+    NotFoundException,
+    forwardRef,
 } from '@nestjs/common';
 import {
-  ACCOUNT_LIFECYCLE_STAGES,
-  type AccountLifecycleStage,
-  type CreateAccountDTO,
-  type UpdateAccountDTO,
+    ACCOUNT_LIFECYCLE_STAGES,
+    type AccountLifecycleStage,
+    type CreateAccountDTO,
+    type UpdateAccountDTO,
 } from './dto/account.dto';
 import {
-  type ActivityListQueryDTO,
-  type CrmActivityPriority,
-  type CrmActivitySourceKind,
-  type CrmActivityStatus,
-  type CrmActivityType,
+    type ActivityListQueryDTO,
+    type CrmActivityPriority,
+    type CrmActivitySourceKind,
+    type CrmActivityStatus,
+    type CrmActivityType,
 } from './dto/activity.dto';
 import { CreateFollowupDTO } from './dto/create-followup.dto';
 import {
-  CreateInteractionDTO,
-  PersonInteractionTypeDTO,
+    CreateInteractionDTO,
+    PersonInteractionTypeDTO,
 } from './dto/create-interaction.dto';
 import { CreateDTO } from './dto/create.dto';
 import {
-  type CrmDashboardPeriod,
-  type DashboardQueryDTO,
+    type CrmDashboardPeriod,
+    type DashboardQueryDTO,
 } from './dto/dashboard-query.dto';
 import { CheckPersonDuplicatesQueryDTO } from './dto/duplicates-query.dto';
 import {
-  FollowupListQueryDTO,
-  FollowupStatsQueryDTO,
+    FollowupListQueryDTO,
+    FollowupStatsQueryDTO,
 } from './dto/followup-query.dto';
 import { MergePersonDTO } from './dto/merge.dto';
 import { ReportsQueryDTO, type CrmReportGroupBy } from './dto/reports-query.dto';
@@ -286,6 +287,8 @@ type CrmReportPayload = {
 
 @Injectable()
 export class PersonService {
+  private readonly logger = new Logger(PersonService.name);
+
   constructor(
     @Inject(forwardRef(() => PrismaService))
     private readonly prismaService: PrismaService,
@@ -2055,17 +2058,17 @@ export class PersonService {
         LIFECYCLE_STAGE_METADATA_KEY,
         data.lifecycle_stage,
       );
-
-      if (nextLifecycleStage && currentLifecycleStage !== nextLifecycleStage) {
-        await this.registerStageTransition(tx, {
-          personId: person.id,
-          fromStage: currentLifecycleStage,
-          toStage: nextLifecycleStage,
-          changedByUserId: actorUserId,
-        });
-      }
     });
 
+    if (nextLifecycleStage && currentLifecycleStage !== nextLifecycleStage) {
+      await this.registerStageTransitionSafely(this.prismaService, {
+        personId: person.id,
+        fromStage: currentLifecycleStage,
+        toStage: nextLifecycleStage,
+        changedByUserId: actorUserId,
+      });
+    }
+
     return {
       success: true,
       lifecycle_stage: data.lifecycle_stage,
@@ -2137,6 +2140,15 @@ export class PersonService {
 
     const currentLifecycleStage = await this.getPersonLifecycleStage(id);
     const nextLifecycleStage = this.normalizeTextOrNull(data.lifecycle_stage);
+    const stageTransitionParams =
+      nextLifecycleStage && currentLifecycleStage !== nextLifecycleStage
+        ? {
+            personId: id,
+            fromStage: currentLifecycleStage,
+            toStage: nextLifecycleStage,
+            changedByUserId: this.coerceNumber(user?.id) || null,
+          }
+        : null;
 
     const incomingContacts = Array.isArray(data.contacts) ? data.contacts : [];
     const incomingAddresses = Array.isArray(data.addresses) ? data.addresses : [];
@@ -2182,18 +2194,16 @@ export class PersonService {
         await this.syncAddresses(tx, id, incomingAddresses, locale);
         await this.syncDocuments(tx, id, incomingDocuments);
 
-        if (nextLifecycleStage && currentLifecycleStage !== nextLifecycleStage) {
-          await this.registerStageTransition(tx, {
-            personId: id,
-            fromStage: currentLifecycleStage,
-            toStage: nextLifecycleStage,
-            changedByUserId: this.coerceNumber(user?.id) || null,
-          });
-        }
-
         return { success: true };
       })
       .then(async (result) => {
+        if (stageTransitionParams) {
+          await this.registerStageTransitionSafely(
+            this.prismaService,
+            stageTransitionParams,
+          );
+        }
+
         await this.cleanupReplacedAvatar(locale, person.avatar_id, data.avatar_id);
         return result;
       });
@@ -3068,8 +3078,28 @@ export class PersonService {
     return this.metadataToString(metadata?.value) ?? 'new';
   }
 
+  private async registerStageTransitionSafely(
+    client: any,
+    params: {
+      personId: number;
+      fromStage: string | null;
+      toStage: string;
+      changedByUserId: number | null;
+    },
+  ) {
+    try {
+      await this.registerStageTransition(client, params);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+
+      this.logger.warn(
+        `Failed to persist CRM stage history for person ${params.personId} (${params.fromStage ?? 'null'} -> ${params.toStage}). Continuing without audit entry. Reason: ${reason}`,
+      );
+    }
+  }
+
   private async registerStageTransition(
-    tx: any,
+    client: any,
     {
       personId,
       fromStage,
@@ -3086,32 +3116,15 @@ export class PersonService {
       return;
     }
 
-    const fromStageSql = fromStage
-      ? Prisma.sql`CAST(${fromStage} AS crm_stage_history_from_stage_enum)`
-      : Prisma.sql`NULL`;
-
-    await tx.$executeRaw(
-      Prisma.sql`
-        INSERT INTO crm_stage_history (
-          person_id,
-          from_stage,
-          to_stage,
-          changed_by_user_id,
-          changed_at,
-          created_at,
-          updated_at
-        )
-        VALUES (
-          ${personId},
-          ${fromStageSql},
-          CAST(${toStage} AS crm_stage_history_to_stage_enum),
-          ${changedByUserId},
-          NOW(),
-          NOW(),
-          NOW()
-        )
-      `,
-    );
+    await client.crm_stage_history.create({
+      data: {
+        person_id: personId,
+        from_stage: fromStage ?? null,
+        to_stage: toStage,
+        changed_by_user_id: changedByUserId,
+        changed_at: new Date(),
+      },
+    });
   }
 
   private async syncPersonSubtypeData(
@@ -4047,69 +4060,59 @@ export class PersonService {
       actorUserId: number | null;
     },
   ) {
-    const existingRows = (await tx.$queryRaw(
-      Prisma.sql`
-        SELECT id
-        FROM crm_activity
-        WHERE person_id = ${personId}
-          AND source_kind = 'followup'
-          AND completed_at IS NULL
-        ORDER BY id DESC
-        LIMIT 1
-      `,
-    )) as Array<{ id: number }>;
-    const existing = existingRows[0];
+    const existing = await tx.crm_activity.findFirst({
+      where: {
+        person_id: personId,
+        source_kind: 'followup',
+        completed_at: null,
+      },
+      orderBy: {
+        id: 'desc',
+      },
+    });
 
     const normalizedNotes = this.normalizeTextOrNull(notes);
+    const subject = this.getFollowupActivitySubject();
+    const dueAtDate = new Date(dueAt);
+    const priority: CrmActivityPriority = 'medium';
+    const type: CrmActivityType = 'task';
 
     if (existing) {
-      await tx.$executeRaw(
-        Prisma.sql`
-          UPDATE crm_activity
-          SET
-            owner_user_id = ${ownerUserId},
-            type = CAST(${'task'} AS crm_activity_type_enum),
-            subject = ${this.getFollowupActivitySubject()},
-            notes = ${normalizedNotes},
-            due_at = CAST(${dueAt} AS TIMESTAMPTZ),
-            priority = CAST(${'medium'} AS crm_activity_priority_enum),
-            updated_at = NOW()
-          WHERE id = ${existing.id}
-        `,
-      );
-      return;
-    }
-
-    await tx.$executeRaw(
-      Prisma.sql`
-        INSERT INTO crm_activity (
-          person_id,
-          owner_user_id,
-          created_by_user_id,
+      await tx.crm_activity.update({
+        where: {
+          id: existing.id,
+        },
+        data: {
+          owner_user_id: ownerUserId,
           type,
           subject,
-          notes,
-          due_at,
+          notes: normalizedNotes,
+          due_at: dueAtDate,
           priority,
-          source_kind,
-          created_at,
-          updated_at
-        )
-        VALUES (
-          ${personId},
-          ${ownerUserId},
-          ${actorUserId},
-          CAST(${'task'} AS crm_activity_type_enum),
-          ${this.getFollowupActivitySubject()},
-          ${normalizedNotes},
-          CAST(${dueAt} AS TIMESTAMPTZ),
-          CAST(${'medium'} AS crm_activity_priority_enum),
-          CAST(${'followup'} AS crm_activity_source_kind_enum),
-          NOW(),
-          NOW()
-        )
-      `,
-    );
+          updated_at: new Date(),
+        },
+      });
+      return;
+    }
+
+    const sourceKind: CrmActivitySourceKind = 'followup';
+    const now = new Date();
+
+    await tx.crm_activity.create({
+      data: {
+        person_id: personId,
+        owner_user_id: ownerUserId,
+        created_by_user_id: actorUserId,
+        type,
+        subject,
+        notes: normalizedNotes,
+        due_at: dueAtDate,
+        priority,
+        source_kind: sourceKind,
+        created_at: now,
+        updated_at: now,
+      },
+    });
   }
 
   private async createCompletedInteractionActivity(
@@ -4127,41 +4130,27 @@ export class PersonService {
     },
   ) {
     const completedAt = new Date(interaction.created_at);
+    const type: CrmActivityType = interaction.type;
+    const priority: CrmActivityPriority = 'medium';
+    const sourceKind: CrmActivitySourceKind = 'interaction';
 
-    await tx.$executeRaw(
-      Prisma.sql`
-        INSERT INTO crm_activity (
-          person_id,
-          owner_user_id,
-          created_by_user_id,
-          completed_by_user_id,
-          type,
-          subject,
-          notes,
-          due_at,
-          completed_at,
-          priority,
-          source_kind,
-          created_at,
-          updated_at
-        )
-        VALUES (
-          ${personId},
-          ${ownerUserId},
-          ${actorUserId},
-          ${actorUserId},
-          CAST(${interaction.type} AS crm_activity_type_enum),
-          ${this.getInteractionActivitySubject(interaction.type)},
-          ${this.normalizeTextOrNull(interaction.notes)},
-          CAST(${interaction.created_at} AS TIMESTAMPTZ),
-          CAST(${interaction.created_at} AS TIMESTAMPTZ),
-          CAST(${'medium'} AS crm_activity_priority_enum),
-          CAST(${'interaction'} AS crm_activity_source_kind_enum),
-          CAST(${interaction.created_at} AS TIMESTAMPTZ),
-          NOW()
-        )
-      `,
-    );
+    await tx.crm_activity.create({
+      data: {
+        person_id: personId,
+        owner_user_id: ownerUserId,
+        created_by_user_id: actorUserId,
+        completed_by_user_id: actorUserId,
+        type,
+        subject: this.getInteractionActivitySubject(interaction.type),
+        notes: this.normalizeTextOrNull(interaction.notes),
+        due_at: completedAt,
+        completed_at: completedAt,
+        priority,
+        source_kind: sourceKind,
+        created_at: completedAt,
+        updated_at: new Date(),
+      },
+    });
   }
 
   private getFollowupActivitySubject() {
@@ -4494,7 +4483,7 @@ export class PersonService {
 
     if (lifecycleStage && lifecycleStage !== 'all') {
       filters.push(
-        Prisma.sql`AND pc.account_lifecycle_stage = CAST(${lifecycleStage} AS person_company_account_lifecycle_stage_enum)`,
+        Prisma.sql`AND pc.account_lifecycle_stage = ${lifecycleStage}`,
       );
     }
 
@@ -4602,12 +4591,12 @@ export class PersonService {
     }
 
     if (type && type !== 'all') {
-      filters.push(Prisma.sql`AND a.type = CAST(${type} AS crm_activity_type_enum)`);
+      filters.push(Prisma.sql`AND a.type = ${type}`);
     }
 
     if (priority && priority !== 'all') {
       filters.push(
-        Prisma.sql`AND a.priority = CAST(${priority} AS crm_activity_priority_enum)`,
+        Prisma.sql`AND a.priority = ${priority}`,
       );
     }
 

package/src/proposal/proposal.service.spec.ts

@@ -0,0 +1,196 @@
+/// <reference types="jest" />
+import { ProposalService } from './proposal.service';
+
+describe('ProposalService regression coverage', () => {
+  let prisma: any;
+  let service: ProposalService;
+
+  beforeEach(() => {
+    prisma = {
+      proposal: {
+        findMany: jest.fn().mockImplementation(({ include }) => {
+          if (
+            include?.person?.select?.trade_name ||
+            include?.person?.select?.email ||
+            include?.person?.select?.phone
+          ) {
+            throw new Error(
+              'Unknown field selected directly on model `person`.',
+            );
+          }
+
+          return Promise.resolve([
+            {
+              id: 101,
+              person_id: 8,
+              person: {
+                id: 8,
+                name: 'Ana Cliente',
+                email: 'contato@cliente.test',
+                phone: '+55 11 99999-0000',
+              },
+              proposal_revision: [],
+            },
+          ]);
+        }),
+        count: jest.fn().mockResolvedValue(1),
+        aggregate: jest.fn().mockResolvedValue({
+          _sum: {
+            total_amount_cents: 0,
+          },
+        }),
+      },
+      person_company: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: 8,
+            trade_name: 'Cliente SA',
+          },
+        ]),
+      },
+      contact: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: 1,
+            person_id: 8,
+            value: 'contato@cliente.test',
+            is_primary: true,
+            contact_type: {
+              code: 'EMAIL',
+            },
+          },
+          {
+            id: 2,
+            person_id: 8,
+            value: '+55 11 99999-0000',
+            is_primary: true,
+            contact_type: {
+              code: 'PHONE',
+            },
+          },
+        ]),
+      },
+      document: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: 3,
+            person_id: 8,
+            value: '12.345.678/0001-90',
+          },
+        ]),
+      },
+      person_metadata: {
+        findFirst: jest.fn().mockResolvedValue(null),
+        update: jest.fn().mockResolvedValue(null),
+        create: jest.fn().mockResolvedValue(null),
+        delete: jest.fn().mockResolvedValue(null),
+      },
+      $transaction: jest.fn(),
+    };
+
+    service = new ProposalService(
+      prisma,
+      {
+        findLinksBySource: jest.fn(),
+        publishEvent: jest.fn(),
+      } as any,
+      {
+        upload: jest.fn(),
+      } as any,
+      {
+        getSettingValues: jest.fn(),
+      } as any,
+    );
+  });
+
+  it('lists proposals without selecting a missing person.trade_name column', async () => {
+    const result = await service.list({
+      search: 'cliente',
+      take: 20,
+      skip: 0,
+      pageSize: 20,
+    } as any);
+
+    expect(prisma.proposal.findMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        include: expect.objectContaining({
+          person: expect.objectContaining({
+            select: expect.not.objectContaining({
+              trade_name: true,
+            }),
+          }),
+        }),
+      }),
+    );
+    expect(prisma.person_company.findMany).toHaveBeenCalledWith({
+      where: {
+        id: {
+          in: [8],
+        },
+      },
+      select: {
+        id: true,
+        trade_name: true,
+      },
+    });
+    expect(prisma.contact.findMany).toHaveBeenCalled();
+    expect(prisma.document.findMany).toHaveBeenCalled();
+    expect(result.data).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          person: expect.objectContaining({
+            trade_name: 'Cliente SA',
+            email: 'contato@cliente.test',
+            phone: '+55 11 99999-0000',
+            document: '12.345.678/0001-90',
+          }),
+        }),
+      ]),
+    );
+  });
+
+  it('syncs person deal value metadata from approved and converted proposal totals', async () => {
+    prisma.proposal.aggregate.mockResolvedValue({
+      _sum: {
+        total_amount_cents: 125050,
+      },
+    });
+    prisma.person_metadata.findFirst.mockResolvedValue({ id: 77 });
+
+    await (service as any).syncPersonDealValueFromApprovedProposals(prisma, 8);
+
+    expect(prisma.proposal.aggregate).toHaveBeenCalledWith({
+      where: {
+        deleted_at: null,
+        person_id: 8,
+        status: {
+          in: ['approved', 'contract_generated'],
+        },
+      },
+      _sum: {
+        total_amount_cents: true,
+      },
+    });
+    expect(prisma.person_metadata.update).toHaveBeenCalledWith({
+      where: { id: 77 },
+      data: { value: '1250.50' },
+    });
+  });
+
+  it('clears person deal value metadata when there are no approved proposals left', async () => {
+    prisma.proposal.aggregate.mockResolvedValue({
+      _sum: {
+        total_amount_cents: 0,
+      },
+    });
+    prisma.person_metadata.findFirst.mockResolvedValue({ id: 88 });
+
+    await (service as any).syncPersonDealValueFromApprovedProposals(prisma, 8);
+
+    expect(prisma.person_metadata.delete).toHaveBeenCalledWith({
+      where: { id: 88 },
+    });
+    expect(prisma.person_metadata.create).not.toHaveBeenCalled();
+    expect(prisma.person_metadata.update).not.toHaveBeenCalled();
+  });
+});