create-appraisejs 0.3.0 → 0.3.1-alpha.1

package/templates/blank/src/lib/metrics/metric-calculator.ts

@@ -12,6 +12,40 @@ const REPEATEDLY_FAILING_THRESHOLD = 3
  */
 const FLAKY_THRESHOLD = 0.05
 
+type CompletedTestRunTestCase = {
+  result: TestRunTestCaseResult | null
+  testRun: {
+    completedAt: Date | null
+  }
+}
+
+type TestCaseMetricSummary = {
+  totalRecentRuns: number
+  failedRecentRuns: number
+  failureRate: number
+  isFlaky: boolean
+  consecutiveFailures: number
+  isRepeatedlyFailing: boolean
+}
+
+type RecalculatedMetricDates = {
+  lastExecutedAt: Date | null
+  lastFailedAt: Date | null
+  lastPassedAt: Date | null
+}
+
+type RecalculatedMetricUpdateData = {
+  lastExecutedAt?: Date
+  lastFailedAt?: Date | null
+  lastPassedAt?: Date | null
+  isRepeatedlyFailing: boolean
+  isFlaky: boolean
+  consecutiveFailures: number
+  failureRate: number
+  totalRecentRuns: number
+  failedRecentRuns: number
+}
+
 /**
  * Calculate the date threshold for recent runs
  */
@@ -21,6 +55,65 @@ function getRecentPeriodDate(): Date {
   return now
 }
 
+function summarizeRecentTestCaseRuns(recentTestRunTestCases: CompletedTestRunTestCase[]): TestCaseMetricSummary {
+  const totalRecentRuns = recentTestRunTestCases.length
+  const failedRecentRuns = recentTestRunTestCases.filter(trtc => trtc.result === TestRunTestCaseResult.FAILED).length
+  const failureRate = totalRecentRuns > 0 ? failedRecentRuns / totalRecentRuns : 0
+  const consecutiveFailures = countConsecutiveFailures(recentTestRunTestCases)
+
+  return {
+    totalRecentRuns,
+    failedRecentRuns,
+    failureRate,
+    isFlaky: failureRate > FLAKY_THRESHOLD && failureRate < 1.0,
+    consecutiveFailures,
+    isRepeatedlyFailing: consecutiveFailures >= REPEATEDLY_FAILING_THRESHOLD,
+  }
+}
+
+function countConsecutiveFailures(testRunTestCases: CompletedTestRunTestCase[]): number {
+  let consecutiveFailures = 0
+
+  for (const trtc of testRunTestCases) {
+    if (trtc.result === TestRunTestCaseResult.FAILED) {
+      consecutiveFailures++
+    } else if (trtc.result === TestRunTestCaseResult.PASSED) {
+      break
+    }
+  }
+
+  return consecutiveFailures
+}
+
+async function findRecentCompletedTestRunTestCases(
+  testCaseId: string,
+  recentPeriodDate: Date,
+): Promise<CompletedTestRunTestCase[]> {
+  return prisma.testRunTestCase.findMany({
+    where: {
+      testCaseId,
+      status: TestRunTestCaseStatus.COMPLETED,
+      testRun: {
+        completedAt: {
+          gte: recentPeriodDate,
+        },
+      },
+    },
+    include: {
+      testRun: {
+        select: {
+          completedAt: true,
+        },
+      },
+    },
+    orderBy: {
+      testRun: {
+        completedAt: 'desc',
+      },
+    },
+  })
+}
+
 /**
  * Updates metrics for a single test case
  * @param testCaseId - The test case ID
@@ -41,57 +134,10 @@ export async function updateTestCaseMetrics(
     // Query recent runs for this test case (last 7 days)
     const recentPeriodDate = getRecentPeriodDate()
 
-    const recentTestRunTestCases = await prisma.testRunTestCase.findMany({
-      where: {
-        testCaseId,
-        status: TestRunTestCaseStatus.COMPLETED,
-        testRun: {
-          completedAt: {
-            gte: recentPeriodDate,
-          },
-        },
-      },
-      include: {
-        testRun: {
-          select: {
-            completedAt: true,
-          },
-        },
-      },
-      orderBy: {
-        testRun: {
-          completedAt: 'desc',
-        },
-      },
-    })
-
-    const totalRecentRuns = recentTestRunTestCases.length
-    const failedRecentRuns = recentTestRunTestCases.filter(
-      trtc => trtc.result === TestRunTestCaseResult.FAILED,
-    ).length
-
-    // Calculate failure rate
-    const failureRate = totalRecentRuns > 0 ? failedRecentRuns / totalRecentRuns : 0
-
-    // Determine if flaky (failure rate > 5% but < 100%)
-    const isFlaky = failureRate > FLAKY_THRESHOLD && failureRate < 1.0
-
-    // Calculate consecutive failures by examining the actual sequence of results
-    // Start from the most recent and count backwards
-    // This ensures accuracy even if test runs are processed out of order
-    let consecutiveFailures = 0
-    for (const trtc of recentTestRunTestCases) {
-      if (trtc.result === TestRunTestCaseResult.FAILED) {
-        consecutiveFailures++
-      } else if (trtc.result === TestRunTestCaseResult.PASSED) {
-        // Once we hit a pass, stop counting consecutive failures
-        break
-      }
-      // UNTESTED results don't break the consecutive failure count
-    }
+    const recentTestRunTestCases = await findRecentCompletedTestRunTestCases(testCaseId, recentPeriodDate)
 
-    // Determine if repeatedly failing (3+ consecutive failures)
-    const isRepeatedlyFailing = consecutiveFailures >= REPEATEDLY_FAILING_THRESHOLD
+    const { totalRecentRuns, failedRecentRuns, failureRate, isFlaky, consecutiveFailures, isRepeatedlyFailing } =
+      summarizeRecentTestCaseRuns(recentTestRunTestCases)
 
     // Determine which date fields to update
     const updateData: {
@@ -140,10 +186,7 @@ export async function updateTestCaseMetrics(
  * @param testSuiteId - The test suite ID
  * @param executedAt - When the test suite was executed
  */
-export async function updateTestSuiteMetrics(
-  testSuiteId: string,
-  executedAt: Date,
-): Promise<void> {
+export async function updateTestSuiteMetrics(testSuiteId: string, executedAt: Date): Promise<void> {
   try {
     await prisma.testSuiteMetrics.upsert({
       where: { testSuiteId },
@@ -166,10 +209,7 @@ export async function updateTestSuiteMetrics(
  * @param testRunId - The test run ID
  * @param executedAt - When the test run was executed
  */
-export async function updateTestSuitesForTestRun(
-  testRunId: string,
-  executedAt: Date,
-): Promise<void> {
+async function updateTestSuitesForTestRun(testRunId: string, executedAt: Date): Promise<void> {
   try {
     // Get all test cases in the test run
     const testRunTestCases = await prisma.testRunTestCase.findMany({
@@ -236,31 +276,52 @@ export async function updateDashboardMetrics(): Promise<void> {
       },
     })
 
-    // Count repeatedly failing tests
-    const repeatedlyFailingTestsCount = await prisma.testCaseMetrics.count({
+    // Count repeatedly failing live tests
+    const repeatedlyFailingTestsCount = await prisma.testCase.count({
       where: {
-        isRepeatedlyFailing: true,
+        metrics: {
+          is: {
+            isRepeatedlyFailing: true,
+          },
+        },
       },
     })
 
-    // Count flaky tests
-    const flakyTestsCount = await prisma.testCaseMetrics.count({
+    // Count flaky live tests
+    const flakyTestsCount = await prisma.testCase.count({
       where: {
-        isFlaky: true,
+        metrics: {
+          is: {
+            isFlaky: true,
+          },
+        },
       },
     })
 
-    // Count suites not executed recently
-    const suitesNotExecutedRecentlyCount = await prisma.testSuiteMetrics.count({
+    // Count live suites with no execution metrics or stale execution metrics
+    const suitesNotExecutedRecentlyCount = await prisma.testSuite.count({
       where: {
         OR: [
           {
-            lastExecutedAt: {
-              lt: recentPeriodDate,
+            metrics: {
+              is: null,
             },
           },
           {
-            lastExecutedAt: null,
+            metrics: {
+              is: {
+                lastExecutedAt: null,
+              },
+            },
+          },
+          {
+            metrics: {
+              is: {
+                lastExecutedAt: {
+                  lt: recentPeriodDate,
+                },
+              },
+            },
           },
         ],
       },
@@ -307,245 +368,165 @@ export async function recalculateTestCaseMetrics(testCaseId: string): Promise<vo
   try {
     const recentPeriodDate = getRecentPeriodDate()
 
-    // Query all recent test run test cases for this test case (last 7 days)
-    const recentTestRunTestCases = await prisma.testRunTestCase.findMany({
-      where: {
+    const recentTestRunTestCases = await findRecentCompletedTestRunTestCases(testCaseId, recentPeriodDate)
+
+    const metricSummary = summarizeRecentTestCaseRuns(recentTestRunTestCases)
+    const recalculatedDates = await resolveRecalculatedMetricDates(testCaseId, recentPeriodDate, recentTestRunTestCases)
+    const updateData = buildRecalculatedMetricUpdateData(metricSummary, recalculatedDates)
+
+    // Upsert the metrics
+    await prisma.testCaseMetrics.upsert({
+      where: { testCaseId },
+      create: {
         testCaseId,
-        status: TestRunTestCaseStatus.COMPLETED,
-        testRun: {
-          completedAt: {
-            gte: recentPeriodDate,
-          },
-        },
-      },
-      include: {
-        testRun: {
-          select: {
-            completedAt: true,
-          },
-        },
-      },
-      orderBy: {
-        testRun: {
-          completedAt: 'desc',
-        },
+        lastExecutedAt: recalculatedDates.lastExecutedAt || undefined,
+        lastFailedAt: recalculatedDates.lastFailedAt || undefined,
+        lastPassedAt: recalculatedDates.lastPassedAt || undefined,
+        ...updateData,
       },
+      update: updateData,
     })
+  } catch (error) {
+    console.error(`[MetricCalculator] Error recalculating test case metrics for ${testCaseId}:`, error)
+    // Don't throw - metrics are non-critical
+  }
+}
 
-    const totalRecentRuns = recentTestRunTestCases.length
-    const failedRecentRuns = recentTestRunTestCases.filter(
-      trtc => trtc.result === TestRunTestCaseResult.FAILED,
-    ).length
-
-    // Calculate failure rate
-    const failureRate = totalRecentRuns > 0 ? failedRecentRuns / totalRecentRuns : 0
-
-    // Determine if flaky (failure rate > 5% but < 100%)
-    const isFlaky = failureRate > FLAKY_THRESHOLD && failureRate < 1.0
-
-    // Calculate consecutive failures by examining the actual sequence of results
-    // Start from the most recent and count backwards
-    let consecutiveFailures = 0
-    for (const trtc of recentTestRunTestCases) {
-      if (trtc.result === TestRunTestCaseResult.FAILED) {
-        consecutiveFailures++
-      } else if (trtc.result === TestRunTestCaseResult.PASSED) {
-        // Once we hit a pass, stop counting consecutive failures
-        break
-      }
-      // UNTESTED results don't break the consecutive failure count
-    }
+async function resolveRecalculatedMetricDates(
+  testCaseId: string,
+  recentPeriodDate: Date,
+  recentTestRunTestCases: CompletedTestRunTestCase[],
+): Promise<RecalculatedMetricDates> {
+  const dates: RecalculatedMetricDates = {
+    lastExecutedAt: getCompletedAt(recentTestRunTestCases[0]),
+    lastFailedAt: getMostRecentResultDate(recentTestRunTestCases, TestRunTestCaseResult.FAILED),
+    lastPassedAt: getMostRecentResultDate(recentTestRunTestCases, TestRunTestCaseResult.PASSED),
+  }
+
+  if (dates.lastExecutedAt && dates.lastFailedAt && dates.lastPassedAt) {
+    return dates
+  }
 
-    // Determine if repeatedly failing (3+ consecutive failures)
-    const isRepeatedlyFailing = consecutiveFailures >= REPEATEDLY_FAILING_THRESHOLD
+  const olderTestRunTestCases = await findMostRecentOlderTestRunTestCases(testCaseId, recentPeriodDate)
+  const mostRecentOlderCompletedAt = getCompletedAt(olderTestRunTestCases[0])
 
-    // Determine last executed, last failed, and last passed dates
-    let lastExecutedAt: Date | null = null
-    let lastFailedAt: Date | null = null
-    let lastPassedAt: Date | null = null
+  if (!dates.lastExecutedAt) {
+    dates.lastExecutedAt = mostRecentOlderCompletedAt
+  }
 
-    if (recentTestRunTestCases.length > 0) {
-      // Most recent execution
-      lastExecutedAt = recentTestRunTestCases[0].testRun.completedAt || new Date()
+  if (!dates.lastFailedAt) {
+    dates.lastFailedAt =
+      getMostRecentResultDate(olderTestRunTestCases, TestRunTestCaseResult.FAILED) ??
+      (await findOlderResultDate(testCaseId, recentPeriodDate, TestRunTestCaseResult.FAILED))
+  }
 
-      // Find most recent failure
-      const mostRecentFailure = recentTestRunTestCases.find(
-        trtc => trtc.result === TestRunTestCaseResult.FAILED,
-      )
-      if (mostRecentFailure) {
-        lastFailedAt = mostRecentFailure.testRun.completedAt || new Date()
-      }
+  if (!dates.lastPassedAt) {
+    dates.lastPassedAt =
+      getMostRecentResultDate(olderTestRunTestCases, TestRunTestCaseResult.PASSED) ??
+      (await findOlderResultDate(testCaseId, recentPeriodDate, TestRunTestCaseResult.PASSED))
+  }
 
-      // Find most recent pass
-      const mostRecentPass = recentTestRunTestCases.find(
-        trtc => trtc.result === TestRunTestCaseResult.PASSED,
-      )
-      if (mostRecentPass) {
-        lastPassedAt = mostRecentPass.testRun.completedAt || new Date()
-      }
-    }
+  return dates
+}
 
-    // If no recent runs, check if there are any older runs to get last executed/failed/passed dates
-    if (!lastExecutedAt || !lastFailedAt || !lastPassedAt) {
-      const olderTestRunTestCases = await prisma.testRunTestCase.findMany({
-        where: {
-          testCaseId,
-          status: TestRunTestCaseStatus.COMPLETED,
-          testRun: {
-            completedAt: {
-              lt: recentPeriodDate,
-            },
-          },
-        },
-        include: {
-          testRun: {
-            select: {
-              completedAt: true,
-            },
-          },
+function getCompletedAt(testRunTestCase?: CompletedTestRunTestCase | null): Date | null {
+  return testRunTestCase ? testRunTestCase.testRun.completedAt || new Date() : null
+}
+
+function getMostRecentResultDate(
+  testRunTestCases: CompletedTestRunTestCase[],
+  result: TestRunTestCaseResult,
+): Date | null {
+  return getCompletedAt(testRunTestCases.find(testRunTestCase => testRunTestCase.result === result))
+}
+
+async function findMostRecentOlderTestRunTestCases(
+  testCaseId: string,
+  recentPeriodDate: Date,
+): Promise<CompletedTestRunTestCase[]> {
+  return prisma.testRunTestCase.findMany({
+    where: {
+      testCaseId,
+      status: TestRunTestCaseStatus.COMPLETED,
+      testRun: {
+        completedAt: {
+          lt: recentPeriodDate,
         },
-        orderBy: {
-          testRun: {
-            completedAt: 'desc',
-          },
+      },
+    },
+    include: {
+      testRun: {
+        select: {
+          completedAt: true,
         },
-        take: 1, // Only need the most recent one
-      })
+      },
+    },
+    orderBy: {
+      testRun: {
+        completedAt: 'desc',
+      },
+    },
+    take: 1,
+  })
+}
 
-      if (olderTestRunTestCases.length > 0) {
-        const mostRecentOlder = olderTestRunTestCases[0]
-        const olderCompletedAt = mostRecentOlder.testRun.completedAt || new Date()
-
-        if (!lastExecutedAt) {
-          lastExecutedAt = olderCompletedAt
-        }
-
-        // Find most recent failure from older runs if not found in recent runs
-        if (!lastFailedAt) {
-          const olderFailure = olderTestRunTestCases.find(
-            trtc => trtc.result === TestRunTestCaseResult.FAILED,
-          )
-          if (!olderFailure) {
-            // Check all older runs for failures
-            const allOlderFailures = await prisma.testRunTestCase.findFirst({
-              where: {
-                testCaseId,
-                status: TestRunTestCaseStatus.COMPLETED,
-                result: TestRunTestCaseResult.FAILED,
-                testRun: {
-                  completedAt: {
-                    lt: recentPeriodDate,
-                  },
-                },
-              },
-              include: {
-                testRun: {
-                  select: {
-                    completedAt: true,
-                  },
-                },
-              },
-              orderBy: {
-                testRun: {
-                  completedAt: 'desc',
-                },
-              },
-            })
-            if (allOlderFailures) {
-              lastFailedAt = allOlderFailures.testRun.completedAt || new Date()
-            }
-          } else {
-            lastFailedAt = olderFailure.testRun.completedAt || new Date()
-          }
-        }
-
-        // Find most recent pass from older runs if not found in recent runs
-        if (!lastPassedAt) {
-          const olderPass = olderTestRunTestCases.find(
-            trtc => trtc.result === TestRunTestCaseResult.PASSED,
-          )
-          if (!olderPass) {
-            // Check all older runs for passes
-            const allOlderPasses = await prisma.testRunTestCase.findFirst({
-              where: {
-                testCaseId,
-                status: TestRunTestCaseStatus.COMPLETED,
-                result: TestRunTestCaseResult.PASSED,
-                testRun: {
-                  completedAt: {
-                    lt: recentPeriodDate,
-                  },
-                },
-              },
-              include: {
-                testRun: {
-                  select: {
-                    completedAt: true,
-                  },
-                },
-              },
-              orderBy: {
-                testRun: {
-                  completedAt: 'desc',
-                },
-              },
-            })
-            if (allOlderPasses) {
-              lastPassedAt = allOlderPasses.testRun.completedAt || new Date()
-            }
-          } else {
-            lastPassedAt = olderPass.testRun.completedAt || new Date()
-          }
-        }
-      }
-    }
+async function findOlderResultDate(
+  testCaseId: string,
+  recentPeriodDate: Date,
+  result: TestRunTestCaseResult,
+): Promise<Date | null> {
+  const testRunTestCase = await prisma.testRunTestCase.findFirst({
+    where: {
+      testCaseId,
+      status: TestRunTestCaseStatus.COMPLETED,
+      result,
+      testRun: {
+        completedAt: {
+          lt: recentPeriodDate,
+        },
+      },
+    },
+    include: {
+      testRun: {
+        select: {
+          completedAt: true,
+        },
+      },
+    },
+    orderBy: {
+      testRun: {
+        completedAt: 'desc',
+      },
+    },
+  })
 
-    // Prepare update data
-    const updateData: {
-      lastExecutedAt?: Date
-      lastFailedAt?: Date | null
-      lastPassedAt?: Date | null
-      isRepeatedlyFailing: boolean
-      isFlaky: boolean
-      consecutiveFailures: number
-      failureRate: number
-      totalRecentRuns: number
-      failedRecentRuns: number
-    } = {
-      isRepeatedlyFailing,
-      isFlaky,
-      consecutiveFailures,
-      failureRate,
-      totalRecentRuns,
-      failedRecentRuns,
-    }
+  return getCompletedAt(testRunTestCase)
+}
 
-    if (lastExecutedAt) {
-      updateData.lastExecutedAt = lastExecutedAt
-    }
-    if (lastFailedAt !== null) {
-      updateData.lastFailedAt = lastFailedAt
-    }
-    if (lastPassedAt !== null) {
-      updateData.lastPassedAt = lastPassedAt
-    }
+function buildRecalculatedMetricUpdateData(
+  metricSummary: TestCaseMetricSummary,
+  dates: RecalculatedMetricDates,
+): RecalculatedMetricUpdateData {
+  const updateData: RecalculatedMetricUpdateData = {
+    isRepeatedlyFailing: metricSummary.isRepeatedlyFailing,
+    isFlaky: metricSummary.isFlaky,
+    consecutiveFailures: metricSummary.consecutiveFailures,
+    failureRate: metricSummary.failureRate,
+    totalRecentRuns: metricSummary.totalRecentRuns,
+    failedRecentRuns: metricSummary.failedRecentRuns,
+  }
 
-    // Upsert the metrics
-    await prisma.testCaseMetrics.upsert({
-      where: { testCaseId },
-      create: {
-        testCaseId,
-        lastExecutedAt: lastExecutedAt || undefined,
-        lastFailedAt: lastFailedAt || undefined,
-        lastPassedAt: lastPassedAt || undefined,
-        ...updateData,
-      },
-      update: updateData,
-    })
-  } catch (error) {
-    console.error(`[MetricCalculator] Error recalculating test case metrics for ${testCaseId}:`, error)
-    // Don't throw - metrics are non-critical
+  if (dates.lastExecutedAt) {
+    updateData.lastExecutedAt = dates.lastExecutedAt
+  }
+  if (dates.lastFailedAt !== null) {
+    updateData.lastFailedAt = dates.lastFailedAt
   }
+  if (dates.lastPassedAt !== null) {
+    updateData.lastPassedAt = dates.lastPassedAt
+  }
+
+  return updateData
 }
 
 /**
@@ -594,11 +575,7 @@ export async function updateMetricsForTestRun(testRunId: string): Promise<void>
     // Update metrics for all test cases in the run
     for (const testRunTestCase of testRun.testCases) {
       if (testRunTestCase.status === TestRunTestCaseStatus.COMPLETED) {
-        await updateTestCaseMetrics(
-          testRunTestCase.testCaseId,
-          testRunTestCase.result,
-          executedAt,
-        )
+        await updateTestCaseMetrics(testRunTestCase.testCaseId, testRunTestCase.result, executedAt)
       }
     }
 

package/templates/blank/src/lib/module-hierarchy-builder.ts

@@ -1,14 +1,5 @@
 import prisma from '@/config/db-config'
 
-/**
- * Represents a module path structure
- */
-export interface ModulePath {
-  path: string
-  name: string
-  parentPath?: string
-}
-
 /**
  * Creates or finds a module by its path
  * @param modulePath - The module path (e.g., "/module1/submodule")
@@ -16,7 +7,7 @@ export interface ModulePath {
  * @param parentId - Optional parent module ID
  * @returns Promise<string> - The ID of the created or found module
  */
-export async function createOrFindModule(modulePath: string, moduleName: string, parentId?: string): Promise<string> {
+async function createOrFindModule(modulePath: string, moduleName: string, parentId?: string): Promise<string> {
   try {
     // First, try to find existing module by name and parent
     const existingModule = await prisma.module.findFirst({

package/templates/blank/src/lib/path-helpers/feature-path.ts

@@ -0,0 +1,10 @@
+import { relative } from 'path'
+
+export function getFeatureModulePath(featureFilePath: string, featuresBaseDir: string): string {
+  const relativePath = relative(featuresBaseDir, featureFilePath)
+  const normalizedPath = relativePath.replace(/\\/g, '/')
+  const pathParts = normalizedPath.split('/').filter(Boolean)
+  const moduleParts = pathParts.slice(0, -1)
+
+  return moduleParts.length > 0 ? `/${moduleParts.join('/')}` : '/'
+}