keycloakify 10.0.0-rc.4 → 10.0.0-rc.6

package/src/bin/shared/copyKeycloakResourcesToPublic.ts

@@ -0,0 +1,87 @@
+import {
+    downloadKeycloakStaticResources,
+    type BuildOptionsLike as BuildOptionsLike_downloadKeycloakStaticResources
+} from "./downloadKeycloakStaticResources";
+import { join as pathJoin, relative as pathRelative } from "path";
+import { themeTypes, keycloak_resources, lastKeycloakVersionWithAccountV1 } from "../shared/constants";
+import { readThisNpmProjectVersion } from "../tools/readThisNpmProjectVersion";
+import { assert } from "tsafe/assert";
+import * as fs from "fs";
+import { rmSync } from "../tools/fs.rmSync";
+import type { BuildOptions } from "./buildOptions";
+
+export type BuildOptionsLike = BuildOptionsLike_downloadKeycloakStaticResources & {
+    loginThemeResourcesFromKeycloakVersion: string;
+    publicDirPath: string;
+};
+
+assert<BuildOptions extends BuildOptionsLike ? true : false>();
+
+export async function copyKeycloakResourcesToPublic(params: { buildOptions: BuildOptionsLike }) {
+    const { buildOptions } = params;
+
+    const destDirPath = pathJoin(buildOptions.publicDirPath, keycloak_resources);
+
+    const keycloakifyBuildinfoFilePath = pathJoin(destDirPath, "keycloakify.buildinfo");
+
+    const keycloakifyBuildinfoRaw = JSON.stringify(
+        {
+            destDirPath,
+            "keycloakifyVersion": readThisNpmProjectVersion(),
+            "buildOptions": {
+                "loginThemeResourcesFromKeycloakVersion": readThisNpmProjectVersion(),
+                "cacheDirPath": pathRelative(destDirPath, buildOptions.cacheDirPath),
+                "npmWorkspaceRootDirPath": pathRelative(destDirPath, buildOptions.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 });
+
+    for (const themeType of themeTypes) {
+        await downloadKeycloakStaticResources({
+            "keycloakVersion": (() => {
+                switch (themeType) {
+                    case "login":
+                        return buildOptions.loginThemeResourcesFromKeycloakVersion;
+                    case "account":
+                        return lastKeycloakVersionWithAccountV1;
+                }
+            })(),
+            themeType,
+            "themeDirPath": destDirPath,
+            buildOptions
+        });
+    }
+
+    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"
+            ].join(" ")
+        )
+    );
+
+    fs.writeFileSync(pathJoin(buildOptions.publicDirPath, keycloak_resources, ".gitignore"), Buffer.from("*", "utf8"));
+
+    fs.writeFileSync(keycloakifyBuildinfoFilePath, Buffer.from(keycloakifyBuildinfoRaw, "utf8"));
+}

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

@@ -3,13 +3,13 @@ import { mkdir, writeFile, unlink } from "fs/promises";
 import fetch from "make-fetch-happen";
 import { dirname as pathDirname, join as pathJoin, basename as pathBasename } from "path";
 import { assert } from "tsafe/assert";
-import { transformCodebase } from "./tools/transformCodebase";
-import { unzip, zip } from "./tools/unzip";
-import { rm } from "./tools/fs.rm";
+import { transformCodebase } from "../tools/transformCodebase";
+import { unzip, zip } from "../tools/unzip";
+import { rm } from "../tools/fs.rm";
 import * as child_process from "child_process";
-import { existsAsync } from "./tools/fs.existsAsync";
-import type { BuildOptions } from "./keycloakify/buildOptions";
-import { getProxyFetchOptions } from "./tools/fetchProxyOptions";
+import { existsAsync } from "../tools/fs.existsAsync";
+import type { BuildOptions } from "./buildOptions";
+import { getProxyFetchOptions } from "../tools/fetchProxyOptions";
 
 export type BuildOptionsLike = {
     cacheDirPath: string;

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/{keycloakify/generateFtl/pageId.ts → shared/pageIds.ts}

@@ -35,7 +35,15 @@ export const loginThemePageIds = [
     "webauthn-error.ftl"
 ] as const;
 
-export const accountThemePageIds = ["password.ftl", "account.ftl", "sessions.ftl", "totp.ftl", "applications.ftl", "log.ftl"] as const;
+export const accountThemePageIds = [
+    "password.ftl",
+    "account.ftl",
+    "sessions.ftl",
+    "totp.ftl",
+    "applications.ftl",
+    "log.ftl",
+    "federatedIdentity.ftl"
+] as const;
 
 export type LoginThemePageId = (typeof loginThemePageIds)[number];
 export type AccountThemePageId = (typeof accountThemePageIds)[number];

package/src/bin/shared/promptKeycloakVersion.ts

@@ -0,0 +1,69 @@
+import { getLatestsSemVersionedTagFactory } from "../tools/octokit-addons/getLatestsSemVersionedTag";
+import { Octokit } from "@octokit/rest";
+import cliSelect from "cli-select";
+import { lastKeycloakVersionWithAccountV1 } from "./constants";
+import { SemVer } from "../tools/SemVer";
+
+export async function promptKeycloakVersion(params: { startingFromMajor: number | undefined }) {
+    const { startingFromMajor } = 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 };
+    })();
+
+    console.log("Select Keycloak version");
+
+    const semVersionedTagByMajor = new Map<number, { tag: string; version: SemVer }>();
+
+    (
+        await getLatestsSemVersionedTag({
+            "count": 50,
+            "owner": "keycloak",
+            "repo": "keycloak"
+        })
+    ).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: version }) => {
+        let out = version;
+
+        if (version === lastKeycloakVersionWithAccountV1) {
+            out += " (last version with account v1 built in)";
+        }
+
+        return out;
+    });
+
+    const { value } = await cliSelect<string>({
+        "values": lastMajorVersions
+    }).catch(() => {
+        console.log("Aborting");
+
+        process.exit(-1);
+    });
+
+    const keycloakVersion = value.split(" ")[0];
+
+    return { keycloakVersion };
+}