keycloakify 10.0.0-rc.17 → 10.0.0-rc.19

package/src/bin/shared/downloadAndUnzip.ts

@@ -1,203 +0,0 @@
-import { createHash } from "crypto";
-import { mkdir, writeFile, unlink } from "fs/promises";
-import fetch from "make-fetch-happen";
-import { dirname as pathDirname, join as pathJoin, basename as pathBasename } from "path";
-import { assert } from "tsafe/assert";
-import { transformCodebase } from "../tools/transformCodebase";
-import { unzip, zip } from "../tools/unzip";
-import { rm } from "../tools/fs.rm";
-import * as child_process from "child_process";
-import { existsAsync } from "../tools/fs.existsAsync";
-import type { BuildOptions } from "./buildOptions";
-import { getProxyFetchOptions } from "../tools/fetchProxyOptions";
-
-export type BuildOptionsLike = {
-    cacheDirPath: string;
-    npmWorkspaceRootDirPath: string;
-};
-
-assert<BuildOptions extends BuildOptionsLike ? true : false>();
-
-export async function downloadAndUnzip(params: {
-    url: string;
-    destDirPath: string;
-    specificDirsToExtract?: string[];
-    preCacheTransform?: {
-        actionCacheId: string;
-        action: (params: { destDirPath: string }) => Promise<void>;
-    };
-    buildOptions: BuildOptionsLike;
-}) {
-    const { url, destDirPath, specificDirsToExtract, preCacheTransform, buildOptions } = params;
-
-    const { extractDirPath, zipFilePath } = (() => {
-        const zipFileBasenameWithoutExt = generateFileNameFromURL({
-            url,
-            "preCacheTransform":
-                preCacheTransform === undefined
-                    ? undefined
-                    : {
-                          "actionCacheId": preCacheTransform.actionCacheId,
-                          "actionFootprint": preCacheTransform.action.toString()
-                      }
-        });
-
-        const zipFilePath = pathJoin(buildOptions.cacheDirPath, `${zipFileBasenameWithoutExt}.zip`);
-        const extractDirPath = pathJoin(buildOptions.cacheDirPath, `tmp_unzip_${zipFileBasenameWithoutExt}`);
-
-        return { zipFilePath, extractDirPath };
-    })();
-
-    download_zip_and_transform: {
-        if (await existsAsync(zipFilePath)) {
-            break download_zip_and_transform;
-        }
-
-        const { response, isFromRemoteCache } = await (async () => {
-            const proxyFetchOptions = await getProxyFetchOptions({
-                "npmWorkspaceRootDirPath": buildOptions.npmWorkspaceRootDirPath
-            });
-
-            const response = await fetch(
-                `https://github.com/keycloakify/keycloakify/releases/download/v0.0.1/${pathBasename(zipFilePath)}`,
-                proxyFetchOptions
-            );
-
-            if (response.status === 200) {
-                return {
-                    response,
-                    "isFromRemoteCache": true
-                };
-            }
-
-            return {
-                "response": await fetch(url, proxyFetchOptions),
-                "isFromRemoteCache": false
-            };
-        })();
-
-        await mkdir(pathDirname(zipFilePath), { "recursive": true });
-
-        /**
-         * The correct way to fix this is to upgrade node-fetch beyond 3.2.5
-         * (see https://github.com/node-fetch/node-fetch/issues/1295#issuecomment-1144061991.)
-         * Unfortunately, octokit (a dependency of keycloakify) also uses node-fetch, and
-         * does not support node-fetch 3.x. So we stick around with this band-aid until
-         * octokit upgrades.
-         */
-        response.body?.setMaxListeners(Number.MAX_VALUE);
-        assert(typeof response.body !== "undefined" && response.body != null);
-
-        await writeFile(zipFilePath, response.body);
-
-        if (isFromRemoteCache) {
-            break download_zip_and_transform;
-        }
-
-        if (specificDirsToExtract === undefined && preCacheTransform === undefined) {
-            break download_zip_and_transform;
-        }
-
-        await unzip(zipFilePath, extractDirPath, specificDirsToExtract);
-
-        try {
-            await preCacheTransform?.action({
-                "destDirPath": extractDirPath
-            });
-        } catch (error) {
-            await Promise.all([rm(extractDirPath, { "recursive": true }), unlink(zipFilePath)]);
-
-            throw error;
-        }
-
-        await unlink(zipFilePath);
-
-        await zip(extractDirPath, zipFilePath);
-
-        await rm(extractDirPath, { "recursive": true });
-
-        upload_to_remote_cache_if_admin: {
-            const githubToken = process.env["KEYCLOAKIFY_ADMIN_GITHUB_PERSONAL_ACCESS_TOKEN"];
-
-            if (!githubToken) {
-                break upload_to_remote_cache_if_admin;
-            }
-
-            console.log("uploading to remote cache");
-
-            try {
-                child_process.execSync(`which putasset`);
-            } catch {
-                child_process.execSync(`npm install -g putasset`);
-            }
-
-            try {
-                child_process.execFileSync("putasset", [
-                    "--owner",
-                    "keycloakify",
-                    "--repo",
-                    "keycloakify",
-                    "--tag",
-                    "v0.0.1",
-                    "--filename",
-                    zipFilePath,
-                    "--token",
-                    githubToken
-                ]);
-            } catch {
-                console.log("upload failed, asset probably already exists in remote cache");
-            }
-        }
-    }
-
-    await unzip(zipFilePath, extractDirPath);
-
-    transformCodebase({
-        "srcDirPath": extractDirPath,
-        "destDirPath": destDirPath
-    });
-
-    await rm(extractDirPath, { "recursive": true });
-}
-
-function generateFileNameFromURL(params: {
-    url: string;
-    preCacheTransform:
-        | {
-              actionCacheId: string;
-              actionFootprint: string;
-          }
-        | undefined;
-}): string {
-    const { preCacheTransform } = params;
-
-    // Parse the URL
-    const url = new URL(params.url);
-
-    // Extract pathname and remove leading slashes
-    let fileName = url.pathname.replace(/^\//, "").replace(/\//g, "_");
-
-    // Optionally, add query parameters replacing special characters
-    if (url.search) {
-        fileName += url.search.replace(/[&=?]/g, "-");
-    }
-
-    // Replace any characters that are not valid in filenames
-    fileName = fileName.replace(/[^a-zA-Z0-9-_]/g, "");
-
-    // Trim or pad the fileName to a specific length
-    fileName = fileName.substring(0, 50);
-
-    add_pre_cache_transform: {
-        if (preCacheTransform === undefined) {
-            break add_pre_cache_transform;
-        }
-
-        // Sanitize actionCacheId the same way as other components
-        const sanitizedActionCacheId = preCacheTransform.actionCacheId.replace(/[^a-zA-Z0-9-_]/g, "_");
-
-        fileName += `_${sanitizedActionCacheId}_${createHash("sha256").update(preCacheTransform.actionFootprint).digest("hex").substring(0, 5)}`;
-    }
-
-    return fileName;
-}

package/src/bin/start-keycloak.ts

@@ -1,309 +0,0 @@
-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 } 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, posix as pathPosix } from "path";
-import * as child_process from "child_process";
-import chalk from "chalk";
-import chokidar from "chokidar";
-import { waitForDebounceFactory } from "powerhooks/tools/waitForDebounce";
-import { getThemeSrcDirPath } from "./shared/getThemeSrcDirPath";
-import { Deferred } from "evt/tools/Deferred";
-
-export type CliCommandOptions = CliCommandOptions_common & {
-    port: number;
-    keycloakVersion: 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 } = 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 (keycloakMajorNumber <= 21) {
-                    return "21-and-below" as const;
-                }
-
-                assert(keycloakMajorNumber !== 22);
-
-                if (keycloakMajorNumber === 23) {
-                    return "23" as const;
-                }
-
-                return "24-and-above" as const;
-            })();
-
-            assert<Equals<typeof keycloakVersionRange, KeycloakVersionRange.WithAccountTheme>>();
-
-            return keycloakVersionRange;
-        } else {
-            const keycloakVersionRange = (() => {
-                if (keycloakMajorNumber <= 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)}`);
-
-    const mountTargets = buildOptions.themeNames
-        .map(themeName => {
-            const themeEntry = metaInfKeycloakThemes.themes.find(({ name }) => name === themeName);
-
-            assert(themeEntry !== undefined);
-
-            return themeEntry.types
-                .map(themeType => {
-                    const localPathDirname = pathJoin(
-                        buildOptions.keycloakifyBuildDirPath,
-                        "src",
-                        "main",
-                        "resources",
-                        "theme",
-                        themeName,
-                        themeType
-                    );
-
-                    return fs
-                        .readdirSync(localPathDirname)
-                        .filter(fileOrDirectoryBasename => !fileOrDirectoryBasename.endsWith(".properties"))
-                        .map(fileOrDirectoryBasename => ({
-                            "localPath": pathJoin(localPathDirname, fileOrDirectoryBasename),
-                            "containerPath": pathPosix.join("/", "opt", "keycloak", "themes", themeName, themeType, fileOrDirectoryBasename)
-                        }));
-                })
-                .flat();
-        })
-        .flat();
-
-    const containerName = "keycloak-keycloakify";
-
-    try {
-        child_process.execSync(`docker rm --force ${containerName}`, { "stdio": "ignore" });
-    } catch {}
-
-    const spawnParams = [
-        "docker",
-        [
-            "run",
-            ...["-p", `${cliCommandOptions.port}:8080`],
-            ...["--name", containerName],
-            ...["-e", "KEYCLOAK_ADMIN=admin"],
-            ...["-e", "KEYCLOAK_ADMIN_PASSWORD=admin"],
-            ...["-v", `${pathJoin(buildOptions.keycloakifyBuildDirPath, jarFileBasename)}:/opt/keycloak/providers/keycloak-theme.jar`],
-            ...(keycloakMajorNumber <= 20 ? ["-e", "JAVA_OPTS=-Dkeycloak.profile=preview"] : []),
-            ...mountTargets.map(({ localPath, containerPath }) => ["-v", `${localPath}:${containerPath}:rw`]).flat(),
-            `quay.io/keycloak/keycloak:${keycloakVersion}`,
-            "start-dev",
-            ...(21 <= keycloakMajorNumber && keycloakMajorNumber < 24 ? ["--features=declarative-user-profile"] : [])
-        ],
-        {
-            "cwd": buildOptions.keycloakifyBuildDirPath
-        }
-    ] as const;
-
-    const child = child_process.spawn(...spawnParams);
-
-    child.stdout.on("data", data => process.stdout.write(data));
-
-    child.stderr.on("data", data => process.stderr.write(data));
-
-    child.on("exit", process.exit);
-
-    const { themeSrcDirPath } = getThemeSrcDirPath({ "reactAppRootDirPath": buildOptions.reactAppRootDirPath });
-
-    {
-        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://test.keycloakify.dev/")}`,
-                    "",
-                    `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(), themeSrcDirPath)}`)} ...`
-                ].join("\n")
-            );
-        };
-
-        child.stdout.on("data", handler);
-    }
-
-    {
-        const { waitForDebounce } = waitForDebounceFactory({ "delay": 400 });
-
-        chokidar.watch(themeSrcDirPath, { "ignoreInitial": true }).on("all", async (...eventArgs) => {
-            console.log({ eventArgs });
-
-            await waitForDebounce();
-
-            console.log(chalk.cyan("Detected changes in the theme. Rebuilding ..."));
-
-            const dViteBuildDone = new Deferred<void>();
-
-            {
-                const child = child_process.spawn("npx", ["vite", "build"], {
-                    "cwd": buildOptions.reactAppRootDirPath,
-                    "env": process.env
-                });
-
-                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) {
-                        dViteBuildDone.resolve();
-                    }
-                });
-            }
-
-            await dViteBuildDone.pr;
-
-            {
-                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"));
-                });
-            }
-        });
-    }
-}

package/src/bin/tools/unzip.ts

@@ -1,141 +0,0 @@
-import fsp from "node:fs/promises";
-import fs from "fs";
-import path from "node:path";
-import yauzl from "yauzl";
-import yazl from "yazl";
-import stream from "node:stream";
-import { promisify } from "node:util";
-
-const pipeline = promisify(stream.pipeline);
-
-async function pathExists(path: string) {
-    try {
-        await fsp.stat(path);
-        return true;
-    } catch (error) {
-        if ((error as { code: string }).code === "ENOENT") {
-            return false;
-        }
-        throw error;
-    }
-}
-
-// Handlings of non posix path is not implemented correctly
-// it work by coincidence. Don't have the time to fix but it should be fixed.
-export async function unzip(file: string, targetFolder: string, specificDirsToExtract?: string[]) {
-    specificDirsToExtract = specificDirsToExtract?.map(dirPath => {
-        if (!dirPath.endsWith("/") || !dirPath.endsWith("\\")) {
-            dirPath += "/";
-        }
-
-        return dirPath;
-    });
-
-    if (!targetFolder.endsWith("/") || !targetFolder.endsWith("\\")) {
-        targetFolder += "/";
-    }
-    if (!fs.existsSync(targetFolder)) {
-        fs.mkdirSync(targetFolder, { recursive: true });
-    }
-
-    return new Promise<void>((resolve, reject) => {
-        yauzl.open(file, { lazyEntries: true }, async (err, zipfile) => {
-            if (err) {
-                reject(err);
-                return;
-            }
-
-            zipfile.readEntry();
-
-            zipfile.on("entry", async entry => {
-                if (specificDirsToExtract !== undefined) {
-                    const dirPath = specificDirsToExtract.find(dirPath => entry.fileName.startsWith(dirPath));
-
-                    // Skip files outside of the unzipSubPath
-                    if (dirPath === undefined) {
-                        zipfile.readEntry();
-                        return;
-                    }
-
-                    // Remove the unzipSubPath from the file name
-                    entry.fileName = entry.fileName.substring(dirPath.length);
-                }
-
-                const target = path.join(targetFolder, entry.fileName);
-
-                // Directory file names end with '/'.
-                // Note that entries for directories themselves are optional.
-                // An entry's fileName implicitly requires its parent directories to exist.
-                if (/[\/\\]$/.test(target)) {
-                    await fsp.mkdir(target, { recursive: true });
-
-                    zipfile.readEntry();
-                    return;
-                }
-
-                // Skip existing files
-                if (await pathExists(target)) {
-                    zipfile.readEntry();
-                    return;
-                }
-
-                zipfile.openReadStream(entry, async (err, readStream) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-
-                    await fsp.mkdir(path.dirname(target), { "recursive": true });
-
-                    await pipeline(readStream, fs.createWriteStream(target));
-
-                    zipfile.readEntry();
-                });
-            });
-
-            zipfile.once("end", function () {
-                zipfile.close();
-                resolve();
-            });
-        });
-    });
-}
-
-// NOTE: This code was directly copied from ChatGPT and appears to function as expected.
-// However, confidence in its complete accuracy and robustness is limited.
-export async function zip(sourceFolder: string, targetZip: string) {
-    return new Promise<void>(async (resolve, reject) => {
-        const zipfile = new yazl.ZipFile();
-        const files: string[] = [];
-
-        // Recursive function to explore directories and their subdirectories
-        async function exploreDir(dir: string) {
-            const dirContent = await fsp.readdir(dir);
-            for (const file of dirContent) {
-                const filePath = path.join(dir, file);
-                const stat = await fsp.stat(filePath);
-                if (stat.isDirectory()) {
-                    await exploreDir(filePath);
-                } else if (stat.isFile()) {
-                    files.push(filePath);
-                }
-            }
-        }
-
-        // Collecting all files to be zipped
-        await exploreDir(sourceFolder);
-
-        // Adding files to zip
-        for (const file of files) {
-            const relativePath = path.relative(sourceFolder, file);
-            zipfile.addFile(file, relativePath);
-        }
-
-        zipfile.outputStream
-            .pipe(fs.createWriteStream(targetZip))
-            .on("close", () => resolve())
-            .on("error", err => reject(err)); // Listen to error events
-
-        zipfile.end();
-    });
-}