create-appraise 0.1.0

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

@@ -0,0 +1,205 @@
+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")
+ * @param moduleName - The name of the module
+ * @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> {
+  try {
+    // First, try to find existing module by name and parent
+    const existingModule = await prisma.module.findFirst({
+      where: {
+        name: moduleName,
+        parentId: parentId || null,
+      },
+    })
+
+    if (existingModule) {
+      return existingModule.id
+    }
+
+    // Create new module
+    const newModule = await prisma.module.create({
+      data: {
+        name: moduleName,
+        parentId: parentId || null,
+        // Add description only if it's required by the schema
+        // For now, we'll leave it empty since it's optional
+      },
+    })
+
+    console.log(`Created module: ${moduleName} (${modulePath})`)
+    return newModule.id
+  } catch (error) {
+    console.error(`Error creating module ${moduleName}:`, error)
+    throw error
+  }
+}
+
+/**
+ * Builds the complete module hierarchy from a module path
+ * @param modulePath - The module path (e.g., "/module1/submodule")
+ * @returns Promise<string> - The ID of the leaf module
+ */
+export async function buildModuleHierarchy(modulePath: string): Promise<string> {
+  try {
+    // Parse the module path
+    const pathParts = modulePath.split('/').filter(part => part && part !== '')
+
+    // Handle empty path (root level) - create/find a default root module
+    if (pathParts.length === 0) {
+      const rootModule = await prisma.module.findFirst({
+        where: {
+          name: 'root',
+          parentId: null,
+        },
+      })
+
+      if (rootModule) {
+        return rootModule.id
+      }
+
+      // Create default root module
+      const newRootModule = await prisma.module.create({
+        data: {
+          name: 'root',
+          parentId: null,
+        },
+      })
+
+      console.log(`Created root module for features without module path`)
+      return newRootModule.id
+    }
+
+    let currentParentId: string | undefined
+    let currentPath = ''
+
+    // Create or find each module in the hierarchy
+    for (let i = 0; i < pathParts.length; i++) {
+      const moduleName = pathParts[i]
+      currentPath += `/${moduleName}`
+
+      const moduleId = await createOrFindModule(currentPath, moduleName, currentParentId)
+
+      currentParentId = moduleId
+    }
+
+    return currentParentId!
+  } catch (error) {
+    console.error(`Error building module hierarchy for path ${modulePath}:`, error)
+    throw error
+  }
+}
+
+/**
+ * Gets all existing modules as a flat list with their paths
+ * @returns Promise<Array<{id: string, name: string, path: string, parentId: string | null}>>
+ */
+export async function getAllModulesWithPaths(): Promise<
+  Array<{
+    id: string
+    name: string
+    path: string
+    parentId: string | null
+  }>
+> {
+  try {
+    const modules = await prisma.module.findMany({
+      orderBy: [{ parentId: 'asc' }, { name: 'asc' }],
+    })
+
+    // Build paths for each module
+    const modulesWithPaths = modules.map(module => {
+      const path = buildModulePath(modules, module)
+      return {
+        id: module.id,
+        name: module.name,
+        path,
+        parentId: module.parentId,
+      }
+    })
+
+    return modulesWithPaths
+  } catch (error) {
+    console.error('Error fetching modules with paths:', error)
+    throw error
+  }
+}
+
+/**
+ * Builds the full path for a module based on its hierarchy
+ * @param allModules - All modules from the database
+ * @param targetModule - The module to build the path for
+ * @returns string - The full module path
+ */
+function buildModulePath(
+  allModules: Array<{ id: string; name: string; parentId: string | null }>,
+  targetModule: { id: string; name: string; parentId: string | null },
+): string {
+  const pathParts: string[] = []
+  let currentModule = targetModule
+
+  // Traverse up the hierarchy
+  while (currentModule) {
+    pathParts.unshift(currentModule.name)
+
+    if (currentModule.parentId) {
+      currentModule = allModules.find(m => m.id === currentModule.parentId)!
+      if (!currentModule) break
+    } else {
+      break
+    }
+  }
+
+  return '/' + pathParts.join('/')
+}
+
+/**
+ * Finds a module by its path
+ * @param modulePath - The module path to find
+ * @returns Promise<string | null> - The module ID or null if not found
+ */
+export async function findModuleByPath(modulePath: string): Promise<string | null> {
+  try {
+    const modules = await prisma.module.findMany()
+    const pathParts = modulePath.split('/').filter(part => part && part !== '')
+
+    if (pathParts.length === 0) {
+      return null
+    }
+
+    // Find the root module
+    let currentModule = modules.find(m => m.name === pathParts[0] && !m.parentId)
+    if (!currentModule) {
+      return null
+    }
+
+    // Traverse down the hierarchy
+    for (let i = 1; i < pathParts.length; i++) {
+      const childModule = modules.find(m => m.name === pathParts[i] && m.parentId === currentModule!.id)
+
+      if (!childModule) {
+        return null
+      }
+
+      currentModule = childModule
+    }
+
+    return currentModule.id
+  } catch (error) {
+    console.error(`Error finding module by path ${modulePath}:`, error)
+    return null
+  }
+}

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

@@ -0,0 +1,71 @@
+import { Module } from '@prisma/client'
+
+/**
+ * Builds the hierarchical path for a module based on its parent modules
+ * @param modules - Array of all modules
+ * @param selectedModule - The module to get the path for
+ * @returns The hierarchical path as a string (e.g., "/user/user profile")
+ */
+export function buildModulePath(modules: Module[], selectedModule: Module): string {
+  const path: string[] = []
+  let currentModule: Module | null = selectedModule
+
+  // Build path from current module up to root
+  while (currentModule) {
+    path.unshift(currentModule.name)
+    currentModule = modules.find(m => m.id === currentModule?.parentId) || null
+  }
+
+  // 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
+}

package/templates/default/src/lib/test-case-utils.ts

@@ -0,0 +1,6 @@
+import crypto from 'crypto'
+
+export function generateUniqueTestCaseIdentifier(): string {
+  const id = crypto.randomBytes(8).toString('hex')
+  return `tc_${id}`
+}

package/templates/default/src/lib/test-run/log-formatter.ts

@@ -0,0 +1,83 @@
+/**
+ * Log formatting utilities for storing and retrieving test run logs
+ */
+
+export interface LogEntry {
+  type: 'stdout' | 'stderr' | 'status'
+  message: string
+  timestamp: Date
+}
+
+/**
+ * Formats log entries into a single text string for storage in the database
+ * Format: [timestamp] [TYPE] message
+ * 
+ * @param logs - Array of log entries to format
+ * @returns Formatted log string
+ */
+export function formatLogsForStorage(logs: LogEntry[]): string {
+  return logs
+    .map(log => {
+      const timestamp = log.timestamp.toISOString()
+      const type = log.type.toUpperCase()
+      // Escape newlines in message to preserve them in the formatted string
+      const escapedMessage = log.message.replace(/\n/g, '\\n')
+      return `[${timestamp}] [${type}] ${escapedMessage}`
+    })
+    .join('\n')
+}
+
+/**
+ * Parses formatted log text back into an array of LogEntry objects
+ * 
+ * @param formattedLogs - Formatted log string from database
+ * @returns Array of log entries
+ */
+export function parseLogsFromStorage(formattedLogs: string): LogEntry[] {
+  if (!formattedLogs || formattedLogs.trim() === '') {
+    return []
+  }
+
+  const lines = formattedLogs.split('\n')
+  const parsedLogs: LogEntry[] = []
+
+  for (const line of lines) {
+    if (!line.trim()) continue
+
+    try {
+      // Match format: [timestamp] [TYPE] message
+      const match = line.match(/^\[([^\]]+)\] \[([^\]]+)\] (.+)$/)
+      
+      if (match) {
+        const [, timestampStr, typeStr, message] = match
+        const timestamp = new Date(timestampStr)
+        const type = typeStr.toLowerCase() as 'stdout' | 'stderr' | 'status'
+        
+        // Unescape newlines in message
+        const unescapedMessage = message.replace(/\\n/g, '\n')
+        
+        // Validate type
+        if (type === 'stdout' || type === 'stderr' || type === 'status') {
+          parsedLogs.push({
+            type,
+            message: unescapedMessage,
+            timestamp: isNaN(timestamp.getTime()) ? new Date() : timestamp,
+          })
+        }
+      } else {
+        // Fallback: treat as stdout if format doesn't match
+        parsedLogs.push({
+          type: 'stdout',
+          message: line,
+          timestamp: new Date(),
+        })
+      }
+    } catch (error) {
+      // Skip malformed lines
+      console.error('[LogFormatter] Error parsing log line:', line, error)
+    }
+  }
+
+  return parsedLogs
+}
+

package/templates/default/src/lib/test-run/process-manager.ts

@@ -0,0 +1,191 @@
+import type { SpawnedProcess } from '@/tests/utils/spawner.util'
+import { EventEmitter } from 'events'
+import { taskSpawner } from '@/tests/utils/spawner.util'
+
+/**
+ * Process Manager - Singleton to track running test processes by test run ID
+ *
+ * This manager maintains a registry of active test processes, allowing
+ * the SSE route handler to look up processes and stream their logs.
+ *
+ * Uses global variable pattern (like Prisma) to persist across Next.js runtime contexts
+ *
+ * Security: Currently stores processes by testRunId only.
+ * TODO: When user authentication is implemented, consider adding user isolation:
+ * - Option 1: Use composite keys like `${userId}:${testRunId}`
+ * - Option 2: Store userId in process metadata and filter by userId in get() method
+ * - Option 3: Create separate ProcessManager instances per user (more complex)
+ */
+class ProcessManager extends EventEmitter {
+  private processes: Map<string, SpawnedProcess> = new Map()
+  // Track event listeners for cleanup
+  private eventListeners: Map<string, Map<string, () => void>> = new Map()
+
+  private constructor() {
+    super()
+    // Private constructor for singleton pattern
+  }
+
+  /**
+   * Get the singleton instance of ProcessManager
+   * Uses global variable to persist across Next.js runtime contexts
+   */
+  static getInstance(): ProcessManager {
+    const globalForProcessManager = global as unknown as {
+      processManager: ProcessManager | undefined
+    }
+
+    if (!globalForProcessManager.processManager) {
+      globalForProcessManager.processManager = new ProcessManager()
+    }
+
+    return globalForProcessManager.processManager
+  }
+
+  /**
+   * Register a process for a test run
+   * Sets up event listeners to parse custom events from stdout/stderr
+   * @param testRunId - The test run ID
+   * @param process - The spawned process instance
+   */
+  register(testRunId: string, process: SpawnedProcess): void {
+    this.processes.set(testRunId, process)
+
+    // Set up listeners to parse custom events from stdout/stderr
+    const listeners = new Map<string, () => void>()
+
+    // Handler for stdout events - parse for custom events
+    const onStdout = ({ processName, data }: { processName: string; data: string }) => {
+      if (processName === process.name) {
+        this.parseAndEmitCustomEvents(testRunId, data)
+      }
+    }
+
+    // Handler for stderr events - parse for custom events
+    const onStderr = ({ processName, data }: { processName: string; data: string }) => {
+      if (processName === process.name) {
+        this.parseAndEmitCustomEvents(testRunId, data)
+      }
+    }
+
+    // Store cleanup functions
+    listeners.set('stdout', () => taskSpawner.removeListener('stdout', onStdout))
+    listeners.set('stderr', () => taskSpawner.removeListener('stderr', onStderr))
+
+    // Register listeners
+    taskSpawner.on('stdout', onStdout)
+    taskSpawner.on('stderr', onStderr)
+
+    this.eventListeners.set(testRunId, listeners)
+  }
+
+  /**
+   * Parse stdout/stderr output for custom event markers and emit them
+   * Expects events in JSON format: {"event":"scenario::end","data":{...}}
+   */
+  private parseAndEmitCustomEvents(testRunId: string, output: string): void {
+    // Split by newlines to handle multi-line output
+    const lines = output.split('\n')
+
+    for (const line of lines) {
+      if (!line.trim()) continue
+
+      try {
+        // Look for JSON objects in the line that contain an "event" field
+        // Matches: {"event":"scenario::end","data":{...}}
+        const jsonMatch = line.match(/\{[\s\S]*"event"[\s\S]*\}/)
+        if (jsonMatch) {
+          const eventData = JSON.parse(jsonMatch[0])
+          if (eventData.event === 'scenario::end') {
+            console.log(`[ProcessManager] Parsed scenario::end event for testRunId: ${testRunId}`, eventData)
+            this.emit('scenario::end', {
+              testRunId,
+              scenarioName: eventData.data?.scenarioName,
+              status: eventData.data?.status,
+              tracePath: eventData.data?.tracePath,
+              ...eventData.data,
+            })
+            console.log(`[ProcessManager] Emitted scenario::end event for testRunId: ${testRunId}`)
+          }
+        }
+      } catch (error) {
+        // Not a custom event, continue parsing other lines
+        // This is expected for regular log output
+        // Only log if it looks like it might be a JSON parse error
+        if (line.trim().startsWith('{')) {
+          console.warn(`[ProcessManager] Failed to parse potential event JSON: ${line.substring(0, 100)}`, error)
+        }
+      }
+    }
+  }
+
+  /**
+   * Get a process by test run ID
+   * @param testRunId - The test run ID
+   * @returns The spawned process or undefined if not found
+   */
+  get(testRunId: string): SpawnedProcess | undefined {
+    return this.processes.get(testRunId)
+  }
+
+  /**
+   * Unregister a process for a test run
+   * Cleans up event listeners
+   * @param testRunId - The test run ID
+   * @returns True if the process was found and removed, false otherwise
+   */
+  unregister(testRunId: string): boolean {
+    // Clean up event listeners
+    const listeners = this.eventListeners.get(testRunId)
+    if (listeners) {
+      listeners.forEach(cleanup => cleanup())
+      this.eventListeners.delete(testRunId)
+    }
+
+    const deleted = this.processes.delete(testRunId)
+    console.log(
+      `[ProcessManager] Unregistering process for testRunId: ${testRunId}, deleted: ${deleted}, remaining processes: ${this.processes.size}`,
+    )
+    return deleted
+  }
+
+  /**
+   * Check if a process exists for a test run
+   * @param testRunId - The test run ID
+   * @returns True if a process exists, false otherwise
+   */
+  has(testRunId: string): boolean {
+    return this.processes.has(testRunId)
+  }
+
+  /**
+   * Get all registered test run IDs (for debugging)
+   * @returns Array of test run IDs
+   */
+  getAllTestRunIds(): string[] {
+    return Array.from(this.processes.keys())
+  }
+
+  /**
+   * Clear all registered processes (useful for cleanup)
+   */
+  clear(): void {
+    // Clean up all event listeners
+    this.eventListeners.forEach(listeners => {
+      listeners.forEach(cleanup => cleanup())
+    })
+    this.eventListeners.clear()
+    this.processes.clear()
+  }
+
+  /**
+   * Get the number of active processes
+   * @returns The number of registered processes
+   */
+  size(): number {
+    return this.processes.size
+  }
+}
+
+// Export singleton instance
+export const processManager = ProcessManager.getInstance()