@fuman/build 0.0.8 → 0.0.11

package/cli/commands/bump-version.js

@@ -17,7 +17,11 @@ function formatBumpVersionResult(result, withReleaseType) {
   lines.push("");
   lines.push("list of changed packages:");
   for (const { package: pkg, because, prevVersion } of result.changedPackages) {
-    lines.push(`  ${pkg.json.name}${because ? ` (because of ${because.join(", ")})` : ""}: ${prevVersion} → ${pkg.json.version}`);
+    let versionStr = prevVersion;
+    if (!pkg.json.fuman?.ownVersioning) {
+      versionStr += ` → ${pkg.json.version}`;
+    }
+    lines.push(`  ${pkg.json.name}${because ? ` (because of ${because.join(", ")})` : ""}: ${versionStr}`);
   }
   return lines.join("\n");
 }

package/cli/commands/release.js

@@ -7,7 +7,7 @@ import { createGithubRelease } from "../../git/github.js";
 import { getLatestTag, getFirstCommit, gitTagExists } from "../../git/utils.js";
 import { jsrCreatePackages } from "../../jsr/create-packages.js";
 import { generateDenoWorkspace } from "../../jsr/generate-workspace.js";
-import { exec } from "../../misc/exec.js";
+import { exec, ExecError } from "../../misc/exec.js";
 import { collectPackageJsons } from "../../package-json/collect-package-jsons.js";
 import { bumpVersion } from "../../versioning/bump-version.js";
 import { generateChangelog } from "../../versioning/generate-changelog.js";
@@ -187,6 +187,7 @@ const releaseCli = bc.command({
     if (args.dryRun) {
       console.log("dry run, skipping release commit and tag");
     } else {
+      await config?.versioning?.beforeReleaseCommit?.(workspaceWithRoot);
       let message = `chore(release): ${tagName}`;
       if (!args.withGithubRelease) {
         message += `
@@ -217,11 +218,19 @@ ${changelog}`;
             stdio: "inherit",
             throwOnError: true
           });
-          await exec(["git", "push", origin, "--force", "--tags"], {
-            cwd: root,
-            stdio: "inherit",
-            throwOnError: true
-          });
+          try {
+            await exec(["git", "push", origin, "--force", "--tags"], {
+              cwd: root,
+              throwOnError: true
+            });
+          } catch (e) {
+            if (!(e instanceof ExecError)) throw e;
+            if (e.result.stderr.includes(`cannot lock ref 'refs/tags/${tagName}': reference already exists`)) {
+              console.log(`❗ tag ${tagName} already exists on ${origin}, skipping`);
+            } else {
+              throw e;
+            }
+          }
         }
       }
     }

package/cli/commands/validate-workspace-deps.d.ts

@@ -32,13 +32,19 @@ export declare function validateWorkspaceDeps(params: {
      * @default true
      */
     skipWorkspaceDeps?: boolean;
+    /** whether to skip validating peer dependencies */
+    skipPeerDeps?: boolean;
 }): Promise<WorkspaceDepsError[]>;
 export declare const validateWorkspaceDepsCli: bc.Command<{
     includeRoot: boolean;
     noSkipWorkspaceDeps: boolean | undefined;
     root: string | undefined;
+    withErrorCode: boolean | undefined;
+    skipPeerDeps: boolean | undefined;
 }, {
     includeRoot: boolean;
     noSkipWorkspaceDeps: boolean | undefined;
     root: string | undefined;
+    withErrorCode: boolean | undefined;
+    skipPeerDeps: boolean | undefined;
 }>;

package/cli/commands/validate-workspace-deps.js

@@ -6,7 +6,8 @@ async function validateWorkspaceDeps(params) {
   const {
     workspaceRoot,
     includeRoot = true,
-    skipWorkspaceDeps = true
+    skipWorkspaceDeps = true,
+    skipPeerDeps = true
   } = params;
   const pjs = await collectPackageJsons(workspaceRoot, includeRoot);
   const workspacePackages = new Set(skipWorkspaceDeps ? pjs.map((pj) => pj.json.name) : []);
@@ -19,6 +20,7 @@ async function validateWorkspaceDeps(params) {
     for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
       const deps = pj[field];
       if (!deps) continue;
+      if (field === "peerDependencies" && skipPeerDeps) continue;
       for (const [name, version] of Object.entries(deps)) {
         if (workspacePackages.has(name)) continue;
         if (version.startsWith("workspace:")) continue;
@@ -26,7 +28,13 @@ async function validateWorkspaceDeps(params) {
           versions[name] = {};
         }
         for (const [pkgName, pkgDepVersions] of Object.entries(versions[name])) {
-          if (!satisfies(version, pkgDepVersions)) {
+          let ok = true;
+          if (pkgDepVersions.match(/^(?:https?:\/\/|catalog:)/)) {
+            ok = version === pkgDepVersions;
+          } else {
+            ok = satisfies(version, pkgDepVersions);
+          }
+          if (!ok) {
             errors.push({
               package: pj.name,
               dependency: name,
@@ -49,19 +57,25 @@ const validateWorkspaceDepsCli = bc.command({
   options: {
     includeRoot: bc.boolean("include-root").desc("whether to also validate the root package.json").default(false),
     noSkipWorkspaceDeps: bc.boolean("no-skip-workspace-deps").desc("whether to not skip validating dependencies of other workspace packages"),
-    root: bc.string().desc("path to the root of the workspace (default: cwd)")
+    root: bc.string().desc("path to the root of the workspace (default: cwd)"),
+    withErrorCode: bc.boolean("with-error-code").desc("whether to exit with a non-zero code if there are mismatches"),
+    skipPeerDeps: bc.boolean("skip-peer-deps").desc("whether to skip validating peer dependencies")
   },
   handler: async (args) => {
     const errors = await validateWorkspaceDeps({
       workspaceRoot: args.root ?? process.cwd(),
       includeRoot: args.includeRoot,
-      skipWorkspaceDeps: !args.noSkipWorkspaceDeps
+      skipWorkspaceDeps: !args.noSkipWorkspaceDeps,
+      skipPeerDeps: args.skipPeerDeps
     });
     if (errors.length > 0) {
       console.error("⚠️ Found external dependencies mismatch:");
       for (const error of errors) {
         console.error(`  - at ${error.package}: ${error.at} has ${error.dependency}@${error.version}, but ${error.otherPackage} has @${error.otherVersion}`);
       }
+      if (args.withErrorCode) {
+        process.exit(1);
+      }
     } else {
       console.log("✅ All external dependencies match!");
     }

package/index.js

@@ -4,20 +4,21 @@ import { generateDocs } from "./cli/commands/docs.js";
 import { generateDepsGraph } from "./cli/commands/gen-deps-graph.js";
 import { validateWorkspaceDeps } from "./cli/commands/validate-workspace-deps.js";
 import { findChangedFiles, getCommitsBetween, getCurrentBranch, getCurrentCommit, getFirstCommit, getLatestTag, gitTagExists, parseConventionalCommit } from "./git/utils.js";
-import { exec } from "./misc/exec.js";
+import { ExecError, exec } from "./misc/exec.js";
 import { normalizeFilePath } from "./misc/path.js";
 import { determinePublishOrder, sortWorkspaceByPublishOrder } from "./misc/publish-order.js";
 import { getTsconfigFiles, getTsconfigFor } from "./misc/tsconfig.js";
 import { NPM_PACKAGE_NAME_REGEX, npmCheckVersion } from "./npm/npm-api.js";
 import { collectPackageJsons, filterPackageJsonsForPublish } from "./package-json/collect-package-jsons.js";
 import { findPackageJson } from "./package-json/find-package-json.js";
-import { parsePackageJson, parsePackageJsonFile, parseWorkspaceRootPackageJson } from "./package-json/parse.js";
+import { parsePackageJson, parsePackageJsonFile, parsePackageJsonFromDir, parseWorkspaceRootPackageJson } from "./package-json/parse.js";
 import { processPackageJson } from "./package-json/process-package-json.js";
 import { PackageJsonSchema } from "./package-json/types.js";
 import { bumpVersion } from "./versioning/bump-version.js";
 import { findProjectChangedFiles, findProjectChangedPackages } from "./versioning/collect-files.js";
 import { generateChangelog } from "./versioning/generate-changelog.js";
 export {
+  ExecError,
   NPM_PACKAGE_NAME_REGEX,
   PackageJsonSchema,
   buildPackage,
@@ -48,6 +49,7 @@ export {
   parseConventionalCommit,
   parsePackageJson,
   parsePackageJsonFile,
+  parsePackageJsonFromDir,
   parseWorkspaceRootPackageJson,
   processPackageJson,
   sortWorkspaceByPublishOrder,

package/misc/exec.d.ts

@@ -8,12 +8,17 @@ export interface ExecResult {
     /** exit code of the command */
     exitCode: number;
 }
+export declare class ExecError extends Error {
+    readonly cmd: string[];
+    readonly result: ExecResult;
+    constructor(cmd: string[], result: ExecResult);
+}
 /**
  * execute a command and return its result
  *
  * **differences from node's `child_process.exec()`**:
  * - if `options.stdio` is set to `'inherit'`, the command will be printed to the console (unless `options.quiet` is set to `true`)
- * - on non-zero exit code, the promise will be rejected with an error if `options.throwOnError` is set to `true`
+ * - on non-zero exit code, the promise will be rejected with an {@link ExecError} if `options.throwOnError` is set to `true`
  *
  * @param cmd  command to execute (first element is the command itself, the rest are arguments to it)
  */

package/misc/exec.js

@@ -2,6 +2,15 @@ import path__default from "node:path";
 import process from "node:process";
 import { spawn } from "cross-spawn";
 import { normalizeFilePath } from "./path.js";
+class ExecError extends Error {
+  constructor(cmd, result) {
+    super(`Command exited with code ${result.exitCode}`, {
+      cause: result
+    });
+    this.cmd = cmd;
+    this.result = result;
+  }
+}
 function exec(cmd, options) {
   return new Promise((resolve, reject) => {
     if (options?.stdio === "inherit" && !options.quiet) {
@@ -29,12 +38,10 @@ function exec(cmd, options) {
     proc.on("error", reject);
     proc.on("close", (code) => {
       if (code !== 0 && options?.throwOnError) {
-        reject(new Error(`Command exited with code ${code}`, {
-          cause: {
-            stderr: Buffer.concat(stderr).toString(),
-            exitCode: code,
-            cmd
-          }
+        reject(new ExecError(cmd, {
+          stdout: Buffer.concat(stdout).toString(),
+          stderr: Buffer.concat(stderr).toString(),
+          exitCode: code ?? -1
         }));
       }
       resolve({
@@ -46,5 +53,6 @@ function exec(cmd, options) {
   });
 }
 export {
+  ExecError,
   exec
 };

package/package-json/collect-package-jsons.d.ts

@@ -3,6 +3,8 @@ import { PackageJson } from './types.js';
 export interface WorkspacePackage {
     /** path to the package root */
     path: string;
+    /** path to the package.json file (note that it might not be a .json file) */
+    packageJsonPath: string;
     /** whether this is the root package */
     root: boolean;
     /** package.json of the package */

package/package-json/collect-package-jsons.js

@@ -2,12 +2,12 @@ import * as path from "node:path";
 import process from "node:process";
 import { glob } from "tinyglobby";
 import { normalizeFilePath } from "../misc/path.js";
-import { parseWorkspaceRootPackageJson, parsePackageJsonFile } from "./parse.js";
+import { parseWorkspaceRootPackageJson, parsePackageJsonFromDir } from "./parse.js";
 const maxDepth = process.env.FUMAN_BUILD_MAX_DEPTH !== void 0 ? Number(process.env.FUMAN_BUILD_MAX_DEPTH) : 5;
 async function collectPackageJsons(workspaceRoot, includeRoot = false) {
   workspaceRoot = normalizeFilePath(workspaceRoot);
   const packageJsons = [];
-  const rootPackageJson = await parseWorkspaceRootPackageJson(workspaceRoot);
+  const { path: rootPackageJsonPath, json: rootPackageJson } = await parseWorkspaceRootPackageJson(workspaceRoot);
   if (!rootPackageJson.workspaces) {
     throw new Error("No workspaces found in package.json");
   }
@@ -15,7 +15,8 @@ async function collectPackageJsons(workspaceRoot, includeRoot = false) {
     packageJsons.push({
       path: workspaceRoot,
       root: true,
-      json: rootPackageJson
+      json: rootPackageJson,
+      packageJsonPath: rootPackageJsonPath
     });
   }
   for (const dir of await glob({
@@ -26,14 +27,15 @@ async function collectPackageJsons(workspaceRoot, includeRoot = false) {
     deep: maxDepth
   })) {
     try {
-      const packageJson = await parsePackageJsonFile(path.join(workspaceRoot, dir, "package.json"));
+      const { json, path: packageJsonPath } = await parsePackageJsonFromDir(path.join(workspaceRoot, dir));
       packageJsons.push({
         path: path.join(workspaceRoot, dir),
         root: false,
-        json: packageJson
+        packageJsonPath,
+        json
       });
     } catch (err) {
-      if (err.code === "ENOENT") ;
+      if (err.code === "ENOENT" || err.cause?.notFound === true) ;
       else {
         throw err;
       }

package/package-json/parse.d.ts

@@ -1,7 +1,14 @@
 import { PackageJson } from './types.js';
 /** parse a package.json from string */
-export declare function parsePackageJson(packageJson: string): PackageJson;
+export declare function parsePackageJson(packageJson: string, format?: 'json' | 'yaml'): PackageJson;
 /** parse a package.json file */
 export declare function parsePackageJsonFile(packageJsonPath: string | URL): Promise<PackageJson>;
+export declare function parsePackageJsonFromDir(dir: string | URL): Promise<{
+    path: string;
+    json: PackageJson;
+}>;
 /** parse the package.json file at the root of the workspace */
-export declare function parseWorkspaceRootPackageJson(workspaceRoot: string | URL): Promise<PackageJson>;
+export declare function parseWorkspaceRootPackageJson(workspaceRoot: string | URL): Promise<{
+    path: string;
+    json: PackageJson;
+}>;

package/package-json/parse.js

@@ -1,18 +1,58 @@
 import * as fsp from "node:fs/promises";
-import path__default from "node:path";
+import path__default, { extname } from "node:path";
 import * as jsyaml from "js-yaml";
+import * as json5_ from "json5";
+import { fileExists } from "../misc/fs.js";
 import { normalizeFilePath } from "../misc/path.js";
 import { PackageJsonSchema } from "./types.js";
-function parsePackageJson(packageJson) {
-  return PackageJsonSchema.parse(JSON.parse(packageJson));
+let json5 = json5_;
+if ("default" in json5_) {
+  json5 = json5_.default;
+}
+function parsePackageJson(packageJson, format = "json") {
+  let obj;
+  if (format === "json") {
+    obj = json5.parse(packageJson);
+  } else {
+    obj = jsyaml.load(packageJson);
+  }
+  return PackageJsonSchema.parse(obj);
 }
 async function parsePackageJsonFile(packageJsonPath) {
-  return parsePackageJson(await fsp.readFile(normalizeFilePath(packageJsonPath), "utf8"));
+  const path2 = normalizeFilePath(packageJsonPath);
+  const ext = extname(path2).slice(1);
+  let format;
+  if (ext === "json5" || ext === "jsonc" || ext === "json") format = "json";
+  else if (ext === "yml" || ext === "yaml") format = "yaml";
+  else throw new Error(`Unknown package.json extension: ${ext}`);
+  try {
+    return parsePackageJson(await fsp.readFile(normalizeFilePath(packageJsonPath), "utf8"), format);
+  } catch (err) {
+    throw new Error(`Could not parse package.json at ${packageJsonPath}`, { cause: err });
+  }
+}
+const EXT_OPTIONS = ["json", "json5", "jsonc", "yml", "yaml"];
+async function parsePackageJsonFromDir(dir) {
+  dir = normalizeFilePath(dir);
+  let packageJsonPath;
+  for (const ext of EXT_OPTIONS) {
+    const tmp = path__default.join(dir, `package.${ext}`);
+    if (await fileExists(tmp)) {
+      packageJsonPath = tmp;
+      break;
+    }
+  }
+  if (packageJsonPath == null) {
+    throw new Error(`Could not find package.json at ${dir}`, { cause: { notFound: true } });
+  }
+  return {
+    path: packageJsonPath,
+    json: await parsePackageJsonFile(packageJsonPath)
+  };
 }
 async function parseWorkspaceRootPackageJson(workspaceRoot) {
   workspaceRoot = normalizeFilePath(workspaceRoot);
-  const packageJsonPath = path__default.join(workspaceRoot, "package.json");
-  const parsed = await parsePackageJsonFile(packageJsonPath);
+  const { path: pjPath, json: parsed } = await parsePackageJsonFromDir(workspaceRoot);
   if (!parsed.workspaces) {
     const pnpmWorkspacePath = path__default.join(workspaceRoot, "pnpm-workspace.yaml");
     let yaml;
@@ -20,7 +60,7 @@ async function parseWorkspaceRootPackageJson(workspaceRoot) {
       yaml = await fsp.readFile(pnpmWorkspacePath, "utf8");
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
-      return parsed;
+      return { path: pjPath, json: parsed };
     }
     const workspace = jsyaml.load(yaml);
     if (!workspace.packages) {
@@ -40,10 +80,11 @@ async function parseWorkspaceRootPackageJson(workspaceRoot) {
     }
     parsed.workspaces = workspace.packages;
   }
-  return parsed;
+  return { path: pjPath, json: parsed };
 }
 export {
   parsePackageJson,
   parsePackageJsonFile,
+  parsePackageJsonFromDir,
   parseWorkspaceRootPackageJson
 };

package/package-json/types.js

@@ -34,7 +34,7 @@ const PackageJsonSchema = z.object({
   engines: z.record(z.string()),
   pnpm: z.object({
     overrides: z.record(z.string())
-  }),
+  }).partial(),
   fuman: z.object({
     jsr: z.union([
       z.literal("skip"),

package/package.json

@@ -1,19 +1,20 @@
 {
     "name": "@fuman/build",
     "type": "module",
-    "version": "0.0.8",
+    "version": "0.0.11",
     "description": "utils for building packages and managing monorepos",
     "license": "MIT",
     "scripts": {},
     "dependencies": {
         "@drizzle-team/brocli": "^0.10.2",
-        "@fuman/fetch": "^0.0.8",
-        "@fuman/io": "^0.0.8",
-        "@fuman/node": "^0.0.8",
-        "@fuman/utils": "^0.0.4",
+        "@fuman/fetch": "^0.0.11",
+        "@fuman/io": "^0.0.11",
+        "@fuman/node": "^0.0.11",
+        "@fuman/utils": "^0.0.11",
         "cross-spawn": "^7.0.5",
         "detect-indent": "^7.0.1",
         "js-yaml": "^4.1.0",
+        "json5": "^2.2.3",
         "picomatch": "^4.0.2",
         "semver": "^7.6.3",
         "tinyglobby": "^0.2.6",

package/versioning/types.d.ts

@@ -1,5 +1,6 @@
 import { MaybePromise } from '@fuman/utils';
 import { CommitInfo, ConventionalCommit } from '../git/utils.js';
+import { WorkspacePackage } from '../package-json/collect-package-jsons.js';
 import { ProjectChangedFile } from './collect-files.js';
 export interface ChangelogGeneratorParams {
     onCommitParseFailed?: (commit: CommitInfo) => void;
@@ -30,4 +31,11 @@ export interface VersioningOptions {
      */
     shouldInclude?: (file: ProjectChangedFile) => MaybePromise<boolean>;
     changelog?: ChangelogGeneratorParams;
+    /**
+     * hook that is called after the versions were bumped and pushed to registries,
+     * but before the release commit is created and pushed to git.
+     *
+     * can be used to add something to the release commit
+     */
+    beforeReleaseCommit?: (workspace: WorkspacePackage[]) => MaybePromise<void>;
 }