keycloakify 11.6.2 → 11.7.1

package/src/bin/initialize-email-theme.ts

@@ -1,13 +1,11 @@
 import { join as pathJoin, relative as pathRelative } from "path";
 import { transformCodebase } from "./tools/transformCodebase";
-import { promptKeycloakVersion } from "./shared/promptKeycloakVersion";
 import type { BuildContext } from "./shared/buildContext";
 import * as fs from "fs";
 import { downloadAndExtractArchive } from "./tools/downloadAndExtractArchive";
 import { maybeDelegateCommandToCustomHandler } from "./shared/customHandler_delegate";
-import fetch from "make-fetch-happen";
-import { SemVer } from "./tools/SemVer";
 import { assert } from "tsafe/assert";
+import { getSupportedDockerImageTags } from "./start-keycloak/getSupportedDockerImageTags";
 
 export async function command(params: { buildContext: BuildContext }) {
     const { buildContext } = params;
@@ -39,40 +37,18 @@ export async function command(params: { buildContext: BuildContext }) {
 
     console.log("Initialize with the base email theme from which version of Keycloak?");
 
-    let { keycloakVersion } = await promptKeycloakVersion({
-        // NOTE: This is arbitrary
-        startingFromMajor: 17,
-        excludeMajorVersions: [],
-        doOmitPatch: false,
-        buildContext
-    });
-
-    const getUrl = (keycloakVersion: string) => {
-        return `https://repo1.maven.org/maven2/org/keycloak/keycloak-themes/${keycloakVersion}/keycloak-themes-${keycloakVersion}.jar`;
-    };
-
-    keycloakVersion = await (async () => {
-        const keycloakVersionParsed = SemVer.parse(keycloakVersion);
-
-        while (true) {
-            const url = getUrl(SemVer.stringify(keycloakVersionParsed));
-
-            const response = await fetch(url, buildContext.fetchOptions);
-
-            if (response.ok) {
-                break;
-            }
-
-            assert(keycloakVersionParsed.patch !== 0);
+    const { extractedDirPath } = await downloadAndExtractArchive({
+        url: await (async () => {
+            const { latestMajorTags } = await getSupportedDockerImageTags({
+                buildContext
+            });
 
-            keycloakVersionParsed.patch--;
-        }
+            const keycloakVersion = latestMajorTags[0];
 
-        return SemVer.stringify(keycloakVersionParsed);
-    })();
+            assert(keycloakVersion !== undefined);
 
-    const { extractedDirPath } = await downloadAndExtractArchive({
-        url: getUrl(keycloakVersion),
+            return `https://repo1.maven.org/maven2/org/keycloak/keycloak-themes/${keycloakVersion}/keycloak-themes-${keycloakVersion}.jar`;
+        })(),
         cacheDirPath: buildContext.cacheDirPath,
         fetchOptions: buildContext.fetchOptions,
         uniqueIdOfOnArchiveFile: "extractOnlyEmailTheme",

package/src/bin/keycloakify/generateResources/generateResources.ts

@@ -37,10 +37,10 @@ import {
 } from "../../shared/metaInfKeycloakThemes";
 import { objectEntries } from "tsafe/objectEntries";
 import { escapeStringForPropertiesFile } from "../../tools/escapeStringForPropertiesFile";
-import * as child_process from "child_process";
 import { getThisCodebaseRootDirPath } from "../../tools/getThisCodebaseRootDirPath";
 import propertiesParser from "properties-parser";
 import { createObjectThatThrowsIfAccessed } from "../../tools/createObjectThatThrowsIfAccessed";
+import { listInstalledModules } from "../../tools/listInstalledModules";
 
 export type BuildContextLike = BuildContextLike_kcContextExclusionsFtlCode &
     BuildContextLike_generateMessageProperties & {
@@ -238,9 +238,9 @@ export async function generateResources(params: {
 
         let languageTags: string[] | undefined = undefined;
 
-        i18n_messages_generation: {
+        i18n_multi_page: {
             if (isSpa) {
-                break i18n_messages_generation;
+                break i18n_multi_page;
             }
 
             assert(themeType !== "admin");
@@ -257,23 +257,43 @@ export async function generateResources(params: {
                 writeMessagePropertiesFiles;
         }
 
-        bring_in_account_spa_messages: {
+        let isLegacyAccountSpa = false;
+
+        // NOTE: Eventually remove this block.
+        i18n_single_page_account_legacy: {
             if (!isSpa) {
-                break bring_in_account_spa_messages;
+                break i18n_single_page_account_legacy;
             }
 
             if (themeType !== "account") {
-                break bring_in_account_spa_messages;
+                break i18n_single_page_account_legacy;
             }
 
-            const accountUiDirPath = child_process
-                .execSync(`npm list @keycloakify/keycloak-account-ui --parseable`, {
-                    cwd: pathDirname(buildContext.packageJsonFilePath)
-                })
-                .toString("utf8")
-                .trim();
+            const [moduleMeta] = await listInstalledModules({
+                packageJsonFilePath: buildContext.packageJsonFilePath,
+                filter: ({ moduleName }) =>
+                    moduleName === "@keycloakify/keycloak-account-ui"
+            });
+
+            assert(
+                moduleMeta !== undefined,
+                `@keycloakify/keycloak-account-ui is supposed to be installed`
+            );
+
+            {
+                const [majorStr] = moduleMeta.version.split(".");
+
+                if (majorStr.length === 6) {
+                    // NOTE: Now we use the format MMmmpp (Major, minor, patch) for example for
+                    // 26.0.7 it would be 260007.
+                    break i18n_single_page_account_legacy;
+                } else {
+                    // 25.0.4-rc.5 or later
+                    isLegacyAccountSpa = true;
+                }
+            }
 
-            const messageDirPath_defaults = pathJoin(accountUiDirPath, "messages");
+            const messageDirPath_defaults = pathJoin(moduleMeta.dirPath, "messages");
 
             if (!fs.existsSync(messageDirPath_defaults)) {
                 throw new Error(
@@ -281,6 +301,8 @@ export async function generateResources(params: {
                 );
             }
 
+            isLegacyAccountSpa = true;
+
             const messagesDirPath_dest = pathJoin(
                 getThemeTypeDirPath({ themeName, themeType: "account" }),
                 "messages"
@@ -342,14 +364,20 @@ export async function generateResources(params: {
                 );
         }
 
-        bring_in_admin_messages: {
-            if (themeType !== "admin") {
-                break bring_in_admin_messages;
+        i18n_single_page: {
+            if (!isSpa) {
+                break i18n_single_page;
+            }
+
+            if (isLegacyAccountSpa) {
+                break i18n_single_page;
             }
 
+            assert(themeType === "account" || themeType === "admin");
+
             const messagesDirPath_theme = pathJoin(
                 buildContext.themeSrcDirPath,
-                "admin",
+                themeType,
                 "i18n"
             );
 
@@ -423,7 +451,7 @@ export async function generateResources(params: {
 
                 propertiesByLang[parsedBasename.lang] ??= {
                     base: createObjectThatThrowsIfAccessed<Buffer>({
-                        debugMessage: `No base ${parsedBasename.lang} translation for admin theme`
+                        debugMessage: `No base ${parsedBasename.lang} translation for ${themeType} theme`
                     }),
                     override: undefined,
                     overrideByThemeName: {}
@@ -446,7 +474,9 @@ export async function generateResources(params: {
                 ] = buffer;
             });
 
-            writeMessagePropertiesFilesByThemeType.admin = ({
+            languageTags = Object.keys(propertiesByLang);
+
+            writeMessagePropertiesFilesByThemeType[themeType] = ({
                 messageDirPath,
                 themeName
             }) => {
@@ -456,8 +486,6 @@ export async function generateResources(params: {
 
                 Object.entries(propertiesByLang).forEach(
                     ([lang, { base, override, overrideByThemeName }]) => {
-                        (languageTags ??= []).push(lang);
-
                         const messages = propertiesParser.parse(base.toString("utf8"));
 
                         if (override !== undefined) {

package/src/bin/main.ts

@@ -303,7 +303,7 @@ program
         key: "path",
         name: (() => {
             const long = "path";
-            const short = "p";
+            const short = "t";
 
             optionsKeys.push(long, short);
 
@@ -318,11 +318,12 @@ program
     .option({
         key: "revert",
         name: (() => {
-            const name = "revert";
+            const long = "revert";
+            const short = "r";
 
-            optionsKeys.push(name);
+            optionsKeys.push(long, short);
 
-            return name;
+            return { long, short };
         })(),
         description: [
             "Restores a file or directory to its original auto-generated state,",

package/src/bin/own.ts

@@ -124,8 +124,7 @@ async function command_own(params: Params_subcommands) {
     ] of targetFileRelativePathsByExtensionModuleMeta.entries()) {
         const extensionModuleDirPath = await getInstalledModuleDirPath({
             moduleName: extensionModuleMeta.moduleName,
-            packageJsonDirPath: pathDirname(buildContext.packageJsonFilePath),
-            projectDirPath: buildContext.projectDirPath
+            packageJsonDirPath: pathDirname(buildContext.packageJsonFilePath)
         });
 
         for (const fileRelativePath of fileRelativePaths) {

package/src/bin/shared/{addSyncExtensionsToPostinstallScript.ts → initializeSpa/addSyncExtensionsToPostinstallScript.ts}

@@ -1,6 +1,6 @@
 import { dirname as pathDirname, relative as pathRelative, sep as pathSep } from "path";
 import { assert } from "tsafe/assert";
-import type { BuildContext } from "./buildContext";
+import type { BuildContext } from "../buildContext";
 
 export type BuildContextLike = {
     projectDirPath: string;
@@ -56,7 +56,7 @@ export function addSyncExtensionsToPostinstallScript(params: {
                 continue;
             }
 
-            if (cmd_preexisting.includes(cmd_base)) {
+            if (!cmd_preexisting.includes(cmd_base)) {
                 scripts[scriptName] = generateCmd({ cmd_preexisting });
                 return;
             }

package/src/bin/shared/initializeSpa/index.ts

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

package/src/bin/shared/initializeSpa/initializeSpa.ts

@@ -0,0 +1,149 @@
+import { dirname as pathDirname, join as pathJoin, relative as pathRelative } from "path";
+import type { BuildContext } from "../buildContext";
+import * as fs from "fs";
+import { assert, is, type Equals } from "tsafe/assert";
+import { id } from "tsafe/id";
+import {
+    addSyncExtensionsToPostinstallScript,
+    type BuildContextLike as BuildContextLike_addSyncExtensionsToPostinstallScript
+} from "./addSyncExtensionsToPostinstallScript";
+import { getIsPrettierAvailable, runPrettier } from "../../tools/runPrettier";
+import { npmInstall } from "../../tools/npmInstall";
+import * as child_process from "child_process";
+import { z } from "zod";
+import chalk from "chalk";
+
+export type BuildContextLike = BuildContextLike_addSyncExtensionsToPostinstallScript & {
+    themeSrcDirPath: string;
+    packageJsonFilePath: string;
+};
+
+assert<BuildContext extends BuildContextLike ? true : false>();
+
+export async function initializeSpa(params: {
+    themeType: "account" | "admin";
+    buildContext: BuildContextLike;
+}) {
+    const { themeType, buildContext } = params;
+
+    {
+        const themeTypeSrcDirPath = pathJoin(buildContext.themeSrcDirPath, themeType);
+
+        if (
+            fs.existsSync(themeTypeSrcDirPath) &&
+            fs.readdirSync(themeTypeSrcDirPath).length > 0
+        ) {
+            console.warn(
+                chalk.red(
+                    `There is already a ${pathRelative(
+                        process.cwd(),
+                        themeTypeSrcDirPath
+                    )} directory in your project. Aborting.`
+                )
+            );
+
+            process.exit(-1);
+        }
+    }
+
+    const parsedPackageJson = (() => {
+        type ParsedPackageJson = {
+            scripts?: Record<string, string | undefined>;
+            dependencies?: Record<string, string | undefined>;
+            devDependencies?: Record<string, string | undefined>;
+        };
+
+        const zParsedPackageJson = (() => {
+            type TargetType = ParsedPackageJson;
+
+            const zTargetType = z.object({
+                scripts: z.record(z.union([z.string(), z.undefined()])).optional(),
+                dependencies: z.record(z.union([z.string(), z.undefined()])).optional(),
+                devDependencies: z.record(z.union([z.string(), z.undefined()])).optional()
+            });
+
+            assert<Equals<z.infer<typeof zTargetType>, TargetType>>;
+
+            return id<z.ZodType<TargetType>>(zTargetType);
+        })();
+        const parsedPackageJson = JSON.parse(
+            fs.readFileSync(buildContext.packageJsonFilePath).toString("utf8")
+        );
+
+        zParsedPackageJson.parse(parsedPackageJson);
+
+        assert(is<ParsedPackageJson>(parsedPackageJson));
+
+        return parsedPackageJson;
+    })();
+
+    addSyncExtensionsToPostinstallScript({
+        parsedPackageJson,
+        buildContext
+    });
+
+    const uiSharedMajor = (() => {
+        const dependencies = {
+            ...parsedPackageJson.devDependencies,
+            ...parsedPackageJson.dependencies
+        };
+
+        const version = dependencies["@keycloakify/keycloak-ui-shared"];
+
+        if (version === undefined) {
+            return undefined;
+        }
+
+        const match = version.match(/^[^~]?(\d+)\./);
+
+        if (match === null) {
+            return undefined;
+        }
+
+        return match[1];
+    })();
+
+    const moduleName = `@keycloakify/keycloak-${themeType}-ui`;
+
+    const version = (
+        JSON.parse(
+            child_process
+                .execSync(`npm show ${moduleName} versions --json`)
+                .toString("utf8")
+                .trim()
+        ) as string[]
+    )
+        .reverse()
+        .filter(version => !version.includes("-"))
+        .find(version =>
+            uiSharedMajor === undefined ? true : version.startsWith(`${uiSharedMajor}.`)
+        );
+
+    assert(version !== undefined);
+
+    (parsedPackageJson.dependencies ??= {})[moduleName] = `~${version}`;
+
+    if (parsedPackageJson.devDependencies !== undefined) {
+        delete parsedPackageJson.devDependencies[moduleName];
+    }
+
+    {
+        let sourceCode = JSON.stringify(parsedPackageJson, undefined, 2);
+
+        if (await getIsPrettierAvailable()) {
+            sourceCode = await runPrettier({
+                sourceCode,
+                filePath: buildContext.packageJsonFilePath
+            });
+        }
+
+        fs.writeFileSync(
+            buildContext.packageJsonFilePath,
+            Buffer.from(sourceCode, "utf8")
+        );
+    }
+
+    await npmInstall({
+        packageJsonDirPath: pathDirname(buildContext.packageJsonFilePath)
+    });
+}

package/src/bin/sync-extensions/extensionModuleMeta.ts

@@ -109,7 +109,6 @@ export async function getExtensionModuleMetas(params: {
     const installedExtensionModules = await (async () => {
         const installedModulesWithKeycloakifyInTheName = await listInstalledModules({
             packageJsonFilePath: buildContext.packageJsonFilePath,
-            projectDirPath: buildContext.packageJsonFilePath,
             filter: ({ moduleName }) =>
                 moduleName.includes("keycloakify") && moduleName !== "keycloakify"
         });

package/src/bin/sync-extensions/getExtensionModuleFileSourceCodeReadyToBeCopied.ts

@@ -104,7 +104,10 @@ function addCommentToSourceCode(params: {
             `<!--`,
             ...commentLines.map(
                 line =>
-                    ` ${line.replace("--path", "-p").replace("Before modifying", "Before modifying or replacing")}`
+                    ` ${line
+                        .replace("--path", "-t")
+                        .replace("--revert", "-r")
+                        .replace("Before modifying", "Before modifying or replacing")}`
             ),
             `-->`
         ].join("\n");

package/src/bin/tools/getInstalledModuleDirPath.ts

@@ -2,40 +2,42 @@ import { join as pathJoin } from "path";
 import { existsAsync } from "./fs.existsAsync";
 import * as child_process from "child_process";
 import { assert } from "tsafe/assert";
+import { getIsRootPath } from "../tools/isRootPath";
 
 export async function getInstalledModuleDirPath(params: {
     moduleName: string;
     packageJsonDirPath: string;
-    projectDirPath: string;
 }) {
-    const { moduleName, packageJsonDirPath, projectDirPath } = params;
+    const { moduleName, packageJsonDirPath } = params;
 
-    common_case: {
-        const dirPath = pathJoin(
-            ...[packageJsonDirPath, "node_modules", ...moduleName.split("/")]
-        );
+    {
+        let dirPath = packageJsonDirPath;
 
-        if (!(await existsAsync(dirPath))) {
-            break common_case;
-        }
+        while (true) {
+            const dirPath_candidate = pathJoin(
+                dirPath,
+                "node_modules",
+                ...moduleName.split("/")
+            );
 
-        return dirPath;
-    }
+            let doesExist: boolean;
 
-    node_modules_at_root_case: {
-        if (projectDirPath === packageJsonDirPath) {
-            break node_modules_at_root_case;
-        }
+            try {
+                doesExist = await existsAsync(dirPath_candidate);
+            } catch {
+                doesExist = false;
+            }
 
-        const dirPath = pathJoin(
-            ...[projectDirPath, "node_modules", ...moduleName.split("/")]
-        );
+            if (doesExist) {
+                return dirPath_candidate;
+            }
 
-        if (!(await existsAsync(dirPath))) {
-            break node_modules_at_root_case;
-        }
+            if (getIsRootPath(dirPath)) {
+                break;
+            }
 
-        return dirPath;
+            dirPath = pathJoin(dirPath, "..");
+        }
     }
 
     const dirPath = child_process

package/src/bin/tools/isRootPath.ts

@@ -0,0 +1,22 @@
+import { normalize as pathNormalize } from "path";
+
+export function getIsRootPath(filePath: string): boolean {
+    const path_normalized = pathNormalize(filePath);
+
+    // Unix-like root ("/")
+    if (path_normalized === "/") {
+        return true;
+    }
+
+    // Check for Windows drive root (e.g., "C:\\")
+    if (/^[a-zA-Z]:\\$/.test(path_normalized)) {
+        return true;
+    }
+
+    // Check for UNC root (e.g., "\\server\share")
+    if (/^\\\\[^\\]+\\[^\\]+\\?$/.test(path_normalized)) {
+        return true;
+    }
+
+    return false;
+}

package/src/bin/tools/listInstalledModules.ts

@@ -8,7 +8,6 @@ import { exclude } from "tsafe/exclude";
 
 export async function listInstalledModules(params: {
     packageJsonFilePath: string;
-    projectDirPath: string;
     filter: (params: { moduleName: string }) => boolean;
 }): Promise<
     {
@@ -18,7 +17,7 @@ export async function listInstalledModules(params: {
         peerDependencies: Record<string, string>;
     }[]
 > {
-    const { packageJsonFilePath, projectDirPath, filter } = params;
+    const { packageJsonFilePath, filter } = params;
 
     const parsedPackageJson = await readPackageJsonDependencies({
         packageJsonFilePath
@@ -36,8 +35,7 @@ export async function listInstalledModules(params: {
         extensionModuleNames.map(async moduleName => {
             const dirPath = await getInstalledModuleDirPath({
                 moduleName,
-                packageJsonDirPath: pathDirname(packageJsonFilePath),
-                projectDirPath
+                packageJsonDirPath: pathDirname(packageJsonFilePath)
             });
 
             const { version, peerDependencies } =

package/src/bin/tsconfig.json

@@ -10,5 +10,5 @@
         "rootDir": "."
     },
     "include": ["**/*.ts", "**/*.tsx"],
-    "exclude": ["initialize-account-theme/src"]
+    "exclude": ["initialize-account-theme/multi-page-boilerplate"]
 }