keycloakify 9.6.6 → 10.0.0-rc.0

package/src/bin/keycloakify/generateFtl/generateFtl.ts

@@ -4,7 +4,6 @@ import { generateCssCodeToDefineGlobals } from "../replacers/replaceImportsInCss
 import { replaceImportsInInlineCssCode } from "../replacers/replaceImportsInInlineCssCode";
 import * as fs from "fs";
 import { join as pathJoin } from "path";
-import { objectKeys } from "tsafe/objectKeys";
 import type { BuildOptions } from "../buildOptions";
 import { assert } from "tsafe/assert";
 import { type ThemeType, nameOfTheGlobal, basenameOfTheKeycloakifyResourcesDir, resources_common } from "../../constants";
@@ -96,35 +95,20 @@ export function generateFtlFilesCodeFactory(params: {
     }
 
     //FTL is no valid html, we can't insert with cheerio, we put placeholder for injecting later.
-    const replaceValueBySearchValue = {
-        '{ "x": "vIdLqMeOed9sdLdIdOxdK0d" }': fs
-            .readFileSync(pathJoin(__dirname, "ftl_object_to_js_code_declaring_an_object.ftl"))
-            .toString("utf8")
-            .match(/^<script>const _=((?:.|\n)+)<\/script>[\n]?$/)![1]
-            .replace("FIELD_NAMES_eKsIY4ZsZ4xeM", fieldNames.map(name => `"${name}"`).join(", "))
-            .replace("KEYCLOAKIFY_VERSION_xEdKd3xEdr", keycloakifyVersion)
-            .replace("KEYCLOAKIFY_THEME_VERSION_sIgKd3xEdr3dx", buildOptions.themeVersion)
-            .replace("KEYCLOAKIFY_THEME_TYPE_dExKd3xEdr", themeType)
-            .replace("KEYCLOAKIFY_THEME_NAME_cXxKd3xEer", themeName)
-            .replace("RESOURCES_COMMON_cLsLsMrtDkpVv", resources_common),
-        "<!-- xIdLqMeOedErIdLsPdNdI9dSlxI -->": [
-            "<#if scripts??>",
-            "    <#list scripts as script>",
-            '        <script src="${script}" type="text/javascript"></script>',
-            "    </#list>",
-            "</#if>"
-        ].join("\n")
-    };
-
-    $("head").prepend(
-        [
-            "<script>",
-            `    window.${nameOfTheGlobal}= ${objectKeys(replaceValueBySearchValue)[0]};`,
-            "</script>",
-            "",
-            objectKeys(replaceValueBySearchValue)[1]
-        ].join("\n")
-    );
+    const ftlObjectToJsCodeDeclaringAnObject = fs
+        .readFileSync(pathJoin(__dirname, "ftl_object_to_js_code_declaring_an_object.ftl"))
+        .toString("utf8")
+        .match(/^<script>const _=((?:.|\n)+)<\/script>[\n]?$/)![1]
+        .replace("FIELD_NAMES_eKsIY4ZsZ4xeM", fieldNames.map(name => `"${name}"`).join(", "))
+        .replace("KEYCLOAKIFY_VERSION_xEdKd3xEdr", keycloakifyVersion)
+        .replace("KEYCLOAKIFY_THEME_VERSION_sIgKd3xEdr3dx", buildOptions.themeVersion)
+        .replace("KEYCLOAKIFY_THEME_TYPE_dExKd3xEdr", themeType)
+        .replace("KEYCLOAKIFY_THEME_NAME_cXxKd3xEer", themeName)
+        .replace("RESOURCES_COMMON_cLsLsMrtDkpVv", resources_common);
+
+    const ftlObjectToJsCodeDeclaringAnObjectPlaceholder = '{ "x": "vIdLqMeOed9sdLdIdOxdK0d" }';
+
+    $("head").prepend(["<script>", `    window.${nameOfTheGlobal}= ${ftlObjectToJsCodeDeclaringAnObjectPlaceholder};`, "</script>"].join("\n"));
 
     // Remove part of the document marked as ignored.
     {
@@ -159,7 +143,7 @@ export function generateFtlFilesCodeFactory(params: {
         let ftlCode = $.html();
 
         Object.entries({
-            ...replaceValueBySearchValue,
+            [ftlObjectToJsCodeDeclaringAnObjectPlaceholder]: ftlObjectToJsCodeDeclaringAnObject,
             "PAGE_ID_xIgLsPgGId9D8e": pageId
         }).map(([searchValue, replaceValue]) => (ftlCode = ftlCode.replace(searchValue, replaceValue)));
 

package/src/bin/keycloakify/generateFtl/pageId.ts

@@ -3,8 +3,8 @@ export const loginThemePageIds = [
     "login-username.ftl",
     "login-password.ftl",
     "webauthn-authenticate.ftl",
+    "webauthn-register.ftl",
     "register.ftl",
-    "register-user-profile.ftl",
     "info.ftl",
     "error.ftl",
     "login-reset-password.ftl",
@@ -20,11 +20,19 @@ export const loginThemePageIds = [
     "login-page-expired.ftl",
     "login-config-totp.ftl",
     "logout-confirm.ftl",
-    "update-user-profile.ftl",
     "idp-review-user-profile.ftl",
     "update-email.ftl",
     "select-authenticator.ftl",
-    "saml-post-form.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"] as const;

package/src/bin/keycloakify/generateStartKeycloakTestingContainer.ts

@@ -1,26 +1,22 @@
 import * as fs from "fs";
 import { join as pathJoin, relative as pathRelative, basename as pathBasename } from "path";
 import { assert } from "tsafe/assert";
-import { Reflect } from "tsafe/Reflect";
 import type { BuildOptions } from "./buildOptions";
 
 export type BuildOptionsLike = {
     keycloakifyBuildDirPath: string;
 };
 
-{
-    const buildOptions = Reflect<BuildOptions>();
-
-    assert<typeof buildOptions extends BuildOptionsLike ? true : false>();
-}
+assert<BuildOptions extends BuildOptionsLike ? true : false>();
 
 generateStartKeycloakTestingContainer.basename = "start_keycloak_testing_container.sh";
 
 const containerName = "keycloak-testing-container";
+const keycloakVersion = "24.0.4";
 
 /** Files for being able to run a hot reload keycloak container */
-export function generateStartKeycloakTestingContainer(params: { jarFilePath: string; keycloakVersion: string; buildOptions: BuildOptionsLike }) {
-    const { jarFilePath, keycloakVersion, buildOptions } = params;
+export function generateStartKeycloakTestingContainer(params: { jarFilePath: string; buildOptions: BuildOptionsLike }) {
+    const { jarFilePath, buildOptions } = params;
 
     const themeRelativeDirPath = pathJoin("src", "main", "resources", "theme");
     const themeDirPath = pathJoin(buildOptions.keycloakifyBuildDirPath, themeRelativeDirPath);

package/src/bin/keycloakify/generateTheme/bringInAccountV1.ts

@@ -1,7 +1,6 @@
 import * as fs from "fs";
 import { join as pathJoin } from "path";
 import { assert } from "tsafe/assert";
-import { Reflect } from "tsafe/Reflect";
 import type { BuildOptions } from "../buildOptions";
 import { resources_common, lastKeycloakVersionWithAccountV1, accountV1ThemeName } from "../../constants";
 import { downloadBuiltinKeycloakTheme } from "../../download-builtin-keycloak-theme";
@@ -9,21 +8,16 @@ import { transformCodebase } from "../../tools/transformCodebase";
 import { rmSync } from "../../tools/fs.rmSync";
 
 type BuildOptionsLike = {
-    keycloakifyBuildDirPath: string;
     cacheDirPath: string;
     npmWorkspaceRootDirPath: string;
 };
 
-{
-    const buildOptions = Reflect<BuildOptions>();
+assert<BuildOptions extends BuildOptionsLike ? true : false>();
 
-    assert<typeof buildOptions extends BuildOptionsLike ? true : false>();
-}
-
-export async function bringInAccountV1(params: { buildOptions: BuildOptionsLike }) {
-    const { buildOptions } = params;
+export async function bringInAccountV1(params: { buildOptions: BuildOptionsLike; srcMainResourcesDirPath: string }) {
+    const { buildOptions, srcMainResourcesDirPath } = params;
 
-    const builtinKeycloakThemeTmpDirPath = pathJoin(buildOptions.keycloakifyBuildDirPath, "..", "tmp_yxdE2_builtin_keycloak_theme");
+    const builtinKeycloakThemeTmpDirPath = pathJoin(srcMainResourcesDirPath, "..", "tmp_yxdE2_builtin_keycloak_theme");
 
     await downloadBuiltinKeycloakTheme({
         "destDirPath": builtinKeycloakThemeTmpDirPath,
@@ -31,7 +25,7 @@ export async function bringInAccountV1(params: { buildOptions: BuildOptionsLike
         buildOptions
     });
 
-    const accountV1DirPath = pathJoin(buildOptions.keycloakifyBuildDirPath, "src", "main", "resources", "theme", accountV1ThemeName, "account");
+    const accountV1DirPath = pathJoin(srcMainResourcesDirPath, "theme", accountV1ThemeName, "account");
 
     transformCodebase({
         "srcDirPath": pathJoin(builtinKeycloakThemeTmpDirPath, "base", "account"),

package/src/bin/keycloakify/generateTheme/generateSrcMainResources.ts

@@ -0,0 +1,267 @@
+import { transformCodebase } from "../../tools/transformCodebase";
+import * as fs from "fs";
+import { join as pathJoin, resolve as pathResolve, dirname as pathDirname } from "path";
+import { replaceImportsInJsCode } from "../replacers/replaceImportsInJsCode";
+import { replaceImportsInCssCode } from "../replacers/replaceImportsInCssCode";
+import { generateFtlFilesCodeFactory, loginThemePageIds, accountThemePageIds } from "../generateFtl";
+import {
+    type ThemeType,
+    lastKeycloakVersionWithAccountV1,
+    keycloak_resources,
+    accountV1ThemeName,
+    basenameOfTheKeycloakifyResourcesDir
+} from "../../constants";
+import { isInside } from "../../tools/isInside";
+import type { BuildOptions } from "../buildOptions";
+import { assert, type Equals } from "tsafe/assert";
+import { downloadKeycloakStaticResources } from "./downloadKeycloakStaticResources";
+import { readFieldNameUsage } from "./readFieldNameUsage";
+import { readExtraPagesNames } from "./readExtraPageNames";
+import { generateMessageProperties } from "./generateMessageProperties";
+import { bringInAccountV1 } from "./bringInAccountV1";
+import { rmSync } from "../../tools/fs.rmSync";
+
+export type BuildOptionsLike = {
+    bundler: "vite" | "webpack";
+    extraThemeProperties: string[] | undefined;
+    themeVersion: string;
+    loginThemeResourcesFromKeycloakVersion: string;
+    reactAppBuildDirPath: string;
+    cacheDirPath: string;
+    assetsDirPath: string;
+    urlPathname: string | undefined;
+    npmWorkspaceRootDirPath: string;
+};
+
+assert<BuildOptions extends BuildOptionsLike ? true : false>();
+
+export async function generateSrcMainResources(params: {
+    themeName: string;
+    themeSrcDirPath: string;
+    keycloakifySrcDirPath: string;
+    buildOptions: BuildOptionsLike;
+    keycloakifyVersion: string;
+    srcMainResourcesDirPath: string;
+}): Promise<{ doesImplementAccountTheme: boolean }> {
+    const { themeName, themeSrcDirPath, keycloakifySrcDirPath, buildOptions, keycloakifyVersion, srcMainResourcesDirPath } = params;
+
+    const getThemeTypeDirPath = (params: { themeType: ThemeType | "email" }) => {
+        const { themeType } = params;
+        return pathJoin(srcMainResourcesDirPath, "theme", themeName, themeType);
+    };
+
+    const cssGlobalsToDefine: Record<string, string> = {};
+
+    const implementedThemeTypes: Record<ThemeType | "email", boolean> = {
+        "login": false,
+        "account": false,
+        "email": false
+    };
+
+    for (const themeType of ["login", "account"] as const) {
+        if (!fs.existsSync(pathJoin(themeSrcDirPath, themeType))) {
+            continue;
+        }
+
+        implementedThemeTypes[themeType] = true;
+
+        const themeTypeDirPath = getThemeTypeDirPath({ themeType });
+
+        apply_replacers_and_move_to_theme_resources: {
+            const destDirPath = pathJoin(themeTypeDirPath, "resources", basenameOfTheKeycloakifyResourcesDir);
+
+            // NOTE: Prevent accumulation of files in the assets dir, as names are hashed they pile up.
+            rmSync(destDirPath, { "recursive": true, "force": true });
+
+            if (themeType === "account" && implementedThemeTypes.login) {
+                // NOTE: We prevend doing it twice, it has been done for the login theme.
+
+                transformCodebase({
+                    "srcDirPath": pathJoin(
+                        getThemeTypeDirPath({
+                            "themeType": "login"
+                        }),
+                        "resources",
+                        basenameOfTheKeycloakifyResourcesDir
+                    ),
+                    destDirPath
+                });
+
+                break apply_replacers_and_move_to_theme_resources;
+            }
+
+            transformCodebase({
+                "srcDirPath": buildOptions.reactAppBuildDirPath,
+                destDirPath,
+                "transformSourceCode": ({ filePath, sourceCode }) => {
+                    //NOTE: Prevent cycles, excludes the folder we generated for debug in public/
+                    // This should not happen if users follow the new instruction setup but we keep it for retrocompatibility.
+                    if (
+                        isInside({
+                            "dirPath": pathJoin(buildOptions.reactAppBuildDirPath, keycloak_resources),
+                            filePath
+                        })
+                    ) {
+                        return undefined;
+                    }
+
+                    if (/\.css?$/i.test(filePath)) {
+                        const { cssGlobalsToDefine: cssGlobalsToDefineForThisFile, fixedCssCode } = replaceImportsInCssCode({
+                            "cssCode": sourceCode.toString("utf8")
+                        });
+
+                        Object.entries(cssGlobalsToDefineForThisFile).forEach(([key, value]) => {
+                            cssGlobalsToDefine[key] = value;
+                        });
+
+                        return { "modifiedSourceCode": Buffer.from(fixedCssCode, "utf8") };
+                    }
+
+                    if (/\.js?$/i.test(filePath)) {
+                        const { fixedJsCode } = replaceImportsInJsCode({
+                            "jsCode": sourceCode.toString("utf8"),
+                            buildOptions
+                        });
+
+                        return { "modifiedSourceCode": Buffer.from(fixedJsCode, "utf8") };
+                    }
+
+                    return { "modifiedSourceCode": sourceCode };
+                }
+            });
+        }
+
+        const { generateFtlFilesCode } = generateFtlFilesCodeFactory({
+            themeName,
+            "indexHtmlCode": fs.readFileSync(pathJoin(buildOptions.reactAppBuildDirPath, "index.html")).toString("utf8"),
+            cssGlobalsToDefine,
+            buildOptions,
+            keycloakifyVersion,
+            themeType,
+            "fieldNames": readFieldNameUsage({
+                keycloakifySrcDirPath,
+                themeSrcDirPath,
+                themeType
+            })
+        });
+
+        [
+            ...(() => {
+                switch (themeType) {
+                    case "login":
+                        return loginThemePageIds;
+                    case "account":
+                        return accountThemePageIds;
+                }
+            })(),
+            ...readExtraPagesNames({
+                themeType,
+                themeSrcDirPath
+            })
+        ].forEach(pageId => {
+            const { ftlCode } = generateFtlFilesCode({ pageId });
+
+            fs.mkdirSync(themeTypeDirPath, { "recursive": true });
+
+            fs.writeFileSync(pathJoin(themeTypeDirPath, pageId), Buffer.from(ftlCode, "utf8"));
+        });
+
+        generateMessageProperties({
+            themeSrcDirPath,
+            themeType
+        }).forEach(({ languageTag, propertiesFileSource }) => {
+            const messagesDirPath = pathJoin(themeTypeDirPath, "messages");
+
+            fs.mkdirSync(pathJoin(themeTypeDirPath, "messages"), { "recursive": true });
+
+            const propertiesFilePath = pathJoin(messagesDirPath, `messages_${languageTag}.properties`);
+
+            fs.writeFileSync(propertiesFilePath, Buffer.from(propertiesFileSource, "utf8"));
+        });
+
+        await downloadKeycloakStaticResources({
+            "keycloakVersion": (() => {
+                switch (themeType) {
+                    case "account":
+                        return lastKeycloakVersionWithAccountV1;
+                    case "login":
+                        return buildOptions.loginThemeResourcesFromKeycloakVersion;
+                }
+            })(),
+            "themeDirPath": pathResolve(pathJoin(themeTypeDirPath, "..")),
+            themeType,
+            buildOptions
+        });
+
+        fs.writeFileSync(
+            pathJoin(themeTypeDirPath, "theme.properties"),
+            Buffer.from(
+                [
+                    `parent=${(() => {
+                        switch (themeType) {
+                            case "account":
+                                return accountV1ThemeName;
+                            case "login":
+                                return "keycloak";
+                        }
+                        assert<Equals<typeof themeType, never>>(false);
+                    })()}`,
+                    ...(buildOptions.extraThemeProperties ?? [])
+                ].join("\n\n"),
+                "utf8"
+            )
+        );
+    }
+
+    email: {
+        const emailThemeSrcDirPath = pathJoin(themeSrcDirPath, "email");
+
+        if (!fs.existsSync(emailThemeSrcDirPath)) {
+            break email;
+        }
+
+        implementedThemeTypes.email = true;
+
+        transformCodebase({
+            "srcDirPath": emailThemeSrcDirPath,
+            "destDirPath": getThemeTypeDirPath({ "themeType": "email" })
+        });
+    }
+
+    const parsedKeycloakThemeJson: { themes: { name: string; types: string[] }[] } = { "themes": [] };
+
+    parsedKeycloakThemeJson.themes.push({
+        "name": themeName,
+        "types": Object.entries(implementedThemeTypes)
+            .filter(([, isImplemented]) => isImplemented)
+            .map(([themeType]) => themeType)
+    });
+
+    account_specific_extra_work: {
+        if (!implementedThemeTypes.account) {
+            break account_specific_extra_work;
+        }
+
+        await bringInAccountV1({
+            srcMainResourcesDirPath,
+            buildOptions
+        });
+
+        parsedKeycloakThemeJson.themes.push({
+            "name": accountV1ThemeName,
+            "types": ["account"]
+        });
+    }
+
+    {
+        const keycloakThemeJsonFilePath = pathJoin(srcMainResourcesDirPath, "META-INF", "keycloak-themes.json");
+
+        try {
+            fs.mkdirSync(pathDirname(keycloakThemeJsonFilePath));
+        } catch {}
+
+        fs.writeFileSync(keycloakThemeJsonFilePath, Buffer.from(JSON.stringify(parsedKeycloakThemeJson, null, 2), "utf8"));
+    }
+
+    return { "doesImplementAccountTheme": implementedThemeTypes.account };
+}