refactor: inputs as class, graceful validation errors

src/fetch-check-runs.ts

@@ -1,28 +1,42 @@
 import * as github from "@actions/github";
 import type { components } from "@octokit/openapi-types";
-import { inputs } from "./inputs";
 import { RelevantCheckRuns } from "./relevant-check-runs";
+import { GitHub } from "@actions/github/lib/utils";
 
 export type CheckRun = components["schemas"]["check-run"];
 
-const octokit = github.getOctokit(inputs.token);
+export class CheckRunFetcher {
+  private octokit: InstanceType<typeof GitHub> | null = null;
 
-export const fetchCheckRuns = async (): Promise<RelevantCheckRuns> => {
-  const iterator = octokit.paginate.iterator(octokit.rest.checks.listForRef, {
-    ...github.context.repo,
-    ref: inputs.ref,
-    per_page: 100,
-  });
+  constructor(
+    private token: string,
+    private ref: string,
+    private ownName: string,
+    private ignoredChecks: Set<string>,
+  ) {}
 
-  let runs: CheckRun[] = [];
+  async fetch(): Promise<RelevantCheckRuns> {
+    this.octokit ??= github.getOctokit(this.token);
 
-  for await (const { data } of iterator) {
-    runs = runs.concat(data);
-  }
+    const iterator = this.octokit.paginate.iterator(
+      this.octokit.rest.checks.listForRef,
+      {
+        ...github.context.repo,
+        ref: this.ref,
+        per_page: 100,
+      },
+    );
+
+    let runs: CheckRun[] = [];
 
-  return new RelevantCheckRuns(
-    runs.filter(
-      (run) => run.name !== inputs.name && !inputs.ignored.has(run.name),
-    ),
-  );
-};
+    for await (const { data } of iterator) {
+      runs = runs.concat(data);
+    }
+
+    return new RelevantCheckRuns(
+      runs.filter(
+        (run) => run.name !== this.ownName && !this.ignoredChecks.has(run.name),
+      ),
+    );
+  }
+}

src/index.ts

@@ -1,26 +1,45 @@
 import * as core from "@actions/core";
 import { delay } from "./delay";
-import { fetchCheckRuns } from "./fetch-check-runs";
-import { inputs } from "./inputs";
+import { CheckRunFetcher } from "./fetch-check-runs";
+import { Inputs } from "./inputs";
 import { Display } from "./display";
 
-const startTime = new Date();
+const run = async (): Promise<void> => {
+  const startTime = new Date();
+  let inputs: Inputs;
 
-const shouldTimeOut = (): boolean => {
-  const executionTime = Math.round(
-    (new Date().getTime() - startTime.getTime()) / 1000,
-  );
-  return executionTime > inputs.timeout;
-};
+  try {
+    inputs = new Inputs();
+  } catch (error) {
+    if (error instanceof Error) {
+      core.setFailed(error);
+      return;
+    } else {
+      throw error;
+    }
+  }
+
+  const shouldTimeOut = (): boolean => {
+    const executionTime = Math.round(
+      (new Date().getTime() - startTime.getTime()) / 1000,
+    );
+    return executionTime > inputs.timeout;
+  };
 
-Display.ignoredCheckNames(inputs.ignored);
+  Display.ignoredCheckNames(inputs.ignored);
 
-const waitForCheckRuns = async (): Promise<void> => {
   try {
+    const checkRunFetcher = new CheckRunFetcher(
+      inputs.token,
+      inputs.ref,
+      inputs.name,
+      inputs.ignored,
+    );
+
     while (!shouldTimeOut()) {
       Display.startingIteration();
 
-      const checkRuns = await fetchCheckRuns();
+      const checkRuns = await checkRunFetcher.fetch();
 
       if (checkRuns.total() === 0) {
         Display.delaying(inputs.interval);
@@ -57,4 +76,4 @@ const waitForCheckRuns = async (): Promise<void> => {
   }
 };
 
-waitForCheckRuns();
+run();

src/inputs.ts

@@ -2,29 +2,38 @@ import * as core from "@actions/core";
 
 const interval = Number(core.getInput("interval"));
 
-if (!Number.isInteger(interval)) {
-  throw new Error("Invalid interval");
-}
+export class Inputs {
+  readonly token: string;
+  readonly name: string;
+  readonly interval: number;
+  readonly timeout: number;
+  readonly ref: string;
+  readonly ignored: Set<string>;
 
-if (interval < 1) {
-  throw new Error("Interval must be greater than 0");
-}
+  constructor() {
+    if (!Number.isInteger(interval)) {
+      throw new Error("Invalid interval");
+    }
 
-const timeout = Number(core.getInput("timeout"));
+    if (interval < 1) {
+      throw new Error("Interval must be greater than 0");
+    }
 
-if (!Number.isInteger(timeout)) {
-  throw new Error("Invalid timeout");
-}
+    const timeout = Number(core.getInput("timeout"));
 
-if (timeout < 1) {
-  throw new Error("Timeout must be greater than 0");
-}
+    if (!Number.isInteger(timeout)) {
+      throw new Error("Invalid timeout");
+    }
+
+    if (timeout < 1) {
+      throw new Error("Timeout must be greater than 0");
+    }
 
-export const inputs = {
-  token: core.getInput("token", { required: true }),
-  name: core.getInput("name"),
-  interval,
-  timeout,
-  ref: core.getInput("ref"),
-  ignored: new Set(core.getMultilineInput("ignored")),
-} as const;
+    this.token = core.getInput("token", { required: true });
+    this.name = core.getInput("name");
+    this.interval = interval;
+    this.timeout = timeout;
+    this.ref = core.getInput("ref");
+    this.ignored = new Set(core.getMultilineInput("ignored"));
+  }
+}