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

package/templates/default/src/lib/sync/projected-feature-utils.ts

@@ -0,0 +1,113 @@
+import { StepParameterType, TemplateStepIcon } from '@prisma/client'
+
+type StoredProjectedStep = {
+  order: number
+  gherkinStep: string
+}
+
+type StoredProjectedDbStep = StoredProjectedStep & {
+  TemplateStep: { signature: string } | null
+  parameters: Array<{ name: string; value: string; order: number; type: StepParameterType }>
+}
+
+export type ProjectedDbTestCaseStep = {
+  order: number
+  keyword: string
+  text: string
+  gherkinStep: string
+  label: string
+  icon: TemplateStepIcon
+  templateStepSignature: string | null
+  parameters: Array<{ name: string; value: string; order: number; type: StepParameterType }>
+}
+
+export function getTestSuiteFilesystemKey(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .replace(/-+/g, '-')
+}
+
+export function getTestSuiteSyncIdentity(name: string, modulePath: string): string {
+  return `${getTestSuiteFilesystemKey(name)}::${modulePath}`
+}
+
+export function generateProjectedGherkinSteps(steps: StoredProjectedStep[]): string[] {
+  if (!steps || steps.length === 0) {
+    return []
+  }
+
+  const sortedSteps = [...steps].sort((left, right) => left.order - right.order)
+  let hasThenInPrevious = false
+  let hasWhenInPrevious = false
+
+  return sortedSteps.map((step, index) => {
+    const gherkinStep = step.gherkinStep?.trim() || ''
+    const firstWord = gherkinStep.split(' ')[0].toLowerCase()
+    const hasGherkinKeyword = ['given', 'when', 'then', 'and', 'but'].includes(firstWord)
+    const stepWithoutKeyword = hasGherkinKeyword ? gherkinStep.split(' ').slice(1).join(' ') : gherkinStep
+
+    if (index === 0) {
+      return `Given ${stepWithoutKeyword}`
+    }
+
+    const isThenStatement =
+      firstWord === 'then' ||
+      stepWithoutKeyword.toLowerCase().startsWith('should') ||
+      stepWithoutKeyword.toLowerCase().startsWith('must') ||
+      stepWithoutKeyword.toLowerCase().startsWith('will')
+
+    if (!hasThenInPrevious) {
+      if (isThenStatement) {
+        hasThenInPrevious = true
+        return `Then ${stepWithoutKeyword}`
+      }
+
+      if (!hasWhenInPrevious) {
+        hasWhenInPrevious = true
+        return `When ${stepWithoutKeyword}`
+      }
+
+      return `And ${stepWithoutKeyword}`
+    }
+
+    if (isThenStatement) {
+      return `And ${stepWithoutKeyword}`
+    }
+
+    hasThenInPrevious = false
+    hasWhenInPrevious = true
+    return `When ${stepWithoutKeyword}`
+  })
+}
+
+export function determineProjectedStepIcon(keyword: string): TemplateStepIcon {
+  const lowerKeyword = keyword.toLowerCase().trim()
+
+  if (lowerKeyword === 'given') return TemplateStepIcon.NAVIGATION
+  if (lowerKeyword === 'then') return TemplateStepIcon.VALIDATION
+  return TemplateStepIcon.MOUSE
+}
+
+export function normalizeProjectedDbTestCaseSteps(steps: StoredProjectedDbStep[]): ProjectedDbTestCaseStep[] {
+  const sortedSteps = [...steps].sort((left, right) => left.order - right.order)
+  const projectedGherkinSteps = generateProjectedGherkinSteps(sortedSteps)
+
+  return sortedSteps.map((step, index) => {
+    const gherkinStep = projectedGherkinSteps[index] ?? ''
+    const [keyword = '', ...textParts] = gherkinStep.split(' ')
+    const text = textParts.join(' ')
+
+    return {
+      order: step.order,
+      keyword,
+      text,
+      gherkinStep,
+      label: text,
+      icon: determineProjectedStepIcon(keyword),
+      templateStepSignature: step.TemplateStep?.signature ?? null,
+      parameters: step.parameters,
+    }
+  })
+}

package/templates/default/src/lib/sync/sync-executor.ts

@@ -0,0 +1,130 @@
+import { execa } from 'execa'
+import { join } from 'path'
+import {
+  getSyncScriptDefinition,
+  resolveRequestedSyncExecutionOrder,
+  type SyncRequestId,
+  type SyncScriptId,
+} from '@/lib/sync/sync-registry'
+
+export type SyncExecutionResult = {
+  requestedScriptId: SyncRequestId
+  executedScriptIds: SyncScriptId[]
+  success: boolean
+  failedScriptId?: SyncScriptId
+  exitCode?: number
+  durationMs: number
+  cause?: string
+}
+
+type ScriptExecutionOutput = {
+  exitCode: number | null
+  stdout: string
+  stderr: string
+}
+
+const ANSI_ESCAPE_PATTERN = /\u001B\[[0-9;]*m/g
+
+function stripAnsi(value: string): string {
+  return value.replace(ANSI_ESCAPE_PATTERN, '')
+}
+
+function normalizeOutputLines(value?: string): string[] {
+  if (!value) {
+    return []
+  }
+
+  return stripAnsi(value)
+    .split(/\r?\n/)
+    .map(line => line.trim())
+    .filter(Boolean)
+}
+
+function sanitizeCause(line: string): string {
+  return line
+    .replace(/^[^A-Za-z0-9]+/, '')
+    .replace(/^(Error|Cause):\s*/i, '')
+    .trim()
+}
+
+function selectMostRelevantLine(lines: string[]): string | undefined {
+  const preferredLine = lines.find(line => /(error|failed|fatal|cannot|unable|invalid|missing)/i.test(line))
+  const selectedLine = preferredLine ?? lines[lines.length - 1]
+
+  if (!selectedLine) {
+    return undefined
+  }
+
+  const sanitized = sanitizeCause(selectedLine)
+  return sanitized || undefined
+}
+
+function parseSyncFailureCause(result: ScriptExecutionOutput | { error: unknown }): string | undefined {
+  if ('error' in result) {
+    return result.error instanceof Error ? result.error.message : String(result.error)
+  }
+
+  return selectMostRelevantLine([
+    ...normalizeOutputLines(result.stderr),
+    ...normalizeOutputLines(result.stdout),
+  ])
+}
+
+async function executeSyncScript(scriptId: SyncScriptId): Promise<ScriptExecutionOutput> {
+  const scriptPath = join(process.cwd(), 'scripts', getSyncScriptDefinition(scriptId).scriptFile)
+
+  const result = await execa(process.execPath, ['--import', 'tsx', scriptPath], {
+    cwd: process.cwd(),
+    stdio: 'pipe',
+    reject: false,
+  })
+
+  return {
+    exitCode: result.exitCode ?? null,
+    stdout: result.stdout,
+    stderr: result.stderr,
+  }
+}
+
+export async function runRequestedSync(requestedScriptId: SyncRequestId): Promise<SyncExecutionResult> {
+  const executionOrder = resolveRequestedSyncExecutionOrder(requestedScriptId)
+  const startTime = Date.now()
+  const executedScriptIds: SyncScriptId[] = []
+
+  for (const scriptId of executionOrder) {
+    try {
+      const result = await executeSyncScript(scriptId)
+      executedScriptIds.push(scriptId)
+
+      if (result.exitCode !== 0) {
+        return {
+          requestedScriptId,
+          executedScriptIds,
+          success: false,
+          failedScriptId: scriptId,
+          exitCode: result.exitCode ?? undefined,
+          durationMs: Date.now() - startTime,
+          cause: parseSyncFailureCause(result),
+        }
+      }
+    } catch (error) {
+      executedScriptIds.push(scriptId)
+
+      return {
+        requestedScriptId,
+        executedScriptIds,
+        success: false,
+        failedScriptId: scriptId,
+        durationMs: Date.now() - startTime,
+        cause: parseSyncFailureCause({ error }),
+      }
+    }
+  }
+
+  return {
+    requestedScriptId,
+    executedScriptIds,
+    success: true,
+    durationMs: Date.now() - startTime,
+  }
+}

package/templates/default/src/lib/sync/sync-pending-counts.test.ts

@@ -0,0 +1,239 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import {
+  StepParameterType,
+  TagType,
+  TemplateStepGroupType,
+  TemplateStepIcon,
+  TemplateStepType,
+} from '@prisma/client'
+import {
+  countModuleMismatches,
+  countTagMismatches,
+  countTemplateStepGroupMismatches,
+  countTemplateStepMismatches,
+  countTestSuiteMismatches,
+  countTestCaseMismatches,
+} from '@/lib/sync/sync-pending-counts'
+
+test('ignores DB-only modules when counting pending module sync work', () => {
+  const count = countModuleMismatches(new Set(['/']), [
+    { id: 'root', name: 'root', path: '/', parentId: null },
+    { id: 'module-1', name: 'ui-only-module', path: '/ui-only-module', parentId: 'root' },
+  ])
+
+  assert.equal(count, 0)
+})
+
+test('ignores DB-only standalone filter tags when filesystem tags are already satisfied', () => {
+  const count = countTagMismatches(
+    [{ name: 'smoke', tagExpression: '@smoke', type: TagType.FILTER }],
+    [
+      { name: 'smoke', type: TagType.FILTER },
+      { name: 'standalone', type: TagType.FILTER },
+    ],
+  )
+
+  assert.equal(count, 0)
+})
+
+test('treats projected template step groups as synchronized even with extra DB rows', () => {
+  const count = countTemplateStepGroupMismatches(
+    [{ name: 'Actions', description: 'Projected from UI', type: TemplateStepGroupType.ACTION }],
+    [
+      { name: 'Actions', description: 'Projected from UI', type: TemplateStepGroupType.ACTION },
+      { name: 'Actions', description: 'stale row', type: TemplateStepGroupType.VALIDATION },
+      { name: 'DB Only Group', description: null, type: TemplateStepGroupType.ACTION },
+    ],
+  )
+
+  assert.equal(count, 0)
+})
+
+test('matches template steps against any equivalent DB row after function normalization', () => {
+  const count = countTemplateStepMismatches(
+    [
+      {
+        groupName: 'Actions',
+        groupType: TemplateStepGroupType.ACTION,
+        step: {
+          jsdoc: {
+            name: 'Click button',
+            description: 'Clicks a button',
+            icon: TemplateStepIcon.MOUSE,
+          },
+          signature: 'click {string}',
+          functionDefinition: '',
+          normalizedFunctionDefinition:
+            "When('click {string}', async function (this: CustomWorld, button: string) {\n  await this.page.click(button);\n});",
+          parameters: [{ name: 'button', order: 0, type: StepParameterType.STRING }],
+          keyword: 'When',
+        },
+      },
+    ],
+    [
+      {
+        signature: 'click {string}',
+        name: 'Click button',
+        description: 'stale row',
+        functionDefinition: "When('click {string}', async function () {});",
+        icon: TemplateStepIcon.MOUSE,
+        type: TemplateStepType.ACTION,
+        templateStepGroup: { name: 'Actions' },
+        parameters: [],
+      },
+      {
+        signature: 'click {string}',
+        name: 'Click button',
+        description: 'Clicks a button',
+        functionDefinition:
+          "When('click {string}', async function (this: CustomWorld, button: string) {\n  await this.page.click(button);\n});",
+        icon: TemplateStepIcon.MOUSE,
+        type: TemplateStepType.ACTION,
+        templateStepGroup: { name: 'Actions' },
+        parameters: [{ name: 'button', order: 0, type: StepParameterType.STRING }],
+      },
+    ],
+  )
+
+  assert.equal(count, 0)
+})
+
+test('matches test suites by generated filesystem key instead of raw DB name', () => {
+  const count = countTestSuiteMismatches(
+    [
+      {
+        name: 'user-login-suite',
+        description: 'Projected suite',
+        modulePath: '/auth',
+        tags: ['@smoke'],
+      },
+    ],
+    [
+      {
+        name: 'User Login Suite',
+        description: 'Projected suite',
+        moduleId: 'module-auth',
+        tags: [{ tagExpression: '@smoke' }],
+      },
+    ],
+    new Map([['module-auth', '/auth']]),
+  )
+
+  assert.equal(count, 0)
+})
+
+test('matches projected test cases against generated feature-file output', () => {
+  const count = countTestCaseMismatches(
+    [
+      {
+        identifierTag: '@tc_login',
+        title: 'Login',
+        description: 'Opens the login screen',
+        testSuiteName: 'user-login-suite',
+        modulePath: '/auth',
+        filterTags: ['@smoke'],
+        steps: [
+          { order: 1, keyword: 'Given', text: 'open the login page' },
+          { order: 2, keyword: 'Then', text: 'should see the dashboard' },
+        ],
+      },
+    ],
+    [
+      {
+        title: 'Login',
+        description: 'Opens the login screen',
+        tags: [
+          { tagExpression: '@tc_login', type: TagType.IDENTIFIER },
+          { tagExpression: '@smoke', type: TagType.FILTER },
+        ],
+        TestSuite: [{ name: 'User Login Suite', moduleId: 'module-auth' }],
+        steps: [
+          {
+            order: 1,
+            gherkinStep: 'When open the login page',
+            label: 'open the login page',
+            icon: TemplateStepIcon.MOUSE,
+            TemplateStep: { signature: 'open the login page' },
+            parameters: [],
+          },
+          {
+            order: 2,
+            gherkinStep: 'Then should see the dashboard',
+            label: 'should see the dashboard',
+            icon: TemplateStepIcon.VALIDATION,
+            TemplateStep: { signature: 'should see the dashboard' },
+            parameters: [],
+          },
+        ],
+      },
+    ],
+    new Map([['module-auth', '/auth']]),
+    [
+      { signature: 'open the login page', parameters: [] },
+      { signature: 'should see the dashboard', parameters: [] },
+    ],
+  )
+
+  assert.equal(count, 0)
+})
+
+test('ignores duplicate stale DB test cases when one matching identifier row exists', () => {
+  const count = countTestCaseMismatches(
+    [
+      {
+        identifierTag: '@tc_profile',
+        title: 'Profile',
+        description: 'Shows the profile page',
+        testSuiteName: 'profile-suite',
+        modulePath: '/account',
+        filterTags: ['@regression'],
+        steps: [{ order: 1, keyword: 'Given', text: 'open the profile page' }],
+      },
+    ],
+    [
+      {
+        title: 'Old Profile',
+        description: 'stale',
+        tags: [
+          { tagExpression: '@tc_profile', type: TagType.IDENTIFIER },
+          { tagExpression: '@regression', type: TagType.FILTER },
+        ],
+        TestSuite: [{ name: 'Other Suite', moduleId: 'module-account' }],
+        steps: [
+          {
+            order: 1,
+            gherkinStep: 'When open the wrong page',
+            label: 'open the wrong page',
+            icon: TemplateStepIcon.MOUSE,
+            TemplateStep: { signature: 'open the wrong page' },
+            parameters: [],
+          },
+        ],
+      },
+      {
+        title: 'Profile',
+        description: 'Shows the profile page',
+        tags: [
+          { tagExpression: '@tc_profile', type: TagType.IDENTIFIER },
+          { tagExpression: '@regression', type: TagType.FILTER },
+        ],
+        TestSuite: [{ name: 'Profile Suite', moduleId: 'module-account' }],
+        steps: [
+          {
+            order: 1,
+            gherkinStep: 'When open the profile page',
+            label: 'open the profile page',
+            icon: TemplateStepIcon.MOUSE,
+            TemplateStep: { signature: 'open the profile page' },
+            parameters: [],
+          },
+        ],
+      },
+    ],
+    new Map([['module-account', '/account']]),
+    [{ signature: 'open the profile page', parameters: [] }],
+  )
+
+  assert.equal(count, 0)
+})