@rpcbase/cli 0.3.0

package/bin.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/* @flow */
+const path = require("path")
+require("dotenv").config({path: path.join(__dirname, "./.env")})
+const yargs = require("yargs/yargs")
+const {hideBin} = require("yargs/helpers")
+
+const default_command = require("./src/default_command")
+const run_client = require("./src/run_client")
+const run_server = require("./src/run_server")
+const update = require("./src/update")
+
+let is_command = false
+
+const args = yargs(hideBin(process.argv))
+  .command(["update", "up"], "Update rb dependencies to latest version", () => {}, async(argv) => {
+    is_command = true
+    await update()
+  })
+  .command("ping", "Ping", () => {}, (argv) => {
+    is_command = true
+    console.log("PING")
+  })
+  // .option("version", {
+  //   alias: "v",
+  //   type: "boolean",
+  //   default: false,
+  //   // description: "Displays CLI version"
+  // })
+  .parse()
+
+if (!is_command) {
+  default_command(args)
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@rpcbase/cli",
+  "version": "0.3.0",
+  "license": "SSPL-1.0",
+  "bin": {
+    "rb": "./bin.js"
+  },
+  "scripts": {
+    "test": "echo \"no test specified exiting with code 0\" && exit 0"
+  },
+  "dependencies": {
+    "bluebird": "3.7.2",
+    "chalk": "4.1.2",
+    "concurrently": "7.0.0",
+    "dotenv": "16.0.0",
+    "semver": "7.3.5",
+    "validator": "13.7.0",
+    "yargs": "17.4.0"
+  }
+}

package/src/auto/run_before.js

@@ -0,0 +1,3 @@
+/* @flow */
+
+// check project folder layout

package/src/default_command.js

@@ -0,0 +1,75 @@
+/* @flow */
+const path = require("path")
+const fs = require("fs")
+const chalk = require("chalk")
+const concurrently = require("concurrently")
+
+const exit_with_message = require("./helpers/exit_with_message")
+const get_run_configs = require("./helpers/get_run_configs")
+const docker_runtime_check = require("./helpers/docker_runtime_check")
+const verify_project = require("./verify_project")
+
+
+const default_command = async(args) => {
+  const run_configs = get_run_configs()
+
+  const run_commands = run_configs.map((cfg) => {
+    let name
+    let command
+    let prefixColor
+    if (cfg.type === "client") {
+      name = "client"
+      // command = "yarn dev"
+      command = "./node_modules/.bin/rb-webpack-browser dev"
+      prefixColor = "#C678DD"
+    } else if (cfg.type === "server") {
+      name = "server"
+      command = "./node_modules/.bin/rb-server start"
+      prefixColor = "#61AFEF"
+    }
+
+    // command, name, prefixColor, env, cwd
+    return {
+      name,
+      command,
+      prefixColor,
+      cwd: cfg.working_dir
+    }
+  })
+
+  if (run_configs.filter((c) => c.type === "server").length > 0) {
+    docker_runtime_check()
+  }
+
+  let project_errors
+
+  const {result, commands} = concurrently(run_commands, {
+    killOthers: ["success", "failure"],
+    handleInput: true,
+    defaultInputTarget: "server",
+  })
+
+  result
+    .then(() => {
+      console.log("Done.")
+    })
+    .catch((err) => {
+      if (project_errors?.length >  0) {
+        console.log(`\n${chalk.bold("exited due to configuration errors:")}`)
+        project_errors.forEach((err) => {
+          console.log(err)
+        })
+      }
+    })
+
+  // asynchronously verify project config and kill process if any error
+  project_errors = await verify_project(run_configs)
+
+  if (project_errors.length > 0) {
+    commands.forEach((c) => {
+      c.kill()
+    })
+  }
+}
+
+module.exports = default_command

package/src/errors.js

@@ -0,0 +1,8 @@
+/* @flow */
+const chalk = require("chalk")
+
+const ERRORS = {
+  INVALID_CWD: `expected to run in ${chalk.cyan("client/")} or ${chalk.cyan("server/server/")} or project root directory`
+}
+
+module.exports = ERRORS

package/src/helpers/docker_runtime_check.js

@@ -0,0 +1,14 @@
+/* @flow */
+const {execSync} = require("child_process")
+const chalk = require("chalk")
+
+const docker_runtime_check = () => {
+  try {
+    execSync("docker version -f json")
+  } catch (err) {
+    console.log(chalk.cyan.bold("docker"), "exited with error")
+    process.exit(1)
+  }
+}
+
+module.exports = docker_runtime_check

package/src/helpers/exit_with_message.js

@@ -0,0 +1,12 @@
+/* @flow */
+const chalk = require("chalk")
+
+const exit_with_message = (message = "", code = 1) => {
+  console.log(chalk.red("error:"), message)
+
+  // TODO: sentry(?) report error
+
+  process.exit(code)
+}
+
+module.exports = exit_with_message

package/src/helpers/get_run_configs.js

@@ -0,0 +1,57 @@
+/* @flow */
+const path = require("path")
+const fs = require("fs")
+
+const ERRORS = require("../errors")
+const exit_with_message = require("./exit_with_message")
+
+
+// run type is client | server | both
+const get_run_configs = () => {
+  const cwd = process.cwd()
+
+  // check if running parent of rb project
+  const dir_contents = fs.readdirSync(cwd)
+  const is_parent_dir = dir_contents.includes("client") && dir_contents.includes("server")
+
+  // check if rb is running in client or server
+  const dir = path.basename(cwd)
+  const is_rb_dir = ["client", "server"].includes(dir)
+
+  if (!is_parent_dir && !is_rb_dir) {
+    exit_with_message(ERRORS.INVALID_CWD)
+    return
+  }
+
+  if (is_parent_dir) {
+    return [
+      {
+        type: "client",
+        working_dir: path.join(cwd, "./client")
+      },
+      {
+        type: "server",
+        working_dir: path.join(cwd, "./server/server")
+      },
+    ]
+  } else {
+    // client
+    if (dir === "client") {
+      return [{
+        type: "client",
+        working_dir: cwd
+      }]
+    // check if parent dir is also server, because we are in server/server
+    } else if (dir === "server" && path.basename(path.dirname(cwd)) === "server") {
+      return [{
+        type: "server",
+        working_dir: cwd
+      }]
+    }
+  }
+
+  // fails when no match found
+  exit_with_message(ERRORS.INVALID_CWD)
+}
+
+module.exports = get_run_configs

package/src/run_client.js

@@ -0,0 +1,5 @@
+/* @flow */
+const path = require("path")
+const fs = require("fs")
+
+// console.log("runclient")

package/src/update/index.js

@@ -0,0 +1,71 @@
+/* @flow */
+const fs = require("fs")
+const path = require("path")
+const util = require("util")
+const {execSync} = require("child_process")
+
+const exec = util.promisify(require("child_process").exec)
+
+
+const get_package_files = () => {
+  const working_dir = process.cwd()
+  const out = execSync(`find . -name "package.json" -not -path ".*/node_modules/*"`)
+  const files = out.toString().trim().split("\n")
+    .map((f) =>  path.join(working_dir, f))
+  return files
+}
+
+const get_outdated = async(dir) => {
+
+  const output = execSync("npm outdated --json || true", {cwd: dir})
+  const outdated = JSON.parse(output.toString())
+
+  // WARNING: we only filter rpcbase deps for now
+  const target_deps = {}
+  Object.keys(outdated)
+    .filter((name) => name.startsWith("@rpcbase"))
+    .forEach((key) => {
+      target_deps[key] = outdated[key].latest
+    })
+
+  return target_deps
+}
+
+
+const update = async() => {
+  const working_dir = process.cwd()
+
+  const package_files = get_package_files()
+
+  for (let i = 0; i < package_files.length; i++) {
+    const package_file = package_files[i]
+    const dir = path.dirname(package_file)
+
+    console.log("updating", path.relative(working_dir, dir) || ".")
+
+    const outdated = await get_outdated(dir)
+
+    const package_json = JSON.parse(fs.readFileSync(package_file, "utf8"))
+
+    let has_updates = false
+
+    Object.keys(outdated).forEach((k) => {
+      if (package_json.dependencies[k]) {
+        package_json.dependencies[k] = outdated[k]
+        console.log("updated", k, "to", outdated[k])
+        has_updates = true
+      }
+    })
+
+    if (has_updates) {
+      fs.writeFileSync(package_file, `${JSON.stringify(package_json, null, 2)}\n`)
+      execSync("yarn", {cwd: dir, stdio: "inherit"})
+    }
+  }
+
+
+
+
+}
+
+module.exports = update

package/src/verify_project/index.js

@@ -0,0 +1,59 @@
+/* @flow */
+const path = require("path")
+const _ = require("lodash")
+const chalk = require("chalk")
+const Promise = require("bluebird")
+
+const verify_packages_installed = require("./verify_packages_installed")
+const verify_env = require("./verify_env")
+
+const get_root_dir = (run_configs) => {
+  let project_root_dir
+  if (run_configs[0].type === "server") {
+    project_root_dir = path.join(run_configs[0].working_dir, "../../")
+  } else if (run_configs[0].type === "client") {
+    project_root_dir = path.join(run_configs[0].working_dir, "../")
+  }
+
+  if (!project_root_dir) {
+    throw new Error("unable to find project root dir")
+  }
+
+  return project_root_dir
+}
+
+
+const verify_project = async(run_configs) => {
+  let result_errors = []
+
+  const project_root_dir = get_root_dir(run_configs)
+
+  // check if all installed packages match semver in package json file
+  const deps_errors = _.flatten(
+    await Promise.map(run_configs.map(({working_dir}) => working_dir), verify_packages_installed(project_root_dir))
+  )
+
+  if (deps_errors.length > 0) {
+    let error_str = `${chalk.bold.red("error:")} the following packages are missing from your ${chalk.bold("node_modules")}\n`
+    deps_errors.forEach((err) => {
+      error_str += `  ${err}\n`
+    })
+    error_str += `\n  run ${chalk.bold("yarn install")} to ensure dependencies are installed\n`
+    result_errors.push(error_str)
+  }
+
+  // get env file from server and validate required services and ports
+  const env_errors = await verify_env(project_root_dir)
+  if (env_errors.length > 0) {
+    let error_str = `${chalk.bold.red("error:")} ${chalk.bold(".env")} misconfigurations\n`
+    env_errors.forEach((err) => {
+      error_str += `  ${err}\n`
+    })
+    result_errors.push(error_str)
+  }
+
+  return result_errors
+}
+
+
+module.exports = verify_project

package/src/verify_project/verify_env.js

@@ -0,0 +1,83 @@
+/* @flow */
+const fs = require("fs")
+const path = require("path")
+const chalk = require("chalk")
+const dotenv = require("dotenv")
+const validator = require("validator")
+
+
+const validate_port = (val) => {
+  if (!validator.isPort(val)) {
+    return `expected ${chalk.bold(val)} to be a valid port number`
+  }
+}
+
+const SERVICES = [
+  {
+    name: "client",
+    required_env: {
+      "CLIENT_PORT": validate_port
+    },
+  },
+  {
+    name: "server",
+    required_env: {
+      "SERVER_PORT": validate_port
+    },
+  },
+  {
+    name: "database0",
+    required_env: {
+      "DATABASE_PORT_0": validate_port,
+      "DATABASE_NAME": (val) => {
+        if (!/^[$A-Z_][0-9A-Z_$-]*$/i.test(val)) {
+          return `expected ${chalk.bold(`'${val}'`)} to be a valid database name`
+        }
+      }
+    },
+  },
+  {
+    name: "database1",
+    required_env: {
+      "DATABASE_PORT_1": validate_port
+    },
+  },
+  {
+    name: "database2",
+    required_env: {
+      "DATABASE_PORT_2": validate_port
+    },
+  },
+]
+
+
+// TODO: service definitions should be validated in docker compose as well
+const verify_env = async(root_dir) => {
+  const env_path = path.join(root_dir, "./server/server/.env")
+  const env_buf = fs.readFileSync(env_path)
+  const parsed_env = dotenv.parse(env_buf)
+
+  const result_errors = []
+
+  SERVICES.forEach((service) => {
+    Object.keys(service.required_env).forEach((k) => {
+      const val_fn = service.required_env[k]
+      const env_val = parsed_env[k]
+
+      if (!env_val) {
+        result_errors.push(`${chalk.yellow.bold(k)} is missing`)
+        return
+      }
+
+      const err = val_fn(env_val)
+      if (err) {
+        result_errors.push(`${chalk.yellow.bold(k)} ${err}`)
+      }
+    })
+  })
+
+  return result_errors
+}
+
+
+module.exports = verify_env

package/src/verify_project/verify_packages_installed.js

@@ -0,0 +1,47 @@
+/* @flow */
+const path = require("path")
+const fs = require("fs")
+const util = require("util")
+const chalk = require("chalk")
+const semverSatisfies = require("semver/functions/satisfies")
+
+const exec = util.promisify(require("child_process").exec)
+
+const LIST_CMD = "npm ls --depth=0 --json || true"
+
+const get_installed_pkgs = async(wd) => {
+  const {stdout: npm_out} = await exec(LIST_CMD, {cwd: wd})
+  const npm_json = JSON.parse(npm_out)
+  const deps = npm_json.dependencies || {}
+
+  const result = {}
+  Object.keys(deps).forEach((k) => {
+    result[k] = deps[k].version
+  })
+
+  return result
+}
+
+
+// check that packages in node_modules match package.json with semver
+const verify_packages_installed = (root_dir) => async(wd) => {
+  const rel_dir = path.relative(root_dir, wd)
+
+  const pack_path = path.join(wd, "./package.json")
+  const pack = JSON.parse(fs.readFileSync(pack_path))
+  const deps = pack.dependencies || {}
+
+  const installed = await get_installed_pkgs(wd)
+
+  const result_errors = []
+
+  Object.keys(deps).forEach((k) => {
+    if (!installed[k]) {
+      result_errors.push(`${chalk.yellow.bold(k)} is missing in ${chalk.bold(rel_dir + "/")}`)
+    }
+  })
+
+  return result_errors
+}
+
+module.exports = verify_packages_installed

package/src/watch/client/index.js

@@ -0,0 +1 @@
+/* @flow */