create-appraisejs 0.2.0-alpha.6 → 0.3.0-alpha.0

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

@@ -1,13 +1,13 @@
-import type { TestRunExecutionRequest, TestRunExecutionResult } from '@/lib/executor/types'
-import { localExecutorAdapter } from '@/lib/executor/local-executor-adapter'
-import { getAutomationRunReportPath } from '@/lib/automation/paths'
-
-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)
-}
+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/default/src/lib/test-run/winston-logger.ts

@@ -1,64 +1,65 @@
-import winston from 'winston'
-import path from 'path'
-import { promises as fs } from 'fs'
-import { ensureAutomationWorkspaceReady, getAutomationRunLogPath, toProjectRelativePath } from '@/lib/automation/paths'
-
-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))
-}
+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/default/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/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)
+}