create-appraisejs 0.3.0-alpha.0 → 0.3.0

package/templates/starter/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/starter/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/starter/src/lib/process/task-spawner.ts

@@ -0,0 +1,273 @@
+import { execa, type Options as ExecaOptions } from 'execa'
+import type { ChildProcess } from 'child_process'
+import { EventEmitter } from 'events'
+
+export interface SpawnerOptions extends ExecaOptions {
+  streamLogs?: boolean
+  prefixLogs?: boolean
+  logPrefix?: string
+  captureOutput?: boolean
+  retainProcessRecord?: boolean
+}
+
+export interface SpawnedProcess {
+  process: ChildProcess
+  pid: number | undefined
+  name: string
+  output: {
+    stdout: string[]
+    stderr: string[]
+  }
+  isRunning: boolean
+  exitCode: number | null
+  startTime: Date
+  endTime: Date | null
+}
+
+export class TaskSpawner extends EventEmitter {
+  private processes: Map<string, SpawnedProcess> = new Map()
+  private processCounter = 0
+  private outputBuffers: Map<string, { stdout: string; stderr: string }> = new Map()
+
+  private scheduleProcessCleanup(processName: string, spawnedProcess: SpawnedProcess): void {
+    setImmediate(() => {
+      spawnedProcess.output.stdout.length = 0
+      spawnedProcess.output.stderr.length = 0
+      this.outputBuffers.delete(processName)
+      this.processes.delete(processName)
+    })
+  }
+
+  removeProcess(processName: string): boolean {
+    this.outputBuffers.delete(processName)
+    return this.processes.delete(processName)
+  }
+
+  async spawn(command: string, args: string[] = [], options: SpawnerOptions = {}): Promise<SpawnedProcess> {
+    const {
+      streamLogs = true,
+      prefixLogs = true,
+      logPrefix,
+      captureOutput = false,
+      retainProcessRecord = true,
+      ...spawnOptions
+    } = options
+
+    const processName = logPrefix || `${command}_${++this.processCounter}`
+    const spawnedProcess: SpawnedProcess = {
+      process: null as unknown as ChildProcess,
+      pid: undefined,
+      name: processName,
+      output: {
+        stdout: [],
+        stderr: [],
+      },
+      isRunning: false,
+      exitCode: null,
+      startTime: new Date(),
+      endTime: null,
+    }
+
+    const stdioConfig = captureOutput ? 'pipe' : streamLogs ? 'inherit' : 'pipe'
+    const childProcess = execa(command, args, {
+      stdio: stdioConfig,
+      reject: false,
+      ...spawnOptions,
+    })
+
+    spawnedProcess.process = childProcess
+    spawnedProcess.pid = childProcess.pid
+    spawnedProcess.isRunning = true
+
+    this.processes.set(processName, spawnedProcess)
+    this.outputBuffers.set(processName, { stdout: '', stderr: '' })
+
+    this.setupProcessListeners(spawnedProcess, {
+      streamLogs,
+      prefixLogs,
+      captureOutput,
+      retainProcessRecord,
+      stdioConfig,
+    })
+
+    this.emit('spawn', spawnedProcess)
+    return spawnedProcess
+  }
+
+  killProcess(processName: string, signal: NodeJS.Signals = 'SIGTERM'): boolean {
+    const spawnedProcess = this.processes.get(processName)
+    if (!spawnedProcess || !spawnedProcess.isRunning) {
+      return false
+    }
+
+    spawnedProcess.process.kill(signal)
+    return true
+  }
+
+  async waitForProcess(processName: string): Promise<number | null> {
+    const spawnedProcess = this.processes.get(processName)
+    if (!spawnedProcess) {
+      throw new Error(`Process '${processName}' not found`)
+    }
+
+    return new Promise(resolve => {
+      if (!spawnedProcess.isRunning) {
+        resolve(spawnedProcess.exitCode)
+        return
+      }
+
+      spawnedProcess.process.on('exit', (code: number | null) => resolve(code))
+    })
+  }
+
+  getProcess(processName: string): SpawnedProcess | undefined {
+    return this.processes.get(processName)
+  }
+
+  private processBufferedOutput(
+    processName: string,
+    stream: 'stdout' | 'stderr',
+    streamLogs: boolean,
+    prefixLogs: boolean,
+    captureOutput: boolean,
+    spawnedProcess: SpawnedProcess,
+  ): void {
+    const buffer = this.outputBuffers.get(processName)
+    if (!buffer) {
+      return
+    }
+
+    const lines = buffer[stream].split('\n')
+    buffer[stream] = lines.pop() || ''
+
+    for (const line of lines) {
+      if (captureOutput) {
+        spawnedProcess.output[stream].push(`${line}\n`)
+      }
+
+      if (streamLogs) {
+        const prefix = prefixLogs ? `[${processName}] ` : ''
+        if (stream === 'stdout') {
+          console.log(`${prefix}${line}`)
+        } else {
+          console.error(`${prefix}${line}`)
+        }
+      }
+
+      this.emit(stream, { processName, data: `${line}\n` })
+    }
+  }
+
+  private setupProcessListeners(
+    spawnedProcess: SpawnedProcess,
+    options: {
+      streamLogs: boolean
+      prefixLogs: boolean
+      captureOutput: boolean
+      retainProcessRecord: boolean
+      stdioConfig: string | string[]
+    },
+  ): void {
+    const { streamLogs, prefixLogs, captureOutput, retainProcessRecord, stdioConfig } = options
+    const { process: childProcess, name } = spawnedProcess
+
+    if (stdioConfig === 'pipe') {
+      childProcess.stdout?.on('data', (data: Buffer) => {
+        const buffer = this.outputBuffers.get(name)
+        if (!buffer) {
+          return
+        }
+
+        buffer.stdout += data.toString()
+        this.processBufferedOutput(name, 'stdout', streamLogs, prefixLogs, captureOutput, spawnedProcess)
+      })
+
+      childProcess.stderr?.on('data', (data: Buffer) => {
+        const buffer = this.outputBuffers.get(name)
+        if (!buffer) {
+          return
+        }
+
+        buffer.stderr += data.toString()
+        this.processBufferedOutput(name, 'stderr', streamLogs, prefixLogs, captureOutput, spawnedProcess)
+      })
+    }
+
+    childProcess.on('exit', (code: number | null) => {
+      if (stdioConfig === 'pipe') {
+        const buffer = this.outputBuffers.get(name)
+        if (buffer) {
+          if (buffer.stdout) {
+            if (captureOutput) {
+              spawnedProcess.output.stdout.push(buffer.stdout)
+            }
+            if (streamLogs) {
+              const prefix = prefixLogs ? `[${name}] ` : ''
+              console.log(`${prefix}${buffer.stdout}`)
+            }
+            this.emit('stdout', { processName: name, data: buffer.stdout })
+          }
+
+          if (buffer.stderr) {
+            if (captureOutput) {
+              spawnedProcess.output.stderr.push(buffer.stderr)
+            }
+            if (streamLogs) {
+              const prefix = prefixLogs ? `[${name}] ` : ''
+              console.error(`${prefix}${buffer.stderr}`)
+            }
+            this.emit('stderr', { processName: name, data: buffer.stderr })
+          }
+
+          this.outputBuffers.delete(name)
+        }
+      }
+
+      spawnedProcess.isRunning = false
+      spawnedProcess.exitCode = code
+      spawnedProcess.endTime = new Date()
+
+      if (!retainProcessRecord) {
+        this.scheduleProcessCleanup(name, spawnedProcess)
+      }
+
+      this.emit('exit', { processName: name, code })
+    })
+
+    childProcess.on('error', (error: Error) => {
+      this.outputBuffers.delete(name)
+      spawnedProcess.isRunning = false
+      spawnedProcess.endTime = new Date()
+
+      if (!retainProcessRecord) {
+        this.scheduleProcessCleanup(name, spawnedProcess)
+      }
+
+      if (streamLogs) {
+        const prefix = prefixLogs ? `[${name}] ` : ''
+        console.error(`${prefix}ERROR: ${error.message}`)
+      }
+
+      this.emit('error', { processName: name, error })
+    })
+  }
+}
+
+const globalForTaskSpawner = global as unknown as {
+  taskSpawner: TaskSpawner | undefined
+}
+
+export const taskSpawner = globalForTaskSpawner.taskSpawner ?? new TaskSpawner()
+
+if (!globalForTaskSpawner.taskSpawner) {
+  globalForTaskSpawner.taskSpawner = taskSpawner
+}
+
+export const spawnTask = (command: string, args: string[] = [], options: SpawnerOptions = {}) =>
+  taskSpawner.spawn(command, args, options)
+
+export const killTask = (processName: string, signal?: NodeJS.Signals) => taskSpawner.killProcess(processName, signal)
+
+export const waitForTask = (processName: string) => taskSpawner.waitForProcess(processName)
+
+export const removeTask = (processName: string) => taskSpawner.removeProcess(processName)

package/templates/starter/src/lib/sync/projected-feature-utils.ts

@@ -0,0 +1,113 @@
+import { StepParameterType, TemplateStepIcon } from '@prisma/client'
+
+type StoredProjectedStep = {
+  order: number
+  gherkinStep: string
+}
+
+type StoredProjectedDbStep = StoredProjectedStep & {
+  TemplateStep: { signature: string } | null
+  parameters: Array<{ name: string; value: string; order: number; type: StepParameterType }>
+}
+
+export type ProjectedDbTestCaseStep = {
+  order: number
+  keyword: string
+  text: string
+  gherkinStep: string
+  label: string
+  icon: TemplateStepIcon
+  templateStepSignature: string | null
+  parameters: Array<{ name: string; value: string; order: number; type: StepParameterType }>
+}
+
+export function getTestSuiteFilesystemKey(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .replace(/-+/g, '-')
+}
+
+export function getTestSuiteSyncIdentity(name: string, modulePath: string): string {
+  return `${getTestSuiteFilesystemKey(name)}::${modulePath}`
+}
+
+export function generateProjectedGherkinSteps(steps: StoredProjectedStep[]): string[] {
+  if (!steps || steps.length === 0) {
+    return []
+  }
+
+  const sortedSteps = [...steps].sort((left, right) => left.order - right.order)
+  let hasThenInPrevious = false
+  let hasWhenInPrevious = false
+
+  return sortedSteps.map((step, index) => {
+    const gherkinStep = step.gherkinStep?.trim() || ''
+    const firstWord = gherkinStep.split(' ')[0].toLowerCase()
+    const hasGherkinKeyword = ['given', 'when', 'then', 'and', 'but'].includes(firstWord)
+    const stepWithoutKeyword = hasGherkinKeyword ? gherkinStep.split(' ').slice(1).join(' ') : gherkinStep
+
+    if (index === 0) {
+      return `Given ${stepWithoutKeyword}`
+    }
+
+    const isThenStatement =
+      firstWord === 'then' ||
+      stepWithoutKeyword.toLowerCase().startsWith('should') ||
+      stepWithoutKeyword.toLowerCase().startsWith('must') ||
+      stepWithoutKeyword.toLowerCase().startsWith('will')
+
+    if (!hasThenInPrevious) {
+      if (isThenStatement) {
+        hasThenInPrevious = true
+        return `Then ${stepWithoutKeyword}`
+      }
+
+      if (!hasWhenInPrevious) {
+        hasWhenInPrevious = true
+        return `When ${stepWithoutKeyword}`
+      }
+
+      return `And ${stepWithoutKeyword}`
+    }
+
+    if (isThenStatement) {
+      return `And ${stepWithoutKeyword}`
+    }
+
+    hasThenInPrevious = false
+    hasWhenInPrevious = true
+    return `When ${stepWithoutKeyword}`
+  })
+}
+
+export function determineProjectedStepIcon(keyword: string): TemplateStepIcon {
+  const lowerKeyword = keyword.toLowerCase().trim()
+
+  if (lowerKeyword === 'given') return TemplateStepIcon.NAVIGATION
+  if (lowerKeyword === 'then') return TemplateStepIcon.VALIDATION
+  return TemplateStepIcon.MOUSE
+}
+
+export function normalizeProjectedDbTestCaseSteps(steps: StoredProjectedDbStep[]): ProjectedDbTestCaseStep[] {
+  const sortedSteps = [...steps].sort((left, right) => left.order - right.order)
+  const projectedGherkinSteps = generateProjectedGherkinSteps(sortedSteps)
+
+  return sortedSteps.map((step, index) => {
+    const gherkinStep = projectedGherkinSteps[index] ?? ''
+    const [keyword = '', ...textParts] = gherkinStep.split(' ')
+    const text = textParts.join(' ')
+
+    return {
+      order: step.order,
+      keyword,
+      text,
+      gherkinStep,
+      label: text,
+      icon: determineProjectedStepIcon(keyword),
+      templateStepSignature: step.TemplateStep?.signature ?? null,
+      parameters: step.parameters,
+    }
+  })
+}