keycloakify 10.0.0-rc.1 → 10.0.0-rc.12

package/src/bin/shared/downloadBuiltinKeycloakTheme.ts

@@ -0,0 +1,264 @@
+import { join as pathJoin } from "path";
+import { downloadAndUnzip } from "./downloadAndUnzip";
+import { type BuildOptions } from "./buildOptions";
+import { assert } from "tsafe/assert";
+import * as child_process from "child_process";
+import * as fs from "fs";
+import { rmSync } from "../tools/fs.rmSync";
+import { lastKeycloakVersionWithAccountV1 } from "../shared/constants";
+import { transformCodebase } from "../tools/transformCodebase";
+
+export type BuildOptionsLike = {
+    cacheDirPath: string;
+    npmWorkspaceRootDirPath: string;
+};
+
+assert<BuildOptions extends BuildOptionsLike ? true : false>();
+
+export async function downloadBuiltinKeycloakTheme(params: { keycloakVersion: string; destDirPath: string; buildOptions: BuildOptionsLike }) {
+    const { keycloakVersion, destDirPath, buildOptions } = params;
+
+    await downloadAndUnzip({
+        destDirPath,
+        "url": `https://github.com/keycloak/keycloak/archive/refs/tags/${keycloakVersion}.zip`,
+        "specificDirsToExtract": ["", "-community"].map(ext => `keycloak-${keycloakVersion}/themes/src/main/resources${ext}/theme`),
+        buildOptions,
+        "preCacheTransform": {
+            "actionCacheId": "npm install and build",
+            "action": async ({ destDirPath }) => {
+                install_common_node_modules: {
+                    const commonResourcesDirPath = pathJoin(destDirPath, "keycloak", "common", "resources");
+
+                    if (!fs.existsSync(commonResourcesDirPath)) {
+                        break install_common_node_modules;
+                    }
+
+                    if (!fs.existsSync(pathJoin(commonResourcesDirPath, "package.json"))) {
+                        break install_common_node_modules;
+                    }
+
+                    if (fs.existsSync(pathJoin(commonResourcesDirPath, "node_modules"))) {
+                        break install_common_node_modules;
+                    }
+
+                    child_process.execSync("npm install --omit=dev", {
+                        "cwd": commonResourcesDirPath,
+                        "stdio": "ignore"
+                    });
+                }
+
+                repatriate_common_resources_from_base_login_theme: {
+                    const baseLoginThemeResourceDir = pathJoin(destDirPath, "base", "login", "resources");
+
+                    if (!fs.existsSync(baseLoginThemeResourceDir)) {
+                        break repatriate_common_resources_from_base_login_theme;
+                    }
+
+                    transformCodebase({
+                        "srcDirPath": baseLoginThemeResourceDir,
+                        "destDirPath": pathJoin(destDirPath, "keycloak", "login", "resources")
+                    });
+                }
+
+                install_and_move_to_common_resources_generated_in_keycloak_v2: {
+                    if (!fs.readFileSync(pathJoin(destDirPath, "keycloak", "login", "theme.properties")).toString("utf8").includes("web_modules")) {
+                        break install_and_move_to_common_resources_generated_in_keycloak_v2;
+                    }
+
+                    const accountV2DirSrcDirPath = pathJoin(destDirPath, "keycloak.v2", "account", "src");
+
+                    if (!fs.existsSync(accountV2DirSrcDirPath)) {
+                        break install_and_move_to_common_resources_generated_in_keycloak_v2;
+                    }
+
+                    const packageManager = fs.existsSync(pathJoin(accountV2DirSrcDirPath, "pnpm-lock.yaml")) ? "pnpm" : "npm";
+
+                    if (packageManager === "pnpm") {
+                        try {
+                            child_process.execSync(`which pnpm`);
+                        } catch {
+                            console.log(`Installing pnpm globally`);
+                            child_process.execSync(`npm install -g pnpm`);
+                        }
+                    }
+
+                    child_process.execSync(`${packageManager} install`, { "cwd": accountV2DirSrcDirPath, "stdio": "ignore" });
+
+                    const packageJsonFilePath = pathJoin(accountV2DirSrcDirPath, "package.json");
+
+                    const packageJsonRaw = fs.readFileSync(packageJsonFilePath);
+
+                    const parsedPackageJson = JSON.parse(packageJsonRaw.toString("utf8"));
+
+                    parsedPackageJson.scripts.build = parsedPackageJson.scripts.build
+                        .replace(`${packageManager} run check-types`, "true")
+                        .replace(`${packageManager} run babel`, "true");
+
+                    fs.writeFileSync(packageJsonFilePath, Buffer.from(JSON.stringify(parsedPackageJson, null, 2), "utf8"));
+
+                    child_process.execSync(`${packageManager} run build`, { "cwd": accountV2DirSrcDirPath, "stdio": "ignore" });
+
+                    fs.writeFileSync(packageJsonFilePath, packageJsonRaw);
+
+                    fs.rmSync(pathJoin(accountV2DirSrcDirPath, "node_modules"), { "recursive": true });
+                }
+
+                remove_keycloak_v2: {
+                    const keycloakV2DirPath = pathJoin(destDirPath, "keycloak.v2");
+
+                    if (!fs.existsSync(keycloakV2DirPath)) {
+                        break remove_keycloak_v2;
+                    }
+
+                    rmSync(keycloakV2DirPath, { "recursive": true });
+                }
+
+                // Note, this is an optimization for reducing the size of the jar
+                remove_unused_node_modules: {
+                    const nodeModuleDirPath = pathJoin(destDirPath, "keycloak", "common", "resources", "node_modules");
+
+                    if (!fs.existsSync(nodeModuleDirPath)) {
+                        break remove_unused_node_modules;
+                    }
+
+                    const toDeletePerfixes = [
+                        "angular",
+                        "bootstrap",
+                        "rcue",
+                        "font-awesome",
+                        "ng-file-upload",
+                        pathJoin("patternfly", "dist", "sass"),
+                        pathJoin("patternfly", "dist", "less"),
+                        pathJoin("patternfly", "dist", "js"),
+                        "d3",
+                        pathJoin("jquery", "src"),
+                        "c3",
+                        "core-js",
+                        "eonasdan-bootstrap-datetimepicker",
+                        "moment",
+                        "react",
+                        "patternfly-bootstrap-treeview",
+                        "popper.js",
+                        "tippy.js",
+                        "jquery-match-height",
+                        "google-code-prettify",
+                        "patternfly-bootstrap-combobox",
+                        "focus-trap",
+                        "tabbable",
+                        "scheduler",
+                        "@types",
+                        "datatables.net",
+                        "datatables.net-colreorder",
+                        "tslib",
+                        "prop-types",
+                        "file-selector",
+                        "datatables.net-colreorder-bs",
+                        "object-assign",
+                        "warning",
+                        "js-tokens",
+                        "loose-envify",
+                        "prop-types-extra",
+                        "attr-accept",
+                        "datatables.net-select",
+                        "drmonty-datatables-colvis",
+                        "datatables.net-bs",
+                        pathJoin("@patternfly", "react"),
+                        pathJoin("@patternfly", "patternfly", "docs")
+                    ];
+
+                    transformCodebase({
+                        "srcDirPath": nodeModuleDirPath,
+                        "destDirPath": nodeModuleDirPath,
+                        "transformSourceCode": ({ sourceCode, fileRelativePath }) => {
+                            if (fileRelativePath.endsWith(".map")) {
+                                return undefined;
+                            }
+
+                            if (toDeletePerfixes.find(prefix => fileRelativePath.startsWith(prefix)) !== undefined) {
+                                return undefined;
+                            }
+
+                            if (fileRelativePath.startsWith(pathJoin("patternfly", "dist", "fonts"))) {
+                                if (
+                                    !fileRelativePath.endsWith(".woff2") &&
+                                    !fileRelativePath.endsWith(".woff") &&
+                                    !fileRelativePath.endsWith(".ttf")
+                                ) {
+                                    return undefined;
+                                }
+                            }
+
+                            return { "modifiedSourceCode": sourceCode };
+                        }
+                    });
+                }
+
+                // Just like node_modules
+                remove_unused_lib: {
+                    const libDirPath = pathJoin(destDirPath, "keycloak", "common", "resources", "lib");
+
+                    if (!fs.existsSync(libDirPath)) {
+                        break remove_unused_lib;
+                    }
+
+                    const toDeletePerfixes = ["ui-ace", "filesaver", "fileupload", "angular", "ui-ace"];
+
+                    transformCodebase({
+                        "srcDirPath": libDirPath,
+                        "destDirPath": libDirPath,
+                        "transformSourceCode": ({ sourceCode, fileRelativePath }) => {
+                            if (fileRelativePath.endsWith(".map")) {
+                                return undefined;
+                            }
+
+                            if (toDeletePerfixes.find(prefix => fileRelativePath.startsWith(prefix)) !== undefined) {
+                                return undefined;
+                            }
+
+                            return { "modifiedSourceCode": sourceCode };
+                        }
+                    });
+                }
+
+                last_account_v1_transformations: {
+                    if (lastKeycloakVersionWithAccountV1 !== keycloakVersion) {
+                        break last_account_v1_transformations;
+                    }
+
+                    {
+                        const accountCssFilePath = pathJoin(destDirPath, "keycloak", "account", "resources", "css", "account.css");
+
+                        fs.writeFileSync(
+                            accountCssFilePath,
+                            Buffer.from(fs.readFileSync(accountCssFilePath).toString("utf8").replace("top: -34px;", "top: -34px !important;"), "utf8")
+                        );
+                    }
+
+                    // Note, this is an optimization for reducing the size of the jar,
+                    // For this version we know exactly which resources are used.
+                    {
+                        const nodeModulesDirPath = pathJoin(destDirPath, "keycloak", "common", "resources", "node_modules");
+
+                        const toKeepPrefixes = [
+                            ...["patternfly.min.css", "patternfly-additions.min.css", "patternfly-additions.min.css"].map(fileBasename =>
+                                pathJoin("patternfly", "dist", "css", fileBasename)
+                            ),
+                            pathJoin("patternfly", "dist", "fonts")
+                        ];
+
+                        transformCodebase({
+                            "srcDirPath": nodeModulesDirPath,
+                            "destDirPath": nodeModulesDirPath,
+                            "transformSourceCode": ({ sourceCode, fileRelativePath }) => {
+                                if (toKeepPrefixes.find(prefix => fileRelativePath.startsWith(prefix)) === undefined) {
+                                    return undefined;
+                                }
+                                return { "modifiedSourceCode": sourceCode };
+                            }
+                        });
+                    }
+                }
+            }
+        }
+    });
+}

package/src/bin/{keycloakify/generateTheme → shared}/downloadKeycloakStaticResources.ts

@@ -1,11 +1,11 @@
-import { transformCodebase } from "../../tools/transformCodebase";
+import { transformCodebase } from "../tools/transformCodebase";
 import { join as pathJoin } from "path";
-import { downloadBuiltinKeycloakTheme } from "../../download-builtin-keycloak-theme";
-import { resources_common, type ThemeType } from "../../constants";
-import { BuildOptions } from "../buildOptions";
+import { downloadBuiltinKeycloakTheme } from "./downloadBuiltinKeycloakTheme";
+import { resources_common, type ThemeType } from "./constants";
+import type { BuildOptions } from "./buildOptions";
 import { assert } from "tsafe/assert";
 import * as crypto from "crypto";
-import { rmSync } from "../../tools/fs.rmSync";
+import { rmSync } from "../tools/fs.rmSync";
 
 export type BuildOptionsLike = {
     cacheDirPath: string;
@@ -23,8 +23,8 @@ export async function downloadKeycloakStaticResources(params: {
     const { themeType, themeDirPath, keycloakVersion, buildOptions } = params;
 
     const tmpDirPath = pathJoin(
-        themeDirPath,
-        `tmp_suLeKsxId_${crypto.createHash("sha256").update(`${themeType}-${keycloakVersion}`).digest("hex").slice(0, 8)}`
+        buildOptions.cacheDirPath,
+        `downloadKeycloakStaticResources_tmp_${crypto.createHash("sha256").update(`${themeType}-${keycloakVersion}`).digest("hex").slice(0, 8)}`
     );
 
     await downloadBuiltinKeycloakTheme({
@@ -45,5 +45,5 @@ export async function downloadKeycloakStaticResources(params: {
         "destDirPath": pathJoin(resourcesPath, resources_common)
     });
 
-    rmSync(tmpDirPath, { "recursive": true, "force": true });
+    rmSync(tmpDirPath, { "recursive": true });
 }

package/src/bin/shared/getJarFileBasename.ts

@@ -0,0 +1,9 @@
+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,6 +1,6 @@
 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";
 

package/src/bin/shared/metaInfKeycloakThemes.ts

@@ -0,0 +1,34 @@
+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 getMetaInfKeycloakThemesJsonPath(params: { keycloakifyBuildDirPath: string }) {
+    const { keycloakifyBuildDirPath } = params;
+
+    return pathJoin(keycloakifyBuildDirPath, "src", "main", "resources", "META-INF", "keycloak-themes.json");
+}
+
+export function readMetaInfKeycloakThemes(params: { keycloakifyBuildDirPath: string }): MetaInfKeycloakTheme {
+    const { keycloakifyBuildDirPath } = params;
+
+    return JSON.parse(fs.readFileSync(getMetaInfKeycloakThemesJsonPath({ keycloakifyBuildDirPath })).toString("utf8")) as MetaInfKeycloakTheme;
+}
+
+export function writeMetaInfKeycloakThemes(params: { keycloakifyBuildDirPath: string; metaInfKeycloakThemes: MetaInfKeycloakTheme }) {
+    const { keycloakifyBuildDirPath, metaInfKeycloakThemes } = params;
+
+    const metaInfKeycloakThemesJsonPath = getMetaInfKeycloakThemesJsonPath({ 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,106 @@
+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 };
+}