create-appraisejs 0.3.0 → 0.3.1-alpha.0

package/templates/starter/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,67 @@ 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 +136,16 @@ 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: {
@@ -166,7 +220,7 @@ export async function updateTestSuiteMetrics(
  * @param testRunId - The test run ID
  * @param executedAt - When the test run was executed
  */
-export async function updateTestSuitesForTestRun(
+async function updateTestSuitesForTestRun(
   testRunId: string,
   executedAt: Date,
 ): Promise<void> {
@@ -307,245 +361,169 @@ 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),
+  }
 
-    // Determine if repeatedly failing (3+ consecutive failures)
-    const isRepeatedlyFailing = consecutiveFailures >= REPEATEDLY_FAILING_THRESHOLD
+  if (dates.lastExecutedAt && dates.lastFailedAt && dates.lastPassedAt) {
+    return dates
+  }
 
-    // Determine last executed, last failed, and last passed dates
-    let lastExecutedAt: Date | null = null
-    let lastFailedAt: Date | null = null
-    let lastPassedAt: Date | null = null
+  const olderTestRunTestCases = await findMostRecentOlderTestRunTestCases(testCaseId, recentPeriodDate)
+  const mostRecentOlderCompletedAt = getCompletedAt(olderTestRunTestCases[0])
 
-    if (recentTestRunTestCases.length > 0) {
-      // Most recent execution
-      lastExecutedAt = recentTestRunTestCases[0].testRun.completedAt || new Date()
+  if (!dates.lastExecutedAt) {
+    dates.lastExecutedAt = mostRecentOlderCompletedAt
+  }
 
-      // Find most recent failure
-      const mostRecentFailure = recentTestRunTestCases.find(
-        trtc => trtc.result === TestRunTestCaseResult.FAILED,
-      )
-      if (mostRecentFailure) {
-        lastFailedAt = mostRecentFailure.testRun.completedAt || new Date()
-      }
+  if (!dates.lastFailedAt) {
+    dates.lastFailedAt =
+      getMostRecentResultDate(olderTestRunTestCases, TestRunTestCaseResult.FAILED) ??
+      (await findOlderResultDate(testCaseId, recentPeriodDate, TestRunTestCaseResult.FAILED))
+  }
 
-      // Find most recent pass
-      const mostRecentPass = recentTestRunTestCases.find(
-        trtc => trtc.result === TestRunTestCaseResult.PASSED,
-      )
-      if (mostRecentPass) {
-        lastPassedAt = mostRecentPass.testRun.completedAt || new Date()
-      }
-    }
+  if (!dates.lastPassedAt) {
+    dates.lastPassedAt =
+      getMostRecentResultDate(olderTestRunTestCases, TestRunTestCaseResult.PASSED) ??
+      (await findOlderResultDate(testCaseId, recentPeriodDate, TestRunTestCaseResult.PASSED))
+  }
 
-    // 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,
-            },
-          },
+  return dates
+}
+
+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
 }
 
 /**

package/templates/starter/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/starter/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('/')}` : '/'
+}

package/templates/starter/src/lib/path-helpers/module-path.ts

@@ -19,53 +19,3 @@ export function buildModulePath(modules: Module[], selectedModule: Module): stri
   // Return path with leading slash
   return `/${path.join('/')}`
 }
-
-/**
- * Alternative implementation that can handle modules with parent relationships
- * This version works with the current data structure where we have parent info
- */
-export function buildModulePathFromParent(
-  modules: (Module & { parent: { name: string } })[],
-  selectedModule: Module & { parent: { name: string } },
-): string {
-  const path: string[] = []
-  let currentModule: (Module & { parent: { name: string } }) | null = selectedModule
-
-  // Build path from current module up to root
-  while (currentModule) {
-    path.unshift(currentModule.name)
-
-    if (currentModule.parent?.name) {
-      // Find the parent module in the modules array
-      const parentModule = modules.find(m => m.name === currentModule?.parent?.name)
-      currentModule = parentModule || null
-    } else {
-      // No parent, we've reached the root
-      currentModule = null
-    }
-  }
-
-  // Return path with leading slash
-  return `/${path.join('/')}`
-}
-
-/**
- * Builds paths for all modules in a single pass for better performance
- * @param modules - Array of all modules with parent info
- * @returns Map of module ID to path string
- */
-export function buildAllModulePaths(modules: (Module & { parent: { name: string } })[]): Map<string, string> {
-  const pathMap = new Map<string, string>()
-
-  // First pass: create a map for quick lookup
-  const moduleMap = new Map<string, Module & { parent: { name: string } }>()
-  modules.forEach(module => moduleMap.set(module.id, module))
-
-  // Second pass: build paths for each module
-  modules.forEach(module => {
-    const path = buildModulePathFromParent(modules, module)
-    pathMap.set(module.id, path)
-  })
-
-  return pathMap
-}