Include environment vars (#15)

* Include environemnt vars

* Add workflow test

* Fix workflow test

* Add include_env_vars

Author: DeveloperRic

.github/workflows/test.yml

@@ -69,3 +69,21 @@ jobs:
           full_text: TEST=1
       - run: cat .env
       - run: grep -zP "^TEST=1$" .env
+  test-including-env-vars:
+    runs-on: ubuntu-latest
+    needs:
+      - build
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/download-artifact@v2
+        with:
+          name: dist
+          path: dist
+      - uses: ./
+        with:
+          full_text: PROD=0
+          include_env_vars: true
+        env:
+          ACTION_CREATE_ENV_TEST: 1
+      - run: cat .env
+      - run: grep -zP "^PROD=0\nTEST=1$" .env

__tests__/main.test.ts

@@ -1,31 +1,41 @@
-import { Args, writeEnv } from '../src/main'
+import { Args, writeToEnvFile } from '../src/main'
 import * as process from 'process'
 import * as cp from 'child_process'
 import * as path from 'path'
 import * as fs from 'fs'
 
 const ARTIFACTS_PATH = path.join(__dirname, 'artifacts')
+const ENV_PREFIX = 'ACTION_CREATE_ENV_'
 
 beforeEach(() => fs.mkdirSync(ARTIFACTS_PATH))
 afterEach(() => fs.rmSync(ARTIFACTS_PATH, { recursive: true, force: true }))
+afterEach(() => {
+  Object.keys(process.env)
+    .filter(key => key.startsWith(ENV_PREFIX))
+    .forEach(key => {
+      delete process.env[key]
+    })
+})
 
 test('throws if <directory> is not found', async () => {
   const args: Args = {
     directory: `${ARTIFACTS_PATH}/this_dir_does_not_exist`,
-    full_text: ''
+    full_text: '',
+    include_env_vars: false
   }
-  await expect(writeEnv(args))
+  await expect(writeToEnvFile(args))
     .rejects
     .toThrow(`Invalid directory input: ${args.directory} doesn't exist.`)
 })
 
 test('throws if <directory> is not a directory', async () => {
   const args: Args = {
     directory: `${ARTIFACTS_PATH}/file`,
-    full_text: ''
+    full_text: '',
+    include_env_vars: false
   }
   fs.writeFileSync(args.directory, '')
-  await expect(writeEnv(args))
+  await expect(writeToEnvFile(args))
     .rejects
     .toThrow(`Invalid directory input: ${args.directory} is not a directory.`)
 })
@@ -36,9 +46,10 @@ test('creates .env', async () => {
     full_text: `
     PROD=0
     TEST=1\n
-    `
+    `,
+    include_env_vars: false
   }
-  await writeEnv(args)
+  await writeToEnvFile(args)
   const content = fs.readFileSync(`${args.directory}/.env`).toString()
   expect(content).toEqual('PROD=0\nTEST=1')
 })
@@ -52,15 +63,28 @@ test('overwrites .env', async () => {
     directory: ARTIFACTS_PATH,
     full_text: `
     PROD=0
-    `
+    `,
+    include_env_vars: false
   }
   const filePath = `${args.directory}/.env`
   fs.writeFileSync(filePath, initialText)
-  await writeEnv(args)
+  await writeToEnvFile(args)
   const content = fs.readFileSync(filePath).toString()
   expect(content).toEqual('PROD=0')
 })
 
+test('includes env vars', async () => {
+  const args: Args = {
+    directory: ARTIFACTS_PATH,
+    full_text: 'PROD=0\n', // should be trimmed
+    include_env_vars: true
+  }
+  process.env[`${ENV_PREFIX}_${ENV_PREFIX}_TEST`] = '1' // prefix should only be removed once
+  await writeToEnvFile(args)
+  const content = fs.readFileSync(`${args.directory}/.env`).toString()
+  expect(content).toEqual(`PROD=0\n_${ENV_PREFIX}_TEST=1`)
+})
+
 // shows how the runner will run a javascript action with env / stdout protocol
 test('test runs', () => {
   process.env['INPUT_FULL_TEXT'] = 'PROD=0'

action.yml

@@ -8,6 +8,11 @@ inputs:
   directory:
     description: 'Directory to write the file to (defaults to .). Parent directories will NOT be created.'
     default: '.'
+  include_env_vars:
+    required: false
+    description: |
+      If set, environemnt vars starting with ACTION_CREATE_ENV_ will be included (i.e. ACTION_CREATE_ENV_PROD=1 will be incldued in .env as PROD=1).
+      Vars set in this way are written after <full_text>.
 runs:
   using: 'node12'
   main: 'dist/index.js'

src/main.ts

@@ -2,21 +2,42 @@ import { getInput, info, setFailed } from '@actions/core'
 import dedent from 'dedent'
 import * as fs from 'fs'
 
+const ENV_PREFIX = 'ACTION_CREATE_ENV_'
+
 export interface Args {
   full_text: string
   directory: string
+  include_env_vars: boolean
+}
+
+function getTextForEnvFile(args: Args) {
+  let text = dedent(args.full_text).trim()
+  if (args.include_env_vars) {
+    const envVars = Object.entries(process.env)
+      .filter(([key]) => key.startsWith(ENV_PREFIX))
+      .map(([key, val]) => {
+        const newKey = key.replace(new RegExp(`^${ENV_PREFIX}`), '')
+        return `${newKey}=${val}`
+      })
+    text += `\n${envVars.join('\n')}`
+  }
+  return text.trim()
+}
+
+function validateArgs(args: Args) {
+  if (!fs.existsSync(args.directory)) {
+    throw new Error(`Invalid directory input: ${args.directory} doesn't exist.`)
+  }
+  if (!fs.statSync(args.directory).isDirectory()) {
+    throw new Error(`Invalid directory input: ${args.directory} is not a directory.`)
+  }
 }
 
-export async function writeEnv(args: Args): Promise<void> {
+export async function writeToEnvFile(args: Args): Promise<void> {
   return new Promise<void>((resolve, reject) => {
-    if (!fs.existsSync(args.directory)) {
-      throw new Error(`Invalid directory input: ${args.directory} doesn't exist.`)
-    }
-    if (!fs.statSync(args.directory).isDirectory()) {
-      throw new Error(`Invalid directory input: ${args.directory} is not a directory.`)
-    }
+    validateArgs(args)
     const filePath = `${args.directory}/.env`
-    const text = dedent(args.full_text).trim()
+    const text = getTextForEnvFile(args)
     fs.writeFile(filePath, text, err => {
       if (err) return reject(err)
       resolve()
@@ -28,10 +49,11 @@ export async function run(): Promise<void> {
   try {
     const args: Args = {
       full_text: getInput('full_text'),
-      directory: getInput('directory')
+      directory: getInput('directory'),
+      include_env_vars: !!getInput('include_env_vars')
     }
     info(`Creating .env file in ${args.directory}`)
-    await writeEnv(args)
+    await writeToEnvFile(args)
     info('Done.')
   } catch (error) {
     setFailed(error.message)