create-appraisejs 0.2.0 → 0.3.0-alpha.1

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

@@ -1,205 +0,0 @@
-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 +0,0 @@
-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-pending-counts.test.ts

@@ -1,263 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import {
-  StepParameterType,
-  TagType,
-  TemplateStepGroupType,
-  TemplateStepIcon,
-  TemplateStepType,
-} from '@prisma/client'
-import {
-  countModuleMismatches,
-  countTagMismatches,
-  countTemplateStepGroupMismatches,
-  countTemplateStepMismatches,
-  countTestSuiteMismatches,
-  countTestCaseMismatches,
-} from '@/lib/sync/sync-pending-counts'
-
-test('ignores DB-only modules when counting pending module sync work', () => {
-  const count = countModuleMismatches(new Set(['/']), [
-    { id: 'root', name: 'root', path: '/', parentId: null },
-    { id: 'module-1', name: 'ui-only-module', path: '/ui-only-module', parentId: 'root' },
-  ])
-
-  assert.equal(count, 0)
-})
-
-test('ignores DB-only standalone filter tags when filesystem tags are already satisfied', () => {
-  const count = countTagMismatches(
-    [{ name: 'smoke', tagExpression: '@smoke', type: TagType.FILTER }],
-    [
-      { name: 'smoke', type: TagType.FILTER },
-      { name: 'standalone', type: TagType.FILTER },
-    ],
-  )
-
-  assert.equal(count, 0)
-})
-
-test('treats projected template step groups as synchronized even with extra DB rows', () => {
-  const count = countTemplateStepGroupMismatches(
-    [{ name: 'Actions', description: 'Projected from UI', type: TemplateStepGroupType.ACTION }],
-    [
-      { name: 'Actions', description: 'Projected from UI', type: TemplateStepGroupType.ACTION },
-      { name: 'Actions', description: 'stale row', type: TemplateStepGroupType.VALIDATION },
-      { name: 'DB Only Group', description: null, type: TemplateStepGroupType.ACTION },
-    ],
-  )
-
-  assert.equal(count, 0)
-})
-
-test('matches template steps against any equivalent DB row after function normalization', () => {
-  const count = countTemplateStepMismatches(
-    [
-      {
-        groupName: 'Actions',
-        groupType: TemplateStepGroupType.ACTION,
-        step: {
-          jsdoc: {
-            name: 'Click button',
-            description: 'Clicks a button',
-            icon: TemplateStepIcon.MOUSE,
-          },
-          signature: 'click {string}',
-          functionDefinition: '',
-          normalizedFunctionDefinition:
-            "When('click {string}', async function (this: CustomWorld, button: string) {\n  await this.page.click(button);\n});",
-          parameters: [{ name: 'button', order: 0, type: StepParameterType.STRING }],
-          keyword: 'When',
-        },
-      },
-    ],
-    [
-      {
-        signature: 'click {string}',
-        name: 'Click button',
-        description: 'stale row',
-        functionDefinition: "When('click {string}', async function () {});",
-        icon: TemplateStepIcon.MOUSE,
-        type: TemplateStepType.ACTION,
-        templateStepGroup: { name: 'Actions' },
-        parameters: [],
-      },
-      {
-        signature: 'click {string}',
-        name: 'Click button',
-        description: 'Clicks a button',
-        functionDefinition:
-          "When('click {string}', async function (this: CustomWorld, button: string) {\n  await this.page.click(button);\n});",
-        icon: TemplateStepIcon.MOUSE,
-        type: TemplateStepType.ACTION,
-        templateStepGroup: { name: 'Actions' },
-        parameters: [{ name: 'button', order: 0, type: StepParameterType.STRING }],
-      },
-    ],
-  )
-
-  assert.equal(count, 0)
-})
-
-test('matches test suites by generated filesystem key instead of raw DB name', () => {
-  const count = countTestSuiteMismatches(
-    [
-      {
-        name: 'user-login-suite',
-        description: 'Projected suite',
-        modulePath: '/auth',
-        tags: ['@smoke'],
-      },
-    ],
-    [
-      {
-        name: 'User Login Suite',
-        description: 'Projected suite',
-        moduleId: 'module-auth',
-        tags: [{ tagExpression: '@smoke' }],
-      },
-    ],
-    new Map([['module-auth', '/auth']]),
-  )
-
-  assert.equal(count, 0)
-})
-
-test('matches test suites when DB description is null and feature uses suite name', () => {
-  const count = countTestSuiteMismatches(
-    [
-      {
-        name: 'user-login-suite',
-        description: 'User Login Suite',
-        modulePath: '/auth',
-        tags: [],
-      },
-    ],
-    [
-      {
-        name: 'User Login Suite',
-        description: null,
-        moduleId: 'module-auth',
-        tags: [],
-      },
-    ],
-    new Map([['module-auth', '/auth']]),
-  )
-
-  assert.equal(count, 0)
-})
-
-test('matches projected test cases against generated feature-file output', () => {
-  const count = countTestCaseMismatches(
-    [
-      {
-        identifierTag: '@tc_login',
-        title: 'Login',
-        description: 'Opens the login screen',
-        testSuiteName: 'user-login-suite',
-        modulePath: '/auth',
-        filterTags: ['@smoke'],
-        steps: [
-          { order: 1, keyword: 'Given', text: 'open the login page' },
-          { order: 2, keyword: 'Then', text: 'should see the dashboard' },
-        ],
-      },
-    ],
-    [
-      {
-        title: 'Login',
-        description: 'Opens the login screen',
-        tags: [
-          { tagExpression: '@tc_login', type: TagType.IDENTIFIER },
-          { tagExpression: '@smoke', type: TagType.FILTER },
-        ],
-        TestSuite: [{ name: 'User Login Suite', moduleId: 'module-auth' }],
-        steps: [
-          {
-            order: 1,
-            gherkinStep: 'When open the login page',
-            label: 'open the login page',
-            icon: TemplateStepIcon.MOUSE,
-            TemplateStep: { signature: 'open the login page' },
-            parameters: [],
-          },
-          {
-            order: 2,
-            gherkinStep: 'Then should see the dashboard',
-            label: 'should see the dashboard',
-            icon: TemplateStepIcon.VALIDATION,
-            TemplateStep: { signature: 'should see the dashboard' },
-            parameters: [],
-          },
-        ],
-      },
-    ],
-    new Map([['module-auth', '/auth']]),
-    [
-      { signature: 'open the login page', parameters: [] },
-      { signature: 'should see the dashboard', parameters: [] },
-    ],
-  )
-
-  assert.equal(count, 0)
-})
-
-test('ignores duplicate stale DB test cases when one matching identifier row exists', () => {
-  const count = countTestCaseMismatches(
-    [
-      {
-        identifierTag: '@tc_profile',
-        title: 'Profile',
-        description: 'Shows the profile page',
-        testSuiteName: 'profile-suite',
-        modulePath: '/account',
-        filterTags: ['@regression'],
-        steps: [{ order: 1, keyword: 'Given', text: 'open the profile page' }],
-      },
-    ],
-    [
-      {
-        title: 'Old Profile',
-        description: 'stale',
-        tags: [
-          { tagExpression: '@tc_profile', type: TagType.IDENTIFIER },
-          { tagExpression: '@regression', type: TagType.FILTER },
-        ],
-        TestSuite: [{ name: 'Other Suite', moduleId: 'module-account' }],
-        steps: [
-          {
-            order: 1,
-            gherkinStep: 'When open the wrong page',
-            label: 'open the wrong page',
-            icon: TemplateStepIcon.MOUSE,
-            TemplateStep: { signature: 'open the wrong page' },
-            parameters: [],
-          },
-        ],
-      },
-      {
-        title: 'Profile',
-        description: 'Shows the profile page',
-        tags: [
-          { tagExpression: '@tc_profile', type: TagType.IDENTIFIER },
-          { tagExpression: '@regression', type: TagType.FILTER },
-        ],
-        TestSuite: [{ name: 'Profile Suite', moduleId: 'module-account' }],
-        steps: [
-          {
-            order: 1,
-            gherkinStep: 'When open the profile page',
-            label: 'open the profile page',
-            icon: TemplateStepIcon.MOUSE,
-            TemplateStep: { signature: 'open the profile page' },
-            parameters: [],
-          },
-        ],
-      },
-    ],
-    new Map([['module-account', '/account']]),
-    [{ signature: 'open the profile page', parameters: [] }],
-  )
-
-  assert.equal(count, 0)
-})