keycloak_theme/src/bin/shared/promptKeycloakVersion.ts

import { getLatestsSemVersionedTagFactory } from "../tools/octokit-addons/getLatestsSemVersionedTag";
import { Octokit } from "@octokit/rest";
import cliSelect from "cli-select";
import { SemVer } from "../tools/SemVer";
import { join as pathJoin, dirname as pathDirname } from "path";
import * as fs from "fs";
import type { ReturnType } from "tsafe";
import { id } from "tsafe/id";

export async function promptKeycloakVersion(params: { startingFromMajor: number | undefined; cacheDirPath: string }) {
    const { startingFromMajor, cacheDirPath } = params;

    const { getLatestsSemVersionedTag } = (() => {
        const { octokit } = (() => {
            const githubToken = process.env.GITHUB_TOKEN;

            const octokit = new Octokit(githubToken === undefined ? undefined : { "auth": githubToken });

            return { octokit };
        })();

        const { getLatestsSemVersionedTag } = getLatestsSemVersionedTagFactory({ octokit });

        return { getLatestsSemVersionedTag };
    })();

    const semVersionedTagByMajor = new Map<number, { tag: string; version: SemVer }>();

    const semVersionedTags = await (async () => {
        const cacheFilePath = pathJoin(cacheDirPath, "keycloak-versions.json");

        type Cache = {
            time: number;
            semVersionedTags: ReturnType<typeof getLatestsSemVersionedTag>;
        };

        use_cache: {
            if (!fs.existsSync(cacheFilePath)) {
                break use_cache;
            }

            const cache: Cache = JSON.parse(fs.readFileSync(cacheFilePath).toString("utf8"));

            if (Date.now() - cache.time > 3_600_000) {
                fs.unlinkSync(cacheFilePath);
                break use_cache;
            }

            return cache.semVersionedTags;
        }

        const semVersionedTags = await getLatestsSemVersionedTag({
            "count": 50,
            "owner": "keycloak",
            "repo": "keycloak"
        });

        {
            const dirPath = pathDirname(cacheFilePath);

            if (!fs.existsSync(dirPath)) {
                fs.mkdirSync(dirPath, { "recursive": true });
            }
        }

        fs.writeFileSync(
            cacheFilePath,
            JSON.stringify(
                id<Cache>({
                    "time": Date.now(),
                    semVersionedTags
                }),
                null,
                2
            )
        );

        return semVersionedTags;
    })();

    semVersionedTags.forEach(semVersionedTag => {
        if (startingFromMajor !== undefined && semVersionedTag.version.major < startingFromMajor) {
            return;
        }

        const currentSemVersionedTag = semVersionedTagByMajor.get(semVersionedTag.version.major);

        if (currentSemVersionedTag !== undefined && SemVer.compare(semVersionedTag.version, currentSemVersionedTag.version) === -1) {
            return;
        }

        semVersionedTagByMajor.set(semVersionedTag.version.major, semVersionedTag);
    });

    const lastMajorVersions = Array.from(semVersionedTagByMajor.values()).map(({ tag }) => tag);

    const { value } = await cliSelect<string>({
        "values": lastMajorVersions
    }).catch(() => {
        process.exit(-1);
    });

    const keycloakVersion = value.split(" ")[0];

    return { keycloakVersion };
}