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

package/src/bin/{keycloakify/generateFtl/pageId.ts → shared/constants.ts}

@@ -1,3 +1,21 @@
+export const keycloak_resources = "keycloak-resources";
+export const resources_common = "resources-common";
+export const lastKeycloakVersionWithAccountV1 = "21.1.2";
+export const basenameOfTheKeycloakifyResourcesDir = "dist";
+
+export const themeTypes = ["login", "account"] as const;
+export const accountV1ThemeName = "account-v1";
+
+export type ThemeType = (typeof themeTypes)[number];
+
+export const vitePluginSubScriptEnvNames = {
+    runPostBuildScript: "KEYCLOAKIFY_RUN_POST_BUILD_SCRIPT",
+    resolveViteConfig: "KEYCLOAKIFY_RESOLVE_VITE_CONFIG"
+} as const;
+
+export const buildForKeycloakMajorVersionEnvName =
+    "KEYCLOAKIFY_BUILD_FOR_KEYCLOAK_MAJOR_VERSION";
+
 export const loginThemePageIds = [
     "login.ftl",
     "login-username.ftl",
@@ -35,7 +53,19 @@ export const loginThemePageIds = [
     "webauthn-error.ftl"
 ] as const;
 
-export const accountThemePageIds = ["password.ftl", "account.ftl", "sessions.ftl", "totp.ftl", "applications.ftl", "log.ftl"] as const;
+export const accountThemePageIds = [
+    "password.ftl",
+    "account.ftl",
+    "sessions.ftl",
+    "totp.ftl",
+    "applications.ftl",
+    "log.ftl",
+    "federatedIdentity.ftl"
+] as const;
 
 export type LoginThemePageId = (typeof loginThemePageIds)[number];
 export type AccountThemePageId = (typeof accountThemePageIds)[number];
+
+export const containerName = "keycloak-keycloakify";
+
+export const fallbackLanguageTag = "en";

package/src/bin/shared/copyKeycloakResourcesToPublic.ts

@@ -0,0 +1,101 @@
+import {
+    downloadKeycloakStaticResources,
+    type BuildContextLike as BuildContextLike_downloadKeycloakStaticResources
+} from "./downloadKeycloakStaticResources";
+import { join as pathJoin, relative as pathRelative } from "path";
+import {
+    themeTypes,
+    keycloak_resources,
+    lastKeycloakVersionWithAccountV1
+} from "../shared/constants";
+import { readThisNpmPackageVersion } from "../tools/readThisNpmPackageVersion";
+import { assert } from "tsafe/assert";
+import * as fs from "fs";
+import { rmSync } from "../tools/fs.rmSync";
+import type { BuildContext } from "./buildContext";
+
+export type BuildContextLike = BuildContextLike_downloadKeycloakStaticResources & {
+    loginThemeResourcesFromKeycloakVersion: string;
+    publicDirPath: string;
+};
+
+assert<BuildContext extends BuildContextLike ? true : false>();
+
+export async function copyKeycloakResourcesToPublic(params: {
+    buildContext: BuildContextLike;
+}) {
+    const { buildContext } = params;
+
+    const destDirPath = pathJoin(buildContext.publicDirPath, keycloak_resources);
+
+    const keycloakifyBuildinfoFilePath = pathJoin(destDirPath, "keycloakify.buildinfo");
+
+    const keycloakifyBuildinfoRaw = JSON.stringify(
+        {
+            destDirPath,
+            keycloakifyVersion: readThisNpmPackageVersion(),
+            buildContext: {
+                loginThemeResourcesFromKeycloakVersion: readThisNpmPackageVersion(),
+                cacheDirPath: pathRelative(destDirPath, buildContext.cacheDirPath),
+                fetchOptions: buildContext.fetchOptions
+            }
+        },
+        null,
+        2
+    );
+
+    skip_if_already_done: {
+        if (!fs.existsSync(keycloakifyBuildinfoFilePath)) {
+            break skip_if_already_done;
+        }
+
+        const keycloakifyBuildinfoRaw_previousRun = fs
+            .readFileSync(keycloakifyBuildinfoFilePath)
+            .toString("utf8");
+
+        if (keycloakifyBuildinfoRaw_previousRun !== keycloakifyBuildinfoRaw) {
+            break skip_if_already_done;
+        }
+
+        return;
+    }
+
+    rmSync(destDirPath, { force: true, recursive: true });
+
+    fs.mkdirSync(destDirPath, { recursive: true });
+
+    fs.writeFileSync(pathJoin(destDirPath, ".gitignore"), Buffer.from("*", "utf8"));
+
+    for (const themeType of themeTypes) {
+        await downloadKeycloakStaticResources({
+            keycloakVersion: (() => {
+                switch (themeType) {
+                    case "login":
+                        return buildContext.loginThemeResourcesFromKeycloakVersion;
+                    case "account":
+                        return lastKeycloakVersionWithAccountV1;
+                }
+            })(),
+            themeType,
+            themeDirPath: destDirPath,
+            buildContext
+        });
+    }
+
+    fs.writeFileSync(
+        pathJoin(destDirPath, "README.txt"),
+        Buffer.from(
+            // prettier-ignore
+            [
+                "This is just a test folder that helps develop",
+                "the login and register page without having to run a Keycloak container\n",
+                "This directory will be automatically excluded from the final build."
+            ].join(" ")
+        )
+    );
+
+    fs.writeFileSync(
+        keycloakifyBuildinfoFilePath,
+        Buffer.from(keycloakifyBuildinfoRaw, "utf8")
+    );
+}

package/src/bin/shared/downloadKeycloakDefaultTheme.ts

@@ -0,0 +1,276 @@
+import { join as pathJoin, relative as pathRelative } from "path";
+import { type BuildContext } from "./buildContext";
+import { assert } from "tsafe/assert";
+import { lastKeycloakVersionWithAccountV1 } from "./constants";
+import { downloadAndExtractArchive } from "../tools/downloadAndExtractArchive";
+
+export type BuildContextLike = {
+    cacheDirPath: string;
+    fetchOptions: BuildContext["fetchOptions"];
+};
+
+assert<BuildContext extends BuildContextLike ? true : false>();
+
+export async function downloadKeycloakDefaultTheme(params: {
+    keycloakVersion: string;
+    buildContext: BuildContextLike;
+}): Promise<{ defaultThemeDirPath: string }> {
+    const { keycloakVersion, buildContext } = params;
+
+    let kcNodeModulesKeepFilePaths: string[] | undefined = undefined;
+    let kcNodeModulesKeepFilePaths_lastAccountV1: string[] | undefined = undefined;
+
+    const { extractedDirPath } = await downloadAndExtractArchive({
+        url: `https://repo1.maven.org/maven2/org/keycloak/keycloak-themes/${keycloakVersion}/keycloak-themes-${keycloakVersion}.jar`,
+        cacheDirPath: buildContext.cacheDirPath,
+        fetchOptions: buildContext.fetchOptions,
+        uniqueIdOfOnOnArchiveFile: "downloadKeycloakDefaultTheme",
+        onArchiveFile: async params => {
+            const fileRelativePath = pathRelative("theme", params.fileRelativePath);
+
+            if (fileRelativePath.startsWith("..")) {
+                return;
+            }
+
+            const { readFile, writeFile } = params;
+
+            skip_keycloak_v2: {
+                if (!fileRelativePath.startsWith(pathJoin("keycloak.v2"))) {
+                    break skip_keycloak_v2;
+                }
+
+                return;
+            }
+
+            last_account_v1_transformations: {
+                if (lastKeycloakVersionWithAccountV1 !== keycloakVersion) {
+                    break last_account_v1_transformations;
+                }
+
+                skip_web_modules: {
+                    if (
+                        !fileRelativePath.startsWith(
+                            pathJoin("keycloak", "common", "resources", "web_modules")
+                        )
+                    ) {
+                        break skip_web_modules;
+                    }
+
+                    return;
+                }
+
+                skip_lib: {
+                    if (
+                        !fileRelativePath.startsWith(
+                            pathJoin("keycloak", "common", "resources", "lib")
+                        )
+                    ) {
+                        break skip_lib;
+                    }
+
+                    return;
+                }
+
+                skip_node_modules: {
+                    if (
+                        !fileRelativePath.startsWith(
+                            pathJoin("keycloak", "common", "resources", "node_modules")
+                        )
+                    ) {
+                        break skip_node_modules;
+                    }
+
+                    if (kcNodeModulesKeepFilePaths_lastAccountV1 === undefined) {
+                        kcNodeModulesKeepFilePaths_lastAccountV1 = [
+                            pathJoin("patternfly", "dist", "css", "patternfly.min.css"),
+                            pathJoin(
+                                "patternfly",
+                                "dist",
+                                "css",
+                                "patternfly-additions.min.css"
+                            ),
+                            pathJoin(
+                                "patternfly",
+                                "dist",
+                                "fonts",
+                                "OpenSans-Regular-webfont.woff2"
+                            ),
+                            pathJoin(
+                                "patternfly",
+                                "dist",
+                                "fonts",
+                                "OpenSans-Bold-webfont.woff2"
+                            ),
+                            pathJoin(
+                                "patternfly",
+                                "dist",
+                                "fonts",
+                                "OpenSans-Light-webfont.woff2"
+                            ),
+                            pathJoin(
+                                "patternfly",
+                                "dist",
+                                "fonts",
+                                "OpenSans-Semibold-webfont.woff2"
+                            ),
+                            pathJoin(
+                                "patternfly",
+                                "dist",
+                                "fonts",
+                                "PatternFlyIcons-webfont.ttf"
+                            ),
+                            pathJoin(
+                                "patternfly",
+                                "dist",
+                                "fonts",
+                                "PatternFlyIcons-webfont.woff"
+                            )
+                        ];
+                    }
+
+                    for (const keepPath of kcNodeModulesKeepFilePaths_lastAccountV1) {
+                        if (fileRelativePath.endsWith(keepPath)) {
+                            break skip_node_modules;
+                        }
+                    }
+
+                    return;
+                }
+
+                patch_account_css: {
+                    if (
+                        fileRelativePath !==
+                        pathJoin("keycloak", "account", "resources", "css", "account.css")
+                    ) {
+                        break patch_account_css;
+                    }
+
+                    await writeFile({
+                        fileRelativePath,
+                        modifiedData: Buffer.from(
+                            (await readFile())
+                                .toString("utf8")
+                                .replace("top: -34px;", "top: -34px !important;"),
+                            "utf8"
+                        )
+                    });
+
+                    return;
+                }
+            }
+
+            skip_unused_resources: {
+                if (keycloakVersion !== "24.0.4") {
+                    break skip_unused_resources;
+                }
+
+                skip_node_modules: {
+                    if (
+                        !fileRelativePath.startsWith(
+                            pathJoin("keycloak", "common", "resources", "node_modules")
+                        )
+                    ) {
+                        break skip_node_modules;
+                    }
+
+                    if (kcNodeModulesKeepFilePaths === undefined) {
+                        kcNodeModulesKeepFilePaths = [
+                            pathJoin("@patternfly", "patternfly", "patternfly.min.css"),
+                            pathJoin("patternfly", "dist", "css", "patternfly.min.css"),
+                            pathJoin(
+                                "patternfly",
+                                "dist",
+                                "css",
+                                "patternfly-additions.min.css"
+                            ),
+                            pathJoin(
+                                "patternfly",
+                                "dist",
+                                "fonts",
+                                "OpenSans-Regular-webfont.woff2"
+                            ),
+                            pathJoin(
+                                "patternfly",
+                                "dist",
+                                "fonts",
+                                "OpenSans-Light-webfont.woff2"
+                            ),
+                            pathJoin(
+                                "patternfly",
+                                "dist",
+                                "fonts",
+                                "OpenSans-Bold-webfont.woff2"
+                            ),
+                            pathJoin(
+                                "patternfly",
+                                "dist",
+                                "fonts",
+                                "OpenSans-Bold-webfont.woff"
+                            ),
+                            pathJoin(
+                                "patternfly",
+                                "dist",
+                                "fonts",
+                                "OpenSans-Bold-webfont.ttf"
+                            ),
+                            pathJoin(
+                                "patternfly",
+                                "dist",
+                                "fonts",
+                                "fontawesome-webfont.woff2"
+                            ),
+                            pathJoin(
+                                "patternfly",
+                                "dist",
+                                "fonts",
+                                "PatternFlyIcons-webfont.ttf"
+                            ),
+                            pathJoin(
+                                "patternfly",
+                                "dist",
+                                "fonts",
+                                "PatternFlyIcons-webfont.woff"
+                            ),
+                            pathJoin("jquery", "dist", "jquery.min.js")
+                        ];
+                    }
+
+                    for (const keepPath of kcNodeModulesKeepFilePaths) {
+                        if (fileRelativePath.endsWith(keepPath)) {
+                            break skip_node_modules;
+                        }
+                    }
+
+                    return;
+                }
+
+                skip_vendor: {
+                    if (
+                        !fileRelativePath.startsWith(
+                            pathJoin("keycloak", "common", "resources", "vendor")
+                        )
+                    ) {
+                        break skip_vendor;
+                    }
+
+                    return;
+                }
+
+                skip_rollup_config: {
+                    if (
+                        fileRelativePath !==
+                        pathJoin("keycloak", "common", "resources", "rollup.config.js")
+                    ) {
+                        break skip_rollup_config;
+                    }
+
+                    return;
+                }
+            }
+
+            await writeFile({ fileRelativePath });
+        }
+    });
+
+    return { defaultThemeDirPath: extractedDirPath };
+}

package/src/bin/shared/downloadKeycloakStaticResources.ts

@@ -0,0 +1,53 @@
+import { transformCodebase } from "../tools/transformCodebase";
+import { join as pathJoin } from "path";
+import {
+    downloadKeycloakDefaultTheme,
+    type BuildContextLike as BuildContextLike_downloadKeycloakDefaultTheme
+} from "./downloadKeycloakDefaultTheme";
+import { resources_common, type ThemeType } from "./constants";
+import type { BuildContext } from "./buildContext";
+import { assert } from "tsafe/assert";
+import { existsAsync } from "../tools/fs.existsAsync";
+
+export type BuildContextLike = BuildContextLike_downloadKeycloakDefaultTheme & {};
+
+assert<BuildContext extends BuildContextLike ? true : false>();
+
+export async function downloadKeycloakStaticResources(params: {
+    themeType: ThemeType;
+    themeDirPath: string;
+    keycloakVersion: string;
+    buildContext: BuildContextLike;
+}) {
+    const { themeType, themeDirPath, keycloakVersion, buildContext } = params;
+
+    const { defaultThemeDirPath } = await downloadKeycloakDefaultTheme({
+        keycloakVersion,
+        buildContext
+    });
+
+    const resourcesDirPath = pathJoin(themeDirPath, themeType, "resources");
+
+    repatriate_base_resources: {
+        const srcDirPath = pathJoin(defaultThemeDirPath, "base", themeType, "resources");
+
+        if (!(await existsAsync(srcDirPath))) {
+            break repatriate_base_resources;
+        }
+
+        transformCodebase({
+            srcDirPath,
+            destDirPath: resourcesDirPath
+        });
+    }
+
+    transformCodebase({
+        srcDirPath: pathJoin(defaultThemeDirPath, "keycloak", themeType, "resources"),
+        destDirPath: resourcesDirPath
+    });
+
+    transformCodebase({
+        srcDirPath: pathJoin(defaultThemeDirPath, "keycloak", "common", "resources"),
+        destDirPath: pathJoin(resourcesDirPath, resources_common)
+    });
+}

package/src/bin/shared/generateKcGenTs.ts

@@ -0,0 +1,68 @@
+import { assert } from "tsafe/assert";
+import type { BuildContext } from "./buildContext";
+import * as fs from "fs/promises";
+import { join as pathJoin } from "path";
+import { existsAsync } from "../tools/fs.existsAsync";
+
+export type BuildContextLike = {
+    projectDirPath: string;
+    themeNames: string[];
+    environmentVariables: { name: string; default: string }[];
+    themeSrcDirPath: string;
+};
+
+assert<BuildContext extends BuildContextLike ? true : false>();
+
+export async function generateKcGenTs(params: {
+    buildContext: BuildContextLike;
+}): Promise<void> {
+    const { buildContext } = params;
+
+    const filePath = pathJoin(buildContext.themeSrcDirPath, "kc.gen.ts");
+
+    const currentContent = (await existsAsync(filePath))
+        ? await fs.readFile(filePath)
+        : undefined;
+
+    const newContent = Buffer.from(
+        [
+            `/* prettier-ignore-start */`,
+            ``,
+            `/* eslint-disable */`,
+            ``,
+            `// @ts-nocheck`,
+            ``,
+            `// noinspection JSUnusedGlobalSymbols`,
+            ``,
+            `// This file is auto-generated by Keycloakify`,
+            ``,
+            `export type ThemeName = ${buildContext.themeNames.map(themeName => `"${themeName}"`).join(" | ")};`,
+            ``,
+            `export const themeNames: ThemeName[] = [${buildContext.themeNames.map(themeName => `"${themeName}"`).join(", ")}];`,
+            ``,
+            `export type KcEnvName = ${buildContext.environmentVariables.length === 0 ? "never" : buildContext.environmentVariables.map(({ name }) => `"${name}"`).join(" | ")};`,
+            ``,
+            `export const kcEnvNames: KcEnvName[] = [${buildContext.environmentVariables.map(({ name }) => `"${name}"`).join(", ")}];`,
+            ``,
+            `export const kcEnvDefaults: Record<KcEnvName, string> = ${JSON.stringify(
+                Object.fromEntries(
+                    buildContext.environmentVariables.map(
+                        ({ name, default: defaultValue }) => [name, defaultValue]
+                    )
+                ),
+                null,
+                2
+            )};`,
+            ``,
+            `/* prettier-ignore-end */`,
+            ``
+        ].join("\n"),
+        "utf8"
+    );
+
+    if (currentContent !== undefined && currentContent.equals(newContent)) {
+        return;
+    }
+
+    await fs.writeFile(filePath, newContent);
+}

package/src/bin/shared/metaInfKeycloakThemes.ts

@@ -0,0 +1,40 @@
+import { join as pathJoin, dirname as pathDirname } from "path";
+import type { ThemeType } from "./constants";
+import * as fs from "fs";
+
+export type MetaInfKeycloakTheme = {
+    themes: { name: string; types: (ThemeType | "email")[] }[];
+};
+
+export function writeMetaInfKeycloakThemes(params: {
+    resourcesDirPath: string;
+    getNewMetaInfKeycloakTheme: (params: {
+        metaInfKeycloakTheme: MetaInfKeycloakTheme | undefined;
+    }) => MetaInfKeycloakTheme;
+}) {
+    const { resourcesDirPath, getNewMetaInfKeycloakTheme } = params;
+
+    const filePath = pathJoin(resourcesDirPath, "META-INF", "keycloak-themes.json");
+
+    const currentMetaInfKeycloakTheme = !fs.existsSync(filePath)
+        ? undefined
+        : (JSON.parse(
+              fs.readFileSync(filePath).toString("utf8")
+          ) as MetaInfKeycloakTheme);
+
+    const newMetaInfKeycloakThemes = getNewMetaInfKeycloakTheme({
+        metaInfKeycloakTheme: currentMetaInfKeycloakTheme
+    });
+
+    {
+        const dirPath = pathDirname(filePath);
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+
+    fs.writeFileSync(
+        filePath,
+        Buffer.from(JSON.stringify(newMetaInfKeycloakThemes, null, 2), "utf8")
+    );
+}