keycloakify 10.0.0-rc.4 → 10.0.0-rc.41

package/src/bin/keycloakify/generateTheme/generateSrcMainResources.ts

@@ -1,267 +0,0 @@
-import { transformCodebase } from "../../tools/transformCodebase";
-import * as fs from "fs";
-import { join as pathJoin, resolve as pathResolve, dirname as pathDirname } from "path";
-import { replaceImportsInJsCode } from "../replacers/replaceImportsInJsCode";
-import { replaceImportsInCssCode } from "../replacers/replaceImportsInCssCode";
-import { generateFtlFilesCodeFactory, loginThemePageIds, accountThemePageIds } from "../generateFtl";
-import {
-    type ThemeType,
-    lastKeycloakVersionWithAccountV1,
-    keycloak_resources,
-    accountV1ThemeName,
-    basenameOfTheKeycloakifyResourcesDir
-} from "../../constants";
-import { isInside } from "../../tools/isInside";
-import type { BuildOptions } from "../buildOptions";
-import { assert, type Equals } from "tsafe/assert";
-import { downloadKeycloakStaticResources } from "./downloadKeycloakStaticResources";
-import { readFieldNameUsage } from "./readFieldNameUsage";
-import { readExtraPagesNames } from "./readExtraPageNames";
-import { generateMessageProperties } from "./generateMessageProperties";
-import { bringInAccountV1 } from "./bringInAccountV1";
-import { rmSync } from "../../tools/fs.rmSync";
-
-export type BuildOptionsLike = {
-    bundler: "vite" | "webpack";
-    extraThemeProperties: string[] | undefined;
-    themeVersion: string;
-    loginThemeResourcesFromKeycloakVersion: string;
-    reactAppBuildDirPath: string;
-    cacheDirPath: string;
-    assetsDirPath: string;
-    urlPathname: string | undefined;
-    npmWorkspaceRootDirPath: string;
-};
-
-assert<BuildOptions extends BuildOptionsLike ? true : false>();
-
-export async function generateSrcMainResources(params: {
-    themeName: string;
-    themeSrcDirPath: string;
-    keycloakifySrcDirPath: string;
-    buildOptions: BuildOptionsLike;
-    keycloakifyVersion: string;
-    srcMainResourcesDirPath: string;
-}): Promise<{ doesImplementAccountTheme: boolean }> {
-    const { themeName, themeSrcDirPath, keycloakifySrcDirPath, buildOptions, keycloakifyVersion, srcMainResourcesDirPath } = params;
-
-    const getThemeTypeDirPath = (params: { themeType: ThemeType | "email" }) => {
-        const { themeType } = params;
-        return pathJoin(srcMainResourcesDirPath, "theme", themeName, themeType);
-    };
-
-    const cssGlobalsToDefine: Record<string, string> = {};
-
-    const implementedThemeTypes: Record<ThemeType | "email", boolean> = {
-        "login": false,
-        "account": false,
-        "email": false
-    };
-
-    for (const themeType of ["login", "account"] as const) {
-        if (!fs.existsSync(pathJoin(themeSrcDirPath, themeType))) {
-            continue;
-        }
-
-        implementedThemeTypes[themeType] = true;
-
-        const themeTypeDirPath = getThemeTypeDirPath({ themeType });
-
-        apply_replacers_and_move_to_theme_resources: {
-            const destDirPath = pathJoin(themeTypeDirPath, "resources", basenameOfTheKeycloakifyResourcesDir);
-
-            // NOTE: Prevent accumulation of files in the assets dir, as names are hashed they pile up.
-            rmSync(destDirPath, { "recursive": true, "force": true });
-
-            if (themeType === "account" && implementedThemeTypes.login) {
-                // NOTE: We prevend doing it twice, it has been done for the login theme.
-
-                transformCodebase({
-                    "srcDirPath": pathJoin(
-                        getThemeTypeDirPath({
-                            "themeType": "login"
-                        }),
-                        "resources",
-                        basenameOfTheKeycloakifyResourcesDir
-                    ),
-                    destDirPath
-                });
-
-                break apply_replacers_and_move_to_theme_resources;
-            }
-
-            transformCodebase({
-                "srcDirPath": buildOptions.reactAppBuildDirPath,
-                destDirPath,
-                "transformSourceCode": ({ filePath, sourceCode }) => {
-                    //NOTE: Prevent cycles, excludes the folder we generated for debug in public/
-                    // This should not happen if users follow the new instruction setup but we keep it for retrocompatibility.
-                    if (
-                        isInside({
-                            "dirPath": pathJoin(buildOptions.reactAppBuildDirPath, keycloak_resources),
-                            filePath
-                        })
-                    ) {
-                        return undefined;
-                    }
-
-                    if (/\.css?$/i.test(filePath)) {
-                        const { cssGlobalsToDefine: cssGlobalsToDefineForThisFile, fixedCssCode } = replaceImportsInCssCode({
-                            "cssCode": sourceCode.toString("utf8")
-                        });
-
-                        Object.entries(cssGlobalsToDefineForThisFile).forEach(([key, value]) => {
-                            cssGlobalsToDefine[key] = value;
-                        });
-
-                        return { "modifiedSourceCode": Buffer.from(fixedCssCode, "utf8") };
-                    }
-
-                    if (/\.js?$/i.test(filePath)) {
-                        const { fixedJsCode } = replaceImportsInJsCode({
-                            "jsCode": sourceCode.toString("utf8"),
-                            buildOptions
-                        });
-
-                        return { "modifiedSourceCode": Buffer.from(fixedJsCode, "utf8") };
-                    }
-
-                    return { "modifiedSourceCode": sourceCode };
-                }
-            });
-        }
-
-        const { generateFtlFilesCode } = generateFtlFilesCodeFactory({
-            themeName,
-            "indexHtmlCode": fs.readFileSync(pathJoin(buildOptions.reactAppBuildDirPath, "index.html")).toString("utf8"),
-            cssGlobalsToDefine,
-            buildOptions,
-            keycloakifyVersion,
-            themeType,
-            "fieldNames": readFieldNameUsage({
-                keycloakifySrcDirPath,
-                themeSrcDirPath,
-                themeType
-            })
-        });
-
-        [
-            ...(() => {
-                switch (themeType) {
-                    case "login":
-                        return loginThemePageIds;
-                    case "account":
-                        return accountThemePageIds;
-                }
-            })(),
-            ...readExtraPagesNames({
-                themeType,
-                themeSrcDirPath
-            })
-        ].forEach(pageId => {
-            const { ftlCode } = generateFtlFilesCode({ pageId });
-
-            fs.mkdirSync(themeTypeDirPath, { "recursive": true });
-
-            fs.writeFileSync(pathJoin(themeTypeDirPath, pageId), Buffer.from(ftlCode, "utf8"));
-        });
-
-        generateMessageProperties({
-            themeSrcDirPath,
-            themeType
-        }).forEach(({ languageTag, propertiesFileSource }) => {
-            const messagesDirPath = pathJoin(themeTypeDirPath, "messages");
-
-            fs.mkdirSync(pathJoin(themeTypeDirPath, "messages"), { "recursive": true });
-
-            const propertiesFilePath = pathJoin(messagesDirPath, `messages_${languageTag}.properties`);
-
-            fs.writeFileSync(propertiesFilePath, Buffer.from(propertiesFileSource, "utf8"));
-        });
-
-        await downloadKeycloakStaticResources({
-            "keycloakVersion": (() => {
-                switch (themeType) {
-                    case "account":
-                        return lastKeycloakVersionWithAccountV1;
-                    case "login":
-                        return buildOptions.loginThemeResourcesFromKeycloakVersion;
-                }
-            })(),
-            "themeDirPath": pathResolve(pathJoin(themeTypeDirPath, "..")),
-            themeType,
-            buildOptions
-        });
-
-        fs.writeFileSync(
-            pathJoin(themeTypeDirPath, "theme.properties"),
-            Buffer.from(
-                [
-                    `parent=${(() => {
-                        switch (themeType) {
-                            case "account":
-                                return accountV1ThemeName;
-                            case "login":
-                                return "keycloak";
-                        }
-                        assert<Equals<typeof themeType, never>>(false);
-                    })()}`,
-                    ...(buildOptions.extraThemeProperties ?? [])
-                ].join("\n\n"),
-                "utf8"
-            )
-        );
-    }
-
-    email: {
-        const emailThemeSrcDirPath = pathJoin(themeSrcDirPath, "email");
-
-        if (!fs.existsSync(emailThemeSrcDirPath)) {
-            break email;
-        }
-
-        implementedThemeTypes.email = true;
-
-        transformCodebase({
-            "srcDirPath": emailThemeSrcDirPath,
-            "destDirPath": getThemeTypeDirPath({ "themeType": "email" })
-        });
-    }
-
-    const parsedKeycloakThemeJson: { themes: { name: string; types: string[] }[] } = { "themes": [] };
-
-    parsedKeycloakThemeJson.themes.push({
-        "name": themeName,
-        "types": Object.entries(implementedThemeTypes)
-            .filter(([, isImplemented]) => isImplemented)
-            .map(([themeType]) => themeType)
-    });
-
-    account_specific_extra_work: {
-        if (!implementedThemeTypes.account) {
-            break account_specific_extra_work;
-        }
-
-        await bringInAccountV1({
-            srcMainResourcesDirPath,
-            buildOptions
-        });
-
-        parsedKeycloakThemeJson.themes.push({
-            "name": accountV1ThemeName,
-            "types": ["account"]
-        });
-    }
-
-    {
-        const keycloakThemeJsonFilePath = pathJoin(srcMainResourcesDirPath, "META-INF", "keycloak-themes.json");
-
-        try {
-            fs.mkdirSync(pathDirname(keycloakThemeJsonFilePath));
-        } catch {}
-
-        fs.writeFileSync(keycloakThemeJsonFilePath, Buffer.from(JSON.stringify(parsedKeycloakThemeJson, null, 2), "utf8"));
-    }
-
-    return { "doesImplementAccountTheme": implementedThemeTypes.account };
-}

package/src/bin/keycloakify/generateTheme/generateTheme.ts

@@ -1,44 +0,0 @@
-import { join as pathJoin } from "path";
-import type { BuildOptions } from "../buildOptions";
-import { assert } from "tsafe/assert";
-import { generateSrcMainResources, type BuildOptionsLike as BuildOptionsLike_generateSrcMainResources } from "./generateSrcMainResources";
-import { generateThemeVariations } from "./generateThemeVariants";
-
-export type BuildOptionsLike = BuildOptionsLike_generateSrcMainResources & {
-    keycloakifyBuildDirPath: string;
-    themeNames: string[];
-};
-
-assert<BuildOptions extends BuildOptionsLike ? true : false>();
-
-export async function generateTheme(params: {
-    themeSrcDirPath: string;
-    keycloakifySrcDirPath: string;
-    buildOptions: BuildOptionsLike;
-    keycloakifyVersion: string;
-}): Promise<{ doesImplementAccountTheme: boolean }> {
-    const { themeSrcDirPath, keycloakifySrcDirPath, buildOptions, keycloakifyVersion } = params;
-
-    const [themeName, ...themeVariantNames] = buildOptions.themeNames;
-
-    const srcMainResourcesDirPath = pathJoin(buildOptions.keycloakifyBuildDirPath, "src", "main", "resources");
-
-    const { doesImplementAccountTheme } = await generateSrcMainResources({
-        themeName,
-        srcMainResourcesDirPath,
-        themeSrcDirPath,
-        keycloakifySrcDirPath,
-        keycloakifyVersion,
-        buildOptions
-    });
-
-    for (const themeVariantName of themeVariantNames) {
-        generateThemeVariations({
-            themeName,
-            themeVariantName,
-            srcMainResourcesDirPath
-        });
-    }
-
-    return { doesImplementAccountTheme };
-}

package/src/bin/keycloakify/generateTheme/generateThemeVariants.ts

@@ -1,50 +0,0 @@
-import { join as pathJoin, extname as pathExtname, sep as pathSep } from "path";
-import { transformCodebase } from "../../tools/transformCodebase";
-import { assert } from "tsafe/assert";
-import * as fs from "fs";
-
-export function generateThemeVariations(params: { themeName: string; themeVariantName: string; srcMainResourcesDirPath: string }) {
-    const { themeName, themeVariantName, srcMainResourcesDirPath } = params;
-
-    const mainThemeDirPath = pathJoin(srcMainResourcesDirPath, "theme", themeName);
-
-    transformCodebase({
-        "srcDirPath": mainThemeDirPath,
-        "destDirPath": pathJoin(mainThemeDirPath, "..", themeVariantName),
-        "transformSourceCode": ({ fileRelativePath, sourceCode }) => {
-            if (pathExtname(fileRelativePath) === ".ftl" && fileRelativePath.split(pathSep).length === 2) {
-                const modifiedSourceCode = Buffer.from(
-                    Buffer.from(sourceCode)
-                        .toString("utf-8")
-                        .replace(`out["themeName"] = "${themeName}";`, `out["themeName"] = "${themeVariantName}";`),
-                    "utf8"
-                );
-
-                assert(Buffer.compare(modifiedSourceCode, sourceCode) !== 0);
-
-                return { modifiedSourceCode };
-            }
-
-            return { "modifiedSourceCode": sourceCode };
-        }
-    });
-
-    {
-        const keycloakThemeJsonFilePath = pathJoin(srcMainResourcesDirPath, "META-INF", "keycloak-themes.json");
-
-        const modifiedParsedJson = JSON.parse(fs.readFileSync(keycloakThemeJsonFilePath).toString("utf8")) as {
-            themes: { name: string; types: string[] }[];
-        };
-
-        modifiedParsedJson.themes.push({
-            "name": themeVariantName,
-            "types": (() => {
-                const theme = modifiedParsedJson.themes.find(({ name }) => name === themeName);
-                assert(theme !== undefined);
-                return theme.types;
-            })()
-        });
-
-        fs.writeFileSync(keycloakThemeJsonFilePath, Buffer.from(JSON.stringify(modifiedParsedJson, null, 2), "utf8"));
-    }
-}

package/src/bin/keycloakify/generateTheme/index.ts

@@ -1 +0,0 @@
-export * from "./generateTheme";

package/src/bin/keycloakify/generateTheme/readFieldNameUsage.ts

@@ -1,55 +0,0 @@
-import { crawl } from "../../tools/crawl";
-import { join as pathJoin } from "path";
-import * as fs from "fs";
-import type { ThemeType } from "../../constants";
-
-/** Assumes the theme type exists */
-export function readFieldNameUsage(params: { keycloakifySrcDirPath: string; themeSrcDirPath: string; themeType: ThemeType }): string[] {
-    const { keycloakifySrcDirPath, themeSrcDirPath, themeType } = params;
-
-    const fieldNames = new Set<string>();
-
-    for (const srcDirPath of [pathJoin(keycloakifySrcDirPath, themeType), pathJoin(themeSrcDirPath, themeType)]) {
-        const filePaths = crawl({ "dirPath": srcDirPath, "returnedPathsType": "absolute" }).filter(filePath => /\.(ts|tsx|js|jsx)$/.test(filePath));
-
-        for (const filePath of filePaths) {
-            const rawSourceFile = fs.readFileSync(filePath).toString("utf8");
-
-            if (!rawSourceFile.includes("messagesPerField")) {
-                continue;
-            }
-
-            for (const functionName of ["printIfExists", "existsError", "get", "exists", "getFirstError"] as const) {
-                if (!rawSourceFile.includes(functionName)) {
-                    continue;
-                }
-
-                try {
-                    rawSourceFile
-                        .split(functionName)
-                        .filter(part => part.startsWith("("))
-                        .map(part => {
-                            let [p1] = part.split(")");
-
-                            p1 = p1.slice(1);
-
-                            return p1;
-                        })
-                        .map(part => {
-                            return part
-                                .split(",")
-                                .map(a => a.trim())
-                                .filter((...[, i]) => (functionName !== "printIfExists" ? true : i === 0))
-                                .filter(a => a.startsWith('"') || a.startsWith("'") || a.startsWith("`"))
-                                .filter(a => a.endsWith('"') || a.endsWith("'") || a.endsWith("`"))
-                                .map(a => a.slice(1).slice(0, -1));
-                        })
-                        .flat()
-                        .forEach(fieldName => fieldNames.add(fieldName));
-                } catch {}
-            }
-        }
-    }
-
-    return Array.from(fieldNames);
-}

package/src/bin/promptKeycloakVersion.ts

@@ -1,49 +0,0 @@
-import { getLatestsSemVersionedTagFactory } from "./tools/octokit-addons/getLatestsSemVersionedTag";
-import { Octokit } from "@octokit/rest";
-import cliSelect from "cli-select";
-import { lastKeycloakVersionWithAccountV1 } from "./constants";
-
-export async function promptKeycloakVersion() {
-    const { getLatestsSemVersionedTag } = (() => {
-        const { octokit } = (() => {
-            const githubToken = process.env.GITHUB_TOKEN;
-
-            const octokit = new Octokit(githubToken === undefined ? undefined : { "auth": githubToken });
-
-            return { octokit };
-        })();
-
-        const { getLatestsSemVersionedTag } = getLatestsSemVersionedTagFactory({ octokit });
-
-        return { getLatestsSemVersionedTag };
-    })();
-
-    console.log("Select Keycloak version?");
-
-    const tags = [
-        ...(await getLatestsSemVersionedTag({
-            "count": 15,
-            "owner": "keycloak",
-            "repo": "keycloak"
-        }).then(arr => arr.map(({ tag }) => tag))),
-        lastKeycloakVersionWithAccountV1,
-        "19.0.1",
-        "11.0.3"
-    ];
-
-    if (process.env["GITHUB_ACTIONS"] === "true") {
-        return { "keycloakVersion": tags[0] };
-    }
-
-    const { value: keycloakVersion } = await cliSelect<string>({
-        "values": tags
-    }).catch(() => {
-        console.log("Aborting");
-
-        process.exit(-1);
-    });
-
-    console.log(keycloakVersion);
-
-    return { keycloakVersion };
-}

package/src/bin/tools/logger.ts

@@ -1,27 +0,0 @@
-type LoggerOpts = {
-    force?: boolean;
-};
-
-type Logger = {
-    log: (message: string, opts?: LoggerOpts) => void;
-    warn: (message: string) => void;
-    error: (message: string) => void;
-};
-
-export const getLogger = ({ isSilent }: { isSilent?: boolean } = {}): Logger => {
-    return {
-        log: (message, { force } = {}) => {
-            if (isSilent && !force) {
-                return;
-            }
-
-            console.log(message);
-        },
-        warn: message => {
-            console.warn(message);
-        },
-        error: message => {
-            console.error(message);
-        }
-    };
-};

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();
-    });
-}

package/src/index.ts

@@ -1 +0,0 @@
-export { createKeycloakAdapter } from "keycloakify/lib/keycloakJsAdapter";

package/src/lib/isStorybook.ts

@@ -1 +0,0 @@
-export const isStorybook = typeof window === "object" && Object.keys(window).find(key => key.startsWith("__STORYBOOK")) !== undefined;