create-appraisejs 0.1.10-alpha.8 → 0.2.0-alpha.1

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/process/task-spawner.ts

@@ -7,6 +7,7 @@ export interface SpawnerOptions extends ExecaOptions {
   prefixLogs?: boolean
   logPrefix?: string
   captureOutput?: boolean
+  retainProcessRecord?: boolean
 }
 
 export interface SpawnedProcess {
@@ -28,8 +29,29 @@ export class TaskSpawner extends EventEmitter {
   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, ...spawnOptions } = options
+    const {
+      streamLogs = true,
+      prefixLogs = true,
+      logPrefix,
+      captureOutput = false,
+      retainProcessRecord = true,
+      ...spawnOptions
+    } = options
 
     const processName = logPrefix || `${command}_${++this.processCounter}`
     const spawnedProcess: SpawnedProcess = {
@@ -49,6 +71,7 @@ export class TaskSpawner extends EventEmitter {
     const stdioConfig = captureOutput ? 'pipe' : streamLogs ? 'inherit' : 'pipe'
     const childProcess = execa(command, args, {
       stdio: stdioConfig,
+      reject: false,
       ...spawnOptions,
     })
 
@@ -63,6 +86,7 @@ export class TaskSpawner extends EventEmitter {
       streamLogs,
       prefixLogs,
       captureOutput,
+      retainProcessRecord,
       stdioConfig,
     })
 
@@ -140,10 +164,11 @@ export class TaskSpawner extends EventEmitter {
       streamLogs: boolean
       prefixLogs: boolean
       captureOutput: boolean
+      retainProcessRecord: boolean
       stdioConfig: string | string[]
     },
   ): void {
-    const { streamLogs, prefixLogs, captureOutput, stdioConfig } = options
+    const { streamLogs, prefixLogs, captureOutput, retainProcessRecord, stdioConfig } = options
     const { process: childProcess, name } = spawnedProcess
 
     if (stdioConfig === 'pipe') {
@@ -201,13 +226,23 @@ export class TaskSpawner extends EventEmitter {
       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}`)
@@ -234,3 +269,5 @@ export const spawnTask = (command: string, args: string[] = [], options: Spawner
 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)