@rpcbase/cli 0.45.0 → 0.47.0

package/bin.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /* @flow */
-process.title = "rb"
+process.title = "rb-cli"
 // load .env
 const path = require("path")
 require("dotenv").config({path: path.join(process.cwd(), "./.env")})
@@ -8,7 +8,7 @@ require("dotenv").config({path: path.join(process.cwd(), "./.env")})
 const yargs = require("yargs/yargs")
 const {hideBin} = require("yargs/helpers")
 
-const increment_pkg = require("./src/increment-pkg")
+const increment_pkg = require("./src/versions/increment-pkg")
 const print_versions = require("./src/print_versions")
 const start_command = require("./src/start_command")
 const sync_dotenv = require("./src/sync-dotenv")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpcbase/cli",
-  "version": "0.45.0",
+  "version": "0.47.0",
   "license": "SSPL-1.0",
   "bin": {
     "rb": "./bin.js"

package/src/versions/helpers/sanitize_str.js

@@ -0,0 +1,5 @@
+/* @flow */
+
+const sanitize_str = (str) => str.toLowerCase().replace(/[^a-z0-9]/g, "")
+
+module.exports = sanitize_str

package/src/versions/increment-pkg/get_gh_client.js

@@ -0,0 +1,26 @@
+/* @flow */
+const {Octokit} = require("octokit")
+const colors = require("picocolors")
+
+const get_gh_token = require("./get_gh_token")
+
+
+const get_gh_client = () => {
+  const gh_token = get_gh_token()
+
+  if (!gh_token) return
+
+  const octokit = new Octokit({
+    auth: gh_token
+  })
+
+  if (!octokit) {
+    console.log(colors.bold(colors.yellow("rb increment-pkg:")), "unable to get a github client, do you have a token in .npmrc or .github_token ?")
+    process.exit(0)
+    return
+  }
+
+  return octokit
+}
+
+module.exports = get_gh_client

package/src/versions/increment-pkg/index.js

@@ -0,0 +1,194 @@
+/* @flow */
+const fs = require("fs")
+const path = require("path")
+const {execSync} = require("child_process")
+
+const Promise = require("bluebird")
+const semver = require("semver")
+
+const sanitize_str = require("../helpers/sanitize_str")
+
+const get_gh_client = require("./get_gh_client")
+
+const octokit = get_gh_client()
+
+
+const resolve_repo = () => {
+  const origin_url = execSync("git remote get-url origin").toString().trim()
+  const owner = path.dirname(origin_url).split(":").pop()
+  const repo = path.basename(origin_url).replace(/\.git$/, "")
+
+  const branch_name = execSync("git branch --show-current").toString().trim()
+
+  return {repo, owner, branch_name}
+}
+
+
+const get_latest_branch_version = async({owner, repo, remote_path, branch_name}) => {
+  let res
+  try {
+    res = await octokit.request("GET /repos/{owner}/{repo}/contents/{path}", {
+      owner,
+      repo,
+      path: remote_path,
+      ref: branch_name,
+    })
+  } catch (err) {
+    if (err.response.status === 404) {
+      return
+    } else {
+      console.log(err)
+    }
+  }
+
+  const file_contents = Buffer.from(res.data.content, "base64").toString()
+  const pack_obj = JSON.parse(file_contents)
+  const branch_version = pack_obj.version
+
+  return branch_version
+}
+
+
+const get_remote_next_version = async({owner, repo, branch_name, remote_path, local_version}) => {
+  let remote_version
+  let next_version
+
+  const sanitized_name = sanitize_str(branch_name)
+
+  if (branch_name === "master") {
+    remote_version = await get_latest_branch_version({
+      owner,
+      repo,
+      remote_path,
+      branch_name,
+    })
+
+    // simple bump from version on master
+    if (remote_version && semver.lte(local_version, remote_version)) {
+      next_version = semver.inc(remote_version, "minor")
+    }
+
+  } else {
+    // try to get the remote version on the current branch name (but if the branch hasnt been pushed yet, this will fail and fallback to master)
+    remote_version = await get_latest_branch_version({
+      owner,
+      repo,
+      remote_path,
+      branch_name,
+    })
+
+    // there is already a remote version on a pre-release branch, so we
+    if (remote_version) {
+      // TODO: handle the case where master has been updated and we need to re-bump the minor version + create a pre-release one
+      next_version = semver.inc(remote_version, "prerelease", sanitized_name)
+
+    }
+
+    // fallback to master
+    if (!remote_version) {
+      remote_version = await get_latest_branch_version({
+        owner,
+        repo,
+        remote_path,
+        branch_name: "master",
+      })
+
+      // there was no remote version from this branch yet, so we first increment the master version, when we create a "prerelease" for this branch
+      if (remote_version) {
+        const bumped = semver.inc(remote_version, "minor")
+        next_version = `${bumped}-${sanitized_name}.0`
+      }
+    }
+  }
+
+  if (!remote_version) {
+    console.log(`${owner}/${repo}/${remote_path} remote package version not found, will skip version bump`)
+  }
+
+  return {remote_version, next_version}
+}
+
+
+// lint-staged script to increment package version when any package in the pkg/ folder is modified
+const increment_pkg = async(args) => {
+  const {files} = args
+
+  const touched_packages = {}
+
+  const packages_dir = path.join(process.cwd(), "./pkg")
+
+  files.forEach((f) => {
+    const rel_path = path.relative(packages_dir, f)
+    // get package dirname
+    const [pack_dir] = path.dirname(rel_path).split("/")
+    // check if it is actually a package
+    const pack_json_path = path.join(packages_dir, `./${pack_dir}/package.json`)
+    if (fs.existsSync(pack_json_path)) {
+      touched_packages[pack_dir] = true
+    }
+  })
+
+  const {repo, owner, branch_name} = resolve_repo()
+
+  const process_package = async(pack_dir) => {
+    const local_pack_path = path.join(packages_dir, `./${pack_dir}/package.json`)
+    const local_pack = JSON.parse(fs.readFileSync(local_pack_path))
+
+    const local_version = local_pack.version
+    if (!local_version) {
+      // skipping because package has no local version
+      return
+    }
+
+    if (!semver.valid(local_version)) {
+      console.log("error:", "local version not valid, got:", JSON.stringify(local_version), "skipping")
+      return
+    }
+
+    // get remote + next version
+    const remote_path = `pkg/${pack_dir}/package.json`
+
+    const master_version = await get_latest_branch_version({
+      owner,
+      repo,
+      remote_path,
+      branch_name: "master"
+    })
+
+    if (!master_version || !semver.valid(master_version)) {
+      console.log("error:", "remote master version not valid, got:", JSON.stringify(master_version), "skipping")
+      return
+    }
+
+    const bumped_version = semver.inc(master_version, "minor")
+
+    if (semver.lt(local_version, bumped_version)) {
+      local_pack.version = bumped_version,
+      fs.writeFileSync(local_pack_path, JSON.stringify(local_pack, null, 2) + "\n")
+      execSync(`git add ${local_pack_path}`)
+    }
+
+    // TODO: this will run on the PR workflow but not before commit here, as we only want a minor bump when incrementing from master, the release channels are handled in CI
+    // const {remote_version, next_version} = await get_remote_next_version({owner, repo, branch_name, remote_path, local_version})
+    //
+    // if (!semver.valid(remote_version)) {
+    //   console.log("warning:", "live version not valid, got:", JSON.stringify(remote_version), "skipping")
+    //   return
+    // }
+    //
+    // // if (next_version && semver.neq(remote_version, next_version)) {
+    // if (next_version && semver.neq(local_version, next_version)) {
+    //   console.log("bumped", local_pack.name, "to", next_version)
+    //
+    //   local_pack.version = next_version
+    //
+    //   fs.writeFileSync(local_pack_path, JSON.stringify(local_pack, null, 2) + "\n")
+    //   // add to git index, in case change was not triggered by package.json
+    //   execSync(`git add ${local_pack_path}`)
+    // }
+  }
+
+  await Promise.map(Object.keys(touched_packages), process_package)
+}
+
+module.exports = increment_pkg

package/src/increment-pkg/index.js

@@ -1,125 +0,0 @@
-/* @flow */
-const fs = require("fs")
-const path = require("path")
-const {execSync} = require("child_process")
-
-const colors = require("picocolors")
-const Promise = require("bluebird")
-const semver = require("semver")
-const {Octokit} = require("octokit")
-
-const get_gh_token = require("./get_gh_token")
-
-
-const get_gh_client = () => {
-  const gh_token = get_gh_token()
-
-  if (!gh_token) return
-
-  const octokit = new Octokit({
-    auth: gh_token
-  })
-
-  return octokit
-}
-
-
-const get_latest_live_version = async(pack_dir) => {
-  const octokit = get_gh_client()
-
-  if (!octokit) {
-    console.log(colors.bold(colors.yellow("rb increment-pkg:")), "unable to get a github client, do you have a token in .npmrc or .github_token ?")
-    process.exit(0)
-    return
-  }
-
-  const origin_url = execSync("git remote get-url origin").toString().trim()
-  const owner = path.dirname(origin_url).split(":").pop()
-  const repo = path.basename(origin_url).replace(/\.git$/, "")
-
-  const remote_path = `pkg/${pack_dir}/package.json`
-
-  let res
-  try {
-    res = await octokit.request("GET /repos/{owner}/{repo}/contents/{path}", {
-      owner,
-      repo,
-      path: remote_path,
-    })
-  } catch (err) {
-    if (err.response.status === 404) {
-      console.log(`${owner}/${repo}/${remote_path} remote package not found, skipping version bump`)
-      return
-    } else {
-      console.log(err)
-    }
-  }
-
-  const file_contents = Buffer.from(res.data.content, "base64").toString()
-  const pack_obj = JSON.parse(file_contents)
-  const live_version = pack_obj.version
-
-  return live_version
-}
-
-
-// lint-staged script to increment package version when any package in the pkg/ folder is modified
-const increment_pkg = async(args) => {
-  const {files} = args
-
-  const touched_packages = {}
-
-  const packages_dir = path.join(process.cwd(), "./pkg")
-
-  files.forEach((f) => {
-    const rel_path = path.relative(packages_dir, f)
-    // get package dirname
-    const [pack_dir] = path.dirname(rel_path).split("/")
-    // check if it is actually a package
-    const pack_json_path = path.join(packages_dir, `./${pack_dir}/package.json`)
-    if (fs.existsSync(pack_json_path)) {
-      touched_packages[pack_dir] = true
-    }
-  })
-
-  const process_package = async(pack_dir) => {
-    const local_pack_path = path.join(packages_dir, `./${pack_dir}/package.json`)
-    const local_pack = JSON.parse(fs.readFileSync(local_pack_path))
-
-    const local_version = local_pack.version
-    if (!local_version) {
-      // skipping because package has no local version
-      return
-    }
-
-    const live_version = await get_latest_live_version(pack_dir)
-
-    if (!semver.valid(live_version)) {
-      console.log("warning:", "live version not valid, got:", JSON.stringify(live_version), "skipping")
-      return
-    }
-
-    if (!semver.valid(local_version)) {
-      console.log("error:", "local version not valid, got:", JSON.stringify(local_version), "skipping")
-      process.exit(1)
-      return
-    }
-
-    // if local_version == live_version -> bump
-    if (live_version && semver.eq(local_version, live_version)) {
-      const new_version = semver.inc(local_version, "minor")
-
-      console.log("bumped", local_pack.name, "to", new_version)
-
-      local_pack.version = new_version
-      fs.writeFileSync(local_pack_path, JSON.stringify(local_pack, null, 2) + "\n")
-
-      // add to git index, in case change was not triggered by package.json
-      execSync(`git add ${local_pack_path}`)
-    }
-  }
-
-  await Promise.map(Object.keys(touched_packages), process_package)
-}
-
-module.exports = increment_pkg