create-appraisejs 0.1.9 → 0.1.10-alpha.0

package/templates/default/src/components/ui/data-table.tsx

@@ -127,7 +127,7 @@ export function DataTable<TData, TValue>({
       <div className="flex justify-end">
         <div className="mb-4 flex gap-2">
           {createLink && (
-            <Button variant="default" size="icon">
+            <Button variant="default" size="icon" asChild>
               <Link href={createLink}>
                 <PlusCircle className="h-4 w-4" />
               </Link>
@@ -154,46 +154,40 @@ export function DataTable<TData, TValue>({
             </DropdownMenu>
           )}
           {modifyLink && (
-            <Button
-              variant="outline"
-              size="icon"
-              disabled={table.getSelectedRowModel().rows.length === 0 || table.getSelectedRowModel().rows.length > 1}
-            >
-              <Link
-                href={`${modifyLink}/${
-                  table.getSelectedRowModel().rows.length > 0
-                    ? (
-                        table.getSelectedRowModel().rows[0].original as {
-                          id: string
-                        }
-                      ).id
-                    : ''
-                }`}
-              >
-                <Pencil className="h-4 w-4" />
-              </Link>
-            </Button>
+            (() => {
+              const disabled =
+                table.getSelectedRowModel().rows.length === 0 || table.getSelectedRowModel().rows.length > 1
+              const href = `${modifyLink}/${disabled ? '' : (table.getSelectedRowModel().rows[0].original as { id: string }).id}`
+              return disabled ? (
+                <Button variant="outline" size="icon" disabled>
+                  <Pencil className="h-4 w-4" />
+                </Button>
+              ) : (
+                <Button variant="outline" size="icon" asChild>
+                  <Link href={href}>
+                    <Pencil className="h-4 w-4" />
+                  </Link>
+                </Button>
+              )
+            })()
           )}
           {viewLink && (
-            <Button
-              variant="outline"
-              size="icon"
-              disabled={table.getSelectedRowModel().rows.length === 0 || table.getSelectedRowModel().rows.length > 1}
-            >
-              <Link
-                href={`${viewLink}/${
-                  table.getSelectedRowModel().rows.length > 0
-                    ? (
-                        table.getSelectedRowModel().rows[0].original as {
-                          id: string
-                        }
-                      ).id
-                    : ''
-                }`}
-              >
-                <Eye className="h-4 w-4" />
-              </Link>
-            </Button>
+            (() => {
+              const disabled =
+                table.getSelectedRowModel().rows.length === 0 || table.getSelectedRowModel().rows.length > 1
+              const href = `${viewLink}/${disabled ? '' : (table.getSelectedRowModel().rows[0].original as { id: string }).id}`
+              return disabled ? (
+                <Button variant="outline" size="icon" disabled>
+                  <Eye className="h-4 w-4" />
+                </Button>
+              ) : (
+                <Button variant="outline" size="icon" asChild>
+                  <Link href={href}>
+                    <Eye className="h-4 w-4" />
+                  </Link>
+                </Button>
+              )
+            })()
           )}
           {deleteAction && (
             <DeletePrompt

package/templates/default/src/lib/automation/paths.ts

@@ -0,0 +1,181 @@
+import { promises as fs } from 'fs'
+import path from 'path'
+
+const repoRoot = process.cwd()
+const automationRoot = path.join(repoRoot, 'automation')
+const legacyTestsRoot = path.join(repoRoot, 'src', 'tests')
+const runtimeImport =
+  "import { When, Then, CustomWorld, expect, SelectorName, resolveLocator, getEnvironment, generateRandomData, RandomDataType } from '../../../packages/cucumber-runtime/src/index.js'"
+
+const mutableLegacyDirectories = ['features', 'locators', 'mapping', 'reports', 'steps'] as const
+
+let automationWorkspaceReadyPromise: Promise<void> | null = null
+
+async function pathExists(targetPath: string): Promise<boolean> {
+  try {
+    await fs.access(targetPath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function rewriteLegacyStepImports(): Promise<void> {
+  const stepsDir = getAutomationStepsDir()
+
+  if (!(await pathExists(stepsDir))) {
+    return
+  }
+
+  const stepFiles = await fs.readdir(stepsDir, { recursive: true })
+  for (const entry of stepFiles) {
+    if (typeof entry !== 'string' || !entry.endsWith('.ts')) {
+      continue
+    }
+
+    const filePath = path.join(stepsDir, entry)
+    let content = await fs.readFile(filePath, 'utf8')
+
+    content = content
+      .replace(/^import \{ (When|Then) \} from '@cucumber\/cucumber';?\r?\n/gm, '')
+      .replace(/^import \{ CustomWorld(?:, expect)? \} from '\.\.\/\.\.\/config\/executor\/world\.js';?\r?\n/gm, '')
+      .replace(/^import \{ SelectorName \} from '(?:@\/types\/locator\/locator\.type|\.\.\/\.\.\/\.\.\/types\/locator\/locator\.type)';?\r?\n/gm, '')
+      .replace(/^import \{ resolveLocator \} from '\.\.\/\.\.\/utils\/locator\.util\.js';?\r?\n/gm, '')
+      .replace(/^import \{ getEnvironment \} from '\.\.\/\.\.\/utils\/environment\.util\.js';?\r?\n/gm, '')
+      .replace(/^import \{ generateRandomData, RandomDataType \} from '\.\.\/\.\.\/utils\/random-data\.util\.js';?\r?\n/gm, '')
+      .trimStart()
+
+    if (!content.startsWith(runtimeImport)) {
+      content = `${runtimeImport}\n${content}`
+    }
+
+    await fs.writeFile(filePath, content)
+  }
+}
+
+async function copyLegacyMutableWorkspace(): Promise<void> {
+  const legacyExists = await pathExists(legacyTestsRoot)
+  const automationExists = await pathExists(automationRoot)
+
+  if (!legacyExists || automationExists) {
+    return
+  }
+
+  await fs.mkdir(automationRoot, { recursive: true })
+
+  const legacyEnvironmentsDir = path.join(legacyTestsRoot, 'config', 'environments')
+  if (await pathExists(legacyEnvironmentsDir)) {
+    await fs.cp(legacyEnvironmentsDir, getAutomationEnvironmentsDir(), { recursive: true })
+  }
+
+  for (const directory of mutableLegacyDirectories) {
+    const sourceDirectory = path.join(legacyTestsRoot, directory)
+    const destinationDirectory = path.join(automationRoot, directory)
+
+    if (await pathExists(sourceDirectory)) {
+      await fs.cp(sourceDirectory, destinationDirectory, { recursive: true })
+    }
+  }
+}
+
+async function copyLegacyEnvironmentsIfNeeded(): Promise<void> {
+  const legacyEnvironmentsDir = path.join(legacyTestsRoot, 'config', 'environments')
+  const automationEnvironmentsFile = path.join(getAutomationEnvironmentsDir(), 'environments.json')
+
+  if (!(await pathExists(legacyEnvironmentsDir)) || (await pathExists(automationEnvironmentsFile))) {
+    return
+  }
+
+  await fs.mkdir(getAutomationEnvironmentsDir(), { recursive: true })
+  await fs.cp(legacyEnvironmentsDir, getAutomationEnvironmentsDir(), { recursive: true })
+}
+
+async function ensureMutableAutomationDirectories(): Promise<void> {
+  const requiredDirectories = [
+    getAutomationRoot(),
+    getAutomationConfigDir(),
+    getAutomationEnvironmentsDir(),
+    getAutomationFeaturesDir(),
+    getAutomationLocatorsDir(),
+    getAutomationMappingDir(),
+    getAutomationReportsDir(),
+    getAutomationReportLogsDir(),
+    getAutomationReportTracesDir(),
+    getAutomationStepsDir(),
+    getAutomationActionStepsDir(),
+    getAutomationValidationStepsDir(),
+  ]
+
+  await Promise.all(requiredDirectories.map(directory => fs.mkdir(directory, { recursive: true })))
+}
+
+async function removeLegacyRuntimeArtifactsFromAutomation(): Promise<void> {
+  await fs.rm(path.join(getAutomationConfigDir(), 'executor'), { recursive: true, force: true })
+  await fs.rm(path.join(getAutomationRoot(), 'hooks'), { recursive: true, force: true })
+  await fs.rm(path.join(getAutomationRoot(), 'support'), { recursive: true, force: true })
+  await fs.rm(path.join(getAutomationRoot(), 'utils'), { recursive: true, force: true })
+}
+
+export async function ensureAutomationWorkspaceReady(): Promise<void> {
+  automationWorkspaceReadyPromise ??= (async () => {
+    await copyLegacyMutableWorkspace()
+    await copyLegacyEnvironmentsIfNeeded()
+    await ensureMutableAutomationDirectories()
+    await removeLegacyRuntimeArtifactsFromAutomation()
+    await rewriteLegacyStepImports()
+  })()
+
+  return automationWorkspaceReadyPromise
+}
+
+export function getAutomationRoot(): string {
+  return automationRoot
+}
+
+export function getLegacyTestsRoot(): string {
+  return legacyTestsRoot
+}
+
+export function getAutomationConfigDir(): string {
+  return path.join(getAutomationRoot(), 'config')
+}
+
+export function getAutomationEnvironmentsDir(): string {
+  return path.join(getAutomationConfigDir(), 'environments')
+}
+
+export function getAutomationFeaturesDir(): string {
+  return path.join(getAutomationRoot(), 'features')
+}
+
+export function getAutomationLocatorsDir(): string {
+  return path.join(getAutomationRoot(), 'locators')
+}
+
+export function getAutomationMappingDir(): string {
+  return path.join(getAutomationRoot(), 'mapping')
+}
+
+export function getAutomationReportsDir(): string {
+  return path.join(getAutomationRoot(), 'reports')
+}
+
+export function getAutomationReportLogsDir(): string {
+  return path.join(getAutomationReportsDir(), 'logs')
+}
+
+export function getAutomationReportTracesDir(): string {
+  return path.join(getAutomationReportsDir(), 'traces')
+}
+
+export function getAutomationStepsDir(): string {
+  return path.join(getAutomationRoot(), 'steps')
+}
+
+export function getAutomationActionStepsDir(): string {
+  return path.join(getAutomationStepsDir(), 'actions')
+}
+
+export function getAutomationValidationStepsDir(): string {
+  return path.join(getAutomationStepsDir(), 'validations')
+}

package/templates/default/src/lib/automation/projection-service.ts

@@ -0,0 +1,230 @@
+import prisma from '@/config/db-config'
+import { createOrUpdateEnvironmentsFile } from '@/lib/environment-file-utils'
+import {
+  createEmptyLocatorGroupFile,
+  createOrUpdateLocatorGroupFile,
+  deleteLocatorGroupFile,
+  moveLocatorGroupFile,
+  removeLocatorMapEntry,
+  renameLocatorGroupFile,
+  updateLocatorMapFile,
+} from '@/lib/locator-group-file-utils'
+import { deleteFeatureFile, generateFeatureFile, regenerateAllFeatureFiles } from '@/lib/feature-file-generator'
+import {
+  createTemplateStepGroupFile,
+  removeTemplateStepGroupFile,
+  renameTemplateStepGroupFile,
+} from '@/lib/utils/template-step-file-manager-intelligent'
+import { generateFileContent, writeTemplateStepFile } from '@/lib/utils/template-step-file-generator'
+import { ensureAutomationWorkspaceReady } from './paths'
+
+type TemplateStepGroupType = 'ACTION' | 'VALIDATION'
+
+function getTemplateStepGroupType(type: string | null | undefined): TemplateStepGroupType {
+  return type === 'VALIDATION' ? 'VALIDATION' : 'ACTION'
+}
+
+class AutomationProjectionService {
+  async syncEnvironments(): Promise<boolean> {
+    await ensureAutomationWorkspaceReady()
+    return createOrUpdateEnvironmentsFile()
+  }
+
+  async createEmptyLocatorGroup(locatorGroupId: string): Promise<boolean> {
+    await ensureAutomationWorkspaceReady()
+    return createEmptyLocatorGroupFile(locatorGroupId)
+  }
+
+  async syncLocatorGroup(locatorGroupId: string): Promise<boolean> {
+    await ensureAutomationWorkspaceReady()
+    return createOrUpdateLocatorGroupFile(locatorGroupId)
+  }
+
+  async renameLocatorGroup(locatorGroupId: string, newName: string, oldName?: string): Promise<boolean> {
+    await ensureAutomationWorkspaceReady()
+    return renameLocatorGroupFile(locatorGroupId, newName, oldName)
+  }
+
+  async moveLocatorGroup(locatorGroupId: string, previousFilePath?: string): Promise<boolean> {
+    await ensureAutomationWorkspaceReady()
+    return moveLocatorGroupFile(locatorGroupId, previousFilePath)
+  }
+
+  async deleteLocatorGroup(locatorGroupId: string): Promise<boolean> {
+    await ensureAutomationWorkspaceReady()
+    return deleteLocatorGroupFile(locatorGroupId)
+  }
+
+  async syncLocatorMap(
+    currentLocatorGroupRoute: string,
+    newLocatorGroupRoute: string,
+    currentLocatorGroupName: string,
+    newLocatorGroupName: string,
+  ): Promise<boolean>
+  async syncLocatorMap(newLocatorGroupName: string, newLocatorGroupRoute: string): Promise<boolean>
+  async syncLocatorMap(param1: string, param2: string, param3?: string, param4?: string): Promise<boolean> {
+    await ensureAutomationWorkspaceReady()
+    if (param3 === undefined || param4 === undefined) {
+      return updateLocatorMapFile(param1, param2)
+    }
+
+    return updateLocatorMapFile(param1, param2, param3, param4)
+  }
+
+  async deleteLocatorMapEntries(locatorGroupNames: string[]): Promise<boolean> {
+    await ensureAutomationWorkspaceReady()
+    return removeLocatorMapEntry(locatorGroupNames)
+  }
+
+  async syncTemplateStepGroup(groupId: string): Promise<void> {
+    await ensureAutomationWorkspaceReady()
+
+    const group = await prisma.templateStepGroup.findUnique({
+      where: { id: groupId },
+      include: {
+        templateSteps: {
+          orderBy: {
+            createdAt: 'asc',
+          },
+        },
+      },
+    })
+
+    if (!group) {
+      return
+    }
+
+    const groupType = getTemplateStepGroupType((group as { type?: string | null }).type)
+
+    if (group.templateSteps.length === 0) {
+      await createTemplateStepGroupFile(group.name, groupType, group.description)
+      return
+    }
+
+    const content = generateFileContent(group.templateSteps)
+    await writeTemplateStepFile(group.name, content, groupType)
+  }
+
+  async deleteTemplateStepGroup(groupId: string): Promise<void> {
+    await ensureAutomationWorkspaceReady()
+
+    const group = await prisma.templateStepGroup.findUnique({
+      where: { id: groupId },
+      select: {
+        name: true,
+        type: true,
+      },
+    })
+
+    if (!group) {
+      return
+    }
+
+    await removeTemplateStepGroupFile(group.name, getTemplateStepGroupType(group.type))
+  }
+
+  async renameTemplateStepGroup(
+    groupId: string,
+    newName: string,
+    newType: string,
+    newDescription?: string | null,
+  ): Promise<void> {
+    await ensureAutomationWorkspaceReady()
+
+    const currentGroup = await prisma.templateStepGroup.findUnique({
+      where: { id: groupId },
+      select: {
+        name: true,
+        type: true,
+      },
+    })
+
+    if (!currentGroup) {
+      return
+    }
+
+    await renameTemplateStepGroupFile(
+      currentGroup.name,
+      newName,
+      getTemplateStepGroupType(currentGroup.type),
+      getTemplateStepGroupType(newType),
+      newDescription,
+    )
+  }
+
+  async syncTemplateStep(stepId: string): Promise<void> {
+    const step = await prisma.templateStep.findUnique({
+      where: { id: stepId },
+      select: { templateStepGroupId: true },
+    })
+
+    if (!step?.templateStepGroupId) {
+      return
+    }
+
+    await this.syncTemplateStepGroup(step.templateStepGroupId)
+  }
+
+  async deleteTemplateStep(stepId: string): Promise<void> {
+    const step = await prisma.templateStep.findUnique({
+      where: { id: stepId },
+      select: { templateStepGroupId: true },
+    })
+
+    if (!step?.templateStepGroupId) {
+      return
+    }
+
+    await this.syncTemplateStepGroup(step.templateStepGroupId)
+  }
+
+  async generateFeature(testSuiteId: string): Promise<string> {
+    await ensureAutomationWorkspaceReady()
+
+    const testSuite = await prisma.testSuite.findUnique({
+      where: { id: testSuiteId },
+      select: {
+        name: true,
+        description: true,
+      },
+    })
+
+    if (!testSuite) {
+      throw new Error(`Test suite ${testSuiteId} not found`)
+    }
+
+    return generateFeatureFile(testSuiteId, testSuite.name, testSuite.description || undefined)
+  }
+
+  async deleteFeature(testSuiteId: string): Promise<boolean> {
+    await ensureAutomationWorkspaceReady()
+    return deleteFeatureFile(testSuiteId)
+  }
+
+  async regenerateAllFeatures(): Promise<string[]> {
+    await ensureAutomationWorkspaceReady()
+    return regenerateAllFeatureFiles()
+  }
+
+  async regenerateAllPathDependentArtifacts(): Promise<void> {
+    await ensureAutomationWorkspaceReady()
+
+    const locatorGroups = await prisma.locatorGroup.findMany({
+      select: { id: true },
+    })
+
+    const templateStepGroups = await prisma.templateStepGroup.findMany({
+      select: { id: true },
+    })
+
+    await Promise.all([
+      this.syncEnvironments(),
+      ...locatorGroups.map(locatorGroup => this.syncLocatorGroup(locatorGroup.id)),
+      ...templateStepGroups.map(group => this.syncTemplateStepGroup(group.id)),
+    ])
+
+    await this.regenerateAllFeatures()
+  }
+}
+
+export const automationProjectionService = new AutomationProjectionService()

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

@@ -1,6 +1,7 @@
 import { promises as fs } from 'fs'
 import * as path from 'path'
 import prisma from '@/config/db-config'
+import { ensureAutomationWorkspaceReady, getAutomationEnvironmentsDir } from '@/lib/automation/paths'
 
 interface EnvironmentConfig {
   baseUrl: string
@@ -9,29 +10,15 @@ interface EnvironmentConfig {
   password: string
 }
 
-/**
- * Gets the file path for the environments.json file
- */
 export function getEnvironmentsFilePath(): string {
-  return path.join('src', 'tests', 'config', 'environments', 'environments.json')
+  return path.join(getAutomationEnvironmentsDir(), 'environments.json')
 }
 
-/**
- * Ensures the config directory exists
- */
 export async function ensureConfigDirectoryExists(): Promise<void> {
-  const filePath = getEnvironmentsFilePath()
-  const dir = path.dirname(filePath)
-  try {
-    await fs.access(dir)
-  } catch {
-    await fs.mkdir(dir, { recursive: true })
-  }
+  await ensureAutomationWorkspaceReady()
+  await fs.mkdir(path.dirname(getEnvironmentsFilePath()), { recursive: true })
 }
 
-/**
- * Generates JSON content for environments from database
- */
 export async function generateEnvironmentsContent(): Promise<Record<string, EnvironmentConfig>> {
   try {
     const environments = await prisma.environment.findMany({
@@ -57,17 +44,14 @@ export async function generateEnvironmentsContent(): Promise<Record<string, Envi
   }
 }
 
-/**
- * Creates or updates the environments.json file
- */
 export async function createOrUpdateEnvironmentsFile(): Promise<boolean> {
   try {
+    await ensureAutomationWorkspaceReady()
     const filePath = getEnvironmentsFilePath()
     await ensureConfigDirectoryExists()
 
     const content = await generateEnvironmentsContent()
 
-    // If no environments exist, delete the file
     if (Object.keys(content).length === 0) {
       await deleteEnvironmentsFile()
       return true
@@ -81,18 +65,15 @@ export async function createOrUpdateEnvironmentsFile(): Promise<boolean> {
   }
 }
 
-/**
- * Deletes the environments.json file
- */
 export async function deleteEnvironmentsFile(): Promise<boolean> {
   try {
+    await ensureAutomationWorkspaceReady()
     const filePath = getEnvironmentsFilePath()
 
-    // Check if file exists before trying to delete
     try {
       await fs.access(filePath)
     } catch {
-      return true // File doesn't exist, nothing to delete
+      return true
     }
 
     await fs.unlink(filePath)
@@ -103,20 +84,18 @@ export async function deleteEnvironmentsFile(): Promise<boolean> {
   }
 }
 
-/**
- * Reads and parses the content of the environments.json file
- */
 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 // File doesn't exist
+      return null
     }
 
     const fileContent = await fs.readFile(filePath, 'utf-8')
@@ -129,12 +108,9 @@ export async function readEnvironmentsFile(): Promise<{
   }
 }
 
-/**
- * Updates a specific environment entry in the environments.json file
- */
 export async function updateEnvironmentEntry(environmentId: string, oldName?: string): Promise<boolean> {
   try {
-    // Get the environment from database
+    await ensureAutomationWorkspaceReady()
     const environment = await prisma.environment.findUnique({
       where: { id: environmentId },
     })
@@ -145,24 +121,21 @@ export async function updateEnvironmentEntry(environmentId: string, oldName?: st
     }
 
     const filePath = getEnvironmentsFilePath()
-
-    // Read existing content
     let environmentsConfig: Record<string, EnvironmentConfig> = {}
+
     try {
       await fs.access(filePath)
       const fileContent = await fs.readFile(filePath, 'utf-8')
       environmentsConfig = JSON.parse(fileContent)
     } catch {
-      // File doesn't exist, start with empty object
+      environmentsConfig = {}
     }
 
-    // Remove old entry if name changed
     if (oldName) {
       const oldKey = oldName.toLowerCase().replace(/\s+/g, '_')
       delete environmentsConfig[oldKey]
     }
 
-    // Add/update the environment entry
     const envKey = environment.name.toLowerCase().replace(/\s+/g, '_')
     environmentsConfig[envKey] = {
       baseUrl: environment.baseUrl,
@@ -171,10 +144,7 @@ export async function updateEnvironmentEntry(environmentId: string, oldName?: st
       password: environment.password || '',
     }
 
-    // Ensure directory exists
     await ensureConfigDirectoryExists()
-
-    // Write updated content
     await fs.writeFile(filePath, JSON.stringify(environmentsConfig, null, 2))
     return true
   } catch (error) {
@@ -183,35 +153,28 @@ export async function updateEnvironmentEntry(environmentId: string, oldName?: st
   }
 }
 
-/**
- * Removes a specific environment entry from the environments.json file
- */
 export async function removeEnvironmentEntry(environmentName: string): Promise<boolean> {
   try {
+    await ensureAutomationWorkspaceReady()
     const filePath = getEnvironmentsFilePath()
 
-    // Check if file exists
     try {
       await fs.access(filePath)
     } catch {
-      return true // File doesn't exist, nothing to remove
+      return true
     }
 
-    // Read existing content
     const fileContent = await fs.readFile(filePath, 'utf-8')
     const environmentsConfig: Record<string, EnvironmentConfig> = JSON.parse(fileContent)
 
-    // Remove the environment entry
     const envKey = environmentName.toLowerCase().replace(/\s+/g, '_')
     delete environmentsConfig[envKey]
 
-    // If no environments left, delete the file
     if (Object.keys(environmentsConfig).length === 0) {
       await deleteEnvironmentsFile()
       return true
     }
 
-    // Write updated content
     await fs.writeFile(filePath, JSON.stringify(environmentsConfig, null, 2))
     return true
   } catch (error) {