create-appraisejs 0.2.0-alpha.6 → 0.3.0-alpha.0

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

@@ -14,6 +14,10 @@ import { scanFeatureFiles, extractModulePathFromFilePath, ParsedFeature } from '
 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'
+import { extractTestSuiteNameFromFilename } from './lib/filename-utils'
+import { splitTagLine } from './lib/tag-parsing'
+import { printSyncSummary } from './lib/sync-summary'
+import { runSyncScript } from './lib/sync-script-runner'
 
 interface TestSuiteFromFS {
   name: string // From filename (without .feature extension)
@@ -35,26 +39,6 @@ interface SyncResult {
   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
@@ -314,49 +298,7 @@ async function syncTestSuitesToDatabase(
 /**
  * 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 {
+async function main(): Promise<SyncResult | void> {
     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.')
@@ -394,23 +336,34 @@ async function main() {
     // 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()
-  }
+    printSyncSummary(
+      [
+        { label: '📁 Test suites scanned', value: result.testSuitesScanned },
+        { label: '✅ Test suites existing', value: result.testSuitesExisting },
+        { label: '➕ Test suites created', value: result.testSuitesCreated },
+        { label: '🔄 Test suites updated', value: result.testSuitesUpdated },
+        { label: '🗑️  Test suites deleted', value: result.testSuitesDeleted },
+        { label: '❌ Errors', value: result.errors.length },
+      ],
+      [
+        {
+          title: 'Created test suites',
+          items: result.createdTestSuites.map(ts => `${ts.name} (${ts.modulePath})`),
+        },
+        {
+          title: 'Updated test suites',
+          items: result.updatedTestSuites.map(ts => `${ts.name} (${ts.modulePath})`),
+        },
+        {
+          title: 'Deleted test suites',
+          items: result.deletedTestSuites.map(ts => `${ts.name} (${ts.modulePath})`),
+        },
+        { title: 'Errors', items: result.errors },
+      ],
+    )
+    return result
 }
 
-main()
+runSyncScript(main)
 
 

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

@@ -1,241 +1,70 @@
-'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'}`,
-    }
-  }
-}
+'use server'
+
+import { ActionResponse } from '@/types/form/actionHandler'
+import {
+  getDashboardMetrics,
+  getEntityMetrics,
+  getRunningTestRunsCount,
+  getTestSuiteExecutionData,
+} from '@/services/dashboard/dashboard-service'
+import { unknownErrorToActionResponse } from '@/services/shared/errors'
+
+export async function getDashboardMetricsAction(): Promise<ActionResponse> {
+  try {
+    const dashboardMetrics = await getDashboardMetrics()
+    return {
+      status: 200,
+      success: true,
+      data: dashboardMetrics,
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export type EntityMetrics = {
+  testCasesCount: number
+  testSuitesCount: number
+  templateStepsCount: number
+  runningTestRunsCount: number
+}
+
+export async function getEntityMetricsAction(): Promise<ActionResponse> {
+  try {
+    const metrics = await getEntityMetrics()
+    return {
+      status: 200,
+      success: true,
+      data: metrics,
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function getRunningTestRunsCountAction(): Promise<ActionResponse> {
+  try {
+    const count = await getRunningTestRunsCount()
+    return {
+      status: 200,
+      success: true,
+      data: count,
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function getTestSuiteExecutionDataAction(): Promise<ActionResponse> {
+  try {
+    const data = await getTestSuiteExecutionData()
+    return {
+      status: 200,
+      success: true,
+      data,
+    }
+  } catch (error) {
+    console.error('[DashboardActions] Error fetching test suite execution data:', error)
+    return unknownErrorToActionResponse(error)
+  }
+}