create-appraise 0.1.0

package/templates/default/scripts/sync-test-suites.ts

@@ -0,0 +1,411 @@
+#!/usr/bin/env tsx
+
+/**
+ * Script to synchronize test suites from feature files to database
+ * Scans feature files to ensure all test suites exist in DB
+ * Filesystem is the source of truth - test suites in DB but not in FS will be deleted
+ * Run this after merging changes to ensure test suite sync
+ *
+ * Usage: npx tsx scripts/sync-test-suites.ts
+ */
+
+import { join } from 'path'
+import prisma from '../src/config/db-config'
+import { scanFeatureFiles, extractModulePathFromFilePath, ParsedFeature } from '../src/lib/gherkin-parser'
+import { buildModuleHierarchy, findModuleByPath, getAllModulesWithPaths } from '../src/lib/module-hierarchy-builder'
+
+interface TestSuiteFromFS {
+  name: string // From filename (without .feature extension)
+  description: string | null // From Feature: line
+  modulePath: string // From folder hierarchy
+  tags: string[] // Feature-level tags (lines before Feature:)
+  filePath: string // Full path to feature file
+}
+
+interface SyncResult {
+  testSuitesScanned: number
+  testSuitesExisting: number
+  testSuitesCreated: number
+  testSuitesUpdated: number
+  testSuitesDeleted: number
+  errors: string[]
+  createdTestSuites: Array<{ name: string; modulePath: string }>
+  updatedTestSuites: Array<{ name: string; modulePath: string }>
+  deletedTestSuites: Array<{ name: string; modulePath: string }>
+}
+
+/**
+ * Extracts test suite name from filename
+ * Example: "login-validation.feature" -> "login-validation"
+ */
+function extractTestSuiteNameFromFilename(filePath: string): string {
+  const fileName = filePath.split(/[/\\]/).pop() || ''
+  return fileName.replace(/\.feature$/, '')
+}
+
+/**
+ * Splits a tag line that may contain multiple tags separated by spaces
+ * Example: "@smoke @demo" -> ["@smoke", "@demo"]
+ */
+function splitTagLine(tagLine: string): string[] {
+  return tagLine
+    .split(/\s+/)
+    .filter(tag => tag.trim().startsWith('@'))
+    .map(tag => tag.trim())
+}
+
+/**
+ * Extracts feature-level tags from parsed feature
+ * Handles tags on the same line separated by spaces
+ */
+function extractFeatureLevelTags(parsedFeature: ParsedFeature): string[] {
+  const tags: string[] = []
+  
+  for (const tagLine of parsedFeature.tags) {
+    if (tagLine.startsWith('@')) {
+      const splitTags = splitTagLine(tagLine)
+      tags.push(...splitTags)
+    }
+  }
+  
+  return tags
+}
+
+/**
+ * Scans feature files and extracts test suite information
+ */
+async function scanTestSuitesFromFilesystem(featuresDir: string): Promise<TestSuiteFromFS[]> {
+  const testSuites: TestSuiteFromFS[] = []
+  
+  console.log('📁 Scanning feature files...')
+  const parsedFeatures = await scanFeatureFiles(featuresDir)
+  console.log(`   Found ${parsedFeatures.length} feature file(s)`)
+  
+  for (const parsedFeature of parsedFeatures) {
+    try {
+      const testSuiteName = extractTestSuiteNameFromFilename(parsedFeature.filePath)
+      const modulePath = extractModulePathFromFilePath(parsedFeature.filePath, featuresDir)
+      const tags = extractFeatureLevelTags(parsedFeature)
+      
+      testSuites.push({
+        name: testSuiteName,
+        description: parsedFeature.featureDescription || null,
+        modulePath,
+        tags,
+        filePath: parsedFeature.filePath,
+      })
+    } catch (error) {
+      console.error(`   ❌ Error processing feature file '${parsedFeature.filePath}': ${error}`)
+    }
+  }
+  
+  return testSuites
+}
+
+/**
+ * Finds tags by tagExpression and returns their IDs
+ * Returns empty array for tags that don't exist (logs warning)
+ */
+async function findTagIdsByExpressions(tagExpressions: string[]): Promise<string[]> {
+  const tagIds: string[] = []
+  
+  for (const tagExpression of tagExpressions) {
+    try {
+      const tag = await prisma.tag.findFirst({
+        where: { tagExpression },
+      })
+      
+      if (tag) {
+        tagIds.push(tag.id)
+      } else {
+        console.log(`   ⚠️  Tag '${tagExpression}' not found in database (skipping tag link)`)
+      }
+    } catch (error) {
+      console.error(`   ❌ Error finding tag '${tagExpression}': ${error}`)
+    }
+  }
+  
+  return tagIds
+}
+
+/**
+ * Syncs test suites from filesystem to database
+ */
+async function syncTestSuitesToDatabase(
+  testSuitesFromFS: TestSuiteFromFS[],
+  result: SyncResult,
+): Promise<void> {
+  console.log('\n✅ Syncing test suites to database...')
+  
+  // Track test suites from filesystem (by name + modulePath)
+  const fsTestSuiteKeys = new Set<string>()
+  
+  for (const testSuite of testSuitesFromFS) {
+    try {
+      const key = `${testSuite.name}::${testSuite.modulePath}`
+      fsTestSuiteKeys.add(key)
+      
+      // Ensure module exists
+      let moduleId = await findModuleByPath(testSuite.modulePath)
+      
+      if (!moduleId) {
+        console.log(`   📦 Creating module hierarchy for path: ${testSuite.modulePath}`)
+        moduleId = await buildModuleHierarchy(testSuite.modulePath)
+      }
+      
+      // Find existing test suite by name and moduleId
+      const existingTestSuite = await prisma.testSuite.findFirst({
+        where: {
+          name: testSuite.name,
+          moduleId: moduleId,
+        },
+        include: {
+          tags: true,
+        },
+      })
+      
+      // Find tag IDs
+      const tagIds = await findTagIdsByExpressions(testSuite.tags)
+      
+      if (existingTestSuite) {
+        // Check if update is needed
+        const currentTagIds = existingTestSuite.tags.map(t => t.id).sort()
+        const newTagIds = tagIds.sort()
+        const tagsChanged = JSON.stringify(currentTagIds) !== JSON.stringify(newTagIds)
+        
+        const needsUpdate =
+          existingTestSuite.description !== (testSuite.description || null) ||
+          existingTestSuite.moduleId !== moduleId ||
+          tagsChanged
+        
+        if (needsUpdate) {
+          // Get existing test cases to explicitly preserve them
+          const existingTestCases = await prisma.testCase.findMany({
+            where: {
+              TestSuite: {
+                some: {
+                  id: existingTestSuite.id,
+                },
+              },
+            },
+            select: { id: true },
+          })
+          
+          const testCaseCount = existingTestCases.length
+          if (testCaseCount > 0) {
+            console.log(
+              `   ℹ️  Preserving ${testCaseCount} existing test case(s) for '${testSuite.name}' (${testSuite.modulePath})`,
+            )
+          }
+          
+          // Update test suite - explicitly preserve test cases by reconnecting them
+          // Only update description, moduleId, and tags
+          await prisma.testSuite.update({
+            where: { id: existingTestSuite.id },
+            data: {
+              description: testSuite.description || null,
+              moduleId: moduleId,
+              tags: {
+                set: tagIds.map(id => ({ id })),
+              },
+              // Explicitly preserve test cases by reconnecting them
+              // This ensures they are not removed during the update
+              testCases: existingTestCases.length > 0
+                ? {
+                    set: existingTestCases.map(tc => ({ id: tc.id })),
+                  }
+                : undefined,
+            },
+          })
+          
+          result.testSuitesUpdated++
+          result.updatedTestSuites.push({
+            name: testSuite.name,
+            modulePath: testSuite.modulePath,
+          })
+          console.log(`   🔄 Updated test suite '${testSuite.name}' (${testSuite.modulePath})`)
+        } else {
+          result.testSuitesExisting++
+          console.log(`   ✓ Test suite '${testSuite.name}' (${testSuite.modulePath}) already up to date`)
+        }
+      } else {
+        // Create new test suite
+        await prisma.testSuite.create({
+          data: {
+            name: testSuite.name,
+            description: testSuite.description || null,
+            moduleId: moduleId,
+            tags: tagIds.length > 0 ? { connect: tagIds.map(id => ({ id })) } : undefined,
+          },
+        })
+        
+        result.testSuitesCreated++
+        result.createdTestSuites.push({
+          name: testSuite.name,
+          modulePath: testSuite.modulePath,
+        })
+        console.log(`   ➕ Created test suite '${testSuite.name}' (${testSuite.modulePath})`)
+      }
+    } catch (error) {
+      const errorMsg = `Error processing test suite '${testSuite.name}' from ${testSuite.filePath}: ${error}`
+      result.errors.push(errorMsg)
+      console.error(`   ❌ ${errorMsg}`)
+    }
+  }
+  
+  // Delete orphaned test suites (test suites in DB but not in FS)
+  console.log('\n🔍 Checking for orphaned test suites (not in filesystem)...')
+  const allDbTestSuites = await prisma.testSuite.findMany({
+    include: {
+      module: true,
+    },
+  })
+  
+  // Get all modules with their paths
+  const modulesWithPaths = await getAllModulesWithPaths()
+  const modulePathMap = new Map<string, string>()
+  for (const mod of modulesWithPaths) {
+    modulePathMap.set(mod.id, mod.path)
+  }
+  
+  for (const dbTestSuite of allDbTestSuites) {
+    try {
+      const modulePath = modulePathMap.get(dbTestSuite.moduleId) || '/'
+      const key = `${dbTestSuite.name}::${modulePath}`
+      
+      if (!fsTestSuiteKeys.has(key)) {
+        // Check if test suite has test cases (for logging)
+        const testSuiteWithCases = await prisma.testSuite.findUnique({
+          where: { id: dbTestSuite.id },
+          include: {
+            testCases: { select: { id: true } },
+          },
+        })
+        
+        if (testSuiteWithCases && testSuiteWithCases.testCases.length > 0) {
+          console.log(
+            `   ⚠️  Test suite '${dbTestSuite.name}' (${modulePath}) has ${testSuiteWithCases.testCases.length} test case(s) - will be cascade deleted`,
+          )
+        }
+        
+        // Delete the test suite (Prisma cascade will handle test cases)
+        await prisma.testSuite.delete({
+          where: { id: dbTestSuite.id },
+        })
+        
+        result.testSuitesDeleted++
+        result.deletedTestSuites.push({
+          name: dbTestSuite.name,
+          modulePath: modulePath,
+        })
+        console.log(`   🗑️  Deleted test suite '${dbTestSuite.name}' (${modulePath}) (not in filesystem)`)
+      }
+    } catch (error) {
+      const errorMsg = `Error deleting test suite '${dbTestSuite.name}': ${error}`
+      result.errors.push(errorMsg)
+      console.error(`   ❌ ${errorMsg}`)
+    }
+  }
+}
+
+/**
+ * Generates and displays sync summary
+ */
+function generateSummary(result: SyncResult): void {
+  console.log('\n📊 Sync Summary:')
+  console.log(`   📁 Test suites scanned: ${result.testSuitesScanned}`)
+  console.log(`   ✅ Test suites existing: ${result.testSuitesExisting}`)
+  console.log(`   ➕ Test suites created: ${result.testSuitesCreated}`)
+  console.log(`   🔄 Test suites updated: ${result.testSuitesUpdated}`)
+  console.log(`   🗑️  Test suites deleted: ${result.testSuitesDeleted}`)
+  console.log(`   ❌ Errors: ${result.errors.length}`)
+  
+  if (result.createdTestSuites.length > 0) {
+    console.log('\n   Created test suites:')
+    result.createdTestSuites.forEach((ts, index) => {
+      console.log(`      ${index + 1}. ${ts.name} (${ts.modulePath})`)
+    })
+  }
+  
+  if (result.updatedTestSuites.length > 0) {
+    console.log('\n   Updated test suites:')
+    result.updatedTestSuites.forEach((ts, index) => {
+      console.log(`      ${index + 1}. ${ts.name} (${ts.modulePath})`)
+    })
+  }
+  
+  if (result.deletedTestSuites.length > 0) {
+    console.log('\n   Deleted test suites:')
+    result.deletedTestSuites.forEach((ts, index) => {
+      console.log(`      ${index + 1}. ${ts.name} (${ts.modulePath})`)
+    })
+  }
+  
+  if (result.errors.length > 0) {
+    console.log('\n   Errors:')
+    result.errors.forEach((error, index) => {
+      console.log(`      ${index + 1}. ${error}`)
+    })
+  }
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  try {
+    console.log('🔄 Starting test suites sync...')
+    console.log('This will scan feature files and sync test suites to database.')
+    console.log('Filesystem is the source of truth - test suites in DB but not in FS will be deleted.')
+    console.log('Note: Test cases are not synced by this script (they will be handled separately).\n')
+    
+    const baseDir = process.cwd()
+    const featuresDir = join(baseDir, 'src', 'tests', 'features')
+    
+    // Scan test suites from filesystem
+    const testSuitesFromFS = await scanTestSuitesFromFilesystem(featuresDir)
+    
+    if (testSuitesFromFS.length === 0) {
+      console.log('\n⚠️  No feature files found. Nothing to sync.')
+      return
+    }
+    
+    console.log(`\n📋 Found ${testSuitesFromFS.length} test suite(s) from feature files:`)
+    for (const ts of testSuitesFromFS) {
+      console.log(`   - ${ts.name} (${ts.modulePath})`)
+    }
+    
+    // Initialize result
+    const result: SyncResult = {
+      testSuitesScanned: testSuitesFromFS.length,
+      testSuitesExisting: 0,
+      testSuitesCreated: 0,
+      testSuitesUpdated: 0,
+      testSuitesDeleted: 0,
+      errors: [],
+      createdTestSuites: [],
+      updatedTestSuites: [],
+      deletedTestSuites: [],
+    }
+    
+    // Sync to database
+    await syncTestSuitesToDatabase(testSuitesFromFS, result)
+    
+    // Generate summary
+    generateSummary(result)
+    
+    if (result.errors.length === 0) {
+      console.log('\n✅ Sync completed successfully!')
+    } else {
+      console.log('\n⚠️  Sync completed with errors. Please review the errors above.')
+      process.exit(1)
+    }
+  } catch (error) {
+    console.error('\n❌ Error during sync:', error)
+    process.exit(1)
+  } finally {
+    await prisma.$disconnect()
+  }
+}
+
+main()

package/templates/default/src/actions/conflict/conflict.action.ts

@@ -0,0 +1,33 @@
+'use server'
+
+import { ActionResponse } from '@/types/form/actionHandler'
+import prisma from '@/config/db-config'
+import { revalidatePath } from 'next/cache'
+
+export async function resolveConflictsAction(conflictIds: string[]): Promise<ActionResponse> {
+  try {
+    const updatedConflicts = await prisma.conflictResolution.updateMany({
+      where: { entityId: { in: conflictIds } },
+      data: { resolved: true },
+    })
+
+    revalidatePath('/locators')
+
+    if (updatedConflicts.count === 0) {
+      return {
+        status: 404,
+        error: 'No conflicts found',
+      }
+    }
+    return {
+      status: 200,
+      data: updatedConflicts.count,
+      message: 'Conflicts resolved successfully',
+    }
+  } catch (error) {
+    return {
+      status: 500,
+      error: `Server error occurred: ${error}`,
+    }
+  }
+}

package/templates/default/src/actions/dashboard/dashboard-actions.ts

@@ -0,0 +1,241 @@
+'use server'
+
+import prisma from '@/config/db-config'
+import { ActionResponse } from '@/types/form/actionHandler'
+import { TestRunStatus, TestRunTestCaseResult } from '@prisma/client'
+
+export async function getDashboardMetricsAction(): Promise<ActionResponse> {
+  try {
+    const dashboardMetrics = await prisma.dashboardMetrics.findFirst()
+    return {
+      status: 200,
+      data: dashboardMetrics,
+    }
+  } catch (error) {
+    return {
+      status: 500,
+      error: `Server error occurred: ${error}`,
+    }
+  }
+}
+
+export type EntityMetrics = {
+  testCasesCount: number
+  testSuitesCount: number
+  templateStepsCount: number
+  runningTestRunsCount: number
+}
+
+export async function getEntityMetricsAction(): Promise<ActionResponse> {
+  try {
+    const testCases = await prisma.testCase.count()
+    const testSuites = await prisma.testSuite.count()
+    const templateSteps = await prisma.templateStep.count()
+    const runningTestRuns = await prisma.testRun.count({
+      where: {
+        status: {
+          in: [TestRunStatus.RUNNING, TestRunStatus.QUEUED, TestRunStatus.CANCELLING],
+        },
+      },
+    })
+    return {
+      status: 200,
+      data: {
+        testCasesCount: testCases,
+        testSuitesCount: testSuites,
+        templateStepsCount: templateSteps,
+        runningTestRunsCount: runningTestRuns,
+      },
+    }
+  } catch (error) {
+    return {
+      status: 500,
+      error: `Server error occurred: ${error}`,
+    }
+  }
+}
+
+/**
+ * Gets the count of ongoing test runs (RUNNING, QUEUED, or CANCELLING)
+ * Used for live tracking on the dashboard
+ */
+export async function getRunningTestRunsCountAction(): Promise<ActionResponse> {
+  try {
+    const count = await prisma.testRun.count({
+      where: {
+        status: {
+          in: [TestRunStatus.RUNNING, TestRunStatus.QUEUED, TestRunStatus.CANCELLING],
+        },
+      },
+    })
+    return {
+      status: 200,
+      data: count,
+    }
+  } catch (error) {
+    return {
+      status: 500,
+      error: `Server error occurred: ${error}`,
+    }
+  }
+}
+
+export type TestSuiteExecutionData = Array<{
+  feature: string
+  passed: number
+  failed: number
+  cancelled: number
+  unknown: number
+  total: number
+}>
+
+/**
+ * Gets test suite execution data from the last 10 completed test runs
+ * Returns pass/fail percentages per test suite
+ */
+export async function getTestSuiteExecutionDataAction(): Promise<ActionResponse> {
+  try {
+    // Fetch the last 10 completed test runs
+    const testRuns = await prisma.testRun.findMany({
+      where: {
+        status: TestRunStatus.COMPLETED,
+        completedAt: {
+          not: null,
+        },
+      },
+      orderBy: {
+        completedAt: 'desc',
+      },
+      take: 10,
+      select: {
+        id: true,
+      },
+    })
+
+    if (testRuns.length === 0) {
+      return {
+        status: 200,
+        data: [] as TestSuiteExecutionData,
+      }
+    }
+
+    const testRunIds = testRuns.map(tr => tr.id)
+
+    // Fetch reports for these test runs with test cases and their test suites
+    const reports = await prisma.report.findMany({
+      where: {
+        testRunId: {
+          in: testRunIds,
+        },
+      },
+      include: {
+        testCases: {
+          include: {
+            testRunTestCase: {
+              include: {
+                testCase: {
+                  include: {
+                    TestSuite: true,
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    })
+
+    // Aggregate data by test suite
+    const suiteDataMap = new Map<
+      string,
+      {
+        name: string
+        passed: number
+        failed: number
+        cancelled: number
+        unknown: number
+        total: number
+      }
+    >()
+
+    // Process each report's test cases
+    for (const report of reports) {
+      for (const reportTestCase of report.testCases) {
+        const testCase = reportTestCase.testRunTestCase.testCase
+        const result = reportTestCase.testRunTestCase.result
+
+        // A test case can belong to multiple test suites
+        for (const testSuite of testCase.TestSuite) {
+          const suiteId = testSuite.id
+          const suiteName = testSuite.name
+
+          if (!suiteDataMap.has(suiteId)) {
+            suiteDataMap.set(suiteId, {
+              name: suiteName,
+              passed: 0,
+              failed: 0,
+              cancelled: 0,
+              unknown: 0,
+              total: 0,
+            })
+          }
+
+          const suiteData = suiteDataMap.get(suiteId)!
+          suiteData.total++
+
+          switch (result) {
+            case TestRunTestCaseResult.PASSED:
+              suiteData.passed++
+              break
+            case TestRunTestCaseResult.FAILED:
+              suiteData.failed++
+              break
+            case TestRunTestCaseResult.UNTESTED:
+              suiteData.cancelled++
+              break
+            default:
+              suiteData.unknown++
+              break
+          }
+        }
+      }
+    }
+
+    // Convert counts to percentages and format for chart
+    const result: TestSuiteExecutionData = []
+
+    for (const [_suiteId, data] of suiteDataMap.entries()) {
+      const total = data.total
+      if (total === 0) continue
+
+      // Calculate percentages
+      const passed = total > 0 ? Number(((data.passed / total) * 100).toFixed(2)) : 0
+      const failed = total > 0 ? Number(((data.failed / total) * 100).toFixed(2)) : 0
+      const cancelled = total > 0 ? Number(((data.cancelled / total) * 100).toFixed(2)) : 0
+      const unknown = total > 0 ? Number(((data.unknown / total) * 100).toFixed(2)) : 0
+
+      result.push({
+        feature: data.name,
+        passed,
+        failed,
+        cancelled,
+        unknown,
+        total: 100, // Always 100 for percentage-based visualization
+      })
+    }
+
+    // Sort by test suite name for consistent display
+    result.sort((a, b) => a.feature.localeCompare(b.feature))
+
+    return {
+      status: 200,
+      data: result,
+    }
+  } catch (error) {
+    console.error('[DashboardActions] Error fetching test suite execution data:', error)
+    return {
+      status: 500,
+      error: `Server error occurred: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    }
+  }
+}