create-appraisejs 0.2.0 → 0.3.0-alpha.1

package/templates/blank/scripts/sync-environments.ts

@@ -0,0 +1,305 @@
+#!/usr/bin/env tsx
+
+/**
+ * Script to synchronize environments from filesystem to database
+ * Scans environments.json file to ensure all environments exist in DB
+ * Run this after merging changes to ensure environment sync
+ *
+ * Usage: npx tsx scripts/sync-environments.ts
+ */
+
+import { promises as fs } from 'fs'
+import path from 'path'
+import prisma from '../src/config/db-config'
+import { ensureAutomationWorkspaceReady, getAutomationEnvironmentsDir } from '../src/lib/automation/paths'
+import { printSyncSummary } from './lib/sync-summary'
+import { runSyncScript } from './lib/sync-script-runner'
+
+interface EnvironmentConfig {
+  baseUrl: string
+  apiBaseUrl: string
+  email: string
+  password: string
+}
+
+interface EnvironmentData {
+  name: string
+  baseUrl: string
+  apiBaseUrl: string | null
+  username: string | null
+  password: string | null
+}
+
+interface SyncResult {
+  environmentsScanned: number
+  environmentsExisting: number
+  environmentsCreated: number
+  environmentsDeleted: number
+  environmentsSkipped: number
+  errors: string[]
+  createdEnvironments: string[]
+  existingEnvironments: string[]
+  deletedEnvironments: string[]
+  skippedEnvironments: string[]
+}
+
+const EMPTY_ENVIRONMENTS_FILE_CONTENT = '{}\n'
+
+/**
+ * Reads and parses the environments.json file
+ */
+async function readEnvironmentsFromFile(): Promise<Record<string, EnvironmentConfig>> {
+  const filePath = path.join(getAutomationEnvironmentsDir(), 'environments.json')
+
+  try {
+    await fs.access(filePath)
+  } catch {
+    await fs.mkdir(path.dirname(filePath), { recursive: true })
+    await fs.writeFile(filePath, EMPTY_ENVIRONMENTS_FILE_CONTENT, 'utf-8')
+    return {}
+  }
+
+  try {
+    const fileContent = await fs.readFile(filePath, 'utf-8')
+    const jsonContent = JSON.parse(fileContent) as Record<string, EnvironmentConfig>
+
+    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 environments file: ${error.message}`)
+    }
+    throw error
+  }
+}
+
+function normalizeEnvironmentName(name: string): string {
+  if (!name || name.trim() === '') {
+    return name
+  }
+
+  return name
+    .trim()
+    .replace(/[_\s]+/g, ' ')
+    .split(' ')
+    .filter(Boolean)
+    .map(segment => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase())
+    .join(' ')
+}
+
+function getEnvironmentIdentityKey(name: string): string {
+  return name
+    .trim()
+    .replace(/[_\s]+/g, ' ')
+    .toLowerCase()
+}
+
+/**
+ * Builds Environment objects from JSON content
+ * Maps JSON structure to Prisma Environment model
+ */
+function buildEnvironmentObjects(
+  jsonContent: Record<string, EnvironmentConfig>,
+): EnvironmentData[] {
+  const environments: EnvironmentData[] = []
+
+  for (const [key, config] of Object.entries(jsonContent)) {
+    // Normalize the environment name to title case for consistency
+    const name = normalizeEnvironmentName(key)
+
+    // Map email to username
+    const username = config.email && config.email.trim() !== '' ? config.email.trim() : null
+
+    // Convert empty strings to null for optional fields
+    const apiBaseUrl = config.apiBaseUrl && config.apiBaseUrl.trim() !== '' ? config.apiBaseUrl.trim() : null
+    const password = config.password && config.password.trim() !== '' ? config.password.trim() : null
+
+    // Validate required fields
+    if (!config.baseUrl || config.baseUrl.trim() === '') {
+      throw new Error(`Environment '${name}' is missing required field 'baseUrl'`)
+    }
+
+    environments.push({
+      name,
+      baseUrl: config.baseUrl.trim(),
+      apiBaseUrl,
+      username,
+      password,
+    })
+  }
+
+  return environments
+}
+
+/**
+ * Syncs environments to database
+ */
+async function syncEnvironmentsToDatabase(environments: EnvironmentData[]): Promise<SyncResult> {
+  const result: SyncResult = {
+    environmentsScanned: environments.length,
+    environmentsExisting: 0,
+    environmentsCreated: 0,
+    environmentsDeleted: 0,
+    environmentsSkipped: 0,
+    errors: [],
+    createdEnvironments: [],
+    existingEnvironments: [],
+    deletedEnvironments: [],
+    skippedEnvironments: [],
+  }
+
+  // Get set of normalized environment names from JSON file (for case-insensitive comparison)
+  const jsonEnvironmentNamesNormalized = new Set(environments.map(env => getEnvironmentIdentityKey(env.name)))
+
+  // Get all environments from database
+  const allDbEnvironments = await prisma.environment.findMany({
+    select: { id: true, name: true, baseUrl: true, apiBaseUrl: true, username: true, password: true },
+  })
+
+  // Create a case-insensitive map: normalized name -> actual DB name
+  const dbEnvironmentsByNormalizedName = new Map<
+    string,
+    { id: string; name: string; baseUrl: string; apiBaseUrl: string | null; username: string | null; password: string | null }
+  >()
+  for (const dbEnv of allDbEnvironments) {
+    const normalizedName = getEnvironmentIdentityKey(dbEnv.name)
+    // If we find a duplicate normalized name, keep the first one
+    if (!dbEnvironmentsByNormalizedName.has(normalizedName)) {
+      dbEnvironmentsByNormalizedName.set(normalizedName, dbEnv)
+    }
+  }
+
+  // Delete environments from DB that are not in JSON file (case-insensitive comparison)
+  for (const dbEnv of allDbEnvironments) {
+    const normalizedDbName = getEnvironmentIdentityKey(dbEnv.name)
+    if (!jsonEnvironmentNamesNormalized.has(normalizedDbName)) {
+      try {
+        // Check if environment has test runs (foreign key constraint prevents deletion)
+        const testRunCount = await prisma.testRun.count({
+          where: { environmentId: dbEnv.id },
+        })
+
+        if (testRunCount > 0) {
+          result.environmentsSkipped++
+          result.skippedEnvironments.push(dbEnv.name)
+          console.log(`   ⚠️  Skipped deletion of '${dbEnv.name}' (has ${testRunCount} test run(s))`)
+        } else {
+          await prisma.environment.delete({
+            where: { name: dbEnv.name },
+          })
+          result.environmentsDeleted++
+          result.deletedEnvironments.push(dbEnv.name)
+          console.log(`   🗑️  Deleted environment '${dbEnv.name}' (not in JSON file)`)
+        }
+      } catch (error) {
+        const errorMsg = `Error deleting environment '${dbEnv.name}': ${error}`
+        result.errors.push(errorMsg)
+        console.error(`   ❌ ${errorMsg}`)
+      }
+    }
+  }
+
+  // Create or update environments from JSON file
+  for (const env of environments) {
+    try {
+      const normalizedName = getEnvironmentIdentityKey(env.name)
+      // Check if environment already exists by normalized name (case-insensitive)
+      const existingDbEnv = dbEnvironmentsByNormalizedName.get(normalizedName)
+
+      if (existingDbEnv) {
+        const needsUpdate =
+          existingDbEnv.baseUrl !== env.baseUrl ||
+          (existingDbEnv.apiBaseUrl ?? null) !== env.apiBaseUrl ||
+          (existingDbEnv.username ?? null) !== env.username ||
+          (existingDbEnv.password ?? null) !== env.password
+
+        if (needsUpdate) {
+          await prisma.environment.update({
+            where: { id: existingDbEnv.id },
+            data: {
+              baseUrl: env.baseUrl,
+              apiBaseUrl: env.apiBaseUrl,
+              username: env.username,
+              password: env.password,
+            },
+          })
+          console.log(`   🔄 Updated environment '${existingDbEnv.name}'`)
+        }
+        result.environmentsExisting++
+        result.existingEnvironments.push(existingDbEnv.name)
+        console.log(`   ✓ Environment '${existingDbEnv.name}' already exists`)
+      } else {
+        // Create the environment
+        await prisma.environment.create({
+          data: {
+            name: env.name,
+            baseUrl: env.baseUrl,
+            apiBaseUrl: env.apiBaseUrl,
+            username: env.username,
+            password: env.password,
+          },
+        })
+        result.environmentsCreated++
+        result.createdEnvironments.push(env.name)
+        console.log(`   ➕ Created environment '${env.name}'`)
+      }
+    } catch (error) {
+      const errorMsg = `Error syncing environment '${env.name}': ${error}`
+      result.errors.push(errorMsg)
+      console.error(`   ❌ ${errorMsg}`)
+    }
+  }
+
+  return result
+}
+
+/**
+ * Generates and displays sync summary
+ */
+async function main(): Promise<SyncResult> {
+    console.log('🔄 Starting environments sync...')
+    console.log('This will scan environments.json and sync environments to database.\n')
+
+    await ensureAutomationWorkspaceReady()
+
+    // Read environments from file
+    console.log('📁 Reading environments.json...')
+    const jsonContent = await readEnvironmentsFromFile()
+    const environmentKeys = Object.keys(jsonContent)
+    console.log(`   Found ${environmentKeys.length} environment(s): ${environmentKeys.join(', ') || 'none'}`)
+
+    // Build environment objects
+    console.log('\n🔍 Building environment objects...')
+    const environments = buildEnvironmentObjects(jsonContent)
+    console.log(`   Built ${environments.length} environment object(s)`)
+
+    // Sync to database
+    console.log('\n✅ Syncing environments to database...')
+    const result = await syncEnvironmentsToDatabase(environments)
+
+    printSyncSummary(
+      [
+        { label: '📁 Environments scanned', value: result.environmentsScanned },
+        { label: '✅ Environments existing', value: result.environmentsExisting },
+        { label: '➕ Environments created', value: result.environmentsCreated },
+        { label: '🗑️  Environments deleted', value: result.environmentsDeleted },
+        { label: '⚠️  Environments skipped', value: result.environmentsSkipped },
+        { label: '❌ Errors', value: result.errors.length },
+      ],
+      [
+        { title: 'Created environments', items: result.createdEnvironments },
+        { title: 'Existing environments', items: result.existingEnvironments },
+        { title: 'Deleted environments', items: result.deletedEnvironments },
+        { title: 'Skipped environments (have test runs)', items: result.skippedEnvironments },
+        { title: 'Errors', items: result.errors },
+      ],
+    )
+    return result
+}
+
+runSyncScript(main)
+
+

package/templates/blank/scripts/sync-locator-groups.ts

@@ -0,0 +1,358 @@
+#!/usr/bin/env tsx
+
+/**
+ * Script to synchronize locator groups from filesystem to database
+ * Scans locator-map.json and locators directory to ensure all locator groups exist in DB
+ * Filesystem is the source of truth - locator groups in DB but not in FS will be deleted
+ * Run this after merging changes to ensure locator group sync
+ *
+ * Usage: npx tsx scripts/sync-locator-groups.ts
+ */
+
+import { promises as fs } from 'fs'
+import { join } from 'path'
+import { glob } from 'glob'
+import prisma from '../src/config/db-config'
+import { findModuleByPath, buildModuleHierarchy } from '../src/lib/module-hierarchy-builder'
+import { getAutomationLocatorMapPath } from '../src/lib/template-sync-utils'
+import { extractLocatorGroupName, extractModulePathFromLocatorFile } from './lib/filename-utils'
+import { printSyncSummary } from './lib/sync-summary'
+import { runSyncScript } from './lib/sync-script-runner'
+
+/**
+ * Represents a locator group from the filesystem
+ */
+interface LocatorGroupFromFS {
+  name: string
+  route: string
+  modulePath: string
+  filePath: string
+}
+
+/**
+ * Represents a locator group entry from locator-map.json
+ */
+interface LocatorMapEntry {
+  name: string
+  path: string
+}
+
+/**
+ * Sync result summary
+ */
+interface SyncResult {
+  locatorGroupsScanned: number
+  locatorGroupsExisting: number
+  locatorGroupsCreated: number
+  locatorGroupsUpdated: number
+  locatorGroupsDeleted: number
+  errors: string[]
+  createdLocatorGroups: string[]
+  updatedLocatorGroups: string[]
+  deletedLocatorGroups: Array<{ name: string; locatorCount: number }>
+}
+
+/**
+ * Reads and parses the locator-map.json file
+ */
+async function readLocatorMap(baseDir: string): Promise<LocatorMapEntry[]> {
+  const locatorMapPath = getAutomationLocatorMapPath(baseDir)
+
+  try {
+    await fs.access(locatorMapPath)
+  } catch {
+    console.warn(`   ⚠️  Locator map file not found at ${locatorMapPath}, continuing without it`)
+    return []
+  }
+
+  try {
+    const fileContent = await fs.readFile(locatorMapPath, 'utf-8')
+    const locatorMap = JSON.parse(fileContent) as LocatorMapEntry[]
+
+    if (!Array.isArray(locatorMap)) {
+      throw new Error('Invalid locator map format: expected an array')
+    }
+
+    return locatorMap
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Invalid JSON in locator map file: ${error.message}`)
+    }
+    throw error
+  }
+}
+
+/**
+ * Scans the locators directory to find all locator group files
+ */
+async function scanLocatorGroupFiles(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 group files: ${error}`)
+  }
+}
+
+/**
+ * Builds a map of locator group names to routes from locator-map.json
+ */
+function buildLocatorMapRouteMap(locatorMap: LocatorMapEntry[]): Map<string, string> {
+  const routeMap = new Map<string, string>()
+
+  for (const entry of locatorMap) {
+    routeMap.set(entry.name, entry.path)
+  }
+
+  return routeMap
+}
+
+/**
+ * Builds locator groups from filesystem
+ * Combines information from locator-map.json and directory structure
+ */
+async function buildLocatorGroupsFromFS(
+  baseDir: string,
+  locatorMap: LocatorMapEntry[],
+): Promise<LocatorGroupFromFS[]> {
+  const locatorGroups: LocatorGroupFromFS[] = []
+  const routeMap = buildLocatorMapRouteMap(locatorMap)
+
+  // Scan all locator group files
+  const files = await scanLocatorGroupFiles(baseDir)
+
+  for (const filePath of files) {
+    const modulePath = extractModulePathFromLocatorFile(filePath, baseDir)
+    const groupName = extractLocatorGroupName(filePath)
+
+    // Get route from locator-map.json, or default to /{groupName}
+    const route = routeMap.get(groupName) || `/${groupName}`
+
+    locatorGroups.push({
+      name: groupName,
+      route,
+      modulePath,
+      filePath,
+    })
+  }
+
+  return locatorGroups
+}
+
+/**
+ * Creates or updates a locator group in the database
+ */
+async function createOrUpdateLocatorGroup(
+  locatorGroup: LocatorGroupFromFS,
+  moduleId: string,
+  result: SyncResult,
+): Promise<void> {
+  try {
+    // Check if locator group already exists
+    const existingGroup = await prisma.locatorGroup.findUnique({
+      where: { name: locatorGroup.name },
+    })
+
+    if (existingGroup) {
+      // Check if update is needed
+      const needsUpdate = existingGroup.route !== locatorGroup.route || existingGroup.moduleId !== moduleId
+
+      if (needsUpdate) {
+        await prisma.locatorGroup.update({
+          where: { id: existingGroup.id },
+          data: {
+            route: locatorGroup.route,
+            moduleId: moduleId,
+          },
+        })
+
+        result.locatorGroupsUpdated++
+        result.updatedLocatorGroups.push(locatorGroup.name)
+        console.log(`   🔄 Updated locator group '${locatorGroup.name}' (route: ${locatorGroup.route})`)
+      } else {
+        result.locatorGroupsExisting++
+        console.log(`   ✓ Locator group '${locatorGroup.name}' already exists and is up to date`)
+      }
+    } else {
+      // Create new locator group
+      await prisma.locatorGroup.create({
+        data: {
+          name: locatorGroup.name,
+          route: locatorGroup.route,
+          moduleId: moduleId,
+        },
+      })
+
+      result.locatorGroupsCreated++
+      result.createdLocatorGroups.push(locatorGroup.name)
+      console.log(`   ➕ Created locator group '${locatorGroup.name}' (route: ${locatorGroup.route})`)
+    }
+  } catch (error) {
+    const errorMsg = `Error syncing locator group '${locatorGroup.name}': ${error}`
+    result.errors.push(errorMsg)
+    console.error(`   ❌ ${errorMsg}`)
+  }
+}
+
+/**
+ * Syncs locator groups from filesystem to database
+ */
+async function syncLocatorGroupsToDatabase(
+  locatorGroups: LocatorGroupFromFS[],
+  result: SyncResult,
+): Promise<void> {
+  console.log('\n✅ Syncing locator groups to database...')
+
+  for (const locatorGroup of locatorGroups) {
+    try {
+      // Ensure module exists (create if needed)
+      let moduleId = await findModuleByPath(locatorGroup.modulePath)
+
+      if (!moduleId) {
+        console.log(`   📦 Creating module hierarchy for path: ${locatorGroup.modulePath}`)
+        moduleId = await buildModuleHierarchy(locatorGroup.modulePath)
+      }
+
+      // Create or update locator group
+      await createOrUpdateLocatorGroup(locatorGroup, moduleId, result)
+    } catch (error) {
+      const errorMsg = `Error processing locator group '${locatorGroup.name}': ${error}`
+      result.errors.push(errorMsg)
+      console.error(`   ❌ ${errorMsg}`)
+    }
+  }
+}
+
+/**
+ * Deletes orphaned locator groups (groups in DB but not in FS)
+ */
+async function deleteOrphanedLocatorGroups(
+  fsLocatorGroupNames: Set<string>,
+  result: SyncResult,
+): Promise<void> {
+  console.log('\n🔍 Checking for orphaned locator groups (not in filesystem)...')
+
+  try {
+    // Get all locator groups from database
+    const dbLocatorGroups = await prisma.locatorGroup.findMany({
+      include: {
+        locators: {
+          select: { id: true },
+        },
+      },
+    })
+
+    for (const dbGroup of dbLocatorGroups) {
+      // Check if locator group exists in filesystem
+      if (!fsLocatorGroupNames.has(dbGroup.name)) {
+        try {
+          const locatorCount = dbGroup.locators.length
+
+          if (locatorCount > 0) {
+            console.log(
+              `   ⚠️  Locator group '${dbGroup.name}' has ${locatorCount} locator(s) - will be cascade deleted`,
+            )
+          }
+
+          // Delete the locator group (Prisma cascade will handle locators)
+          await prisma.locatorGroup.delete({
+            where: { id: dbGroup.id },
+          })
+
+          result.locatorGroupsDeleted++
+          result.deletedLocatorGroups.push({
+            name: dbGroup.name,
+            locatorCount,
+          })
+          console.log(`   🗑️  Deleted locator group '${dbGroup.name}' (not in filesystem)`)
+        } catch (error) {
+          const errorMsg = `Error deleting locator group '${dbGroup.name}': ${error}`
+          result.errors.push(errorMsg)
+          console.error(`   ❌ ${errorMsg}`)
+        }
+      }
+    }
+  } catch (error) {
+    const errorMsg = `Error checking for orphaned locator groups: ${error}`
+    result.errors.push(errorMsg)
+    console.error(`   ❌ ${errorMsg}`)
+  }
+}
+
+/**
+ * Generates and displays sync summary
+ */
+async function main(): Promise<SyncResult> {
+    console.log('🔄 Starting locator groups sync...')
+    console.log('This will scan filesystem directories and sync locator groups to database.')
+    console.log('Filesystem is the source of truth - locator groups in DB but not in FS will be deleted.\n')
+
+    const baseDir = process.cwd()
+
+    // Initialize result
+    const result: SyncResult = {
+      locatorGroupsScanned: 0,
+      locatorGroupsExisting: 0,
+      locatorGroupsCreated: 0,
+      locatorGroupsUpdated: 0,
+      locatorGroupsDeleted: 0,
+      errors: [],
+      createdLocatorGroups: [],
+      updatedLocatorGroups: [],
+      deletedLocatorGroups: [],
+    }
+
+    // Read locator map
+    console.log('📄 Reading locator-map.json...')
+    const locatorMap = await readLocatorMap(baseDir)
+    console.log(`   Found ${locatorMap.length} entry(ies) in locator map`)
+
+    // Build locator groups from filesystem
+    console.log('\n📁 Scanning automation/locators directory...')
+    const locatorGroups = await buildLocatorGroupsFromFS(baseDir, locatorMap)
+    result.locatorGroupsScanned = locatorGroups.length
+    console.log(`   Found ${locatorGroups.length} locator group(s) in filesystem`)
+
+    if (locatorGroups.length > 0) {
+      console.log('\n   Locator groups found:')
+      locatorGroups.forEach((group, index) => {
+        console.log(`      ${index + 1}. ${group.name} (route: ${group.route}, module: ${group.modulePath})`)
+      })
+    }
+
+    // Sync to database
+    await syncLocatorGroupsToDatabase(locatorGroups, result)
+
+    // Delete orphaned locator groups
+    const fsLocatorGroupNames = new Set(locatorGroups.map(g => g.name))
+    await deleteOrphanedLocatorGroups(fsLocatorGroupNames, result)
+
+    printSyncSummary(
+      [
+        { label: '📁 Locator groups scanned', value: result.locatorGroupsScanned },
+        { label: '✅ Locator groups existing', value: result.locatorGroupsExisting },
+        { label: '➕ Locator groups created', value: result.locatorGroupsCreated },
+        { label: '🔄 Locator groups updated', value: result.locatorGroupsUpdated },
+        { label: '🗑️  Locator groups deleted', value: result.locatorGroupsDeleted },
+        { label: '❌ Errors', value: result.errors.length },
+      ],
+      [
+        { title: 'Created locator groups', items: result.createdLocatorGroups },
+        { title: 'Updated locator groups', items: result.updatedLocatorGroups },
+        {
+          title: 'Deleted locator groups',
+          items: result.deletedLocatorGroups.map(
+            group => `${group.name} (${group.locatorCount} locator(s) cascade deleted)`,
+          ),
+        },
+        { title: 'Errors', items: result.errors },
+      ],
+    )
+    return result
+}
+
+runSyncScript(main)