create-appraisejs 0.3.0 → 0.3.1-alpha.1

package/templates/blank/src/lib/sync/sync-pending-counts.ts

@@ -6,26 +6,36 @@ import { parse } from '@babel/parser'
 import * as t from '@babel/types'
 import _traverse from '@babel/traverse'
 import type { NodePath } from '@babel/traverse'
-import {
-  StepParameterType,
-  TagType,
-  TemplateStepGroupType,
-  TemplateStepIcon,
-  TemplateStepType,
-} from '@prisma/client'
+import { StepParameterType, TagType, TemplateStepGroupType, TemplateStepIcon, TemplateStepType } from '@prisma/client'
 import prisma from '@/config/db-config'
 import { getAutomationEnvironmentsDir, getAutomationFeaturesDir } from '@/lib/automation/automation-path-roots'
 import { ensureAutomationWorkspaceReady } from '@/lib/automation/automation-workspace'
-import { extractModulePathFromFilePath, scanFeatureFiles, type ParsedFeature, type ParsedStep } from '@/lib/gherkin-parser'
+import {
+  extractModulePathFromFilePath,
+  scanFeatureFiles,
+  type ParsedFeature,
+  type ParsedStep,
+} from '@/lib/gherkin-parser'
 import { getAllModulesWithPaths } from '@/lib/module-hierarchy-builder'
-import { SYNC_ALL_REQUEST_ID, syncScriptDefinitions, type SyncRequestId, type SyncScriptId } from '@/lib/sync/sync-registry'
-import { getTagTypeFromName } from '@/lib/tag-utils'
+import {
+  SYNC_ALL_REQUEST_ID,
+  syncScriptDefinitions,
+  type SyncRequestId,
+  type SyncScriptId,
+} from '@/lib/sync/sync-registry'
+import { getTagTypeFromName } from '@/lib/tag-identifiers'
 import { extractModulePathFromAutomationFile, getAutomationLocatorMapPath } from '@/lib/template-sync-utils'
 import {
   determineProjectedStepIcon,
   getTestSuiteSyncIdentity,
   normalizeProjectedDbTestCaseSteps,
 } from '@/lib/sync/projected-feature-utils'
+import {
+  parseGroupJSDocLenient as parseGroupJSDoc,
+  parseStepJSDocLenient as parseStepJSDoc,
+  type StepGroupJSDoc,
+  type StepJSDoc,
+} from '@/lib/jsdoc/template-step-jsdoc'
 
 const traverse = (_traverse as { default?: typeof _traverse }).default ?? _traverse
 
@@ -63,18 +73,6 @@ type LocatorFileData = {
   locators: Record<string, string>
 }
 
-type StepGroupJSDoc = {
-  name: string
-  description: string | null
-  type: TemplateStepGroupType
-}
-
-type StepJSDoc = {
-  name: string
-  description: string | null
-  icon: TemplateStepIcon
-}
-
 type StepParameter = {
   name: string
   type: StepParameterType
@@ -95,6 +93,8 @@ type ParsedStepFile = {
   steps: ParsedTemplateStep[]
 }
 
+type StepKeyword = ParsedTemplateStep['keyword']
+
 type TemplateStepFromFs = {
   step: ParsedTemplateStep
   groupName: string
@@ -118,6 +118,10 @@ type TestCaseFromFs = {
   steps: ParsedStep[]
 }
 
+type CollapsedTestCaseFromFs = TestCaseFromFs & {
+  expectedSuiteIdentities: Set<string>
+}
+
 type ParameterMatch = {
   name: string
   value: string
@@ -296,201 +300,120 @@ async function readLocatorFile(filePath: string): Promise<Record<string, string>
   }
 }
 
-function parseGroupJSDoc(content: string): StepGroupJSDoc | null {
-  const lines = content.split('\n')
-  let startLine = 0
-
-  while (startLine < lines.length) {
-    const line = lines[startLine].trim()
-    if (line === '' || line.startsWith('import ')) {
-      startLine++
-      continue
-    }
-    break
-  }
+function mapTypeToParameterType(typeName: string): StepParameterType {
+  const normalized = typeName.trim()
 
-  if (startLine >= lines.length || !lines[startLine].trim().startsWith('/**')) {
-    return null
-  }
+  if (normalized === 'SelectorName') return StepParameterType.LOCATOR
+  if (normalized === 'string') return StepParameterType.STRING
+  if (normalized === 'number' || normalized === 'int') return StepParameterType.NUMBER
+  if (normalized === 'boolean') return StepParameterType.BOOLEAN
+  if (normalized === 'Date') return StepParameterType.DATE
 
-  let hasType = false
-  let endLine = -1
-  let name: string | null = null
-  let description: string | null = null
-  let type: string | null = null
-
-  const maxLines = Math.min(lines.length, startLine + 50)
-  for (let i = startLine; i < maxLines; i++) {
-    const line = lines[i].trim()
-
-    if (line.includes('*/')) {
-      const beforeClose = line.split('*/')[0].trim()
-
-      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')) {
-        const match = beforeClose.match(/@type\s+(.+)/)
-        if (match) {
-          hasType = true
-          type = match[1].trim()
-        }
-      }
+  throw new Error(`Unsupported parameter type: ${typeName}`)
+}
 
-      endLine = i
-      break
-    }
+function extractFunctionDefinition(callExpression: t.CallExpression, sourceCode: string): string {
+  const start = callExpression.start
+  const end = callExpression.end
 
-    if (line.startsWith('* @name') || line.startsWith('*@name')) {
-      const match = line.match(/@name\s+(.+)/)
-      if (match) name = match[1].trim()
-    } else if (line.startsWith('* @description') || line.startsWith('*@description')) {
-      const match = line.match(/@description\s+(.+)/)
-      if (match) description = match[1].trim() || null
-    } else if (line.startsWith('* @type') || line.startsWith('*@type')) {
-      const match = line.match(/@type\s+(.+)/)
-      if (match) {
-        hasType = true
-        type = match[1].trim()
-      }
-    }
+  if (start == null || end == null) {
+    throw new Error('Cannot extract function definition.')
   }
 
-  if (!hasType || endLine < 0 || !name || !type) {
-    return null
+  let code = sourceCode.slice(start, end).trim()
+  const trailingSource = sourceCode.slice(end, end + 10).trim()
+  if (trailingSource.startsWith(';')) {
+    code += ';'
   }
 
-  const normalizedType = type.toUpperCase()
-  if (normalizedType !== 'ACTION' && normalizedType !== 'VALIDATION') {
-    return null
-  }
+  return code
+}
 
-  return {
-    name: name.trim(),
-    description: description ? description.trim() : null,
-    type: normalizedType as TemplateStepGroupType,
-  }
+function getStepKeyword(node: t.CallExpression): StepKeyword | null {
+  const callee = node.callee
+  return t.isIdentifier(callee) && (callee.name === 'When' || callee.name === 'Then' || callee.name === 'Given')
+    ? callee.name
+    : null
 }
 
-function parseStepJSDoc(content: string, startLine: number): StepJSDoc | null {
-  const lines = content.split('\n')
-  let jsdocStart = -1
-
-  for (let i = startLine - 1; i >= 0 && i >= startLine - 20; i--) {
-    const line = lines[i]?.trim()
-    if (line?.includes('*/')) {
-      jsdocStart = i
-      for (let j = i - 1; j >= 0 && j >= i - 10; j--) {
-        const previousLine = lines[j]?.trim()
-        if (previousLine?.startsWith('/**')) {
-          jsdocStart = j
-          break
-        }
-      }
-      break
-    }
+function getStepSignature(node: t.CallExpression): string | null {
+  const patternArg = node.arguments[0]
+  return t.isStringLiteral(patternArg) ? patternArg.value : null
+}
 
-    if (line?.startsWith('/**')) {
-      jsdocStart = i
-      break
-    }
-  }
+function getStepFunction(node: t.CallExpression): t.Function | null {
+  const functionArg = node.arguments[1]
+  return t.isFunction(functionArg) ? functionArg : null
+}
 
-  if (jsdocStart === -1) {
+function getIdentifierParameterType(parameter: t.Identifier): string | null {
+  if (!parameter.typeAnnotation || !t.isTSTypeAnnotation(parameter.typeAnnotation)) {
     return null
   }
 
-  let name: string | null = null
-  let description: string | null = null
-  let icon: string | null = null
-  let foundJSDoc = false
+  const annotation = parameter.typeAnnotation.typeAnnotation
+  if (t.isTSTypeReference(annotation) && t.isIdentifier(annotation.typeName)) {
+    return annotation.typeName.name
+  }
 
-  for (let i = jsdocStart; i < Math.min(lines.length, jsdocStart + 20); i++) {
-    const line = lines[i]?.trim()
+  if (t.isTSStringKeyword(annotation)) return 'string'
+  if (t.isTSNumberKeyword(annotation)) return 'number'
+  if (t.isTSBooleanKeyword(annotation)) return 'boolean'
+  return null
+}
 
-    if (line?.startsWith('/**')) {
-      foundJSDoc = true
+function parseStepParameters(parameters: t.Function['params']): StepParameter[] | null {
+  const parsedParameters: StepParameter[] = []
+
+  for (const parameter of parameters) {
+    if ((t.isIdentifier(parameter) && parameter.name === 'this') || t.isObjectPattern(parameter)) {
       continue
     }
 
-    if (line?.includes('*/')) {
-      const beforeClose = line.split('*/')[0].trim()
-      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('* @icon') || beforeClose.startsWith('*@icon')) {
-        const match = beforeClose.match(/@icon\s+(.+)/)
-        if (match) icon = match[1].trim()
-      }
-      break
+    if (!t.isIdentifier(parameter)) {
+      continue
     }
 
-    if (!foundJSDoc) {
+    const typeName = getIdentifierParameterType(parameter)
+    if (!typeName) {
       continue
     }
 
-    if (line?.startsWith('* @name') || line?.startsWith('*@name')) {
-      const match = line.match(/@name\s+(.+)/)
-      if (match) name = match[1].trim()
-    } else if (line?.startsWith('* @description') || line?.startsWith('*@description')) {
-      const match = line.match(/@description\s+(.+)/)
-      if (match) description = match[1].trim() || null
-    } else if (line?.startsWith('* @icon') || line?.startsWith('*@icon')) {
-      const match = line.match(/@icon\s+(.+)/)
-      if (match) icon = match[1].trim()
+    try {
+      parsedParameters.push({
+        name: parameter.name,
+        type: mapTypeToParameterType(typeName),
+        order: parsedParameters.length,
+      })
+    } catch {
+      return null
     }
   }
 
-  if (!name || !icon) {
-    return null
-  }
-
-  const iconUpper = icon.toUpperCase()
-  const validIcons = Object.values(TemplateStepIcon)
-  if (!validIcons.includes(iconUpper as TemplateStepIcon)) {
-    return null
-  }
-
-  return {
-    name: name.trim(),
-    description: description ? description.trim() : null,
-    icon: iconUpper as TemplateStepIcon,
-  }
+  return parsedParameters
 }
 
-function mapTypeToParameterType(typeName: string): StepParameterType {
-  const normalized = typeName.trim()
-
-  if (normalized === 'SelectorName') return StepParameterType.LOCATOR
-  if (normalized === 'string') return StepParameterType.STRING
-  if (normalized === 'number' || normalized === 'int') return StepParameterType.NUMBER
-  if (normalized === 'boolean') return StepParameterType.BOOLEAN
-  if (normalized === 'Date') return StepParameterType.DATE
-
-  throw new Error(`Unsupported parameter type: ${typeName}`)
-}
+function parseStepCall(node: t.CallExpression, content: string): ParsedTemplateStep | null {
+  const keyword = getStepKeyword(node)
+  if (!keyword || node.arguments.length < 2) return null
 
-function extractFunctionDefinition(callExpression: t.CallExpression, sourceCode: string): string {
-  const start = callExpression.start
-  const end = callExpression.end
+  const signature = getStepSignature(node)
+  const functionArg = getStepFunction(node)
+  const lineNumber = node.loc?.start?.line
+  if (!signature || !functionArg || lineNumber == null) return null
 
-  if (start == null || end == null) {
-    throw new Error('Cannot extract function definition.')
-  }
+  const jsdoc = parseStepJSDoc(content, lineNumber - 1)
+  const parameters = parseStepParameters(functionArg.params)
+  if (!jsdoc || !parameters) return null
 
-  let code = sourceCode.slice(start, end).trim()
-  const trailingSource = sourceCode.slice(end, end + 10).trim()
-  if (trailingSource.startsWith(';')) {
-    code += ';'
+  return {
+    jsdoc,
+    signature,
+    functionDefinition: extractFunctionDefinition(node, content),
+    normalizedFunctionDefinition: '',
+    parameters,
+    keyword,
   }
-
-  return code
 }
 
 function parseStepFile(content: string): ParsedStepFile | null {
@@ -508,87 +431,8 @@ function parseStepFile(content: string): ParsedStepFile | null {
 
   traverse(ast, {
     CallExpression(path: NodePath<t.CallExpression>) {
-      const node = path.node
-      const callee = node.callee
-      let keyword: 'When' | 'Then' | 'Given' | null = null
-
-      if (t.isIdentifier(callee) && (callee.name === 'When' || callee.name === 'Then' || callee.name === 'Given')) {
-        keyword = callee.name as 'When' | 'Then' | 'Given'
-      }
-
-      if (!keyword || node.arguments.length < 2) {
-        return
-      }
-
-      const patternArg = node.arguments[0]
-      const functionArg = node.arguments[1]
-
-      if (!t.isStringLiteral(patternArg) || !t.isFunction(functionArg)) {
-        return
-      }
-
-      const lineNumber = node.loc?.start?.line
-      if (lineNumber == null) {
-        return
-      }
-
-      const jsdoc = parseStepJSDoc(content, lineNumber - 1)
-      if (!jsdoc) {
-        return
-      }
-
-      const parameters: StepParameter[] = []
-      let order = 0
-
-      for (const parameter of functionArg.params) {
-        if (t.isIdentifier(parameter) && parameter.name === 'this') {
-          continue
-        }
-
-        if (t.isObjectPattern(parameter)) {
-          continue
-        }
-
-        if (!t.isIdentifier(parameter) || !parameter.typeAnnotation || !t.isTSTypeAnnotation(parameter.typeAnnotation)) {
-          continue
-        }
-
-        const annotation = parameter.typeAnnotation.typeAnnotation
-        let typeName: string | null = null
-
-        if (t.isTSTypeReference(annotation) && t.isIdentifier(annotation.typeName)) {
-          typeName = annotation.typeName.name
-        } else if (t.isTSStringKeyword(annotation)) {
-          typeName = 'string'
-        } else if (t.isTSNumberKeyword(annotation)) {
-          typeName = 'number'
-        } else if (t.isTSBooleanKeyword(annotation)) {
-          typeName = 'boolean'
-        }
-
-        if (!typeName) {
-          continue
-        }
-
-        try {
-          parameters.push({
-            name: parameter.name,
-            type: mapTypeToParameterType(typeName),
-            order: order++,
-          })
-        } catch {
-          return
-        }
-      }
-
-      steps.push({
-        jsdoc,
-        signature: patternArg.value,
-        functionDefinition: extractFunctionDefinition(node, content),
-        normalizedFunctionDefinition: '',
-        parameters,
-        keyword,
-      })
+      const step = parseStepCall(path.node, content)
+      if (step) steps.push(step)
     },
   })
 
@@ -610,7 +454,10 @@ function extractFeatureLevelTags(parsedFeature: ParsedFeature): string[] {
   return parsedFeature.tags.flatMap(splitTagLine)
 }
 
-function parseScenarioTitle(scenarioName: string, scenarioDescription?: string): { title: string; description: string } {
+function parseScenarioTitle(
+  scenarioName: string,
+  scenarioDescription?: string,
+): { title: string; description: string } {
   if (scenarioDescription) {
     return {
       title: scenarioDescription.trim(),
@@ -673,7 +520,11 @@ function matchGherkinStepToTemplateStep(
   }>,
 ): { signature: string; parameters: ParameterMatch[] } | null {
   for (const templateStep of templateSteps) {
-    const parameters = extractParametersFromGherkinStep(gherkinStep.text, templateStep.signature, templateStep.parameters)
+    const parameters = extractParametersFromGherkinStep(
+      gherkinStep.text,
+      templateStep.signature,
+      templateStep.parameters,
+    )
     if (parameters) {
       return {
         signature: templateStep.signature,
@@ -723,11 +574,7 @@ function sameStepParameters(
 
   return left.every((parameter, index) => {
     const other = right[index]
-    return (
-      parameter.name === other?.name &&
-      parameter.order === other?.order &&
-      parameter.type === other?.type
-    )
+    return parameter.name === other?.name && parameter.order === other?.order && parameter.type === other?.type
   })
 }
 
@@ -896,14 +743,21 @@ export function countModuleMismatches(
   return count
 }
 
-function countEnvironmentMismatches(
+export function countEnvironmentMismatches(
   filesystemEnvironments: EnvironmentData[],
-  dbEnvironments: Array<{ name: string }>,
+  dbEnvironments: Array<{
+    name: string
+    baseUrl: string
+    apiBaseUrl: string | null
+    username: string | null
+    password: string | null
+    _count?: { testRuns: number }
+  }>,
 ): number {
   const fsByNormalizedName = new Map(
     filesystemEnvironments.map(environment => [getEnvironmentIdentityKey(environment.name), environment]),
   )
-  const dbByNormalizedName = new Map<string, { name: string }>()
+  const dbByNormalizedName = new Map<string, (typeof dbEnvironments)[number]>()
 
   for (const environment of dbEnvironments) {
     const normalizedName = getEnvironmentIdentityKey(environment.name)
@@ -917,11 +771,22 @@ function countEnvironmentMismatches(
     const existing = dbByNormalizedName.get(getEnvironmentIdentityKey(environment.name))
     if (!existing) {
       count++
+      continue
+    }
+
+    if (
+      existing.baseUrl !== environment.baseUrl ||
+      (existing.apiBaseUrl ?? null) !== environment.apiBaseUrl ||
+      (existing.username ?? null) !== environment.username ||
+      (existing.password ?? null) !== environment.password
+    ) {
+      count++
     }
   }
 
   for (const environment of dbEnvironments) {
-    if (!fsByNormalizedName.has(getEnvironmentIdentityKey(environment.name))) {
+    const canDelete = (environment._count?.testRuns ?? 0) === 0
+    if (canDelete && !fsByNormalizedName.has(getEnvironmentIdentityKey(environment.name))) {
       count++
     }
   }
@@ -979,10 +844,15 @@ export function countTemplateStepMismatches(
     parameters: Array<{ name: string; order: number; type: StepParameterType }>
   }>,
 ): number {
+  const filesystemStepsBySignature = new Map<string, TemplateStepFromFs>()
   const dbBySignature = groupRecordsByKey(dbSteps, step => step.signature)
   let count = 0
 
   for (const item of filesystemSteps) {
+    filesystemStepsBySignature.set(item.step.signature, item)
+  }
+
+  for (const item of filesystemStepsBySignature.values()) {
     const expectedType =
       item.groupType === TemplateStepGroupType.ACTION ? TemplateStepType.ACTION : TemplateStepType.ASSERTION
 
@@ -1006,16 +876,20 @@ export function countTemplateStepMismatches(
   return count
 }
 
-function countLocatorGroupMismatches(
+export function countLocatorGroupMismatches(
   filesystemGroups: LocatorGroupFromFs[],
   dbGroups: Array<{ name: string; route: string; moduleId: string }>,
   modulePathMap: Map<string, string>,
 ): number {
-  const fsByName = new Map(filesystemGroups.map(group => [group.name, group]))
+  const fsByName = new Map<string, LocatorGroupFromFs>()
   const dbByName = new Map(dbGroups.map(group => [group.name, group]))
   let count = 0
 
   for (const group of filesystemGroups) {
+    fsByName.set(group.name, group)
+  }
+
+  for (const group of fsByName.values()) {
     const existing = dbByName.get(group.name)
     if (!existing) {
       count++
@@ -1089,10 +963,15 @@ export function countTestSuiteMismatches(
   const dbByKey = groupRecordsByKey(dbSuites, suite =>
     getTestSuiteSyncIdentity(suite.name, modulePathMap.get(suite.moduleId) ?? '/'),
   )
+  const filesystemSuitesByKey = new Map<string, TestSuiteFromFs>()
   let count = 0
 
   for (const suite of filesystemSuites) {
     const suiteKey = getTestSuiteSyncIdentity(suite.name, suite.modulePath)
+    filesystemSuitesByKey.set(suiteKey, suite)
+  }
+
+  for (const [suiteKey, suite] of filesystemSuitesByKey) {
     const fsTagExpressions = suite.tags.map(normalizeTagExpression)
     const hasMatch = (dbByKey.get(suiteKey) ?? []).some(existing => {
       const dbTagExpressions = existing.tags.map(tag => normalizeTagExpression(tag.tagExpression))
@@ -1174,9 +1053,29 @@ export function countTestCaseMismatches(
     parameters: Array<{ name: string; order: number; type: StepParameterType }>
   }>,
 ): number {
+  const filesystemTestCasesByIdentifier = new Map<string, CollapsedTestCaseFromFs>()
   const dbByIdentifier = new Map<string, Array<(typeof dbTestCases)[number]>>()
   let count = 0
 
+  for (const testCase of filesystemTestCases) {
+    const expectedSuiteIdentity = getTestSuiteSyncIdentity(testCase.testSuiteName, testCase.modulePath)
+    const existing = filesystemTestCasesByIdentifier.get(testCase.identifierTag)
+
+    if (existing) {
+      existing.expectedSuiteIdentities.add(expectedSuiteIdentity)
+      filesystemTestCasesByIdentifier.set(testCase.identifierTag, {
+        ...testCase,
+        expectedSuiteIdentities: existing.expectedSuiteIdentities,
+      })
+      continue
+    }
+
+    filesystemTestCasesByIdentifier.set(testCase.identifierTag, {
+      ...testCase,
+      expectedSuiteIdentities: new Set([expectedSuiteIdentity]),
+    })
+  }
+
   for (const testCase of dbTestCases) {
     const identifierTag = testCase.tags.find(tag => tag.type === TagType.IDENTIFIER)
     if (!identifierTag) {
@@ -1193,21 +1092,23 @@ export function countTestCaseMismatches(
     dbByIdentifier.set(normalizedIdentifier, [testCase])
   }
 
-  for (const testCase of filesystemTestCases) {
-    const expectedSuiteIdentity = getTestSuiteSyncIdentity(testCase.testSuiteName, testCase.modulePath)
+  for (const testCase of filesystemTestCasesByIdentifier.values()) {
     const normalizedFilterTags = testCase.filterTags.map(normalizeTagExpression)
     const hasMatch = (dbByIdentifier.get(testCase.identifierTag) ?? []).some(existing => {
       const existingFilterTags = existing.tags
         .filter(tag => tag.type === TagType.FILTER)
         .map(tag => normalizeTagExpression(tag.tagExpression))
-      const isLinkedToExpectedSuite = existing.TestSuite.some(
-        suite => getTestSuiteSyncIdentity(suite.name, modulePathMap.get(suite.moduleId) ?? '/') === expectedSuiteIdentity,
+      const existingSuiteIdentities = new Set(
+        existing.TestSuite.map(suite => getTestSuiteSyncIdentity(suite.name, modulePathMap.get(suite.moduleId) ?? '/')),
+      )
+      const isLinkedToExpectedSuites = Array.from(testCase.expectedSuiteIdentities).every(identity =>
+        existingSuiteIdentities.has(identity),
       )
 
       return (
         existing.title === testCase.title &&
         existing.description === testCase.description &&
-        isLinkedToExpectedSuite &&
+        isLinkedToExpectedSuites &&
         sameStringSet(existingFilterTags, normalizedFilterTags) &&
         !hasProjectedTestCaseStepMismatch(testCase.steps, existing.steps, dbTemplateSteps)
       )
@@ -1222,7 +1123,10 @@ export function countTestCaseMismatches(
 }
 
 function emptyCounts(): SyncPendingCounts {
-  const counts = Object.fromEntries(syncScriptDefinitions.map(definition => [definition.id, 0])) as Record<SyncScriptId, number>
+  const counts = Object.fromEntries(syncScriptDefinitions.map(definition => [definition.id, 0])) as Record<
+    SyncScriptId,
+    number
+  >
   return {
     ...counts,
     [SYNC_ALL_REQUEST_ID]: 0,
@@ -1246,7 +1150,18 @@ export async function getSyncPendingCounts(): Promise<SyncPendingCounts> {
       dbTestCases,
     ] = await Promise.all([
       getAllModulesWithPaths(),
-      prisma.environment.findMany({ select: { name: true } }),
+      prisma.environment.findMany({
+        select: {
+          name: true,
+          baseUrl: true,
+          apiBaseUrl: true,
+          username: true,
+          password: true,
+          _count: {
+            select: { testRuns: true },
+          },
+        },
+      }),
       prisma.tag.findMany({ select: { name: true, type: true } }),
       prisma.templateStepGroup.findMany({ select: { name: true, description: true, type: true } }),
       prisma.templateStep.findMany({
@@ -1323,13 +1238,18 @@ export async function getSyncPendingCounts(): Promise<SyncPendingCounts> {
       })),
     )
 
-    const modulePathMap = new Map(dbModules.map(module => [module.id, module.name === 'root' && module.parentId === null ? '/' : module.path]))
+    const modulePathMap = new Map(
+      dbModules.map(module => [module.id, module.name === 'root' && module.parentId === null ? '/' : module.path]),
+    )
 
     const counts: Record<SyncScriptId, number> = {
       'sync-modules': countModuleMismatches(filesystem.modulePaths, dbModules),
       'sync-environments': countEnvironmentMismatches(filesystem.environments, dbEnvironments),
       'sync-tags': countTagMismatches(filesystem.tagObjects, dbTags),
-      'sync-template-step-groups': countTemplateStepGroupMismatches(filesystem.templateStepGroups, dbTemplateStepGroups),
+      'sync-template-step-groups': countTemplateStepGroupMismatches(
+        filesystem.templateStepGroups,
+        dbTemplateStepGroups,
+      ),
       'sync-template-steps': countTemplateStepMismatches(filesystem.templateSteps, normalizedDbTemplateSteps),
       'sync-locator-groups': countLocatorGroupMismatches(filesystem.locatorGroups, dbLocatorGroups, modulePathMap),
       'sync-locators': countLocatorMismatches(filesystem.locatorFiles, dbLocatorGroups),