create-appraisejs 0.1.9 → 0.1.10-alpha.0

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

@@ -2,44 +2,29 @@
 
 import prisma from '@/config/db-config'
 import { locatorGroupSchema } from '@/constants/form-opts/locator-group-form-opts'
+import { automationProjectionService } from '@/lib/automation/projection-service'
+import { getLocatorGroupFilePath, readLocatorGroupFile } from '@/lib/locator-group-file-utils'
 import { ActionResponse } from '@/types/form/actionHandler'
 import { revalidatePath } from 'next/cache'
 import { z } from 'zod'
 import { Prisma } from '@prisma/client'
-import {
-  createOrUpdateLocatorGroupFile,
-  deleteLocatorGroupFile,
-  renameLocatorGroupFile,
-  moveLocatorGroupFile,
-  createEmptyLocatorGroupFile,
-  readLocatorGroupFile,
-  updateLocatorMapFile,
-  removeLocatorMapEntry,
-} from '@/lib/locator-group-file-utils'
-
-// Common include pattern for locator groups
+
 const locatorGroupInclude = {
   module: {
     select: { name: true },
   },
 } as const
 
-/**
- * Check if a locator group name already exists
- */
 async function checkUniqueName(name: string, excludeId?: string): Promise<boolean> {
   const existing = await prisma.locatorGroup.findFirst({
     where: {
-      name: name,
+      name,
       ...(excludeId && { id: { not: excludeId } }),
     },
   })
   return !!existing
 }
 
-/**
- * Get all locator groups
- */
 export async function getAllLocatorGroupsAction(): Promise<ActionResponse> {
   try {
     const locatorGroups = await prisma.locatorGroup.findMany({
@@ -58,9 +43,6 @@ export async function getAllLocatorGroupsAction(): Promise<ActionResponse> {
   }
 }
 
-/**
- * Get a locator group by ID
- */
 export async function getLocatorGroupByIdAction(id: string): Promise<ActionResponse> {
   try {
     const locatorGroup = await prisma.locatorGroup.findUnique({
@@ -80,15 +62,11 @@ export async function getLocatorGroupByIdAction(id: string): Promise<ActionRespo
   }
 }
 
-/**
- * Create a new locator group
- */
 export async function createLocatorGroupAction(
   _prev: unknown,
   value: z.infer<typeof locatorGroupSchema>,
 ): Promise<ActionResponse> {
   try {
-    // Check if name already exists
     const nameExists = await checkUniqueName(value.name)
     if (nameExists) {
       return {
@@ -96,6 +74,7 @@ export async function createLocatorGroupAction(
         error: 'A locator group with this name already exists. Please choose a different name.',
       }
     }
+
     const locatorGroup = await prisma.locatorGroup.create({
       data: {
         name: value.name,
@@ -107,9 +86,8 @@ export async function createLocatorGroupAction(
       },
     })
 
-    // Create empty JSON file initially
-    await createEmptyLocatorGroupFile(locatorGroup.id)
-    await updateLocatorMapFile(value.name, value.route ?? '/')
+    await automationProjectionService.createEmptyLocatorGroup(locatorGroup.id)
+    await automationProjectionService.syncLocatorMap(value.name, value.route ?? '/')
 
     revalidatePath('/locator-groups')
     return {
@@ -118,7 +96,6 @@ export async function createLocatorGroupAction(
       message: 'Locator group created successfully',
     }
   } catch (error) {
-    // Handle Prisma unique constraint error
     if (error instanceof Prisma.PrismaClientKnownRequestError && error.code === 'P2002') {
       return {
         status: 400,
@@ -132,16 +109,12 @@ export async function createLocatorGroupAction(
   }
 }
 
-/**
- * Update an existing locator group
- */
 export async function updateLocatorGroupAction(
   _prev: unknown,
   value: z.infer<typeof locatorGroupSchema>,
   id?: string,
 ): Promise<ActionResponse> {
   try {
-    // Get current state to detect changes
     const currentLocatorGroup = await prisma.locatorGroup.findUnique({
       where: { id },
       include: { module: true },
@@ -154,7 +127,6 @@ export async function updateLocatorGroupAction(
       }
     }
 
-    // Check if name already exists (only if name is changing)
     if (currentLocatorGroup.name !== value.name) {
       const nameExists = await checkUniqueName(value.name, id)
       if (nameExists) {
@@ -165,7 +137,8 @@ export async function updateLocatorGroupAction(
       }
     }
 
-    // Update the locator group
+    const previousFilePath = await getLocatorGroupFilePath(id!)
+
     const updatedLocatorGroup = await prisma.locatorGroup.update({
       where: { id },
       data: {
@@ -179,28 +152,27 @@ export async function updateLocatorGroupAction(
       include: locatorGroupInclude,
     })
 
-    // Handle file operations based on changes
     const nameChanged = currentLocatorGroup.name !== value.name
     const moduleChanged = currentLocatorGroup.moduleId !== value.moduleId
     const routeChanged = currentLocatorGroup.route !== value.route
 
-    if (nameChanged && moduleChanged) {
-      // Both changed - move the file (this will handle both changes)
-      await moveLocatorGroupFile(id!)
+    if (moduleChanged) {
+      await automationProjectionService.moveLocatorGroup(id!, previousFilePath ?? undefined)
     } else if (nameChanged) {
-      // Only name changed - rename the file
-      await renameLocatorGroupFile(id!, value.name, currentLocatorGroup.name)
-    } else if (moduleChanged) {
-      // Only module changed - move the file
-      await moveLocatorGroupFile(id!)
+      await automationProjectionService.renameLocatorGroup(id!, value.name, currentLocatorGroup.name)
     } else {
-      // No structural changes - just update content
-      await createOrUpdateLocatorGroupFile(id!)
+      await automationProjectionService.syncLocatorGroup(id!)
     }
 
     if (routeChanged || nameChanged) {
-      await updateLocatorMapFile(currentLocatorGroup.route, value.route ?? '/', currentLocatorGroup.name, value.name)
+      await automationProjectionService.syncLocatorMap(
+        currentLocatorGroup.route,
+        value.route ?? '/',
+        currentLocatorGroup.name,
+        value.name,
+      )
     }
+
     revalidatePath('/locator-groups')
     return {
       status: 200,
@@ -208,7 +180,6 @@ export async function updateLocatorGroupAction(
       message: 'Locator group updated successfully',
     }
   } catch (error) {
-    // Handle Prisma unique constraint error
     if (error instanceof Prisma.PrismaClientKnownRequestError && error.code === 'P2002') {
       return {
         status: 400,
@@ -222,26 +193,16 @@ export async function updateLocatorGroupAction(
   }
 }
 
-/**
- * Delete locator groups
- */
 export async function deleteLocatorGroupAction(ids: string[]): Promise<ActionResponse> {
   try {
-    // Get locator group names before deletion for locator map cleanup
     const locatorGroupsToDelete = await prisma.locatorGroup.findMany({
       where: { id: { in: ids } },
       select: { name: true },
     })
 
-    const locatorGroupNames = locatorGroupsToDelete.map(group => group.name)
-
-    // Remove entries from locator map
-    await removeLocatorMapEntry(locatorGroupNames)
+    await automationProjectionService.deleteLocatorMapEntries(locatorGroupsToDelete.map(group => group.name))
+    await Promise.all(ids.map(id => automationProjectionService.deleteLocatorGroup(id)))
 
-    // Delete JSON files first
-    await Promise.all(ids.map(id => deleteLocatorGroupFile(id)))
-
-    // Delete the locator groups (locators will be deleted via cascade)
     await prisma.locatorGroup.deleteMany({
       where: { id: { in: ids } },
     })
@@ -260,9 +221,6 @@ export async function deleteLocatorGroupAction(ids: string[]): Promise<ActionRes
   }
 }
 
-/**
- * Get the content of a specific locator group file
- */
 export async function getLocatorGroupFileContentAction(locatorGroupId: string): Promise<ActionResponse> {
   try {
     const fileData = await readLocatorGroupFile(locatorGroupId)
@@ -286,9 +244,6 @@ export async function getLocatorGroupFileContentAction(locatorGroupId: string):
   }
 }
 
-/**
- * Check if a locator group name is unique
- */
 export async function checkLocatorGroupNameUniqueAction(name: string, excludeId?: string): Promise<ActionResponse> {
   try {
     const nameExists = await checkUniqueName(name, excludeId)
@@ -304,23 +259,14 @@ export async function checkLocatorGroupNameUniqueAction(name: string, excludeId?
   }
 }
 
-/**
- * Regenerate all locator group files from database
- */
 export async function regenerateAllLocatorGroupFilesAction(): Promise<ActionResponse> {
   try {
     const locatorGroups = await prisma.locatorGroup.findMany({
-      include: {
-        module: true,
-        locators: {
-          select: { name: true, value: true },
-        },
-      },
+      select: { id: true },
     })
 
-    // Process all files in parallel for better performance
     const results = await Promise.allSettled(
-      locatorGroups.map(locatorGroup => createOrUpdateLocatorGroupFile(locatorGroup.id)),
+      locatorGroups.map(locatorGroup => automationProjectionService.syncLocatorGroup(locatorGroup.id)),
     )
 
     const successCount = results.filter(result => result.status === 'fulfilled' && result.value).length

package/templates/default/src/actions/modules/module-actions.ts

@@ -2,6 +2,7 @@
 
 import prisma from '@/config/db-config'
 import { moduleSchema, ROOT_MODULE_UUID } from '@/constants/form-opts/module-form-opts'
+import { automationProjectionService } from '@/lib/automation/projection-service'
 import { ActionResponse } from '@/types/form/actionHandler'
 import { revalidatePath } from 'next/cache'
 import { z } from 'zod'
@@ -36,6 +37,7 @@ export async function deleteModuleAction(ids: string[]): Promise<ActionResponse>
         id: { in: ids },
       },
     })
+    await automationProjectionService.regenerateAllPathDependentArtifacts()
     revalidatePath('/modules')
     return {
       status: 200,
@@ -53,7 +55,6 @@ export async function createModuleAction(_prev: unknown, value: z.infer<typeof m
   try {
     moduleSchema.parse(value)
 
-    // Convert the special root UUID to null for database storage
     const moduleData = {
       ...value,
       parentId: value.parentId === ROOT_MODULE_UUID ? null : value.parentId,
@@ -62,6 +63,7 @@ export async function createModuleAction(_prev: unknown, value: z.infer<typeof m
     const newModule = await prisma.module.create({
       data: moduleData,
     })
+    await automationProjectionService.regenerateAllPathDependentArtifacts()
     revalidatePath('/modules')
     return {
       status: 200,
@@ -108,7 +110,6 @@ export async function updateModuleAction(
   try {
     moduleSchema.parse(value)
 
-    // Convert the special root UUID to null for database storage
     const moduleData = {
       ...value,
       parentId: value.parentId === ROOT_MODULE_UUID ? null : value.parentId,
@@ -118,6 +119,7 @@ export async function updateModuleAction(
       where: { id },
       data: moduleData,
     })
+    await automationProjectionService.regenerateAllPathDependentArtifacts()
     revalidatePath('/modules')
     return {
       status: 200,

package/templates/default/src/actions/tags/tag-actions.ts

@@ -2,6 +2,7 @@
 
 import prisma from '@/config/db-config'
 import { tagSchema } from '@/constants/form-opts/tag-form-opts'
+import { automationProjectionService } from '@/lib/automation/projection-service'
 import { ActionResponse } from '@/types/form/actionHandler'
 import { TagType } from '@prisma/client'
 import { revalidatePath } from 'next/cache'
@@ -29,7 +30,7 @@ export async function getAllTagsAction(): Promise<ActionResponse> {
 export async function deleteTagAction(ids: string[]): Promise<ActionResponse> {
   try {
     await prisma.tag.deleteMany({ where: { id: { in: ids } } })
-
+    await automationProjectionService.regenerateAllFeatures()
     revalidatePath('/tags')
 
     return {
@@ -50,6 +51,7 @@ export async function createTagAction(_prev: unknown, value: z.infer<typeof tagS
       data: value,
     })
 
+    await automationProjectionService.regenerateAllFeatures()
     revalidatePath('/tags')
 
     return {
@@ -88,6 +90,7 @@ export async function updateTagAction(
   try {
     const updatedTag = await prisma.tag.update({ where: { id }, data: value })
 
+    await automationProjectionService.regenerateAllFeatures()
     revalidatePath('/tags')
 
     return {

package/templates/default/src/actions/template-step/template-step-actions.ts

@@ -2,37 +2,11 @@
 
 import prisma from '@/config/db-config'
 import { templateStepSchema } from '@/constants/form-opts/template-test-step-form-opts'
+import { automationProjectionService } from '@/lib/automation/projection-service'
 import { ActionResponse } from '@/types/form/actionHandler'
 import { StepParameterType, TemplateStepIcon, TemplateStepType } from '@prisma/client'
 import { revalidatePath } from 'next/cache'
 import { z } from 'zod'
-import {
-  addTemplateStepToFile,
-  removeTemplateStepFromFile,
-  updateTemplateStepInFile,
-} from '@/lib/utils/template-step-file-manager-intelligent'
-
-// TemplateStepGroupType helper - will be available from @prisma/client after migration
-type TemplateStepGroupType = 'ACTION' | 'VALIDATION'
-
-// Type helper to safely extract type from Prisma templateStepGroup records
-type TemplateStepGroupWithType = {
-  id: string
-  name: string
-  description: string | null
-  type?: TemplateStepGroupType
-  createdAt: Date
-  updatedAt: Date
-}
-
-function getGroupTypeFromRelation(group: unknown): TemplateStepGroupType {
-  const groupWithType = group as TemplateStepGroupWithType
-  const type = groupWithType.type
-  if (type === 'VALIDATION' || type === 'ACTION') {
-    return type
-  }
-  return 'ACTION' // default
-}
 
 export async function getAllTemplateStepsAction(): Promise<ActionResponse> {
   try {
@@ -61,19 +35,14 @@ export async function getAllTemplateStepsAction(): Promise<ActionResponse> {
 
 export async function deleteTemplateStepAction(templateStepIds: string[]): Promise<ActionResponse> {
   try {
-    // Get the template steps with their group info before deletion
     const stepsToDelete = await prisma.templateStep.findMany({
       where: { id: { in: templateStepIds } },
-      include: {
-        templateStepGroup: true,
+      select: {
+        templateStepGroupId: true,
       },
     })
 
-    // Delete in order: child records first. TemplateTestCaseStepParameter and
-    // TestCaseStepParameter must be removed before TemplateTestCaseStep/TestCaseStep
-    // (which are cascade-deleted from TemplateStep).
     await prisma.$transaction(async tx => {
-      // Delete TemplateTestCaseStepParameter records first
       await tx.templateTestCaseStepParameter.deleteMany({
         where: {
           templateTestCaseStep: {
@@ -82,7 +51,6 @@ export async function deleteTemplateStepAction(templateStepIds: string[]): Promi
         },
       })
 
-      // Delete TestCaseStepParameter records
       await tx.testCaseStepParameter.deleteMany({
         where: {
           testCaseStep: {
@@ -91,14 +59,12 @@ export async function deleteTemplateStepAction(templateStepIds: string[]): Promi
         },
       })
 
-      // Delete the template step parameters
       await tx.templateStepParameter.deleteMany({
         where: {
           templateStepId: { in: templateStepIds },
         },
       })
 
-      // Delete the template steps (this will cascade delete TemplateTestCaseStep and TestCaseStep)
       await tx.templateStep.deleteMany({
         where: {
           id: { in: templateStepIds },
@@ -106,18 +72,8 @@ export async function deleteTemplateStepAction(templateStepIds: string[]): Promi
       })
     })
 
-    // Remove the deleted steps from their respective group files
-    for (const step of stepsToDelete) {
-      if (step.templateStepGroup) {
-        try {
-          const groupType = getGroupTypeFromRelation(step.templateStepGroup)
-          await removeTemplateStepFromFile(step.templateStepGroup.name, step, groupType)
-        } catch (fileError) {
-          console.error(`Failed to remove step from file for group "${step.templateStepGroup.name}":`, fileError)
-          // Don't fail the entire operation if file update fails
-        }
-      }
-    }
+    const affectedGroupIds = [...new Set(stepsToDelete.map(step => step.templateStepGroupId))]
+    await Promise.all(affectedGroupIds.map(groupId => automationProjectionService.syncTemplateStepGroup(groupId)))
 
     revalidatePath('/template-steps')
     return {
@@ -137,7 +93,6 @@ export async function createTemplateStepAction(
   value: z.infer<typeof templateStepSchema>,
 ): Promise<ActionResponse> {
   try {
-    // First, try to create the template step
     const newTemplateStep = await prisma.templateStep.create({
       data: {
         name: value.name,
@@ -159,21 +114,9 @@ export async function createTemplateStepAction(
           },
         },
       },
-      include: {
-        templateStepGroup: true,
-      },
     })
 
-    // If database creation succeeds, add the step to the group's file
-    if (newTemplateStep.templateStepGroup) {
-      try {
-        const groupType = getGroupTypeFromRelation(newTemplateStep.templateStepGroup)
-        await addTemplateStepToFile(newTemplateStep.templateStepGroup.name, newTemplateStep, groupType)
-      } catch (fileError) {
-        console.error(`Failed to add step to file after creating template step:`, fileError)
-        // Don't fail the entire operation if file update fails
-      }
-    }
+    await automationProjectionService.syncTemplateStepGroup(newTemplateStep.templateStepGroupId)
 
     revalidatePath('/template-steps')
 
@@ -203,11 +146,10 @@ export async function updateTemplateStepAction(
       }
     }
 
-    // Get the current template step to check if group changed
     const currentStep = await prisma.templateStep.findUnique({
       where: { id },
-      include: {
-        templateStepGroup: true,
+      select: {
+        templateStepGroupId: true,
       },
     })
 
@@ -218,10 +160,6 @@ export async function updateTemplateStepAction(
       }
     }
 
-    // Check if the group changed
-    const groupChanged = currentStep.templateStepGroupId !== value.templateStepGroupId
-
-    // Update the template step
     const updatedTemplateStep = await prisma.templateStep.update({
       where: { id },
       data: {
@@ -247,39 +185,10 @@ export async function updateTemplateStepAction(
           },
         },
       },
-      include: {
-        templateStepGroup: true,
-      },
     })
 
-    // Update files for affected groups
-    try {
-      if (groupChanged) {
-        // If group changed, remove from old group and add to new group
-        if (currentStep.templateStepGroup) {
-          const oldGroupType = getGroupTypeFromRelation(currentStep.templateStepGroup)
-          await removeTemplateStepFromFile(currentStep.templateStepGroup.name, currentStep, oldGroupType)
-        }
-        if (updatedTemplateStep.templateStepGroup) {
-          const newGroupType = getGroupTypeFromRelation(updatedTemplateStep.templateStepGroup)
-          await addTemplateStepToFile(updatedTemplateStep.templateStepGroup.name, updatedTemplateStep, newGroupType)
-        }
-      } else {
-        // If group didn't change, just update the step in the current group
-        if (updatedTemplateStep.templateStepGroup) {
-          const groupType = getGroupTypeFromRelation(updatedTemplateStep.templateStepGroup)
-          await updateTemplateStepInFile(
-            updatedTemplateStep.templateStepGroup.name,
-            updatedTemplateStep,
-            groupType,
-            currentStep,
-          )
-        }
-      }
-    } catch (fileError) {
-      console.error(`Failed to update file after updating template step:`, fileError)
-      // Don't fail the entire operation if file update fails
-    }
+    const affectedGroupIds = new Set([currentStep.templateStepGroupId, updatedTemplateStep.templateStepGroupId])
+    await Promise.all(Array.from(affectedGroupIds).map(groupId => automationProjectionService.syncTemplateStepGroup(groupId)))
 
     revalidatePath('/template-steps')
     return {