keycloakify 10.0.0-rc.6 → 10.0.0-rc.60

package/src/bin/shared/constants.ts

@@ -1,4 +1,6 @@
 export const nameOfTheGlobal = "kcContext";
+export const nameOfTheLocalizationRealmOverridesUserProfileProperty =
+    "__localizationRealmOverridesUserProfile";
 export const keycloak_resources = "keycloak-resources";
 export const resources_common = "resources-common";
 export const lastKeycloakVersionWithAccountV1 = "21.1.2";
@@ -10,6 +12,60 @@ export const accountV1ThemeName = "account-v1";
 export type ThemeType = (typeof themeTypes)[number];
 
 export const vitePluginSubScriptEnvNames = {
-    "runPostBuildScript": "KEYCLOAKIFY_RUN_POST_BUILD_SCRIPT",
-    "resolveViteConfig": "KEYCLOAKIFY_RESOLVE_VITE_CONFIG"
+    runPostBuildScript: "KEYCLOAKIFY_RUN_POST_BUILD_SCRIPT",
+    resolveViteConfig: "KEYCLOAKIFY_RESOLVE_VITE_CONFIG"
 } as const;
+
+export const onlyBuildJarFileBasenameEnvName = "KEYCLOAKIFY_ONLY_BUILD_JAR_FILE_BASENAME";
+
+export const loginThemePageIds = [
+    "login.ftl",
+    "login-username.ftl",
+    "login-password.ftl",
+    "webauthn-authenticate.ftl",
+    "webauthn-register.ftl",
+    "register.ftl",
+    "info.ftl",
+    "error.ftl",
+    "login-reset-password.ftl",
+    "login-verify-email.ftl",
+    "terms.ftl",
+    "login-oauth2-device-verify-user-code.ftl",
+    "login-oauth-grant.ftl",
+    "login-otp.ftl",
+    "login-update-profile.ftl",
+    "login-update-password.ftl",
+    "login-idp-link-confirm.ftl",
+    "login-idp-link-email.ftl",
+    "login-page-expired.ftl",
+    "login-config-totp.ftl",
+    "logout-confirm.ftl",
+    "idp-review-user-profile.ftl",
+    "update-email.ftl",
+    "select-authenticator.ftl",
+    "saml-post-form.ftl",
+    "delete-credential.ftl",
+    "code.ftl",
+    "delete-account-confirm.ftl",
+    "frontchannel-logout.ftl",
+    "login-recovery-authn-code-config.ftl",
+    "login-recovery-authn-code-input.ftl",
+    "login-reset-otp.ftl",
+    "login-x509-info.ftl",
+    "webauthn-error.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];
+
+export const containerName = "keycloak-keycloakify";

package/src/bin/shared/copyKeycloakResourcesToPublic.ts

@@ -1,37 +1,46 @@
 import {
     downloadKeycloakStaticResources,
-    type BuildOptionsLike as BuildOptionsLike_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 { readThisNpmProjectVersion } from "../tools/readThisNpmProjectVersion";
+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 { BuildOptions } from "./buildOptions";
+import type { BuildContext } from "./buildContext";
 
-export type BuildOptionsLike = BuildOptionsLike_downloadKeycloakStaticResources & {
+export type BuildContextLike = BuildContextLike_downloadKeycloakStaticResources & {
     loginThemeResourcesFromKeycloakVersion: string;
     publicDirPath: string;
 };
 
-assert<BuildOptions extends BuildOptionsLike ? true : false>();
+assert<BuildContext extends BuildContextLike ? true : false>();
 
-export async function copyKeycloakResourcesToPublic(params: { buildOptions: BuildOptionsLike }) {
-    const { buildOptions } = params;
+export async function copyKeycloakResourcesToPublic(params: {
+    buildContext: BuildContextLike;
+}) {
+    const { buildContext } = params;
 
-    const destDirPath = pathJoin(buildOptions.publicDirPath, keycloak_resources);
+    const destDirPath = pathJoin(buildContext.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)
+            keycloakifyVersion: readThisNpmPackageVersion(),
+            buildContext: {
+                loginThemeResourcesFromKeycloakVersion: readThisNpmPackageVersion(),
+                cacheDirPath: pathRelative(destDirPath, buildContext.cacheDirPath),
+                npmWorkspaceRootDirPath: pathRelative(
+                    destDirPath,
+                    buildContext.npmWorkspaceRootDirPath
+                )
             }
         },
         null,
@@ -43,7 +52,9 @@ export async function copyKeycloakResourcesToPublic(params: { buildOptions: Buil
             break skip_if_already_done;
         }
 
-        const keycloakifyBuildinfoRaw_previousRun = fs.readFileSync(keycloakifyBuildinfoFilePath).toString("utf8");
+        const keycloakifyBuildinfoRaw_previousRun = fs
+            .readFileSync(keycloakifyBuildinfoFilePath)
+            .toString("utf8");
 
         if (keycloakifyBuildinfoRaw_previousRun !== keycloakifyBuildinfoRaw) {
             break skip_if_already_done;
@@ -52,21 +63,25 @@ export async function copyKeycloakResourcesToPublic(params: { buildOptions: Buil
         return;
     }
 
-    rmSync(destDirPath, { "force": true, "recursive": true });
+    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": (() => {
+            keycloakVersion: (() => {
                 switch (themeType) {
                     case "login":
-                        return buildOptions.loginThemeResourcesFromKeycloakVersion;
+                        return buildContext.loginThemeResourcesFromKeycloakVersion;
                     case "account":
                         return lastKeycloakVersionWithAccountV1;
                 }
             })(),
             themeType,
-            "themeDirPath": destDirPath,
-            buildOptions
+            themeDirPath: destDirPath,
+            buildContext
         });
     }
 
@@ -76,12 +91,14 @@ export async function copyKeycloakResourcesToPublic(params: { buildOptions: Buil
             // prettier-ignore
             [
                 "This is just a test folder that helps develop",
-                "the login and register page without having to run a Keycloak container"
+                "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(pathJoin(buildOptions.publicDirPath, keycloak_resources, ".gitignore"), Buffer.from("*", "utf8"));
-
-    fs.writeFileSync(keycloakifyBuildinfoFilePath, Buffer.from(keycloakifyBuildinfoRaw, "utf8"));
+    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

@@ -1,49 +1,53 @@
 import { transformCodebase } from "../tools/transformCodebase";
 import { join as pathJoin } from "path";
-import { downloadBuiltinKeycloakTheme } from "./downloadBuiltinKeycloakTheme";
+import {
+    downloadKeycloakDefaultTheme,
+    type BuildContextLike as BuildContextLike_downloadKeycloakDefaultTheme
+} from "./downloadKeycloakDefaultTheme";
 import { resources_common, type ThemeType } from "./constants";
-import type { BuildOptions } from "./buildOptions";
+import type { BuildContext } from "./buildContext";
 import { assert } from "tsafe/assert";
-import * as crypto from "crypto";
-import { rmSync } from "../tools/fs.rmSync";
+import { existsAsync } from "../tools/fs.existsAsync";
 
-export type BuildOptionsLike = {
-    cacheDirPath: string;
-    npmWorkspaceRootDirPath: string;
-};
+export type BuildContextLike = BuildContextLike_downloadKeycloakDefaultTheme & {};
 
-assert<BuildOptions extends BuildOptionsLike ? true : false>();
+assert<BuildContext extends BuildContextLike ? true : false>();
 
 export async function downloadKeycloakStaticResources(params: {
     themeType: ThemeType;
     themeDirPath: string;
     keycloakVersion: string;
-    buildOptions: BuildOptionsLike;
+    buildContext: BuildContextLike;
 }) {
-    const { themeType, themeDirPath, keycloakVersion, buildOptions } = params;
+    const { themeType, themeDirPath, keycloakVersion, buildContext } = params;
 
-    const tmpDirPath = pathJoin(
-        buildOptions.cacheDirPath,
-        `downloadKeycloakStaticResources_tmp_${crypto.createHash("sha256").update(`${themeType}-${keycloakVersion}`).digest("hex").slice(0, 8)}`
-    );
-
-    await downloadBuiltinKeycloakTheme({
+    const { defaultThemeDirPath } = await downloadKeycloakDefaultTheme({
         keycloakVersion,
-        "destDirPath": tmpDirPath,
-        buildOptions
+        buildContext
     });
 
-    const resourcesPath = pathJoin(themeDirPath, themeType, "resources");
+    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(tmpDirPath, "keycloak", themeType, "resources"),
-        "destDirPath": resourcesPath
+        srcDirPath: pathJoin(defaultThemeDirPath, "keycloak", themeType, "resources"),
+        destDirPath: resourcesDirPath
     });
 
     transformCodebase({
-        "srcDirPath": pathJoin(tmpDirPath, "keycloak", "common", "resources"),
-        "destDirPath": pathJoin(resourcesPath, resources_common)
+        srcDirPath: pathJoin(defaultThemeDirPath, "keycloak", "common", "resources"),
+        destDirPath: pathJoin(resourcesDirPath, resources_common)
     });
-
-    rmSync(tmpDirPath, { "recursive": true });
 }

package/src/bin/shared/generateKcGenTs.ts

@@ -0,0 +1,72 @@
+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

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

package/src/bin/shared/getThemeSrcDirPath.ts

@@ -7,12 +7,15 @@ 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(