keycloakify 10.0.0-rc.4 → 10.0.0-rc.41

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

@@ -0,0 +1,320 @@
+import { transformCodebase } from "../../tools/transformCodebase";
+import * as fs from "fs";
+import { join as pathJoin, resolve as pathResolve } from "path";
+import { replaceImportsInJsCode } from "../replacers/replaceImportsInJsCode";
+import { replaceImportsInCssCode } from "../replacers/replaceImportsInCssCode";
+import {
+    generateFtlFilesCodeFactory,
+    type BuildContextLike as BuildContextLike_kcContextExclusionsFtlCode
+} from "../generateFtl";
+import {
+    type ThemeType,
+    lastKeycloakVersionWithAccountV1,
+    keycloak_resources,
+    accountV1ThemeName,
+    basenameOfTheKeycloakifyResourcesDir,
+    loginThemePageIds,
+    accountThemePageIds
+} from "../../shared/constants";
+import { isInside } from "../../tools/isInside";
+import type { BuildContext } from "../../shared/buildContext";
+import { assert, type Equals } from "tsafe/assert";
+import {
+    downloadKeycloakStaticResources,
+    type BuildContextLike as BuildContextLike_downloadKeycloakStaticResources
+} from "../../shared/downloadKeycloakStaticResources";
+import { readFieldNameUsage } from "./readFieldNameUsage";
+import { readExtraPagesNames } from "./readExtraPageNames";
+import { generateMessageProperties } from "./generateMessageProperties";
+import {
+    bringInAccountV1,
+    type BuildContextLike as BuildContextLike_bringInAccountV1
+} from "./bringInAccountV1";
+import { getThemeSrcDirPath } from "../../shared/getThemeSrcDirPath";
+import { rmSync } from "../../tools/fs.rmSync";
+import { readThisNpmPackageVersion } from "../../tools/readThisNpmPackageVersion";
+import {
+    writeMetaInfKeycloakThemes,
+    type MetaInfKeycloakTheme
+} from "../../shared/metaInfKeycloakThemes";
+import { objectEntries } from "tsafe/objectEntries";
+import { escapeStringForPropertiesFile } from "../../tools/escapeStringForPropertiesFile";
+
+export type BuildContextLike = BuildContextLike_kcContextExclusionsFtlCode &
+    BuildContextLike_downloadKeycloakStaticResources &
+    BuildContextLike_bringInAccountV1 & {
+        bundler: "vite" | "webpack";
+        extraThemeProperties: string[] | undefined;
+        loginThemeResourcesFromKeycloakVersion: string;
+        projectBuildDirPath: string;
+        assetsDirPath: string;
+        urlPathname: string | undefined;
+        projectDirPath: string;
+        keycloakifyBuildDirPath: string;
+        environmentVariables: { name: string; default: string }[];
+    };
+
+assert<BuildContext extends BuildContextLike ? true : false>();
+
+export async function generateSrcMainResourcesForMainTheme(params: {
+    themeName: string;
+    buildContext: BuildContextLike;
+}): Promise<void> {
+    const { themeName, buildContext } = params;
+
+    const { themeSrcDirPath } = getThemeSrcDirPath({
+        projectDirPath: buildContext.projectDirPath
+    });
+
+    const getThemeTypeDirPath = (params: { themeType: ThemeType | "email" }) => {
+        const { themeType } = params;
+        return pathJoin(
+            buildContext.keycloakifyBuildDirPath,
+            "src",
+            "main",
+            "resources",
+            "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 prevent 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: buildContext.projectBuildDirPath,
+                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(
+                                buildContext.projectBuildDirPath,
+                                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"),
+                            buildContext
+                        });
+
+                        return {
+                            modifiedSourceCode: Buffer.from(fixedJsCode, "utf8")
+                        };
+                    }
+
+                    return { modifiedSourceCode: sourceCode };
+                }
+            });
+        }
+
+        const { generateFtlFilesCode } = generateFtlFilesCodeFactory({
+            themeName,
+            indexHtmlCode: fs
+                .readFileSync(pathJoin(buildContext.projectBuildDirPath, "index.html"))
+                .toString("utf8"),
+            cssGlobalsToDefine,
+            buildContext,
+            keycloakifyVersion: readThisNpmPackageVersion(),
+            themeType,
+            fieldNames: readFieldNameUsage({
+                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 buildContext.loginThemeResourcesFromKeycloakVersion;
+                }
+            })(),
+            themeDirPath: pathResolve(pathJoin(themeTypeDirPath, "..")),
+            themeType,
+            buildContext
+        });
+
+        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);
+                    })()}`,
+                    ...(buildContext.extraThemeProperties ?? []),
+                    buildContext.environmentVariables.map(
+                        ({ name, default: defaultValue }) =>
+                            `${name}=\${env.${name}:${escapeStringForPropertiesFile(defaultValue)}}`
+                    )
+                ].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" })
+        });
+    }
+
+    if (implementedThemeTypes.account) {
+        await bringInAccountV1({
+            buildContext
+        });
+    }
+
+    {
+        const metaInfKeycloakThemes: MetaInfKeycloakTheme = { themes: [] };
+
+        metaInfKeycloakThemes.themes.push({
+            name: themeName,
+            types: objectEntries(implementedThemeTypes)
+                .filter(([, isImplemented]) => isImplemented)
+                .map(([themeType]) => themeType)
+        });
+
+        if (implementedThemeTypes.account) {
+            metaInfKeycloakThemes.themes.push({
+                name: accountV1ThemeName,
+                types: ["account"]
+            });
+        }
+
+        writeMetaInfKeycloakThemes({
+            keycloakifyBuildDirPath: buildContext.keycloakifyBuildDirPath,
+            metaInfKeycloakThemes
+        });
+    }
+}

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

@@ -0,0 +1,80 @@
+import { join as pathJoin, extname as pathExtname, sep as pathSep } from "path";
+import { transformCodebase } from "../../tools/transformCodebase";
+import type { BuildContext } from "../../shared/buildContext";
+import {
+    readMetaInfKeycloakThemes,
+    writeMetaInfKeycloakThemes
+} from "../../shared/metaInfKeycloakThemes";
+import { assert } from "tsafe/assert";
+
+export type BuildContextLike = {
+    keycloakifyBuildDirPath: string;
+};
+
+assert<BuildContext extends BuildContextLike ? true : false>();
+
+export function generateSrcMainResourcesForThemeVariant(params: {
+    themeName: string;
+    themeVariantName: string;
+    buildContext: BuildContextLike;
+}) {
+    const { themeName, themeVariantName, buildContext } = params;
+
+    const mainThemeDirPath = pathJoin(
+        buildContext.keycloakifyBuildDirPath,
+        "src",
+        "main",
+        "resources",
+        "theme",
+        themeName
+    );
+
+    transformCodebase({
+        srcDirPath: mainThemeDirPath,
+        destDirPath: pathJoin(mainThemeDirPath, "..", themeVariantName),
+        transformSourceCode: ({ fileRelativePath, sourceCode }) => {
+            if (
+                pathExtname(fileRelativePath) === ".ftl" &&
+                fileRelativePath.split(pathSep).length === 2
+            ) {
+                const modifiedSourceCode = Buffer.from(
+                    Buffer.from(sourceCode)
+                        .toString("utf-8")
+                        .replace(
+                            `out["themeName"] = "${themeName}";`,
+                            `out["themeName"] = "${themeVariantName}";`
+                        ),
+                    "utf8"
+                );
+
+                assert(Buffer.compare(modifiedSourceCode, sourceCode) !== 0);
+
+                return { modifiedSourceCode };
+            }
+
+            return { modifiedSourceCode: sourceCode };
+        }
+    });
+
+    {
+        const updatedMetaInfKeycloakThemes = readMetaInfKeycloakThemes({
+            keycloakifyBuildDirPath: buildContext.keycloakifyBuildDirPath
+        });
+
+        updatedMetaInfKeycloakThemes.themes.push({
+            name: themeVariantName,
+            types: (() => {
+                const theme = updatedMetaInfKeycloakThemes.themes.find(
+                    ({ name }) => name === themeName
+                );
+                assert(theme !== undefined);
+                return theme.types;
+            })()
+        });
+
+        writeMetaInfKeycloakThemes({
+            keycloakifyBuildDirPath: buildContext.keycloakifyBuildDirPath,
+            metaInfKeycloakThemes: updatedMetaInfKeycloakThemes
+        });
+    }
+}

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

@@ -0,0 +1 @@
+export * from "./generateSrcMainResources";

package/src/bin/keycloakify/{generateTheme → generateSrcMainResources}/readExtraPageNames.ts

@@ -1,20 +1,28 @@
 import { crawl } from "../../tools/crawl";
-import { accountThemePageIds, loginThemePageIds } from "../generateFtl";
 import { id } from "tsafe/id";
 import { removeDuplicates } from "evt/tools/reducers/removeDuplicates";
 import * as fs from "fs";
 import { join as pathJoin } from "path";
-import type { ThemeType } from "../../constants";
-
-export function readExtraPagesNames(params: { themeSrcDirPath: string; themeType: ThemeType }): string[] {
+import {
+    type ThemeType,
+    accountThemePageIds,
+    loginThemePageIds
+} from "../../shared/constants";
+
+export function readExtraPagesNames(params: {
+    themeSrcDirPath: string;
+    themeType: ThemeType;
+}): string[] {
     const { themeSrcDirPath, themeType } = params;
 
     const filePaths = crawl({
-        "dirPath": pathJoin(themeSrcDirPath, themeType),
-        "returnedPathsType": "absolute"
+        dirPath: pathJoin(themeSrcDirPath, themeType),
+        returnedPathsType: "absolute"
     }).filter(filePath => /\.(ts|tsx|js|jsx)$/.test(filePath));
 
-    const candidateFilePaths = filePaths.filter(filePath => /kcContext\.[^.]+$/.test(filePath));
+    const candidateFilePaths = filePaths.filter(filePath =>
+        /[kK]cContext\.[^.]+$/.test(filePath)
+    );
 
     if (candidateFilePaths.length === 0) {
         candidateFilePaths.push(...filePaths);
@@ -25,7 +33,12 @@ export function readExtraPagesNames(params: { themeSrcDirPath: string; themeType
     for (const candidateFilPath of candidateFilePaths) {
         const rawSourceFile = fs.readFileSync(candidateFilPath).toString("utf8");
 
-        extraPages.push(...Array.from(rawSourceFile.matchAll(/["']?pageId["']?\s*:\s*["']([^.]+.ftl)["']/g), m => m[1]));
+        extraPages.push(
+            ...Array.from(
+                rawSourceFile.matchAll(/["']?pageId["']?\s*:\s*["']([^.]+.ftl)["']/g),
+                m => m[1]
+            )
+        );
     }
 
     return extraPages.reduce(...removeDuplicates<string>()).filter(pageId => {

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

@@ -0,0 +1,83 @@
+import { crawl } from "../../tools/crawl";
+import { join as pathJoin } from "path";
+import * as fs from "fs";
+import type { ThemeType } from "../../shared/constants";
+import { getThisCodebaseRootDirPath } from "../../tools/getThisCodebaseRootDirPath";
+
+/** Assumes the theme type exists */
+export function readFieldNameUsage(params: {
+    themeSrcDirPath: string;
+    themeType: ThemeType;
+}): string[] {
+    const { themeSrcDirPath, themeType } = params;
+
+    const fieldNames = new Set<string>();
+
+    for (const srcDirPath of [
+        pathJoin(getThisCodebaseRootDirPath(), "src", themeType),
+        pathJoin(themeSrcDirPath, themeType)
+    ]) {
+        const filePaths = crawl({
+            dirPath: srcDirPath,
+            returnedPathsType: "absolute"
+        }).filter(filePath => /\.(ts|tsx|js|jsx)$/.test(filePath));
+
+        for (const filePath of filePaths) {
+            const rawSourceFile = fs.readFileSync(filePath).toString("utf8");
+
+            if (!rawSourceFile.includes("messagesPerField")) {
+                continue;
+            }
+
+            for (const functionName of [
+                "printIfExists",
+                "existsError",
+                "get",
+                "exists",
+                "getFirstError"
+            ] as const) {
+                if (!rawSourceFile.includes(functionName)) {
+                    continue;
+                }
+
+                try {
+                    rawSourceFile
+                        .split(functionName)
+                        .filter(part => part.startsWith("("))
+                        .map(part => {
+                            let [p1] = part.split(")");
+
+                            p1 = p1.slice(1);
+
+                            return p1;
+                        })
+                        .map(part => {
+                            return part
+                                .split(",")
+                                .map(a => a.trim())
+                                .filter((...[, i]) =>
+                                    functionName !== "printIfExists" ? true : i === 0
+                                )
+                                .filter(
+                                    a =>
+                                        a.startsWith('"') ||
+                                        a.startsWith("'") ||
+                                        a.startsWith("`")
+                                )
+                                .filter(
+                                    a =>
+                                        a.endsWith('"') ||
+                                        a.endsWith("'") ||
+                                        a.endsWith("`")
+                                )
+                                .map(a => a.slice(1).slice(0, -1));
+                        })
+                        .flat()
+                        .forEach(fieldName => fieldNames.add(fieldName));
+                } catch {}
+            }
+        }
+    }
+
+    return Array.from(fieldNames);
+}

package/src/bin/keycloakify/generateStartKeycloakTestingContainer.ts

@@ -1,15 +1,19 @@
 import * as fs from "fs";
-import { join as pathJoin, relative as pathRelative, basename as pathBasename } from "path";
+import {
+    join as pathJoin,
+    relative as pathRelative,
+    basename as pathBasename
+} from "path";
 import { assert } from "tsafe/assert";
-import type { BuildOptions } from "./buildOptions";
-import { accountV1ThemeName } from "../constants";
+import type { BuildContext } from "../shared/buildContext";
+import { accountV1ThemeName } from "../shared/constants";
 
-export type BuildOptionsLike = {
+export type BuildContextLike = {
     keycloakifyBuildDirPath: string;
     themeNames: string[];
 };
 
-assert<BuildOptions extends BuildOptionsLike ? true : false>();
+assert<BuildContext extends BuildContextLike ? true : false>();
 
 generateStartKeycloakTestingContainer.basename = "start_keycloak_testing_container.sh";
 
@@ -20,21 +24,24 @@ const keycloakVersion = "24.0.4";
 export function generateStartKeycloakTestingContainer(params: {
     jarFilePath: string;
     doesImplementAccountTheme: boolean;
-    buildOptions: BuildOptionsLike;
+    buildContext: BuildContextLike;
 }) {
-    const { jarFilePath, doesImplementAccountTheme, buildOptions } = params;
+    const { jarFilePath, doesImplementAccountTheme, buildContext } = params;
 
     const themeRelativeDirPath = pathJoin("src", "main", "resources", "theme");
 
     fs.writeFileSync(
-        pathJoin(buildOptions.keycloakifyBuildDirPath, generateStartKeycloakTestingContainer.basename),
+        pathJoin(
+            buildContext.keycloakifyBuildDirPath,
+            generateStartKeycloakTestingContainer.basename
+        ),
         Buffer.from(
             [
                 "#!/usr/bin/env bash",
                 "",
                 `docker rm ${containerName} || true`,
                 "",
-                `cd "${buildOptions.keycloakifyBuildDirPath}"`,
+                `cd "${buildContext.keycloakifyBuildDirPath}"`,
                 "",
                 "docker run \\",
                 "   -p 8080:8080 \\",
@@ -43,11 +50,18 @@ export function generateStartKeycloakTestingContainer(params: {
                 "   -e KEYCLOAK_ADMIN_PASSWORD=admin \\",
                 `   -v "${pathJoin(
                     "$(pwd)",
-                    pathRelative(buildOptions.keycloakifyBuildDirPath, jarFilePath)
+                    pathRelative(buildContext.keycloakifyBuildDirPath, jarFilePath)
                 )}":"/opt/keycloak/providers/${pathBasename(jarFilePath)}" \\`,
-                [...(doesImplementAccountTheme ? [accountV1ThemeName] : []), ...buildOptions.themeNames].map(
+                [
+                    ...(doesImplementAccountTheme ? [accountV1ThemeName] : []),
+                    ...buildContext.themeNames
+                ].map(
                     themeName =>
-                        `   -v "${pathJoin("$(pwd)", themeRelativeDirPath, themeName).replace(/\\/g, "/")}":"/opt/keycloak/themes/${themeName}":rw \\`
+                        `   -v "${pathJoin(
+                            "$(pwd)",
+                            themeRelativeDirPath,
+                            themeName
+                        ).replace(/\\/g, "/")}":"/opt/keycloak/themes/${themeName}":rw \\`
                 ),
                 `   -it quay.io/keycloak/keycloak:${keycloakVersion} \\`,
                 `   start-dev`,
@@ -55,6 +69,6 @@ export function generateStartKeycloakTestingContainer(params: {
             ].join("\n"),
             "utf8"
         ),
-        { "mode": 0o755 }
+        { mode: 0o755 }
     );
 }

package/src/bin/keycloakify/index.ts

@@ -1,8 +1 @@
-#!/usr/bin/env node
-
 export * from "./keycloakify";
-import { main } from "./keycloakify";
-
-if (require.main === module) {
-    main();
-}