keycloakify 10.0.0-rc.3 → 10.0.0-rc.30

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

@@ -1,49 +0,0 @@
-import { transformCodebase } from "../../tools/transformCodebase";
-import { join as pathJoin } from "path";
-import { downloadBuiltinKeycloakTheme } from "../../download-builtin-keycloak-theme";
-import { resources_common, type ThemeType } from "../../constants";
-import { BuildOptions } from "../buildOptions";
-import { assert } from "tsafe/assert";
-import * as crypto from "crypto";
-import { rmSync } from "../../tools/fs.rmSync";
-
-export type BuildOptionsLike = {
-    cacheDirPath: string;
-    npmWorkspaceRootDirPath: string;
-};
-
-assert<BuildOptions extends BuildOptionsLike ? true : false>();
-
-export async function downloadKeycloakStaticResources(params: {
-    themeType: ThemeType;
-    themeDirPath: string;
-    keycloakVersion: string;
-    buildOptions: BuildOptionsLike;
-}) {
-    const { themeType, themeDirPath, keycloakVersion, buildOptions } = params;
-
-    const tmpDirPath = pathJoin(
-        themeDirPath,
-        `tmp_suLeKsxId_${crypto.createHash("sha256").update(`${themeType}-${keycloakVersion}`).digest("hex").slice(0, 8)}`
-    );
-
-    await downloadBuiltinKeycloakTheme({
-        keycloakVersion,
-        "destDirPath": tmpDirPath,
-        buildOptions
-    });
-
-    const resourcesPath = pathJoin(themeDirPath, themeType, "resources");
-
-    transformCodebase({
-        "srcDirPath": pathJoin(tmpDirPath, "keycloak", themeType, "resources"),
-        "destDirPath": resourcesPath
-    });
-
-    transformCodebase({
-        "srcDirPath": pathJoin(tmpDirPath, "keycloak", "common", "resources"),
-        "destDirPath": pathJoin(resourcesPath, resources_common)
-    });
-
-    rmSync(tmpDirPath, { "recursive": true, "force": true });
-}

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

@@ -1,118 +0,0 @@
-export declare namespace keycloak_js {
-    export type KeycloakPromiseCallback<T> = (result: T) => void;
-    export class KeycloakPromise<TSuccess, TError> extends Promise<TSuccess> {
-        success(callback: KeycloakPromiseCallback<TSuccess>): KeycloakPromise<TSuccess, TError>;
-        error(callback: KeycloakPromiseCallback<TError>): KeycloakPromise<TSuccess, TError>;
-    }
-    export interface KeycloakAdapter {
-        login(options?: KeycloakLoginOptions): KeycloakPromise<void, void>;
-        logout(options?: KeycloakLogoutOptions): KeycloakPromise<void, void>;
-        register(options?: KeycloakLoginOptions): KeycloakPromise<void, void>;
-        accountManagement(): KeycloakPromise<void, void>;
-        redirectUri(options: { redirectUri: string }, encodeHash: boolean): string;
-    }
-    export interface KeycloakLogoutOptions {
-        redirectUri?: string;
-    }
-    export interface KeycloakLoginOptions {
-        scope?: string;
-        redirectUri?: string;
-        prompt?: "none" | "login";
-        action?: string;
-        maxAge?: number;
-        loginHint?: string;
-        idpHint?: string;
-        locale?: string;
-        cordovaOptions?: { [optionName: string]: string };
-    }
-
-    export type KeycloakInstance = Record<
-        "createLoginUrl" | "createLogoutUrl" | "createRegisterUrl",
-        (options: KeycloakLoginOptions | undefined) => string
-    > & {
-        createAccountUrl(): string;
-        redirectUri?: string;
-    };
-}
-
-/**
- * @deprecated: This will be removed in the next major version.
- * If you use this, please copy paste the code into your project.
- * Better yet migrate away from keycloak-js and use https://docs.oidc-spa.dev instead.
- *
- * NOTE: This is just a slightly modified version of the default adapter in keycloak-js
- * The goal here is just to be able to inject search param in url before keycloak redirect.
- * Our use case for it is to pass over the login screen the states of useGlobalState
- * namely isDarkModeEnabled, lgn...
- */
-export function createKeycloakAdapter(params: {
-    keycloakInstance: keycloak_js.KeycloakInstance;
-    transformUrlBeforeRedirect: (url: string) => string;
-    getRedirectMethod?: () => "overwrite location.href" | "location.replace";
-}): keycloak_js.KeycloakAdapter {
-    const { keycloakInstance, transformUrlBeforeRedirect, getRedirectMethod = () => "overwrite location.href" } = params;
-
-    const neverResolvingPromise: keycloak_js.KeycloakPromise<void, void> = Object.defineProperties(new Promise(() => {}), {
-        "success": { "value": () => {} },
-        "error": { "value": () => {} }
-    }) as any;
-
-    return {
-        "login": options => {
-            const newHref = transformUrlBeforeRedirect(keycloakInstance.createLoginUrl(options));
-            switch (getRedirectMethod()) {
-                case "location.replace":
-                    window.location.replace(newHref);
-                    break;
-                case "overwrite location.href":
-                    window.location.href = newHref;
-                    break;
-            }
-            return neverResolvingPromise;
-        },
-        "register": options => {
-            const newHref = transformUrlBeforeRedirect(keycloakInstance.createRegisterUrl(options));
-            switch (getRedirectMethod()) {
-                case "location.replace":
-                    window.location.replace(newHref);
-                    break;
-                case "overwrite location.href":
-                    window.location.href = newHref;
-                    break;
-            }
-
-            return neverResolvingPromise;
-        },
-        "logout": options => {
-            window.location.replace(transformUrlBeforeRedirect(keycloakInstance.createLogoutUrl(options)));
-            return neverResolvingPromise;
-        },
-        "accountManagement": () => {
-            const accountUrl = transformUrlBeforeRedirect(keycloakInstance.createAccountUrl());
-
-            if (accountUrl === "undefined") {
-                throw new Error("Not supported by the OIDC server");
-            }
-
-            switch (getRedirectMethod()) {
-                case "location.replace":
-                    window.location.replace(accountUrl);
-                    break;
-                case "overwrite location.href":
-                    window.location.href = accountUrl;
-                    break;
-            }
-
-            return neverResolvingPromise;
-        },
-        "redirectUri": options => {
-            if (options && options.redirectUri) {
-                return options.redirectUri;
-            } else if (keycloakInstance.redirectUri) {
-                return keycloakInstance.redirectUri;
-            } else {
-                return window.location.href;
-            }
-        }
-    };
-}