create-appraisejs 0.1.9 → 0.1.10-alpha.0

package/templates/default/src/actions/template-step-group/template-step-group-actions.ts

@@ -2,46 +2,19 @@
 
 import prisma from '@/config/db-config'
 import { templateStepGroupSchema } from '@/constants/form-opts/template-step-group-form-opts'
+import { automationProjectionService } from '@/lib/automation/projection-service'
 import { ActionResponse } from '@/types/form/actionHandler'
 import { Prisma } from '@prisma/client'
 import { revalidatePath } from 'next/cache'
 import { z, ZodError } from 'zod'
 
-// TemplateStepGroupType will be available after Prisma migration
 type TemplateStepGroupType = 'ACTION' | 'VALIDATION'
 
-// Type helper to safely extract type from Prisma records
-type TemplateStepGroupWithType = {
-  id: string
-  name: string
-  description: string | null
-  type?: TemplateStepGroupType
-  createdAt: Date
-  updatedAt: Date
-}
-
 function getGroupType(group: unknown): TemplateStepGroupType {
-  const groupWithType = group as TemplateStepGroupWithType
-  const type = groupWithType.type
-  if (type === 'VALIDATION' || type === 'ACTION') {
-    return type
-  }
-  return 'ACTION' // default
+  const type = (group as { type?: TemplateStepGroupType }).type
+  return type === 'VALIDATION' ? 'VALIDATION' : 'ACTION'
 }
 
-import {
-  createTemplateStepGroupFile,
-  removeTemplateStepGroupFile,
-  renameTemplateStepGroupFile,
-  ensureGroupJSDoc,
-} from '@/lib/utils/template-step-file-manager-intelligent'
-import { promises as fs } from 'fs'
-import { getFilePath, formatFileContent } from '@/lib/utils/template-step-file-generator'
-
-/**
- * Get all template step groups
- * @returns ActionResponse
- */
 export async function getAllTemplateStepGroupsAction(): Promise<ActionResponse> {
   try {
     const templateStepGroups = await prisma.templateStepGroup.findMany()
@@ -49,20 +22,14 @@ export async function getAllTemplateStepGroupsAction(): Promise<ActionResponse>
       status: 200,
       data: templateStepGroups,
     }
-  } catch (e) {
+  } catch (error) {
     return {
       status: 500,
-      error: `Server error occurred: ${e}`,
+      error: `Server error occurred: ${error}`,
     }
   }
 }
 
-/**
- * Create a new template step group
- * @param _prev - Previous state
- * @param value - Template step group data
- * @returns ActionResponse
- */
 export async function createTemplateStepGroupAction(
   _prev: unknown,
   value: z.infer<typeof templateStepGroupSchema>,
@@ -71,36 +38,32 @@ export async function createTemplateStepGroupAction(
     templateStepGroupSchema.parse(value)
 
     const type: TemplateStepGroupType = (value.type as string) === 'VALIDATION' ? 'VALIDATION' : 'ACTION'
-
-    // First, try to create the file - if this fails, we won't create the database record
-    await createTemplateStepGroupFile(value.name, type, value.description)
-
-    // If file creation succeeds, create the database record
-    // Note: Using type assertion because Prisma client hasn't been regenerated yet
-    await prisma.templateStepGroup.create({
+    const createdGroup = await prisma.templateStepGroup.create({
       data: {
         name: value.name,
         description: value.description,
-        type: type,
+        type,
       } as Parameters<typeof prisma.templateStepGroup.create>[0]['data'],
     })
 
+    await automationProjectionService.syncTemplateStepGroup(createdGroup.id)
+
     revalidatePath('/template-step-groups')
     return {
       status: 200,
       message: 'Template step group created successfully',
     }
-  } catch (e) {
-    if (e instanceof ZodError) {
+  } catch (error) {
+    if (error instanceof ZodError) {
       return {
         status: 400,
-        error: e.message,
+        error: error.message,
       }
     }
-    if (e instanceof Prisma.PrismaClientKnownRequestError) {
+    if (error instanceof Prisma.PrismaClientKnownRequestError) {
       return {
         status: 500,
-        error: e.message,
+        error: error.message,
       }
     }
     return {
@@ -110,54 +73,27 @@ export async function createTemplateStepGroupAction(
   }
 }
 
-/**
- * Delete a template step group
- * @param id - Template step group id(s)
- * @returns ActionResponse
- */
-export async function deleteTemplateStepGroupAction(id: string[]): Promise<ActionResponse> {
+export async function deleteTemplateStepGroupAction(ids: string[]): Promise<ActionResponse> {
   try {
-    // Get the group names and types before deletion for file cleanup
-    const groupsToDelete = await prisma.templateStepGroup.findMany({
-      where: { id: { in: id } },
-    })
+    await Promise.all(ids.map(id => automationProjectionService.deleteTemplateStepGroup(id)))
 
-    // With proper cascade deletes in the schema, we can now rely on the database
-    // to handle the deletion of related entities automatically
     await prisma.templateStepGroup.deleteMany({
-      where: { id: { in: id } },
+      where: { id: { in: ids } },
     })
 
-    // Clean up the files after successful database deletion
-    for (const group of groupsToDelete) {
-      try {
-        const groupType = getGroupType(group)
-        await removeTemplateStepGroupFile(group.name, groupType)
-      } catch (fileError) {
-        console.error(`Failed to delete file for group "${group.name}":`, fileError)
-        // Don't fail the entire operation if file deletion fails
-      }
-    }
-
     revalidatePath('/template-step-groups')
     return {
       status: 200,
       message: 'Template step group(s) deleted successfully',
     }
-  } catch (e) {
-    console.error('Error deleting template step group:', e)
+  } catch (error) {
     return {
       status: 500,
-      error: `Server error occurred: ${e}`,
+      error: `Server error occurred: ${error}`,
     }
   }
 }
 
-/**
- * Get a template step group by id
- * @param id - Template step group id
- * @returns ActionResponse
- */
 export async function getTemplateStepGroupByIdAction(id: string): Promise<ActionResponse> {
   try {
     const templateStepGroup = await prisma.templateStepGroup.findUnique({
@@ -167,19 +103,12 @@ export async function getTemplateStepGroupByIdAction(id: string): Promise<Action
       status: 200,
       data: templateStepGroup,
     }
-  } catch (e) {
-    console.error(e)
-    throw e
+  } catch (error) {
+    console.error(error)
+    throw error
   }
 }
 
-/**
- * Update a template step group
- * @param _prev - Previous state
- * @param value - Template step group data
- * @param id - Template step group id
- * @returns ActionResponse
- */
 export async function updateTemplateStepGroupAction(
   _prev: unknown,
   value: z.infer<typeof templateStepGroupSchema>,
@@ -195,7 +124,6 @@ export async function updateTemplateStepGroupAction(
       }
     }
 
-    // Get the current group to check if name or type changed
     const currentGroup = await prisma.templateStepGroup.findUnique({
       where: { id },
     })
@@ -209,40 +137,11 @@ export async function updateTemplateStepGroupAction(
 
     const newType: TemplateStepGroupType = (value.type as string) === 'VALIDATION' ? 'VALIDATION' : 'ACTION'
     const currentType = getGroupType(currentGroup)
-    const nameChanged = currentGroup.name !== value.name
-    const typeChanged = currentType !== newType
-    const descriptionChanged = currentGroup.description !== value.description
-
-    // If name or type changed, we need to handle file renaming/moving
-    if (nameChanged || typeChanged) {
-      // Rename/move the file to preserve all existing content and update JSDoc
-      try {
-        await renameTemplateStepGroupFile(currentGroup.name, value.name, currentType, newType, value.description)
-      } catch (fileError) {
-        console.error(
-          `Failed to rename/move file from "${currentGroup.name}" (${currentType}) to "${value.name}" (${newType}):`,
-          fileError,
-        )
-        // Continue with the update even if file rename fails
-      }
-    } else if (descriptionChanged) {
-      // Only description changed, update JSDoc in place
-      try {
-        const filePath = getFilePath(value.name, newType)
-
-        let fileContent = await fs.readFile(filePath, 'utf8')
-        fileContent = ensureGroupJSDoc(fileContent, value.name, value.description || null, newType)
 
-        const formattedContent = await formatFileContent(fileContent)
-        await fs.writeFile(filePath, formattedContent, 'utf8')
-      } catch (fileError) {
-        console.error(`Failed to update JSDoc for group "${value.name}":`, fileError)
-        // Continue with the update even if file update fails
-      }
+    if (currentGroup.name !== value.name || currentType !== newType) {
+      await automationProjectionService.renameTemplateStepGroup(id, value.name, newType, value.description)
     }
 
-    // Update the database record
-    // Note: Using type assertion because Prisma client hasn't been regenerated yet
     await prisma.templateStepGroup.update({
       where: { id },
       data: {
@@ -252,22 +151,24 @@ export async function updateTemplateStepGroupAction(
       } as Parameters<typeof prisma.templateStepGroup.update>[0]['data'],
     })
 
+    await automationProjectionService.syncTemplateStepGroup(id)
+
     revalidatePath('/template-step-groups')
     return {
       status: 200,
       message: 'Template step group updated successfully',
     }
-  } catch (e) {
-    if (e instanceof ZodError) {
+  } catch (error) {
+    if (error instanceof ZodError) {
       return {
         status: 400,
-        error: e.message,
+        error: error.message,
       }
     }
-    if (e instanceof Prisma.PrismaClientKnownRequestError) {
+    if (error instanceof Prisma.PrismaClientKnownRequestError) {
       return {
         status: 500,
-        error: e.message,
+        error: error.message,
       }
     }
     return {

package/templates/default/src/actions/test-case/test-case-actions.ts

@@ -4,16 +4,11 @@ import prisma from '@/config/db-config'
 import { ActionResponse } from '@/types/form/actionHandler'
 import { revalidatePath } from 'next/cache'
 import { testCaseSchema } from '@/constants/form-opts/test-case-form-opts'
+import { automationProjectionService } from '@/lib/automation/projection-service'
 import { z } from 'zod'
-import { generateFeatureFile } from '@/lib/feature-file-generator'
-
 import { StepParameterType, TagType } from '@prisma/client'
 import { generateUniqueTestCaseIdentifier } from '@/lib/test-case-utils'
 
-/**
- * Get all test cases
- * @returns ActionResponse
- */
 export async function getAllTestCasesAction(): Promise<ActionResponse> {
   try {
     const testCases = await prisma.testCase.findMany({
@@ -31,35 +26,27 @@ export async function getAllTestCasesAction(): Promise<ActionResponse> {
       status: 200,
       data: testCases,
     }
-  } catch (e) {
+  } catch (error) {
     return {
       status: 500,
-      error: `Server error occurred: ${e}`,
+      error: `Server error occurred: ${error}`,
     }
   }
 }
 
-/**
- * Delete a test case
- * @param id - Test case id
- * @returns ActionResponse
- */
-export async function deleteTestCaseAction(id: string[]): Promise<ActionResponse> {
+export async function deleteTestCaseAction(ids: string[]): Promise<ActionResponse> {
   try {
-    // Get the test suites that will be affected before deletion
     const affectedTestSuites = await prisma.testSuite.findMany({
       where: {
         testCases: {
           some: {
             id: {
-              in: id,
+              in: ids,
             },
           },
         },
       },
-      include: {
-        module: true,
-      },
+      select: { id: true },
     })
 
     const testCaseIdentifierTags = await prisma.tag.findMany({
@@ -68,7 +55,7 @@ export async function deleteTestCaseAction(id: string[]): Promise<ActionResponse
         testCases: {
           some: {
             id: {
-              in: id,
+              in: ids,
             },
           },
         },
@@ -79,96 +66,74 @@ export async function deleteTestCaseAction(id: string[]): Promise<ActionResponse
     })
 
     await prisma.$transaction(async tx => {
-      // Delete all test run test cases associated with the test cases
-      // Note: This has RESTRICT constraint in the database, so must be deleted first
       await tx.testRunTestCase.deleteMany({
         where: {
           testCaseId: {
-            in: id,
+            in: ids,
           },
         },
       })
 
-      // Delete all reviews associated with the test cases
       await tx.review.deleteMany({
         where: {
           testCaseId: {
-            in: id,
+            in: ids,
           },
         },
       })
 
-      // Delete all linked Jira tickets associated with the test cases
       await tx.linkedJiraTicket.deleteMany({
         where: {
           testCaseId: {
-            in: id,
+            in: ids,
           },
         },
       })
 
-      // Delete all step parameters associated with the test case steps
       await tx.testCaseStepParameter.deleteMany({
         where: {
           testCaseStep: {
             testCaseId: {
-              in: id,
+              in: ids,
             },
           },
         },
       })
 
-      // Delete all test case steps
       await tx.testCaseStep.deleteMany({
         where: {
           testCaseId: {
-            in: id,
+            in: ids,
           },
         },
       })
 
-      // Delete all test case identifier tags associated with the test cases
       await tx.tag.deleteMany({
         where: {
           id: { in: testCaseIdentifierTags.map(tag => tag.id) },
         },
       })
 
-      // Delete the test cases
       await tx.testCase.deleteMany({
-        where: { id: { in: id } },
+        where: { id: { in: ids } },
       })
     })
 
-    // Regenerate feature files for affected test suites
-    for (const testSuite of affectedTestSuites) {
-      try {
-        await generateFeatureFile(testSuite.id, testSuite.name, testSuite.description || undefined)
-      } catch (featureFileError) {
-        console.error(`Error regenerating feature file for test suite ${testSuite.name}:`, featureFileError)
-        // Don't fail the deletion if feature file regeneration fails
-      }
-    }
+    await Promise.all(affectedTestSuites.map(testSuite => automationProjectionService.generateFeature(testSuite.id)))
 
     revalidatePath('/test-cases')
     return {
       status: 200,
       message: 'Test case(s) deleted successfully',
     }
-  } catch (e) {
-    console.error('Error deleting test case(s):', e)
+  } catch (error) {
     return {
       status: 500,
-      error: `Server error occurred: ${e}`,
+      error: `Server error occurred: ${error}`,
     }
   }
 }
 
-/**
- * Create a test case
- * @param testCase - Test case
- * @returns ActionResponse
- */
 export async function createTestCaseAction(value: z.infer<typeof testCaseSchema>): Promise<ActionResponse> {
   try {
     testCaseSchema.parse(value)
@@ -180,6 +145,7 @@ export async function createTestCaseAction(value: z.infer<typeof testCaseSchema>
         tagExpression: `@${uniqueTestCaseIdentifier}`,
       },
     })
+
     const baseData = {
       title: value.title,
       description: value.description ?? '',
@@ -205,7 +171,6 @@ export async function createTestCaseAction(value: z.infer<typeof testCaseSchema>
       },
     }
 
-    // Only include tags if there are tagIds provided
     const data =
       value.tagIds && value.tagIds.length > 0
         ? {
@@ -225,22 +190,14 @@ export async function createTestCaseAction(value: z.infer<typeof testCaseSchema>
       data,
       include: {
         TestSuite: {
-          include: {
-            module: true,
+          select: {
+            id: true,
           },
         },
       },
     })
 
-    // Regenerate feature files for all related test suites
-    for (const testSuite of newTestCase.TestSuite) {
-      try {
-        await generateFeatureFile(testSuite.id, testSuite.name, testSuite.description || undefined)
-      } catch (featureFileError) {
-        console.error(`Error regenerating feature file for test suite ${testSuite.name}:`, featureFileError)
-        // Don't fail the creation if feature file regeneration fails
-      }
-    }
+    await Promise.all(newTestCase.TestSuite.map(testSuite => automationProjectionService.generateFeature(testSuite.id)))
 
     revalidatePath('/test-cases')
     return {
@@ -248,19 +205,14 @@ export async function createTestCaseAction(value: z.infer<typeof testCaseSchema>
       message: 'Test case created successfully',
       data: newTestCase,
     }
-  } catch (e) {
+  } catch (error) {
     return {
       status: 500,
-      error: `Server error occurred: ${e}`,
+      error: `Server error occurred: ${error}`,
     }
   }
 }
 
-/**
- * Get a test case by id
- * @param id - Test case id
- * @returns ActionResponse
- */
 export async function getTestCaseByIdAction(id: string): Promise<ActionResponse> {
   try {
     const testCase = await prisma.testCase.findUnique({
@@ -294,10 +246,10 @@ export async function getTestCaseByIdAction(id: string): Promise<ActionResponse>
         tagIds: testCase?.tags.map(tag => tag.id) || [],
       },
     }
-  } catch (e) {
+  } catch (error) {
     return {
       status: 500,
-      error: `Server error occurred: ${e}`,
+      error: `Server error occurred: ${error}`,
     }
   }
 }
@@ -310,40 +262,35 @@ export async function updateTestCaseAction(
     throw new Error("updateTestCaseAction: 'id' parameter is required for updating a test case.")
   }
   try {
-    // Get the test suites that will be affected before updating
     const affectedTestSuites = await prisma.testSuite.findMany({
       where: {
         testCases: {
           some: {
-            id: id,
+            id,
           },
         },
       },
-      include: {
-        module: true,
+      select: {
+        id: true,
       },
     })
 
-    // 1. Find all step IDs for the test case
     const steps = await prisma.testCaseStep.findMany({
       where: { testCaseId: id },
       select: { id: true },
     })
     const stepIds = steps.map(step => step.id)
 
-    // 2. Delete all parameters for those steps
     if (stepIds.length > 0) {
       await prisma.testCaseStepParameter.deleteMany({
         where: { testCaseStepId: { in: stepIds } },
       })
     }
 
-    // 3. Delete all steps for the test case
     await prisma.testCaseStep.deleteMany({
       where: { testCaseId: id },
     })
 
-    // 4. Get existing IDENTIFIER tags to preserve them
     const existingTestCase = await prisma.testCase.findUnique({
       where: { id },
       include: {
@@ -358,19 +305,17 @@ export async function updateTestCaseAction(
       },
     })
 
-    // 5. Combine IDENTIFIER tags with FILTER tags from the form
     const identifierTagIds = existingTestCase?.tags.map(tag => tag.id) || []
     const filterTagIds = value.tagIds || []
     const allTagIds = [...identifierTagIds, ...filterTagIds]
 
-    // 6. Then, update the test case with new steps
     const testCase = await prisma.testCase.update({
       where: { id },
       data: {
         title: value.title,
         description: value.description ?? '',
         tags: {
-          set: allTagIds.map(id => ({ id })),
+          set: allTagIds.map(tagId => ({ id: tagId })),
         },
         steps: {
           create: value.steps.map(step => ({
@@ -395,25 +340,17 @@ export async function updateTestCaseAction(
       },
     })
 
-    // Regenerate feature files for all affected test suites
-    for (const testSuite of affectedTestSuites) {
-      try {
-        await generateFeatureFile(testSuite.id, testSuite.name, testSuite.description || undefined)
-      } catch (featureFileError) {
-        console.error(`Error regenerating feature file for test suite ${testSuite.name}:`, featureFileError)
-        // Don't fail the update if feature file regeneration fails
-      }
-    }
+    await Promise.all(affectedTestSuites.map(testSuite => automationProjectionService.generateFeature(testSuite.id)))
 
     return {
       status: 200,
       message: 'Test case updated successfully',
       data: testCase,
     }
-  } catch (e) {
+  } catch (error) {
     return {
       status: 500,
-      error: `Server error occurred: ${e}`,
+      error: `Server error occurred: ${error}`,
     }
   }
 }

package/templates/default/src/actions/test-run/test-run-actions.ts

@@ -12,8 +12,7 @@ import {
   TagType,
   Tag,
 } from '@prisma/client'
-import { executeTestRun } from '@/lib/test-run/test-run-executor'
-import { waitForTask, taskSpawner, killTask } from '@/tests/utils/spawner.util'
+import { localExecutorAdapter } from '@/lib/executor/local-executor-adapter'
 import { revalidatePath } from 'next/cache'
 import { formatLogsForStorage, parseLogsFromStorage, type LogEntry } from '@/lib/test-run/log-formatter'
 import { processManager } from '@/lib/test-run/process-manager'
@@ -471,7 +470,7 @@ export async function createTestRunAction(
 
     // Execute test run asynchronously (don't await, let it run in background)
     try {
-      const { process: spawnedProcess, reportPath } = await executeTestRun({
+      const { process: spawnedProcess, reportPath } = await localExecutorAdapter.executeTestRun({
         testRunId: testRun.runId,
         environment,
         tags,
@@ -533,7 +532,7 @@ export async function createTestRunAction(
       executePromise
         .then(async spawnedProcess => {
           // Wait for process to complete
-          const exitCode = await waitForTask(spawnedProcess.name)
+          const exitCode = await localExecutorAdapter.waitForProcess(spawnedProcess.name)
 
           // Collect all logs from the process output
           const logEntries: LogEntry[] = []
@@ -906,7 +905,7 @@ export async function checkTraceViewerStatusAction(testRunId: string, testCaseId
 
     // Check if trace viewer process is running
     const processName = `trace-viewer-${testCaseId}`
-    const process = taskSpawner.getProcess(processName)
+    const process = localExecutorAdapter.getProcess(processName)
     const isRunning = process?.isRunning ?? false
 
     return {
@@ -989,12 +988,7 @@ export async function spawnTraceViewerAction(testRunId: string, testCaseId: stri
 
     // Spawn playwright show-trace command
     // The process is self-closing when the user closes the trace viewer
-    const spawnedProcess = await taskSpawner.spawn('npx', ['playwright', 'show-trace', absoluteTracePath], {
-      streamLogs: true,
-      prefixLogs: true,
-      logPrefix: `trace-viewer-${testCaseId}`,
-      captureOutput: false, // No need to capture output for trace viewer
-    })
+    const spawnedProcess = await localExecutorAdapter.spawnTraceViewer(testCaseId, absoluteTracePath)
 
     console.log(
       `[TestRunAction] Spawned trace viewer process for testCaseId: ${testCaseId}, tracePath: ${absoluteTracePath}`,
@@ -1077,10 +1071,10 @@ export async function cancelTestRunAction(testRunId: string): Promise<ActionResp
       }
     }
 
-    const killed = killTask(process.name, 'SIGTERM')
+    const killed = localExecutorAdapter.killProcess(process.name, 'SIGTERM')
     console.log(`[TestRunAction] Killed: ${killed}`)
     if (!killed) {
-      const forceKilled = killTask(process.name, 'SIGKILL')
+      const forceKilled = localExecutorAdapter.killProcess(process.name, 'SIGKILL')
       if (!forceKilled) {
         console.warn(`[TestRunAction] Failed to force kill process for testRunId: ${testRunId}`)
       }
@@ -1183,3 +1177,7 @@ export async function checkTestRunNameUniqueAction(name: string, excludeId?: str
     }
   }
 }
+
+
+
+