create-appraise 0.1.0

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

@@ -0,0 +1,349 @@
+#!/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'
+
+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 = 'src/tests/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 = 'src/tests/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: src/tests/locators/home/home.json -> /home
+ */
+function extractModulePathFromLocatorFile(filePath: string, baseDir: string): string {
+  const testsDir = join(baseDir, 'src', 'tests')
+  const relativePath = filePath.replace(testsDir, '').replace(/\\/g, '/')
+  const pathParts = relativePath.split('/').filter(p => p && p !== 'locators')
+  const moduleParts = pathParts.slice(0, -1) // Remove filename
+  return moduleParts.length > 0 ? '/' + moduleParts.join('/') : '/'
+}
+
+/**
+ * Extracts module path from feature file path
+ * Example: src/tests/features/login/demo.feature -> /login
+ */
+function extractModulePathFromFeatureFile(filePath: string, baseDir: string): string {
+  const featuresBaseDir = join(baseDir, 'src', 'tests', 'features')
+  const relativePath = filePath.replace(featuresBaseDir, '').replace(/\\/g, '/')
+  const pathParts = relativePath.split('/').filter(part => part && part !== '')
+  const moduleParts = pathParts.slice(0, -1) // Remove filename
+  return moduleParts.length > 0 ? '/' + moduleParts.join('/') : '/'
+}
+
+/**
+ * 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 src/tests/locators...')
+    const locatorModulePaths = await scanLocatorDirectories(baseDir)
+    console.log(`   Found ${locatorModulePaths.length} module path(s): ${locatorModulePaths.join(', ') || 'none'}`)
+
+    console.log('\n📁 Scanning src/tests/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

@@ -0,0 +1,292 @@
+#!/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'
+
+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
+
+    // Determine type: IDENTIFIER if starts with tc_, otherwise FILTER
+    const type = name.startsWith('tc_') ? TagType.IDENTIFIER : TagType.FILTER
+
+    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, 'src', 'tests', 'features')
+
+    // Scan feature files
+    console.log('📁 Scanning feature files in src/tests/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()
+