create-appraisejs 0.3.0 → 0.3.1-alpha.0

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

@@ -1,91 +1,9 @@
-import { relative } from 'path'
 import prisma from '@/config/db-config'
 import { ParsedFeature, ParsedStep } from './gherkin-parser'
 import { buildModuleHierarchy } from './module-hierarchy-builder'
-import { TemplateStepType, TemplateStepIcon, TestCase, TagType } from '@prisma/client'
-import { getTagTypeFromExpression } from './tag-utils'
-
-/**
- * Syncs feature files to the database by creating missing test suites and test cases
- * @param parsedFeatures - Array of parsed feature files
- * @param featuresBaseDir - Base directory for features
- * @returns Promise<{createdTestSuites: number, createdTestCases: number, createdTemplateSteps: number}>
- */
-export async function syncFeaturesToDatabase(
-  parsedFeatures: ParsedFeature[],
-  featuresBaseDir: string,
-): Promise<{
-  createdTestSuites: number
-  createdTestCases: number
-  createdTemplateSteps: number
-}> {
-  let createdTestSuites = 0
-  let createdTestCases = 0
-  let createdTemplateSteps = 0
-
-  try {
-    for (const feature of parsedFeatures) {
-      // Extract module path from file path
-      const modulePath = extractModulePathFromFilePath(feature.filePath, featuresBaseDir)
-
-      // Build or find the module hierarchy
-      const moduleId = await buildModuleHierarchy(modulePath)
-
-      // Find or create test suite
-      const testSuiteId = await findOrCreateTestSuite(
-        feature.featureName,
-        feature.featureDescription,
-        moduleId,
-        feature.tags,
-      )
-
-      if (testSuiteId) {
-        createdTestSuites++
-
-        // Process each scenario in the feature
-        for (const scenario of feature.scenarios) {
-          const testCaseId = await findOrCreateTestCase(
-            scenario.name,
-            scenario.description || '',
-            testSuiteId,
-            scenario.tags,
-          )
-
-          if (testCaseId) {
-            createdTestCases++
-
-            // Process steps for this test case
-            for (const step of scenario.steps) {
-              const templateStepId = await findOrCreateTemplateStep(step)
-
-              if (templateStepId) {
-                createdTemplateSteps++
-              }
-
-              // Create or update test case step
-              if (testCaseId && templateStepId) {
-                await createOrUpdateTestCaseStep(testCaseId, step, templateStepId)
-              }
-            }
-          }
-        }
-      }
-    }
-
-    console.log(
-      `Sync completed: ${createdTestSuites} test suites, ${createdTestCases} test cases, ${createdTemplateSteps} template steps created`,
-    )
-
-    return {
-      createdTestSuites,
-      createdTestCases,
-      createdTemplateSteps,
-    }
-  } catch (error) {
-    console.error('Error syncing features to database:', error)
-    throw error
-  }
-}
+import { Prisma, TemplateStepType, TemplateStepIcon, TestCase, TagType } from '@prisma/client'
+import { getTagTypeFromExpression } from './tag-identifiers'
+import { getFeatureModulePath } from './path-helpers/feature-path'
 
 /**
  * Determines the tag type based on the tag expression pattern
@@ -153,23 +71,6 @@ async function findOrCreateTag(tagExpression: string): Promise<string> {
   }
 }
 
-/**
- * Extracts module path from feature file path
- * Works cross-platform (Windows, Mac, Linux)
- */
-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 !== '')
-
-  // Remove the filename and join the remaining parts
-  const moduleParts = pathParts.slice(0, -1)
-  return moduleParts.length > 0 ? '/' + moduleParts.join('/') : '/'
-}
-
 /**
  * Finds or creates a test suite
  */
@@ -406,6 +307,115 @@ async function createOrUpdateTestCaseStep(testCaseId: string, step: ParsedStep,
   }
 }
 
+type ParsedScenario = ParsedFeature['scenarios'][number]
+type ExistingTestSuite = Prisma.TestSuiteGetPayload<{
+  include: {
+    testCases: true
+  }
+}>
+
+async function createScenarioTestCase(scenario: ParsedScenario, testSuiteId: string): Promise<string | null> {
+  return findOrCreateTestCase(scenario.name, scenario.description || '', testSuiteId, scenario.tags)
+}
+
+async function createScenarioSteps(testCaseId: string, steps: ParsedStep[]): Promise<number> {
+  let createdTemplateSteps = 0
+
+  for (const step of steps) {
+    const templateStepId = await findOrCreateTemplateStep(step)
+
+    if (templateStepId) {
+      createdTemplateSteps++
+      await createOrUpdateTestCaseStep(testCaseId, step, templateStepId)
+    }
+  }
+
+  return createdTemplateSteps
+}
+
+async function findExistingTestSuite(feature: ParsedFeature, moduleId: string): Promise<ExistingTestSuite | null> {
+  return prisma.testSuite.findFirst({
+    where: {
+      name: feature.featureName,
+      moduleId: moduleId,
+    },
+    include: {
+      testCases: true,
+    },
+  })
+}
+
+async function connectTagsToTestSuite(testSuiteId: string, tags?: string[]): Promise<void> {
+  if (!tags || tags.length === 0) {
+    return
+  }
+
+  const tagIds = await Promise.all(tags.map(tag => findOrCreateTag(tag)))
+
+  await prisma.testSuite.update({
+    where: { id: testSuiteId },
+    data: {
+      tags: {
+        connect: tagIds.map(id => ({ id })),
+      },
+    },
+  })
+}
+
+async function addMissingScenariosToTestSuite(feature: ParsedFeature, testSuite: ExistingTestSuite): Promise<number> {
+  let addedScenarios = 0
+
+  for (const scenario of feature.scenarios) {
+    const existingTestCase = testSuite.testCases.find(tc => tc.title === scenario.name)
+
+    if (!existingTestCase && (await addScenarioToTestSuite(scenario, testSuite.id))) {
+      addedScenarios++
+    }
+  }
+
+  return addedScenarios
+}
+
+async function addScenarioToTestSuite(scenario: ParsedScenario, testSuiteId: string): Promise<boolean> {
+  const testCaseId = await createScenarioTestCase(scenario, testSuiteId)
+
+  if (!testCaseId) {
+    return false
+  }
+
+  await createScenarioSteps(testCaseId, scenario.steps)
+  return true
+}
+
+async function createTestSuiteWithScenarios(
+  feature: ParsedFeature,
+  moduleId: string,
+): Promise<{
+  createdTestSuite: boolean
+  addedScenarios: number
+}> {
+  const testSuiteId = await findOrCreateTestSuite(
+    feature.featureName,
+    feature.featureDescription,
+    moduleId,
+    feature.tags,
+  )
+
+  if (!testSuiteId) {
+    return { createdTestSuite: false, addedScenarios: 0 }
+  }
+
+  let addedScenarios = 0
+
+  for (const scenario of feature.scenarios) {
+    if (await addScenarioToTestSuite(scenario, testSuiteId)) {
+      addedScenarios++
+    }
+  }
+
+  return { createdTestSuite: true, addedScenarios }
+}
+
 /**
  * Merges scenarios from feature files with existing test suites
  * This handles conflicts by adding missing scenarios to existing test suites
@@ -422,95 +432,10 @@ export async function mergeScenariosWithExistingTestSuites(
 
   try {
     for (const feature of parsedFeatures) {
-      const modulePath = extractModulePathFromFilePath(feature.filePath, featuresBaseDir)
-      const moduleId = await buildModuleHierarchy(modulePath)
-
-      // Find existing test suite
-      const existingTestSuite = await prisma.testSuite.findFirst({
-        where: {
-          name: feature.featureName,
-          moduleId: moduleId,
-        },
-        include: {
-          testCases: true,
-        },
-      })
+      const result = await mergeFeatureScenarios(feature, featuresBaseDir)
 
-      if (existingTestSuite) {
-        mergedTestSuites++
-
-        // Associate feature-level tags with existing test suite
-        if (feature.tags && feature.tags.length > 0) {
-          const tagIds = await Promise.all(feature.tags.map(tag => findOrCreateTag(tag)))
-          await prisma.testSuite.update({
-            where: { id: existingTestSuite.id },
-            data: {
-              tags: {
-                connect: tagIds.map(id => ({ id })),
-              },
-            },
-          })
-        }
-
-        // Check each scenario and add if it doesn't exist
-        for (const scenario of feature.scenarios) {
-          const existingTestCase = existingTestSuite.testCases.find(tc => tc.title === scenario.name)
-
-          if (!existingTestCase) {
-            // Create new test case for this scenario
-            const testCaseId = await findOrCreateTestCase(
-              scenario.name,
-              scenario.description || '',
-              existingTestSuite.id,
-              scenario.tags,
-            )
-
-            if (testCaseId) {
-              addedScenarios++
-
-              // Add steps for this test case
-              for (const step of scenario.steps) {
-                const templateStepId = await findOrCreateTemplateStep(step)
-                if (templateStepId && testCaseId) {
-                  await createOrUpdateTestCaseStep(testCaseId, step, templateStepId)
-                }
-              }
-            }
-          }
-        }
-      } else {
-        // Create new test suite with all scenarios
-        const testSuiteId = await findOrCreateTestSuite(
-          feature.featureName,
-          feature.featureDescription,
-          moduleId,
-          feature.tags,
-        )
-
-        if (testSuiteId) {
-          mergedTestSuites++
-
-          for (const scenario of feature.scenarios) {
-            const testCaseId = await findOrCreateTestCase(
-              scenario.name,
-              scenario.description || '',
-              testSuiteId,
-              scenario.tags,
-            )
-
-            if (testCaseId) {
-              addedScenarios++
-
-              for (const step of scenario.steps) {
-                const templateStepId = await findOrCreateTemplateStep(step)
-                if (templateStepId && testCaseId) {
-                  await createOrUpdateTestCaseStep(testCaseId, step, templateStepId)
-                }
-              }
-            }
-          }
-        }
-      }
+      mergedTestSuites += result.mergedTestSuites
+      addedScenarios += result.addedScenarios
     }
 
     console.log(`Merge completed: ${mergedTestSuites} test suites processed, ${addedScenarios} new scenarios added`)
@@ -524,3 +449,30 @@ export async function mergeScenariosWithExistingTestSuites(
     throw error
   }
 }
+
+async function mergeFeatureScenarios(
+  feature: ParsedFeature,
+  featuresBaseDir: string,
+): Promise<{
+  mergedTestSuites: number
+  addedScenarios: number
+}> {
+  const moduleId = await buildModuleHierarchy(getFeatureModulePath(feature.filePath, featuresBaseDir))
+  const existingTestSuite = await findExistingTestSuite(feature, moduleId)
+
+  if (existingTestSuite) {
+    await connectTagsToTestSuite(existingTestSuite.id, feature.tags)
+
+    return {
+      mergedTestSuites: 1,
+      addedScenarios: await addMissingScenariosToTestSuite(feature, existingTestSuite),
+    }
+  }
+
+  const result = await createTestSuiteWithScenarios(feature, moduleId)
+
+  return {
+    mergedTestSuites: result.createdTestSuite ? 1 : 0,
+    addedScenarios: result.addedScenarios,
+  }
+}

package/templates/starter/src/lib/environment-file-utils.ts

@@ -13,16 +13,16 @@ interface EnvironmentConfig {
 
 const EMPTY_ENVIRONMENTS_FILE_CONTENT = '{}\n'
 
-export function getEnvironmentsFilePath(): string {
+function getEnvironmentsFilePath(): string {
   return path.join(getAutomationEnvironmentsDir(), 'environments.json')
 }
 
-export async function ensureConfigDirectoryExists(): Promise<void> {
+async function ensureConfigDirectoryExists(): Promise<void> {
   await ensureAutomationWorkspaceReady()
   await fs.mkdir(path.dirname(getEnvironmentsFilePath()), { recursive: true })
 }
 
-export async function generateEnvironmentsContent(): Promise<Record<string, EnvironmentConfig>> {
+async function generateEnvironmentsContent(): Promise<Record<string, EnvironmentConfig>> {
   try {
     const environments = await prisma.environment.findMany({
       orderBy: { createdAt: 'asc' },
@@ -67,115 +67,3 @@ export async function createOrUpdateEnvironmentsFile(): Promise<boolean> {
     return false
   }
 }
-
-export async function deleteEnvironmentsFile(): Promise<boolean> {
-  try {
-    await ensureAutomationWorkspaceReady()
-    const filePath = getEnvironmentsFilePath()
-    await ensureConfigDirectoryExists()
-    await fs.writeFile(filePath, EMPTY_ENVIRONMENTS_FILE_CONTENT)
-    return true
-  } catch (error) {
-    console.error('Error deleting environments file:', error)
-    return false
-  }
-}
-
-export async function readEnvironmentsFile(): Promise<{
-  filePath: string
-  content: Record<string, EnvironmentConfig>
-} | null> {
-  try {
-    await ensureAutomationWorkspaceReady()
-    const filePath = getEnvironmentsFilePath()
-
-    try {
-      await fs.access(filePath)
-    } catch {
-      return null
-    }
-
-    const fileContent = await fs.readFile(filePath, 'utf-8')
-    const jsonContent = JSON.parse(fileContent)
-
-    return { filePath, content: jsonContent }
-  } catch (error) {
-    console.error('Error reading environments file:', error)
-    return null
-  }
-}
-
-export async function updateEnvironmentEntry(environmentId: string, oldName?: string): Promise<boolean> {
-  try {
-    await ensureAutomationWorkspaceReady()
-    const environment = await prisma.environment.findUnique({
-      where: { id: environmentId },
-    })
-
-    if (!environment) {
-      console.error(`Environment with ID ${environmentId} not found`)
-      return false
-    }
-
-    const filePath = getEnvironmentsFilePath()
-    let environmentsConfig: Record<string, EnvironmentConfig> = {}
-
-    try {
-      await fs.access(filePath)
-      const fileContent = await fs.readFile(filePath, 'utf-8')
-      environmentsConfig = JSON.parse(fileContent)
-    } catch {
-      environmentsConfig = {}
-    }
-
-    if (oldName) {
-      const oldKey = oldName.toLowerCase().replace(/\s+/g, '_')
-      delete environmentsConfig[oldKey]
-    }
-
-    const envKey = environment.name.toLowerCase().replace(/\s+/g, '_')
-    environmentsConfig[envKey] = {
-      baseUrl: environment.baseUrl,
-      apiBaseUrl: environment.apiBaseUrl || '',
-      email: environment.username || '',
-      password: environment.password || '',
-    }
-
-    await ensureConfigDirectoryExists()
-    await fs.writeFile(filePath, JSON.stringify(environmentsConfig, null, 2))
-    return true
-  } catch (error) {
-    console.error('Error updating environment entry:', error)
-    return false
-  }
-}
-
-export async function removeEnvironmentEntry(environmentName: string): Promise<boolean> {
-  try {
-    await ensureAutomationWorkspaceReady()
-    const filePath = getEnvironmentsFilePath()
-
-    try {
-      await fs.access(filePath)
-    } catch {
-      return true
-    }
-
-    const fileContent = await fs.readFile(filePath, 'utf-8')
-    const environmentsConfig: Record<string, EnvironmentConfig> = JSON.parse(fileContent)
-
-    const envKey = environmentName.toLowerCase().replace(/\s+/g, '_')
-    delete environmentsConfig[envKey]
-
-    if (Object.keys(environmentsConfig).length === 0) {
-      await deleteEnvironmentsFile()
-      return true
-    }
-
-    await fs.writeFile(filePath, JSON.stringify(environmentsConfig, null, 2))
-    return true
-  } catch (error) {
-    console.error('Error removing environment entry:', error)
-    return false
-  }
-}

package/templates/starter/src/lib/executor/local-executor-adapter.ts

@@ -25,7 +25,7 @@ function generateReportPath(testRunId: string): string {
   return getAutomationRunReportPath(testRunId)
 }
 
-export class LocalExecutorAdapter implements ExecutorAdapter {
+class LocalExecutorAdapter implements ExecutorAdapter {
   async executeTestRun(config: TestRunExecutionRequest): Promise<TestRunExecutionResult> {
     await ensureAutomationWorkspaceReady()
 

package/templates/starter/src/lib/form/tanstack-form-action.ts

@@ -0,0 +1,7 @@
+type TanStackFormSubmitHandler = () => unknown | Promise<unknown>
+
+export function getTanStackFormAction(handleSubmit: TanStackFormSubmitHandler) {
+  return () => {
+    void handleSubmit()
+  }
+}

package/templates/starter/src/lib/form/tanstack-form.tsx

@@ -0,0 +1,18 @@
+'use client'
+
+import type { FormHTMLAttributes, ReactNode } from 'react'
+
+import { getTanStackFormAction } from './tanstack-form-action'
+
+type TanStackFormProps = Omit<FormHTMLAttributes<HTMLFormElement>, 'action' | 'onSubmit'> & {
+  onSubmit: () => unknown | Promise<unknown>
+  children: ReactNode
+}
+
+export function TanStackForm({ onSubmit, children, ...props }: TanStackFormProps) {
+  return (
+    <form action={getTanStackFormAction(onSubmit)} {...props}>
+      {children}
+    </form>
+  )
+}

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

@@ -1,8 +1,8 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
 import { promises as fs } from 'fs'
 import { join } from 'path'
 import { tmpdir } from 'os'
+import { expect, test } from 'vitest'
+
 import { parseFeatureFile } from '@/lib/gherkin-parser'
 
 async function withTempFeatureFile(content: string): Promise<string> {
@@ -23,9 +23,9 @@ Scenario: logs in
 
   const parsed = await parseFeatureFile(filePath)
 
-  assert.ok(parsed)
-  assert.equal(parsed?.featureName, 'Login workflow')
-  assert.equal(parsed?.featureDescription, 'Login workflow')
+  expect(parsed).not.toBeNull()
+  expect(parsed?.featureName).toBe('Login workflow')
+  expect(parsed?.featureDescription).toBe('Login workflow')
 })
 
 test('keeps Feature line as description even when free text follows', async () => {
@@ -39,6 +39,6 @@ Scenario: buys item
 
   const parsed = await parseFeatureFile(filePath)
 
-  assert.ok(parsed)
-  assert.equal(parsed?.featureDescription, 'Checkout flow')
+  expect(parsed).not.toBeNull()
+  expect(parsed?.featureDescription).toBe('Checkout flow')
 })