pipework 0.252.0 → 0.252.1

package/src/cli/commands/lint.ts

@@ -0,0 +1,62 @@
+import { spawnSync } from 'node:child_process'
+import { dirname, relative } from 'node:path'
+import { findConfig } from '../../core/config/discover.js'
+import { error } from '../output.js'
+import { builtinConfigArgs, lintTargets, loadLintIncludes, resolveEslintBin } from './check.js'
+
+// eslint options that take their value as the next argument. Anything else starting
+// with `-` is a switch, so the argument after it is a file.
+const VALUE_FLAGS = new Set([
+  '-c', '--config', '--ext', '--resolve-plugins-relative-to', '--rulesdir', '--parser',
+  '--parser-options', '--plugin', '--rule', '--global', '--env', '-f', '--format',
+  '-o', '--output-file', '--max-warnings', '--cache-location', '--cache-strategy',
+  '--ignore-path', '--ignore-pattern', '--stdin-filename', '--report-unused-disable-directives-severity',
+  '--exit-on-fatal-error-severity', '--concurrency', '--flag', '--inspect-config-option',
+  '--print-config',
+])
+
+function namesConfig(args: readonly string[]): boolean {
+  return args.some(a => a === '-c' || a === '--config' || a.startsWith('--config='))
+}
+
+/** True when `args` name at least one file or glob for eslint to lint. */
+export function namesFiles(args: readonly string[]): boolean {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]!
+    if (arg === '--') return i < args.length - 1
+    if (!arg.startsWith('-') || arg === '-') return true
+    if (VALUE_FLAGS.has(arg)) i++
+  }
+  return false
+}
+
+/**
+ * `pipework lint [eslint args...]`: eslint in `cwd` with the config, globs and binary
+ * `pipework check` uses. With no files named, lints the include globs; with files, only
+ * those. Every argument is forwarded verbatim. Returns eslint's exit code.
+ */
+export async function lintCommand(cwd: string, args: readonly string[]): Promise<number> {
+  const eslintBin = resolveEslintBin(cwd)
+  const configPath = findConfig(cwd)
+  const root = configPath === null ? cwd : dirname(configPath)
+  const label = relative(root, cwd) || '.'
+
+  const forwarded = [...args]
+  if (!namesFiles(args)) {
+    const includes = await loadLintIncludes(root)
+    const targets = lintTargets(cwd, includes.for(label))
+    if (targets.length === 0) {
+      error(`Nothing to lint in ${label}: none of the lint include globs reach a directory that exists.`)
+      return 1
+    }
+    // A default glob that reaches nothing (no .tsx here) is not an error, as in `check`.
+    forwarded.unshift(...targets, '--no-error-on-unmatched-pattern')
+  }
+
+  const result = spawnSync(eslintBin, [...forwarded, ...(namesConfig(args) ? [] : builtinConfigArgs(cwd))], { cwd, stdio: 'inherit' })
+  if (result.error !== undefined) {
+    error(`Failed to run eslint: ${result.error.message}`)
+    return 1
+  }
+  return result.status ?? 1
+}

package/src/cli/commands/migrate.ts

@@ -0,0 +1,132 @@
+import { info, success, error as logError, warn } from '../output.js'
+import type { MigrateResult } from '../../data/migrate/run.js'
+import { frameworkTablesChanged } from '../../data/migrate/provision-framework.js'
+
+export interface MigrateCommandOptions {
+  db: string | undefined
+  cwd: string
+  confirm: boolean | undefined
+  allowDestructive: boolean | undefined
+  acknowledgeLock: boolean | undefined
+}
+
+export async function migrate(options: MigrateCommandOptions): Promise<void> {
+  const { discoverInstance, findConfig } = await import('../../core/config/discover.js')
+  const { migrateAll, migrateOne, UnsafeMigrationError } = await import('../../data/migrate/run.js')
+  const { formatCheckResult } = await import('../../data/migrate/check.js')
+
+  if (findConfig(options.cwd) === null) {
+    logError(
+      'No pipework.config.ts found in the current directory.\n\n' +
+      '  Run `pipework init` to create one.\n'
+    )
+    process.exit(1)
+  }
+
+  const rejection = rejectRetiredFlags(options)
+  if (rejection !== null) {
+    logError(rejection)
+    process.exit(1)
+  }
+
+  const instance = await discoverInstance(options.cwd)
+
+  if (instance.config.environment === 'production' && options.confirm !== true) {
+    logError(
+      'Refusing to run migrations in production without --confirm.\n\n' +
+      '  This is a destructive operation that modifies your production database schema.\n' +
+      '  Run: pipework migrate --confirm\n',
+    )
+    process.exit(1)
+  }
+
+  if (instance.config.environment === 'production') {
+    warn('Running migrations against PRODUCTION database.')
+  }
+
+  const migrateOptions = {}
+
+  try {
+    if (options.db !== undefined) {
+      info(`Migrating database: ${options.db}`)
+      const result = await migrateOne(instance, instance.config.database(options.db), migrateOptions)
+      reportResumed(result)
+      reportFrameworkTables(result)
+      success(`${options.db}: ${result.migrationsRun} migrations applied`)
+    } else {
+      info('Migrating all databases...')
+      const results = await migrateAll(instance, migrateOptions)
+      for (const result of results) {
+        reportResumed(result)
+        reportFrameworkTables(result)
+        success(`${result.database}: ${result.migrationsRun} migrations applied`)
+      }
+    }
+  } catch (err) {
+    if (err instanceof UnsafeMigrationError) {
+      const report = formatCheckResult(err.check)
+      logError(report)
+      process.exit(1)
+    }
+    throw err
+  } finally {
+    await instance.pool.closeAll()
+  }
+}
+
+/**
+ * `--allow-destructive` / `--acknowledge-lock` authorized an *invocation*, so
+ * the first destructive migration that had to ship put them into a deploy
+ * workflow permanently and every migration after that was pre-approved by a
+ * decision nobody revisits. Authorization is per-migration now, declared in
+ * the file that raises the hazard, where review can see it.
+ *
+ * Failing loudly rather than ignoring them is the point: a pipeline still
+ * passing these is a pipeline that has been running ungated.
+ *
+ * Returns the error text, or null when neither flag was passed.
+ */
+export function rejectRetiredFlags(options: {
+  allowDestructive: boolean | undefined
+  acknowledgeLock: boolean | undefined
+}): string | null {
+  const used = [
+    options.allowDestructive === true ? '--allow-destructive' : null,
+    options.acknowledgeLock === true ? '--acknowledge-lock' : null,
+  ].filter((f): f is string => f !== null)
+
+  if (used.length === 0) return null
+
+  return (
+    `${used.join(' and ')} ${used.length > 1 ? 'are' : 'is'} no longer accepted.\n\n` +
+    '  Authorization belongs in the migration, not the deploy command.\n' +
+    '  A flag here approves every migration this pipeline will ever run;\n' +
+    '  a pragma approves the one file it is written in, in the diff where\n' +
+    '  it is reviewed.\n\n' +
+    '  Run `pipework migrate` with no flags. It will name each migration\n' +
+    '  that needs a declaration and the exact line to add, e.g.\n\n' +
+    '    -- pipework:expect-destructive\n' +
+    '    DROP TABLE "graph_co_change_edges";\n'
+  )
+}
+
+// A half-applied no-transaction file that was picked up and finished is not a
+// routine apply: it says the previous run died mid-file. Name it. Issue #378.
+function reportResumed(result: MigrateResult): void {
+  for (const r of result.resumed) {
+    warn(
+      `${result.database}: resumed "${r.tag}" from statement ${r.fromStatement} of ` +
+      `${r.totalStatements} — a previous run stopped mid-file.`,
+    )
+  }
+}
+
+function reportFrameworkTables(result: MigrateResult): void {
+  const f = result.frameworkTables
+  if (!frameworkTablesChanged(f)) return
+  info(
+    `${result.database}: framework tables created ${f.created.length === 0 ? 'none' : f.created.join(', ')}; ` +
+    `columns added ${f.columnsAdded.length === 0 ? 'none' : f.columnsAdded.join(', ')}; ` +
+    `${f.partitionsCreated.length} day partitions created`,
+  )
+}

package/src/cli/commands/openapi.ts

@@ -0,0 +1,63 @@
+import { mkdirSync, writeFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { ConfigError } from '../../core/config/errors.js'
+import type { HttpSurfaceBuilder } from '../../core/surface/types.js'
+import { success } from '../output.js'
+
+export interface OpenapiCommandOptions {
+  cwd: string
+  surface?: string | undefined
+  out?: string | undefined
+}
+
+/** Writes an http surface's OpenAPI document, byte-identical to the server's GET, without connecting to any database. */
+export async function openapi(options: OpenapiCommandOptions): Promise<void> {
+  const { discoverInstance } = await import('../../core/config/discover.js')
+  const instance = await discoverInstance(options.cwd)
+
+  const all = instance.surfaceMap()
+  const httpNames = Object.entries(all).filter(([, s]) => s.kind === 'http').map(([n]) => n)
+
+  let name: string
+  if (options.surface !== undefined) {
+    const picked = all[options.surface]
+    if (picked === undefined || picked.kind !== 'http') {
+      throw new ConfigError(
+        picked === undefined
+          ? `No surface named "${options.surface}".`
+          : `Surface "${options.surface}" is a ${picked.kind} surface, not http.`,
+        `The http surfaces are: ${httpNames.length > 0 ? httpNames.join(', ') : '(none)'}. Pass --surface <name>.`,
+      )
+    }
+    name = options.surface
+  } else {
+    const withInfo = httpNames.filter((n) => hasOpenapiInfo(all[n] as HttpSurfaceBuilder))
+    if (withInfo.length !== 1) {
+      throw new ConfigError(
+        `Expected exactly one http surface with \`openapi\` info, found ${String(withInfo.length)}.`,
+        `The http surfaces are: ${httpNames.length > 0 ? httpNames.join(', ') : '(none)'}. Add \`openapi: { title, version }\` to one, or pass --surface <name>.`,
+      )
+    }
+    name = withInfo[0] as string
+  }
+
+  const text = JSON.stringify((all[name] as HttpSurfaceBuilder).openapi())
+  if (options.out === undefined) {
+    process.stdout.write(text)
+    return
+  }
+  const file = resolve(options.cwd, options.out)
+  mkdirSync(dirname(file), { recursive: true })
+  writeFileSync(file, text)
+  success(`Wrote ${options.out} (surface ${name})`)
+}
+
+function hasOpenapiInfo(s: HttpSurfaceBuilder): boolean {
+  try {
+    s.openapi()
+    return true
+  } catch (err) {
+    if (err instanceof ConfigError) return false
+    throw err
+  }
+}

package/src/cli/commands/remove.ts

@@ -0,0 +1,72 @@
+import { resolve } from 'node:path'
+import { readFileSync, writeFileSync } from 'node:fs'
+import { sync as syncWorkspace } from '../../workspace/sync.js'
+import { loadConfig } from './shared/load-config.js'
+import { reportRemoved } from './shared/report-removed.js'
+import { runPnpmInstall } from './shared/pnpm-install.js'
+import { findConfigFile } from './shared/find-config.js'
+import { info, success, error, bold, warn } from '../output.js'
+
+export async function remove(cwd: string, packages: readonly string[]): Promise<void> {
+  if (packages.length === 0) {
+    error(`Missing package name.\n\n  Usage: ${bold('pipework remove <pkg> [...]')}\n`)
+    process.exit(1)
+  }
+
+  const resolved = resolve(cwd)
+  const configPath = findConfigFile(resolved)
+
+  const source = readFileSync(configPath, 'utf-8')
+  const { result: updated, removed } = removeDependencies(source, packages)
+
+  if (removed.length === 0) {
+    warn(`None of the specified packages were found in dependencies.`)
+    return
+  }
+
+  writeFileSync(configPath, updated)
+  info(`Removed ${removed.join(', ')}`)
+
+  const notFound = packages.filter(p => !removed.includes(p))
+  if (notFound.length > 0) {
+    warn(`Not found in dependencies: ${notFound.join(', ')}`)
+  }
+
+  const { config, appName } = await loadConfig(resolved)
+  info('Syncing workspace...')
+  const result = syncWorkspace({ config, cwd: resolved, appName })
+  success(`Generated ${String(result.files.length)} file(s).`)
+  reportRemoved(result)
+
+  info('Running pnpm install...')
+  const outcome = runPnpmInstall({ cwd: resolved, requiredPipeworkVersion: result.pipeworkVersion })
+  if (!outcome.ok) {
+    error(outcome.message)
+    process.exit(1)
+  }
+  success(`Install complete — pipework@${outcome.installedPipeworkVersion} in node_modules.`)
+}
+
+function removeDependencies(
+  source: string,
+  packages: readonly string[],
+): { result: string; removed: string[] } {
+  const removed: string[] = []
+  let result = source
+
+  for (const pkg of packages) {
+    const lineRegex = new RegExp(
+      `\\n?[ \\t]*['"]${escapeRegex(pkg)}['"]\\s*:\\s*['"][^'"]*['"],?[ \\t]*\\n?`,
+    )
+    if (lineRegex.test(result)) {
+      result = result.replace(lineRegex, '\n')
+      removed.push(pkg)
+    }
+  }
+
+  return { result, removed }
+}
+
+function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}

package/src/cli/commands/run.ts

@@ -0,0 +1,50 @@
+import { resolve } from 'node:path'
+import { existsSync } from 'node:fs'
+import { pathToFileURL } from 'node:url'
+import { runScript } from '../../async/jobs/run-script.js'
+import { bold, error, success } from '../output.js'
+
+export interface RunCommandOptions {
+  script: string
+  cwd: string
+  tenant?: string | undefined
+  jobType?: string | undefined
+}
+
+export async function run(options: RunCommandOptions): Promise<void> {
+  const scriptPath = resolve(options.cwd, options.script)
+
+  if (!existsSync(scriptPath)) {
+    throw new Error(
+      `Script not found: ${options.script}\n\n` +
+      `  Provide a path relative to the project root.\n` +
+      `  Example: ${bold('pipework run ./scripts/seed.ts')}\n`,
+    )
+  }
+
+  const { discoverInstance } = await import('../../core/config/discover.js')
+
+  const instance = await discoverInstance(options.cwd)
+
+  try {
+    try {
+      await runScript(instance, async () => {
+        await import(pathToFileURL(scriptPath).href)
+      }, {
+        jobType: options.jobType ?? 'script',
+        tenant: options.tenant ?? null,
+      })
+    } catch (err) {
+      error(`Script failed: ${options.script}`)
+      throw err
+    }
+    const exitCode = process.exitCode
+    if (exitCode !== undefined && Number(exitCode) !== 0) {
+      error(`Script failed: ${options.script} (exit code ${String(exitCode)})`)
+      return
+    }
+    success(`Script completed: ${options.script}`)
+  } finally {
+    await instance.pool.closeAll()
+  }
+}

package/src/cli/commands/scope.ts

@@ -0,0 +1,54 @@
+import type { ScopeMode } from '../../workspace/affected.js'
+
+export interface ParsedScope {
+  readonly scope: ScopeMode
+  readonly suite: string | undefined
+  /** `--fast` was given — `test` trims to the fast tiers. Issue #325. */
+  readonly fast: boolean
+}
+
+export function parseScope(values: {
+  all?: boolean | undefined
+  module?: string | undefined
+  staged?: boolean | undefined
+  fast?: boolean | undefined
+  full?: boolean | undefined
+  suite?: string | undefined
+}): ParsedScope {
+  const flags = [
+    values.all === true ? '--all' : null,
+    values.module !== undefined ? '--module' : null,
+    values.staged === true ? '--staged' : null,
+    values.fast === true ? '--fast' : null,
+    values.full === true ? '--full' : null,
+  ].filter((f): f is string => f !== null)
+
+  if (flags.length > 1) {
+    throw new Error(`${flags.join(' and ')} are mutually exclusive.`)
+  }
+
+  let scope: ScopeMode
+  if (values.full === true || values.all === true) {
+    // --full and --all both mean every module; --full additionally keeps all
+    // test tiers (the default whenever `fast` is false).
+    scope = { kind: 'all' }
+  } else if (values.fast === true) {
+    // --fast: only modules touched on this branch, diffed against the
+    // merge-base with the base branch. resolveAffected fails open to every
+    // module when that cannot be computed. Issue #325.
+    scope = { kind: 'diff', mode: 'branch' }
+  } else if (values.module !== undefined) {
+    scope = { kind: 'module', path: values.module }
+  } else if (values.staged === true) {
+    scope = { kind: 'diff', mode: 'staged' }
+  } else {
+    // Bare form: branch diff — merge-base to worktree, so committed work,
+    // uncommitted edits, and untracked files all count. The old default
+    // (`uncommitted`) scoped to the dirty tree only, so a committed-clean
+    // branch evaluated nothing and exited 0 — a vacuous green recorded three
+    // times by consumers. Unlike --fast this keeps every test tier.
+    scope = { kind: 'diff', mode: 'branch' }
+  }
+
+  return { scope, suite: values.suite, fast: values.fast === true }
+}

package/src/cli/commands/serve.ts

@@ -0,0 +1,68 @@
+import { spawn } from 'node:child_process'
+import { dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { ConfigError } from '../../core/config/errors.js'
+import { SURFACE_KINDS_ENV } from '../surface-kinds.js'
+import { resolveRegisterPath, resolveBootstrapPath } from './dev.js'
+
+export interface ServeOptions {
+  port: string | undefined
+  /** Run only the worker surfaces: no http server, no scripts. */
+  workerOnly: boolean
+  cwd: string
+}
+
+// `pipework serve` — the production entrypoint. It discovers the manifold and binds
+// every surface via the SAME bootstrap as `dev` (discoverInstance -> manifold.start),
+// differing only in that it does NOT pass `--watch`: a stable long-running process,
+// not a file-watcher. This is the supported replacement for hand-rolled serve scripts
+// that reached into pipework/dist internals (e.g. `dist/core/config/discover.js`).
+//
+// Exported + pure so the "serve never watches" contract is unit-testable without
+// spawning a process.
+export function buildServeArgs(registerPath: string, bootstrapPath: string): string[] {
+  return ['--import', registerPath, bootstrapPath]
+}
+
+/**
+ * The environment `serve` gives its child. `--worker-only` selects the worker surfaces only (script
+ * surfaces are one-shot work that belongs to the main process, so a scaled worker never repeats them)
+ * and opens no port, so it refuses `--port`.
+ */
+export function buildServeEnv(options: ServeOptions, base: Record<string, string | undefined> = process.env): Record<string, string | undefined> {
+  if (options.workerOnly && options.port !== undefined) {
+    throw new ConfigError(
+      '--worker-only opens no port, so --port does not apply.',
+      'Drop --port, or drop --worker-only to run the http surface.',
+    )
+  }
+  const env: Record<string, string | undefined> = { ...base, 'PIPEWORK_CWD': options.cwd }
+  if (options.port !== undefined) {
+    env['PORT'] = options.port
+  }
+  if (options.workerOnly) {
+    env[SURFACE_KINDS_ENV] = 'worker'
+    // A PORT in the environment must not reach a process that listens nowhere.
+    delete env['PORT']
+  }
+  return env
+}
+
+export function serve(options: ServeOptions): void {
+  const cliDir = dirname(fileURLToPath(import.meta.url))
+  const env = buildServeEnv(options)
+
+  const args = buildServeArgs(resolveRegisterPath(cliDir), resolveBootstrapPath(cliDir))
+
+  const child = spawn('node', args, { cwd: options.cwd, stdio: 'inherit', env })
+
+  child.on('exit', (code, signal) => {
+    if (signal === 'SIGTERM' || signal === 'SIGINT') {
+      process.exit(0)
+    }
+    process.exit(code ?? 0)
+  })
+
+  process.on('SIGTERM', () => child.kill('SIGTERM'))
+  process.on('SIGINT', () => child.kill('SIGINT'))
+}

package/src/cli/commands/shard.ts

@@ -0,0 +1,31 @@
+/** `--shard <index>/<count>`: run part `index` of `count` disjoint parts of one run. */
+export interface Shard {
+  readonly index: number
+  readonly count: number
+}
+
+export function parseShard(value: string): Shard {
+  const match = /^(\d+)\/(\d+)$/.exec(value)
+  const index = match === null ? 0 : Number(match[1])
+  const count = match === null ? 0 : Number(match[2])
+  if (match === null || index < 1 || count < 1 || index > count) {
+    throw new Error(
+      `--shard takes <index>/<count> with 1 <= index <= count (for example --shard 2/4); got "${value}".`,
+    )
+  }
+  return { index, count }
+}
+
+export function shardArg(shard: Shard): string {
+  return `${String(shard.index)}/${String(shard.count)}`
+}
+
+/**
+ * The modules part `index` of `count` owns: sorted, then dealt round-robin, so
+ * the parts are disjoint and together hold every module.
+ */
+export function shardModules(modules: readonly string[], shard: Shard | undefined): string[] {
+  const sorted = [...modules].sort()
+  if (shard === undefined) return sorted
+  return sorted.filter((_, i) => i % shard.count === shard.index - 1)
+}

package/src/cli/commands/shared/config-pipework-version.ts

@@ -0,0 +1,28 @@
+import { readFileSync, writeFileSync } from 'node:fs'
+
+// The `pipework: '<version>'` entries of a config source: a (possibly quoted) key named
+// pipework whose value is a plain version literal, with an optional range prefix.
+const PIPEWORK_PIN = /(?<![\w$.-])(['"]?)pipework\1(\s*:\s*)(['"])([\^~>=<]*)(\d+\.\d+\.\d+[^'"\n]*)\3/g
+
+export type ConfigRewrite =
+  | { readonly kind: 'rewritten'; readonly source: string }
+  | { readonly kind: 'unchanged' }
+  | { readonly kind: 'none' }
+  | { readonly kind: 'ambiguous'; readonly count: number }
+
+/** Sets the one `pipework` version literal in a config's source, keeping its range prefix. */
+export function rewritePipeworkVersion(source: string, version: string): ConfigRewrite {
+  const matches = [...source.matchAll(PIPEWORK_PIN)]
+  if (matches.length === 0) return { kind: 'none' }
+  if (matches.length > 1) return { kind: 'ambiguous', count: matches.length }
+  const rewritten = source.replace(PIPEWORK_PIN, (_m, q: string, sep: string, quote: string, prefix: string) =>
+    `${q}pipework${q}${sep}${quote}${prefix}${version}${quote}`)
+  return rewritten === source ? { kind: 'unchanged' } : { kind: 'rewritten', source: rewritten }
+}
+
+/** Rewrites the config file in place; returns what happened so the caller can tell the user. */
+export function rewriteConfigFileVersion(path: string, version: string): ConfigRewrite {
+  const result = rewritePipeworkVersion(readFileSync(path, 'utf-8'), version)
+  if (result.kind === 'rewritten') writeFileSync(path, result.source, 'utf-8')
+  return result
+}

package/src/cli/commands/shared/find-config.ts

@@ -0,0 +1,22 @@
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { error } from '../../output.js'
+
+const CONFIG_FILENAMES = [
+  'pipework.config.ts',
+  'pipework.config.js',
+  'pipework.config.mjs',
+]
+
+export function findConfigFile(cwd: string): string {
+  for (const name of CONFIG_FILENAMES) {
+    const full = join(cwd, name)
+    if (existsSync(full)) return full
+  }
+
+  error(
+    'No pipework config file found.\n\n' +
+    '  Run `pipework init` to create one, or check that you are in the right directory.\n',
+  )
+  process.exit(1)
+}

package/src/cli/commands/shared/load-config.ts

@@ -0,0 +1,35 @@
+import type { Blueprint } from '../../../core/config/schema.js'
+import { findConfigFile } from './find-config.js'
+import { error } from '../../output.js'
+
+export interface LoadedConfig {
+  readonly config: Blueprint
+  readonly appName: string
+}
+
+export async function loadConfig(cwd: string): Promise<LoadedConfig> {
+  findConfigFile(cwd)
+
+  const { discoverInstance } = await import('../../../core/config/discover.js')
+
+  let instance
+  try {
+    instance = await discoverInstance(cwd)
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    error(
+      `pipework.config.ts found but failed to load:\n\n` +
+      `  ${message}\n\n` +
+      `  Check that all required environment variables are set.\n`,
+    )
+    process.exit(1)
+  }
+
+  const rawConfig = instance.config.raw as Blueprint
+  const appName = rawConfig.name ?? 'app'
+
+  return {
+    config: rawConfig,
+    appName,
+  }
+}