@dbx-tools/projen 0.9.12 → 0.9.18

package/tasks/release-pr.ts

@@ -15,6 +15,7 @@ import * as projectUtils from "@dbx-tools/core/project-utils";
 import { asyncUtils, json, log, object } from "@dbx-tools/shared-core";
 import { Command } from "commander";
 import { publishLocalRelease } from "./local-publish.ts";
+import { hasLocalReleaseTargets, missingLocalReleaseTools } from "./release-assets.ts";
 import { generateReleaseSummary } from "./release-summary.ts";
 import {
   releaseArchitectureOption,
@@ -38,20 +39,57 @@ import {
   githubAccountSupportsWorkflowChanges,
   githubAuthenticatedAccounts,
   githubRepositoryApiPath,
+  githubRepositoryCanManage,
   githubRepositoryIdentity,
+  githubRepositoryPermissions,
   githubRepositorySpecifier,
   githubTokenArguments,
   githubTokenEnvironmentName,
 } from "../src/release-github.ts";
+import { withWorkspaceMutationLock } from "../src/workspace-lock.ts";
 import {
   readWorkspaceVersion,
   resolveBaseVersion,
   resolveNextVersion,
 } from "../src/workspace-version.ts";
-import { withWorkspaceMutationLock } from "../src/workspace-lock.ts";
 
 const logger = log.logger("projen:release");
 
+export type ReleaseBuildMode = "auto" | "local" | "remote";
+
+/** Resolve an explicit or environment-sensitive native release build mode. */
+export function resolveReleaseBuildMode(options: {
+  readonly requested: ReleaseBuildMode;
+  readonly canManage: boolean;
+  readonly localTools: readonly string[];
+  readonly hasLocalTargets: boolean;
+  readonly approve: boolean;
+  readonly wait: boolean;
+  readonly hostPlatform?: NodeJS.Platform;
+}): Exclude<ReleaseBuildMode, "auto"> {
+  const local =
+    options.canManage &&
+    options.hasLocalTargets &&
+    (options.hostPlatform ?? process.platform) === "darwin" &&
+    options.localTools.length === 0 &&
+    options.approve &&
+    options.wait;
+  if (options.requested === "auto") return local ? "local" : "remote";
+  if (options.requested === "remote") return "remote";
+  if (!options.canManage) throw new Error("--build local requires maintain or admin permission");
+  if (!options.hasLocalTargets) throw new Error("--build local requires Rust release targets");
+  if ((options.hostPlatform ?? process.platform) !== "darwin") {
+    throw new Error("--build local requires macOS");
+  }
+  if (options.localTools.length > 0) {
+    throw new Error(`--build local requires: ${options.localTools.join(", ")}`);
+  }
+  if (!options.approve || !options.wait) {
+    throw new Error("--build local requires automatic merge and waiting");
+  }
+  return "local";
+}
+
 function git(
   root: string,
   args: string[],
@@ -151,12 +189,27 @@ async function waitForReleaseWorkflow(
   });
 }
 
+async function waitForGitHubRelease(
+  root: string,
+  tag: string,
+  env: NodeJS.ProcessEnv,
+  timeoutMs: number,
+): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (taskCommandSucceeds(root, "gh", ["release", "view", tag], { env })) return;
+    await asyncUtils.sleep(2_000);
+  }
+  throw new Error(`GitHub Release ${tag} did not appear within ${timeoutMs}ms`);
+}
+
 function githubAccount(root: string): {
   hostname: string;
   owner: string;
   repository: string;
   login: string;
   token: string;
+  canManage: boolean;
 } {
   const repository = projectUtils.repositoryUrl(root);
   if (!repository) throw new Error("Release preparation requires a GitHub repository");
@@ -199,21 +252,20 @@ function githubAccount(root: string): {
     });
     const repositoryData =
       repositoryResult.exitCode === 0 ? json.parseRecord(repositoryResult.stdout ?? "") : undefined;
-    const permissions = object.isRecord(repositoryData?.permissions)
-      ? repositoryData.permissions
-      : undefined;
-    if (
-      permissions?.push !== true &&
-      permissions?.maintain !== true &&
-      permissions?.admin !== true
-    ) {
+    const permissions = githubRepositoryPermissions(repositoryData);
+    if (!permissions.push && !permissions.maintain && !permissions.admin) {
       continue;
     }
     logger.info("selected GitHub CLI account", {
       login: account.login,
       repository: `${identity.owner}/${identity.repository}`,
     });
-    return { ...identity, login: account.login, token };
+    return {
+      ...identity,
+      login: account.login,
+      token,
+      canManage: githubRepositoryCanManage(permissions),
+    };
   }
   const detected =
     accounts
@@ -271,6 +323,7 @@ program
   .option("--no-validate", "skip repository validation tasks, Rust tests, and TypeScript compile")
   .option("--no-local-publish", "skip local npm, PyPI, and Cargo publication")
   .option("--no-local-cargo", "skip local Cargo publication")
+  .option("--build <mode>", "native release build: auto, local, or remote", "auto")
   .option("--no-approve", "open the release pull request without enabling automatic merge")
   .option("--no-wait", "return after enabling automatic merge without watching publication")
   .option(
@@ -295,6 +348,7 @@ program
       validate: boolean;
       localPublish: boolean;
       localCargo: boolean;
+      build: ReleaseBuildMode;
       approve: boolean;
       wait: boolean;
       waitTimeoutMinutes: string;
@@ -316,6 +370,26 @@ program
         const currentBranch = git(root, ["branch", "--show-current"], { capture: true });
         if (!currentBranch) throw new Error("Release preparation requires a local branch");
         const account = githubAccount(root);
+        if (!["auto", "local", "remote"].includes(opts.build)) {
+          throw new Error("--build must be auto, local, or remote");
+        }
+        const inspectLocalTools =
+          opts.build === "local" || (opts.build === "auto" && account.canManage);
+        const localTools = inspectLocalTools ? missingLocalReleaseTools(root) : [];
+        const buildMode = resolveReleaseBuildMode({
+          requested: opts.build,
+          canManage: account.canManage,
+          localTools,
+          hasLocalTargets: hasLocalReleaseTargets(root),
+          approve: opts.approve,
+          wait: opts.wait,
+        });
+        logger.info("selected native release build", {
+          requested: opts.build,
+          resolved: buildMode,
+          manager: account.canManage,
+          ...(localTools.length > 0 ? { missing: localTools } : {}),
+        });
         git(root, ["fetch", "--tags", "origin", opts.base]);
         const comparisonBase = resolveBaseVersion(root, [opts.prefix], {
           fetch: false,
@@ -455,7 +529,13 @@ program
         git(releaseRoot, ["add", "-A"]);
         const staged = git(releaseRoot, ["diff", "--cached", "--name-only"], { capture: true });
         if (staged) {
-          git(releaseRoot, ["commit", "-m", `chore(release): ${next.version}`]);
+          git(releaseRoot, [
+            "commit",
+            "-m",
+            `chore(release): ${next.version}`,
+            "-m",
+            `Release-Build: ${buildMode}`,
+          ]);
         } else if (!worktreeExists) {
           throw new Error("Release preparation produced no changes");
         }
@@ -471,6 +551,8 @@ program
           `Source commit: ${git(releaseRoot, ["rev-parse", `${releaseBranch}^`], { capture: true })}`,
           "",
           "Merging this PR updates VERSION on main and starts the public release workflow.",
+          "",
+          `Native build: ${buildMode}.`,
           ...(releaseSummary ? ["", releaseSummary] : []),
         ].join("\n");
         const githubEnvironment = {
@@ -511,8 +593,6 @@ program
             env: githubEnvironment,
           });
         }
-        git(root, ["worktree", "remove", "--force", releaseRoot]);
-        git(root, ["branch", "--delete", "--force", releaseBranch]);
         if (opts.approve && opts.wait) {
           const mergeSha = await waitForPullRequestMerge(
             root,
@@ -521,10 +601,39 @@ program
             waitTimeoutMs,
           );
           logger.info("release pull request merged", { releaseBranch, mergeSha });
+          if (buildMode === "local") {
+            git(root, ["fetch", "origin", opts.base]);
+            git(releaseRoot, ["switch", "--detach", mergeSha]);
+            runTaskCommand(releaseRoot, process.execPath, ["install"]);
+            await waitForGitHubRelease(root, releaseTag, githubEnvironment, waitTimeoutMs);
+            const releaseAssetsScript = join(
+              releaseRoot,
+              "node_modules/@dbx-tools/projen/tasks/release-assets.ts",
+            );
+            runTaskCommand(
+              releaseRoot,
+              process.execPath,
+              [
+                releaseAssetsScript,
+                "--root",
+                releaseRoot,
+                "--version",
+                next.version,
+                "--tag",
+                releaseTag,
+                "--upload",
+              ],
+              { env: githubEnvironment },
+            );
+          }
+          git(root, ["worktree", "remove", "--force", releaseRoot]);
+          git(root, ["branch", "--delete", "--force", releaseBranch]);
           await waitForReleaseWorkflow(root, opts.base, mergeSha, githubEnvironment, waitTimeoutMs);
           logger.success(`published ${releaseTag} from ${mergeSha}`);
           return;
         }
+        git(root, ["worktree", "remove", "--force", releaseRoot]);
+        git(root, ["branch", "--delete", "--force", releaseBranch]);
         logger.success(
           `${
             opts.approve ? "enabled automatic merge for" : "opened"
@@ -534,4 +643,4 @@ program
     },
   );
 
-await program.parseAsync();
+if (import.meta.main) await program.parseAsync();

package/tasks/rust.ts

@@ -3,7 +3,7 @@ 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 } from "@dbx-tools/shared-core";
+import { log, object } from "@dbx-tools/shared-core";
 import { readDbxToolsConfig, repoRoot } from "../src/packages.ts";
 import {
   discoverRustCrates,
@@ -40,7 +40,7 @@ function currentStructure(config: RustWorkspaceMapping): RustWorkspaceMapping {
     const binding = recorded.get(rust);
     return binding ? [binding] : [{ crate: "", rust }];
   });
-  return { root: config.root, crates, bindings, binaries: config.binaries ?? [] };
+  return { ...config, crates, bindings };
 }
 
 /** Whether discovered crate membership or UniFFI marker membership changed. */
@@ -87,18 +87,47 @@ function generate(binding: RustBindingMapping): void {
   if (result.status !== 0) throw new Error(`binding generation exited with ${result.status}`);
 }
 
-export function affectedRustBindings(
+function* iterateAffectedRustBindings(
   bindings: readonly RustBindingMapping[],
   changed: ReadonlySet<string>,
-): RustBindingMapping[] {
+): Generator<RustBindingMapping> {
   const affected = new Set(changed);
-  const ordered = orderRustBindings(bindings);
-  for (const binding of ordered) {
+  for (const binding of orderRustBindings(bindings)) {
     if (binding.dependencies?.some((dependency) => affected.has(dependency))) {
       affected.add(binding.crate);
     }
+    if (affected.has(binding.crate)) yield binding;
   }
-  return ordered.filter((binding) => affected.has(binding.crate));
+}
+
+export function affectedRustBindings(
+  bindings: readonly RustBindingMapping[],
+  changed: ReadonlySet<string>,
+): RustBindingMapping[] {
+  return [...iterateAffectedRustBindings(bindings, changed)];
+}
+
+/**
+ * Lazily resolve direct binding owners so lock checks stop at the first match.
+ */
+export function changedRustOwners(
+  config: RustWorkspaceMapping,
+  changed: readonly string[],
+): object.Sequence<RustBindingMapping> {
+  return object
+    .sequence(changed)
+    .map((path) => ownerBinding(path, config.bindings))
+    .nonNull()
+    .distinct();
+}
+
+/** Collect direct owners, then lazily yield them and their dependents in order. */
+export function changedRustBindings(
+  config: RustWorkspaceMapping,
+  changed: readonly string[],
+): object.Sequence<RustBindingMapping> {
+  const targets = new Set(changedRustOwners(config, changed).map((binding) => binding.crate));
+  return object.sequence(iterateAffectedRustBindings(config.bindings, targets));
 }
 
 const config = rustConfig();
@@ -113,37 +142,37 @@ async function main(): Promise<void> {
     return;
   }
 
-  watchLoop("rust", [resolve(repoRoot, config.root)], (changed) => {
-    const latest = rustConfig() ?? config;
-    if (rustStructureChanged(latest)) {
-      logger.start("Rust project structure changed - re-synthesizing (+install)");
-      runSynth({ post: true });
-      logger.success("Rust project structure synchronized");
-      const refreshed = rustConfig();
-      if (!refreshed) return;
-      const targets = new Map<string, RustBindingMapping>();
-      for (const path of changed) {
-        const binding = ownerBinding(path, refreshed.bindings);
-        if (binding) targets.set(binding.crate, binding);
+  watchLoop(
+    "rust",
+    [resolve(repoRoot, config.root)],
+    (changed) => {
+      const latest = rustConfig() ?? config;
+      if (rustStructureChanged(latest)) {
+        logger.start("Rust project structure changed - re-synthesizing (+install)");
+        runSynth({ post: true });
+        logger.success("Rust project structure synchronized");
+        const refreshed = rustConfig();
+        if (!refreshed) return;
+        for (const binding of changedRustBindings(refreshed, changed)) {
+          logger.start(`generating ${binding.crate} bindings`);
+          generate(binding);
+          logger.success(`generated ${binding.crate} bindings`);
+        }
+        return;
       }
-      for (const binding of affectedRustBindings(refreshed.bindings, new Set(targets.keys()))) {
+      for (const binding of changedRustBindings(latest, changed)) {
         logger.start(`generating ${binding.crate} bindings`);
         generate(binding);
         logger.success(`generated ${binding.crate} bindings`);
       }
-      return;
-    }
-    const targets = new Map<string, RustBindingMapping>();
-    for (const path of changed) {
-      const binding = ownerBinding(path, latest.bindings);
-      if (binding) targets.set(binding.crate, binding);
-    }
-    for (const binding of affectedRustBindings(latest.bindings, new Set(targets.keys()))) {
-      logger.start(`generating ${binding.crate} bindings`);
-      generate(binding);
-      logger.success(`generated ${binding.crate} bindings`);
-    }
-  });
+    },
+    {
+      check: (changed) => {
+        const latest = rustConfig() ?? config;
+        return changedRustOwners(latest, changed).some(() => true) || rustStructureChanged(latest);
+      },
+    },
+  );
 }
 
 if (import.meta.main) await main();

package/tasks/uniffi-python.js

@@ -5,6 +5,7 @@ import {
   mkdirSync,
   mkdtempSync,
   readFileSync,
+  readdirSync,
   rmSync,
   writeFileSync,
 } from "node:fs";
@@ -130,6 +131,7 @@ export const installPythonBindings = ({
   module,
   packageRoot,
   platform,
+  generatedSource,
   readonly = false,
   run,
   targetDirectory,
@@ -137,20 +139,25 @@ export const installPythonBindings = ({
   const packageName = module.split(".").at(-1);
   if (!packageName) throw new Error(`Invalid Python module ${module}`);
   const packageDirectory = resolve(packageRoot, "src", ...module.split("."));
-  const generatedDirectory = mkdtempSync(join(tmpdir(), `${packageName}-python-`));
+  const generatedDirectory = generatedSource
+    ? undefined
+    : mkdtempSync(join(tmpdir(), `${packageName}-python-`));
   const generator = resolve(targetDirectory, pythonBindingGeneratorName(crate, platform));
-  if (!existsSync(generator)) throw new Error(`Missing UniFFI generator ${generator}`);
 
   try {
-    run(
-      generator,
-      pythonBindingGeneratorArgs({
-        crate,
-        library,
-        output: generatedDirectory,
-      }),
-    );
-    const generated = join(generatedDirectory, `${crate.replaceAll("-", "_")}.py`);
+    if (!generatedSource) {
+      if (!existsSync(generator)) throw new Error(`Missing UniFFI generator ${generator}`);
+      run(
+        generator,
+        pythonBindingGeneratorArgs({
+          crate,
+          library,
+          output: generatedDirectory,
+        }),
+      );
+    }
+    const generated =
+      generatedSource ?? join(generatedDirectory, `${crate.replaceAll("-", "_")}.py`);
     if (!existsSync(generated)) throw new Error(`Missing generated binding ${generated}`);
     mkdirSync(packageDirectory, { recursive: true });
 
@@ -162,6 +169,11 @@ export const installPythonBindings = ({
     setWritable(init);
     writeFileSync(init, `${generatedHeader(crate)}from .bindings import *\n`);
 
+    for (const candidate of readdirSync(packageDirectory)) {
+      if (/\.(?:dll|dylib|so)$/.test(candidate)) {
+        rmSync(join(packageDirectory, candidate), { force: true });
+      }
+    }
     const nativeLibrary = join(packageDirectory, basename(library));
     setWritable(nativeLibrary);
     cpSync(library, nativeLibrary);
@@ -174,6 +186,6 @@ export const installPythonBindings = ({
     rmSync(join(packageDirectory, "_generated"), { recursive: true, force: true });
     return { bindings, init, library: nativeLibrary };
   } finally {
-    rmSync(generatedDirectory, { recursive: true, force: true });
+    if (generatedDirectory) rmSync(generatedDirectory, { recursive: true, force: true });
   }
 };

package/tasks/uniffi-release.mjs

@@ -17,7 +17,12 @@ import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { parseArgs } from "node:util";
 import { spawnSync } from "node:child_process";
-import { installPythonBindings, stampPythonProject } from "./uniffi-python.js";
+import {
+  installPythonBindings,
+  pythonBindingGeneratorArgs,
+  pythonBindingGeneratorName,
+  stampPythonProject,
+} from "./uniffi-python.js";
 
 const require = createRequire(import.meta.url);
 const bundledToml = fileURLToPath(new URL("./smol-toml.cjs", import.meta.url));
@@ -34,7 +39,9 @@ const parsed = parseArgs({
     "native-package": { type: "string" },
     "python-package": { type: "string" },
     "python-module": { type: "string" },
+    "python-bindings": { type: "string" },
     "cargo-target": { type: "string" },
+    "generator-target": { type: "string" },
     "node-triple": { type: "string" },
     "python-tag": { type: "string" },
     os: { type: "string" },
@@ -227,7 +234,9 @@ const facadeDependency = (name, dependency, catalog, workspaceVersions) => {
   if (dependency.startsWith("workspace:")) {
     const version = workspaceVersions.get(name);
     if (!version) throw new Error(`Missing workspace version for ${name}`);
-    return dependency === "workspace:*" ? version : `${dependency.slice("workspace:".length)}${version}`;
+    return dependency === "workspace:*"
+      ? version
+      : `${dependency.slice("workspace:".length)}${version}`;
   }
   if (!dependency.startsWith("catalog:")) return dependency;
   const resolved = catalog[name];
@@ -412,8 +421,10 @@ const packagePython = ({
   pythonTag,
   version,
   cargoTarget,
+  generatorTarget,
   os,
   pythonModule,
+  pythonBindings,
 }) => {
   const pythonRoot = resolve(output, "python-root");
   cpSync(resolve(root, pythonDirectory), pythonRoot, { recursive: true });
@@ -440,8 +451,9 @@ const packagePython = ({
     module: pythonModule,
     packageRoot: pythonRoot,
     platform: os,
+    generatedSource: pythonBindings,
     run,
-    targetDirectory: resolve(cargoTargetRoot, cargoTarget, "release"),
+    targetDirectory: resolve(cargoTargetRoot, generatorTarget ?? cargoTarget, "release"),
   });
 
   const wheelDirectory = resolve(output, "python");
@@ -461,6 +473,25 @@ const packagePython = ({
   ]);
 };
 
+const generatePython = () => {
+  const crate = required("crate");
+  const cargoTarget = required("cargo-target");
+  const os = required("os");
+  const output = resolve(root, required("output"));
+  const generator = resolve(
+    cargoTargetRoot,
+    cargoTarget,
+    "release",
+    pythonBindingGeneratorName(crate, os),
+  );
+  const library = libraryPath(crate, cargoTarget, os);
+  if (!existsSync(generator)) throw new Error(`Missing UniFFI generator ${generator}`);
+  if (!existsSync(library)) throw new Error(`Missing native library ${library}`);
+  rmSync(output, { recursive: true, force: true });
+  mkdirSync(output, { recursive: true });
+  run(generator, pythonBindingGeneratorArgs({ crate, library, output }));
+};
+
 const build = () => {
   const crate = required("crate");
   const cargoTarget = required("cargo-target");
@@ -481,6 +512,8 @@ const build = () => {
       ...(existsSync(resolve(root, "Cargo.lock")) ? ["--locked"] : []),
       "--package",
       crate,
+      "--features",
+      "uniffi-bindgen",
       "--target",
       cargoTarget,
     ]);
@@ -513,14 +546,18 @@ const build = () => {
       pythonTag,
       version,
       cargoTarget,
+      generatorTarget: parsed.values["generator-target"],
       os,
       pythonModule: required("python-module"),
+      pythonBindings: parsed.values["python-bindings"],
     });
   }
 };
 
 if (parsed.positionals[0] === "build") {
   build();
+} else if (parsed.positionals[0] === "generate-python") {
+  generatePython();
 } else if (parsed.positionals[0] === "facade") {
   packageNodeFacade({
     output: resolve(root, required("output")),

package/tasks/uniffi.ts

@@ -119,6 +119,8 @@ if (!values["skip-build"]) {
     ...(existsSync(join(root, "Cargo.lock")) ? ["--locked"] : []),
     "--package",
     crate,
+    "--features",
+    "uniffi-bindgen",
     ...(values["cargo-target"] ? ["--target", values["cargo-target"]] : []),
   ]);
 }