create-appraisejs 0.3.1-alpha.1 → 0.4.0

package/templates/blank/src/lib/feature-file-generator.ts

@@ -4,6 +4,7 @@ import prisma from '@/config/db-config'
 import { buildModulePath } from '@/lib/path-helpers/module-path'
 import { getAutomationFeaturesDir } from '@/lib/automation/automation-path-roots'
 import { ensureAutomationWorkspaceReady } from '@/lib/automation/automation-workspace'
+import { buildAppraiseMetadata, getAppraiseMetadataPath } from '@/lib/appraise-test-case-metadata'
 import { generateProjectedGherkinSteps, getTestSuiteFilesystemKey } from '@/lib/sync/projected-feature-utils'
 
 async function isDirectoryEmpty(dirPath: string): Promise<boolean> {
@@ -32,6 +33,18 @@ async function removeEmptyDirectoriesUp(dirPath: string, basePath: string): Prom
   }
 }
 
+async function unlinkIfExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.unlink(filePath)
+    return true
+  } catch (error: unknown) {
+    if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+      return false
+    }
+    throw error
+  }
+}
+
 export async function generateFeatureFile(
   testSuiteId: string,
   testSuiteName: string,
@@ -53,6 +66,14 @@ export async function generateFeatureFile(
                   order: 'asc',
                 },
               },
+              flowBlocks: {
+                include: {
+                  nodes: true,
+                },
+                orderBy: {
+                  order: 'asc',
+                },
+              },
               tags: true,
             },
           },
@@ -73,6 +94,15 @@ export async function generateFeatureFile(
       testSuite.testCases,
       testSuite.tags,
     )
+    const metadataContent = JSON.stringify(
+      buildAppraiseMetadata({
+        testSuiteName,
+        modulePath,
+        testCases: testSuite.testCases,
+      }),
+      null,
+      2,
+    )
 
     const featuresBaseDir = getAutomationFeaturesDir()
     const moduleDir = join(featuresBaseDir, modulePath.substring(1))
@@ -82,6 +112,7 @@ export async function generateFeatureFile(
     const featureFilePath = join(moduleDir, `${safeFileName}.feature`)
 
     await fs.writeFile(featureFilePath, featureContent, 'utf8')
+    await fs.writeFile(getAppraiseMetadataPath(featureFilePath), `${metadataContent}\n`, 'utf8')
     return featureFilePath
   } catch (error) {
     console.error('Error generating feature file:', error)
@@ -178,17 +209,12 @@ export async function deleteFeatureFile(testSuiteId: string): Promise<boolean> {
     const featuresBaseDir = getAutomationFeaturesDir()
     const moduleDir = join(featuresBaseDir, modulePath.substring(1))
     const featureFilePath = join(moduleDir, `${safeFileName}.feature`)
+    const metadataFilePath = getAppraiseMetadataPath(featureFilePath)
 
-    try {
-      await fs.unlink(featureFilePath)
-      await removeEmptyDirectoriesUp(moduleDir, featuresBaseDir)
-      return true
-    } catch (error: unknown) {
-      if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
-        return false
-      }
-      throw error
-    }
+    const deletedFeature = await unlinkIfExists(featureFilePath)
+    const deletedMetadata = await unlinkIfExists(metadataFilePath)
+    await removeEmptyDirectoriesUp(moduleDir, featuresBaseDir)
+    return deletedFeature || deletedMetadata
   } catch (error) {
     console.error('Error deleting feature file:', error)
     throw error
@@ -220,6 +246,14 @@ export async function regenerateAllFeatureFiles(): Promise<string[]> {
                 order: 'asc',
               },
             },
+            flowBlocks: {
+              include: {
+                nodes: true,
+              },
+              orderBy: {
+                order: 'asc',
+              },
+            },
             tags: true,
           },
         },
@@ -239,6 +273,15 @@ export async function regenerateAllFeatureFiles(): Promise<string[]> {
           testSuite.testCases,
           testSuite.tags,
         )
+        const metadataContent = JSON.stringify(
+          buildAppraiseMetadata({
+            testSuiteName: testSuite.name,
+            modulePath,
+            testCases: testSuite.testCases,
+          }),
+          null,
+          2,
+        )
 
         const moduleDir = join(featuresBaseDir, modulePath.substring(1))
         await fs.mkdir(moduleDir, { recursive: true })
@@ -247,6 +290,7 @@ export async function regenerateAllFeatureFiles(): Promise<string[]> {
         const featureFilePath = join(moduleDir, `${safeFileName}.feature`)
 
         await fs.writeFile(featureFilePath, featureContent, 'utf8')
+        await fs.writeFile(getAppraiseMetadataPath(featureFilePath), `${metadataContent}\n`, 'utf8')
         generatedFiles.push(featureFilePath)
       } catch (error) {
         console.error(`Error generating feature file for test suite ${testSuite.name}:`, error)

package/templates/blank/src/lib/gherkin-parser.test.ts

@@ -3,6 +3,7 @@ import { join } from 'path'
 import { tmpdir } from 'os'
 import { expect, test } from 'vitest'
 
+import { getAppraiseMetadataPath } from '@/lib/appraise-test-case-metadata'
 import { parseFeatureFile } from '@/lib/gherkin-parser'
 
 async function withTempFeatureFile(content: string): Promise<string> {
@@ -42,3 +43,54 @@ Scenario: buys item
   expect(parsed).not.toBeNull()
   expect(parsed?.featureDescription).toBe('Checkout flow')
 })
+
+test('attaches adjacent Appraise metadata to matching scenarios', async () => {
+  const filePath = await withTempFeatureFile(`
+Feature: Checkout flow
+
+@tc_checkout_buy @smoke
+Scenario: [Legacy description] Legacy title
+  Given user adds item to cart
+`)
+  await fs.writeFile(
+    getAppraiseMetadataPath(filePath),
+    JSON.stringify({
+      version: 1,
+      testSuite: { name: 'checkout-flow', modulePath: '/checkout' },
+      testCases: [
+        {
+          identifierTag: '@tc_checkout_buy',
+          title: 'Buys item',
+          description: 'Happy path',
+          nodes: [{ nodeId: 'node-cart', order: 1, label: 'Add item' }],
+          flowBlocks: [{ id: 'block-cart', name: 'Cart', order: 0, nodeIds: ['node-cart'] }],
+        },
+      ],
+    }),
+    'utf8',
+  )
+
+  const parsed = await parseFeatureFile(filePath)
+
+  expect(parsed?.scenarios[0]?.appraiseMetadata).toMatchObject({
+    title: 'Buys item',
+    description: 'Happy path',
+    nodes: [{ nodeId: 'node-cart', order: 1, label: 'Add item' }],
+  })
+})
+
+test('falls back to feature-only parsing when sidecar is malformed', async () => {
+  const filePath = await withTempFeatureFile(`
+Feature: Checkout flow
+
+@tc_checkout_buy
+Scenario: buys item
+  Given user adds item to cart
+`)
+  await fs.writeFile(getAppraiseMetadataPath(filePath), '{', 'utf8')
+
+  const parsed = await parseFeatureFile(filePath)
+
+  expect(parsed?.scenarios[0]?.appraiseMetadata).toBeUndefined()
+  expect(parsed?.metadataWarnings).toHaveLength(1)
+})

package/templates/blank/src/lib/gherkin-parser.ts

@@ -1,5 +1,11 @@
 import { promises as fs } from 'fs'
 import { join } from 'path'
+import {
+  getAppraiseMetadataPath,
+  getMetadataByIdentifier,
+  readAppraiseMetadataFile,
+  type AppraiseTestCaseMetadataEntry,
+} from '@/lib/appraise-test-case-metadata'
 import { getFeatureModulePath } from '@/lib/path-helpers/feature-path'
 
 /**
@@ -11,6 +17,7 @@ export interface ParsedFeature {
   featureDescription?: string
   tags: string[]
   scenarios: ParsedScenario[]
+  metadataWarnings: string[]
 }
 
 /**
@@ -21,6 +28,7 @@ export interface ParsedScenario {
   description?: string
   tags: string[]
   steps: ParsedStep[]
+  appraiseMetadata?: AppraiseTestCaseMetadataEntry
 }
 
 /**
@@ -30,6 +38,7 @@ export interface ParsedStep {
   keyword: string
   text: string
   order: number
+  appraiseNode?: AppraiseTestCaseMetadataEntry['nodes'][number]
 }
 
 const STEP_KEYWORDS = ['Given', 'When', 'Then', 'And', 'But'] as const
@@ -103,6 +112,23 @@ function parseFeatureLine(line: string) {
   return line.replace('Feature:', '').trim()
 }
 
+function normalizeTagExpression(tagExpression: string): string {
+  return tagExpression.startsWith('@') ? tagExpression : `@${tagExpression}`
+}
+
+function getScenarioIdentifierTag(scenario: ParsedScenario): string | null {
+  for (const tagLine of scenario.tags) {
+    const tags = tagLine.split(/\s+/).filter(tag => tag.trim().startsWith('@'))
+    const identifierTag = tags.find(tag => normalizeTagExpression(tag).replace(/^@/, '').startsWith('tc_'))
+
+    if (identifierTag) {
+      return normalizeTagExpression(identifierTag)
+    }
+  }
+
+  return null
+}
+
 function startScenario(lines: string[], index: number): ParsedScenario {
   const { name, description } = parseScenarioHeader(lines[index])
 
@@ -170,10 +196,21 @@ function parseGherkinLines(lines: string[]) {
  */
 export async function parseFeatureFile(filePath: string): Promise<ParsedFeature | null> {
   try {
-    const content = await fs.readFile(filePath, 'utf-8')
+    const [content, metadataResult] = await Promise.all([
+      fs.readFile(filePath, 'utf-8'),
+      readAppraiseMetadataFile(getAppraiseMetadataPath(filePath)),
+    ])
     const lines = normalizeGherkinLines(content)
     const featureTags = getFeatureTags(lines)
     const { featureName, featureDescription, scenarios } = parseGherkinLines(lines)
+    const metadataByIdentifier = getMetadataByIdentifier(metadataResult.metadata)
+
+    for (const scenario of scenarios) {
+      const identifierTag = getScenarioIdentifierTag(scenario)
+      if (identifierTag) {
+        scenario.appraiseMetadata = metadataByIdentifier.get(identifierTag)
+      }
+    }
 
     if (!featureName) {
       console.warn(`No feature found in file: ${filePath}`)
@@ -186,6 +223,7 @@ export async function parseFeatureFile(filePath: string): Promise<ParsedFeature
       featureDescription: featureDescription || undefined,
       tags: featureTags,
       scenarios,
+      metadataWarnings: metadataResult.warnings,
     }
   } catch (error) {
     console.error(`Error parsing feature file ${filePath}:`, error)

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

@@ -7,6 +7,8 @@ type StoredProjectedStep = {
 }
 
 type StoredProjectedDbStep = StoredProjectedStep & {
+  flowNodeId: string | null
+  label: string
   TemplateStep: { signature: string } | null
   parameters: Array<{ name: string; value: string; order: number; type: StepParameterType }>
 }
@@ -16,6 +18,7 @@ export type ProjectedDbTestCaseStep = {
   keyword: string
   text: string
   gherkinStep: string
+  flowNodeId: string | null
   label: string
   icon: TemplateStepIcon
   templateStepSignature: string | null
@@ -64,7 +67,8 @@ export function normalizeProjectedDbTestCaseSteps(steps: StoredProjectedDbStep[]
       keyword,
       text,
       gherkinStep,
-      label: text,
+      flowNodeId: step.flowNodeId,
+      label: step.label,
       icon: determineProjectedStepIcon(keyword),
       templateStepSignature: step.TemplateStep?.signature ?? null,
       parameters: step.parameters,

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

@@ -342,6 +342,53 @@ describe('sync pending counts', () => {
     expect(count).toBe(0)
   })
 
+  it('counts sidecar-backed node label and flow block mismatches', () => {
+    const baseFilesystemCase = {
+      identifierTag: '@tc_checkout',
+      title: 'Checkout',
+      description: 'Buys an item',
+      testSuiteName: 'checkout-suite',
+      modulePath: '/commerce',
+      filterTags: [],
+      steps: [{ order: 1, keyword: 'Given' as const, text: 'open checkout' }],
+      hasAppraiseMetadata: true,
+      nodes: [{ nodeId: 'node-open', order: 1, label: 'Open checkout' }],
+      flowBlocks: [{ id: 'block-flow', name: 'Checkout flow', order: 0, nodeIds: ['node-open'] }],
+    }
+
+    const dbCase = {
+      title: 'Checkout',
+      description: 'Buys an item',
+      tags: [{ tagExpression: '@tc_checkout', type: TagType.IDENTIFIER }],
+      TestSuite: [{ name: 'Checkout Suite', moduleId: 'module-commerce' }],
+      steps: [
+        {
+          order: 1,
+          gherkinStep: 'When open checkout',
+          flowNodeId: 'node-open',
+          label: 'Old label',
+          icon: TemplateStepIcon.MOUSE,
+          TemplateStep: { signature: 'open checkout' },
+          parameters: [],
+        },
+      ],
+      flowBlocks: [
+        {
+          id: 'block-flow',
+          name: 'Checkout flow',
+          order: 0,
+          nodes: [{ flowNodeId: 'node-other' }],
+        },
+      ],
+    }
+
+    const count = countTestCaseMismatches([baseFilesystemCase], [dbCase], new Map([['module-commerce', '/commerce']]), [
+      { signature: 'open checkout', parameters: [] },
+    ])
+
+    expect(count).toBe(1)
+  })
+
   it('ignores duplicate stale DB test cases when one matching identifier row exists', () => {
     const count = countTestCaseMismatches(
       [
@@ -402,6 +449,74 @@ describe('sync pending counts', () => {
     expect(count).toBe(0)
   })
 
+  it('treats And steps after Then as in sync when DB stores the feature-file keyword', () => {
+    const count = countTestCaseMismatches(
+      [
+        {
+          identifierTag: '@tc_route',
+          title: 'Route Check',
+          description: 'Validates route after login',
+          testSuiteName: 'authentication',
+          modulePath: '/E2E Auth',
+          filterTags: [],
+          steps: [
+            { order: 1, keyword: 'Given', text: 'open the login page' },
+            { order: 2, keyword: 'Then', text: 'the url route should be equal to "/home"' },
+            { order: 3, keyword: 'And', text: 'the page title should be "Home"' },
+          ],
+        },
+      ],
+      [
+        {
+          title: 'Route Check',
+          description: 'Validates route after login',
+          tags: [{ tagExpression: '@tc_route', type: TagType.IDENTIFIER }],
+          TestSuite: [{ name: 'Authentication', 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: [],
+            },
+            {
+              order: 2,
+              gherkinStep: 'Then the url route should be equal to "/home"',
+              label: 'the url route should be equal to "/home"',
+              icon: TemplateStepIcon.VALIDATION,
+              TemplateStep: { signature: 'the url route should be equal to {string}' },
+              parameters: [{ name: 'route', value: '/home', order: 0, type: StepParameterType.STRING }],
+            },
+            {
+              order: 3,
+              gherkinStep: 'And the page title should be "Home"',
+              label: 'the page title should be "Home"',
+              icon: TemplateStepIcon.MOUSE,
+              TemplateStep: { signature: 'the page title should be {string}' },
+              parameters: [{ name: 'title', value: 'Home', order: 0, type: StepParameterType.STRING }],
+            },
+          ],
+        },
+      ],
+      new Map([['module-auth', '/E2E Auth']]),
+      [
+        { signature: 'open the login page', parameters: [] },
+        {
+          signature: 'the url route should be equal to {string}',
+          parameters: [{ name: 'route', order: 0, type: StepParameterType.STRING }],
+        },
+        {
+          signature: 'the page title should be {string}',
+          parameters: [{ name: 'title', order: 0, type: StepParameterType.STRING }],
+        },
+      ],
+    )
+
+    expect(count).toBe(0)
+  })
+
   it('collapses duplicate filesystem test-case identifiers to the script final state', () => {
     const count = countTestCaseMismatches(
       [

package/templates/blank/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,9 @@ type TestCaseFromFs = {
   modulePath: string
   filterTags: string[]
   steps: ParsedStep[]
+  hasAppraiseMetadata?: boolean
+  nodes: AppraiseTestCaseMetadataNode[]
+  flowBlocks: AppraiseTestCaseMetadataFlowBlock[]
 }
 
 type CollapsedTestCaseFromFs = TestCaseFromFs & {
@@ -686,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 ?? [],
       })
     }
   }
@@ -987,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
@@ -1003,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)
     ) {
@@ -1031,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<{
@@ -1041,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<{
@@ -1110,7 +1191,8 @@ export function countTestCaseMismatches(
         existing.description === testCase.description &&
         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 ?? [])
       )
     })
 
@@ -1216,6 +1298,7 @@ export async function getSyncPendingCounts(): Promise<SyncPendingCounts> {
             select: {
               order: true,
               gherkinStep: true,
+              flowNodeId: true,
               label: true,
               icon: true,
               TemplateStep: {
@@ -1227,6 +1310,18 @@ export async function getSyncPendingCounts(): Promise<SyncPendingCounts> {
               },
             },
           },
+          flowBlocks: {
+            select: {
+              id: true,
+              name: true,
+              order: true,
+              nodes: {
+                select: {
+                  flowNodeId: true,
+                },
+              },
+            },
+          },
         },
       }),
     ])

package/templates/blank/src/services/test-run/test-run-service.test.ts

@@ -39,6 +39,7 @@ const {
   mockProcessManagerOn,
   mockProcessManagerRemoveListener,
   mockFsAccess,
+  mockGenerateFeature,
 } = vi.hoisted(() => ({
   mockEnvironmentFindUnique: vi.fn(),
   mockTagFindMany: vi.fn(),
@@ -68,6 +69,7 @@ const {
   mockProcessManagerOn: vi.fn(),
   mockProcessManagerRemoveListener: vi.fn(),
   mockFsAccess: vi.fn(),
+  mockGenerateFeature: vi.fn(),
 }))
 
 vi.mock('@/config/db-config', () => ({
@@ -118,6 +120,12 @@ vi.mock('@/lib/test-suite-identifier-service', () => ({
   ensureTestSuiteIdentifierTags: mockEnsureTestSuiteIdentifierTags,
 }))
 
+vi.mock('@/lib/automation/projection-service', () => ({
+  automationProjectionService: {
+    generateFeature: mockGenerateFeature,
+  },
+}))
+
 vi.mock('@/services/report/report-service', () => ({
   storeReportFromFileService: mockStoreReportFromFileService,
 }))
@@ -266,6 +274,7 @@ describe('createTestRunFromValidatedValue', () => {
       error: vi.fn(),
     })
     mockGetLogFilePath.mockReturnValue('logs/run-1.log')
+    mockGenerateFeature.mockResolvedValue('automation/features/login.feature')
     mockTestRunUpdate.mockResolvedValue({})
     mockExecuteTestRun.mockResolvedValue({
       process: {
@@ -297,6 +306,7 @@ describe('createTestRunFromValidatedValue', () => {
     const result = await createTestRunFromValidatedValue(baseValue)
 
     expect(mockEnsureTestSuiteIdentifierTags).toHaveBeenCalledWith(['suite-1'])
+    expect(mockGenerateFeature).toHaveBeenCalledWith('suite-1')
     expect(mockTestRunCreate).toHaveBeenCalledWith({
       data: {
         name: 'Nightly Run',