create-appraisejs 0.3.1-alpha.0 → 0.4.0-alpha.0

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

@@ -27,9 +27,11 @@ import { getTagTypeFromName } from '@/lib/tag-identifiers'
 import { extractModulePathFromAutomationFile, getAutomationLocatorMapPath } from '@/lib/template-sync-utils'
 import {
   determineProjectedStepIcon,
+  generateProjectedGherkinSteps,
   getTestSuiteSyncIdentity,
   normalizeProjectedDbTestCaseSteps,
 } from '@/lib/sync/projected-feature-utils'
+import type { AppraiseTestCaseMetadataFlowBlock, AppraiseTestCaseMetadataNode } from '@/lib/appraise-test-case-metadata'
 import {
   parseGroupJSDocLenient as parseGroupJSDoc,
   parseStepJSDocLenient as parseStepJSDoc,
@@ -116,6 +118,13 @@ type TestCaseFromFs = {
   modulePath: string
   filterTags: string[]
   steps: ParsedStep[]
+  hasAppraiseMetadata?: boolean
+  nodes: AppraiseTestCaseMetadataNode[]
+  flowBlocks: AppraiseTestCaseMetadataFlowBlock[]
+}
+
+type CollapsedTestCaseFromFs = TestCaseFromFs & {
+  expectedSuiteIdentities: Set<string>
 }
 
 type ParameterMatch = {
@@ -682,15 +691,18 @@ async function buildFilesystemSnapshot(baseDir: string): Promise<FilesystemSnaps
         continue
       }
 
-      const { title, description } = parseScenarioTitle(scenario.name, scenario.description)
+      const parsedTitle = parseScenarioTitle(scenario.name, scenario.description)
       testCases.push({
         identifierTag: normalizeTagExpression(identifierTag),
-        title,
-        description,
+        title: scenario.appraiseMetadata?.title ?? parsedTitle.title,
+        description: scenario.appraiseMetadata?.description ?? parsedTitle.description,
         testSuiteName,
         modulePath,
         filterTags: flattenedTags.filter(tag => normalizeTagExpression(tag) !== normalizeTagExpression(identifierTag)),
         steps: scenario.steps,
+        hasAppraiseMetadata: scenario.appraiseMetadata != null,
+        nodes: scenario.appraiseMetadata?.nodes ?? [],
+        flowBlocks: scenario.appraiseMetadata?.flowBlocks ?? [],
       })
     }
   }
@@ -739,14 +751,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)
@@ -760,11 +779,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++
     }
   }
@@ -822,10 +852,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
 
@@ -849,16 +884,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++
@@ -932,10 +971,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))
@@ -951,11 +995,41 @@ export function countTestSuiteMismatches(
   return count
 }
 
+type ProjectedTestCaseStep = {
+  order: number
+  gherkinStep: string
+  label: string
+  icon: TemplateStepIcon
+}
+
+function normalizeProjectedFsTestCaseSteps(stepsFromFs: ParsedStep[]): ProjectedTestCaseStep[] {
+  const storedSteps = stepsFromFs.map(step => ({
+    order: step.order,
+    gherkinStep: `${step.keyword} ${step.text}`,
+  }))
+  const projectedGherkinSteps = generateProjectedGherkinSteps(storedSteps)
+
+  return stepsFromFs.map((step, index) => {
+    const gherkinStep = projectedGherkinSteps[index] ?? ''
+    const [keyword = '', ...textParts] = gherkinStep.split(' ')
+    const label = textParts.join(' ')
+
+    return {
+      order: step.order,
+      gherkinStep,
+      label,
+      icon: determineProjectedStepIcon(keyword),
+    }
+  })
+}
+
 function hasProjectedTestCaseStepMismatch(
   stepsFromFs: ParsedStep[],
+  nodesFromFs: AppraiseTestCaseMetadataNode[] = [],
   dbSteps: Array<{
     order: number
     gherkinStep: string
+    flowNodeId: string | null
     label: string
     icon: TemplateStepIcon
     TemplateStep: { signature: string } | null
@@ -967,23 +1041,26 @@ function hasProjectedTestCaseStepMismatch(
   }>,
 ): boolean {
   const projectedDbSteps = normalizeProjectedDbTestCaseSteps(dbSteps)
+  const projectedFsSteps = normalizeProjectedFsTestCaseSteps(stepsFromFs)
   const dbStepsByOrder = new Map(projectedDbSteps.map(step => [step.order, step]))
+  const fsStepsByOrder = new Map(stepsFromFs.map(step => [step.order, step]))
+  const nodesByOrder = new Map(nodesFromFs.map(node => [node.order, node]))
 
-  for (const step of stepsFromFs) {
-    const existing = dbStepsByOrder.get(step.order)
-    const matchedTemplateStep = matchGherkinStepToTemplateStep(step, dbTemplateSteps)
+  for (const projectedFsStep of projectedFsSteps) {
+    const existing = dbStepsByOrder.get(projectedFsStep.order)
+    const sourceStep = fsStepsByOrder.get(projectedFsStep.order)
+    const metadataNode = nodesByOrder.get(projectedFsStep.order)
+    const matchedTemplateStep = sourceStep ? matchGherkinStepToTemplateStep(sourceStep, dbTemplateSteps) : null
 
     if (!existing || !matchedTemplateStep) {
       return true
     }
 
-    const expectedIcon = determineProjectedStepIcon(step.keyword)
-    const expectedGherkinStep = `${step.keyword} ${step.text}`
-
     if (
-      existing.gherkinStep !== expectedGherkinStep ||
-      existing.label !== step.text ||
-      existing.icon !== expectedIcon ||
+      existing.gherkinStep !== projectedFsStep.gherkinStep ||
+      existing.flowNodeId !== (metadataNode?.nodeId ?? existing.flowNodeId) ||
+      existing.label !== (metadataNode?.label ?? projectedFsStep.label) ||
+      existing.icon !== projectedFsStep.icon ||
       existing.templateStepSignature !== matchedTemplateStep.signature ||
       !sameResolvedParameters(existing.parameters, matchedTemplateStep.parameters)
     ) {
@@ -995,6 +1072,39 @@ function hasProjectedTestCaseStepMismatch(
   return projectedDbSteps.some(step => !fsOrders.has(step.order))
 }
 
+function hasFlowBlockMismatch(
+  flowBlocksFromFs: AppraiseTestCaseMetadataFlowBlock[] = [],
+  hasAppraiseMetadata: boolean | undefined,
+  dbFlowBlocks: Array<{
+    id: string
+    name: string
+    order: number
+    nodes: Array<{ flowNodeId: string }>
+  }>,
+): boolean {
+  if (!hasAppraiseMetadata) {
+    return false
+  }
+
+  if (flowBlocksFromFs.length !== dbFlowBlocks.length) {
+    return true
+  }
+
+  const dbById = new Map(dbFlowBlocks.map(block => [block.id, block]))
+
+  return flowBlocksFromFs.some(block => {
+    const existing = dbById.get(block.id)
+    if (!existing || existing.name !== block.name || existing.order !== block.order) {
+      return true
+    }
+
+    return !sameStringSet(
+      existing.nodes.map(node => node.flowNodeId),
+      block.nodeIds,
+    )
+  })
+}
+
 export function countTestCaseMismatches(
   filesystemTestCases: TestCaseFromFs[],
   dbTestCases: Array<{
@@ -1005,11 +1115,18 @@ export function countTestCaseMismatches(
     steps: Array<{
       order: number
       gherkinStep: string
+      flowNodeId: string | null
       label: string
       icon: TemplateStepIcon
       TemplateStep: { signature: string } | null
       parameters: Array<{ name: string; value: string; order: number; type: StepParameterType }>
     }>
+    flowBlocks: Array<{
+      id: string
+      name: string
+      order: number
+      nodes: Array<{ flowNodeId: string }>
+    }>
   }>,
   modulePathMap: Map<string, string>,
   dbTemplateSteps: Array<{
@@ -1017,9 +1134,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) {
@@ -1036,24 +1173,26 @@ 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)
+        !hasProjectedTestCaseStepMismatch(testCase.steps, testCase.nodes, existing.steps, dbTemplateSteps) &&
+        !hasFlowBlockMismatch(testCase.flowBlocks, testCase.hasAppraiseMetadata, existing.flowBlocks ?? [])
       )
     })
 
@@ -1093,7 +1232,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({
@@ -1148,6 +1298,7 @@ export async function getSyncPendingCounts(): Promise<SyncPendingCounts> {
             select: {
               order: true,
               gherkinStep: true,
+              flowNodeId: true,
               label: true,
               icon: true,
               TemplateStep: {
@@ -1159,6 +1310,18 @@ export async function getSyncPendingCounts(): Promise<SyncPendingCounts> {
               },
             },
           },
+          flowBlocks: {
+            select: {
+              id: true,
+              name: true,
+              order: true,
+              nodes: {
+                select: {
+                  flowNodeId: true,
+                },
+              },
+            },
+          },
         },
       }),
     ])

package/templates/starter/src/lib/template-automation-paths.ts

@@ -13,7 +13,7 @@ function getAutomationLocatorsDir(baseDir: string): string {
 }
 
 export function getAutomationLocatorMapPath(baseDir: string): string {
-  return join(baseDir, 'automation', 'mapping', 'locator-map.json')
+  return toPosixPath(join(baseDir, 'automation', 'mapping', 'locator-map.json'))
 }
 
 export function extractModulePathFromAutomationFile(

package/templates/starter/src/lib/template-sync-utils.d.ts

@@ -1,7 +1,14 @@
-export declare function shouldExcludeTemplatePath(relativePath: string): boolean;
-export declare function shouldBackfillLegacyEnvironmentConfig(targetHasEnvironmentsFile: boolean, legacyEnvironmentsDirExists: boolean): boolean;
-export declare function getAutomationFeaturesDir(baseDir: string): string;
-export declare function getAutomationLocatorsDir(baseDir: string): string;
-export declare function getAutomationLocatorMapPath(baseDir: string): string;
-export declare function extractModulePathFromAutomationFile(filePath: string, baseDir: string, automationSubdir: 'features' | 'locators'): string;
-//# sourceMappingURL=template-sync-utils.d.ts.map
+export declare function shouldExcludeTemplatePath(relativePath: string): boolean
+export declare function shouldBackfillLegacyEnvironmentConfig(
+  targetHasEnvironmentsFile: boolean,
+  legacyEnvironmentsDirExists: boolean,
+): boolean
+export declare function getAutomationFeaturesDir(baseDir: string): string
+export declare function getAutomationLocatorsDir(baseDir: string): string
+export declare function getAutomationLocatorMapPath(baseDir: string): string
+export declare function extractModulePathFromAutomationFile(
+  filePath: string,
+  baseDir: string,
+  automationSubdir: 'features' | 'locators',
+): string
+//# sourceMappingURL=template-sync-utils.d.ts.map

package/templates/starter/src/lib/test-case-utils.ts

@@ -1,6 +1,6 @@
-import crypto from 'crypto'
-
-export function generateUniqueTestCaseIdentifier(): string {
-  const id = crypto.randomBytes(8).toString('hex')
-  return `tc_${id}`
-}
+import crypto from 'crypto'
+
+export function generateUniqueTestCaseIdentifier(): string {
+  const id = crypto.randomBytes(8).toString('hex')
+  return `tc_${id}`
+}

package/templates/starter/src/lib/test-run/log-formatter.ts

@@ -1,83 +1,82 @@
-/**
- * Log formatting utilities for storing and retrieving test run logs
- */
-
-export interface LogEntry {
-  type: 'stdout' | 'stderr' | 'status'
-  message: string
-  timestamp: Date
-}
-
-/**
- * Formats log entries into a single text string for storage in the database
- * Format: [timestamp] [TYPE] message
- * 
- * @param logs - Array of log entries to format
- * @returns Formatted log string
- */
-export function formatLogsForStorage(logs: LogEntry[]): string {
-  return logs
-    .map(log => {
-      const timestamp = log.timestamp.toISOString()
-      const type = log.type.toUpperCase()
-      // Escape newlines in message to preserve them in the formatted string
-      const escapedMessage = log.message.replace(/\n/g, '\\n')
-      return `[${timestamp}] [${type}] ${escapedMessage}`
-    })
-    .join('\n')
-}
-
-/**
- * Parses formatted log text back into an array of LogEntry objects
- * 
- * @param formattedLogs - Formatted log string from database
- * @returns Array of log entries
- */
-export function parseLogsFromStorage(formattedLogs: string): LogEntry[] {
-  if (!formattedLogs || formattedLogs.trim() === '') {
-    return []
-  }
-
-  const lines = formattedLogs.split('\n')
-  const parsedLogs: LogEntry[] = []
-
-  for (const line of lines) {
-    if (!line.trim()) continue
-
-    try {
-      // Match format: [timestamp] [TYPE] message
-      const match = line.match(/^\[([^\]]+)\] \[([^\]]+)\] (.+)$/)
-      
-      if (match) {
-        const [, timestampStr, typeStr, message] = match
-        const timestamp = new Date(timestampStr)
-        const type = typeStr.toLowerCase() as 'stdout' | 'stderr' | 'status'
-        
-        // Unescape newlines in message
-        const unescapedMessage = message.replace(/\\n/g, '\n')
-        
-        // Validate type
-        if (type === 'stdout' || type === 'stderr' || type === 'status') {
-          parsedLogs.push({
-            type,
-            message: unescapedMessage,
-            timestamp: isNaN(timestamp.getTime()) ? new Date() : timestamp,
-          })
-        }
-      } else {
-        // Fallback: treat as stdout if format doesn't match
-        parsedLogs.push({
-          type: 'stdout',
-          message: line,
-          timestamp: new Date(),
-        })
-      }
-    } catch (error) {
-      // Skip malformed lines
-      console.error('[LogFormatter] Error parsing log line:', line, error)
-    }
-  }
-
-  return parsedLogs
-}
-
+/**
+ * Log formatting utilities for storing and retrieving test run logs
+ */
+
+export interface LogEntry {
+  type: 'stdout' | 'stderr' | 'status'
+  message: string
+  timestamp: Date
+}
+
+/**
+ * Formats log entries into a single text string for storage in the database
+ * Format: [timestamp] [TYPE] message
+ *
+ * @param logs - Array of log entries to format
+ * @returns Formatted log string
+ */
+export function formatLogsForStorage(logs: LogEntry[]): string {
+  return logs
+    .map(log => {
+      const timestamp = log.timestamp.toISOString()
+      const type = log.type.toUpperCase()
+      // Escape newlines in message to preserve them in the formatted string
+      const escapedMessage = log.message.replace(/\n/g, '\\n')
+      return `[${timestamp}] [${type}] ${escapedMessage}`
+    })
+    .join('\n')
+}
+
+/**
+ * Parses formatted log text back into an array of LogEntry objects
+ *
+ * @param formattedLogs - Formatted log string from database
+ * @returns Array of log entries
+ */
+export function parseLogsFromStorage(formattedLogs: string): LogEntry[] {
+  if (!formattedLogs || formattedLogs.trim() === '') {
+    return []
+  }
+
+  const lines = formattedLogs.split('\n')
+  const parsedLogs: LogEntry[] = []
+
+  for (const line of lines) {
+    if (!line.trim()) continue
+
+    try {
+      // Match format: [timestamp] [TYPE] message
+      const match = line.match(/^\[([^\]]+)\] \[([^\]]+)\] (.+)$/)
+
+      if (match) {
+        const [, timestampStr, typeStr, message] = match
+        const timestamp = new Date(timestampStr)
+        const type = typeStr.toLowerCase() as 'stdout' | 'stderr' | 'status'
+
+        // Unescape newlines in message
+        const unescapedMessage = message.replace(/\\n/g, '\n')
+
+        // Validate type
+        if (type === 'stdout' || type === 'stderr' || type === 'status') {
+          parsedLogs.push({
+            type,
+            message: unescapedMessage,
+            timestamp: isNaN(timestamp.getTime()) ? new Date() : timestamp,
+          })
+        }
+      } else {
+        // Fallback: treat as stdout if format doesn't match
+        parsedLogs.push({
+          type: 'stdout',
+          message: line,
+          timestamp: new Date(),
+        })
+      }
+    } catch (error) {
+      // Skip malformed lines
+      console.error('[LogFormatter] Error parsing log line:', line, error)
+    }
+  }
+
+  return parsedLogs
+}