@jsenv/github-pull-request-impact 1.7.2 → 1.7.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/github-pull-request-impact",
-  "version": "1.7.2",
+  "version": "1.7.3",
   "description": "Report pull request impact on something",
   "license": "MIT",
   "author": {
@@ -34,8 +34,8 @@
     "test": "node ./scripts/test.mjs"
   },
   "dependencies": {
-    "@jsenv/fetch": "1.1.32",
-    "@jsenv/filesystem": "4.2.3",
-    "@jsenv/log": "3.3.4"
+    "@jsenv/fetch": "1.1.41",
+    "@jsenv/filesystem": "4.3.2",
+    "@jsenv/log": "3.4.1"
   }
 }

package/src/commentGitHubPullRequestImpact.js

@@ -4,14 +4,14 @@
  * @jsenv/file-size-impact, @jsenv/performance-impact and @jsenv/lighthouse-score-impact
  */
 
-import { fileURLToPath } from "node:url"
-import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
-import { createLogger } from "@jsenv/log"
+import { fileURLToPath } from "node:url";
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem";
+import { createLogger } from "@jsenv/log";
 
-import * as githubRESTAPI from "./internal/github_rest_api.js"
-import { exec } from "./internal/exec.js"
-import { renderGeneratedByText } from "./internal/renderGeneratedByText.js"
-import { createGitHubPullRequestCommentText } from "./internal/createGitHubPullRequestCommentText.js"
+import * as githubRESTAPI from "./internal/github_rest_api.js";
+import { exec } from "./internal/exec.js";
+import { renderGeneratedByText } from "./internal/renderGeneratedByText.js";
+import { createGitHubPullRequestCommentText } from "./internal/createGitHubPullRequestCommentText.js";
 
 export const commentGitHubPullRequestImpact = async ({
   logLevel,
@@ -39,42 +39,42 @@ export const commentGitHubPullRequestImpact = async ({
 
   catchError = false,
 }) => {
-  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl)
+  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl);
   if (typeof collectInfo !== "function") {
     throw new TypeError(
       `collectInfo must be a function but received ${collectInfo}`,
-    )
+    );
   }
   if (typeof commentIdentifier !== "string") {
     throw new TypeError(
       `commentIdentifier must be a string but received ${commentIdentifier}`,
-    )
+    );
   }
   if (typeof githubToken !== "string") {
     throw new TypeError(
       `githubToken must be a string but received ${githubToken}`,
-    )
+    );
   }
   if (typeof repositoryOwner !== "string") {
     throw new TypeError(
       `repositoryOwner must be a string but received ${repositoryOwner}`,
-    )
+    );
   }
   if (typeof repositoryName !== "string") {
     throw new TypeError(
       `repositoryName must be a string but received ${repositoryName}`,
-    )
+    );
   }
-  pullRequestNumber = String(pullRequestNumber)
+  pullRequestNumber = String(pullRequestNumber);
   if (typeof pullRequestNumber !== "string") {
     throw new TypeError(
       `pullRequestNumber must be a string but received ${pullRequestNumber}`,
-    )
+    );
   }
 
-  const logger = createLogger({ logLevel })
+  const logger = createLogger({ logLevel });
 
-  let cleanup = () => {}
+  let cleanup = () => {};
 
   try {
     return await commentPrImpact({
@@ -99,11 +99,11 @@ export const commentGitHubPullRequestImpact = async ({
       commitInGeneratedByInfo,
 
       catchError,
-    })
+    });
   } finally {
-    cleanup()
+    cleanup();
   }
-}
+};
 
 const commentPrImpact = async ({
   logger,
@@ -129,28 +129,28 @@ const commentPrImpact = async ({
   catchError,
 }) => {
   const execCommandInRootDirectory = (command) => {
-    logger.info(`> ${command}`)
+    logger.info(`> ${command}`);
     return exec(command, {
       cwd: fileURLToPath(rootDirectoryUrl),
       onLog: (string) => {
         if (commandLogs) {
-          logger.info(string)
+          logger.info(string);
         }
       },
       onErrorLog: (string) => logger.error(string),
-    })
-  }
+    });
+  };
 
-  const pullApiUrl = `https://api.github.com/repos/${repositoryOwner}/${repositoryName}/pulls/${pullRequestNumber}`
+  const pullApiUrl = `https://api.github.com/repos/${repositoryOwner}/${repositoryName}/pulls/${pullRequestNumber}`;
   // https://developer.github.com/v3/pulls/#get-a-pull-request
-  logger.debug(`get pull request ${pullApiUrl}`)
+  logger.debug(`get pull request ${pullApiUrl}`);
   const pullRequest = await githubRESTAPI.GET({
     url: pullApiUrl,
     githubToken,
-  })
-  const pullRequestHtmlUrl = pullRequest.html_url
-  const pullRequestBase = pullRequest.base.ref
-  const pullRequestHead = pullRequest.head.ref
+  });
+  const pullRequestHtmlUrl = pullRequest.html_url;
+  const pullRequestBase = pullRequest.base.ref;
+  const pullRequestHead = pullRequest.head.ref;
 
   /*
   Adds a commit-sha hidden at the top of the comment body:
@@ -160,8 +160,8 @@ const commentPrImpact = async ({
   was not updated (It happened to me several times).
   */
   const commentHeader = `${commentIdentifier}
-<!-- head-commit-sha=${pullRequest.head.sha} -->`
-  const commentWarnings = []
+<!-- head-commit-sha=${pullRequest.head.sha} -->`;
+  const commentWarnings = [];
   const commentFooter = renderGeneratedByText({
     generatedByLink,
     runLink,
@@ -171,179 +171,179 @@ const commentPrImpact = async ({
           text: shortenCommiSha(pullRequest.head.sha),
         }
       : null,
-  })
+  });
 
-  logger.debug(`searching comment in pull request ${pullRequestHtmlUrl}`)
-  const pullRequestCommentApiUrl = pullRequest.comments_url
+  logger.debug(`searching comment in pull request ${pullRequestHtmlUrl}`);
+  const pullRequestCommentApiUrl = pullRequest.comments_url;
   const comments = await githubRESTAPI.GET({
     url: pullRequestCommentApiUrl,
     githubToken,
-  })
+  });
   const existingComment = comments.find(({ body }) =>
     body.includes(commentIdentifier),
-  )
+  );
   if (existingComment) {
-    logger.debug(`comment found at ${existingComment.html_url}.`)
+    logger.debug(`comment found at ${existingComment.html_url}.`);
   } else {
-    logger.debug(`no existing comment found`)
+    logger.debug(`no existing comment found`);
   }
 
   const patchOrPostComment = async (commentInfo) => {
-    let commentParts
+    let commentParts;
     if (typeof commentInfo === "string") {
       commentParts = {
         header: commentHeader,
         warnings: commentWarnings,
         body: commentInfo,
         footer: commentFooter,
-      }
+      };
     } else {
       commentParts = {
         header: commentHeader,
         warnings: [...commentWarnings, ...(commentInfo.warnings || [])],
         body: commentInfo.body,
         footer: commentFooter,
-      }
+      };
     }
 
-    const commentBody = createGitHubPullRequestCommentText(commentParts)
+    const commentBody = createGitHubPullRequestCommentText(commentParts);
 
     if (existingComment) {
       if (existingComment.body === commentBody) {
-        logger.info(`existing comment body is the same -> skip comment PATCH`)
-        return existingComment
+        logger.info(`existing comment body is the same -> skip comment PATCH`);
+        return existingComment;
       }
-      logger.info(`updating comment at ${existingComment.html_url}`)
+      logger.info(`updating comment at ${existingComment.html_url}`);
       const comment = await githubRESTAPI.PATCH({
         url: `https://api.github.com/repos/${repositoryOwner}/${repositoryName}/issues/comments/${existingComment.id}`,
         githubToken,
         body: { body: commentBody },
-      })
-      logger.info("comment updated")
-      return comment
+      });
+      logger.info("comment updated");
+      return comment;
     }
 
-    logger.info(`creating comment`)
+    logger.info(`creating comment`);
     const comment = await githubRESTAPI.POST({
       url: `https://api.github.com/repos/${repositoryOwner}/${repositoryName}/issues/${pullRequestNumber}/comments`,
       githubToken,
       body: { body: commentBody },
-    })
-    logger.info(`comment created at ${comment.html_url}`)
-    return comment
-  }
+    });
+    logger.info(`comment created at ${comment.html_url}`);
+    return comment;
+  };
 
   const isFork =
-    pullRequest.base.repo.full_name !== pullRequest.head.repo.full_name
+    pullRequest.base.repo.full_name !== pullRequest.head.repo.full_name;
   const isInPullRequestWorkflow =
-    process.env.GITHUB_EVENT_NAME === "pull_request"
+    process.env.GITHUB_EVENT_NAME === "pull_request";
   if (isFork && isInPullRequestWorkflow) {
-    logger.warn(formatGithubTokenNotAllowedToCommentWarning())
+    logger.warn(formatGithubTokenNotAllowedToCommentWarning());
   }
 
-  let headRef
+  let headRef;
   if (isFork) {
     // https://github.community/t/checkout-a-branch-from-a-fork/276/2
-    headRef = `refs/pull/${pullRequestNumber}/merge`
+    headRef = `refs/pull/${pullRequestNumber}/merge`;
   } else {
-    headRef = pullRequestHead
+    headRef = pullRequestHead;
   }
 
-  let beforeMergeInfo
+  let beforeMergeInfo;
   try {
     // cannot use depth=1 arg otherwise git merge might have merge conflicts
     await execCommandInRootDirectory(
       `git fetch --no-tags --prune origin ${pullRequestBase}`,
-    )
+    );
     await execCommandInRootDirectory(
       `git reset --hard origin/${pullRequestBase}`,
-    )
+    );
     beforeMergeInfo = await collectInfo({
       beforeMerge: true,
       execCommandInRootDirectory,
-    })
+    });
     if (infoLogs) {
-      logger.debug(debugBeforeMergeInfo(beforeMergeInfo))
+      logger.debug(debugBeforeMergeInfo(beforeMergeInfo));
     }
   } catch (error) {
-    logger.error(error.stack)
+    logger.error(error.stack);
     const comment = await patchOrPostComment(
       createCommentForBeforeMergeError(error, {
         pullRequestHead,
         pullRequestBase,
       }),
-    )
+    );
     if (catchError) {
-      return { error, comment }
+      return { error, comment };
     }
-    throw error
+    throw error;
   }
 
-  let afterMergeInfo
+  let afterMergeInfo;
   try {
     // buildCommand might generate files that could conflict when doing the merge
     // reset to avoid potential merge conflicts
     await execCommandInRootDirectory(
       `git reset --hard origin/${pullRequestBase}`,
-    )
+    );
     // Avoid "The following untracked working tree files would be overwritten by merge" error
-    await execCommandInRootDirectory(`git clean -d -f .`)
+    await execCommandInRootDirectory(`git clean -d -f .`);
     // cannot use depth=1 arg otherwise git merge might have merge conflicts
     await execCommandInRootDirectory(
       `git fetch --no-tags --prune origin ${headRef}`,
-    )
+    );
     // ensure there is user.email + user.name required to perform git merge command
     // without them git would complain that it does not know who we are
 
     const restoreGitUserEmail = await ensureGitConfig("user.email", {
       valueIfMissing: "you@example.com",
       execCommandInRootDirectory,
-    })
+    });
     const restoreGitUserName = await ensureGitConfig("user.name", {
       valueIfMissing: "Your Name",
       execCommandInRootDirectory,
-    })
+    });
     // could we use https://stackoverflow.com/a/6283843 ?
     try {
       await execCommandInRootDirectory(
         `git merge FETCH_HEAD --allow-unrelated-histories --no-ff --no-commit`,
-      )
+      );
     } catch (e) {
-      throw new Error(`git merge command failed (is there a merge conflict?)`)
+      throw new Error(`git merge command failed (is there a merge conflict?)`);
     }
-    await restoreGitUserEmail()
-    await restoreGitUserName()
+    await restoreGitUserEmail();
+    await restoreGitUserName();
     afterMergeInfo = await collectInfo({
       afterMerge: true,
       execCommandInRootDirectory,
-    })
+    });
     if (infoLogs) {
-      logger.debug(debugAfterMergeInfo(afterMergeInfo))
+      logger.debug(debugAfterMergeInfo(afterMergeInfo));
     }
   } catch (error) {
-    logger.error(error.stack)
+    logger.error(error.stack);
     const gitHubComment = await patchOrPostComment(
       createCommentForAfterMergeError(error, {
         pullRequestHead,
         pullRequestBase,
       }),
-    )
+    );
     if (catchError) {
-      return { error, gitHubComment }
+      return { error, gitHubComment };
     }
-    throw error
+    throw error;
   }
 
-  const beforeMergeVersion = beforeMergeInfo.version
-  const afterMergeVersion = afterMergeInfo.version
+  const beforeMergeVersion = beforeMergeInfo.version;
+  const afterMergeVersion = afterMergeInfo.version;
   if (beforeMergeVersion !== afterMergeInfo.version) {
     const gitHubComment = await patchOrPostComment(
       createCommentForVersionMismatch({
         beforeMergeVersion,
         afterMergeVersion,
       }),
-    )
-    return { gitHubComment }
+    );
+    return { gitHubComment };
   }
 
   const commentForComparison = await createCommentForComparison({
@@ -354,55 +354,55 @@ const commentPrImpact = async ({
     beforeMergeData: beforeMergeInfo.data,
     afterMergeData: afterMergeInfo.data,
     existingComment,
-  })
-  const gitHubComment = await patchOrPostComment(commentForComparison)
+  });
+  const gitHubComment = await patchOrPostComment(commentForComparison);
 
-  return { gitHubComment }
-}
+  return { gitHubComment };
+};
 
 const ensureGitConfig = async (
   name,
   { execCommandInRootDirectory, valueIfMissing },
 ) => {
   try {
-    await execCommandInRootDirectory(`git config ${name}`)
-    return () => {}
+    await execCommandInRootDirectory(`git config ${name}`);
+    return () => {};
   } catch (e) {
-    await execCommandInRootDirectory(`git config ${name} "${valueIfMissing}"`)
+    await execCommandInRootDirectory(`git config ${name} "${valueIfMissing}"`);
     return async () => {
-      await execCommandInRootDirectory(`git config --unset ${name}`)
-    }
+      await execCommandInRootDirectory(`git config --unset ${name}`);
+    };
   }
-}
+};
 
 // https://docs.github.com/en/github/writing-on-github/working-with-advanced-formatting/autolinked-references-and-urls#commit-shas
 const shortenCommiSha = (sha) => {
-  if (sha.includes("@")) return sha
-  return sha.slice(0, 7)
-}
+  if (sha.includes("@")) return sha;
+  return sha.slice(0, 7);
+};
 
 const debugBeforeMergeInfo = (beforeMergeInfo) => {
   return `
 --- before merge info ---
 ${JSON.stringify(beforeMergeInfo, null, "  ")}
 
-`
-}
+`;
+};
 
 const debugAfterMergeInfo = (afterMergeInfo) => {
   return `
 --- after merge info ---
 ${JSON.stringify(afterMergeInfo, null, "  ")}
 
-`
-}
+`;
+};
 
 const formatGithubTokenNotAllowedToCommentWarning = () => {
   return `The github token will certainly not be allowed to post comment in the pull request.
 This is because pull request comes from a fork and your workflow is runned on "pull_request".
 To fix this, change "pull_request" for "pull_request_target" in your workflow file.
-See https://docs.github.com/en/actions/reference/events-that-trigger-workflows#pull_request_target`
-}
+See https://docs.github.com/en/actions/reference/events-that-trigger-workflows#pull_request_target`;
+};
 
 const jsenvCreateBeforeMergeErrorComment = (
   error,
@@ -414,8 +414,8 @@ const jsenvCreateBeforeMergeErrorComment = (
 
 <pre>${error.stack}</pre>
 
----`
-}
+---`;
+};
 
 const jsenvCreateCommentForAfterMergeError = (
   error,
@@ -427,8 +427,8 @@ const jsenvCreateCommentForAfterMergeError = (
 
 <pre>${error.stack}</pre>
 
----`
-}
+---`;
+};
 
 const jsenvCreateCommentForVersionMismatch = ({
   beforeMergeVersion,
@@ -442,8 +442,8 @@ Before merge data version: ${beforeMergeVersion}
 <br />
 After merge data version: ${afterMergeversion}
 
----`
-}
+---`;
+};
 
 const jsenvCreateCommentForComparison = ({
   beforeMergeInfo,
@@ -452,5 +452,5 @@ const jsenvCreateCommentForComparison = ({
   return `--- before merge ---
 ${JSON.stringify(beforeMergeInfo, null, "  ")}
 --- after merge ---
-${JSON.stringify(afterMergeInfo, null, "  ")}`
-}
+${JSON.stringify(afterMergeInfo, null, "  ")}`;
+};

package/src/internal/createGitHubPullRequestCommentText.js

@@ -1,4 +1,4 @@
-const GITHUB_MAX_COMMENT_LENGTH = 65536
+const GITHUB_MAX_COMMENT_LENGTH = 65536;
 
 export const createGitHubPullRequestCommentText = ({
   header = "",
@@ -17,12 +17,12 @@ export const createGitHubPullRequestCommentText = ({
     warnings,
     body,
     footer,
-  })
+  });
 
-  const commentLength = Buffer.byteLength(commentText)
+  const commentLength = Buffer.byteLength(commentText);
 
   if (commentLength < maxLength) {
-    return commentText
+    return commentText;
   }
 
   // on veut ajouter un warning + savoir combien de place il nous reste
@@ -33,8 +33,8 @@ export const createGitHubPullRequestCommentText = ({
     warnings,
     body,
     footer,
-  })
-}
+  });
+};
 
 const truncateComment = ({
   commentLength,
@@ -49,45 +49,45 @@ const truncateComment = ({
     `**Warning:** The comment body was truncated to fit GitHub limit on comment length.
 As the body is truncated the message might be hard to read.
 For the record the full comment length was ${commentLength} bytes.`,
-  ]
+  ];
 
   const commentWithFakeBody = composeCommentText({
     header,
     warnings: warningsWithTruncateWarning,
     body: "a",
     footer,
-  })
-  const commentWithFakeBodyLength = Buffer.byteLength(commentWithFakeBody)
-  let bytesAvailableForBody = maxLength - commentWithFakeBodyLength
+  });
+  const commentWithFakeBodyLength = Buffer.byteLength(commentWithFakeBody);
+  let bytesAvailableForBody = maxLength - commentWithFakeBodyLength;
   // add 1 because fake body had one letter
-  bytesAvailableForBody++
+  bytesAvailableForBody++;
   // remove byte length of `…` that is appended to the truncated body
-  bytesAvailableForBody -= Buffer.byteLength(`…`)
+  bytesAvailableForBody -= Buffer.byteLength(`…`);
 
-  const bodyTruncated = `${body.slice(0, bytesAvailableForBody)}…`
+  const bodyTruncated = `${body.slice(0, bytesAvailableForBody)}…`;
 
   return composeCommentText({
     header,
     warnings: warningsWithTruncateWarning,
     body: bodyTruncated,
     footer,
-  })
-}
+  });
+};
 
 const composeCommentText = ({ header, warnings, body, footer }) => {
-  const warningsAsText = composeWarningsText(warnings)
+  const warningsAsText = composeWarningsText(warnings);
   const parts = [header, warningsAsText, body, footer].filter(
     (string) => string.length > 0,
-  )
+  );
 
   return parts.join(`
 
-`)
-}
+`);
+};
 
 const composeWarningsText = (warnings) => {
   if (warnings.length === 0) {
-    return ""
+    return "";
   }
 
   return `---
@@ -96,5 +96,5 @@ ${warnings.join(`
 
 `)}
 
----`
-}
+---`;
+};

package/src/internal/exec.js

@@ -1,4 +1,4 @@
-import { exec as nodeExec } from "node:child_process"
+import { exec as nodeExec } from "node:child_process";
 
 export const exec = (
   command,
@@ -13,20 +13,20 @@ export const exec = (
       },
       (error, out) => {
         if (error) {
-          reject(error)
+          reject(error);
         } else {
-          resolve(out)
+          resolve(out);
         }
       },
-    )
+    );
 
     commandProcess.stdout.on("data", (data) => {
-      onLog(data)
-    })
+      onLog(data);
+    });
     commandProcess.stderr.on("data", (data) => {
       // debug because this output is part of
       // the error message generated by a failing npm publish
-      onErrorLog(data)
-    })
-  })
-}
+      onErrorLog(data);
+    });
+  });
+};

package/src/internal/github_rest_api.js

@@ -1,4 +1,4 @@
-import { fetchUrl } from "@jsenv/fetch"
+import { fetchUrl } from "@jsenv/fetch";
 
 export const GET = async ({ url, githubToken, headers }) => {
   return sendHttpRequest({
@@ -10,13 +10,13 @@ export const GET = async ({ url, githubToken, headers }) => {
     },
     responseStatusHandlers: {
       200: async (response) => {
-        const json = await response.json()
-        return json
+        const json = await response.json();
+        return json;
       },
       404: () => null,
     },
-  })
-}
+  });
+};
 
 export const POST = ({ url, body, githubToken, headers }) => {
   return sendHttpRequest({
@@ -29,12 +29,12 @@ export const POST = ({ url, body, githubToken, headers }) => {
     body: JSON.stringify(body),
     responseStatusHandlers: {
       201: async (response) => {
-        const json = await response.json()
-        return json
+        const json = await response.json();
+        return json;
       },
     },
-  })
-}
+  });
+};
 
 export const PATCH = async ({ url, body, githubToken, headers }) => {
   return sendHttpRequest({
@@ -47,21 +47,21 @@ export const PATCH = async ({ url, body, githubToken, headers }) => {
     body: JSON.stringify(body),
     responseStatusHandlers: {
       200: async (response) => {
-        const json = await response.json()
-        return json
+        const json = await response.json();
+        return json;
       },
     },
-  })
-}
+  });
+};
 
 const tokenToHeaders = (token) => {
   if (!token) {
-    throw new Error(`missing token, request will not be authorized.`)
+    throw new Error(`missing token, request will not be authorized.`);
   }
   return {
     authorization: `token ${token}`,
-  }
-}
+  };
+};
 
 const sendHttpRequest = async ({
   url,
@@ -70,7 +70,7 @@ const sendHttpRequest = async ({
   body,
   responseStatusHandlers = {},
 }) => {
-  let response
+  let response;
   try {
     response = await fetchUrl(url, {
       method,
@@ -81,7 +81,7 @@ const sendHttpRequest = async ({
         ...headers,
       },
       body,
-    })
+    });
   } catch (error) {
     throw new Error(`network error during request.
 --- request method ---
@@ -89,15 +89,15 @@ ${method}
 --- request url ---
 ${url}
 --- error stack ---
-${error.stack}`)
+${error.stack}`);
   }
 
-  const { status } = response
-  const responseStatusHandler = responseStatusHandlers[status]
+  const { status } = response;
+  const responseStatusHandler = responseStatusHandlers[status];
   if (responseStatusHandler) {
-    return responseStatusHandler(response)
+    return responseStatusHandler(response);
   }
-  const responseBodyAsJson = await response.json()
+  const responseBodyAsJson = await response.json();
   const error = new Error(`unexpected response status.
 --- response status ---
 ${response.status}
@@ -108,7 +108,7 @@ ${method}
 --- request url ---
 ${url}
 --- response json ---
-${(JSON.stringify(responseBodyAsJson), null, "  ")}`)
-  error.responseStatus = status
-  throw error
-}
+${(JSON.stringify(responseBodyAsJson), null, "  ")}`);
+  error.responseStatus = status;
+  throw error;
+};

package/src/internal/renderGeneratedByText.js

@@ -6,8 +6,8 @@ export const renderGeneratedByText = ({
   if (runLink && typeof runLink !== "object") {
     console.warn(
       `runLink ignored because it should be an object with {url, text}, received ${runLink}`,
-    )
-    runLink = null
+    );
+    runLink = null;
   }
 
   const parts = [
@@ -16,9 +16,9 @@ export const renderGeneratedByText = ({
     ...(commitLink
       ? [`on <a href="${commitLink.url}">${commitLink.text}</a>`]
       : []),
-  ]
+  ];
 
   return `<sub>
   ${parts.join(` `)}
-</sub>`
-}
+</sub>`;
+};

package/src/main.js

@@ -1,6 +1,6 @@
-export { readGitHubWorkflowEnv } from "./readGitHubWorkflowEnv.js"
-export { commentGitHubPullRequestImpact } from "./commentGitHubPullRequestImpact.js"
+export { readGitHubWorkflowEnv } from "./readGitHubWorkflowEnv.js";
+export { commentGitHubPullRequestImpact } from "./commentGitHubPullRequestImpact.js";
 
 // not planned to be documented but can be useful
 // to get a github comment from a { warnings, body } object
-export { createGitHubPullRequestCommentText } from "./internal/createGitHubPullRequestCommentText.js"
+export { createGitHubPullRequestCommentText } from "./internal/createGitHubPullRequestCommentText.js";

package/src/readGitHubWorkflowEnv.js

@@ -1,32 +1,32 @@
-import { readFileSync } from "node:fs"
+import { readFileSync } from "node:fs";
 
 export const readGitHubWorkflowEnv = () => {
-  const eventName = process.env.GITHUB_EVENT_NAME
+  const eventName = process.env.GITHUB_EVENT_NAME;
   if (!eventName) {
     throw new Error(
       `missing process.env.GITHUB_EVENT_NAME, we are not in a github workflow`,
-    )
+    );
   }
   if (eventName !== "pull_request" && eventName !== "pull_request_target") {
-    throw new Error(`must be called only in a pull request`)
+    throw new Error(`must be called only in a pull request`);
   }
-  const githubToken = process.env.GITHUB_TOKEN
+  const githubToken = process.env.GITHUB_TOKEN;
   if (!githubToken) {
-    throw new Error(`missing githubToken`)
+    throw new Error(`missing githubToken`);
   }
-  const githubRepository = process.env.GITHUB_REPOSITORY
+  const githubRepository = process.env.GITHUB_REPOSITORY;
   if (!githubRepository) {
-    throw new Error(`missing process.env.GITHUB_REPOSITORY`)
+    throw new Error(`missing process.env.GITHUB_REPOSITORY`);
   }
-  const [repositoryOwner, repositoryName] = githubRepository.split("/")
-  const pullRequestNumber = readPullRequestNumber()
-  const runId = process.env.GITHUB_RUN_ID
+  const [repositoryOwner, repositoryName] = githubRepository.split("/");
+  const pullRequestNumber = readPullRequestNumber();
+  const runId = process.env.GITHUB_RUN_ID;
   const runLink = runId
     ? {
         url: `https://github.com/${repositoryOwner}/${repositoryName}/actions/runs/${runId}`,
         text: `${process.env.GITHUB_WORKFLOW || "workflow"}#${runId}`,
       }
-    : undefined
+    : undefined;
   return {
     rootDirectoryUrl: process.env.GITHUB_WORKSPACE,
     githubToken,
@@ -34,47 +34,47 @@ export const readGitHubWorkflowEnv = () => {
     repositoryName,
     pullRequestNumber,
     runLink,
-  }
-}
+  };
+};
 
 const readPullRequestNumber = () => {
-  const githubRef = process.env.GITHUB_REF
+  const githubRef = process.env.GITHUB_REF;
   if (!githubRef) {
-    throw new Error(`missing process.env.GITHUB_REF`)
+    throw new Error(`missing process.env.GITHUB_REF`);
   }
-  const pullRequestNumber = githubRefToPullRequestNumber(githubRef)
-  if (pullRequestNumber) return pullRequestNumber
+  const pullRequestNumber = githubRefToPullRequestNumber(githubRef);
+  if (pullRequestNumber) return pullRequestNumber;
   // https://github.com/actions/checkout/issues/58#issuecomment-589447479
-  const githubEventFilePath = process.env.GITHUB_EVENT_PATH
+  const githubEventFilePath = process.env.GITHUB_EVENT_PATH;
   if (githubEventFilePath) {
     console.warn(`pull request number not found in process.env.GITHUB_REF, trying inside github event file.
 --- process.env.GITHUB_REF ---
 ${githubRef}
 --- github event file path ---
 ${githubEventFilePath}
-`)
-    const githubEventFileContent = String(readFileSync(githubEventFilePath))
-    const githubEvent = JSON.parse(githubEventFileContent)
-    const pullRequestNumber = githubEvent.pull_request.number
-    console.warn(`pull request number found in the file: ${pullRequestNumber}`)
+`);
+    const githubEventFileContent = String(readFileSync(githubEventFilePath));
+    const githubEvent = JSON.parse(githubEventFileContent);
+    const pullRequestNumber = githubEvent.pull_request.number;
+    console.warn(`pull request number found in the file: ${pullRequestNumber}`);
     if (pullRequestNumber) {
-      return pullRequestNumber
+      return pullRequestNumber;
     }
   }
   throw new Error(`cannot get pull request number from process.env.GITHUB_REF
 --- process.env.GITHUB_REF ---
-${githubRef}`)
-}
+${githubRef}`);
+};
 
 const githubRefToPullRequestNumber = (githubRef) => {
-  const pullPrefix = "refs/pull/"
-  const pullRequestNumberStartIndex = githubRef.indexOf(pullPrefix)
-  if (pullRequestNumberStartIndex === -1) return undefined
+  const pullPrefix = "refs/pull/";
+  const pullRequestNumberStartIndex = githubRef.indexOf(pullPrefix);
+  if (pullRequestNumberStartIndex === -1) return undefined;
   const afterPull = githubRef.slice(
     pullRequestNumberStartIndex + pullPrefix.length,
-  )
-  const slashAfterPullIndex = afterPull.indexOf("/")
-  if (slashAfterPullIndex === -1) return undefined
-  const pullRequestNumberString = afterPull.slice(0, slashAfterPullIndex)
-  return Number(pullRequestNumberString)
-}
+  );
+  const slashAfterPullIndex = afterPull.indexOf("/");
+  if (slashAfterPullIndex === -1) return undefined;
+  const pullRequestNumberString = afterPull.slice(0, slashAfterPullIndex);
+  return Number(pullRequestNumberString);
+};