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

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

@@ -0,0 +1,287 @@
+#!/usr/bin/env tsx
+
+/**
+ * Combined sync script that orchestrates all entity sync scripts in the correct dependency order
+ * Ensures database and filesystem parity by running all sync scripts sequentially
+ * Continues execution even if individual scripts fail, providing a comprehensive summary at the end
+ *
+ * Usage: npx tsx scripts/sync-all.ts
+ */
+
+import { execa } from 'execa'
+import { join } from 'path'
+import {
+  getSyncScriptDefinition,
+  resolveRequestedSyncExecutionOrder,
+  SYNC_ALL_REQUEST_ID,
+  type SyncScriptId,
+} from '../src/lib/sync/sync-registry'
+import { printSyncSummary } from './lib/sync-summary'
+const SYNC_SCRIPT_IDS = resolveRequestedSyncExecutionOrder(SYNC_ALL_REQUEST_ID)
+const DIVIDER = '='.repeat(80)
+
+interface DatabaseChanges {
+  scanned: number
+  existing: number
+  created: number
+  updated: number
+  deleted: number
+  errors: number
+}
+
+interface ScriptResult {
+  name: string
+  description: string
+  success: boolean
+  exitCode: number | null
+  duration: number
+  stdout: string
+  stderr: string
+  error?: Error
+  dbChanges?: DatabaseChanges
+}
+
+interface SyncSummary {
+  totalScripts: number
+  successfulScripts: number
+  failedScripts: number
+  totalDuration: number
+  results: ScriptResult[]
+  totalDbChanges: DatabaseChanges
+}
+
+const DB_CHANGE_PATTERNS: Array<{ key: keyof DatabaseChanges; regex: RegExp }> = [
+  { key: 'scanned', regex: /scanned:\s*(\d+)/i },
+  { key: 'existing', regex: /existing:\s*(\d+)/i },
+  { key: 'created', regex: /created:\s*(\d+)/i },
+  { key: 'updated', regex: /updated:\s*(\d+)/i },
+  { key: 'deleted', regex: /deleted:\s*(\d+)/i },
+  { key: 'errors', regex: /Errors:\s*(\d+)/i },
+]
+
+/**
+ * Parses database changes from sync script output
+ * Extracts counts from the "Sync Summary:" section
+ */
+function parseDatabaseChanges(stdout: string): DatabaseChanges | undefined {
+  const changes: DatabaseChanges = {
+    scanned: 0,
+    existing: 0,
+    created: 0,
+    updated: 0,
+    deleted: 0,
+    errors: 0,
+  }
+
+  // Child sync scripts are expected to print a canonical "📊 Sync Summary:"
+  // block. If absent, we skip aggregation for that child.
+  const summaryIndex = stdout.indexOf('📊 Sync Summary:')
+  if (summaryIndex === -1) {
+    return undefined
+  }
+
+  const summarySection = stdout.substring(summaryIndex)
+
+  for (const pattern of DB_CHANGE_PATTERNS) {
+    const match = summarySection.match(pattern.regex)
+    if (match) {
+      changes[pattern.key] = parseInt(match[1], 10) || 0
+    }
+  }
+
+  return changes
+}
+
+/**
+ * Executes a single sync script and captures the result
+ */
+async function executeSyncScript(scriptId: SyncScriptId): Promise<ScriptResult> {
+  const definition = getSyncScriptDefinition(scriptId)
+  const scriptPath = join(process.cwd(), 'scripts', definition.scriptFile)
+  const startTime = Date.now()
+
+  try {
+    console.log(`\n🔄 Running ${scriptId}...`)
+    const result = await execa(process.execPath, ['--import', 'tsx', scriptPath], {
+      cwd: process.cwd(),
+      stdio: 'pipe',
+      // Non-zero exit codes are reported in summary but should not stop orchestration.
+      reject: false,
+    })
+
+    const duration = Date.now() - startTime
+    const success = result.exitCode === 0
+    const dbChanges = parseDatabaseChanges(result.stdout)
+
+    if (success) {
+      console.log(`   ✅ ${scriptId} completed successfully (${duration}ms)`)
+    } else {
+      console.log(`   ❌ ${scriptId} failed with exit code ${result.exitCode} (${duration}ms)`)
+      if (result.stderr) {
+        console.log(`   Error output: ${result.stderr.substring(0, 200)}...`)
+      }
+    }
+
+    return {
+      name: scriptId,
+      description: definition.description,
+      success,
+      exitCode: result.exitCode ?? null,
+      duration,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      dbChanges,
+    }
+  } catch (error) {
+    const duration = Date.now() - startTime
+    console.log(`   ❌ ${scriptId} threw an error (${duration}ms)`)
+    console.error(`   Error: ${error}`)
+
+    return {
+      name: scriptId,
+      description: definition.description,
+      success: false,
+      exitCode: null,
+      duration,
+      stdout: '',
+      stderr: error instanceof Error ? error.message : String(error),
+      error: error instanceof Error ? error : new Error(String(error)),
+    }
+  }
+}
+
+/**
+ * Aggregates database changes across all scripts
+ */
+function aggregateDatabaseChanges(results: ScriptResult[]): DatabaseChanges {
+  const total: DatabaseChanges = {
+    scanned: 0,
+    existing: 0,
+    created: 0,
+    updated: 0,
+    deleted: 0,
+    errors: 0,
+  }
+
+  for (const result of results) {
+    if (result.dbChanges) {
+      total.scanned += result.dbChanges.scanned
+      total.existing += result.dbChanges.existing
+      total.created += result.dbChanges.created
+      total.updated += result.dbChanges.updated
+      total.deleted += result.dbChanges.deleted
+      total.errors += result.dbChanges.errors
+    }
+  }
+
+  return total
+}
+
+/**
+ * Generates and displays a comprehensive summary of the sync operation
+ */
+function hasDatabaseChanges(changes: DatabaseChanges): boolean {
+  return Object.values(changes).some(value => value > 0)
+}
+
+function displaySummary(summary: SyncSummary): void {
+  console.log('\n' + DIVIDER)
+  console.log('📊 SYNC ALL - EXECUTION SUMMARY')
+  console.log(DIVIDER)
+
+  console.log(`\n📈 Overall Statistics:`)
+  console.log(`   Total scripts: ${summary.totalScripts}`)
+  console.log(`   ✅ Successful: ${summary.successfulScripts}`)
+  console.log(`   ❌ Failed: ${summary.failedScripts}`)
+  console.log(`   ⏱️  Total duration: ${(summary.totalDuration / 1000).toFixed(2)}s`)
+
+  console.log(`\n📋 Execution Results:`)
+  summary.results.forEach((result, index) => {
+    const status = result.success ? '✅' : '❌'
+    const duration = `${(result.duration / 1000).toFixed(2)}s`
+    console.log(`   ${index + 1}. ${status} ${result.name} (${result.description}) - ${duration}`)
+    
+    if (!result.success) {
+      if (result.exitCode !== null) {
+        console.log(`      Exit code: ${result.exitCode}`)
+      }
+      if (result.stderr) {
+        const errorPreview = result.stderr.split('\n').slice(0, 3).join(' | ')
+        console.log(`      Error: ${errorPreview}`)
+      }
+    }
+  })
+
+  // Reuse shared summary rendering so aggregate output format remains
+  // structurally aligned with individual sync scripts.
+  if (hasDatabaseChanges(summary.totalDbChanges)) {
+    printSyncSummary([
+      { label: '📁 Total entities scanned', value: summary.totalDbChanges.scanned },
+      { label: '✅ Total entities existing', value: summary.totalDbChanges.existing },
+      { label: '➕ Total entities created', value: summary.totalDbChanges.created },
+      { label: '🔄 Total entities updated', value: summary.totalDbChanges.updated },
+      { label: '🗑️  Total entities deleted', value: summary.totalDbChanges.deleted },
+      { label: '❌ Total errors encountered', value: summary.totalDbChanges.errors },
+    ])
+  }
+
+  console.log(`\n${DIVIDER}`)
+
+  if (summary.failedScripts === 0) {
+    console.log('✅ All sync scripts completed successfully!')
+    console.log(DIVIDER + '\n')
+  } else {
+    console.log(`⚠️  ${summary.failedScripts} script(s) failed. Please review the errors above.`)
+    console.log(DIVIDER + '\n')
+  }
+}
+
+/**
+ * Main function that orchestrates all sync scripts
+ */
+async function main(): Promise<number> {
+  const startTime = Date.now()
+  const results: ScriptResult[] = []
+
+  console.log('🚀 Starting combined sync operation...')
+  console.log('This will sync all entities from filesystem to database in the correct dependency order.')
+  console.log('Execution will continue even if individual scripts fail.\n')
+
+  // Execute in dependency order from registry; we intentionally continue through
+  // failures to provide complete visibility of system state in one run.
+  for (const scriptId of SYNC_SCRIPT_IDS) {
+    const result = await executeSyncScript(scriptId)
+    results.push(result)
+    
+    // Continue execution even if script failed (as per user requirement)
+    // The script will log the failure but continue with remaining scripts
+  }
+
+  const totalDuration = Date.now() - startTime
+  const successfulScripts = results.filter(r => r.success).length
+  const failedScripts = results.filter(r => !r.success).length
+  const totalDbChanges = aggregateDatabaseChanges(results)
+
+  const summary: SyncSummary = {
+    totalScripts: SYNC_SCRIPT_IDS.length,
+    successfulScripts,
+    failedScripts,
+    totalDuration,
+    results,
+    totalDbChanges,
+  }
+
+  // Display comprehensive summary
+  displaySummary(summary)
+
+  return failedScripts > 0 ? 1 : 0
+}
+
+// Run the main function
+main().catch(error => {
+  console.error('\n❌ Fatal error during sync orchestration:', error)
+  return 1
+})
+  .then(exitCode => {
+    process.exit(exitCode)
+  })

package/templates/starter/scripts/sync-appraise-base-template.ts

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+/**
+ * Sync the starter template from the base app (repo root).
+ * Copies src/, automation/, prisma/, public/, scripts/, selected internal packages,
+ * and root config files into templates/starter/ while preserving template-only files.
+ *
+ * Usage: npx tsx scripts/sync-appraise-base-template.ts
+ * Or: npm run sync-template
+ */
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'fs'
+import { dirname, join } from 'path'
+import { fileURLToPath } from 'url'
+import { shouldBackfillLegacyEnvironmentConfig, shouldExcludeTemplatePath } from '../src/lib/template-sync-utils'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const repoRoot = join(__dirname, '..')
+const target = join(repoRoot, 'templates', 'starter')
+
+/**
+ * Delegates template path exclusion decisions to shared sync rules.
+ */
+function shouldExclude(relativePath: string): boolean {
+  return shouldExcludeTemplatePath(relativePath)
+}
+
+/**
+ * Recursively copies a directory while applying path-level exclusion rules.
+ */
+function copyDirWithFilter(
+  src: string,
+  dest: string,
+  options: { base?: string; shouldExcludePath?: (relativePath: string) => boolean } = {},
+): void {
+  if (!existsSync(src)) return
+
+  const { base = src, shouldExcludePath = shouldExclude } = options
+  mkdirSync(dest, { recursive: true })
+  for (const entry of readdirSync(src, { withFileTypes: true })) {
+    const srcPath = join(src, entry.name)
+    const relativePath = srcPath.slice(base.length + 1).replace(/\\/g, '/')
+    if (shouldExcludePath(relativePath)) continue
+
+    const destPath = join(dest, entry.name)
+    if (entry.isDirectory()) {
+      copyDirWithFilter(srcPath, destPath, { base, shouldExcludePath })
+      continue
+    }
+
+    cpSync(srcPath, destPath, { force: true })
+  }
+}
+
+/**
+ * Copies a file and ensures destination directory exists.
+ */
+function copyFile(src: string, dest: string): void {
+  mkdirSync(dirname(dest), { recursive: true })
+  cpSync(src, dest, { force: true })
+}
+
+/**
+ * Resets reports directory in template to an empty starter shape.
+ */
+function resetAutomationReports(templateRoot: string): void {
+  const reportsRoot = join(templateRoot, 'automation', 'reports')
+  rmSync(reportsRoot, { recursive: true, force: true })
+  mkdirSync(join(reportsRoot, 'logs'), { recursive: true })
+  mkdirSync(join(reportsRoot, 'traces'), { recursive: true })
+}
+
+/**
+ * Resets template locator map to a clean empty array.
+ */
+function resetAutomationLocatorMap(templateRoot: string): void {
+  const locatorMapPath = join(templateRoot, 'automation', 'mapping', 'locator-map.json')
+  mkdirSync(dirname(locatorMapPath), { recursive: true })
+  writeFileSync(locatorMapPath, '[]\n')
+}
+
+/**
+ * Backfills legacy environment config when new location is missing.
+ */
+function syncLegacyEnvironmentConfig(): void {
+  const legacyEnvironmentsDir = join(repoRoot, 'src', 'tests', 'config', 'environments')
+  const targetEnvironmentsDir = join(target, 'automation', 'config', 'environments')
+  const targetEnvironmentsFile = join(targetEnvironmentsDir, 'environments.json')
+
+  if (!shouldBackfillLegacyEnvironmentConfig(existsSync(targetEnvironmentsFile), existsSync(legacyEnvironmentsDir))) {
+    return
+  }
+
+  mkdirSync(targetEnvironmentsDir, { recursive: true })
+  cpSync(legacyEnvironmentsDir, targetEnvironmentsDir, { recursive: true, force: true })
+  console.log('Backfilled automation/config/environments from legacy src/tests config.')
+}
+
+type InternalPackageSyncConfig = {
+  name: string
+  directories: string[]
+}
+
+const INTERNAL_PACKAGES: InternalPackageSyncConfig[] = [
+  { name: 'cucumber-runtime', directories: ['src'] },
+  { name: 'locator-picker-companion', directories: ['src', 'dist'] },
+]
+
+/**
+ * Syncs one internal package into template/packages.
+ */
+function syncInternalPackage({ name, directories }: InternalPackageSyncConfig): void {
+  const packageRoot = join(repoRoot, 'packages', name)
+  const packageTarget = join(target, 'packages', name)
+
+  rmSync(packageTarget, { recursive: true, force: true })
+  mkdirSync(packageTarget, { recursive: true })
+
+  copyFile(join(packageRoot, 'package.json'), join(packageTarget, 'package.json'))
+  copyFile(join(packageRoot, 'tsconfig.json'), join(packageTarget, 'tsconfig.json'))
+
+  const shouldExcludeInternalPackagePath = (relativePath: string): boolean => {
+    if (relativePath === 'dist' || relativePath.startsWith('dist/')) {
+      return false
+    }
+
+    return shouldExclude(relativePath)
+  }
+
+  for (const directory of directories) {
+    copyDirWithFilter(join(packageRoot, directory), join(packageTarget, directory), {
+      base: packageRoot,
+      shouldExcludePath: shouldExcludeInternalPackagePath,
+    })
+  }
+}
+
+function main(): void {
+  const readmePath = join(target, 'README.md')
+  const appraisejsConfigPath = join(target, 'appraisejs.config.json')
+  const savedReadme = existsSync(readmePath) ? readFileSync(readmePath, 'utf8') : null
+  const savedAppraisejsConfig = existsSync(appraisejsConfigPath) ? readFileSync(appraisejsConfigPath, 'utf8') : null
+
+  rmSync(target, { recursive: true, force: true })
+  mkdirSync(target, { recursive: true })
+
+  console.log('Copying src/...')
+  copyDirWithFilter(join(repoRoot, 'src'), join(target, 'src'))
+
+console.log('Copying automation/...')
+copyDirWithFilter(join(repoRoot, 'automation'), join(target, 'automation'))
+syncLegacyEnvironmentConfig()
+resetAutomationReports(target)
+resetAutomationLocatorMap(target)
+
+for (const internalPackage of INTERNAL_PACKAGES) {
+  console.log(`Copying internal package ${internalPackage.name}...`)
+  syncInternalPackage(internalPackage)
+}
+
+console.log('Copying prisma/...')
+copyDirWithFilter(join(repoRoot, 'prisma'), join(target, 'prisma'))
+console.log('Copying public/...')
+copyDirWithFilter(join(repoRoot, 'public'), join(target, 'public'))
+console.log('Copying scripts/...')
+copyDirWithFilter(join(repoRoot, 'scripts'), join(target, 'scripts'))
+
+const legacyTestsRoot = join(target, 'src', 'tests')
+if (existsSync(legacyTestsRoot)) {
+  rmSync(legacyTestsRoot, { recursive: true, force: true })
+}
+
+const configFiles = [
+  '.gitignore',
+  'eslint.config.mjs',
+  'tailwind.config.ts',
+  'tsconfig.json',
+  'postcss.config.mjs',
+  'components.json',
+  'next.config.ts',
+  'next-env.d.ts',
+  '.env.example',
+  'package-lock.json',
+  'yarn.lock',
+  'pnpm-lock.yaml',
+  'bun.lockb',
+]
+for (const name of configFiles) {
+  const src = join(repoRoot, name)
+  if (existsSync(src)) {
+    copyFile(src, join(target, name))
+  }
+}
+
+const cucumberSource = join(repoRoot, 'cucumber.mjs')
+if (existsSync(cucumberSource)) {
+  copyFile(cucumberSource, join(target, 'cucumber.mjs'))
+  console.log('Synced cucumber.mjs to template')
+}
+
+const vscodeSource = join(repoRoot, '.vscode')
+if (existsSync(vscodeSource)) {
+  cpSync(vscodeSource, join(target, '.vscode'), { recursive: true, force: true })
+  console.log('Synced .vscode to template')
+}
+
+const rootPkg = JSON.parse(readFileSync(join(repoRoot, 'package.json'), 'utf8')) as {
+  scripts: Record<string, string>
+  [key: string]: unknown
+}
+rootPkg.scripts = {
+  ...rootPkg.scripts,
+  build: 'npm run build:local',
+  'build:local':
+    'npm run generate-db-client && npm run build:cucumber-runtime && npm run build:locator-picker-companion && next build',
+  start: 'next start',
+  'generate-db-client': 'npx prisma generate --schema prisma/schema.prisma',
+  'migrate-db': 'npx prisma migrate deploy',
+  'install-playwright': 'npx playwright install',
+  setup: 'npm run install-dependencies && npm run setup:db && npm run build:local && npm run protect-seeded-files',
+  'setup:db': 'npm run setup-env && npm run generate-db-client && npm run migrate-db && npm run sync-all',
+  'setup:full':
+    'npm run install-dependencies && npm run setup:db && npm run build:local && npm run protect-seeded-files',
+  'protect-seeded-files': 'npx tsx scripts/protect-seeded-files.ts',
+  'appraisejs:setup': 'npm run setup',
+  'appraisejs:sync': 'npm run sync-all',
+  'appraisejs:install-step': 'npx tsx scripts/install-template-step.ts',
+}
+delete rootPkg.scripts['build:appraisejs']
+delete rootPkg.scripts['build-step-registry']
+writeFileSync(join(target, 'package.json'), JSON.stringify(rootPkg, null, 2) + '\n')
+console.log('Wrote template package.json with production-first scaffold scripts.')
+
+  if (savedReadme) {
+    writeFileSync(readmePath, savedReadme)
+    console.log('Restored README.md')
+  }
+  if (savedAppraisejsConfig) {
+    writeFileSync(appraisejsConfigPath, savedAppraisejsConfig)
+    console.log('Restored appraisejs.config.json')
+  }
+
+  console.log('Synced base app to templates/starter with starter automation assets.')
+}
+
+main()