create-appraisejs 0.1.6 → 0.1.8-alpha

package/templates/default/src/lib/transformers/key-to-icon-transformer.tsx

@@ -1,95 +1,95 @@
-import { TemplateStepIcon } from '@prisma/client'
-import {
-  ALargeSmall,
-  BugPlay,
-  Database,
-  Download,
-  Globe,
-  Keyboard,
-  MousePointerClick,
-  Save,
-  Server,
-  Upload,
-  Loader,
-  CheckCheck,
-  LucideIcon,
-} from 'lucide-react'
-import { ReactElement } from 'react'
-
-export const KeyToIconTransformer = (key: TemplateStepIcon, className?: string) => {
-  switch (key) {
-    case 'MOUSE':
-      return <MousePointerClick className={className} />
-    case 'NAVIGATION':
-      return <Globe className={className} />
-    case 'INPUT':
-      return <Keyboard className={className} />
-    case 'DOWNLOAD':
-      return <Download className={className} />
-    case 'API':
-      return <Server className={className} />
-    case 'STORE':
-      return <Save className={className} />
-    case 'FORMAT':
-      return <ALargeSmall className={className} />
-    case 'DATA':
-      return <Database className={className} />
-    case 'UPLOAD':
-      return <Upload className={className} />
-    case 'WAIT':
-      return <Loader className={className} />
-    case 'VALIDATION':
-      return <CheckCheck className={className} />
-    case 'DEBUG':
-      return <BugPlay className={className} />
-  }
-}
-
-// Map of component types to TemplateStepIcon values
-const componentToIconMap = new Map<LucideIcon, TemplateStepIcon>([
-  [MousePointerClick, 'MOUSE'],
-  [Globe, 'NAVIGATION'],
-  [Keyboard, 'INPUT'],
-  [Download, 'DOWNLOAD'],
-  [Server, 'API'],
-  [Save, 'STORE'],
-  [ALargeSmall, 'FORMAT'],
-  [Database, 'DATA'],
-  [Upload, 'UPLOAD'],
-  [Loader, 'WAIT'],
-  [CheckCheck, 'VALIDATION'],
-  [BugPlay, 'DEBUG'],
-])
-
-// Map of string values to TemplateStepIcon values
-const stringToIconMap = new Map<string, TemplateStepIcon>([
-  ['MOUSE', 'MOUSE'],
-  ['NAVIGATION', 'NAVIGATION'],
-  ['INPUT', 'INPUT'],
-  ['DOWNLOAD', 'DOWNLOAD'],
-  ['API', 'API'],
-  ['STORE', 'STORE'],
-  ['FORMAT', 'FORMAT'],
-  ['DATA', 'DATA'],
-  ['UPLOAD', 'UPLOAD'],
-  ['WAIT', 'WAIT'],
-  ['VALIDATION', 'VALIDATION'],
-  ['DEBUG', 'DEBUG'],
-])
-
-export const IconToKeyTransformer = (icon: React.ReactNode | string): TemplateStepIcon | undefined => {
-  // Handle string input
-  if (typeof icon === 'string') {
-    return stringToIconMap.get(icon)
-  }
-
-  // Handle React component input
-  if (!icon || typeof icon !== 'object') return undefined
-
-  // Get the component type from the React element
-  const componentType = (icon as ReactElement)?.type
-  if (!componentType) return undefined
-
-  // Look up the icon in our map
-  return componentToIconMap.get(componentType as LucideIcon)
-}
+import { TemplateStepIcon } from '@prisma/client'
+import {
+  ALargeSmall,
+  BugPlay,
+  Database,
+  Download,
+  Globe,
+  Keyboard,
+  MousePointerClick,
+  Save,
+  Server,
+  Upload,
+  Loader,
+  CheckCheck,
+  LucideIcon,
+} from 'lucide-react'
+import { ReactElement } from 'react'
+
+export const KeyToIconTransformer = (key: TemplateStepIcon, className?: string) => {
+  switch (key) {
+    case 'MOUSE':
+      return <MousePointerClick className={className} />
+    case 'NAVIGATION':
+      return <Globe className={className} />
+    case 'INPUT':
+      return <Keyboard className={className} />
+    case 'DOWNLOAD':
+      return <Download className={className} />
+    case 'API':
+      return <Server className={className} />
+    case 'STORE':
+      return <Save className={className} />
+    case 'FORMAT':
+      return <ALargeSmall className={className} />
+    case 'DATA':
+      return <Database className={className} />
+    case 'UPLOAD':
+      return <Upload className={className} />
+    case 'WAIT':
+      return <Loader className={className} />
+    case 'VALIDATION':
+      return <CheckCheck className={className} />
+    case 'DEBUG':
+      return <BugPlay className={className} />
+  }
+}
+
+// Map of component types to TemplateStepIcon values
+const componentToIconMap = new Map<LucideIcon, TemplateStepIcon>([
+  [MousePointerClick, 'MOUSE'],
+  [Globe, 'NAVIGATION'],
+  [Keyboard, 'INPUT'],
+  [Download, 'DOWNLOAD'],
+  [Server, 'API'],
+  [Save, 'STORE'],
+  [ALargeSmall, 'FORMAT'],
+  [Database, 'DATA'],
+  [Upload, 'UPLOAD'],
+  [Loader, 'WAIT'],
+  [CheckCheck, 'VALIDATION'],
+  [BugPlay, 'DEBUG'],
+])
+
+// Map of string values to TemplateStepIcon values
+const stringToIconMap = new Map<string, TemplateStepIcon>([
+  ['MOUSE', 'MOUSE'],
+  ['NAVIGATION', 'NAVIGATION'],
+  ['INPUT', 'INPUT'],
+  ['DOWNLOAD', 'DOWNLOAD'],
+  ['API', 'API'],
+  ['STORE', 'STORE'],
+  ['FORMAT', 'FORMAT'],
+  ['DATA', 'DATA'],
+  ['UPLOAD', 'UPLOAD'],
+  ['WAIT', 'WAIT'],
+  ['VALIDATION', 'VALIDATION'],
+  ['DEBUG', 'DEBUG'],
+])
+
+export const IconToKeyTransformer = (icon: React.ReactNode | string): TemplateStepIcon | undefined => {
+  // Handle string input
+  if (typeof icon === 'string') {
+    return stringToIconMap.get(icon)
+  }
+
+  // Handle React component input
+  if (!icon || typeof icon !== 'object') return undefined
+
+  // Get the component type from the React element
+  const componentType = (icon as ReactElement)?.type
+  if (!componentType) return undefined
+
+  // Look up the icon in our map
+  return componentToIconMap.get(componentType as LucideIcon)
+}

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
+}