@dotenvx/dotenvx 0.2.23

package/README.md

@@ -0,0 +1,274 @@
+![dotenvx](https://dotenv.org/better-banner.png)
+
+*a better dotenv*–from the creator of [`dotenv`](https://github.com/motdotla/dotenv).
+
+* run anywhere (cross-platform)
+* multi-environment
+* encrypted envs
+
+ 
+
+
+### Quickstart
+
+```sh
+brew install dotenvx/brew/dotenvx
+```
+> * [other ways to install](#other-ways-to-install)
+
+ 
+
+## Run Anywhere
+
+```sh
+$ echo "HELLO=World" > .env && echo "console.log('Hello ' + process.env.HELLO)" > index.js
+
+$ node index.js
+Hello undefined
+
+$ dotenv run -- node index.js
+Hello World
+> :-D
+```
+
+More examples
+
+* <details><summary>Python 🐍</summary><br>
+
+  ```sh
+  $ echo 'import os;print("Hello " + os.getenv("HELLO", ""))' > index.py
+
+  $ dotenv run -- python3 index.py
+  Hello World
+  ```
+
+  </details>
+* <details><summary>PHP 🐘</summary><br>
+
+  ```sh
+  $ echo '<?php echo "Hello {$_SERVER["HELLO"]}\n";' > index.php
+
+  $ dotenv run -- php index.php
+  Hello World
+  ```
+
+  </details>
+* <details><summary>Ruby 💎</summary><br>
+
+  ```sh
+  $ echo 'puts "Hello #{ENV["HELLO"]}"' > index.rb
+
+  $ dotenv run -- ruby index.rb
+  Hello World
+  ```
+
+  </details>
+* <details><summary>Rust 🦀</summary><br>
+
+  ```sh
+  $ echo 'fn main() {let hello = std::env::var("HELLO").unwrap_or("".to_string());println!("Hello {hello}");}' > src/main.rs
+
+  $ dotenv run -- cargo run
+  Hello World
+  ```
+
+  </details>
+* <details><summary>Frameworks ▲</summary><br>
+
+  ```sh
+  $ dotenv run -- next dev
+  $ dotenv run -- npm start
+  $ dotenv run -- bin/rails s
+  $ dotenv run -- php artisan serve
+  ```
+
+  </details>
+* <details><summary>Docker 🐳</summary><br>
+
+  ```sh
+  # run as a command-line tool
+  docker run -it --rm -v $(pwd):/app dotenv/dotenv run -- node index.js
+  ```
+
+  ```sh
+  # include in a Dockerfile
+  # example coming soon
+  ```
+
+  </details>
+
+* <details><summary>CI/CDs 🐙</summary><br>
+
+  ```sh
+  examples coming soon
+  ```
+
+  </details>
+* <details><summary>Platforms</summary><br>
+
+  ```sh
+  examples coming soon
+  ```
+
+  </details>
+* <details><summary>npx</summary><br>
+
+  ```sh
+  # alternatively use npx
+  $ npx @dotenv/dotenv run -- node index.js
+  $ npx @dotenv/dotenv run -- next dev
+  $ npx @dotenv/dotenv run -- npm start
+  ```
+
+  </details>
+* <details><summary>Git</summary><br>
+
+  ```sh
+  # use as a git submodule
+  $ git dotenv run -- node index.js
+  $ git dotenv run -- next dev
+  $ git dotenv run -- npm start
+  ```
+
+  </details>
+
+&nbsp;
+
+## Multiple Environments
+
+Pass the `--env-file` flag (shorthand `-f`) to run any environment from a `.env.environment` file.
+
+```sh
+$ dotenv run --env-file=.env.production -- node index.js
+[dotenv][INFO] Injecting 12 production environment variables into your application process
+```
+
+Combine multiple `.env` files if you like.
+
+```
+$ dotenv run --env-file=.env.local --env-file=.env -- node index.js
+[dotenv][INFO] Injecting 12 local, 1 development environment variables into your application process
+```
+
+&nbsp;
+
+## Encrypt Your Env Files
+
+WIP
+
+&nbsp;
+
+## Usage
+
+### Guide
+
+Begin by creating a simple 'hello world' program.
+
+```js
+// index.js
+console.log(`Hello ${process.env.HELLO}`)
+```
+
+Run it.
+
+```js
+$ node index.js
+Hello undefined
+```
+
+Run it with `dotenv`.
+
+```sh
+$ dotenv run -- node index.js
+[dotenv@x.x.x][WARN] ENOENT: no such file or directory, open '/../../.env'
+Hello undefined
+```
+
+It warns you when there is no `.env` file (pass the `--quiet` flag to suppress these warnings).
+
+Create the `.env` file.
+
+```ini
+# env
+JELLO="World"
+```
+
+Run it again.
+
+```sh
+$ dotenv run -- node index.js
+[dotenv@x.x.x][INFO] Injecting 0 environment variables into your application process
+Hello undefined
+```
+
+Hrm, still undefined. Pass the `--debug` flag to debug the issue. I'll give you a hint: 🍮
+
+```sh
+$ dotenv run --debug -- node index.js
+[dotenv@x.x.x][VERBOSE] Loading env from /../../.env
+[dotenv@x.x.x][DEBUG] Reading env from /../../.env
+[dotenv@x.x.x][DEBUG] Parsing env from /../../.env
+[dotenv@x.x.x][DEBUG] {"JELLO":"World"}
+
+# Oops, HELLO not JELLO ^^
+```
+
+Fix your `.env` file.
+
+```ini
+# .env
+HELLO="World"
+```
+
+One last time. [Le tired](https://youtu.be/kCpjgl2baLs?t=45).
+
+```sh
+$ dotenv run -- node index.js
+[dotenv@x.x.x][INFO] Injecting 0 environment variables into your application process
+Hello undefined
+```
+
+&nbsp;
+
+
+## Install
+
+Installing with [`brew`](https://brew.sh) is most straight forward:
+
+```sh
+brew install dotenvx/brew/dotenvx
+```
+
+### Other Ways to Install
+
+1. After `brew`, installing globally using [`npm`](https://www.npmjs.com/package/@dotenvx/dotenvx) is easiest:
+
+```sh
+npm install @dotenvx/dotenvx --global
+```
+
+2. Or use with [`npx`](https://www.npmjs.com/package/npx):
+
+```sh
+npx @dotenvx/dotenvx help
+```
+
+3. dotenvx is a standalone binary, so (if you want) you can just download it directly:
+
+```sh
+# download it to `./dotenvx`
+curl -Lo ./dotenvx --compressed -f --proto '=https' https://github.com/dotenvx/dotenvx/releases/latest/download/dotenvx-$(uname)-$(uname -m).tar.gz
+
+# install it to `/usr/local/bin/dotenvx`
+sudo install -m 755 dotenvx /usr/local/bin
+
+# check it works
+dotenvx --help
+```
+
+## Contributing
+
+If you have questions or feedback:
+
+* [github.com/dotenvx/dotenvx](https://github.com/dotenvx/dotenvx) - bugs and discussions
+* [@dotenvx 𝕏](https://x.com/dotenvx) (DMs are open)

package/package.json

@@ -0,0 +1,45 @@
+{
+  "version": "0.2.23",
+  "name": "@dotenvx/dotenvx",
+  "description": "a better dotenv–from the creator of `dotenv`",
+  "author": "@motdotla",
+  "keywords": [
+    "dotenv",
+    "env"
+  ],
+  "homepage": "https://github.com/dotenvx/dotenvx",
+  "repository": "dotenvx/dotenvx",
+  "license": "MIT",
+  "files": [
+    "src/**/*"
+  ],
+  "main": "src/lib/main.js",
+  "bin": {
+    "dotenvx": "./src/cli/dotenvx.js",
+    "git-dotenvx": "./src/cli/dotenvx.js"
+  },
+  "scripts": {
+    "standard": "standard",
+    "standard:fix": "standard --fix",
+    "test": "jest"
+  },
+  "dependencies": {
+    "commander": "^11.1.0",
+    "dotenv": "^16.3.1",
+    "winston": "^3.11.0"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0",
+    "jest-mock-process": "^2.0.0",
+    "pkg": "^5.8.1",
+    "standard": "^17.1.0"
+  },
+  "standard": {
+    "env": [
+      "jest"
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/cli/dotenvx.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+
+const fs = require('fs')
+const { Command } = require('commander')
+const program = new Command()
+
+// constants
+const ENCODING = 'utf8'
+
+const logger = require('./../shared/logger')
+const helpers = require('./helpers')
+const packageJson = require('./../shared/packageJson')
+const main = require('./../lib/main')
+
+// global log levels
+program
+  .option('-l, --log-level <level>', 'set log level', 'info')
+  .option('-q, --quiet', 'sets log level to error')
+  .option('-v, --verbose', 'sets log level to verbose')
+  .option('-d, --debug', 'sets log level to debug')
+  .hook('preAction', (thisCommand, actionCommand) => {
+    const options = thisCommand.opts()
+
+    if (options.logLevel) {
+      logger.level = options.logLevel
+      logger.debug(`Setting log level to ${options.logLevel}`)
+    }
+
+    // --quiet overides --log-level. only errors will be shown
+    if (options.quiet) {
+      logger.level = 'error'
+    }
+
+    // --verbose overrides --quiet
+    if (options.verbose) {
+      logger.level = 'verbose'
+    }
+
+    // --debug overrides --verbose
+    if (options.debug) {
+      logger.level = 'debug'
+    }
+  })
+
+// cli
+program
+  .name(packageJson.name)
+  .description(packageJson.description)
+  .version(packageJson.version)
+
+// commands
+program.command('encrypt')
+  .description('encrypt something')
+  .action((_str, _options) => {
+    console.log('encrypted!')
+  })
+
+program.command('decrypt')
+  .description('decrypt something')
+  .action((_str, _options) => {
+    console.log('decrypted!')
+  })
+
+program.command('run')
+  .description('Inject env variables into your application process')
+  .option('-f, --env-file <paths...>', 'path to your env file', '.env')
+  .option('-o, --overload', 'override existing env variables')
+  .action(function () {
+    // injecting 1 environment variable from ${options.envFile}
+    const options = this.opts()
+    logger.debug('Configuring options')
+    logger.debug(options)
+
+    // convert to array if needed
+    let optionEnvFile = options.envFile
+    if (!Array.isArray(optionEnvFile)) {
+      optionEnvFile = [optionEnvFile]
+    }
+
+    const env = {}
+
+    for (const envFilepath of optionEnvFile) {
+      const filepath = helpers.resolvePath(envFilepath)
+
+      logger.verbose(`Loading env from ${filepath}`)
+
+      try {
+        logger.debug(`Reading env from ${filepath}`)
+        const src = fs.readFileSync(filepath, { encoding: ENCODING })
+
+        logger.debug(`Parsing env from ${filepath}`)
+        const parsed = main.parse(src)
+
+        logger.debug(`Populating env from ${filepath}`)
+        main.populate(process.env, parsed, { debug: (logger.level === 'debug'), override: options.overload })
+      } catch (e) {
+        logger.warn(e)
+      }
+    }
+
+    logger.info('Injecting X environment variables into your application process')
+
+    // Extract command and arguments after '--'
+    const commandIndex = process.argv.indexOf('--')
+    if (commandIndex === -1 || commandIndex === process.argv.length - 1) {
+      logger.error('At least one argument is required after the run command, received 0.')
+      logger.error('Exiting')
+      process.exit(1)
+    } else {
+      const subCommand = process.argv.slice(commandIndex + 1)
+
+      helpers.executeCommand(subCommand, env)
+    }
+  })
+
+program.parse(process.argv)

package/src/cli/helpers.js

@@ -0,0 +1,28 @@
+const path = require('path')
+const { spawn } = require('child_process')
+
+// resolve path based on current running process location
+const resolvePath = function (filepath) {
+  return path.resolve(process.cwd(), filepath)
+}
+
+const executeCommand = function (subCommand, env) {
+  const subprocess = spawn(subCommand[0], subCommand.slice(1), {
+    stdio: 'inherit',
+    shell: true,
+    env: { ...process.env, ...env }
+  })
+
+  subprocess.on('close', (code) => {
+    process.exit(code)
+  })
+
+  subprocess.on('error', (_err) => {
+    process.exit(1)
+  })
+}
+
+module.exports = {
+  resolvePath,
+  executeCommand
+}

package/src/lib/main.js

@@ -0,0 +1,28 @@
+const logger = require('./../shared/logger')
+const dotenv = require('dotenv')
+
+const config = function (options) {
+  return dotenv.config(options)
+}
+
+const parse = function (src) {
+  const result = dotenv.parse(src)
+
+  logger.debug(result)
+
+  return result
+}
+
+const populate = function (processEnv, parsed, options = {}) {
+  const result = dotenv.populate(processEnv, parsed, options = {})
+
+  logger.debug(process.env)
+
+  return result
+}
+
+module.exports = {
+  config,
+  parse,
+  populate
+}

package/src/shared/logger.js

@@ -0,0 +1,26 @@
+const winston = require('winston')
+
+const printf = winston.format.printf
+const combine = winston.format.combine
+const createLogger = winston.createLogger
+const transports = winston.transports
+
+const packageJson = require('./packageJson')
+
+const dotenvxFormat = printf(({ level, message, label, timestamp }) => {
+  const formattedMessage = typeof message === 'object' ? JSON.stringify(message) : message
+
+  return `[dotenvx@${packageJson.version}][${level.toUpperCase()}] ${formattedMessage}`
+})
+
+const logger = createLogger({
+  level: 'info',
+  format: combine(
+    dotenvxFormat
+  ),
+  transports: [
+    new transports.Console()
+  ]
+})
+
+module.exports = logger

package/src/shared/packageJson.js

@@ -0,0 +1,8 @@
+const fs = require('fs')
+const path = require('path')
+
+const packageJsonPath = path.join(__dirname, '../../package.json')
+
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
+
+module.exports = packageJson