@fuman/build 0.0.1

package/cli/commands/jsr.js

@@ -0,0 +1,79 @@
+import process from "node:process";
+import { jsrCreatePackages } from "../../jsr/create-packages.js";
+import { generateDenoWorkspace } from "../../jsr/generate-workspace.js";
+import { populateFromUpstream } from "../../jsr/populate.js";
+import { loadConfig } from "./_utils.js";
+import * as bc from "@drizzle-team/brocli";
+const populate = bc.command({
+  name: "populate",
+  desc: "populate a local JSR instance with packages from an upstream registry",
+  options: {
+    upstream: bc.string().desc("URL of the upstream registry (default: process.env.JSR_URL)"),
+    createViaApi: bc.boolean("create-via-api").desc("create packages via the API instead of manually via web UI"),
+    packages: bc.string().desc("comma-separated list of packages to populate (with version, e.g. `@std/fs@0.105.0`)").required(),
+    downstream: bc.string().desc("URL of the downstream local registry").required(),
+    token: bc.string().desc("API token"),
+    quiet: bc.boolean().alias("q").desc("suppress output"),
+    publishArgs: bc.string("publish-args").desc("Additional arguments to pass to `deno publish`")
+  },
+  transform: (args) => {
+    return {
+      ...args,
+      packages: args.packages.split(",").map((s) => s.trim()),
+      publishArgs: args.publishArgs?.split(" ")
+    };
+  },
+  handler: populateFromUpstream
+});
+const createPackages = bc.command({
+  name: "create-packages",
+  desc: "create missing packages from the workspace",
+  options: {
+    registry: bc.string("registry").desc("URL of the registry to publish to").default("https://jsr.io"),
+    root: bc.string().desc("path to the root of the workspace (default: cwd)"),
+    token: bc.string("token").desc("token to use for managing the packages"),
+    githubRepo: bc.string("github-repo").desc("github repo to set for the package (requires --token)")
+  },
+  handler: async (args) => {
+    const hasFailed = await jsrCreatePackages({
+      workspaceRoot: args.root ?? process.cwd(),
+      registry: args.registry,
+      token: args.token,
+      githubRepo: args.githubRepo
+    });
+    if (!hasFailed) {
+      console.log("✅ \x1B[;32mall packages were published\x1B[;0m");
+    }
+  }
+});
+const generateDenoWorkspaceCli = bc.command({
+  name: "gen-deno-workspace",
+  options: {
+    workspaceRoot: bc.string("root").desc("path to the root of the workspace (default: cwd)"),
+    withDryRun: bc.boolean("with-dry-run").desc("whether to run `deno publish --dry-run` after generating the workspace")
+  },
+  handler: async (args) => {
+    const workspaceRoot = args.workspaceRoot ?? process.cwd();
+    const rootConfig = await loadConfig({
+      workspaceRoot
+    });
+    const outDir = await generateDenoWorkspace({
+      workspaceRoot,
+      rootConfig: rootConfig?.jsr,
+      withDryRun: args.withDryRun
+    });
+    console.log(`\x1B[;32mdeno workspace generated at ${outDir}`);
+  }
+});
+const jsrCli = bc.command({
+  name: "jsr",
+  desc: "jsr-related commands",
+  subcommands: [
+    populate,
+    createPackages,
+    generateDenoWorkspaceCli
+  ]
+});
+export {
+  jsrCli
+};

package/cli/commands/publish.d.ts

@@ -0,0 +1,48 @@
+import { WorkspacePackage } from '../../package-json/collect-package-jsons.js';
+import { bc } from './_utils.js';
+export interface PublishPackagesResult {
+    failed: string[];
+    tarballs: string[];
+}
+export declare function publishPackages(params: {
+    workspaceRoot?: string;
+    workspace?: WorkspacePackage[];
+    packages: string[];
+    unpublishExisting?: boolean;
+    registryUrl?: string;
+    token?: string;
+    distDir?: string;
+    dryRun?: boolean;
+    publishArgs?: string[];
+    withTarballs?: boolean;
+    withBuild?: boolean;
+    skipVersionCheck?: boolean;
+    fixedVersion?: string;
+}): Promise<PublishPackagesResult>;
+export declare const publishPackagesCli: bc.Command<{
+    root: string | undefined;
+    unpublishExisting: boolean | undefined;
+    skipVersionCheck: boolean | undefined;
+    registryUrl: string | undefined;
+    token: string | undefined;
+    distDir: string | undefined;
+    dryRun: boolean | undefined;
+    publishArgs: string | undefined;
+    packages: string;
+    withTarballs: boolean | undefined;
+    withBuild: boolean | undefined;
+    fixedVersion: string | undefined;
+}, {
+    root: string | undefined;
+    unpublishExisting: boolean | undefined;
+    skipVersionCheck: boolean | undefined;
+    registryUrl: string | undefined;
+    token: string | undefined;
+    distDir: string | undefined;
+    dryRun: boolean | undefined;
+    publishArgs: string | undefined;
+    packages: string;
+    withTarballs: boolean | undefined;
+    withBuild: boolean | undefined;
+    fixedVersion: string | undefined;
+}>;

package/cli/commands/publish.js

@@ -0,0 +1,197 @@
+import * as fsp from "node:fs/promises";
+import { resolve, join } from "node:path";
+import process from "node:process";
+import { asNonNull } from "@fuman/utils";
+import { isRunningInGithubActions, writeGithubActionsOutput } from "../../ci/github-actions.js";
+import { exec } from "../../misc/exec.js";
+import { sortWorkspaceByPublishOrder } from "../../misc/publish-order.js";
+import { npmCheckVersion } from "../../npm/npm-api.js";
+import { collectPackageJsons, filterPackageJsonsForPublish } from "../../package-json/collect-package-jsons.js";
+import { parsePackageJsonFile } from "../../package-json/parse.js";
+import * as bc from "@drizzle-team/brocli";
+import { buildPackage } from "./build.js";
+const DEFAULT_REGISTRY_URL = "https://registry.npmjs.org";
+async function publishPackages(params) {
+  const {
+    workspaceRoot = process.cwd(),
+    workspace = await collectPackageJsons(workspaceRoot, true),
+    packages,
+    unpublishExisting = false,
+    skipVersionCheck = false,
+    registryUrl = DEFAULT_REGISTRY_URL,
+    token,
+    distDir = "dist",
+    publishArgs = [],
+    dryRun,
+    withTarballs,
+    withBuild,
+    fixedVersion
+  } = params;
+  const workspaceWithoutRoot = workspace.filter((pkg) => !pkg.root);
+  const ordered = filterPackageJsonsForPublish(sortWorkspaceByPublishOrder(workspaceWithoutRoot), "npm");
+  const toPublish = packages.length === 1 && packages[0] === ":all" ? ordered : ordered.filter((pkg) => packages.includes(asNonNull(pkg.json.name)));
+  const failed = [];
+  const tarballs = [];
+  if (token != null && !dryRun) {
+    await exec([
+      "npm",
+      "config",
+      "set",
+      "--global",
+      new URL(":_authToken", registryUrl).href.replace(/^https:\/\//, "//"),
+      token
+    ], { throwOnError: true });
+  }
+  if (!dryRun) {
+    await exec(["npm", "whoami", "--registry", registryUrl], { throwOnError: true });
+  }
+  if (isRunningInGithubActions() && process.env.ACTIONS_ID_TOKEN_REQUEST_URL != null && registryUrl === DEFAULT_REGISTRY_URL) {
+    if (!publishArgs.some((it) => it.startsWith("--provenance"))) {
+      publishArgs.push("--provenance");
+    }
+  }
+  for (const pkg of toPublish) {
+    const pkgVersion = fixedVersion ?? asNonNull(pkg.json.version);
+    if (!dryRun && !skipVersionCheck && await npmCheckVersion({
+      registry: registryUrl,
+      package: asNonNull(pkg.json.name),
+      version: pkgVersion
+    })) {
+      if (unpublishExisting) {
+        await exec([
+          "npm",
+          "unpublish",
+          "--force",
+          "--registry",
+          registryUrl,
+          `${asNonNull(pkg.json.name)}@${pkgVersion}`
+        ], {
+          stdio: "inherit"
+        });
+      } else {
+        console.log(`Skipping ${pkg.json.name}@${pkgVersion} because it is already published`);
+        continue;
+      }
+    }
+    if (withBuild) {
+      if (pkg.json.scripts?.build !== void 0) {
+        const res2 = await exec([
+          "npm",
+          "run",
+          "build"
+        ], {
+          cwd: join(pkg.path),
+          stdio: "inherit"
+        });
+        if (res2.exitCode !== 0) {
+          console.log("failed to build %s", pkg.json.name);
+          failed.push(asNonNull(pkg.json.name));
+          continue;
+        }
+      } else {
+        try {
+          await buildPackage({
+            workspaceRoot,
+            workspace,
+            packageName: asNonNull(pkg.json.name),
+            fixedVersion
+          });
+        } catch (err) {
+          console.log("failed to build %s:", pkg.json.name);
+          console.error(err);
+          failed.push(asNonNull(pkg.json.name));
+          continue;
+        }
+      }
+    }
+    const fullDistDir = join(pkg.path, distDir);
+    if (fixedVersion != null) {
+      const distPkgJsonPath = join(fullDistDir, "package.json");
+      const pkgJson = await parsePackageJsonFile(distPkgJsonPath);
+      pkgJson.version = fixedVersion;
+      await fsp.writeFile(distPkgJsonPath, JSON.stringify(pkgJson, null, 4));
+    }
+    console.log(`publishing ${pkg.json.name}@${pkgVersion}`);
+    if (pkg.json.name?.includes("/")) {
+      if (!publishArgs.some((it) => it.startsWith("--access"))) {
+        publishArgs.push("--access=public");
+      }
+    }
+    const res = await exec([
+      "npm",
+      "publish",
+      "--registry",
+      registryUrl,
+      ...dryRun ? ["--dry-run"] : ["-q"],
+      ...publishArgs
+    ], {
+      cwd: fullDistDir,
+      stdio: "inherit"
+    });
+    if (res.exitCode !== 0) {
+      failed.push(asNonNull(pkg.json.name));
+    }
+    if (withTarballs) {
+      const tar = await exec(["npm", "pack", "-q"], {
+        cwd: fullDistDir
+      });
+      if (tar.exitCode !== 0) {
+        console.error(tar.stderr);
+      } else {
+        tarballs.push(tar.stdout.trim());
+      }
+    }
+  }
+  return {
+    failed,
+    tarballs
+  };
+}
+const publishPackagesCli = bc.command({
+  name: "publish",
+  desc: "publish packages to npm",
+  options: {
+    root: bc.string().desc("path to the root of the workspace (default: cwd)"),
+    unpublishExisting: bc.boolean("unpublish-existing").desc("whether to unpublish if the version is already published (only available for certain registries, won't work with registry.npmjs.org)"),
+    skipVersionCheck: bc.boolean("skip-version-check").desc("whether to skip checking if the version is already published"),
+    registryUrl: bc.string("registry").desc("URL of the registry to publish to"),
+    token: bc.string("token").desc("token to use for publishing (note: this will override the global .npmrc file)"),
+    distDir: bc.string("dist-dir").desc("directory to publish from, relative to package root (default: dist)"),
+    dryRun: bc.boolean("dry-run").desc("whether to skip publishing and only print what is going to happen"),
+    publishArgs: bc.string("publish-args").desc("arguments to pass to `npm publish`"),
+    packages: bc.positional("packages").desc("name of the packages to publish (comma-separated, or :all to publish the entire workspace)").default(":all"),
+    withTarballs: bc.boolean("with-tarballs").desc("whether to generate tarballs in the dist directory using `npm pack` (doesn't work with jsr)"),
+    withBuild: bc.boolean("with-build").desc("whether to build the package before publishing using `build` npm script (or defaulting to building using fuman-build if one is not found)"),
+    fixedVersion: bc.string("fixed-version").desc("version to publish the package to (overrides the version in every package.json, useful for pre-releases)")
+  },
+  handler: async (options) => {
+    const { failed, tarballs } = await publishPackages({
+      ...options,
+      workspaceRoot: options.root != null ? resolve(process.cwd(), options.root) : process.cwd(),
+      packages: options.packages.split(","),
+      publishArgs: options.publishArgs?.split(" ")
+    });
+    if (failed.length > 0) {
+      console.log("failed to publish:");
+      for (const pkg of failed) {
+        console.log(`  ${pkg}`);
+      }
+      process.exit(1);
+    }
+    if (tarballs.length > 0) {
+      if (isRunningInGithubActions()) {
+        console.log("written paths to tarballs to `tarballs` output");
+        writeGithubActionsOutput("tarballs", tarballs.join(","));
+      } else {
+        console.log("tarballs generated:");
+        for (const tar of tarballs) {
+          console.log(`  ${tar}`);
+        }
+      }
+    }
+  }
+});
+export {
+  publishPackages,
+  publishPackagesCli
+};

package/cli/commands/release.d.ts

@@ -0,0 +1,34 @@
+import { bc } from './_utils.js';
+export declare const releaseCli: bc.Command<{
+    kind: "auto" | "major" | "minor" | "patch";
+    withGithubRelease: boolean;
+    githubToken: string | undefined;
+    githubRepo: string | undefined;
+    withJsr: boolean;
+    jsrRegistry: string | undefined;
+    jsrToken: string | undefined;
+    jsrPublishArgs: string | undefined;
+    jsrCreatePackages: boolean | undefined;
+    withNpm: boolean | undefined;
+    npmToken: string | undefined;
+    npmPublishArgs: string | undefined;
+    npmDistDir: string | undefined;
+    npmRegistry: string | undefined;
+    dryRun: boolean | undefined;
+}, {
+    kind: "auto" | "major" | "minor" | "patch";
+    withGithubRelease: boolean;
+    githubToken: string | undefined;
+    githubRepo: string | undefined;
+    withJsr: boolean;
+    jsrRegistry: string | undefined;
+    jsrToken: string | undefined;
+    jsrPublishArgs: string | undefined;
+    jsrCreatePackages: boolean | undefined;
+    withNpm: boolean | undefined;
+    npmToken: string | undefined;
+    npmPublishArgs: string | undefined;
+    npmDistDir: string | undefined;
+    npmRegistry: string | undefined;
+    dryRun: boolean | undefined;
+}>;

package/cli/commands/release.js

@@ -0,0 +1,226 @@
+import { createReadStream } from "node:fs";
+import { basename } from "node:path";
+import process from "node:process";
+import { nodeReadableToWeb } from "@fuman/node";
+import { asNonNull, notImplemented } from "@fuman/utils";
+import { sort } from "semver";
+import { createGithubRelease } from "../../git/github.js";
+import { getLatestTag, getFirstCommit } 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 { collectPackageJsons } from "../../package-json/collect-package-jsons.js";
+import { bumpVersion } from "../../versioning/bump-version.js";
+import { generateChangelog } from "../../versioning/generate-changelog.js";
+import { loadConfig } from "./_utils.js";
+import { formatBumpVersionResult } from "./bump-version.js";
+import { publishPackages } from "./publish.js";
+import * as bc from "@drizzle-team/brocli";
+const releaseCli = bc.command({
+  name: "release",
+  desc: "release packages",
+  options: {
+    kind: bc.string("kind").desc("release kind").enum("major", "minor", "patch", "auto").default("auto"),
+    withGithubRelease: bc.boolean("with-github-release").desc("whether to create a github release (requires GITHUB_TOKEN env var). if false, will only create a commit with the release notes").default(false),
+    githubToken: bc.string("github-token").desc("github token to use for creating a release (defaults to GITHUB_TOKEN env var)"),
+    githubRepo: bc.string("github-repo").desc("github repo to create a release for (defaults to GITHUB_REPOSITORY env var)"),
+    withJsr: bc.boolean("with-jsr").desc("whether to publish to jsr").default(false),
+    jsrRegistry: bc.string("jsr-registry").desc("URL of the jsr registry to publish to"),
+    jsrToken: bc.string("jsr-token").desc("jsr token to use for publishing"),
+    jsrPublishArgs: bc.string("jsr-publish-args").desc("additional arguments to pass to `deno publish`"),
+    jsrCreatePackages: bc.boolean("jsr-create-packages").desc("whether to create missing packages in jsr"),
+    withNpm: bc.boolean("with-npm").desc("whether to publish to npm"),
+    npmToken: bc.string("npm-token").desc("npm token to use for publishing (note: this will override the global .npmrc file)"),
+    npmPublishArgs: bc.string("npm-publish-args").desc("additional arguments to pass to `npm publish`"),
+    npmDistDir: bc.string("npm-dist-dir").desc("directory to publish to npm from, relative to package root (default: dist)"),
+    npmRegistry: bc.string("npm-registry").desc("URL of the npm registry to publish to"),
+    dryRun: bc.boolean("dry-run").desc("whether to skip publishing and only print what is going to happen")
+  },
+  handler: async (args) => {
+    const root = process.cwd();
+    const config = await loadConfig({
+      workspaceRoot: root,
+      configPath: "build.config.js",
+      require: false
+    });
+    const workspaceWithRoot = await collectPackageJsons(root, true);
+    const workspace = workspaceWithRoot.filter((pkg) => !pkg.root);
+    const prevTag = await getLatestTag(root);
+    if (prevTag == null) {
+      console.log("🤔 no previous tag found, assuming this is a first ever release");
+    } else {
+      console.log(`📌 previous tag: ${prevTag}`);
+    }
+    let changedPackages;
+    let bumpVersionResult;
+    if (prevTag != null) {
+      bumpVersionResult = await bumpVersion({
+        workspace,
+        since: prevTag ?? await getFirstCommit(root),
+        type: args.kind === "auto" ? void 0 : args.kind,
+        cwd: root,
+        params: config?.versioning,
+        dryRun: args.dryRun
+      });
+      changedPackages = bumpVersionResult.changedPackages.map((pkg) => pkg.package);
+      if (bumpVersionResult.changedPackages.length === 0) {
+        console.log("🤔 no packages changed, nothing to do");
+        process.exit(1);
+      }
+      console.log(formatBumpVersionResult(bumpVersionResult, args.kind === "auto"));
+    } else {
+      changedPackages = workspace;
+    }
+    console.log("");
+    console.log("📝 generating changelog...");
+    const changelog = prevTag != null ? await generateChangelog({
+      workspace: changedPackages,
+      cwd: root,
+      since: prevTag,
+      params: config?.versioning
+    }) : "Initial release";
+    if (args.dryRun) {
+      console.log("--begin changelog--");
+      console.log(changelog);
+      console.log("--end changelog--");
+    }
+    let tarballs = [];
+    if (args.withNpm) {
+      console.log("");
+      console.log("📤 publishing to npm...");
+      const publishResult = await publishPackages({
+        packages: changedPackages.map((pkg) => asNonNull(pkg.json.name)),
+        workspace: workspaceWithRoot,
+        workspaceRoot: root,
+        registryUrl: args.npmRegistry,
+        token: args.npmToken,
+        distDir: args.npmDistDir,
+        publishArgs: args.npmPublishArgs?.split(" "),
+        dryRun: args.dryRun,
+        withBuild: true,
+        withTarballs: args.withGithubRelease
+      });
+      if (publishResult.failed.length > 0) {
+        console.log("❌ failed to publish:");
+        for (const pkg of publishResult.failed) {
+          console.log(`  ${pkg}`);
+        }
+        process.exit(1);
+      }
+      console.log("\x1B[;32m✅ published to npm\x1B[;0m");
+      tarballs = publishResult.tarballs;
+    } else if (args.withGithubRelease) {
+      notImplemented("Cannot create a github release without publishing to npm (yet)");
+    }
+    if (args.withJsr) {
+      if (args.jsrCreatePackages) {
+        console.log("");
+        console.log("🔄 creating missing packages in jsr...");
+        const hasMissing = await jsrCreatePackages({
+          workspaceRoot: root,
+          workspacePackages: workspaceWithRoot,
+          registry: args.jsrRegistry,
+          token: args.jsrToken,
+          githubRepo: args.githubRepo
+        });
+        if (hasMissing) {
+          console.log("\x1B[;31m  ❌ some packages are missing, this might cause issues\x1B[;0m");
+        }
+      }
+      console.log("");
+      console.log("🔄 generating deno workspace...");
+      const workspaceDir = await generateDenoWorkspace({
+        workspaceRoot: root,
+        workspacePackages: workspaceWithRoot,
+        rootConfig: config?.jsr
+      });
+      console.log("");
+      console.log("📤 publishing to jsr...");
+      await exec([
+        "deno",
+        "publish",
+        "--quiet",
+        "--allow-dirty",
+        ...args.dryRun ? ["--dry-run"] : [],
+        ...args.jsrPublishArgs?.split(" ") ?? []
+      ], {
+        env: {
+          ...process.env,
+          JSR_URL: args.jsrRegistry
+        },
+        cwd: workspaceDir,
+        stdio: "inherit",
+        throwOnError: true
+      });
+      console.log("\x1B[;32m✅ published to jsr\x1B[;0m");
+    }
+    let tagName;
+    if (!bumpVersionResult) {
+      const versions = sort(workspace.map((pkg) => asNonNull(pkg.json.version)));
+      tagName = `v${versions[versions.length - 1]}`;
+    } else {
+      tagName = `v${bumpVersionResult.nextVersion}`;
+    }
+    if (args.dryRun) {
+      console.log("dry run, skipping release commit and tag");
+    } else {
+      let message = tagName;
+      if (!args.withGithubRelease) {
+        message += `
+
+${changelog}`;
+      }
+      await exec(["git", "commit", "-am", message, "--allow-empty"], {
+        cwd: root,
+        stdio: "inherit",
+        throwOnError: true
+      });
+      await exec(["git", "tag", tagName], {
+        cwd: root,
+        stdio: "inherit",
+        throwOnError: true
+      });
+    }
+    if (args.withGithubRelease) {
+      if (args.dryRun) {
+        console.log("dry run, skipping github release");
+      } else {
+        const token = args.githubToken ?? process.env.GITHUB_TOKEN;
+        if (token == null) {
+          throw new Error("github token is not set");
+        }
+        const repo = args.githubRepo ?? process.env.GITHUB_REPOSITORY;
+        if (repo == null) {
+          throw new Error("github repo is not set");
+        }
+        console.log("");
+        console.log("🐙 creating github release...");
+        await createGithubRelease({
+          token,
+          repo,
+          tag: tagName,
+          name: tagName,
+          body: changelog,
+          artifacts: tarballs.map((file) => ({
+            name: basename(file),
+            type: "application/gzip",
+            body: nodeReadableToWeb(createReadStream(file))
+          }))
+        });
+        console.log(`\x1B[;32m✅github release created: https://github.com/${repo}/releases/tag/${tagName}\x1B[;0m`);
+      }
+    }
+    if (!args.dryRun) {
+      await exec(["git", "push", "--follow-tags"], {
+        cwd: root,
+        stdio: "inherit",
+        throwOnError: true
+      });
+    }
+    console.log("");
+    console.log("🎉 done!");
+  }
+});
+export {
+  releaseCli
+};

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

@@ -0,0 +1,38 @@
+import { bc } from './_utils.js';
+export interface WorkspaceDepsError {
+    /** package name where the mismatch occurred */
+    package: string;
+    /** name of the mismatched dependency */
+    dependency: string;
+    /** version of the mismatched dependency */
+    version: string;
+    /** type of dependency (`dependencies`, `devDependencies`, etc) */
+    at: string;
+    /** package name where the dependency was originally declared */
+    otherPackage: string;
+    /** original version of the dependency */
+    otherVersion: string;
+}
+export declare function validateWorkspaceDeps(workspaceRoot: string | URL, params?: {
+    /**
+     * whether to also validate the root package.json
+     *
+     * @default true
+     */
+    includeRoot?: boolean;
+    /**
+     * whether to skip validating dependencies of other workspace packages
+     *
+     * @default true
+     */
+    skipWorkspaceDeps?: boolean;
+}): Promise<WorkspaceDepsError[]>;
+export declare const validateWorkspaceDepsCli: bc.Command<{
+    includeRoot: boolean;
+    noSkipWorkspaceDeps: boolean | undefined;
+    root: string | undefined;
+}, {
+    includeRoot: boolean;
+    noSkipWorkspaceDeps: boolean | undefined;
+    root: string | undefined;
+}>;