create-appraisejs 0.2.0 → 0.3.0-alpha.1

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

@@ -1,416 +0,0 @@
-#!/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 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'
-import { ensureAutomationWorkspaceReady, getAutomationFeaturesDir } from '../src/lib/automation/paths'
-import { getTestSuiteSyncIdentity, getTestSuiteFilesystemKey } from '../src/lib/sync/projected-feature-utils'
-
-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 = getTestSuiteSyncIdentity(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 existingTestSuites = await prisma.testSuite.findMany({
-        where: {
-          moduleId: moduleId,
-        },
-        include: {
-          tags: true,
-        },
-      })
-      const existingTestSuite = existingTestSuites.find(
-        candidate => getTestSuiteFilesystemKey(candidate.name) === getTestSuiteFilesystemKey(testSuite.name),
-      )
-      
-      // 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 = getTestSuiteSyncIdentity(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')
-
-    await ensureAutomationWorkspaceReady()
-    const featuresDir = getAutomationFeaturesDir()
-    
-    // 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

@@ -1,33 +0,0 @@
-'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

@@ -1,241 +0,0 @@
-'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'}`,
-    }
-  }
-}