keycloakify 10.0.0-rc.14 → 10.0.0-rc.140

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

@@ -0,0 +1,89 @@
+import * as fs from "fs";
+import { join as pathJoin } from "path";
+import { assert } from "tsafe/assert";
+import type { BuildContext } from "../../shared/buildContext";
+import {
+    RESOURCES_COMMON,
+    LAST_KEYCLOAK_VERSION_WITH_ACCOUNT_V1,
+    ACCOUNT_V1_THEME_NAME
+} from "../../shared/constants";
+import {
+    downloadKeycloakDefaultTheme,
+    BuildContextLike as BuildContextLike_downloadKeycloakDefaultTheme
+} from "../../shared/downloadKeycloakDefaultTheme";
+import { transformCodebase } from "../../tools/transformCodebase";
+
+export type BuildContextLike = BuildContextLike_downloadKeycloakDefaultTheme;
+
+assert<BuildContext extends BuildContextLike ? true : false>();
+
+export async function bringInAccountV1(params: {
+    resourcesDirPath: string;
+    buildContext: BuildContextLike;
+}) {
+    const { resourcesDirPath, buildContext } = params;
+
+    const { defaultThemeDirPath } = await downloadKeycloakDefaultTheme({
+        keycloakVersion: LAST_KEYCLOAK_VERSION_WITH_ACCOUNT_V1,
+        buildContext
+    });
+
+    const accountV1DirPath = pathJoin(
+        resourcesDirPath,
+        "theme",
+        ACCOUNT_V1_THEME_NAME,
+        "account"
+    );
+
+    transformCodebase({
+        srcDirPath: pathJoin(defaultThemeDirPath, "base", "account"),
+        destDirPath: accountV1DirPath
+    });
+
+    transformCodebase({
+        srcDirPath: pathJoin(defaultThemeDirPath, "keycloak", "account", "resources"),
+        destDirPath: pathJoin(accountV1DirPath, "resources")
+    });
+
+    transformCodebase({
+        srcDirPath: pathJoin(defaultThemeDirPath, "keycloak", "common", "resources"),
+        destDirPath: pathJoin(accountV1DirPath, "resources", RESOURCES_COMMON)
+    });
+
+    fs.writeFileSync(
+        pathJoin(accountV1DirPath, "theme.properties"),
+        Buffer.from(
+            [
+                "accountResourceProvider=account-v1",
+                "",
+                "locales=ar,ca,cs,da,de,en,es,fr,fi,hu,it,ja,lt,nl,no,pl,pt-BR,ru,sk,sv,tr,zh-CN",
+                "",
+                "styles=" +
+                    [
+                        "css/account.css",
+                        "img/icon-sidebar-active.png",
+                        "img/logo.png",
+                        ...[
+                            "patternfly.min.css",
+                            "patternfly-additions.min.css",
+                            "patternfly-additions.min.css"
+                        ].map(
+                            fileBasename =>
+                                `${RESOURCES_COMMON}/node_modules/patternfly/dist/css/${fileBasename}`
+                        )
+                    ].join(" "),
+                "",
+                "##### css classes for form buttons",
+                "# main class used for all buttons",
+                "kcButtonClass=btn",
+                "# classes defining priority of the button - primary or default (there is typically only one priority button for the form)",
+                "kcButtonPrimaryClass=btn-primary",
+                "kcButtonDefaultClass=btn-default",
+                "# classes defining size of the button",
+                "kcButtonLargeClass=btn-lg",
+                ""
+            ].join("\n"),
+            "utf8"
+        )
+    );
+}

package/src/bin/keycloakify/generateResources/generateMessageProperties.ts

@@ -0,0 +1,192 @@
+import { type ThemeType, FALLBACK_LANGUAGE_TAG } from "../../shared/constants";
+import { crawl } from "../../tools/crawl";
+import { join as pathJoin } from "path";
+import { symToStr } from "tsafe/symToStr";
+import * as recast from "recast";
+import * as babelParser from "@babel/parser";
+import babelGenerate from "@babel/generator";
+import * as babelTypes from "@babel/types";
+import { escapeStringForPropertiesFile } from "../../tools/escapeStringForPropertiesFile";
+import { getThisCodebaseRootDirPath } from "../../tools/getThisCodebaseRootDirPath";
+import * as fs from "fs";
+import { assert } from "tsafe/assert";
+
+export function generateMessageProperties(params: {
+    themeSrcDirPath: string;
+    themeType: ThemeType;
+}): { languageTag: string; propertiesFileSource: string }[] {
+    const { themeSrcDirPath, themeType } = params;
+
+    const baseMessagesDirPath = pathJoin(
+        getThisCodebaseRootDirPath(),
+        "src",
+        themeType,
+        "i18n",
+        "messages_defaultSet"
+    );
+
+    const baseMessageBundle: { [languageTag: string]: Record<string, string> } =
+        Object.fromEntries(
+            fs
+                .readdirSync(baseMessagesDirPath)
+                .filter(baseName => baseName !== "index.ts")
+                .map(basename => ({
+                    languageTag: basename.replace(/\.ts$/, ""),
+                    filePath: pathJoin(baseMessagesDirPath, basename)
+                }))
+                .map(({ languageTag, filePath }) => {
+                    const lines = fs
+                        .readFileSync(filePath)
+                        .toString("utf8")
+                        .split(/\r?\n/);
+
+                    let messagesJson = "{";
+
+                    let isInDeclaration = false;
+
+                    for (const line of lines) {
+                        if (!isInDeclaration) {
+                            if (line.startsWith("const messages")) {
+                                isInDeclaration = true;
+                            }
+
+                            continue;
+                        }
+
+                        if (line.startsWith("}")) {
+                            messagesJson += "}";
+                            break;
+                        }
+
+                        messagesJson += line;
+                    }
+
+                    const messages = JSON.parse(messagesJson) as Record<string, string>;
+
+                    return [languageTag, messages];
+                })
+        );
+
+    const { i18nTsFilePath } = (() => {
+        let files = crawl({
+            dirPath: pathJoin(themeSrcDirPath, themeType),
+            returnedPathsType: "absolute"
+        });
+
+        files = files.filter(file => {
+            const regex = /\.(js|ts|tsx)$/;
+            return regex.test(file);
+        });
+
+        files = files.sort((a, b) => {
+            const regex = /\.i18n\.(ts|js|tsx)$/;
+            const aIsI18nFile = regex.test(a);
+            const bIsI18nFile = regex.test(b);
+            return aIsI18nFile === bIsI18nFile ? 0 : aIsI18nFile ? -1 : 1;
+        });
+
+        files = files.sort((a, b) => a.length - b.length);
+
+        files = files.filter(file =>
+            fs.readFileSync(file).toString("utf8").includes("createUseI18n(")
+        );
+
+        const i18nTsFilePath: string | undefined = files[0];
+
+        return { i18nTsFilePath };
+    })();
+
+    const messageBundle: { [languageTag: string]: Record<string, string> } | undefined =
+        (() => {
+            if (i18nTsFilePath === undefined) {
+                return undefined;
+            }
+
+            const root = recast.parse(fs.readFileSync(i18nTsFilePath).toString("utf8"), {
+                parser: {
+                    parse: (code: string) =>
+                        babelParser.parse(code, {
+                            sourceType: "module",
+                            plugins: ["typescript"]
+                        }),
+                    generator: babelGenerate,
+                    types: babelTypes
+                }
+            });
+
+            let messageBundleDeclarationTsCode: string | undefined = undefined;
+
+            recast.visit(root, {
+                visitCallExpression: function (path) {
+                    if (
+                        path.node.callee.type === "Identifier" &&
+                        path.node.callee.name === "createUseI18n"
+                    ) {
+                        messageBundleDeclarationTsCode = babelGenerate(
+                            path.node.arguments[0] as any
+                        ).code;
+                        return false;
+                    }
+
+                    this.traverse(path);
+                }
+            });
+
+            assert(messageBundleDeclarationTsCode !== undefined);
+
+            let messageBundle: {
+                [languageTag: string]: Record<string, string>;
+            } = {};
+
+            try {
+                eval(
+                    `${symToStr({ messageBundle })} = ${messageBundleDeclarationTsCode}`
+                );
+            } catch {
+                console.warn(
+                    [
+                        "WARNING: Make sure the messageBundle your provided as argument of createUseI18n can be statically evaluated.",
+                        "This is important because we need to put your i18n messages in messages_*.properties files",
+                        "or they won't be available server side.",
+                        "\n",
+                        "The following code could not be evaluated:",
+                        "\n",
+                        messageBundleDeclarationTsCode
+                    ].join(" ")
+                );
+            }
+
+            return messageBundle;
+        })();
+
+    const mergedMessageBundle: { [languageTag: string]: Record<string, string> } =
+        Object.fromEntries(
+            Object.entries(baseMessageBundle).map(([languageTag, messages]) => [
+                languageTag,
+                {
+                    ...messages,
+                    ...(messageBundle === undefined
+                        ? {}
+                        : messageBundle[languageTag] ??
+                          messageBundle[FALLBACK_LANGUAGE_TAG] ??
+                          messageBundle[Object.keys(messageBundle)[0]] ??
+                          {})
+                }
+            ])
+        );
+
+    const messageProperties: { languageTag: string; propertiesFileSource: string }[] =
+        Object.entries(mergedMessageBundle).map(([languageTag, messages]) => ({
+            languageTag,
+            propertiesFileSource: [
+                "",
+                ...(themeType !== "account" ? ["parent=base"] : []),
+                ...Object.entries(messages).map(
+                    ([key, value]) => `${key}=${escapeStringForPropertiesFile(value)}`
+                ),
+                ""
+            ].join("\n")
+        }));
+
+    return messageProperties;
+}

package/src/bin/keycloakify/generateResources/generateResources.ts

@@ -0,0 +1,42 @@
+import type { BuildContext } from "../../shared/buildContext";
+import { assert } from "tsafe/assert";
+import {
+    generateResourcesForMainTheme,
+    type BuildContextLike as BuildContextLike_generateResourcesForMainTheme
+} from "./generateResourcesForMainTheme";
+import { generateResourcesForThemeVariant } from "./generateResourcesForThemeVariant";
+import fs from "fs";
+import { rmSync } from "../../tools/fs.rmSync";
+
+export type BuildContextLike = BuildContextLike_generateResourcesForMainTheme & {
+    themeNames: string[];
+};
+
+assert<BuildContext extends BuildContextLike ? true : false>();
+
+export async function generateResources(params: {
+    buildContext: BuildContextLike;
+    resourcesDirPath: string;
+}): Promise<void> {
+    const { resourcesDirPath, buildContext } = params;
+
+    const [themeName, ...themeVariantNames] = buildContext.themeNames;
+
+    if (fs.existsSync(resourcesDirPath)) {
+        rmSync(resourcesDirPath, { recursive: true });
+    }
+
+    await generateResourcesForMainTheme({
+        resourcesDirPath,
+        themeName,
+        buildContext
+    });
+
+    for (const themeVariantName of themeVariantNames) {
+        generateResourcesForThemeVariant({
+            resourcesDirPath,
+            themeName,
+            themeVariantName
+        });
+    }
+}

package/src/bin/keycloakify/generateResources/generateResourcesForMainTheme.ts

@@ -0,0 +1,366 @@
+import { transformCodebase } from "../../tools/transformCodebase";
+import * as fs from "fs";
+import {
+    join as pathJoin,
+    resolve as pathResolve,
+    relative as pathRelative,
+    dirname as pathDirname,
+    basename as pathBasename
+} from "path";
+import { replaceImportsInJsCode } from "../replacers/replaceImportsInJsCode";
+import { replaceImportsInCssCode } from "../replacers/replaceImportsInCssCode";
+import {
+    generateFtlFilesCodeFactory,
+    type BuildContextLike as BuildContextLike_kcContextExclusionsFtlCode
+} from "../generateFtl";
+import {
+    type ThemeType,
+    LAST_KEYCLOAK_VERSION_WITH_ACCOUNT_V1,
+    KEYCLOAK_RESOURCES,
+    ACCOUNT_V1_THEME_NAME,
+    BASENAME_OF_KEYCLOAKIFY_RESOURCES_DIR,
+    LOGIN_THEME_PAGE_IDS,
+    ACCOUNT_THEME_PAGE_IDS
+} from "../../shared/constants";
+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 { 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";
+import { downloadAndExtractArchive } from "../../tools/downloadAndExtractArchive";
+
+export type BuildContextLike = BuildContextLike_kcContextExclusionsFtlCode &
+    BuildContextLike_downloadKeycloakStaticResources &
+    BuildContextLike_bringInAccountV1 & {
+        extraThemeProperties: string[] | undefined;
+        loginThemeResourcesFromKeycloakVersion: string;
+        projectDirPath: string;
+        projectBuildDirPath: string;
+        environmentVariables: { name: string; default: string }[];
+        implementedThemeTypes: BuildContext["implementedThemeTypes"];
+        themeSrcDirPath: string;
+        bundler: "vite" | "webpack";
+    };
+
+assert<BuildContext extends BuildContextLike ? true : false>();
+
+export async function generateResourcesForMainTheme(params: {
+    themeName: string;
+    resourcesDirPath: string;
+    buildContext: BuildContextLike;
+}): Promise<void> {
+    const { themeName, resourcesDirPath, buildContext } = params;
+
+    const getThemeTypeDirPath = (params: { themeType: ThemeType | "email" }) => {
+        const { themeType } = params;
+        return pathJoin(resourcesDirPath, "theme", themeName, themeType);
+    };
+
+    for (const themeType of ["login", "account"] as const) {
+        if (!buildContext.implementedThemeTypes[themeType].isImplemented) {
+            continue;
+        }
+
+        const isForAccountSpa =
+            themeType === "account" &&
+            (assert(buildContext.implementedThemeTypes.account.isImplemented),
+            buildContext.implementedThemeTypes.account.type === "Single-Page");
+
+        const themeTypeDirPath = getThemeTypeDirPath({ themeType });
+
+        apply_replacers_and_move_to_theme_resources: {
+            const destDirPath = pathJoin(
+                themeTypeDirPath,
+                "resources",
+                BASENAME_OF_KEYCLOAKIFY_RESOURCES_DIR
+            );
+
+            // 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" &&
+                buildContext.implementedThemeTypes.login.isImplemented
+            ) {
+                // NOTE: We prevent doing it twice, it has been done for the login theme.
+
+                transformCodebase({
+                    srcDirPath: pathJoin(
+                        getThemeTypeDirPath({
+                            themeType: "login"
+                        }),
+                        "resources",
+                        BASENAME_OF_KEYCLOAKIFY_RESOURCES_DIR
+                    ),
+                    destDirPath
+                });
+
+                break apply_replacers_and_move_to_theme_resources;
+            }
+
+            {
+                const dirPath = pathJoin(
+                    buildContext.projectBuildDirPath,
+                    KEYCLOAK_RESOURCES
+                );
+
+                if (fs.existsSync(dirPath)) {
+                    assert(buildContext.bundler === "webpack");
+
+                    throw new Error(
+                        [
+                            `Keycloakify build error: The ${KEYCLOAK_RESOURCES} directory shouldn't exist in your build directory.`,
+                            `(${pathRelative(process.cwd(), dirPath)}).\n`,
+                            `Theses assets are only required for local development with Storybook.",
+                            "Please remove this directory as an additional step of your command.\n`,
+                            `For example: \`"build": "... && rimraf ${pathRelative(buildContext.projectDirPath, dirPath)}"\``
+                        ].join(" ")
+                    );
+                }
+            }
+
+            transformCodebase({
+                srcDirPath: buildContext.projectBuildDirPath,
+                destDirPath,
+                transformSourceCode: ({ filePath, fileRelativePath, sourceCode }) => {
+                    if (filePath.endsWith(".css")) {
+                        const { fixedCssCode } = replaceImportsInCssCode({
+                            cssCode: sourceCode.toString("utf8"),
+                            cssFileRelativeDirPath: pathDirname(fileRelativePath),
+                            buildContext
+                        });
+
+                        return {
+                            modifiedSourceCode: Buffer.from(fixedCssCode, "utf8")
+                        };
+                    }
+
+                    if (filePath.endsWith(".js")) {
+                        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"),
+            buildContext,
+            keycloakifyVersion: readThisNpmPackageVersion(),
+            themeType,
+            fieldNames: readFieldNameUsage({
+                themeSrcDirPath: buildContext.themeSrcDirPath,
+                themeType
+            })
+        });
+
+        [
+            ...(() => {
+                switch (themeType) {
+                    case "login":
+                        return LOGIN_THEME_PAGE_IDS;
+                    case "account":
+                        return isForAccountSpa ? ["index.ftl"] : ACCOUNT_THEME_PAGE_IDS;
+                }
+            })(),
+            ...(isForAccountSpa
+                ? []
+                : readExtraPagesNames({
+                      themeType,
+                      themeSrcDirPath: buildContext.themeSrcDirPath
+                  }))
+        ].forEach(pageId => {
+            const { ftlCode } = generateFtlFilesCode({ pageId });
+
+            fs.writeFileSync(
+                pathJoin(themeTypeDirPath, pageId),
+                Buffer.from(ftlCode, "utf8")
+            );
+        });
+
+        i18n_messages_generation: {
+            if (isForAccountSpa) {
+                break i18n_messages_generation;
+            }
+
+            generateMessageProperties({
+                themeSrcDirPath: buildContext.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")
+                );
+            });
+        }
+
+        keycloak_static_resources: {
+            if (isForAccountSpa) {
+                break keycloak_static_resources;
+            }
+
+            await downloadKeycloakStaticResources({
+                keycloakVersion: (() => {
+                    switch (themeType) {
+                        case "account":
+                            return LAST_KEYCLOAK_VERSION_WITH_ACCOUNT_V1;
+                        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 isForAccountSpa ? "base" : ACCOUNT_V1_THEME_NAME;
+                            case "login":
+                                return "keycloak";
+                        }
+                        assert<Equals<typeof themeType, never>>(false);
+                    })()}`,
+                    ...(isForAccountSpa ? ["deprecatedMode=false"] : []),
+                    ...(buildContext.extraThemeProperties ?? []),
+                    ...buildContext.environmentVariables.map(
+                        ({ name, default: defaultValue }) =>
+                            `${name}=\${env.${name}:${escapeStringForPropertiesFile(defaultValue)}}`
+                    )
+                ].join("\n\n"),
+                "utf8"
+            )
+        );
+    }
+
+    email: {
+        if (!buildContext.implementedThemeTypes.email.isImplemented) {
+            break email;
+        }
+
+        const emailThemeSrcDirPath = pathJoin(buildContext.themeSrcDirPath, "email");
+
+        transformCodebase({
+            srcDirPath: emailThemeSrcDirPath,
+            destDirPath: getThemeTypeDirPath({ themeType: "email" })
+        });
+    }
+
+    bring_in_account_v1: {
+        if (!buildContext.implementedThemeTypes.account.isImplemented) {
+            break bring_in_account_v1;
+        }
+
+        if (buildContext.implementedThemeTypes.account.type !== "Multi-Page") {
+            break bring_in_account_v1;
+        }
+
+        await bringInAccountV1({
+            resourcesDirPath,
+            buildContext
+        });
+    }
+
+    bring_in_account_v3_i18n_messages: {
+        if (!buildContext.implementedThemeTypes.account.isImplemented) {
+            break bring_in_account_v3_i18n_messages;
+        }
+        if (buildContext.implementedThemeTypes.account.type !== "Single-Page") {
+            break bring_in_account_v3_i18n_messages;
+        }
+
+        const { extractedDirPath } = await downloadAndExtractArchive({
+            urlOrPath: "https://repo1.maven.org/maven2/org/keycloak/keycloak-account-ui/25.0.1/keycloak-account-ui-25.0.1.jar",
+            cacheDirPath: buildContext.cacheDirPath,
+            fetchOptions: buildContext.fetchOptions,
+            uniqueIdOfOnArchiveFile: "bring_in_account_v3_i18n_messages",
+            onArchiveFile: async ({ fileRelativePath, writeFile }) => {
+                if (
+                    !fileRelativePath.startsWith(
+                        pathJoin("theme", "keycloak.v3", "account", "messages")
+                    )
+                ) {
+                    return;
+                }
+                await writeFile({
+                    fileRelativePath: pathBasename(fileRelativePath)
+                });
+            }
+        });
+
+        transformCodebase({
+            srcDirPath: extractedDirPath,
+            destDirPath: pathJoin(
+                getThemeTypeDirPath({ themeType: "account" }),
+                "messages"
+            )
+        });
+    }
+
+    {
+        const metaInfKeycloakThemes: MetaInfKeycloakTheme = { themes: [] };
+
+        metaInfKeycloakThemes.themes.push({
+            name: themeName,
+            types: objectEntries(buildContext.implementedThemeTypes)
+                .filter(([, { isImplemented }]) => isImplemented)
+                .map(([themeType]) => themeType)
+        });
+
+        if (buildContext.implementedThemeTypes.account.isImplemented) {
+            metaInfKeycloakThemes.themes.push({
+                name: ACCOUNT_V1_THEME_NAME,
+                types: ["account"]
+            });
+        }
+
+        writeMetaInfKeycloakThemes({
+            resourcesDirPath,
+            getNewMetaInfKeycloakTheme: () => metaInfKeycloakThemes
+        });
+    }
+}