src/utils/githubREST.mts

   1 import { get } from "http";
   2 import { Octokit } from "octokit";
   3
   4 interface GithubRelease {
   5   tagName: string;
   6   //downloadUrl: string;
   7 }
   8
   9 // NOTE: The primary rate limit for unauthenticated requests is 60 requests per hour.
  10 export const SDK_REPOSITORY_URL = "https://github.com/raspberrypi/pico-sdk.git";
  11 export const NINJA_REPOSITORY_URL = "https://github.com/ninja-build/ninja.git";
  12 export const CMAKE_REPOSITORY_URL = "https://github.com/Kitware/CMake.git";
  13 export const PYENV_REPOSITORY_URL = "https://github.com/pyenv/pyenv.git";
  14
  15 export async function getSDKReleases(): Promise<GithubRelease[]> {
  16   const octokit = new Octokit();
  17
  18   const response = await octokit.request("GET /repos/{owner}/{repo}/releases", {
  19     owner: "raspberrypi",
  20     repo: "pico-sdk",
  21     headers: {
  22       // eslint-disable-next-line @typescript-eslint/naming-convention
  23       "X-GitHub-Api-Version": "2022-11-28",
  24     },
  25   });
  26
  27   if (response.status !== 200) {
  28     return new Promise<Array<{ tagName: string }>>(resolve => {
  29       get("http://localhost:8080/releases/pico-sdk", response => {
  30         let data = "";
  31
  32         // Append data as it arrives
  33         response.on("data", chunk => {
  34           data += chunk;
  35         });
  36
  37         response.on("end", () => {
  38           const releases: Array<{ tag_name: string }> = JSON.parse(
  39             data
  40           ) as Array<{ tag_name: string }>;
  41
  42           resolve(
  43             releases
  44               .flatMap(release => ({
  45                 tagName: release.tag_name,
  46               }))
  47               .filter(release => release !== null) as Array<{ tagName: string }>
  48           );
  49         });
  50       });
  51     });
  52   }
  53
  54   return response.data
  55     .flatMap(release => ({
  56       tagName: release.tag_name,
  57     }))
  58     .filter(release => release !== null) as GithubRelease[];
  59 }
  60
  61 export async function getNinjaReleases(): Promise<Array<{ tagName: string }>> {
  62   const octokit = new Octokit();
  63
  64   const response = await octokit.request("GET /repos/{owner}/{repo}/releases", {
  65     owner: "ninja-build",
  66     repo: "ninja",
  67     headers: {
  68       // eslint-disable-next-line @typescript-eslint/naming-convention
  69       "X-GitHub-Api-Version": "2022-11-28",
  70     },
  71   });
  72
  73   if (response.status !== 200) {
  74     return new Promise<Array<{ tagName: string }>>(resolve => {
  75       get("http://localhost:8080/releases/Ninja", response => {
  76         let data = "";
  77
  78         // Append data as it arrives
  79         response.on("data", chunk => {
  80           data += chunk;
  81         });
  82
  83         response.on("end", () => {
  84           const releases: Array<{ tag_name: string }> = JSON.parse(
  85             data
  86           ) as Array<{ tag_name: string }>;
  87
  88           resolve(
  89             releases
  90               .flatMap(release => ({
  91                 tagName: release.tag_name,
  92               }))
  93               .filter(release => release !== null) as Array<{ tagName: string }>
  94           );
  95         });
  96       });
  97     });
  98   }
  99
 100   return (
 101     response.data
 102       //.slice(0, 10)
 103       .flatMap(release => ({
 104         tagName: release.tag_name,
 105       }))
 106       .filter(release => release !== null) as Array<{ tagName: string }>
 107   );
 108 }
 109
 110 export async function getCmakeReleases(): Promise<Array<{ tagName: string }>> {
 111   const octokit = new Octokit();
 112
 113   const response = await octokit.request("GET /repos/{owner}/{repo}/releases", {
 114     owner: "Kitware",
 115     repo: "CMake",
 116     headers: {
 117       // eslint-disable-next-line @typescript-eslint/naming-convention
 118       "X-GitHub-Api-Version": "2022-11-28",
 119     },
 120   });
 121
 122   if (response.status !== 200) {
 123     return new Promise<Array<{ tagName: string }>>(resolve => {
 124       get("http://localhost:8080/releases/CMake", response => {
 125         let data = "";
 126
 127         // Append data as it arrives
 128         response.on("data", chunk => {
 129           data += chunk;
 130         });
 131
 132         response.on("end", () => {
 133           const releases: Array<{ tag_name: string }> = JSON.parse(
 134             data
 135           ) as Array<{ tag_name: string }>;
 136
 137           resolve(
 138             releases
 139               .flatMap(release => ({
 140                 tagName: release.tag_name,
 141               }))
 142               .filter(release => release !== null) as Array<{ tagName: string }>
 143           );
 144         });
 145       });
 146     });
 147   }
 148
 149   return (
 150     response.data
 151       //.slice(0, 10)
 152       .flatMap(release => ({
 153         tagName: release.tag_name,
 154       }))
 155       .filter(release => release !== null) as Array<{ tagName: string }>
 156   );
 157 }