next.js/turbopack/packages/devlow-bench/src/cli.ts

import minimist from 'minimist'
import { setCurrentScenarios } from './describe.js'
import { join } from 'path'
import { Scenario, ScenarioVariant, runScenarios } from './index.js'
import compose from './interfaces/compose.js'
import { pathToFileURL } from 'url'
;(async () => {
  const knownArgs = new Set([
    'scenario',
    's',
    'json',
    'j',
    'console',
    'datadog',
    'snowflake',
    'interactive',
    'i',
    'help',
    'h',
    '?',
    '_',
  ])
  const args = minimist(process.argv.slice(2), {
    alias: {
      s: 'scenario',
      j: 'json',
      i: 'interactive',
      '?': 'help',
      h: 'help',
    },
  })

  if (args.help || (Object.keys(args).length === 1 && args._.length === 0)) {
    console.log('Usage: devlow-bench [options] <scenario files>')
    console.log('## Selecting scenarios')
    console.log(
      '  --scenario=<filter>, -s=<filter>   Only run the scenario with the given name'
    )
    console.log(
      '  --interactive, -i                  Select scenarios and variants interactively'
    )
    console.log(
      '  --<prop>=<value>                   Filter by any variant property defined in scenarios'
    )
    console.log('## Output')
    console.log(
      '  --json=<path>, -j=<path>           Write the results to the given path as JSON'
    )
    console.log(
      '  --console                          Print the results to the console'
    )
    console.log(
      '  --datadog[=<hostname>]             Upload the results to Datadog'
    )
    console.log(
      '                                     (requires DATADOG_API_KEY environment variables)'
    )
    console.log(
      '  --snowflake[=<batch-uri>]          Upload the results to Snowflake'
    )
    console.log(
      '                                     (requires SNOWFLAKE_TOPIC_NAME and SNOWFLAKE_SCHEMA_ID and environment variables)'
    )
    console.log('## Help')
    console.log('  --help, -h, -?                     Show this help')
  }

  const scenarios: Scenario[] = []
  setCurrentScenarios(scenarios)

  for (const path of args._) {
    await import(pathToFileURL(join(process.cwd(), path)).toString())
  }

  setCurrentScenarios(null)

  const cliIface = {
    filterScenarios: async (scenarios: Scenario[]) => {
      if (args.scenario) {
        const filter = [].concat(args.scenario)
        return scenarios.filter((s) =>
          filter.some((filter) => s.name.includes(filter))
        )
      }
      return scenarios
    },
    filterScenarioVariants: async (variants: ScenarioVariant[]) => {
      const propEntries = Object.entries(args).filter(
        ([key]) => !knownArgs.has(key)
      )
      if (propEntries.length === 0) return variants
      for (const [key, value] of propEntries) {
        const values = (Array.isArray(value) ? value : [value]).map((v) =>
          v.toString()
        )
        variants = variants.filter((variant) => {
          const prop = variant.props[key]
          if (typeof prop === 'undefined') return false
          const str = prop.toString()
          return values.some((v) => str.includes(v))
        })
      }
      return variants
    },
  }
  let ifaces = [
    cliIface,
    args.interactive && (await import('./interfaces/interactive.js')).default(),
    args.json && (await import('./interfaces/json.js')).default(args.json),
    args.datadog &&
      (await import('./interfaces/datadog.js')).default(
        typeof args.datadog === 'string' ? { host: args.datadog } : undefined
      ),
    args.snowflake &&
      (await import('./interfaces/snowflake.js')).default(
        typeof args.snowflake === 'string'
          ? { gatewayUri: args.snowflake }
          : undefined
      ),
    args.console !== false &&
      (await import('./interfaces/console.js')).default(),
  ].filter((x) => x)
  await runScenarios(scenarios, compose(...ifaces))
})().catch((e) => {
  console.error(e.stack)
  process.exit(1)
})