create-appraisejs 0.3.0 → 0.3.1-alpha.0

package/templates/starter/src/lib/test-suite-identifier-service.ts

@@ -1,6 +1,6 @@
 import prisma from '@/config/db-config'
 import { generateUniqueTestSuiteIdentifier } from '@/lib/test-suite-utils'
-import { getIdentifierTagByPrefix } from '@/lib/tag-utils'
+import { getIdentifierTagByPrefix } from '@/lib/tag-filters'
 import { TagType } from '@prisma/client'
 
 async function createTestSuiteIdentifierTag() {

package/templates/starter/src/lib/transformers/gherkin-converter.ts

@@ -1,42 +1,42 @@
-import { TemplateStepType } from '@prisma/client'
-
-export const generateGherkinStep = (
-  type: TemplateStepType,
-  signature: string,
-  parameters: { value: string; order: number }[],
-) => {
-  const signatureParts = signature.split(' ')
-  const sortedParameters = parameters.sort((a, b) => a.order - b.order)
-
-  const gherkinStep = signatureParts
-    .map(part => {
-      // Check if this part is a parameter placeholder
-      if (part.startsWith('{') && part.endsWith('}')) {
-        const parameter = sortedParameters.shift()
-
-        // If no parameter or missing value, return the placeholder to indicate incompleteness
-        if (!parameter || !parameter.value || parameter.value.trim() === '') {
-          return part
-        }
-
-        // Format the parameter value based on its type
-        switch (part) {
-          case '{string}':
-            return `"${parameter.value}"`
-          case '{int}':
-            return parameter.value
-          case '{boolean}':
-            return parameter.value
-          default:
-            return parameter.value
-        }
-      }
-
-      return part
-    })
-    .join(' ')
-
-  // Prepend the appropriate Gherkin keyword based on type
-  const keyword = type === 'ACTION' ? 'When' : 'Then'
-  return `${keyword} ${gherkinStep}`
-}
+import { TemplateStepType } from '@prisma/client'
+
+export const generateGherkinStep = (
+  type: TemplateStepType,
+  signature: string,
+  parameters: { value: string; order: number }[],
+) => {
+  const signatureParts = signature.split(' ')
+  const sortedParameters = parameters.sort((a, b) => a.order - b.order)
+
+  const gherkinStep = signatureParts
+    .map(part => {
+      // Check if this part is a parameter placeholder
+      if (part.startsWith('{') && part.endsWith('}')) {
+        const parameter = sortedParameters.shift()
+
+        // If no parameter or missing value, return the placeholder to indicate incompleteness
+        if (!parameter || !parameter.value || parameter.value.trim() === '') {
+          return part
+        }
+
+        // Format the parameter value based on its type
+        switch (part) {
+          case '{string}':
+            return `"${parameter.value}"`
+          case '{int}':
+            return parameter.value
+          case '{boolean}':
+            return parameter.value
+          default:
+            return parameter.value
+        }
+      }
+
+      return part
+    })
+    .join(' ')
+
+  // Prepend the appropriate Gherkin keyword based on type
+  const keyword = type === 'ACTION' ? 'When' : 'Then'
+  return `${keyword} ${gherkinStep}`
+}

package/templates/starter/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/starter/src/lib/transformers/template-test-case-converter.ts

@@ -2,35 +2,18 @@ import {
   TemplateTestCase,
   TemplateTestCaseStep,
   TemplateTestCaseStepParameter,
+  TemplateTestCaseFlowBlock,
+  TemplateTestCaseFlowBlockNode,
   TemplateStepIcon,
-  StepParameterType,
 } from '@prisma/client'
-import { NodeOrderMap } from '@/types/diagram/diagram'
+import { FlowBlock, 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
-  }[]
+  flowBlocks: FlowBlock[]
 }
 
 /**
@@ -43,6 +26,7 @@ export const templateTestCaseToTestCaseConverter = (
     steps: (TemplateTestCaseStep & {
       parameters: TemplateTestCaseStepParameter[]
     })[]
+    flowBlocks?: (TemplateTestCaseFlowBlock & { nodes: TemplateTestCaseFlowBlockNode[] })[]
   },
 ): ConvertedTestCaseData => {
   // Convert template test case to test case format
@@ -54,7 +38,7 @@ export const templateTestCaseToTestCaseConverter = (
   const nodesOrder: NodeOrderMap = {}
 
   templateTestCase.steps.forEach((step, index) => {
-    const nodeId = `node-${index}`
+    const nodeId = step.flowNodeId ?? `node-${index}`
 
     // Convert parameters from template format to test case format
     const parameters = step.parameters.map(param => ({
@@ -65,6 +49,7 @@ export const templateTestCaseToTestCaseConverter = (
     }))
 
     nodesOrder[nodeId] = {
+      nodeId,
       order: step.order,
       label: step.label,
       gherkinStep: step.gherkinStep,
@@ -79,48 +64,12 @@ export const templateTestCaseToTestCaseConverter = (
     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),
+    flowBlocks:
+      templateTestCase.flowBlocks?.map(block => ({
+        id: block.id,
+        name: block.name,
+        nodeIds: block.nodes.map(node => node.flowNodeId),
+      })) ?? [],
   }
 }
 

package/templates/starter/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
+}

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

@@ -37,7 +37,7 @@ function generateStepDefinition(templateStep: TemplateStep): string | null {
   return `${generateStepJSDoc(templateStep)}\n${stripLeadingJSDoc(functionDefinition)}`
 }
 
-export function sanitizeFileName(groupName: string): string {
+function sanitizeFileName(groupName: string): string {
   return groupName
     .toLowerCase()
     .trim()
@@ -74,7 +74,7 @@ export async function formatFileContent(content: string): Promise<string> {
   }
 }
 
-export function getSubdirectoryName(type: TemplateStepGroupType | string): string {
+function getSubdirectoryName(type: TemplateStepGroupType | string): string {
   const typeStr = String(type)
   return typeStr === 'ACTION' ? 'actions' : 'validations'
 }
@@ -109,20 +109,3 @@ export async function writeTemplateStepFile(
     throw new Error(`File generation failed: ${error}`)
   }
 }
-
-export async function deleteTemplateStepFile(groupName: string, type: TemplateStepGroupType | string): Promise<void> {
-  try {
-    const filePath = getFilePath(groupName, type)
-
-    try {
-      await fs.access(filePath)
-    } catch {
-      return
-    }
-
-    await fs.unlink(filePath)
-  } catch (error) {
-    console.error(`Failed to delete template step file for group "${groupName}":`, error)
-    throw new Error(`File deletion failed: ${error}`)
-  }
-}