@dbx-tools/projen 0.9.19 → 0.9.28

package/tasks/python-registry.ts

@@ -1,8 +1,8 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
-import * as exec from "@dbx-tools/core/exec";
 import { net } from "@dbx-tools/shared-core";
+import { captureTaskCommand } from "../src/_task-command.ts";
 
 export interface LocalPythonRegistry {
   readonly indexUrl: string;
@@ -126,14 +126,7 @@ function splitIndexList(value: string | undefined): string[] {
 
 /** Read a `pip config get <key>`, treating pip's literal "undefined" as unset. */
 function pipConfig(key: string): string | undefined {
-  const res = exec.spawnSync("python", ["-m", "pip", "config", "get", key], {
-    cwd: process.cwd(),
-    stdout: "capture",
-    stderr: "ignore",
-    stdin: "ignore",
-    check: false,
-  });
-  const out = res.stdout?.trim();
+  const out = captureTaskCommand(process.cwd(), "python", ["-m", "pip", "config", "get", key]);
   return out && out !== "undefined" ? out : undefined;
 }
 

package/tasks/python-release.ts

@@ -0,0 +1,74 @@
+/** Shared Python release manifest parsing and dependency projection. */
+
+const projectTable = (document: unknown): Record<string, unknown> => {
+  const project = (document as { project?: unknown })?.project;
+  if (!project || typeof project !== "object" || Array.isArray(project)) {
+    throw new Error("Missing Python project metadata");
+  }
+  return project as Record<string, unknown>;
+};
+
+const directSibling = (
+  dependency: string,
+  sibling: { readonly directory: string; readonly name: string },
+): boolean => {
+  const prefix = `${sibling.name} @ git+`;
+  if (!dependency.startsWith(prefix)) return false;
+  const marker = "#subdirectory=";
+  const markerIndex = dependency.indexOf(marker, prefix.length);
+  if (markerIndex < 0) return false;
+  const directory = dependency.slice(markerIndex + marker.length);
+  return directory === sibling.directory || directory.endsWith(`/${sibling.directory}`);
+};
+
+export function pythonProjectInfo(
+  source: string,
+  toml: { parse(source: string): unknown },
+): { name: string; version: string; private: boolean } {
+  const document = toml.parse(source) as { tool?: { "dbx-tools"?: { private?: boolean } } };
+  const project = projectTable(document);
+  if (typeof project.name !== "string" || !project.name) {
+    throw new Error("Missing Python project name");
+  }
+  if (typeof project.version !== "string" || !project.version) {
+    throw new Error("Missing Python project version");
+  }
+  return {
+    name: project.name,
+    version: project.version,
+    private: document.tool?.["dbx-tools"]?.private === true,
+  };
+}
+
+export function preparePythonProjectForPublication(
+  source: string,
+  options: {
+    readonly packages: readonly { readonly directory: string; readonly name: string }[];
+    readonly toml: { parse(source: string): unknown; stringify(document: unknown): string };
+    readonly version: string;
+  },
+): string {
+  const marker = source.startsWith("# ") ? source.slice(0, source.indexOf("\n")) : undefined;
+  const document = options.toml.parse(source);
+  const project = projectTable(document);
+  if (project.version !== options.version) {
+    throw new Error(
+      `Python project version ${String(project.version)} does not match release ${options.version}`,
+    );
+  }
+  const dependencies = project.dependencies;
+  if (dependencies !== undefined && !Array.isArray(dependencies)) {
+    throw new Error("Python project dependencies must be an array");
+  }
+  if (dependencies) {
+    project.dependencies = dependencies.map((dependency) => {
+      if (typeof dependency !== "string") {
+        throw new Error("Python project dependencies must be strings");
+      }
+      const sibling = options.packages.find((candidate) => directSibling(dependency, candidate));
+      return sibling ? `${sibling.name}==${options.version}` : dependency;
+    });
+  }
+  const body = options.toml.stringify(document).trimEnd();
+  return `${marker ? `${marker}\n\n` : ""}${body}\n`;
+}

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/release.ts

@@ -0,0 +1,99 @@
+#!/usr/bin/env -S bun
+/** Run the configured release transaction. */
+import * as projectUtils from "@dbx-tools/core/project-utils";
+import { log } from "@dbx-tools/shared-core";
+import { Command } from "commander";
+import {
+  captureGitTaskCommand,
+  gitTaskCommandSucceeds,
+  runGitTaskCommand,
+  runTaskCommand,
+} from "../src/_task-command.ts";
+import { assertReleaseVersion } from "./release-version.ts";
+import { readWorkspaceVersion } from "../src/workspace-version.ts";
+
+const logger = log.logger("projen:release");
+
+export function runRelease(options: {
+  readonly root: string;
+  readonly branch: string;
+  readonly bump?: boolean;
+  readonly prefix: string;
+  readonly remote: string;
+}): string {
+  const { branch, prefix, remote, root } = options;
+  const currentBranch = captureGitTaskCommand(root, ["branch", "--show-current"], { check: true });
+  if (currentBranch !== branch) {
+    throw new Error(
+      `release must run on ${branch}, current branch is ${currentBranch || "detached"}`,
+    );
+  }
+
+  if (options.bump ?? true) {
+    const status = captureGitTaskCommand(
+      root,
+      ["status", "--porcelain=v1", "--untracked-files=all"],
+      { check: true },
+    );
+    if (status) {
+      throw new Error("release with automatic bump requires a clean working tree");
+    }
+    runTaskCommand(root, "bun", ["run", "bump"]);
+  }
+
+  const version = readWorkspaceVersion(root);
+  const tag = `${prefix}${version}`;
+  runGitTaskCommand(root, ["fetch", remote, branch, "--tags"]);
+  assertReleaseVersion(version, { root, prefixes: [prefix], assertNext: true });
+
+  if (gitTaskCommandSucceeds(root, ["rev-parse", "--verify", `refs/tags/${tag}`])) {
+    throw new Error(`release tag ${tag} already exists`);
+  }
+
+  runTaskCommand(root, "bun", ["run", "version:check"]);
+  const status = captureGitTaskCommand(
+    root,
+    ["status", "--porcelain=v1", "--untracked-files=all"],
+    { check: true },
+  );
+  if (status) {
+    if (gitTaskCommandSucceeds(root, ["diff", "--quiet", "HEAD", "--", "VERSION"])) {
+      throw new Error("release changes must include the local VERSION bump");
+    }
+    runGitTaskCommand(root, ["add", "--all"]);
+    runGitTaskCommand(root, ["commit", "-m", `chore(release): ${version}`]);
+  }
+
+  const remoteHead = captureGitTaskCommand(root, ["rev-parse", `${remote}/${branch}`], {
+    check: true,
+  });
+  const head = captureGitTaskCommand(root, ["rev-parse", "HEAD"], { check: true });
+  if (!gitTaskCommandSucceeds(root, ["merge-base", "--is-ancestor", remoteHead, head])) {
+    throw new Error(`${branch} must contain ${remote}/${branch} before release`);
+  }
+
+  runGitTaskCommand(root, ["push", remote, `HEAD:${branch}`]);
+  runGitTaskCommand(root, ["tag", "--annotate", tag, "--message", tag]);
+  runGitTaskCommand(root, ["push", remote, `refs/tags/${tag}`]);
+  logger.success(`released ${tag}`, { sha: head });
+  return tag;
+}
+
+if (import.meta.main) {
+  new Command()
+    .option("--root <path>", "repository root")
+    .option("--branch <name>", "release branch", "main")
+    .option("--prefix <prefix>", "release tag prefix", "v")
+    .option("--remote <name>", "git remote", "origin")
+    .option("--no-bump", "use an existing synchronized local version bump")
+    .action((options: { root?: string; branch: string; bump: boolean; prefix: string; remote: string }) => {
+      runRelease({
+        root: options.root ?? projectUtils.root() ?? process.cwd(),
+        branch: options.branch,
+        bump: options.bump,
+        prefix: options.prefix,
+        remote: options.remote,
+      });
+    })
+    .parse();
+}

package/tasks/sync.ts

@@ -2,7 +2,7 @@
 import { fileURLToPath } from "node:url";
 import { log } from "@dbx-tools/shared-core";
 import concurrently from "concurrently";
-import { readDbxToolsConfig, repoRoot } from "../src/packages.ts";
+import { pythonNodeBindingProjects, repoRoot } from "../src/packages.ts";
 import { runSynth } from "../src/scaffold.ts";
 import { withWorkspaceMutationLock } from "../src/workspace-lock.ts";
 
@@ -26,14 +26,13 @@ function taskPath(script: string): string {
   return fileURLToPath(new URL(`./${script}`, import.meta.url));
 }
 
-/** Whether synth recorded at least one Rust crate for the focused watcher. */
-function hasRustProjects(): boolean {
-  const rust = readDbxToolsConfig(repoRoot)?.rust;
-  if (!rust || typeof rust !== "object" || Array.isArray(rust)) return false;
-  return (
-    Array.isArray((rust as { crates?: unknown }).crates) &&
-    (rust as { crates: unknown[] }).crates.length > 0
-  );
+/** One restartable focused watcher managed by the sync supervisor. */
+function watcher(script: string, name: string, prefixColor: string, ...args: string[]) {
+  return {
+    command: ["bun", JSON.stringify(taskPath(script)), ...args].join(" "),
+    name,
+    prefixColor,
+  };
 }
 
 if (!process.argv.includes("--watch")) {
@@ -65,16 +64,12 @@ if (!process.argv.includes("--watch")) {
   }
 
   const watchers = [
-    { command: `bun "${taskPath("projenrc.ts")}"`, name: "projenrc", prefixColor: "magenta" },
-    { command: `bun "${taskPath("barrels.ts")}" --watch`, name: "barrels", prefixColor: "cyan" },
-    { command: `bun "${taskPath("openapi.ts")}" --watch`, name: "openapi", prefixColor: "green" },
+    watcher("projenrc.ts", "projenrc", "magenta"),
+    watcher("barrels.ts", "barrels", "cyan", "--watch"),
+    watcher("openapi.ts", "openapi", "green", "--watch"),
   ];
-  if (hasRustProjects()) {
-    watchers.push({
-      command: `bun "${taskPath("rust.ts")}" --watch`,
-      name: "rust",
-      prefixColor: "yellow",
-    });
+  if (pythonNodeBindingProjects(repoRoot).length > 0) {
+    watchers.push(watcher("python-node-bindings-watch.ts", "node-bindings", "blue"));
   }
   const { result } = concurrently(watchers, {
     prefix: "name",

package/tasks/version-check.ts

@@ -1,14 +1,12 @@
 #!/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 { json, log } 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 { recordedPackages } from "../src/packages.ts";
 import { readWorkspaceVersion } from "../src/workspace-version.ts";
 
 const logger = log.logger("projen:version-check");
@@ -25,90 +23,33 @@ 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 }> {
-  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(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"
-    ) {
-      return [];
-    }
-    return [
-      {
-        name: candidate.name,
-        version: candidate.version,
-        path: toPosix(relative(root, dirname(candidate.manifest_path))) || ".",
-      },
-    ];
-  });
-}
-
 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)));
   }
-
   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();