create-appraisejs 0.3.0 → 0.3.1-alpha.0

package/templates/starter/src/constants/form-opts/diagram/node-form.ts

@@ -1,30 +1,13 @@
-import { StepParameterType } from '@prisma/client'
-import { z } from 'zod'
+import type { StepParameterType } from '@prisma/client'
 
-export const nodeDataSchema = z.object({
-  label: z.string().min(3, { message: 'Label must be at least 3 characters' }),
-  gherkinStep: z.string(),
-  templateStepId: z.string().min(1, { message: 'Template step is required' }),
-  parameters: z.array(
-    z.object({
-      name: z.string(),
-      value: z.string(),
-      type: z.nativeEnum(StepParameterType),
-      order: z.number(),
-    }),
-  ),
-})
-
-export type NodeData = z.infer<typeof nodeDataSchema>
-
-export const formOpts = {
-  defaultValues: {
-    label: '',
-    gherkinStep: '',
-    templateStepId: '',
-    parameters: [],
-  } as NodeData,
-  validators: {
-    onChange: nodeDataSchema,
-  },
+export type NodeFormData = {
+  label: string
+  gherkinStep: string
+  templateStepId: string
+  parameters: {
+    name: string
+    value: string
+    type: StepParameterType
+    order: number
+  }[]
 }

package/templates/starter/src/constants/form-opts/environment-form-opts.ts

@@ -10,7 +10,7 @@ export const environmentSchema = z.object({
 
 export type Environment = z.infer<typeof environmentSchema>
 
-export const formOpts = {
+export const environmentFormOpts = {
   defaultValues: {
     name: '',
     baseUrl: '',

package/templates/starter/src/constants/form-opts/locator-group-form-opts.ts

@@ -7,15 +7,9 @@ export const locatorGroupSchema = z.object({
   route: z.string().optional(),
 })
 
-// Schema for checking unique name (used in server actions)
-export const locatorGroupUniqueNameSchema = z.object({
-  name: z.string().min(1, { message: 'Name is required' }),
-  id: z.string().optional(), // For updates, exclude current record
-})
-
 export type LocatorGroup = z.infer<typeof locatorGroupSchema>
 
-export const formOpts = {
+export const locatorGroupFormOpts = {
   defaultValues: {
     name: '',
     moduleId: '',

package/templates/starter/src/constants/form-opts/module-form-opts.ts

@@ -10,7 +10,7 @@ export const moduleSchema = z.object({
 
 export type Module = z.infer<typeof moduleSchema>
 
-export const formOpts = {
+export const moduleFormOpts = {
   defaultValues: {
     name: '',
     parentId: ROOT_MODULE_UUID,

package/templates/starter/src/constants/form-opts/tag-form-opts.ts

@@ -31,7 +31,7 @@ export const tagSchema = z.object({
 
 export type Tag = z.infer<typeof tagSchema>
 
-export const formOpts = {
+export const tagFormOpts = {
   defaultValues: {
     name: '',
     tagExpression: '',

package/templates/starter/src/constants/form-opts/template-selection-form-opts.ts

@@ -3,14 +3,3 @@ import { z } from 'zod'
 export const templateSelectionSchema = z.object({
   templateTestCaseId: z.string().min(1, { message: 'Template test case is required' }),
 })
-
-export type TemplateSelection = z.infer<typeof templateSelectionSchema>
-
-export const formOpts = {
-  defaultValues: {
-    templateTestCaseId: '',
-  },
-  validators: {
-    onChange: templateSelectionSchema,
-  },
-}

package/templates/starter/src/constants/form-opts/template-step-group-form-opts.ts

@@ -12,7 +12,7 @@ export const templateStepGroupSchema = z.object({
 
 export type TemplateStepGroup = z.infer<typeof templateStepGroupSchema>
 
-export const formOpts = {
+export const templateStepGroupFormOpts = {
   defaultValues: {
     name: '',
     description: '',

package/templates/starter/src/constants/form-opts/template-test-case-form-opts.ts

@@ -1,39 +1,9 @@
-import { StepParameterType, TemplateStepIcon } from '@prisma/client'
 import { z } from 'zod'
+import { flowBlockSchema, testCaseStepsSchema } from './test-case-step-form-opts'
 
 export const templateTestCaseSchema = z.object({
   title: z.string().min(3, { message: 'Title must be at least 3 characters' }),
   description: z.string().optional(),
-  steps: z
-    .array(
-      z.object({
-        gherkinStep: z.string(),
-        label: z.string(),
-        icon: z.nativeEnum(TemplateStepIcon),
-        parameters: z.array(
-          z.object({
-            name: z.string(),
-            value: z.string(),
-            type: z.nativeEnum(StepParameterType),
-            order: z.number(),
-          }),
-        ),
-        order: z.number(),
-        templateStepId: z.string(),
-      }),
-    )
-    .min(1, { message: 'Steps are required' }),
+  flowBlocks: z.array(flowBlockSchema).default([]),
+  steps: testCaseStepsSchema,
 })
-
-export type TemplateTestCase = z.infer<typeof templateTestCaseSchema>
-
-export const formOpts = {
-  defaultValues: {
-    title: '',
-    description: '',
-    steps: [],
-  } as TemplateTestCase,
-  validators: {
-    onChange: templateTestCaseSchema,
-  },
-}

package/templates/starter/src/constants/form-opts/template-test-step-form-opts.ts

@@ -19,7 +19,7 @@ export const templateStepSchema = z.object({
 
 export type TemplateStep = z.infer<typeof templateStepSchema>
 
-export const formOpts = {
+export const templateStepFormOpts = {
   defaultValues: {
     name: '',
     description: '',

package/templates/starter/src/constants/form-opts/test-case-form-opts.ts

@@ -1,43 +1,11 @@
-import { StepParameterType, TemplateStepIcon } from '@prisma/client'
 import { z } from 'zod'
+import { flowBlockSchema, testCaseStepsSchema } from './test-case-step-form-opts'
 
 export const testCaseSchema = z.object({
   title: z.string().min(3, { message: 'Title must be at least 3 characters' }),
   description: z.string().optional(),
   testSuiteIds: z.array(z.string()),
   tagIds: z.array(z.string()).optional(),
-  steps: z
-    .array(
-      z.object({
-        gherkinStep: z.string(),
-        label: z.string(),
-        icon: z.nativeEnum(TemplateStepIcon),
-        parameters: z.array(
-          z.object({
-            name: z.string(),
-            value: z.string(),
-            type: z.nativeEnum(StepParameterType),
-            order: z.number(),
-          }),
-        ),
-        order: z.number(),
-        templateStepId: z.string(),
-      }),
-    )
-    .min(1, { message: 'Steps are required' }),
+  flowBlocks: z.array(flowBlockSchema).default([]),
+  steps: testCaseStepsSchema,
 })
-
-export type TestCase = z.infer<typeof testCaseSchema>
-
-export const formOpts = {
-  defaultValues: {
-    title: '',
-    description: '',
-    testSuiteIds: [],
-    tagIds: [],
-    steps: [],
-  } as TestCase,
-  validators: {
-    onChange: testCaseSchema,
-  },
-}

package/templates/starter/src/constants/form-opts/test-case-step-form-opts.ts

@@ -0,0 +1,27 @@
+import { StepParameterType, TemplateStepIcon } from '@prisma/client'
+import { z } from 'zod'
+
+export const flowBlockSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  nodeIds: z.array(z.string()),
+})
+
+const testCaseStepSchema = z.object({
+  nodeId: z.string().optional(),
+  gherkinStep: z.string(),
+  label: z.string(),
+  icon: z.nativeEnum(TemplateStepIcon),
+  parameters: z.array(
+    z.object({
+      name: z.string(),
+      value: z.string(),
+      type: z.nativeEnum(StepParameterType),
+      order: z.number(),
+    }),
+  ),
+  order: z.number(),
+  templateStepId: z.string(),
+})
+
+export const testCaseStepsSchema = z.array(testCaseStepSchema).min(1, { message: 'Steps are required' })

package/templates/starter/src/constants/form-opts/test-run-form-opts.ts

@@ -18,7 +18,7 @@ export const testRunSchema = z.object({
 
 export type TestRun = z.infer<typeof testRunSchema>
 
-export const formOpts = {
+export const testRunFormOpts = {
   defaultValues: {
     name: '',
     environmentId: '',

package/templates/starter/src/constants/form-opts/test-suite-form-opts.ts

@@ -10,7 +10,7 @@ export const testSuiteSchema = z.object({
 
 export type TestSuite = z.infer<typeof testSuiteSchema>
 
-export const formOpts = {
+export const testSuiteFormOpts = {
   defaultValues: {
     name: '',
     description: '',

package/templates/starter/src/hooks/use-toast.ts

@@ -69,7 +69,7 @@ const addToRemoveQueue = (toastId: string) => {
   toastTimeouts.set(toastId, timeout)
 }
 
-export const reducer = (state: State, action: Action): State => {
+const reducer = (state: State, action: Action): State => {
   switch (action.type) {
     case 'ADD_TOAST':
       return {

package/templates/starter/src/lib/automation/automation-path-roots.ts

@@ -54,7 +54,7 @@ export function getAutomationRunReportPath(runId: string): string {
   return path.join(getAutomationReportRunDir(runId), 'cucumber.json')
 }
 
-export function getAutomationReportLogsDir(runId: string): string {
+function getAutomationReportLogsDir(runId: string): string {
   return path.join(getAutomationReportRunDir(runId), 'logs')
 }
 
@@ -62,14 +62,6 @@ export function getAutomationRunLogPath(runId: string): string {
   return path.join(getAutomationReportLogsDir(runId), 'run.log')
 }
 
-export function getAutomationReportTracesDir(runId: string): string {
-  return path.join(getAutomationReportRunDir(runId), 'traces')
-}
-
-export function getAutomationReportScreenshotsDir(runId: string): string {
-  return path.join(getAutomationReportRunDir(runId), 'screenshots')
-}
-
 export function toProjectRelativePath(targetPath: string): string {
   const normalizedPath = path.isAbsolute(targetPath) ? path.relative(getRepoRoot(), targetPath) : targetPath
   return normalizedPath.replace(/\\/g, '/')

package/templates/starter/src/lib/bidirectional-sync.ts

@@ -1,6 +1,6 @@
 import { promises as fs } from 'fs'
-import { join, relative } from 'path'
-import { scanFeatureFiles } from './gherkin-parser'
+import { join } from 'path'
+import { extractModulePathFromFilePath, scanFeatureFiles } from './gherkin-parser'
 import { mergeScenariosWithExistingTestSuites } from './database-sync'
 import { generateFeatureFile } from './feature-file-generator'
 import prisma from '@/config/db-config'
@@ -170,82 +170,8 @@ export async function performDryRunSync(featuresBaseDir: string): Promise<{
   try {
     console.log('🔍 Performing dry run of bidirectional sync...')
 
-    // Check filesystem -> database sync
-    const parsedFeatures = await scanFeatureFiles(featuresBaseDir)
-
-    for (const feature of parsedFeatures) {
-      const modulePath = extractModulePathFromFilePath(feature.filePath, featuresBaseDir)
-
-      // Check if module exists
-      const moduleExists = await checkModuleExists(modulePath)
-      if (!moduleExists) {
-        wouldCreate.testSuites.push(`Module: ${modulePath}`)
-      }
-
-      // Check if test suite exists
-      const testSuiteExists = await checkTestSuiteExists(feature.featureName, modulePath)
-      if (!testSuiteExists) {
-        wouldCreate.testSuites.push(`Test Suite: ${feature.featureName}`)
-      }
-
-      // Check scenarios
-      for (const scenario of feature.scenarios) {
-        const testCaseExists = await checkTestCaseExists(scenario.name, feature.featureName, modulePath)
-        if (!testCaseExists) {
-          wouldCreate.testCases.push(`Test Case: ${scenario.name}`)
-        }
-
-        // Check template steps
-        for (const step of scenario.steps) {
-          const templateStepExists = await checkTemplateStepExists(step)
-          if (!templateStepExists) {
-            wouldCreate.templateSteps.push(`Template Step: ${step.keyword} ${step.text}`)
-          }
-        }
-
-        // Check scenario-level tags
-        for (const tag of scenario.tags) {
-          const tagExists = await checkTagExists(tag)
-          if (!tagExists) {
-            if (!wouldCreate.tags.includes(tag)) {
-              wouldCreate.tags.push(tag)
-            }
-          }
-        }
-      }
-
-      // Check feature-level tags
-      for (const tag of feature.tags) {
-        const tagExists = await checkTagExists(tag)
-        if (!tagExists) {
-          if (!wouldCreate.tags.includes(tag)) {
-            wouldCreate.tags.push(tag)
-          }
-        }
-      }
-    }
-
-    // Check database -> filesystem sync
-    const testSuites = await prisma.testSuite.findMany({
-      include: {
-        testCases: true,
-        module: true,
-      },
-    })
-
-    for (const testSuite of testSuites) {
-      const expectedPath = buildExpectedFeatureFilePath(testSuite, featuresBaseDir)
-      const fileExists = await fs
-        .access(expectedPath)
-        .then(() => true)
-        .catch(() => false)
-
-      if (fileExists) {
-        wouldUpdate.push(expectedPath)
-      } else {
-        wouldGenerate.push(expectedPath)
-      }
-    }
+    await collectFilesystemDryRunChanges(featuresBaseDir, wouldCreate)
+    await collectDatabaseDryRunChanges(featuresBaseDir, wouldGenerate, wouldUpdate)
 
     console.log('🔍 Dry run completed!')
     console.log(`Would generate ${wouldGenerate.length} feature files`)
@@ -268,38 +194,19 @@ export async function performDryRunSync(featuresBaseDir: string): Promise<{
 
 // Helper functions for dry run
 
-function extractModulePathFromFilePath(featureFilePath: string, featuresBaseDir: string): string {
-  // Use path.relative for cross-platform path handling
-  const relativePath = relative(featuresBaseDir, featureFilePath)
-
-  // Normalize to forward slashes for module path format (database uses /)
-  const normalizedPath = relativePath.replace(/\\/g, '/')
-  const pathParts = normalizedPath.split('/').filter(part => part && part !== '')
-  const moduleParts = pathParts.slice(0, -1)
-  return moduleParts.length > 0 ? '/' + moduleParts.join('/') : '/'
+type DryRunCreateSummary = {
+  testSuites: string[]
+  testCases: string[]
+  templateSteps: string[]
+  tags: string[]
 }
 
-async function checkModuleExists(modulePath: string): Promise<boolean> {
-  try {
-    const pathParts = modulePath.split('/').filter(part => part && part !== '')
-    if (pathParts.length === 0) return true
-
-    let currentParentId: string | null = null
+type ParsedDryRunFeature = Awaited<ReturnType<typeof scanFeatureFiles>>[number]
+type ParsedDryRunScenario = ParsedDryRunFeature['scenarios'][number]
 
-    for (const moduleName of pathParts) {
-      const foundModule: Module | null = await prisma.module.findFirst({
-        where: {
-          name: moduleName,
-          parentId: currentParentId,
-        },
-      })
-      if (!foundModule) return false
-      currentParentId = foundModule.id
-    }
-    return true
-  } catch {
-    return false
-  }
+async function checkModuleExists(modulePath: string): Promise<boolean> {
+  const pathParts = modulePath.split('/').filter(part => part && part !== '')
+  return pathParts.length === 0 || (await findModuleIdByPath(modulePath)) !== null
 }
 
 async function checkTestSuiteExists(featureName: string, modulePath: string): Promise<boolean> {
@@ -430,3 +337,105 @@ function buildModulePathFromTestSuite(testSuite: TestSuiteWithModule): string {
   // Simplified module path building - in practice, you'd use the existing logic
   return `/${testSuite.module.name}`
 }
+
+async function collectFilesystemDryRunChanges(featuresBaseDir: string, wouldCreate: DryRunCreateSummary) {
+  const parsedFeatures = await scanFeatureFiles(featuresBaseDir)
+
+  for (const feature of parsedFeatures) {
+    await collectFeatureDryRunChanges(feature, featuresBaseDir, wouldCreate)
+  }
+}
+
+async function collectFeatureDryRunChanges(
+  feature: ParsedDryRunFeature,
+  featuresBaseDir: string,
+  wouldCreate: DryRunCreateSummary,
+) {
+  const modulePath = extractModulePathFromFilePath(feature.filePath, featuresBaseDir)
+
+  await collectModuleAndSuiteDryRunChanges(feature.featureName, modulePath, wouldCreate)
+
+  for (const scenario of feature.scenarios) {
+    await collectScenarioDryRunChanges(scenario, feature.featureName, modulePath, wouldCreate)
+  }
+
+  await collectMissingTags(feature.tags, wouldCreate)
+}
+
+async function collectModuleAndSuiteDryRunChanges(
+  featureName: string,
+  modulePath: string,
+  wouldCreate: DryRunCreateSummary,
+) {
+  const moduleExists = await checkModuleExists(modulePath)
+  if (!moduleExists) {
+    wouldCreate.testSuites.push(`Module: ${modulePath}`)
+  }
+
+  const testSuiteExists = await checkTestSuiteExists(featureName, modulePath)
+  if (!testSuiteExists) {
+    wouldCreate.testSuites.push(`Test Suite: ${featureName}`)
+  }
+}
+
+async function collectScenarioDryRunChanges(
+  scenario: ParsedDryRunScenario,
+  featureName: string,
+  modulePath: string,
+  wouldCreate: DryRunCreateSummary,
+) {
+  const testCaseExists = await checkTestCaseExists(scenario.name, featureName, modulePath)
+  if (!testCaseExists) {
+    wouldCreate.testCases.push(`Test Case: ${scenario.name}`)
+  }
+
+  for (const step of scenario.steps) {
+    const templateStepExists = await checkTemplateStepExists(step)
+    if (!templateStepExists) {
+      wouldCreate.templateSteps.push(`Template Step: ${step.keyword} ${step.text}`)
+    }
+  }
+
+  await collectMissingTags(scenario.tags, wouldCreate)
+}
+
+async function collectMissingTags(tags: string[], wouldCreate: DryRunCreateSummary) {
+  for (const tag of tags) {
+    const tagExists = await checkTagExists(tag)
+    if (!tagExists && !wouldCreate.tags.includes(tag)) {
+      wouldCreate.tags.push(tag)
+    }
+  }
+}
+
+async function collectDatabaseDryRunChanges(featuresBaseDir: string, wouldGenerate: string[], wouldUpdate: string[]) {
+  const testSuites = await prisma.testSuite.findMany({
+    include: {
+      testCases: true,
+      module: true,
+    },
+  })
+
+  for (const testSuite of testSuites) {
+    await collectFeatureFileDryRunChange(testSuite, featuresBaseDir, wouldGenerate, wouldUpdate)
+  }
+}
+
+async function collectFeatureFileDryRunChange(
+  testSuite: TestSuiteWithModule,
+  featuresBaseDir: string,
+  wouldGenerate: string[],
+  wouldUpdate: string[],
+) {
+  const expectedPath = buildExpectedFeatureFilePath(testSuite, featuresBaseDir)
+  const fileExists = await fs
+    .access(expectedPath)
+    .then(() => true)
+    .catch(() => false)
+
+  if (fileExists) {
+    wouldUpdate.push(expectedPath)
+  } else {
+    wouldGenerate.push(expectedPath)
+  }
+}