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

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

@@ -0,0 +1,523 @@
+import { getBuildContext } from "../shared/buildContext";
+import { exclude } from "tsafe/exclude";
+import type { CliCommandOptions as CliCommandOptions_common } from "../main";
+import { promptKeycloakVersion } from "../shared/promptKeycloakVersion";
+import { ACCOUNT_V1_THEME_NAME, CONTAINER_NAME } from "../shared/constants";
+import { SemVer } from "../tools/SemVer";
+import { assert, type Equals } from "tsafe/assert";
+import * as fs from "fs";
+import {
+    join as pathJoin,
+    relative as pathRelative,
+    sep as pathSep,
+    basename as pathBasename
+} 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 { getAbsoluteAndInOsFormatPath } from "../tools/getAbsoluteAndInOsFormatPath";
+import cliSelect from "cli-select";
+import * as runExclusive from "run-exclusive";
+import { extractArchive } from "../tools/extractArchive";
+import { appBuild } from "./appBuild";
+import { keycloakifyBuild } from "./keycloakifyBuild";
+import { isInside } from "../tools/isInside";
+import { existsAsync } from "../tools/fs.existsAsync";
+import { rm } from "../tools/fs.rm";
+import { downloadAndExtractArchive } from "../tools/downloadAndExtractArchive";
+
+export type CliCommandOptions = CliCommandOptions_common & {
+    port: number | undefined;
+    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 buildContext = getBuildContext({ cliCommandOptions });
+
+    const { dockerImageTag } = await (async () => {
+        if (cliCommandOptions.keycloakVersion !== undefined) {
+            return { dockerImageTag: cliCommandOptions.keycloakVersion };
+        }
+
+        if (buildContext.startKeycloakOptions.dockerImage !== undefined) {
+            return {
+                dockerImageTag: buildContext.startKeycloakOptions.dockerImage.tag
+            };
+        }
+
+        console.log(
+            [
+                chalk.cyan(
+                    "On which version of Keycloak do you want to test your theme?"
+                ),
+                chalk.gray(
+                    "You can also explicitly provide the version with `npx keycloakify start-keycloak --keycloak-version 25.0.2` (or any other version)"
+                )
+            ].join("\n")
+        );
+
+        const { keycloakVersion } = await promptKeycloakVersion({
+            startingFromMajor: 18,
+            excludeMajorVersions: [22],
+            buildContext
+        });
+
+        console.log(`→ ${keycloakVersion}`);
+
+        return { dockerImageTag: keycloakVersion };
+    })();
+
+    const keycloakMajorVersionNumber = (() => {
+        if (buildContext.startKeycloakOptions.dockerImage === undefined) {
+            return SemVer.parse(dockerImageTag).major;
+        }
+
+        const { tag } = buildContext.startKeycloakOptions.dockerImage;
+
+        const [wrap] = [18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28]
+            .map(majorVersionNumber => ({
+                majorVersionNumber,
+                index: tag.indexOf(`${majorVersionNumber}`)
+            }))
+            .filter(({ index }) => index !== -1)
+            .sort((a, b) => a.index - b.index);
+
+        if (wrap === undefined) {
+            console.warn(
+                chalk.yellow(
+                    `Could not determine the major Keycloak version number from the docker image tag ${tag}. Assuming 25`
+                )
+            );
+            return 25;
+        }
+
+        return wrap.majorVersionNumber;
+    })();
+
+    {
+        const { isAppBuildSuccess } = await appBuild({
+            buildContext
+        });
+
+        if (!isAppBuildSuccess) {
+            console.log(
+                chalk.red(
+                    `App build failed, exiting. Try building your app (e.g 'npm run build') and see what's wrong.`
+                )
+            );
+            process.exit(1);
+        }
+
+        const { isKeycloakifyBuildSuccess } = await keycloakifyBuild({
+            buildForKeycloakMajorVersionNumber: keycloakMajorVersionNumber,
+            buildContext
+        });
+
+        if (!isKeycloakifyBuildSuccess) {
+            console.log(
+                chalk.red(
+                    `Keycloakify build failed, exiting. Try running 'npx keycloakify build' and see what's wrong.`
+                )
+            );
+            process.exit(1);
+        }
+    }
+
+    const jarFilePath = 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(jarFilePath !== undefined);
+
+    const extensionJarFilePaths = await Promise.all(
+        buildContext.startKeycloakOptions.extensionJars.map(async extensionJar => {
+            switch (extensionJar.type) {
+                case "path": {
+                    assert(
+                        await existsAsync(extensionJar.path),
+                        `${extensionJar.path} does not exist`
+                    );
+                    return extensionJar.path;
+                }
+                case "url": {
+                    const { archiveFilePath } = await downloadAndExtractArchive({
+                        cacheDirPath: buildContext.cacheDirPath,
+                        fetchOptions: buildContext.fetchOptions,
+                        urlOrPath: extensionJar.url,
+                        uniqueIdOfOnArchiveFile: "no extraction",
+                        onArchiveFile: async () => {}
+                    });
+                    return archiveFilePath;
+                }
+            }
+            assert<Equals<typeof extensionJar, never>>(false);
+        })
+    );
+
+    const realmJsonFilePath = await (async () => {
+        if (cliCommandOptions.realmJsonFilePath !== undefined) {
+            if (cliCommandOptions.realmJsonFilePath === "none") {
+                return undefined;
+            }
+            return getAbsoluteAndInOsFormatPath({
+                pathIsh: cliCommandOptions.realmJsonFilePath,
+                cwd: process.cwd()
+            });
+        }
+
+        if (buildContext.startKeycloakOptions.realmJsonFilePath !== undefined) {
+            assert(
+                await existsAsync(buildContext.startKeycloakOptions.realmJsonFilePath),
+                `${pathRelative(process.cwd(), buildContext.startKeycloakOptions.realmJsonFilePath)} does not exist`
+            );
+            return buildContext.startKeycloakOptions.realmJsonFilePath;
+        }
+
+        const internalFilePath = await (async () => {
+            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);
+        })();
+
+        if (internalFilePath === undefined) {
+            return undefined;
+        }
+
+        const filePath = pathJoin(
+            buildContext.cacheDirPath,
+            pathBasename(internalFilePath)
+        );
+
+        fs.writeFileSync(
+            filePath,
+            Buffer.from(
+                fs
+                    .readFileSync(internalFilePath)
+                    .toString("utf8")
+                    .replace(/keycloakify\-starter/g, buildContext.themeNames[0])
+            ),
+            "utf8"
+        );
+
+        return filePath;
+    })();
+
+    async function extractThemeResourcesFromJar() {
+        await extractArchive({
+            archiveFilePath: jarFilePath,
+            onArchiveFile: async ({ relativeFilePathInArchive, writeFile }) => {
+                if (isInside({ dirPath: "theme", filePath: relativeFilePathInArchive })) {
+                    await writeFile({
+                        filePath: pathJoin(
+                            buildContext.keycloakifyBuildDirPath,
+                            relativeFilePathInArchive
+                        )
+                    });
+                }
+            }
+        });
+    }
+
+    {
+        const destDirPath = pathJoin(buildContext.keycloakifyBuildDirPath, "theme");
+        if (await existsAsync(destDirPath)) {
+            await rm(destDirPath, { recursive: true });
+        }
+    }
+
+    await extractThemeResourcesFromJar();
+
+    const jarFilePath_cacheDir = pathJoin(
+        buildContext.cacheDirPath,
+        pathBasename(jarFilePath)
+    );
+
+    fs.copyFileSync(jarFilePath, jarFilePath_cacheDir);
+
+    try {
+        child_process.execSync(`docker rm --force ${CONTAINER_NAME}`, {
+            stdio: "ignore"
+        });
+    } catch {}
+
+    const SPACE_PLACEHOLDER = "SPACE_PLACEHOLDER_xKLmdPd";
+
+    const dockerRunArgs: string[] = [
+        `-p${SPACE_PLACEHOLDER}${cliCommandOptions.port ?? buildContext.startKeycloakOptions.port ?? 8080}:8080`,
+        `--name${SPACE_PLACEHOLDER}${CONTAINER_NAME}`,
+        `-e${SPACE_PLACEHOLDER}KEYCLOAK_ADMIN=admin`,
+        `-e${SPACE_PLACEHOLDER}KEYCLOAK_ADMIN_PASSWORD=admin`,
+        ...(realmJsonFilePath === undefined
+            ? []
+            : [
+                  `-v${SPACE_PLACEHOLDER}".${pathSep}${pathRelative(process.cwd(), realmJsonFilePath)}":/opt/keycloak/data/import/myrealm-realm.json`
+              ]),
+        `-v${SPACE_PLACEHOLDER}"./${pathRelative(process.cwd(), jarFilePath_cacheDir)}":/opt/keycloak/providers/keycloak-theme.jar`,
+        ...extensionJarFilePaths.map(
+            jarFilePath =>
+                `-v${SPACE_PLACEHOLDER}".${pathSep}${pathRelative(process.cwd(), jarFilePath)}":/opt/keycloak/providers/${pathBasename(jarFilePath)}`
+        ),
+        ...(keycloakMajorVersionNumber <= 20
+            ? [`-e${SPACE_PLACEHOLDER}JAVA_OPTS=-Dkeycloak.profile=preview`]
+            : []),
+        ...[
+            ...buildContext.themeNames,
+            ...(fs.existsSync(
+                pathJoin(
+                    buildContext.keycloakifyBuildDirPath,
+                    "theme",
+                    ACCOUNT_V1_THEME_NAME
+                )
+            )
+                ? [ACCOUNT_V1_THEME_NAME]
+                : [])
+        ]
+            .map(themeName => ({
+                localDirPath: pathJoin(
+                    buildContext.keycloakifyBuildDirPath,
+                    "theme",
+                    themeName
+                ),
+                containerDirPath: `/opt/keycloak/themes/${themeName}`
+            }))
+            .map(
+                ({ localDirPath, containerDirPath }) =>
+                    `-v${SPACE_PLACEHOLDER}".${pathSep}${pathRelative(process.cwd(), localDirPath)}":${containerDirPath}:rw`
+            ),
+        ...buildContext.environmentVariables
+            .map(({ name }) => ({ name, envValue: process.env[name] }))
+            .map(({ name, envValue }) =>
+                envValue === undefined ? undefined : { name, envValue }
+            )
+            .filter(exclude(undefined))
+            .map(
+                ({ name, envValue }) =>
+                    `--env${SPACE_PLACEHOLDER}${name}='${envValue.replace(/'/g, "'\\''")}'`
+            ),
+        ...buildContext.startKeycloakOptions.dockerExtraArgs.join(SPACE_PLACEHOLDER),
+        `${buildContext.startKeycloakOptions.dockerImage?.reference ?? "quay.io/keycloak/keycloak"}:${dockerImageTag}`,
+        "start-dev",
+        ...(21 <= keycloakMajorVersionNumber && keycloakMajorVersionNumber < 24
+            ? ["--features=declarative-user-profile"]
+            : []),
+        ...(realmJsonFilePath === undefined ? [] : ["--import-realm"]),
+        ...buildContext.startKeycloakOptions.keycloakExtraArgs.join(SPACE_PLACEHOLDER)
+    ];
+
+    console.log(
+        chalk.blue(
+            [
+                `$ docker run \\`,
+                ...dockerRunArgs
+                    .map(arg => arg.replace(new RegExp(SPACE_PLACEHOLDER, "g"), " "))
+                    .map(
+                        (line, i, arr) =>
+                            `    ${line}${arr.length - 1 === i ? "" : " \\"}`
+                    )
+            ].join("\n")
+        )
+    );
+
+    const child = child_process.spawn(
+        "docker",
+        ["run", ...dockerRunArgs.map(line => line.split(SPACE_PLACEHOLDER)).flat()],
+        { shell: true }
+    );
+
+    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(buildContext.projectDirPath, "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(
+                [
+                    "",
+                    `The ftl files from ${chalk.bold(
+                        `.${pathSep}${pathRelative(process.cwd(), pathJoin(buildContext.keycloakifyBuildDirPath, "theme"))}`
+                    )} are mounted in the Keycloak container.`,
+                    "",
+                    `Keycloak Admin console: ${chalk.cyan.bold(
+                        `http://localhost:${cliCommandOptions.port}`
+                    )}`,
+                    `- user:     ${chalk.cyan.bold("admin")}`,
+                    `- password: ${chalk.cyan.bold("admin")}`,
+                    "",
+                    "",
+                    `${chalk.green("Your theme is accessible at:")}`,
+                    `${chalk.green("➜")} ${chalk.cyan.bold(
+                        `https://my-theme.keycloakify.dev${cliCommandOptions.port === 8080 ? "" : `?port=${cliCommandOptions.port}`}`
+                    )}`,
+                    "",
+                    "You can login with the following credentials:",
+                    `- username: ${chalk.cyan.bold("testuser")}`,
+                    `- password: ${chalk.cyan.bold("password123")}`,
+                    "",
+                    `Watching for changes in ${chalk.bold(
+                        `.${pathSep}${pathRelative(process.cwd(), buildContext.projectDirPath)}`
+                    )}`
+                ].join("\n")
+            );
+        };
+
+        child.stdout.on("data", handler);
+    }
+
+    {
+        const runFullBuild = runExclusive.build(async () => {
+            console.log(chalk.cyan("Detected changes in the theme. Rebuilding ..."));
+
+            const { isAppBuildSuccess } = await appBuild({
+                buildContext
+            });
+
+            if (!isAppBuildSuccess) {
+                return;
+            }
+
+            const { isKeycloakifyBuildSuccess } = await keycloakifyBuild({
+                buildForKeycloakMajorVersionNumber: keycloakMajorVersionNumber,
+                buildContext
+            });
+
+            if (!isKeycloakifyBuildSuccess) {
+                return;
+            }
+
+            await extractThemeResourcesFromJar();
+
+            console.log(chalk.green("Theme rebuilt and updated in Keycloak."));
+        });
+
+        const { waitForDebounce } = waitForDebounceFactory({ delay: 400 });
+
+        chokidar
+            .watch(
+                [
+                    srcDirPath,
+                    buildContext.publicDirPath,
+                    pathJoin(buildContext.projectDirPath, "package.json"),
+                    pathJoin(buildContext.projectDirPath, "vite.config.ts"),
+                    pathJoin(buildContext.projectDirPath, "vite.config.js"),
+                    pathJoin(buildContext.projectDirPath, "index.html"),
+                    pathJoin(getThisCodebaseRootDirPath(), "src")
+                ],
+                {
+                    ignoreInitial: true
+                }
+            )
+            .on("all", async (...[, filePath]) => {
+                console.log(`Detected changes in ${filePath}`);
+
+                await waitForDebounce();
+
+                runFullBuild();
+            });
+    }
+}

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/assertNoPnpmDlx.ts

@@ -0,0 +1,17 @@
+import { sep as pathSep } from "path";
+import chalk from "chalk";
+
+export function assertNoPnpmDlx() {
+    if (__dirname.includes(`${pathSep}pnpm${pathSep}dlx${pathSep}`)) {
+        console.log(
+            [
+                chalk.red(
+                    "Please don't use `pnpm dlx keycloakify` (download and execute)"
+                ),
+                "\nUse `npx keycloakify` or `pnpm exec keycloakify` instead since you want to use the keycloakify",
+                "version that is installed in your project and not download and run the latest NPM version of keycloakify."
+            ].join(" ")
+        );
+        process.exit(1);
+    }
+}

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[] = [];