create-appraise 0.1.0

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

@@ -0,0 +1,278 @@
+'use server'
+
+import prisma from '@/config/db-config'
+import { templateStepGroupSchema } from '@/constants/form-opts/template-step-group-form-opts'
+import { ActionResponse } from '@/types/form/actionHandler'
+import { Prisma } from '@prisma/client'
+import { revalidatePath } from 'next/cache'
+import { z, ZodError } from 'zod'
+
+// TemplateStepGroupType will be available after Prisma migration
+type TemplateStepGroupType = 'ACTION' | 'VALIDATION'
+
+// Type helper to safely extract type from Prisma records
+type TemplateStepGroupWithType = {
+  id: string
+  name: string
+  description: string | null
+  type?: TemplateStepGroupType
+  createdAt: Date
+  updatedAt: Date
+}
+
+function getGroupType(group: unknown): TemplateStepGroupType {
+  const groupWithType = group as TemplateStepGroupWithType
+  const type = groupWithType.type
+  if (type === 'VALIDATION' || type === 'ACTION') {
+    return type
+  }
+  return 'ACTION' // default
+}
+
+import {
+  createTemplateStepGroupFile,
+  removeTemplateStepGroupFile,
+  renameTemplateStepGroupFile,
+  ensureGroupJSDoc,
+} from '@/lib/utils/template-step-file-manager-intelligent'
+import { promises as fs } from 'fs'
+import { getFilePath, formatFileContent } from '@/lib/utils/template-step-file-generator'
+
+/**
+ * Get all template step groups
+ * @returns ActionResponse
+ */
+export async function getAllTemplateStepGroupsAction(): Promise<ActionResponse> {
+  try {
+    const templateStepGroups = await prisma.templateStepGroup.findMany()
+    return {
+      status: 200,
+      data: templateStepGroups,
+    }
+  } catch (e) {
+    return {
+      status: 500,
+      error: `Server error occurred: ${e}`,
+    }
+  }
+}
+
+/**
+ * Create a new template step group
+ * @param _prev - Previous state
+ * @param value - Template step group data
+ * @returns ActionResponse
+ */
+export async function createTemplateStepGroupAction(
+  _prev: unknown,
+  value: z.infer<typeof templateStepGroupSchema>,
+): Promise<ActionResponse> {
+  try {
+    templateStepGroupSchema.parse(value)
+
+    const type: TemplateStepGroupType = (value.type as string) === 'VALIDATION' ? 'VALIDATION' : 'ACTION'
+
+    // First, try to create the file - if this fails, we won't create the database record
+    await createTemplateStepGroupFile(value.name, type, value.description)
+
+    // If file creation succeeds, create the database record
+    // Note: Using type assertion because Prisma client hasn't been regenerated yet
+    await prisma.templateStepGroup.create({
+      data: {
+        name: value.name,
+        description: value.description,
+        type: type,
+      } as Parameters<typeof prisma.templateStepGroup.create>[0]['data'],
+    })
+
+    revalidatePath('/template-step-groups')
+    return {
+      status: 200,
+      message: 'Template step group created successfully',
+    }
+  } catch (e) {
+    if (e instanceof ZodError) {
+      return {
+        status: 400,
+        error: e.message,
+      }
+    }
+    if (e instanceof Prisma.PrismaClientKnownRequestError) {
+      return {
+        status: 500,
+        error: e.message,
+      }
+    }
+    return {
+      status: 500,
+      error: 'Server error occurred',
+    }
+  }
+}
+
+/**
+ * Delete a template step group
+ * @param id - Template step group id(s)
+ * @returns ActionResponse
+ */
+export async function deleteTemplateStepGroupAction(id: string[]): Promise<ActionResponse> {
+  try {
+    // Get the group names and types before deletion for file cleanup
+    const groupsToDelete = await prisma.templateStepGroup.findMany({
+      where: { id: { in: id } },
+    })
+
+    // With proper cascade deletes in the schema, we can now rely on the database
+    // to handle the deletion of related entities automatically
+    await prisma.templateStepGroup.deleteMany({
+      where: { id: { in: id } },
+    })
+
+    // Clean up the files after successful database deletion
+    for (const group of groupsToDelete) {
+      try {
+        const groupType = getGroupType(group)
+        await removeTemplateStepGroupFile(group.name, groupType)
+      } catch (fileError) {
+        console.error(`Failed to delete file for group "${group.name}":`, fileError)
+        // Don't fail the entire operation if file deletion fails
+      }
+    }
+
+    revalidatePath('/template-step-groups')
+    return {
+      status: 200,
+      message: 'Template step group(s) deleted successfully',
+    }
+  } catch (e) {
+    console.error('Error deleting template step group:', e)
+    return {
+      status: 500,
+      error: `Server error occurred: ${e}`,
+    }
+  }
+}
+
+/**
+ * Get a template step group by id
+ * @param id - Template step group id
+ * @returns ActionResponse
+ */
+export async function getTemplateStepGroupByIdAction(id: string): Promise<ActionResponse> {
+  try {
+    const templateStepGroup = await prisma.templateStepGroup.findUnique({
+      where: { id },
+    })
+    return {
+      status: 200,
+      data: templateStepGroup,
+    }
+  } catch (e) {
+    console.error(e)
+    throw e
+  }
+}
+
+/**
+ * Update a template step group
+ * @param _prev - Previous state
+ * @param value - Template step group data
+ * @param id - Template step group id
+ * @returns ActionResponse
+ */
+export async function updateTemplateStepGroupAction(
+  _prev: unknown,
+  value: z.infer<typeof templateStepGroupSchema>,
+  id?: string,
+): Promise<ActionResponse> {
+  try {
+    templateStepGroupSchema.parse(value)
+
+    if (!id) {
+      return {
+        status: 400,
+        error: 'Template step group ID is required',
+      }
+    }
+
+    // Get the current group to check if name or type changed
+    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 nameChanged = currentGroup.name !== value.name
+    const typeChanged = currentType !== newType
+    const descriptionChanged = currentGroup.description !== value.description
+
+    // If name or type changed, we need to handle file renaming/moving
+    if (nameChanged || typeChanged) {
+      // Rename/move the file to preserve all existing content and update JSDoc
+      try {
+        await renameTemplateStepGroupFile(currentGroup.name, value.name, currentType, newType, value.description)
+      } catch (fileError) {
+        console.error(
+          `Failed to rename/move file from "${currentGroup.name}" (${currentType}) to "${value.name}" (${newType}):`,
+          fileError,
+        )
+        // Continue with the update even if file rename fails
+      }
+    } else if (descriptionChanged) {
+      // Only description changed, update JSDoc in place
+      try {
+        const filePath = getFilePath(value.name, newType)
+
+        let fileContent = await fs.readFile(filePath, 'utf8')
+        fileContent = ensureGroupJSDoc(fileContent, value.name, value.description || null, newType)
+
+        const formattedContent = await formatFileContent(fileContent)
+        await fs.writeFile(filePath, formattedContent, 'utf8')
+      } catch (fileError) {
+        console.error(`Failed to update JSDoc for group "${value.name}":`, fileError)
+        // Continue with the update even if file update fails
+      }
+    }
+
+    // Update the database record
+    // Note: Using type assertion because Prisma client hasn't been regenerated yet
+    await prisma.templateStepGroup.update({
+      where: { id },
+      data: {
+        name: value.name,
+        description: value.description,
+        type: newType,
+      } as Parameters<typeof prisma.templateStepGroup.update>[0]['data'],
+    })
+
+    revalidatePath('/template-step-groups')
+    return {
+      status: 200,
+      message: 'Template step group updated successfully',
+    }
+  } catch (e) {
+    if (e instanceof ZodError) {
+      return {
+        status: 400,
+        error: e.message,
+      }
+    }
+    if (e instanceof Prisma.PrismaClientKnownRequestError) {
+      return {
+        status: 500,
+        error: e.message,
+      }
+    }
+    return {
+      status: 500,
+      error: 'Server error occurred',
+    }
+  }
+}

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

@@ -0,0 +1,238 @@
+'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}`,
+    }
+  }
+}