@hed-hog/operations 0.0.299 → 0.0.301

package/src/operations.proposal.subscriber.ts

@@ -0,0 +1,86 @@
+import {
+    IntegrationDeveloperApiService,
+    LinkType,
+} from '@hed-hog/core';
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
+import { OperationsService } from './operations.service';
+
+@Injectable()
+export class OperationsProposalSubscriber implements OnModuleInit {
+  private readonly logger = new Logger(OperationsProposalSubscriber.name);
+
+  constructor(
+    private readonly integrationApi: IntegrationDeveloperApiService,
+    private readonly operationsService: OperationsService,
+  ) {}
+
+  onModuleInit(): void {
+    const handler = async (event) => {
+      const payload = (event.payload || {}) as {
+        proposalId?: number;
+      };
+      const sourceEntityType =
+        String(event.aggregateType || '').trim() || 'proposal';
+      const sourceEntityId =
+        String(payload.proposalId || event.aggregateId || '').trim() ||
+        event.aggregateId;
+
+      if (!sourceEntityId) {
+        throw new Error(`Missing proposal aggregate id for ${event.eventName}.`);
+      }
+
+      const existingLinks = await this.integrationApi.findLinksBySource({
+        module: event.sourceModule,
+        entityType: sourceEntityType,
+        entityId: sourceEntityId,
+      });
+
+      const alreadyLinked = existingLinks.some(
+        (link) =>
+          link.targetModule === 'operations' &&
+          link.targetEntityType === 'contract',
+      );
+
+      if (alreadyLinked) {
+        this.logger.debug(
+          `Skipping duplicate contract generation for ${sourceEntityType}:${sourceEntityId} from ${event.eventName}`,
+        );
+        return;
+      }
+
+      const createdContract =
+        await this.operationsService.createContractFromProposalIntegration(
+          event.payload || {},
+        );
+
+      await this.integrationApi.createLink({
+        sourceModule: event.sourceModule,
+        sourceEntityType,
+        sourceEntityId,
+        targetModule: 'operations',
+        targetEntityType: 'contract',
+        targetEntityId: String(createdContract.id),
+        linkType: LinkType.REFERENCE,
+        metadata: {
+          eventName: event.eventName,
+          contractCode: createdContract.code,
+        },
+      });
+    };
+
+    this.integrationApi.subscribeMany([
+      {
+        eventName: 'contact.proposal.convert_requested',
+        consumerName: 'operations.contract-from-proposal',
+        priority: 10,
+        handler,
+      },
+      {
+        eventName: 'contact.proposal.approved',
+        consumerName: 'operations.contract-from-proposal-legacy',
+        priority: 5,
+        handler,
+      },
+    ]);
+  }
+}

package/src/operations.service.spec.ts

@@ -0,0 +1,210 @@
+/// <reference types="jest" />
+
+import { BadRequestException } from '@nestjs/common';
+import { OperationsService } from './operations.service';
+
+describe('OperationsService proposal integration', () => {
+  let service: OperationsService;
+  let prisma: { $transaction: jest.Mock };
+  let integrationApi: { publishEvent: jest.Mock };
+
+  beforeEach(() => {
+    prisma = {
+      $transaction: jest.fn(),
+    };
+
+    integrationApi = {
+      publishEvent: jest.fn().mockResolvedValue(undefined),
+    };
+
+    service = new OperationsService(
+      prisma as any,
+      {} as any,
+      integrationApi as any,
+      {} as any,
+      {} as any,
+    );
+
+    jest.spyOn(service as any, 'generateContractCode').mockResolvedValue('CTR-001');
+    jest.spyOn(service as any, 'replaceContractParties').mockResolvedValue(undefined);
+    jest
+      .spyOn(service as any, 'replaceContractFinancialTerms')
+      .mockResolvedValue(undefined);
+    jest.spyOn(service as any, 'replaceContractRevisions').mockResolvedValue(undefined);
+    jest.spyOn(service as any, 'insertContractHistory').mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('throws when proposalId is missing', async () => {
+    await expect(
+      service.createContractFromProposalIntegration({}),
+    ).rejects.toThrow(BadRequestException);
+  });
+
+  it('returns the existing contract when the CRM proposal was already converted', async () => {
+    const tx = {
+      $queryRawUnsafe: jest
+        .fn()
+        .mockResolvedValueOnce([])
+        .mockResolvedValueOnce([{ id: 42, code: 'CTR-EXISTING' }]),
+    };
+
+    prisma.$transaction.mockImplementation(async (callback: (client: unknown) => unknown) =>
+      callback(tx),
+    );
+
+    const result = await service.createContractFromProposalIntegration({
+      proposalId: 1001,
+      title: 'Already converted proposal',
+    });
+
+    expect(result).toEqual({
+      id: 42,
+      code: 'CTR-EXISTING',
+    });
+    expect((service as any).generateContractCode).not.toHaveBeenCalled();
+    expect((service as any).replaceContractParties).not.toHaveBeenCalled();
+    expect(integrationApi.publishEvent).not.toHaveBeenCalled();
+  });
+
+  it('creates a draft contract with CRM origin metadata and emits an event', async () => {
+    const tx = {
+      $queryRawUnsafe: jest
+        .fn()
+        .mockResolvedValueOnce([])
+        .mockResolvedValueOnce([])
+        .mockResolvedValueOnce([{ id: 77 }]),
+    };
+
+    prisma.$transaction.mockImplementation(async (callback: (client: unknown) => unknown) =>
+      callback(tx),
+    );
+
+    const payload = {
+      proposalId: 1001,
+      proposalRevisionId: 21,
+      personId: 5,
+      approvedByUserId: 9,
+      correlationId: 'proposal:1001',
+      code: 'P-1001',
+      title: 'Implementation Proposal',
+      total: 1234,
+      currency: 'USD',
+      locale: 'en',
+      commercialTerms: {
+        contractCategory: 'client' as const,
+        contractType: 'service_agreement' as const,
+        billingModel: 'monthly_retainer' as const,
+        validFrom: '2025-01-10',
+        validUntil: '2025-12-31',
+        notes: 'Annual support agreement',
+      },
+      person: {
+        id: 5,
+        name: 'Acme Contact',
+        tradeName: 'Acme Ltd',
+        email: 'ops@acme.test',
+        phone: '555-0100',
+        document: '12.345.678/0001-90',
+      },
+      revision: {
+        id: 21,
+        title: 'Revision 1',
+        summary: 'Approved commercial terms',
+        contentHtml: '<p>draft</p>',
+      },
+      items: [
+        {
+          name: 'Monthly retainer',
+          description: 'Support hours',
+          amount: 1000,
+          recurrence: 'monthly' as const,
+        },
+        {
+          name: 'Setup fee',
+          amount: 234,
+          recurrence: 'one_time' as const,
+        },
+      ],
+    };
+
+    const result = await service.createContractFromProposalIntegration(payload);
+
+    expect(result).toEqual({
+      id: 77,
+      code: 'CTR-001',
+    });
+
+    const insertCall = tx.$queryRawUnsafe.mock.calls[2];
+    expect(insertCall[0]).toContain('INSERT INTO operations_contract');
+    expect(insertCall).toContain('crm_proposal');
+    expect(insertCall).toContain('1001');
+
+    expect((service as any).replaceContractParties).toHaveBeenCalledWith(
+      tx,
+      77,
+      [
+        expect.objectContaining({
+          partyRole: 'client',
+          displayName: 'Acme Ltd',
+          isPrimary: true,
+        }),
+      ],
+    );
+    expect((service as any).replaceContractFinancialTerms).toHaveBeenCalledWith(
+      tx,
+      77,
+      expect.arrayContaining([
+        expect.objectContaining({
+          label: 'Monthly retainer',
+          amount: 1000,
+          recurrence: 'monthly',
+        }),
+        expect.objectContaining({
+          label: 'Setup fee',
+          amount: 234,
+          recurrence: 'one_time',
+        }),
+      ]),
+    );
+    expect((service as any).replaceContractRevisions).toHaveBeenCalledWith(
+      tx,
+      77,
+      [
+        expect.objectContaining({
+          title: 'Revision 1',
+          status: 'draft',
+        }),
+      ],
+    );
+    expect((service as any).insertContractHistory).toHaveBeenCalledWith(
+      tx,
+      77,
+      9,
+      'created',
+      'Draft contract generated from CRM proposal P-1001.',
+      expect.any(String),
+    );
+
+    expect(integrationApi.publishEvent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        eventName: 'operations.contract.created',
+        payload: expect.objectContaining({
+          proposalId: 1001,
+          contract: expect.objectContaining({
+            id: 77,
+            originType: 'crm_proposal',
+            originId: '1001',
+            contractType: 'service_agreement',
+          }),
+        }),
+      }),
+      expect.objectContaining({
+        persistenceClient: tx,
+      }),
+    );
+  });
+});