aberlaas-release 2.20.1

package/lib/ensureNpmLogin.js

@@ -0,0 +1,170 @@
+import { _ } from 'golgoth';
+import {
+  consoleInfo,
+  consoleWarn,
+  env,
+  firostError,
+  prompt,
+  readJson,
+  run,
+  sleep,
+  wrap,
+  write,
+} from 'firost';
+import { hostGitPath, hostPackagePath } from 'aberlaas-helper';
+
+export const __ = {
+  /**
+   * Ensures the user is logged in to npm by checking authentication status and prompting for login if needed.
+   * @returns {boolean|undefined} Returns true if already logged in, undefined if login was required and completed
+   * @throws {Error} Throws error if npm authentication fails for reasons other than E401 unauthorized
+   */
+  async ensureNpmLogin() {
+    try {
+      await __.npmRun('whoami');
+      return true;
+    } catch (err) {
+      if (err.code == 'ABERLAAS_RELEASE_NPM_ERROR_E401') {
+        await __.waitForNpmLogin();
+        return;
+      }
+      throw err;
+    }
+  },
+
+  /**
+   * Executes an npm command and returns its output
+   * @param {string} command - The npm command to execute (without 'npm' prefix)
+   * @returns {string} The stdout output from the npm command
+   * @throws {Error} Throws a formatted error if the npm command fails
+   */
+  async npmRun(command) {
+    try {
+      const { stdout } = await __.run(`npm ${command}`, {
+        stdout: false,
+        stderr: false,
+      });
+      return stdout;
+    } catch ({ stderr }) {
+      const errorLines = _.split(stderr, '\n');
+
+      // Identify known npm errors
+      if (_.startsWith(errorLines[0], 'npm error code')) {
+        const npmErrorCode = _.replace(errorLines[0], 'npm error code ', '');
+        const npmErrorMessage = _.chain(errorLines).slice(1).join('\n').value();
+        throw firostError(
+          `ABERLAAS_RELEASE_NPM_ERROR_${npmErrorCode}`,
+          npmErrorMessage,
+        );
+      }
+
+      // Throw unknown errors up
+      throw firostError('ABERLAAS_RELEASE_NPM_UNKNOWN_ERROR', stderr);
+    }
+  },
+
+  /**
+   * Prompts the user to create and configure an npm authentication token when not logged in.
+   * Opens the npm token creation page in browser, guides user through token setup,
+   * collects the token, and saves it to .npmrc file.
+   */
+  async waitForNpmLogin() {
+    __.consoleWarn('You are not currently authentified to npm.');
+
+    await __.displayLoginInstructions();
+    await __.openBrowserForToken();
+    await __.saveNpmToken();
+
+    // Try again
+    await __.ensureNpmLogin();
+  },
+
+  /**
+   * Displays login instructions to the user
+   */
+  async displayLoginInstructions() {
+    const rootPackage = await readJson(hostPackagePath('package.json'));
+    const packageName = rootPackage.name;
+    const tokenName = __.generateTokenName(packageName);
+
+    __.consoleInfo('');
+    __.consoleInfo('Your npm token page will open.');
+    __.consoleInfo('We suggest you fill in the following informations:');
+    __.consoleInfo('');
+    __.consoleInfo('GENERAL');
+    __.consoleInfo(`Token name*: ${tokenName}`);
+    __.consoleInfo('☑️ Bypass two-factor authentication (2FA)');
+    __.consoleInfo('');
+    __.consoleInfo('PACKAGE AND SCOPES');
+    __.consoleInfo('Permissions: Read and write');
+    __.consoleInfo(`🔘 Only select packages and scopes: ${packageName}`);
+    __.consoleInfo('');
+    __.consoleInfo('EXPIRATION');
+    __.consoleInfo('Expiration date: 90 days');
+    __.consoleInfo('');
+  },
+
+  /**
+   * Generates a suggested token name from package name
+   * @param {string} packageName - The package name
+   * @returns {string} The suggested token name
+   */
+  generateTokenName(packageName) {
+    const cleanPackageName = _.chain(packageName)
+      .replace('-', '_')
+      .replace('@', '')
+      .replace('/', '_')
+      .toUpper()
+      .value();
+    return `ABERLAAS_RELEASE_${cleanPackageName}`;
+  },
+
+  /**
+   * Opens browser for token creation
+   */
+  async openBrowserForToken() {
+    const npmUsername = await __.getNpmUsername();
+    const tokenUrl = __.buildTokenUrl(npmUsername);
+
+    await __.prompt('Press Enter to open the webpage');
+    __.run(`$BROWSER ${tokenUrl}`, { shell: true, stderr: false });
+    await __.sleep(2000);
+  },
+
+  /**
+   * Gets the NPM username from environment variable or prompts user for input
+   * @returns {string} The NPM username
+   */
+  async getNpmUsername() {
+    return (
+      __.env('ABERLAAS_NPM_USERNAME') || (await __.prompt('NPM Username: '))
+    );
+  },
+
+  /**
+   * Builds the npm token creation URL for a given username
+   * @param {string} npmUsername - The npm username
+   * @returns {string} The token creation URL
+   */
+  buildTokenUrl(npmUsername) {
+    return `https://www.npmjs.com/settings/${npmUsername}/tokens/granular-access-tokens/new`;
+  },
+
+  /**
+   * Saves the npm token to .npmrc file
+   */
+  async saveNpmToken() {
+    const npmToken = await __.prompt('Enter you new token here:');
+    const npmrcContent = `//registry.npmjs.org/:_authToken=${npmToken}`;
+    const npmrcPath = hostGitPath('.npmrc');
+    await write(npmrcContent, npmrcPath);
+  },
+  run,
+  env,
+  prompt,
+  consoleWarn,
+  consoleInfo,
+  sleep,
+};
+
+export const ensureNpmLogin = wrap(__, 'ensureNpmLogin');

package/lib/ensureValidSetup.js

@@ -0,0 +1,137 @@
+import { _ } from 'golgoth';
+import { consoleInfo, firostError, run as firostRun } from 'firost';
+import { hostGitRoot, yarnRun } from 'aberlaas-helper';
+import Gilmore from 'gilmore';
+import { ensureNpmLogin } from './ensureNpmLogin.js';
+
+export const __ = {
+  /**
+   * Validates that the provided bump type is one of the accepted semantic
+   * versioning types, or empty for auto-detection.
+   * @param {object} cliArgs Release options
+   * @returns {void} - Returns nothing if valid, throws error if invalid
+   * @throws {Error} Throws ABERLAAS_RELEASE_UNKNOWN_BUMP_TYPE error if bumpType is provided but not 'patch', 'minor', or 'major'
+   */
+  ensureCorrectBumpType(cliArgs) {
+    const bumpType = cliArgs._[0];
+
+    // If no bump type provided, allow it (will be auto-detected)
+    if (_.isEmpty(bumpType)) {
+      return true;
+    }
+
+    // If bump type is provided, validate it
+    if (_.includes(['patch', 'minor', 'major'], bumpType)) {
+      return true;
+    }
+
+    throw firostError(
+      'ABERLAAS_RELEASE_UNKNOWN_BUMP_TYPE',
+      'Bump type should be either major, minor or patch (or omitted for auto-detection)',
+    );
+  },
+
+  /**
+   * Ensures the repository is on the main branch before allowing a release
+   * @param {object} repo - The repository object with branch operations
+   * @returns {Promise<boolean>} True if on main branch
+   * @throws {Error} Throws ABERLAAS_RELEASE_NOT_ON_MAIN_BRANCH error if not on main branch
+   */
+  async ensureCorrectBranch(repo) {
+    const currentBranch = await repo.currentBranchName();
+    if (currentBranch == 'main') {
+      return true;
+    }
+    throw firostError(
+      'ABERLAAS_RELEASE_NOT_ON_MAIN_BRANCH',
+      'You must be on branch main to release.',
+    );
+  },
+
+  /**
+   * Ensures the repository has no uncommitted changes before proceeding with operations
+   * @param {object} repo - The repository object to check status on
+   * @returns {Promise<boolean>} Returns true if repository is clean
+   * @throws {Error} Throws ABERLAAS_RELEASE_NOT_CLEAN_DIRECTORY error if uncommitted changes exist
+   */
+  async ensureCleanRepository(repo) {
+    const changes = await repo.status();
+    if (_.isEmpty(changes)) {
+      return true;
+    }
+    throw firostError(
+      'ABERLAAS_RELEASE_NOT_CLEAN_DIRECTORY',
+      'Your working directory must be clean, with no uncommitted changes.',
+    );
+  },
+
+  /**
+   * Ensures that all tests are passing before proceeding with a release
+   * @param {object} cliArgs Release options
+   * @returns {Promise<void>} A promise that resolves if tests pass, rejects with ABERLAAS_RELEASE_TESTS_FAILING error if tests fail
+   */
+  async ensureTestsArePassing(cliArgs = {}) {
+    if (cliArgs['skip-test']) {
+      return false;
+    }
+    __.consoleInfo('Running tests...');
+    try {
+      await __.yarnRun('test --failFast');
+      return true;
+    } catch (err) {
+      throw firostError('ABERLAAS_RELEASE_TESTS_FAILING', err.message);
+    }
+  },
+
+  /**
+   * Ensures that linting passes by running the lint process and throwing an error if it fails
+   * @param {object} cliArgs Release options
+   * @returns {Promise<void>} A promise that resolves if linting passes
+   * @throws {Error} Throws ABERLAAS_RELEASE_LINT_FAILING error if linting fails
+   */
+  async ensureLintIsPassing(cliArgs = {}) {
+    if (cliArgs['skip-lint']) {
+      return false;
+    }
+    __.consoleInfo('Running lint...');
+    try {
+      await __.yarnRun('lint');
+      return true;
+    } catch (err) {
+      throw firostError('ABERLAAS_RELEASE_LINT_FAILING', err.message);
+    }
+  },
+
+  consoleInfo,
+  ensureNpmLogin,
+  firostRun,
+  yarnRun,
+};
+
+/**
+ * Validate all pre-conditions before starting the release
+ * @param {object} cliArgs Release options
+ * @param {boolean} cliArgs.skipTest Skip test execution
+ * @param {boolean} cliArgs.skipLint Skip lint execution
+ * @returns {Promise<void>}
+ */
+export async function ensureValidSetup(cliArgs = {}) {
+  __.ensureCorrectBumpType(cliArgs);
+
+  const repo = new Gilmore(hostGitRoot());
+
+  // Need to be on branch main
+  await __.ensureCorrectBranch(repo);
+
+  // Need to have a clean directory
+  await __.ensureCleanRepository(repo);
+
+  // Check npm login
+  await __.ensureNpmLogin();
+
+  // Check tests are passing
+  await __.ensureTestsArePassing(cliArgs);
+
+  // Check lint is passing
+  await __.ensureLintIsPassing(cliArgs);
+}

package/lib/getReleaseData.js

@@ -0,0 +1,111 @@
+import { _, pMap } from 'golgoth';
+import { glob, readJson } from 'firost';
+import { hostGitPath, hostGitRoot } from 'aberlaas-helper';
+import { getGitDiff, parseCommits } from 'changelogen';
+import semver from 'semver';
+
+export const __ = {
+  /**
+   * Gets all packages that need to be released
+   * @returns {Array<{filepath: string, content: object}>} Array of packages with their filepath and content
+   */
+  async getAllPackagesToRelease() {
+    const rootPackagePath = hostGitPath('package.json');
+    const rootPackageContent = await readJson(rootPackagePath);
+    const workspaces = rootPackageContent.workspaces;
+
+    // If no workspaces, this is the package to publish
+    if (!workspaces) {
+      if (rootPackageContent.private) {
+        return [];
+      }
+      return [
+        {
+          filepath: rootPackagePath,
+          content: rootPackageContent,
+        },
+      ];
+    }
+
+    // If workspaces, we get the packages of all those workspaces
+    const rootPath = hostGitRoot();
+    const rawList = await pMap(workspaces, async (workspacePattern) => {
+      const packagesPath = await glob(
+        `${rootPath}/${workspacePattern}/package.json`,
+      );
+      const packagesData = await pMap(packagesPath, async (filepath) => {
+        const content = await readJson(filepath);
+        if (content.private) {
+          return false;
+        }
+        return {
+          filepath,
+          content,
+        };
+      });
+      return _.compact(packagesData);
+    });
+
+    return _.flatten(rawList);
+  },
+  /**
+   * Determines the appropriate semantic version bump type based on CLI arguments or git commit analysis
+   * @param {object} [cliArgs={}] - Command line arguments object containing potential bump type
+   * @param {string} currentVersion - The current version to compare commits against
+   * @returns {Promise<string>} The bump type: 'major', 'minor', or 'patch'
+   */
+  async getBumpType(cliArgs = {}, currentVersion) {
+    const argFromCli = cliArgs._[0];
+    if (argFromCli) {
+      return argFromCli;
+    }
+
+    // Getting all commits since last version tag
+    const rawCommits = await getGitDiff(
+      `v${currentVersion}`,
+      'HEAD',
+      hostGitRoot(),
+    );
+    // This is the minimal object required by changelogen
+    const minimalConfig = { scopeMap: {} };
+    const commits = parseCommits(rawCommits, minimalConfig);
+
+    // If any commit has breaking changes: major
+    const hasBreakingChanges = _.some(commits, { isBreaking: true });
+    if (hasBreakingChanges) {
+      return 'major';
+    }
+
+    // If any commit adds a feature: minor
+    const hasFeature = _.some(commits, { type: 'feat' });
+    if (hasFeature) {
+      return 'minor';
+    }
+
+    // Anything else: patch
+    return 'patch';
+  },
+};
+
+/**
+ * Gathers all release information from CLI arguments
+ * @param {object} cliArgs - CLI arguments from minimist
+ * @returns {object} Release data containing bumpType, allPackages, currentVersion, newVersion, skipChangelog
+ */
+export async function getReleaseData(cliArgs) {
+  const allPackages = await __.getAllPackagesToRelease();
+  const currentVersion = allPackages[0].content.version;
+
+  const bumpType = await __.getBumpType(cliArgs, currentVersion);
+
+  const newVersion = semver.inc(currentVersion, bumpType);
+  const skipChangelog = !!cliArgs['skip-changelog'];
+
+  return {
+    bumpType,
+    allPackages,
+    currentVersion,
+    newVersion,
+    skipChangelog,
+  };
+}

package/lib/main.js

@@ -0,0 +1,52 @@
+import path from 'node:path';
+import { pMap } from 'golgoth';
+import { consoleInfo, run as firostRun } from 'firost';
+import { ensureValidSetup } from './ensureValidSetup.js';
+import { getReleaseData } from './getReleaseData.js';
+import { updateGitRepo } from './updateGitRepo.js';
+
+export let __;
+
+/**
+ * Wrapper to release the current module(s)
+ * @param {object} cliArgs CLI Argument object, as created by minimist
+ * @returns {boolean} True on success
+ */
+export async function run(cliArgs = {}) {
+  await __.ensureValidSetup(cliArgs);
+
+  const releaseData = await __.getReleaseData(cliArgs);
+  __.consoleInfo(`Release new version ${releaseData.newVersion}`);
+
+  await __.updateGitRepo(releaseData);
+
+  await __.publishAllPackagesToNpm(releaseData);
+}
+
+__ = {
+  /**
+   * Publishes all packages to npm
+   * @param {object} releaseData - Release data containing allPackages
+   */
+  async publishAllPackagesToNpm(releaseData) {
+    await pMap(
+      releaseData.allPackages,
+      async ({ filepath, content }) => {
+        const packageName = content.name;
+        __.consoleInfo(`Publishing ${packageName} to npm`);
+
+        const packageDir = path.dirname(filepath);
+        await __.firostRun('npm publish --access public', { cwd: packageDir });
+      },
+      { concurrency: 1 },
+    );
+  },
+
+  ensureValidSetup,
+  updateGitRepo,
+  getReleaseData,
+  consoleInfo,
+  firostRun,
+};
+
+export default { run };

package/lib/updateChangelog.js

@@ -0,0 +1,150 @@
+import { _ } from 'golgoth';
+import {
+  consoleInfo,
+  exists,
+  firostError,
+  read,
+  run,
+  select,
+  write,
+} from 'firost';
+import { hostGitPath, hostGitRoot } from 'aberlaas-helper';
+import { generateMarkDown, getGitDiff, parseCommits } from 'changelogen';
+import cliMarkdown from 'cli-markdown';
+
+export const __ = {
+  /**
+   * Generate changelog markdown from git commits between two versions
+   * @param {object} releaseData - Release data containing currentVersion, newVersion, and skipChangelog
+   * @returns {string} Generated changelog markdown
+   */
+  async generateChangelogFromGit(releaseData) {
+    const { currentVersion, newVersion } = releaseData;
+    const gitRoot = hostGitRoot();
+    const currentVersionTag = `v${currentVersion}`;
+
+    // Get config
+    const config = {
+      from: currentVersionTag,
+      to: 'HEAD',
+      newVersion,
+      noAuthors: true,
+      types: {
+        feat: { title: 'Features', semver: 'minor' },
+        fix: { title: 'Bug Fixes', semver: 'patch' },
+        perf: { title: 'Performance', semver: 'patch' },
+      },
+      templates: {
+        tagMessage: 'v{{newVersion}}',
+        tagBody: 'v{{newVersion}}',
+      },
+      // Note: This scopeMap key is required by changelogen
+      scopeMap: {},
+    };
+
+    const rawCommits = await getGitDiff(currentVersionTag, 'HEAD', gitRoot);
+    const commits = parseCommits(rawCommits, config);
+
+    // Filter commits to only keep user-facing types
+    const allowedTypes = _.keys(config.types);
+    const filteredCommits = _.filter(commits, (commit) => {
+      return _.includes(allowedTypes, commit.type);
+    });
+
+    // Sort commits by type order
+    const typeOrder = { feat: 0, fix: 1, perf: 2 };
+    const sortedCommits = _.sortBy(filteredCommits, (commit) => {
+      return typeOrder[commit.type];
+    });
+
+    // Generate markdown
+    return await generateMarkDown(sortedCommits, config);
+  },
+
+  /**
+   * Display the changelog and ask the user to accept/edit/cancel.
+   * @param {string} changelog - The changelog content to display and confirm
+   * @param {object} selectOptions - Options object with input stream for testing
+   * @returns {string} The approved (and possibly edited) changelog content
+   */
+  async confirmOrEditChangelog(changelog, selectOptions = {}) {
+    __.consoleInfo('CHANGELOG:');
+
+    __.consoleLog(_.repeat('━', 60));
+    __.consoleLog(__.cliMarkdown(changelog));
+    __.consoleLog(_.repeat('━', 60));
+
+    const nextStep = await __.select(
+      'What to do?',
+      [
+        { name: '✅ Approve', value: 'approve' },
+        { name: '📝 Edit', value: 'edit' },
+        { name: '⛔️ Cancel', value: 'cancel' },
+      ],
+      selectOptions,
+    );
+
+    if (nextStep == 'cancel') {
+      throw firostError(
+        'ABERLAAS_RELEASE_CHANGELOG_CANCELLED',
+        'Release cancelled by user',
+      );
+    }
+
+    if (nextStep === 'approve') {
+      return changelog;
+    }
+
+    // Save the changelog in temp file and edit it
+    const changelogFilepath = hostGitPath('./tmp/CHANGELOG.md');
+    await write(changelog, changelogFilepath);
+
+    await __.run(`$EDITOR ${changelogFilepath}`, {
+      stdin: true,
+      shell: true,
+    });
+
+    const newChangelog = await read(changelogFilepath);
+    return await __.confirmOrEditChangelog(newChangelog, selectOptions);
+  },
+
+  /**
+   * Prepends new changelog content to existing CHANGELOG.md file
+   * @param {string} newChangelog - The new changelog content to prepend
+   */
+  async addToExistingChangelogFile(newChangelog) {
+    const changelogPath = hostGitPath('CHANGELOG.md');
+
+    if (!(await exists(changelogPath))) {
+      await write(newChangelog, changelogPath);
+      return;
+    }
+
+    const existingChangelog = await read(changelogPath);
+    const updatedChangelog = `${newChangelog}\n\n${existingChangelog}`;
+    await write(updatedChangelog, changelogPath);
+  },
+
+  consoleInfo,
+  consoleLog(input) {
+    console.log(input);
+  },
+  select,
+  cliMarkdown,
+  run,
+};
+
+/**
+ * Update the CHANGELOG.md file with new additions
+ * @param {object} releaseData - Release data containing currentVersion, newVersion, and skipChangelog
+ */
+export async function updateChangelog(releaseData) {
+  if (releaseData.skipChangelog) {
+    return;
+  }
+
+  const suggestedChangelog = await __.generateChangelogFromGit(releaseData);
+  const approvedChangelog = await __.confirmOrEditChangelog(suggestedChangelog);
+
+  await __.addToExistingChangelogFile(approvedChangelog);
+}

package/lib/updateGitRepo.js

@@ -0,0 +1,62 @@
+import { pMap } from 'golgoth';
+import { consoleInfo, writeJson } from 'firost';
+import { hostGitRoot } from 'aberlaas-helper';
+import Gilmore from 'gilmore';
+import { updateChangelog } from './updateChangelog.js';
+
+export const __ = {
+  /**
+   * Bumps the version of all packages to the new version
+   * @param {object} releaseData - Release data containing allPackages and newVersion
+   */
+  async bumpAllPackageVersions(releaseData) {
+    await pMap(releaseData.allPackages, async ({ filepath, content }) => {
+      const packageName = content.name;
+      __.consoleInfo(`Updating ${packageName} to ${releaseData.newVersion}`);
+      const newContent = { ...content, version: releaseData.newVersion };
+      await writeJson(newContent, filepath, {
+        sort: false,
+      });
+    });
+  },
+
+  /**
+   * Creates a commit, tag, and pushes to remote repository
+   * @param {object} releaseData - Release data containing newVersion
+   */
+  async commitTagAndPush(releaseData) {
+    const gitRoot = hostGitRoot();
+    const repo = new Gilmore(gitRoot);
+
+    // Create commit
+    __.consoleInfo(
+      `Creating new commit for version v${releaseData.newVersion}`,
+    );
+    await repo.commitAll(`v${releaseData.newVersion}`, { skipHook: true });
+
+    // Create tag
+    await repo.createTag(`v${releaseData.newVersion}`);
+
+    // Push to remote
+    __.consoleInfo('Pushing to remote repository');
+    await repo.push();
+  },
+
+  consoleInfo,
+  updateChangelog,
+};
+
+/**
+ * Update git repository with all changes for the release
+ * @param {object} releaseData - Release data containing currentVersion, newVersion, skipChangelog, and allPackages
+ */
+export async function updateGitRepo(releaseData) {
+  // Update CHANGELOG.md
+  await __.updateChangelog(releaseData);
+
+  // Update all .version keys in packages
+  await __.bumpAllPackageVersions(releaseData);
+
+  // Commit and push to remote
+  await __.commitTagAndPush(releaseData);
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "aberlaas-release",
+  "type": "module",
+  "sideEffects": false,
+  "description": "aberlaas release command: Release and publish new versions",
+  "version": "2.20.1",
+  "repository": "pixelastic/aberlaas",
+  "homepage": "https://projects.pixelastic.com/aberlaas/",
+  "author": "Tim Carry (@pixelastic)",
+  "license": "MIT",
+  "files": [
+    "lib/*.js"
+  ],
+  "exports": {
+    ".": "./lib/main.js"
+  },
+  "main": "./lib/main.js",
+  "engines": {
+    "node": ">=18.18.0"
+  },
+  "dependencies": {
+    "aberlaas-helper": "workspace:*",
+    "aberlaas-lint": "workspace:*",
+    "aberlaas-test": "workspace:*",
+    "changelogen": "0.6.2",
+    "cli-markdown": "3.5.1",
+    "firost": "5.5.1",
+    "gilmore": "1.2.0",
+    "golgoth": "3.0.0",
+    "semver": "7.7.3"
+  },
+  "scripts": {
+    "build": "cd ../docs && yarn run build",
+    "build:prod": "cd ../docs && yarn run build:prod",
+    "cms": "cd ../docs && yarn run cms",
+    "serve": "cd ../docs && yarn run serve",
+    "release": "cd ../.. && ./scripts/release",
+    "test:meta": "cd ../.. && ./scripts/test-meta",
+    "test": "cd ../.. && ./scripts/test",
+    "test:watch": "cd ../.. && ./scripts/test-watch",
+    "compress": "cd ../.. && ./scripts/compress",
+    "lint": "cd ../.. && ./scripts/lint",
+    "lint:fix": "cd ../.. && ./scripts/lint-fix"
+  }
+}