@wjwjq/release-helper 0.0.1

package/src/publish.ts

@@ -0,0 +1,308 @@
+import fs from "fs"
+import path from "path"
+import { URL } from "url"
+import crypto from "crypto"
+import mime from 'mime'
+import * as inquirer from "@inquirer/prompts"
+import { setTimeout } from 'node:timers/promises';
+
+import { Gitlab } from "@gitbeaker/rest"
+
+import { __releaseDir, releaseConf, $ } from './prepare'
+import { logger } from "./logger"
+
+export async function isGitFlowRepo() {
+  try {
+    let { stdout } = await $('git config', ['--get-regexp', `^gitflow\.`])
+    return stdout.toString().length > 0;
+  } catch (error) {
+    console.error("🚀 ~ doGitFlowRelease ~ error:", error)
+  }
+
+  return false;
+}
+
+async function getRepo() {
+  const res = await $`git remote -v `.pipe` sed -n '1p'`.pipe`awk -F ' ' '{print $2}'`.pipe`sed -e 's/.git//'`;
+  const repo = res.stdout.replace("\n", "");
+
+  if (repo.startsWith("git@")) {
+    const ps = repo.split("/");
+    return {
+      isHttpRepo: false,
+      repo: repo.split(":")[1],
+      repoName: ps[ps.length - 1].replace(".git", "")
+    };
+  }
+
+  const url = new URL(repo);
+  const ps = url.pathname.split("/");
+
+  return {
+    isHttpRepo: true,
+    repo: url.pathname,
+    origin: url.origin,
+    repoName: ps[ps.length - 1]
+  };
+}
+
+async function getChangeLog(host: string, newVersion: string, userSelectedLatestTag: string, markdownUrls: { tar: string, md5: string, doc: string }) {
+  async function getLog() {
+    let output = "";
+    try {
+      /** 
+       * 判断是否为gitflow 
+       *  
+       *  --> 是 获取最近两次tag 之间的commit记录，  若不足两次，则获取最新一次往前的所有记录
+       *  --> 否 获取最近一次tag 之后的commit记录
+       */
+
+      const isGitFlow = await isGitFlowRepo();
+
+      const { stdout } = await $`git tag --sort=-creatordate`;
+      const tags = stdout.split('\n');
+      const latestTag = tags[0]
+      let tagRange = '';
+      if (isGitFlow) {
+        if (tags.length >= 2) {
+          const secondLastTag = userSelectedLatestTag !== '' ? userSelectedLatestTag : tags[1]
+          tagRange = `${secondLastTag}..${latestTag}`
+        } else if (tags.length === 1) {
+          tagRange = latestTag;
+        }
+      } else {
+        if (tags.length >= 1) {
+          tagRange = `${latestTag}..HEAD`;
+        } 
+      }
+      
+      let logCmd = `git log ${tagRange} --format=%B%H----DELIMITER---- --abbrev-commit`;
+      const { stdout: r } = await $(logCmd);
+      output = r;
+    } catch (error) {
+      console.error("🚀 ~ getLog ~ error:", error)
+      const { stdout: r } = await $`git log --format=%B%H----DELIMITER----`;
+      output = r;
+    }
+
+    return output;
+  }
+
+  const output = await getLog();
+
+  const commitsArray = output
+    .split("----DELIMITER----\n")
+    .map(commit => {
+      const [message, sha] = commit.split("\n").filter(msg => msg != "" && !msg.startsWith("Merge"));
+      return { sha, message };
+    })
+    .filter(commit => Boolean(commit.sha));
+
+  let currentChangelog = "";
+
+  // if (fs.existsSync(path.resolve(__dirname, "../CHANGELOG.md"))) {
+  //   currentChangelog = fs.readFileSync(path.resolve(__dirname, "../CHANGELOG.md"), "utf-8");
+  // }
+
+  const { repo } = await getRepo();
+
+  // 用version和时间作为release 标记
+  let newChangelog = ``;// `# ${newVersion} (${new Date().toISOString().split("T")[0]})\n\n`;
+
+  let features: string[] = [];
+  let Bugfixes: string[] = [];
+
+  // 分别维护features和bugfixes的内容，并将message和commit的链接进行绑定
+  commitsArray.forEach(commit => {
+    const commitSha = `([${commit.sha.substring(0, 6)}](${host}/${repo}/-/commit/${commit.sha}))`;
+
+    if (commit.message.startsWith("feat:") || commit.message.startsWith("feat：")) {
+      const feats = commit.message.replace(/feat[:|：]/, "").replace(/;|；/g, "$").split("$");
+      features = features.concat(feats.map(f => `* ${f.replace(/^\s+/, "")} ${commitSha}\n`,));
+
+    }
+    if (commit.message.startsWith("fix:") || commit.message.startsWith("fix：")) {
+      const fixes = commit.message.replace(/fix[:|：]/, "").replace(/;|；/g, "$").split("$");
+      Bugfixes = Bugfixes.concat(fixes.map(f => `* ${f.replace(/^\s+/, "")} ${commitSha}\n`,));
+    }
+  });
+
+  if (features.length) {
+    newChangelog += `# Features\n`;
+    features.forEach(feature => {
+      newChangelog += feature;
+    });
+    newChangelog += "\n";
+  }
+
+  if (Bugfixes.length) {
+    newChangelog += `# Bugfixes\n`;
+    Bugfixes.forEach(bugfix => {
+      newChangelog += bugfix;
+    });
+    newChangelog += "\n";
+  }
+  console.log("🚀 ~ getChangeLog ~features & Bugfixes:", features, Bugfixes)
+
+  // add attach
+  newChangelog += `# Artifacts\n`;
+  newChangelog += `## tar包\n`;
+  newChangelog += `${markdownUrls.tar}\n`;
+
+  newChangelog += `## md5\n`;
+  newChangelog += `${markdownUrls.md5}\n`;
+
+  newChangelog += `## 文档\n`;
+  newChangelog += `${markdownUrls.doc}\n`;
+
+
+  // prepend the newChangelog to the current one
+  return `${newChangelog}${currentChangelog}`;
+}
+
+export async function getGitTags(){
+  const { stdout } = await $`git tag --sort=-creatordate`;
+  return stdout.split('\n');
+}
+
+export async function selectLatestTag(targetVersion: string){
+  let latestTag = '';
+  const tags = await getGitTags();
+
+  if(tags.length >= 2){
+    const ac = new AbortController(); 
+   const prompt = inquirer
+    .select(
+      {
+        message: '请选择发布信息从哪次tag开始生成，（默认： 最近一次，特别针对某主版本之间有小版本过渡的情况）(timing out in 10 seconds)：',
+        default: tags[0],
+        choices: tags.filter(item => item !== targetVersion).map(tag => ({ value: tag})),
+      },
+    )
+    prompt
+      .finally(() => {
+        ac.abort();
+      })
+      // Silencing the cancellation error.
+      .catch(() => {});
+
+    const defaultValue = setTimeout(10000, 'timeout', { signal: ac.signal }).then(() => {
+      prompt.cancel();
+      return tags[0];
+    });
+
+    latestTag = await Promise.race([defaultValue, prompt]);
+  }
+
+  return latestTag
+}
+
+export async function publish(params: {
+  version: string;
+  pkgName: string;
+  appName: string;
+  remoteBranch: string;
+  userSelectedLatestTag: string
+}) {
+  const {
+    version,
+    pkgName,
+    appName,
+    remoteBranch,
+    userSelectedLatestTag = ''
+  } = params || {};
+ 
+  try {
+    const { repo } = await getRepo();
+
+    const { host, token } = releaseConf; 
+
+    logger.tip('start to publish');
+    
+    const api = new Gitlab({
+      host,
+      token,
+      rejectUnauthorized: false
+    });
+
+    const projects = await api.Projects.all();
+
+    const proj = projects.find(item => item.path_with_namespace === repo);
+
+    if (proj === undefined) {
+      throw Error(`The target repo not founded!`);
+    }
+
+    const id = proj.id;
+
+    const assetFile = path.resolve(__releaseDir, pkgName);
+    const file = fs.readFileSync(assetFile);
+
+    const hash = crypto.createHash("md5");
+    hash.update(file);
+    const md5 = hash.digest("hex");
+    const md5FileName = `${appName}_${version}.md5.txt`;
+
+    // 读取doc目录下所有文档并上传
+    const docPath = path.join(__releaseDir, "doc")
+    // 替换文件档中的变量
+    const replacedConstants = [["\\$APP_NAME\\$", appName], ["\\$VERSION\\$", version], ["\\$TAR_PKG\\$", pkgName]];
+
+    const docUploadsPromises = fs.readdirSync(docPath)
+      .map(docFIleName => {
+        const docFilePath = path.resolve(docPath, docFIleName)
+        const stats = fs.statSync(docFilePath)
+        if (stats.isFile()) {
+          let content = fs.readFileSync(docFilePath).toString();
+
+          const doc = replacedConstants.reduce((prev, [reg, value]) => {
+            return prev.replace(new RegExp(reg, 'g'), value);
+          }, content)
+ 
+          return api.Projects.uploadForReference(id, { content: new Blob([doc], { type: mime.getType(docFIleName)! }), filename: docFIleName })
+        }
+      }).filter(item => item)
+
+    logger.info('start to upload resources')
+    const [tarUploads, md5Uploads, ...docUploads] = await Promise.all([
+      api.Projects.uploadForReference(id, { content: new Blob([file], { type: 'application/gzip' }), filename: pkgName }),
+      api.Projects.uploadForReference(id, { content: new Blob([md5], { type: 'text/plain' }), filename: md5FileName }),
+      ...docUploadsPromises,
+    ]);
+    
+    const description = await getChangeLog(host, version, userSelectedLatestTag, { tar: tarUploads.markdown, md5: md5Uploads.markdown, doc: docUploads.map(item => item!.markdown).join('\n') });
+
+    logger.tip("start tag and release to git repo") 
+
+    const tags = await api.Tags.all(id);
+    if (tags.find(r => r.name === version) === undefined) {
+      await api.Tags.create(id, version, remoteBranch);
+    }
+
+    const releases = await api.ProjectReleases.all(id);
+    let res;
+    if (releases.find(r => r.name === version)) {
+      res = await api.ProjectReleases.edit(id, version, {
+        description
+      });
+    } else {
+      res = await api.ProjectReleases.create(id, {
+        tag_name: version,
+        description
+      });
+    }
+
+    // 通过assets api 发布 artifacts
+    await api.ReleaseLinks.create(id, version, pkgName, `${host}${tarUploads.full_path}`, { linkType: "package" });
+    await api.ReleaseLinks.create(id, version, md5FileName, `${host}${md5Uploads.full_path}`, { linkType: "other" });
+    await Promise.all(docUploads.map(doc => api.ReleaseLinks.create(id, version, doc!.alt, `${host}${doc!.full_path}`, { linkType: "other" })));
+
+    fs.unlinkSync(assetFile);
+
+    logger.success(`Successfully released at: ${res._links.self} `)
+  } catch (error) {
+    logger.error("🚀 ~ file: publish.js ~ error:")
+    console.error(error);
+    return Promise.reject(error)
+  }
+}

package/src/release.ts

@@ -0,0 +1,292 @@
+import * as inquirer from "@inquirer/prompts"
+import process from "process"
+import pc from "picocolors"
+
+import { pack } from './pack'
+import { getGitTags, isGitFlowRepo, publish, selectLatestTag } from './publish'
+
+import { __releaseDir, releaseConf, $, checkEnvInfo } from './prepare'
+import { ResultPromise } from "execa"
+
+import { logger } from './logger';
+
+export async function release(fromPublishCmd = false) {
+  try {
+    await checkEnvInfo();
+
+    await hasUncommittedChanges();
+
+    // 保存当前分支信息，打包发布完成后切回当前分支
+    let { stdout: originalBranch } = await $(`git branch --show-current`)
+
+    /**
+     * 
+     * a. 指定版本号tag
+     * 
+     * b. 是否遵循git flow 发布流程，
+     *  
+     *    1. 是 --> 测是否是develop分支，
+     * 
+     *             --> 是 同步develop，走git flow release到master, 并从远程master 切tag 打包并上传
+     *             --> 否  检测是否为release 分支，
+     *                     --> 是， 走git flow release 到master, 并从远程master 切tag 打包并上传
+     *                     --> 提示，分支错误
+     *    2. 否 --> 选择指定的远程分支，
+     * c. 选择从哪个分支生成release msgs
+     *    --> 默认最新发布分支
+     *    --> 自定义 
+     * d. 从指定分支或master 并打tag 和打包并上传 
+     */
+
+    // 获取版本号
+    let version = await inquirer
+      .input({
+        message: '请输入版本号：',
+      },)
+
+    if (version == '') {
+      logger.error('版本号不能为空！')
+      return
+    }
+    // 补齐v开头 如果是数字开头
+    if (/^\d/.test(version)) {
+      version = `v${version}`
+    }
+
+    // 版本号检测
+    const tags = await getGitTags();
+    if (tags.some(tag => tag === version)) {
+      logger.error('版本号已存在，请更换版本号！')
+      return;
+    }
+ 
+
+    let remoteTargetBranch = 'master';
+    if (fromPublishCmd) {
+      remoteTargetBranch = await doCustomSpecifyBranchRelease()
+    } else {
+      const releaseWay = await inquirer
+        .select(
+          {
+            message: '请选择发布方式：',
+            default: '1',
+            choices: [
+              {
+                name: 'Git flow流程发布',
+                value: '1',
+                description: '遵循Git flow流程，需保证仓库已初始化为git flow模式, 以master为远程分支，打Tag',
+              },
+              {
+                name: '自定义分支打包发布',
+                value: '2',
+                description: '自定义指定远程分支，打Tag的方式',
+              },
+            ]
+          },
+        )
+
+      if (releaseWay === '1') {
+        remoteTargetBranch = await doGitFlowRelease(version);
+      } else if (releaseWay === '2') {
+        remoteTargetBranch = await doCustomSpecifyBranchRelease()
+      } else {
+        logger.error(`发布方式不能为空`)
+        return
+      }
+
+      if (remoteTargetBranch == null) {
+        logger.error(`目标发布分支不能为空`)
+        return
+      }
+    }
+
+    logger.tip(`start build and pack`)
+
+    // 切换到指定分支 同步remote后 打包 
+    await execGitCheckout(remoteTargetBranch);
+
+    await execGitPullOrigin(remoteTargetBranch);
+
+    // 选择从哪个tag开始生成release 信息
+    const userSelectedLatestTag = await selectLatestTag(version);
+
+    await execWithPipe(releaseConf.buildCmd)
+
+    const source = await pack(version);
+
+    if (source === undefined) {
+      return
+    }
+
+
+    await publish({ ...source, remoteBranch: remoteTargetBranch, userSelectedLatestTag });
+
+    logger.info(pc.green('done'))
+
+    // 切换回起始分支 
+    await execGitCheckout(originalBranch)
+  } catch (error) {
+    console.error('Error:', error);
+  }
+}
+
+
+async function doGitFlowRelease(version: string) {
+  // 检查 .git/config 中是否存在 gitflow 配置
+  const isGitFlow = await isGitFlowRepo();
+  if (!isGitFlow) {
+    logger.error('当前仓库 非git flow仓库，请使用git flow init 初始化后，再执行此命令')
+    process.exit(1);
+  }
+
+  // 获取当前所属分支
+  let { stdout: currentBranch } = await $(`git branch --show-current`) 
+
+  const releaseBranch = `release/${version}`
+  if (currentBranch !== 'develop' && currentBranch !== releaseBranch) {
+    // await hasUncommittedFiles();
+    /** 
+     * 判断是否已存在 release/version 分支
+     *   是--> 如果本地是否此分支
+     *          -->否 checkout -b 指定分支
+     *          -->是 checkout 指定分支
+     *   否--> 切换到develop分支 
+     */
+    const { stdout } = await $('git branch -a');
+    const branches = stdout.split('\n').map(branch => branch.trim().replace(/^\* /, ''));
+    const preReleaseBranch = branches.includes(releaseBranch) ? releaseBranch : 'develop'
+    await execGitCheckout(preReleaseBranch)
+  }
+
+  if (currentBranch === 'develop') {
+    await execGitPullOrigin(`develop`)
+
+    const flowReleaseRes = await execWithPipe(`git flow release start ${version}`)
+    if (!(flowReleaseRes.stdout.indexOf(`A new branch '${releaseBranch}' was created`) > -1)) {
+      logger.error('执行 git flow release 失败')
+      process.exit(1);
+    }
+  } else {
+    try {
+      await execGitPullOrigin(releaseBranch)
+    } catch (error) {
+      console.error("🚀 ~ doGitFlowRelease ~ error:", error)
+      if (!(error && error.toString().indexOf(`fatal: couldn't find remote ref ${releaseBranch}`) > -1)) {
+        logger.error(`同步分支： ${releaseBranch} 失败`)
+        process.exit(1);
+      }
+    }
+  }
+
+  // 添加版本到package.json
+  try {
+    const npmVersionRes = await $(`npm version ${version} --no-git-tag-version`)
+    if (npmVersionRes.stderr) {
+      logger.error('添加版本信息到package.json失败')
+      process.exit(1);
+    }
+
+    logger.info(pc.green(`添加 ${version} 版本信息到package.json 成功`))
+  } catch (error) {
+    if (error && error.toString().indexOf('npm error Version not changed') == -1) {
+      logger.error('添加版本信息到package.json失败')
+      process.exit(1);
+    }
+  }
+  const hasUncommitted = await hasUncommittedChanges(true);
+
+  if (hasUncommitted) {
+    await $(`git add -A`)
+    await $('git commit', ['-m', `Release version: ${version}`, '--no-verify'])
+  }
+
+  await execWithPipe(`git flow release finish`, [version, '-m', `Release version: ${version}`]);
+  // if (releaseFRes.stderr) {
+  //   logger.error('执行 git flow release finish 失败')
+  //   process.exit(1);
+  // }
+
+  // 同步到远端
+  await $(`git push --all`)
+  await $(`git push --tags`)
+
+  return 'master'
+}
+
+async function doCustomSpecifyBranchRelease() {
+
+  const { stdout } = await $('git branch -r');
+  const branches = stdout.split('\n').map(branch => branch.trim()).filter(item => !item.startsWith('origin/HEAD')).map(branch => ({ value: branch.replace('origin/', '') }));
+
+  const selectedBranch = await inquirer.select({
+    message: '请选择目标分支, 分支未找到，请先将本地分支推到远端，再执行此命令',
+    choices: branches
+  })
+  
+  return selectedBranch;
+}
+
+
+async function hasUncommittedChanges(boolReturned = false) {
+  // 检查当前分支是否存在未提交文件
+  const { stdout: uncommitted } = await $`git status --porcelain`
+
+  if (boolReturned) {
+    return !!uncommitted.toString().length
+  }
+
+  if (uncommitted.toString().length) {
+    logger.error('当前分支存在尚未提交的文件，请提交后再运行此命令')
+    return Promise.reject(true)
+  }
+
+  return Promise.resolve(false);
+}
+
+
+async function execGitPullOrigin(remoteTargetBranch: string) {
+  logger.tip(`${ remoteTargetBranch} syncing...`)
+
+  const syncReleaseBranchRes = $('git', ['pull', 'origin', remoteTargetBranch])
+  syncReleaseBranchRes.stdout.pipe(process.stdout)
+  syncReleaseBranchRes.stderr.pipe(process.stderr)
+  const res = await syncReleaseBranchRes;
+  // fatal: unable to access 'https://github.com/user/repo.git/': Could not resolve host: xxx
+  // fatal: unable to access 'https://github.com/user/repo.git/':
+  // fatal: Couldn't find remote ref chore/releset_test  ...
+  if (res.stdout.indexOf('fatal:') > -1 || res.stderr.indexOf('fatal:') > -1) {
+    logger.error(`同步${remoteTargetBranch} 失败`)
+    process.exit(1);
+  }
+}
+
+async function execWithPipe(...args: any[]) {
+  const execRes = $(...args as Parameters<typeof $>) as unknown as ResultPromise<{
+    encoding: "utf8";
+  }>
+  execRes.stdout.pipe(process.stdout);
+  execRes.stderr.pipe(process.stderr);
+  const result = await execRes
+  return result
+}
+
+
+async function execGitCheckout(remoteTargetBranch: string) {
+  await hasUncommittedChanges();
+
+  const { stdout: prevCurrentBranch } = await $(`git branch --show-current`)
+
+  if (prevCurrentBranch !== remoteTargetBranch) {
+    const execRes = $(`git checkout ${remoteTargetBranch}`)
+    execRes.stdout.pipe(process.stdout);
+    execRes.stderr.pipe(process.stderr);
+    const result = await execRes;
+
+    const { stdout: currentBranch } = await $(`git branch --show-current`)
+
+    if (currentBranch !== remoteTargetBranch) {
+      logger.error(`目标发布分支[${remoteTargetBranch}] checkout 失败`)
+      return Promise.reject(result);
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "include": ["src"],
+  "exclude": ["node_modules"],
+  "compilerOptions": {
+    "module": "ES2022",
+    "target": "ES2022",
+    "moduleResolution": "Node",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noUnusedLocals": true
+  }
+}