@rpcbase/cli 0.37.0 → 0.38.0

package/bin.js

@@ -51,16 +51,24 @@ yargs(hideBin(process.argv))
     await update()
   })
   // sync-dotenv
-  .command(["sync-dotenv"], "Compare and sync dotenv files", (yargs) => {
+  .command("sync-dotenv [source_env] [dest_env]", "Compare and sync dotenv files", (yargs) => {
     yargs
       .option("write", {
         type: "boolean",
         default: false,
         description: "Write the ouput to dest env file"
       })
+      .positional("source_env", {
+        describe: "source .env file",
+        type: "string"
+      })
+      .positional("dest_env", {
+        describe: "destination env file",
+        type: "string"
+      })
   }, async(argv) => {
     if (argv.version) return print_versions()
-    await sync_dotenv()
+    await sync_dotenv(argv.source_env, argv.dest_env)
   })
   // Ping
   .command("ping", "Ping", () => {}, (argv) => {

package/package.json

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

package/src/sync-dotenv/index.js

@@ -1,137 +1,125 @@
+/* @flow */
 const path = require("path")
 const fs = require("fs")
 const os = require('os')
-const parseEnv = require("parse-dotenv")
-const dotenv = require("dotenv")
+const parse_env = require("parse-dotenv")
+
 
 const DEFAULT_ENV_PATH = path.resolve(process.cwd(), ".env")
-const DEFAULT_SAMPLE_ENV = path.resolve(process.cwd(), ".env.sample")
+const SAMPLE_ENV_SUFFIX = ".sample"
+const COMMENT_PREFIX = "__COMMENT_"
 
-const envToString = (parsed) =>
+const env_to_string = (parsed) =>
   Object.keys(parsed)
     .map(key => `${key}=${parsed[key] || ""}`)
     .join(os.EOL)
     .replace(/(__\w+_\d+__=)/g, "")
 
-const writeToSampleEnv = (path, parsedEnv) => {
+
+const write_to_dest_env = (path, parsed_env) => {
   try {
-    fs.writeFileSync(path, envToString(parsedEnv))
+    fs.writeFileSync(path, env_to_string(parsed_env))
   } catch (e) {
     throw new Error(`Sync failed. ${e.message}`)
   }
 }
 
-const emptyObjProps = (obj) => {
-  const objCopy = { ...obj }
-  Object.keys(objCopy).forEach(key => {
-    if (objCopy[key].includes("#")) {
-      if (objCopy[key].match(/(".*"|'.*')/g)) {
-        const objArr = objCopy[key].split(/(".*"|'.*')/)
-        objCopy[key] = objArr.slice(-1)[0].trim()
+
+const get_empty_obj_props = (obj) => {
+
+  const obj_copy = { ...obj }
+
+  Object.keys(obj_copy).forEach(key => {
+    if (obj_copy[key].includes("#")) {
+      if (obj_copy[key].match(/(".*"|'.*')/g)) {
+        const objArr = obj_copy[key].split(/(".*"|'.*')/)
+        obj_copy[key] = objArr.slice(-1)[0].trim()
       } else {
-        const objArr = objCopy[key].split("#")
-        objCopy[key] = `#${objArr.slice(-1)[0]}`
+        const objArr = obj_copy[key].split("#")
+        obj_copy[key] = `#${objArr.slice(-1)[0]}`
       }
 
       return
     }
 
-    if (!key.startsWith("__COMMENT_")) {
-      objCopy[key] = ""
+    if (!key.startsWith(COMMENT_PREFIX)) {
+      obj_copy[key] = ""
     }
   })
 
-  return objCopy
+  return obj_copy
 }
 
-const getUniqueVarsFromEnvs = (
+const get_unique_vars_from_envs = (
   env,
-  envExample,
+  env_example,
   config = {}
 ) => {
-  const ignoreKeys = config.preserve || []
-
-  const uniqueKeys = new Set(Object.keys(env))
-  const uniqueKeysArray = Array.from(uniqueKeys)
+  const unique_keys = new Set(Object.keys(env))
+  const unique_keys_list = Array.from(unique_keys)
 
-  const uniqueFromSource = uniqueKeysArray.map((key) => {
-    if (key.startsWith("__COMMENT_")) return { [key]: env[key] }
-    return { [key]: envExample[key] || "" }
+  const unique_from_source = unique_keys_list.map((key) => {
+    if (key.startsWith(COMMENT_PREFIX)) return { [key]: env[key] }
+    return { [key]: env_example[key] || "" }
   })
 
-  const presevedVars = Object.keys(envExample)
-    .map(key => ({ [key]: envExample[key] }))
+  const preseved_vars = Object.keys(env_example)
+    .map(key => ({ [key]: env_example[key] }))
     // .filter(env => {
     //   console.log("ICICIC", env)
     //   return ignoreKeys.length && ignoreKeys.includes(Object.keys(env)[0])
     // })
 
-  return [...uniqueFromSource, ...presevedVars]
+  return [...unique_from_source, ...preseved_vars]
 }
 
 
-const syncWithSampleEnv = (
-  envPath,
-  envExamplePath
+const sync_with_dest_env = (
+  env_path,
+  env_example_path
 ) => {
   const config = { emptyLines: true, comments: true }
 
-  const sourceEnv = emptyObjProps(
-    parseEnv(envPath, config)
+  const source_env = get_empty_obj_props(
+    parse_env(env_path, config)
   )
-  const targetEnv = parseEnv(envExamplePath)
 
-  const uniqueVars = getUniqueVarsFromEnvs(sourceEnv, targetEnv, config)
-  const envCopy = {}
-  uniqueVars.forEach(env => {
+  const target_env = parse_env(env_example_path)
+
+  const unique_vars = get_unique_vars_from_envs(source_env, target_env, config)
+  const env_copy = {}
+
+  unique_vars.forEach(env => {
     const [key] = Object.keys(env)
-    envCopy[key] = env[key]
+    env_copy[key] = env[key]
   })
 
-  writeToSampleEnv(envExamplePath, envCopy)
+  write_to_dest_env(env_example_path, env_copy)
 }
 
 
 const sync_dotenv = (
-  source,
-  sample_env,
-  samples
+  env_path,
+  _dest_env,
 ) => {
-  if (sample_env && (sample_env === ".env" || path.basename(sample_env) === ".env")) {
-    throw new Error("Cannot sync .env with .env")
+  if (env_path && !fs.existsSync(env_path)) {
+    throw new Error(`env_path: ${env_path} doesn't exist`)
   }
 
-  const sample_env_paths = !samples
-    ? [path.resolve(process.cwd(), sample_env || DEFAULT_SAMPLE_ENV)]
-    : globby
-      .sync(samples)
-      .map((sample) => path.resolve(process.cwd(), sample))
-
-  const envPath = source
-    ? fs.existsSync(source)
-      ? source
-      : null
-    : DEFAULT_ENV_PATH
-
-  if (envPath === null) throw new Error(`${source} not found`)
-
-  if (!source && !fs.existsSync(envPath)) throw new Error(".env doesn't exists")
-
-  if (!sample_env_paths.length)
-    throw new Error(`${samples} did not match any file`)
+  const source_path = env_path || DEFAULT_ENV_PATH
 
-  if (!fs.existsSync(sample_env_paths[0])) {
-    fs.writeFileSync(sample_env_paths[0], "")
-    // throw new Error(`${sample_env || path.basename(DEFAULT_SAMPLE_ENV)} not found`)
+  if (!fs.existsSync(source_path)) {
+    throw new Error(`${env_path || ".env"} file not found`)
   }
 
-  const sourcePath = envPath
+  const dest_env_path = _dest_env || `${source_path}${SAMPLE_ENV_SUFFIX}`
 
-  for (const samplePath of sample_env_paths) {
-    syncWithSampleEnv(sourcePath, samplePath)
+  // creates the sample env file if it doesn't exist
+  if (!fs.existsSync(dest_env_path)) {
+    fs.writeFileSync(dest_env_path, "")
   }
 
-  return sample_env_paths.join(" ")
+  sync_with_dest_env(source_path, dest_env_path)
 }
 
 

package/src/sync-dotenv/LICENSE

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2019 Luqman Olushi O.
-Copyright (c) 2023 rpcbase
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.