create-appraise 0.1.0

package/templates/default/scripts/sync-template-step-groups.ts

@@ -0,0 +1,399 @@
+#!/usr/bin/env tsx
+
+/**
+ * Script to synchronize template step groups from filesystem to database
+ * Scans step definition files to ensure all step groups exist in DB
+ * Filesystem is the source of truth - groups in DB but not in FS will be deleted
+ * Run this after merging changes to ensure step group sync
+ *
+ * Usage: npx tsx scripts/template-step-group-sync.ts
+ */
+
+import { promises as fs } from 'fs'
+import { join } from 'path'
+import { glob } from 'glob'
+import prisma from '../src/config/db-config'
+import { TemplateStepGroupType } from '@prisma/client'
+
+interface StepGroupJSDoc {
+  name: string
+  description: string | null
+  type: TemplateStepGroupType
+}
+
+interface StepGroupData {
+  name: string
+  description: string | null
+  type: TemplateStepGroupType
+}
+
+interface SyncResult {
+  groupsScanned: number
+  groupsExisting: number
+  groupsCreated: number
+  groupsDeleted: number
+  groupsSkipped: number
+  groupsSkippedNoJSDoc: number
+  errors: string[]
+  createdGroups: string[]
+  existingGroups: string[]
+  deletedGroups: string[]
+  skippedGroups: string[]
+  skippedNoJSDocFiles: string[]
+}
+
+/**
+ * Parses JSDoc comment to extract step group metadata
+ * Returns null if no valid group JSDoc is found
+ */
+function parseGroupJSDoc(content: string): StepGroupJSDoc | null {
+  const lines = content.split('\n')
+
+  // Look for JSDoc comment at the very top of the file
+  if (lines.length === 0) {
+    return null
+  }
+
+  const firstLine = lines[0].trim()
+  if (!firstLine.startsWith('/**')) {
+    return null
+  }
+
+  // Check if this JSDoc contains group metadata (@type distinguishes group from step JSDoc)
+  let hasType = false
+  let endLine = -1
+  let name: string | null = null
+  let description: string | null = null
+  let type: string | null = null
+
+  // Look through the JSDoc block until we find the closing */
+  // Use a reasonable limit (50 lines) to avoid parsing entire files if JSDoc is malformed
+  const maxLines = Math.min(lines.length, 50)
+  for (let i = 0; i < maxLines; i++) {
+    const line = lines[i].trim()
+
+    // Check if this line contains the closing */ (could be on same line as content)
+    if (line.includes('*/')) {
+      // Found end of JSDoc - extract content before */
+      const beforeClose = line.split('*/')[0].trim()
+
+      // Process the content before */ if it contains JSDoc tags
+      // Since we already split by */, beforeClose doesn't contain it anymore
+      if (beforeClose.startsWith('* @name') || beforeClose.startsWith('*@name')) {
+        const match = beforeClose.match(/@name\s+(.+)/)
+        if (match) {
+          name = match[1].trim()
+        }
+      } else if (beforeClose.startsWith('* @description') || beforeClose.startsWith('*@description')) {
+        const match = beforeClose.match(/@description\s+(.+)/)
+        if (match) {
+          description = match[1].trim() || null
+        }
+      } else if (beforeClose.startsWith('* @type') || beforeClose.startsWith('*@type')) {
+        hasType = true
+        const match = beforeClose.match(/@type\s+(.+)/)
+        if (match) {
+          type = match[1].trim()
+        }
+      }
+
+      endLine = i
+      break
+    } else if (line.startsWith('* @name') || line.startsWith('*@name')) {
+      // Extract name
+      const match = line.match(/@name\s+(.+)/)
+      if (match) {
+        name = match[1].trim()
+      }
+    } else if (line.startsWith('* @description') || line.startsWith('*@description')) {
+      // Extract description
+      const match = line.match(/@description\s+(.+)/)
+      if (match) {
+        description = match[1].trim() || null
+      }
+    } else if (line.startsWith('* @type') || line.startsWith('*@type')) {
+      // Found @type - this is group metadata (steps have @icon, not @type)
+      hasType = true
+      const match = line.match(/@type\s+(.+)/)
+      if (match) {
+        type = match[1].trim()
+      }
+    }
+  }
+
+  // If we found a JSDoc block at the top with @type, return parsed data
+  if (hasType && endLine >= 0 && name && type) {
+    // Validate and map type to enum
+    const normalizedType = type.toUpperCase()
+    if (normalizedType !== 'ACTION' && normalizedType !== 'VALIDATION') {
+      throw new Error(`Invalid @type value: ${type}. Must be ACTION or VALIDATION`)
+    }
+
+    return {
+      name: name.trim(),
+      description: description ? description.trim() : null,
+      type: normalizedType as TemplateStepGroupType,
+    }
+  }
+
+  return null
+}
+
+/**
+ * Scans step definition files in actions and validations directories
+ */
+async function scanStepFiles(baseDir: string): Promise<string[]> {
+  const _stepsDir = join(baseDir, 'src', 'tests', 'steps')
+  const stepFiles: string[] = []
+
+  try {
+    // Get all .step.ts files in actions and validations directories
+    const patterns = ['src/tests/steps/actions/**/*.step.ts', 'src/tests/steps/validations/**/*.step.ts']
+
+    for (const pattern of patterns) {
+      const files = await glob(pattern, {
+        cwd: baseDir,
+      })
+      stepFiles.push(...files)
+    }
+  } catch (error) {
+    console.error('Error scanning step files:', error)
+    throw error
+  }
+
+  return stepFiles
+}
+
+/**
+ * Reads and parses step files to extract step group metadata
+ */
+async function readStepGroupsFromFiles(baseDir: string): Promise<StepGroupData[]> {
+  const stepFiles = await scanStepFiles(baseDir)
+  const stepGroups: StepGroupData[] = []
+  const errors: string[] = []
+
+  for (const file of stepFiles) {
+    try {
+      const filePath = join(baseDir, file)
+      const content = await fs.readFile(filePath, 'utf-8')
+      const jsdoc = parseGroupJSDoc(content)
+
+      if (jsdoc) {
+        stepGroups.push(jsdoc)
+      } else {
+        errors.push(`File '${file}' does not have a valid group JSDoc comment`)
+      }
+    } catch (error) {
+      const errorMsg = `Error reading file '${file}': ${error}`
+      errors.push(errorMsg)
+      console.error(`   ⚠️  ${errorMsg}`)
+    }
+  }
+
+  if (errors.length > 0) {
+    console.log(`\n⚠️  Warning: ${errors.length} file(s) skipped due to missing or invalid JSDoc:`)
+    errors.forEach((error, index) => {
+      console.log(`      ${index + 1}. ${error}`)
+    })
+  }
+
+  return stepGroups
+}
+
+/**
+ * Syncs step groups to database
+ */
+async function syncStepGroupsToDatabase(stepGroups: StepGroupData[]): Promise<SyncResult> {
+  const result: SyncResult = {
+    groupsScanned: stepGroups.length,
+    groupsExisting: 0,
+    groupsCreated: 0,
+    groupsDeleted: 0,
+    groupsSkipped: 0,
+    groupsSkippedNoJSDoc: 0,
+    errors: [],
+    createdGroups: [],
+    existingGroups: [],
+    deletedGroups: [],
+    skippedGroups: [],
+    skippedNoJSDocFiles: [],
+  }
+
+  // Get set of step group names from filesystem
+  const fsGroupNames = new Set(stepGroups.map(group => group.name))
+
+  // Get all step groups from database
+  const allDbGroups = await prisma.templateStepGroup.findMany({
+    select: { id: true, name: true },
+  })
+
+  // Delete step groups from DB that are not in filesystem
+  for (const dbGroup of allDbGroups) {
+    if (!fsGroupNames.has(dbGroup.name)) {
+      try {
+        // Check if step group has template steps (foreign key constraint prevents deletion)
+        const templateStepCount = await prisma.templateStep.count({
+          where: { templateStepGroupId: dbGroup.id },
+        })
+
+        if (templateStepCount > 0) {
+          result.groupsSkipped++
+          result.skippedGroups.push(dbGroup.name)
+          console.log(`   ⚠️  Skipped deletion of '${dbGroup.name}' (has ${templateStepCount} template step(s))`)
+        } else {
+          await prisma.templateStepGroup.delete({
+            where: { id: dbGroup.id },
+          })
+          result.groupsDeleted++
+          result.deletedGroups.push(dbGroup.name)
+          console.log(`   🗑️  Deleted step group '${dbGroup.name}' (not in filesystem)`)
+        }
+      } catch (error) {
+        const errorMsg = `Error deleting step group '${dbGroup.name}': ${error}`
+        result.errors.push(errorMsg)
+        console.error(`   ❌ ${errorMsg}`)
+      }
+    }
+  }
+
+  // Create or update step groups from filesystem
+  for (const group of stepGroups) {
+    try {
+      // Check if step group already exists by name
+      const existing = await prisma.templateStepGroup.findFirst({
+        where: { name: group.name },
+      })
+
+      if (existing) {
+        // Check if update is needed (description or type changed)
+        const needsUpdate = existing.description !== group.description || existing.type !== group.type
+
+        if (needsUpdate) {
+          await prisma.templateStepGroup.update({
+            where: { id: existing.id },
+            data: {
+              description: group.description,
+              type: group.type,
+            },
+          })
+          result.groupsExisting++
+          result.existingGroups.push(group.name)
+          console.log(`   🔄 Updated step group '${group.name}'`)
+        } else {
+          result.groupsExisting++
+          result.existingGroups.push(group.name)
+          console.log(`   ✓ Step group '${group.name}' already exists`)
+        }
+      } else {
+        // Create the step group
+        await prisma.templateStepGroup.create({
+          data: {
+            name: group.name,
+            description: group.description,
+            type: group.type,
+          },
+        })
+        result.groupsCreated++
+        result.createdGroups.push(group.name)
+        console.log(`   ➕ Created step group '${group.name}'`)
+      }
+    } catch (error) {
+      const errorMsg = `Error syncing step group '${group.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(`   📁 Step groups scanned: ${result.groupsScanned}`)
+  console.log(`   ✅ Step groups existing: ${result.groupsExisting}`)
+  console.log(`   ➕ Step groups created: ${result.groupsCreated}`)
+  console.log(`   🗑️  Step groups deleted: ${result.groupsDeleted}`)
+  console.log(`   ⚠️  Step groups skipped: ${result.groupsSkipped}`)
+  console.log(`   ❌ Errors: ${result.errors.length}`)
+
+  if (result.createdGroups.length > 0) {
+    console.log('\n   Created step groups:')
+    result.createdGroups.forEach((name, index) => {
+      console.log(`      ${index + 1}. ${name}`)
+    })
+  }
+
+  if (result.existingGroups.length > 0) {
+    console.log('\n   Existing step groups:')
+    result.existingGroups.forEach((name, index) => {
+      console.log(`      ${index + 1}. ${name}`)
+    })
+  }
+
+  if (result.deletedGroups.length > 0) {
+    console.log('\n   Deleted step groups:')
+    result.deletedGroups.forEach((name, index) => {
+      console.log(`      ${index + 1}. ${name}`)
+    })
+  }
+
+  if (result.skippedGroups.length > 0) {
+    console.log('\n   Skipped step groups (have template steps):')
+    result.skippedGroups.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 template step group sync...')
+    console.log('This will scan step definition files and sync step groups to database.\n')
+
+    const baseDir = process.cwd()
+
+    // Read step groups from files
+    console.log('📁 Scanning step definition files...')
+    const stepGroups = await readStepGroupsFromFiles(baseDir)
+    console.log(`   Found ${stepGroups.length} step group(s) with valid JSDoc`)
+
+    if (stepGroups.length === 0) {
+      console.log('\n⚠️  No step groups found. Please ensure step files have valid JSDoc comments.')
+      process.exit(0)
+    }
+
+    // Sync to database
+    console.log('\n✅ Syncing step groups to database...')
+    const result = await syncStepGroupsToDatabase(stepGroups)
+
+    // 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()