create-appraisejs 0.3.0-alpha.0 → 0.3.0-alpha.1

package/templates/starter/package.json

@@ -0,0 +1,139 @@
+{
+  "name": "appraise",
+  "version": "0.2.0-alpha",
+  "private": false,
+  "type": "module",
+  "scripts": {
+    "dev": "next dev",
+    "init": "DISABLE_DEVTOOLS=1 NEXT_PUBLIC_DISABLE_DEVTOOLS=1 next dev",
+    "build:cucumber-runtime": "tsc -p packages/cucumber-runtime/tsconfig.json",
+    "build:locator-picker-companion": "tsc -p packages/locator-picker-companion/tsconfig.json",
+    "build": "npm run build:local",
+    "start": "next start",
+    "lint": "eslint .",
+    "install-playwright": "npx playwright install",
+    "install-dependencies": "npm install --legacy-peer-deps",
+    "setup-env": "npx tsx scripts/setup-env.ts",
+    "migrate-db": "npx prisma migrate deploy",
+    "setup": "npm run install-dependencies && npm run setup:db && npm run build:local && npm run protect-seeded-files",
+    "sync-features": "npx tsx scripts/regenerate-features.ts",
+    "sync-features:dry-run": "npx tsx scripts/regenerate-features.ts --dry-run",
+    "sync-locator-groups": "npx tsx scripts/sync-locator-groups.ts",
+    "sync-environments": "npx tsx scripts/sync-environments.ts",
+    "sync-locators": "npx tsx scripts/sync-locators.ts",
+    "sync-modules": "npx tsx scripts/sync-modules.ts",
+    "sync-tags": "npx tsx scripts/sync-tags.ts",
+    "sync-test-suites": "npx tsx scripts/sync-test-suites.ts",
+    "sync-test-cases": "npx tsx scripts/sync-test-cases.ts",
+    "sync-template-step-groups": "npx tsx scripts/sync-template-step-groups.ts",
+    "sync-template-steps": "npx tsx scripts/sync-template-steps.ts",
+    "sync-all": "npx tsx scripts/sync-all.ts",
+    "sync-template": "npx tsx scripts/sync-appraise-base-template.ts",
+    "appraisejs:install-step": "npx tsx scripts/install-template-step.ts",
+    "test": "cucumber-js",
+    "validate": "node --import tsx scripts/run-vitest.ts",
+    "build:local": "npm run generate-db-client && npm run build:cucumber-runtime && npm run build:locator-picker-companion && next build",
+    "generate-db-client": "npx prisma generate --schema prisma/schema.prisma",
+    "setup:db": "npm run setup-env && npm run generate-db-client && npm run migrate-db && npm run sync-all",
+    "setup:full": "npm run install-dependencies && npm run setup:db && npm run build:local && npm run protect-seeded-files",
+    "protect-seeded-files": "npx tsx scripts/protect-seeded-files.ts",
+    "appraisejs:setup": "npm run setup",
+    "appraisejs:sync": "npm run sync-all"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.27.0",
+    "@babel/types": "^7.27.0",
+    "@codemirror/lang-jinja": "^6.0.0",
+    "@faker-js/faker": "^10.2.0",
+    "@prisma/client": "^6.2.1",
+    "@radix-ui/react-alert-dialog": "^1.1.14",
+    "@radix-ui/react-avatar": "^1.1.10",
+    "@radix-ui/react-checkbox": "^1.3.2",
+    "@radix-ui/react-dialog": "^1.1.14",
+    "@radix-ui/react-dropdown-menu": "^2.1.15",
+    "@radix-ui/react-label": "^2.1.7",
+    "@radix-ui/react-navigation-menu": "^1.2.13",
+    "@radix-ui/react-popover": "^1.1.14",
+    "@radix-ui/react-progress": "^1.1.8",
+    "@radix-ui/react-radio-group": "^1.3.8",
+    "@radix-ui/react-scroll-area": "^1.2.9",
+    "@radix-ui/react-select": "^2.2.5",
+    "@radix-ui/react-separator": "^1.1.7",
+    "@radix-ui/react-slot": "^1.2.3",
+    "@radix-ui/react-tabs": "^1.1.12",
+    "@radix-ui/react-toast": "^1.2.14",
+    "@radix-ui/react-tooltip": "^1.2.8",
+    "@tanstack/react-form": "^1.25.0",
+    "@tanstack/react-table": "^8.20.6",
+    "@types/archiver": "^7.0.0",
+    "@uiw/codemirror-extensions-langs": "^4.25.4",
+    "@uiw/codemirror-theme-github": "^4.25.4",
+    "@uiw/react-codemirror": "^4.25.4",
+    "@xyflow/react": "^12.4.4",
+    "archiver": "^7.0.1",
+    "better-sqlite3": "^12.4.1",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cmdk": "^1.1.1",
+    "date-fns": "^4.1.0",
+    "lucide-react": "^0.473.0",
+    "motion": "^12.23.26",
+    "next": "^16.1.6",
+    "next-themes": "^0.4.4",
+    "react": "^19.2.1",
+    "react-day-picker": "^9.7.0",
+    "react-dom": "^19.2.1",
+    "recharts": "^2.15.4",
+    "tailwind-merge": "^2.6.0",
+    "tailwindcss-animate": "^1.0.7",
+    "winston": "^3.19.0",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@babel/traverse": "^7.28.5",
+    "@cucumber/cucumber": "^12.6.0",
+    "@cucumber/pretty-formatter": "^3.0.0",
+    "@cucumber/tag-expressions": "^8.0.0",
+    "@eslint/eslintrc": "^3",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/babel__traverse": "^7.28.0",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/chai": "^5.2.2",
+    "@types/chai-as-promised": "^8.0.2",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.17.16",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "baseline-browser-mapping": "^2.9.3",
+    "chai": "^5.2.1",
+    "chai-as-promised": "^8.0.1",
+    "commander": "^14.0.2",
+    "dotenv": "^17.2.3",
+    "eslint": "^9",
+    "eslint-config-next": "^16.1.6",
+    "execa": "^9.6.0",
+    "glob": "^11.0.3",
+    "globals": "^16.4.0",
+    "jiti": "^2.6.1",
+    "jsdom": "^29.0.1",
+    "playwright": "^1.58.0",
+    "postcss": "^8",
+    "prettier": "^3.6.2",
+    "prettier-plugin-tailwindcss": "^0.6.14",
+    "prisma": "^6.2.1",
+    "rimraf": "^6.1.2",
+    "tailwindcss": "^3.4.1",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.20.4",
+    "typescript": "^5.7.3",
+    "vitest": "^4.1.1"
+  },
+  "overrides": {
+    "react-is": "^19.2.1",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "minimatch": ">=10.2.1"
+  }
+}

package/templates/starter/packages/cucumber-runtime/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@appraise/cucumber-runtime",
+  "private": true,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  }
+}

package/templates/starter/packages/cucumber-runtime/src/cache.util.ts

@@ -0,0 +1,93 @@
+import { readFileSync } from 'fs'
+import { globSync } from 'glob'
+import * as path from 'path'
+import { LocatorCollection, LocatorMap } from './types.js'
+import { getAutomationLocatorMapPath, getAutomationLocatorsDir } from './paths.js'
+
+function toGlobPath(targetPath: string): string {
+  return targetPath.split(path.sep).join('/')
+}
+
+export class LocatorCache {
+  private static instance: LocatorCache
+  private data: Record<string, LocatorCollection> = {}
+  private filePaths: Record<string, string> = {}
+  private loadedFiles: Set<string> = new Set()
+
+  private constructor() {
+    globSync(`${toGlobPath(getAutomationLocatorsDir())}/**/*.json`).forEach(file => {
+      const fileName = path.basename(file, path.extname(file))
+      this.filePaths[fileName ?? file] = file
+    })
+  }
+
+  public static getInstance(): LocatorCache {
+    if (!LocatorCache.instance) {
+      LocatorCache.instance = new LocatorCache()
+    }
+    return LocatorCache.instance
+  }
+
+  public get(key: string): LocatorCollection | null {
+    if (!this.loadedFiles.has(key) && this.filePaths[key]) {
+      try {
+        const filePath = this.filePaths[key]
+        const data = JSON.parse(readFileSync(filePath, 'utf8'))
+        this.data[key] = data as LocatorCollection
+        this.loadedFiles.add(key)
+      } catch (error) {
+        console.error(`Error loading locator file for key "${key}":`, error)
+        return null
+      }
+    }
+
+    return this.data[key] ? { ...this.data[key] } : null
+  }
+
+  public preloadAll(): void {
+    Object.keys(this.filePaths).forEach(key => {
+      if (!this.loadedFiles.has(key)) {
+        this.get(key)
+      }
+    })
+  }
+
+  public getAvailableKeys(): string[] {
+    return Object.keys(this.filePaths)
+  }
+
+  public isLoaded(key: string): boolean {
+    return this.loadedFiles.has(key)
+  }
+}
+
+export class LocatorMapCache {
+  private static instance: LocatorMapCache
+  private data: LocatorMap[] = []
+
+  private constructor() {
+    this.data = JSON.parse(readFileSync(getAutomationLocatorMapPath(), 'utf8'))
+  }
+
+  public static getInstance(): LocatorMapCache {
+    if (!LocatorMapCache.instance) {
+      LocatorMapCache.instance = new LocatorMapCache()
+    }
+    return LocatorMapCache.instance
+  }
+
+  public get(key: string): LocatorMap {
+    try {
+      return this.data.find(map => map.path === key) as LocatorMap
+    } catch {
+      return {
+        name: '',
+        path: '',
+      }
+    }
+  }
+
+  public getAll(): LocatorMap[] {
+    return this.data
+  }
+}

package/templates/starter/packages/cucumber-runtime/src/cli.ts

@@ -0,0 +1,68 @@
+import { Command, Option, OptionValues } from 'commander'
+import parseTagExpression from '@cucumber/tag-expressions'
+import { getAllEnvironments } from './environment.util.js'
+import { BrowserName } from './types.js'
+
+export interface CliOptions extends OptionValues {
+  environment: string
+  tags: string
+  parallel: number
+  browser: BrowserName
+  headless: 'true' | 'false'
+}
+
+const BROWSER_CHOICES = ['chromium', 'firefox', 'webkit'] as const
+const HEADLESS_CHOICES = ['true', 'false'] as const
+const DEFAULT_PARALLEL_WORKERS = 1
+const DEFAULT_BROWSER: BrowserName = 'chromium'
+const DEFAULT_HEADLESS = 'true'
+
+const program = new Command()
+
+let environmentNames: string[] = []
+try {
+  environmentNames = Object.keys(getAllEnvironments())
+} catch (error) {
+  console.error('Failed to load environments:', error instanceof Error ? error.message : 'Unknown error')
+  process.exit(1)
+}
+
+function parsePositiveInt(value: string): number {
+  const parsed = Number(value)
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`--parallel must be a positive integer, got "${value}"`)
+  }
+  return parsed
+}
+
+function validateCucumberTagExpression(value: string): string {
+  try {
+    parseTagExpression(value)
+    return value
+  } catch (error) {
+    throw new Error(`Invalid tag expression: ${error instanceof Error ? error.message : 'Unknown error'}`)
+  }
+}
+
+program
+  .name('cucumber-runtime')
+  .description('CLI for running Appraise cucumber automation')
+  .version('1.0.0')
+  .addOption(
+    new Option('-e, --environment <environment>', 'The environment to run the tests on')
+      .choices(environmentNames)
+      .makeOptionMandatory(),
+  )
+  .addOption(
+    new Option('-t, --tags <tags>', 'The tags to run the tests on')
+      .argParser(validateCucumberTagExpression)
+      .makeOptionMandatory(),
+  )
+  .option('-p, --parallel <parallel>', 'The number of parallel workers to run', parsePositiveInt, DEFAULT_PARALLEL_WORKERS)
+  .addOption(new Option('-b, --browser <browser>', 'The browser to run').choices(BROWSER_CHOICES).default(DEFAULT_BROWSER))
+  .addOption(new Option('--headless <headless>', 'Whether to run headless').choices(HEADLESS_CHOICES).default(DEFAULT_HEADLESS))
+
+export function startCli(): CliOptions {
+  program.parse()
+  return program.opts() as CliOptions
+}

package/templates/starter/packages/cucumber-runtime/src/environment.util.ts

@@ -0,0 +1,21 @@
+import { readFileSync } from 'fs'
+import { getAutomationEnvironmentsFilePath } from './paths.js'
+
+interface EnvironmentConfig {
+  baseUrl: string
+  apiBaseUrl: string
+  email: string
+  password: string
+}
+
+export function getEnvironment(environment: string): EnvironmentConfig {
+  const environmentConfig: Record<string, EnvironmentConfig> = JSON.parse(
+    readFileSync(getAutomationEnvironmentsFilePath(), 'utf8'),
+  )
+
+  return environmentConfig[environment.toLowerCase()] as EnvironmentConfig
+}
+
+export function getAllEnvironments(): Record<string, EnvironmentConfig> {
+  return JSON.parse(readFileSync(getAutomationEnvironmentsFilePath(), 'utf8'))
+}

package/templates/starter/packages/cucumber-runtime/src/executor.ts

@@ -0,0 +1,32 @@
+import { execa } from 'execa'
+import { config } from 'dotenv'
+import { startCli } from './cli.js'
+
+async function bootstrap(): Promise<void> {
+  config()
+
+  try {
+    const { environment, tags, parallel, browser, headless } = startCli()
+
+    process.env.ENVIRONMENT = environment
+    process.env.HEADLESS = headless
+    process.env.BROWSER = browser
+
+    const cucumberArgs: string[] = ['cucumber-js', '-t', tags]
+    if (parallel > 1) {
+      cucumberArgs.push('--parallel', parallel.toString())
+    }
+
+    const subprocess = execa('npx', cucumberArgs, {
+      stdio: 'inherit',
+    })
+
+    const result = await subprocess
+    process.exit(result.exitCode ?? 0)
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : 'Unknown error')
+    process.exit(1)
+  }
+}
+
+bootstrap()

package/templates/starter/packages/cucumber-runtime/src/hooks.ts

@@ -0,0 +1,106 @@
+import { After, AfterAll, AfterStep, Before, BeforeAll, setDefaultTimeout } from '@cucumber/cucumber'
+import { config } from 'dotenv'
+import { promises as fs } from 'fs'
+import { chromium, firefox, webkit, ChromiumBrowser, FirefoxBrowser, WebKitBrowser } from 'playwright'
+import { getAutomationScreenshotDir, getAutomationTraceDir, toProjectRelativePath } from './paths.js'
+import { BrowserName } from './types.js'
+import { CustomWorld } from './world.js'
+
+config()
+
+const SCREENSHOT_ATTACHMENT_MEDIA_TYPE = 'application/vnd.appraisejs.report-step-screenshot+json'
+let browser: ChromiumBrowser | FirefoxBrowser | WebKitBrowser
+let currentScenarioStatus = 'unknown'
+
+BeforeAll(async function () {
+  setDefaultTimeout(60000)
+  const browserName = (process.env.BROWSER as BrowserName) || 'chromium'
+
+  switch (browserName) {
+    case 'chromium':
+      browser = await chromium.launch({ headless: process.env.HEADLESS === 'true' })
+      break
+    case 'firefox':
+      browser = await firefox.launch({ headless: process.env.HEADLESS === 'true' })
+      break
+    case 'webkit':
+      browser = await webkit.launch({ headless: process.env.HEADLESS === 'true' })
+      break
+    default:
+      throw new Error(`Invalid browser name: ${browserName}`)
+  }
+})
+
+Before(async function (this: CustomWorld) {
+  this.clearVars()
+  this.context = await browser.newContext()
+  await this.context.tracing.start({
+    screenshots: true,
+    snapshots: true,
+    sources: true,
+  })
+  this.page = await this.context.newPage()
+})
+
+AfterStep(async function (this: CustomWorld, result) {
+  const status = result.result?.status
+  if (status === 'FAILED') {
+    currentScenarioStatus = 'failed'
+
+    if (result.pickleStep?.text) {
+      try {
+        const screenshotDir = getAutomationScreenshotDir()
+        await fs.mkdir(screenshotDir, { recursive: true })
+
+        const screenshotPath = `${screenshotDir}/${crypto.randomUUID()}.png`
+        await this.page.screenshot({ path: screenshotPath, fullPage: true })
+        await this.attach(
+          JSON.stringify({ screenshotPath: toProjectRelativePath(screenshotPath) }),
+          SCREENSHOT_ATTACHMENT_MEDIA_TYPE,
+        )
+      } catch (error) {
+        console.warn(
+          `[CucumberRuntime] Failed to capture screenshot for step "${result.pickleStep.text}": ${error instanceof Error ? error.message : 'Unknown error'}`,
+        )
+      }
+    }
+  } else if (status === 'SKIPPED' && currentScenarioStatus !== 'failed') {
+    currentScenarioStatus = 'skipped'
+  } else if (status === 'PASSED' && currentScenarioStatus === 'unknown') {
+    currentScenarioStatus = 'passed'
+  }
+})
+
+After(async function (this: CustomWorld, scenario) {
+  let tracePath: string | undefined
+  if (scenario.result?.status === 'FAILED') {
+    const traceDir = getAutomationTraceDir()
+    await fs.mkdir(traceDir, { recursive: true })
+    const absoluteTracePath = `${traceDir}/${crypto.randomUUID()}.zip`
+    tracePath = toProjectRelativePath(absoluteTracePath)
+    await this.context.tracing.stop({ path: absoluteTracePath })
+  }
+
+  const eventJson = JSON.stringify({
+    event: 'scenario::end',
+    data: {
+      featureName: scenario.gherkinDocument?.feature?.name,
+      scenarioName: scenario.pickle.name,
+      scenarioTags: scenario.pickle.tags?.map(tag => tag.name) ?? [],
+      status: currentScenarioStatus,
+      tracePath,
+    },
+  })
+
+  console.log(eventJson)
+  process.stdout.write(eventJson + '\n')
+
+  currentScenarioStatus = 'unknown'
+
+  await this.page.close()
+  await this.context.close()
+})
+
+AfterAll(async function () {
+  await browser.close()
+})

package/templates/starter/packages/cucumber-runtime/src/index.ts

@@ -0,0 +1,17 @@
+export {
+  After,
+  AfterAll,
+  AfterStep,
+  Before,
+  BeforeAll,
+  Given,
+  Then,
+  When,
+  defineParameterType,
+  setDefaultTimeout,
+} from '@cucumber/cucumber'
+export { CustomWorld, expect } from './world.js'
+export { getEnvironment, getAllEnvironments } from './environment.util.js'
+export { resolveLocator, retry, waitForRouteSettled } from './locator.util.js'
+export { generateRandomData, RandomDataType } from './random-data.util.js'
+export type { BrowserName, Locator, LocatorCollection, LocatorMap, Selector, SelectorName } from './types.js'