create-appraise 0.1.0

package/templates/default/src/lib/transformers/template-test-case-converter.ts

@@ -0,0 +1,160 @@
+import {
+  TemplateTestCase,
+  TemplateTestCaseStep,
+  TemplateTestCaseStepParameter,
+  TemplateStepIcon,
+  StepParameterType,
+} from '@prisma/client'
+import { NodeOrderMap } from '@/types/diagram/diagram'
+
+export interface ConvertedTestCaseData {
+  title: string
+  description: string
+  testSuiteIds: string[]
+  nodesOrder: NodeOrderMap
+}
+
+export interface TestCaseFormData {
+  title: string
+  description: string
+  testSuiteIds: string[]
+  steps: {
+    gherkinStep: string
+    label: string
+    icon: TemplateStepIcon
+    parameters: {
+      name: string
+      value: string
+      type: StepParameterType
+      order: number
+    }[]
+    order: number
+    templateStepId: string
+  }[]
+}
+
+/**
+ * Converts a template test case to the format expected by the test case form component
+ * @param templateTestCase - The template test case with steps and parameters
+ * @returns Converted data in the format expected by TestCaseForm
+ */
+export const templateTestCaseToTestCaseConverter = (
+  templateTestCase: TemplateTestCase & {
+    steps: (TemplateTestCaseStep & {
+      parameters: TemplateTestCaseStepParameter[]
+    })[]
+  },
+): ConvertedTestCaseData => {
+  // Convert template test case to test case format
+  const title = templateTestCase.name
+  const description = templateTestCase.description || ''
+  const testSuiteIds: string[] = [] // Will be populated by user selection
+
+  // Convert steps to NodeOrderMap format
+  const nodesOrder: NodeOrderMap = {}
+
+  templateTestCase.steps.forEach((step, index) => {
+    const nodeId = `node-${index}`
+
+    // Convert parameters from template format to test case format
+    const parameters = step.parameters.map(param => ({
+      name: param.name,
+      value: param.defaultValue, // Convert defaultValue to value
+      type: param.type,
+      order: param.order,
+    }))
+
+    nodesOrder[nodeId] = {
+      order: step.order,
+      label: step.label,
+      gherkinStep: step.gherkinStep,
+      icon: step.icon as TemplateStepIcon,
+      parameters,
+      templateStepId: step.templateStepId,
+    }
+  })
+
+  return {
+    title,
+    description,
+    testSuiteIds,
+    nodesOrder,
+  }
+}
+
+/**
+ * Converts NodeOrderMap to the format expected by TestCaseForm and createTestCaseAction
+ * @param nodesOrder - The NodeOrderMap from the converter
+ * @returns Data in the format expected by the test case form
+ */
+export const convertNodeOrderMapToTestCaseFormData = (nodesOrder: NodeOrderMap): TestCaseFormData['steps'] => {
+  return Object.entries(nodesOrder)
+    .map(([, nodeData]) => ({
+      gherkinStep: nodeData.gherkinStep || '',
+      label: nodeData.label,
+      icon: nodeData.icon as TemplateStepIcon,
+      parameters: nodeData.parameters,
+      order: nodeData.order,
+      templateStepId: nodeData.templateStepId,
+    }))
+    .sort((a, b) => a.order - b.order)
+}
+
+/**
+ * Converts a template test case directly to the format expected by createTestCaseAction
+ * @param templateTestCase - The template test case with steps and parameters
+ * @param testSuiteIds - Optional test suite IDs to assign
+ * @returns Data ready for test case creation
+ */
+export const templateTestCaseToTestCaseFormData = (
+  templateTestCase: TemplateTestCase & {
+    steps: (TemplateTestCaseStep & {
+      parameters: TemplateTestCaseStepParameter[]
+    })[]
+  },
+  testSuiteIds: string[] = [],
+): TestCaseFormData => {
+  const convertedData = templateTestCaseToTestCaseConverter(templateTestCase)
+
+  return {
+    title: convertedData.title,
+    description: convertedData.description,
+    testSuiteIds: testSuiteIds.length > 0 ? testSuiteIds : convertedData.testSuiteIds,
+    steps: convertNodeOrderMapToTestCaseFormData(convertedData.nodesOrder),
+  }
+}
+
+/**
+ * Validates if the converted data is ready for test case creation
+ * @param convertedData - The converted test case data
+ * @returns Validation result with any errors
+ */
+export const validateConvertedTestCaseData = (
+  convertedData: ConvertedTestCaseData,
+): { isValid: boolean; errors: string[] } => {
+  const errors: string[] = []
+
+  if (!convertedData.title || convertedData.title.trim().length < 3) {
+    errors.push('Title must be at least 3 characters long')
+  }
+
+  if (Object.keys(convertedData.nodesOrder).length === 0) {
+    errors.push('At least one step is required')
+  }
+
+  // Validate each step
+  Object.entries(convertedData.nodesOrder).forEach(([nodeId, nodeData]) => {
+    if (!nodeData.label || nodeData.label.trim().length === 0) {
+      errors.push(`Step ${nodeId}: Label is required`)
+    }
+
+    if (!nodeData.templateStepId) {
+      errors.push(`Step ${nodeId}: Template step ID is required`)
+    }
+  })
+
+  return {
+    isValid: errors.length === 0,
+    errors,
+  }
+}

package/templates/default/src/lib/utils/node-param-validation.ts

@@ -0,0 +1,81 @@
+import { StepParameterType, TemplateStepParameter } from '@prisma/client'
+
+/**
+ * Type for node data with parameters needed for validation
+ */
+type NodeDataForValidation = {
+  templateStepId: string
+  parameters: {
+    name: string
+    value: string
+    type: StepParameterType
+    order: number
+  }[]
+}
+
+/**
+ * Checks if a node has missing mandatory parameters
+ * @param nodeData - The node data to validate (must have templateStepId and parameters)
+ * @param templateStepParams - All available template step parameters
+ * @param defaultValueInput - If true, all parameters are optional (skip validation)
+ * @returns true if any mandatory parameter is missing, false otherwise
+ */
+export function checkMissingMandatoryParams(
+  nodeData: NodeDataForValidation,
+  templateStepParams: TemplateStepParameter[],
+  defaultValueInput: boolean,
+): boolean {
+  // Skip all validation if defaultValueInput is true (all fields are optional)
+  if (defaultValueInput) {
+    return false
+  }
+
+  // Get all template step parameters for this node's templateStepId
+  const nodeParams = templateStepParams.filter(param => param.templateStepId === nodeData.templateStepId)
+
+  // Create a map of node parameters by name for quick lookup
+  const nodeParamMap = new Map(nodeData.parameters.map(param => [param.name, param.value]))
+
+  // Check each required parameter
+  for (const param of nodeParams) {
+    const value = nodeParamMap.get(param.name)
+
+    // LOCATOR: Check if value is empty (we can't check locator group selection from node data)
+    if (param.type === 'LOCATOR') {
+      if (!value || value.trim() === '') {
+        return true
+      }
+    }
+
+    // STRING: Check if value is empty
+    if (param.type === 'STRING') {
+      if (!value || value.trim() === '') {
+        return true
+      }
+    }
+
+    // NUMBER: Check if value is empty
+    if (param.type === 'NUMBER') {
+      if (!value || value.trim() === '') {
+        return true
+      }
+    }
+
+    // DATE: Check if value is empty or invalid
+    if (param.type === 'DATE') {
+      if (!value || value.trim() === '') {
+        return true
+      }
+      // Try to parse the date to check if it's valid
+      const date = new Date(value)
+      if (isNaN(date.getTime())) {
+        return true
+      }
+    }
+
+    // BOOLEAN: Always has a value (true/false), so skip validation
+    // No validation needed for BOOLEAN type
+  }
+
+  return false
+}

package/templates/default/src/lib/utils/template-step-file-generator.ts

@@ -0,0 +1,167 @@
+import { promises as fs } from 'fs'
+import { join } from 'path'
+import prettier from 'prettier'
+import { TemplateStep, TemplateStepGroupType } from '@prisma/client'
+
+/**
+ * Sanitizes a template step group name for file naming
+ * Converts to kebab-case (lowercase with underscores for spaces)
+ */
+export function sanitizeFileName(groupName: string): string {
+  return groupName
+    .toLowerCase()
+    .trim()
+    .replace(/\s+/g, '_') // Replace spaces with underscores
+    .replace(/[^a-z0-9_]/g, '') // Remove special characters except underscores
+}
+
+/**
+ * Generates the content for a template step group file
+ * Concatenates all function definitions from template steps in the group
+ */
+export function generateFileContent(templateSteps: TemplateStep[]): string {
+  // Required imports for all template step group files
+  const requiredImports = `import { When } from '@cucumber/cucumber';
+import { CustomWorld } from '../../config/executor/world.js';
+import { SelectorName } from '@/types/locator/locator.type';
+import { resolveLocator } from '../../utils/locator.util';
+
+`
+
+  if (!templateSteps || templateSteps.length === 0) {
+    return (
+      requiredImports + '// This file is generated automatically. Add template steps to this group to generate content.'
+    )
+  }
+
+  // Extract and concatenate function definitions
+  const functionDefinitions = templateSteps
+    .map(step => step.functionDefinition)
+    .filter(Boolean) // Remove undefined/null values
+    .join('\n\n')
+
+  return requiredImports + functionDefinitions
+}
+
+/**
+ * Formats the file content using Prettier
+ */
+export async function formatFileContent(content: string): Promise<string> {
+  try {
+    const formattedContent = await prettier.format(content, {
+      parser: 'typescript',
+      semi: true,
+      singleQuote: true,
+      trailingComma: 'es5',
+      printWidth: 80,
+      tabWidth: 2,
+    })
+    return formattedContent
+  } catch (error) {
+    console.error('Prettier formatting failed:', error)
+    // Return original content if formatting fails
+    return content
+  }
+}
+
+/**
+ * Gets the subdirectory name for a given template step group type
+ */
+export function getSubdirectoryName(type: TemplateStepGroupType | string): string {
+  const typeStr = String(type)
+  return typeStr === 'ACTION' ? 'actions' : 'validations'
+}
+
+/**
+ * Ensures the steps directory and subdirectories exist, creates them if they don't
+ */
+export async function ensureStepsDirectory(): Promise<string> {
+  const stepsDir = join(process.cwd(), 'src', 'tests', 'steps')
+
+  try {
+    await fs.access(stepsDir)
+  } catch {
+    // Directory doesn't exist, create it
+    await fs.mkdir(stepsDir, { recursive: true })
+  }
+
+  // Ensure both subdirectories exist
+  const actionsDir = join(stepsDir, 'actions')
+  const validationsDir = join(stepsDir, 'validations')
+
+  try {
+    await fs.access(actionsDir)
+  } catch {
+    await fs.mkdir(actionsDir, { recursive: true })
+  }
+
+  try {
+    await fs.access(validationsDir)
+  } catch {
+    await fs.mkdir(validationsDir, { recursive: true })
+  }
+
+  return stepsDir
+}
+
+/**
+ * Generates the full file path for a template step group
+ */
+export function getFilePath(groupName: string, type: TemplateStepGroupType | string): string {
+  const sanitizedName = sanitizeFileName(groupName)
+  const subdirectory = getSubdirectoryName(type)
+  return join(process.cwd(), 'src', 'tests', 'steps', subdirectory, `${sanitizedName}.step.ts`)
+}
+
+/**
+ * Writes content to a template step group file
+ */
+export async function writeTemplateStepFile(
+  groupName: string,
+  content: string,
+  type: TemplateStepGroupType | string,
+): Promise<void> {
+  try {
+    // Ensure directory exists
+    await ensureStepsDirectory()
+
+    // Format content with Prettier
+    const formattedContent = await formatFileContent(content)
+
+    // Get file path
+    const filePath = getFilePath(groupName, type)
+
+    // Write file
+    await fs.writeFile(filePath, formattedContent, 'utf8')
+
+    console.log(`Template step file generated: ${filePath}`)
+  } catch (error) {
+    console.error(`Failed to write template step file for group "${groupName}":`, error)
+    throw new Error(`File generation failed: ${error}`)
+  }
+}
+
+/**
+ * Deletes a template step group file
+ */
+export async function deleteTemplateStepFile(groupName: string, type: TemplateStepGroupType | string): Promise<void> {
+  try {
+    const filePath = getFilePath(groupName, type)
+
+    // Check if file exists before trying to delete
+    try {
+      await fs.access(filePath)
+    } catch {
+      // File doesn't exist, nothing to delete
+      return
+    }
+
+    // Delete file
+    await fs.unlink(filePath)
+
+    console.log(`Template step file deleted: ${filePath}`)
+  } catch (error) {
+    console.error(`Failed to delete template step file for group "${groupName}":`, error)
+    throw new Error(`File deletion failed: ${error}`)
+  }
+}