create-appraisejs 0.3.0 → 0.3.1-alpha.0

package/templates/blank/src/services/test-run/test-run-service.ts

@@ -18,7 +18,7 @@ import { promises as fs } from 'fs'
 import { updateTestCaseMetrics, updateMetricsForTestRun } from '@/lib/metrics/metric-calculator'
 import { getAutomationReportRunDir, resolveStoredPath } from '@/lib/automation/automation-path-roots'
 import { ensureTestSuiteIdentifierTags } from '@/lib/test-suite-identifier-service'
-import { getIdentifierTagByPrefix } from '@/lib/tag-utils'
+import { getIdentifierTagByPrefix } from '@/lib/tag-filters'
 import { findMatchingTestRunTestCase } from '@/lib/test-run/matching'
 import { storeReportFromFileService } from '@/services/report/report-service'
 import {
@@ -100,6 +100,12 @@ export async function listTestSuiteTestCases() {
 
 type TestRunTestCaseLink = { testCaseId: string; testSuiteId?: string | null }
 
+type ResolvedTestRunFilters = {
+  tagExpression: string | null
+  tags: Tag[]
+  testRunTestCases: TestRunTestCaseLink[]
+}
+
 async function resolveTagExpressionAndTestCases(value: TestRunFormValue): Promise<{
   tagExpression: string
   tags: Tag[]
@@ -125,154 +131,175 @@ async function resolveTagExpressionAndTestCases(value: TestRunFormValue): Promis
     )
   }
 
-  let tags: Tag[] = []
-  let tagExpression: string | null = null
-  let testRunTestCases: TestRunTestCaseLink[] = []
+  const { tagExpression, tags, testRunTestCases } = isFilteringByTags
+    ? await resolveTaggedTestRunFilters(value.tags)
+    : await resolveSuiteTestRunFilters(value.testSuites)
 
-  if (isFilteringByTags) {
-    tags = await prisma.tag.findMany({
-      where: { id: { in: value.tags } },
-    })
+  if (!tagExpression) {
+    throw new ServiceError('No executable tests were resolved from the selected filters.', 'VALIDATION', 400)
+  }
+
+  return { tagExpression, tags, testRunTestCases, environment }
+}
 
-    tagExpression = buildOrExpression(tags.map(tag => `(${tag.tagExpression})`))
+async function resolveTaggedTestRunFilters(tagIds: string[]): Promise<ResolvedTestRunFilters> {
+  const tags = await prisma.tag.findMany({
+    where: { id: { in: tagIds } },
+  })
 
-    const tagFilteredTestCases = await prisma.testCase.findMany({
-      where: {
-        OR: [
-          {
-            tags: {
-              some: { id: { in: value.tags } },
-            },
+  const tagExpression = buildOrExpression(tags.map(tag => `(${tag.tagExpression})`))
+  const tagFilteredTestCases = await prisma.testCase.findMany({
+    where: {
+      OR: [
+        {
+          tags: {
+            some: { id: { in: tagIds } },
           },
-          {
-            TestSuite: {
-              some: {
-                tags: {
-                  some: { id: { in: value.tags } },
-                },
+        },
+        {
+          TestSuite: {
+            some: {
+              tags: {
+                some: { id: { in: tagIds } },
               },
             },
           },
-        ],
-      },
-    })
+        },
+      ],
+    },
+  })
 
-    testRunTestCases = tagFilteredTestCases.map(tc => ({
-      testCaseId: tc.id,
+  return {
+    tagExpression,
+    tags,
+    testRunTestCases: tagFilteredTestCases.map(testCase => ({
+      testCaseId: testCase.id,
       testSuiteId: null,
-    }))
-  } else if (isFilteringByTestSuites) {
-    await ensureTestSuiteIdentifierTags(value.testSuites.map(testSuite => testSuite.testSuiteId))
-
-    const selectedSuites = await prisma.testSuite.findMany({
-      where: {
-        id: {
-          in: value.testSuites.map(testSuite => testSuite.testSuiteId),
-        },
+    })),
+  }
+}
+
+async function resolveSuiteTestRunFilters(value: TestRunFormValue['testSuites']): Promise<ResolvedTestRunFilters> {
+  await ensureTestSuiteIdentifierTags(value.map(testSuite => testSuite.testSuiteId))
+
+  const selectedSuites = await prisma.testSuite.findMany({
+    where: {
+      id: {
+        in: value.map(testSuite => testSuite.testSuiteId),
       },
-      include: {
-        tags: true,
-        testCases: {
-          include: {
-            tags: true,
-          },
+    },
+    include: {
+      tags: true,
+      testCases: {
+        include: {
+          tags: true,
         },
       },
-    })
+    },
+  })
 
-    if (selectedSuites.length !== value.testSuites.length) {
-      throw new ServiceError('One or more selected test suites could not be found.', 'VALIDATION', 400)
-    }
+  if (selectedSuites.length !== value.length) {
+    throw new ServiceError('One or more selected test suites could not be found.', 'VALIDATION', 400)
+  }
 
-    const selectedSuiteById = new Map(selectedSuites.map(testSuite => [testSuite.id, testSuite]))
-    const suiteClauses: string[] = []
+  const selectedSuiteById = new Map(selectedSuites.map(testSuite => [testSuite.id, testSuite]))
+  const suiteClauses: string[] = []
+  const testRunTestCases: TestRunTestCaseLink[] = []
 
-    for (const suiteSelection of value.testSuites) {
-      const selectedSuite = selectedSuiteById.get(suiteSelection.testSuiteId)
-      if (!selectedSuite) {
-        continue
-      }
+  for (const suiteSelection of value) {
+    const suiteResult = resolveSuiteSelectionFilter(selectedSuiteById.get(suiteSelection.testSuiteId), suiteSelection)
+    if (!suiteResult) {
+      continue
+    }
 
-      if (selectedSuite.testCases.length === 0) {
-        continue
-      }
+    suiteClauses.push(suiteResult.clause)
+    testRunTestCases.push(...suiteResult.testRunTestCases)
+  }
 
-      const normalizedSelection = normalizeSuiteSelection(
-        suiteSelection,
-        selectedSuite.testCases.map(testCase => testCase.id),
-      )
+  return {
+    tagExpression: buildOrExpression(suiteClauses.map(clause => `(${clause})`)),
+    tags: [],
+    testRunTestCases,
+  }
+}
 
-      if (!normalizedSelection) {
-        continue
+function resolveSuiteSelectionFilter(
+  selectedSuite:
+    | {
+        id: string
+        name: string
+        tags: Tag[]
+        testCases: Array<{ id: string; title: string; tags: Tag[] }>
       }
+    | undefined,
+  suiteSelection: TestRunFormValue['testSuites'][number],
+): { clause: string; testRunTestCases: TestRunTestCaseLink[] } | null {
+  if (!selectedSuite || selectedSuite.testCases.length === 0) {
+    return null
+  }
 
-      const suiteIdentifierTag = getIdentifierTagByPrefix(selectedSuite.tags, 'ts_')
-      if (!suiteIdentifierTag) {
-        throw new ServiceError(
-          `Test suite "${selectedSuite.name}" does not have an identifier tag.`,
-          'VALIDATION',
-          400,
-        )
-      }
+  const normalizedSelection = normalizeSuiteSelection(
+    suiteSelection,
+    selectedSuite.testCases.map(testCase => testCase.id),
+  )
 
-      if (normalizedSelection.runAll) {
-        suiteClauses.push(`(${suiteIdentifierTag.tagExpression})`)
-        testRunTestCases.push(
-          ...selectedSuite.testCases.map(testCase => ({
-            testCaseId: testCase.id,
-            testSuiteId: selectedSuite.id,
-          })),
-        )
-        continue
-      }
+  if (!normalizedSelection) {
+    return null
+  }
 
-      const selectedTestCases = selectedSuite.testCases.filter(testCase =>
-        normalizedSelection.testCaseIds.includes(testCase.id),
-      )
+  const suiteIdentifierTag = getIdentifierTagByPrefix(selectedSuite.tags, 'ts_')
+  if (!suiteIdentifierTag) {
+    throw new ServiceError(`Test suite "${selectedSuite.name}" does not have an identifier tag.`, 'VALIDATION', 400)
+  }
 
-      if (selectedTestCases.length === 0) {
-        throw new ServiceError(
-          `Test suite "${selectedSuite.name}" requires at least one selected test case.`,
-          'VALIDATION',
-          400,
-        )
-      }
+  if (normalizedSelection.runAll) {
+    return {
+      clause: `(${suiteIdentifierTag.tagExpression})`,
+      testRunTestCases: selectedSuite.testCases.map(testCase => ({
+        testCaseId: testCase.id,
+        testSuiteId: selectedSuite.id,
+      })),
+    }
+  }
 
-      const missingIdentifierTestCase = selectedTestCases.find(
-        testCase => !getIdentifierTagByPrefix(testCase.tags, 'tc_'),
-      )
-      if (missingIdentifierTestCase) {
-        throw new ServiceError(
-          `Test case "${missingIdentifierTestCase.title}" does not have an identifier tag.`,
-          'VALIDATION',
-          400,
-        )
-      }
+  return resolvePartialSuiteSelectionFilter(selectedSuite, normalizedSelection.testCaseIds, suiteIdentifierTag)
+}
 
-      const testCaseTagExpressions = selectedTestCases.map(testCase => {
-        const identifierTag = getIdentifierTagByPrefix(testCase.tags, 'tc_')
-        return identifierTag!.tagExpression
-      })
+function resolvePartialSuiteSelectionFilter(
+  selectedSuite: {
+    id: string
+    name: string
+    testCases: Array<{ id: string; title: string; tags: Tag[] }>
+  },
+  selectedTestCaseIds: string[],
+  suiteIdentifierTag: Tag,
+): { clause: string; testRunTestCases: TestRunTestCaseLink[] } {
+  const selectedTestCases = selectedSuite.testCases.filter(testCase => selectedTestCaseIds.includes(testCase.id))
 
-      suiteClauses.push(
-        `(${suiteIdentifierTag.tagExpression}) and (${testCaseTagExpressions.map(tag => `(${tag})`).join(' or ')})`,
-      )
-      testRunTestCases.push(
-        ...selectedTestCases.map(testCase => ({
-          testCaseId: testCase.id,
-          testSuiteId: selectedSuite.id,
-        })),
-      )
+  if (selectedTestCases.length === 0) {
+    throw new ServiceError(
+      `Test suite "${selectedSuite.name}" requires at least one selected test case.`,
+      'VALIDATION',
+      400,
+    )
+  }
+
+  const testCaseTagExpressions = selectedTestCases.map(testCase => {
+    const identifierTag = getIdentifierTagByPrefix(testCase.tags, 'tc_')
+    if (!identifierTag) {
+      throw new ServiceError(`Test case "${testCase.title}" does not have an identifier tag.`, 'VALIDATION', 400)
     }
 
-    tagExpression = buildOrExpression(suiteClauses.map(clause => `(${clause})`))
-  }
+    return identifierTag.tagExpression
+  })
 
-  if (!tagExpression) {
-    throw new ServiceError('No executable tests were resolved from the selected filters.', 'VALIDATION', 400)
+  return {
+    clause: `(${suiteIdentifierTag.tagExpression}) and (${testCaseTagExpressions.map(tag => `(${tag})`).join(' or ')})`,
+    testRunTestCases: selectedTestCases.map(testCase => ({
+      testCaseId: testCase.id,
+      testSuiteId: selectedSuite.id,
+    })),
   }
-
-  return { tagExpression, tags, testRunTestCases, environment }
 }
 
 export type UpdateScenarioStatusResult =

package/templates/blank/src/test/motion-react-vitest-mocks.ts

@@ -0,0 +1,18 @@
+import { createElement, Fragment, type HTMLAttributes, type ReactNode } from 'react'
+
+function MotionDiv({ children, ...props }: HTMLAttributes<HTMLDivElement>) {
+  return createElement('div', props, children)
+}
+
+export const motionReactVitestMock = {
+  AnimatePresence: ({ children }: { children: ReactNode }) => createElement(Fragment, null, children),
+  LazyMotion: ({ children }: { children: ReactNode }) => createElement(Fragment, null, children),
+  domAnimation: {},
+  motion: {
+    div: MotionDiv,
+  },
+}
+
+export const motionReactMVitestMock = {
+  div: MotionDiv,
+}

package/templates/blank/src/test/setup-motion-react-mocks.ts

@@ -0,0 +1,4 @@
+import { vi } from 'vitest'
+
+vi.mock('motion/react', () => import('@/test/motion-react-vitest-mocks').then(m => m.motionReactVitestMock))
+vi.mock('motion/react-m', () => import('@/test/motion-react-vitest-mocks').then(m => m.motionReactMVitestMock))

package/templates/blank/src/types/diagram/diagram.ts

@@ -1,6 +1,7 @@
 import { StepParameterType } from '@prisma/client'
 
 export type NodeData = {
+  nodeId?: string
   order: number
   label: string
   gherkinStep?: string
@@ -18,6 +19,7 @@ export type NodeData = {
 export type NodeOrderMap = Record<string, NodeData>
 
 export type TemplateTestCaseNodeData = {
+  nodeId?: string
   order: number
   label: string
   gherkinStep?: string
@@ -32,3 +34,9 @@ export type TemplateTestCaseNodeData = {
 }
 
 export type TemplateTestCaseNodeOrderMap = Record<string, TemplateTestCaseNodeData>
+
+export type FlowBlock = {
+  id: string
+  name: string
+  nodeIds: string[]
+}

package/templates/blank/src/types/diagram/template-step.ts

@@ -1,8 +1,11 @@
-import { TemplateStep, TemplateStepGroup } from '@prisma/client'
+import { TemplateStep, TemplateStepGroup, TemplateStepParameter } from '@prisma/client'
+
+export type TemplateStepParameterSummary = Pick<TemplateStepParameter, 'id' | 'name'>
 
 /** Template step with optional group relation (e.g. from getAllTemplateStepsAction). */
 export type TemplateStepWithGroup = TemplateStep & {
-  templateStepGroup?: TemplateStepGroup
+  templateStepGroup?: TemplateStepGroup | null
+  parameters?: TemplateStepParameterSummary[]
 }
 
 /** Returns the group name in title case for display (e.g. "navigation" -> "Navigation"). */

package/templates/blank/src/types/report.ts

@@ -0,0 +1,84 @@
+import type { Prisma } from '@prisma/client'
+
+export type ReportWithRelations = Prisma.ReportGetPayload<{
+  include: {
+    testRun: {
+      include: {
+        environment: true
+        tags: true
+      }
+    }
+    testCases: {
+      include: {
+        testRunTestCase: {
+          include: {
+            testCase: {
+              include: {
+                tags: true
+              }
+            }
+            testSuite: true
+          }
+        }
+        reportScenario: {
+          include: {
+            reportFeature: true
+          }
+        }
+      }
+    }
+  }
+}>
+
+export type ReportDetailWithRelations = Prisma.ReportGetPayload<{
+  include: {
+    testRun: {
+      include: {
+        environment: true
+        tags: true
+      }
+    }
+    features: {
+      include: {
+        tags: true
+        scenarios: {
+          include: {
+            tags: true
+            steps: {
+              orderBy: {
+                order: 'asc'
+              }
+            }
+            hooks: true
+          }
+        }
+      }
+    }
+    testCases: {
+      include: {
+        testRunTestCase: {
+          include: {
+            testCase: {
+              include: {
+                tags: true
+              }
+            }
+            testSuite: true
+          }
+        }
+        reportScenario: {
+          include: {
+            reportFeature: true
+            tags: true
+            steps: {
+              orderBy: {
+                order: 'asc'
+              }
+            }
+            hooks: true
+          }
+        }
+      }
+    }
+  }
+}>

package/templates/blank/tsconfig.json

@@ -27,5 +27,5 @@
     ".next/types/**/*.ts",
     ".next/dev/types/**/*.ts"
   ],
-  "exclude": ["node_modules", "packages/create-appraisejs", "packages/appraisejs", "templates/starter"]
+  "exclude": ["node_modules", "packages/create-appraisejs", "packages/appraisejs", "templates/starter", "templates/blank"]
 }

package/templates/default/next-env.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+import "./.next/types/routes.d.ts";
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/templates/default/packages/locator-picker-companion/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};