create-appraisejs 0.1.10-alpha.8 → 0.2.0-alpha.1

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

@@ -10,58 +10,13 @@
 
 import { execa } from 'execa'
 import { join } from 'path'
-
-/**
- * Sync script configuration with execution order and dependencies
- * Order is critical - scripts must run after their dependencies
- */
-const SYNC_SCRIPTS = [
-  {
-    name: 'sync-modules',
-    description: 'Sync module hierarchy',
-    dependencies: [], // No dependencies - base entity
-  },
-  {
-    name: 'sync-environments',
-    description: 'Sync environments',
-    dependencies: [], // No dependencies - standalone
-  },
-  {
-    name: 'sync-tags',
-    description: 'Sync tags',
-    dependencies: [], // No dependencies - standalone
-  },
-  {
-    name: 'sync-template-step-groups',
-    description: 'Sync template step groups',
-    dependencies: [], // No dependencies - base for template steps
-  },
-  {
-    name: 'sync-template-steps',
-    description: 'Sync template steps',
-    dependencies: ['sync-template-step-groups'], // Depends on template-step-groups
-  },
-  {
-    name: 'sync-locator-groups',
-    description: 'Sync locator groups',
-    dependencies: ['sync-modules'], // Depends on modules
-  },
-  {
-    name: 'sync-locators',
-    description: 'Sync locators',
-    dependencies: ['sync-locator-groups'], // Depends on locator-groups
-  },
-  {
-    name: 'sync-test-suites',
-    description: 'Sync test suites',
-    dependencies: ['sync-modules', 'sync-tags'], // Depends on modules and tags
-  },
-  {
-    name: 'sync-test-cases',
-    description: 'Sync test cases',
-    dependencies: ['sync-test-suites', 'sync-template-steps', 'sync-tags'], // Depends on test-suites, template-steps, and tags
-  },
-] as const
+import {
+  getSyncScriptDefinition,
+  resolveRequestedSyncExecutionOrder,
+  SYNC_ALL_REQUEST_ID,
+  type SyncScriptId,
+} from '../src/lib/sync/sync-registry'
+const SYNC_SCRIPT_IDS = resolveRequestedSyncExecutionOrder(SYNC_ALL_REQUEST_ID)
 
 interface DatabaseChanges {
   scanned: number
@@ -138,13 +93,14 @@ function parseDatabaseChanges(stdout: string): DatabaseChanges | undefined {
 /**
  * Executes a single sync script and captures the result
  */
-async function executeSyncScript(scriptName: string): Promise<ScriptResult> {
-  const scriptPath = join(process.cwd(), 'scripts', `${scriptName}.ts`)
+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 ${scriptName}...`)
-    const result = await execa('npx', ['tsx', scriptPath], {
+    console.log(`\n🔄 Running ${scriptId}...`)
+    const result = await execa(process.execPath, ['--import', 'tsx', scriptPath], {
       cwd: process.cwd(),
       stdio: 'pipe',
       reject: false, // Don't throw on non-zero exit codes
@@ -155,17 +111,17 @@ async function executeSyncScript(scriptName: string): Promise<ScriptResult> {
     const dbChanges = parseDatabaseChanges(result.stdout)
 
     if (success) {
-      console.log(`   ✅ ${scriptName} completed successfully (${duration}ms)`)
+      console.log(`   ✅ ${scriptId} completed successfully (${duration}ms)`)
     } else {
-      console.log(`   ❌ ${scriptName} failed with exit code ${result.exitCode} (${duration}ms)`)
+      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: scriptName,
-      description: SYNC_SCRIPTS.find(s => s.name === scriptName)?.description || scriptName,
+      name: scriptId,
+      description: definition.description,
       success,
       exitCode: result.exitCode ?? null,
       duration,
@@ -175,12 +131,12 @@ async function executeSyncScript(scriptName: string): Promise<ScriptResult> {
     }
   } catch (error) {
     const duration = Date.now() - startTime
-    console.log(`   ❌ ${scriptName} threw an error (${duration}ms)`)
+    console.log(`   ❌ ${scriptId} threw an error (${duration}ms)`)
     console.error(`   Error: ${error}`)
 
     return {
-      name: scriptName,
-      description: SYNC_SCRIPTS.find(s => s.name === scriptName)?.description || scriptName,
+      name: scriptId,
+      description: definition.description,
       success: false,
       exitCode: null,
       duration,
@@ -301,8 +257,8 @@ async function main(): Promise<void> {
   console.log('Execution will continue even if individual scripts fail.\n')
 
   // Execute each script in order
-  for (const script of SYNC_SCRIPTS) {
-    const result = await executeSyncScript(script.name)
+  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)
@@ -315,7 +271,7 @@ async function main(): Promise<void> {
   const totalDbChanges = aggregateDatabaseChanges(results)
 
   const summary: SyncSummary = {
-    totalScripts: SYNC_SCRIPTS.length,
+    totalScripts: SYNC_SCRIPT_IDS.length,
     successfulScripts,
     failedScripts,
     totalDuration,

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
  * Sync the default template from the base app (repo root).
- * Copies src/, automation/, prisma/, public/, scripts/, the cucumber runtime package,
+ * Copies src/, automation/, prisma/, public/, scripts/, selected internal packages,
  * and root config files into templates/default/ while preserving template-only files.
  *
  * Usage: npx tsx scripts/sync-appraise-base-template.ts
@@ -20,18 +20,23 @@ function shouldExclude(relativePath: string): boolean {
   return shouldExcludeTemplatePath(relativePath)
 }
 
-function copyDirWithFilter(src: string, dest: string, base = src): void {
+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 (shouldExclude(relativePath)) continue
+    if (shouldExcludePath(relativePath)) continue
 
     const destPath = join(dest, entry.name)
     if (entry.isDirectory()) {
-      copyDirWithFilter(srcPath, destPath, base)
+      copyDirWithFilter(srcPath, destPath, { base, shouldExcludePath })
       continue
     }
 
@@ -51,6 +56,12 @@ function resetAutomationReports(templateRoot: string): void {
   mkdirSync(join(reportsRoot, 'traces'), { recursive: true })
 }
 
+function resetAutomationLocatorMap(templateRoot: string): void {
+  const locatorMapPath = join(templateRoot, 'automation', 'mapping', 'locator-map.json')
+  mkdirSync(dirname(locatorMapPath), { recursive: true })
+  writeFileSync(locatorMapPath, '[]\n')
+}
+
 function syncLegacyEnvironmentConfig(): void {
   const legacyEnvironmentsDir = join(repoRoot, 'src', 'tests', 'config', 'environments')
   const targetEnvironmentsDir = join(target, 'automation', 'config', 'environments')
@@ -65,22 +76,46 @@ function syncLegacyEnvironmentConfig(): void {
   console.log('Backfilled automation/config/environments from legacy src/tests config.')
 }
 
-function syncCucumberRuntimePackage(): void {
-  const runtimeTarget = join(target, 'packages', 'cucumber-runtime')
-  rmSync(runtimeTarget, { recursive: true, force: true })
-  mkdirSync(runtimeTarget, { recursive: true })
+type InternalPackageSyncConfig = {
+  name: string
+  directories: string[]
+}
+
+const INTERNAL_PACKAGES: InternalPackageSyncConfig[] = [
+  { name: 'cucumber-runtime', directories: ['src'] },
+  { name: 'locator-picker-companion', directories: ['src', 'dist'] },
+]
+
+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'))
 
-  copyFile(join(repoRoot, 'packages', 'cucumber-runtime', 'package.json'), join(runtimeTarget, 'package.json'))
-  copyFile(join(repoRoot, 'packages', 'cucumber-runtime', 'tsconfig.json'), join(runtimeTarget, 'tsconfig.json'))
-  copyDirWithFilter(join(repoRoot, 'packages', 'cucumber-runtime', 'src'), join(runtimeTarget, 'src'))
+  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,
+    })
+  }
 }
 
 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
+const savedAppraisejsConfig = existsSync(appraisejsConfigPath) ? readFileSync(appraisejsConfigPath, 'utf8') : null
 
 rmSync(target, { recursive: true, force: true })
 mkdirSync(target, { recursive: true })
@@ -92,9 +127,12 @@ console.log('Copying automation/...')
 copyDirWithFilter(join(repoRoot, 'automation'), join(target, 'automation'))
 syncLegacyEnvironmentConfig()
 resetAutomationReports(target)
+resetAutomationLocatorMap(target)
 
-console.log('Copying cucumber runtime package...')
-syncCucumberRuntimePackage()
+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'))
@@ -149,13 +187,13 @@ const rootPkg = JSON.parse(readFileSync(join(repoRoot, 'package.json'), 'utf8'))
 rootPkg.scripts = {
   ...rootPkg.scripts,
   build: 'npm run build:local',
-  'build:local': 'npm run generate-db-client && npm run build:cucumber-runtime && next build',
+  '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: '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',

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

@@ -69,15 +69,25 @@ async function readEnvironmentsFromFile(): Promise<Record<string, EnvironmentCon
   }
 }
 
-/**
- * Normalizes environment name to title case for consistent comparison
- * e.g., "staging" -> "Staging", "STAGING" -> "Staging", "Staging" -> "Staging"
- */
 function normalizeEnvironmentName(name: string): string {
   if (!name || name.trim() === '') {
     return name
   }
-  return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase()
+
+  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()
 }
 
 /**
@@ -135,19 +145,20 @@ async function syncEnvironmentsToDatabase(environments: EnvironmentData[]): Prom
   }
 
   // Get set of normalized environment names from JSON file (for case-insensitive comparison)
-  const jsonEnvironmentNamesNormalized = new Set(
-    environments.map(env => normalizeEnvironmentName(env.name))
-  )
+  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 },
+    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 }>()
+  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 = normalizeEnvironmentName(dbEnv.name)
+    const normalizedName = getEnvironmentIdentityKey(dbEnv.name)
     // If we find a duplicate normalized name, keep the first one
     if (!dbEnvironmentsByNormalizedName.has(normalizedName)) {
       dbEnvironmentsByNormalizedName.set(normalizedName, dbEnv)
@@ -156,7 +167,7 @@ async function syncEnvironmentsToDatabase(environments: EnvironmentData[]): Prom
 
   // Delete environments from DB that are not in JSON file (case-insensitive comparison)
   for (const dbEnv of allDbEnvironments) {
-    const normalizedDbName = normalizeEnvironmentName(dbEnv.name)
+    const normalizedDbName = getEnvironmentIdentityKey(dbEnv.name)
     if (!jsonEnvironmentNamesNormalized.has(normalizedDbName)) {
       try {
         // Check if environment has test runs (foreign key constraint prevents deletion)
@@ -187,23 +198,32 @@ async function syncEnvironmentsToDatabase(environments: EnvironmentData[]): Prom
   // Create or update environments from JSON file
   for (const env of environments) {
     try {
-      const normalizedName = normalizeEnvironmentName(env.name)
+      const normalizedName = getEnvironmentIdentityKey(env.name)
       // Check if environment already exists by normalized name (case-insensitive)
       const existingDbEnv = dbEnvironmentsByNormalizedName.get(normalizedName)
 
       if (existingDbEnv) {
-        // Environment exists, check if name needs to be updated to normalized form
-        if (existingDbEnv.name !== env.name) {
-          // Update the name to normalized form
+        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: { name: env.name },
+            data: {
+              baseUrl: env.baseUrl,
+              apiBaseUrl: env.apiBaseUrl,
+              username: env.username,
+              password: env.password,
+            },
           })
-          console.log(`   🔄 Updated environment name from '${existingDbEnv.name}' to '${env.name}'`)
+          console.log(`   🔄 Updated environment '${existingDbEnv.name}'`)
         }
         result.environmentsExisting++
-        result.existingEnvironments.push(env.name)
-        console.log(`   ✓ Environment '${env.name}' already exists`)
+        result.existingEnvironments.push(existingDbEnv.name)
+        console.log(`   ✓ Environment '${existingDbEnv.name}' already exists`)
       } else {
         // Create the environment
         await prisma.environment.create({
@@ -323,4 +343,3 @@ main()
 
 
 
-