create-appraisejs 0.1.9 → 0.1.10-alpha.1

package/templates/default/scripts/sync-template-step-groups.ts

@@ -49,13 +49,21 @@ interface SyncResult {
 function parseGroupJSDoc(content: string): StepGroupJSDoc | null {
   const lines = content.split('\n')
 
-  // Look for JSDoc comment at the very top of the file
   if (lines.length === 0) {
     return null
   }
 
-  const firstLine = lines[0].trim()
-  if (!firstLine.startsWith('/**')) {
+  let startLine = 0
+  while (startLine < lines.length) {
+    const line = lines[startLine].trim()
+    if (line === '' || line.startsWith('import ')) {
+      startLine++
+      continue
+    }
+    break
+  }
+
+  if (startLine >= lines.length || !lines[startLine].trim().startsWith('/**')) {
     return null
   }
 
@@ -68,8 +76,8 @@ function parseGroupJSDoc(content: string): StepGroupJSDoc | null {
 
   // Look through the JSDoc block until we find the closing */
   // Use a reasonable limit (50 lines) to avoid parsing entire files if JSDoc is malformed
-  const maxLines = Math.min(lines.length, 50)
-  for (let i = 0; i < maxLines; i++) {
+  const maxLines = Math.min(lines.length, startLine + 50)
+  for (let i = startLine; i < maxLines; i++) {
     const line = lines[i].trim()
 
     // Check if this line contains the closing */ (could be on same line as content)
@@ -148,7 +156,7 @@ async function scanStepFiles(baseDir: string): Promise<string[]> {
 
   try {
     // Get all .step.ts files in actions and validations directories
-    const patterns = ['src/tests/steps/actions/**/*.step.ts', 'src/tests/steps/validations/**/*.step.ts']
+    const patterns = ['automation/steps/actions/**/*.step.ts', 'automation/steps/validations/**/*.step.ts']
 
     for (const pattern of patterns) {
       const files = await glob(pattern, {
@@ -397,3 +405,5 @@ async function main() {
 }
 
 main()
+
+

package/templates/default/scripts/sync-template-steps.ts

@@ -77,8 +77,17 @@ function parseGroupJSDoc(content: string): StepGroupJSDoc | null {
     return null
   }
 
-  const firstLine = lines[0].trim()
-  if (!firstLine.startsWith('/**')) {
+  let startLine = 0
+  while (startLine < lines.length) {
+    const line = lines[startLine].trim()
+    if (line === '' || line.startsWith('import ')) {
+      startLine++
+      continue
+    }
+    break
+  }
+
+  if (startLine >= lines.length || !lines[startLine].trim().startsWith('/**')) {
     return null
   }
 
@@ -88,8 +97,8 @@ function parseGroupJSDoc(content: string): StepGroupJSDoc | null {
   let description: string | null = null
   let type: string | null = null
 
-  const maxLines = Math.min(lines.length, 50)
-  for (let i = 0; i < maxLines; i++) {
+  const maxLines = Math.min(lines.length, startLine + 50)
+  for (let i = startLine; i < maxLines; i++) {
     const line = lines[i].trim()
 
     if (line.includes('*/')) {
@@ -455,7 +464,7 @@ function parseStepFile(content: string, filePath: string): StepData | null {
  * Scans step definition files
  */
 async function scanStepFiles(baseDir: string): Promise<string[]> {
-  const patterns = ['src/tests/steps/actions/**/*.step.ts', 'src/tests/steps/validations/**/*.step.ts']
+  const patterns = ['automation/steps/actions/**/*.step.ts', 'automation/steps/validations/**/*.step.ts']
   const stepFiles: string[] = []
 
   for (const pattern of patterns) {
@@ -804,3 +813,5 @@ async function main() {
 }
 
 main()
+
+

package/templates/default/scripts/sync-test-cases.ts

@@ -9,7 +9,6 @@
  * Usage: npx tsx scripts/sync-test-cases.ts
  */
 
-import { join } from 'path'
 import prisma from '../src/config/db-config'
 import {
   scanFeatureFiles,
@@ -18,6 +17,7 @@ import {
 } from '../src/lib/gherkin-parser'
 import { buildModuleHierarchy, findModuleByPath } from '../src/lib/module-hierarchy-builder'
 import { TemplateStepType, TemplateStepIcon, StepParameterType, TagType } from '@prisma/client'
+import { ensureAutomationWorkspaceReady, getAutomationFeaturesDir } from '../src/lib/automation/paths'
 
 interface TestCaseFromFS {
   identifierTag: string // @tc_... tag
@@ -852,8 +852,8 @@ async function main() {
     console.log('This will scan feature files and sync test cases to database.')
     console.log('Filesystem is the source of truth - test cases in DB but not in FS will be deleted.\n')
 
-    const baseDir = process.cwd()
-    const featuresDir = join(baseDir, 'src', 'tests', 'features')
+    await ensureAutomationWorkspaceReady()
+    const featuresDir = getAutomationFeaturesDir()
 
     // Scan test cases from filesystem
     const testCasesFromFS = await scanTestCasesFromFilesystem(featuresDir)
@@ -903,3 +903,6 @@ async function main() {
 }
 
 main()
+
+
+

package/templates/default/scripts/sync-test-suites.ts

@@ -9,10 +9,10 @@
  * Usage: npx tsx scripts/sync-test-suites.ts
  */
 
-import { join } from 'path'
 import prisma from '../src/config/db-config'
 import { scanFeatureFiles, extractModulePathFromFilePath, ParsedFeature } from '../src/lib/gherkin-parser'
 import { buildModuleHierarchy, findModuleByPath, getAllModulesWithPaths } from '../src/lib/module-hierarchy-builder'
+import { ensureAutomationWorkspaceReady, getAutomationFeaturesDir } from '../src/lib/automation/paths'
 
 interface TestSuiteFromFS {
   name: string // From filename (without .feature extension)
@@ -358,9 +358,9 @@ async function main() {
     console.log('This will scan feature files and sync test suites to database.')
     console.log('Filesystem is the source of truth - test suites in DB but not in FS will be deleted.')
     console.log('Note: Test cases are not synced by this script (they will be handled separately).\n')
-    
-    const baseDir = process.cwd()
-    const featuresDir = join(baseDir, 'src', 'tests', 'features')
+
+    await ensureAutomationWorkspaceReady()
+    const featuresDir = getAutomationFeaturesDir()
     
     // Scan test suites from filesystem
     const testSuitesFromFS = await scanTestSuitesFromFilesystem(featuresDir)
@@ -409,3 +409,6 @@ async function main() {
 }
 
 main()
+
+
+

package/templates/default/src/actions/environments/environment-actions.ts

@@ -2,18 +2,15 @@
 
 import prisma from '@/config/db-config'
 import { environmentSchema } from '@/constants/form-opts/environment-form-opts'
+import { automationProjectionService } from '@/lib/automation/projection-service'
 import { ActionResponse } from '@/types/form/actionHandler'
 import { revalidatePath } from 'next/cache'
 import { z } from 'zod'
-import { createOrUpdateEnvironmentsFile, updateEnvironmentEntry } from '@/lib/environment-file-utils'
 
-/**
- * Check if an environment name already exists
- */
 async function checkUniqueName(name: string, excludeId?: string): Promise<boolean> {
   const existing = await prisma.environment.findFirst({
     where: {
-      name: name,
+      name,
       ...(excludeId && { id: { not: excludeId } }),
     },
   })
@@ -28,8 +25,7 @@ export async function getAllEnvironmentsAction(): Promise<ActionResponse> {
       },
     })
 
-    // Update the environments.json file
-    await createOrUpdateEnvironmentsFile()
+    await automationProjectionService.syncEnvironments()
 
     return {
       status: 200,
@@ -51,8 +47,7 @@ export async function deleteEnvironmentAction(ids: string[]): Promise<ActionResp
       },
     })
 
-    // Update the environments.json file
-    await createOrUpdateEnvironmentsFile()
+    await automationProjectionService.syncEnvironments()
 
     revalidatePath('/environments')
     return {
@@ -74,7 +69,6 @@ export async function createEnvironmentAction(
   try {
     environmentSchema.parse(value)
 
-    // Check if name already exists
     const nameExists = await checkUniqueName(value.name)
     if (nameExists) {
       return {
@@ -83,7 +77,6 @@ export async function createEnvironmentAction(
       }
     }
 
-    // Convert empty strings to null for optional fields
     const environmentData = {
       ...value,
       apiBaseUrl: value.apiBaseUrl === '' ? null : value.apiBaseUrl,
@@ -95,8 +88,7 @@ export async function createEnvironmentAction(
       data: environmentData,
     })
 
-    // Update the environments.json file
-    await createOrUpdateEnvironmentsFile()
+    await automationProjectionService.syncEnvironments()
 
     revalidatePath('/environments')
     return {
@@ -137,13 +129,11 @@ export async function updateEnvironmentAction(
   try {
     environmentSchema.parse(value)
 
-    // Get the current environment to check if name changed
     const currentEnvironment = await prisma.environment.findUnique({
       where: { id },
       select: { name: true },
     })
 
-    // Check if name is being changed and if the new name already exists
     if (currentEnvironment?.name !== value.name) {
       const nameExists = await checkUniqueName(value.name, id)
       if (nameExists) {
@@ -154,7 +144,6 @@ export async function updateEnvironmentAction(
       }
     }
 
-    // Convert empty strings to null for optional fields
     const environmentData = {
       ...value,
       apiBaseUrl: value.apiBaseUrl === '' ? null : value.apiBaseUrl,
@@ -167,10 +156,7 @@ export async function updateEnvironmentAction(
       data: environmentData,
     })
 
-    // Update the environments.json file
-    // If name changed, we need to remove the old entry and add the new one
-    const oldName = currentEnvironment?.name !== value.name ? currentEnvironment?.name : undefined
-    await updateEnvironmentEntry(id!, oldName)
+    await automationProjectionService.syncEnvironments()
 
     revalidatePath('/environments')
     return {
@@ -186,9 +172,6 @@ export async function updateEnvironmentAction(
   }
 }
 
-/**
- * Check if an environment name is unique
- */
 export async function checkEnvironmentNameUniqueAction(name: string, excludeId?: string): Promise<ActionResponse> {
   try {
     const nameExists = await checkUniqueName(name, excludeId)

package/templates/default/src/actions/locator/locator-actions.ts

@@ -2,21 +2,24 @@
 
 import prisma from '@/config/db-config'
 import { locatorSchema } from '@/constants/form-opts/locator-form-opts'
+import { automationProjectionService } from '@/lib/automation/projection-service'
+import { getAutomationLocatorsDir } from '@/lib/automation/paths'
+import { getLocatorGroupFilePath } from '@/lib/locator-group-file-utils'
+import { buildModuleHierarchy } from '@/lib/module-hierarchy-builder'
 import { ActionResponse } from '@/types/form/actionHandler'
 import { revalidatePath } from 'next/cache'
 import { z } from 'zod'
-import { createOrUpdateLocatorGroupFile, getLocatorGroupFilePath } from '@/lib/locator-group-file-utils'
 import { promises as fs } from 'fs'
 import path from 'path'
 import { glob } from 'glob'
-import { buildModuleHierarchy } from '@/lib/module-hierarchy-builder'
 
-// Helper function to update locator group JSON file when locators change
 async function updateLocatorGroupFile(locatorGroupId: string | null): Promise<void> {
-  if (!locatorGroupId) return
+  if (!locatorGroupId) {
+    return
+  }
 
   try {
-    await createOrUpdateLocatorGroupFile(locatorGroupId)
+    await automationProjectionService.syncLocatorGroup(locatorGroupId)
   } catch (error) {
     console.error('Error updating locator group file:', error)
   }
@@ -52,20 +55,18 @@ export async function getAllLocatorsAction(): Promise<ActionResponse> {
 
 export async function deleteLocatorAction(ids: string[]): Promise<ActionResponse> {
   try {
-    // Get locator group IDs before deletion to update files
     const locatorsToDelete = await prisma.locator.findMany({
       where: { id: { in: ids } },
       select: { locatorGroupId: true },
     })
 
-    const locatorGroupIds = [...new Set(locatorsToDelete.map(l => l.locatorGroupId).filter(Boolean))]
+    const locatorGroupIds = [...new Set(locatorsToDelete.map(locator => locator.locatorGroupId).filter(Boolean))]
 
     const locator = await prisma.locator.deleteMany({
       where: { id: { in: ids } },
     })
 
-    // Update JSON files for affected locator groups in parallel
-    await Promise.all(locatorGroupIds.filter(Boolean).map(groupId => updateLocatorGroupFile(groupId)))
+    await Promise.all(locatorGroupIds.map(groupId => updateLocatorGroupFile(groupId)))
 
     revalidatePath('/locators')
     return {
@@ -102,7 +103,6 @@ export async function createLocatorAction(
       },
     })
 
-    // Update the locator group JSON file
     if (value.locatorGroupId) {
       await updateLocatorGroupFile(value.locatorGroupId)
     }
@@ -113,10 +113,10 @@ export async function createLocatorAction(
       data: newLocator,
       message: 'Locator created successfully',
     }
-  } catch (e) {
+  } catch (error) {
     return {
       status: 500,
-      error: `Server error occurred: ${e}`,
+      error: `Server error occurred: ${error}`,
     }
   }
 }
@@ -127,7 +127,6 @@ export async function updateLocatorAction(
   id?: string,
 ): Promise<ActionResponse> {
   try {
-    // Get the current locator to check if locatorGroupId changed
     const currentLocator = await prisma.locator.findUnique({
       where: { id },
       select: { locatorGroupId: true },
@@ -149,11 +148,9 @@ export async function updateLocatorAction(
       },
     })
 
-    // Update JSON files for affected locator groups
     const groupsToUpdate = new Set<string>()
 
     if (currentLocator?.locatorGroupId !== value.locatorGroupId) {
-      // Group changed - update both old and new groups
       if (currentLocator?.locatorGroupId) {
         groupsToUpdate.add(currentLocator.locatorGroupId)
       }
@@ -161,11 +158,9 @@ export async function updateLocatorAction(
         groupsToUpdate.add(value.locatorGroupId)
       }
     } else if (value.locatorGroupId) {
-      // Same group - just update the current group
       groupsToUpdate.add(value.locatorGroupId)
     }
 
-    // Update all affected groups in parallel
     await Promise.all(Array.from(groupsToUpdate).map(groupId => updateLocatorGroupFile(groupId)))
 
     revalidatePath('/locators')
@@ -174,10 +169,10 @@ export async function updateLocatorAction(
       data: updatedLocator,
       message: 'Locator updated successfully',
     }
-  } catch (e) {
+  } catch (error) {
     return {
       status: 500,
-      error: `Server error occurred: ${e}`,
+      error: `Server error occurred: ${error}`,
     }
   }
 }
@@ -198,10 +193,10 @@ export async function getLocatorByIdAction(id: string): Promise<ActionResponse>
       status: 200,
       data: locator,
     }
-  } catch (e) {
+  } catch (error) {
     return {
       status: 500,
-      error: `Server error occurred: ${e}`,
+      error: `Server error occurred: ${error}`,
     }
   }
 }
@@ -230,29 +225,18 @@ export async function getUngroupedLocatorsAction(): Promise<ActionResponse> {
   }
 }
 
-/**
- * Extracts module path from locator file path
- */
 function extractModulePathFromLocatorFile(filePath: string): string {
-  const testsDir = path.join(process.cwd(), 'src', 'tests')
-  const relativePath = path.relative(testsDir, filePath)
-  const pathParts = relativePath.split(/[/\\]/).filter(p => p && p !== 'locators')
-  const moduleParts = pathParts.slice(0, -1) // Remove filename
-  return moduleParts.length > 0 ? '/' + moduleParts.join('/') : '/'
+  const locatorsDir = getAutomationLocatorsDir()
+  const relativePath = path.relative(locatorsDir, filePath)
+  const pathParts = relativePath.split(/[/\\]/).filter(part => part)
+  const moduleParts = pathParts.slice(0, -1)
+  return moduleParts.length > 0 ? `/${moduleParts.join('/')}` : '/'
 }
 
-/**
- * Extracts locator group name from file path
- * The group name is just the filename without extension
- */
 function extractLocatorGroupName(filePath: string): string {
-  const fileName = path.basename(filePath, '.json')
-  return fileName
+  return path.basename(filePath, '.json')
 }
 
-/**
- * Detects and creates conflict resolution entries for locators
- */
 async function detectAndCreateConflicts(
   locatorId: string,
   locatorName: string,
@@ -261,7 +245,6 @@ async function detectAndCreateConflicts(
 ): Promise<number> {
   let conflictCount = 0
 
-  // Find existing locators in the same group
   const existingLocators = await prisma.locator.findMany({
     where: {
       locatorGroupId,
@@ -270,9 +253,7 @@ async function detectAndCreateConflicts(
   })
 
   for (const existingLocator of existingLocators) {
-    // Check for duplicate name conflict
     if (existingLocator.name === locatorName) {
-      // Check if conflict already exists for this locator
       const existingConflict = await prisma.conflictResolution.findFirst({
         where: {
           entityType: 'LOCATOR',
@@ -284,7 +265,6 @@ async function detectAndCreateConflicts(
       })
 
       if (!existingConflict) {
-        // Create conflict for both locators
         await prisma.conflictResolution.create({
           data: {
             entityType: 'LOCATOR',
@@ -305,10 +285,7 @@ async function detectAndCreateConflicts(
         })
         conflictCount++
       }
-    }
-    // Check for duplicate value conflict (different name)
-    else if (existingLocator.value === locatorValue && existingLocator.name !== locatorName) {
-      // Check if conflict already exists for this locator
+    } else if (existingLocator.value === locatorValue && existingLocator.name !== locatorName) {
       const existingConflict = await prisma.conflictResolution.findFirst({
         where: {
           entityType: 'LOCATOR',
@@ -320,7 +297,6 @@ async function detectAndCreateConflicts(
       })
 
       if (!existingConflict) {
-        // Create conflict for both locators
         await prisma.conflictResolution.create({
           data: {
             entityType: 'LOCATOR',
@@ -347,18 +323,12 @@ async function detectAndCreateConflicts(
   return conflictCount
 }
 
-/**
- * Syncs locators from JSON files to database
- */
 export async function syncLocatorsFromFilesAction(): Promise<ActionResponse> {
   try {
-    // Use relative pattern with forward slashes for cross-platform compatibility
-    // glob library requires forward slashes in patterns on all platforms
-    const pattern = 'src/tests/locators/**/*.json'
+    const pattern = 'automation/locators/**/*.json'
     const relativeFiles = await glob(pattern, {
       cwd: process.cwd(),
     })
-    // Resolve to absolute paths for file operations
     const files = relativeFiles.map(file => path.resolve(process.cwd(), file))
 
     let synced = 0
@@ -368,20 +338,17 @@ export async function syncLocatorsFromFilesAction(): Promise<ActionResponse> {
 
     for (const filePath of files) {
       try {
-        // Read locator file
         const content = await fs.readFile(filePath, 'utf-8')
         const locators = JSON.parse(content) as Record<string, string>
 
-        // Extract module path and group name
         const modulePath = extractModulePathFromLocatorFile(filePath)
         const moduleId = await buildModuleHierarchy(modulePath)
         const groupName = extractLocatorGroupName(filePath)
 
-        // Find or create locator group
         let locatorGroup = await prisma.locatorGroup.findFirst({
           where: {
             name: groupName,
-            moduleId: moduleId,
+            moduleId,
           },
         })
 
@@ -390,17 +357,14 @@ export async function syncLocatorsFromFilesAction(): Promise<ActionResponse> {
             data: {
               name: groupName,
               route: `/${groupName}`,
-              moduleId: moduleId,
+              moduleId,
             },
           })
         }
 
-        // Track this locator group as affected
         affectedLocatorGroupIds.add(locatorGroup.id)
 
-        // Sync locators FROM FILE TO DATABASE
         for (const [locatorName, locatorValue] of Object.entries(locators)) {
-          // Check if locator already exists
           const existingLocator = await prisma.locator.findFirst({
             where: {
               name: locatorName,
@@ -411,7 +375,6 @@ export async function syncLocatorsFromFilesAction(): Promise<ActionResponse> {
           let locatorId: string
 
           if (existingLocator) {
-            // Update existing locator value if different (file takes precedence)
             if (existingLocator.value !== locatorValue) {
               await prisma.locator.update({
                 where: { id: existingLocator.id },
@@ -420,7 +383,6 @@ export async function syncLocatorsFromFilesAction(): Promise<ActionResponse> {
             }
             locatorId = existingLocator.id
           } else {
-            // Create new locator from file
             const newLocator = await prisma.locator.create({
               data: {
                 name: locatorName,
@@ -432,29 +394,22 @@ export async function syncLocatorsFromFilesAction(): Promise<ActionResponse> {
             synced++
           }
 
-          // Detect and create conflicts
-          const conflictCount = await detectAndCreateConflicts(locatorId, locatorName, locatorValue, locatorGroup.id)
-          totalConflicts += conflictCount
+          totalConflicts += await detectAndCreateConflicts(locatorId, locatorName, locatorValue, locatorGroup.id)
         }
 
-        // Sync locators FROM DATABASE TO FILE (bidirectional sync)
-        // Get all locators from database for this group
         const dbLocators = await prisma.locator.findMany({
           where: { locatorGroupId: locatorGroup.id },
           select: { name: true, value: true },
         })
 
-        // Merge: file values take precedence, but add DB locators that aren't in file
         const mergedLocators: Record<string, string> = { ...locators }
         for (const dbLocator of dbLocators) {
-          // Only add if not already in file (file values take precedence)
           if (!(dbLocator.name in mergedLocators)) {
             mergedLocators[dbLocator.name] = dbLocator.value
             synced++
           }
         }
 
-        // Write merged content back to file
         await fs.writeFile(filePath, JSON.stringify(mergedLocators, null, 2) + '\n', 'utf-8')
       } catch (error) {
         const errorMessage = `Error syncing locator file ${filePath}: ${error}`
@@ -463,57 +418,45 @@ export async function syncLocatorsFromFilesAction(): Promise<ActionResponse> {
       }
     }
 
-    // Handle locator groups that exist in DB but don't have files yet
-    // Create files for these groups with their DB locators
     try {
       const allLocatorGroups = await prisma.locatorGroup.findMany({
         include: {
           locators: {
             select: { name: true, value: true },
           },
-          module: true,
         },
       })
 
       for (const locatorGroup of allLocatorGroups) {
-        // Skip if we already processed this group (it has a file)
         if (affectedLocatorGroupIds.has(locatorGroup.id)) {
           continue
         }
 
         try {
-          // Get the file path for this locator group
-          const relativeFilePath = await getLocatorGroupFilePath(locatorGroup.id)
-          if (!relativeFilePath) {
-            // If we can't determine the path, skip this group
+          const filePath = await getLocatorGroupFilePath(locatorGroup.id)
+          if (!filePath) {
             continue
           }
 
-          const fullPath = path.join(process.cwd(), relativeFilePath)
-
-          // Check if file exists
           try {
-            await fs.access(fullPath)
-            // File exists, merge DB locators into it
-            const fileContent = await fs.readFile(fullPath, 'utf-8')
+            await fs.access(filePath)
+            const fileContent = await fs.readFile(filePath, 'utf-8')
             const fileLocators = JSON.parse(fileContent) as Record<string, string>
-
-            // Merge: file values take precedence, but add DB locators that aren't in file
             const mergedLocators: Record<string, string> = { ...fileLocators }
+
             for (const dbLocator of locatorGroup.locators) {
               if (!(dbLocator.name in mergedLocators)) {
                 mergedLocators[dbLocator.name] = dbLocator.value
               }
             }
 
-            await fs.writeFile(fullPath, JSON.stringify(mergedLocators, null, 2) + '\n', 'utf-8')
+            await fs.writeFile(filePath, JSON.stringify(mergedLocators, null, 2) + '\n', 'utf-8')
           } catch {
-            // File doesn't exist, create it with DB locators
-            await fs.mkdir(path.dirname(fullPath), { recursive: true })
+            await fs.mkdir(path.dirname(filePath), { recursive: true })
             const dbLocators: Record<string, string> = Object.fromEntries(
-              locatorGroup.locators.map(loc => [loc.name, loc.value]),
+              locatorGroup.locators.map(locator => [locator.name, locator.value]),
             )
-            await fs.writeFile(fullPath, JSON.stringify(dbLocators, null, 2) + '\n', 'utf-8')
+            await fs.writeFile(filePath, JSON.stringify(dbLocators, null, 2) + '\n', 'utf-8')
           }
         } catch (error) {
           const errorMessage = `Error syncing locator group ${locatorGroup.id} to file: ${error}`