create-appraise 0.1.0

package/templates/default/src/lib/environment-file-utils.ts

@@ -0,0 +1,221 @@
+import { promises as fs } from 'fs'
+import * as path from 'path'
+import prisma from '@/config/db-config'
+
+interface EnvironmentConfig {
+  baseUrl: string
+  apiBaseUrl: string
+  email: string
+  password: string
+}
+
+/**
+ * Gets the file path for the environments.json file
+ */
+export function getEnvironmentsFilePath(): string {
+  return path.join('src', 'tests', 'config', 'environments', 'environments.json')
+}
+
+/**
+ * Ensures the config directory exists
+ */
+export async function ensureConfigDirectoryExists(): Promise<void> {
+  const filePath = getEnvironmentsFilePath()
+  const dir = path.dirname(filePath)
+  try {
+    await fs.access(dir)
+  } catch {
+    await fs.mkdir(dir, { recursive: true })
+  }
+}
+
+/**
+ * Generates JSON content for environments from database
+ */
+export async function generateEnvironmentsContent(): Promise<Record<string, EnvironmentConfig>> {
+  try {
+    const environments = await prisma.environment.findMany({
+      orderBy: { createdAt: 'asc' },
+    })
+
+    const environmentsConfig: Record<string, EnvironmentConfig> = {}
+
+    environments.forEach(env => {
+      const envKey = env.name.toLowerCase().replace(/\s+/g, '_')
+      environmentsConfig[envKey] = {
+        baseUrl: env.baseUrl,
+        apiBaseUrl: env.apiBaseUrl || '',
+        email: env.username || '',
+        password: env.password || '',
+      }
+    })
+
+    return environmentsConfig
+  } catch (error) {
+    console.error('Error generating environments content:', error)
+    return {}
+  }
+}
+
+/**
+ * Creates or updates the environments.json file
+ */
+export async function createOrUpdateEnvironmentsFile(): Promise<boolean> {
+  try {
+    const filePath = getEnvironmentsFilePath()
+    await ensureConfigDirectoryExists()
+
+    const content = await generateEnvironmentsContent()
+
+    // If no environments exist, delete the file
+    if (Object.keys(content).length === 0) {
+      await deleteEnvironmentsFile()
+      return true
+    }
+
+    await fs.writeFile(filePath, JSON.stringify(content, null, 2))
+    return true
+  } catch (error) {
+    console.error('Error creating/updating environments file:', error)
+    return false
+  }
+}
+
+/**
+ * Deletes the environments.json file
+ */
+export async function deleteEnvironmentsFile(): Promise<boolean> {
+  try {
+    const filePath = getEnvironmentsFilePath()
+
+    // Check if file exists before trying to delete
+    try {
+      await fs.access(filePath)
+    } catch {
+      return true // File doesn't exist, nothing to delete
+    }
+
+    await fs.unlink(filePath)
+    return true
+  } catch (error) {
+    console.error('Error deleting environments file:', error)
+    return false
+  }
+}
+
+/**
+ * Reads and parses the content of the environments.json file
+ */
+export async function readEnvironmentsFile(): Promise<{
+  filePath: string
+  content: Record<string, EnvironmentConfig>
+} | null> {
+  try {
+    const filePath = getEnvironmentsFilePath()
+
+    try {
+      await fs.access(filePath)
+    } catch {
+      return null // File doesn't exist
+    }
+
+    const fileContent = await fs.readFile(filePath, 'utf-8')
+    const jsonContent = JSON.parse(fileContent)
+
+    return { filePath, content: jsonContent }
+  } catch (error) {
+    console.error('Error reading environments file:', error)
+    return null
+  }
+}
+
+/**
+ * Updates a specific environment entry in the environments.json file
+ */
+export async function updateEnvironmentEntry(environmentId: string, oldName?: string): Promise<boolean> {
+  try {
+    // Get the environment from database
+    const environment = await prisma.environment.findUnique({
+      where: { id: environmentId },
+    })
+
+    if (!environment) {
+      console.error(`Environment with ID ${environmentId} not found`)
+      return false
+    }
+
+    const filePath = getEnvironmentsFilePath()
+
+    // Read existing content
+    let environmentsConfig: Record<string, EnvironmentConfig> = {}
+    try {
+      await fs.access(filePath)
+      const fileContent = await fs.readFile(filePath, 'utf-8')
+      environmentsConfig = JSON.parse(fileContent)
+    } catch {
+      // File doesn't exist, start with empty object
+    }
+
+    // Remove old entry if name changed
+    if (oldName) {
+      const oldKey = oldName.toLowerCase().replace(/\s+/g, '_')
+      delete environmentsConfig[oldKey]
+    }
+
+    // Add/update the environment entry
+    const envKey = environment.name.toLowerCase().replace(/\s+/g, '_')
+    environmentsConfig[envKey] = {
+      baseUrl: environment.baseUrl,
+      apiBaseUrl: environment.apiBaseUrl || '',
+      email: environment.username || '',
+      password: environment.password || '',
+    }
+
+    // Ensure directory exists
+    await ensureConfigDirectoryExists()
+
+    // Write updated content
+    await fs.writeFile(filePath, JSON.stringify(environmentsConfig, null, 2))
+    return true
+  } catch (error) {
+    console.error('Error updating environment entry:', error)
+    return false
+  }
+}
+
+/**
+ * Removes a specific environment entry from the environments.json file
+ */
+export async function removeEnvironmentEntry(environmentName: string): Promise<boolean> {
+  try {
+    const filePath = getEnvironmentsFilePath()
+
+    // Check if file exists
+    try {
+      await fs.access(filePath)
+    } catch {
+      return true // File doesn't exist, nothing to remove
+    }
+
+    // Read existing content
+    const fileContent = await fs.readFile(filePath, 'utf-8')
+    const environmentsConfig: Record<string, EnvironmentConfig> = JSON.parse(fileContent)
+
+    // Remove the environment entry
+    const envKey = environmentName.toLowerCase().replace(/\s+/g, '_')
+    delete environmentsConfig[envKey]
+
+    // If no environments left, delete the file
+    if (Object.keys(environmentsConfig).length === 0) {
+      await deleteEnvironmentsFile()
+      return true
+    }
+
+    // Write updated content
+    await fs.writeFile(filePath, JSON.stringify(environmentsConfig, null, 2))
+    return true
+  } catch (error) {
+    console.error('Error removing environment entry:', error)
+    return false
+  }
+}

package/templates/default/src/lib/feature-file-generator.ts

@@ -0,0 +1,411 @@
+import { promises as fs } from 'fs'
+import { join, dirname } from 'path'
+import prisma from '@/config/db-config'
+import { buildModulePath } from '@/lib/path-helpers/module-path'
+
+/**
+ * Checks if a directory is empty (no files or subdirectories)
+ * @param dirPath - Path to the directory to check
+ * @returns Promise<boolean> - True if directory is empty, false otherwise
+ */
+async function isDirectoryEmpty(dirPath: string): Promise<boolean> {
+  try {
+    const entries = await fs.readdir(dirPath)
+    return entries.length === 0
+  } catch (error) {
+    // If directory doesn't exist or can't be read, consider it empty
+    console.warn(`Could not read directory ${dirPath}:`, error)
+    return true
+  }
+}
+
+/**
+ * Removes empty directories up the hierarchy until a non-empty directory is found
+ * @param dirPath - Starting directory path to clean up
+ * @param basePath - Base path to stop cleaning (e.g., features directory)
+ * @returns Promise<void>
+ */
+async function removeEmptyDirectoriesUp(dirPath: string, basePath: string): Promise<void> {
+  let currentPath = dirPath
+
+  // Keep going up the directory tree until we reach the base path
+  while (currentPath !== basePath && currentPath !== dirname(currentPath)) {
+    try {
+      // Check if current directory is empty
+      if (await isDirectoryEmpty(currentPath)) {
+        await fs.rmdir(currentPath)
+        console.log(`Removed empty directory: ${currentPath}`)
+        // Move up one level
+        currentPath = dirname(currentPath)
+      } else {
+        // Directory is not empty, stop cleaning
+        break
+      }
+    } catch (error) {
+      // If we can't remove the directory or it doesn't exist, stop
+      console.warn(`Could not remove directory ${currentPath}:`, error)
+      break
+    }
+  }
+}
+
+/**
+ * Generates a Gherkin feature file for a test suite
+ * @param testSuiteId - The ID of the test suite
+ * @param testSuiteName - The name of the test suite
+ * @param testSuiteDescription - The description of the test suite
+ * @param moduleName - The name of the module the test suite belongs to
+ * @returns Promise<string> - The path to the generated feature file
+ */
+export async function generateFeatureFile(
+  testSuiteId: string,
+  testSuiteName: string,
+  testSuiteDescription?: string,
+): Promise<string> {
+  try {
+    // Fetch test suite with test cases, steps, tags, and all modules for path building
+    const [testSuite, allModules] = await Promise.all([
+      prisma.testSuite.findUnique({
+        where: { id: testSuiteId },
+        include: {
+          testCases: {
+            include: {
+              steps: {
+                include: {
+                  parameters: true,
+                },
+                orderBy: {
+                  order: 'asc',
+                },
+              },
+              tags: true,
+            },
+          },
+          module: true,
+          tags: true,
+        },
+      }),
+      prisma.module.findMany(), // Get all modules to build hierarchy path
+    ])
+
+    if (!testSuite) {
+      throw new Error(`Test suite with ID ${testSuiteId} not found`)
+    }
+
+    // Build the module path for directory structure
+    const modulePath = buildModulePath(allModules, testSuite.module)
+
+    // Generate feature file content
+    const featureContent = generateFeatureContent(
+      testSuiteDescription || testSuiteName, // Use description as feature title, fallback to name
+      testSuite.testCases,
+      testSuite.tags,
+    )
+
+    // Create the features directory with module path
+    const featuresBaseDir = join(process.cwd(), 'src', 'tests', 'features')
+    const moduleDir = join(featuresBaseDir, modulePath.substring(1)) // Remove leading slash
+    await fs.mkdir(moduleDir, { recursive: true })
+
+    // Generate a safe filename from the test suite name only
+    const safeFileName = generateSafeFileName(testSuiteName)
+    const featureFilePath = join(moduleDir, `${safeFileName}.feature`)
+
+    // Write the feature file
+    await fs.writeFile(featureFilePath, featureContent, 'utf8')
+
+    return featureFilePath
+  } catch (error) {
+    console.error('Error generating feature file:', error)
+    throw error
+  }
+}
+
+/**
+ * Generates the content for a Gherkin feature file
+ */
+function generateFeatureContent(
+  featureTitle: string,
+  testCases: Array<{
+    title: string
+    description: string
+    steps: Array<{
+      gherkinStep: string
+      order: number
+    }>
+    tags?: Array<{
+      tagExpression: string
+    }>
+  }>,
+  testSuiteTags?: Array<{
+    tagExpression: string
+  }>,
+): string {
+  const lines: string[] = []
+
+  // Warning header
+  lines.push('# AUTO-GENERATED FILE - DO NOT EDIT MANUALLY')
+  lines.push('# This file is automatically generated from Test Suite data.')
+  lines.push('# Any manual changes will be overwritten when the Test Suite is updated.')
+  lines.push('# To modify this feature, update the corresponding Test Suite in the application.')
+  lines.push('')
+
+  // Add feature-level tags (one tag per line)
+  if (testSuiteTags && testSuiteTags.length > 0) {
+    testSuiteTags.forEach(tag => {
+      lines.push(tag.tagExpression)
+    })
+  }
+
+  // Feature header - use description as feature title
+  lines.push(`Feature: ${featureTitle}`)
+  lines.push('')
+
+  // Get test suite tag expressions for deduplication
+  const testSuiteTagExpressions = new Set((testSuiteTags || []).map(tag => tag.tagExpression.toLowerCase()))
+
+  // Generate scenarios for each test case that has steps
+  let scenarioCount = 0
+  testCases.forEach(testCase => {
+    // Only generate scenario if test case has steps
+    if (testCase.steps && testCase.steps.length > 0) {
+      // Generate Gherkin steps from test case steps
+      const gherkinSteps = generateGherkinStepsFromTestCase(testCase.steps)
+
+      // Only add scenario if there are actual gherkin steps
+      if (gherkinSteps.length > 0) {
+        if (scenarioCount > 0) {
+          lines.push('') // Add blank line between scenarios
+        }
+
+        // Add scenario-level tags (skip if already present at feature level)
+        if (testCase.tags && testCase.tags.length > 0) {
+          testCase.tags.forEach(tag => {
+            // Only add tag if it's not already present at feature level
+            if (!testSuiteTagExpressions.has(tag.tagExpression.toLowerCase())) {
+              lines.push(`  ${tag.tagExpression}`)
+            }
+          })
+        }
+
+        lines.push(`  Scenario: [${testCase.title}] ${testCase.description}`)
+
+        gherkinSteps.forEach(step => {
+          lines.push(`    ${step}`)
+        })
+
+        scenarioCount++
+      }
+    }
+  })
+
+  return lines.join('\n') + '\n'
+}
+
+/**
+ * Generates Gherkin steps from test case steps using the same logic as the frontend
+ */
+function generateGherkinStepsFromTestCase(
+  steps: Array<{
+    gherkinStep: string
+    order: number
+  }>,
+): string[] {
+  if (!steps || steps.length === 0) {
+    return []
+  }
+
+  // Sort steps by order
+  const sortedSteps = steps.sort((a, b) => a.order - b.order)
+
+  let hasThenInPrevious = false
+  let hasWhenInPrevious = false
+
+  return sortedSteps.map((step, index) => {
+    const gherkinStep = step.gherkinStep?.trim() || ''
+    const firstWord = gherkinStep.split(' ')[0].toLowerCase()
+    const hasGherkinKeyword = ['given', 'when', 'then', 'and', 'but'].includes(firstWord)
+    const stepWithoutKeyword = hasGherkinKeyword ? gherkinStep.split(' ').slice(1).join(' ') : gherkinStep
+
+    // First step always starts with Given
+    if (index === 0) {
+      return `Given ${stepWithoutKeyword}`
+    }
+
+    // Check if this step should be a Then statement
+    const isThenStatement =
+      firstWord === 'then' ||
+      stepWithoutKeyword.toLowerCase().startsWith('should') ||
+      stepWithoutKeyword.toLowerCase().startsWith('must') ||
+      stepWithoutKeyword.toLowerCase().startsWith('will')
+
+    // If we haven't seen a Then yet
+    if (!hasThenInPrevious) {
+      // If this is a Then statement
+      if (isThenStatement) {
+        hasThenInPrevious = true
+        return `Then ${stepWithoutKeyword}`
+      }
+
+      // If we haven't seen a When yet, use When
+      if (!hasWhenInPrevious) {
+        hasWhenInPrevious = true
+        return `When ${stepWithoutKeyword}`
+      }
+      // After When, use And
+      return `And ${stepWithoutKeyword}`
+    }
+
+    // After Then
+    if (isThenStatement) {
+      // If it's another Then statement, use And
+      return `And ${stepWithoutKeyword}`
+    }
+    // After Then, use When for new actions
+    hasThenInPrevious = false
+    hasWhenInPrevious = true
+    return `When ${stepWithoutKeyword}`
+  })
+}
+
+/**
+ * Deletes a feature file for a test suite
+ * @param testSuiteId - The ID of the test suite
+ * @returns Promise<boolean> - True if file was deleted, false if file didn't exist
+ */
+export async function deleteFeatureFile(testSuiteId: string): Promise<boolean> {
+  try {
+    // Fetch test suite and all modules to build the correct path
+    const [testSuite, allModules] = await Promise.all([
+      prisma.testSuite.findUnique({
+        where: { id: testSuiteId },
+        include: {
+          module: true,
+        },
+      }),
+      prisma.module.findMany(),
+    ])
+
+    if (!testSuite) {
+      console.warn(`Test suite with ID ${testSuiteId} not found for feature file deletion`)
+      return false
+    }
+
+    // Build the module path for directory structure
+    const modulePath = buildModulePath(allModules, testSuite.module)
+    const safeFileName = generateSafeFileName(testSuite.name)
+
+    const featuresBaseDir = join(process.cwd(), 'src', 'tests', 'features')
+    const moduleDir = join(featuresBaseDir, modulePath.substring(1)) // Remove leading slash
+    const featureFilePath = join(moduleDir, `${safeFileName}.feature`)
+
+    try {
+      await fs.unlink(featureFilePath)
+      console.log(`Feature file deleted: ${featureFilePath}`)
+
+      // Clean up empty directories up the module hierarchy
+      await removeEmptyDirectoriesUp(moduleDir, featuresBaseDir)
+
+      return true
+    } catch (error: unknown) {
+      if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+        console.warn(`Feature file not found for deletion: ${featureFilePath}`)
+        return false
+      }
+      throw error
+    }
+  } catch (error) {
+    console.error('Error deleting feature file:', error)
+    throw error
+  }
+}
+
+/**
+ * Regenerates all feature files from the current database state
+ * This is useful after merging changes or database migrations to ensure sync
+ * @returns Promise<string[]> - Array of generated feature file paths
+ */
+export async function regenerateAllFeatureFiles(): Promise<string[]> {
+  try {
+    console.log('Starting regeneration of all feature files...')
+
+    // Clear existing feature files directory
+    const featuresBaseDir = join(process.cwd(), 'src', 'tests', 'features')
+    try {
+      await fs.rm(featuresBaseDir, { recursive: true, force: true })
+    } catch (error) {
+      console.warn('Could not clear features directory:', error)
+    }
+
+    // Fetch all test suites from database
+    const testSuites = await prisma.testSuite.findMany({
+      include: {
+        testCases: {
+          include: {
+            steps: {
+              include: {
+                parameters: true,
+              },
+              orderBy: {
+                order: 'asc',
+              },
+            },
+            tags: true,
+          },
+        },
+        module: true,
+        tags: true,
+      },
+    })
+
+    // Fetch all modules for path building
+    const allModules = await prisma.module.findMany()
+
+    const generatedFiles: string[] = []
+
+    // Generate feature file for each test suite
+    for (const testSuite of testSuites) {
+      try {
+        const modulePath = buildModulePath(allModules, testSuite.module)
+        const featureContent = generateFeatureContent(
+          testSuite.description || testSuite.name,
+          testSuite.testCases,
+          testSuite.tags,
+        )
+
+        // Create the features directory with module path
+        const moduleDir = join(featuresBaseDir, modulePath.substring(1)) // Remove leading slash
+        await fs.mkdir(moduleDir, { recursive: true })
+
+        // Generate filename and write file
+        const safeFileName = generateSafeFileName(testSuite.name)
+        const featureFilePath = join(moduleDir, `${safeFileName}.feature`)
+
+        await fs.writeFile(featureFilePath, featureContent, 'utf8')
+        generatedFiles.push(featureFilePath)
+
+        console.log(`Generated: ${featureFilePath}`)
+      } catch (error) {
+        console.error(`Error generating feature file for test suite ${testSuite.name}:`, error)
+      }
+    }
+
+    console.log(`Regeneration complete. Generated ${generatedFiles.length} feature files.`)
+    return generatedFiles
+  } catch (error) {
+    console.error('Error during feature files regeneration:', error)
+    throw error
+  }
+}
+
+/**
+ * Generates a safe filename from test suite name
+ */
+function generateSafeFileName(testSuiteName: string): string {
+  // Convert to lowercase and replace spaces and special characters with hyphens
+  return testSuiteName
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '') // Remove leading/trailing hyphens
+    .replace(/-+/g, '-') // Replace multiple consecutive hyphens with single hyphen
+}