keycloakify 10.0.0-rc.3 → 10.0.0-rc.5

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 };
+}

package/src/bin/start-keycloak-container.ts

@@ -0,0 +1,141 @@
+import { readBuildOptions } from "./shared/buildOptions";
+import type { CliCommandOptions } from "./main";
+import { promptKeycloakVersion } from "./shared/promptKeycloakVersion";
+import { readMetaInfKeycloakThemes } from "./shared/metaInfKeycloakThemes";
+import { accountV1ThemeName } from "./shared/constants";
+import { SemVer } from "./tools/SemVer";
+import type { KeycloakVersionRange } from "./shared/KeycloakVersionRange";
+import { getJarFileBasename } from "./shared/getJarFileBasename";
+import { assert, type Equals } from "tsafe/assert";
+import * as fs from "fs";
+import { join as pathJoin, posix as pathPosix } from "path";
+import * as child_process from "child_process";
+
+export async function command(params: { cliCommandOptions: CliCommandOptions }) {
+    const { cliCommandOptions } = params;
+
+    const buildOptions = readBuildOptions({ cliCommandOptions });
+
+    const metaInfKeycloakThemes = readMetaInfKeycloakThemes({
+        "keycloakifyBuildDirPath": buildOptions.keycloakifyBuildDirPath
+    });
+
+    const doesImplementAccountTheme = metaInfKeycloakThemes.themes.some(({ name }) => name === accountV1ThemeName);
+
+    const { keycloakVersion, keycloakMajorNumber } = await (async function getKeycloakMajor(): Promise<{
+        keycloakVersion: string;
+        keycloakMajorNumber: number;
+    }> {
+        const { keycloakVersion } = await promptKeycloakVersion({
+            "startingFromMajor": 17
+        });
+
+        const keycloakMajorNumber = SemVer.parse(keycloakVersion).major;
+
+        if (doesImplementAccountTheme && keycloakMajorNumber === 22) {
+            console.log([
+                "Unfortunately, Keycloakify themes that implements an account theme do not work on Keycloak 22",
+                "Please select any other Keycloak version"
+            ]);
+            return getKeycloakMajor();
+        }
+
+        return { keycloakVersion, keycloakMajorNumber };
+    })();
+
+    const keycloakVersionRange: KeycloakVersionRange = (() => {
+        if (doesImplementAccountTheme) {
+            const keycloakVersionRange = (() => {
+                if (keycloakMajorNumber <= 21) {
+                    return "21-and-below" as const;
+                }
+
+                assert(keycloakMajorNumber !== 22);
+
+                if (keycloakMajorNumber === 23) {
+                    return "23" as const;
+                }
+
+                return "24-and-above" as const;
+            })();
+
+            assert<Equals<typeof keycloakVersionRange, KeycloakVersionRange.WithAccountTheme>>();
+
+            return keycloakVersionRange;
+        } else {
+            const keycloakVersionRange = (() => {
+                if (keycloakMajorNumber <= 21) {
+                    return "21-and-below" as const;
+                }
+
+                return "22-and-above" as const;
+            })();
+
+            assert<Equals<typeof keycloakVersionRange, KeycloakVersionRange.WithoutAccountTheme>>();
+
+            return keycloakVersionRange;
+        }
+    })();
+
+    const { jarFileBasename } = getJarFileBasename({ keycloakVersionRange });
+
+    const mountTargets = buildOptions.themeNames
+        .map(themeName => {
+            const themeEntry = metaInfKeycloakThemes.themes.find(({ name }) => name === themeName);
+
+            assert(themeEntry !== undefined);
+
+            return themeEntry.types
+                .map(themeType => {
+                    const localPathDirname = pathJoin(
+                        buildOptions.keycloakifyBuildDirPath,
+                        "src",
+                        "main",
+                        "resources",
+                        "theme",
+                        themeName,
+                        themeType
+                    );
+
+                    return fs
+                        .readdirSync(localPathDirname)
+                        .filter(fileOrDirectoryBasename => !fileOrDirectoryBasename.endsWith(".properties"))
+                        .map(fileOrDirectoryBasename => ({
+                            "localPath": pathJoin(localPathDirname, fileOrDirectoryBasename),
+                            "containerPath": pathPosix.join("/", "opt", "keycloak", "themes", themeName, themeType, fileOrDirectoryBasename)
+                        }));
+                })
+                .flat();
+        })
+        .flat();
+
+    const containerName = "keycloak-keycloakify";
+
+    try {
+        child_process.execSync(`docker rm ${containerName}`, { "stdio": "ignore" });
+    } catch {}
+
+    const child = child_process.spawn(
+        "docker",
+        [
+            "run",
+            ...["-p", "8080:8080"],
+            ...["--name", containerName],
+            ...["-e", "KEYCLOAK_ADMIN=admin"],
+            ...["-e", "KEYCLOAK_ADMIN_PASSWORD=admin"],
+            ...["-v", `"${pathJoin(buildOptions.keycloakifyBuildDirPath, jarFileBasename)}":"/opt/keycloak/providers/keycloak-theme.jar"`],
+            ...(keycloakMajorNumber <= 20 ? ["-e", "JAVA_OPTS=-Dkeycloak.profile=preview"] : []),
+            ...mountTargets.map(({ localPath, containerPath }) => ["-v", `"${localPath}":"${containerPath}":rw`]).flat(),
+            ...["-it", `quay.io/keycloak/keycloak:${keycloakVersion}`],
+            "start-dev",
+            ...(21 <= keycloakMajorNumber && keycloakMajorNumber < 24 ? ["--features=declarative-user-profile"] : [])
+        ],
+        {
+            "cwd": buildOptions.keycloakifyBuildDirPath
+        }
+    );
+
+    child.stdout.on("data", data => console.log(data.toString("utf8")));
+
+    child.stderr.on("data", data => console.error(data.toString("utf8")));
+}

package/src/bin/tools/fs.rmSync.ts

@@ -20,13 +20,13 @@ export function rmSync(dirPath: string, options: { recursive: true; force?: true
 
     const removeDir_rec = (dirPath: string) =>
         fs.readdirSync(dirPath).forEach(basename => {
-            const fileOrDirpath = pathJoin(dirPath, basename);
+            const fileOrDirPath = pathJoin(dirPath, basename);
 
-            if (fs.lstatSync(fileOrDirpath).isDirectory()) {
-                removeDir_rec(fileOrDirpath);
+            if (fs.lstatSync(fileOrDirPath).isDirectory()) {
+                removeDir_rec(fileOrDirPath);
                 return;
             } else {
-                fs.unlinkSync(fileOrDirpath);
+                fs.unlinkSync(fileOrDirPath);
             }
         });
 

package/src/bin/{keycloakify/buildOptions → tools}/getNpmWorkspaceRootDirPath.ts

@@ -2,31 +2,14 @@ import * as child_process from "child_process";
 import { join as pathJoin, resolve as pathResolve, sep as pathSep } from "path";
 import { assert } from "tsafe/assert";
 
-let cache:
-    | {
-          reactAppRootDirPath: string;
-          npmWorkspaceRootDirPath: string;
-      }
-    | undefined = undefined;
-
 export function getNpmWorkspaceRootDirPath(params: { reactAppRootDirPath: string }) {
     const { reactAppRootDirPath } = params;
 
-    use_cache: {
-        if (cache === undefined || cache.reactAppRootDirPath !== reactAppRootDirPath) {
-            break use_cache;
-        }
-
-        const { npmWorkspaceRootDirPath } = cache;
-
-        return { npmWorkspaceRootDirPath };
-    }
-
     const npmWorkspaceRootDirPath = (function callee(depth: number): string {
         const cwd = pathResolve(pathJoin(...[reactAppRootDirPath, ...Array(depth).fill("..")]));
 
         try {
-            child_process.execSync("npm config get", { cwd, "stdio": ["pipe", "pipe", "pipe"] });
+            child_process.execSync("npm config get", { cwd, "stdio": "ignore" });
         } catch (error) {
             if (String(error).includes("ENOWORKSPACES")) {
                 assert(cwd !== pathSep, "NPM workspace not found");
@@ -40,10 +23,5 @@ export function getNpmWorkspaceRootDirPath(params: { reactAppRootDirPath: string
         return cwd;
     })(0);
 
-    cache = {
-        reactAppRootDirPath,
-        npmWorkspaceRootDirPath
-    };
-
     return { npmWorkspaceRootDirPath };
 }

package/src/login/UserProfileFormFields.tsx

@@ -201,18 +201,15 @@ function FieldErrors(props: {
         <span
             id={`input-error-${attribute.name}${fieldIndex === undefined ? "" : `-${fieldIndex}`}`}
             className={getClassName("kcInputErrorMessageClass")}
-            style={{
-                "position": displayableErrors.length === 1 ? "absolute" : undefined
-            }}
             aria-live="polite"
         >
             {displayableErrors
                 .filter(error => error.fieldIndex === fieldIndex)
                 .map(({ errorMessage }, i, arr) => (
-                    <>
+                    <Fragment key={i}>
                         <span key={i}>{errorMessage}</span>
                         {arr.length - 1 !== i && <br />}
-                    </>
+                    </Fragment>
                 ))}
         </span>
     );