feat: support pagination of tags

with short circuiting.

Closes #3

Author: EricCrosson

.github/workflows/ci.yml

@@ -38,8 +38,8 @@ jobs:
         if: steps.cache-node-modules.outputs.cache-hit != 'true'
         run: npm ci --ignore-scripts
 
-      - name: Compile TypeScript
-        run: npm run build
+      - name: Type check
+        run: ./node_modules/.bin/tsc --noEmit
 
       - name: Test
         run: npm test

src/fetch.ts

@@ -1,6 +1,8 @@
 import type { Octokit } from "./octokit";
+import { isEqual, none, Option, some } from "./option";
 
-import type {
+import {
+  isExactSemanticVersion,
   ExactSemanticVersion,
   RepositorySlug,
   SemanticVersion,
@@ -19,18 +21,87 @@ type Tag = {
 
 export type TagsResponse = ReadonlyArray<Tag>;
 
-// NOTE: there's a foot-gun here around lack of pagination
-export async function fetchRepoTags(
+function containsExactTag(
+  tags: readonly SemanticVersion[] | undefined
+): ExactSemanticVersion | undefined {
+  if (tags === undefined) {
+    return undefined;
+  }
+  return tags.find(isExactSemanticVersion);
+}
+
+// Find the exact semantic version tag that this tag maps to.
+//
+// We need an exact tag because that's the only accepted input
+// to GitHub's getReleaseByTag endpoint.
+export async function findExactSemanticVersionTag(
   octokit: Octokit,
-  slug: RepositorySlug
-): Promise<TagsResponse> {
-  const response = await octokit.rest.repos.listTags({
-    owner: slug.owner,
-    repo: slug.repository,
-    per_page: 100,
-  });
-  // NOTE: we are not parsing here, so this is an unlawful type cast
-  return response.data as unknown as TagsResponse;
+  slug: RepositorySlug,
+  givenTag: SemanticVersion
+): Promise<ExactSemanticVersion> {
+  if (isExactSemanticVersion(givenTag)) {
+    return givenTag;
+  }
+
+  const versionsBySha: Record<Sha, SemanticVersion[]> = {};
+  let givenTagSha: Option<Sha> = none();
+
+  // Conditions to stop looping are -- we know both the:
+  //
+  // - sha that the given tag points to
+  // - exact version tag matching that sha
+  //
+  // These can be found in either order.
+
+  for await (const response of octokit.paginate.iterator(
+    octokit.rest.repos.listTags,
+    {
+      owner: slug.owner,
+      repo: slug.repository,
+      per_page: 100,
+    }
+  )) {
+    // NOTE: we are not parsing here, so this is an unlawful type cast
+    for (const tag of response.data as unknown as TagsResponse) {
+      const sha = tag.commit.sha;
+      const version = tag.name;
+
+      // If we found the sha the given tag points to
+      if (version === givenTag) {
+        givenTagSha = some(sha);
+        // check if we already knew the exact version tag matching that sha
+        const maybeExactTag = containsExactTag(versionsBySha[sha]);
+        if (maybeExactTag !== undefined) {
+          return maybeExactTag;
+        }
+      }
+
+      // If we're not looking at the given tag, and we're not looking
+      // at an exact version, this data is of no use to us.
+      if (!isExactSemanticVersion(version)) {
+        continue;
+      }
+
+      // It is possible that we know the sha for the given tag,
+      // we're just looking for exact version tag matching that sha.
+      if (isEqual(givenTagSha, sha)) {
+        return version;
+      }
+
+      // Otherwise, record this map of sha -> exact version tag
+      // so we can find it when we know the sha of the given tag.
+      const associatedVersions = versionsBySha[sha];
+      if (associatedVersions === undefined) {
+        versionsBySha[sha] = [version];
+      } else {
+        associatedVersions.push(version);
+      }
+    }
+  }
+
+  throw new Error(
+    `Expected to find an exact semantic version tag matching ${givenTag}`
+  );
 }
 
 type ReleaseAssetMetadata = {

src/github.ts

@@ -6,7 +6,6 @@ import * as core from "@actions/core";
 import * as tc from "@actions/tool-cache";
 
 import { getErrors, unwrap } from "./either";
-import { resolveReleaseTag } from "./github";
 import { getOctokit, Octokit } from "./octokit";
 import {
   parseCacheDirectory,
@@ -15,7 +14,10 @@ import {
   TargetBinary,
 } from "./parse";
 import { getTargetTriple } from "./platform";
-import { fetchReleaseAssetMetadataFromTag, fetchRepoTags } from "./fetch";
+import {
+  fetchReleaseAssetMetadataFromTag,
+  findExactSemanticVersionTag,
+} from "./fetch";
 import type { ExactSemanticVersion, RepositorySlug } from "./types";
 
 function getDestinationDirectory(
@@ -40,11 +42,13 @@ async function installGitHubReleaseBinary(
   cacheDirectory: string,
   token: string
 ): Promise<void> {
-  // NOTE: there's a foot-gun here cause by lack of pagination
-  const repoTags = await fetchRepoTags(octokit, targetBinary.slug);
-  const releaseTag = resolveReleaseTag(repoTags, targetBinary.tag);
   const targetTriple = getTargetTriple(arch(), platform());
 
+  const releaseTag = await findExactSemanticVersionTag(
+    octokit,
+    targetBinary.slug,
+    targetBinary.tag
+  );
   const releaseAsset = await fetchReleaseAssetMetadataFromTag(
     octokit,
     targetBinary.slug,

src/index.ts

@@ -0,0 +1,16 @@
+export type Option<A> = { tag: "none" } | { tag: "some"; value: A };
+
+export function none<A>(): Option<A> {
+  return { tag: "none" };
+}
+
+export function some<A>(value: A): Option<A> {
+  return { tag: "some", value };
+}
+
+export function isEqual<A>(value: Option<A>, to: A): boolean {
+  if (value.tag === "none") {
+    return false;
+  }
+  return value.value === to;
+}