create-appraisejs 0.2.0 → 0.3.0-alpha.0

package/templates/default/src/lib/locator-picker/suggestions.ts

@@ -18,16 +18,18 @@ export function normalizeRoute(value: string | null | undefined): string {
     return '/'
   }
 
+  const collapseSlashes = (routeValue: string) => routeValue.replace(/\/{2,}/g, '/')
+
   try {
     const parsed = new URL(value)
-    return parsed.pathname || '/'
+    return collapseSlashes(parsed.pathname || '/')
   } catch {
     const route = value.trim()
     if (route === '') {
       return '/'
     }
 
-    return route.startsWith('/') ? route : `/${route}`
+    return collapseSlashes(route.startsWith('/') ? route : `/${route}`)
   }
 }
 

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

@@ -1,11 +1,7 @@
 import prisma from '@/config/db-config'
+import { RECENT_PERIOD_DAYS } from '@/services/shared/constants'
 import { TestRunTestCaseResult, TestRunTestCaseStatus } from '@prisma/client'
 
-/**
- * Time period for "recent" runs in days
- */
-const RECENT_PERIOD_DAYS = 7
-
 /**
  * Threshold for consecutive failures to be considered "repeatedly failing"
  */
@@ -38,7 +34,7 @@ export async function updateTestCaseMetrics(
 ): Promise<void> {
   try {
     // Get existing metrics or create new one
-    const _existingMetrics = await prisma.testCaseMetrics.findUnique({
+    await prisma.testCaseMetrics.findUnique({
       where: { testCaseId },
     })
 

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

@@ -1,205 +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
-  }
-}
+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

@@ -1,71 +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
-}
+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/sync/sync-executor.test.ts

@@ -0,0 +1,76 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { resolveRequestedSyncExecutionOrder } from '@/lib/sync/sync-registry'
+
+vi.mock('execa', () => ({
+  execa: vi.fn(),
+}))
+
+import { execa } from 'execa'
+import { runRequestedSync } from './sync-executor'
+
+describe('runRequestedSync', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('executes requested sync scripts in dependency order', async () => {
+    vi.mocked(execa).mockResolvedValue({
+      exitCode: 0,
+      stdout: 'ok',
+      stderr: '',
+    } as never)
+
+    const result = await runRequestedSync('sync-test-cases')
+
+    expect(result).toMatchObject({
+      requestedScriptId: 'sync-test-cases',
+      executedScriptIds: resolveRequestedSyncExecutionOrder('sync-test-cases'),
+      success: true,
+    })
+    expect(execa).toHaveBeenCalledTimes(resolveRequestedSyncExecutionOrder('sync-test-cases').length)
+  })
+
+  it('stops on the first failing script and reports the parsed cause', async () => {
+    vi.mocked(execa)
+      .mockResolvedValueOnce({
+        exitCode: 0,
+        stdout: 'modules synced',
+        stderr: '',
+      } as never)
+      .mockResolvedValueOnce({
+        exitCode: 0,
+        stdout: 'tags synced',
+        stderr: '',
+      } as never)
+      .mockResolvedValueOnce({
+        exitCode: 2,
+        stdout: '',
+        stderr: '\u001b[31mError: Missing suite definitions\u001b[39m',
+      } as never)
+
+    const result = await runRequestedSync('sync-test-cases')
+
+    expect(result).toMatchObject({
+      requestedScriptId: 'sync-test-cases',
+      success: false,
+      failedScriptId: 'sync-test-suites',
+      exitCode: 2,
+      executedScriptIds: ['sync-modules', 'sync-tags', 'sync-test-suites'],
+      cause: 'Missing suite definitions',
+    })
+  })
+
+  it('returns a failure result when the sync process throws', async () => {
+    vi.mocked(execa).mockRejectedValue(new Error('spawn EACCES'))
+
+    const result = await runRequestedSync('sync-modules')
+
+    expect(result).toMatchObject({
+      requestedScriptId: 'sync-modules',
+      success: false,
+      failedScriptId: 'sync-modules',
+      executedScriptIds: ['sync-modules'],
+      cause: 'spawn EACCES',
+    })
+  })
+})