create-appraisejs 0.3.0 → 0.3.1-alpha.1

package/templates/blank/src/lib/path-helpers/module-path.ts

@@ -19,53 +19,3 @@ export function buildModulePath(modules: Module[], selectedModule: Module): stri
   // Return path with leading slash
   return `/${path.join('/')}`
 }
-
-/**
- * Alternative implementation that can handle modules with parent relationships
- * This version works with the current data structure where we have parent info
- */
-export function buildModulePathFromParent(
-  modules: (Module & { parent: { name: string } })[],
-  selectedModule: Module & { parent: { name: string } },
-): string {
-  const path: string[] = []
-  let currentModule: (Module & { parent: { name: string } }) | null = selectedModule
-
-  // Build path from current module up to root
-  while (currentModule) {
-    path.unshift(currentModule.name)
-
-    if (currentModule.parent?.name) {
-      // Find the parent module in the modules array
-      const parentModule = modules.find(m => m.name === currentModule?.parent?.name)
-      currentModule = parentModule || null
-    } else {
-      // No parent, we've reached the root
-      currentModule = null
-    }
-  }
-
-  // Return path with leading slash
-  return `/${path.join('/')}`
-}
-
-/**
- * Builds paths for all modules in a single pass for better performance
- * @param modules - Array of all modules with parent info
- * @returns Map of module ID to path string
- */
-export function buildAllModulePaths(modules: (Module & { parent: { name: string } })[]): Map<string, string> {
-  const pathMap = new Map<string, string>()
-
-  // First pass: create a map for quick lookup
-  const moduleMap = new Map<string, Module & { parent: { name: string } }>()
-  modules.forEach(module => moduleMap.set(module.id, module))
-
-  // Second pass: build paths for each module
-  modules.forEach(module => {
-    const path = buildModulePathFromParent(modules, module)
-    pathMap.set(module.id, path)
-  })
-
-  return pathMap
-}

package/templates/blank/src/lib/process/task-spawner.ts

@@ -24,7 +24,7 @@ export interface SpawnedProcess {
   endTime: Date | null
 }
 
-export class TaskSpawner extends EventEmitter {
+class TaskSpawner extends EventEmitter {
   private processes: Map<string, SpawnedProcess> = new Map()
   private processCounter = 0
   private outputBuffers: Map<string, { stdout: string; stderr: string }> = new Map()
@@ -158,6 +158,54 @@ export class TaskSpawner extends EventEmitter {
     }
   }
 
+  private emitOutputLine(
+    processName: string,
+    stream: 'stdout' | 'stderr',
+    data: string,
+    streamLogs: boolean,
+    prefixLogs: boolean,
+    captureOutput: boolean,
+    spawnedProcess: SpawnedProcess,
+  ): void {
+    if (captureOutput) {
+      spawnedProcess.output[stream].push(data)
+    }
+
+    if (streamLogs) {
+      const prefix = prefixLogs ? `[${processName}] ` : ''
+      if (stream === 'stdout') {
+        console.log(`${prefix}${data}`)
+      } else {
+        console.error(`${prefix}${data}`)
+      }
+    }
+
+    this.emit(stream, { processName, data })
+  }
+
+  private flushBufferedOutput(
+    processName: string,
+    streamLogs: boolean,
+    prefixLogs: boolean,
+    captureOutput: boolean,
+    spawnedProcess: SpawnedProcess,
+  ): void {
+    const buffer = this.outputBuffers.get(processName)
+    if (!buffer) {
+      return
+    }
+
+    if (buffer.stdout) {
+      this.emitOutputLine(processName, 'stdout', buffer.stdout, streamLogs, prefixLogs, captureOutput, spawnedProcess)
+    }
+
+    if (buffer.stderr) {
+      this.emitOutputLine(processName, 'stderr', buffer.stderr, streamLogs, prefixLogs, captureOutput, spawnedProcess)
+    }
+
+    this.outputBuffers.delete(processName)
+  }
+
   private setupProcessListeners(
     spawnedProcess: SpawnedProcess,
     options: {
@@ -195,32 +243,7 @@ export class TaskSpawner extends EventEmitter {
 
     childProcess.on('exit', (code: number | null) => {
       if (stdioConfig === 'pipe') {
-        const buffer = this.outputBuffers.get(name)
-        if (buffer) {
-          if (buffer.stdout) {
-            if (captureOutput) {
-              spawnedProcess.output.stdout.push(buffer.stdout)
-            }
-            if (streamLogs) {
-              const prefix = prefixLogs ? `[${name}] ` : ''
-              console.log(`${prefix}${buffer.stdout}`)
-            }
-            this.emit('stdout', { processName: name, data: buffer.stdout })
-          }
-
-          if (buffer.stderr) {
-            if (captureOutput) {
-              spawnedProcess.output.stderr.push(buffer.stderr)
-            }
-            if (streamLogs) {
-              const prefix = prefixLogs ? `[${name}] ` : ''
-              console.error(`${prefix}${buffer.stderr}`)
-            }
-            this.emit('stderr', { processName: name, data: buffer.stderr })
-          }
-
-          this.outputBuffers.delete(name)
-        }
+        this.flushBufferedOutput(name, streamLogs, prefixLogs, captureOutput, spawnedProcess)
       }
 
       spawnedProcess.isRunning = false

package/templates/blank/src/lib/sync/projected-feature-utils.ts

@@ -1,4 +1,5 @@
 import { StepParameterType, TemplateStepIcon } from '@prisma/client'
+import { formatOrderedGherkinSteps } from '@/lib/gherkin-step-format'
 
 type StoredProjectedStep = {
   order: number
@@ -38,48 +39,7 @@ export function generateProjectedGherkinSteps(steps: StoredProjectedStep[]): str
     return []
   }
 
-  const sortedSteps = [...steps].sort((left, right) => left.order - right.order)
-  let hasThenInPrevious = false
-  let hasWhenInPrevious = false
-
-  return sortedSteps.map((step, index) => {
-    const gherkinStep = step.gherkinStep?.trim() || ''
-    const firstWord = gherkinStep.split(' ')[0].toLowerCase()
-    const hasGherkinKeyword = ['given', 'when', 'then', 'and', 'but'].includes(firstWord)
-    const stepWithoutKeyword = hasGherkinKeyword ? gherkinStep.split(' ').slice(1).join(' ') : gherkinStep
-
-    if (index === 0) {
-      return `Given ${stepWithoutKeyword}`
-    }
-
-    const isThenStatement =
-      firstWord === 'then' ||
-      stepWithoutKeyword.toLowerCase().startsWith('should') ||
-      stepWithoutKeyword.toLowerCase().startsWith('must') ||
-      stepWithoutKeyword.toLowerCase().startsWith('will')
-
-    if (!hasThenInPrevious) {
-      if (isThenStatement) {
-        hasThenInPrevious = true
-        return `Then ${stepWithoutKeyword}`
-      }
-
-      if (!hasWhenInPrevious) {
-        hasWhenInPrevious = true
-        return `When ${stepWithoutKeyword}`
-      }
-
-      return `And ${stepWithoutKeyword}`
-    }
-
-    if (isThenStatement) {
-      return `And ${stepWithoutKeyword}`
-    }
-
-    hasThenInPrevious = false
-    hasWhenInPrevious = true
-    return `When ${stepWithoutKeyword}`
-  })
+  return formatOrderedGherkinSteps(steps)
 }
 
 export function determineProjectedStepIcon(keyword: string): TemplateStepIcon {

package/templates/blank/src/lib/sync/sync-executor.ts

@@ -64,10 +64,7 @@ function parseSyncFailureCause(result: ScriptExecutionOutput | { error: unknown
     return result.error instanceof Error ? result.error.message : String(result.error)
   }
 
-  return selectMostRelevantLine([
-    ...normalizeOutputLines(result.stderr),
-    ...normalizeOutputLines(result.stdout),
-  ])
+  return selectMostRelevantLine([...normalizeOutputLines(result.stderr), ...normalizeOutputLines(result.stdout)])
 }
 
 async function executeSyncScript(scriptId: SyncScriptId): Promise<ScriptExecutionOutput> {

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

@@ -1,12 +1,8 @@
 import { describe, expect, it } from 'vitest'
+import { StepParameterType, TagType, TemplateStepGroupType, TemplateStepIcon, TemplateStepType } from '@prisma/client'
 import {
-  StepParameterType,
-  TagType,
-  TemplateStepGroupType,
-  TemplateStepIcon,
-  TemplateStepType,
-} from '@prisma/client'
-import {
+  countEnvironmentMismatches,
+  countLocatorGroupMismatches,
   countModuleMismatches,
   countTagMismatches,
   countTemplateStepGroupMismatches,
@@ -25,6 +21,40 @@ describe('sync pending counts', () => {
     expect(count).toBe(0)
   })
 
+  it('counts environment value changes but not deletions the sync script skips', () => {
+    const count = countEnvironmentMismatches(
+      [
+        {
+          name: 'Local',
+          baseUrl: 'http://localhost:3000',
+          apiBaseUrl: null,
+          username: 'demo@example.com',
+          password: null,
+        },
+      ],
+      [
+        {
+          name: 'Local',
+          baseUrl: 'http://localhost:3001',
+          apiBaseUrl: null,
+          username: 'demo@example.com',
+          password: null,
+          _count: { testRuns: 0 },
+        },
+        {
+          name: 'Historic',
+          baseUrl: 'https://old.example.com',
+          apiBaseUrl: null,
+          username: null,
+          password: null,
+          _count: { testRuns: 2 },
+        },
+      ],
+    )
+
+    expect(count).toBe(1)
+  })
+
   it('ignores DB-only standalone filter tags when filesystem tags are already satisfied', () => {
     const count = countTagMismatches(
       [{ name: 'smoke', tagExpression: '@smoke', type: TagType.FILTER }],
@@ -99,6 +129,59 @@ describe('sync pending counts', () => {
     expect(count).toBe(0)
   })
 
+  it('collapses duplicate filesystem template-step signatures to the script final state', () => {
+    const count = countTemplateStepMismatches(
+      [
+        {
+          groupName: 'Actions',
+          groupType: TemplateStepGroupType.ACTION,
+          step: {
+            jsdoc: {
+              name: 'Old duplicate',
+              description: 'First parsed copy',
+              icon: TemplateStepIcon.MOUSE,
+            },
+            signature: 'click {string}',
+            functionDefinition: '',
+            normalizedFunctionDefinition: "When('click {string}', async function () {});",
+            parameters: [],
+            keyword: 'When',
+          },
+        },
+        {
+          groupName: 'Actions',
+          groupType: TemplateStepGroupType.ACTION,
+          step: {
+            jsdoc: {
+              name: 'Click button',
+              description: 'Final parsed copy',
+              icon: TemplateStepIcon.MOUSE,
+            },
+            signature: 'click {string}',
+            functionDefinition: '',
+            normalizedFunctionDefinition: "When('click {string}', async function () {});",
+            parameters: [],
+            keyword: 'When',
+          },
+        },
+      ],
+      [
+        {
+          signature: 'click {string}',
+          name: 'Click button',
+          description: 'Final parsed copy',
+          functionDefinition: "When('click {string}', async function () {});",
+          icon: TemplateStepIcon.MOUSE,
+          type: TemplateStepType.ACTION,
+          templateStepGroup: { name: 'Actions' },
+          parameters: [],
+        },
+      ],
+    )
+
+    expect(count).toBe(0)
+  })
+
   it('matches test suites by generated filesystem key instead of raw DB name', () => {
     const count = countTestSuiteMismatches(
       [
@@ -147,6 +230,63 @@ describe('sync pending counts', () => {
     expect(count).toBe(0)
   })
 
+  it('collapses duplicate filesystem locator-group names to the script final state', () => {
+    const count = countLocatorGroupMismatches(
+      [
+        {
+          name: 'Login Page',
+          route: '/first',
+          modulePath: '/auth',
+        },
+        {
+          name: 'Login Page',
+          route: '/login',
+          modulePath: '/auth',
+        },
+      ],
+      [
+        {
+          name: 'Login Page',
+          route: '/login',
+          moduleId: 'module-auth',
+        },
+      ],
+      new Map([['module-auth', '/auth']]),
+    )
+
+    expect(count).toBe(0)
+  })
+
+  it('collapses duplicate filesystem test-suite identities to the script final state', () => {
+    const count = countTestSuiteMismatches(
+      [
+        {
+          name: 'user-login-suite',
+          description: 'First parsed copy',
+          modulePath: '/auth',
+          tags: ['@smoke'],
+        },
+        {
+          name: 'user-login-suite',
+          description: 'Final parsed copy',
+          modulePath: '/auth',
+          tags: ['@smoke', '@regression'],
+        },
+      ],
+      [
+        {
+          name: 'User Login Suite',
+          description: 'Final parsed copy',
+          moduleId: 'module-auth',
+          tags: [{ tagExpression: '@smoke' }, { tagExpression: '@regression' }],
+        },
+      ],
+      new Map([['module-auth', '/auth']]),
+    )
+
+    expect(count).toBe(0)
+  })
+
   it('matches projected test cases against generated feature-file output', () => {
     const count = countTestCaseMismatches(
       [
@@ -261,4 +401,58 @@ describe('sync pending counts', () => {
 
     expect(count).toBe(0)
   })
+
+  it('collapses duplicate filesystem test-case identifiers to the script final state', () => {
+    const count = countTestCaseMismatches(
+      [
+        {
+          identifierTag: '@tc_login',
+          title: 'Login',
+          description: 'Runs the login flow',
+          testSuiteName: 'login-smoke',
+          modulePath: '/auth',
+          filterTags: ['@demo'],
+          steps: [{ order: 1, keyword: 'Given', text: 'open the login page' }],
+        },
+        {
+          identifierTag: '@tc_login',
+          title: 'Login',
+          description: 'Runs the login flow',
+          testSuiteName: 'login-regression',
+          modulePath: '/auth',
+          filterTags: ['@auth', '@demo'],
+          steps: [{ order: 1, keyword: 'Given', text: 'open the login page' }],
+        },
+      ],
+      [
+        {
+          title: 'Login',
+          description: 'Runs the login flow',
+          tags: [
+            { tagExpression: '@tc_login', type: TagType.IDENTIFIER },
+            { tagExpression: '@auth', type: TagType.FILTER },
+            { tagExpression: '@demo', type: TagType.FILTER },
+          ],
+          TestSuite: [
+            { name: 'Login Smoke', moduleId: 'module-auth' },
+            { name: 'Login Regression', moduleId: 'module-auth' },
+          ],
+          steps: [
+            {
+              order: 1,
+              gherkinStep: 'Given open the login page',
+              label: 'open the login page',
+              icon: TemplateStepIcon.NAVIGATION,
+              TemplateStep: { signature: 'open the login page' },
+              parameters: [],
+            },
+          ],
+        },
+      ],
+      new Map([['module-auth', '/auth']]),
+      [{ signature: 'open the login page', parameters: [] }],
+    )
+
+    expect(count).toBe(0)
+  })
 })