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

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

@@ -1,87 +1,118 @@
-'use client'
-
-import {
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogTitle,
-  DialogTrigger,
-  DialogClose,
-} from '../ui/dialog'
-import { Button } from '../ui/button'
-import { AlertCircle, Trash, X } from 'lucide-react'
-import { useState } from 'react'
-
-export default function DeletePrompt({
-  isDisabled,
-  dialogTitle,
-  dialogDescription,
-  confirmationText,
-  deleteHandler,
-  open,
-  onOpenChange,
-}: {
-  isDisabled?: boolean
-  dialogTitle: string
-  dialogDescription: string
-  confirmationText: string
-  deleteHandler: () => Promise<void>
-  open?: boolean
-  onOpenChange?: (open: boolean) => void
-}) {
-  const [internalOpen, setInternalOpen] = useState(false)
-
-  // Use controlled state if provided, otherwise use internal state
-  const isOpen = open !== undefined ? open : internalOpen
-  const setIsOpen = onOpenChange || setInternalOpen
-
-  // Determine if we're in controlled mode (open prop provided)
-  const isControlled = open !== undefined
-
-  return (
-    <Dialog open={isOpen} onOpenChange={setIsOpen}>
-      {!isControlled && (
-        <DialogTrigger asChild disabled={isDisabled}>
-          <Button variant="outline" size="icon">
-            <Trash className="h-4 w-4" />
-          </Button>
-        </DialogTrigger>
-      )}
-      <DialogContent className="border-none">
-        <DialogHeader>
-          <DialogTitle className="flex items-end gap-2">
-            <AlertCircle className="h-5 w-5" />
-            {dialogTitle}
-          </DialogTitle>
-          <DialogDescription>{dialogDescription}</DialogDescription>
-        </DialogHeader>
-        <div className="mb-4 flex flex-col gap-2">
-          <h1 className="text-md">{confirmationText}</h1>
-        </div>
-        <DialogFooter>
-          <Button
-            variant="destructive"
-            className="bg-red-500 hover:bg-red-600"
-            onClick={async () => {
-              await deleteHandler()
-              setIsOpen(false)
-            }}
-          >
-            <span className="flex items-center gap-2 text-white">
-              <Trash className="h-4 w-4" />
-              Delete
-            </span>
-          </Button>
-          <DialogClose asChild className="bg-gray-700 text-white hover:bg-gray-800">
-            <Button variant="secondary">
-              <X className="h-4 w-4" />
-              Cancel
-            </Button>
-          </DialogClose>
-        </DialogFooter>
-      </DialogContent>
-    </Dialog>
-  )
-}
+'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/default/src/constants/form-opts/diagram/node-form.ts

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

@@ -1,24 +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,
-  },
-}
+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/default/src/constants/form-opts/locator-group-form-opts.ts

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

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

@@ -1,42 +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,
-  },
-}
+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/default/src/constants/form-opts/template-selection-form-opts.ts

@@ -1,16 +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,
-  },
-}
+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,
+  },
+}

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

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

@@ -1,39 +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,
-  },
-}
+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,
+  },
+}