keycloakify 10.0.0-rc.4 → 10.0.0-rc.41

package/src/bin/shared/copyKeycloakResourcesToPublic.ts

@@ -0,0 +1,104 @@
+import {
+    downloadKeycloakStaticResources,
+    type BuildContextLike as BuildContextLike_downloadKeycloakStaticResources
+} from "./downloadKeycloakStaticResources";
+import { join as pathJoin, relative as pathRelative } from "path";
+import {
+    themeTypes,
+    keycloak_resources,
+    lastKeycloakVersionWithAccountV1
+} from "../shared/constants";
+import { readThisNpmPackageVersion } from "../tools/readThisNpmPackageVersion";
+import { assert } from "tsafe/assert";
+import * as fs from "fs";
+import { rmSync } from "../tools/fs.rmSync";
+import type { BuildContext } from "./buildContext";
+
+export type BuildContextLike = BuildContextLike_downloadKeycloakStaticResources & {
+    loginThemeResourcesFromKeycloakVersion: string;
+    publicDirPath: string;
+};
+
+assert<BuildContext extends BuildContextLike ? true : false>();
+
+export async function copyKeycloakResourcesToPublic(params: {
+    buildContext: BuildContextLike;
+}) {
+    const { buildContext } = params;
+
+    const destDirPath = pathJoin(buildContext.publicDirPath, keycloak_resources);
+
+    const keycloakifyBuildinfoFilePath = pathJoin(destDirPath, "keycloakify.buildinfo");
+
+    const keycloakifyBuildinfoRaw = JSON.stringify(
+        {
+            destDirPath,
+            keycloakifyVersion: readThisNpmPackageVersion(),
+            buildContext: {
+                loginThemeResourcesFromKeycloakVersion: readThisNpmPackageVersion(),
+                cacheDirPath: pathRelative(destDirPath, buildContext.cacheDirPath),
+                npmWorkspaceRootDirPath: pathRelative(
+                    destDirPath,
+                    buildContext.npmWorkspaceRootDirPath
+                )
+            }
+        },
+        null,
+        2
+    );
+
+    skip_if_already_done: {
+        if (!fs.existsSync(keycloakifyBuildinfoFilePath)) {
+            break skip_if_already_done;
+        }
+
+        const keycloakifyBuildinfoRaw_previousRun = fs
+            .readFileSync(keycloakifyBuildinfoFilePath)
+            .toString("utf8");
+
+        if (keycloakifyBuildinfoRaw_previousRun !== keycloakifyBuildinfoRaw) {
+            break skip_if_already_done;
+        }
+
+        return;
+    }
+
+    rmSync(destDirPath, { force: true, recursive: true });
+
+    fs.mkdirSync(destDirPath, { recursive: true });
+
+    fs.writeFileSync(pathJoin(destDirPath, ".gitignore"), Buffer.from("*", "utf8"));
+
+    for (const themeType of themeTypes) {
+        await downloadKeycloakStaticResources({
+            keycloakVersion: (() => {
+                switch (themeType) {
+                    case "login":
+                        return buildContext.loginThemeResourcesFromKeycloakVersion;
+                    case "account":
+                        return lastKeycloakVersionWithAccountV1;
+                }
+            })(),
+            themeType,
+            themeDirPath: destDirPath,
+            buildContext
+        });
+    }
+
+    fs.writeFileSync(
+        pathJoin(destDirPath, "README.txt"),
+        Buffer.from(
+            // prettier-ignore
+            [
+                "This is just a test folder that helps develop",
+                "the login and register page without having to run a Keycloak container\n",
+                "This directory will be automatically excluded from the final build."
+            ].join(" ")
+        )
+    );
+
+    fs.writeFileSync(
+        keycloakifyBuildinfoFilePath,
+        Buffer.from(keycloakifyBuildinfoRaw, "utf8")
+    );
+}

package/src/bin/shared/downloadKeycloakDefaultTheme.ts

@@ -0,0 +1,207 @@
+import { join as pathJoin, relative as pathRelative } from "path";
+import { type BuildContext } from "./buildContext";
+import { assert } from "tsafe/assert";
+import { lastKeycloakVersionWithAccountV1 } from "./constants";
+import { downloadAndExtractArchive } from "../tools/downloadAndExtractArchive";
+import { isInside } from "../tools/isInside";
+
+export type BuildContextLike = {
+    cacheDirPath: string;
+    npmWorkspaceRootDirPath: string;
+};
+
+assert<BuildContext extends BuildContextLike ? true : false>();
+
+export async function downloadKeycloakDefaultTheme(params: {
+    keycloakVersion: string;
+    buildContext: BuildContextLike;
+}): Promise<{ defaultThemeDirPath: string }> {
+    const { keycloakVersion, buildContext } = params;
+
+    const { extractedDirPath } = await downloadAndExtractArchive({
+        url: `https://repo1.maven.org/maven2/org/keycloak/keycloak-themes/${keycloakVersion}/keycloak-themes-${keycloakVersion}.jar`,
+        cacheDirPath: buildContext.cacheDirPath,
+        npmWorkspaceRootDirPath: buildContext.npmWorkspaceRootDirPath,
+        uniqueIdOfOnOnArchiveFile: "downloadKeycloakDefaultTheme",
+        onArchiveFile: async params => {
+            if (!isInside({ dirPath: "theme", filePath: params.fileRelativePath })) {
+                return;
+            }
+
+            const { readFile, writeFile } = params;
+
+            const fileRelativePath = pathRelative("theme", params.fileRelativePath);
+
+            skip_keycloak_v2: {
+                if (
+                    !isInside({
+                        dirPath: pathJoin("keycloak.v2"),
+                        filePath: fileRelativePath
+                    })
+                ) {
+                    break skip_keycloak_v2;
+                }
+
+                return;
+            }
+
+            last_account_v1_transformations: {
+                if (lastKeycloakVersionWithAccountV1 !== keycloakVersion) {
+                    break last_account_v1_transformations;
+                }
+
+                patch_account_css: {
+                    if (
+                        fileRelativePath !==
+                        pathJoin("keycloak", "account", "resources", "css", "account.css")
+                    ) {
+                        break patch_account_css;
+                    }
+
+                    await writeFile({
+                        fileRelativePath,
+                        modifiedData: Buffer.from(
+                            (await readFile())
+                                .toString("utf8")
+                                .replace("top: -34px;", "top: -34px !important;"),
+                            "utf8"
+                        )
+                    });
+
+                    return;
+                }
+
+                skip_web_modules: {
+                    if (
+                        !isInside({
+                            dirPath: pathJoin(
+                                "keycloak",
+                                "common",
+                                "resources",
+                                "web_modules"
+                            ),
+                            filePath: fileRelativePath
+                        })
+                    ) {
+                        break skip_web_modules;
+                    }
+
+                    return;
+                }
+
+                skip_unused_node_modules: {
+                    const nodeModulesDirPath = pathJoin(
+                        "keycloak",
+                        "common",
+                        "resources",
+                        "node_modules"
+                    );
+
+                    if (
+                        !isInside({
+                            dirPath: nodeModulesDirPath,
+                            filePath: fileRelativePath
+                        })
+                    ) {
+                        break skip_unused_node_modules;
+                    }
+
+                    const toKeepPrefixes = [
+                        ...[
+                            "patternfly.min.css",
+                            "patternfly-additions.min.css",
+                            "patternfly-additions.min.css"
+                        ].map(fileBasename =>
+                            pathJoin(
+                                nodeModulesDirPath,
+                                "patternfly",
+                                "dist",
+                                "css",
+                                fileBasename
+                            )
+                        ),
+                        pathJoin(nodeModulesDirPath, "patternfly", "dist", "fonts")
+                    ];
+
+                    if (
+                        toKeepPrefixes.find(prefix =>
+                            fileRelativePath.startsWith(prefix)
+                        ) !== undefined
+                    ) {
+                        break skip_unused_node_modules;
+                    }
+
+                    return;
+                }
+            }
+
+            skip_unused_resources: {
+                if (keycloakVersion !== "24.0.4") {
+                    break skip_unused_resources;
+                }
+
+                for (const dirBasename of [
+                    "@patternfly-v5",
+                    "@rollup",
+                    "rollup",
+                    "react",
+                    "react-dom",
+                    "shx",
+                    ".pnpm"
+                ]) {
+                    if (
+                        isInside({
+                            dirPath: pathJoin(
+                                "keycloak",
+                                "common",
+                                "resources",
+                                "node_modules",
+                                dirBasename
+                            ),
+                            filePath: fileRelativePath
+                        })
+                    ) {
+                        return;
+                    }
+                }
+
+                for (const dirBasename of ["react", "react-dom"]) {
+                    if (
+                        isInside({
+                            dirPath: pathJoin(
+                                "keycloak",
+                                "common",
+                                "resources",
+                                "vendor",
+                                dirBasename
+                            ),
+                            filePath: fileRelativePath
+                        })
+                    ) {
+                        return;
+                    }
+                }
+
+                if (
+                    isInside({
+                        dirPath: pathJoin(
+                            "keycloak",
+                            "common",
+                            "resources",
+                            "node_modules",
+                            "@patternfly",
+                            "react-core"
+                        ),
+                        filePath: fileRelativePath
+                    })
+                ) {
+                    return;
+                }
+            }
+
+            await writeFile({ fileRelativePath });
+        }
+    });
+
+    return { defaultThemeDirPath: extractedDirPath };
+}

package/src/bin/shared/downloadKeycloakStaticResources.ts

@@ -0,0 +1,53 @@
+import { transformCodebase } from "../tools/transformCodebase";
+import { join as pathJoin } from "path";
+import {
+    downloadKeycloakDefaultTheme,
+    type BuildContextLike as BuildContextLike_downloadKeycloakDefaultTheme
+} from "./downloadKeycloakDefaultTheme";
+import { resources_common, type ThemeType } from "./constants";
+import type { BuildContext } from "./buildContext";
+import { assert } from "tsafe/assert";
+import { existsAsync } from "../tools/fs.existsAsync";
+
+export type BuildContextLike = BuildContextLike_downloadKeycloakDefaultTheme & {};
+
+assert<BuildContext extends BuildContextLike ? true : false>();
+
+export async function downloadKeycloakStaticResources(params: {
+    themeType: ThemeType;
+    themeDirPath: string;
+    keycloakVersion: string;
+    buildContext: BuildContextLike;
+}) {
+    const { themeType, themeDirPath, keycloakVersion, buildContext } = params;
+
+    const { defaultThemeDirPath } = await downloadKeycloakDefaultTheme({
+        keycloakVersion,
+        buildContext
+    });
+
+    const resourcesDirPath = pathJoin(themeDirPath, themeType, "resources");
+
+    repatriate_base_resources: {
+        const srcDirPath = pathJoin(defaultThemeDirPath, "base", themeType, "resources");
+
+        if (!(await existsAsync(srcDirPath))) {
+            break repatriate_base_resources;
+        }
+
+        transformCodebase({
+            srcDirPath,
+            destDirPath: resourcesDirPath
+        });
+    }
+
+    transformCodebase({
+        srcDirPath: pathJoin(defaultThemeDirPath, "keycloak", themeType, "resources"),
+        destDirPath: resourcesDirPath
+    });
+
+    transformCodebase({
+        srcDirPath: pathJoin(defaultThemeDirPath, "keycloak", "common", "resources"),
+        destDirPath: pathJoin(resourcesDirPath, resources_common)
+    });
+}

package/src/bin/shared/generateKcGenTs.ts

@@ -0,0 +1,71 @@
+import { assert } from "tsafe/assert";
+import type { BuildContext } from "./buildContext";
+import { getThemeSrcDirPath } from "./getThemeSrcDirPath";
+import * as fs from "fs/promises";
+import { join as pathJoin } from "path";
+import { existsAsync } from "../tools/fs.existsAsync";
+
+export type BuildContextLike = {
+    projectDirPath: string;
+    themeNames: string[];
+    environmentVariables: { name: string; default: string }[];
+};
+
+assert<BuildContext extends BuildContextLike ? true : false>();
+
+export async function generateKcGenTs(params: {
+    buildContext: BuildContextLike;
+}): Promise<void> {
+    const { buildContext } = params;
+
+    const { themeSrcDirPath } = getThemeSrcDirPath({
+        projectDirPath: buildContext.projectDirPath
+    });
+
+    const filePath = pathJoin(themeSrcDirPath, "kc.gen.ts");
+
+    const currentContent = (await existsAsync(filePath))
+        ? await fs.readFile(filePath)
+        : undefined;
+
+    const newContent = Buffer.from(
+        [
+            `/* prettier-ignore-start */`,
+            ``,
+            `/* eslint-disable */`,
+            ``,
+            `// @ts-nocheck`,
+            ``,
+            `// noinspection JSUnusedGlobalSymbols`,
+            ``,
+            `// This file is auto-generated by Keycloakify`,
+            ``,
+            `export type ThemeName = ${buildContext.themeNames.map(themeName => `"${themeName}"`).join(" | ")};`,
+            ``,
+            `export const themeNames: ThemeName[] = [${buildContext.themeNames.map(themeName => `"${themeName}"`).join(", ")}];`,
+            ``,
+            `export type KcEnvName = ${buildContext.environmentVariables.length === 0 ? "never" : buildContext.environmentVariables.map(({ name }) => `"${name}"`).join(" | ")};`,
+            ``,
+            `export const KcEnvNames: KcEnvName[] = [${buildContext.environmentVariables.map(({ name }) => `"${name}"`).join(", ")}];`,
+            ``,
+            `export const kcEnvDefaults: Record<KcEnvName, string> = ${JSON.stringify(
+                Object.fromEntries(
+                    buildContext.environmentVariables.map(
+                        ({ name, default: defaultValue }) => [name, defaultValue]
+                    )
+                ),
+                null,
+                2
+            )};`,
+            ``,
+            `/* prettier-ignore-end */`
+        ].join("\n"),
+        "utf8"
+    );
+
+    if (currentContent !== undefined && currentContent.equals(newContent)) {
+        return;
+    }
+
+    await fs.writeFile(filePath, newContent);
+}

package/src/bin/shared/getJarFileBasename.ts

@@ -0,0 +1,11 @@
+import type { KeycloakVersionRange } from "./KeycloakVersionRange";
+
+export function getJarFileBasename(params: {
+    keycloakVersionRange: KeycloakVersionRange;
+}) {
+    const { keycloakVersionRange } = params;
+
+    const jarFileBasename = `keycloak-theme-for-kc-${keycloakVersionRange}.jar`;
+
+    return { jarFileBasename };
+}

package/src/bin/{getThemeSrcDirPath.ts → shared/getThemeSrcDirPath.ts}

@@ -1,18 +1,21 @@
 import * as fs from "fs";
 import { exclude } from "tsafe";
-import { crawl } from "./tools/crawl";
+import { crawl } from "../tools/crawl";
 import { join as pathJoin } from "path";
 import { themeTypes } from "./constants";
 
 const themeSrcDirBasenames = ["keycloak-theme", "keycloak_theme"];
 
 /** Can't catch error, if the directory isn't found, this function will just exit the process with an error message. */
-export function getThemeSrcDirPath(params: { reactAppRootDirPath: string }) {
-    const { reactAppRootDirPath } = params;
+export function getThemeSrcDirPath(params: { projectDirPath: string }) {
+    const { projectDirPath } = params;
 
-    const srcDirPath = pathJoin(reactAppRootDirPath, "src");
+    const srcDirPath = pathJoin(projectDirPath, "src");
 
-    const themeSrcDirPath: string | undefined = crawl({ "dirPath": srcDirPath, "returnedPathsType": "relative to dirPath" })
+    const themeSrcDirPath: string | undefined = crawl({
+        dirPath: srcDirPath,
+        returnedPathsType: "relative to dirPath"
+    })
         .map(fileRelativePath => {
             for (const themeSrcDirBasename of themeSrcDirBasenames) {
                 const split = fileRelativePath.split(themeSrcDirBasename);
@@ -32,7 +35,7 @@ export function getThemeSrcDirPath(params: { reactAppRootDirPath: string }) {
         if (!fs.existsSync(pathJoin(srcDirPath, themeType))) {
             continue;
         }
-        return { "themeSrcDirPath": srcDirPath };
+        return { themeSrcDirPath: srcDirPath };
     }
 
     console.error(

package/src/bin/shared/metaInfKeycloakThemes.ts

@@ -0,0 +1,61 @@
+import { join as pathJoin, dirname as pathDirname } from "path";
+import type { ThemeType } from "./constants";
+import * as fs from "fs";
+
+export type MetaInfKeycloakTheme = {
+    themes: { name: string; types: (ThemeType | "email")[] }[];
+};
+
+export function getMetaInfKeycloakThemesJsonFilePath(params: {
+    keycloakifyBuildDirPath: string;
+}) {
+    const { keycloakifyBuildDirPath } = params;
+
+    return pathJoin(
+        keycloakifyBuildDirPath === "." ? "" : keycloakifyBuildDirPath,
+        "src",
+        "main",
+        "resources",
+        "META-INF",
+        "keycloak-themes.json"
+    );
+}
+
+export function readMetaInfKeycloakThemes(params: {
+    keycloakifyBuildDirPath: string;
+}): MetaInfKeycloakTheme {
+    const { keycloakifyBuildDirPath } = params;
+
+    return JSON.parse(
+        fs
+            .readFileSync(
+                getMetaInfKeycloakThemesJsonFilePath({
+                    keycloakifyBuildDirPath
+                })
+            )
+            .toString("utf8")
+    ) as MetaInfKeycloakTheme;
+}
+
+export function writeMetaInfKeycloakThemes(params: {
+    keycloakifyBuildDirPath: string;
+    metaInfKeycloakThemes: MetaInfKeycloakTheme;
+}) {
+    const { keycloakifyBuildDirPath, metaInfKeycloakThemes } = params;
+
+    const metaInfKeycloakThemesJsonPath = getMetaInfKeycloakThemesJsonFilePath({
+        keycloakifyBuildDirPath
+    });
+
+    {
+        const dirPath = pathDirname(metaInfKeycloakThemesJsonPath);
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+
+    fs.writeFileSync(
+        metaInfKeycloakThemesJsonPath,
+        Buffer.from(JSON.stringify(metaInfKeycloakThemes, null, 2), "utf8")
+    );
+}

package/src/bin/shared/promptKeycloakVersion.ts

@@ -0,0 +1,125 @@
+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 };
+}