create-appraisejs 0.3.0-alpha.0 → 0.3.0-alpha.1

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

@@ -0,0 +1,114 @@
+'use server'
+
+import { templateStepSchema } from '@/constants/form-opts/template-test-step-form-opts'
+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 { revalidatePath } from 'next/cache'
+import { z } from 'zod'
+
+export async function getAllTemplateStepsAction(): Promise<ActionResponse> {
+  try {
+    const templateSteps = await listTemplateSteps()
+    return {
+      status: 200,
+      success: true,
+      data: templateSteps,
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function deleteTemplateStepAction(templateStepIds: string[]): Promise<ActionResponse> {
+  try {
+    await deleteTemplateSteps(templateStepIds)
+    revalidatePath('/template-steps')
+    return {
+      status: 200,
+      success: true,
+      message: 'Template steps deleted successfully',
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function createTemplateStepAction(
+  _prev: unknown,
+  value: z.infer<typeof templateStepSchema>,
+): Promise<ActionResponse> {
+  try {
+    const newTemplateStep = await createTemplateStep(value)
+    revalidatePath('/template-steps')
+    return {
+      status: 200,
+      success: true,
+      message: 'Template step created successfully',
+      data: newTemplateStep,
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function updateTemplateStepAction(
+  _prev: unknown,
+  value: z.infer<typeof templateStepSchema>,
+  id?: string,
+): Promise<ActionResponse> {
+  try {
+    const updatedTemplateStep = await updateTemplateStep(id, value)
+    revalidatePath('/template-steps')
+    return {
+      status: 200,
+      success: true,
+      message: 'Template step updated successfully',
+      data: updatedTemplateStep,
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function getTemplateStepByIdAction(id: string): Promise<ActionResponse> {
+  try {
+    const templateStep = await getTemplateStepByIdOrThrow(id)
+    return {
+      status: 200,
+      success: true,
+      data: templateStep,
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function getAllTemplateStepParamsAction(): Promise<ActionResponse> {
+  try {
+    const templateStepParams = await listAllTemplateStepParameters()
+    return {
+      status: 200,
+      success: true,
+      data: templateStepParams,
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}

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

@@ -0,0 +1,129 @@
+'use server'
+
+import { templateStepGroupSchema } from '@/constants/form-opts/template-step-group-form-opts'
+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 { revalidatePath } from 'next/cache'
+import { z, ZodError } from 'zod'
+import { Prisma } from '@prisma/client'
+
+export async function getAllTemplateStepGroupsAction(): Promise<ActionResponse> {
+  try {
+    const templateStepGroups = await listTemplateStepGroups()
+    return {
+      status: 200,
+      success: true,
+      data: templateStepGroups,
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function createTemplateStepGroupAction(
+  _prev: unknown,
+  value: z.infer<typeof templateStepGroupSchema>,
+): Promise<ActionResponse> {
+  try {
+    templateStepGroupSchema.parse(value)
+    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,
+      }
+    }
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function deleteTemplateStepGroupAction(ids: string[]): Promise<ActionResponse> {
+  try {
+    await deleteTemplateStepGroups(ids)
+    revalidatePath('/template-step-groups')
+    return {
+      status: 200,
+      success: true,
+      message: 'Template step group(s) deleted successfully',
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function getTemplateStepGroupByIdAction(id: string): Promise<ActionResponse> {
+  try {
+    const templateStepGroup = await getTemplateStepGroupByIdOrThrow(id)
+    return {
+      status: 200,
+      success: true,
+      data: templateStepGroup,
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function updateTemplateStepGroupAction(
+  _prev: unknown,
+  value: z.infer<typeof templateStepGroupSchema>,
+  id?: string,
+): Promise<ActionResponse> {
+  try {
+    templateStepGroupSchema.parse(value)
+    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,
+      }
+    }
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}

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

@@ -0,0 +1,98 @@
+'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)
+  }
+}

package/templates/starter/src/actions/test-case/test-case-actions.ts

@@ -0,0 +1,108 @@
+'use server'
+
+import { ActionResponse } from '@/types/form/actionHandler'
+import { revalidatePath } from 'next/cache'
+import { testCaseSchema } from '@/constants/form-opts/test-case-form-opts'
+import { z } from 'zod'
+import {
+  createTestCaseFromInput,
+  deleteTestCasesByIds,
+  getTestCaseByIdOrThrow,
+  listTestCases,
+  updateTestCaseFromInput,
+} from '@/services/test-case/test-case-service'
+import { ServiceError, serviceErrorToActionResponse, unknownErrorToActionResponse } from '@/services/shared/errors'
+
+export async function getAllTestCasesAction(): Promise<ActionResponse> {
+  try {
+    const testCases = await listTestCases()
+    return {
+      status: 200,
+      success: true,
+      data: testCases,
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function deleteTestCaseAction(ids: string[]): Promise<ActionResponse> {
+  try {
+    await deleteTestCasesByIds(ids)
+
+    revalidatePath('/test-cases')
+    return {
+      status: 200,
+      success: true,
+      message: 'Test case(s) deleted successfully',
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function createTestCaseAction(value: z.infer<typeof testCaseSchema>): Promise<ActionResponse> {
+  try {
+    testCaseSchema.parse(value)
+    const newTestCase = await createTestCaseFromInput(value)
+
+    revalidatePath('/test-cases')
+    return {
+      status: 200,
+      success: true,
+      message: 'Test case created successfully',
+      data: newTestCase,
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function getTestCaseByIdAction(id: string): Promise<ActionResponse> {
+  try {
+    const testCase = await getTestCaseByIdOrThrow(id)
+    return {
+      status: 200,
+      success: true,
+      data: testCase,
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function updateTestCaseAction(
+  value: z.infer<typeof testCaseSchema>,
+  id?: string,
+): Promise<ActionResponse> {
+  if (!id) {
+    return {
+      status: 400,
+      success: false,
+      error: "updateTestCaseAction: 'id' parameter is required for updating a test case.",
+    }
+  }
+  try {
+    testCaseSchema.parse(value)
+    const testCase = await updateTestCaseFromInput(value, id)
+
+    revalidatePath('/test-cases')
+    return {
+      status: 200,
+      success: true,
+      message: 'Test case updated successfully',
+      data: testCase,
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}

package/templates/starter/src/actions/test-run/test-run-actions.ts

@@ -0,0 +1,269 @@
+'use server'
+
+import { testRunSchema } from '@/constants/form-opts/test-run-form-opts'
+import { ActionResponse } from '@/types/form/actionHandler'
+import { z } from 'zod'
+import { revalidatePath } from 'next/cache'
+import {
+  cancelTestRunService,
+  checkTraceViewerStatusService,
+  createTestRunFromValidatedValue,
+  deleteTestRunsByIds,
+  getTestRunLogsService,
+  getTestRunByIdOrThrow,
+  isTestRunNameTaken,
+  listTestRuns,
+  listTestSuiteTestCases,
+  spawnTraceViewerService,
+} from '@/services/test-run/test-run-service'
+import { ServiceError, serviceErrorToActionResponse, unknownErrorToActionResponse } from '@/services/shared/errors'
+
+export async function getAllTestRunsAction(filter?: string): Promise<ActionResponse> {
+  try {
+    const testRuns = await listTestRuns(filter)
+    return {
+      status: 200,
+      success: true,
+      data: testRuns,
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function getTestRunByIdAction(id: string): Promise<ActionResponse> {
+  try {
+    const testRun = await getTestRunByIdOrThrow(id)
+    return {
+      status: 200,
+      success: true,
+      data: testRun,
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function deleteTestRunAction(id: string[]): Promise<ActionResponse> {
+  try {
+    await deleteTestRunsByIds(id)
+
+    revalidatePath('/test-runs')
+    revalidatePath('/')
+    return {
+      status: 200,
+      success: true,
+      message: 'Test run(s) deleted successfully',
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function getAllTestSuiteTestCasesAction(): Promise<ActionResponse> {
+  try {
+    const testSuiteTestCases = await listTestSuiteTestCases()
+    return {
+      status: 200,
+      success: true,
+      data: testSuiteTestCases,
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function getTestRunLogsAction(testRunId: string): Promise<ActionResponse> {
+  try {
+    const logs = await getTestRunLogsService(testRunId)
+
+    return {
+      status: 200,
+      success: true,
+      data: logs,
+    }
+  } catch (error) {
+    console.error(`[TestRunAction] Error retrieving logs for testRunId: ${testRunId}:`, error)
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function createTestRunAction(
+  _prev: unknown,
+  value: z.infer<typeof testRunSchema>,
+): Promise<ActionResponse> {
+  try {
+    testRunSchema.parse(value)
+
+    const result = await createTestRunFromValidatedValue(value)
+
+    return {
+      status: 200,
+      success: true,
+      message: 'Test run created successfully',
+      data: { testRunId: result.runId, id: result.id },
+    }
+  } catch (error) {
+    console.error('Error creating test run:', error)
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function checkTraceViewerStatusAction(testRunId: string, testCaseId: string): Promise<ActionResponse> {
+  try {
+    const outcome = await checkTraceViewerStatusService(testRunId, testCaseId)
+
+    if (outcome.kind === 'test_run_not_found') {
+      return {
+        status: 404,
+        success: false,
+        error: 'Test run not found',
+      }
+    }
+
+    if (outcome.kind === 'test_case_not_in_run') {
+      return {
+        status: 404,
+        success: false,
+        error: 'Test case not found in this test run',
+      }
+    }
+
+    return {
+      status: 200,
+      success: true,
+      data: {
+        isRunning: outcome.isRunning,
+        processName: outcome.processName,
+      },
+    }
+  } catch (error) {
+    console.error(
+      `[TestRunAction] Error checking trace viewer status for testRunId: ${testRunId}, testCaseId: ${testCaseId}:`,
+      error,
+    )
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function spawnTraceViewerAction(testRunId: string, testCaseId: string): Promise<ActionResponse> {
+  try {
+    const outcome = await spawnTraceViewerService(testRunId, testCaseId)
+
+    if (outcome.kind === 'test_run_not_found') {
+      return {
+        status: 404,
+        success: false,
+        error: 'Test run not found',
+      }
+    }
+
+    if (outcome.kind === 'test_case_not_in_run') {
+      return {
+        status: 404,
+        success: false,
+        error: 'Test case not found in this test run',
+      }
+    }
+
+    if (outcome.kind === 'no_trace_path') {
+      return {
+        status: 400,
+        success: false,
+        error: 'No trace path available for this test case',
+      }
+    }
+
+    if (outcome.kind === 'trace_file_missing') {
+      return {
+        status: 404,
+        success: false,
+        error: `Trace file not found at path: ${outcome.path}`,
+      }
+    }
+
+    return {
+      status: 200,
+      success: true,
+      message: 'Trace viewer launched successfully',
+      data: {
+        processName: outcome.processName,
+      },
+    }
+  } catch (error) {
+    console.error(
+      `[TestRunAction] Error spawning trace viewer for testRunId: ${testRunId}, testCaseId: ${testCaseId}:`,
+      error,
+    )
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function cancelTestRunAction(testRunId: string): Promise<ActionResponse> {
+  try {
+    const outcome = await cancelTestRunService(testRunId)
+
+    if (outcome.kind === 'not_found') {
+      return {
+        status: 404,
+        success: false,
+        error: 'Test run not found',
+      }
+    }
+
+    if (outcome.kind === 'invalid_state') {
+      return {
+        status: 400,
+        success: false,
+        error: outcome.message,
+      }
+    }
+
+    if (outcome.kind === 'already_cancelling') {
+      return {
+        status: 200,
+        success: true,
+        message: 'Test run cancellation is already in progress',
+      }
+    }
+
+    if (outcome.kind === 'cancelled_no_process') {
+      return {
+        status: 200,
+        success: true,
+        message: 'Test run cancelled successfully',
+      }
+    }
+
+    revalidatePath('/test-runs')
+    revalidatePath(`/test-runs/${testRunId}`)
+
+    return {
+      status: 200,
+      success: true,
+      message: 'Test run stopped successfully',
+    }
+  } catch (error) {
+    console.error(`[TestRunAction] Error stopping test run ${testRunId}:`, error)
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function checkTestRunNameUniqueAction(name: string, excludeId?: string): Promise<ActionResponse> {
+  try {
+    const nameExists = await isTestRunNameTaken(name, excludeId)
+    return {
+      status: 200,
+      success: true,
+      data: { isUnique: !nameExists },
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}