create-appraisejs 0.2.0 → 0.3.0-alpha.1

package/templates/default/src/lib/automation/paths.ts

@@ -1,211 +0,0 @@
-import { promises as fs } from 'fs'
-import path from 'path'
-
-const repoRoot = process.cwd()
-const automationRoot = path.join(repoRoot, 'automation')
-const legacyTestsRoot = path.join(repoRoot, 'src', 'tests')
-const runtimeImport =
-  "import { When, Then, CustomWorld, expect, SelectorName, resolveLocator, getEnvironment, generateRandomData, RandomDataType } from '../../../packages/cucumber-runtime/src/index.js'"
-const runtimeImportPattern =
-  /^import\s*\{[\s\S]*?\}\s*from\s*['"]\.\.\/\.\.\/\.\.\/packages\/cucumber-runtime\/src\/index(?:\.js)?['"];?\r?\n*/gm
-
-const mutableLegacyDirectories = ['features', 'locators', 'mapping', 'steps'] as const
-
-let automationWorkspaceReadyPromise: Promise<void> | null = null
-
-async function pathExists(targetPath: string): Promise<boolean> {
-  try {
-    await fs.access(targetPath)
-    return true
-  } catch {
-    return false
-  }
-}
-
-async function rewriteLegacyStepImports(): Promise<void> {
-  const stepsDir = getAutomationStepsDir()
-
-  if (!(await pathExists(stepsDir))) {
-    return
-  }
-
-  const stepFiles = await fs.readdir(stepsDir, { recursive: true })
-  for (const entry of stepFiles) {
-    if (typeof entry !== 'string' || !entry.endsWith('.ts')) {
-      continue
-    }
-
-    const filePath = path.join(stepsDir, entry)
-    let content = await fs.readFile(filePath, 'utf8')
-
-    content = content
-      .replace(runtimeImportPattern, '')
-      .replace(/^import \{ (When|Then) \} from '@cucumber\/cucumber';?\r?\n/gm, '')
-      .replace(/^import \{ CustomWorld(?:, expect)? \} from '\.\.\/\.\.\/config\/executor\/world\.js';?\r?\n/gm, '')
-      .replace(
-        /^import \{ SelectorName \} from '(?:@\/types\/locator\/locator\.type|\.\.\/\.\.\/\.\.\/types\/locator\/locator\.type)';?\r?\n/gm,
-        '',
-      )
-      .replace(/^import \{ resolveLocator \} from '\.\.\/\.\.\/utils\/locator\.util\.js';?\r?\n/gm, '')
-      .replace(/^import \{ getEnvironment \} from '\.\.\/\.\.\/utils\/environment\.util\.js';?\r?\n/gm, '')
-      .replace(
-        /^import \{ generateRandomData, RandomDataType \} from '\.\.\/\.\.\/utils\/random-data\.util\.js';?\r?\n/gm,
-        '',
-      )
-      .trimStart()
-
-    content = `${runtimeImport}\n${content}`
-
-    await fs.writeFile(filePath, content)
-  }
-}
-
-async function copyLegacyMutableWorkspace(): Promise<void> {
-  const legacyExists = await pathExists(legacyTestsRoot)
-  const automationExists = await pathExists(automationRoot)
-
-  if (!legacyExists || automationExists) {
-    return
-  }
-
-  await fs.mkdir(automationRoot, { recursive: true })
-
-  const legacyEnvironmentsDir = path.join(legacyTestsRoot, 'config', 'environments')
-  if (await pathExists(legacyEnvironmentsDir)) {
-    await fs.cp(legacyEnvironmentsDir, getAutomationEnvironmentsDir(), { recursive: true })
-  }
-
-  for (const directory of mutableLegacyDirectories) {
-    const sourceDirectory = path.join(legacyTestsRoot, directory)
-    const destinationDirectory = path.join(automationRoot, directory)
-
-    if (await pathExists(sourceDirectory)) {
-      await fs.cp(sourceDirectory, destinationDirectory, { recursive: true })
-    }
-  }
-}
-
-async function copyLegacyEnvironmentsIfNeeded(): Promise<void> {
-  const legacyEnvironmentsDir = path.join(legacyTestsRoot, 'config', 'environments')
-  const automationEnvironmentsFile = path.join(getAutomationEnvironmentsDir(), 'environments.json')
-
-  if (!(await pathExists(legacyEnvironmentsDir)) || (await pathExists(automationEnvironmentsFile))) {
-    return
-  }
-
-  await fs.mkdir(getAutomationEnvironmentsDir(), { recursive: true })
-  await fs.cp(legacyEnvironmentsDir, getAutomationEnvironmentsDir(), { recursive: true })
-}
-
-async function ensureMutableAutomationDirectories(): Promise<void> {
-  const requiredDirectories = [
-    getAutomationRoot(),
-    getAutomationConfigDir(),
-    getAutomationEnvironmentsDir(),
-    getAutomationFeaturesDir(),
-    getAutomationLocatorsDir(),
-    getAutomationMappingDir(),
-    getAutomationReportsDir(),
-    getAutomationStepsDir(),
-    getAutomationActionStepsDir(),
-    getAutomationValidationStepsDir(),
-  ]
-
-  await Promise.all(requiredDirectories.map(directory => fs.mkdir(directory, { recursive: true })))
-}
-
-async function removeLegacyRuntimeArtifactsFromAutomation(): Promise<void> {
-  await fs.rm(path.join(getAutomationConfigDir(), 'executor'), { recursive: true, force: true })
-  await fs.rm(path.join(getAutomationRoot(), 'hooks'), { recursive: true, force: true })
-  await fs.rm(path.join(getAutomationRoot(), 'support'), { recursive: true, force: true })
-  await fs.rm(path.join(getAutomationRoot(), 'utils'), { recursive: true, force: true })
-}
-
-export async function ensureAutomationWorkspaceReady(): Promise<void> {
-  automationWorkspaceReadyPromise ??= (async () => {
-    await copyLegacyMutableWorkspace()
-    await copyLegacyEnvironmentsIfNeeded()
-    await ensureMutableAutomationDirectories()
-    await removeLegacyRuntimeArtifactsFromAutomation()
-    await rewriteLegacyStepImports()
-  })()
-
-  return automationWorkspaceReadyPromise
-}
-
-export function getAutomationRoot(): string {
-  return automationRoot
-}
-
-export function getLegacyTestsRoot(): string {
-  return legacyTestsRoot
-}
-
-export function getAutomationConfigDir(): string {
-  return path.join(getAutomationRoot(), 'config')
-}
-
-export function getAutomationEnvironmentsDir(): string {
-  return path.join(getAutomationConfigDir(), 'environments')
-}
-
-export function getAutomationFeaturesDir(): string {
-  return path.join(getAutomationRoot(), 'features')
-}
-
-export function getAutomationLocatorsDir(): string {
-  return path.join(getAutomationRoot(), 'locators')
-}
-
-export function getAutomationMappingDir(): string {
-  return path.join(getAutomationRoot(), 'mapping')
-}
-
-export function getAutomationReportsDir(): string {
-  return path.join(getAutomationRoot(), 'reports')
-}
-
-export function getAutomationReportRunDir(runId: string): string {
-  return path.join(getAutomationReportsDir(), runId)
-}
-
-export function getAutomationRunReportPath(runId: string): string {
-  return path.join(getAutomationReportRunDir(runId), 'cucumber.json')
-}
-
-export function getAutomationReportLogsDir(runId: string): string {
-  return path.join(getAutomationReportRunDir(runId), 'logs')
-}
-
-export function getAutomationRunLogPath(runId: string): string {
-  return path.join(getAutomationReportLogsDir(runId), 'run.log')
-}
-
-export function getAutomationReportTracesDir(runId: string): string {
-  return path.join(getAutomationReportRunDir(runId), 'traces')
-}
-
-export function getAutomationReportScreenshotsDir(runId: string): string {
-  return path.join(getAutomationReportRunDir(runId), 'screenshots')
-}
-
-export function toProjectRelativePath(targetPath: string): string {
-  const normalizedPath = path.isAbsolute(targetPath) ? path.relative(repoRoot, targetPath) : targetPath
-  return normalizedPath.replace(/\\/g, '/')
-}
-
-export function resolveStoredPath(storedPath: string): string {
-  return path.isAbsolute(storedPath) ? storedPath : path.join(repoRoot, storedPath)
-}
-
-export function getAutomationStepsDir(): string {
-  return path.join(getAutomationRoot(), 'steps')
-}
-
-export function getAutomationActionStepsDir(): string {
-  return path.join(getAutomationStepsDir(), 'actions')
-}
-
-export function getAutomationValidationStepsDir(): string {
-  return path.join(getAutomationStepsDir(), 'validations')
-}

package/templates/default/src/lib/bidirectional-sync.ts

@@ -1,432 +0,0 @@
-import { promises as fs } from 'fs'
-import { join, relative } from 'path'
-import { scanFeatureFiles } from './gherkin-parser'
-import { mergeScenariosWithExistingTestSuites } from './database-sync'
-import { generateFeatureFile } from './feature-file-generator'
-import prisma from '@/config/db-config'
-import { Module, TestSuite } from '@prisma/client'
-
-// Type for TestSuite with included module relation
-type TestSuiteWithModule = TestSuite & {
-  module: Module
-}
-
-/**
- * Result of the bidirectional sync operation
- */
-export interface SyncResult {
-  // Database to Filesystem sync
-  generatedFeatureFiles: number
-  updatedFeatureFiles: number
-
-  // Filesystem to Database sync
-  createdTestSuites: number
-  createdTestCases: number
-  createdTemplateSteps: number
-  mergedTestSuites: number
-  addedScenarios: number
-
-  // Overall stats
-  totalProcessed: number
-  errors: string[]
-}
-
-/**
- * Performs bidirectional synchronization between database and feature files
- * @param featuresBaseDir - Base directory for feature files
- * @returns Promise<SyncResult> - Result of the sync operation
- */
-export async function performBidirectionalSync(featuresBaseDir: string): Promise<SyncResult> {
-  const result: SyncResult = {
-    generatedFeatureFiles: 0,
-    updatedFeatureFiles: 0,
-    createdTestSuites: 0,
-    createdTestCases: 0,
-    createdTemplateSteps: 0,
-    mergedTestSuites: 0,
-    addedScenarios: 0,
-    totalProcessed: 0,
-    errors: [],
-  }
-
-  try {
-    console.log('🔄 Starting bidirectional sync between database and feature files...')
-
-    // Step 1: Sync from filesystem to database (FS -> DB)
-    console.log('📁 Scanning feature files from filesystem...')
-    const parsedFeatures = await scanFeatureFiles(featuresBaseDir)
-    console.log(`Found ${parsedFeatures.length} feature files`)
-
-    if (parsedFeatures.length > 0) {
-      console.log('💾 Syncing feature files to database...')
-      const fsToDbResult = await mergeScenariosWithExistingTestSuites(parsedFeatures, featuresBaseDir)
-
-      result.mergedTestSuites = fsToDbResult.mergedTestSuites
-      result.addedScenarios = fsToDbResult.addedScenarios
-    }
-
-    // Step 2: Sync from database to filesystem (DB -> FS)
-    console.log('🗄️ Fetching test suites from database...')
-    const testSuites = await prisma.testSuite.findMany({
-      include: {
-        testCases: {
-          include: {
-            steps: {
-              include: {
-                parameters: true,
-              },
-              orderBy: {
-                order: 'asc',
-              },
-            },
-          },
-        },
-        module: true,
-      },
-    })
-
-    console.log(`Found ${testSuites.length} test suites in database`)
-
-    // Ensure features directory exists
-    await fs.mkdir(featuresBaseDir, { recursive: true })
-
-    // Generate/update feature files for each test suite
-    for (const testSuite of testSuites) {
-      try {
-        const featureFilePath = await generateFeatureFile(
-          testSuite.id,
-          testSuite.name,
-          testSuite.description || undefined,
-        )
-
-        // Check if this was a new file or update
-        const fileExists = await fs
-          .access(featureFilePath)
-          .then(() => true)
-          .catch(() => false)
-
-        if (fileExists) {
-          result.updatedFeatureFiles++
-        } else {
-          result.generatedFeatureFiles++
-        }
-
-        console.log(`✅ Processed: ${featureFilePath}`)
-      } catch (error) {
-        const errorMsg = `Error processing test suite ${testSuite.name}: ${error}`
-        console.error(errorMsg)
-        result.errors.push(errorMsg)
-      }
-    }
-
-    result.totalProcessed = testSuites.length
-
-    console.log('\n✅ Bidirectional sync completed!')
-    console.log(`📊 Summary:`)
-    console.log(`   - Generated feature files: ${result.generatedFeatureFiles}`)
-    console.log(`   - Updated feature files: ${result.updatedFeatureFiles}`)
-    console.log(`   - Merged test suites: ${result.mergedTestSuites}`)
-    console.log(`   - Added scenarios: ${result.addedScenarios}`)
-    console.log(`   - Total processed: ${result.totalProcessed}`)
-
-    if (result.errors.length > 0) {
-      console.log(`   - Errors: ${result.errors.length}`)
-      result.errors.forEach(error => console.log(`     - ${error}`))
-    }
-
-    return result
-  } catch (error) {
-    const errorMsg = `Fatal error during bidirectional sync: ${error}`
-    console.error(errorMsg)
-    result.errors.push(errorMsg)
-    throw error
-  }
-}
-
-/**
- * Performs a dry run of the bidirectional sync to show what would be changed
- * @param featuresBaseDir - Base directory for feature files
- * @returns Promise<{wouldGenerate: string[], wouldUpdate: string[], wouldCreate: any[]}>
- */
-export async function performDryRunSync(featuresBaseDir: string): Promise<{
-  wouldGenerate: string[]
-  wouldUpdate: string[]
-  wouldCreate: {
-    testSuites: string[]
-    testCases: string[]
-    templateSteps: string[]
-    tags: string[]
-  }
-}> {
-  const wouldGenerate: string[] = []
-  const wouldUpdate: string[] = []
-  const wouldCreate = {
-    testSuites: [] as string[],
-    testCases: [] as string[],
-    templateSteps: [] as string[],
-    tags: [] as string[],
-  }
-
-  try {
-    console.log('🔍 Performing dry run of bidirectional sync...')
-
-    // Check filesystem -> database sync
-    const parsedFeatures = await scanFeatureFiles(featuresBaseDir)
-
-    for (const feature of parsedFeatures) {
-      const modulePath = extractModulePathFromFilePath(feature.filePath, featuresBaseDir)
-
-      // Check if module exists
-      const moduleExists = await checkModuleExists(modulePath)
-      if (!moduleExists) {
-        wouldCreate.testSuites.push(`Module: ${modulePath}`)
-      }
-
-      // Check if test suite exists
-      const testSuiteExists = await checkTestSuiteExists(feature.featureName, modulePath)
-      if (!testSuiteExists) {
-        wouldCreate.testSuites.push(`Test Suite: ${feature.featureName}`)
-      }
-
-      // Check scenarios
-      for (const scenario of feature.scenarios) {
-        const testCaseExists = await checkTestCaseExists(scenario.name, feature.featureName, modulePath)
-        if (!testCaseExists) {
-          wouldCreate.testCases.push(`Test Case: ${scenario.name}`)
-        }
-
-        // Check template steps
-        for (const step of scenario.steps) {
-          const templateStepExists = await checkTemplateStepExists(step)
-          if (!templateStepExists) {
-            wouldCreate.templateSteps.push(`Template Step: ${step.keyword} ${step.text}`)
-          }
-        }
-
-        // Check scenario-level tags
-        for (const tag of scenario.tags) {
-          const tagExists = await checkTagExists(tag)
-          if (!tagExists) {
-            if (!wouldCreate.tags.includes(tag)) {
-              wouldCreate.tags.push(tag)
-            }
-          }
-        }
-      }
-
-      // Check feature-level tags
-      for (const tag of feature.tags) {
-        const tagExists = await checkTagExists(tag)
-        if (!tagExists) {
-          if (!wouldCreate.tags.includes(tag)) {
-            wouldCreate.tags.push(tag)
-          }
-        }
-      }
-    }
-
-    // Check database -> filesystem sync
-    const testSuites = await prisma.testSuite.findMany({
-      include: {
-        testCases: true,
-        module: true,
-      },
-    })
-
-    for (const testSuite of testSuites) {
-      const expectedPath = buildExpectedFeatureFilePath(testSuite, featuresBaseDir)
-      const fileExists = await fs
-        .access(expectedPath)
-        .then(() => true)
-        .catch(() => false)
-
-      if (fileExists) {
-        wouldUpdate.push(expectedPath)
-      } else {
-        wouldGenerate.push(expectedPath)
-      }
-    }
-
-    console.log('🔍 Dry run completed!')
-    console.log(`Would generate ${wouldGenerate.length} feature files`)
-    console.log(`Would update ${wouldUpdate.length} feature files`)
-    console.log(`Would create ${wouldCreate.testSuites.length} test suites`)
-    console.log(`Would create ${wouldCreate.testCases.length} test cases`)
-    console.log(`Would create ${wouldCreate.templateSteps.length} template steps`)
-    console.log(`Would create ${wouldCreate.tags.length} tags`)
-
-    return {
-      wouldGenerate,
-      wouldUpdate,
-      wouldCreate,
-    }
-  } catch (error) {
-    console.error('Error during dry run:', error)
-    throw error
-  }
-}
-
-// Helper functions for dry run
-
-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 !== '')
-  const moduleParts = pathParts.slice(0, -1)
-  return moduleParts.length > 0 ? '/' + moduleParts.join('/') : '/'
-}
-
-async function checkModuleExists(modulePath: string): Promise<boolean> {
-  try {
-    const pathParts = modulePath.split('/').filter(part => part && part !== '')
-    if (pathParts.length === 0) return true
-
-    let currentParentId: string | null = null
-
-    for (const moduleName of pathParts) {
-      const foundModule: Module | null = await prisma.module.findFirst({
-        where: {
-          name: moduleName,
-          parentId: currentParentId,
-        },
-      })
-      if (!foundModule) return false
-      currentParentId = foundModule.id
-    }
-    return true
-  } catch {
-    return false
-  }
-}
-
-async function checkTestSuiteExists(featureName: string, modulePath: string): Promise<boolean> {
-  try {
-    const moduleId = await findModuleIdByPath(modulePath)
-    if (!moduleId) return false
-
-    const testSuite: TestSuite | null = await prisma.testSuite.findFirst({
-      where: {
-        name: featureName,
-        moduleId: moduleId,
-      },
-    })
-
-    return testSuite !== null
-  } catch {
-    return false
-  }
-}
-
-async function checkTestCaseExists(testCaseName: string, featureName: string, modulePath: string): Promise<boolean> {
-  try {
-    const moduleId = await findModuleIdByPath(modulePath)
-    if (!moduleId) return false
-
-    const testSuite = await prisma.testSuite.findFirst({
-      where: {
-        name: featureName,
-        moduleId: moduleId,
-      },
-    })
-
-    if (!testSuite) return false
-
-    const testCase = await prisma.testCase.findFirst({
-      where: {
-        title: testCaseName,
-        TestSuite: {
-          some: {
-            id: testSuite.id,
-          },
-        },
-      },
-    })
-
-    return !!testCase
-  } catch {
-    return false
-  }
-}
-
-async function checkTemplateStepExists(step: { keyword: string; text: string }): Promise<boolean> {
-  try {
-    const signature = `${step.keyword} ${step.text}`
-    const templateStep = await prisma.templateStep.findFirst({
-      where: {
-        signature: signature,
-      },
-    })
-
-    return !!templateStep
-  } catch {
-    return false
-  }
-}
-
-async function checkTagExists(tagExpression: string): Promise<boolean> {
-  try {
-    const tag = await prisma.tag.findFirst({
-      where: {
-        tagExpression: tagExpression,
-      },
-    })
-
-    return !!tag
-  } catch {
-    return false
-  }
-}
-
-async function findModuleIdByPath(modulePath: string): Promise<string | null> {
-  try {
-    const pathParts = modulePath.split('/').filter(part => part && part !== '')
-    // Handle empty path (root level) - find the default root module
-    if (pathParts.length === 0) {
-      const rootModule = await prisma.module.findFirst({
-        where: {
-          name: 'root',
-          parentId: null,
-        },
-      })
-      return rootModule?.id || null
-    }
-
-    let currentParentId: string | null = null
-
-    for (const moduleName of pathParts) {
-      const foundModule: Module | null = await prisma.module.findFirst({
-        where: {
-          name: moduleName,
-          parentId: currentParentId,
-        },
-      })
-
-      if (!foundModule) return null
-      currentParentId = foundModule.id
-    }
-
-    return currentParentId
-  } catch {
-    return null
-  }
-}
-
-function buildExpectedFeatureFilePath(testSuite: TestSuiteWithModule, featuresBaseDir: string): string {
-  // This is a simplified version - in practice, you'd use the same logic as generateFeatureFile
-  const modulePath = buildModulePathFromTestSuite(testSuite)
-  const safeFileName = testSuite.name
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .replace(/-+/g, '-')
-
-  return join(featuresBaseDir, modulePath.substring(1), `${safeFileName}.feature`)
-}
-
-function buildModulePathFromTestSuite(testSuite: TestSuiteWithModule): string {
-  // Simplified module path building - in practice, you'd use the existing logic
-  return `/${testSuite.module.name}`
-}