refactor: use patchFlowLastUpdated from step model

Author: kevinkim-ogp

packages/backend/src/graphql/__tests__/mutations/create-step.itest.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import createStep from '@/graphql/mutations/create-step'
 import Flow from '@/models/flow'
@@ -10,9 +10,16 @@ describe('createStep mutation integration tests', async () => {
   let testFlow: Flow
   let existingSteps: Step[]
   let context: Context
+  const patchFlowLastUpdatedSpy = vi.fn().mockResolvedValue({})
 
   // Clean up (and seed) database before each test.
   beforeEach(async () => {
+    vi.resetAllMocks()
+
+    vi.spyOn(Step.prototype, 'patchFlowLastUpdated').mockImplementation(
+      patchFlowLastUpdatedSpy,
+    )
+
     // Clear out all rows. Adjust deletion order if using foreign keys.
     await Step.query().delete()
     await Flow.query().delete()
@@ -119,20 +126,15 @@ describe('createStep mutation integration tests', async () => {
     expect(steps.map((step) => step.position)).toEqual([1, 2, 3, 4])
   })
 
-  it('should update flow updatedAt when creating a step', async () => {
-    const originalUpdatedAt = testFlow.updatedAt
+  it('should call patchFlowLastUpdated when creating a step', async () => {
     const params = {
       input: {
         flow: { id: testFlow.id },
         previousStep: { id: existingSteps[2].id },
       },
     }
-
     await createStep(null, params, context)
-    const updatedFlow = await Flow.query().findById(testFlow.id)
-    expect(new Date(updatedFlow.updatedAt).getTime()).toBeGreaterThan(
-      new Date(originalUpdatedAt).getTime(),
-    )
+    expect(patchFlowLastUpdatedSpy).toHaveBeenCalledTimes(1)
   })
 
   it('throws an error if the flow does not belong to the current user', async () => {

packages/backend/src/graphql/__tests__/mutations/delete-step.itest.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import deleteStep from '@/graphql/mutations/delete-step'
 import Flow from '@/models/flow'
@@ -12,8 +12,16 @@ describe('deleteStep mutation', () => {
   let context: Context
   let testFlow: Flow
   let testSteps: Step[]
+  const patchFlowLastUpdatedSpy = vi.fn().mockResolvedValue({})
 
   beforeEach(async () => {
+    vi.resetAllMocks()
+
+    // Mock the patchFlowLastUpdated method
+    vi.spyOn(Step.prototype, 'patchFlowLastUpdated').mockImplementation(
+      patchFlowLastUpdatedSpy,
+    )
+
     // Clear out all rows
     await Step.query().delete()
     await Flow.query().delete()
@@ -168,48 +176,17 @@ describe('deleteStep mutation', () => {
     expect(invalidatedStep.status).toBe('incomplete')
   })
 
-  it('should update flow updatedAt when deleting trigger step', async () => {
-    const originalUpdatedAt = testFlow.updatedAt
-
-    await new Promise((resolve) => setTimeout(resolve, 10))
-
-    const result = await deleteStep(
-      null,
-      { input: { ids: [testSteps[0].id] } },
-      context,
-    )
-
-    // Verify the flow's updatedAt was updated
-    expect(result.updatedAt).toBeDefined()
-    expect(new Date(result.updatedAt).getTime()).toBeGreaterThan(
-      new Date(originalUpdatedAt).getTime(),
-    )
-
-    // Verify the returned flow has the updated timestamp
-    const updatedFlow = await Flow.query().findById(testFlow.id)
-    expect(updatedFlow.updatedAt).toStrictEqual(result.updatedAt)
+  it('should call patchFlowLastUpdated when deleting trigger step', async () => {
+    await deleteStep(null, { input: { ids: [testSteps[0].id] } }, context)
+    expect(patchFlowLastUpdatedSpy).toHaveBeenCalledTimes(1)
   })
 
-  it('should update flow updatedAt when deleting action steps', async () => {
-    const originalUpdatedAt = testFlow.updatedAt
-
-    // Wait a moment to ensure different timestamp
-    await new Promise((resolve) => setTimeout(resolve, 10))
-
-    const result = await deleteStep(
+  it('should call patchFlowLastUpdated when deleting action steps', async () => {
+    await deleteStep(
       null,
       { input: { ids: [testSteps[1].id, testSteps[2].id] } },
       context,
     )
-
-    // Verify the flow's updatedAt was updated
-    expect(result.updatedAt).toBeDefined()
-    expect(new Date(result.updatedAt).getTime()).toBeGreaterThan(
-      new Date(originalUpdatedAt).getTime(),
-    )
-
-    // Verify the returned flow has the updated timestamp
-    const updatedFlow = await Flow.query().findById(testFlow.id)
-    expect(updatedFlow.updatedAt).toStrictEqual(result.updatedAt)
+    expect(patchFlowLastUpdatedSpy).toHaveBeenCalledTimes(1)
   })
 })

packages/backend/src/graphql/__tests__/mutations/update-step.itest.ts

@@ -16,7 +16,7 @@ const mockStepId = '8c2a70d1-e78b-431e-9069-a4d8f97883f7'
 describe('updateStep mutation', () => {
   let context: Context
   let patchAndFetchByIdSpy: ReturnType<typeof vi.fn>
-  const flowPatchSpy = vi.fn().mockResolvedValue({})
+  const patchFlowLastUpdatedSpy = vi.fn().mockResolvedValue({})
 
   // Helper to create step mock with flow
   const createStepMock = (stepData: any = {}) => ({
@@ -31,10 +31,8 @@ describe('updateStep mutation', () => {
               status: 'completed',
               flow: {
                 id: mockFlowId,
-                $query: vi.fn().mockReturnValue({
-                  patch: flowPatchSpy,
-                }),
               },
+              patchFlowLastUpdated: patchFlowLastUpdatedSpy,
               ...stepData,
             },
       ),
@@ -304,12 +302,6 @@ describe('updateStep mutation', () => {
   it('updating empty step name should not update template config', async () => {
     // Override the steps query to return template config
     setupRelatedQueryMock({
-      flow: {
-        id: mockFlowId,
-        $query: vi.fn().mockReturnValue({
-          patch: vi.fn().mockResolvedValue({}),
-        }),
-      },
       config: {
         stepName: 'some-step-name',
         templateConfig: { appEventKey: 'existingAppEventKey' },
@@ -346,18 +338,8 @@ describe('updateStep mutation', () => {
     )
   })
 
-  it('should call flow patch method when updating a step', async () => {
+  it('should call patchFlowLastUpdated when updating a step', async () => {
     await updateStep(null, { input: { ...genericInputParams } }, context)
-
-    // Verify flow's patch method was called
-    expect(flowPatchSpy).toHaveBeenCalledTimes(1)
-    expect(flowPatchSpy).toHaveBeenCalledWith({
-      updatedAt: expect.any(String),
-    })
-
-    const updatedAtCall = flowPatchSpy.mock.calls[0][0]
-    expect(new Date(updatedAtCall.updatedAt).toISOString()).toBe(
-      updatedAtCall.updatedAt,
-    )
+    expect(patchFlowLastUpdatedSpy).toHaveBeenCalledTimes(1)
   })
 })

packages/backend/src/graphql/mutations/create-step.ts

@@ -56,7 +56,7 @@ const createStep: MutationResolvers['createStep'] = async (
       connectionId: input.connection?.id,
     })
 
-    await flow.$query(trx).patch({ updatedAt: new Date().toISOString() })
+    await step.patchFlowLastUpdated()
 
     return step
   })

packages/backend/src/graphql/mutations/delete-step.ts

@@ -110,7 +110,7 @@ const deleteStep: MutationResolvers['deleteStep'] = async (
         .patch({ position: raw(`position - ${steps.length}`) })
     }
 
-    await flow.$query(trx).patch({ updatedAt: new Date().toISOString() })
+    await steps[0].patchFlowLastUpdated()
 
     return await flow
       .$query(trx)

packages/backend/src/graphql/mutations/update-step.ts

@@ -60,9 +60,7 @@ const updateStep: MutationResolvers['updateStep'] = async (
       .withGraphFetched('connection')
 
     // update the flow's last updated
-    await step.flow.$query(trx).patch({
-      updatedAt: new Date().toISOString(),
-    })
+    await step.patchFlowLastUpdated()
 
     return updatedStep
   })

packages/backend/src/models/__tests__/step.itest.ts

@@ -166,4 +166,20 @@ describe('step model', () => {
       expect(lastExecutionStep).toHaveProperty('id', executionStepIds[1])
     })
   })
+
+  describe('patchFlowLastUpdated', () => {
+    it('should patch the flow last updated', async () => {
+      const flow = await step.$relatedQuery('flow')
+      const originalUpdatedAt = flow.updatedAt
+
+      await step.patchFlowLastUpdated()
+
+      const updatedFlow = await step.$relatedQuery('flow')
+
+      expect(updatedFlow.updatedAt).toBeDefined()
+      expect(new Date(updatedFlow.updatedAt).getTime()).toBeGreaterThan(
+        new Date(originalUpdatedAt).getTime(),
+      )
+    })
+  })
 })

packages/backend/src/models/step.ts

@@ -192,6 +192,12 @@ class Step extends Base {
     return command
   }
 
+  async patchFlowLastUpdated() {
+    await this.$relatedQuery('flow').patch({
+      updatedAt: new Date().toISOString(),
+    })
+  }
+
   static async beforeUpdate(args: StaticHookArguments<Step>): Promise<void> {
     await super.beforeUpdate(args)