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

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

@@ -1,37 +1,29 @@
 'use server'
 
-import prisma from '@/config/db-config'
 import { templateStepGroupSchema } from '@/constants/form-opts/template-step-group-form-opts'
-import { automationProjectionService } from '@/lib/automation/projection-service'
+import {
+  createTemplateStepGroup,
+  deleteTemplateStepGroups,
+  getTemplateStepGroupByIdOrThrow,
+  listTemplateStepGroups,
+  updateTemplateStepGroup,
+} from '@/services/template-step-group/template-step-group-service'
+import { ServiceError, serviceErrorToActionResponse, unknownErrorToActionResponse } from '@/services/shared/errors'
 import { ActionResponse } from '@/types/form/actionHandler'
-import { Prisma } from '@prisma/client'
 import { revalidatePath } from 'next/cache'
 import { z, ZodError } from 'zod'
-
-type TemplateStepGroupType = 'ACTION' | 'VALIDATION'
-
-function getGroupType(group: unknown): TemplateStepGroupType {
-  const type = (group as { type?: TemplateStepGroupType }).type
-  return type === 'VALIDATION' ? 'VALIDATION' : 'ACTION'
-}
-
-function normalizeOptionalText(value: string | null | undefined): string | null {
-  const normalized = value?.trim()
-  return normalized ? normalized : null
-}
+import { Prisma } from '@prisma/client'
 
 export async function getAllTemplateStepGroupsAction(): Promise<ActionResponse> {
   try {
-    const templateStepGroups = await prisma.templateStepGroup.findMany()
+    const templateStepGroups = await listTemplateStepGroups()
     return {
       status: 200,
+      success: true,
       data: templateStepGroups,
     }
   } catch (error) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
-    }
+    return unknownErrorToActionResponse(error)
   }
 }
 
@@ -41,77 +33,62 @@ export async function createTemplateStepGroupAction(
 ): Promise<ActionResponse> {
   try {
     templateStepGroupSchema.parse(value)
-
-    const type: TemplateStepGroupType = (value.type as string) === 'VALIDATION' ? 'VALIDATION' : 'ACTION'
-    const description = normalizeOptionalText(value.description)
-    const createdGroup = await prisma.templateStepGroup.create({
-      data: {
-        name: value.name,
-        description,
-        type,
-      } as Parameters<typeof prisma.templateStepGroup.create>[0]['data'],
-    })
-
-    await automationProjectionService.syncTemplateStepGroup(createdGroup.id)
-
+    await createTemplateStepGroup(value)
     revalidatePath('/template-step-groups')
     return {
       status: 200,
+      success: true,
       message: 'Template step group created successfully',
     }
   } catch (error) {
     if (error instanceof ZodError) {
       return {
         status: 400,
+        success: false,
         error: error.message,
       }
     }
     if (error instanceof Prisma.PrismaClientKnownRequestError) {
       return {
         status: 500,
+        success: false,
         error: error.message,
       }
     }
-    return {
-      status: 500,
-      error: 'Server error occurred',
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
     }
+    return unknownErrorToActionResponse(error)
   }
 }
 
 export async function deleteTemplateStepGroupAction(ids: string[]): Promise<ActionResponse> {
   try {
-    await Promise.all(ids.map(id => automationProjectionService.deleteTemplateStepGroup(id)))
-
-    await prisma.templateStepGroup.deleteMany({
-      where: { id: { in: ids } },
-    })
-
+    await deleteTemplateStepGroups(ids)
     revalidatePath('/template-step-groups')
     return {
       status: 200,
+      success: true,
       message: 'Template step group(s) deleted successfully',
     }
   } catch (error) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
-    }
+    return unknownErrorToActionResponse(error)
   }
 }
 
 export async function getTemplateStepGroupByIdAction(id: string): Promise<ActionResponse> {
   try {
-    const templateStepGroup = await prisma.templateStepGroup.findUnique({
-      where: { id },
-    })
+    const templateStepGroup = await getTemplateStepGroupByIdOrThrow(id)
     return {
       status: 200,
+      success: true,
       data: templateStepGroup,
     }
   } catch (error) {
-    console.error(error)
-    throw error
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
   }
 }
 
@@ -122,65 +99,31 @@ export async function updateTemplateStepGroupAction(
 ): Promise<ActionResponse> {
   try {
     templateStepGroupSchema.parse(value)
-
-    if (!id) {
-      return {
-        status: 400,
-        error: 'Template step group ID is required',
-      }
-    }
-
-    const currentGroup = await prisma.templateStepGroup.findUnique({
-      where: { id },
-    })
-
-    if (!currentGroup) {
-      return {
-        status: 404,
-        error: 'Template step group not found',
-      }
-    }
-
-    const newType: TemplateStepGroupType = (value.type as string) === 'VALIDATION' ? 'VALIDATION' : 'ACTION'
-    const currentType = getGroupType(currentGroup)
-    const description = normalizeOptionalText(value.description)
-
-    if (currentGroup.name !== value.name || currentType !== newType) {
-      await automationProjectionService.renameTemplateStepGroup(id, value.name, newType, description)
-    }
-
-    await prisma.templateStepGroup.update({
-      where: { id },
-      data: {
-        name: value.name,
-        description,
-        type: newType,
-      } as Parameters<typeof prisma.templateStepGroup.update>[0]['data'],
-    })
-
-    await automationProjectionService.syncTemplateStepGroup(id)
-
+    await updateTemplateStepGroup(id, value)
     revalidatePath('/template-step-groups')
     return {
       status: 200,
+      success: true,
       message: 'Template step group updated successfully',
     }
   } catch (error) {
     if (error instanceof ZodError) {
       return {
         status: 400,
+        success: false,
         error: error.message,
       }
     }
     if (error instanceof Prisma.PrismaClientKnownRequestError) {
       return {
         status: 500,
+        success: false,
         error: error.message,
       }
     }
-    return {
-      status: 500,
-      error: 'Server error occurred',
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
     }
+    return unknownErrorToActionResponse(error)
   }
 }

package/templates/default/src/actions/template-test-case/template-test-case-actions.ts

@@ -1,238 +1,98 @@
-'use server'
-
-import prisma from '@/config/db-config'
-import { ActionResponse } from '@/types/form/actionHandler'
-import { revalidatePath } from 'next/cache'
-import { templateTestCaseSchema } from '@/constants/form-opts/template-test-case-form-opts'
-import { StepParameterType } from '@prisma/client'
-import { z } from 'zod'
-
-/**
- * Get all template test cases
- * @returns ActionResponse
- */
-export async function getAllTemplateTestCasesAction(): Promise<ActionResponse> {
-  try {
-    const templateTestCases = await prisma.templateTestCase.findMany({
-      include: {
-        steps: {
-          include: {
-            parameters: true,
-          },
-        },
-      },
-    })
-
-    return {
-      status: 200,
-      data: templateTestCases,
-    }
-  } catch (e) {
-    return {
-      status: 500,
-      message: `Server error occurred: ${e}`,
-    }
-  }
-}
-
-/**
- * Delete a template test case
- * @param id - Template test case id
- * @returns ActionResponse
- */
-export async function deleteTemplateTestCaseAction(id: string[]): Promise<ActionResponse> {
-  try {
-    await prisma.$transaction(async tx => {
-      // Delete all step parameters associated with the test case steps
-      await tx.templateTestCaseStepParameter.deleteMany({
-        where: {
-          templateTestCaseStep: {
-            templateTestCaseId: {
-              in: id,
-            },
-          },
-        },
-      })
-
-      // Delete all test case steps
-      await tx.templateTestCaseStep.deleteMany({
-        where: {
-          templateTestCaseId: {
-            in: id,
-          },
-        },
-      })
-
-      // Delete the test cases
-      await tx.templateTestCase.deleteMany({
-        where: { id: { in: id } },
-      })
-    })
-
-    revalidatePath('/template-test-cases')
-    return {
-      status: 200,
-      message: 'Template test case(s) deleted successfully',
-    }
-  } catch (e) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${e}`,
-    }
-  }
-}
-
-/**
- * Create a template test case
- * @param value - Template test case
- * @returns ActionResponse
- */
-export async function createTemplateTestCaseAction(
-  value: z.infer<typeof templateTestCaseSchema>,
-): Promise<ActionResponse> {
-  try {
-    templateTestCaseSchema.parse(value)
-    const newTemplateTestCase = await prisma.templateTestCase.create({
-      data: {
-        name: value.title,
-        description: value.description ?? '',
-
-        steps: {
-          create: value.steps.map(step => ({
-            gherkinStep: step.gherkinStep,
-            label: step.label,
-            icon: step.icon,
-            parameters: {
-              create: step.parameters.map(param => ({
-                name: param.name,
-                defaultValue: param.value,
-                type: param.type as StepParameterType,
-                order: param.order,
-              })),
-            },
-            TemplateStep: {
-              connect: {
-                id: step.templateStepId,
-              },
-            },
-            order: step.order,
-          })),
-        },
-      },
-    })
-    revalidatePath('/template-test-cases')
-    return {
-      status: 200,
-      message: 'Template test case created successfully',
-      data: newTemplateTestCase,
-    }
-  } catch (e) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${e}`,
-    }
-  }
-}
-
-/**
- * Get a template test case by id
- * @param id - Template test case id
- * @returns ActionResponse
- */
-export async function getTemplateTestCaseByIdAction(id: string): Promise<ActionResponse> {
-  try {
-    const templateTestCase = await prisma.templateTestCase.findUnique({
-      where: { id },
-      include: {
-        steps: {
-          include: {
-            parameters: true,
-          },
-        },
-      },
-    })
-    return {
-      status: 200,
-      data: templateTestCase,
-    }
-  } catch (e) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${e}`,
-    }
-  }
-}
-
-/**
- * Update a template test case
- * @param value - Template test case
- * @param id - Template test case id
- * @returns ActionResponse
- */
-export async function updateTemplateTestCaseAction(
-  value: z.infer<typeof templateTestCaseSchema>,
-  id?: string,
-): Promise<ActionResponse> {
-  if (!id) {
-    throw new Error("updateTemplateTestCaseAction: 'id' parameter is required for updating a template test case.")
-  }
-  try {
-    // 1. Find all step IDs for the test case
-    const steps = await prisma.templateTestCaseStep.findMany({
-      where: { templateTestCaseId: id },
-      select: { id: true },
-    })
-    const stepIds = steps.map(step => step.id)
-
-    // 2. Delete all parameters for those steps
-    if (stepIds.length > 0) {
-      await prisma.templateTestCaseStepParameter.deleteMany({
-        where: { templateTestCaseStep: { id: { in: stepIds } } },
-      })
-    }
-
-    // 3. Delete all steps for the test case
-    await prisma.templateTestCaseStep.deleteMany({
-      where: { templateTestCaseId: id },
-    })
-
-    // 4. Then, update the test case with new steps
-    const templateTestCase = await prisma.templateTestCase.update({
-      where: { id },
-      data: {
-        name: value.title,
-        description: value.description ?? '',
-        steps: {
-          create: value.steps.map(step => ({
-            gherkinStep: step.gherkinStep,
-            label: step.label ?? '',
-            icon: step.icon ?? '',
-            parameters: {
-              create: step.parameters.map(param => ({
-                name: param.name,
-                defaultValue: param.value,
-                type: param.type as StepParameterType,
-                order: param.order,
-              })),
-            },
-            templateStepId: step.templateStepId,
-            order: step.order,
-          })),
-        },
-      },
-      include: {
-        steps: true,
-      },
-    })
-    return {
-      status: 200,
-      message: 'Template test case updated successfully',
-      data: templateTestCase,
-    }
-  } catch (e) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${e}`,
-    }
-  }
-}
+'use server'
+
+import { templateTestCaseSchema } from '@/constants/form-opts/template-test-case-form-opts'
+import {
+  createTemplateTestCase,
+  deleteTemplateTestCases,
+  getTemplateTestCaseByIdOrThrow,
+  listTemplateTestCases,
+  updateTemplateTestCase,
+} from '@/services/template-test-case/template-test-case-service'
+import { ServiceError, serviceErrorToActionResponse, unknownErrorToActionResponse } from '@/services/shared/errors'
+import { ActionResponse } from '@/types/form/actionHandler'
+import { revalidatePath } from 'next/cache'
+import { z } from 'zod'
+
+export async function getAllTemplateTestCasesAction(): Promise<ActionResponse> {
+  try {
+    const templateTestCases = await listTemplateTestCases()
+    return {
+      status: 200,
+      success: true,
+      data: templateTestCases,
+    }
+  } catch (e) {
+    return unknownErrorToActionResponse(e)
+  }
+}
+
+export async function deleteTemplateTestCaseAction(id: string[]): Promise<ActionResponse> {
+  try {
+    await deleteTemplateTestCases(id)
+    revalidatePath('/template-test-cases')
+    return {
+      status: 200,
+      success: true,
+      message: 'Template test case(s) deleted successfully',
+    }
+  } catch (e) {
+    return unknownErrorToActionResponse(e)
+  }
+}
+
+export async function createTemplateTestCaseAction(value: z.infer<typeof templateTestCaseSchema>): Promise<ActionResponse> {
+  try {
+    templateTestCaseSchema.parse(value)
+    const newTemplateTestCase = await createTemplateTestCase(value)
+    revalidatePath('/template-test-cases')
+    return {
+      status: 200,
+      success: true,
+      message: 'Template test case created successfully',
+      data: newTemplateTestCase,
+    }
+  } catch (e) {
+    if (e instanceof ServiceError) {
+      return serviceErrorToActionResponse(e)
+    }
+    return unknownErrorToActionResponse(e)
+  }
+}
+
+export async function getTemplateTestCaseByIdAction(id: string): Promise<ActionResponse> {
+  try {
+    const templateTestCase = await getTemplateTestCaseByIdOrThrow(id)
+    return {
+      status: 200,
+      success: true,
+      data: templateTestCase,
+    }
+  } catch (e) {
+    if (e instanceof ServiceError) {
+      return serviceErrorToActionResponse(e)
+    }
+    return unknownErrorToActionResponse(e)
+  }
+}
+
+export async function updateTemplateTestCaseAction(
+  value: z.infer<typeof templateTestCaseSchema>,
+  id?: string,
+): Promise<ActionResponse> {
+  try {
+    templateTestCaseSchema.parse(value)
+    const templateTestCase = await updateTemplateTestCase(id, value)
+    revalidatePath('/template-test-cases')
+    return {
+      status: 200,
+      success: true,
+      message: 'Template test case updated successfully',
+      data: templateTestCase,
+    }
+  } catch (e) {
+    if (e instanceof ServiceError) {
+      return serviceErrorToActionResponse(e)
+    }
+    return unknownErrorToActionResponse(e)
+  }
+}