@dbx-tools/projen 0.9.21 → 0.9.29

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.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

@@ -4,9 +4,8 @@ import { existsSync, readFileSync } from "node:fs";
 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 { captureTaskCommand } from "../src/_task-command.ts";
 import { recordedPackages } from "../src/packages.ts";
 import { readWorkspaceVersion } from "../src/workspace-version.ts";
 
@@ -24,30 +23,6 @@ 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 }> {
-  if (!existsSync(join(root, "Cargo.toml"))) return [];
-  const locked = existsSync(join(root, "Cargo.lock"));
-  const metadata = json.parseRecord(
-    captureTaskCommand(
-      root,
-      "cargo",
-      ["metadata", ...(locked ? ["--locked"] : []), "--format-version", "1", "--no-deps"],
-      { check: true, stderr: "inherit" },
-    ),
-  );
-  if (!Array.isArray(metadata?.packages)) return [];
-  return metadata.packages.flatMap((candidate) => {
-    if (
-      !object.isRecord(candidate) ||
-      typeof candidate.name !== "string" ||
-      typeof candidate.version !== "string"
-    ) {
-      return [];
-    }
-    return [{ name: candidate.name, version: candidate.version }];
-  });
-}
-
 function main(): void {
   const root = projectUtils.root() ?? process.cwd();
   const version = readWorkspaceVersion(root);
@@ -71,8 +46,6 @@ function main(): void {
   for (const path of find.findFiles("**/pyproject.toml", { cwd: root })) {
     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(`Workspace version mismatch:\n${mismatches.join("\n")}`);
   }

package/src/_release-platform.ts

@@ -1,78 +0,0 @@
-import { Option } from "commander";
-import type { VersionLevel } from "./workspace-version.ts";
-
-/** Supported semantic version increments for release commands. */
-export const RELEASE_LEVELS = [
-  "patch",
-  "minor",
-  "major",
-] as const satisfies readonly VersionLevel[];
-
-/** Supported release operating systems. */
-export const RELEASE_OSES = ["darwin", "linux", "win32"] as const;
-
-/** Supported release CPU architectures. */
-export const RELEASE_ARCHES = ["arm64", "x64"] as const;
-
-/** Release operating system selector. */
-export type ReleaseOs = (typeof RELEASE_OSES)[number];
-
-/** Release CPU architecture selector. */
-export type ReleaseArch = (typeof RELEASE_ARCHES)[number];
-
-export type { VersionLevel } from "./workspace-version.ts";
-
-/** Stable archive name for one native release binary. */
-export function releaseBinaryAssetName(
-  binaryName: string,
-  nodeTarget: string,
-  operatingSystem: ReleaseOs,
-): string {
-  const extension = operatingSystem === "win32" ? "zip" : "tar.gz";
-  return `${binaryName}-${nodeTarget}.${extension}`;
-}
-
-function collectValue<T extends string>(value: T, previous: T[]): T[] {
-  return [...previous, value];
-}
-
-/** Commander option for selecting the semantic release increment. */
-export function releaseLevelOption(): Option {
-  return new Option("-l, --level <level>", "semver increment")
-    .choices([...RELEASE_LEVELS])
-    .default("patch");
-}
-
-/** Repeatable Commander option for release operating systems. */
-export function releaseOperatingSystemOption(): Option {
-  return new Option("--os <os>", "release operating system, repeatable; crossed with every --arch")
-    .choices([...RELEASE_OSES])
-    .argParser((value, previous: ReleaseOs[]) => collectValue(value as ReleaseOs, previous))
-    .default([] as ReleaseOs[]);
-}
-
-/** Repeatable Commander option for release CPU architectures. */
-export function releaseArchitectureOption(): Option {
-  return new Option(
-    "--arch <arch>",
-    "release CPU architecture, repeatable; crossed with every --os",
-  )
-    .choices([...RELEASE_ARCHES])
-    .argParser((value, previous: ReleaseArch[]) => collectValue(value as ReleaseArch, previous))
-    .default([] as ReleaseArch[]);
-}
-
-/** Cartesian-product release target filter shared by release commands. */
-export function releasePlatformFilter(
-  operatingSystems: readonly string[],
-  architectures: readonly string[],
-): string {
-  if ((operatingSystems.length === 0) !== (architectures.length === 0)) {
-    throw new Error("--os and --arch must be used together");
-  }
-  return operatingSystems
-    .flatMap((operatingSystem) =>
-      architectures.map((architecture) => `${operatingSystem}:${architecture}`),
-    )
-    .join(",");
-}