keycloakify 10.0.0-rc.63 → 10.0.0-rc.65

package/src/bin/shared/getImplementedThemeTypes.ts

@@ -0,0 +1,38 @@
+import { join as pathJoin } from "path";
+import { objectFromEntries } from "tsafe/objectFromEntries";
+import * as fs from "fs";
+import { type ThemeType } from "./constants";
+import { getThemeSrcDirPath } from "./getThemeSrcDirPath";
+
+type ImplementedThemeTypes = Readonly<Record<ThemeType | "email", boolean>>;
+
+let cache:
+    | { projectDirPath: string; implementedThemeTypes: ImplementedThemeTypes }
+    | undefined;
+
+export function getImplementedThemeTypes(params: { projectDirPath: string }) {
+    const { projectDirPath } = params;
+
+    if (cache !== undefined && cache.projectDirPath === projectDirPath) {
+        const { implementedThemeTypes } = cache;
+        return { implementedThemeTypes };
+    }
+
+    cache = undefined;
+
+    const { themeSrcDirPath } = getThemeSrcDirPath({
+        projectDirPath
+    });
+
+    const implementedThemeTypes: Readonly<Record<ThemeType | "email", boolean>> =
+        objectFromEntries(
+            (["login", "account", "email"] as const).map(themeType => [
+                themeType,
+                fs.existsSync(pathJoin(themeSrcDirPath, themeType))
+            ])
+        );
+
+    cache = { projectDirPath, implementedThemeTypes };
+
+    return { implementedThemeTypes };
+}

package/src/bin/shared/getThemeSrcDirPath.ts

@@ -3,48 +3,60 @@ import { exclude } from "tsafe";
 import { crawl } from "../tools/crawl";
 import { join as pathJoin } from "path";
 import { themeTypes } from "./constants";
+import chalk from "chalk";
 
-const themeSrcDirBasenames = ["keycloak-theme", "keycloak_theme"];
+let cache: { projectDirPath: string; themeSrcDirPath: string } | undefined = undefined;
 
 /** Can't catch error, if the directory isn't found, this function will just exit the process with an error message. */
 export function getThemeSrcDirPath(params: { projectDirPath: string }) {
     const { projectDirPath } = params;
 
-    const srcDirPath = pathJoin(projectDirPath, "src");
-
-    const themeSrcDirPath: string | undefined = crawl({
-        dirPath: srcDirPath,
-        returnedPathsType: "relative to dirPath"
-    })
-        .map(fileRelativePath => {
-            for (const themeSrcDirBasename of themeSrcDirBasenames) {
-                const split = fileRelativePath.split(themeSrcDirBasename);
-                if (split.length === 2) {
-                    return pathJoin(srcDirPath, split[0] + themeSrcDirBasename);
-                }
-            }
-            return undefined;
-        })
-        .filter(exclude(undefined))[0];
-
-    if (themeSrcDirPath !== undefined) {
+    if (cache !== undefined && cache.projectDirPath === projectDirPath) {
+        const { themeSrcDirPath } = cache;
         return { themeSrcDirPath };
     }
 
-    for (const themeType of [...themeTypes, "email"]) {
-        if (!fs.existsSync(pathJoin(srcDirPath, themeType))) {
-            continue;
+    cache = undefined;
+
+    const { themeSrcDirPath } = (() => {
+        const srcDirPath = pathJoin(projectDirPath, "src");
+
+        const themeSrcDirPath: string | undefined = crawl({
+            dirPath: srcDirPath,
+            returnedPathsType: "relative to dirPath"
+        })
+            .map(fileRelativePath => {
+                for (const themeSrcDirBasename of themeSrcDirBasenames) {
+                    const split = fileRelativePath.split(themeSrcDirBasename);
+                    if (split.length === 2) {
+                        return pathJoin(srcDirPath, split[0] + themeSrcDirBasename);
+                    }
+                }
+                return undefined;
+            })
+            .filter(exclude(undefined))[0];
+
+        if (themeSrcDirPath !== undefined) {
+            return { themeSrcDirPath };
+        }
+
+        for (const themeType of [...themeTypes, "email"]) {
+            if (!fs.existsSync(pathJoin(srcDirPath, themeType))) {
+                continue;
+            }
+            return { themeSrcDirPath: srcDirPath };
         }
-        return { themeSrcDirPath: srcDirPath };
-    }
 
-    console.error(
-        [
-            "Can't locate your theme source directory. It should be either: ",
-            "src/ or src/keycloak-theme or src/keycloak_theme.",
-            "Example in the starter: https://github.com/keycloakify/keycloakify-starter/tree/main/src/keycloak-theme"
-        ].join("\n")
-    );
+        console.log(
+            chalk.red("Can't locate your theme source directory. It should be either: ")
+        );
 
-    process.exit(-1);
+        process.exit(-1);
+    })();
+
+    cache = { projectDirPath, themeSrcDirPath };
+
+    return { themeSrcDirPath };
 }
+
+const themeSrcDirBasenames = ["keycloak-theme", "keycloak_theme"];

package/src/bin/shared/metaInfKeycloakThemes.ts

@@ -1,84 +1,40 @@
 import { join as pathJoin, dirname as pathDirname } from "path";
 import type { ThemeType } from "./constants";
 import * as fs from "fs";
-import { assert } from "tsafe/assert";
-import { extractArchive } from "../tools/extractArchive";
 
 export type MetaInfKeycloakTheme = {
     themes: { name: string; types: (ThemeType | "email")[] }[];
 };
 
-export function getMetaInfKeycloakThemesJsonFilePath(params: {
-    resourcesDirPath: string;
-}) {
-    const { resourcesDirPath } = params;
-
-    return pathJoin(
-        resourcesDirPath === "." ? "" : resourcesDirPath,
-        "META-INF",
-        "keycloak-themes.json"
-    );
-}
-
-export function readMetaInfKeycloakThemes_fromResourcesDirPath(params: {
+export function writeMetaInfKeycloakThemes(params: {
     resourcesDirPath: string;
+    getNewMetaInfKeycloakTheme: (params: {
+        metaInfKeycloakTheme: MetaInfKeycloakTheme | undefined;
+    }) => MetaInfKeycloakTheme;
 }) {
-    const { resourcesDirPath } = params;
-
-    return JSON.parse(
-        fs
-            .readFileSync(
-                getMetaInfKeycloakThemesJsonFilePath({
-                    resourcesDirPath
-                })
-            )
-            .toString("utf8")
-    ) as MetaInfKeycloakTheme;
-}
+    const { resourcesDirPath, getNewMetaInfKeycloakTheme } = params;
 
-export async function readMetaInfKeycloakThemes_fromJar(params: {
-    jarFilePath: string;
-}): Promise<MetaInfKeycloakTheme> {
-    const { jarFilePath } = params;
-    let metaInfKeycloakThemes: MetaInfKeycloakTheme | undefined = undefined;
+    const filePath = pathJoin(resourcesDirPath, "META-INF", "keycloak-themes.json");
 
-    await extractArchive({
-        archiveFilePath: jarFilePath,
-        onArchiveFile: async ({ relativeFilePathInArchive, readFile, earlyExit }) => {
-            if (
-                relativeFilePathInArchive ===
-                getMetaInfKeycloakThemesJsonFilePath({ resourcesDirPath: "." })
-            ) {
-                metaInfKeycloakThemes = JSON.parse((await readFile()).toString("utf8"));
-                earlyExit();
-            }
-        }
-    });
-
-    assert(metaInfKeycloakThemes !== undefined);
-
-    return metaInfKeycloakThemes;
-}
-
-export function writeMetaInfKeycloakThemes(params: {
-    resourcesDirPath: string;
-    metaInfKeycloakThemes: MetaInfKeycloakTheme;
-}) {
-    const { resourcesDirPath, metaInfKeycloakThemes } = params;
+    const currentMetaInfKeycloakTheme = !fs.existsSync(filePath)
+        ? undefined
+        : (JSON.parse(
+              fs.readFileSync(filePath).toString("utf8")
+          ) as MetaInfKeycloakTheme);
 
-    const metaInfKeycloakThemesJsonPath = getMetaInfKeycloakThemesJsonFilePath({
-        resourcesDirPath
+    const newMetaInfKeycloakThemes = getNewMetaInfKeycloakTheme({
+        metaInfKeycloakTheme: currentMetaInfKeycloakTheme
     });
 
     {
-        const dirPath = pathDirname(metaInfKeycloakThemesJsonPath);
+        const dirPath = pathDirname(filePath);
         if (!fs.existsSync(dirPath)) {
             fs.mkdirSync(dirPath, { recursive: true });
         }
     }
 
     fs.writeFileSync(
-        metaInfKeycloakThemesJsonPath,
-        Buffer.from(JSON.stringify(metaInfKeycloakThemes, null, 2), "utf8")
+        filePath,
+        Buffer.from(JSON.stringify(newMetaInfKeycloakThemes, null, 2), "utf8")
     );
 }

package/src/bin/start-keycloak/keycloakifyBuild.ts

@@ -14,7 +14,7 @@ export type BuildContextLike = {
 assert<BuildContext extends BuildContextLike ? true : false>();
 
 export async function keycloakifyBuild(params: {
-    onlyBuildJarFileBasename: string | undefined;
+    onlyBuildJarFileBasename: string;
     buildContext: BuildContextLike;
 }): Promise<{ isKeycloakifyBuildSuccess: boolean }> {
     const { buildContext, onlyBuildJarFileBasename } = params;

package/src/bin/start-keycloak/start-keycloak.ts

@@ -2,7 +2,7 @@ import { getBuildContext } from "../shared/buildContext";
 import { exclude } from "tsafe/exclude";
 import type { CliCommandOptions as CliCommandOptions_common } from "../main";
 import { promptKeycloakVersion } from "../shared/promptKeycloakVersion";
-import { readMetaInfKeycloakThemes_fromJar } from "../shared/metaInfKeycloakThemes";
+import { getImplementedThemeTypes } from "../shared/getImplementedThemeTypes";
 import { accountV1ThemeName, containerName } from "../shared/constants";
 import { SemVer } from "../tools/SemVer";
 import type { KeycloakVersionRange } from "../shared/KeycloakVersionRange";
@@ -91,66 +91,8 @@ export async function command(params: { cliCommandOptions: CliCommandOptions })
 
     const buildContext = getBuildContext({ cliCommandOptions });
 
-    {
-        const { isAppBuildSuccess } = await appBuild({
-            buildContext
-        });
-
-        if (!isAppBuildSuccess) {
-            console.log(
-                chalk.red(
-                    `App build failed, exiting. Try running 'yarn build-keycloak-theme' and see what's wrong.`
-                )
-            );
-            process.exit(1);
-        }
-
-        const { isKeycloakifyBuildSuccess } = await keycloakifyBuild({
-            onlyBuildJarFileBasename: undefined,
-            buildContext
-        });
-
-        if (!isKeycloakifyBuildSuccess) {
-            console.log(
-                chalk.red(
-                    `Keycloakify build failed, exiting. Try running 'yarn build-keycloak-theme' and see what's wrong.`
-                )
-            );
-            process.exit(1);
-        }
-    }
-
-    const { doesImplementAccountTheme } = await (async () => {
-        const latestJarFilePath = fs
-            .readdirSync(buildContext.keycloakifyBuildDirPath)
-            .filter(fileBasename => fileBasename.endsWith(".jar"))
-            .map(fileBasename =>
-                pathJoin(buildContext.keycloakifyBuildDirPath, fileBasename)
-            )
-            .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs)[0];
-
-        assert(latestJarFilePath !== undefined);
-
-        const metaInfKeycloakThemes = await readMetaInfKeycloakThemes_fromJar({
-            jarFilePath: latestJarFilePath
-        });
-
-        const mainThemeEntry = metaInfKeycloakThemes.themes.find(
-            ({ name }) => name === buildContext.themeNames[0]
-        );
-
-        assert(mainThemeEntry !== undefined);
-
-        const doesImplementAccountTheme = mainThemeEntry.types.includes("account");
-
-        return { doesImplementAccountTheme };
-    })();
-
     const { keycloakVersion, keycloakMajorNumber: keycloakMajorVersionNumber } =
-        await (async function getKeycloakMajor(): Promise<{
-            keycloakVersion: string;
-            keycloakMajorNumber: number;
-        }> {
+        await (async () => {
             if (cliCommandOptions.keycloakVersion !== undefined) {
                 return {
                     keycloakVersion: cliCommandOptions.keycloakVersion,
@@ -173,20 +115,14 @@ export async function command(params: { cliCommandOptions: CliCommandOptions })
 
             const keycloakMajorNumber = SemVer.parse(keycloakVersion).major;
 
-            if (doesImplementAccountTheme && keycloakMajorNumber === 22) {
-                console.log(
-                    [
-                        "Unfortunately, Keycloakify themes that implements an account theme do not work on Keycloak 22",
-                        "Please select any other Keycloak version"
-                    ].join(" ")
-                );
-                return getKeycloakMajor();
-            }
-
             return { keycloakVersion, keycloakMajorNumber };
         })();
 
     const keycloakVersionRange: KeycloakVersionRange = (() => {
+        const doesImplementAccountTheme = getImplementedThemeTypes({
+            projectDirPath: buildContext.projectDirPath
+        }).implementedThemeTypes.account;
+
         if (doesImplementAccountTheme) {
             const keycloakVersionRange = (() => {
                 if (keycloakMajorVersionNumber <= 21) {
@@ -233,6 +169,35 @@ export async function command(params: { cliCommandOptions: CliCommandOptions })
 
     const { jarFileBasename } = getJarFileBasename({ keycloakVersionRange });
 
+    {
+        const { isAppBuildSuccess } = await appBuild({
+            buildContext
+        });
+
+        if (!isAppBuildSuccess) {
+            console.log(
+                chalk.red(
+                    `App build failed, exiting. Try running 'npm run build-keycloak-theme' and see what's wrong.`
+                )
+            );
+            process.exit(1);
+        }
+
+        const { isKeycloakifyBuildSuccess } = await keycloakifyBuild({
+            onlyBuildJarFileBasename: jarFileBasename,
+            buildContext
+        });
+
+        if (!isKeycloakifyBuildSuccess) {
+            console.log(
+                chalk.red(
+                    `Keycloakify build failed, exiting. Try running 'npm run build-keycloak-theme' and see what's wrong.`
+                )
+            );
+            process.exit(1);
+        }
+    }
+
     console.log(`Using Keycloak ${chalk.bold(jarFileBasename)}`);
 
     const realmJsonFilePath = await (async () => {