create-appraisejs 0.2.0 → 0.3.0-alpha.1

package/templates/starter/src/lib/utils/template-step-file-manager.ts

@@ -0,0 +1,166 @@
+import prisma from '@/config/db-config'
+import { writeTemplateStepFile, deleteTemplateStepFile, generateFileContent } from './template-step-file-generator'
+import { TemplateStepGroupType } from '@prisma/client'
+
+// TemplateStepGroupType helper - will be available from @prisma/client after migration
+type TemplateStepGroupTypeLocal = 'ACTION' | 'VALIDATION'
+
+// Type helper to safely extract type from Prisma templateStepGroup records
+type TemplateStepGroupWithType = {
+  id: string
+  name: string
+  description: string | null
+  type?: TemplateStepGroupTypeLocal
+  createdAt: Date
+  updatedAt: Date
+}
+
+function getGroupType(group: unknown): TemplateStepGroupTypeLocal {
+  const groupWithType = group as TemplateStepGroupWithType
+  const type = groupWithType.type
+  if (type === 'VALIDATION' || type === 'ACTION') {
+    return type
+  }
+  return 'ACTION' // default
+}
+
+/**
+ * Regenerates the file for a specific template step group
+ * This function is called whenever template steps in a group change
+ */
+export async function regenerateTemplateStepGroupFile(groupId: string): Promise<void> {
+  try {
+    // Get the template step group with all its template steps
+    const group = await prisma.templateStepGroup.findUnique({
+      where: { id: groupId },
+      include: {
+        templateSteps: {
+          orderBy: {
+            // Order by creation time or any other field you prefer
+            createdAt: 'asc',
+          },
+        },
+      },
+    })
+
+    if (!group) {
+      throw new Error(`Template step group with ID ${groupId} not found`)
+    }
+
+    // Generate file content from template steps
+    const content = generateFileContent(group.templateSteps)
+
+    // Write the file
+    const type = getGroupType(group)
+    await writeTemplateStepFile(group.name, content, type)
+
+    console.log(`File regenerated for template step group: ${group.name}`)
+  } catch (error) {
+    console.error(`Failed to regenerate file for template step group ${groupId}:`, error)
+    throw new Error(`File regeneration failed: ${error}`)
+  }
+}
+
+/**
+ * Creates a placeholder file for a new template step group
+ * Called when a new group is created
+ * @deprecated Use createTemplateStepGroupFile from template-step-file-manager-intelligent.ts instead
+ */
+export async function createTemplateStepGroupFile(
+  groupName: string,
+  type: TemplateStepGroupType | string = 'ACTION',
+): Promise<void> {
+  try {
+    // Create empty placeholder content with required imports
+    const placeholderContent =
+      '// This file is generated automatically. Add template steps to this group to generate content.'
+
+    // Write the placeholder file
+    await writeTemplateStepFile(groupName, placeholderContent, type)
+
+    console.log(`Placeholder file created for template step group: ${groupName}`)
+  } catch (error) {
+    console.error(`Failed to create placeholder file for group "${groupName}":`, error)
+    throw new Error(`File creation failed: ${error}`)
+  }
+}
+
+/**
+ * Deletes the file for a template step group
+ * Called when a group is deleted
+ * @deprecated Use removeTemplateStepGroupFile from template-step-file-manager-intelligent.ts instead
+ */
+export async function removeTemplateStepGroupFile(
+  groupName: string,
+  type: TemplateStepGroupType | string = 'ACTION',
+): Promise<void> {
+  try {
+    await deleteTemplateStepFile(groupName, type)
+
+    console.log(`File deleted for template step group: ${groupName}`)
+  } catch (error) {
+    console.error(`Failed to delete file for group "${groupName}":`, error)
+    throw new Error(`File deletion failed: ${error}`)
+  }
+}
+
+/**
+ * Handles file regeneration when a template step is created, updated, or deleted
+ * This function determines which groups need file regeneration
+ */
+export async function handleTemplateStepChange(
+  templateStepId: string,
+  operation: 'create' | 'update' | 'delete',
+): Promise<void> {
+  try {
+    let groupId: string | null = null
+
+    if (operation === 'delete') {
+      // For delete operations, we need to get the group ID before deletion
+      const step = await prisma.templateStep.findUnique({
+        where: { id: templateStepId },
+        select: { templateStepGroupId: true },
+      })
+      groupId = step?.templateStepGroupId || null
+    } else {
+      // For create/update operations, get the current group ID
+      const step = await prisma.templateStep.findUnique({
+        where: { id: templateStepId },
+        select: { templateStepGroupId: true },
+      })
+      groupId = step?.templateStepGroupId || null
+    }
+
+    if (groupId) {
+      // Regenerate the file for the affected group
+      await regenerateTemplateStepGroupFile(groupId)
+    }
+  } catch (error) {
+    console.error(`Failed to handle template step change for step ${templateStepId}:`, error)
+    throw new Error(`File update failed: ${error}`)
+  }
+}
+
+/**
+ * Handles file regeneration when a template step is moved between groups
+ * This is a special case that requires regenerating files for both groups
+ */
+export async function handleTemplateStepGroupChange(
+  oldGroupId: string | null,
+  newGroupId: string | null,
+): Promise<void> {
+  try {
+    // Regenerate file for the old group (if it exists)
+    if (oldGroupId) {
+      await regenerateTemplateStepGroupFile(oldGroupId)
+    }
+
+    // Regenerate file for the new group (if it exists)
+    if (newGroupId) {
+      await regenerateTemplateStepGroupFile(newGroupId)
+    }
+  } catch (error) {
+    console.error(`Failed to handle template step group change:`, error)
+    throw new Error(`File update failed: ${error}`)
+  }
+}

package/templates/starter/src/lib/utils.ts

@@ -0,0 +1,31 @@
+import { clsx, type ClassValue } from 'clsx'
+import { twMerge } from 'tailwind-merge'
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}
+
+export function calculateCompletionPercentage(total: number, completed: number) {
+  return Math.round((completed / total) * 100)
+}
+
+/**
+ * Formats a date to show only date and time (without seconds/milliseconds)
+ * @param date - Date string or Date object
+ * @returns Formatted date string in format: "MM/DD/YYYY, HH:MM AM/PM"
+ */
+export function formatDateTime(date: string | Date | null | undefined): string {
+  if (!date) return '-'
+
+  const dateObj = typeof date === 'string' ? new Date(date) : date
+
+  if (isNaN(dateObj.getTime())) return '-'
+
+  return dateObj.toLocaleString('en-US', {
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    hour12: true,
+  })
+}

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

@@ -0,0 +1,106 @@
+import { describe, expect, it, vi } from 'vitest'
+import { TestRunTestCaseResult } from '@prisma/client'
+import { getTestSuiteExecutionData } from './dashboard-service'
+
+vi.mock('@/config/db-config', () => ({
+  default: {
+    testRun: { findMany: vi.fn() },
+    report: { findMany: vi.fn() },
+  },
+}))
+
+import prisma from '@/config/db-config'
+
+describe('getTestSuiteExecutionData', () => {
+  it('returns empty array when no completed test runs', async () => {
+    vi.mocked(prisma.testRun.findMany).mockResolvedValue([] as never)
+    await expect(getTestSuiteExecutionData()).resolves.toEqual([])
+    expect(prisma.report.findMany).not.toHaveBeenCalled()
+  })
+
+  it('aggregates per-suite counts from reports', async () => {
+    vi.mocked(prisma.testRun.findMany).mockResolvedValue([{ id: 'run-1' }] as never)
+    vi.mocked(prisma.report.findMany).mockResolvedValue([
+      {
+        id: 'rep-1',
+        testCases: [
+          {
+            testRunTestCase: {
+              result: TestRunTestCaseResult.PASSED,
+              testCase: {
+                TestSuite: [{ id: 'suite-a', name: 'Alpha' }],
+              },
+            },
+          },
+          {
+            testRunTestCase: {
+              result: TestRunTestCaseResult.FAILED,
+              testCase: {
+                TestSuite: [{ id: 'suite-a', name: 'Alpha' }],
+              },
+            },
+          },
+          {
+            testRunTestCase: {
+              result: TestRunTestCaseResult.UNTESTED,
+              testCase: {
+                TestSuite: [{ id: 'suite-b', name: 'Beta' }],
+              },
+            },
+          },
+        ],
+      },
+    ] as never)
+
+    const data = await getTestSuiteExecutionData()
+
+    expect(data).toHaveLength(2)
+    const alpha = data.find(d => d.feature === 'Alpha')
+    const beta = data.find(d => d.feature === 'Beta')
+    expect(alpha).toMatchObject({
+      passed: 1,
+      failed: 1,
+      cancelled: 0,
+      unknown: 0,
+      total: 2,
+    })
+    expect(beta).toMatchObject({
+      passed: 0,
+      failed: 0,
+      cancelled: 1,
+      unknown: 0,
+      total: 1,
+    })
+  })
+
+  it('maps non-pass/fail/untested results to unknown', async () => {
+    vi.mocked(prisma.testRun.findMany).mockResolvedValue([{ id: 'run-1' }] as never)
+    vi.mocked(prisma.report.findMany).mockResolvedValue([
+      {
+        id: 'rep-1',
+        testCases: [
+          {
+            testRunTestCase: {
+              result: 'OTHER' as TestRunTestCaseResult,
+              testCase: {
+                TestSuite: [{ id: 'suite-x', name: 'Gamma' }],
+              },
+            },
+          },
+        ],
+      },
+    ] as never)
+
+    const data = await getTestSuiteExecutionData()
+    expect(data).toEqual([
+      expect.objectContaining({
+        feature: 'Gamma',
+        passed: 0,
+        failed: 0,
+        cancelled: 0,
+        unknown: 1,
+        total: 1,
+      }),
+    ])
+  })
+})

package/templates/starter/src/services/dashboard/dashboard-service.ts

@@ -0,0 +1,173 @@
+import prisma from '@/config/db-config'
+import { TestRunStatus, TestRunTestCaseResult } from '@prisma/client'
+
+/** Stacked bar segments are raw counts; `total` matches passed+failed+cancelled+unknown. */
+export type TestSuiteExecutionData = Array<{
+  feature: string
+  passed: number
+  failed: number
+  cancelled: number
+  unknown: number
+  total: number
+}>
+
+export type EntityMetrics = {
+  testCasesCount: number
+  testSuitesCount: number
+  templateStepsCount: number
+  runningTestRunsCount: number
+}
+
+export async function getDashboardMetrics() {
+  return prisma.dashboardMetrics.findFirst()
+}
+
+export async function getEntityMetrics(): Promise<EntityMetrics> {
+  const testCases = await prisma.testCase.count()
+  const testSuites = await prisma.testSuite.count()
+  const templateSteps = await prisma.templateStep.count()
+  const runningTestRuns = await prisma.testRun.count({
+    where: {
+      status: {
+        in: [TestRunStatus.RUNNING, TestRunStatus.QUEUED, TestRunStatus.CANCELLING],
+      },
+    },
+  })
+
+  return {
+    testCasesCount: testCases,
+    testSuitesCount: testSuites,
+    templateStepsCount: templateSteps,
+    runningTestRunsCount: runningTestRuns,
+  }
+}
+
+export async function getRunningTestRunsCount(): Promise<number> {
+  return prisma.testRun.count({
+    where: {
+      status: {
+        in: [TestRunStatus.RUNNING, TestRunStatus.QUEUED, TestRunStatus.CANCELLING],
+      },
+    },
+  })
+}
+
+export async function getTestSuiteExecutionData(): Promise<TestSuiteExecutionData> {
+  const testRuns = await prisma.testRun.findMany({
+    where: {
+      status: TestRunStatus.COMPLETED,
+      completedAt: {
+        not: null,
+      },
+    },
+    orderBy: {
+      completedAt: 'desc',
+    },
+    take: 10,
+    select: {
+      id: true,
+    },
+  })
+
+  if (testRuns.length === 0) {
+    return []
+  }
+
+  const testRunIds = testRuns.map(tr => tr.id)
+
+  const reports = await prisma.report.findMany({
+    where: {
+      testRunId: {
+        in: testRunIds,
+      },
+    },
+    include: {
+      testCases: {
+        include: {
+          testRunTestCase: {
+            include: {
+              testCase: {
+                include: {
+                  TestSuite: true,
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  })
+
+  const suiteDataMap = new Map<
+    string,
+    {
+      name: string
+      passed: number
+      failed: number
+      cancelled: number
+      unknown: number
+      total: number
+    }
+  >()
+
+  for (const report of reports) {
+    for (const reportTestCase of report.testCases) {
+      const testCase = reportTestCase.testRunTestCase.testCase
+      const result = reportTestCase.testRunTestCase.result
+
+      for (const testSuite of testCase.TestSuite) {
+        const suiteId = testSuite.id
+        const suiteName = testSuite.name
+
+        if (!suiteDataMap.has(suiteId)) {
+          suiteDataMap.set(suiteId, {
+            name: suiteName,
+            passed: 0,
+            failed: 0,
+            cancelled: 0,
+            unknown: 0,
+            total: 0,
+          })
+        }
+
+        const suiteData = suiteDataMap.get(suiteId)!
+        suiteData.total++
+
+        switch (result) {
+          case TestRunTestCaseResult.PASSED:
+            suiteData.passed++
+            break
+          case TestRunTestCaseResult.FAILED:
+            suiteData.failed++
+            break
+          case TestRunTestCaseResult.UNTESTED:
+            suiteData.cancelled++
+            break
+          default:
+            suiteData.unknown++
+            break
+        }
+      }
+    }
+  }
+
+  const result: TestSuiteExecutionData = []
+
+  for (const [, data] of suiteDataMap.entries()) {
+    const total = data.total
+    if (total === 0) continue
+
+    result.push({
+      feature: data.name,
+      passed: data.passed,
+      failed: data.failed,
+      cancelled: data.cancelled,
+      unknown: data.unknown,
+      total,
+    })
+  }
+
+  result.sort((a, b) => a.feature.localeCompare(b.feature))
+
+  return result
+}

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

@@ -0,0 +1,137 @@
+import { describe, expect, it, vi } from 'vitest'
+import { environmentSchema } from '@/constants/form-opts/environment-form-opts'
+import { automationProjectionService } from '@/lib/automation/projection-service'
+import {
+  createEnvironment,
+  deleteEnvironments,
+  getEnvironmentByIdOrThrow,
+  listEnvironments,
+  updateEnvironment,
+} from './environment-service'
+
+vi.mock('@/config/db-config', () => ({
+  default: {
+    environment: {
+      findUnique: vi.fn(),
+      findFirst: vi.fn(),
+      create: vi.fn(),
+      findMany: vi.fn(),
+      deleteMany: vi.fn(),
+      update: vi.fn(),
+    },
+  },
+}))
+
+vi.mock('@/lib/automation/projection-service', () => ({
+  automationProjectionService: {
+    syncEnvironments: vi.fn().mockResolvedValue(undefined),
+  },
+}))
+
+import prisma from '@/config/db-config'
+
+const basePayload = environmentSchema.parse({
+  name: 'Dev',
+  baseUrl: 'https://example.com',
+  apiBaseUrl: '',
+  username: '',
+  password: '',
+})
+
+describe('getEnvironmentByIdOrThrow', () => {
+  it('throws when environment is missing', async () => {
+    vi.mocked(prisma.environment.findUnique).mockResolvedValue(null)
+    await expect(getEnvironmentByIdOrThrow('missing')).rejects.toMatchObject({
+      message: 'Environment not found',
+      statusCode: 404,
+    })
+  })
+})
+
+describe('createEnvironment', () => {
+  it('throws when name already exists', async () => {
+    vi.mocked(prisma.environment.findFirst).mockResolvedValue({ id: 'e1' } as never)
+    await expect(createEnvironment(basePayload)).rejects.toMatchObject({
+      message: expect.stringContaining('already exists'),
+      statusCode: 400,
+    })
+    expect(prisma.environment.create).not.toHaveBeenCalled()
+  })
+
+  it('creates and returns environment when name is unique', async () => {
+    vi.mocked(prisma.environment.findFirst).mockResolvedValue(null)
+    const created = { id: 'new-id', name: 'Dev' }
+    vi.mocked(prisma.environment.create).mockResolvedValue(created as never)
+
+    await expect(createEnvironment(basePayload)).resolves.toEqual(created)
+    expect(prisma.environment.create).toHaveBeenCalledWith({
+      data: {
+        name: 'Dev',
+        baseUrl: 'https://example.com',
+        apiBaseUrl: null,
+        username: null,
+        password: null,
+      },
+    })
+    expect(automationProjectionService.syncEnvironments).toHaveBeenCalled()
+  })
+})
+
+describe('listEnvironments', () => {
+  it('loads environments and syncs the projection file', async () => {
+    vi.mocked(prisma.environment.findMany).mockResolvedValue([{ id: 'env-1' }] as never)
+
+    await expect(listEnvironments()).resolves.toEqual([{ id: 'env-1' }])
+    expect(prisma.environment.findMany).toHaveBeenCalledWith({
+      orderBy: { createdAt: 'desc' },
+    })
+    expect(automationProjectionService.syncEnvironments).toHaveBeenCalled()
+  })
+})
+
+describe('deleteEnvironments', () => {
+  it('deletes environments and syncs projection output', async () => {
+    vi.mocked(prisma.environment.deleteMany).mockResolvedValue({ count: 1 } as never)
+
+    await deleteEnvironments(['env-1'])
+
+    expect(prisma.environment.deleteMany).toHaveBeenCalledWith({
+      where: { id: { in: ['env-1'] } },
+    })
+    expect(automationProjectionService.syncEnvironments).toHaveBeenCalled()
+  })
+})
+
+describe('updateEnvironment', () => {
+  it('updates the environment, normalizes blank fields, and syncs projections', async () => {
+    vi.mocked(prisma.environment.findUnique)
+      .mockResolvedValueOnce({ name: 'Old Name' } as never)
+      .mockResolvedValueOnce({ id: 'env-1' } as never)
+    vi.mocked(prisma.environment.findFirst).mockResolvedValue(null)
+    vi.mocked(prisma.environment.update).mockResolvedValue({ id: 'env-1', name: 'Dev' } as never)
+
+    const result = await updateEnvironment(
+      'env-1',
+      environmentSchema.parse({
+        name: 'Dev',
+        baseUrl: 'https://example.com',
+        apiBaseUrl: '',
+        username: '',
+        password: '',
+      }),
+    )
+
+    expect(result).toEqual({ id: 'env-1', name: 'Dev' })
+    expect(prisma.environment.update).toHaveBeenCalledWith({
+      where: { id: 'env-1' },
+      data: {
+        name: 'Dev',
+        baseUrl: 'https://example.com',
+        apiBaseUrl: null,
+        username: null,
+        password: null,
+      },
+    })
+    expect(automationProjectionService.syncEnvironments).toHaveBeenCalled()
+  })
+})

package/templates/starter/src/services/environment/environment-service.ts

@@ -0,0 +1,96 @@
+import prisma from '@/config/db-config'
+import { environmentSchema } from '@/constants/form-opts/environment-form-opts'
+import { automationProjectionService } from '@/lib/automation/projection-service'
+import { ServiceError } from '@/services/shared/errors'
+import type { Environment } from '@prisma/client'
+import type { z } from 'zod'
+
+async function checkUniqueName(name: string, excludeId?: string): Promise<boolean> {
+  const existing = await prisma.environment.findFirst({
+    where: {
+      name,
+      ...(excludeId && { id: { not: excludeId } }),
+    },
+  })
+  return !!existing
+}
+
+function normalizeEnvironmentPayload(value: z.infer<typeof environmentSchema>) {
+  return {
+    ...value,
+    apiBaseUrl: value.apiBaseUrl === '' ? null : value.apiBaseUrl,
+    username: value.username === '' ? null : value.username,
+    password: value.password === '' ? null : value.password,
+  }
+}
+
+export async function listEnvironments(): Promise<Environment[]> {
+  const environments = await prisma.environment.findMany({
+    orderBy: { createdAt: 'desc' },
+  })
+  await automationProjectionService.syncEnvironments()
+  return environments
+}
+
+export async function deleteEnvironments(ids: string[]): Promise<void> {
+  await prisma.environment.deleteMany({ where: { id: { in: ids } } })
+  await automationProjectionService.syncEnvironments()
+}
+
+export async function createEnvironment(value: z.infer<typeof environmentSchema>): Promise<Environment> {
+  const nameExists = await checkUniqueName(value.name)
+  if (nameExists) {
+    throw new ServiceError(
+      'An environment with this name already exists. Please choose a different name.',
+      'VALIDATION',
+      400,
+    )
+  }
+  const newEnvironment = await prisma.environment.create({
+    data: normalizeEnvironmentPayload(value),
+  })
+  await automationProjectionService.syncEnvironments()
+  return newEnvironment
+}
+
+export async function getEnvironmentByIdOrThrow(id: string): Promise<Environment> {
+  const environmentData = await prisma.environment.findUnique({ where: { id } })
+  if (!environmentData) {
+    throw new ServiceError('Environment not found', 'NOT_FOUND', 404)
+  }
+  return environmentData
+}
+
+export async function updateEnvironment(
+  id: string | undefined,
+  value: z.infer<typeof environmentSchema>,
+): Promise<Environment> {
+  if (!id) {
+    throw new ServiceError('Environment id is required', 'VALIDATION', 400)
+  }
+  const currentEnvironment = await prisma.environment.findUnique({
+    where: { id },
+    select: { name: true },
+  })
+  if (!currentEnvironment) {
+    throw new ServiceError('Environment not found', 'NOT_FOUND', 404)
+  }
+
+  if (currentEnvironment.name !== value.name) {
+    const nameExists = await checkUniqueName(value.name, id)
+    if (nameExists) {
+      throw new ServiceError(
+        'An environment with this name already exists. Please choose a different name.',
+        'VALIDATION',
+        400,
+      )
+    }
+  }
+
+  const updatedEnvironment = await prisma.environment.update({
+    where: { id },
+    data: normalizeEnvironmentPayload(value),
+  })
+  await automationProjectionService.syncEnvironments()
+  return updatedEnvironment
+}