create-appraisejs 0.3.0-alpha.0 → 0.3.0

package/templates/starter/src/components/ui/tabs.tsx

@@ -0,0 +1,55 @@
+'use client'
+
+import * as React from 'react'
+import * as TabsPrimitive from '@radix-ui/react-tabs'
+
+import { cn } from '@/lib/utils'
+
+const Tabs = TabsPrimitive.Root
+
+const TabsList = React.forwardRef<
+  React.ElementRef<typeof TabsPrimitive.List>,
+  React.ComponentPropsWithoutRef<typeof TabsPrimitive.List>
+>(({ className, ...props }, ref) => (
+  <TabsPrimitive.List
+    ref={ref}
+    className={cn(
+      'inline-flex h-9 items-center justify-center rounded-lg bg-muted p-1 text-muted-foreground',
+      className,
+    )}
+    {...props}
+  />
+))
+TabsList.displayName = TabsPrimitive.List.displayName
+
+const TabsTrigger = React.forwardRef<
+  React.ElementRef<typeof TabsPrimitive.Trigger>,
+  React.ComponentPropsWithoutRef<typeof TabsPrimitive.Trigger>
+>(({ className, ...props }, ref) => (
+  <TabsPrimitive.Trigger
+    ref={ref}
+    className={cn(
+      'inline-flex items-center justify-center whitespace-nowrap rounded-md px-3 py-1 text-sm font-medium ring-offset-background transition-all focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 data-[state=active]:bg-background data-[state=active]:text-foreground data-[state=active]:shadow',
+      className,
+    )}
+    {...props}
+  />
+))
+TabsTrigger.displayName = TabsPrimitive.Trigger.displayName
+
+const TabsContent = React.forwardRef<
+  React.ElementRef<typeof TabsPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof TabsPrimitive.Content>
+>(({ className, ...props }, ref) => (
+  <TabsPrimitive.Content
+    ref={ref}
+    className={cn(
+      'mt-2 ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2',
+      className,
+    )}
+    {...props}
+  />
+))
+TabsContent.displayName = TabsPrimitive.Content.displayName
+
+export { Tabs, TabsList, TabsTrigger, TabsContent }

package/templates/starter/src/components/ui/textarea.tsx

@@ -0,0 +1,21 @@
+import * as React from 'react'
+
+import { cn } from '@/lib/utils'
+
+const Textarea = React.forwardRef<HTMLTextAreaElement, React.ComponentProps<'textarea'>>(
+  ({ className, ...props }, ref) => {
+    return (
+      <textarea
+        className={cn(
+          'flex min-h-[60px] w-full rounded-md border border-input bg-transparent px-3 py-2 text-base shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50 md:text-sm',
+          className,
+        )}
+        ref={ref}
+        {...props}
+      />
+    )
+  },
+)
+Textarea.displayName = 'Textarea'
+
+export { Textarea }

package/templates/starter/src/components/ui/toast.tsx

@@ -0,0 +1,113 @@
+'use client'
+
+import * as React from 'react'
+import * as ToastPrimitives from '@radix-ui/react-toast'
+import { cva, type VariantProps } from 'class-variance-authority'
+import { X } from 'lucide-react'
+
+import { cn } from '@/lib/utils'
+
+const ToastProvider = ToastPrimitives.Provider
+
+const ToastViewport = React.forwardRef<
+  React.ElementRef<typeof ToastPrimitives.Viewport>,
+  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Viewport>
+>(({ className, ...props }, ref) => (
+  <ToastPrimitives.Viewport
+    ref={ref}
+    className={cn(
+      'fixed top-0 z-[100] flex max-h-screen w-full flex-col-reverse p-4 sm:bottom-0 sm:right-0 sm:top-auto sm:flex-col md:max-w-[420px]',
+      className,
+    )}
+    {...props}
+  />
+))
+ToastViewport.displayName = ToastPrimitives.Viewport.displayName
+
+const toastVariants = cva(
+  'group pointer-events-auto relative flex w-full items-center justify-between space-x-2 overflow-hidden rounded-md border p-4 pr-6 shadow-lg transition-all data-[swipe=cancel]:translate-x-0 data-[swipe=end]:translate-x-[var(--radix-toast-swipe-end-x)] data-[swipe=move]:translate-x-[var(--radix-toast-swipe-move-x)] data-[swipe=move]:transition-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[swipe=end]:animate-out data-[state=closed]:fade-out-80 data-[state=closed]:slide-out-to-right-full data-[state=open]:slide-in-from-top-full data-[state=open]:sm:slide-in-from-bottom-full',
+  {
+    variants: {
+      variant: {
+        default: 'border bg-background text-foreground',
+        destructive: 'destructive group border-destructive bg-destructive text-destructive-foreground',
+      },
+    },
+    defaultVariants: {
+      variant: 'default',
+    },
+  },
+)
+
+const Toast = React.forwardRef<
+  React.ElementRef<typeof ToastPrimitives.Root>,
+  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Root> & VariantProps<typeof toastVariants>
+>(({ className, variant, ...props }, ref) => {
+  return <ToastPrimitives.Root ref={ref} className={cn(toastVariants({ variant }), className)} {...props} />
+})
+Toast.displayName = ToastPrimitives.Root.displayName
+
+const ToastAction = React.forwardRef<
+  React.ElementRef<typeof ToastPrimitives.Action>,
+  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Action>
+>(({ className, ...props }, ref) => (
+  <ToastPrimitives.Action
+    ref={ref}
+    className={cn(
+      'inline-flex h-8 shrink-0 items-center justify-center rounded-md border bg-transparent px-3 text-sm font-medium transition-colors hover:bg-secondary focus:outline-none focus:ring-1 focus:ring-ring disabled:pointer-events-none disabled:opacity-50 group-[.destructive]:border-muted/40 group-[.destructive]:hover:border-destructive/30 group-[.destructive]:hover:bg-destructive group-[.destructive]:hover:text-destructive-foreground group-[.destructive]:focus:ring-destructive',
+      className,
+    )}
+    {...props}
+  />
+))
+ToastAction.displayName = ToastPrimitives.Action.displayName
+
+const ToastClose = React.forwardRef<
+  React.ElementRef<typeof ToastPrimitives.Close>,
+  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Close>
+>(({ className, ...props }, ref) => (
+  <ToastPrimitives.Close
+    ref={ref}
+    className={cn(
+      'absolute right-1 top-1 rounded-md p-1 text-foreground/50 opacity-0 transition-opacity hover:text-foreground focus:opacity-100 focus:outline-none focus:ring-1 group-hover:opacity-100 group-[.destructive]:text-red-300 group-[.destructive]:hover:text-red-50 group-[.destructive]:focus:ring-red-400 group-[.destructive]:focus:ring-offset-red-600',
+      className,
+    )}
+    toast-close=""
+    {...props}
+  >
+    <X className="h-4 w-4" />
+  </ToastPrimitives.Close>
+))
+ToastClose.displayName = ToastPrimitives.Close.displayName
+
+const ToastTitle = React.forwardRef<
+  React.ElementRef<typeof ToastPrimitives.Title>,
+  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Title>
+>(({ className, ...props }, ref) => (
+  <ToastPrimitives.Title ref={ref} className={cn('text-sm font-semibold [&+div]:text-xs', className)} {...props} />
+))
+ToastTitle.displayName = ToastPrimitives.Title.displayName
+
+const ToastDescription = React.forwardRef<
+  React.ElementRef<typeof ToastPrimitives.Description>,
+  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Description>
+>(({ className, ...props }, ref) => (
+  <ToastPrimitives.Description ref={ref} className={cn('text-sm opacity-90', className)} {...props} />
+))
+ToastDescription.displayName = ToastPrimitives.Description.displayName
+
+type ToastProps = React.ComponentPropsWithoutRef<typeof Toast>
+
+type ToastActionElement = React.ReactElement<typeof ToastAction>
+
+export {
+  type ToastProps,
+  type ToastActionElement,
+  ToastProvider,
+  ToastViewport,
+  Toast,
+  ToastTitle,
+  ToastDescription,
+  ToastClose,
+  ToastAction,
+}

package/templates/starter/src/components/ui/toaster.tsx

@@ -0,0 +1,26 @@
+'use client'
+
+import { useToast } from '@/hooks/use-toast'
+import { Toast, ToastClose, ToastDescription, ToastProvider, ToastTitle, ToastViewport } from '@/components/ui/toast'
+
+export function Toaster() {
+  const { toasts } = useToast()
+
+  return (
+    <ToastProvider>
+      {toasts.map(function ({ id, title, description, action, ...props }) {
+        return (
+          <Toast key={id} {...props}>
+            <div className="grid gap-1">
+              {title && <ToastTitle>{title}</ToastTitle>}
+              {description && <ToastDescription>{description}</ToastDescription>}
+            </div>
+            {action}
+            <ToastClose />
+          </Toast>
+        )
+      })}
+      <ToastViewport />
+    </ToastProvider>
+  )
+}

package/templates/starter/src/components/ui/tooltip.tsx

@@ -0,0 +1,32 @@
+"use client"
+
+import * as React from "react"
+import * as TooltipPrimitive from "@radix-ui/react-tooltip"
+
+import { cn } from "@/lib/utils"
+
+const TooltipProvider = TooltipPrimitive.Provider
+
+const Tooltip = TooltipPrimitive.Root
+
+const TooltipTrigger = TooltipPrimitive.Trigger
+
+const TooltipContent = React.forwardRef<
+  React.ElementRef<typeof TooltipPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content>
+>(({ className, sideOffset = 4, ...props }, ref) => (
+  <TooltipPrimitive.Portal>
+    <TooltipPrimitive.Content
+      ref={ref}
+      sideOffset={sideOffset}
+      className={cn(
+        "z-50 overflow-hidden rounded-md bg-primary px-3 py-1.5 text-xs text-primary-foreground animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 origin-[--radix-tooltip-content-transform-origin]",
+        className
+      )}
+      {...props}
+    />
+  </TooltipPrimitive.Portal>
+))
+TooltipContent.displayName = TooltipPrimitive.Content.displayName
+
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider }

package/templates/starter/src/components/user-prompt/delete-prompt.test.tsx

@@ -0,0 +1,60 @@
+// @vitest-environment jsdom
+
+import { render, screen, waitFor } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { describe, expect, it, vi } from 'vitest'
+
+import DeletePrompt from './delete-prompt'
+
+describe('DeletePrompt', () => {
+  it('opens from the trigger and closes after a successful delete', async () => {
+    const user = userEvent.setup()
+    const deleteHandler = vi.fn().mockResolvedValue(true)
+
+    render(
+      <DeletePrompt
+        dialogTitle="Delete Item"
+        dialogDescription="Please confirm your action"
+        confirmationText="Are you sure?"
+        deleteHandler={deleteHandler}
+      />,
+    )
+
+    await user.click(screen.getByRole('button', { name: /delete item/i }))
+
+    expect(screen.getByRole('dialog')).toBeInTheDocument()
+
+    await user.click(screen.getByRole('button', { name: /^delete$/i }))
+
+    await waitFor(() => {
+      expect(deleteHandler).toHaveBeenCalledTimes(1)
+    })
+
+    await waitFor(() => {
+      expect(screen.queryByRole('dialog')).not.toBeInTheDocument()
+    })
+  })
+
+  it('keeps the dialog open when the delete handler reports a failure', async () => {
+    const user = userEvent.setup()
+    const deleteHandler = vi.fn().mockResolvedValue(false)
+
+    render(
+      <DeletePrompt
+        dialogTitle="Delete Item"
+        dialogDescription="Please confirm your action"
+        confirmationText="Are you sure?"
+        deleteHandler={deleteHandler}
+      />,
+    )
+
+    await user.click(screen.getByRole('button', { name: /delete item/i }))
+    await user.click(screen.getByRole('button', { name: /^delete$/i }))
+
+    await waitFor(() => {
+      expect(deleteHandler).toHaveBeenCalledTimes(1)
+    })
+
+    expect(screen.getByRole('dialog')).toBeInTheDocument()
+  })
+})

package/templates/starter/src/components/user-prompt/delete-prompt.tsx

@@ -0,0 +1,118 @@
+'use client'
+
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+} from '../ui/dialog'
+import { Button } from '../ui/button'
+import { AlertCircle, Trash, X } from 'lucide-react'
+import { useState } from 'react'
+
+export type DeletePromptProps = {
+  isDisabled?: boolean
+  dialogTitle: string
+  dialogDescription: string
+  confirmationText: string
+  deleteHandler: () => Promise<boolean | void>
+  open?: boolean
+  onOpenChange?: (open: boolean) => void
+  triggerLabel?: string
+  confirmLabel?: string
+  cancelLabel?: string
+}
+
+export default function DeletePrompt({
+  isDisabled,
+  dialogTitle,
+  dialogDescription,
+  confirmationText,
+  deleteHandler,
+  open,
+  onOpenChange,
+  triggerLabel = 'Delete item',
+  confirmLabel = 'Delete',
+  cancelLabel = 'Cancel',
+}: DeletePromptProps) {
+  const [internalOpen, setInternalOpen] = useState(false)
+  const [isDeleting, setIsDeleting] = useState(false)
+
+  const isControlled = open !== undefined
+  const isOpen = isControlled ? open : internalOpen
+
+  const handleOpenChange = (nextOpen: boolean) => {
+    if (!isControlled) {
+      setInternalOpen(nextOpen)
+    }
+
+    onOpenChange?.(nextOpen)
+  }
+
+  const handleDelete = async () => {
+    setIsDeleting(true)
+
+    try {
+      const shouldClose = (await deleteHandler()) !== false
+
+      if (shouldClose) {
+        handleOpenChange(false)
+      }
+    } catch {
+      // Keep the dialog open so the caller can surface an error state.
+    } finally {
+      setIsDeleting(false)
+    }
+  }
+
+  return (
+    <Dialog open={isOpen} onOpenChange={handleOpenChange}>
+      {!isControlled && (
+        <DialogTrigger asChild disabled={isDisabled}>
+          <Button variant="outline" size="icon" aria-label={triggerLabel}>
+            <Trash className="h-4 w-4" aria-hidden="true" />
+            <span className="sr-only">{triggerLabel}</span>
+          </Button>
+        </DialogTrigger>
+      )}
+      <DialogContent className="border-none">
+        <DialogHeader>
+          <DialogTitle className="flex items-end gap-2">
+            <AlertCircle className="h-5 w-5" aria-hidden="true" />
+            {dialogTitle}
+          </DialogTitle>
+          <DialogDescription>{dialogDescription}</DialogDescription>
+        </DialogHeader>
+        <div className="mb-4 flex flex-col gap-2">
+          <p className="text-md">{confirmationText}</p>
+        </div>
+        <DialogFooter>
+          <Button
+            variant="destructive"
+            className="bg-red-500 hover:bg-red-600"
+            onClick={handleDelete}
+            disabled={isDeleting}
+          >
+            <span className="flex items-center gap-2 text-white">
+              <Trash className="h-4 w-4" aria-hidden="true" />
+              {isDeleting ? 'Deleting...' : confirmLabel}
+            </span>
+          </Button>
+          <Button
+            type="button"
+            variant="secondary"
+            className="bg-gray-700 text-white hover:bg-gray-800"
+            onClick={() => handleOpenChange(false)}
+            disabled={isDeleting}
+          >
+            <X className="h-4 w-4" aria-hidden="true" />
+            {cancelLabel}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}

package/templates/starter/src/config/db-config.ts

@@ -0,0 +1,71 @@
+import fs from 'fs'
+import { createRequire } from 'module'
+import path from 'path'
+
+function readProjectDatabaseUrl(): string | null {
+  const envPath = path.join(process.cwd(), '.env')
+  if (!fs.existsSync(envPath)) {
+    return null
+  }
+
+  const envContent = fs.readFileSync(envPath, 'utf8')
+  const match = envContent.match(/^\s*DATABASE_URL\s*=\s*(?:"([^"]*)"|'([^']*)'|([^#\r\n]+))\s*$/m)
+  const rawValue = match?.[1] ?? match?.[2] ?? match?.[3]
+  const normalizedValue = rawValue?.trim()
+
+  return normalizedValue ? normalizedValue : null
+}
+
+function normalizeDatabaseUrl(databaseUrl: string): string {
+  if (!databaseUrl.startsWith('file:')) {
+    return databaseUrl
+  }
+
+  const sqlitePathWithQuery = databaseUrl.slice('file:'.length)
+  if (!sqlitePathWithQuery || sqlitePathWithQuery === ':memory:') {
+    return databaseUrl
+  }
+
+  const queryStartIndex = sqlitePathWithQuery.indexOf('?')
+  const sqlitePath = queryStartIndex >= 0 ? sqlitePathWithQuery.slice(0, queryStartIndex) : sqlitePathWithQuery
+  const query = queryStartIndex >= 0 ? sqlitePathWithQuery.slice(queryStartIndex) : ''
+
+  if (path.isAbsolute(sqlitePath)) {
+    return databaseUrl
+  }
+
+  // Prisma resolves relative SQLite paths from the schema directory. The app's schema
+  // lives in `<project>/prisma`, so normalize local file URLs to that location.
+  const absolutePath = path.resolve(process.cwd(), 'prisma', sqlitePath)
+  return `file:${absolutePath}${query}`
+}
+
+function ensureProjectDatabaseUrl(): void {
+  if (process.env.DATABASE_URL) {
+    return
+  }
+
+  const projectDatabaseUrl = readProjectDatabaseUrl()
+  if (!projectDatabaseUrl) {
+    return
+  }
+
+  process.env.DATABASE_URL = normalizeDatabaseUrl(projectDatabaseUrl)
+}
+
+ensureProjectDatabaseUrl()
+
+type PrismaClientInstance = import('@prisma/client').PrismaClient
+const require = createRequire(import.meta.url)
+const { PrismaClient } = require('@prisma/client') as {
+  PrismaClient: new () => PrismaClientInstance
+}
+
+const globalForPrisma = global as unknown as {
+  prisma: PrismaClientInstance | undefined
+}
+const prisma = globalForPrisma.prisma ?? new PrismaClient()
+
+if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma
+
+export default prisma

package/templates/starter/src/constants/form-opts/diagram/node-form.ts

@@ -0,0 +1,30 @@
+import { StepParameterType } from '@prisma/client'
+import { z } from 'zod'
+
+export const nodeDataSchema = z.object({
+  label: z.string().min(3, { message: 'Label must be at least 3 characters' }),
+  gherkinStep: z.string(),
+  templateStepId: z.string().min(1, { message: 'Template step is required' }),
+  parameters: z.array(
+    z.object({
+      name: z.string(),
+      value: z.string(),
+      type: z.nativeEnum(StepParameterType),
+      order: z.number(),
+    }),
+  ),
+})
+
+export type NodeData = z.infer<typeof nodeDataSchema>
+
+export const formOpts = {
+  defaultValues: {
+    label: '',
+    gherkinStep: '',
+    templateStepId: '',
+    parameters: [],
+  } as NodeData,
+  validators: {
+    onChange: nodeDataSchema,
+  },
+}

package/templates/starter/src/constants/form-opts/environment-form-opts.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod'
+
+export const environmentSchema = z.object({
+  name: z.string().min(1, { message: 'Name is required' }),
+  baseUrl: z.string().url({ message: 'Base URL must be a valid URL' }),
+  apiBaseUrl: z.string().url({ message: 'API Base URL must be a valid URL' }).optional().or(z.literal('')),
+  username: z.string().optional().or(z.literal('')),
+  password: z.string().optional().or(z.literal('')),
+})
+
+export type Environment = z.infer<typeof environmentSchema>
+
+export const formOpts = {
+  defaultValues: {
+    name: '',
+    baseUrl: '',
+    apiBaseUrl: '',
+    username: '',
+    password: '',
+  },
+  validators: {
+    onChange: environmentSchema,
+  },
+}

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

@@ -0,0 +1,28 @@
+import { z } from 'zod'
+
+export const locatorGroupSchema = z.object({
+  name: z.string().min(1, { message: 'Name is required' }),
+  moduleId: z.string().min(1, { message: 'Module is required' }),
+  locators: z.array(z.string()).optional(),
+  route: z.string().optional(),
+})
+
+// Schema for checking unique name (used in server actions)
+export const locatorGroupUniqueNameSchema = z.object({
+  name: z.string().min(1, { message: 'Name is required' }),
+  id: z.string().optional(), // For updates, exclude current record
+})
+
+export type LocatorGroup = z.infer<typeof locatorGroupSchema>
+
+export const formOpts = {
+  defaultValues: {
+    name: '',
+    moduleId: '',
+    locators: [],
+    route: '',
+  },
+  validators: {
+    onChange: locatorGroupSchema,
+  },
+}

package/templates/starter/src/constants/form-opts/module-form-opts.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod'
+
+// Special UUID to represent root (no parent) in the form
+export const ROOT_MODULE_UUID = '00000000-0000-0000-0000-000000000000'
+
+export const moduleSchema = z.object({
+  name: z.string().min(1, { message: 'Name is required' }),
+  parentId: z.string().optional().or(z.undefined()),
+})
+
+export type Module = z.infer<typeof moduleSchema>
+
+export const formOpts = {
+  defaultValues: {
+    name: '',
+    parentId: ROOT_MODULE_UUID,
+  },
+  validators: {
+    onChange: moduleSchema,
+  },
+}

package/templates/starter/src/constants/form-opts/tag-form-opts.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod'
+
+export const tagSchema = z.object({
+  name: z.string().min(1, { message: 'Name is required' }),
+  tagExpression: z
+    .string()
+    .min(1, { message: 'Tag expression is required' })
+    .refine(
+      value => {
+        // Check if the value follows Gherkin tag rules
+        // Only one tag allowed per entry - single word after @ symbol
+        const trimmedValue = value.trim()
+        if (!trimmedValue) return false
+
+        // Should not contain any spaces (only one tag allowed)
+        if (trimmedValue.includes(' ')) return false
+
+        // Tag should start with @
+        if (!trimmedValue.startsWith('@')) return false
+
+        // Tag should have at least one character after @
+        if (trimmedValue.length <= 1) return false
+
+        return true
+      },
+      {
+        message: 'Tag expression must be a single tag starting with @ and contain no spaces (e.g., "@smoke")',
+      },
+    ),
+})
+
+export type Tag = z.infer<typeof tagSchema>
+
+export const formOpts = {
+  defaultValues: {
+    name: '',
+    tagExpression: '',
+  },
+  validators: {
+    onChange: tagSchema,
+  },
+}

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

@@ -0,0 +1,16 @@
+import { z } from 'zod'
+
+export const templateSelectionSchema = z.object({
+  templateTestCaseId: z.string().min(1, { message: 'Template test case is required' }),
+})
+
+export type TemplateSelection = z.infer<typeof templateSelectionSchema>
+
+export const formOpts = {
+  defaultValues: {
+    templateTestCaseId: '',
+  },
+  validators: {
+    onChange: templateSelectionSchema,
+  },
+}