feat(ensureExists): allow action to succeed when file not found

README.md

@@ -20,6 +20,10 @@ Log variables after reading from the `.env` file.
 
 Mask values after reading from the `.env` file.
 
+### `ensure-exists`
+
+Fail the action when `.env` file is not found at `path`. Default is `true`.
+
 ### `export-variables`
 
 Export values as environment variables in addition to storing them in the output after reading from the `.env` file.

dotenv_action.js

@@ -1,27 +1,44 @@
-const fs = require("fs");
+const core = require("@actions/core");
 
-let dotenv_action = function (dotenvFile, keysCase) {
-  if (!fs.existsSync(dotenvFile)) {
-    throw new Error("file does not exist");
+const fs = require("node:fs");
+
+/**
+ * @param {object} kwargs
+ * @param {boolean} kwargs.ensureExists ensure that the file exists
+ * @param {'bypass' | 'lower' | 'upper'} kwargs.keysCase transform keys case or preserve them as they are
+ * @param {string} kwargs.path a relative path from the repository root
+ */
+const dotenvAction = ({ path, keysCase, ensureExists }) => {
+  const exists = fs.existsSync(path);
+
+  if (!exists && ensureExists) {
+    core.info(
+      "Action will fail as it was unable to load the environment file from the provided path. If you wish to bypass this check, set the 'ensure-exists' option to 'false'.",
+    );
+
+    throw new Error(`Environment file not found at path: '${path}'`);
   }
 
-  const dotenv = require("dotenv").config({ path: dotenvFile });
+  const dotenv = require("dotenv").config({ path: path });
   const dotenv_expand = require("dotenv-expand").expand(dotenv);
-  console.log("loading .env file from " + dotenvFile);
+
+  core.info(`Loading environment file from path: '${path}'`);
 
   const returnedMap = {};
+
   for (const key in dotenv_expand.parsed) {
     const value = dotenv_expand.parsed[key];
 
-    if (keysCase == "bypass") {
+    if (keysCase === "bypass") {
       returnedMap[key] = value;
-    } else if (keysCase == "upper") {
+    } else if (keysCase === "upper") {
       returnedMap[key.toLocaleUpperCase()] = value;
     } else {
       returnedMap[key.toLocaleLowerCase()] = value;
     }
   }
+
   return returnedMap;
 };
 
-module.exports = dotenv_action;
+module.exports = dotenvAction;

index.js

@@ -1,40 +1,44 @@
 const core = require("@actions/core");
 const dotenvAction = require("./dotenv_action");
+
 try {
-  const dotenvFile = core.getInput("path");
-  const logVariables = core.getInput("log-variables").toLowerCase() === "true";
-  const maskVariables =
-    core.getInput("mask-variables").toLowerCase() === "true";
-  const exportVariables =
-    core.getInput("export-variables").toLowerCase() === "true";
+  const ensureExists = core.getInput("ensure-exists").toLowerCase();
+  const keysCase = core.getInput("keys-case").toLowerCase();
+  const logVariables = core.getInput("log-variables").toLowerCase();
+  const maskVariables = core.getInput("mask-variables").toLowerCase();
+  const exportVariables = core.getInput("export-variables").toLowerCase();
+
   const exportVariablesPrefix = core.getInput("export-variables-prefix");
-  const keysCase = core
-    .getInput("keys-case", { required: false })
-    .toLowerCase();
-  const variables = dotenvAction(dotenvFile, keysCase, logVariables);
+  const path = core.getInput("path");
+
+  const variables = dotenvAction({
+    path: path || ".env",
+    ensureExists: (ensureExists || "true") === "true",
+    keysCase: keysCase || "lower",
+  });
 
-  if (maskVariables) {
+  if (maskVariables === "true") {
     for (const key in variables) {
       const value = variables[key];
+
       core.setSecret(value);
     }
   }
 
-  if (logVariables) {
-    console.log(variables);
-  } else {
-    console.log(
-      `loaded ${Object.keys(variables).length} values into the environment`,
-    );
-  }
+  core.info(
+    logVariables === "true"
+      ? JSON.stringify(variables, null, 2)
+      : `Loaded ${Object.keys(variables).length} values into the environment.`,
+  );
 
   core.setOutput("generic", "please check for actual outputs");
 
   for (const key in variables) {
     const value = variables[key];
+
     core.setOutput(key, value);
 
-    if (exportVariables) {
+    if (exportVariables === "true") {
       core.exportVariable(exportVariablesPrefix + key, value);
     }
   }

index.test.js

@@ -1,53 +1,91 @@
-test("test runs with custom path", () => {
-  const dotenv_action = require("./dotenv_action");
-  expect(dotenv_action("fixtures/.env")).toEqual({ fixtures_1: "123" });
+const { it, expect } = require("@jest/globals");
+
+const dotenvAction = require("./dotenv_action");
+
+it("fails when path does not exist and 'ensure-exists' is 'true'", () => {
+  expect(() =>
+    dotenvAction({
+      path: "nosuchfile",
+      ensureExists: true,
+    }),
+  ).toThrow(Error);
+});
+
+it("runs when path does not exist and 'ensure-exists' is 'false'", () => {
+  const actual = dotenvAction({
+    path: "nosuchfile",
+    ensureExists: false,
+  });
+
+  expect(actual).toEqual({});
+});
+
+it("runs with custom path", () => {
+  const actual = dotenvAction({
+    path: "fixtures/.env",
+  });
+
+  expect(actual).toEqual({
+    fixtures_1: "123",
+  });
 });
 
-test("test runs with different path", () => {
-  const dotenv_action = require("./dotenv_action");
-  expect(dotenv_action("fixtures/.another.env")).toEqual({
+it("runs with another custom path", () => {
+  const actual = dotenvAction({
+    path: "fixtures/.another.env",
+  });
+
+  expect(actual).toEqual({
     fixtures_2: "xyz",
     other_key: "this",
   });
 });
 
-test("test runs with broken path", () => {
-  const dotenv_action = require("./dotenv_action");
-  expect(() => {
-    dotenv_action("nosuchfile");
-  }).toThrow(Error);
-});
+it("runs with expanded values", () => {
+  const actual = dotenvAction({
+    path: "fixtures/.expand.env",
+  });
 
-test("test runs with expanded values", () => {
-  const dotenv_action = require("./dotenv_action");
-  expect(dotenv_action("fixtures/.expand.env")).toEqual({
+  expect(actual).toEqual({
     fixtures_3: "xyz",
     expanded: "123-xyz",
     expanded_2: "123-xyz",
   });
 });
 
-test("test runs with bypass case for keys", () => {
-  const dotenv_action = require("./dotenv_action");
-  expect(dotenv_action("fixtures/.case.env", "bypass")).toEqual({
+it("runs with bypass case for keys", () => {
+  const actual = dotenvAction({
+    path: "fixtures/.case.env",
+    keysCase: "bypass",
+  });
+
+  expect(actual).toEqual({
     FIXTURES_4: "foo",
     fixtures_5: "bar",
     Fixtures_6: "abc",
   });
 });
 
-test("test runs with lower case for keys", () => {
-  const dotenv_action = require("./dotenv_action");
-  expect(dotenv_action("fixtures/.case.env", "lower")).toEqual({
+it("runs with lower case for keys", () => {
+  const actual = dotenvAction({
+    path: "fixtures/.case.env",
+    keysCase: "lower",
+  });
+
+  expect(actual).toEqual({
     fixtures_4: "foo",
     fixtures_5: "bar",
     fixtures_6: "abc",
   });
 });
 
-test("test runs with upper case for keys", () => {
-  const dotenv_action = require("./dotenv_action");
-  expect(dotenv_action("fixtures/.case.env", "upper")).toEqual({
+it("runs with upper case for keys", () => {
+  const actual = dotenvAction({
+    path: "fixtures/.case.env",
+    keysCase: "upper",
+  });
+
+  expect(actual).toEqual({
     FIXTURES_4: "foo",
     FIXTURES_5: "bar",
     FIXTURES_6: "abc",