create-appraisejs 0.3.0 → 0.3.1-alpha.0

package/templates/blank/scripts/lib/step-file-parser.ts

@@ -2,16 +2,19 @@ import { parse } from '@babel/parser'
 import _traverse from '@babel/traverse'
 import type { NodePath } from '@babel/traverse'
 import * as t from '@babel/types'
-import { StepParameterType, TemplateStepIcon } from '@prisma/client'
-import { parseGroupJSDoc, StepGroupJSDoc } from './jsdoc-parser'
+import { StepParameterType } from '@prisma/client'
+import {
+  findNearestJSDocStart,
+  parseGroupJSDocStrict as parseGroupJSDoc,
+  parseStepJSDocStrict as parseStepJSDoc,
+  type StepGroupJSDoc,
+  type StepJSDoc,
+} from '@/lib/jsdoc/template-step-jsdoc'
 
 const traverse = (_traverse as { default?: typeof _traverse }).default ?? _traverse
 
-export interface StepJSDoc {
-  name: string
-  description: string | null
-  icon: TemplateStepIcon
-}
+export type { StepJSDoc }
+export { parseStepJSDoc }
 
 export interface StepParameter {
   name: string
@@ -36,112 +39,13 @@ export interface StepData {
   filePath: string
 }
 
-/**
- * Reads the nearest preceding JSDoc block for a step call and extracts metadata.
- */
-export function parseStepJSDoc(content: string, startLine: number): StepJSDoc | null {
-  const lines = content.split('\n')
-  let jsdocStart = -1
-  for (let i = startLine - 1; i >= 0 && i >= startLine - 20; i--) {
-    const line = lines[i]?.trim()
-    if (line?.includes('*/')) {
-      jsdocStart = i
-      for (let j = i - 1; j >= 0 && j >= i - 10; j--) {
-        const prevLine = lines[j]?.trim()
-        if (prevLine?.startsWith('/**')) {
-          jsdocStart = j
-          break
-        }
-      }
-      break
-    } else if (line?.startsWith('/**')) {
-      jsdocStart = i
-      break
-    }
-  }
-
-  if (jsdocStart === -1) return null
-
-  let name: string | null = null
-  let description: string | null = null
-  let icon: string | null = null
-  let foundJSDoc = false
-
-  for (let i = jsdocStart; i < Math.min(lines.length, jsdocStart + 20); i++) {
-    const line = lines[i]?.trim()
-
-    if (line?.startsWith('/**')) {
-      foundJSDoc = true
-      continue
-    }
-
-    if (line?.includes('*/')) {
-      const beforeClose = line.split('*/')[0].trim()
-      if (beforeClose.startsWith('* @name') || beforeClose.startsWith('*@name')) {
-        const match = beforeClose.match(/@name\s+(.+)/)
-        if (match) name = match[1].trim()
-      } else if (beforeClose.startsWith('* @description') || beforeClose.startsWith('*@description')) {
-        const match = beforeClose.match(/@description\s+(.+)/)
-        if (match) description = match[1].trim() || null
-      } else if (beforeClose.startsWith('* @icon') || beforeClose.startsWith('*@icon')) {
-        const match = beforeClose.match(/@icon\s+(.+)/)
-        if (match) icon = match[1].trim()
-      }
-      break
-    }
-
-    if (foundJSDoc) {
-      if (line?.startsWith('* @name') || line?.startsWith('*@name')) {
-        const match = line.match(/@name\s+(.+)/)
-        if (match) name = match[1].trim()
-      } else if (line?.startsWith('* @description') || line?.startsWith('*@description')) {
-        const match = line.match(/@description\s+(.+)/)
-        if (match) description = match[1].trim() || null
-      } else if (line?.startsWith('* @icon') || line?.startsWith('*@icon')) {
-        const match = line.match(/@icon\s+(.+)/)
-        if (match) icon = match[1].trim()
-      }
-    }
-  }
-
-  if (!name || !icon) return null
-
-  const iconUpper = icon.toUpperCase()
-  const validIcons = Object.values(TemplateStepIcon)
-  if (!validIcons.includes(iconUpper as TemplateStepIcon)) {
-    throw new Error(`Invalid @icon value: ${icon}. Must be one of: ${validIcons.join(', ')}`)
-  }
-
-  return {
-    name: name.trim(),
-    description: description ? description.trim() : null,
-    icon: iconUpper as TemplateStepIcon,
-  }
-}
+type StepKeyword = ParsedStep['keyword']
 
 function findStepJSDocStartOffset(content: string, startLine: number): number | null {
   const lines = content.split('\n')
-  let jsdocStart = -1
-
-  for (let i = startLine - 1; i >= 0 && i >= startLine - 20; i--) {
-    const line = lines[i]?.trim()
-    if (line?.includes('*/')) {
-      jsdocStart = i
-      for (let j = i - 1; j >= 0 && j >= i - 10; j--) {
-        const prevLine = lines[j]?.trim()
-        if (prevLine?.startsWith('/**')) {
-          jsdocStart = j
-          break
-        }
-      }
-      break
-    } else if (line?.startsWith('/**')) {
-      jsdocStart = i
-      break
-    }
-  }
+  const jsdocStart = findNearestJSDocStart(lines, startLine)
 
-  if (jsdocStart === -1) {
+  if (jsdocStart == null) {
     return null
   }
 
@@ -218,6 +122,102 @@ export function extractStepSourceRange(
   return { start, end }
 }
 
+function getStepKeyword(node: t.CallExpression): StepKeyword | null {
+  const callee = node.callee
+  return t.isIdentifier(callee) && (callee.name === 'When' || callee.name === 'Then' || callee.name === 'Given')
+    ? callee.name
+    : null
+}
+
+function getStepSignature(node: t.CallExpression): string | null {
+  const patternArg = node.arguments[0]
+  return t.isStringLiteral(patternArg) ? patternArg.value : null
+}
+
+function getStepFunction(node: t.CallExpression): t.Function | null {
+  const funcArg = node.arguments[1]
+  return t.isFunction(funcArg) ? funcArg : null
+}
+
+function isCucumberWorldParam(param: t.Function['params'][number]): boolean {
+  if (t.isIdentifier(param)) {
+    return param.name === 'this'
+  }
+
+  if (!t.isObjectPattern(param) || param.properties.length !== 1) {
+    return false
+  }
+
+  const prop = param.properties[0]
+  return t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name === 'this'
+}
+
+function getIdentifierParamType(param: t.Identifier): string | null {
+  if (!param.typeAnnotation || !t.isTSTypeAnnotation(param.typeAnnotation)) {
+    return null
+  }
+
+  const typeAnnotation = param.typeAnnotation.typeAnnotation
+  if (t.isTSTypeReference(typeAnnotation) && t.isIdentifier(typeAnnotation.typeName)) {
+    return typeAnnotation.typeName.name
+  }
+
+  if (t.isTSStringKeyword(typeAnnotation)) return 'string'
+  if (t.isTSNumberKeyword(typeAnnotation)) return 'number'
+  if (t.isTSBooleanKeyword(typeAnnotation)) return 'boolean'
+  return null
+}
+
+function parseStepParameters(params: t.Function['params']): StepParameter[] {
+  const parameters: StepParameter[] = []
+
+  for (const param of params) {
+    if (isCucumberWorldParam(param) || !t.isIdentifier(param)) {
+      continue
+    }
+
+    const paramType = getIdentifierParamType(param)
+    if (!paramType) {
+      continue
+    }
+
+    parameters.push({
+      name: param.name,
+      type: mapTypeToParameterType(paramType),
+      order: parameters.length,
+    })
+  }
+
+  return parameters
+}
+
+function parseStepCall(node: t.CallExpression, content: string): ParsedStep | null {
+  const keyword = getStepKeyword(node)
+  if (!keyword || node.arguments.length < 2) return null
+
+  const signature = getStepSignature(node)
+  const funcArg = getStepFunction(node)
+  const lineNumber = node.loc?.start?.line
+  if (!signature || !funcArg || lineNumber === undefined) return null
+
+  const jsdoc = parseStepJSDoc(content, lineNumber - 1)
+  if (!jsdoc) return null
+
+  const functionDefinition = extractFunctionDefinition(node, content)
+  const { start, end } = extractStepSourceRange(node, content, lineNumber - 1)
+
+  return {
+    jsdoc,
+    signature,
+    source: content.slice(start, end).trim(),
+    start,
+    end,
+    functionDefinition,
+    parameters: parseStepParameters(funcArg.params),
+    keyword,
+  }
+}
+
 /**
  * Parses a `.step.ts` file into group + step definitions from AST.
  */
@@ -239,75 +239,8 @@ export function parseStepFile(content: string, filePath: string): StepData | nul
 
   traverse(ast, {
     CallExpression(path: NodePath<t.CallExpression>) {
-      const node = path.node
-      const callee = node.callee
-      let keyword: 'When' | 'Then' | 'Given' | null = null
-      if (t.isIdentifier(callee) && (callee.name === 'When' || callee.name === 'Then' || callee.name === 'Given')) {
-        keyword = callee.name as 'When' | 'Then' | 'Given'
-      }
-
-      if (!keyword || node.arguments.length < 2) return
-
-      const patternArg = node.arguments[0]
-      if (!t.isStringLiteral(patternArg)) return
-      const signature = patternArg.value
-
-      const funcArg = node.arguments[1]
-      if (!t.isFunction(funcArg)) return
-
-      const lineNumber = node.loc?.start?.line
-      if (lineNumber === undefined) return
-
-      const jsdoc = parseStepJSDoc(content, lineNumber - 1)
-      if (!jsdoc) return
-
-      const parameters: StepParameter[] = []
-      let order = 0
-      for (const param of funcArg.params) {
-        if (t.isIdentifier(param) && param.name === 'this') continue
-        if (t.isObjectPattern(param) && param.properties.length === 1) {
-          const prop = param.properties[0]
-          if (t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name === 'this') continue
-        }
-
-        let paramName: string | null = null
-        let paramType: string | null = null
-
-        if (t.isIdentifier(param)) {
-          paramName = param.name
-          if (param.typeAnnotation && t.isTSTypeAnnotation(param.typeAnnotation)) {
-            const typeAnnotation = param.typeAnnotation.typeAnnotation
-            if (t.isTSTypeReference(typeAnnotation) && t.isIdentifier(typeAnnotation.typeName)) {
-              paramType = typeAnnotation.typeName.name
-            } else if (t.isTSStringKeyword(typeAnnotation)) {
-              paramType = 'string'
-            } else if (t.isTSNumberKeyword(typeAnnotation)) {
-              paramType = 'number'
-            } else if (t.isTSBooleanKeyword(typeAnnotation)) {
-              paramType = 'boolean'
-            }
-          }
-        }
-
-        if (paramName && paramType) {
-          const mappedType = mapTypeToParameterType(paramType)
-          parameters.push({ name: paramName, type: mappedType, order: order++ })
-        }
-      }
-
-      const functionDefinition = extractFunctionDefinition(node, content)
-      const { start, end } = extractStepSourceRange(node, content, lineNumber - 1)
-      const source = content.slice(start, end).trim()
-      steps.push({
-        jsdoc,
-        signature,
-        source,
-        start,
-        end,
-        functionDefinition,
-        parameters,
-        keyword,
-      })
+      const step = parseStepCall(path.node, content)
+      if (step) steps.push(step)
     },
   })
 

package/templates/blank/scripts/lib/template-sync-utils.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  extractModulePathFromAutomationFile,
+  getAutomationLocatorMapPath,
+  shouldBackfillLegacyEnvironmentConfig,
+  shouldExcludeTemplatePath,
+} from '../../src/lib/template-sync-utils'
+
+describe('template sync utils', () => {
+  it('excludes generated and local-only template paths', () => {
+    expect(shouldExcludeTemplatePath('node_modules/react/index.js')).toBe(true)
+    expect(shouldExcludeTemplatePath('automation/reports/latest.json')).toBe(true)
+    expect(shouldExcludeTemplatePath('prisma/dev.sqlite3')).toBe(true)
+    expect(shouldExcludeTemplatePath('src/app/page.tsx')).toBe(false)
+  })
+
+  it('detects whether legacy environment config should be backfilled', () => {
+    expect(shouldBackfillLegacyEnvironmentConfig(false, true)).toBe(true)
+    expect(shouldBackfillLegacyEnvironmentConfig(true, true)).toBe(false)
+    expect(shouldBackfillLegacyEnvironmentConfig(false, false)).toBe(false)
+  })
+
+  it('builds automation paths and extracts module paths from automation files', () => {
+    expect(getAutomationLocatorMapPath('/repo')).toBe('/repo/automation/mapping/locator-map.json')
+    expect(
+      extractModulePathFromAutomationFile(
+        '/repo/automation/features/payments/refunds/test.feature',
+        '/repo',
+        'features',
+      ),
+    ).toBe('/payments/refunds')
+    expect(extractModulePathFromAutomationFile('/repo/automation/locators/root.ts', '/repo', 'locators')).toBe('/')
+  })
+})

package/templates/blank/scripts/run-fallow-commit.mjs

@@ -0,0 +1,23 @@
+import { spawnSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import path from 'node:path'
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url))
+const repoRoot = path.resolve(scriptDir, '..')
+const fallowBin = path.join(repoRoot, 'node_modules', '.bin', 'fallow')
+
+const env = { ...process.env }
+delete env.GIT_INDEX_FILE
+
+const result = spawnSync(
+  fallowBin,
+  ['audit', '--base', 'HEAD', '--format', 'json', '--quiet', '--explain', '--fail-on-issues'],
+  { cwd: repoRoot, env, stdio: 'inherit' },
+)
+
+if (result.error) {
+  console.error(result.error)
+  process.exit(2)
+}
+
+process.exit(result.status ?? 1)

package/templates/blank/scripts/sync-tags.ts

@@ -13,7 +13,7 @@ import { join } from 'path'
 import prisma from '../src/config/db-config'
 import { scanFeatureFiles, ParsedFeature } from '../src/lib/gherkin-parser'
 import { TagType } from '@prisma/client'
-import { getTagTypeFromName } from '../src/lib/tag-utils'
+import { getTagTypeFromName } from '../src/lib/tag-identifiers'
 import { splitTagLine } from './lib/tag-parsing'
 import { printSyncSummary } from './lib/sync-summary'
 import { runSyncScript } from './lib/sync-script-runner'