create-appraisejs 0.2.0 → 0.3.0-alpha.1

package/templates/starter/src/services/template-step/template-step-service.ts

@@ -0,0 +1,171 @@
+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 { ServiceError } from '@/services/shared/errors'
+import { Prisma, StepParameterType, TemplateStepIcon, TemplateStepType } from '@prisma/client'
+import prettier from 'prettier'
+import type { TemplateStep, TemplateStepParameter } from '@prisma/client'
+import type { 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
+  }
+}
+
+const templateStepDetailInclude = {
+  parameters: true,
+  templateStepGroup: true,
+} as const
+
+export type TemplateStepDetail = Prisma.TemplateStepGetPayload<{ include: typeof templateStepDetailInclude }>
+
+export async function listTemplateSteps() {
+  return prisma.templateStep.findMany({
+    include: {
+      parameters: {
+        select: { id: true, name: true },
+      },
+      templateStepGroup: true,
+    },
+  })
+}
+
+export async function deleteTemplateSteps(templateStepIds: string[]): Promise<void> {
+  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)))
+}
+
+export async function createTemplateStep(value: z.infer<typeof templateStepSchema>): Promise<TemplateStep> {
+  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)
+  return newTemplateStep
+}
+
+export async function updateTemplateStep(
+  id: string | undefined,
+  value: z.infer<typeof templateStepSchema>,
+): Promise<TemplateStep> {
+  if (!id) {
+    throw new ServiceError('Template step ID is required', 'VALIDATION', 400)
+  }
+
+  const currentStep = await prisma.templateStep.findUnique({
+    where: { id },
+    select: { templateStepGroupId: true },
+  })
+  if (!currentStep) {
+    throw new ServiceError('Template step not found', 'NOT_FOUND', 404)
+  }
+
+  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)))
+
+  return updatedTemplateStep
+}
+
+export async function getTemplateStepByIdOrThrow(id: string): Promise<TemplateStepDetail> {
+  const templateStep = await prisma.templateStep.findUnique({
+    where: { id },
+    include: templateStepDetailInclude,
+  })
+  if (!templateStep) {
+    throw new ServiceError('Template step not found', 'NOT_FOUND', 404)
+  }
+  return templateStep
+}
+
+export async function listAllTemplateStepParameters(): Promise<TemplateStepParameter[]> {
+  return prisma.templateStepParameter.findMany({})
+}

package/templates/starter/src/services/template-step-group/template-step-group-service.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it, vi } from 'vitest'
+import { getTemplateStepGroupByIdOrThrow } from './template-step-group-service'
+
+vi.mock('@/config/db-config', () => ({
+  default: {
+    templateStepGroup: {
+      findUnique: vi.fn(),
+    },
+  },
+}))
+
+import prisma from '@/config/db-config'
+
+describe('getTemplateStepGroupByIdOrThrow', () => {
+  it('throws when template step group is missing', async () => {
+    vi.mocked(prisma.templateStepGroup.findUnique).mockResolvedValue(null)
+    await expect(getTemplateStepGroupByIdOrThrow('missing')).rejects.toMatchObject({
+      message: 'Template step group not found',
+      statusCode: 404,
+    })
+  })
+})

package/templates/starter/src/services/template-step-group/template-step-group-service.ts

@@ -0,0 +1,81 @@
+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 { ServiceError } from '@/services/shared/errors'
+import type { TemplateStepGroup } from '@prisma/client'
+import type { z } from 'zod'
+
+type TemplateStepGroupType = 'ACTION' | 'VALIDATION'
+
+function getGroupType(group: Pick<TemplateStepGroup, 'type'>): TemplateStepGroupType {
+  return group.type === 'VALIDATION' ? 'VALIDATION' : 'ACTION'
+}
+
+function normalizeOptionalText(value: string | null | undefined): string | null {
+  const normalized = value?.trim()
+  return normalized ? normalized : null
+}
+
+export async function listTemplateStepGroups(): Promise<TemplateStepGroup[]> {
+  return prisma.templateStepGroup.findMany()
+}
+
+export async function createTemplateStepGroup(value: z.infer<typeof templateStepGroupSchema>): Promise<TemplateStepGroup> {
+  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)
+  return createdGroup
+}
+
+export async function deleteTemplateStepGroups(ids: string[]): Promise<void> {
+  await Promise.all(ids.map(id => automationProjectionService.deleteTemplateStepGroup(id)))
+  await prisma.templateStepGroup.deleteMany({ where: { id: { in: ids } } })
+}
+
+export async function getTemplateStepGroupByIdOrThrow(id: string): Promise<TemplateStepGroup> {
+  const templateStepGroup = await prisma.templateStepGroup.findUnique({ where: { id } })
+  if (!templateStepGroup) {
+    throw new ServiceError('Template step group not found', 'NOT_FOUND', 404)
+  }
+  return templateStepGroup
+}
+
+export async function updateTemplateStepGroup(
+  id: string | undefined,
+  value: z.infer<typeof templateStepGroupSchema>,
+): Promise<void> {
+  if (!id) {
+    throw new ServiceError('Template step group ID is required', 'VALIDATION', 400)
+  }
+
+  const currentGroup = await prisma.templateStepGroup.findUnique({ where: { id } })
+  if (!currentGroup) {
+    throw new ServiceError('Template step group not found', 'NOT_FOUND', 404)
+  }
+
+  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)
+}

package/templates/starter/src/services/template-test-case/template-test-case-service.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it, vi } from 'vitest'
+import { getTemplateTestCaseByIdOrThrow } from './template-test-case-service'
+
+vi.mock('@/config/db-config', () => ({
+  default: {
+    templateTestCase: {
+      findUnique: vi.fn(),
+    },
+  },
+}))
+
+import prisma from '@/config/db-config'
+
+describe('getTemplateTestCaseByIdOrThrow', () => {
+  it('throws when template test case is missing', async () => {
+    vi.mocked(prisma.templateTestCase.findUnique).mockResolvedValue(null)
+    await expect(getTemplateTestCaseByIdOrThrow('missing')).rejects.toMatchObject({
+      message: 'Template test case not found',
+      statusCode: 404,
+    })
+  })
+})

package/templates/starter/src/services/template-test-case/template-test-case-service.ts

@@ -0,0 +1,128 @@
+import prisma from '@/config/db-config'
+import { templateTestCaseSchema } from '@/constants/form-opts/template-test-case-form-opts'
+import { ServiceError } from '@/services/shared/errors'
+import { Prisma, StepParameterType } from '@prisma/client'
+import type { TemplateTestCase } from '@prisma/client'
+import type { z } from 'zod'
+
+const templateTestCaseInclude = {
+  steps: {
+    include: {
+      parameters: true,
+    },
+  },
+} as const
+
+export type TemplateTestCaseDetail = Prisma.TemplateTestCaseGetPayload<{ include: typeof templateTestCaseInclude }>
+
+export async function listTemplateTestCases() {
+  return prisma.templateTestCase.findMany({
+    include: templateTestCaseInclude,
+  })
+}
+
+export async function deleteTemplateTestCases(ids: string[]): Promise<void> {
+  await prisma.$transaction(async tx => {
+    await tx.templateTestCaseStepParameter.deleteMany({
+      where: {
+        templateTestCaseStep: {
+          templateTestCaseId: { in: ids },
+        },
+      },
+    })
+    await tx.templateTestCaseStep.deleteMany({
+      where: { templateTestCaseId: { in: ids } },
+    })
+    await tx.templateTestCase.deleteMany({ where: { id: { in: ids } } })
+  })
+}
+
+export async function createTemplateTestCase(value: z.infer<typeof templateTestCaseSchema>): Promise<TemplateTestCase> {
+  return 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,
+        })),
+      },
+    },
+  })
+}
+
+export async function getTemplateTestCaseByIdOrThrow(id: string): Promise<TemplateTestCaseDetail> {
+  const templateTestCase = await prisma.templateTestCase.findUnique({
+    where: { id },
+    include: templateTestCaseInclude,
+  })
+  if (!templateTestCase) {
+    throw new ServiceError('Template test case not found', 'NOT_FOUND', 404)
+  }
+  return templateTestCase
+}
+
+export async function updateTemplateTestCase(
+  id: string | undefined,
+  value: z.infer<typeof templateTestCaseSchema>,
+): Promise<TemplateTestCase> {
+  if (!id) {
+    throw new ServiceError(
+      "updateTemplateTestCase: 'id' parameter is required for updating a template test case.",
+      'VALIDATION',
+      400,
+    )
+  }
+
+  const steps = await prisma.templateTestCaseStep.findMany({
+    where: { templateTestCaseId: id },
+    select: { id: true },
+  })
+  const stepIds = steps.map(step => step.id)
+
+  if (stepIds.length > 0) {
+    await prisma.templateTestCaseStepParameter.deleteMany({
+      where: { templateTestCaseStep: { id: { in: stepIds } } },
+    })
+  }
+
+  await prisma.templateTestCaseStep.deleteMany({ where: { templateTestCaseId: id } })
+
+  return 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 },
+  })
+}

package/templates/starter/src/services/test-case/test-case-service.test.ts

@@ -0,0 +1,175 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { StepParameterType, TagType, TemplateStepIcon } from '@prisma/client'
+import { createTestCaseFromInput, updateTestCaseFromInput, deleteTestCasesByIds } from './test-case-service'
+
+vi.mock('@/config/db-config', () => ({
+  default: {
+    testSuite: { findMany: vi.fn() },
+    tag: { findMany: vi.fn(), create: vi.fn() },
+    $transaction: vi.fn(),
+    testCase: { create: vi.fn(), findUnique: vi.fn(), update: vi.fn() },
+    testCaseStep: { findMany: vi.fn(), deleteMany: vi.fn() },
+    testCaseStepParameter: { deleteMany: vi.fn() },
+  },
+}))
+
+vi.mock('@/lib/automation/projection-service', () => ({
+  automationProjectionService: {
+    generateFeature: vi.fn().mockResolvedValue(undefined),
+  },
+}))
+
+import prisma from '@/config/db-config'
+import { automationProjectionService } from '@/lib/automation/projection-service'
+
+const baseInput = {
+  title: 'Login works',
+  description: 'Checks login',
+  testSuiteIds: ['suite-a'],
+  tagIds: ['tag-1'],
+  steps: [
+    {
+      gherkinStep: 'Given I log in',
+      label: 'Login',
+      icon: TemplateStepIcon.MOUSE,
+      parameters: [
+        {
+          name: 'username',
+          value: 'demo@example.com',
+          type: StepParameterType.STRING,
+          order: 0,
+        },
+      ],
+      order: 0,
+      templateStepId: 'template-1',
+    },
+  ],
+}
+
+function createMockTx() {
+  return {
+    testRunTestCase: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }) },
+    review: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }) },
+    linkedJiraTicket: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }) },
+    testCaseStepParameter: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }) },
+    testCaseStep: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }) },
+    tag: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }) },
+    testCase: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }) },
+  }
+}
+
+describe('deleteTestCasesByIds', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('loads suites and tags, runs transactional deletes, then regenerates features for affected suites', async () => {
+    vi.mocked(prisma.testSuite.findMany).mockResolvedValue([{ id: 'suite-a' }, { id: 'suite-b' }] as never)
+    vi.mocked(prisma.tag.findMany).mockResolvedValue([{ id: 'tag-1' }] as never)
+
+    const tx = createMockTx()
+    vi.mocked(prisma.$transaction).mockImplementation(async fn => {
+      await fn(tx as never)
+    })
+
+    await deleteTestCasesByIds(['tc-1', 'tc-2'])
+
+    expect(prisma.testSuite.findMany).toHaveBeenCalled()
+    expect(prisma.tag.findMany).toHaveBeenCalled()
+    expect(tx.testCase.deleteMany).toHaveBeenCalledWith({
+      where: { id: { in: ['tc-1', 'tc-2'] } },
+    })
+    expect(tx.tag.deleteMany).toHaveBeenCalledWith({
+      where: { id: { in: ['tag-1'] } },
+    })
+    expect(automationProjectionService.generateFeature).toHaveBeenCalledWith('suite-a')
+    expect(automationProjectionService.generateFeature).toHaveBeenCalledWith('suite-b')
+  })
+
+  it('still completes transaction when no suites need feature regeneration', async () => {
+    vi.mocked(prisma.testSuite.findMany).mockResolvedValue([] as never)
+    vi.mocked(prisma.tag.findMany).mockResolvedValue([] as never)
+    const tx = createMockTx()
+    vi.mocked(prisma.$transaction).mockImplementation(async fn => {
+      await fn(tx as never)
+    })
+
+    await deleteTestCasesByIds(['tc-x'])
+
+    expect(automationProjectionService.generateFeature).not.toHaveBeenCalled()
+    expect(tx.testCase.deleteMany).toHaveBeenCalled()
+  })
+})
+
+describe('createTestCaseFromInput', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('creates an identifier tag, persists the test case, and regenerates affected features', async () => {
+    vi.mocked(prisma.tag.create).mockResolvedValue({ id: 'identifier-tag' } as never)
+    vi.mocked(prisma.testCase.create).mockResolvedValue({
+      id: 'tc-1',
+      TestSuite: [{ id: 'suite-a' }],
+    } as never)
+
+    const result = await createTestCaseFromInput(baseInput)
+
+    expect(result).toEqual({
+      id: 'tc-1',
+      TestSuite: [{ id: 'suite-a' }],
+    })
+    expect(prisma.tag.create).toHaveBeenCalledWith({
+      data: {
+        name: expect.stringMatching(/^tc_/),
+        type: TagType.IDENTIFIER,
+        tagExpression: expect.stringMatching(/^@tc_/),
+      },
+    })
+    expect(prisma.testCase.create).toHaveBeenCalled()
+    expect(automationProjectionService.generateFeature).toHaveBeenCalledWith('suite-a')
+  })
+})
+
+describe('updateTestCaseFromInput', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('replaces steps, preserves identifier tags, and regenerates affected suite features', async () => {
+    vi.mocked(prisma.testSuite.findMany).mockResolvedValue([{ id: 'suite-a' }] as never)
+    vi.mocked(prisma.testCaseStep.findMany).mockResolvedValue([{ id: 'step-1' }] as never)
+    vi.mocked(prisma.testCase.findUnique).mockResolvedValue({
+      id: 'tc-1',
+      tags: [{ id: 'identifier-tag' }],
+    } as never)
+    vi.mocked(prisma.testCase.update).mockResolvedValue({
+      id: 'tc-1',
+      steps: [],
+    } as never)
+
+    const result = await updateTestCaseFromInput(baseInput, 'tc-1')
+
+    expect(result).toEqual({ id: 'tc-1', steps: [] })
+    expect(prisma.testCaseStepParameter.deleteMany).toHaveBeenCalledWith({
+      where: { testCaseStepId: { in: ['step-1'] } },
+    })
+    expect(prisma.testCaseStep.deleteMany).toHaveBeenCalledWith({
+      where: { testCaseId: 'tc-1' },
+    })
+    expect(prisma.testCase.update).toHaveBeenCalledWith({
+      where: { id: 'tc-1' },
+      data: expect.objectContaining({
+        title: 'Login works',
+        description: 'Checks login',
+        tags: {
+          set: [{ id: 'identifier-tag' }, { id: 'tag-1' }],
+        },
+      }),
+      include: {
+        steps: true,
+      },
+    })
+    expect(automationProjectionService.generateFeature).toHaveBeenCalledWith('suite-a')
+  })
+})