@hed-hog/operations 0.0.330 → 0.0.332

package/dist/operations.service.spec.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const common_1 = require("@nestjs/common");
 const operations_service_1 = require("./operations.service");
 const operations_access_service_1 = require("./services/shared/operations-access.service");
-describe('OperationsService proposal integration', () => {
+describe("OperationsService proposal integration", () => {
     let service;
     let prisma;
     let integrationApi;
@@ -16,37 +16,43 @@ describe('OperationsService proposal integration', () => {
             publishEvent: jest.fn().mockResolvedValue(undefined),
         };
         service = new operations_service_1.OperationsService(prisma, {}, integrationApi, {}, {}, new operations_access_service_1.OperationsAccessService());
-        jest.spyOn(service, 'generateContractCode').mockResolvedValue('CTR-001');
-        jest.spyOn(service, 'replaceContractParties').mockResolvedValue(undefined);
-        jest.spyOn(service, 'insertContractHistory').mockResolvedValue(undefined);
+        jest
+            .spyOn(service, "generateContractCode")
+            .mockResolvedValue("CTR-001");
+        jest
+            .spyOn(service, "replaceContractParties")
+            .mockResolvedValue(undefined);
+        jest
+            .spyOn(service, "insertContractHistory")
+            .mockResolvedValue(undefined);
     });
     afterEach(() => {
         jest.restoreAllMocks();
     });
-    it('throws when proposalId is missing', async () => {
+    it("throws when proposalId is missing", async () => {
         await expect(service.createContractFromProposalIntegration({})).rejects.toThrow(common_1.BadRequestException);
     });
-    it('returns the existing contract when the CRM proposal was already converted', async () => {
+    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' }]),
+                .mockResolvedValueOnce([{ id: 42, code: "CTR-EXISTING" }]),
         };
         prisma.$transaction.mockImplementation(async (callback) => callback(tx));
         const result = await service.createContractFromProposalIntegration({
             proposalId: 1001,
-            title: 'Already converted proposal',
+            title: "Already converted proposal",
         });
         expect(result).toEqual({
             id: 42,
-            code: 'CTR-EXISTING',
+            code: "CTR-EXISTING",
         });
         expect(service.generateContractCode).not.toHaveBeenCalled();
         expect(service.replaceContractParties).not.toHaveBeenCalled();
         expect(integrationApi.publishEvent).not.toHaveBeenCalled();
     });
-    it('creates a draft contract with CRM origin metadata and emits an event', async () => {
+    it("creates a draft contract with CRM origin metadata and emits an event", async () => {
         const tx = {
             $queryRawUnsafe: jest
                 .fn()
@@ -60,74 +66,74 @@ describe('OperationsService proposal integration', () => {
             proposalRevisionId: 21,
             personId: 5,
             approvedByUserId: 9,
-            correlationId: 'proposal:1001',
-            code: 'P-1001',
-            title: 'Implementation Proposal',
+            correlationId: "proposal:1001",
+            code: "P-1001",
+            title: "Implementation Proposal",
             total: 1234,
-            currency: 'USD',
-            locale: 'en',
+            currency: "USD",
+            locale: "en",
             commercialTerms: {
-                contractCategory: 'client',
-                contractType: 'service_agreement',
-                billingModel: 'monthly_retainer',
-                validFrom: '2025-01-10',
-                validUntil: '2025-12-31',
-                notes: 'Annual support agreement',
+                contractCategory: "client",
+                contractType: "service_agreement",
+                billingModel: "monthly_retainer",
+                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',
+                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>',
+                title: "Revision 1",
+                summary: "Approved commercial terms",
+                contentHtml: "<p>draft</p>",
             },
             items: [
                 {
-                    name: 'Monthly retainer',
-                    description: 'Support hours',
+                    name: "Monthly retainer",
+                    description: "Support hours",
                     amount: 1000,
-                    recurrence: 'monthly',
+                    recurrence: "monthly",
                 },
                 {
-                    name: 'Setup fee',
+                    name: "Setup fee",
                     amount: 234,
-                    recurrence: 'one_time',
+                    recurrence: "one_time",
                 },
             ],
         };
         const result = await service.createContractFromProposalIntegration(payload);
         expect(result).toEqual({
             id: 77,
-            code: 'CTR-001',
+            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(insertCall[0]).toContain("INSERT INTO operations_contract");
+        expect(insertCall).toContain("crm_proposal");
+        expect(insertCall).toContain("1001");
         expect(service.replaceContractParties).toHaveBeenCalledWith(tx, 77, [
             expect.objectContaining({
-                partyRole: 'client',
-                displayName: 'Acme Ltd',
+                partyRole: "client",
+                displayName: "Acme Ltd",
                 isPrimary: true,
             }),
         ]);
-        expect(service.insertContractHistory).toHaveBeenCalledWith(tx, 77, 9, 'created', 'Draft contract generated from CRM proposal P-1001.', expect.any(String));
+        expect(service.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',
+            eventName: "operations.contract.created",
             payload: expect.objectContaining({
                 proposalId: 1001,
                 contract: expect.objectContaining({
                     id: 77,
-                    originType: 'crm_proposal',
-                    originId: '1001',
-                    contractType: 'service_agreement',
+                    originType: "crm_proposal",
+                    originId: "1001",
+                    contractType: "service_agreement",
                 }),
             }),
         }), expect.objectContaining({
@@ -135,7 +141,7 @@ describe('OperationsService proposal integration', () => {
         }));
     });
 });
-describe('OperationsService quick-entry timesheets', () => {
+describe("OperationsService quick-entry timesheets", () => {
     let service;
     beforeEach(() => {
         service = new operations_service_1.OperationsService({
@@ -143,11 +149,11 @@ describe('OperationsService quick-entry timesheets', () => {
         }, {}, {
             publishEvent: jest.fn().mockResolvedValue(undefined),
         }, {}, {}, new operations_access_service_1.OperationsAccessService());
-        jest.spyOn(service, 'getActorContext').mockResolvedValue({
+        jest.spyOn(service, "getActorContext").mockResolvedValue({
             userId: 15,
-            roleSlugs: ['operations-collaborator'],
+            roleSlugs: ["operations-collaborator"],
             collaboratorId: 7,
-            collaboratorName: 'Taylor Tester',
+            collaboratorName: "Taylor Tester",
             isDirector: false,
             isSupervisor: false,
             isCollaborator: true,
@@ -159,45 +165,55 @@ describe('OperationsService quick-entry timesheets', () => {
     afterEach(() => {
         jest.restoreAllMocks();
     });
-    it('rejects quick entries with non-positive duration', async () => {
+    it("rejects quick entries with non-positive duration", async () => {
         await expect(service.createTimesheetEntry(15, {
             projectId: 11,
-            workDate: '2026-04-09',
+            workDate: "2026-04-09",
             duration: 0,
-            unit: 'minutes',
+            unit: "minutes",
         })).rejects.toThrow(common_1.BadRequestException);
     });
-    it('rejects quick entries without a work date', async () => {
+    it("rejects quick entries without a work date", async () => {
         await expect(service.createTimesheetEntry(15, {
             projectId: 11,
             duration: 30,
-            unit: 'minutes',
+            unit: "minutes",
         })).rejects.toThrow(common_1.BadRequestException);
     });
-    it('stores quick-entry duration in minutes and keeps hours compatible', async () => {
+    it("stores quick-entry duration in minutes and keeps hours compatible", async () => {
         const tx = {
             $queryRawUnsafe: jest.fn().mockResolvedValue([{ id: 91 }]),
         };
         service.prisma.$transaction.mockImplementation(async (callback) => callback(tx));
-        jest.spyOn(service, 'resolveOwnedProjectAssignment').mockResolvedValue({
+        jest
+            .spyOn(service, "resolveOwnedProjectAssignment")
+            .mockResolvedValue({
             id: 33,
             projectId: 11,
-            projectName: 'Project Atlas',
-            projectCode: 'OPS-11',
-            roleLabel: 'Engineer',
+            projectName: "Project Atlas",
+            projectCode: "OPS-11",
+            roleLabel: "Engineer",
         });
-        jest.spyOn(service, 'getOwnedTaskRecord').mockResolvedValue({
+        jest.spyOn(service, "getOwnedTaskRecord").mockResolvedValue({
             id: 44,
-            name: 'Implement API',
+            name: "Implement API",
             projectAssignmentId: 33,
             projectId: 11,
-            projectName: 'Project Atlas',
-            projectCode: 'OPS-11',
+            projectName: "Project Atlas",
+            projectCode: "OPS-11",
         });
-        jest.spyOn(service, 'getOrCreateTimesheetForWorkDate').mockResolvedValue(55);
-        jest.spyOn(service, 'refreshTimesheetTotal').mockResolvedValue(undefined);
-        jest.spyOn(service, 'submitTimesheetForApproval').mockResolvedValue(undefined);
-        jest.spyOn(service, 'getTimesheetEntryByIdForActor').mockResolvedValue({
+        jest
+            .spyOn(service, "getOrCreateTimesheetForWorkDate")
+            .mockResolvedValue(55);
+        jest
+            .spyOn(service, "refreshTimesheetTotal")
+            .mockResolvedValue(undefined);
+        jest
+            .spyOn(service, "submitTimesheetForApproval")
+            .mockResolvedValue(undefined);
+        jest
+            .spyOn(service, "getTimesheetEntryByIdForActor")
+            .mockResolvedValue({
             id: 91,
             durationMinutes: 90,
             hours: 1.5,
@@ -205,58 +221,60 @@ describe('OperationsService quick-entry timesheets', () => {
         const result = await service.createTimesheetEntry(15, {
             projectId: 11,
             taskId: 44,
-            workDate: '2026-04-09',
+            workDate: "2026-04-09",
             duration: 1.5,
-            unit: 'hours',
-            description: 'Worked on the API layer',
+            unit: "hours",
+            description: "Worked on the API layer",
         });
         expect(result).toEqual(expect.objectContaining({
             id: 91,
             durationMinutes: 90,
             hours: 1.5,
         }));
-        expect(tx.$queryRawUnsafe).toHaveBeenCalledWith(expect.stringContaining('INSERT INTO operations_timesheet_entry'), 55, 33, 44, 'Implement API', '2026-04-09', 90, 1.5, 'Worked on the API layer');
+        expect(tx.$queryRawUnsafe).toHaveBeenCalledWith(expect.stringContaining("INSERT INTO operations_timesheet_entry"), 55, 33, 44, "Implement API", "2026-04-09", 90, 1.5, "Worked on the API layer");
         expect(service.submitTimesheetForApproval).toHaveBeenCalledWith(tx, 55, 7);
     });
-    it('uses the task assignment when full timesheet entries omit projectAssignmentId', async () => {
+    it("uses the task assignment when full timesheet entries omit projectAssignmentId", async () => {
         const tx = {
             $queryRawUnsafe: jest.fn().mockResolvedValue([{ id: 55 }]),
             $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
         };
         service.prisma.$transaction.mockImplementation(async (callback) => callback(tx));
-        jest.spyOn(service, 'getCollaboratorById').mockResolvedValue({
+        jest.spyOn(service, "getCollaboratorById").mockResolvedValue({
             id: 7,
             supervisorId: 18,
         });
-        jest.spyOn(service, 'getOwnedTaskRecord').mockResolvedValue({
+        jest.spyOn(service, "getOwnedTaskRecord").mockResolvedValue({
             id: 44,
-            name: 'Implement API',
+            name: "Implement API",
             projectAssignmentId: 33,
             projectId: 11,
-            projectName: 'Project Atlas',
-            projectCode: 'OPS-11',
+            projectName: "Project Atlas",
+            projectCode: "OPS-11",
         });
-        jest.spyOn(service, 'refreshTimesheetTotal').mockResolvedValue(undefined);
-        jest.spyOn(service, 'listSingleTimesheet').mockResolvedValue({
+        jest
+            .spyOn(service, "refreshTimesheetTotal")
+            .mockResolvedValue(undefined);
+        jest.spyOn(service, "listSingleTimesheet").mockResolvedValue({
             id: 55,
-            status: 'draft',
+            status: "draft",
         });
         await service.createTimesheet(15, {
-            weekStartDate: '2026-04-06',
-            weekEndDate: '2026-04-12',
+            weekStartDate: "2026-04-06",
+            weekEndDate: "2026-04-12",
             entries: [
                 {
                     taskId: 44,
-                    workDate: '2026-04-09',
+                    workDate: "2026-04-09",
                     duration: 2,
-                    unit: 'hours',
-                    description: 'Worked on the API layer',
+                    unit: "hours",
+                    description: "Worked on the API layer",
                 },
             ],
         });
-        expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(expect.stringContaining('INSERT INTO operations_timesheet_entry'), 55, 33, 44, 'Implement API', '2026-04-09', 120, 2, 'Worked on the API layer');
+        expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(expect.stringContaining("INSERT INTO operations_timesheet_entry"), 55, 33, 44, "Implement API", "2026-04-09", 120, 2, "Worked on the API layer");
     });
-    it('rejects submitting a timesheet without a resolved approver', async () => {
+    it("rejects submitting a timesheet without a resolved approver", async () => {
         const tx = {
             $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
             $queryRawUnsafe: jest
@@ -265,24 +283,24 @@ describe('OperationsService quick-entry timesheets', () => {
                 .mockResolvedValueOnce([{ exists: true }]),
         };
         service.prisma.$transaction.mockImplementation(async (callback) => callback(tx));
-        jest.spyOn(service, 'getTimesheetById').mockResolvedValue({
+        jest.spyOn(service, "getTimesheetById").mockResolvedValue({
             id: 55,
             collaboratorId: 7,
             approverCollaboratorId: null,
-            status: 'draft',
+            status: "draft",
         });
-        jest.spyOn(service, 'getCollaboratorById').mockResolvedValue({
+        jest.spyOn(service, "getCollaboratorById").mockResolvedValue({
             id: 7,
             supervisorId: null,
         });
-        jest.spyOn(service, 'listSingleTimesheet').mockResolvedValue({
+        jest.spyOn(service, "listSingleTimesheet").mockResolvedValue({
             id: 55,
-            status: 'submitted',
+            status: "submitted",
         });
         await expect(service.submitTimesheet(15, 55)).rejects.toThrow(common_1.BadRequestException);
         expect(tx.$executeRawUnsafe).not.toHaveBeenCalled();
     });
-    it('rejects submitting a timesheet without active entries', async () => {
+    it("rejects submitting a timesheet without active entries", async () => {
         const tx = {
             $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
             $queryRawUnsafe: jest
@@ -291,49 +309,54 @@ describe('OperationsService quick-entry timesheets', () => {
                 .mockResolvedValueOnce([{ exists: false }]),
         };
         service.prisma.$transaction.mockImplementation(async (callback) => callback(tx));
-        jest.spyOn(service, 'getTimesheetById').mockResolvedValue({
+        jest.spyOn(service, "getTimesheetById").mockResolvedValue({
             id: 56,
             collaboratorId: 7,
             approverCollaboratorId: 18,
-            status: 'draft',
+            status: "draft",
         });
-        jest.spyOn(service, 'getCollaboratorById').mockResolvedValue({
+        jest.spyOn(service, "getCollaboratorById").mockResolvedValue({
             id: 7,
             supervisorId: 18,
         });
-        jest.spyOn(service, 'listSingleTimesheet').mockResolvedValue({
+        jest.spyOn(service, "listSingleTimesheet").mockResolvedValue({
             id: 56,
-            status: 'submitted',
+            status: "submitted",
         });
         await expect(service.submitTimesheet(15, 56)).rejects.toThrow(common_1.BadRequestException);
         expect(tx.$executeRawUnsafe).not.toHaveBeenCalled();
     });
-    it('deletes only draft quick entries and refreshes the weekly total', async () => {
+    it("deletes only draft quick entries and refreshes the weekly total", async () => {
         const tx = {
             $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
+            $queryRawUnsafe: jest.fn().mockResolvedValue([]),
         };
         service.prisma.$transaction.mockImplementation(async (callback) => callback(tx));
-        jest.spyOn(service, 'getTimesheetEntryByIdForActor').mockResolvedValue({
+        jest
+            .spyOn(service, "getTimesheetEntryByIdForActor")
+            .mockResolvedValue({
             id: 91,
             timesheetId: 55,
             collaboratorId: 7,
-            status: 'draft',
+            status: "draft",
         });
-        jest.spyOn(service, 'refreshTimesheetTotal').mockResolvedValue(undefined);
+        jest
+            .spyOn(service, "refreshTimesheetTotal")
+            .mockResolvedValue(undefined);
         await expect(service.removeTimesheetEntry(15, 91)).resolves.toEqual({
             success: true,
         });
-        expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(expect.stringContaining('UPDATE operations_timesheet_entry'), 91);
+        expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(expect.stringContaining("UPDATE operations_timesheet_entry"), 91);
         expect(service.refreshTimesheetTotal).toHaveBeenCalledWith(tx, 55);
     });
-    it('updates quick entries and moves them to the correct weekly timesheet', async () => {
+    it("updates quick entries and moves them to the correct weekly timesheet", async () => {
         const tx = {
             $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
             $queryRawUnsafe: jest.fn().mockResolvedValue([]),
         };
         service.prisma.$transaction.mockImplementation(async (callback) => callback(tx));
         jest
-            .spyOn(service, 'getTimesheetEntryByIdForActor')
+            .spyOn(service, "getTimesheetEntryByIdForActor")
             .mockResolvedValueOnce({
             id: 93,
             timesheetId: 55,
@@ -341,10 +364,10 @@ describe('OperationsService quick-entry timesheets', () => {
             projectId: 11,
             projectAssignmentId: 33,
             taskId: 44,
-            status: 'draft',
-            weekStartDate: '2026-04-06',
-            weekEndDate: '2026-04-12',
-            workDate: '2026-04-09',
+            status: "draft",
+            weekStartDate: "2026-04-06",
+            weekEndDate: "2026-04-12",
+            workDate: "2026-04-09",
             hours: 1,
             durationMinutes: 60,
         })
@@ -355,80 +378,222 @@ describe('OperationsService quick-entry timesheets', () => {
             projectId: 12,
             projectAssignmentId: 34,
             taskId: 45,
-            status: 'draft',
-            weekStartDate: '2026-04-13',
-            weekEndDate: '2026-04-19',
-            workDate: '2026-04-14',
+            status: "draft",
+            weekStartDate: "2026-04-13",
+            weekEndDate: "2026-04-19",
+            workDate: "2026-04-14",
             hours: 2,
             durationMinutes: 120,
-            taskName: 'Review backlog',
+            taskName: "Review backlog",
         });
-        jest.spyOn(service, 'resolveOwnedProjectAssignment').mockResolvedValue({
+        jest
+            .spyOn(service, "resolveOwnedProjectAssignment")
+            .mockResolvedValue({
             id: 34,
             projectId: 12,
-            projectName: 'Project Boreal',
-            projectCode: 'OPS-12',
-            roleLabel: 'Engineer',
+            projectName: "Project Boreal",
+            projectCode: "OPS-12",
+            roleLabel: "Engineer",
         });
-        jest.spyOn(service, 'getOwnedTaskRecord').mockResolvedValue({
+        jest.spyOn(service, "getOwnedTaskRecord").mockResolvedValue({
             id: 45,
-            name: 'Review backlog',
+            name: "Review backlog",
             projectAssignmentId: 34,
             projectId: 12,
-            projectName: 'Project Boreal',
-            projectCode: 'OPS-12',
+            projectName: "Project Boreal",
+            projectCode: "OPS-12",
         });
-        jest.spyOn(service, 'getOrCreateTimesheetForWorkDate').mockResolvedValue(77);
-        jest.spyOn(service, 'refreshTimesheetTotal').mockResolvedValue(undefined);
-        jest.spyOn(service, 'cleanupEmptyEditableTimesheet').mockResolvedValue(undefined);
-        jest.spyOn(service, 'submitTimesheetForApproval').mockResolvedValue(undefined);
+        jest
+            .spyOn(service, "getOrCreateTimesheetForWorkDate")
+            .mockResolvedValue(77);
+        jest
+            .spyOn(service, "refreshTimesheetTotal")
+            .mockResolvedValue(undefined);
+        jest
+            .spyOn(service, "cleanupEmptyEditableTimesheet")
+            .mockResolvedValue(undefined);
+        jest
+            .spyOn(service, "submitTimesheetForApproval")
+            .mockResolvedValue(undefined);
         const result = await service.updateTimesheetEntry(15, 93, {
             projectId: 12,
             projectAssignmentId: 34,
             taskId: 45,
-            workDate: '2026-04-14',
+            workDate: "2026-04-14",
             duration: 2,
-            unit: 'hours',
-            description: 'Backlog refinement',
+            unit: "hours",
+            description: "Backlog refinement",
         });
         expect(result).toEqual(expect.objectContaining({
             id: 93,
             timesheetId: 77,
         }));
-        expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(expect.stringContaining('UPDATE operations_timesheet_entry'), 77, 34, 45, 'Review backlog', '2026-04-14', 120, 2, 'Backlog refinement', 93);
+        expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(expect.stringContaining("UPDATE operations_timesheet_entry"), 77, 34, 45, "Review backlog", "2026-04-14", 120, 2, "Backlog refinement", 93);
         expect(service.refreshTimesheetTotal).toHaveBeenCalledWith(tx, 55);
         expect(service.refreshTimesheetTotal).toHaveBeenCalledWith(tx, 77);
         expect(service.cleanupEmptyEditableTimesheet).toHaveBeenCalledWith(tx, 55);
         expect(service.submitTimesheetForApproval).toHaveBeenCalledWith(tx, 77, 7);
     });
-    it('allows deleting entries from submitted timesheets until approval', async () => {
+    it("allows deleting entries from submitted timesheets until approval", async () => {
         const tx = {
             $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
         };
         service.prisma.$transaction.mockImplementation(async (callback) => callback(tx));
-        jest.spyOn(service, 'getTimesheetEntryByIdForActor').mockResolvedValue({
+        jest
+            .spyOn(service, "getTimesheetEntryByIdForActor")
+            .mockResolvedValue({
             id: 92,
             timesheetId: 56,
             collaboratorId: 7,
-            status: 'submitted',
+            status: "submitted",
         });
-        jest.spyOn(service, 'refreshTimesheetTotal').mockResolvedValue(undefined);
-        jest.spyOn(service, 'cleanupEmptyEditableTimesheet').mockResolvedValue(undefined);
+        jest
+            .spyOn(service, "refreshTimesheetTotal")
+            .mockResolvedValue(undefined);
+        jest
+            .spyOn(service, "cleanupEmptyEditableTimesheet")
+            .mockResolvedValue(undefined);
         await expect(service.removeTimesheetEntry(15, 92)).resolves.toEqual({
             success: true,
         });
     });
-    it('rejects deleting entries from approved timesheets', async () => {
-        jest.spyOn(service, 'getTimesheetEntryByIdForActor').mockResolvedValue({
+    it("rejects deleting entries from approved timesheets", async () => {
+        jest
+            .spyOn(service, "getTimesheetEntryByIdForActor")
+            .mockResolvedValue({
             id: 94,
             timesheetId: 57,
             collaboratorId: 7,
-            status: 'approved',
+            status: "approved",
         });
         await expect(service.removeTimesheetEntry(15, 94)).rejects.toThrow(common_1.BadRequestException);
     });
 });
-describe('OperationsService approval side effects', () => {
+describe("OperationsService task column activity", () => {
+    let service;
+    let prisma;
+    let integrationApi;
+    const baseTask = {
+        id: 44,
+        name: "Implement board",
+        description: null,
+        priority: "medium",
+        status: "todo",
+        dueDate: null,
+        estimateHours: null,
+        position: 0,
+        tags: null,
+        assigneeCollaboratorId: null,
+        projectAssignmentId: null,
+        projectId: 11,
+        projectName: "Project Atlas",
+        projectCode: "OPS-11",
+        doingStartedAt: null,
+        totalDoingMinutes: 0,
+        deletedAt: null,
+    };
+    beforeEach(() => {
+        prisma = {
+            $transaction: jest.fn(),
+        };
+        integrationApi = {
+            publishEvent: jest.fn().mockResolvedValue(undefined),
+        };
+        service = new operations_service_1.OperationsService(prisma, {}, integrationApi, {}, {}, new operations_access_service_1.OperationsAccessService());
+        jest.spyOn(service, "getActorContext").mockResolvedValue({
+            userId: 15,
+            roleSlugs: ["operations-collaborator"],
+            collaboratorId: 7,
+            collaboratorName: "Taylor Tester",
+            isDirector: false,
+            isSupervisor: false,
+            isCollaborator: true,
+            teamCollaboratorIds: [],
+            visibleCollaboratorIds: [7],
+            visibleProjectIds: [11],
+        });
+        jest
+            .spyOn(service, "assertProjectAccess")
+            .mockResolvedValue(undefined);
+        jest.spyOn(service, "getProjectBoardTask").mockResolvedValue(Object.assign(Object.assign({}, baseTask), { assigneeCollaboratorId: 7, status: "doing" }));
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    function mockTransaction() {
+        const tx = {
+            $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
+        };
+        prisma.$transaction.mockImplementation(async (callback) => callback(tx));
+        return tx;
+    }
+    it("records todo to doing and auto-assigns the actor", async () => {
+        const tx = mockTransaction();
+        jest
+            .spyOn(service, "getTaskRecordForActor")
+            .mockResolvedValue(baseTask);
+        await service.updateTask(15, 44, { status: "doing" });
+        expect(tx.$executeRawUnsafe).toHaveBeenCalledTimes(2);
+        expect(tx.$executeRawUnsafe.mock.calls[0][0]).toContain("doing_started_at = CASE");
+        expect(tx.$executeRawUnsafe.mock.calls[0][3]).toBe(7);
+        expect(tx.$executeRawUnsafe.mock.calls[0][15]).toBe(true);
+        expect(tx.$executeRawUnsafe.mock.calls[0][16]).toBe(false);
+        expect(tx.$executeRawUnsafe.mock.calls[1][0]).toContain("INSERT INTO operations_task_activity");
+        expect(tx.$executeRawUnsafe.mock.calls[1].slice(1)).toEqual([
+            44,
+            7,
+            "status_changed",
+            "todo",
+            "doing",
+        ]);
+    });
+    it("records doing to review and closes accumulated doing minutes", async () => {
+        const tx = mockTransaction();
+        jest.spyOn(service, "getTaskRecordForActor").mockResolvedValue(Object.assign(Object.assign({}, baseTask), { status: "doing", assigneeCollaboratorId: 9, doingStartedAt: "2026-05-16T10:00:00.000Z", totalDoingMinutes: 15 }));
+        await service.updateTask(15, 44, { status: "review" });
+        expect(tx.$executeRawUnsafe).toHaveBeenCalledTimes(2);
+        expect(tx.$executeRawUnsafe.mock.calls[0][3]).toBe(9);
+        expect(tx.$executeRawUnsafe.mock.calls[0][15]).toBe(false);
+        expect(tx.$executeRawUnsafe.mock.calls[0][16]).toBe(true);
+        expect(tx.$executeRawUnsafe.mock.calls[1].slice(1)).toEqual([
+            44,
+            7,
+            "status_changed",
+            "doing",
+            "review",
+        ]);
+    });
+    it("blocks moving advanced without a linked collaborator when no assignee exists", async () => {
+        prisma.$transaction.mockImplementation(async (callback) => callback({ $executeRawUnsafe: jest.fn() }));
+        jest.spyOn(service, "getActorContext").mockResolvedValue({
+            userId: 15,
+            roleSlugs: ["admin"],
+            collaboratorId: null,
+            collaboratorName: null,
+            isDirector: true,
+            isSupervisor: true,
+            isCollaborator: true,
+            teamCollaboratorIds: [],
+            visibleCollaboratorIds: [],
+            visibleProjectIds: [],
+        });
+        jest
+            .spyOn(service, "getTaskRecordForActor")
+            .mockResolvedValue(baseTask);
+        await expect(service.updateTask(15, 44, { status: "review" })).rejects.toThrow(common_1.BadRequestException);
+    });
+    it("does not create activity when the status does not change", async () => {
+        const tx = mockTransaction();
+        jest
+            .spyOn(service, "getTaskRecordForActor")
+            .mockResolvedValue(baseTask);
+        await service.updateTask(15, 44, { status: "todo" });
+        expect(tx.$executeRawUnsafe).toHaveBeenCalledTimes(1);
+        expect(tx.$executeRawUnsafe.mock.calls[0][15]).toBe(false);
+        expect(tx.$executeRawUnsafe.mock.calls[0][16]).toBe(false);
+    });
+});
+describe("OperationsService approval side effects", () => {
     let service;
     beforeEach(() => {
         service = new operations_service_1.OperationsService({
@@ -436,11 +601,11 @@ describe('OperationsService approval side effects', () => {
         }, {}, {
             publishEvent: jest.fn().mockResolvedValue(undefined),
         }, {}, {}, new operations_access_service_1.OperationsAccessService());
-        jest.spyOn(service, 'getActorContext').mockResolvedValue({
+        jest.spyOn(service, "getActorContext").mockResolvedValue({
             userId: 22,
-            roleSlugs: ['admin-operations-supervisor'],
+            roleSlugs: ["admin-operations-supervisor"],
             collaboratorId: 18,
-            collaboratorName: 'Sam Supervisor',
+            collaboratorName: "Sam Supervisor",
             isDirector: false,
             isSupervisor: true,
             isCollaborator: false,
@@ -452,7 +617,7 @@ describe('OperationsService approval side effects', () => {
     afterEach(() => {
         jest.restoreAllMocks();
     });
-    it('applies approved permanent schedule adjustments to the active collaborator weekly schedule', async () => {
+    it("applies approved permanent schedule adjustments to the active collaborator weekly schedule", async () => {
         const tx = {
             $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
             $queryRawUnsafe: jest
@@ -460,19 +625,19 @@ describe('OperationsService approval side effects', () => {
                 .mockResolvedValueOnce([
                 {
                     collaboratorId: 7,
-                    requestScope: 'permanent',
+                    requestScope: "permanent",
                 },
             ])
                 .mockResolvedValueOnce([
                 {
-                    weekday: 'monday',
+                    weekday: "monday",
                     isWorkingDay: true,
-                    startTime: '08:00',
-                    endTime: '17:00',
+                    startTime: "08:00",
+                    endTime: "17:00",
                     breakMinutes: 45,
                 },
                 {
-                    weekday: 'friday',
+                    weekday: "friday",
                     isWorkingDay: false,
                     startTime: null,
                     endTime: null,
@@ -481,68 +646,74 @@ describe('OperationsService approval side effects', () => {
             ]),
         };
         service.prisma.$transaction.mockImplementation(async (callback) => callback(tx));
-        jest.spyOn(service, 'querySingle')
+        jest
+            .spyOn(service, "querySingle")
             .mockResolvedValueOnce({
             id: 81,
-            targetType: 'schedule_adjustment_request',
+            targetType: "schedule_adjustment_request",
             targetId: 400,
             requesterCollaboratorId: 7,
             approverCollaboratorId: 18,
-            status: 'pending',
+            status: "pending",
         })
             .mockResolvedValueOnce({
             id: 81,
-            targetType: 'schedule_adjustment_request',
+            targetType: "schedule_adjustment_request",
             targetId: 400,
-            status: 'approved',
-            decidedAt: '2026-04-11T12:00:00.000Z',
-            decisionNote: 'Approved for the new weekly schedule.',
+            status: "approved",
+            decidedAt: "2026-04-11T12:00:00.000Z",
+            decisionNote: "Approved for the new weekly schedule.",
         });
-        jest.spyOn(service, 'insertApprovalHistory').mockResolvedValue(undefined);
+        jest
+            .spyOn(service, "insertApprovalHistory")
+            .mockResolvedValue(undefined);
         await expect(service.approve(22, 81, {
-            note: 'Approved for the new weekly schedule.',
+            note: "Approved for the new weekly schedule.",
         })).resolves.toEqual(expect.objectContaining({
             id: 81,
-            status: 'approved',
+            status: "approved",
         }));
-        expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(expect.stringContaining('UPDATE operations_schedule_adjustment_request'), 'approved', 18, 400);
-        expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(expect.stringContaining('UPDATE operations_collaborator_schedule_day'), 7);
-        expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(expect.stringContaining('INSERT INTO operations_collaborator_schedule_day'), 7, 'monday', true, '08:00', '17:00', 45);
-        expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(expect.stringContaining('INSERT INTO operations_collaborator_schedule_day'), 7, 'friday', false, null, null, 0);
+        expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(expect.stringContaining("UPDATE operations_schedule_adjustment_request"), "approved", 18, 400);
+        expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(expect.stringContaining("UPDATE operations_collaborator_schedule_day"), 7);
+        expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(expect.stringContaining("INSERT INTO operations_collaborator_schedule_day"), 7, "monday", true, "08:00", "17:00", 45);
+        expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(expect.stringContaining("INSERT INTO operations_collaborator_schedule_day"), 7, "friday", false, null, null, 0);
     });
-    it('keeps the collaborator weekly schedule unchanged for approved temporary adjustments', async () => {
+    it("keeps the collaborator weekly schedule unchanged for approved temporary adjustments", async () => {
         const tx = {
             $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
             $queryRawUnsafe: jest.fn().mockResolvedValueOnce([
                 {
                     collaboratorId: 7,
-                    requestScope: 'temporary',
+                    requestScope: "temporary",
                 },
             ]),
         };
         service.prisma.$transaction.mockImplementation(async (callback) => callback(tx));
-        jest.spyOn(service, 'querySingle')
+        jest
+            .spyOn(service, "querySingle")
             .mockResolvedValueOnce({
             id: 82,
-            targetType: 'schedule_adjustment_request',
+            targetType: "schedule_adjustment_request",
             targetId: 401,
             requesterCollaboratorId: 7,
             approverCollaboratorId: 18,
-            status: 'pending',
+            status: "pending",
         })
             .mockResolvedValueOnce({
             id: 82,
-            targetType: 'schedule_adjustment_request',
+            targetType: "schedule_adjustment_request",
             targetId: 401,
-            status: 'approved',
-            decidedAt: '2026-04-11T12:05:00.000Z',
-            decisionNote: 'Approved as a temporary exception.',
+            status: "approved",
+            decidedAt: "2026-04-11T12:05:00.000Z",
+            decisionNote: "Approved as a temporary exception.",
         });
-        jest.spyOn(service, 'insertApprovalHistory').mockResolvedValue(undefined);
+        jest
+            .spyOn(service, "insertApprovalHistory")
+            .mockResolvedValue(undefined);
         await service.approve(22, 82, {
-            note: 'Approved as a temporary exception.',
+            note: "Approved as a temporary exception.",
         });
-        expect(tx.$executeRawUnsafe).not.toHaveBeenCalledWith(expect.stringContaining('UPDATE operations_collaborator_schedule_day'), 7);
+        expect(tx.$executeRawUnsafe).not.toHaveBeenCalledWith(expect.stringContaining("UPDATE operations_collaborator_schedule_day"), 7);
     });
 });
 //# sourceMappingURL=operations.service.spec.js.map