@dbx-tools/projen 0.9.19 → 0.9.21

package/tasks/release-summary.ts

@@ -85,10 +85,6 @@ export type ReleaseSummaryRunner = (
   prompt: string,
 ) => string | undefined | Promise<string | undefined>;
 
-function capture(root: string, command: string, args: string[]): string {
-  return captureTaskCommand(root, command, args);
-}
-
 function contentText(value: unknown): string | undefined {
   if (typeof value === "string") return stringUtils.trimToNull(value) ?? undefined;
   if (!Array.isArray(value)) return undefined;
@@ -162,7 +158,7 @@ async function runProvider(
   root: string,
   prompt: string,
 ): Promise<string | undefined> {
-  if (!capture(root, provider.command, [...provider.probeArgs])) return undefined;
+  if (!captureTaskCommand(root, provider.command, [...provider.probeArgs])) return undefined;
   let summary: string | undefined;
   let previousEventKey: string | undefined;
   const textOutput: string[] = [];
@@ -317,15 +313,17 @@ export async function generateReleaseSummary(options: {
   const output = join(options.root, relativeOutput);
   if (existsSync(output)) rmSync(output);
   const target =
-    options.toRef && capture(options.root, "git", ["rev-parse", "--verify", options.toRef])
+    options.toRef &&
+    captureTaskCommand(options.root, "git", ["rev-parse", "--verify", options.toRef])
       ? options.toRef
       : "HEAD";
   const range =
-    options.fromRef && capture(options.root, "git", ["rev-parse", "--verify", options.fromRef])
+    options.fromRef &&
+    captureTaskCommand(options.root, "git", ["rev-parse", "--verify", options.fromRef])
       ? `${options.fromRef}..${target}`
       : target;
   const scopedPaths = options.paths?.length ? [...options.paths] : ["."];
-  const commits = capture(options.root, "git", [
+  const commits = captureTaskCommand(options.root, "git", [
     "log",
     "--no-merges",
     "--format=%s%n%b",
@@ -333,7 +331,7 @@ export async function generateReleaseSummary(options: {
     "--",
     ...scopedPaths,
   ]);
-  const changedFiles = capture(options.root, "git", [
+  const changedFiles = captureTaskCommand(options.root, "git", [
     "diff",
     "--name-status",
     range,
@@ -341,7 +339,7 @@ export async function generateReleaseSummary(options: {
     ...scopedPaths,
     `:(exclude)${relativeOutput}`,
   ]);
-  const diffStat = capture(options.root, "git", [
+  const diffStat = captureTaskCommand(options.root, "git", [
     "diff",
     "--stat",
     range,

package/tasks/release-version.ts

@@ -3,7 +3,28 @@
 import { resolve } from "node:path";
 import { parseArgs } from "node:util";
 import * as projectUtils from "@dbx-tools/core/project-utils";
-import { compareSemver, parseSemver, resolveRemoteVersion } from "../src/workspace-version.ts";
+import { captureGitTaskCommand } from "../src/_task-command.ts";
+import { compareSemver, parseSemver, type Semver } from "../src/workspace-version.ts";
+
+function publishedVersion(root: string, prefixes: readonly string[]): string | undefined {
+  let best: Semver | undefined;
+  for (const prefix of prefixes) {
+    const tags = captureGitTaskCommand(root, [
+      "-c",
+      "versionsort.suffix=-",
+      "tag",
+      "--sort=-version:refname",
+      "--list",
+      `${prefix}*`,
+    ]);
+    for (const tag of tags.split("\n")) {
+      if (!tag.startsWith(prefix)) continue;
+      const version = parseSemver(tag.slice(prefix.length));
+      if (version && (!best || compareSemver(version, best) > 0)) best = version;
+    }
+  }
+  return best?.join(".");
+}
 
 export function assertReleaseVersion(
   version: string,
@@ -18,7 +39,7 @@ export function assertReleaseVersion(
   if (!options.assertNext) return;
   const root = resolve(options.root ?? projectUtils.root() ?? process.cwd());
   const prefixes = options.prefixes?.length ? options.prefixes : ["v"];
-  const current = resolveRemoteVersion(root, prefixes, { fetch: false });
+  const current = publishedVersion(root, prefixes);
   const currentParsed = current ? parseSemver(current) : undefined;
   if (currentParsed && compareSemver(parsed, currentParsed) <= 0) {
     throw new Error(`release version ${version} must be greater than published ${current}`);

package/tasks/rust.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env -S bun
-import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { dirname, isAbsolute, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { log, object } from "@dbx-tools/shared-core";
+import { runTaskCommand, taskCommandSucceeds } from "../src/_task-command.ts";
 import { readDbxToolsConfig, repoRoot } from "../src/packages.ts";
 import {
   discoverRustCrates,
@@ -27,7 +27,7 @@ function rustConfig(): RustWorkspaceMapping | undefined {
 }
 
 function cargoAvailable(): boolean {
-  return spawnSync("cargo", ["--version"], { stdio: "ignore" }).status === 0;
+  return taskCommandSucceeds(repoRoot, "cargo", ["--version"]);
 }
 
 function currentStructure(config: RustWorkspaceMapping): RustWorkspaceMapping {
@@ -74,17 +74,12 @@ function generate(binding: RustBindingMapping): void {
       ? ["--python", binding.python, "--python-module", binding.pythonModule ?? ""]
       : []),
   ];
-  const result = spawnSync(
-    process.execPath,
-    [
-      resolve(dirname(fileURLToPath(import.meta.url)), "uniffi.ts"),
-      "--crate",
-      binding.crate,
-      ...targets,
-    ],
-    { cwd: repoRoot, stdio: "inherit" },
-  );
-  if (result.status !== 0) throw new Error(`binding generation exited with ${result.status}`);
+  runTaskCommand(repoRoot, process.execPath, [
+    resolve(dirname(fileURLToPath(import.meta.url)), "uniffi.ts"),
+    "--crate",
+    binding.crate,
+    ...targets,
+  ]);
 }
 
 function* iterateAffectedRustBindings(

package/tasks/uniffi-python.d.ts

@@ -20,13 +20,12 @@ export interface PythonProjectInfo {
 /** Read the project identity and publication flag from parsed TOML metadata. */
 export function pythonProjectInfo(source: string, toml: TomlCodec): PythonProjectInfo;
 
-/** Stamp a temporary publication version and exact sibling dependencies. */
-export function stampPythonProject(
+/** Project registry-compatible sibling requirements onto a temporary package copy. */
+export function preparePythonProjectForPublication(
   source: string,
   options: {
     readonly packages: readonly PythonPackageMapping[];
     readonly rewriteDependencies?: boolean;
-    readonly usePackageVersions?: boolean;
     readonly toml: TomlCodec;
     readonly version: string;
   },

package/tasks/uniffi-python.js

@@ -67,23 +67,18 @@ export const pythonProjectInfo = (source, toml) => {
   };
 };
 
-const compatibleRequirement = (version) => {
-  const [major, minor] = version.split(".").map(Number);
-  const upper = major === 0 ? `0.${minor + 1}.0` : `${major + 1}.0.0`;
-  return `>=${version},<${upper}`;
-};
-
-export const stampPythonProject = (
+export const preparePythonProjectForPublication = (
   source,
-  { packages, rewriteDependencies = true, usePackageVersions = false, toml, version },
+  { packages, rewriteDependencies = true, toml, version },
 ) => {
   const marker = source.startsWith("# ") ? source.slice(0, source.indexOf("\n")) : undefined;
   const document = toml.parse(source);
   const project = projectTable(document);
-  if (typeof project.version !== "string") {
-    throw new Error("Missing Python project version");
+  if (project.version !== version) {
+    throw new Error(
+      `Python project version ${String(project.version)} does not match release ${version}`,
+    );
   }
-  project.version = version;
   if (rewriteDependencies) {
     const dependencies = project.dependencies;
     if (dependencies !== undefined && !Array.isArray(dependencies)) {
@@ -95,15 +90,7 @@ export const stampPythonProject = (
           throw new Error("Python project dependencies must be strings");
         }
         const sibling = packages.find((candidate) => directSibling(dependency, candidate));
-        return sibling
-          ? `${sibling.name}${
-              usePackageVersions
-                ? sibling.uniffi
-                  ? `==${sibling.version}`
-                  : compatibleRequirement(sibling.version)
-                : `==${version}`
-            }`
-          : dependency;
+        return sibling ? `${sibling.name}==${version}` : dependency;
       });
     }
   }

package/tasks/uniffi-release.mjs

@@ -19,9 +19,9 @@ import { parseArgs } from "node:util";
 import { spawnSync } from "node:child_process";
 import {
   installPythonBindings,
+  preparePythonProjectForPublication,
   pythonBindingGeneratorArgs,
   pythonBindingGeneratorName,
-  stampPythonProject,
 } from "./uniffi-python.js";
 
 const require = createRequire(import.meta.url);
@@ -327,15 +327,14 @@ const packageNodeFacade = ({ output, nodeDirectory, nodePackage, version, native
   rmSync(resolve(output, "npm-facade"), { recursive: true, force: true });
   mkdirSync(output, { recursive: true });
   cpSync(resolve(root, nodeDirectory), facadeDirectory, { recursive: true });
+  rmSync(join(facadeDirectory, "dist"), { recursive: true, force: true });
   const barrel = join(facadeDirectory, "index.ts");
-  writable(barrel);
-  writeFileSync(
-    barrel,
-    readFileSync(barrel, "utf8").replace(
-      /^export const PACKAGE_VERSION = .*;$/m,
-      `export const PACKAGE_VERSION = ${JSON.stringify(version)};`,
-    ),
-  );
+  const barrelVersion = /^export const PACKAGE_VERSION = "([^"]+)";$/m.exec(
+    readFileSync(barrel, "utf8"),
+  )?.[1];
+  if (barrelVersion !== version) {
+    throw new Error(`Facade PACKAGE_VERSION ${String(barrelVersion)} does not match ${version}`);
+  }
   for (const file of readdirSync(join(facadeDirectory, "src"))) {
     if (/\.(dll|dylib|so)$/.test(file)) {
       rmSync(join(facadeDirectory, "src", file), { force: true });
@@ -358,11 +357,18 @@ const packageNodeFacade = ({ output, nodeDirectory, nodePackage, version, native
   const workspaceManifest = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
   const catalog = workspaceManifest.catalog ?? {};
   const workspaceVersions = localWorkspacePackages();
-  manifest.version = version;
-  manifest.private = false;
+  if (manifest.version !== version) {
+    throw new Error(`Facade package version ${String(manifest.version)} does not match ${version}`);
+  }
+  if (manifest.private === true) throw new Error(`${manifest.name} is private`);
   manifest.license = manifest.license === "UNLICENSED" ? "Apache-2.0" : manifest.license;
   manifest.optionalDependencies = Object.fromEntries(
-    Object.keys(manifest.optionalDependencies ?? {}).map((name) => [name, version]),
+    Object.entries(manifest.optionalDependencies ?? {}).map(([name, dependency]) => {
+      if (dependency !== version) {
+        throw new Error(`${manifest.name} optional dependency ${name} does not match ${version}`);
+      }
+      return [name, dependency];
+    }),
   );
   manifest.dependencies = Object.fromEntries(
     Object.entries(manifest.dependencies ?? {}).map(([name, dependency]) => [
@@ -435,7 +441,7 @@ const packagePython = ({
     [];
   writeFileSync(
     pyproject,
-    stampPythonProject(readFileSync(pyproject, "utf8"), {
+    preparePythonProjectForPublication(readFileSync(pyproject, "utf8"), {
       packages: workspaceBindings.flatMap((binding) =>
         binding.pythonPackage && binding.python
           ? [{ name: binding.pythonPackage, directory: binding.python }]

package/tasks/uniffi.ts

@@ -1,5 +1,4 @@
 #!/usr/bin/env -S bun
-import { spawnSync } from "node:child_process";
 import {
   cpSync,
   existsSync,
@@ -16,6 +15,7 @@ import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 import { installPythonBindings } from "./uniffi-python.js";
+import { captureTaskCommand, runLoggedTaskCommand } from "../src/_task-command.ts";
 import { makeReadonly, makeWritable, stampGenerated } from "../src/generated.ts";
 import type { RustWorkspaceMapping } from "../src/project-rs.ts";
 import {
@@ -62,31 +62,22 @@ const normalizedOutput = (value: string): string =>
     .replace(/[ \t]+$/gm, "")
     .trim();
 const run = (command: string, args: string[]) => {
-  const result = spawnSync(command, args, { cwd: root, encoding: "utf8" });
-  const stdout = normalizedOutput(result.stdout ?? "");
-  const stderr = normalizedOutput(result.stderr ?? "");
-  if (stdout) process.stdout.write(`${stdout}\n`);
-  if (stderr) process.stderr.write(`${stderr}\n`);
-  if (result.error) {
-    throw new Error(`${command} failed: ${result.error.message}`, { cause: result.error });
-  }
-  if (result.status !== 0) throw new Error(`${command} exited with ${result.status}`);
+  runLoggedTaskCommand(root, command, args, {
+    onLine: (line) => {
+      const normalized = normalizedOutput(line);
+      if (normalized) process.stdout.write(`${normalized}\n`);
+    },
+  });
 };
 
-const cargoMetadata = spawnSync("cargo", ["metadata", "--format-version", "1", "--no-deps"], {
-  cwd: root,
-  encoding: "utf8",
-});
-if (cargoMetadata.error) {
-  throw new Error(`cargo metadata failed: ${cargoMetadata.error.message}`, {
-    cause: cargoMetadata.error,
-  });
-}
-if (cargoMetadata.status !== 0) {
-  throw new Error(`cargo metadata exited with ${cargoMetadata.status}`);
-}
-const cargoTargetRoot = (JSON.parse(cargoMetadata.stdout) as { target_directory?: unknown })
-  .target_directory;
+const cargoTargetRoot = (
+  JSON.parse(
+    captureTaskCommand(root, "cargo", ["metadata", "--format-version", "1", "--no-deps"], {
+      check: true,
+      stderr: "inherit",
+    }),
+  ) as { target_directory?: unknown }
+).target_directory;
 if (typeof cargoTargetRoot !== "string" || !cargoTargetRoot) {
   throw new Error("cargo metadata returned no target_directory");
 }

package/tasks/version-check.ts

@@ -1,14 +1,13 @@
 #!/usr/bin/env -S bun
-/** Verify that every committed package version matches its owning release unit. */
+/** Verify that every committed package version matches the root VERSION file. */
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, join, relative } from "node:path";
-import * as exec from "@dbx-tools/core/exec";
+import { join } from "node:path";
 import * as projectUtils from "@dbx-tools/core/project-utils";
 import { find } from "@dbx-tools/path";
 import { json, log, object } from "@dbx-tools/shared-core";
 import { parse } from "smol-toml";
-import { recordedPackages, toPosix } from "../src/packages.ts";
-import type { ReleaseUnitGraph } from "../src/release-catalog.ts";
+import { captureTaskCommand } from "../src/_task-command.ts";
+import { recordedPackages } from "../src/packages.ts";
 import { readWorkspaceVersion } from "../src/workspace-version.ts";
 
 const logger = log.logger("projen:version-check");
@@ -25,90 +24,59 @@ function pythonVersion(path: string): string | undefined {
   return typeof manifest.project?.version === "string" ? manifest.project.version : undefined;
 }
 
-function cargoVersions(root: string): Array<{ name: string; version: string; path: string }> {
+function cargoVersions(root: string): Array<{ name: string; version: string }> {
   if (!existsSync(join(root, "Cargo.toml"))) return [];
   const locked = existsSync(join(root, "Cargo.lock"));
-  const result = exec.spawnSync(
-    "cargo",
-    ["metadata", ...(locked ? ["--locked"] : []), "--format-version", "1", "--no-deps"],
-    {
-      cwd: root,
-      stdout: "capture",
-      stderr: "inherit",
-      stdin: "ignore",
-      check: true,
-    },
+  const metadata = json.parseRecord(
+    captureTaskCommand(
+      root,
+      "cargo",
+      ["metadata", ...(locked ? ["--locked"] : []), "--format-version", "1", "--no-deps"],
+      { check: true, stderr: "inherit" },
+    ),
   );
-  const metadata = json.parseRecord(result.stdout ?? "");
   if (!Array.isArray(metadata?.packages)) return [];
   return metadata.packages.flatMap((candidate) => {
     if (
       !object.isRecord(candidate) ||
       typeof candidate.name !== "string" ||
-      typeof candidate.version !== "string" ||
-      typeof candidate.manifest_path !== "string"
+      typeof candidate.version !== "string"
     ) {
       return [];
     }
-    return [
-      {
-        name: candidate.name,
-        version: candidate.version,
-        path: toPosix(relative(root, dirname(candidate.manifest_path))) || ".",
-      },
-    ];
+    return [{ name: candidate.name, version: candidate.version }];
   });
 }
 
 function main(): void {
   const root = projectUtils.root() ?? process.cwd();
-  const fixedVersion = readWorkspaceVersion(root);
-  const graphPath = join(root, ".projen/release-units.json");
-  const graph = existsSync(graphPath)
-    ? (JSON.parse(readFileSync(graphPath, "utf8")) as ReleaseUnitGraph)
-    : undefined;
-  const units = new Map(graph?.units.map((unit) => [unit.id, unit.version]) ?? []);
-  const projects = new Map(graph?.projects.map((entry) => [entry.path, entry]) ?? []);
+  const version = readWorkspaceVersion(root);
   const mismatches: string[] = [];
-  const expected = (path: string): string | undefined => {
-    const releaseProject = projects.get(path);
-    if (releaseProject?.unit) return units.get(releaseProject.unit);
-    return graph?.mode === "independent" ? undefined : fixedVersion;
-  };
-  const check = (name: string, path: string, actual: string | undefined): void => {
-    const version = expected(path);
-    if (version !== undefined && actual !== version) {
-      mismatches.push(`${name}: ${actual ?? "missing"} != ${version}`);
-    }
+  const check = (name: string, actual: string | undefined): void => {
+    if (actual !== version) mismatches.push(`${name}: ${actual ?? "missing"} != ${version}`);
   };
 
-  check("package.json", ".", manifestVersion(join(root, "package.json")));
+  check("package.json", manifestVersion(join(root, "package.json")));
   for (const pkg of recordedPackages(root)) {
-    check(`${pkg.path}/package.json`, pkg.path, manifestVersion(join(pkg.dir, "package.json")));
+    check(`${pkg.path}/package.json`, manifestVersion(join(pkg.dir, "package.json")));
     const barrel = join(pkg.dir, "index.ts");
     if (existsSync(barrel)) {
       const actual = /export const PACKAGE_VERSION = "([^"]+)";/.exec(
         readFileSync(barrel, "utf8"),
       )?.[1];
-      check(`${pkg.path}/index.ts`, pkg.path, actual);
+      check(`${pkg.path}/index.ts`, actual);
     }
   }
 
   for (const path of find.findFiles("**/pyproject.toml", { cwd: root })) {
-    check(path, toPosix(dirname(path)), pythonVersion(join(root, path)));
-  }
-  for (const pkg of cargoVersions(root)) {
-    check(`Cargo package ${pkg.name}`, pkg.path, pkg.version);
+    check(path, pythonVersion(join(root, path)));
   }
+  for (const pkg of cargoVersions(root)) check(`Cargo package ${pkg.name}`, pkg.version);
 
   if (mismatches.length > 0) {
-    throw new Error(`Release-unit version mismatch:\n${mismatches.join("\n")}`);
+    throw new Error(`Workspace version mismatch:\n${mismatches.join("\n")}`);
   }
-  logger.success(
-    graph
-      ? `all package versions match ${graph.units.length} release units`
-      : `all workspace versions match ${fixedVersion}`,
-  );
+  logger.success(`all workspace package versions match ${version}`);
 }
 
 main();