create-appraisejs 0.2.0-alpha.6 → 0.3.0-alpha.0

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

@@ -1,64 +1,45 @@
 'use server'
 
-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 {
+  checkLocatorGroupNameUnique,
+  createLocatorGroup,
+  deleteLocatorGroups,
+  getLocatorGroupByIdOrThrow,
+  listLocatorGroups,
+  updateLocatorGroup,
+} from '@/services/locator-group/locator-group-service'
+import { ServiceError, serviceErrorToActionResponse, unknownErrorToActionResponse } from '@/services/shared/errors'
 import { ActionResponse } from '@/types/form/actionHandler'
 import { revalidatePath } from 'next/cache'
 import { z } from 'zod'
-import { Prisma } from '@prisma/client'
-
-const locatorGroupInclude = {
-  module: {
-    select: { name: true },
-  },
-} as const
-
-async function checkUniqueName(name: string, excludeId?: string): Promise<boolean> {
-  const existing = await prisma.locatorGroup.findFirst({
-    where: {
-      name,
-      ...(excludeId && { id: { not: excludeId } }),
-    },
-  })
-  return !!existing
-}
 
 export async function getAllLocatorGroupsAction(): Promise<ActionResponse> {
   try {
-    const locatorGroups = await prisma.locatorGroup.findMany({
-      include: locatorGroupInclude,
-    })
-
+    const locatorGroups = await listLocatorGroups()
     return {
       status: 200,
+      success: true,
       data: locatorGroups,
     }
   } catch (error) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
-    }
+    return unknownErrorToActionResponse(error)
   }
 }
 
 export async function getLocatorGroupByIdAction(id: string): Promise<ActionResponse> {
   try {
-    const locatorGroup = await prisma.locatorGroup.findUnique({
-      where: { id },
-      include: locatorGroupInclude,
-    })
-
+    const locatorGroup = await getLocatorGroupByIdOrThrow(id)
     return {
       status: 200,
+      success: true,
       data: locatorGroup,
     }
   } catch (error) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
     }
+    return unknownErrorToActionResponse(error)
   }
 }
 
@@ -67,45 +48,19 @@ export async function createLocatorGroupAction(
   value: z.infer<typeof locatorGroupSchema>,
 ): Promise<ActionResponse> {
   try {
-    const nameExists = await checkUniqueName(value.name)
-    if (nameExists) {
-      return {
-        status: 400,
-        error: 'A locator group with this name already exists. Please choose a different name.',
-      }
-    }
-
-    const locatorGroup = await prisma.locatorGroup.create({
-      data: {
-        name: value.name,
-        moduleId: value.moduleId,
-        route: value.route ?? '/',
-        locators: {
-          connect: value.locators?.map(locator => ({ id: locator })) || [],
-        },
-      },
-    })
-
-    await automationProjectionService.createEmptyLocatorGroup(locatorGroup.id)
-    await automationProjectionService.syncLocatorMap(value.name, value.route ?? '/')
-
+    const locatorGroup = await createLocatorGroup(value)
     revalidatePath('/locator-groups')
     return {
       status: 200,
+      success: true,
       data: locatorGroup,
       message: 'Locator group created successfully',
     }
   } catch (error) {
-    if (error instanceof Prisma.PrismaClientKnownRequestError && error.code === 'P2002') {
-      return {
-        status: 400,
-        error: 'A locator group with this name already exists. Please choose a different name.',
-      }
-    }
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
     }
+    return unknownErrorToActionResponse(error)
   }
 }
 
@@ -115,179 +70,46 @@ export async function updateLocatorGroupAction(
   id?: string,
 ): Promise<ActionResponse> {
   try {
-    const currentLocatorGroup = await prisma.locatorGroup.findUnique({
-      where: { id },
-      include: { module: true },
-    })
-
-    if (!currentLocatorGroup) {
-      return {
-        status: 404,
-        error: 'Locator group not found',
-      }
-    }
-
-    if (currentLocatorGroup.name !== value.name) {
-      const nameExists = await checkUniqueName(value.name, id)
-      if (nameExists) {
-        return {
-          status: 400,
-          error: 'A locator group with this name already exists. Please choose a different name.',
-        }
-      }
-    }
-
-    const previousFilePath = await getLocatorGroupFilePath(id!)
-    const locatorConnections = value.locators?.map(locator => ({ id: locator })) ?? []
-
-    const updatedLocatorGroup = await prisma.locatorGroup.update({
-      where: { id },
-      data: {
-        name: value.name,
-        moduleId: value.moduleId,
-        route: value.route,
-        ...(value.locators !== undefined && {
-          locators: {
-            set: locatorConnections,
-          },
-        }),
-      },
-      include: locatorGroupInclude,
-    })
-
-    const nameChanged = currentLocatorGroup.name !== value.name
-    const moduleChanged = currentLocatorGroup.moduleId !== value.moduleId
-    const routeChanged = currentLocatorGroup.route !== value.route
-
-    if (moduleChanged) {
-      await automationProjectionService.moveLocatorGroup(id!, previousFilePath ?? undefined)
-    } else if (nameChanged) {
-      await automationProjectionService.renameLocatorGroup(id!, value.name, currentLocatorGroup.name)
-    } else {
-      await automationProjectionService.syncLocatorGroup(id!)
-    }
-
-    if (routeChanged || nameChanged) {
-      await automationProjectionService.syncLocatorMap(
-        currentLocatorGroup.route,
-        value.route ?? '/',
-        currentLocatorGroup.name,
-        value.name,
-      )
-    }
-
+    const updatedLocatorGroup = await updateLocatorGroup(id, value)
     revalidatePath('/locator-groups')
     return {
       status: 200,
+      success: true,
       data: updatedLocatorGroup,
       message: 'Locator group updated successfully',
     }
   } catch (error) {
-    if (error instanceof Prisma.PrismaClientKnownRequestError && error.code === 'P2002') {
-      return {
-        status: 400,
-        error: 'A locator group with this name already exists. Please choose a different name.',
-      }
-    }
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
     }
+    return unknownErrorToActionResponse(error)
   }
 }
 
 export async function deleteLocatorGroupAction(ids: string[]): Promise<ActionResponse> {
   try {
-    const locatorGroupsToDelete = await prisma.locatorGroup.findMany({
-      where: { id: { in: ids } },
-      select: { name: true },
-    })
-
-    await automationProjectionService.deleteLocatorMapEntries(locatorGroupsToDelete.map(group => group.name))
-    await Promise.all(ids.map(id => automationProjectionService.deleteLocatorGroup(id)))
-
-    await prisma.locatorGroup.deleteMany({
-      where: { id: { in: ids } },
-    })
-
+    await deleteLocatorGroups(ids)
     revalidatePath('/locator-groups')
     return {
       status: 200,
+      success: true,
       data: ids,
       message: `${ids.length} locator group(s) deleted successfully`,
     }
   } catch (error) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
-    }
-  }
-}
-
-export async function getLocatorGroupFileContentAction(locatorGroupId: string): Promise<ActionResponse> {
-  try {
-    const fileData = await readLocatorGroupFile(locatorGroupId)
-
-    if (!fileData) {
-      return {
-        status: 404,
-        error: 'Locator group not found or file path could not be determined',
-      }
-    }
-
-    return {
-      status: 200,
-      data: fileData,
-    }
-  } catch (error) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
-    }
+    return unknownErrorToActionResponse(error)
   }
 }
 
 export async function checkLocatorGroupNameUniqueAction(name: string, excludeId?: string): Promise<ActionResponse> {
   try {
-    const nameExists = await checkUniqueName(name, excludeId)
+    const isUnique = await checkLocatorGroupNameUnique(name, excludeId)
     return {
       status: 200,
-      data: { isUnique: !nameExists },
+      success: true,
+      data: { isUnique },
     }
   } catch (error) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
-    }
-  }
-}
-
-export async function regenerateAllLocatorGroupFilesAction(): Promise<ActionResponse> {
-  try {
-    const locatorGroups = await prisma.locatorGroup.findMany({
-      select: { id: true },
-    })
-
-    const results = await Promise.allSettled(
-      locatorGroups.map(locatorGroup => automationProjectionService.syncLocatorGroup(locatorGroup.id)),
-    )
-
-    const successCount = results.filter(result => result.status === 'fulfilled' && result.value).length
-    const errorCount = results.length - successCount
-
-    return {
-      status: 200,
-      data: {
-        total: locatorGroups.length,
-        success: successCount,
-        errors: errorCount,
-      },
-      message: `Regenerated ${successCount} files successfully. ${errorCount} errors encountered.`,
-    }
-  } catch (error) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
-    }
+    return unknownErrorToActionResponse(error)
   }
 }

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

@@ -0,0 +1,81 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('next/cache', () => ({
+  revalidatePath: vi.fn(),
+}))
+
+vi.mock('@/lib/locator-picker/session-manager', () => ({
+  locatorPickerSessionManager: {
+    startSession: vi.fn(),
+    getSession: vi.fn(),
+    closeSession: vi.fn(),
+    markReadyAfterSave: vi.fn().mockResolvedValue(undefined),
+  },
+}))
+
+vi.mock('@/services/locator/locator-service', () => ({
+  savePickedLocatorFromRequest: vi.fn(),
+}))
+
+import { revalidatePath } from 'next/cache'
+import { locatorPickerSessionManager } from '@/lib/locator-picker/session-manager'
+import { savePickedLocatorFromRequest } from '@/services/locator/locator-service'
+import { savePickedLocatorAction } from './locator-picker-actions'
+
+describe('savePickedLocatorAction', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('revalidates locator pages after a successful update', async () => {
+    vi.mocked(savePickedLocatorFromRequest).mockResolvedValue({
+      kind: 'success',
+      locatorId: 'loc-1',
+      locatorGroupId: 'group-1',
+      message: 'Locator updated successfully.',
+      wasUpdate: true,
+    })
+
+    const result = await savePickedLocatorAction({
+      sessionId: 'session-1',
+      locatorId: 'loc-1',
+      locatorName: 'submit',
+      selector: '[data-testid="submit"]',
+      resolutionMode: 'existing',
+      existingLocatorGroupId: 'group-1',
+    })
+
+    expect(result).toEqual({
+      status: 200,
+      success: true,
+      data: {
+        locatorId: 'loc-1',
+        locatorGroupId: 'group-1',
+      },
+      message: 'Locator updated successfully.',
+    })
+    expect(revalidatePath).toHaveBeenCalledWith('/locators')
+    expect(revalidatePath).toHaveBeenCalledWith('/locator-groups')
+    expect(revalidatePath).toHaveBeenCalledWith('/locators/create')
+    expect(revalidatePath).toHaveBeenCalledWith('/locators/modify/loc-1')
+  })
+
+  it('marks the session ready again when saving throws', async () => {
+    vi.mocked(savePickedLocatorFromRequest).mockRejectedValue(new Error('disk full'))
+
+    const result = await savePickedLocatorAction({
+      sessionId: 'session-9',
+      locatorName: 'submit',
+      selector: '[data-testid="submit"]',
+      resolutionMode: 'existing',
+      existingLocatorGroupId: 'group-1',
+    })
+
+    expect(locatorPickerSessionManager.markReadyAfterSave).toHaveBeenCalledWith('session-9')
+    expect(result).toEqual({
+      status: 500,
+      success: false,
+      error: 'disk full',
+    })
+  })
+})

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

@@ -1,13 +1,11 @@
 'use server'
 
-import prisma from '@/config/db-config'
-import { automationProjectionService } from '@/lib/automation/projection-service'
-import { normalizeRoute } from '@/lib/locator-picker/suggestions'
-import { locatorPickerSessionManager } from '@/lib/locator-picker/session-manager'
 import type { ActionResponse } from '@/types/form/actionHandler'
 import type { SavePickedLocatorRequest, StartLocatorPickerSessionRequest } from '@/types/locator-picker'
 import { revalidatePath } from 'next/cache'
 import { z } from 'zod'
+import { locatorPickerSessionManager } from '@/lib/locator-picker/session-manager'
+import { savePickedLocatorFromRequest } from '@/services/locator/locator-service'
 
 const startLocatorPickerSessionSchema = z
   .object({
@@ -18,18 +16,6 @@ const startLocatorPickerSessionSchema = z
     message: 'Choose an environment or provide a URL.',
   })
 
-const savePickedLocatorSchema = z.object({
-  locatorId: z.string().min(1).optional(),
-  sessionId: z.string().min(1).optional(),
-  locatorName: z.string().min(1, { message: 'Locator name is required.' }),
-  selector: z.string().min(1, { message: 'Selector is required.' }),
-  resolutionMode: z.enum(['existing', 'create']),
-  existingLocatorGroupId: z.string().optional(),
-  newLocatorGroupName: z.string().optional(),
-  route: z.string().optional(),
-  moduleId: z.string().optional(),
-})
-
 export async function startLocatorPickerSessionAction(
   request: StartLocatorPickerSessionRequest,
 ): Promise<ActionResponse> {
@@ -39,12 +25,14 @@ export async function startLocatorPickerSessionAction(
 
     return {
       status: session.status === 'error' ? 500 : 200,
+      success: session.status !== 'error',
       data: session,
       error: session.error,
     }
   } catch (error) {
     return {
       status: 500,
+      success: false,
       error: error instanceof Error ? error.message : 'Failed to start the locator picker session.',
     }
   }
@@ -56,187 +44,58 @@ export async function getLocatorPickerSessionAction(sessionId: string): Promise<
     if (!session) {
       return {
         status: 404,
+        success: false,
         error: 'Locator picker session not found.',
       }
     }
 
     return {
       status: 200,
+      success: true,
       data: session,
     }
   } catch (error) {
     return {
       status: 500,
+      success: false,
       error: error instanceof Error ? error.message : 'Failed to load the locator picker session.',
     }
   }
 }
 
-export async function closeLocatorPickerSessionAction(sessionId: string): Promise<ActionResponse> {
-  try {
-    const session = await locatorPickerSessionManager.closeSession(sessionId)
-    if (!session) {
-      return {
-        status: 404,
-        error: 'Locator picker session not found.',
-      }
-    }
-
-    return {
-      status: 200,
-      data: session,
-    }
-  } catch (error) {
-    return {
-      status: 500,
-      error: error instanceof Error ? error.message : 'Failed to close the locator picker session.',
-    }
-  }
-}
-
 export async function savePickedLocatorAction(request: SavePickedLocatorRequest): Promise<ActionResponse> {
   try {
-    const value = savePickedLocatorSchema.parse(request)
-    const session = value.sessionId ? await locatorPickerSessionManager.getSession(value.sessionId) : null
-    const fail = async (status: number, error: string): Promise<ActionResponse> => {
-      await locatorPickerSessionManager.markReadyAfterSave(value.sessionId)
-      return { status, error }
-    }
+    const outcome = await savePickedLocatorFromRequest(request)
 
-    await locatorPickerSessionManager.markSaving(value.sessionId)
-
-    let locatorGroupId = value.existingLocatorGroupId
-    let locatorGroupName = ''
-    const route = normalizeRoute(value.route || session?.currentPathname)
-    const locatorName = value.locatorName.trim()
-    const selector = value.selector.trim()
-    const currentLocator = value.locatorId
-      ? await prisma.locator.findUnique({
-          where: { id: value.locatorId },
-          select: { locatorGroupId: true },
-        })
-      : null
-
-    if (value.locatorId && !currentLocator) {
-      return fail(404, 'The locator you are editing no longer exists.')
-    }
-
-    if (value.resolutionMode === 'existing') {
-      if (!locatorGroupId) {
-        return fail(400, 'Choose an existing locator group before saving.')
-      }
-
-      const locatorGroup = await prisma.locatorGroup.findUnique({
-        where: {
-          id: locatorGroupId,
-        },
-      })
-
-      if (!locatorGroup) {
-        return fail(404, 'The selected locator group no longer exists.')
-      }
-
-      locatorGroupName = locatorGroup.name
-    } else {
-      if (!value.newLocatorGroupName || value.newLocatorGroupName.trim() === '') {
-        return fail(400, 'Locator group name is required when creating a new group.')
-      }
-
-      if (!value.moduleId) {
-        return fail(400, 'Choose a module for the new locator group.')
-      }
-
-      const duplicateGroup = await prisma.locatorGroup.findFirst({
-        where: {
-          name: value.newLocatorGroupName.trim(),
-        },
-      })
-
-      if (duplicateGroup) {
-        return fail(400, 'A locator group with this name already exists. Choose a different name.')
+    if (outcome.kind === 'error') {
+      return {
+        status: outcome.status,
+        success: false,
+        error: outcome.message,
       }
-
-      const newLocatorGroup = await prisma.locatorGroup.create({
-        data: {
-          name: value.newLocatorGroupName.trim(),
-          route,
-          moduleId: value.moduleId,
-        },
-      })
-
-      locatorGroupId = newLocatorGroup.id
-      locatorGroupName = newLocatorGroup.name
-
-      await automationProjectionService.createEmptyLocatorGroup(newLocatorGroup.id)
-      await automationProjectionService.syncLocatorMap(newLocatorGroup.name, route)
-    }
-
-    if (!locatorGroupId) {
-      return fail(500, 'Failed to resolve the locator group for saving.')
-    }
-
-    const existingLocator = await prisma.locator.findFirst({
-      where: {
-        locatorGroupId,
-        name: locatorName,
-        ...(value.locatorId
-          ? {
-              id: {
-                not: value.locatorId,
-              },
-            }
-          : {}),
-      },
-    })
-
-    if (existingLocator) {
-      return fail(400, `A locator named "${locatorName}" already exists in ${locatorGroupName}.`)
-    }
-
-    const locator = value.locatorId
-      ? await prisma.locator.update({
-          where: { id: value.locatorId },
-          data: {
-            name: locatorName,
-            value: selector,
-            locatorGroupId,
-          },
-        })
-      : await prisma.locator.create({
-          data: {
-            name: locatorName,
-            value: selector,
-            locatorGroupId,
-          },
-        })
-
-    const groupsToSync = new Set<string>([locatorGroupId])
-    if (currentLocator?.locatorGroupId && currentLocator.locatorGroupId !== locatorGroupId) {
-      groupsToSync.add(currentLocator.locatorGroupId)
     }
 
-    await Promise.all(Array.from(groupsToSync).map(groupId => automationProjectionService.syncLocatorGroup(groupId)))
-    await locatorPickerSessionManager.markReadyAfterSave(value.sessionId)
-
     revalidatePath('/locators')
     revalidatePath('/locator-groups')
     revalidatePath('/locators/create')
-    if (value.locatorId) {
-      revalidatePath(`/locators/modify/${value.locatorId}`)
+    if (outcome.wasUpdate) {
+      revalidatePath(`/locators/modify/${outcome.locatorId}`)
     }
 
     return {
       status: 200,
+      success: true,
       data: {
-        locatorId: locator.id,
-        locatorGroupId,
+        locatorId: outcome.locatorId,
+        locatorGroupId: outcome.locatorGroupId,
       },
-      message: value.locatorId ? 'Locator updated successfully.' : 'Locator saved successfully.',
+      message: outcome.message,
     }
   } catch (error) {
     await locatorPickerSessionManager.markReadyAfterSave(request.sessionId).catch(() => undefined)
     return {
       status: 500,
+      success: false,
       error: error instanceof Error ? error.message : 'Failed to save the picked locator.',
     }
   }