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

package/templates/starter/src/constants/form-opts/template-step-group-form-opts.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod'
+
+// TemplateStepGroupType enum - will be available from @prisma/client after migration
+const TemplateStepGroupTypeEnum = z.enum(['ACTION', 'VALIDATION'])
+type TemplateStepGroupType = z.infer<typeof TemplateStepGroupTypeEnum>
+
+export const templateStepGroupSchema = z.object({
+  name: z.string().min(3, { message: 'Name must be at least 3 characters' }),
+  description: z.string().optional(),
+  type: TemplateStepGroupTypeEnum,
+})
+
+export type TemplateStepGroup = z.infer<typeof templateStepGroupSchema>
+
+export const formOpts = {
+  defaultValues: {
+    name: '',
+    description: '',
+    type: 'ACTION' as TemplateStepGroupType,
+  } as TemplateStepGroup,
+  validators: {
+    onChange: templateStepGroupSchema,
+  },
+}

package/templates/starter/src/constants/form-opts/template-test-case-form-opts.ts

@@ -0,0 +1,39 @@
+import { StepParameterType, TemplateStepIcon } from '@prisma/client'
+import { z } from 'zod'
+
+export const templateTestCaseSchema = z.object({
+  title: z.string().min(3, { message: 'Title must be at least 3 characters' }),
+  description: z.string().optional(),
+  steps: z
+    .array(
+      z.object({
+        gherkinStep: z.string(),
+        label: z.string(),
+        icon: z.nativeEnum(TemplateStepIcon),
+        parameters: z.array(
+          z.object({
+            name: z.string(),
+            value: z.string(),
+            type: z.nativeEnum(StepParameterType),
+            order: z.number(),
+          }),
+        ),
+        order: z.number(),
+        templateStepId: z.string(),
+      }),
+    )
+    .min(1, { message: 'Steps are required' }),
+})
+
+export type TemplateTestCase = z.infer<typeof templateTestCaseSchema>
+
+export const formOpts = {
+  defaultValues: {
+    title: '',
+    description: '',
+    steps: [],
+  } as TemplateTestCase,
+  validators: {
+    onChange: templateTestCaseSchema,
+  },
+}

package/templates/starter/src/constants/form-opts/template-test-step-form-opts.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod'
+
+export const templateStepSchema = z.object({
+  name: z.string().min(3, { message: 'Name must be at least 3 characters' }),
+  description: z.string().optional(),
+  type: z.string(),
+  signature: z.string(),
+  functionDefinition: z.string().optional(),
+  params: z.array(
+    z.object({
+      name: z.string(),
+      type: z.string(),
+      order: z.number(),
+    }),
+  ),
+  icon: z.string(),
+  templateStepGroupId: z.string().min(1, { message: 'Template step group is required' }),
+})
+
+export type TemplateStep = z.infer<typeof templateStepSchema>
+
+export const formOpts = {
+  defaultValues: {
+    name: '',
+    description: '',
+    type: 'ACTION',
+    signature: '',
+    functionDefinition: '',
+    params: [],
+    icon: 'MOUSE',
+    templateStepGroupId: '',
+  } as TemplateStep,
+  validators: {
+    onChange: templateStepSchema,
+  },
+}

package/templates/starter/src/constants/form-opts/test-case-form-opts.ts

@@ -0,0 +1,43 @@
+import { StepParameterType, TemplateStepIcon } from '@prisma/client'
+import { z } from 'zod'
+
+export const testCaseSchema = z.object({
+  title: z.string().min(3, { message: 'Title must be at least 3 characters' }),
+  description: z.string().optional(),
+  testSuiteIds: z.array(z.string()),
+  tagIds: z.array(z.string()).optional(),
+  steps: z
+    .array(
+      z.object({
+        gherkinStep: z.string(),
+        label: z.string(),
+        icon: z.nativeEnum(TemplateStepIcon),
+        parameters: z.array(
+          z.object({
+            name: z.string(),
+            value: z.string(),
+            type: z.nativeEnum(StepParameterType),
+            order: z.number(),
+          }),
+        ),
+        order: z.number(),
+        templateStepId: z.string(),
+      }),
+    )
+    .min(1, { message: 'Steps are required' }),
+})
+
+export type TestCase = z.infer<typeof testCaseSchema>
+
+export const formOpts = {
+  defaultValues: {
+    title: '',
+    description: '',
+    testSuiteIds: [],
+    tagIds: [],
+    steps: [],
+  } as TestCase,
+  validators: {
+    onChange: testCaseSchema,
+  },
+}

package/templates/starter/src/constants/form-opts/test-run-form-opts.ts

@@ -0,0 +1,33 @@
+import { BrowserEngine } from '@prisma/client'
+import { z } from 'zod'
+
+export const testRunSchema = z.object({
+  name: z.string().min(1, { message: 'Name is required' }),
+  environmentId: z.string().min(1, { message: 'Environment is required' }),
+  tags: z.array(z.string()),
+  testWorkersCount: z.number().min(1, { message: 'Test workers count must be at least 1' }).optional(),
+  browserEngine: z.nativeEnum(BrowserEngine),
+  testSuites: z.array(
+    z.object({
+      testSuiteId: z.string().min(1, { message: 'Test suite is required' }),
+      runAll: z.boolean(),
+      testCaseIds: z.array(z.string()),
+    }),
+  ),
+})
+
+export type TestRun = z.infer<typeof testRunSchema>
+
+export const formOpts = {
+  defaultValues: {
+    name: '',
+    environmentId: '',
+    tags: [],
+    testWorkersCount: 1,
+    browserEngine: BrowserEngine.CHROMIUM,
+    testSuites: [],
+  } as TestRun,
+  validators: {
+    onChange: testRunSchema,
+  },
+}

package/templates/starter/src/constants/form-opts/test-suite-form-opts.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod'
+
+export const testSuiteSchema = z.object({
+  name: z.string().min(3, { message: 'Name must be at least 3 characters' }),
+  description: z.string().optional(),
+  testCases: z.array(z.string()).optional(),
+  moduleId: z.string().min(1, { message: 'Module is required' }),
+  tagIds: z.array(z.string()).optional(),
+})
+
+export type TestSuite = z.infer<typeof testSuiteSchema>
+
+export const formOpts = {
+  defaultValues: {
+    name: '',
+    description: '',
+    testCases: [],
+    moduleId: '',
+    tagIds: [],
+  } as TestSuite,
+  validators: {
+    onChange: testSuiteSchema,
+  },
+}

package/templates/starter/src/hooks/use-toast.ts

@@ -0,0 +1,187 @@
+'use client'
+
+// Inspired by react-hot-toast library
+import * as React from 'react'
+
+import type { ToastActionElement, ToastProps } from '@/components/ui/toast'
+
+const TOAST_LIMIT = 1
+const TOAST_REMOVE_DELAY = 1000000
+
+type ToasterToast = ToastProps & {
+  id: string
+  title?: React.ReactNode
+  description?: React.ReactNode
+  action?: ToastActionElement
+}
+
+let count = 0
+
+function genId() {
+  count = (count + 1) % Number.MAX_SAFE_INTEGER
+  return count.toString()
+}
+
+type ActionType = {
+  ADD_TOAST: 'ADD_TOAST'
+  UPDATE_TOAST: 'UPDATE_TOAST'
+  DISMISS_TOAST: 'DISMISS_TOAST'
+  REMOVE_TOAST: 'REMOVE_TOAST'
+}
+
+type Action =
+  | {
+      type: ActionType['ADD_TOAST']
+      toast: ToasterToast
+    }
+  | {
+      type: ActionType['UPDATE_TOAST']
+      toast: Partial<ToasterToast>
+    }
+  | {
+      type: ActionType['DISMISS_TOAST']
+      toastId?: ToasterToast['id']
+    }
+  | {
+      type: ActionType['REMOVE_TOAST']
+      toastId?: ToasterToast['id']
+    }
+
+interface State {
+  toasts: ToasterToast[]
+}
+
+const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>()
+
+const addToRemoveQueue = (toastId: string) => {
+  if (toastTimeouts.has(toastId)) {
+    return
+  }
+
+  const timeout = setTimeout(() => {
+    toastTimeouts.delete(toastId)
+    dispatch({
+      type: 'REMOVE_TOAST',
+      toastId: toastId,
+    })
+  }, TOAST_REMOVE_DELAY)
+
+  toastTimeouts.set(toastId, timeout)
+}
+
+export const reducer = (state: State, action: Action): State => {
+  switch (action.type) {
+    case 'ADD_TOAST':
+      return {
+        ...state,
+        toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
+      }
+
+    case 'UPDATE_TOAST':
+      return {
+        ...state,
+        toasts: state.toasts.map(t => (t.id === action.toast.id ? { ...t, ...action.toast } : t)),
+      }
+
+    case 'DISMISS_TOAST': {
+      const { toastId } = action
+
+      // ! Side effects ! - This could be extracted into a dismissToast() action,
+      // but I'll keep it here for simplicity
+      if (toastId) {
+        addToRemoveQueue(toastId)
+      } else {
+        state.toasts.forEach(toast => {
+          addToRemoveQueue(toast.id)
+        })
+      }
+
+      return {
+        ...state,
+        toasts: state.toasts.map(t =>
+          t.id === toastId || toastId === undefined
+            ? {
+                ...t,
+                open: false,
+              }
+            : t,
+        ),
+      }
+    }
+    case 'REMOVE_TOAST':
+      if (action.toastId === undefined) {
+        return {
+          ...state,
+          toasts: [],
+        }
+      }
+      return {
+        ...state,
+        toasts: state.toasts.filter(t => t.id !== action.toastId),
+      }
+  }
+}
+
+const listeners: Array<(state: State) => void> = []
+
+let memoryState: State = { toasts: [] }
+
+function dispatch(action: Action) {
+  memoryState = reducer(memoryState, action)
+  listeners.forEach(listener => {
+    listener(memoryState)
+  })
+}
+
+type Toast = Omit<ToasterToast, 'id'>
+
+function toast({ ...props }: Toast) {
+  const id = genId()
+
+  const update = (props: ToasterToast) =>
+    dispatch({
+      type: 'UPDATE_TOAST',
+      toast: { ...props, id },
+    })
+  const dismiss = () => dispatch({ type: 'DISMISS_TOAST', toastId: id })
+
+  dispatch({
+    type: 'ADD_TOAST',
+    toast: {
+      ...props,
+      id,
+      open: true,
+      onOpenChange: open => {
+        if (!open) dismiss()
+      },
+    },
+  })
+
+  return {
+    id: id,
+    dismiss,
+    update,
+  }
+}
+
+function useToast() {
+  const [state, setState] = React.useState<State>(memoryState)
+
+  React.useEffect(() => {
+    listeners.push(setState)
+    return () => {
+      const index = listeners.indexOf(setState)
+      if (index > -1) {
+        listeners.splice(index, 1)
+      }
+    }
+  }, [state])
+
+  return {
+    ...state,
+    toast,
+    dismiss: (toastId?: string) => dispatch({ type: 'DISMISS_TOAST', toastId }),
+  }
+}
+
+export { useToast, toast }

package/templates/starter/src/lib/automation/automation-path-roots.ts

@@ -0,0 +1,95 @@
+import path from 'path'
+
+// Two-arg join with turbopackIgnore on process.cwd() — required for Turbopack NFT (see Next.js docs).
+function getRepoRoot(): string {
+  return path.join(/* turbopackIgnore: true */ process.cwd(), '.')
+}
+
+let automationRootCache: string | undefined
+let legacyTestsRootCache: string | undefined
+
+export function getAutomationRoot(): string {
+  if (automationRootCache === undefined) {
+    automationRootCache = path.join(getRepoRoot(), 'automation')
+  }
+  return automationRootCache
+}
+
+export function getLegacyTestsRoot(): string {
+  if (legacyTestsRootCache === undefined) {
+    legacyTestsRootCache = path.join(getRepoRoot(), 'src', 'tests')
+  }
+  return legacyTestsRootCache
+}
+
+export function getAutomationConfigDir(): string {
+  return path.join(getAutomationRoot(), 'config')
+}
+
+export function getAutomationEnvironmentsDir(): string {
+  return path.join(getAutomationConfigDir(), 'environments')
+}
+
+export function getAutomationFeaturesDir(): string {
+  return path.join(getAutomationRoot(), 'features')
+}
+
+export function getAutomationLocatorsDir(): string {
+  return path.join(getAutomationRoot(), 'locators')
+}
+
+export function getAutomationMappingDir(): string {
+  return path.join(getAutomationRoot(), 'mapping')
+}
+
+export function getAutomationReportsDir(): string {
+  return path.join(getAutomationRoot(), 'reports')
+}
+
+export function getAutomationReportRunDir(runId: string): string {
+  return path.join(getAutomationReportsDir(), runId)
+}
+
+export function getAutomationRunReportPath(runId: string): string {
+  return path.join(getAutomationReportRunDir(runId), 'cucumber.json')
+}
+
+export function getAutomationReportLogsDir(runId: string): string {
+  return path.join(getAutomationReportRunDir(runId), 'logs')
+}
+
+export function getAutomationRunLogPath(runId: string): string {
+  return path.join(getAutomationReportLogsDir(runId), 'run.log')
+}
+
+export function getAutomationReportTracesDir(runId: string): string {
+  return path.join(getAutomationReportRunDir(runId), 'traces')
+}
+
+export function getAutomationReportScreenshotsDir(runId: string): string {
+  return path.join(getAutomationReportRunDir(runId), 'screenshots')
+}
+
+export function toProjectRelativePath(targetPath: string): string {
+  const normalizedPath = path.isAbsolute(targetPath) ? path.relative(getRepoRoot(), targetPath) : targetPath
+  return normalizedPath.replace(/\\/g, '/')
+}
+
+export function resolveStoredPath(storedPath: string): string {
+  if (path.isAbsolute(storedPath)) {
+    return storedPath
+  }
+  return path.join(getRepoRoot(), storedPath)
+}
+
+export function getAutomationStepsDir(): string {
+  return path.join(getAutomationRoot(), 'steps')
+}
+
+export function getAutomationActionStepsDir(): string {
+  return path.join(getAutomationStepsDir(), 'actions')
+}
+
+export function getAutomationValidationStepsDir(): string {
+  return path.join(getAutomationStepsDir(), 'validations')
+}

package/templates/starter/src/lib/automation/automation-workspace.ts

@@ -0,0 +1,147 @@
+import { promises as fs } from 'fs'
+import path from 'path'
+import {
+  getAutomationConfigDir,
+  getAutomationEnvironmentsDir,
+  getAutomationFeaturesDir,
+  getAutomationLocatorsDir,
+  getAutomationMappingDir,
+  getAutomationReportsDir,
+  getAutomationRoot,
+  getAutomationStepsDir,
+  getAutomationActionStepsDir,
+  getAutomationValidationStepsDir,
+  getLegacyTestsRoot,
+} from './automation-path-roots'
+
+const runtimeImport =
+  "import { When, Then, CustomWorld, expect, SelectorName, resolveLocator, getEnvironment, generateRandomData, RandomDataType } from '../../../packages/cucumber-runtime/src/index.js'"
+const runtimeImportPattern =
+  /^import\s*\{[\s\S]*?\}\s*from\s*['"]\.\.\/\.\.\/\.\.\/packages\/cucumber-runtime\/src\/index(?:\.js)?['"];?\r?\n*/gm
+
+const mutableLegacyDirectories = ['features', 'locators', 'mapping', 'steps'] as const
+
+let automationWorkspaceReadyPromise: Promise<void> | null = null
+
+async function pathExists(targetPath: string): Promise<boolean> {
+  try {
+    await fs.access(targetPath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function rewriteLegacyStepImports(): Promise<void> {
+  const stepsDir = getAutomationStepsDir()
+
+  if (!(await pathExists(stepsDir))) {
+    return
+  }
+
+  const stepFiles = await fs.readdir(stepsDir, { recursive: true })
+  for (const entry of stepFiles) {
+    if (typeof entry !== 'string' || !entry.endsWith('.ts')) {
+      continue
+    }
+
+    const filePath = path.join(stepsDir, entry)
+    let content = await fs.readFile(filePath, 'utf8')
+
+    content = content
+      .replace(runtimeImportPattern, '')
+      .replace(/^import \{ (When|Then) \} from '@cucumber\/cucumber';?\r?\n/gm, '')
+      .replace(/^import \{ CustomWorld(?:, expect)? \} from '\.\.\/\.\.\/config\/executor\/world\.js';?\r?\n/gm, '')
+      .replace(
+        /^import \{ SelectorName \} from '(?:@\/types\/locator\/locator\.type|\.\.\/\.\.\/\.\.\/types\/locator\/locator\.type)';?\r?\n/gm,
+        '',
+      )
+      .replace(/^import \{ resolveLocator \} from '\.\.\/\.\.\/utils\/locator\.util\.js';?\r?\n/gm, '')
+      .replace(/^import \{ getEnvironment \} from '\.\.\/\.\.\/utils\/environment\.util\.js';?\r?\n/gm, '')
+      .replace(
+        /^import \{ generateRandomData, RandomDataType \} from '\.\.\/\.\.\/utils\/random-data\.util\.js';?\r?\n/gm,
+        '',
+      )
+      .trimStart()
+
+    content = `${runtimeImport}\n${content}`
+
+    await fs.writeFile(filePath, content)
+  }
+}
+
+async function copyLegacyMutableWorkspace(): Promise<void> {
+  const legacyTestsRoot = getLegacyTestsRoot()
+  const automationRoot = getAutomationRoot()
+  const legacyExists = await pathExists(legacyTestsRoot)
+  const automationExists = await pathExists(automationRoot)
+
+  if (!legacyExists || automationExists) {
+    return
+  }
+
+  await fs.mkdir(automationRoot, { recursive: true })
+
+  const legacyEnvironmentsDir = path.join(legacyTestsRoot, 'config', 'environments')
+  if (await pathExists(legacyEnvironmentsDir)) {
+    await fs.cp(legacyEnvironmentsDir, getAutomationEnvironmentsDir(), { recursive: true })
+  }
+
+  for (const directory of mutableLegacyDirectories) {
+    const sourceDirectory = path.join(legacyTestsRoot, directory)
+    const destinationDirectory = path.join(automationRoot, directory)
+
+    if (await pathExists(sourceDirectory)) {
+      await fs.cp(sourceDirectory, destinationDirectory, { recursive: true })
+    }
+  }
+}
+
+async function copyLegacyEnvironmentsIfNeeded(): Promise<void> {
+  const legacyTestsRoot = getLegacyTestsRoot()
+  const legacyEnvironmentsDir = path.join(legacyTestsRoot, 'config', 'environments')
+  const automationEnvironmentsFile = path.join(getAutomationEnvironmentsDir(), 'environments.json')
+
+  if (!(await pathExists(legacyEnvironmentsDir)) || (await pathExists(automationEnvironmentsFile))) {
+    return
+  }
+
+  await fs.mkdir(getAutomationEnvironmentsDir(), { recursive: true })
+  await fs.cp(legacyEnvironmentsDir, getAutomationEnvironmentsDir(), { recursive: true })
+}
+
+async function ensureMutableAutomationDirectories(): Promise<void> {
+  const requiredDirectories = [
+    getAutomationRoot(),
+    getAutomationConfigDir(),
+    getAutomationEnvironmentsDir(),
+    getAutomationFeaturesDir(),
+    getAutomationLocatorsDir(),
+    getAutomationMappingDir(),
+    getAutomationReportsDir(),
+    getAutomationStepsDir(),
+    getAutomationActionStepsDir(),
+    getAutomationValidationStepsDir(),
+  ]
+
+  await Promise.all(requiredDirectories.map(directory => fs.mkdir(directory, { recursive: true })))
+}
+
+async function removeLegacyRuntimeArtifactsFromAutomation(): Promise<void> {
+  await fs.rm(path.join(getAutomationConfigDir(), 'executor'), { recursive: true, force: true })
+  await fs.rm(path.join(getAutomationRoot(), 'hooks'), { recursive: true, force: true })
+  await fs.rm(path.join(getAutomationRoot(), 'support'), { recursive: true, force: true })
+  await fs.rm(path.join(getAutomationRoot(), 'utils'), { recursive: true, force: true })
+}
+
+export async function ensureAutomationWorkspaceReady(): Promise<void> {
+  automationWorkspaceReadyPromise ??= (async () => {
+    await copyLegacyMutableWorkspace()
+    await copyLegacyEnvironmentsIfNeeded()
+    await ensureMutableAutomationDirectories()
+    await removeLegacyRuntimeArtifactsFromAutomation()
+    await rewriteLegacyStepImports()
+  })()
+
+  return automationWorkspaceReadyPromise
+}

package/templates/starter/src/lib/automation/paths.ts

@@ -0,0 +1,6 @@
+/**
+ * Automation path helpers (no Node fs) and workspace bootstrap (fs).
+ * Import from `automation-path-roots` when you only need path strings — avoids pulling fs into the bundle graph.
+ */
+export * from './automation-path-roots'
+export { ensureAutomationWorkspaceReady } from './automation-workspace'