keycloakify 10.0.0-rc.1 → 10.0.0-rc.100

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

@@ -1,179 +0,0 @@
-import type { ThemeType } from "../../constants";
-import { crawl } from "../../tools/crawl";
-import { join as pathJoin } from "path";
-import { readFileSync } from "fs";
-import { symToStr } from "tsafe/symToStr";
-import { removeDuplicates } from "evt/tools/reducers/removeDuplicates";
-import * as recast from "recast";
-import * as babelParser from "@babel/parser";
-import babelGenerate from "@babel/generator";
-import * as babelTypes from "@babel/types";
-
-export function generateMessageProperties(params: {
-    themeSrcDirPath: string;
-    themeType: ThemeType;
-}): { languageTag: string; propertiesFileSource: string }[] {
-    const { themeSrcDirPath, themeType } = params;
-
-    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 => readFileSync(file).toString("utf8").includes("createUseI18n"));
-
-    if (files.length === 0) {
-        return [];
-    }
-
-    const extraMessages = files
-        .map(file => {
-            const root = recast.parse(readFileSync(file).toString("utf8"), {
-                "parser": {
-                    "parse": (code: string) => babelParser.parse(code, { "sourceType": "module", "plugins": ["typescript"] }),
-                    "generator": babelGenerate,
-                    "types": babelTypes
-                }
-            });
-
-            const codes: string[] = [];
-
-            recast.visit(root, {
-                "visitCallExpression": function (path) {
-                    if (path.node.callee.type === "Identifier" && path.node.callee.name === "createUseI18n") {
-                        codes.push(babelGenerate(path.node.arguments[0] as any).code);
-                    }
-                    this.traverse(path);
-                }
-            });
-
-            return codes;
-        })
-        .flat()
-        .map(code => {
-            let extraMessages: { [languageTag: string]: Record<string, string> } = {};
-
-            try {
-                eval(`${symToStr({ extraMessages })} = ${code}`);
-            } catch {
-                console.warn(
-                    [
-                        "WARNING: Make sure that the first argument of createUseI18n can be evaluated in a javascript",
-                        "runtime where only the node globals are available.",
-                        "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",
-                        code
-                    ].join(" ")
-                );
-            }
-
-            return extraMessages;
-        });
-
-    const languageTags = extraMessages
-        .map(extraMessage => Object.keys(extraMessage))
-        .flat()
-        .reduce(...removeDuplicates<string>());
-
-    const keyValueMapByLanguageTag: Record<string, Record<string, string>> = {};
-
-    for (const languageTag of languageTags) {
-        const keyValueMap: Record<string, string> = {};
-
-        for (const extraMessage of extraMessages) {
-            const keyValueMap_i = extraMessage[languageTag];
-
-            if (keyValueMap_i === undefined) {
-                continue;
-            }
-
-            for (const [key, value] of Object.entries(keyValueMap_i)) {
-                if (keyValueMap[key] !== undefined) {
-                    console.warn(
-                        [
-                            "WARNING: The following key is defined multiple times:",
-                            "\n",
-                            key,
-                            "\n",
-                            "The following value will be ignored:",
-                            "\n",
-                            value,
-                            "\n",
-                            "The following value was already defined:",
-                            "\n",
-                            keyValueMap[key]
-                        ].join(" ")
-                    );
-                    continue;
-                }
-
-                keyValueMap[key] = value;
-            }
-        }
-
-        keyValueMapByLanguageTag[languageTag] = keyValueMap;
-    }
-
-    const out: { languageTag: string; propertiesFileSource: string }[] = [];
-
-    for (const [languageTag, keyValueMap] of Object.entries(keyValueMapByLanguageTag)) {
-        const propertiesFileSource = Object.entries(keyValueMap)
-            .map(([key, value]) => `${key}=${escapeString(value)}`)
-            .join("\n");
-
-        out.push({
-            languageTag,
-            "propertiesFileSource": ["# This file was generated by keycloakify", "", "parent=base", "", propertiesFileSource, ""].join("\n")
-        });
-    }
-
-    return out;
-}
-
-// Convert a JavaScript string to UTF-16 encoding
-function toUTF16(codePoint: number): string {
-    if (codePoint <= 0xffff) {
-        // BMP character
-        return "\\u" + codePoint.toString(16).padStart(4, "0");
-    } else {
-        // Non-BMP character
-        codePoint -= 0x10000;
-        let highSurrogate = (codePoint >> 10) + 0xd800;
-        let lowSurrogate = (codePoint % 0x400) + 0xdc00;
-        return "\\u" + highSurrogate.toString(16).padStart(4, "0") + "\\u" + lowSurrogate.toString(16).padStart(4, "0");
-    }
-}
-
-// Escapes special characters and converts unicode to UTF-16 encoding
-function escapeString(str: string): string {
-    let escapedStr = "";
-    for (const char of [...str]) {
-        const codePoint = char.codePointAt(0);
-        if (!codePoint) continue;
-        if (char === "'") {
-            escapedStr += "''"; // double single quotes
-        } else if (codePoint > 0x7f) {
-            escapedStr += toUTF16(codePoint); // non-ascii characters
-        } else {
-            escapedStr += char;
-        }
-    }
-    return escapedStr;
-}

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

@@ -1,267 +0,0 @@
-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 };
-}

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

@@ -1,44 +0,0 @@
-import { join as pathJoin } from "path";
-import type { BuildOptions } from "../buildOptions";
-import { assert } from "tsafe/assert";
-import { generateSrcMainResources, type BuildOptionsLike as BuildOptionsLike_generateSrcMainResources } from "./generateSrcMainResources";
-import { generateThemeVariations } from "./generateThemeVariants";
-
-export type BuildOptionsLike = BuildOptionsLike_generateSrcMainResources & {
-    keycloakifyBuildDirPath: string;
-    themeNames: string[];
-};
-
-assert<BuildOptions extends BuildOptionsLike ? true : false>();
-
-export async function generateTheme(params: {
-    themeSrcDirPath: string;
-    keycloakifySrcDirPath: string;
-    buildOptions: BuildOptionsLike;
-    keycloakifyVersion: string;
-}): Promise<{ doesImplementAccountTheme: boolean }> {
-    const { themeSrcDirPath, keycloakifySrcDirPath, buildOptions, keycloakifyVersion } = params;
-
-    const [themeName, ...themeVariantNames] = buildOptions.themeNames;
-
-    const srcMainResourcesDirPath = pathJoin(buildOptions.keycloakifyBuildDirPath, "src", "main", "resources");
-
-    const { doesImplementAccountTheme } = await generateSrcMainResources({
-        themeName,
-        srcMainResourcesDirPath,
-        themeSrcDirPath,
-        keycloakifySrcDirPath,
-        keycloakifyVersion,
-        buildOptions
-    });
-
-    for (const themeVariantName of themeVariantNames) {
-        generateThemeVariations({
-            themeName,
-            themeVariantName,
-            srcMainResourcesDirPath
-        });
-    }
-
-    return { doesImplementAccountTheme };
-}

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

@@ -1,50 +0,0 @@
-import { join as pathJoin, extname as pathExtname, sep as pathSep } from "path";
-import { transformCodebase } from "../../tools/transformCodebase";
-import { assert } from "tsafe/assert";
-import * as fs from "fs";
-
-export function generateThemeVariations(params: { themeName: string; themeVariantName: string; srcMainResourcesDirPath: string }) {
-    const { themeName, themeVariantName, srcMainResourcesDirPath } = params;
-
-    const mainThemeDirPath = pathJoin(srcMainResourcesDirPath, "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 keycloakThemeJsonFilePath = pathJoin(srcMainResourcesDirPath, "META-INF", "keycloak-themes.json");
-
-        const modifiedParsedJson = JSON.parse(fs.readFileSync(keycloakThemeJsonFilePath).toString("utf8")) as {
-            themes: { name: string; types: string[] }[];
-        };
-
-        modifiedParsedJson.themes.push({
-            "name": themeVariantName,
-            "types": (() => {
-                const theme = modifiedParsedJson.themes.find(({ name }) => name === themeName);
-                assert(theme !== undefined);
-                return theme.types;
-            })()
-        });
-
-        fs.writeFileSync(keycloakThemeJsonFilePath, Buffer.from(JSON.stringify(modifiedParsedJson, null, 2), "utf8"));
-    }
-}

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

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

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

@@ -1,55 +0,0 @@
-import { crawl } from "../../tools/crawl";
-import { join as pathJoin } from "path";
-import * as fs from "fs";
-import type { ThemeType } from "../../constants";
-
-/** Assumes the theme type exists */
-export function readFieldNameUsage(params: { keycloakifySrcDirPath: string; themeSrcDirPath: string; themeType: ThemeType }): string[] {
-    const { keycloakifySrcDirPath, themeSrcDirPath, themeType } = params;
-
-    const fieldNames = new Set<string>();
-
-    for (const srcDirPath of [pathJoin(keycloakifySrcDirPath, 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/replacers/replaceImportsInInlineCssCode.ts

@@ -1,24 +0,0 @@
-import type { BuildOptions } from "../buildOptions";
-import { assert } from "tsafe/assert";
-import { basenameOfTheKeycloakifyResourcesDir } from "../../constants";
-
-export type BuildOptionsLike = {
-    urlPathname: string | undefined;
-};
-
-assert<BuildOptions extends BuildOptionsLike ? true : false>();
-
-export function replaceImportsInInlineCssCode(params: { cssCode: string; buildOptions: BuildOptionsLike }): {
-    fixedCssCode: string;
-} {
-    const { cssCode, buildOptions } = params;
-
-    const fixedCssCode = cssCode.replace(
-        buildOptions.urlPathname === undefined
-            ? /url\(["']?\/([^/][^)"']+)["']?\)/g
-            : new RegExp(`url\\(["']?${buildOptions.urlPathname}([^)"']+)["']?\\)`, "g"),
-        (...[, group]) => `url(\${url.resourcesPath}/${basenameOfTheKeycloakifyResourcesDir}/${group})`
-    );
-
-    return { fixedCssCode };
-}

package/src/bin/promptKeycloakVersion.ts

@@ -1,49 +0,0 @@
-import { getLatestsSemVersionedTagFactory } from "./tools/octokit-addons/getLatestsSemVersionedTag";
-import { Octokit } from "@octokit/rest";
-import cliSelect from "cli-select";
-import { lastKeycloakVersionWithAccountV1 } from "./constants";
-
-export async function promptKeycloakVersion() {
-    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 tags = [
-        ...(await getLatestsSemVersionedTag({
-            "count": 15,
-            "owner": "keycloak",
-            "repo": "keycloak"
-        }).then(arr => arr.map(({ tag }) => tag))),
-        lastKeycloakVersionWithAccountV1,
-        "19.0.1",
-        "11.0.3"
-    ];
-
-    if (process.env["GITHUB_ACTIONS"] === "true") {
-        return { "keycloakVersion": tags[0] };
-    }
-
-    const { value: keycloakVersion } = await cliSelect<string>({
-        "values": tags
-    }).catch(() => {
-        console.log("Aborting");
-
-        process.exit(-1);
-    });
-
-    console.log(keycloakVersion);
-
-    return { keycloakVersion };
-}