create-appraisejs 0.3.0 → 0.3.1-alpha.0

package/templates/starter/scripts/sync-test-suites.ts

@@ -18,6 +18,7 @@ import { extractTestSuiteNameFromFilename } from './lib/filename-utils'
 import { splitTagLine } from './lib/tag-parsing'
 import { printSyncSummary } from './lib/sync-summary'
 import { runSyncScript } from './lib/sync-script-runner'
+import type { Prisma } from '@prisma/client'
 
 interface TestSuiteFromFS {
   name: string // From filename (without .feature extension)
@@ -39,6 +40,9 @@ interface SyncResult {
   deletedTestSuites: Array<{ name: string; modulePath: string }>
 }
 
+type ExistingTestSuite = Prisma.TestSuiteGetPayload<{ include: { tags: true } }>
+type DbTestSuiteWithModule = Prisma.TestSuiteGetPayload<{ include: { module: true } }>
+
 /**
  * Extracts feature-level tags from parsed feature
  * Handles tags on the same line separated by spaces
@@ -113,6 +117,232 @@ async function findTagIdsByExpressions(tagExpressions: string[]): Promise<string
   return tagIds
 }
 
+async function resolveModuleId(modulePath: string) {
+  let moduleId = await findModuleByPath(modulePath)
+
+  if (!moduleId) {
+    console.log(`   📦 Creating module hierarchy for path: ${modulePath}`)
+    moduleId = await buildModuleHierarchy(modulePath)
+  }
+
+  return moduleId
+}
+
+async function findExistingTestSuite(testSuite: TestSuiteFromFS, moduleId: string): Promise<ExistingTestSuite | undefined> {
+  const existingTestSuites = await prisma.testSuite.findMany({
+    where: {
+      moduleId,
+    },
+    include: {
+      tags: true,
+    },
+  })
+
+  return existingTestSuites.find(
+    candidate => getTestSuiteFilesystemKey(candidate.name) === getTestSuiteFilesystemKey(testSuite.name),
+  )
+}
+
+function getSortedTagIds(existingTestSuite: ExistingTestSuite, tagIds: string[]) {
+  return {
+    currentTagIds: existingTestSuite.tags.map(t => t.id).sort(),
+    newTagIds: [...tagIds].sort(),
+  }
+}
+
+function testSuiteNeedsUpdate(existingTestSuite: ExistingTestSuite, testSuite: TestSuiteFromFS, moduleId: string, tagIds: string[]) {
+  const { currentTagIds, newTagIds } = getSortedTagIds(existingTestSuite, tagIds)
+
+  return (
+    existingTestSuite.description !== (testSuite.description || null) ||
+    existingTestSuite.moduleId !== moduleId ||
+    JSON.stringify(currentTagIds) !== JSON.stringify(newTagIds)
+  )
+}
+
+async function getExistingTestCaseRefs(existingTestSuiteId: string) {
+  return prisma.testCase.findMany({
+    where: {
+      TestSuite: {
+        some: {
+          id: existingTestSuiteId,
+        },
+      },
+    },
+    select: { id: true },
+  })
+}
+
+function logPreservedTestCases(testCaseCount: number, testSuite: TestSuiteFromFS) {
+  if (testCaseCount === 0) {
+    return
+  }
+
+  console.log(
+    `   ℹ️  Preserving ${testCaseCount} existing test case(s) for '${testSuite.name}' (${testSuite.modulePath})`,
+  )
+}
+
+async function updateExistingTestSuite(
+  existingTestSuite: ExistingTestSuite,
+  testSuite: TestSuiteFromFS,
+  moduleId: string,
+  tagIds: string[],
+  result: SyncResult,
+) {
+  const existingTestCases = await getExistingTestCaseRefs(existingTestSuite.id)
+  logPreservedTestCases(existingTestCases.length, testSuite)
+
+  await prisma.testSuite.update({
+    where: { id: existingTestSuite.id },
+    data: {
+      description: testSuite.description || null,
+      moduleId,
+      tags: {
+        set: tagIds.map(id => ({ id })),
+      },
+      testCases:
+        existingTestCases.length > 0
+          ? {
+              set: existingTestCases.map(tc => ({ id: tc.id })),
+            }
+          : undefined,
+    },
+  })
+
+  result.testSuitesUpdated++
+  result.updatedTestSuites.push({
+    name: testSuite.name,
+    modulePath: testSuite.modulePath,
+  })
+  console.log(`   🔄 Updated test suite '${testSuite.name}' (${testSuite.modulePath})`)
+}
+
+async function createTestSuite(testSuite: TestSuiteFromFS, moduleId: string, tagIds: string[], result: SyncResult) {
+  await prisma.testSuite.create({
+    data: {
+      name: testSuite.name,
+      description: testSuite.description || null,
+      moduleId,
+      tags: tagIds.length > 0 ? { connect: tagIds.map(id => ({ id })) } : undefined,
+    },
+  })
+
+  result.testSuitesCreated++
+  result.createdTestSuites.push({
+    name: testSuite.name,
+    modulePath: testSuite.modulePath,
+  })
+  console.log(`   ➕ Created test suite '${testSuite.name}' (${testSuite.modulePath})`)
+}
+
+async function syncFilesystemTestSuite(testSuite: TestSuiteFromFS, fsTestSuiteKeys: Set<string>, result: SyncResult) {
+  const key = getTestSuiteSyncIdentity(testSuite.name, testSuite.modulePath)
+  fsTestSuiteKeys.add(key)
+
+  const moduleId = await resolveModuleId(testSuite.modulePath)
+  const existingTestSuite = await findExistingTestSuite(testSuite, moduleId)
+  const tagIds = await findTagIdsByExpressions(testSuite.tags)
+
+  if (!existingTestSuite) {
+    await createTestSuite(testSuite, moduleId, tagIds, result)
+    return
+  }
+
+  if (testSuiteNeedsUpdate(existingTestSuite, testSuite, moduleId, tagIds)) {
+    await updateExistingTestSuite(existingTestSuite, testSuite, moduleId, tagIds, result)
+    return
+  }
+
+  result.testSuitesExisting++
+  console.log(`   ✓ Test suite '${testSuite.name}' (${testSuite.modulePath}) already up to date`)
+}
+
+function createModulePathMap(modulesWithPaths: Awaited<ReturnType<typeof getAllModulesWithPaths>>) {
+  const modulePathMap = new Map<string, string>()
+
+  for (const mod of modulesWithPaths) {
+    modulePathMap.set(mod.id, mod.path)
+  }
+
+  return modulePathMap
+}
+
+async function logOrphanedTestCases(dbTestSuite: DbTestSuiteWithModule, modulePath: string) {
+  const testSuiteWithCases = await prisma.testSuite.findUnique({
+    where: { id: dbTestSuite.id },
+    include: {
+      testCases: { select: { id: true } },
+    },
+  })
+
+  if (testSuiteWithCases && testSuiteWithCases.testCases.length > 0) {
+    console.log(
+      `   ⚠️  Test suite '${dbTestSuite.name}' (${modulePath}) has ${testSuiteWithCases.testCases.length} test case(s) - will be cascade deleted`,
+    )
+  }
+}
+
+async function deleteOrphanedTestSuite(dbTestSuite: DbTestSuiteWithModule, modulePath: string, result: SyncResult) {
+  await logOrphanedTestCases(dbTestSuite, modulePath)
+
+  await prisma.testSuite.delete({
+    where: { id: dbTestSuite.id },
+  })
+
+  result.testSuitesDeleted++
+  result.deletedTestSuites.push({
+    name: dbTestSuite.name,
+    modulePath,
+  })
+  console.log(`   🗑️  Deleted test suite '${dbTestSuite.name}' (${modulePath}) (not in filesystem)`)
+}
+
+function getDbTestSuiteModulePath(dbTestSuite: DbTestSuiteWithModule, modulePathMap: Map<string, string>) {
+  return modulePathMap.get(dbTestSuite.moduleId) || '/'
+}
+
+function isOrphanedTestSuite(dbTestSuite: DbTestSuiteWithModule, modulePath: string, fsTestSuiteKeys: Set<string>) {
+  return !fsTestSuiteKeys.has(getTestSuiteSyncIdentity(dbTestSuite.name, modulePath))
+}
+
+function recordOrphanDeleteError(dbTestSuite: DbTestSuiteWithModule, error: unknown, result: SyncResult) {
+  const errorMsg = `Error deleting test suite '${dbTestSuite.name}': ${error}`
+  result.errors.push(errorMsg)
+  console.error(`   ❌ ${errorMsg}`)
+}
+
+async function deleteOrphanedTestSuiteIfNeeded(
+  dbTestSuite: DbTestSuiteWithModule,
+  modulePathMap: Map<string, string>,
+  fsTestSuiteKeys: Set<string>,
+  result: SyncResult,
+) {
+  try {
+    const modulePath = getDbTestSuiteModulePath(dbTestSuite, modulePathMap)
+
+    if (isOrphanedTestSuite(dbTestSuite, modulePath, fsTestSuiteKeys)) {
+      await deleteOrphanedTestSuite(dbTestSuite, modulePath, result)
+    }
+  } catch (error) {
+    recordOrphanDeleteError(dbTestSuite, error, result)
+  }
+}
+
+async function deleteOrphanedTestSuites(fsTestSuiteKeys: Set<string>, result: SyncResult) {
+  console.log('\n🔍 Checking for orphaned test suites (not in filesystem)...')
+  const allDbTestSuites = await prisma.testSuite.findMany({
+    include: {
+      module: true,
+    },
+  })
+  const modulePathMap = createModulePathMap(await getAllModulesWithPaths())
+
+  for (const dbTestSuite of allDbTestSuites) {
+    await deleteOrphanedTestSuiteIfNeeded(dbTestSuite, modulePathMap, fsTestSuiteKeys, result)
+  }
+}
+
 /**
  * Syncs test suites from filesystem to database
  */
@@ -127,172 +357,15 @@ async function syncTestSuitesToDatabase(
   
   for (const testSuite of testSuitesFromFS) {
     try {
-      const key = getTestSuiteSyncIdentity(testSuite.name, testSuite.modulePath)
-      fsTestSuiteKeys.add(key)
-      
-      // Ensure module exists
-      let moduleId = await findModuleByPath(testSuite.modulePath)
-      
-      if (!moduleId) {
-        console.log(`   📦 Creating module hierarchy for path: ${testSuite.modulePath}`)
-        moduleId = await buildModuleHierarchy(testSuite.modulePath)
-      }
-      
-      // Find existing test suite by name and moduleId
-      const existingTestSuites = await prisma.testSuite.findMany({
-        where: {
-          moduleId: moduleId,
-        },
-        include: {
-          tags: true,
-        },
-      })
-      const existingTestSuite = existingTestSuites.find(
-        candidate => getTestSuiteFilesystemKey(candidate.name) === getTestSuiteFilesystemKey(testSuite.name),
-      )
-      
-      // Find tag IDs
-      const tagIds = await findTagIdsByExpressions(testSuite.tags)
-      
-      if (existingTestSuite) {
-        // Check if update is needed
-        const currentTagIds = existingTestSuite.tags.map(t => t.id).sort()
-        const newTagIds = tagIds.sort()
-        const tagsChanged = JSON.stringify(currentTagIds) !== JSON.stringify(newTagIds)
-        
-        const needsUpdate =
-          existingTestSuite.description !== (testSuite.description || null) ||
-          existingTestSuite.moduleId !== moduleId ||
-          tagsChanged
-        
-        if (needsUpdate) {
-          // Get existing test cases to explicitly preserve them
-          const existingTestCases = await prisma.testCase.findMany({
-            where: {
-              TestSuite: {
-                some: {
-                  id: existingTestSuite.id,
-                },
-              },
-            },
-            select: { id: true },
-          })
-          
-          const testCaseCount = existingTestCases.length
-          if (testCaseCount > 0) {
-            console.log(
-              `   ℹ️  Preserving ${testCaseCount} existing test case(s) for '${testSuite.name}' (${testSuite.modulePath})`,
-            )
-          }
-          
-          // Update test suite - explicitly preserve test cases by reconnecting them
-          // Only update description, moduleId, and tags
-          await prisma.testSuite.update({
-            where: { id: existingTestSuite.id },
-            data: {
-              description: testSuite.description || null,
-              moduleId: moduleId,
-              tags: {
-                set: tagIds.map(id => ({ id })),
-              },
-              // Explicitly preserve test cases by reconnecting them
-              // This ensures they are not removed during the update
-              testCases: existingTestCases.length > 0
-                ? {
-                    set: existingTestCases.map(tc => ({ id: tc.id })),
-                  }
-                : undefined,
-            },
-          })
-          
-          result.testSuitesUpdated++
-          result.updatedTestSuites.push({
-            name: testSuite.name,
-            modulePath: testSuite.modulePath,
-          })
-          console.log(`   🔄 Updated test suite '${testSuite.name}' (${testSuite.modulePath})`)
-        } else {
-          result.testSuitesExisting++
-          console.log(`   ✓ Test suite '${testSuite.name}' (${testSuite.modulePath}) already up to date`)
-        }
-      } else {
-        // Create new test suite
-        await prisma.testSuite.create({
-          data: {
-            name: testSuite.name,
-            description: testSuite.description || null,
-            moduleId: moduleId,
-            tags: tagIds.length > 0 ? { connect: tagIds.map(id => ({ id })) } : undefined,
-          },
-        })
-        
-        result.testSuitesCreated++
-        result.createdTestSuites.push({
-          name: testSuite.name,
-          modulePath: testSuite.modulePath,
-        })
-        console.log(`   ➕ Created test suite '${testSuite.name}' (${testSuite.modulePath})`)
-      }
+      await syncFilesystemTestSuite(testSuite, fsTestSuiteKeys, result)
     } catch (error) {
       const errorMsg = `Error processing test suite '${testSuite.name}' from ${testSuite.filePath}: ${error}`
       result.errors.push(errorMsg)
       console.error(`   ❌ ${errorMsg}`)
     }
   }
-  
-  // Delete orphaned test suites (test suites in DB but not in FS)
-  console.log('\n🔍 Checking for orphaned test suites (not in filesystem)...')
-  const allDbTestSuites = await prisma.testSuite.findMany({
-    include: {
-      module: true,
-    },
-  })
-  
-  // Get all modules with their paths
-  const modulesWithPaths = await getAllModulesWithPaths()
-  const modulePathMap = new Map<string, string>()
-  for (const mod of modulesWithPaths) {
-    modulePathMap.set(mod.id, mod.path)
-  }
-  
-  for (const dbTestSuite of allDbTestSuites) {
-    try {
-      const modulePath = modulePathMap.get(dbTestSuite.moduleId) || '/'
-      const key = getTestSuiteSyncIdentity(dbTestSuite.name, modulePath)
-      
-      if (!fsTestSuiteKeys.has(key)) {
-        // Check if test suite has test cases (for logging)
-        const testSuiteWithCases = await prisma.testSuite.findUnique({
-          where: { id: dbTestSuite.id },
-          include: {
-            testCases: { select: { id: true } },
-          },
-        })
-        
-        if (testSuiteWithCases && testSuiteWithCases.testCases.length > 0) {
-          console.log(
-            `   ⚠️  Test suite '${dbTestSuite.name}' (${modulePath}) has ${testSuiteWithCases.testCases.length} test case(s) - will be cascade deleted`,
-          )
-        }
-        
-        // Delete the test suite (Prisma cascade will handle test cases)
-        await prisma.testSuite.delete({
-          where: { id: dbTestSuite.id },
-        })
-        
-        result.testSuitesDeleted++
-        result.deletedTestSuites.push({
-          name: dbTestSuite.name,
-          modulePath: modulePath,
-        })
-        console.log(`   🗑️  Deleted test suite '${dbTestSuite.name}' (${modulePath}) (not in filesystem)`)
-      }
-    } catch (error) {
-      const errorMsg = `Error deleting test suite '${dbTestSuite.name}': ${error}`
-      result.errors.push(errorMsg)
-      console.error(`   ❌ ${errorMsg}`)
-    }
-  }
+
+  await deleteOrphanedTestSuites(fsTestSuiteKeys, result)
 }
 
 /**
@@ -365,5 +438,3 @@ async function main(): Promise<SyncResult | void> {
 }
 
 runSyncScript(main)
-
-

package/templates/starter/src/actions/dashboard/dashboard-actions.ts

@@ -22,13 +22,6 @@ export async function getDashboardMetricsAction(): Promise<ActionResponse> {
   }
 }
 
-export type EntityMetrics = {
-  testCasesCount: number
-  testSuitesCount: number
-  templateStepsCount: number
-  runningTestRunsCount: number
-}
-
 export async function getEntityMetricsAction(): Promise<ActionResponse> {
   try {
     const metrics = await getEntityMetrics()

package/templates/starter/src/actions/locator-picker/locator-picker-actions.test.ts

@@ -31,7 +31,12 @@ describe('savePickedLocatorAction', () => {
     vi.mocked(savePickedLocatorFromRequest).mockResolvedValue({
       kind: 'success',
       locatorId: 'loc-1',
+      locatorName: 'submit',
       locatorGroupId: 'group-1',
+      locatorGroupName: 'Checkout',
+      selector: '[data-testid="submit"]',
+      route: '/checkout',
+      moduleId: 'module-1',
       message: 'Locator updated successfully.',
       wasUpdate: true,
     })
@@ -50,7 +55,12 @@ describe('savePickedLocatorAction', () => {
       success: true,
       data: {
         locatorId: 'loc-1',
+        locatorName: 'submit',
         locatorGroupId: 'group-1',
+        locatorGroupName: 'Checkout',
+        selector: '[data-testid="submit"]',
+        route: '/checkout',
+        moduleId: 'module-1',
       },
       message: 'Locator updated successfully.',
     })

package/templates/starter/src/actions/locator-picker/locator-picker-actions.ts

@@ -87,7 +87,12 @@ export async function savePickedLocatorAction(request: SavePickedLocatorRequest)
       success: true,
       data: {
         locatorId: outcome.locatorId,
+        locatorName: outcome.locatorName,
         locatorGroupId: outcome.locatorGroupId,
+        locatorGroupName: outcome.locatorGroupName,
+        selector: outcome.selector,
+        route: outcome.route,
+        moduleId: outcome.moduleId,
       },
       message: outcome.message,
     }