create-appraisejs 0.2.0 → 0.3.0-alpha.1

package/templates/default/package.json

@@ -1,132 +0,0 @@
-{
-  "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",
-    "test": "cucumber-js",
-    "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",
-    "@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",
-    "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"
-  },
-  "overrides": {
-    "react-is": "^19.2.1",
-    "@types/react": "^19.2.7",
-    "@types/react-dom": "^19.2.3",
-    "minimatch": ">=10.2.1"
-  }
-}

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

@@ -1,13 +0,0 @@
-{
-  "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/default/packages/cucumber-runtime/src/cache.util.ts

@@ -1,93 +0,0 @@
-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/default/packages/cucumber-runtime/src/cli.ts

@@ -1,68 +0,0 @@
-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/default/packages/cucumber-runtime/src/environment.util.ts

@@ -1,21 +0,0 @@
-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/default/packages/cucumber-runtime/src/executor.ts

@@ -1,32 +0,0 @@
-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/default/packages/cucumber-runtime/src/index.ts

@@ -1,17 +0,0 @@
-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'

package/templates/default/packages/cucumber-runtime/src/locator.util.ts

@@ -1,234 +0,0 @@
-import { Page } from 'playwright'
-import { LocatorCache, LocatorMapCache } from './cache.util.js'
-
-const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
-
-export async function retry<T>(
-  fn: () => Promise<T>,
-  {
-    retries = 5,
-    delayMs = 100,
-    backoff = 1.6,
-    shouldRetry = () => true,
-  }: {
-    retries?: number
-    delayMs?: number
-    backoff?: number
-    shouldRetry?: (error: unknown) => boolean
-  } = {},
-): Promise<T> {
-  let lastErr: unknown
-  let delay = delayMs
-
-  for (let i = 0; i <= retries; i++) {
-    try {
-      return await fn()
-    } catch (error) {
-      lastErr = error
-      if (i === retries || !shouldRetry(error)) {
-        break
-      }
-      await sleep(delay)
-      delay = Math.floor(delay * backoff)
-    }
-  }
-
-  throw lastErr
-}
-
-const routeKey = (page: Page, includeSearch = false) => {
-  const url = new URL(page.url())
-  return includeSearch ? `${url.pathname}${url.search}` : url.pathname
-}
-
-export async function waitForRouteSettled(
-  page: Page,
-  {
-    timeoutMs = 15000,
-    pollMs = 50,
-    urlStableMs = 500,
-    domQuietMs = 300,
-    includeSearch = false,
-  }: {
-    timeoutMs?: number
-    pollMs?: number
-    urlStableMs?: number
-    domQuietMs?: number
-    includeSearch?: boolean
-  } = {},
-): Promise<string> {
-  const deadline = Date.now() + timeoutMs
-  await page.waitForLoadState('domcontentloaded', { timeout: timeoutMs })
-
-  let lastKey = routeKey(page, includeSearch)
-  let stableSince = Date.now()
-  let navBumpedAt = Date.now()
-
-  const onFrameNav = () => {
-    navBumpedAt = Date.now()
-  }
-
-  page.on('framenavigated', onFrameNav)
-
-  try {
-    while (Date.now() < deadline) {
-      await sleep(pollMs)
-
-      const key = routeKey(page, includeSearch)
-      if (key !== lastKey) {
-        lastKey = key
-        stableSince = Date.now()
-        continue
-      }
-
-      const now = Date.now()
-      const urlStableLongEnough = now - stableSince >= urlStableMs
-      const noRecentNav = now - navBumpedAt >= urlStableMs
-      if (!urlStableLongEnough || !noRecentNav) {
-        continue
-      }
-
-      const domQuiet = await page
-        .evaluate(quietMs => {
-          return new Promise<boolean>(resolve => {
-            let lastMutation = Date.now()
-            const observer = new MutationObserver(() => {
-              lastMutation = Date.now()
-            })
-            observer.observe(document, { subtree: true, childList: true, attributes: true })
-
-            const tick = () => {
-              if (Date.now() - lastMutation >= quietMs) {
-                observer.disconnect()
-                resolve(true)
-                return
-              }
-              setTimeout(tick, 50)
-            }
-
-            tick()
-          })
-        }, domQuietMs)
-        .catch(() => false)
-
-      if (domQuiet) {
-        return lastKey
-      }
-    }
-
-    return routeKey(page, includeSearch)
-  } finally {
-    page.off('framenavigated', onFrameNav)
-  }
-}
-
-const getLocatorMapData = async (page: Page) => {
-  const locatorMap = LocatorMapCache.getInstance()
-  const currentPath = new URL(page.url()).pathname
-  const data = locatorMap.get(currentPath)
-
-  if (!data) {
-    throw new Error(`LOCATOR_MAP_NOT_FOUND::${currentPath}`)
-  }
-
-  return data
-}
-
-async function validateResolvedSelector(
-  page: Page,
-  selector: string,
-  {
-    timeoutMs = 1500,
-    requireVisible = true,
-    requireUnique = false,
-  }: {
-    timeoutMs?: number
-    requireVisible?: boolean
-    requireUnique?: boolean
-  } = {},
-): Promise<boolean> {
-  try {
-    const locator = page.locator(selector)
-    await locator.first().waitFor({ state: 'attached', timeout: timeoutMs })
-
-    if (requireVisible) {
-      await locator.first().waitFor({ state: 'visible', timeout: timeoutMs })
-    }
-
-    if (requireUnique) {
-      const count = await locator.count()
-      if (count !== 1) {
-        return false
-      }
-    }
-
-    return true
-  } catch {
-    return false
-  }
-}
-
-export async function resolveLocator(
-  page: Page,
-  locatorName: string,
-  {
-    maxResolvePasses = 2,
-    validate = {
-      timeoutMs: 1500,
-      requireVisible: true,
-      requireUnique: false,
-    },
-  }: {
-    maxResolvePasses?: number
-    validate?: {
-      timeoutMs?: number
-      requireVisible?: boolean
-      requireUnique?: boolean
-    }
-  } = {},
-): Promise<string | null> {
-  try {
-    for (let pass = 0; pass < maxResolvePasses; pass++) {
-      await waitForRouteSettled(page, {
-        timeoutMs: 15000,
-        urlStableMs: 500,
-        domQuietMs: 300,
-        pollMs: 50,
-        includeSearch: false,
-      })
-
-      const beforePath = new URL(page.url()).pathname
-      const locatorMapData = await retry(() => getLocatorMapData(page), {
-        retries: 6,
-        delayMs: 80,
-        backoff: 1.5,
-        shouldRetry: error => error instanceof Error && error.message.startsWith('LOCATOR_MAP_NOT_FOUND::'),
-      })
-
-      const locators = LocatorCache.getInstance().get(locatorMapData.name)
-      if (!locators) {
-        throw new Error(`Locator bundle not found for name ${locatorMapData.name}`)
-      }
-
-      const selector = locators[locatorName]
-      if (!selector) {
-        throw new Error(`Locator "${locatorName}" not found for name ${locatorMapData.name}`)
-      }
-
-      const afterPath = new URL(page.url()).pathname
-      if (afterPath !== beforePath) {
-        continue
-      }
-
-      const isValid = await validateResolvedSelector(page, selector as unknown as string, validate)
-      if (isValid) {
-        return selector as unknown as string
-      }
-    }
-
-    throw new Error(`Failed to resolve a valid locator for "${locatorName}" after ${maxResolvePasses} passes`)
-  } catch (error) {
-    console.error(error)
-    return null
-  }
-}

package/templates/default/packages/cucumber-runtime/src/parameter-types.ts

@@ -1,7 +0,0 @@
-import { defineParameterType } from '@cucumber/cucumber'
-
-defineParameterType({
-  name: 'boolean',
-  regexp: /true|false/,
-  transformer: (s: string) => s === 'true',
-})

package/templates/default/packages/cucumber-runtime/src/random-data.util.ts

@@ -1,35 +0,0 @@
-import { faker } from '@faker-js/faker'
-
-export enum RandomDataType {
-  FULL_NAME = 'fullName',
-  FIRST_NAME = 'firstName',
-  LAST_NAME = 'lastName',
-  EMAIL = 'email',
-  PASSWORD = 'password',
-  PHONE = 'phone',
-  ADDRESS = 'address',
-  UNIQUE_TEXT = 'uniqueText',
-}
-
-export function generateRandomData(randomDataType: RandomDataType): string {
-  switch (randomDataType) {
-    case RandomDataType.FULL_NAME:
-      return faker.person.fullName()
-    case RandomDataType.FIRST_NAME:
-      return faker.person.firstName()
-    case RandomDataType.LAST_NAME:
-      return faker.person.lastName()
-    case RandomDataType.EMAIL:
-      return faker.internet.email()
-    case RandomDataType.PASSWORD:
-      return faker.internet.password()
-    case RandomDataType.PHONE:
-      return faker.phone.number()
-    case RandomDataType.ADDRESS:
-      return faker.location.streetAddress()
-    case RandomDataType.UNIQUE_TEXT:
-      return faker.string.uuid()
-    default:
-      throw new Error(`Invalid random data type: ${randomDataType}`)
-  }
-}

package/templates/default/packages/cucumber-runtime/src/types.ts

@@ -1,13 +0,0 @@
-export type BrowserName = 'chromium' | 'firefox' | 'webkit'
-
-export type CSSSelector = string
-export type XPathSelector = `/${string}` | `//${string}`
-export type SelectorName = string
-export type Selector = CSSSelector | XPathSelector
-export type Locator = Record<string, Selector>
-export type LocatorMap = {
-  name: string
-  path: string
-}
-
-export type LocatorCollection = Record<string, Locator>