create-appraisejs 0.2.0 → 0.3.0-alpha.1

package/templates/default/scripts/sync-modules.ts

@@ -1,341 +0,0 @@
-#!/usr/bin/env tsx
-
-/**
- * Script to synchronize module hierarchy from filesystem to database
- * Scans locators and features directories to ensure all modules exist in DB
- * Filesystem is the source of truth - modules in DB but not in FS will be deleted
- * Run this after merging changes to ensure module sync
- *
- * Usage: npx tsx scripts/sync-modules.ts
- */
-
-import { buildModuleHierarchy, findModuleByPath, getAllModulesWithPaths } from '../src/lib/module-hierarchy-builder'
-import { join } from 'path'
-import { glob } from 'glob'
-import prisma from '../src/config/db-config'
-import { extractModulePathFromAutomationFile } from '../src/lib/template-sync-utils'
-
-interface SyncResult {
-  modulesScanned: number
-  modulesExisting: number
-  modulesCreated: number
-  modulesDeleted: number
-  errors: string[]
-  createdModules: string[]
-  existingModules: string[]
-  deletedModules: string[]
-}
-
-/**
- * Scans locator directories and extracts module paths
- */
-async function scanLocatorDirectories(baseDir: string): Promise<string[]> {
-  const modulePaths = new Set<string>()
-
-  try {
-    // Get all JSON files in locators directory
-    const pattern = 'automation/locators/**/*.json'
-    const files = await glob(pattern, {
-      cwd: baseDir,
-    })
-
-    for (const file of files) {
-      const filePath = join(baseDir, file)
-      const modulePath = extractModulePathFromLocatorFile(filePath, baseDir)
-      if (modulePath) {
-        modulePaths.add(modulePath)
-      }
-    }
-  } catch (error) {
-    console.error('Error scanning locator directories:', error)
-    throw error
-  }
-
-  return Array.from(modulePaths)
-}
-
-/**
- * Scans feature directories and extracts module paths
- */
-async function scanFeatureDirectories(baseDir: string): Promise<string[]> {
-  const modulePaths = new Set<string>()
-
-  try {
-    // Get all feature files
-    const pattern = 'automation/features/**/*.feature'
-    const files = await glob(pattern, {
-      cwd: baseDir,
-    })
-
-    for (const file of files) {
-      const filePath = join(baseDir, file)
-      const modulePath = extractModulePathFromFeatureFile(filePath, baseDir)
-      if (modulePath) {
-        modulePaths.add(modulePath)
-      }
-    }
-  } catch (error) {
-    console.error('Error scanning feature directories:', error)
-    throw error
-  }
-
-  return Array.from(modulePaths)
-}
-
-/**
- * Extracts module path from locator file path
- * Example: automation/locators/home/home.json -> /home
- */
-function extractModulePathFromLocatorFile(filePath: string, baseDir: string): string {
-  return extractModulePathFromAutomationFile(filePath, baseDir, 'locators')
-}
-
-/**
- * Extracts module path from feature file path
- * Example: automation/features/login/demo.feature -> /login
- */
-function extractModulePathFromFeatureFile(filePath: string, baseDir: string): string {
-  return extractModulePathFromAutomationFile(filePath, baseDir, 'features')
-}
-
-/**
- * Builds a module tree from discovered paths
- * Returns a map of module paths to their parent paths
- */
-function buildModuleTree(modulePaths: string[]): Map<string, string | null> {
-  const tree = new Map<string, string | null>()
-
-  // Add all paths and their parent paths
-  for (const modulePath of modulePaths) {
-    if (modulePath === '/') {
-      tree.set('/', null)
-      continue
-    }
-
-    const pathParts = modulePath.split('/').filter(p => p)
-    let currentPath = ''
-
-    for (let i = 0; i < pathParts.length; i++) {
-      currentPath += '/' + pathParts[i]
-
-      if (i === 0) {
-        tree.set(currentPath, null)
-      } else {
-        const parentPath = '/' + pathParts.slice(0, i).join('/')
-        tree.set(currentPath, parentPath)
-      }
-    }
-  }
-
-  return tree
-}
-
-/**
- * Syncs modules to database (creates missing modules)
- */
-async function syncModulesToDatabase(moduleTree: Map<string, string | null>): Promise<SyncResult> {
-  const result: SyncResult = {
-    modulesScanned: moduleTree.size,
-    modulesExisting: 0,
-    modulesCreated: 0,
-    modulesDeleted: 0,
-    errors: [],
-    createdModules: [],
-    existingModules: [],
-    deletedModules: [],
-  }
-
-  // Sort paths by depth (shallowest first) to ensure parents are created before children
-  const sortedPaths = Array.from(moduleTree.keys()).sort((a, b) => {
-    const depthA = a.split('/').filter(p => p).length
-    const depthB = b.split('/').filter(p => p).length
-    return depthA - depthB
-  })
-
-  for (const modulePath of sortedPaths) {
-    try {
-      // Check if module already exists
-      const existingModuleId = await findModuleByPath(modulePath)
-
-      if (existingModuleId) {
-        result.modulesExisting++
-        result.existingModules.push(modulePath)
-        console.log(`   ✓ Module '${modulePath}' already exists`)
-      } else {
-        // Build the hierarchy for this path (which will create it if needed)
-        await buildModuleHierarchy(modulePath)
-        result.modulesCreated++
-        result.createdModules.push(modulePath)
-        console.log(`   ➕ Created module '${modulePath}'`)
-      }
-    } catch (error) {
-      const errorMsg = `Error syncing module '${modulePath}': ${error}`
-      result.errors.push(errorMsg)
-      console.error(`   ❌ ${errorMsg}`)
-    }
-  }
-
-  return result
-}
-
-/**
- * Deletes orphaned modules (modules in DB but not in FS)
- */
-async function deleteOrphanedModules(fsModulePaths: Set<string>, result: SyncResult): Promise<void> {
-  console.log('\n🔍 Checking for orphaned modules (not in filesystem)...')
-
-  try {
-    // Get all modules from database with their paths
-    const dbModules = await getAllModulesWithPaths()
-
-    // Sort modules by reverse depth (deepest first) to avoid foreign key constraint issues
-    const sortedDbModules = dbModules.sort((a, b) => {
-      const depthA = a.path.split('/').filter(p => p).length
-      const depthB = b.path.split('/').filter(p => p).length
-      return depthB - depthA // Reverse order
-    })
-
-    for (const dbModule of sortedDbModules) {
-      // Skip the default root module (preserve it)
-      if (dbModule.name === 'root' && dbModule.parentId === null) {
-        continue
-      }
-
-      // Check if module path exists in FS
-      if (!fsModulePaths.has(dbModule.path)) {
-        try {
-          // Check if module has dependencies (for logging)
-          const moduleWithDeps = await prisma.module.findUnique({
-            where: { id: dbModule.id },
-            include: {
-              locatorGroups: { select: { id: true } },
-              testSuites: { select: { id: true } },
-            },
-          })
-
-          if (moduleWithDeps) {
-            const hasLocatorGroups = moduleWithDeps.locatorGroups.length > 0
-            const hasTestSuites = moduleWithDeps.testSuites.length > 0
-
-            if (hasLocatorGroups || hasTestSuites) {
-              const deps = []
-              if (hasLocatorGroups) deps.push(`${moduleWithDeps.locatorGroups.length} locator group(s)`)
-              if (hasTestSuites) deps.push(`${moduleWithDeps.testSuites.length} test suite(s)`)
-              console.log(
-                `   ⚠️  Module '${dbModule.path}' has dependencies (${deps.join(', ')}) - will be cascade deleted`,
-              )
-            }
-
-            // Delete the module (Prisma cascade will handle children, locatorGroups, and testSuites)
-            await prisma.module.delete({
-              where: { id: dbModule.id },
-            })
-
-            result.modulesDeleted++
-            result.deletedModules.push(dbModule.path)
-            console.log(`   🗑️  Deleted module '${dbModule.path}' (not in filesystem)`)
-          }
-        } catch (error) {
-          const errorMsg = `Error deleting module '${dbModule.path}': ${error}`
-          result.errors.push(errorMsg)
-          console.error(`   ❌ ${errorMsg}`)
-        }
-      }
-    }
-  } catch (error) {
-    const errorMsg = `Error checking for orphaned modules: ${error}`
-    result.errors.push(errorMsg)
-    console.error(`   ❌ ${errorMsg}`)
-  }
-}
-
-/**
- * Generates and displays sync summary
- */
-function generateSummary(result: SyncResult): void {
-  console.log('\n📊 Sync Summary:')
-  console.log(`   📁 Modules scanned: ${result.modulesScanned}`)
-  console.log(`   ✅ Modules existing: ${result.modulesExisting}`)
-  console.log(`   ➕ Modules created: ${result.modulesCreated}`)
-  console.log(`   🗑️  Modules deleted: ${result.modulesDeleted}`)
-  console.log(`   ❌ Errors: ${result.errors.length}`)
-
-  if (result.createdModules.length > 0) {
-    console.log('\n   Created modules:')
-    result.createdModules.forEach((path, index) => {
-      console.log(`      ${index + 1}. ${path}`)
-    })
-  }
-
-  if (result.deletedModules.length > 0) {
-    console.log('\n   Deleted modules:')
-    result.deletedModules.forEach((path, index) => {
-      console.log(`      ${index + 1}. ${path}`)
-    })
-  }
-
-  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 {
-    console.log('🔄 Starting modules sync...')
-    console.log('This will scan filesystem directories and sync module hierarchy to database.')
-    console.log('Filesystem is the source of truth - modules in DB but not in FS will be deleted.\n')
-
-    const baseDir = process.cwd()
-
-    // Scan directories
-    console.log('📁 Scanning automation/locators...')
-    const locatorModulePaths = await scanLocatorDirectories(baseDir)
-    console.log(`   Found ${locatorModulePaths.length} module path(s): ${locatorModulePaths.join(', ') || 'none'}`)
-
-    console.log('\n📁 Scanning automation/features...')
-    const featureModulePaths = await scanFeatureDirectories(baseDir)
-    console.log(`   Found ${featureModulePaths.length} module path(s): ${featureModulePaths.join(', ') || 'none'}`)
-
-    // Combine and deduplicate
-    const allModulePaths = Array.from(new Set([...locatorModulePaths, ...featureModulePaths]))
-    console.log(`\n🔍 Building module hierarchy from ${allModulePaths.length} unique module path(s)...`)
-
-    // Build module tree
-    const moduleTree = buildModuleTree(allModulePaths)
-
-    // Sync to database (create missing modules)
-    console.log('\n✅ Syncing modules to database...')
-    const result = await syncModulesToDatabase(moduleTree)
-
-    // Delete orphaned modules (modules in DB but not in FS)
-    const fsModulePathsSet = new Set(allModulePaths)
-    // Also add all parent paths from the tree
-    for (const path of moduleTree.keys()) {
-      fsModulePathsSet.add(path)
-    }
-    await deleteOrphanedModules(fsModulePathsSet, 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()
-  }
-}
-
-main()

package/templates/default/scripts/sync-tags.ts

@@ -1,291 +0,0 @@
-#!/usr/bin/env tsx
-
-/**
- * Script to synchronize tags from feature files to database
- * Scans feature files to ensure all tags exist in DB
- * Filesystem is the source of truth - tags in DB but not in FS will be deleted
- * Run this after merging changes to ensure tag sync
- *
- * Usage: npx tsx scripts/sync-tags.ts
- */
-
-import { join } from 'path'
-import prisma from '../src/config/db-config'
-import { scanFeatureFiles, ParsedFeature } from '../src/lib/gherkin-parser'
-import { TagType } from '@prisma/client'
-import { getTagTypeFromName } from '../src/lib/tag-utils'
-
-interface TagData {
-  name: string // Without @ prefix, for DB storage
-  tagExpression: string // With @ prefix, for tagExpression field
-  type: TagType // IDENTIFIER or FILTER
-}
-
-interface SyncResult {
-  tagsScanned: number
-  tagsExisting: number
-  tagsCreated: number
-  tagsDeleted: number
-  errors: string[]
-  createdTags: string[]
-  deletedTags: string[]
-}
-
-/**
- * Splits a tag line that may contain multiple tags separated by spaces
- * Example: "@smoke @demo" -> ["@smoke", "@demo"]
- */
-function splitTagLine(tagLine: string): string[] {
-  // Split by spaces and filter for strings that start with @
-  return tagLine
-    .split(/\s+/)
-    .filter(tag => tag.trim().startsWith('@'))
-    .map(tag => tag.trim())
-}
-
-/**
- * Extracts unique tags from parsed feature files
- * Combines feature-level and scenario-level tags
- * Handles tags on the same line separated by spaces
- */
-function extractUniqueTags(parsedFeatures: ParsedFeature[]): Set<string> {
-  const uniqueTags = new Set<string>()
-
-  for (const feature of parsedFeatures) {
-    // Add feature-level tags
-    for (const tagLine of feature.tags) {
-      if (tagLine.startsWith('@')) {
-        // Split tags that might be on the same line
-        const tags = splitTagLine(tagLine)
-        for (const tag of tags) {
-          uniqueTags.add(tag)
-        }
-      }
-    }
-
-    // Add scenario-level tags
-    for (const scenario of feature.scenarios) {
-      for (const tagLine of scenario.tags) {
-        if (tagLine.startsWith('@')) {
-          // Split tags that might be on the same line
-          const tags = splitTagLine(tagLine)
-          for (const tag of tags) {
-            uniqueTags.add(tag)
-          }
-        }
-      }
-    }
-  }
-
-  return uniqueTags
-}
-
-/**
- * Builds Tag objects from tag expressions
- * Maps tag expressions to Prisma Tag model structure
- */
-function buildTagObjects(tagExpressions: Set<string>): TagData[] {
-  const tagObjects: TagData[] = []
-
-  for (const tagExpression of tagExpressions) {
-    // Strip @ prefix for name field
-    const name = tagExpression.startsWith('@') ? tagExpression.substring(1) : tagExpression
-
-    const type = getTagTypeFromName(name)
-
-    tagObjects.push({
-      name,
-      tagExpression, // Keep @ prefix for tagExpression
-      type,
-    })
-  }
-
-  return tagObjects
-}
-
-/**
- * Syncs tags to database
- * Creates missing tags and deletes orphaned tags (FS is source of truth)
- */
-async function syncTagsToDatabase(tagObjects: TagData[]): Promise<SyncResult> {
-  const result: SyncResult = {
-    tagsScanned: tagObjects.length,
-    tagsExisting: 0,
-    tagsCreated: 0,
-    tagsDeleted: 0,
-    errors: [],
-    createdTags: [],
-    deletedTags: [],
-  }
-
-  // Get set of tag names from feature files (FS source of truth)
-  const fsTagNames = new Set(tagObjects.map(tag => tag.name))
-
-  // Get all tags from database
-  const allDbTags = await prisma.tag.findMany({
-    select: { id: true, name: true },
-  })
-
-  // Delete tags from DB that are not in FS (FS is source of truth)
-  console.log('\n🔍 Checking for orphaned tags (not in feature files)...')
-  for (const dbTag of allDbTags) {
-    if (!fsTagNames.has(dbTag.name)) {
-      try {
-        await prisma.tag.delete({
-          where: { id: dbTag.id },
-        })
-        result.tagsDeleted++
-        result.deletedTags.push(dbTag.name)
-        console.log(`   🗑️  Deleted tag '${dbTag.name}' (not in feature files)`)
-      } catch (error) {
-        const errorMsg = `Error deleting tag '${dbTag.name}': ${error}`
-        result.errors.push(errorMsg)
-        console.error(`   ❌ ${errorMsg}`)
-      }
-    }
-  }
-
-  // Create or check tags from FS
-  console.log('\n✅ Syncing tags from feature files to database...')
-  for (const tagData of tagObjects) {
-    try {
-      // Check if tag already exists by name (names are unique per user requirement)
-      const existing = await prisma.tag.findFirst({
-        where: { name: tagData.name },
-      })
-
-      if (existing) {
-        // If tag exists but has wrong type, update it
-        // This fixes tags that were created with wrong type (e.g., via UI or old code)
-        if (existing.type !== tagData.type) {
-          await prisma.tag.update({
-            where: { id: existing.id },
-            data: { type: tagData.type },
-          })
-          result.tagsCreated++ // Count as created since we're fixing it
-          result.createdTags.push(tagData.name)
-          console.log(`   🔄 Updated tag '${tagData.name}' type from ${existing.type} to ${tagData.type}`)
-        } else {
-          result.tagsExisting++
-          console.log(`   ✓ Tag '${tagData.name}' already exists`)
-        }
-      } else {
-        // Create the tag
-        await prisma.tag.create({
-          data: {
-            name: tagData.name,
-            tagExpression: tagData.tagExpression,
-            type: tagData.type,
-          },
-        })
-        result.tagsCreated++
-        result.createdTags.push(tagData.name)
-        console.log(`   ➕ Created tag '${tagData.name}' (type: ${tagData.type})`)
-      }
-    } catch (error) {
-      const errorMsg = `Error syncing tag '${tagData.name}': ${error}`
-      result.errors.push(errorMsg)
-      console.error(`   ❌ ${errorMsg}`)
-    }
-  }
-
-  return result
-}
-
-/**
- * Generates and displays sync summary
- */
-function generateSummary(result: SyncResult): void {
-  console.log('\n📊 Sync Summary:')
-  console.log(`   📁 Tags scanned: ${result.tagsScanned}`)
-  console.log(`   ✅ Tags existing: ${result.tagsExisting}`)
-  console.log(`   ➕ Tags created: ${result.tagsCreated}`)
-  console.log(`   🗑️  Tags deleted: ${result.tagsDeleted}`)
-  console.log(`   ❌ Errors: ${result.errors.length}`)
-
-  if (result.createdTags.length > 0) {
-    console.log('\n   Created tags:')
-    result.createdTags.forEach((name, index) => {
-      console.log(`      ${index + 1}. ${name}`)
-    })
-  }
-
-  if (result.deletedTags.length > 0) {
-    console.log('\n   Deleted tags:')
-    result.deletedTags.forEach((name, index) => {
-      console.log(`      ${index + 1}. ${name}`)
-    })
-  }
-
-  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 {
-    console.log('🔄 Starting tags sync...')
-    console.log('This will scan feature files and sync tags to database.')
-    console.log('Filesystem is the source of truth - tags in DB but not in FS will be deleted.\n')
-
-    const baseDir = process.cwd()
-    const featuresDir = join(baseDir, 'automation', 'features')
-
-    // Scan feature files
-    console.log('📁 Scanning feature files in automation/features...')
-    const parsedFeatures = await scanFeatureFiles(featuresDir)
-    console.log(`   Found ${parsedFeatures.length} feature file(s)`)
-
-    if (parsedFeatures.length === 0) {
-      console.log('\n⚠️  No feature files found. Nothing to sync.')
-      return
-    }
-
-    // Extract unique tags
-    console.log('\n🔍 Extracting unique tags from feature files...')
-    const uniqueTagExpressions = extractUniqueTags(parsedFeatures)
-    console.log(`   Found ${uniqueTagExpressions.size} unique tag(s)`)
-
-    if (uniqueTagExpressions.size === 0) {
-      console.log('\n⚠️  No tags found in feature files. Nothing to sync.')
-      return
-    }
-
-    // Build tag objects
-    console.log('\n🔨 Building tag objects...')
-    const tagObjects = buildTagObjects(uniqueTagExpressions)
-    console.log(`   Built ${tagObjects.length} tag object(s)`)
-
-    // Log tag details
-    console.log('\n   Tag details:')
-    for (const tag of tagObjects) {
-      console.log(`      - ${tag.tagExpression} → name: '${tag.name}', type: ${tag.type}`)
-    }
-
-    // Sync to database
-    const result = await syncTagsToDatabase(tagObjects)
-
-    // 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()
-  }
-}
-
-main()