create-appraisejs 0.1.10-alpha.8 → 0.2.0-alpha.1

package/templates/default/src/constants/form-opts/locator-form-opts.ts

@@ -1,20 +1,20 @@
-import { z } from 'zod'
-
-export const locatorSchema = z.object({
-  name: z.string().min(1, { message: 'Name is required' }),
-  value: z.string().min(1, { message: 'Value is required' }),
-  locatorGroupId: z.string().min(1, { message: 'Locator group is required' }),
-})
-
-export type Locator = z.infer<typeof locatorSchema>
-
-export const formOpts = {
-  defaultValues: {
-    name: '',
-    value: '',
-    locatorGroupId: '',
-  },
-  validators: {
-    onChange: locatorSchema,
-  },
-}
+import { z } from 'zod'
+
+export const locatorSchema = z.object({
+  name: z.string().min(1, { message: 'Name is required' }),
+  value: z.string().min(1, { message: 'Value is required' }),
+  locatorGroupId: z.string().min(1, { message: 'Locator group is required' }),
+})
+
+export type Locator = z.infer<typeof locatorSchema>
+
+export const formOpts = {
+  defaultValues: {
+    name: '',
+    value: '',
+    locatorGroupId: '',
+  },
+  validators: {
+    onChange: locatorSchema,
+  },
+}

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/review-form-opts.ts

@@ -1,23 +1,23 @@
-import { ReviewStatus } from '@prisma/client'
-import { z } from 'zod'
-
-export const reviewSchema = z.object({
-  testCaseId: z.string().min(1, { message: 'Test case is required' }),
-  status: z.nativeEnum(ReviewStatus),
-  comments: z.string().optional(),
-  reviewerId: z.string().min(1, { message: 'Reviewer is required' }),
-})
-
-export type Review = z.infer<typeof reviewSchema>
-
-export const formOpts = {
-  defaultValues: {
-    testCaseId: '',
-    status: 'PENDING',
-    comments: '',
-    reviewerId: '',
-  },
-  validators: {
-    onChange: reviewSchema,
-  },
-}
+import { ReviewStatus } from '@prisma/client'
+import { z } from 'zod'
+
+export const reviewSchema = z.object({
+  testCaseId: z.string().min(1, { message: 'Test case is required' }),
+  status: z.nativeEnum(ReviewStatus),
+  comments: z.string().optional(),
+  reviewerId: z.string().min(1, { message: 'Reviewer is required' }),
+})
+
+export type Review = z.infer<typeof reviewSchema>
+
+export const formOpts = {
+  defaultValues: {
+    testCaseId: '',
+    status: 'PENDING',
+    comments: '',
+    reviewerId: '',
+  },
+  validators: {
+    onChange: reviewSchema,
+  },
+}

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,
+  },
+}

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-run-form-opts.ts

@@ -7,9 +7,11 @@ export const testRunSchema = z.object({
   tags: z.array(z.string()),
   testWorkersCount: z.number().min(1, { message: 'Test workers count must be at least 1' }).optional(),
   browserEngine: z.nativeEnum(BrowserEngine),
-  testCases: z.array(
+  testSuites: z.array(
     z.object({
-      testCaseId: z.string().min(1, { message: 'Test case is required' }),
+      testSuiteId: z.string().min(1, { message: 'Test suite is required' }),
+      runAll: z.boolean(),
+      testCaseIds: z.array(z.string()),
     }),
   ),
 })
@@ -23,7 +25,7 @@ export const formOpts = {
     tags: [],
     testWorkersCount: 1,
     browserEngine: BrowserEngine.CHROMIUM,
-    testCases: [],
+    testSuites: [],
   } as TestRun,
   validators: {
     onChange: testRunSchema,

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,
+  },
+}