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

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

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

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