@dbx-tools/projen 0.6.229 → 0.7.0

package/tasks/uniffi-python.js

@@ -54,16 +54,27 @@ export const pythonProjectInfo = (source, toml) => {
   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");
+  }
   const config = document?.tool?.["dbx-tools"];
   return {
     name: project.name,
+    version: project.version,
     private: Boolean(config && typeof config === "object" && config.private === true),
+    uniffi: Boolean(config && typeof config === "object" && config.uniffi === true),
   };
 };
 
+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 = (
   source,
-  { packages, rewriteDependencies = true, toml, version },
+  { packages, rewriteDependencies = true, usePackageVersions = false, toml, version },
 ) => {
   const marker = source.startsWith("# ") ? source.slice(0, source.indexOf("\n")) : undefined;
   const document = toml.parse(source);
@@ -83,7 +94,15 @@ export const stampPythonProject = (
           throw new Error("Python project dependencies must be strings");
         }
         const sibling = packages.find((candidate) => directSibling(dependency, candidate));
-        return sibling ? `${sibling.name}==${version}` : dependency;
+        return sibling
+          ? `${sibling.name}${
+              usePackageVersions
+                ? sibling.uniffi
+                  ? `==${sibling.version}`
+                  : compatibleRequirement(sibling.version)
+                : `==${version}`
+            }`
+          : dependency;
       });
     }
   }

package/tasks/uniffi-release.mjs

@@ -222,9 +222,13 @@ const testNodeFacade = ({
 };
 
 /** Resolve workspace and generated catalog protocols for a publishable facade. */
-const facadeDependency = (name, dependency, version, catalog) => {
+const facadeDependency = (name, dependency, catalog, workspaceVersions) => {
   if (typeof dependency !== "string") return dependency;
-  if (dependency.startsWith("workspace:")) return version;
+  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}`;
+  }
   if (!dependency.startsWith("catalog:")) return dependency;
   const resolved = catalog[name];
   if (!resolved) throw new Error(`Missing root catalog entry for ${name}`);
@@ -344,6 +348,7 @@ const packageNodeFacade = ({ output, nodeDirectory, nodePackage, version, native
   const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
   const workspaceManifest = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
   const catalog = workspaceManifest.catalog ?? {};
+  const workspaceVersions = localWorkspacePackages();
   manifest.version = version;
   manifest.private = false;
   manifest.license = manifest.license === "UNLICENSED" ? "Apache-2.0" : manifest.license;
@@ -353,7 +358,7 @@ const packageNodeFacade = ({ output, nodeDirectory, nodePackage, version, native
   manifest.dependencies = Object.fromEntries(
     Object.entries(manifest.dependencies ?? {}).map(([name, dependency]) => [
       name,
-      facadeDependency(name, dependency, version, catalog),
+      facadeDependency(name, dependency, catalog, workspaceVersions),
     ]),
   );
   writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);

package/tasks/version-check.ts

@@ -1,12 +1,13 @@
 #!/usr/bin/env -S bun
-/** Verify that every committed package version matches the workspace VERSION. */
+/** Verify that every committed package version matches its owning release unit. */
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join, relative } from "node:path";
 import { exec, project } from "@dbx-tools/core";
 import { find } from "@dbx-tools/path";
 import { json, log, object } from "@dbx-tools/shared-core";
 import { parse } from "smol-toml";
 import { recordedPackages } from "../src/packages.ts";
+import type { ReleaseUnitGraph } from "../src/release-catalog.ts";
 import { readWorkspaceVersion } from "../src/workspace-version.ts";
 
 const logger = log.logger("projen:version-check");
@@ -23,7 +24,7 @@ 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 }> {
+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(
@@ -43,43 +44,70 @@ function cargoVersions(root: string): Array<{ name: string; version: string }> {
     if (
       !object.isRecord(candidate) ||
       typeof candidate.name !== "string" ||
-      typeof candidate.version !== "string"
+      typeof candidate.version !== "string" ||
+      typeof candidate.manifest_path !== "string"
     ) {
       return [];
     }
-    return [{ name: candidate.name, version: candidate.version }];
+    return [
+      {
+        name: candidate.name,
+        version: candidate.version,
+        path: relative(root, dirname(candidate.manifest_path)).replaceAll("\\", "/") || ".",
+      },
+    ];
   });
 }
 
 function main(): void {
   const root = project.root() ?? process.cwd();
-  const version = readWorkspaceVersion(root);
+  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 mismatches: string[] = [];
-  const check = (name: string, actual: string | undefined): void => {
-    if (actual !== version) mismatches.push(`${name}: ${actual ?? "missing"} != ${version}`);
+  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}`);
+    }
   };
 
-  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`, manifestVersion(join(pkg.dir, "package.json")));
+    check(`${pkg.path}/package.json`, pkg.path, 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`, actual);
+      check(`${pkg.path}/index.ts`, pkg.path, actual);
     }
   }
 
   for (const path of find.findFiles("**/pyproject.toml", { cwd: root })) {
-    check(path, pythonVersion(join(root, path)));
+    check(path, dirname(path).replaceAll("\\", "/"), pythonVersion(join(root, path)));
+  }
+  for (const pkg of cargoVersions(root)) {
+    check(`Cargo package ${pkg.name}`, pkg.path, pkg.version);
   }
-  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")}`);
+    throw new Error(`Release-unit version mismatch:\n${mismatches.join("\n")}`);
   }
-  logger.success(`all workspace versions match ${version}`);
+  logger.success(
+    graph
+      ? `all package versions match ${graph.units.length} release units`
+      : `all workspace versions match ${fixedVersion}`,
+  );
 }
 
 main();