@karmaniverous/get-dotenv 2.6.8 → 3.0.1

package/dist/default/lib/getDotenv.js

@@ -7,7 +7,8 @@ exports.getDotenvSync = exports.getDotenv = void 0;
 var _dotenvExpand = require("dotenv-expand");
 var _fsExtra = _interopRequireDefault(require("fs-extra"));
 var _path = _interopRequireDefault(require("path"));
-var _uuid = require("uuid");
+var _nanoid = require("nanoid");
+var _dotenvDefaults = require("./dotenvDefaults.js");
 var _readDotenv = require("./readDotenv.js");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 // npm imports
@@ -19,19 +20,21 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  *
  * @typedef {Object} OptionsType
  *
- * @property {string} [dotenvToken] - token indicating a dotenv file (default: '.env')
+ * @property {string} [dotenvToken] - token indicating a dotenv file
  * @property {string} [dynamicPath] - path to file exporting an object keyed to dynamic variable functions
  * @property {string} [env] - target environment
- * @property {bool} [excludeDynamic] - exclude dynamic variables (default: false)
- * @property {bool} [excludeEnv] - exclude environment-specific variables (default: false)
- * @property {bool} [excludeGlobal] - exclude global & dynamic variables (default: false)
- * @property {bool} [excludePrivate] - exclude private variables (default: false)
- * @property {bool} [excludePublic] - exclude public variables (default: false)
- * @property {bool} [loadProcess] - load dotenv to process.env (default: false)
- * @property {bool} [log] - log result to console (default: false)
+ * @property {bool} [excludeDynamic] - exclude dynamic variables
+ * @property {bool} [excludeEnv] - exclude environment-specific variables
+ * @property {bool} [excludeGlobal] - exclude global & dynamic variables
+ * @property {bool} [excludePrivate] - exclude private variables
+ * @property {bool} [excludePublic] - exclude public variables
+ * @property {bool} [loadProcess] - load dotenv to process.env
+ * @property {bool} [log] - log result to logger
+ * @property {function} [logger] - logger function
  * @property {string} [outputPath] - if populated, writes consolidated .env file to this path (follows {@link https://github.com/motdotla/dotenv-expand/blob/master/tests/.env dotenv-expand rules})
- * @property {string[]} [paths] - array of input directory paths (default ['./'])
- * @property {string} [privateToken] - token indicating private variables (default: 'local').
+ * @property {string[]} [paths] - array of input directory paths
+ * @property {string} [privateToken] - token indicating private variables
+ * @property {object} [vars] - explicit variables to include
  */
 
 /**
@@ -45,40 +48,52 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * @returns {Promise<object>} The combined parsed dotenv object.
  */
 const getDotenv = async function () {
+  let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  // Apply defaults.
   let {
-    dotenvToken = '.env',
+    dotenvToken,
     env,
     dynamicPath,
-    excludeDynamic = false,
-    excludeEnv = false,
-    excludeGlobal = false,
-    excludePrivate = false,
-    excludePublic = false,
-    loadProcess = false,
-    log = false,
+    excludeDynamic,
+    excludeEnv,
+    excludeGlobal,
+    excludePrivate,
+    excludePublic,
+    loadProcess,
+    log,
+    logger,
     outputPath,
-    paths = ['./'],
-    privateToken = 'local'
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    paths,
+    privateToken,
+    vars = {}
+  } = {
+    ..._dotenvDefaults.dotenvDefaults,
+    ...options
+  };
+
   // Read .env files.
-  const parsed = await paths.reduce(async (e, p) => ({
-    ...(await e),
-    ...(excludePublic ? {} : {
-      ...(excludeGlobal ? {} : await (0, _readDotenv.readDotenv)(_path.default.resolve(p, dotenvToken))),
-      ...(env && !excludeEnv ? await (0, _readDotenv.readDotenv)(_path.default.resolve(p, `${dotenvToken}.${env}`)) : {})
-    }),
-    ...(excludePrivate ? {} : {
-      ...(excludeGlobal ? {} : await (0, _readDotenv.readDotenv)(_path.default.resolve(p, `${dotenvToken}.${privateToken}`))),
-      ...(env && !excludeEnv ? await (0, _readDotenv.readDotenv)(_path.default.resolve(p, `${dotenvToken}.${env}.${privateToken}`)) : {})
-    })
-  }), {});
-  const outputKey = (0, _uuid.v4)();
+  const loaded = await paths.reduce(async (e, p) => {
+    let publicGlobal = excludePublic || excludeGlobal ? {} : (0, _readDotenv.readDotenv)(_path.default.resolve(p, dotenvToken));
+    let publicEnv = excludePublic || excludeEnv ? {} : (0, _readDotenv.readDotenv)(_path.default.resolve(p, `${dotenvToken}.${env}`));
+    let privateGlobal = excludePrivate || excludeGlobal ? {} : (0, _readDotenv.readDotenv)(_path.default.resolve(p, `${dotenvToken}.${privateToken}`));
+    let privateEnv = excludePrivate || excludeEnv ? {} : (0, _readDotenv.readDotenv)(_path.default.resolve(p, `${dotenvToken}.${env}.${privateToken}`));
+    [e, publicGlobal, publicEnv, privateGlobal, privateEnv] = await Promise.all([e, publicGlobal, publicEnv, privateGlobal, privateEnv]);
+    return {
+      ...e,
+      ...publicGlobal,
+      ...publicEnv,
+      ...privateGlobal,
+      ...privateEnv
+    };
+  }, {});
+  const outputKey = (0, _nanoid.nanoid)();
   const {
     parsed: dotenv
   } = (0, _dotenvExpand.expand)({
     ignoreProcessEnv: true,
     parsed: {
-      ...parsed,
+      ...loaded,
+      ...vars,
       ...(outputPath ? {
         [outputKey]: outputPath
       } : {})
@@ -108,14 +123,14 @@ const getDotenv = async function () {
   }
 
   // Log result.
-  if (log) console.log(dotenv);
+  if (log) logger(dotenv);
 
   // Load process.env.
   if (loadProcess) Object.assign(process.env, dotenv, {
     getdotenvOptions: JSON.stringify({
       dotenvToken,
-      dynamicPath,
       env,
+      dynamicPath,
       excludeDynamic,
       excludeEnv,
       excludeGlobal,
@@ -142,40 +157,50 @@ const getDotenv = async function () {
  */
 exports.getDotenv = getDotenv;
 const getDotenvSync = function () {
+  let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  // Apply defaults.
   let {
-    dotenvToken = '.env',
-    dynamicPath,
+    dotenvToken,
     env,
-    excludeDynamic = false,
-    excludeEnv = false,
-    excludeGlobal = false,
-    excludePrivate = false,
-    excludePublic = false,
-    loadProcess = false,
-    log = false,
+    dynamicPath,
+    excludeDynamic,
+    excludeEnv,
+    excludeGlobal,
+    excludePrivate,
+    excludePublic,
+    loadProcess,
+    log,
     outputPath,
-    paths = ['./'],
-    privateToken = 'local'
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    paths,
+    privateToken,
+    vars
+  } = {
+    ..._dotenvDefaults.dotenvDefaults,
+    ...options
+  };
+
   // Read .env files.
-  const parsed = paths.reduce((e, p) => ({
-    ...e,
-    ...(excludePublic ? {} : {
-      ...(excludeGlobal ? {} : (0, _readDotenv.readDotenvSync)(_path.default.resolve(p, dotenvToken))),
-      ...(env && !excludeEnv ? (0, _readDotenv.readDotenvSync)(_path.default.resolve(p, `${dotenvToken}.${env}`)) : {})
-    }),
-    ...(excludePrivate ? {} : {
-      ...(excludeGlobal ? {} : (0, _readDotenv.readDotenvSync)(_path.default.resolve(p, `${dotenvToken}.${privateToken}`))),
-      ...(env && !excludeEnv ? (0, _readDotenv.readDotenvSync)(_path.default.resolve(p, `${dotenvToken}.${env}.${privateToken}`)) : {})
-    })
-  }), {});
-  const outputKey = (0, _uuid.v4)();
+  const loaded = paths.reduce((e, p) => {
+    let publicGlobal = excludePublic || excludeGlobal ? {} : (0, _readDotenv.readDotenvSync)(_path.default.resolve(p, dotenvToken));
+    let publicEnv = excludePublic || excludeEnv ? {} : (0, _readDotenv.readDotenvSync)(_path.default.resolve(p, `${dotenvToken}.${env}`));
+    let privateGlobal = excludePrivate || excludeGlobal ? {} : (0, _readDotenv.readDotenvSync)(_path.default.resolve(p, `${dotenvToken}.${privateToken}`));
+    let privateEnv = excludePrivate || excludeEnv ? {} : (0, _readDotenv.readDotenvSync)(_path.default.resolve(p, `${dotenvToken}.${env}.${privateToken}`));
+    return {
+      ...e,
+      ...publicGlobal,
+      ...publicEnv,
+      ...privateGlobal,
+      ...privateEnv
+    };
+  }, {});
+  const outputKey = (0, _nanoid.nanoid)();
   const {
     parsed: dotenv
   } = (0, _dotenvExpand.expand)({
     ignoreProcessEnv: true,
     parsed: {
-      ...parsed,
+      ...loaded,
+      ...vars,
       ...(outputPath ? {
         [outputKey]: outputPath
       } : {})

package/dist/default/lib/index.js

@@ -9,10 +9,10 @@ Object.defineProperty(exports, "dotenvExpand", {
     return _dotenvExpand.dotenvExpand;
   }
 });
-Object.defineProperty(exports, "getAwsSsoCredentials", {
+Object.defineProperty(exports, "getCli", {
   enumerable: true,
   get: function () {
-    return _getAwsSsoCredentials.getAwsSsoCredentials;
+    return _getCli.getCli;
   }
 });
 Object.defineProperty(exports, "getDotenv", {
@@ -27,13 +27,6 @@ Object.defineProperty(exports, "getDotenvSync", {
     return _getDotenv.getDotenvSync;
   }
 });
-Object.defineProperty(exports, "parseBranch", {
-  enumerable: true,
-  get: function () {
-    return _parseBranch.parseBranch;
-  }
-});
 var _dotenvExpand = require("./dotenvExpand.js");
-var _getAwsSsoCredentials = require("./getAwsSsoCredentials.js");
 var _getDotenv = require("./getDotenv.js");
-var _parseBranch = require("./parseBranch.js");
+var _getCli = require("./getCli.js");

package/lib/dotenvDefaults.js

@@ -0,0 +1,13 @@
+export const dotenvDefaults = {
+  dotenvToken: '.env',
+  excludeDynamic: false,
+  excludeEnv: false,
+  excludeGlobal: false,
+  excludePrivate: false,
+  excludePublic: false,
+  loadProcess: false,
+  log: false,
+  logger: console.log,
+  paths: ['./'],
+  privateToken: 'local',
+};

package/lib/getCli.js

@@ -0,0 +1,282 @@
+// npm imports
+import { boolean } from 'boolean';
+import { Command } from 'commander';
+import { execaCommand } from 'execa';
+import fromPairs from 'lodash.frompairs';
+import isString from 'lodash.isstring';
+
+// lib imports
+import { dotenvDefaults } from './dotenvDefaults.js';
+import { dotenvExpand } from './dotenvExpand.js';
+import { getDotenv } from './getDotenv.js';
+
+const booleanExpand = (value) => boolean(dotenvExpand(value));
+
+/**
+ * GetDotenv CLI Options type
+ *
+ * @typedef {Object} GetDotenvCliOptions
+ * @property {string} [cliInvocation] - cli invocation string (used for cli help)
+ * @property {string} [dotenvToken] - token indicating a dotenv file
+ * @property {string} [dynamicPath] - path to file exporting an object keyed to dynamic variable functions
+ * @property {string} [env] - target environment
+ * @property {bool} [excludeDynamic] - exclude dynamic variables
+ * @property {bool} [excludeEnv] - exclude environment-specific variables
+ * @property {bool} [excludeGlobal] - exclude global & dynamic variables
+ * @property {bool} [excludePrivate] - exclude private variables
+ * @property {bool} [excludePublic] - exclude public variables
+ * @property {bool} [log] - log result to console
+ * @property {function} [logger] - logger function
+ * @property {string} [outputPath] - if populated, writes consolidated .env file to this path (follows {@link https://github.com/motdotla/dotenv-expand/blob/master/tests/.env dotenv-expand rules})
+ * @property {string} [paths] - space-delimited list of input directory paths
+ * @property {string} [privateToken] - token indicating private variables.
+ * @property {bool|string} [shell] - execa shell option
+ * @property {bool} [suppressDotenv] - suppress dotenv loading
+ */
+
+/**
+ * GetDotenv CLI Pre-hook Callback type. Transforms inbound options & executes side effects.
+ *
+ * @async
+ * @callback GetDotenvPreHookCallback
+ * @param {GetDotenvCliOptions} options - inbound GetDotenv CLI Options object
+ * @returns {GetDotenvCliOptions} transformed GetDotenv CLI Options object (undefined return value is ignored)
+ */
+
+/**
+ * GetDotenv CLI Post-hook Callback type. Executes side effects within getdotenv context.
+ *
+ * @async
+ * @callback GetDotenvPostHookCallback
+ * @param {GetDotenvCliOptions} options - GetDotenv CLI Options object
+ * @param {object} dotenv - dotenv object
+ */
+
+/**
+ * GetDotenv CLI Config type
+ *
+ * @typedef {Object} GetDotenvCliConfig
+ * @property {object} [config] - config options
+ * @property {GetDotenvCliOptions} [config.defaultOptions] - default options
+ * @property {GetDotenvPreHookCallback} [config.preHook] - transforms inbound options & executes side effects
+ * @property {GetDotenvPostHookCallback} [config.postHook] - executes side effects within getdotenv context
+ */
+
+/**
+ * Generate a CLI for get-dotenv.
+ *
+ * @param {GetDotenvCliConfig} [config] - config object
+ * @returns {object} The CLI command.
+ */
+export const getCli = ({ defaultOptions = {}, preHook, postHook } = {}) => {
+  let {
+    cliInvocation = 'getdotenv',
+    command,
+    dotenvToken,
+    dynamicPath,
+    env,
+    excludeDynamic,
+    excludeEnv,
+    excludeGlobal,
+    excludePrivate,
+    excludePublic,
+    log,
+    outputPath,
+    paths,
+    pathsDelimiter = '\\s+',
+    privateToken,
+    shell,
+    suppressDotenv,
+    vars,
+    varsAssignor = '=',
+    varsDelimiter = '\\s+',
+  } = {
+    ...dotenvDefaults,
+    ...defaultOptions,
+  };
+
+  if (Array.isArray(paths)) paths = paths.join(' ');
+
+  return (
+    new Command()
+      .name(cliInvocation)
+      // .usage('[options] [command] [command options] [commad args]')
+      .description(
+        'Base CLI. All options except delimiters follow dotenv-expand rules.'
+      )
+      .enablePositionalOptions()
+      .passThroughOptions()
+      .option('-e, --env <string>', 'environment name', dotenvExpand, env)
+      .option(
+        '-p, --paths <string>',
+        'delimited list of paths to dotenv directory',
+        dotenvExpand,
+        paths
+      )
+      .option(
+        '--paths-delimiter <string>',
+        'regex paths delimiter',
+        pathsDelimiter
+      )
+      .option(
+        '-v, --vars <string>',
+        'delimited list KEY=VALUE pairs',
+        dotenvExpand,
+        vars
+      )
+      .option(
+        '--vars-delimiter <string>',
+        'regex vars delimiter',
+        varsDelimiter
+      )
+      .option(
+        '--vars-assignor <string>',
+        'regex vars assignment operator',
+        varsAssignor
+      )
+      .option(
+        '-y, --dynamic-path <string>',
+        'dynamic variables path',
+        dotenvExpand,
+        dynamicPath
+      )
+      .option(
+        '-o, --output-path <string>',
+        'consolidated output file, follows dotenv-expand rules using loaded env vars',
+        dotenvExpand,
+        outputPath
+      )
+      .option(
+        '-n, --exclude-env [bool]',
+        'exclude environment-specific variables',
+        booleanExpand,
+        excludeEnv ?? false
+      )
+      .option(
+        '-g, --exclude-global [bool]',
+        'exclude global & dynamic variables',
+        booleanExpand,
+        excludeGlobal ?? false
+      )
+      .option(
+        '-r, --exclude-private [bool]',
+        'exclude private variables',
+        booleanExpand,
+        excludePrivate ?? false
+      )
+      .option(
+        '-u, --exclude-public [bool]',
+        'exclude public variables',
+        booleanExpand,
+        excludePublic ?? false
+      )
+      .option(
+        '-z, --exclude-dynamic [bool]',
+        'exclude dynamic variables',
+        booleanExpand,
+        excludeDynamic ?? false
+      )
+      .option(
+        '-l, --log [bool]',
+        'console log extracted variables',
+        booleanExpand,
+        log ?? false
+      )
+      .option(
+        '-x, --suppress-dotenv',
+        'suppress dotenv loading',
+        booleanExpand,
+        suppressDotenv ?? false
+      )
+      .option(
+        '-c, --command <string>',
+        'shell command string',
+        dotenvExpand,
+        command
+      )
+      .option('-s, --shell <string>', 'execa shell option', dotenvExpand, shell)
+      .option(
+        '--dotenv-token <string>',
+        'token indicating a dotenv file',
+        dotenvExpand,
+        dotenvToken
+      )
+      .option(
+        '--private-token <string>',
+        'token indicating private variables',
+        dotenvExpand,
+        privateToken
+      )
+      .addCommand(
+        new Command()
+          .name('cmd')
+          .description('execute shell command string (default command)')
+          .configureHelp({ showGlobalOptions: true })
+          .enablePositionalOptions()
+          .passThroughOptions()
+          .action(async (options, { args, parent }) => {
+            if (args.length)
+              await execaCommand(args.join(' '), {
+                stdio: 'inherit',
+                shell: parent.opts().shell,
+              });
+          }),
+        { isDefault: true }
+      )
+      .hook('preSubcommand', async (thisCommand) => {
+        // Inherit options from parent command.
+        let options = {
+          ...(process.env['getdotenvOptions']
+            ? JSON.parse(process.env['getdotenvOptions'])
+            : {}),
+          ...thisCommand.opts(),
+        };
+
+        // Execute pre-hook.
+        if (preHook) options = (await preHook(options)) ?? options;
+
+        // Get options.
+        let {
+          command,
+          paths,
+          pathsDelimiter,
+          suppressDotenv,
+          vars: varsStr,
+          varsDelimiter,
+          varsAssignor,
+          ...rest
+        } = options;
+
+        // Parse vars.
+        const vars = varsStr?.length
+          ? fromPairs(
+              varsStr
+                .split(new RegExp(varsDelimiter))
+                .map((v) => v.split(new RegExp(varsAssignor)))
+            )
+          : undefined;
+
+        // Execute getdotenv.
+        if (paths?.length && !suppressDotenv) {
+          if (isString(paths)) paths = paths?.split(new RegExp(pathsDelimiter));
+
+          var dotenv = await getDotenv({
+            ...rest,
+            loadProcess: true,
+            paths,
+            vars,
+          });
+        }
+
+        // Execute post-hook.
+        if (postHook) await postHook(options, dotenv);
+
+        // Execute shell command.
+        if (command)
+          await execaCommand(command, {
+            stdio: 'inherit',
+            shell,
+          });
+      })
+  );
+};