create-appraisejs 0.3.0-alpha.0 → 0.3.0

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

@@ -0,0 +1,369 @@
+#!/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'
+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)
+  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 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
+ */
+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.')
+    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)
+    
+    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
+}
+
+runSyncScript(main)
+
+

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

@@ -0,0 +1,70 @@
+'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)
+  }
+}

package/templates/starter/src/actions/environments/environment-actions.ts

@@ -0,0 +1,102 @@
+'use server'
+
+import { environmentSchema } from '@/constants/form-opts/environment-form-opts'
+import {
+  createEnvironment,
+  deleteEnvironments,
+  getEnvironmentByIdOrThrow,
+  listEnvironments,
+  updateEnvironment,
+} from '@/services/environment/environment-service'
+import { ServiceError, serviceErrorToActionResponse, unknownErrorToActionResponse } from '@/services/shared/errors'
+import { ActionResponse } from '@/types/form/actionHandler'
+import { revalidatePath } from 'next/cache'
+import { z } from 'zod'
+
+export async function getAllEnvironmentsAction(): Promise<ActionResponse> {
+  try {
+    const environments = await listEnvironments()
+    return {
+      status: 200,
+      success: true,
+      data: environments,
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function deleteEnvironmentAction(ids: string[]): Promise<ActionResponse> {
+  try {
+    await deleteEnvironments(ids)
+    revalidatePath('/environments')
+    return {
+      status: 200,
+      success: true,
+      message: 'Environments deleted successfully',
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function createEnvironmentAction(
+  _prev: unknown,
+  value: z.infer<typeof environmentSchema>,
+): Promise<ActionResponse> {
+  try {
+    environmentSchema.parse(value)
+    const newEnvironment = await createEnvironment(value)
+    revalidatePath('/environments')
+    return {
+      status: 200,
+      success: true,
+      data: newEnvironment,
+      message: 'Environment created successfully',
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function getEnvironmentByIdAction(id: string): Promise<ActionResponse> {
+  try {
+    const environmentData = await getEnvironmentByIdOrThrow(id)
+    return {
+      status: 200,
+      success: true,
+      data: environmentData,
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function updateEnvironmentAction(
+  _prev: unknown,
+  value: z.infer<typeof environmentSchema>,
+  id?: string,
+): Promise<ActionResponse> {
+  try {
+    environmentSchema.parse(value)
+    const updatedEnvironment = await updateEnvironment(id, value)
+    revalidatePath('/environments')
+    return {
+      status: 200,
+      success: true,
+      data: updatedEnvironment,
+      message: 'Environment updated successfully',
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}

package/templates/starter/src/actions/locator/locator-actions.ts

@@ -0,0 +1,77 @@
+'use server'
+
+import { ActionResponse } from '@/types/form/actionHandler'
+import { revalidatePath } from 'next/cache'
+import {
+  deleteLocators,
+  getLocatorByIdOrThrow,
+  listLocators,
+  syncLocatorsFromFiles,
+} from '@/services/locator/locator-service'
+import { ServiceError, serviceErrorToActionResponse, unknownErrorToActionResponse } from '@/services/shared/errors'
+
+export async function getAllLocatorsAction(): Promise<ActionResponse> {
+  try {
+    const locators = await listLocators()
+    return {
+      status: 200,
+      success: true,
+      data: locators,
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function deleteLocatorAction(ids: string[]): Promise<ActionResponse> {
+  try {
+    const locator = await deleteLocators(ids)
+
+    revalidatePath('/locators')
+    return {
+      status: 200,
+      success: true,
+      data: locator,
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function getLocatorByIdAction(id: string): Promise<ActionResponse> {
+  try {
+    const locator = await getLocatorByIdOrThrow(id)
+    return {
+      status: 200,
+      success: true,
+      data: locator,
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function syncLocatorsFromFilesAction(): Promise<ActionResponse> {
+  try {
+    const result = await syncLocatorsFromFiles()
+
+    revalidatePath('/locators')
+
+    return {
+      status: 200,
+      success: true,
+      data: {
+        locatorsCreated: result.locatorsCreated,
+        locatorsMergedToFile: result.locatorsMergedToFile,
+        conflicts: result.conflicts,
+        errors: result.errors,
+      },
+      message: `Created ${result.locatorsCreated} locators, merged ${result.locatorsMergedToFile} into files, ${result.conflicts} conflicts detected`,
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}