@decaf-ts/utils
Version:
module management utils for decaf-ts
167 lines • 20.8 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ReleaseScript = void 0;
const utils_1 = require("./../../utils/utils.cjs");
const constants_1 = require("./../../utils/constants.cjs");
const input_1 = require("./../../input/input.cjs");
const command_1 = require("./../command.cjs");
const options = {
ci: {
type: "boolean",
default: true,
},
message: {
type: "string",
short: "m",
},
tag: {
type: "string",
short: "t",
default: undefined,
},
};
/**
* @class ReleaseScript
* @extends {Command}
* @cavegory scripts
* @description A command-line script for managing releases and version updates.
* @summary This script automates the process of creating and pushing new releases. It handles version updates,
* commit messages, and optionally publishes to NPM. The script supports semantic versioning and can work in both CI and non-CI environments.
*
* @param {Object} options - Configuration options for the script
* @param {boolean} options.ci - Whether the script is running in a CI environment (default: true)
* @param {string} options.message - The release message (short: 'm')
* @param {string} options.tag - The version tag to use (short: 't', default: undefined)
*/
class ReleaseScript extends command_1.Command {
constructor() {
super("ReleaseScript", options);
}
/**
* @description Prepares the version for the release.
* @summary This method validates the provided tag or prompts the user for a new one if not provided or invalid.
* It also displays the latest git tags for reference.
* @param {string} tag - The version tag to prepare
* @returns {Promise<string>} The prepared version tag
*
* @mermaid
* sequenceDiagram
* participant R as ReleaseScript
* participant T as TestVersion
* participant U as UserInput
* participant G as Git
* R->>T: testVersion(tag)
* alt tag is valid
* T-->>R: return tag
* else tag is invalid or not provided
* R->>G: List latest git tags
* R->>U: Prompt for new tag
* U-->>R: return new tag
* end
*/
async prepareVersion(tag) {
const log = this.log.for(this.prepareVersion);
tag = this.testVersion(tag || "");
if (!tag) {
log.verbose("No release message provided. Prompting for one:");
log.info(`Listing latest git tags:`);
await (0, utils_1.runCommand)("git tag --sort=-taggerdate | head -n 5").promise;
return await input_1.UserInput.insistForText("tag", "Enter the new tag number (accepts v*.*.*[-...])", (val) => !!val.toString().match(/^v[0-9]+\.[0-9]+.[0-9]+(-[0-9a-zA-Z-]+)?$/));
}
return tag;
}
/**
* @description Tests if the provided version is valid.
* @summary This method checks if the version is a valid semantic version or a predefined update type (PATCH, MINOR, MAJOR).
* @param {string} version - The version to test
* @returns {string | undefined} The validated version or undefined if invalid
*/
testVersion(version) {
const log = this.log.for(this.testVersion);
version = version.trim().toLowerCase();
switch (version) {
case constants_1.SemVersion.PATCH:
case constants_1.SemVersion.MINOR:
case constants_1.SemVersion.MAJOR:
log.verbose(`Using provided SemVer update: ${version}`, 1);
return version;
default:
log.verbose(`Testing provided version for SemVer compatibility: ${version}`, 1);
if (!new RegExp(constants_1.SemVersionRegex).test(version)) {
log.debug(`Invalid version number: ${version}`);
return undefined;
}
log.verbose(`version approved: ${version}`, 1);
return version;
}
}
/**
* @description Prepares the release message.
* @summary This method either returns the provided message or prompts the user for a new one if not provided.
* @param {string} [message] - The release message
* @returns {Promise<string>} The prepared release message
*/
async prepareMessage(message) {
const log = this.log.for(this.prepareMessage);
if (!message) {
log.verbose("No release message provided. Prompting for one");
return await input_1.UserInput.insistForText("message", "What should be the release message/ticket?", (val) => !!val && val.toString().length > 5);
}
return message;
}
/**
* @description Runs the release script.
* @summary This method orchestrates the entire release process, including version preparation, message creation,
* git operations, and npm publishing (if not in CI environment).
* @param {ParseArgsResult} args - The parsed command-line arguments
* @returns {Promise<void>}
*
* @mermaid
* sequenceDiagram
* participant R as ReleaseScript
* participant V as PrepareVersion
* participant M as PrepareMessage
* participant N as NPM
* participant G as Git
* participant U as UserInput
* R->>V: prepareVersion(tag)
* R->>M: prepareMessage(message)
* R->>N: Run prepare-release script
* R->>G: Check git status
* alt changes exist
* R->>U: Ask for confirmation
* U-->>R: Confirm
* R->>G: Add and commit changes
* end
* R->>N: Update npm version
* R->>G: Push changes and tags
* alt not CI environment
* R->>N: Publish to npm
* end
*/
async run(args) {
let result;
const { ci } = args;
let { tag, message } = args;
tag = await this.prepareVersion(tag);
message = await this.prepareMessage(message);
result = await (0, utils_1.runCommand)(`npm run prepare-release -- ${tag} ${message}`, {
cwd: process.cwd(),
}).promise;
result = await (0, utils_1.runCommand)("git status --porcelain").promise;
await result;
if (result.logs.length &&
(await input_1.UserInput.askConfirmation("git-changes", "Do you want to push the changes to the remote repository?", true))) {
await (0, utils_1.runCommand)("git add .").promise;
await (0, utils_1.runCommand)(`git commit -m "${tag} - ${message} - after release preparation${ci ? "" : constants_1.NoCIFLag}"`).promise;
}
await (0, utils_1.runCommand)(`npm version "${tag}" -m "${message}${ci ? "" : constants_1.NoCIFLag}"`).promise;
await (0, utils_1.runCommand)("git push --follow-tags").promise;
if (!ci) {
await (0, utils_1.runCommand)("NPM_TOKEN=$(cat .npmtoken) npm publish --access public")
.promise;
}
}
}
exports.ReleaseScript = ReleaseScript;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tag-release.js","sourceRoot":"","sources":["../../../src/cli/commands/tag-release.ts"],"names":[],"mappings":"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","sourcesContent":["import { runCommand } from \"../../utils/utils\";\nimport { NoCIFLag, SemVersion, SemVersionRegex } from \"../../utils/constants\";\nimport { UserInput } from \"../../input/input\";\nimport { Command } from \"../command\";\nimport { DefaultCommandValues } from \"../index\";\nimport { LoggingConfig } from \"@decaf-ts/logging\";\n\nconst options = {\n  ci: {\n    type: \"boolean\",\n    default: true,\n  },\n  message: {\n    type: \"string\",\n    short: \"m\",\n  },\n  tag: {\n    type: \"string\",\n    short: \"t\",\n    default: undefined,\n  },\n};\n\n/**\n * @class ReleaseScript\n * @extends {Command}\n * @cavegory scripts\n * @description A command-line script for managing releases and version updates.\n * @summary This script automates the process of creating and pushing new releases. It handles version updates,\n * commit messages, and optionally publishes to NPM. The script supports semantic versioning and can work in both CI and non-CI environments.\n *\n * @param {Object} options - Configuration options for the script\n * @param {boolean} options.ci - Whether the script is running in a CI environment (default: true)\n * @param {string} options.message - The release message (short: 'm')\n * @param {string} options.tag - The version tag to use (short: 't', default: undefined)\n */\nexport class ReleaseScript extends Command<typeof options, void> {\n  constructor() {\n    super(\"ReleaseScript\", options);\n  }\n\n  /**\n   * @description Prepares the version for the release.\n   * @summary This method validates the provided tag or prompts the user for a new one if not provided or invalid.\n   * It also displays the latest git tags for reference.\n   * @param {string} tag - The version tag to prepare\n   * @returns {Promise<string>} The prepared version tag\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant R as ReleaseScript\n   *   participant T as TestVersion\n   *   participant U as UserInput\n   *   participant G as Git\n   *   R->>T: testVersion(tag)\n   *   alt tag is valid\n   *     T-->>R: return tag\n   *   else tag is invalid or not provided\n   *     R->>G: List latest git tags\n   *     R->>U: Prompt for new tag\n   *     U-->>R: return new tag\n   *   end\n   */\n  async prepareVersion(tag?: string): Promise<string> {\n    const log = this.log.for(this.prepareVersion);\n    tag = this.testVersion((tag as string) || \"\");\n    if (!tag) {\n      log.verbose(\"No release message provided. Prompting for one:\");\n      log.info(`Listing latest git tags:`);\n      await runCommand(\"git tag --sort=-taggerdate | head -n 5\").promise;\n      return await UserInput.insistForText(\n        \"tag\",\n        \"Enter the new tag number (accepts v*.*.*[-...])\",\n        (val) =>\n          !!val.toString().match(/^v[0-9]+\\.[0-9]+.[0-9]+(-[0-9a-zA-Z-]+)?$/)\n      );\n    }\n    return tag;\n  }\n\n  /**\n   * @description Tests if the provided version is valid.\n   * @summary This method checks if the version is a valid semantic version or a predefined update type (PATCH, MINOR, MAJOR).\n   * @param {string} version - The version to test\n   * @returns {string | undefined} The validated version or undefined if invalid\n   */\n  testVersion(version: string): string | undefined {\n    const log = this.log.for(this.testVersion);\n    version = version.trim().toLowerCase();\n    switch (version) {\n      case SemVersion.PATCH:\n      case SemVersion.MINOR:\n      case SemVersion.MAJOR:\n        log.verbose(`Using provided SemVer update: ${version}`, 1);\n        return version;\n      default:\n        log.verbose(\n          `Testing provided version for SemVer compatibility: ${version}`,\n          1\n        );\n        if (!new RegExp(SemVersionRegex).test(version)) {\n          log.debug(`Invalid version number: ${version}`);\n          return undefined;\n        }\n        log.verbose(`version approved: ${version}`, 1);\n        return version;\n    }\n  }\n\n  /**\n   * @description Prepares the release message.\n   * @summary This method either returns the provided message or prompts the user for a new one if not provided.\n   * @param {string} [message] - The release message\n   * @returns {Promise<string>} The prepared release message\n   */\n  async prepareMessage(message?: string) {\n    const log = this.log.for(this.prepareMessage);\n    if (!message) {\n      log.verbose(\"No release message provided. Prompting for one\");\n      return await UserInput.insistForText(\n        \"message\",\n        \"What should be the release message/ticket?\",\n        (val) => !!val && val.toString().length > 5\n      );\n    }\n    return message;\n  }\n\n  /**\n   * @description Runs the release script.\n   * @summary This method orchestrates the entire release process, including version preparation, message creation,\n   * git operations, and npm publishing (if not in CI environment).\n   * @param {ParseArgsResult} args - The parsed command-line arguments\n   * @returns {Promise<void>}\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant R as ReleaseScript\n   *   participant V as PrepareVersion\n   *   participant M as PrepareMessage\n   *   participant N as NPM\n   *   participant G as Git\n   *   participant U as UserInput\n   *   R->>V: prepareVersion(tag)\n   *   R->>M: prepareMessage(message)\n   *   R->>N: Run prepare-release script\n   *   R->>G: Check git status\n   *   alt changes exist\n   *     R->>U: Ask for confirmation\n   *     U-->>R: Confirm\n   *     R->>G: Add and commit changes\n   *   end\n   *   R->>N: Update npm version\n   *   R->>G: Push changes and tags\n   *   alt not CI environment\n   *     R->>N: Publish to npm\n   *   end\n   */\n  async run(\n    args: LoggingConfig &\n      typeof DefaultCommandValues & { [k in keyof typeof options]: unknown }\n  ): Promise<void> {\n    let result: any;\n    const { ci } = args;\n    let { tag, message } = args;\n    tag = await this.prepareVersion(tag as string);\n    message = await this.prepareMessage(message as string);\n    result = await runCommand(`npm run prepare-release -- ${tag} ${message}`, {\n      cwd: process.cwd(),\n    }).promise;\n    result = await runCommand(\"git status --porcelain\").promise;\n    await result;\n    if (\n      result.logs.length &&\n      (await UserInput.askConfirmation(\n        \"git-changes\",\n        \"Do you want to push the changes to the remote repository?\",\n        true\n      ))\n    ) {\n      await runCommand(\"git add .\").promise;\n      await runCommand(\n        `git commit -m \"${tag} - ${message} - after release preparation${ci ? \"\" : NoCIFLag}\"`\n      ).promise;\n    }\n    await runCommand(\n      `npm version \"${tag}\" -m \"${message}${ci ? \"\" : NoCIFLag}\"`\n    ).promise;\n    await runCommand(\"git push --follow-tags\").promise;\n    if (!ci) {\n      await runCommand(\"NPM_TOKEN=$(cat .npmtoken) npm publish --access public\")\n        .promise;\n    }\n  }\n}\n"]}