create-appraise 0.1.0

package/templates/default/src/lib/gherkin-parser.ts

@@ -0,0 +1,259 @@
+import { promises as fs } from 'fs'
+import { join, relative } from 'path'
+
+/**
+ * Represents a parsed feature file with its scenarios and steps
+ */
+export interface ParsedFeature {
+  filePath: string
+  featureName: string
+  featureDescription?: string
+  tags: string[]
+  scenarios: ParsedScenario[]
+}
+
+/**
+ * Represents a parsed scenario from a feature file
+ */
+export interface ParsedScenario {
+  name: string
+  description?: string
+  tags: string[]
+  steps: ParsedStep[]
+}
+
+/**
+ * Represents a parsed step from a feature file
+ */
+export interface ParsedStep {
+  keyword: string
+  text: string
+  order: number
+}
+
+/**
+ * Parses a Gherkin feature file and extracts scenarios and steps
+ * @param filePath - Path to the feature file
+ * @returns Promise<ParsedFeature | null> - Parsed feature data or null if parsing fails
+ */
+export async function parseFeatureFile(filePath: string): Promise<ParsedFeature | null> {
+  try {
+    const content = await fs.readFile(filePath, 'utf-8')
+
+    // Simple Gherkin parser implementation
+    const lines = content.split('\n').map(line => line.trim())
+    const scenarios: ParsedScenario[] = []
+
+    let featureName = ''
+    let featureDescription = ''
+    const featureTags: string[] = []
+    let currentScenario: ParsedScenario | null = null
+    let stepOrder = 1
+
+    // Find feature line and extract tags before it
+    let _featureLineIndex = -1
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].startsWith('Feature:')) {
+        _featureLineIndex = i
+        // Look backwards for tags (skip comments and empty lines)
+        for (let j = i - 1; j >= 0; j--) {
+          const prevLine = lines[j]
+          if (prevLine === '' || prevLine.startsWith('#')) {
+            continue
+          }
+          if (prevLine.startsWith('@')) {
+            featureTags.unshift(prevLine) // Add to beginning to maintain order
+          } else {
+            break // Stop when we hit a non-tag line
+          }
+        }
+        break
+      }
+    }
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i]
+
+      // Skip comments and empty lines
+      if (line.startsWith('#') || line === '') {
+        continue
+      }
+
+      // Parse Feature line
+      if (line.startsWith('Feature:')) {
+        featureName = line.replace('Feature:', '').trim()
+        // Look for description in next lines
+        let j = i + 1
+        while (j < lines.length && lines[j] && !lines[j].startsWith('Scenario:') && !lines[j].startsWith('Feature:')) {
+          if (lines[j] && !lines[j].startsWith('#')) {
+            featureDescription += (featureDescription ? ' ' : '') + lines[j]
+          }
+          j++
+        }
+        continue
+      }
+
+      // Parse Scenario line
+      if (line.startsWith('Scenario:')) {
+        // Save previous scenario if exists
+        if (currentScenario) {
+          scenarios.push(currentScenario)
+        }
+
+        // Extract tags before this scenario
+        const scenarioTags: string[] = []
+        for (let j = i - 1; j >= 0; j--) {
+          const prevLine = lines[j]
+          if (prevLine === '' || prevLine.startsWith('#')) {
+            continue
+          }
+          if (prevLine.startsWith('@')) {
+            scenarioTags.unshift(prevLine) // Add to beginning to maintain order
+          } else {
+            break // Stop when we hit a non-tag line
+          }
+        }
+
+        const scenarioText = line.replace('Scenario:', '').trim()
+        const [name, description] =
+          scenarioText.split(']').length > 1
+            ? [scenarioText.split(']')[1].trim(), scenarioText.split(']')[0].replace('[', '').trim()]
+            : [scenarioText, '']
+
+        currentScenario = {
+          name: name,
+          description: description || undefined,
+          tags: scenarioTags,
+          steps: [],
+        }
+        stepOrder = 1
+        continue
+      }
+
+      // Parse steps (Given, When, Then, And, But)
+      if (
+        currentScenario &&
+        (line.startsWith('Given ') ||
+          line.startsWith('When ') ||
+          line.startsWith('Then ') ||
+          line.startsWith('And ') ||
+          line.startsWith('But '))
+      ) {
+        const keyword = line.split(' ')[0]
+        const text = line.substring(keyword.length).trim()
+
+        currentScenario.steps.push({
+          keyword: keyword,
+          text: text,
+          order: stepOrder++,
+        })
+      }
+    }
+
+    // Add the last scenario
+    if (currentScenario) {
+      scenarios.push(currentScenario)
+    }
+
+    if (!featureName) {
+      console.warn(`No feature found in file: ${filePath}`)
+      return null
+    }
+
+    return {
+      filePath,
+      featureName,
+      featureDescription: featureDescription || undefined,
+      tags: featureTags,
+      scenarios,
+    }
+  } catch (error) {
+    console.error(`Error parsing feature file ${filePath}:`, error)
+    return null
+  }
+}
+
+/**
+ * Scans a directory for feature files and parses them
+ * @param directoryPath - Path to scan for feature files
+ * @returns Promise<ParsedFeature[]> - Array of parsed feature files
+ */
+export async function scanFeatureFiles(directoryPath: string): Promise<ParsedFeature[]> {
+  const parsedFeatures: ParsedFeature[] = []
+
+  try {
+    const entries = await fs.readdir(directoryPath, { withFileTypes: true })
+
+    for (const entry of entries) {
+      const fullPath = join(directoryPath, entry.name)
+
+      if (entry.isDirectory()) {
+        // Recursively scan subdirectories
+        const subFeatures = await scanFeatureFiles(fullPath)
+        parsedFeatures.push(...subFeatures)
+      } else if (entry.isFile() && entry.name.endsWith('.feature')) {
+        // Parse feature file
+        const parsedFeature = await parseFeatureFile(fullPath)
+        if (parsedFeature) {
+          parsedFeatures.push(parsedFeature)
+        }
+      }
+    }
+  } catch (error) {
+    console.error(`Error scanning directory ${directoryPath}:`, error)
+  }
+
+  return parsedFeatures
+}
+
+/**
+ * Extracts module path from feature file path
+ * Works cross-platform (Windows, Mac, Linux)
+ * @param featureFilePath - Full path to the feature file
+ * @param featuresBaseDir - Base directory for features
+ * @returns string - Module path (e.g., "/module1/submodule")
+ */
+export function extractModulePathFromFilePath(featureFilePath: string, featuresBaseDir: string): string {
+  // Use path.relative for cross-platform path handling
+  const relativePath = relative(featuresBaseDir, featureFilePath)
+
+  // Normalize to forward slashes for module path format (database uses /)
+  const normalizedPath = relativePath.replace(/\\/g, '/')
+  const pathParts = normalizedPath.split('/').filter(part => part && part !== '')
+
+  // Remove the filename and join the remaining parts
+  const moduleParts = pathParts.slice(0, -1)
+  return moduleParts.length > 0 ? '/' + moduleParts.join('/') : '/'
+}
+
+/**
+ * Generates a safe test suite name from feature name
+ * @param featureName - Name of the feature
+ * @returns string - Safe test suite name
+ */
+export function generateSafeTestSuiteName(featureName: string): string {
+  return featureName
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]+/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+/**
+ * Generates a safe test case name from scenario name
+ * @param scenarioName - Name of the scenario
+ * @returns string - Safe test case name
+ */
+export function generateSafeTestCaseName(scenarioName: string): string {
+  // Remove scenario prefix if present and clean up the name
+  const cleanName = scenarioName
+    .replace(/^Scenario:\s*/i, '')
+    .replace(/^\[.*?\]\s*/, '') // Remove [brackets] prefix
+    .trim()
+
+  return cleanName
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]+/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+}

package/templates/default/src/lib/locator-group-file-utils.ts

@@ -0,0 +1,370 @@
+import { promises as fs } from 'fs'
+import path from 'path'
+import prisma from '@/config/db-config'
+import { buildModulePath } from '@/lib/path-helpers/module-path'
+
+/**
+ * Gets the file path for a locator group based on its module hierarchy
+ */
+export async function getLocatorGroupFilePath(locatorGroupId: string): Promise<string | null> {
+  try {
+    const locatorGroup = await prisma.locatorGroup.findUnique({
+      where: { id: locatorGroupId },
+      include: { module: true },
+    })
+
+    if (!locatorGroup) return null
+
+    const allModules = await prisma.module.findMany()
+    const modulePath = buildModulePath(allModules, locatorGroup.module)
+
+    const sanitizedPath = modulePath.replace(/^\//, '').replace(/\//g, path.sep)
+    const fileName = `${locatorGroup.name}.json`
+
+    return path.join('src', 'tests', 'locators', sanitizedPath, fileName)
+  } catch (error) {
+    console.error('Error getting locator group file path:', error)
+    return null
+  }
+}
+
+/**
+ * Generates JSON content for a locator group from its locators
+ */
+export async function generateLocatorGroupContent(locatorGroupId: string): Promise<Record<string, string>> {
+  try {
+    const locatorGroup = await prisma.locatorGroup.findUnique({
+      where: { id: locatorGroupId },
+      include: {
+        locators: {
+          select: { name: true, value: true },
+        },
+      },
+    })
+
+    if (!locatorGroup) return {}
+
+    return Object.fromEntries(locatorGroup.locators.map(locator => [locator.name, locator.value]))
+  } catch (error) {
+    console.error('Error generating locator group content:', error)
+    return {}
+  }
+}
+
+/**
+ * Ensures a directory exists, creating it if necessary
+ */
+export async function ensureDirectoryExists(filePath: string): Promise<void> {
+  const dir = path.dirname(filePath)
+  try {
+    await fs.access(dir)
+  } catch {
+    await fs.mkdir(dir, { recursive: true })
+  }
+}
+
+/**
+ * Creates or updates a locator group JSON file
+ */
+export async function createOrUpdateLocatorGroupFile(locatorGroupId: string): Promise<boolean> {
+  try {
+    const filePath = await getLocatorGroupFilePath(locatorGroupId)
+    if (!filePath) return false
+
+    await ensureDirectoryExists(filePath)
+    const content = await generateLocatorGroupContent(locatorGroupId)
+
+    await fs.writeFile(filePath, JSON.stringify(content, null, 2))
+    return true
+  } catch (error) {
+    console.error('Error creating/updating locator group file:', error)
+    return false
+  }
+}
+
+/**
+ * Deletes a locator group JSON file and cleans up empty directories
+ */
+export async function deleteLocatorGroupFile(locatorGroupId: string): Promise<boolean> {
+  try {
+    const filePath = await getLocatorGroupFilePath(locatorGroupId)
+    if (!filePath) return false
+
+    // 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)
+    await cleanupEmptyDirectories(filePath)
+    return true
+  } catch (error) {
+    console.error('Error deleting locator group file:', error)
+    return false
+  }
+}
+
+/**
+ * Renames a locator group file when the name changes
+ */
+export async function renameLocatorGroupFile(
+  oldLocatorGroupId: string,
+  newName: string,
+  oldName?: string,
+): Promise<boolean> {
+  try {
+    // Get the current file path (with new name) for the directory
+    const currentFilePath = await getLocatorGroupFilePath(oldLocatorGroupId)
+    if (!currentFilePath) return false
+
+    // If oldName is provided, construct the old file path manually
+    // Otherwise, try to get it from the current path (fallback)
+    let oldFilePath: string
+    if (oldName) {
+      oldFilePath = path.join(path.dirname(currentFilePath), `${oldName}.json`)
+    } else {
+      oldFilePath = currentFilePath
+    }
+
+    const newFilePath = path.join(path.dirname(currentFilePath), `${newName}.json`)
+
+    try {
+      await fs.access(oldFilePath)
+      console.log('oldFilePath exists:', oldFilePath)
+      await fs.rename(oldFilePath, newFilePath)
+      console.log('File renamed successfully from', oldFilePath, 'to', newFilePath)
+    } catch (error) {
+      console.log('File not found at old path, creating new one:', error)
+      // File doesn't exist, create new one
+      return await createOrUpdateLocatorGroupFile(oldLocatorGroupId)
+    }
+
+    return true
+  } catch (error) {
+    console.error('Error renaming locator group file:', error)
+    return false
+  }
+}
+
+/**
+ * Moves a locator group file when the module changes
+ */
+export async function moveLocatorGroupFile(locatorGroupId: string): Promise<boolean> {
+  try {
+    // Delete old file and create new one in correct location
+    await deleteLocatorGroupFile(locatorGroupId)
+    return await createOrUpdateLocatorGroupFile(locatorGroupId)
+  } catch (error) {
+    console.error('Error moving locator group file:', error)
+    return false
+  }
+}
+
+/**
+ * Cleans up empty directories recursively
+ */
+async function cleanupEmptyDirectories(filePath: string): Promise<void> {
+  let currentDir = path.dirname(filePath)
+
+  while (currentDir !== 'tests' && currentDir !== '.') {
+    try {
+      const files = await fs.readdir(currentDir)
+      if (files.length === 0) {
+        await fs.rmdir(currentDir)
+        currentDir = path.dirname(currentDir)
+      } else {
+        break
+      }
+    } catch {
+      break
+    }
+  }
+}
+
+/**
+ * Creates an empty JSON file for a new locator group
+ */
+export async function createEmptyLocatorGroupFile(locatorGroupId: string): Promise<boolean> {
+  try {
+    const filePath = await getLocatorGroupFilePath(locatorGroupId)
+    if (!filePath) return false
+
+    await ensureDirectoryExists(filePath)
+    await fs.writeFile(filePath, JSON.stringify({}, null, 2))
+    return true
+  } catch (error) {
+    console.error('Error creating empty locator group file:', error)
+    return false
+  }
+}
+
+/**
+ * Reads and parses the content of a locator group file
+ */
+export async function readLocatorGroupFile(
+  locatorGroupId: string,
+): Promise<{ filePath: string; content: Record<string, string> } | null> {
+  try {
+    const filePath = await getLocatorGroupFilePath(locatorGroupId)
+    if (!filePath) return null
+
+    const fileContent = await fs.readFile(filePath, 'utf-8')
+    const jsonContent = JSON.parse(fileContent)
+
+    return { filePath, content: jsonContent }
+  } catch (error) {
+    console.error('Error reading locator group file:', error)
+    return null
+  }
+}
+
+/**
+ * Updates the locator map file with locator group information
+ * Overload for updating existing entries (4 parameters)
+ */
+export async function updateLocatorMapFile(
+  currentLocatorGroupRoute: string,
+  newLocatorGroupRoute: string,
+  currentLocatorGroupName: string,
+  newLocatorGroupName: string,
+): Promise<boolean>
+
+/**
+ * Updates the locator map file with locator group information
+ * Overload for adding new entries (2 parameters)
+ */
+export async function updateLocatorMapFile(newLocatorGroupName: string, newLocatorGroupRoute: string): Promise<boolean>
+
+/**
+ * Implementation of updateLocatorMapFile with proper overload handling
+ */
+export async function updateLocatorMapFile(
+  param1: string,
+  param2: string,
+  param3?: string,
+  param4?: string,
+): Promise<boolean> {
+  try {
+    const locatorMapPath = path.join('src', 'tests', 'mapping', 'locator-map.json')
+
+    // Ensure the mapping directory exists
+    await ensureDirectoryExists(locatorMapPath)
+
+    let locatorMap: Array<{ name: string; path: string }> = []
+
+    // Read existing locator map or create empty array
+    try {
+      const fileContent = await fs.readFile(locatorMapPath, 'utf-8')
+      locatorMap = JSON.parse(fileContent)
+    } catch {
+      // File doesn't exist, start with empty array
+      locatorMap = []
+    }
+
+    // Determine if this is a 2-param call (new entry) or 4-param call (update)
+    const isNewEntry = param3 === undefined && param4 === undefined
+
+    if (isNewEntry) {
+      // 2 params: newLocatorGroupName, newLocatorGroupRoute
+      const name = param1
+      const route = param2
+
+      // Check for uniqueness
+      const existingEntry = locatorMap.find(entry => entry.name === name)
+      if (existingEntry) {
+        console.error(`Locator group with name "${name}" already exists in locator map`)
+        return false
+      }
+
+      // Add new entry
+      locatorMap.push({ name, path: route })
+    } else {
+      // 4 params: update existing entry
+      const currentLocatorGroupRoute = param1
+      const newLocatorGroupRoute = param2
+      const currentLocatorGroupName = param3!
+      const newLocatorGroupName = param4!
+
+      // Find the entry to update
+      const entryIndex = locatorMap.findIndex(entry => entry.name === currentLocatorGroupName)
+      if (entryIndex === -1) {
+        console.error(`Locator group with name "${currentLocatorGroupName}" not found in locator map`)
+        return false
+      }
+
+      // Check if new name is unique (if name is changing)
+      if (currentLocatorGroupName !== newLocatorGroupName) {
+        const existingEntry = locatorMap.find(entry => entry.name === newLocatorGroupName)
+        if (existingEntry) {
+          console.error(`Locator group with name "${newLocatorGroupName}" already exists in locator map`)
+          return false
+        }
+      }
+
+      // Update the entry
+      const updatedEntry = { ...locatorMap[entryIndex] }
+
+      // Update name if it changed
+      if (currentLocatorGroupName !== newLocatorGroupName) {
+        updatedEntry.name = newLocatorGroupName
+      }
+
+      // Update path if it changed
+      if (currentLocatorGroupRoute !== newLocatorGroupRoute) {
+        updatedEntry.path = newLocatorGroupRoute
+      }
+
+      locatorMap[entryIndex] = updatedEntry
+    }
+
+    // Write the updated locator map back to file
+    await fs.writeFile(locatorMapPath, JSON.stringify(locatorMap, null, 2))
+    return true
+  } catch (error) {
+    console.error('Error updating locator map file:', error)
+    return false
+  }
+}
+
+/**
+ * Removes locator group entries from the locator map file
+ * @param locatorGroupNames - Array of locator group names to remove
+ */
+export async function removeLocatorMapEntry(locatorGroupNames: string[]): Promise<boolean> {
+  try {
+    const locatorMapPath = path.join('src', 'tests', 'mapping', 'locator-map.json')
+
+    // Check if file exists
+    try {
+      await fs.access(locatorMapPath)
+    } catch {
+      // File doesn't exist, nothing to remove
+      return true
+    }
+
+    // Read existing locator map
+    const fileContent = await fs.readFile(locatorMapPath, 'utf-8')
+    let locatorMap: Array<{ name: string; path: string }> = JSON.parse(fileContent)
+
+    // Filter out the entries to be removed
+    const originalLength = locatorMap.length
+    locatorMap = locatorMap.filter(entry => !locatorGroupNames.includes(entry.name))
+
+    // Check if any entries were actually removed
+    const removedCount = originalLength - locatorMap.length
+    if (removedCount === 0) {
+      console.log('No matching locator group entries found in locator map')
+      return true
+    }
+
+    // Write the updated locator map back to file
+    await fs.writeFile(locatorMapPath, JSON.stringify(locatorMap, null, 2))
+    console.log(`Removed ${removedCount} locator group entry(ies) from locator map`)
+    return true
+  } catch (error) {
+    console.error('Error removing locator map entries:', error)
+    return false
+  }
+}