create-appraisejs 0.2.0 → 0.3.0-alpha.1

package/templates/starter/src/lib/test-run/report-parser.ts

@@ -0,0 +1,352 @@
+import { readFile } from 'fs/promises'
+import { StepStatus, StepKeyword } from '@prisma/client'
+
+const SCREENSHOT_ATTACHMENT_MEDIA_TYPE = 'application/vnd.appraisejs.report-step-screenshot+json'
+
+/**
+ * Parsed report structure matching cucumber.json format
+ */
+export interface ParsedReport {
+  features: Array<{
+    name: string
+    description: string
+    uri: string
+    line: number
+    keyword: string
+    tags: Array<{ name: string; line: number }>
+    scenarios: Array<{
+      name: string
+      description: string
+      line: number
+      keyword: string
+      type: string
+      cucumberId: string
+      tags: Array<{ name: string; line: number }>
+      steps: Array<{
+        keyword: string
+        line: number | null
+        name: string
+        matchLocation?: string
+        status: string
+        duration: number
+        errorMessage?: string
+        errorTrace?: string
+        screenshotPath?: string
+        hidden: boolean
+        order: number
+      }>
+      hooks: Array<{
+        keyword: string
+        status: string
+        duration: number
+        errorMessage?: string
+        errorTrace?: string
+        hidden: boolean
+      }>
+    }>
+  }>
+}
+
+/**
+ * Cucumber JSON report structure (as received from cucumber-js)
+ */
+interface CucumberJsonFeature {
+  description: string
+  elements: Array<{
+    description: string
+    id: string
+    keyword: string
+    line: number
+    name: string
+    steps: Array<{
+      keyword: string
+      line?: number
+      name?: string
+      hidden?: boolean
+      match?: {
+        location: string
+      }
+      result?: {
+        status: string
+        duration?: number
+        error_message?: string
+      }
+      embeddings?: Array<{
+        data?: string
+        mime_type?: string
+      }>
+    }>
+    tags: Array<{
+      name: string
+      line: number
+    }>
+    type: string
+  }>
+  id: string
+  line: number
+  keyword: string
+  name: string
+  tags: Array<{
+    name: string
+    line: number
+  }>
+  uri: string
+}
+
+function extractScreenshotPath(
+  embeddings: Array<{ data?: string; mime_type?: string }> | undefined,
+): string | undefined {
+  const screenshotAttachment = embeddings?.find(embedding => embedding.mime_type === SCREENSHOT_ATTACHMENT_MEDIA_TYPE)
+
+  if (!screenshotAttachment?.data) {
+    return undefined
+  }
+
+  const parsePayload = (payload: string): string | undefined => {
+    try {
+      const parsedPayload = JSON.parse(payload) as { screenshotPath?: unknown }
+      return typeof parsedPayload.screenshotPath === 'string' ? parsedPayload.screenshotPath : undefined
+    } catch {
+      return undefined
+    }
+  }
+
+  const directPayload = parsePayload(screenshotAttachment.data)
+  if (directPayload) {
+    return directPayload
+  }
+
+  const decodedPayload = Buffer.from(screenshotAttachment.data, 'base64').toString('utf8')
+  return parsePayload(decodedPayload)
+}
+
+/**
+ * Maps cucumber step status to Prisma StepStatus enum
+ */
+function mapStepStatus(status: string): StepStatus {
+  const upperStatus = status.toUpperCase()
+  switch (upperStatus) {
+    case 'PASSED':
+      return StepStatus.PASSED
+    case 'FAILED':
+      return StepStatus.FAILED
+    case 'SKIPPED':
+      return StepStatus.SKIPPED
+    case 'PENDING':
+      return StepStatus.PENDING
+    case 'UNDEFINED':
+      return StepStatus.UNDEFINED
+    default:
+      return StepStatus.PENDING
+  }
+}
+
+/**
+ * Maps cucumber step keyword to Prisma StepKeyword enum
+ */
+function mapStepKeyword(keyword: string): StepKeyword {
+  const trimmedKeyword = keyword.trim()
+  const upperKeyword = trimmedKeyword.toUpperCase()
+  switch (upperKeyword) {
+    case 'GIVEN':
+      return StepKeyword.GIVEN
+    case 'WHEN':
+      return StepKeyword.WHEN
+    case 'THEN':
+      return StepKeyword.THEN
+    case 'AND':
+      return StepKeyword.AND
+    case 'BUT':
+      return StepKeyword.BUT
+    case 'BEFORE':
+      return StepKeyword.BEFORE
+    case 'AFTER':
+      return StepKeyword.AFTER
+    default:
+      // Default to GIVEN for unknown keywords
+      return StepKeyword.GIVEN
+  }
+}
+
+/**
+ * Separates error message from stack trace
+ * Cucumber's error_message typically contains both the error message and stack trace
+ * The stack trace usually starts with "at" or contains file paths
+ *
+ * @param errorMessage - The full error message from Cucumber
+ * @returns Object with separated message and trace
+ */
+function separateErrorMessageAndTrace(errorMessage: string | undefined): {
+  message: string | undefined
+  trace: string | undefined
+} {
+  if (!errorMessage) {
+    return { message: undefined, trace: undefined }
+  }
+
+  // Look for common stack trace indicators
+  // Stack traces typically start with "at", "    at", or contain file paths with line numbers
+  const stackTracePatterns = [
+    /\n\s*at\s/, // "at" at the start of a line (with optional whitespace)
+    /\n\s+at\s/, // "at" with leading whitespace
+    /Error:\s*$/m, // Error: at end of line (message ends, trace starts)
+  ]
+
+  // Find the first occurrence of a stack trace pattern
+  let splitIndex = -1
+  for (const pattern of stackTracePatterns) {
+    const match = errorMessage.match(pattern)
+    if (match && match.index !== undefined) {
+      // If we find "at" pattern, split before it (include the newline before "at")
+      // If we find "Error:" pattern, split after it
+      if (pattern.source.includes('Error:')) {
+        splitIndex = match.index + match[0].length
+      } else {
+        splitIndex = match.index
+      }
+      break
+    }
+  }
+
+  // If no stack trace pattern found, check if it looks like just a message (short, no file paths)
+  if (splitIndex === -1) {
+    // Check if it contains file paths (common in stack traces)
+    const hasFilePath = /[\/\\][\w\-\.]+:\d+/.test(errorMessage)
+    if (hasFilePath && errorMessage.length > 200) {
+      // Likely contains a trace, try to find where message ends
+      // Usually the first few lines are the message, rest is trace
+      const lines = errorMessage.split('\n')
+      // Look for the first line that starts with whitespace and "at" or contains a file path
+      for (let i = 0; i < lines.length; i++) {
+        if (/^\s*at\s/.test(lines[i]) || /[\/\\][\w\-\.]+:\d+/.test(lines[i])) {
+          splitIndex = errorMessage.indexOf(lines[i])
+          break
+        }
+      }
+    }
+  }
+
+  if (splitIndex > 0) {
+    const message = errorMessage.substring(0, splitIndex).trim()
+    const trace = errorMessage.substring(splitIndex).trim()
+    return {
+      message: message || undefined,
+      trace: trace || undefined,
+    }
+  }
+
+  // If we can't separate them, treat the whole thing as the message
+  // and leave trace as undefined (better than duplicating)
+  return {
+    message: errorMessage.trim() || undefined,
+    trace: undefined,
+  }
+}
+
+/**
+ * Parses a cucumber.json report file into a structured ParsedReport object
+ *
+ * @param reportPath - Path to the cucumber.json file
+ * @returns Parsed report structure
+ * @throws Error if file cannot be read or parsed
+ */
+export async function parseCucumberReport(reportPath: string): Promise<ParsedReport> {
+  try {
+    // Read the report file
+    const fileContent = await readFile(reportPath, 'utf-8')
+    const cucumberData: CucumberJsonFeature[] = JSON.parse(fileContent)
+
+    // Parse features
+    const features = cucumberData.map(feature => {
+      // Separate steps into regular steps and hooks
+      const scenarios = feature.elements.map(element => {
+        const steps: ParsedReport['features'][0]['scenarios'][0]['steps'] = []
+        const hooks: ParsedReport['features'][0]['scenarios'][0]['hooks'] = []
+
+        element.steps.forEach((step, index) => {
+          const isHook = step.keyword === 'Before' || step.keyword === 'After'
+          const stepStatus = step.result?.status || 'pending'
+          const duration = step.result?.duration || 0
+
+          // Separate error message from stack trace
+          const { message: errorMessage, trace: errorTrace } = separateErrorMessageAndTrace(step.result?.error_message)
+          const screenshotPath = extractScreenshotPath(step.embeddings)
+
+          if (isHook) {
+            hooks.push({
+              keyword: step.keyword,
+              status: stepStatus,
+              duration,
+              errorMessage,
+              errorTrace,
+              hidden: step.hidden || false,
+            })
+          } else {
+            steps.push({
+              keyword: step.keyword.trim(),
+              line: step.line || null,
+              name: step.name || '',
+              matchLocation: step.match?.location,
+              status: stepStatus,
+              duration,
+              errorMessage,
+              errorTrace,
+              screenshotPath,
+              hidden: step.hidden || false,
+              order: index,
+            })
+          }
+        })
+
+        return {
+          name: element.name,
+          description: element.description || '',
+          line: element.line,
+          keyword: element.keyword,
+          type: element.type,
+          cucumberId: element.id,
+          tags: element.tags.map(tag => ({
+            name: tag.name,
+            line: tag.line,
+          })),
+          steps,
+          hooks,
+        }
+      })
+
+      return {
+        name: feature.name,
+        description: feature.description || '',
+        uri: feature.uri,
+        line: feature.line,
+        keyword: feature.keyword,
+        tags: feature.tags.map(tag => ({
+          name: tag.name,
+          line: tag.line,
+        })),
+        scenarios,
+      }
+    })
+
+    return { features }
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to parse cucumber report at ${reportPath}: ${error.message}`)
+    }
+    throw new Error(`Failed to parse cucumber report at ${reportPath}: Unknown error`)
+  }
+}
+
+/**
+ * Helper function to convert parsed step status to Prisma enum
+ */
+export function getStepStatusEnum(status: string): StepStatus {
+  return mapStepStatus(status)
+}
+
+/**
+ * Helper function to convert parsed step keyword to Prisma enum
+ */
+export function getStepKeywordEnum(keyword: string): StepKeyword {
+  return mapStepKeyword(keyword)
+}

package/templates/starter/src/lib/test-run/test-run-executor.ts

@@ -0,0 +1,13 @@
+import type { TestRunExecutionRequest, TestRunExecutionResult } from '@/lib/executor/types'
+import { localExecutorAdapter } from '@/lib/executor/local-executor-adapter'
+import { getAutomationRunReportPath } from '@/lib/automation/automation-path-roots'
+
+export type TestRunExecutionConfig = TestRunExecutionRequest
+
+export function generateReportPath(testRunId: string): string {
+  return getAutomationRunReportPath(testRunId)
+}
+
+export async function executeTestRun(config: TestRunExecutionConfig): Promise<TestRunExecutionResult> {
+  return localExecutorAdapter.executeTestRun(config)
+}

package/templates/starter/src/lib/test-run/winston-logger.ts

@@ -0,0 +1,65 @@
+import winston from 'winston'
+import path from 'path'
+import { promises as fs } from 'fs'
+import { getAutomationRunLogPath, toProjectRelativePath } from '@/lib/automation/automation-path-roots'
+import { ensureAutomationWorkspaceReady } from '@/lib/automation/automation-workspace'
+
+async function ensureLogsDirectory(testRunId: string): Promise<void> {
+  await ensureAutomationWorkspaceReady()
+  await fs.mkdir(path.dirname(getAutomationRunLogPath(testRunId)), { recursive: true })
+}
+
+export async function createTestRunLogger(testRunId: string): Promise<winston.Logger> {
+  await ensureLogsDirectory(testRunId)
+  const logFilePath = getAutomationRunLogPath(testRunId)
+
+  const logFormat = winston.format.combine(
+    winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+    winston.format.errors({ stack: true }),
+    winston.format.printf(({ timestamp, level, message, stack }) => {
+      if (stack) {
+        return `${timestamp} [${level.toUpperCase()}]: ${message}\n${stack}`
+      }
+      return `${timestamp} [${level.toUpperCase()}]: ${message}`
+    }),
+  )
+
+  return winston.createLogger({
+    level: 'info',
+    format: logFormat,
+    transports: [
+      new winston.transports.Console({
+        format: winston.format.combine(
+          winston.format.colorize(),
+          winston.format.printf(({ timestamp, level, message, stack }) => {
+            if (stack) {
+              return `${timestamp} [${level}]: ${message}\n${stack}`
+            }
+            return `${timestamp} [${level}]: ${message}`
+          }),
+        ),
+      }),
+      new winston.transports.File({
+        filename: logFilePath,
+        maxsize: 10 * 1024 * 1024,
+        maxFiles: 5,
+      }),
+    ],
+  })
+}
+
+export async function closeLogger(logger: winston.Logger): Promise<void> {
+  return new Promise((resolve, reject) => {
+    logger.end((err: Error | null) => {
+      if (err) {
+        reject(err)
+      } else {
+        resolve()
+      }
+    })
+  })
+}
+
+export function getLogFilePath(testRunId: string): string {
+  return toProjectRelativePath(getAutomationRunLogPath(testRunId))
+}

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

@@ -0,0 +1,76 @@
+import prisma from '@/config/db-config'
+import { generateUniqueTestSuiteIdentifier } from '@/lib/test-suite-utils'
+import { getIdentifierTagByPrefix } from '@/lib/tag-utils'
+import { TagType } from '@prisma/client'
+
+async function createTestSuiteIdentifierTag() {
+  const identifier = generateUniqueTestSuiteIdentifier()
+
+  return prisma.tag.create({
+    data: {
+      name: identifier,
+      type: TagType.IDENTIFIER,
+      tagExpression: `@${identifier}`,
+    },
+  })
+}
+
+export async function ensureTestSuiteIdentifierTags(testSuiteIds?: string[]): Promise<void> {
+  const testSuites = await prisma.testSuite.findMany({
+    where: testSuiteIds ? { id: { in: testSuiteIds } } : undefined,
+    include: {
+      tags: {
+        select: {
+          id: true,
+          name: true,
+          tagExpression: true,
+          type: true,
+        },
+      },
+    },
+  })
+
+  for (const testSuite of testSuites) {
+    const suiteIdentifierTag = getIdentifierTagByPrefix(testSuite.tags, 'ts_')
+    if (suiteIdentifierTag) {
+      continue
+    }
+
+    const identifierTag = await createTestSuiteIdentifierTag()
+    await prisma.testSuite.update({
+      where: { id: testSuite.id },
+      data: {
+        tags: {
+          connect: {
+            id: identifierTag.id,
+          },
+        },
+      },
+    })
+  }
+}
+
+export async function getOrCreateTestSuiteIdentifierTagId(testSuiteId: string): Promise<string> {
+  await ensureTestSuiteIdentifierTags([testSuiteId])
+
+  const testSuite = await prisma.testSuite.findUnique({
+    where: { id: testSuiteId },
+    include: {
+      tags: {
+        select: {
+          id: true,
+          name: true,
+          tagExpression: true,
+          type: true,
+        },
+      },
+    },
+  })
+
+  const identifierTag = testSuite ? getIdentifierTagByPrefix(testSuite.tags, 'ts_') : undefined
+  if (!identifierTag) {
+    throw new Error(`Unable to resolve identifier tag for test suite ${testSuiteId}`)
+  }
+
+  return identifierTag.id
+}

package/templates/starter/src/lib/test-suite-utils.ts

@@ -0,0 +1,6 @@
+import crypto from 'crypto'
+
+export function generateUniqueTestSuiteIdentifier(): string {
+  const id = crypto.randomBytes(8).toString('hex')
+  return `ts_${id}`
+}

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

@@ -0,0 +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}`
+}

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

@@ -0,0 +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)
+}