create-appraisejs 0.3.0 → 0.3.1-alpha.1

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

@@ -92,7 +92,7 @@ const syncScriptDefinitionMap = new Map<SyncScriptId, (typeof syncScriptDefiniti
   syncScriptDefinitions.map(definition => [definition.id, definition]),
 )
 
-export function isSyncScriptId(value: string): value is SyncScriptId {
+function isSyncScriptId(value: string): value is SyncScriptId {
   return syncScriptDefinitionMap.has(value as SyncScriptId)
 }
 
@@ -110,7 +110,7 @@ export function getSyncScriptDefinition(scriptId: SyncScriptId) {
   return definition
 }
 
-export function resolveSyncExecutionOrder(requestedScriptId: SyncScriptId): SyncScriptId[] {
+function resolveSyncExecutionOrder(requestedScriptId: SyncScriptId): SyncScriptId[] {
   const visiting = new Set<SyncScriptId>()
   const visited = new Set<SyncScriptId>()
   const executionOrder: SyncScriptId[] = []

package/templates/blank/src/lib/tag-filters.ts

@@ -0,0 +1,11 @@
+import { Tag, TagType } from '@prisma/client'
+
+type TagShape = Pick<Tag, 'name' | 'tagExpression' | 'type'>
+
+export function getIdentifierTagByPrefix<T extends TagShape>(tags: T[], prefix: 'tc_' | 'ts_'): T | undefined {
+  return tags.find(tag => tag.type === TagType.IDENTIFIER && tag.name.startsWith(prefix))
+}
+
+export function getFilterTags<T extends TagShape>(tags: T[]): T[] {
+  return tags.filter(tag => tag.type === TagType.FILTER)
+}

package/templates/blank/src/lib/tag-identifiers.ts

@@ -0,0 +1,18 @@
+import { TagType } from '@prisma/client'
+
+function isIdentifierTagName(name: string): boolean {
+  return name.startsWith('tc_') || name.startsWith('ts_')
+}
+
+function isIdentifierTagExpression(tagExpression: string): boolean {
+  const normalized = tagExpression.startsWith('@') ? tagExpression.slice(1) : tagExpression
+  return isIdentifierTagName(normalized)
+}
+
+export function getTagTypeFromName(name: string): TagType {
+  return isIdentifierTagName(name) ? TagType.IDENTIFIER : TagType.FILTER
+}
+
+export function getTagTypeFromExpression(tagExpression: string): TagType {
+  return isIdentifierTagExpression(tagExpression) ? TagType.IDENTIFIER : TagType.FILTER
+}

package/templates/blank/src/lib/tag-utils.ts

@@ -1,28 +1,2 @@
-import { Tag, TagType } from '@prisma/client'
-
-type TagShape = Pick<Tag, 'name' | 'tagExpression' | 'type'>
-
-export function isIdentifierTagName(name: string): boolean {
-  return name.startsWith('tc_') || name.startsWith('ts_')
-}
-
-export function isIdentifierTagExpression(tagExpression: string): boolean {
-  const normalized = tagExpression.startsWith('@') ? tagExpression.slice(1) : tagExpression
-  return isIdentifierTagName(normalized)
-}
-
-export function getTagTypeFromName(name: string): TagType {
-  return isIdentifierTagName(name) ? TagType.IDENTIFIER : TagType.FILTER
-}
-
-export function getTagTypeFromExpression(tagExpression: string): TagType {
-  return isIdentifierTagExpression(tagExpression) ? TagType.IDENTIFIER : TagType.FILTER
-}
-
-export function getIdentifierTagByPrefix<T extends TagShape>(tags: T[], prefix: 'tc_' | 'ts_'): T | undefined {
-  return tags.find(tag => tag.type === TagType.IDENTIFIER && tag.name.startsWith(prefix))
-}
-
-export function getFilterTags<T extends TagShape>(tags: T[]): T[] {
-  return tags.filter(tag => tag.type === TagType.FILTER)
-}
+export * from './tag-filters'
+export * from './tag-identifiers'

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

@@ -0,0 +1,34 @@
+import { join, relative } from 'path'
+
+function toPosixPath(value: string): string {
+  return value.replace(/\\/g, '/')
+}
+
+function getAutomationFeaturesDir(baseDir: string): string {
+  return join(baseDir, 'automation', 'features')
+}
+
+function getAutomationLocatorsDir(baseDir: string): string {
+  return join(baseDir, 'automation', 'locators')
+}
+
+export function getAutomationLocatorMapPath(baseDir: string): string {
+  return toPosixPath(join(baseDir, 'automation', 'mapping', 'locator-map.json'))
+}
+
+export function extractModulePathFromAutomationFile(
+  filePath: string,
+  baseDir: string,
+  automationSubdir: 'features' | 'locators',
+): string {
+  const automationBaseDir =
+    automationSubdir === 'features' ? getAutomationFeaturesDir(baseDir) : getAutomationLocatorsDir(baseDir)
+  const normalizedBaseDir = toPosixPath(automationBaseDir).replace(/\/$/, '')
+  const normalizedFilePath = toPosixPath(filePath)
+  const relativePath = normalizedFilePath.startsWith(`${normalizedBaseDir}/`)
+    ? normalizedFilePath.slice(normalizedBaseDir.length + 1)
+    : toPosixPath(relative(automationBaseDir, filePath))
+  const pathParts = relativePath.split('/').filter(part => part && part !== '')
+  const moduleParts = pathParts.slice(0, -1)
+  return moduleParts.length > 0 ? `/${moduleParts.join('/')}` : '/'
+}

package/templates/blank/src/lib/template-path-exclusions.ts

@@ -0,0 +1,34 @@
+const EXCLUDED_DIRS = new Set(['node_modules', '.next', '.git', 'dist'])
+const EXCLUDED_EXTENSIONS = new Set(['.db', '.sqlite', '.sqlite3', '.tsbuildinfo'])
+const EXCLUDED_PATH_PREFIXES = ['automation/reports/']
+const EXCLUDED_FILENAMES = new Set(['.DS_Store'])
+
+function toPosixPath(value: string): string {
+  return value.replace(/\\/g, '/')
+}
+
+export function shouldExcludeTemplatePath(relativePath: string): boolean {
+  const normalizedPath = toPosixPath(relativePath)
+  const parts = normalizedPath.split('/')
+
+  if (parts.some(part => EXCLUDED_DIRS.has(part))) return true
+  if (parts.some(part => EXCLUDED_FILENAMES.has(part))) return true
+  if (EXCLUDED_PATH_PREFIXES.some(prefix => normalizedPath.startsWith(prefix))) return true
+
+  const ext = normalizedPath.endsWith('.sqlite3')
+    ? '.sqlite3'
+    : normalizedPath.endsWith('.sqlite')
+      ? '.sqlite'
+      : normalizedPath.endsWith('.tsbuildinfo')
+        ? '.tsbuildinfo'
+        : normalizedPath.slice(normalizedPath.lastIndexOf('.'))
+
+  return EXCLUDED_EXTENSIONS.has(ext)
+}
+
+export function shouldBackfillLegacyEnvironmentConfig(
+  targetHasEnvironmentsFile: boolean,
+  legacyEnvironmentsDirExists: boolean,
+): boolean {
+  return !targetHasEnvironmentsFile && legacyEnvironmentsDirExists
+}

package/templates/blank/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/blank/src/lib/template-sync-utils.ts

@@ -1,65 +1,2 @@
-import { join, relative } from 'path'
-
-const EXCLUDED_DIRS = new Set(['node_modules', '.next', '.git', 'dist'])
-const EXCLUDED_EXTENSIONS = new Set(['.db', '.sqlite', '.sqlite3', '.tsbuildinfo'])
-const EXCLUDED_PATH_PREFIXES = ['automation/reports/']
-const EXCLUDED_FILENAMES = new Set(['.DS_Store'])
-
-function toPosixPath(value: string): string {
-  return value.replace(/\\/g, '/')
-}
-
-export function shouldExcludeTemplatePath(relativePath: string): boolean {
-  const normalizedPath = toPosixPath(relativePath)
-  const parts = normalizedPath.split('/')
-
-  if (parts.some(part => EXCLUDED_DIRS.has(part))) return true
-  if (parts.some(part => EXCLUDED_FILENAMES.has(part))) return true
-  if (EXCLUDED_PATH_PREFIXES.some(prefix => normalizedPath.startsWith(prefix))) return true
-
-  const ext = normalizedPath.endsWith('.sqlite3')
-    ? '.sqlite3'
-    : normalizedPath.endsWith('.sqlite')
-      ? '.sqlite'
-      : normalizedPath.endsWith('.tsbuildinfo')
-        ? '.tsbuildinfo'
-        : normalizedPath.slice(normalizedPath.lastIndexOf('.'))
-
-  return EXCLUDED_EXTENSIONS.has(ext)
-}
-
-export function shouldBackfillLegacyEnvironmentConfig(
-  targetHasEnvironmentsFile: boolean,
-  legacyEnvironmentsDirExists: boolean,
-): boolean {
-  return !targetHasEnvironmentsFile && legacyEnvironmentsDirExists
-}
-
-export function getAutomationFeaturesDir(baseDir: string): string {
-  return join(baseDir, 'automation', 'features')
-}
-
-export function getAutomationLocatorsDir(baseDir: string): string {
-  return join(baseDir, 'automation', 'locators')
-}
-
-export function getAutomationLocatorMapPath(baseDir: string): string {
-  return join(baseDir, 'automation', 'mapping', 'locator-map.json')
-}
-
-export function extractModulePathFromAutomationFile(
-  filePath: string,
-  baseDir: string,
-  automationSubdir: 'features' | 'locators',
-): string {
-  const automationBaseDir =
-    automationSubdir === 'features' ? getAutomationFeaturesDir(baseDir) : getAutomationLocatorsDir(baseDir)
-  const normalizedBaseDir = toPosixPath(automationBaseDir).replace(/\/$/, '')
-  const normalizedFilePath = toPosixPath(filePath)
-  const relativePath = normalizedFilePath.startsWith(`${normalizedBaseDir}/`)
-    ? normalizedFilePath.slice(normalizedBaseDir.length + 1)
-    : toPosixPath(relative(automationBaseDir, filePath))
-  const pathParts = relativePath.split('/').filter(part => part && part !== '')
-  const moduleParts = pathParts.slice(0, -1)
-  return moduleParts.length > 0 ? `/${moduleParts.join('/')}` : '/'
-}
+export { extractModulePathFromAutomationFile, getAutomationLocatorMapPath } from './template-automation-paths'
+export { shouldBackfillLegacyEnvironmentConfig, shouldExcludeTemplatePath } from './template-path-exclusions'

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

@@ -11,7 +11,7 @@ export interface LogEntry {
 /**
  * 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
  */
@@ -29,7 +29,7 @@ export function formatLogsForStorage(logs: LogEntry[]): string {
 
 /**
  * Parses formatted log text back into an array of LogEntry objects
- * 
+ *
  * @param formattedLogs - Formatted log string from database
  * @returns Array of log entries
  */
@@ -47,15 +47,15 @@ export function parseLogsFromStorage(formattedLogs: string): LogEntry[] {
     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({
@@ -80,4 +80,3 @@ export function parseLogsFromStorage(formattedLogs: string): LogEntry[] {
 
   return parsedLogs
 }
-

package/templates/blank/src/lib/test-run/matching.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest'
+import { TagType, TestRunTestCaseStatus } from '@prisma/client'
+import { findMatchingTestRunTestCase } from '@/lib/test-run/matching'
+
+const identifierTag = (tagExpression: string) => ({
+  name: tagExpression.slice(1),
+  tagExpression,
+  type: TagType.IDENTIFIER,
+})
+
+const runTestCase = (
+  overrides: Partial<Parameters<typeof findMatchingTestRunTestCase>[0][number]> & {
+    id: string
+    title: string
+    suiteTag?: string
+    testCaseTag?: string
+  },
+) => ({
+  id: overrides.id,
+  status: overrides.status ?? TestRunTestCaseStatus.PENDING,
+  testSuiteId: overrides.testSuiteId ?? 'suite-1',
+  testCase: {
+    id: `case-${overrides.id}`,
+    title: overrides.title,
+    tags: overrides.testCaseTag ? [identifierTag(overrides.testCaseTag)] : [],
+  },
+  testSuite: overrides.suiteTag
+    ? {
+        id: overrides.testSuiteId ?? 'suite-1',
+        name: 'Smoke Suite',
+        tags: [identifierTag(overrides.suiteTag)],
+      }
+    : null,
+})
+
+describe('findMatchingTestRunTestCase', () => {
+  it('prefers suite and test case identifier tags over scenario titles', () => {
+    const suiteOnlyMatch = runTestCase({
+      id: 'suite-only',
+      title: 'Checkout',
+      suiteTag: '@ts_checkout',
+      testCaseTag: '@tc_wrong',
+    })
+    const exactIdentifierMatch = runTestCase({
+      id: 'exact',
+      title: 'Different title',
+      suiteTag: '@ts_checkout',
+      testCaseTag: '@tc_pay',
+    })
+
+    const match = findMatchingTestRunTestCase([suiteOnlyMatch, exactIdentifierMatch], {
+      scenarioName: '[Checkout] Pay with card',
+      scenarioTags: ['ts_checkout', '@tc_pay'],
+    })
+
+    expect(match).toBe(exactIdentifierMatch)
+  })
+
+  it('falls back to bracketed scenario titles and chooses an unfinished candidate first', () => {
+    const completedCandidate = runTestCase({
+      id: 'completed',
+      status: TestRunTestCaseStatus.COMPLETED,
+      title: 'Checkout',
+    })
+    const pendingCandidate = runTestCase({
+      id: 'pending',
+      status: TestRunTestCaseStatus.PENDING,
+      title: 'Checkout',
+    })
+
+    const match = findMatchingTestRunTestCase([completedCandidate, pendingCandidate], {
+      scenarioName: '[Checkout] Pay with card',
+    })
+
+    expect(match).toBe(pendingCandidate)
+  })
+})

package/templates/blank/src/lib/test-run/matching.ts

@@ -1,5 +1,5 @@
 import { TagType, TestRunTestCaseStatus } from '@prisma/client'
-import { getIdentifierTagByPrefix } from '@/lib/tag-utils'
+import { getIdentifierTagByPrefix } from '@/lib/tag-filters'
 
 type TagLike = {
   name: string
@@ -41,7 +41,7 @@ function consumeCandidate<T extends MatchableRunTestCase>(candidates: T[]): T |
   return unconsumed ?? candidates[0]
 }
 
-export function extractTestCaseTitleFromScenarioName(scenarioName: string): string | null {
+function extractTestCaseTitleFromScenarioName(scenarioName: string): string | null {
   const bracketMatch = scenarioName.match(/^\[([^\]]+)\]/)
   if (bracketMatch) {
     return bracketMatch[1].trim()

package/templates/blank/src/lib/test-run/report-parser.test.ts

@@ -0,0 +1,113 @@
+import { readFile } from 'fs/promises'
+import { StepKeyword, StepStatus } from '@prisma/client'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { getStepKeywordEnum, getStepStatusEnum, parseCucumberReport } from '@/lib/test-run/report-parser'
+
+vi.mock('fs/promises', () => ({
+  readFile: vi.fn(),
+}))
+
+describe('parseCucumberReport', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+  })
+
+  it('maps cucumber features, hooks, errors, and screenshot attachments', async () => {
+    vi.mocked(readFile).mockResolvedValueOnce(
+      JSON.stringify([
+        {
+          description: 'Feature description',
+          elements: [
+            {
+              description: 'Scenario description',
+              id: 'checkout;pay-with-card',
+              keyword: 'Scenario',
+              line: 7,
+              name: 'Pay with card',
+              steps: [
+                {
+                  keyword: 'Before',
+                  result: { duration: 1, status: 'passed' },
+                },
+                {
+                  embeddings: [
+                    {
+                      data: JSON.stringify({ screenshotPath: 'screenshots/pay-card.png' }),
+                      mime_type: 'application/vnd.appraisejs.report-step-screenshot+json',
+                    },
+                  ],
+                  keyword: 'Given ',
+                  line: 9,
+                  match: { location: 'steps/payment.ts:12' },
+                  name: 'I am on checkout',
+                  result: {
+                    duration: 10,
+                    error_message: 'Expected checkout page\n    at steps/payment.ts:12:3',
+                    status: 'failed',
+                  },
+                },
+              ],
+              tags: [{ line: 6, name: '@tc_pay' }],
+              type: 'scenario',
+            },
+          ],
+          id: 'checkout',
+          keyword: 'Feature',
+          line: 1,
+          name: 'Checkout',
+          tags: [{ line: 1, name: '@ts_checkout' }],
+          uri: 'features/checkout.feature',
+        },
+      ]),
+    )
+
+    const report = await parseCucumberReport('/tmp/cucumber.json')
+
+    expect(report.features[0]).toMatchObject({
+      description: 'Feature description',
+      keyword: 'Feature',
+      line: 1,
+      name: 'Checkout',
+      scenarios: [
+        {
+          cucumberId: 'checkout;pay-with-card',
+          hooks: [{ duration: 1, hidden: false, keyword: 'Before', status: 'passed' }],
+          name: 'Pay with card',
+          steps: [
+            {
+              duration: 10,
+              errorMessage: 'Expected checkout page',
+              errorTrace: 'at steps/payment.ts:12:3',
+              keyword: 'Given',
+              line: 9,
+              matchLocation: 'steps/payment.ts:12',
+              name: 'I am on checkout',
+              order: 1,
+              screenshotPath: 'screenshots/pay-card.png',
+              status: 'failed',
+            },
+          ],
+        },
+      ],
+      tags: [{ line: 1, name: '@ts_checkout' }],
+      uri: 'features/checkout.feature',
+    })
+  })
+
+  it('wraps read and parse failures with report path context', async () => {
+    vi.mocked(readFile).mockRejectedValueOnce(new Error('permission denied'))
+
+    await expect(parseCucumberReport('/tmp/missing.json')).rejects.toThrow(
+      'Failed to parse cucumber report at /tmp/missing.json: permission denied',
+    )
+  })
+})
+
+describe('report parser enum helpers', () => {
+  it('maps unknown statuses and keywords to safe defaults', () => {
+    expect(getStepStatusEnum('passed')).toBe(StepStatus.PASSED)
+    expect(getStepStatusEnum('unknown')).toBe(StepStatus.PENDING)
+    expect(getStepKeywordEnum(' Then ')).toBe(StepKeyword.THEN)
+    expect(getStepKeywordEnum('Eventually')).toBe(StepKeyword.GIVEN)
+  })
+})

package/templates/blank/src/lib/test-suite-identifier-service.ts

@@ -1,6 +1,6 @@
 import prisma from '@/config/db-config'
 import { generateUniqueTestSuiteIdentifier } from '@/lib/test-suite-utils'
-import { getIdentifierTagByPrefix } from '@/lib/tag-utils'
+import { getIdentifierTagByPrefix } from '@/lib/tag-filters'
 import { TagType } from '@prisma/client'
 
 async function createTestSuiteIdentifierTag() {

package/templates/blank/src/lib/transformers/template-test-case-converter.ts

@@ -2,35 +2,18 @@ import {
   TemplateTestCase,
   TemplateTestCaseStep,
   TemplateTestCaseStepParameter,
+  TemplateTestCaseFlowBlock,
+  TemplateTestCaseFlowBlockNode,
   TemplateStepIcon,
-  StepParameterType,
 } from '@prisma/client'
-import { NodeOrderMap } from '@/types/diagram/diagram'
+import { FlowBlock, NodeOrderMap } from '@/types/diagram/diagram'
 
 export interface ConvertedTestCaseData {
   title: string
   description: string
   testSuiteIds: string[]
   nodesOrder: NodeOrderMap
-}
-
-export interface TestCaseFormData {
-  title: string
-  description: string
-  testSuiteIds: string[]
-  steps: {
-    gherkinStep: string
-    label: string
-    icon: TemplateStepIcon
-    parameters: {
-      name: string
-      value: string
-      type: StepParameterType
-      order: number
-    }[]
-    order: number
-    templateStepId: string
-  }[]
+  flowBlocks: FlowBlock[]
 }
 
 /**
@@ -43,6 +26,7 @@ export const templateTestCaseToTestCaseConverter = (
     steps: (TemplateTestCaseStep & {
       parameters: TemplateTestCaseStepParameter[]
     })[]
+    flowBlocks?: (TemplateTestCaseFlowBlock & { nodes: TemplateTestCaseFlowBlockNode[] })[]
   },
 ): ConvertedTestCaseData => {
   // Convert template test case to test case format
@@ -54,7 +38,7 @@ export const templateTestCaseToTestCaseConverter = (
   const nodesOrder: NodeOrderMap = {}
 
   templateTestCase.steps.forEach((step, index) => {
-    const nodeId = `node-${index}`
+    const nodeId = step.flowNodeId ?? `node-${index}`
 
     // Convert parameters from template format to test case format
     const parameters = step.parameters.map(param => ({
@@ -65,6 +49,7 @@ export const templateTestCaseToTestCaseConverter = (
     }))
 
     nodesOrder[nodeId] = {
+      nodeId,
       order: step.order,
       label: step.label,
       gherkinStep: step.gherkinStep,
@@ -79,48 +64,12 @@ export const templateTestCaseToTestCaseConverter = (
     description,
     testSuiteIds,
     nodesOrder,
-  }
-}
-
-/**
- * Converts NodeOrderMap to the format expected by TestCaseForm and createTestCaseAction
- * @param nodesOrder - The NodeOrderMap from the converter
- * @returns Data in the format expected by the test case form
- */
-export const convertNodeOrderMapToTestCaseFormData = (nodesOrder: NodeOrderMap): TestCaseFormData['steps'] => {
-  return Object.entries(nodesOrder)
-    .map(([, nodeData]) => ({
-      gherkinStep: nodeData.gherkinStep || '',
-      label: nodeData.label,
-      icon: nodeData.icon as TemplateStepIcon,
-      parameters: nodeData.parameters,
-      order: nodeData.order,
-      templateStepId: nodeData.templateStepId,
-    }))
-    .sort((a, b) => a.order - b.order)
-}
-
-/**
- * Converts a template test case directly to the format expected by createTestCaseAction
- * @param templateTestCase - The template test case with steps and parameters
- * @param testSuiteIds - Optional test suite IDs to assign
- * @returns Data ready for test case creation
- */
-export const templateTestCaseToTestCaseFormData = (
-  templateTestCase: TemplateTestCase & {
-    steps: (TemplateTestCaseStep & {
-      parameters: TemplateTestCaseStepParameter[]
-    })[]
-  },
-  testSuiteIds: string[] = [],
-): TestCaseFormData => {
-  const convertedData = templateTestCaseToTestCaseConverter(templateTestCase)
-
-  return {
-    title: convertedData.title,
-    description: convertedData.description,
-    testSuiteIds: testSuiteIds.length > 0 ? testSuiteIds : convertedData.testSuiteIds,
-    steps: convertNodeOrderMapToTestCaseFormData(convertedData.nodesOrder),
+    flowBlocks:
+      templateTestCase.flowBlocks?.map(block => ({
+        id: block.id,
+        name: block.name,
+        nodeIds: block.nodes.map(node => node.flowNodeId),
+      })) ?? [],
   }
 }