create-appraisejs 0.3.1-alpha.0 → 0.3.1-alpha.1

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/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

@@ -10,8 +10,7 @@ import {
 import { ensureAutomationWorkspaceReady } from '@/lib/automation/automation-workspace'
 
 const RUNTIME_IMPORT = '../../../packages/cucumber-runtime/src/index.js'
-const REQUIRED_RUNTIME_IMPORT =
-  `import { When, Then, CustomWorld, expect, SelectorName, resolveLocator, getEnvironment, generateRandomData, RandomDataType } from '${RUNTIME_IMPORT}';\n\n`
+const REQUIRED_RUNTIME_IMPORT = `import { When, Then, CustomWorld, expect, SelectorName, resolveLocator, getEnvironment, generateRandomData, RandomDataType } from '${RUNTIME_IMPORT}';\n\n`
 
 function generateStepJSDoc(templateStep: Pick<TemplateStep, 'name' | 'description' | 'icon'>): string {
   const lines = ['/**']
@@ -47,7 +46,10 @@ function sanitizeFileName(groupName: string): string {
 
 export function generateFileContent(templateSteps: TemplateStep[]): string {
   if (!templateSteps || templateSteps.length === 0) {
-    return REQUIRED_RUNTIME_IMPORT + '// This file is generated automatically. Add template steps to this group to generate content.'
+    return (
+      REQUIRED_RUNTIME_IMPORT +
+      '// This file is generated automatically. Add template steps to this group to generate content.'
+    )
   }
 
   const functionDefinitions = templateSteps

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

@@ -103,7 +103,17 @@ interface RequiredImport {
 const REQUIRED_IMPORTS: RequiredImport[] = [
   {
     module: '../../../packages/cucumber-runtime/src/index',
-    namedExports: ['When', 'Then', 'CustomWorld', 'expect', 'SelectorName', 'resolveLocator', 'getEnvironment', 'generateRandomData', 'RandomDataType'],
+    namedExports: [
+      'When',
+      'Then',
+      'CustomWorld',
+      'expect',
+      'SelectorName',
+      'resolveLocator',
+      'getEnvironment',
+      'generateRandomData',
+      'RandomDataType',
+    ],
     from: '../../../packages/cucumber-runtime/src/index.js',
   },
 ]

package/templates/starter/src/services/dashboard/dashboard-service.test.ts

@@ -1,16 +1,43 @@
 import { describe, expect, it, vi } from 'vitest'
 import { TestRunTestCaseResult } from '@prisma/client'
-import { getTestSuiteExecutionData } from './dashboard-service'
+import { getDashboardMetrics, getTestSuiteExecutionData } from './dashboard-service'
+
+const { updateDashboardMetricsMock } = vi.hoisted(() => ({
+  updateDashboardMetricsMock: vi.fn(),
+}))
 
 vi.mock('@/config/db-config', () => ({
   default: {
     testRun: { findMany: vi.fn() },
     report: { findMany: vi.fn() },
+    dashboardMetrics: { findFirst: vi.fn() },
   },
 }))
 
+vi.mock('@/lib/metrics/metric-calculator', () => ({
+  updateDashboardMetrics: updateDashboardMetricsMock,
+}))
+
 import prisma from '@/config/db-config'
 
+describe('getDashboardMetrics', () => {
+  it('refreshes dashboard aggregates before returning the persisted row', async () => {
+    const metrics = {
+      failedRecentRunsCount: 0,
+      repeatedlyFailingTestsCount: 0,
+      flakyTestsCount: 0,
+      suitesNotExecutedRecentlyCount: 0,
+    }
+    updateDashboardMetricsMock.mockResolvedValue(undefined)
+    vi.mocked(prisma.dashboardMetrics.findFirst).mockResolvedValue(metrics as never)
+
+    await expect(getDashboardMetrics()).resolves.toBe(metrics)
+
+    expect(updateDashboardMetricsMock).toHaveBeenCalledOnce()
+    expect(prisma.dashboardMetrics.findFirst).toHaveBeenCalledOnce()
+  })
+})
+
 describe('getTestSuiteExecutionData', () => {
   it('returns empty array when no completed test runs', async () => {
     vi.mocked(prisma.testRun.findMany).mockResolvedValue([] as never)

package/templates/starter/src/services/dashboard/dashboard-service.ts

@@ -1,4 +1,5 @@
 import prisma from '@/config/db-config'
+import { updateDashboardMetrics } from '@/lib/metrics/metric-calculator'
 import { TestRunStatus, TestRunTestCaseResult } from '@prisma/client'
 
 /** Stacked bar segments are raw counts; `total` matches passed+failed+cancelled+unknown. */
@@ -19,6 +20,7 @@ export type EntityMetrics = {
 }
 
 export async function getDashboardMetrics() {
+  await updateDashboardMetrics()
   return prisma.dashboardMetrics.findFirst()
 }
 

package/templates/starter/src/services/locator/locator-service.test.ts

@@ -37,9 +37,7 @@ describe('detectAndCreateConflicts', () => {
   it('returns 0 when no other locators in group', async () => {
     vi.mocked(prisma.locator.findMany).mockResolvedValue([])
 
-    await expect(
-      detectAndCreateConflicts('loc-1', 'btn', '//x', 'group-1'),
-    ).resolves.toBe(0)
+    await expect(detectAndCreateConflicts('loc-1', 'btn', '//x', 'group-1')).resolves.toBe(0)
     expect(prisma.conflictResolution.create).not.toHaveBeenCalled()
   })
 })

package/templates/starter/src/services/locator/locator-service.ts

@@ -352,7 +352,9 @@ export type SavePickedLocatorOutcome =
     }
   | { kind: 'error'; status: number; message: string }
 
-export async function savePickedLocatorFromRequest(request: SavePickedLocatorRequest): Promise<SavePickedLocatorOutcome> {
+export async function savePickedLocatorFromRequest(
+  request: SavePickedLocatorRequest,
+): Promise<SavePickedLocatorOutcome> {
   const value = savePickedLocatorSchema.parse(request)
   const session = value.sessionId ? await locatorPickerSessionManager.getSession(value.sessionId) : null
 

package/templates/starter/src/services/locator/locator-sync-utils.test.ts

@@ -3,10 +3,7 @@ import { mergeMissingLocators } from './locator-sync-utils'
 
 describe('mergeMissingLocators', () => {
   it('adds keys only from locatorsToEnsure that are missing in base', () => {
-    const { mergedLocators, addedCount } = mergeMissingLocators(
-      { a: '1', b: '2' },
-      { b: 'x', c: '3' },
-    )
+    const { mergedLocators, addedCount } = mergeMissingLocators({ a: '1', b: '2' }, { b: 'x', c: '3' })
     expect(mergedLocators).toEqual({ a: '1', b: '2', c: '3' })
     expect(addedCount).toBe(1)
   })

package/templates/starter/src/services/module/module-service.ts

@@ -46,10 +46,7 @@ export async function getModuleByIdOrThrow(id: string): Promise<ModuleWithParent
   return moduleData
 }
 
-export async function updateModule(
-  id: string | undefined,
-  value: z.infer<typeof moduleSchema>,
-): Promise<Module> {
+export async function updateModule(id: string | undefined, value: z.infer<typeof moduleSchema>): Promise<Module> {
   if (!id) {
     throw new ServiceError('Module id is required', 'VALIDATION', 400)
   }