create-appraisejs 0.3.0-alpha.0 → 0.3.0-alpha.1

package/templates/starter/scripts/sync-locators.ts

@@ -0,0 +1,348 @@
+#!/usr/bin/env tsx
+
+/**
+ * Script to synchronize locators from filesystem to database
+ * Scans locator JSON files to ensure all locators exist in DB
+ * Filesystem is the source of truth - locators in DB but not in FS will be deleted
+ * Run this after merging changes to ensure locator sync
+ *
+ * Usage: npx tsx scripts/sync-locators.ts
+ */
+
+import { promises as fs } from 'fs'
+import { join } from 'path'
+import { glob } from 'glob'
+import prisma from '../src/config/db-config'
+import { buildModuleHierarchy } from '../src/lib/module-hierarchy-builder'
+import { getLocatorGroupFilePath } from '../src/lib/locator-group-file-utils'
+import { extractLocatorGroupName, extractModulePathFromLocatorFile } from './lib/filename-utils'
+import { printSyncSummary } from './lib/sync-summary'
+import { runSyncScript } from './lib/sync-script-runner'
+
+interface SyncResult {
+  locatorsScanned: number
+  locatorsExisting: number
+  locatorsCreated: number
+  locatorsDeleted: number
+  locatorsUpdated: number
+  locatorGroupsDeleted: number
+  errors: string[]
+  createdLocators: Array<{ name: string; group: string }>
+  deletedLocators: Array<{ name: string; group: string }>
+  updatedLocators: Array<{ name: string; group: string }>
+  deletedLocatorGroups: Array<{ name: string; locatorCount: number }>
+}
+
+/**
+ * Scans locator directory for all JSON files
+ */
+async function scanLocatorFiles(baseDir: string): Promise<string[]> {
+  const pattern = 'automation/locators/**/*.json'
+  try {
+    const files = await glob(pattern, {
+      cwd: baseDir,
+    })
+    return files.map(file => join(baseDir, file))
+  } catch (error) {
+    throw new Error(`Error scanning locator files: ${error}`)
+  }
+}
+
+/**
+ * Reads and parses a locator JSON file
+ */
+async function readLocatorFile(filePath: string): Promise<Record<string, string>> {
+  try {
+    await fs.access(filePath)
+  } catch {
+    throw new Error(`Locator file not found at ${filePath}`)
+  }
+
+  try {
+    const fileContent = await fs.readFile(filePath, 'utf-8')
+    const jsonContent = JSON.parse(fileContent) as Record<string, string>
+
+    if (!jsonContent || typeof jsonContent !== 'object') {
+      throw new Error('Invalid JSON structure: expected an object')
+    }
+
+    return jsonContent
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Invalid JSON in locator file: ${error.message}`)
+    }
+    throw error
+  }
+}
+
+/**
+ * Finds or creates a LocatorGroup
+ */
+async function findOrCreateLocatorGroup(
+  groupName: string,
+  moduleId: string,
+): Promise<string> {
+  // Try to find existing locator group
+  const existingGroup = await prisma.locatorGroup.findFirst({
+    where: {
+      name: groupName,
+      moduleId: moduleId,
+    },
+  })
+
+  if (existingGroup) {
+    return existingGroup.id
+  }
+
+  // Create new locator group
+  const newGroup = await prisma.locatorGroup.create({
+    data: {
+      name: groupName,
+      route: `/${groupName}`,
+      moduleId: moduleId,
+    },
+  })
+
+  return newGroup.id
+}
+
+/**
+ * Syncs locators from a single file to database
+ */
+async function syncLocatorsFromFile(
+  filePath: string,
+  baseDir: string,
+  result: SyncResult,
+  processedGroupIds: Set<string>,
+): Promise<void> {
+  try {
+    // Extract module path and group name
+    const modulePath = extractModulePathFromLocatorFile(filePath, baseDir)
+    const groupName = extractLocatorGroupName(filePath)
+
+    console.log(`\n   📄 Processing file: ${filePath.replace(baseDir, '')}`)
+    console.log(`      Module path: ${modulePath}`)
+    console.log(`      Group name: ${groupName}`)
+
+    // Build module hierarchy
+    const moduleId = await buildModuleHierarchy(modulePath)
+
+    // Find or create locator group
+    const locatorGroupId = await findOrCreateLocatorGroup(groupName, moduleId)
+    
+    // Track this group as processed (has a file)
+    processedGroupIds.add(locatorGroupId)
+
+    // Read locators from file
+    const fileLocators = await readLocatorFile(filePath)
+    const fileLocatorNames = Object.keys(fileLocators)
+    result.locatorsScanned += fileLocatorNames.length
+
+    console.log(`      Found ${fileLocatorNames.length} locator(s) in file`)
+
+    // Get existing locators from database for this group
+    const dbLocators = await prisma.locator.findMany({
+      where: { locatorGroupId: locatorGroupId },
+      select: { id: true, name: true, value: true },
+    })
+
+    const dbLocatorMap = new Map(dbLocators.map(loc => [loc.name, loc]))
+
+    // Add or update locators from file
+    for (const [locatorName, locatorValue] of Object.entries(fileLocators)) {
+      const existingLocator = dbLocatorMap.get(locatorName)
+
+      if (existingLocator) {
+        // Check if value changed
+        if (existingLocator.value !== locatorValue) {
+          // Update locator value (file takes precedence)
+          await prisma.locator.update({
+            where: { id: existingLocator.id },
+            data: { value: locatorValue },
+          })
+          result.locatorsUpdated++
+          result.updatedLocators.push({ name: locatorName, group: groupName })
+          console.log(`      🔄 Updated locator '${locatorName}'`)
+        } else {
+          result.locatorsExisting++
+        }
+      } else {
+        // Create new locator
+        await prisma.locator.create({
+          data: {
+            name: locatorName,
+            value: locatorValue,
+            locatorGroupId: locatorGroupId,
+          },
+        })
+        result.locatorsCreated++
+        result.createdLocators.push({ name: locatorName, group: groupName })
+        console.log(`      ➕ Created locator '${locatorName}'`)
+      }
+    }
+
+    // Delete locators that exist in DB but not in file (FS is source of truth)
+    for (const dbLocator of dbLocators) {
+      if (!fileLocatorNames.includes(dbLocator.name)) {
+        await prisma.locator.delete({
+          where: { id: dbLocator.id },
+        })
+        result.locatorsDeleted++
+        result.deletedLocators.push({ name: dbLocator.name, group: groupName })
+        console.log(`      🗑️  Deleted locator '${dbLocator.name}' (not in file)`)
+      }
+    }
+  } catch (error) {
+    const errorMsg = `Error syncing locator file ${filePath}: ${error}`
+    result.errors.push(errorMsg)
+    console.error(`   ❌ ${errorMsg}`)
+  }
+}
+
+/**
+ * Deletes locator groups that don't have corresponding files
+ */
+async function deleteOrphanedLocatorGroups(
+  processedGroupIds: Set<string>,
+  baseDir: string,
+  result: SyncResult,
+): Promise<void> {
+  console.log('\n🔍 Checking for orphaned locator groups (no file in filesystem)...')
+  
+  try {
+    // Get all locator groups from database
+    const allLocatorGroups = await prisma.locatorGroup.findMany({
+      include: {
+        locators: {
+          select: { id: true },
+        },
+      },
+    })
+
+    for (const group of allLocatorGroups) {
+      // Skip if this group was processed (has a file)
+      if (processedGroupIds.has(group.id)) {
+        continue
+      }
+
+      // Check if file exists for this group
+      const relativeFilePath = await getLocatorGroupFilePath(group.id)
+      if (!relativeFilePath) {
+        // Can't determine file path, skip
+        continue
+      }
+
+      const fullPath = join(baseDir, relativeFilePath)
+
+      try {
+        // Check if file exists
+        await fs.access(fullPath)
+        // File exists, so this group is valid
+      } catch {
+        // File doesn't exist - delete the locator group (cascade will delete locators)
+        const locatorCount = group.locators.length
+        await prisma.locatorGroup.delete({
+          where: { id: group.id },
+        })
+        result.locatorGroupsDeleted++
+        result.deletedLocatorGroups.push({ name: group.name, locatorCount })
+        console.log(`   🗑️  Deleted locator group '${group.name}' (${locatorCount} locator(s) deleted)`)
+      }
+    }
+  } catch (error) {
+    const errorMsg = `Error deleting orphaned locator groups: ${error}`
+    result.errors.push(errorMsg)
+    console.error(`   ❌ ${errorMsg}`)
+  }
+}
+
+/**
+ * Syncs all locators to database
+ */
+async function syncLocatorsToDatabase(files: string[], baseDir: string): Promise<SyncResult> {
+  const result: SyncResult = {
+    locatorsScanned: 0,
+    locatorsExisting: 0,
+    locatorsCreated: 0,
+    locatorsDeleted: 0,
+    locatorsUpdated: 0,
+    locatorGroupsDeleted: 0,
+    errors: [],
+    createdLocators: [],
+    deletedLocators: [],
+    updatedLocators: [],
+    deletedLocatorGroups: [],
+  }
+
+  // Track which locator groups have files
+  const processedGroupIds = new Set<string>()
+
+  // Process all files
+  for (const filePath of files) {
+    await syncLocatorsFromFile(filePath, baseDir, result, processedGroupIds)
+  }
+
+  // Delete locator groups that don't have files
+  await deleteOrphanedLocatorGroups(processedGroupIds, baseDir, result)
+
+  return result
+}
+
+/**
+ * Generates and displays sync summary
+ */
+async function main(): Promise<SyncResult | void> {
+    console.log('🔄 Starting locators sync...')
+    console.log('This will scan locator JSON files and sync locators to database.')
+    console.log('Filesystem is the source of truth - locators in DB but not in FS will be deleted.\n')
+
+    const baseDir = process.cwd()
+
+    // Scan locator files
+    console.log('📁 Scanning automation/locators...')
+    const files = await scanLocatorFiles(baseDir)
+    console.log(`   Found ${files.length} locator file(s)`)
+
+    if (files.length === 0) {
+      console.log('\n⚠️  No locator files found. Nothing to sync.')
+      return
+    }
+
+    // Sync to database
+    console.log('\n✅ Syncing locators to database...')
+    const result = await syncLocatorsToDatabase(files, baseDir)
+
+    printSyncSummary(
+      [
+        { label: '📁 Locators scanned', value: result.locatorsScanned },
+        { label: '✅ Locators existing', value: result.locatorsExisting },
+        { label: '➕ Locators created', value: result.locatorsCreated },
+        { label: '🔄 Locators updated', value: result.locatorsUpdated },
+        { label: '🗑️  Locators deleted', value: result.locatorsDeleted },
+        { label: '🗑️  Locator groups deleted', value: result.locatorGroupsDeleted },
+        { label: '❌ Errors', value: result.errors.length },
+      ],
+      [
+        {
+          title: 'Created locators',
+          items: result.createdLocators.map(loc => `${loc.name} (group: ${loc.group})`),
+        },
+        {
+          title: 'Updated locators',
+          items: result.updatedLocators.map(loc => `${loc.name} (group: ${loc.group})`),
+        },
+        {
+          title: 'Deleted locators',
+          items: result.deletedLocators.map(loc => `${loc.name} (group: ${loc.group})`),
+        },
+        {
+          title: 'Deleted locator groups',
+          items: result.deletedLocatorGroups.map(group => `${group.name} (${group.locatorCount} locator(s) deleted)`),
+        },
+        { title: 'Errors', items: result.errors },
+      ],
+    )
+    return result
+}
+
+runSyncScript(main)

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

@@ -0,0 +1,302 @@
+#!/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'
+import { extractModulePathFromLocatorFile } from './lib/filename-utils'
+import { printSyncSummary } from './lib/sync-summary'
+import { runSyncScript } from './lib/sync-script-runner'
+
+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 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
+ */
+async function main(): Promise<SyncResult> {
+    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)
+
+    printSyncSummary(
+      [
+        { label: '📁 Modules scanned', value: result.modulesScanned },
+        { label: '✅ Modules existing', value: result.modulesExisting },
+        { label: '➕ Modules created', value: result.modulesCreated },
+        { label: '🗑️  Modules deleted', value: result.modulesDeleted },
+        { label: '❌ Errors', value: result.errors.length },
+      ],
+      [
+        { title: 'Created modules', items: result.createdModules },
+        { title: 'Deleted modules', items: result.deletedModules },
+        { title: 'Errors', items: result.errors },
+      ],
+    )
+    return result
+}
+
+runSyncScript(main)