@vzn/vx-migrate 0.0.633 → 0.0.635

package/README.md

@@ -1,6 +1,8 @@
 # @vzn/vx-migrate
 
-Everything for adopting [`@vzn/vx`](https://github.com/vznjs/vx) from Turborepo, Nx or Vite Task, in one package with zero dependencies:
+Website: <https://vznjs.github.io/vx/> · this plugin: <https://vznjs.github.io/vx/plugins/vx-migrate/> · source: <https://github.com/vznjs/vx>
+
+Everything for adopting [`@vzn/vx`](https://vznjs.github.io/vx/) from Turborepo, Nx or Vite Task, in one package with zero dependencies:
 
 - **`turbo()`** — a temporary start for a Turbo repository: the plugin fills vx's `project` stage from `turbo.json` and each package's `package.json` scripts until the migrator writes native config.
 - **`nx()`** — the same temporary start for an Nx repository, filled from Nx's resolved project graph. Executor targets (`@nx/js:tsc`, `@nx/vite:build`, your own) run as themselves through **`nx-exec`**, one executor per process.
@@ -232,7 +234,7 @@ Your `package.json` scripts are never edited. `--dry` installs nothing and says
 
 ### Turbo
 
-Reads the root pipeline (`tasks` in Turbo 2, `pipeline` in Turbo 1), per-package `turbo.json` `extends` overlays and each package's scripts, through the same mapper `turbo()` runs live — so the written configs say what the plugin was doing. Turbo's global fields become a generated root `vx-preset.ts` each config imports and spreads: TypeScript composition replaces global config. So does a task's `env` that several configs share (`buildEnv`), where inline it would repeat in every package (vercel/ai: 63 names, twice in each of ~100 configs, half the output). Turbo's `//#` root tasks are written to a `vx.config.ts` at the workspace root, which makes the root a project (core's D-39), and a package task's `//#x` edge reaches it. When a `vx.workspace.ts` already exists without one, the report names the `@vzn/vx-lockfile` plugin for the repo's lockfile: Turbo keys each package on its own lockfile entries, and core keys every task on the whole file until a plugin claims it.
+Reads the root pipeline (`tasks` in Turbo 2, `pipeline` in Turbo 1), per-package `turbo.json` `extends` overlays and each package's scripts, through the same mapper `turbo()` runs live — so the written configs say what the plugin was doing. Turbo's global fields become a generated root `vx-preset.ts` each config imports and spreads: TypeScript composition replaces global config. A config that a `tsconfig*.json` in its directory or above (below the root) takes in, where that project is composite or sets `rootDir`, declares the values it uses instead: `tsc` refuses a file outside the package (TS6059, TS6307; withastro/astro's `scripts/` and the `performance/` project its `packages/astro/tsconfig.test.json` takes in). So does a task's `env` that several configs share (`buildEnv`), where inline it would repeat in every package (vercel/ai: 63 names, twice in each of ~100 configs, half the output). Turbo's `//#` root tasks are written to a `vx.config.ts` at the workspace root, which makes the root a project (core's D-39), and a package task's `//#x` edge reaches it. When a `vx.workspace.ts` already exists without one, the report names the `@vzn/vx-lockfile` plugin for the repo's lockfile: Turbo keys each package on its own lockfile entries, and core keys every task on the whole file until a plugin claims it.
 
 | Turborepo                           | vx                                                                                                |
 | ----------------------------------- | ------------------------------------------------------------------------------------------------- |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx-migrate",
-  "version": "0.0.633",
+  "version": "0.0.635",
   "license": "MIT",
   "description": "Adopt @vzn/vx from Turborepo or Nx: run the repo unchanged, migrate it to vx.config.ts, and keep your Turbo or Nx remote cache",
   "keywords": [
@@ -8,6 +8,7 @@
     "vx-plugin",
     "monorepo",
     "turborepo",
+    "turbo",
     "nx",
     "migration",
     "remote-cache"
@@ -39,7 +40,7 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@vzn/vx": "^0.0.633"
+    "@vzn/vx": "^0.0.635"
   },
   "repository": {
     "type": "git",

package/src/migrate-turbo.ts

@@ -23,6 +23,7 @@ import { gitIgnored, spareTrackedOutputs, trackedFiles, trackedKinds } from './t
 import { DOTENV_GLOBS_HEAD, DOTENV_PROBE, DOTENV_PROBE_TOP } from './dotenv-probe.js'
 import { adoptedToolNotes } from './workspace-notes.js'
 import { spelledNames } from './spelled-env.js'
+import { sealsConfig } from './sealed-tsconfig.js'
 
 /** What a task's `npm_package_*` read: the manifest, so a bump reaches them. */
 const MANIFEST_IMPORT = "import pkg from './package.json' with { type: 'json' }"
@@ -67,6 +68,11 @@ export async function migrateTurbo(
 
   const shared = hoistTaskEnv(mapping.projects)
   const probes = nameProbes(mapping.projects)
+  const { inputs, env, pass } = mapping.globals
+  const decls = presetDeclarations(inputs, env, pass, shared.lists, probes.named)
+  // Written unless every config that uses it declares its values itself.
+  let imported = false
+  let anySealed = false
   const projects: GeneratedProject[] = mapping.projects.map((p) => {
     const used = new Set<string>([
       ...(shared.usedBy.get(p.name) ?? []),
@@ -74,29 +80,29 @@ export async function migrateTurbo(
     ])
     for (const t of p.tasks) for (const kind of t.uses) used.add(PRESET_NAMES[kind])
     const readsManifest = p.tasks.some((t) => JSON.stringify(t.task ?? {}).includes('"pkg.'))
+    const sealed =
+      used.size > 0 &&
+      sealsConfig(root, path.join(path.resolve(root, p.dir), `vx.config.${format}`))
+    if (used.size > 0 && !sealed) imported = true
+    if (sealed) anySealed = true
     return {
       name: p.name,
       dir: p.dir,
       importLines: [
         ...(readsManifest ? [MANIFEST_IMPORT] : []),
-        ...presetImportLines(used, root, p.dir, format),
+        ...(sealed
+          ? decls.filter(([name]) => used.has(name)).map(([, line]) => line)
+          : presetImportLines(used, root, p.dir, format)),
       ],
       tasks: p.tasks.map(({ name, todos, task }) => ({ name, todos, task })),
     }
   })
 
-  const { inputs, env, pass } = mapping.globals
   const extraFiles: MigrationPlan['extraFiles'] = []
-  if (
-    inputs.length > 0 ||
-    env.length > 0 ||
-    pass.length > 0 ||
-    shared.lists.length > 0 ||
-    probes.named.length > 0
-  ) {
+  if (decls.length > 0 && (imported || !anySealed)) {
     extraFiles.push({
       relPath: presetFile(format),
-      contents: renderPreset(inputs, env, pass, shared.lists, probes.named),
+      contents: [...decls.map(([, line]) => `export ${line}`), ''].join('\n'),
     })
   }
 
@@ -303,23 +309,24 @@ function nameProbes(projects: readonly TurboMappedProject[]): {
   return { named: named.sort((a, b) => order.indexOf(a) - order.indexOf(b)), usedBy }
 }
 
-function renderPreset(
+/** Each preset value as `[name, 'const name = …']`, in the preset's order. */
+function presetDeclarations(
   inputs: string[],
   env: string[],
   pass: string[],
   shared: readonly SharedList[],
   probes: readonly Probe[],
-): string {
+): [string, string][] {
   // Escape each entry via the shared `quote()` — a turbo.json global (a file
   // glob, or an env name a user hand-wrote) may contain a `'`/`\`/newline that
   // would otherwise splice into a malformed, unloadable `vx-preset.ts`.
   const arr = (xs: string[]): string => `[${xs.map(quote).join(', ')}]`
-  const lines: string[] = []
-  if (inputs.length > 0) lines.push(`export const globalInputs = ${arr(inputs)}`)
-  if (env.length > 0) lines.push(`export const globalEnvInputs = ${arr(env)}`)
-  if (pass.length > 0) lines.push(`export const globalPassThroughEnv = ${arr(pass)}`)
-  for (const l of shared) lines.push(`export const ${l.name} = ${arr([...l.values])}`)
-  for (const probe of probes) lines.push(`export const ${probe.name} = ${quote(probe.command)}`)
-  lines.push('')
-  return lines.join('\n')
+  const out: [string, string][] = []
+  const add = (name: string, value: string) => out.push([name, `const ${name} = ${value}`])
+  if (inputs.length > 0) add('globalInputs', arr(inputs))
+  if (env.length > 0) add('globalEnvInputs', arr(env))
+  if (pass.length > 0) add('globalPassThroughEnv', arr(pass))
+  for (const l of shared) add(l.name, arr([...l.values]))
+  for (const probe of probes) add(probe.name, quote(probe.command))
+  return out
 }

package/src/sealed-tsconfig.ts

@@ -0,0 +1,89 @@
+// A tsconfig that is a composite project (or sets `rootDir`) refuses a
+// source file outside its directory: withastro/astro's
+// `scripts/tsconfig.json` type-checked the written `vx.config.mjs`, and its
+// import of the root `vx-preset.mjs` failed the build (TS6059, TS6307). So
+// did `packages/astro/tsconfig.test.json`, which takes in the nested
+// `performance/vx.config.mjs`. A config such a project takes in declares
+// the preset values it uses itself.
+
+import { readdirSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+
+type TsConfig = {
+  extends?: unknown
+  include?: unknown
+  exclude?: unknown
+  files?: unknown
+  compilerOptions?: { composite?: unknown; rootDir?: unknown }
+}
+
+function read(file: string): TsConfig | null {
+  try {
+    return (Bun.JSONC.parse(readFileSync(file, 'utf8')) ?? {}) as TsConfig
+  } catch {
+    return null
+  }
+}
+
+/** A tsconfig glob as `Bun.Glob` reads it, relative to the tsconfig's own directory. */
+function pattern(p: string): string {
+  const rel = p.replace(/^\$\{configDir\}\/?/, '').replace(/^\.\//, '')
+  if (rel === '' || rel === '.') return '**/*'
+  // A directory names everything under it, as tsc reads it.
+  return /[*?{]/.test(rel) || /\.[A-Za-z0-9]+$/.test(rel) ? rel : `${rel.replace(/\/$/, '')}/**/*`
+}
+
+/** Does the project `file` states take in `rel` (relative to its directory) and refuse files outside it? */
+function seals(file: string, rel: string): boolean {
+  let sealed: boolean | undefined
+  let include: unknown
+  let exclude: unknown
+  let files: unknown
+  let at: TsConfig | null = read(file)
+  let from = path.dirname(file)
+  // The nearest file that states a field decides it, as `extends` resolves.
+  for (let depth = 0; at !== null && depth < 8; depth++) {
+    const o = at.compilerOptions
+    if (sealed === undefined && o?.composite !== undefined) sealed = o.composite === true
+    if (sealed !== true && typeof o?.rootDir === 'string') sealed = true
+    include ??= at.include
+    exclude ??= at.exclude
+    files ??= at.files
+    const ext = at.extends
+    // A package (`@tsconfig/node20`) is not followed: what it seals is rare.
+    if (typeof ext !== 'string' || !ext.startsWith('.')) break
+    const next = path.resolve(from, ext.endsWith('.json') ? ext : `${ext}.json`)
+    from = path.dirname(next)
+    at = read(next)
+  }
+  if (sealed !== true) return false
+  const hit = (list: unknown): boolean =>
+    Array.isArray(list) &&
+    list.some((g) => typeof g === 'string' && new Bun.Glob(pattern(g)).match(rel))
+  if (hit(exclude)) return false
+  if (Array.isArray(files) && files.some((f) => typeof f === 'string' && pattern(f) === rel))
+    return true
+  if (Array.isArray(include)) return hit(include)
+  // `files` alone lists exactly what it compiles; neither means everything.
+  return !Array.isArray(files)
+}
+
+/**
+ * Is `config` (absolute) taken in by a sealing tsconfig (`tsconfig*.json`)
+ * in its directory or one above it, below `root`? The root's own project
+ * holds the preset, so it refuses nothing.
+ */
+export function sealsConfig(root: string, config: string): boolean {
+  for (let dir = path.dirname(config); dir !== root && dir.startsWith(root);) {
+    let names: string[] = []
+    try {
+      names = readdirSync(dir).filter((n) => /^tsconfig.*\.json$/.test(n))
+    } catch {}
+    const rel = path.relative(dir, config).split(path.sep).join('/')
+    if (names.some((n) => seals(path.join(dir, n), rel))) return true
+    const up = path.dirname(dir)
+    if (up === dir) break
+    dir = up
+  }
+  return false
+}