create-appraisejs 0.2.0 → 0.3.0-alpha.0

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

@@ -1,107 +1,99 @@
-'use server'
-
-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'
-import { z } from 'zod'
-
-export async function getAllTagsAction(): Promise<ActionResponse> {
-  try {
-    const tags = await prisma.tag.findMany({
-      where: {
-        type: TagType.FILTER,
-      },
-    })
-    return {
-      status: 200,
-      data: tags,
-    }
-  } catch (error) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
-    }
-  }
-}
-
-export async function deleteTagAction(ids: string[]): Promise<ActionResponse> {
-  try {
-    await prisma.tag.deleteMany({ where: { id: { in: ids } } })
-    await automationProjectionService.regenerateAllFeatures()
-    revalidatePath('/tags')
-
-    return {
-      status: 200,
-      message: 'Tag deleted successfully',
-    }
-  } catch (error) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
-    }
-  }
-}
-
-export async function createTagAction(_prev: unknown, value: z.infer<typeof tagSchema>): Promise<ActionResponse> {
-  try {
-    const newTag = await prisma.tag.create({
-      data: value,
-    })
-
-    await automationProjectionService.regenerateAllFeatures()
-    revalidatePath('/tags')
-
-    return {
-      status: 200,
-      data: newTag,
-      message: 'Tag created successfully',
-    }
-  } catch (error) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
-    }
-  }
-}
-
-export async function getTagByIdAction(id: string): Promise<ActionResponse> {
-  try {
-    const tag = await prisma.tag.findUnique({ where: { id } })
-    return {
-      status: 200,
-      data: tag,
-    }
-  } catch (error) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
-    }
-  }
-}
-
-export async function updateTagAction(
-  _prev: unknown,
-  value: z.infer<typeof tagSchema>,
-  id?: string,
-): Promise<ActionResponse> {
-  try {
-    const updatedTag = await prisma.tag.update({ where: { id }, data: value })
-
-    await automationProjectionService.regenerateAllFeatures()
-    revalidatePath('/tags')
-
-    return {
-      status: 200,
-      data: updatedTag,
-      message: 'Tag updated successfully',
-    }
-  } catch (error) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
-    }
-  }
-}
+'use server'
+
+import { tagSchema } from '@/constants/form-opts/tag-form-opts'
+import {
+  createTag,
+  deleteTags,
+  getTagByIdOrThrow,
+  listFilterTags,
+  updateTag,
+} from '@/services/tag/tag-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 getAllTagsAction(): Promise<ActionResponse> {
+  try {
+    const tags = await listFilterTags()
+    return {
+      status: 200,
+      success: true,
+      data: tags,
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function deleteTagAction(ids: string[]): Promise<ActionResponse> {
+  try {
+    await deleteTags(ids)
+    revalidatePath('/tags')
+    return {
+      status: 200,
+      success: true,
+      message: 'Tag deleted successfully',
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function createTagAction(_prev: unknown, value: z.infer<typeof tagSchema>): Promise<ActionResponse> {
+  try {
+    tagSchema.parse(value)
+    const newTag = await createTag(value)
+    revalidatePath('/tags')
+    return {
+      status: 200,
+      success: true,
+      data: newTag,
+      message: 'Tag created successfully',
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function getTagByIdAction(id: string): Promise<ActionResponse> {
+  try {
+    const tag = await getTagByIdOrThrow(id)
+    return {
+      status: 200,
+      success: true,
+      data: tag,
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function updateTagAction(
+  _prev: unknown,
+  value: z.infer<typeof tagSchema>,
+  id?: string,
+): Promise<ActionResponse> {
+  try {
+    tagSchema.parse(value)
+    const updatedTag = await updateTag(id, value)
+    revalidatePath('/tags')
+    return {
+      status: 200,
+      success: true,
+      data: updatedTag,
+      message: 'Tag updated successfully',
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}

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

@@ -1,118 +1,43 @@
 'use server'
 
-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 {
+  createTemplateStep,
+  deleteTemplateSteps,
+  getTemplateStepByIdOrThrow,
+  listAllTemplateStepParameters,
+  listTemplateSteps,
+  updateTemplateStep,
+} from '@/services/template-step/template-step-service'
+import { ServiceError, serviceErrorToActionResponse, unknownErrorToActionResponse } from '@/services/shared/errors'
 import { ActionResponse } from '@/types/form/actionHandler'
-import { StepParameterType, TemplateStepIcon, TemplateStepType } from '@prisma/client'
 import { revalidatePath } from 'next/cache'
-import prettier from 'prettier'
 import { z } from 'zod'
 
-function normalizeOptionalText(value: string | null | undefined): string | null {
-  const normalized = value?.trim()
-  return normalized ? normalized : null
-}
-
-async function normalizeFunctionDefinition(functionDefinition: string | null | undefined): Promise<string> {
-  const source = functionDefinition?.trim()
-  if (!source) {
-    return ''
-  }
-
-  try {
-    return (
-      await prettier.format(source, {
-        parser: 'typescript',
-        semi: true,
-        singleQuote: true,
-        trailingComma: 'es5',
-        printWidth: 80,
-        tabWidth: 2,
-      })
-    ).trim()
-  } catch {
-    return source
-  }
-}
-
 export async function getAllTemplateStepsAction(): Promise<ActionResponse> {
   try {
-    const templateSteps = await prisma.templateStep.findMany({
-      include: {
-        parameters: {
-          select: {
-            id: true,
-            name: true,
-          },
-        },
-        templateStepGroup: true,
-      },
-    })
+    const templateSteps = await listTemplateSteps()
     return {
       status: 200,
+      success: true,
       data: templateSteps,
     }
   } catch (error) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
-    }
+    return unknownErrorToActionResponse(error)
   }
 }
 
 export async function deleteTemplateStepAction(templateStepIds: string[]): Promise<ActionResponse> {
   try {
-    const stepsToDelete = await prisma.templateStep.findMany({
-      where: { id: { in: templateStepIds } },
-      select: {
-        templateStepGroupId: true,
-      },
-    })
-
-    await prisma.$transaction(async tx => {
-      await tx.templateTestCaseStepParameter.deleteMany({
-        where: {
-          templateTestCaseStep: {
-            templateStepId: { in: templateStepIds },
-          },
-        },
-      })
-
-      await tx.testCaseStepParameter.deleteMany({
-        where: {
-          testCaseStep: {
-            templateStepId: { in: templateStepIds },
-          },
-        },
-      })
-
-      await tx.templateStepParameter.deleteMany({
-        where: {
-          templateStepId: { in: templateStepIds },
-        },
-      })
-
-      await tx.templateStep.deleteMany({
-        where: {
-          id: { in: templateStepIds },
-        },
-      })
-    })
-
-    const affectedGroupIds = [...new Set(stepsToDelete.map(step => step.templateStepGroupId))]
-    await Promise.all(affectedGroupIds.map(groupId => automationProjectionService.syncTemplateStepGroup(groupId)))
-
+    await deleteTemplateSteps(templateStepIds)
     revalidatePath('/template-steps')
     return {
       status: 200,
+      success: true,
       message: 'Template steps deleted successfully',
     }
   } catch (error) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
-    }
+    return unknownErrorToActionResponse(error)
   }
 }
 
@@ -121,46 +46,19 @@ export async function createTemplateStepAction(
   value: z.infer<typeof templateStepSchema>,
 ): Promise<ActionResponse> {
   try {
-    const description = normalizeOptionalText(value.description)
-    const functionDefinition = await normalizeFunctionDefinition(value.functionDefinition)
-
-    const newTemplateStep = await prisma.templateStep.create({
-      data: {
-        name: value.name,
-        type: value.type as TemplateStepType,
-        signature: value.signature,
-        description,
-        functionDefinition,
-        parameters: {
-          create: value.params.map(param => ({
-            name: param.name,
-            type: param.type as StepParameterType,
-            order: param.order,
-          })),
-        },
-        icon: value.icon as TemplateStepIcon,
-        templateStepGroup: {
-          connect: {
-            id: value.templateStepGroupId,
-          },
-        },
-      },
-    })
-
-    await automationProjectionService.syncTemplateStepGroup(newTemplateStep.templateStepGroupId)
-
+    const newTemplateStep = await createTemplateStep(value)
     revalidatePath('/template-steps')
-
     return {
       status: 200,
+      success: true,
       message: 'Template step created successfully',
       data: newTemplateStep,
     }
   } catch (error) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
     }
+    return unknownErrorToActionResponse(error)
   }
 }
 
@@ -170,106 +68,47 @@ export async function updateTemplateStepAction(
   id?: string,
 ): Promise<ActionResponse> {
   try {
-    if (!id) {
-      return {
-        status: 400,
-        error: 'Template step ID is required',
-      }
-    }
-
-    const currentStep = await prisma.templateStep.findUnique({
-      where: { id },
-      select: {
-        templateStepGroupId: true,
-      },
-    })
-
-    if (!currentStep) {
-      return {
-        status: 404,
-        error: 'Template step not found',
-      }
-    }
-
-    const description = normalizeOptionalText(value.description)
-    const functionDefinition = await normalizeFunctionDefinition(value.functionDefinition)
-
-    const updatedTemplateStep = await prisma.templateStep.update({
-      where: { id },
-      data: {
-        name: value.name,
-        type: value.type as TemplateStepType,
-        signature: value.signature,
-        description,
-        functionDefinition,
-        parameters: {
-          deleteMany: {
-            templateStepId: id,
-          },
-          create: value.params.map(param => ({
-            name: param.name,
-            type: param.type as StepParameterType,
-            order: param.order,
-          })),
-        },
-        icon: value.icon as TemplateStepIcon,
-        templateStepGroup: {
-          connect: {
-            id: value.templateStepGroupId,
-          },
-        },
-      },
-    })
-
-    const affectedGroupIds = new Set([currentStep.templateStepGroupId, updatedTemplateStep.templateStepGroupId])
-    await Promise.all(Array.from(affectedGroupIds).map(groupId => automationProjectionService.syncTemplateStepGroup(groupId)))
-
+    const updatedTemplateStep = await updateTemplateStep(id, value)
     revalidatePath('/template-steps')
     return {
       status: 200,
+      success: true,
       message: 'Template step updated successfully',
       data: updatedTemplateStep,
     }
   } catch (error) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
     }
+    return unknownErrorToActionResponse(error)
   }
 }
 
 export async function getTemplateStepByIdAction(id: string): Promise<ActionResponse> {
   try {
-    const templateStep = await prisma.templateStep.findUnique({
-      where: { id },
-      include: {
-        parameters: true,
-        templateStepGroup: true,
-      },
-    })
+    const templateStep = await getTemplateStepByIdOrThrow(id)
     return {
       status: 200,
+      success: true,
       data: templateStep,
     }
   } catch (error) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
     }
+    return unknownErrorToActionResponse(error)
   }
 }
 
 export async function getAllTemplateStepParamsAction(): Promise<ActionResponse> {
   try {
-    const templateStepParams = await prisma.templateStepParameter.findMany({})
+    const templateStepParams = await listAllTemplateStepParameters()
     return {
       status: 200,
+      success: true,
       data: templateStepParams,
     }
   } catch (error) {
-    return {
-      status: 500,
-      error: `Server error occurred: ${error}`,
-    }
+    return unknownErrorToActionResponse(error)
   }
 }