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

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

@@ -1,36 +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,
-  },
-}
+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/default/src/constants/form-opts/test-case-form-opts.ts

@@ -1,43 +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,
-  },
-}
+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/default/src/constants/form-opts/test-suite-form-opts.ts

@@ -1,24 +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,
-  },
-}
+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/default/src/hooks/use-toast.ts

@@ -1,187 +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 }
+'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/default/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')
+}