binary-collections 2.0.7 → 2.0.9

package/lib/clean-github-actions-caches.cjs

@@ -0,0 +1,162 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const axios = require("axios");
+const { parseGitRemotes } = require("./utils");
+const path = require("upath");
+const fs = require("fs");
+const projectDir = process.cwd();
+const envPath = path.join(projectDir, ".env");
+// Load the .env file using dotenv
+if (fs.existsSync(envPath)) {
+    require("dotenv").config({ path: envPath });
+}
+else {
+    console.warn(`.env file not found at ${envPath}`);
+}
+// delete caches leaving single last cache based on creation date
+const ACCESS_TOKEN = process.env.GITHUB_TOKEN || process.env.ACCESS_TOKEN;
+if (!ACCESS_TOKEN) {
+    throw new Error("Access token is not provided. Please set ACCESS_TOKEN or GITHUB_TOKEN in your environment variables.");
+}
+/**
+ * Deletes a GitHub Actions cache.
+ * @param {string} GH_REPO - The GitHub repository in the format "owner/repo".
+ * @param {string} cacheId - The ID of the cache to delete.
+ * @returns {Promise} - A promise that resolves on success and rejects on error.
+ */
+function deleteGitHubActionsCache(GH_REPO, cacheId) {
+    return new Promise((resolve, reject) => {
+        const url = `https://api.github.com/repos/${GH_REPO}/actions/caches/${cacheId}`;
+        const token = ACCESS_TOKEN;
+        if (!token) {
+            return reject(new Error("Access token is not provided"));
+        }
+        axios
+            .delete(url, {
+            headers: {
+                Authorization: `token ${token}`,
+                Accept: "application/vnd.github.v3+json"
+            }
+        })
+            .then((response) => {
+            console.log(`Cache (${cacheId}) deleted successfully`, response.data);
+            resolve(response.data); // Resolve with the response data
+        })
+            .catch((error) => {
+            var _a;
+            console.error("Error deleting cache:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error.message || "Unknown error");
+            reject(error); // Reject with the error
+        });
+    });
+}
+/**
+ * list github actions caches
+ * @param {string} GH_REPO
+ * @returns {Promise<Record<string, Record<string, any>[]>>}
+ */
+function get_caches(GH_REPO) {
+    const url = `https://api.github.com/repos/${GH_REPO}/actions/caches`;
+    return new Promise((resolve, reject) => {
+        axios
+            .get(url, {
+            headers: {
+                Accept: "application/vnd.github.v3+json",
+                Authorization: `token ${ACCESS_TOKEN}`
+            }
+        })
+            .then((response) => {
+            /**
+             * @type {Record<string, any>[]}
+             */
+            const data = response.data.actions_caches;
+            // resolve(response.data);
+            /**
+             * extract the prefix from the key
+             * @param {string} key
+             * @returns
+             */
+            const getPrefix = (key) => {
+                const split = key.split(/[-_]/);
+                if (split.length == 3) {
+                    return `${split[0]}-${split[1]}`;
+                }
+                else if (split.length > 3) {
+                    return `${split[0]}-${split[1]}-${split[2]}`;
+                }
+                return split[0];
+            };
+            // Group by prefix
+            const grouped = data.reduce(
+            /**
+             * @param {Record<string, Record<string, any>[]>} acc
+             * @param {Record<string, any>} item
+             * @returns {Record<string, Record<string, any>[]>}
+             */
+            (acc, item) => {
+                const prefix = getPrefix(item.key);
+                if (!acc[prefix]) {
+                    acc[prefix] = [];
+                }
+                acc[prefix].push(item);
+                return acc;
+            }, {});
+            // Convert the grouped object into an array of arrays
+            // const result = Object.values(grouped);
+            resolve(grouped);
+        })
+            .catch((error) => {
+            console.error("Error fetching data:", error);
+            reject(error); // Reject the promise with the error
+        });
+    });
+}
+/**
+ * Deletes old GitHub Actions caches for the current repository (origin remote),
+ * keeping only the most recent cache for each prefix (based on creation date).
+ * Retrieves caches, groups by prefix, sorts by creation date, and deletes all but the latest.
+ */
+(() => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const remotes = yield parseGitRemotes();
+        const GH_REPO = remotes.origin;
+        const caches = yield get_caches(GH_REPO);
+        for (const key in caches) {
+            if (Object.hasOwnProperty.call(caches, key)) {
+                const items = caches[key]
+                    .sort((a, b) => new Date(b.created_at) - new Date(a.created_at))
+                    .map((item) => (Object.assign(Object.assign({}, item), { human_readable_date: new Date(item.created_at).toLocaleString() })));
+                if (items.length > 1) {
+                    const ids = items.map((o) => o.id);
+                    ids.shift(); // keep the most recent cache
+                    if (ids.length > 0) {
+                        for (const id of ids) {
+                            try {
+                                yield deleteGitHubActionsCache(GH_REPO, id);
+                            }
+                            catch (err) {
+                                console.error(`Error deleting cache ${id}:`, err);
+                            }
+                        }
+                    }
+                    else {
+                        console.log(`cache prefix ${key} no cache left`);
+                    }
+                }
+                else {
+                    console.log(`cache prefix ${key} only have 1 cache`);
+                }
+            }
+        }
+    }
+    catch (e) {
+        console.error(`Error: ${e}`);
+    }
+}))();

package/lib/clean-github-actions-caches.d.cts

@@ -0,0 +1 @@
+export {};

package/lib/clean-github-actions-caches.d.mts

@@ -0,0 +1,169 @@
+const axios = require("axios");
+const { parseGitRemotes } = require("./utils");
+const path = require("upath");
+const fs = require("fs");
+const projectDir = process.cwd();
+const envPath = path.join(projectDir, ".env");
+
+// Load the .env file using dotenv
+if (fs.existsSync(envPath)) {
+  require("dotenv").config({ path: envPath });
+} else {
+  console.warn(`.env file not found at ${envPath}`);
+}
+
+// delete caches leaving single last cache based on creation date
+
+const ACCESS_TOKEN = process.env.GITHUB_TOKEN || process.env.ACCESS_TOKEN;
+
+if (!ACCESS_TOKEN) {
+  throw new Error(
+    "Access token is not provided. Please set ACCESS_TOKEN or GITHUB_TOKEN in your environment variables."
+  );
+}
+
+/**
+ * Deletes a GitHub Actions cache.
+ * @param {string} GH_REPO - The GitHub repository in the format "owner/repo".
+ * @param {string} cacheId - The ID of the cache to delete.
+ * @returns {Promise} - A promise that resolves on success and rejects on error.
+ */
+function deleteGitHubActionsCache(GH_REPO, cacheId) {
+  return new Promise((resolve, reject) => {
+    const url = `https://api.github.com/repos/${GH_REPO}/actions/caches/${cacheId}`;
+    const token = ACCESS_TOKEN;
+
+    if (!token) {
+      return reject(new Error("Access token is not provided"));
+    }
+
+    axios
+      .delete(url, {
+        headers: {
+          Authorization: `token ${token}`,
+          Accept: "application/vnd.github.v3+json"
+        }
+      })
+      .then((response) => {
+        console.log(`Cache (${cacheId}) deleted successfully`, response.data);
+        resolve(response.data); // Resolve with the response data
+      })
+      .catch((error) => {
+        console.error("Error deleting cache:", error.response?.data || error.message || "Unknown error");
+        reject(error); // Reject with the error
+      });
+  });
+}
+
+/**
+ * list github actions caches
+ * @param {string} GH_REPO
+ * @returns {Promise<Record<string, Record<string, any>[]>>}
+ */
+function get_caches(GH_REPO) {
+  const url = `https://api.github.com/repos/${GH_REPO}/actions/caches`;
+
+  return new Promise((resolve, reject) => {
+    axios
+      .get(url, {
+        headers: {
+          Accept: "application/vnd.github.v3+json",
+          Authorization: `token ${ACCESS_TOKEN}`
+        }
+      })
+      .then((response) => {
+        /**
+         * @type {Record<string, any>[]}
+         */
+        const data = response.data.actions_caches;
+        // resolve(response.data);
+        /**
+         * extract the prefix from the key
+         * @param {string} key
+         * @returns
+         */
+        const getPrefix = (key) => {
+          const split = key.split(/[-_]/);
+          if (split.length == 3) {
+            return `${split[0]}-${split[1]}`;
+          } else if (split.length > 3) {
+            return `${split[0]}-${split[1]}-${split[2]}`;
+          }
+          return split[0];
+        };
+
+        // Group by prefix
+        const grouped = data.reduce(
+          /**
+           * @param {Record<string, Record<string, any>[]>} acc
+           * @param {Record<string, any>} item
+           * @returns {Record<string, Record<string, any>[]>}
+           */
+          (acc, item) => {
+            const prefix = getPrefix(item.key);
+
+            if (!acc[prefix]) {
+              acc[prefix] = [];
+            }
+
+            acc[prefix].push(item);
+
+            return acc;
+          },
+          {}
+        );
+
+        // Convert the grouped object into an array of arrays
+        // const result = Object.values(grouped);
+        resolve(grouped);
+      })
+      .catch((error) => {
+        console.error("Error fetching data:", error);
+        reject(error); // Reject the promise with the error
+      });
+  });
+}
+
+/**
+ * Deletes old GitHub Actions caches for the current repository (origin remote),
+ * keeping only the most recent cache for each prefix (based on creation date).
+ * Retrieves caches, groups by prefix, sorts by creation date, and deletes all but the latest.
+ */
+(async () => {
+  try {
+    const remotes = await parseGitRemotes();
+    const GH_REPO = remotes.origin;
+    const caches = await get_caches(GH_REPO);
+
+    for (const key in caches) {
+      if (Object.hasOwnProperty.call(caches, key)) {
+        const items = caches[key]
+          .sort((a, b) => new Date(b.created_at) - new Date(a.created_at))
+          .map((item) => ({
+            ...item,
+            human_readable_date: new Date(item.created_at).toLocaleString()
+          }));
+
+        if (items.length > 1) {
+          const ids = items.map((o) => o.id);
+          ids.shift(); // keep the most recent cache
+          if (ids.length > 0) {
+            for (const id of ids) {
+              try {
+                await deleteGitHubActionsCache(GH_REPO, id);
+              } catch (err) {
+                console.error(`Error deleting cache ${id}:`, err);
+              }
+            }
+          } else {
+            console.log(`cache prefix ${key} no cache left`);
+          }
+        } else {
+          console.log(`cache prefix ${key} only have 1 cache`);
+        }
+      }
+    }
+  } catch (e) {
+    console.error(`Error: ${e}`);
+  }
+})();

package/lib/clean-github-actions-caches.d.ts

@@ -0,0 +1,169 @@
+const axios = require("axios");
+const { parseGitRemotes } = require("./utils");
+const path = require("upath");
+const fs = require("fs");
+const projectDir = process.cwd();
+const envPath = path.join(projectDir, ".env");
+
+// Load the .env file using dotenv
+if (fs.existsSync(envPath)) {
+  require("dotenv").config({ path: envPath });
+} else {
+  console.warn(`.env file not found at ${envPath}`);
+}
+
+// delete caches leaving single last cache based on creation date
+
+const ACCESS_TOKEN = process.env.GITHUB_TOKEN || process.env.ACCESS_TOKEN;
+
+if (!ACCESS_TOKEN) {
+  throw new Error(
+    "Access token is not provided. Please set ACCESS_TOKEN or GITHUB_TOKEN in your environment variables."
+  );
+}
+
+/**
+ * Deletes a GitHub Actions cache.
+ * @param {string} GH_REPO - The GitHub repository in the format "owner/repo".
+ * @param {string} cacheId - The ID of the cache to delete.
+ * @returns {Promise} - A promise that resolves on success and rejects on error.
+ */
+function deleteGitHubActionsCache(GH_REPO, cacheId) {
+  return new Promise((resolve, reject) => {
+    const url = `https://api.github.com/repos/${GH_REPO}/actions/caches/${cacheId}`;
+    const token = ACCESS_TOKEN;
+
+    if (!token) {
+      return reject(new Error("Access token is not provided"));
+    }
+
+    axios
+      .delete(url, {
+        headers: {
+          Authorization: `token ${token}`,
+          Accept: "application/vnd.github.v3+json"
+        }
+      })
+      .then((response) => {
+        console.log(`Cache (${cacheId}) deleted successfully`, response.data);
+        resolve(response.data); // Resolve with the response data
+      })
+      .catch((error) => {
+        console.error("Error deleting cache:", error.response?.data || error.message || "Unknown error");
+        reject(error); // Reject with the error
+      });
+  });
+}
+
+/**
+ * list github actions caches
+ * @param {string} GH_REPO
+ * @returns {Promise<Record<string, Record<string, any>[]>>}
+ */
+function get_caches(GH_REPO) {
+  const url = `https://api.github.com/repos/${GH_REPO}/actions/caches`;
+
+  return new Promise((resolve, reject) => {
+    axios
+      .get(url, {
+        headers: {
+          Accept: "application/vnd.github.v3+json",
+          Authorization: `token ${ACCESS_TOKEN}`
+        }
+      })
+      .then((response) => {
+        /**
+         * @type {Record<string, any>[]}
+         */
+        const data = response.data.actions_caches;
+        // resolve(response.data);
+        /**
+         * extract the prefix from the key
+         * @param {string} key
+         * @returns
+         */
+        const getPrefix = (key) => {
+          const split = key.split(/[-_]/);
+          if (split.length == 3) {
+            return `${split[0]}-${split[1]}`;
+          } else if (split.length > 3) {
+            return `${split[0]}-${split[1]}-${split[2]}`;
+          }
+          return split[0];
+        };
+
+        // Group by prefix
+        const grouped = data.reduce(
+          /**
+           * @param {Record<string, Record<string, any>[]>} acc
+           * @param {Record<string, any>} item
+           * @returns {Record<string, Record<string, any>[]>}
+           */
+          (acc, item) => {
+            const prefix = getPrefix(item.key);
+
+            if (!acc[prefix]) {
+              acc[prefix] = [];
+            }
+
+            acc[prefix].push(item);
+
+            return acc;
+          },
+          {}
+        );
+
+        // Convert the grouped object into an array of arrays
+        // const result = Object.values(grouped);
+        resolve(grouped);
+      })
+      .catch((error) => {
+        console.error("Error fetching data:", error);
+        reject(error); // Reject the promise with the error
+      });
+  });
+}
+
+/**
+ * Deletes old GitHub Actions caches for the current repository (origin remote),
+ * keeping only the most recent cache for each prefix (based on creation date).
+ * Retrieves caches, groups by prefix, sorts by creation date, and deletes all but the latest.
+ */
+(async () => {
+  try {
+    const remotes = await parseGitRemotes();
+    const GH_REPO = remotes.origin;
+    const caches = await get_caches(GH_REPO);
+
+    for (const key in caches) {
+      if (Object.hasOwnProperty.call(caches, key)) {
+        const items = caches[key]
+          .sort((a, b) => new Date(b.created_at) - new Date(a.created_at))
+          .map((item) => ({
+            ...item,
+            human_readable_date: new Date(item.created_at).toLocaleString()
+          }));
+
+        if (items.length > 1) {
+          const ids = items.map((o) => o.id);
+          ids.shift(); // keep the most recent cache
+          if (ids.length > 0) {
+            for (const id of ids) {
+              try {
+                await deleteGitHubActionsCache(GH_REPO, id);
+              } catch (err) {
+                console.error(`Error deleting cache ${id}:`, err);
+              }
+            }
+          } else {
+            console.log(`cache prefix ${key} no cache left`);
+          }
+        } else {
+          console.log(`cache prefix ${key} only have 1 cache`);
+        }
+      }
+    }
+  } catch (e) {
+    console.error(`Error: ${e}`);
+  }
+})();

package/lib/clean-github-actions-caches.mjs

@@ -0,0 +1,132 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_utils
+} from "./chunk-APBWENF6.mjs";
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-AASHBCRW.mjs";
+
+// src/clean-github-actions-caches.cjs
+var require_clean_github_actions_caches = __commonJS({
+  "src/clean-github-actions-caches.cjs"() {
+    init_esm_shims();
+    var axios = __require("axios");
+    var { parseGitRemotes } = require_utils();
+    var path = __require("upath");
+    var fs = __require("fs");
+    var projectDir = process.cwd();
+    var envPath = path.join(projectDir, ".env");
+    if (fs.existsSync(envPath)) {
+      __require("dotenv").config({ path: envPath });
+    } else {
+      console.warn(`.env file not found at ${envPath}`);
+    }
+    var ACCESS_TOKEN = process.env.GITHUB_TOKEN || process.env.ACCESS_TOKEN;
+    if (!ACCESS_TOKEN) {
+      throw new Error(
+        "Access token is not provided. Please set ACCESS_TOKEN or GITHUB_TOKEN in your environment variables."
+      );
+    }
+    function deleteGitHubActionsCache(GH_REPO, cacheId) {
+      return new Promise((resolve, reject) => {
+        const url = `https://api.github.com/repos/${GH_REPO}/actions/caches/${cacheId}`;
+        const token = ACCESS_TOKEN;
+        if (!token) {
+          return reject(new Error("Access token is not provided"));
+        }
+        axios.delete(url, {
+          headers: {
+            Authorization: `token ${token}`,
+            Accept: "application/vnd.github.v3+json"
+          }
+        }).then((response) => {
+          console.log(`Cache (${cacheId}) deleted successfully`, response.data);
+          resolve(response.data);
+        }).catch((error) => {
+          var _a;
+          console.error("Error deleting cache:", ((_a = error.response) == null ? void 0 : _a.data) || error.message || "Unknown error");
+          reject(error);
+        });
+      });
+    }
+    function get_caches(GH_REPO) {
+      const url = `https://api.github.com/repos/${GH_REPO}/actions/caches`;
+      return new Promise((resolve, reject) => {
+        axios.get(url, {
+          headers: {
+            Accept: "application/vnd.github.v3+json",
+            Authorization: `token ${ACCESS_TOKEN}`
+          }
+        }).then((response) => {
+          const data = response.data.actions_caches;
+          const getPrefix = (key) => {
+            const split = key.split(/[-_]/);
+            if (split.length == 3) {
+              return `${split[0]}-${split[1]}`;
+            } else if (split.length > 3) {
+              return `${split[0]}-${split[1]}-${split[2]}`;
+            }
+            return split[0];
+          };
+          const grouped = data.reduce(
+            /**
+             * @param {Record<string, Record<string, any>[]>} acc
+             * @param {Record<string, any>} item
+             * @returns {Record<string, Record<string, any>[]>}
+             */
+            (acc, item) => {
+              const prefix = getPrefix(item.key);
+              if (!acc[prefix]) {
+                acc[prefix] = [];
+              }
+              acc[prefix].push(item);
+              return acc;
+            },
+            {}
+          );
+          resolve(grouped);
+        }).catch((error) => {
+          console.error("Error fetching data:", error);
+          reject(error);
+        });
+      });
+    }
+    (async () => {
+      try {
+        const remotes = await parseGitRemotes();
+        const GH_REPO = remotes.origin;
+        const caches = await get_caches(GH_REPO);
+        for (const key in caches) {
+          if (Object.hasOwnProperty.call(caches, key)) {
+            const items = caches[key].sort((a, b) => new Date(b.created_at) - new Date(a.created_at)).map((item) => ({
+              ...item,
+              human_readable_date: new Date(item.created_at).toLocaleString()
+            }));
+            if (items.length > 1) {
+              const ids = items.map((o) => o.id);
+              ids.shift();
+              if (ids.length > 0) {
+                for (const id of ids) {
+                  try {
+                    await deleteGitHubActionsCache(GH_REPO, id);
+                  } catch (err) {
+                    console.error(`Error deleting cache ${id}:`, err);
+                  }
+                }
+              } else {
+                console.log(`cache prefix ${key} no cache left`);
+              }
+            } else {
+              console.log(`cache prefix ${key} only have 1 cache`);
+            }
+          }
+        }
+      } catch (e) {
+        console.error(`Error: ${e}`);
+      }
+    })();
+  }
+});
+export default require_clean_github_actions_caches();