keycloakify 10.0.0-rc.17 → 10.0.0-rc.18

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

@@ -0,0 +1,467 @@
+import { readBuildOptions } from "../shared/buildOptions";
+import type { CliCommandOptions as CliCommandOptions_common } from "../main";
+import { promptKeycloakVersion } from "../shared/promptKeycloakVersion";
+import { readMetaInfKeycloakThemes } from "../shared/metaInfKeycloakThemes";
+import {
+    accountV1ThemeName,
+    skipBuildJarsEnvName,
+    containerName
+} from "../shared/constants";
+import { SemVer } from "../tools/SemVer";
+import type { KeycloakVersionRange } from "../shared/KeycloakVersionRange";
+import { getJarFileBasename } from "../shared/getJarFileBasename";
+import { assert, type Equals } from "tsafe/assert";
+import * as fs from "fs";
+import { join as pathJoin, relative as pathRelative, sep as pathSep } from "path";
+import * as child_process from "child_process";
+import chalk from "chalk";
+import chokidar from "chokidar";
+import { waitForDebounceFactory } from "powerhooks/tools/waitForDebounce";
+import { getThisCodebaseRootDirPath } from "../tools/getThisCodebaseRootDirPath";
+import { Deferred } from "evt/tools/Deferred";
+import { getAbsoluteAndInOsFormatPath } from "../tools/getAbsoluteAndInOsFormatPath";
+import cliSelect from "cli-select";
+import * as runExclusive from "run-exclusive";
+import { extractArchive } from "../tools/extractArchive";
+
+export type CliCommandOptions = CliCommandOptions_common & {
+    port: number;
+    keycloakVersion: string | undefined;
+    realmJsonFilePath: string | undefined;
+};
+
+export async function command(params: { cliCommandOptions: CliCommandOptions }) {
+    exit_if_docker_not_installed: {
+        let commandOutput: Buffer | undefined = undefined;
+
+        try {
+            commandOutput = child_process.execSync("docker --version", {
+                stdio: ["ignore", "pipe", "ignore"]
+            });
+        } catch {}
+
+        if (commandOutput?.toString("utf8").includes("Docker")) {
+            break exit_if_docker_not_installed;
+        }
+
+        console.log(
+            [
+                `${chalk.red("Docker required.")}`,
+                `Install it with Docker Desktop: ${chalk.bold.underline(
+                    "https://www.docker.com/products/docker-desktop/"
+                )}`,
+                `(or any other way)`
+            ].join(" ")
+        );
+
+        process.exit(1);
+    }
+
+    exit_if_docker_not_running: {
+        let isDockerRunning: boolean;
+
+        try {
+            child_process.execSync("docker info", { stdio: "ignore" });
+            isDockerRunning = true;
+        } catch {
+            isDockerRunning = false;
+        }
+
+        if (isDockerRunning) {
+            break exit_if_docker_not_running;
+        }
+
+        console.log(
+            [
+                `${chalk.red("Docker daemon is not running.")}`,
+                `Please start Docker Desktop and try again.`
+            ].join(" ")
+        );
+
+        process.exit(1);
+    }
+
+    const { cliCommandOptions } = params;
+
+    const buildOptions = readBuildOptions({ cliCommandOptions });
+
+    exit_if_theme_not_built: {
+        if (fs.existsSync(buildOptions.keycloakifyBuildDirPath)) {
+            break exit_if_theme_not_built;
+        }
+
+        console.log(
+            [
+                `${chalk.red("The theme has not been built.")}`,
+                `Please run ${chalk.bold("npx vite && npx keycloakify build")} first.`
+            ].join(" ")
+        );
+        process.exit(1);
+    }
+
+    const metaInfKeycloakThemes = readMetaInfKeycloakThemes({
+        keycloakifyBuildDirPath: buildOptions.keycloakifyBuildDirPath
+    });
+
+    const doesImplementAccountTheme = metaInfKeycloakThemes.themes.some(
+        ({ name }) => name === accountV1ThemeName
+    );
+
+    const { keycloakVersion, keycloakMajorNumber: keycloakMajorVersionNumber } =
+        await (async function getKeycloakMajor(): Promise<{
+            keycloakVersion: string;
+            keycloakMajorNumber: number;
+        }> {
+            if (cliCommandOptions.keycloakVersion !== undefined) {
+                return {
+                    keycloakVersion: cliCommandOptions.keycloakVersion,
+                    keycloakMajorNumber: SemVer.parse(cliCommandOptions.keycloakVersion)
+                        .major
+                };
+            }
+
+            console.log(
+                chalk.cyan("On which version of Keycloak do you want to test your theme?")
+            );
+
+            const { keycloakVersion } = await promptKeycloakVersion({
+                startingFromMajor: 17,
+                cacheDirPath: buildOptions.cacheDirPath
+            });
+
+            console.log(`→ ${keycloakVersion}`);
+
+            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 = (() => {
+        if (doesImplementAccountTheme) {
+            const keycloakVersionRange = (() => {
+                if (keycloakMajorVersionNumber <= 21) {
+                    return "21-and-below" as const;
+                }
+
+                assert(keycloakMajorVersionNumber !== 22);
+
+                if (keycloakMajorVersionNumber === 23) {
+                    return "23" as const;
+                }
+
+                return "24-and-above" as const;
+            })();
+
+            assert<
+                Equals<typeof keycloakVersionRange, KeycloakVersionRange.WithAccountTheme>
+            >();
+
+            return keycloakVersionRange;
+        } else {
+            const keycloakVersionRange = (() => {
+                if (keycloakMajorVersionNumber <= 21) {
+                    return "21-and-below" as const;
+                }
+
+                return "22-and-above" as const;
+            })();
+
+            assert<
+                Equals<
+                    typeof keycloakVersionRange,
+                    KeycloakVersionRange.WithoutAccountTheme
+                >
+            >();
+
+            return keycloakVersionRange;
+        }
+    })();
+
+    const { jarFileBasename } = getJarFileBasename({ keycloakVersionRange });
+
+    console.log(`Using Keycloak ${chalk.bold(jarFileBasename)}`);
+
+    try {
+        child_process.execSync(`docker rm --force ${containerName}`, {
+            stdio: "ignore"
+        });
+    } catch {}
+
+    const realmJsonFilePath = await (async () => {
+        if (cliCommandOptions.realmJsonFilePath !== undefined) {
+            console.log(
+                chalk.green(
+                    `Using realm json file: ${cliCommandOptions.realmJsonFilePath}`
+                )
+            );
+
+            return getAbsoluteAndInOsFormatPath({
+                pathIsh: cliCommandOptions.realmJsonFilePath,
+                cwd: process.cwd()
+            });
+        }
+
+        const dirPath = pathJoin(
+            getThisCodebaseRootDirPath(),
+            "src",
+            "bin",
+            "start-keycloak"
+        );
+
+        const filePath = pathJoin(
+            dirPath,
+            `myrealm-realm-${keycloakMajorVersionNumber}.json`
+        );
+
+        if (fs.existsSync(filePath)) {
+            return filePath;
+        }
+
+        console.log(
+            `${chalk.yellow(
+                `Keycloakify do not have a realm configuration for Keycloak ${keycloakMajorVersionNumber} yet.`
+            )}`
+        );
+
+        console.log(chalk.cyan("Select what configuration to use:"));
+
+        const { value } = await cliSelect<string>({
+            values: [
+                ...fs
+                    .readdirSync(dirPath)
+                    .filter(fileBasename => fileBasename.endsWith(".json")),
+                "none"
+            ]
+        }).catch(() => {
+            process.exit(-1);
+        });
+
+        if (value === "none") {
+            return undefined;
+        }
+
+        return pathJoin(dirPath, value);
+    })();
+
+    const jarFilePath = pathJoin(buildOptions.keycloakifyBuildDirPath, jarFileBasename);
+
+    let doLinkAccountV1Theme = false;
+
+    await extractArchive({
+        archiveFilePath: jarFilePath,
+        onArchiveFile: async ({ relativeFilePathInArchive, readFile, writeFile }) => {
+            for (const themeName of buildOptions.themeNames) {
+                if (
+                    relativeFilePathInArchive ===
+                    pathJoin("theme", themeName, "account", "theme.properties")
+                ) {
+                    if (
+                        (await readFile())
+                            .toString("utf8")
+                            .includes(`parent=${accountV1ThemeName}`)
+                    ) {
+                        doLinkAccountV1Theme = true;
+                    }
+
+                    await writeFile({
+                        filePath: pathJoin(
+                            buildOptions.keycloakifyBuildDirPath,
+                            "src",
+                            "main",
+                            "resources",
+                            "theme",
+                            themeName,
+                            "account",
+                            "theme.properties"
+                        )
+                    });
+                }
+            }
+        }
+    });
+
+    const spawnArgs = [
+        "docker",
+        [
+            "run",
+            ...["-p", `${cliCommandOptions.port}:8080`],
+            ...["--name", containerName],
+            ...["-e", "KEYCLOAK_ADMIN=admin"],
+            ...["-e", "KEYCLOAK_ADMIN_PASSWORD=admin"],
+            ...(realmJsonFilePath === undefined
+                ? []
+                : [
+                      "-v",
+                      `${realmJsonFilePath}:/opt/keycloak/data/import/myrealm-realm.json`
+                  ]),
+            ...["-v", `${jarFilePath}:/opt/keycloak/providers/keycloak-theme.jar`],
+            ...(keycloakMajorVersionNumber <= 20
+                ? ["-e", "JAVA_OPTS=-Dkeycloak.profile=preview"]
+                : []),
+            ...[
+                ...buildOptions.themeNames,
+                ...(doLinkAccountV1Theme ? [accountV1ThemeName] : [])
+            ]
+                .map(themeName => ({
+                    localDirPath: pathJoin(
+                        buildOptions.keycloakifyBuildDirPath,
+                        "src",
+                        "main",
+                        "resources",
+                        "theme",
+                        themeName
+                    ),
+                    containerDirPath: `/opt/keycloak/themes/${themeName}`
+                }))
+                .map(({ localDirPath, containerDirPath }) => [
+                    "-v",
+                    `${localDirPath}:${containerDirPath}:rw`
+                ])
+                .flat(),
+            `quay.io/keycloak/keycloak:${keycloakVersion}`,
+            "start-dev",
+            ...(21 <= keycloakMajorVersionNumber && keycloakMajorVersionNumber < 24
+                ? ["--features=declarative-user-profile"]
+                : []),
+            ...(realmJsonFilePath === undefined ? [] : ["--import-realm"])
+        ],
+        {
+            cwd: buildOptions.keycloakifyBuildDirPath
+        }
+    ] as const;
+
+    const child = child_process.spawn(...spawnArgs);
+
+    child.stdout.on("data", data => process.stdout.write(data));
+
+    child.stderr.on("data", data => process.stderr.write(data));
+
+    child.on("exit", process.exit);
+
+    const srcDirPath = pathJoin(buildOptions.reactAppRootDirPath, "src");
+
+    {
+        const handler = async (data: Buffer) => {
+            if (!data.toString("utf8").includes("Listening on: http://0.0.0.0:8080")) {
+                return;
+            }
+
+            child.stdout.off("data", handler);
+
+            await new Promise(resolve => setTimeout(resolve, 1_000));
+
+            console.log(
+                [
+                    "",
+                    `${chalk.green("Your theme is accessible at:")}`,
+                    `${chalk.green("➜")} ${chalk.cyan.bold(
+                        "https://my-theme.keycloakify.dev/"
+                    )}`,
+                    "",
+                    "You can login with the following credentials:",
+                    `- username: ${chalk.cyan.bold("testuser")}`,
+                    `- password: ${chalk.cyan.bold("password123")}`,
+                    "",
+                    `Keycloak Admin console: ${chalk.cyan.bold(
+                        `http://localhost:${cliCommandOptions.port}`
+                    )}`,
+                    `- user:     ${chalk.cyan.bold("admin")}`,
+                    `- password: ${chalk.cyan.bold("admin")}`,
+                    "",
+                    `Watching for changes in ${chalk.bold(
+                        `.${pathSep}${pathRelative(process.cwd(), srcDirPath)}`
+                    )}`
+                ].join("\n")
+            );
+        };
+
+        child.stdout.on("data", handler);
+    }
+
+    {
+        const runBuildKeycloakTheme = runExclusive.build(async () => {
+            console.log(chalk.cyan("Detected changes in the theme. Rebuilding ..."));
+
+            {
+                const dResult = new Deferred<{ isSuccess: boolean }>();
+
+                const child = child_process.spawn("npx", ["vite", "build"], {
+                    cwd: buildOptions.reactAppRootDirPath
+                });
+
+                child.stdout.on("data", data => {
+                    if (data.toString("utf8").includes("gzip:")) {
+                        return;
+                    }
+
+                    process.stdout.write(data);
+                });
+
+                child.stderr.on("data", data => process.stderr.write(data));
+
+                child.on("exit", code => dResult.resolve({ isSuccess: code === 0 }));
+
+                const { isSuccess } = await dResult.pr;
+
+                if (!isSuccess) {
+                    return;
+                }
+            }
+
+            {
+                const dResult = new Deferred<{ isSuccess: boolean }>();
+
+                const child = child_process.spawn("npx", ["keycloakify", "build"], {
+                    cwd: buildOptions.reactAppRootDirPath,
+                    env: {
+                        ...process.env,
+                        [skipBuildJarsEnvName]: "true"
+                    }
+                });
+
+                child.stdout.on("data", data => process.stdout.write(data));
+
+                child.stderr.on("data", data => process.stderr.write(data));
+
+                child.on("exit", code => {
+                    if (code !== 0) {
+                        console.log(chalk.yellow("Theme not updated, build failed"));
+                        return;
+                    }
+
+                    console.log(chalk.green("Rebuild done"));
+                });
+
+                child.on("exit", code => dResult.resolve({ isSuccess: code === 0 }));
+
+                const { isSuccess } = await dResult.pr;
+
+                if (!isSuccess) {
+                    return;
+                }
+            }
+        });
+
+        const { waitForDebounce } = waitForDebounceFactory({ delay: 400 });
+
+        chokidar
+            .watch([srcDirPath, pathJoin(getThisCodebaseRootDirPath(), "src")], {
+                ignoreInitial: true
+            })
+            .on("all", async () => {
+                await waitForDebounce();
+
+                runBuildKeycloakTheme();
+            });
+    }
+}

package/src/bin/tools/SemVer.ts

@@ -12,35 +12,39 @@ export namespace SemVer {
     export type BumpType = (typeof bumpTypes)[number];
 
     export function parse(versionStr: string): SemVer {
-        const match = versionStr.match(/^v?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-rc.([0-9]+))?$/);
+        const match = versionStr.match(
+            /^v?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-rc.([0-9]+))?$/
+        );
 
         if (!match) {
             throw new Error(`${versionStr} is not a valid semantic version`);
         }
 
         const semVer: Omit<SemVer, "parsedFrom"> = {
-            "major": parseInt(match[1]),
-            "minor": parseInt(match[2]),
-            "patch": (() => {
+            major: parseInt(match[1]),
+            minor: parseInt(match[2]),
+            patch: (() => {
                 const str = match[3];
 
                 return str === undefined ? 0 : parseInt(str);
             })(),
             ...(() => {
                 const str = match[4];
-                return str === undefined ? {} : { "rc": parseInt(str) };
+                return str === undefined ? {} : { rc: parseInt(str) };
             })()
         };
 
         const initialStr = stringify(semVer);
 
         Object.defineProperty(semVer, "parsedFrom", {
-            "enumerable": true,
-            "get": function () {
+            enumerable: true,
+            get: function () {
                 const currentStr = stringify(this);
 
                 if (currentStr !== initialStr) {
-                    throw new Error(`SemVer.parsedFrom can't be read anymore, the version have been modified from ${initialStr} to ${currentStr}`);
+                    throw new Error(
+                        `SemVer.parsedFrom can't be read anymore, the version have been modified from ${initialStr} to ${currentStr}`
+                    );
                 }
 
                 return versionStr;
@@ -51,7 +55,9 @@ export namespace SemVer {
     }
 
     export function stringify(v: Omit<SemVer, "parsedFrom">): string {
-        return `${v.major}.${v.minor}.${v.patch}${v.rc === undefined ? "" : `-rc.${v.rc}`}`;
+        return `${v.major}.${v.minor}.${v.patch}${
+            v.rc === undefined ? "" : `-rc.${v.rc}`
+        }`;
     }
 
     /**
@@ -80,12 +86,25 @@ export namespace SemVer {
     console.log(compare(parse("3.0.0-rc.3"), parse("4.0.0")) === -1 )
     */
 
-    export function bumpType(params: { versionBehind: string | SemVer; versionAhead: string | SemVer }): BumpType | "no bump" {
-        const versionAhead = typeof params.versionAhead === "string" ? parse(params.versionAhead) : params.versionAhead;
-        const versionBehind = typeof params.versionBehind === "string" ? parse(params.versionBehind) : params.versionBehind;
+    export function bumpType(params: {
+        versionBehind: string | SemVer;
+        versionAhead: string | SemVer;
+    }): BumpType | "no bump" {
+        const versionAhead =
+            typeof params.versionAhead === "string"
+                ? parse(params.versionAhead)
+                : params.versionAhead;
+        const versionBehind =
+            typeof params.versionBehind === "string"
+                ? parse(params.versionBehind)
+                : params.versionBehind;
 
         if (compare(versionBehind, versionAhead) === 1) {
-            throw new Error(`Version regression ${stringify(versionBehind)} -> ${stringify(versionAhead)}`);
+            throw new Error(
+                `Version regression ${stringify(versionBehind)} -> ${stringify(
+                    versionAhead
+                )}`
+            );
         }
 
         for (const level of ["major", "minor", "patch", "rc"] as const) {

package/src/bin/tools/String.prototype.replaceAll.ts

@@ -1,4 +1,8 @@
-export function replaceAll(string: string, searchValue: string | RegExp, replaceValue: string): string {
+export function replaceAll(
+    string: string,
+    searchValue: string | RegExp,
+    replaceValue: string
+): string {
     if ((string as any).replaceAll !== undefined) {
         return (string as any).replaceAll(searchValue, replaceValue);
     }
@@ -24,7 +28,10 @@ export function replaceAll(string: string, searchValue: string | RegExp, replace
 
     // Convert searchValue to string if it's not a string or RegExp
     var searchString = String(searchValue);
-    var regexFromString = new RegExp(searchString.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g");
+    var regexFromString = new RegExp(
+        searchString.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"),
+        "g"
+    );
 
     return string.replace(regexFromString, replaceValue);
 }

package/src/bin/tools/crawl.ts

@@ -16,7 +16,10 @@ const crawlRec = (dirPath: string, filePaths: string[]) => {
 };
 
 /** List all files in a given directory return paths relative to the dir_path */
-export function crawl(params: { dirPath: string; returnedPathsType: "absolute" | "relative to dirPath" }): string[] {
+export function crawl(params: {
+    dirPath: string;
+    returnedPathsType: "absolute" | "relative to dirPath";
+}): string[] {
     const { dirPath, returnedPathsType } = params;
 
     const filePaths: string[] = [];