create-appraise 0.1.0

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

@@ -0,0 +1,43 @@
+import { StepParameterType, TemplateStepIcon } from '@prisma/client'
+import { z } from 'zod'
+
+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' }),
+})
+
+export type TestCase = z.infer<typeof testCaseSchema>
+
+export const formOpts = {
+  defaultValues: {
+    title: '',
+    description: '',
+    testSuiteIds: [],
+    tagIds: [],
+    steps: [],
+  } as TestCase,
+  validators: {
+    onChange: testCaseSchema,
+  },
+}

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

@@ -0,0 +1,31 @@
+import { BrowserEngine } from '@prisma/client'
+import { z } from 'zod'
+
+export const testRunSchema = z.object({
+  name: z.string().min(1, { message: 'Name is required' }),
+  environmentId: z.string().min(1, { message: 'Environment is required' }),
+  tags: z.array(z.string()),
+  testWorkersCount: z.number().min(1, { message: 'Test workers count must be at least 1' }).optional(),
+  browserEngine: z.nativeEnum(BrowserEngine),
+  testCases: z.array(
+    z.object({
+      testCaseId: z.string().min(1, { message: 'Test case is required' }),
+    }),
+  ),
+})
+
+export type TestRun = z.infer<typeof testRunSchema>
+
+export const formOpts = {
+  defaultValues: {
+    name: '',
+    environmentId: '',
+    tags: [],
+    testWorkersCount: 1,
+    browserEngine: BrowserEngine.CHROMIUM,
+    testCases: [],
+  } as TestRun,
+  validators: {
+    onChange: testRunSchema,
+  },
+}

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

@@ -0,0 +1,24 @@
+import { z } from 'zod'
+
+export const testSuiteSchema = z.object({
+  name: z.string().min(3, { message: 'Name must be at least 3 characters' }),
+  description: z.string().optional(),
+  testCases: z.array(z.string()).optional(),
+  moduleId: z.string().min(1, { message: 'Module is required' }),
+  tagIds: z.array(z.string()).optional(),
+})
+
+export type TestSuite = z.infer<typeof testSuiteSchema>
+
+export const formOpts = {
+  defaultValues: {
+    name: '',
+    description: '',
+    testCases: [],
+    moduleId: '',
+    tagIds: [],
+  } as TestSuite,
+  validators: {
+    onChange: testSuiteSchema,
+  },
+}

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

@@ -0,0 +1,187 @@
+'use client'
+
+// Inspired by react-hot-toast library
+import * as React from 'react'
+
+import type { ToastActionElement, ToastProps } from '@/components/ui/toast'
+
+const TOAST_LIMIT = 1
+const TOAST_REMOVE_DELAY = 1000000
+
+type ToasterToast = ToastProps & {
+  id: string
+  title?: React.ReactNode
+  description?: React.ReactNode
+  action?: ToastActionElement
+}
+
+let count = 0
+
+function genId() {
+  count = (count + 1) % Number.MAX_SAFE_INTEGER
+  return count.toString()
+}
+
+type ActionType = {
+  ADD_TOAST: 'ADD_TOAST'
+  UPDATE_TOAST: 'UPDATE_TOAST'
+  DISMISS_TOAST: 'DISMISS_TOAST'
+  REMOVE_TOAST: 'REMOVE_TOAST'
+}
+
+type Action =
+  | {
+      type: ActionType['ADD_TOAST']
+      toast: ToasterToast
+    }
+  | {
+      type: ActionType['UPDATE_TOAST']
+      toast: Partial<ToasterToast>
+    }
+  | {
+      type: ActionType['DISMISS_TOAST']
+      toastId?: ToasterToast['id']
+    }
+  | {
+      type: ActionType['REMOVE_TOAST']
+      toastId?: ToasterToast['id']
+    }
+
+interface State {
+  toasts: ToasterToast[]
+}
+
+const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>()
+
+const addToRemoveQueue = (toastId: string) => {
+  if (toastTimeouts.has(toastId)) {
+    return
+  }
+
+  const timeout = setTimeout(() => {
+    toastTimeouts.delete(toastId)
+    dispatch({
+      type: 'REMOVE_TOAST',
+      toastId: toastId,
+    })
+  }, TOAST_REMOVE_DELAY)
+
+  toastTimeouts.set(toastId, timeout)
+}
+
+export const reducer = (state: State, action: Action): State => {
+  switch (action.type) {
+    case 'ADD_TOAST':
+      return {
+        ...state,
+        toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
+      }
+
+    case 'UPDATE_TOAST':
+      return {
+        ...state,
+        toasts: state.toasts.map(t => (t.id === action.toast.id ? { ...t, ...action.toast } : t)),
+      }
+
+    case 'DISMISS_TOAST': {
+      const { toastId } = action
+
+      // ! Side effects ! - This could be extracted into a dismissToast() action,
+      // but I'll keep it here for simplicity
+      if (toastId) {
+        addToRemoveQueue(toastId)
+      } else {
+        state.toasts.forEach(toast => {
+          addToRemoveQueue(toast.id)
+        })
+      }
+
+      return {
+        ...state,
+        toasts: state.toasts.map(t =>
+          t.id === toastId || toastId === undefined
+            ? {
+                ...t,
+                open: false,
+              }
+            : t,
+        ),
+      }
+    }
+    case 'REMOVE_TOAST':
+      if (action.toastId === undefined) {
+        return {
+          ...state,
+          toasts: [],
+        }
+      }
+      return {
+        ...state,
+        toasts: state.toasts.filter(t => t.id !== action.toastId),
+      }
+  }
+}
+
+const listeners: Array<(state: State) => void> = []
+
+let memoryState: State = { toasts: [] }
+
+function dispatch(action: Action) {
+  memoryState = reducer(memoryState, action)
+  listeners.forEach(listener => {
+    listener(memoryState)
+  })
+}
+
+type Toast = Omit<ToasterToast, 'id'>
+
+function toast({ ...props }: Toast) {
+  const id = genId()
+
+  const update = (props: ToasterToast) =>
+    dispatch({
+      type: 'UPDATE_TOAST',
+      toast: { ...props, id },
+    })
+  const dismiss = () => dispatch({ type: 'DISMISS_TOAST', toastId: id })
+
+  dispatch({
+    type: 'ADD_TOAST',
+    toast: {
+      ...props,
+      id,
+      open: true,
+      onOpenChange: open => {
+        if (!open) dismiss()
+      },
+    },
+  })
+
+  return {
+    id: id,
+    dismiss,
+    update,
+  }
+}
+
+function useToast() {
+  const [state, setState] = React.useState<State>(memoryState)
+
+  React.useEffect(() => {
+    listeners.push(setState)
+    return () => {
+      const index = listeners.indexOf(setState)
+      if (index > -1) {
+        listeners.splice(index, 1)
+      }
+    }
+  }, [state])
+
+  return {
+    ...state,
+    toast,
+    dismiss: (toastId?: string) => dispatch({ type: 'DISMISS_TOAST', toastId }),
+  }
+}
+
+export { useToast, toast }

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

@@ -0,0 +1,432 @@
+import { promises as fs } from 'fs'
+import { join, relative } from 'path'
+import { scanFeatureFiles } from './gherkin-parser'
+import { mergeScenariosWithExistingTestSuites } from './database-sync'
+import { generateFeatureFile } from './feature-file-generator'
+import prisma from '@/config/db-config'
+import { Module, TestSuite } from '@prisma/client'
+
+// Type for TestSuite with included module relation
+type TestSuiteWithModule = TestSuite & {
+  module: Module
+}
+
+/**
+ * Result of the bidirectional sync operation
+ */
+export interface SyncResult {
+  // Database to Filesystem sync
+  generatedFeatureFiles: number
+  updatedFeatureFiles: number
+
+  // Filesystem to Database sync
+  createdTestSuites: number
+  createdTestCases: number
+  createdTemplateSteps: number
+  mergedTestSuites: number
+  addedScenarios: number
+
+  // Overall stats
+  totalProcessed: number
+  errors: string[]
+}
+
+/**
+ * Performs bidirectional synchronization between database and feature files
+ * @param featuresBaseDir - Base directory for feature files
+ * @returns Promise<SyncResult> - Result of the sync operation
+ */
+export async function performBidirectionalSync(featuresBaseDir: string): Promise<SyncResult> {
+  const result: SyncResult = {
+    generatedFeatureFiles: 0,
+    updatedFeatureFiles: 0,
+    createdTestSuites: 0,
+    createdTestCases: 0,
+    createdTemplateSteps: 0,
+    mergedTestSuites: 0,
+    addedScenarios: 0,
+    totalProcessed: 0,
+    errors: [],
+  }
+
+  try {
+    console.log('🔄 Starting bidirectional sync between database and feature files...')
+
+    // Step 1: Sync from filesystem to database (FS -> DB)
+    console.log('📁 Scanning feature files from filesystem...')
+    const parsedFeatures = await scanFeatureFiles(featuresBaseDir)
+    console.log(`Found ${parsedFeatures.length} feature files`)
+
+    if (parsedFeatures.length > 0) {
+      console.log('💾 Syncing feature files to database...')
+      const fsToDbResult = await mergeScenariosWithExistingTestSuites(parsedFeatures, featuresBaseDir)
+
+      result.mergedTestSuites = fsToDbResult.mergedTestSuites
+      result.addedScenarios = fsToDbResult.addedScenarios
+    }
+
+    // Step 2: Sync from database to filesystem (DB -> FS)
+    console.log('🗄️ Fetching test suites from database...')
+    const testSuites = await prisma.testSuite.findMany({
+      include: {
+        testCases: {
+          include: {
+            steps: {
+              include: {
+                parameters: true,
+              },
+              orderBy: {
+                order: 'asc',
+              },
+            },
+          },
+        },
+        module: true,
+      },
+    })
+
+    console.log(`Found ${testSuites.length} test suites in database`)
+
+    // Ensure features directory exists
+    await fs.mkdir(featuresBaseDir, { recursive: true })
+
+    // Generate/update feature files for each test suite
+    for (const testSuite of testSuites) {
+      try {
+        const featureFilePath = await generateFeatureFile(
+          testSuite.id,
+          testSuite.name,
+          testSuite.description || undefined,
+        )
+
+        // Check if this was a new file or update
+        const fileExists = await fs
+          .access(featureFilePath)
+          .then(() => true)
+          .catch(() => false)
+
+        if (fileExists) {
+          result.updatedFeatureFiles++
+        } else {
+          result.generatedFeatureFiles++
+        }
+
+        console.log(`✅ Processed: ${featureFilePath}`)
+      } catch (error) {
+        const errorMsg = `Error processing test suite ${testSuite.name}: ${error}`
+        console.error(errorMsg)
+        result.errors.push(errorMsg)
+      }
+    }
+
+    result.totalProcessed = testSuites.length
+
+    console.log('\n✅ Bidirectional sync completed!')
+    console.log(`📊 Summary:`)
+    console.log(`   - Generated feature files: ${result.generatedFeatureFiles}`)
+    console.log(`   - Updated feature files: ${result.updatedFeatureFiles}`)
+    console.log(`   - Merged test suites: ${result.mergedTestSuites}`)
+    console.log(`   - Added scenarios: ${result.addedScenarios}`)
+    console.log(`   - Total processed: ${result.totalProcessed}`)
+
+    if (result.errors.length > 0) {
+      console.log(`   - Errors: ${result.errors.length}`)
+      result.errors.forEach(error => console.log(`     - ${error}`))
+    }
+
+    return result
+  } catch (error) {
+    const errorMsg = `Fatal error during bidirectional sync: ${error}`
+    console.error(errorMsg)
+    result.errors.push(errorMsg)
+    throw error
+  }
+}
+
+/**
+ * Performs a dry run of the bidirectional sync to show what would be changed
+ * @param featuresBaseDir - Base directory for feature files
+ * @returns Promise<{wouldGenerate: string[], wouldUpdate: string[], wouldCreate: any[]}>
+ */
+export async function performDryRunSync(featuresBaseDir: string): Promise<{
+  wouldGenerate: string[]
+  wouldUpdate: string[]
+  wouldCreate: {
+    testSuites: string[]
+    testCases: string[]
+    templateSteps: string[]
+    tags: string[]
+  }
+}> {
+  const wouldGenerate: string[] = []
+  const wouldUpdate: string[] = []
+  const wouldCreate = {
+    testSuites: [] as string[],
+    testCases: [] as string[],
+    templateSteps: [] as string[],
+    tags: [] as string[],
+  }
+
+  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)
+      }
+    }
+
+    console.log('🔍 Dry run completed!')
+    console.log(`Would generate ${wouldGenerate.length} feature files`)
+    console.log(`Would update ${wouldUpdate.length} feature files`)
+    console.log(`Would create ${wouldCreate.testSuites.length} test suites`)
+    console.log(`Would create ${wouldCreate.testCases.length} test cases`)
+    console.log(`Would create ${wouldCreate.templateSteps.length} template steps`)
+    console.log(`Would create ${wouldCreate.tags.length} tags`)
+
+    return {
+      wouldGenerate,
+      wouldUpdate,
+      wouldCreate,
+    }
+  } catch (error) {
+    console.error('Error during dry run:', error)
+    throw error
+  }
+}
+
+// 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('/') : '/'
+}
+
+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
+
+    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 checkTestSuiteExists(featureName: string, modulePath: string): Promise<boolean> {
+  try {
+    const moduleId = await findModuleIdByPath(modulePath)
+    if (!moduleId) return false
+
+    const testSuite: TestSuite | null = await prisma.testSuite.findFirst({
+      where: {
+        name: featureName,
+        moduleId: moduleId,
+      },
+    })
+
+    return testSuite !== null
+  } catch {
+    return false
+  }
+}
+
+async function checkTestCaseExists(testCaseName: string, featureName: string, modulePath: string): Promise<boolean> {
+  try {
+    const moduleId = await findModuleIdByPath(modulePath)
+    if (!moduleId) return false
+
+    const testSuite = await prisma.testSuite.findFirst({
+      where: {
+        name: featureName,
+        moduleId: moduleId,
+      },
+    })
+
+    if (!testSuite) return false
+
+    const testCase = await prisma.testCase.findFirst({
+      where: {
+        title: testCaseName,
+        TestSuite: {
+          some: {
+            id: testSuite.id,
+          },
+        },
+      },
+    })
+
+    return !!testCase
+  } catch {
+    return false
+  }
+}
+
+async function checkTemplateStepExists(step: { keyword: string; text: string }): Promise<boolean> {
+  try {
+    const signature = `${step.keyword} ${step.text}`
+    const templateStep = await prisma.templateStep.findFirst({
+      where: {
+        signature: signature,
+      },
+    })
+
+    return !!templateStep
+  } catch {
+    return false
+  }
+}
+
+async function checkTagExists(tagExpression: string): Promise<boolean> {
+  try {
+    const tag = await prisma.tag.findFirst({
+      where: {
+        tagExpression: tagExpression,
+      },
+    })
+
+    return !!tag
+  } catch {
+    return false
+  }
+}
+
+async function findModuleIdByPath(modulePath: string): Promise<string | null> {
+  try {
+    const pathParts = modulePath.split('/').filter(part => part && part !== '')
+    // Handle empty path (root level) - find the default root module
+    if (pathParts.length === 0) {
+      const rootModule = await prisma.module.findFirst({
+        where: {
+          name: 'root',
+          parentId: null,
+        },
+      })
+      return rootModule?.id || null
+    }
+
+    let currentParentId: string | null = null
+
+    for (const moduleName of pathParts) {
+      const foundModule: Module | null = await prisma.module.findFirst({
+        where: {
+          name: moduleName,
+          parentId: currentParentId,
+        },
+      })
+
+      if (!foundModule) return null
+      currentParentId = foundModule.id
+    }
+
+    return currentParentId
+  } catch {
+    return null
+  }
+}
+
+function buildExpectedFeatureFilePath(testSuite: TestSuiteWithModule, featuresBaseDir: string): string {
+  // This is a simplified version - in practice, you'd use the same logic as generateFeatureFile
+  const modulePath = buildModulePathFromTestSuite(testSuite)
+  const safeFileName = testSuite.name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .replace(/-+/g, '-')
+
+  return join(featuresBaseDir, modulePath.substring(1), `${safeFileName}.feature`)
+}
+
+function buildModulePathFromTestSuite(testSuite: TestSuiteWithModule): string {
+  // Simplified module path building - in practice, you'd use the existing logic
+  return `/${testSuite.module.name}`
+}