create-appraisejs 0.2.0 → 0.3.0-alpha.0

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

@@ -1,166 +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}`)
-  }
-}
+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/default/src/lib/utils.ts

@@ -1,31 +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,
-  })
-}
+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/default/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/default/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
+}