keycloakify 8.0.0-rc.3 → 9.0.0-rc.0

package/src/bin/keycloakify/generateJavaStackFiles/account-v1-java/services/resources/account/AccountFormServiceFactory.java

@@ -0,0 +1,64 @@
+package org.keycloak.services.resources.account;
+
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import java.util.Map;
+import lombok.extern.jbosslog.JBossLog;
+import org.keycloak.Config.Scope;
+import org.keycloak.events.EventBuilder;
+import org.keycloak.models.ClientModel;
+import org.keycloak.models.KeycloakSession;
+import org.keycloak.models.KeycloakSessionFactory;
+import org.keycloak.models.ProtocolMapperModel;
+import org.keycloak.models.RealmModel;
+import org.keycloak.provider.ProviderEvent;
+import org.keycloak.services.resource.AccountResourceProvider;
+import org.keycloak.services.resource.AccountResourceProviderFactory;
+import jakarta.ws.rs.NotFoundException;
+import org.keycloak.models.Constants;
+
+@JBossLog
+@AutoService(AccountResourceProviderFactory.class)
+public class AccountFormServiceFactory implements AccountResourceProviderFactory {
+
+  public static final String ID = "account-v1";
+
+  @Override
+  public String getId() {
+    return ID;
+  }
+
+  private ClientModel getAccountManagementClient(RealmModel realm) {
+    ClientModel client = realm.getClientByClientId(Constants.ACCOUNT_MANAGEMENT_CLIENT_ID);
+    if (client == null || !client.isEnabled()) {
+      log.debug("account management not enabled");
+      throw new NotFoundException("account management not enabled");
+    }
+    return client;
+  }
+
+  @Override
+  public AccountResourceProvider create(KeycloakSession session) {
+    log.info("create");
+    RealmModel realm = session.getContext().getRealm();
+    ClientModel client = getAccountManagementClient(realm);
+    EventBuilder event = new EventBuilder​(realm, session, session.getContext().getConnection());
+    return new AccountFormService(session, client, event);
+  }
+
+  @Override
+  public void init(Scope config) {
+    log.info("init");
+  }
+
+  @Override
+  public void postInit(KeycloakSessionFactory factory) {
+    log.info("postInit");
+  }
+
+  @Override
+  public void close() {
+    log.info("close");
+  }
+}

package/src/bin/keycloakify/generateJavaStackFiles/bringInAccountV1.ts

@@ -0,0 +1,92 @@
+import * as fs from "fs";
+import { join as pathJoin, dirname as pathDirname } from "path";
+import { assert } from "tsafe/assert";
+import { Reflect } from "tsafe/Reflect";
+import type { BuildOptions } from "../BuildOptions";
+import { resources_common, lastKeycloakVersionWithAccountV1, accountV1 } from "../../constants";
+import { downloadBuiltinKeycloakTheme } from "../../download-builtin-keycloak-theme";
+import { transformCodebase } from "../../tools/transformCodebase";
+
+export type BuildOptionsLike = {
+    keycloakifyBuildDirPath: string;
+    cacheDirPath: string;
+};
+
+{
+    const buildOptions = Reflect<BuildOptions>();
+
+    assert<typeof buildOptions extends BuildOptionsLike ? true : false>();
+}
+
+export async function bringInAccountV1(params: { buildOptions: BuildOptionsLike }) {
+    const { buildOptions } = params;
+
+    const builtinKeycloakThemeTmpDirPath = pathJoin(buildOptions.keycloakifyBuildDirPath, "..", "tmp_yxdE2_builtin_keycloak_theme");
+
+    await downloadBuiltinKeycloakTheme({
+        "destDirPath": builtinKeycloakThemeTmpDirPath,
+        "keycloakVersion": lastKeycloakVersionWithAccountV1,
+        buildOptions
+    });
+
+    const accountV1DirPath = pathJoin(buildOptions.keycloakifyBuildDirPath, "src", "main", "resources", "theme", accountV1, "account");
+
+    transformCodebase({
+        "srcDirPath": pathJoin(builtinKeycloakThemeTmpDirPath, "base", "account"),
+        "destDirPath": accountV1DirPath
+    });
+
+    const commonResourceFilePaths = [
+        "node_modules/patternfly/dist/css/patternfly.min.css",
+        "node_modules/patternfly/dist/css/patternfly-additions.min.css"
+    ];
+
+    for (const relativeFilePath of commonResourceFilePaths.map(path => pathJoin(...path.split("/")))) {
+        const destFilePath = pathJoin(accountV1DirPath, "resources", resources_common, relativeFilePath);
+
+        fs.mkdirSync(pathDirname(destFilePath), { "recursive": true });
+
+        fs.cpSync(pathJoin(builtinKeycloakThemeTmpDirPath, "keycloak", "common", "resources", relativeFilePath), destFilePath);
+    }
+
+    const resourceFilePaths = ["css/account.css"];
+
+    for (const relativeFilePath of resourceFilePaths.map(path => pathJoin(...path.split("/")))) {
+        const destFilePath = pathJoin(accountV1DirPath, "resources", relativeFilePath);
+
+        fs.mkdirSync(pathDirname(destFilePath), { "recursive": true });
+
+        fs.cpSync(pathJoin(builtinKeycloakThemeTmpDirPath, "keycloak", "account", "resources", relativeFilePath), destFilePath);
+    }
+
+    fs.rmSync(builtinKeycloakThemeTmpDirPath, { "recursive": true });
+
+    fs.writeFileSync(
+        pathJoin(accountV1DirPath, "theme.properties"),
+        Buffer.from(
+            [
+                "accountResourceProvider=org.keycloak.services.resources.account.AccountFormService",
+                "",
+                "locales=ar,ca,cs,da,de,en,es,fr,fi,hu,it,ja,lt,nl,no,pl,pt-BR,ru,sk,sv,tr,zh-CN",
+                "",
+                "styles=" + [...resourceFilePaths, ...commonResourceFilePaths.map(path => `resources_common/${path}`)].join(" "),
+                "",
+                "##### css classes for form buttons",
+                "# main class used for all buttons",
+                "kcButtonClass=btn",
+                "# classes defining priority of the button - primary or default (there is typically only one priority button for the form)",
+                "kcButtonPrimaryClass=btn-primary",
+                "kcButtonDefaultClass=btn-default",
+                "# classes defining size of the button",
+                "kcButtonLargeClass=btn-lg",
+                ""
+            ].join("\n"),
+            "utf8"
+        )
+    );
+
+    transformCodebase({
+        "srcDirPath": pathJoin(__dirname, "account-v1-java"),
+        "destDirPath": pathJoin(buildOptions.keycloakifyBuildDirPath, "src", "main", "java", "org", "keycloak")
+    });
+}

package/src/bin/keycloakify/generateJavaStackFiles/generateJavaStackFiles.ts

@@ -0,0 +1,211 @@
+import * as fs from "fs";
+import { join as pathJoin, dirname as pathDirname } from "path";
+import { assert } from "tsafe/assert";
+import { Reflect } from "tsafe/Reflect";
+import type { BuildOptions } from "../BuildOptions";
+import { type ThemeType, retrocompatPostfix, accountV1 } from "../../constants";
+import { bringInAccountV1 } from "./bringInAccountV1";
+
+export type BuildOptionsLike = {
+    groupId: string;
+    artifactId: string;
+    themeVersion: string;
+    cacheDirPath: string;
+    keycloakifyBuildDirPath: string;
+    themeNames: string[];
+};
+
+{
+    const buildOptions = Reflect<BuildOptions>();
+
+    assert<typeof buildOptions extends BuildOptionsLike ? true : false>();
+}
+
+export async function generateJavaStackFiles(params: {
+    implementedThemeTypes: Record<ThemeType | "email", boolean>;
+    buildOptions: BuildOptionsLike;
+}): Promise<{
+    jarFilePath: string;
+}> {
+    const { implementedThemeTypes, buildOptions } = params;
+
+    {
+        const { pomFileCode } = (function generatePomFileCode(): {
+            pomFileCode: string;
+        } {
+            const pomFileCode = [
+                `<?xml version="1.0"?>`,
+                `<project xmlns="http://maven.apache.org/POM/4.0.0"`,
+                `	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"`,
+                `	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">`,
+                `	<modelVersion>4.0.0</modelVersion>`,
+                `	<groupId>${buildOptions.groupId}</groupId>`,
+                `	<artifactId>${buildOptions.artifactId}</artifactId>`,
+                `	<version>${buildOptions.themeVersion}</version>`,
+                `	<name>${buildOptions.artifactId}</name>`,
+                `	<description />`,
+                `	<packaging>jar</packaging>`,
+                `	<properties>`,
+                `	    <java.version>17</java.version>`,
+                `	    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>`,
+                `	    <keycloak.version>999.0.0-SNAPSHOT</keycloak.version>`,
+                `	    <guava.version>32.0.0-jre</guava.version>`,
+                `	    <lombok.version>1.18.28</lombok.version>`,
+                `	    <auto-service.version>1.1.1</auto-service.version>`,
+                `	</properties>`,
+                `	<build>`,
+                `	    <plugins>`,
+                `	        <plugin>`,
+                `	            <artifactId>maven-compiler-plugin</artifactId>`,
+                `	            <version>3.11.0</version>`,
+                `	            <configuration>`,
+                `	                <source>\${java.version}</source>`,
+                `	                <target>\${java.version}</target>`,
+                `	                <compilerArgument>-Xlint:unchecked</compilerArgument>`,
+                `	                <compilerArgument>-Xlint:deprecation</compilerArgument>`,
+                `	                <useIncrementalCompilation>false</useIncrementalCompilation>`,
+                `	                <annotationProcessorPaths>`,
+                `	                    <path>`,
+                `	                        <groupId>com.google.auto.service</groupId>`,
+                `	                        <artifactId>auto-service</artifactId>`,
+                `	                        <version>\${auto-service.version}</version>`,
+                `	                    </path>`,
+                `	                    <path>`,
+                `	                        <groupId>org.projectlombok</groupId>`,
+                `	                        <artifactId>lombok</artifactId>`,
+                `	                        <version>\${lombok.version}</version>`,
+                `	                    </path>`,
+                `	                </annotationProcessorPaths>`,
+                `	            </configuration>`,
+                `	        </plugin>`,
+                `	        <plugin>`,
+                `	            <groupId>org.apache.maven.plugins</groupId>`,
+                `	            <artifactId>maven-jar-plugin</artifactId>`,
+                `	            <version>3.2.0</version>`,
+                `	            <configuration>`,
+                `	                <archive>`,
+                `	                    <manifestEntries>`,
+                `	                        <Dependencies>`,
+                `	                            <![CDATA[org.keycloak.keycloak-common,org.keycloak.keycloak-core,org.keycloak.keycloak-server-spi,org.keycloak.keycloak-server-spi-private,org.keycloak.keycloak-services,com.google.guava]]>`,
+                `	                        </Dependencies>`,
+                `	                    </manifestEntries>`,
+                `	                </archive>`,
+                `	            </configuration>`,
+                `	        </plugin>`,
+                `	        <plugin>`,
+                `	            <groupId>com.spotify.fmt</groupId>`,
+                `	            <artifactId>fmt-maven-plugin</artifactId>`,
+                `	            <version>2.20</version>`,
+                `	        </plugin>`,
+                `	    </plugins>`,
+                `	</build>`,
+                `	<dependencies>`,
+                `	    <dependency>`,
+                `	        <groupId>org.projectlombok</groupId>`,
+                `	        <artifactId>lombok</artifactId>`,
+                `	        <version>\${lombok.version}</version>`,
+                `	        <scope>provided</scope>`,
+                `	    </dependency>`,
+                `	    <dependency>`,
+                `	        <groupId>com.google.auto.service</groupId>`,
+                `	        <artifactId>auto-service</artifactId>`,
+                `	        <version>\${auto-service.version}</version>`,
+                `	        <scope>provided</scope>`,
+                `	    </dependency>`,
+                `	    <dependency>`,
+                `	        <groupId>org.keycloak</groupId>`,
+                `	        <artifactId>keycloak-server-spi</artifactId>`,
+                `	        <version>\${keycloak.version}</version>`,
+                `	        <scope>provided</scope>`,
+                `	    </dependency>`,
+                `	    <dependency>`,
+                `	        <groupId>org.keycloak</groupId>`,
+                `	        <artifactId>keycloak-server-spi-private</artifactId>`,
+                `	        <version>\${keycloak.version}</version>`,
+                `	        <scope>provided</scope>`,
+                `	    </dependency>`,
+                `	    <dependency>`,
+                `	        <groupId>org.keycloak</groupId>`,
+                `	        <artifactId>keycloak-services</artifactId>`,
+                `	        <version>\${keycloak.version}</version>`,
+                `	        <scope>provided</scope>`,
+                `	    </dependency>`,
+                `	    <dependency>`,
+                `	        <groupId>jakarta.ws.rs</groupId>`,
+                `	        <artifactId>jakarta.ws.rs-api</artifactId>`,
+                `	        <version>3.1.0</version>`,
+                `	        <scope>provided</scope>`,
+                `	    </dependency>`,
+                `	    <dependency>`,
+                `	        <groupId>com.google.guava</groupId>`,
+                `	        <artifactId>guava</artifactId>`,
+                `	        <version>\${guava.version}</version>`,
+                `	        <scope>provided</scope>`,
+                `	    </dependency>`,
+                `	</dependencies>`,
+                `</project>`
+            ].join("\n");
+
+            return { pomFileCode };
+        })();
+
+        fs.writeFileSync(pathJoin(buildOptions.keycloakifyBuildDirPath, "pom.xml"), Buffer.from(pomFileCode, "utf8"));
+    }
+
+    if (implementedThemeTypes.account) {
+        await bringInAccountV1({ buildOptions });
+    }
+
+    {
+        const themeManifestFilePath = pathJoin(buildOptions.keycloakifyBuildDirPath, "src", "main", "resources", "META-INF", "keycloak-themes.json");
+
+        try {
+            fs.mkdirSync(pathDirname(themeManifestFilePath));
+        } catch {}
+
+        fs.writeFileSync(
+            themeManifestFilePath,
+            Buffer.from(
+                JSON.stringify(
+                    {
+                        "themes": [
+                            ...(!implementedThemeTypes.account
+                                ? []
+                                : [
+                                      {
+                                          "name": accountV1,
+                                          "types": ["account"]
+                                      }
+                                  ]),
+                            ...buildOptions.themeNames
+                                .map(themeName => [
+                                    {
+                                        "name": themeName,
+                                        "types": Object.entries(implementedThemeTypes)
+                                            .filter(([, isImplemented]) => isImplemented)
+                                            .map(([themeType]) => themeType)
+                                    },
+                                    ...(!implementedThemeTypes.account
+                                        ? []
+                                        : [
+                                              {
+                                                  "name": `${themeName}${retrocompatPostfix}`,
+                                                  "types": ["account"]
+                                              }
+                                          ])
+                                ])
+                                .flat()
+                        ]
+                    },
+                    null,
+                    2
+                ),
+                "utf8"
+            )
+        );
+    }
+
+    return {
+        "jarFilePath": pathJoin(buildOptions.keycloakifyBuildDirPath, "target", `${buildOptions.artifactId}-${buildOptions.themeVersion}.jar`)
+    };
+}

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

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

package/src/bin/keycloakify/generateStartKeycloakTestingContainer.ts

@@ -1,53 +1,52 @@
 import * as fs from "fs";
 import { join as pathJoin } from "path";
 import { assert } from "tsafe/assert";
+import { Reflect } from "tsafe/Reflect";
 import type { BuildOptions } from "./BuildOptions";
 
 export type BuildOptionsLike = {
-    themeName: string;
-    extraThemeNames: string[];
+    keycloakifyBuildDirPath: string;
 };
 
-assert<BuildOptions extends BuildOptionsLike ? true : false>();
+{
+    const buildOptions = Reflect<BuildOptions>();
+
+    assert<typeof buildOptions extends BuildOptionsLike ? true : false>();
+}
 
 generateStartKeycloakTestingContainer.basename = "start_keycloak_testing_container.sh";
 
 const containerName = "keycloak-testing-container";
 
 /** Files for being able to run a hot reload keycloak container */
-export function generateStartKeycloakTestingContainer(params: {
-    keycloakVersion: string;
-    keycloakThemeBuildingDirPath: string;
-    buildOptions: BuildOptionsLike;
-}) {
-    const {
-        keycloakThemeBuildingDirPath,
-        keycloakVersion,
-        buildOptions: { themeName, extraThemeNames }
-    } = params;
+export function generateStartKeycloakTestingContainer(params: { keycloakVersion: string; buildOptions: BuildOptionsLike }) {
+    const { keycloakVersion, buildOptions } = params;
+
+    const themeRelativeDirPath = pathJoin("src", "main", "resources", "theme");
+    const themeDirPath = pathJoin(buildOptions.keycloakifyBuildDirPath, themeRelativeDirPath);
 
     fs.writeFileSync(
-        pathJoin(keycloakThemeBuildingDirPath, generateStartKeycloakTestingContainer.basename),
+        pathJoin(buildOptions.keycloakifyBuildDirPath, generateStartKeycloakTestingContainer.basename),
         Buffer.from(
             [
                 "#!/usr/bin/env bash",
                 "",
                 `docker rm ${containerName} || true`,
                 "",
-                `cd "${keycloakThemeBuildingDirPath.replace(/\\/g, "/")}"`,
+                `cd "${buildOptions.keycloakifyBuildDirPath}"`,
                 "",
                 "docker run \\",
                 "   -p 8080:8080 \\",
                 `   --name ${containerName} \\`,
                 "   -e KEYCLOAK_ADMIN=admin \\",
                 "   -e KEYCLOAK_ADMIN_PASSWORD=admin \\",
-                ...[themeName, ...extraThemeNames].map(
-                    themeName =>
-                        `   -v "${pathJoin(keycloakThemeBuildingDirPath, "src", "main", "resources", "theme", themeName).replace(
-                            /\\/g,
-                            "/"
-                        )}":"/opt/keycloak/themes/${themeName}":rw \\`
-                ),
+                ...fs
+                    .readdirSync(themeDirPath)
+                    .filter(name => fs.lstatSync(pathJoin(themeDirPath, name)).isDirectory())
+                    .map(
+                        themeName =>
+                            `   -v "${pathJoin(".", themeRelativeDirPath, themeName).replace(/\\/g, "/")}":"/opt/keycloak/themes/${themeName}":rw \\`
+                    ),
                 `   -it quay.io/keycloak/keycloak:${keycloakVersion} \\`,
                 `   start-dev --features=declarative-user-profile`,
                 ""

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

@@ -1,45 +1,49 @@
 import { transformCodebase } from "../../tools/transformCodebase";
 import * as fs from "fs";
-import { join as pathJoin, relative as pathRelative } from "path";
-import type { ThemeType } from "../generateFtl";
+import { join as pathJoin } from "path";
 import { downloadBuiltinKeycloakTheme } from "../../download-builtin-keycloak-theme";
-import {
-    resourcesCommonDirPathRelativeToPublicDir,
-    resourcesDirPathRelativeToPublicDir,
-    basenameOfKeycloakDirInPublicDir
-} from "../../mockTestingResourcesPath";
+import { resources_common, type ThemeType } from "../../constants";
+import { BuildOptions } from "../BuildOptions";
+import { assert } from "tsafe/assert";
 import * as crypto from "crypto";
 
+export type BuildOptionsLike = {
+    cacheDirPath: string;
+};
+
+assert<BuildOptions extends BuildOptionsLike ? true : false>();
+
 export async function downloadKeycloakStaticResources(
     // prettier-ignore
     params: {
-        projectDirPath: string;
         themeType: ThemeType;
         themeDirPath: string;
         keycloakVersion: string;
         usedResources: {
             resourcesCommonFilePaths: string[];
             resourcesFilePaths: string[];
-        } | undefined
+        } | undefined;
+        buildOptions: BuildOptionsLike;
     }
 ) {
-    const { projectDirPath, themeType, themeDirPath, keycloakVersion, usedResources } = params;
+    const { themeType, themeDirPath, keycloakVersion, usedResources, buildOptions } = params;
 
     const tmpDirPath = pathJoin(
         themeDirPath,
-        "..",
         `tmp_suLeKsxId_${crypto.createHash("sha256").update(`${themeType}-${keycloakVersion}`).digest("hex").slice(0, 8)}`
     );
 
     await downloadBuiltinKeycloakTheme({
-        projectDirPath,
         keycloakVersion,
-        "destDirPath": tmpDirPath
+        "destDirPath": tmpDirPath,
+        buildOptions
     });
 
+    const resourcesPath = pathJoin(themeDirPath, themeType, "resources");
+
     transformCodebase({
         "srcDirPath": pathJoin(tmpDirPath, "keycloak", themeType, "resources"),
-        "destDirPath": pathJoin(themeDirPath, pathRelative(basenameOfKeycloakDirInPublicDir, resourcesDirPathRelativeToPublicDir)),
+        "destDirPath": resourcesPath,
         "transformSourceCode":
             usedResources === undefined
                 ? undefined
@@ -54,7 +58,7 @@ export async function downloadKeycloakStaticResources(
 
     transformCodebase({
         "srcDirPath": pathJoin(tmpDirPath, "keycloak", "common", "resources"),
-        "destDirPath": pathJoin(themeDirPath, pathRelative(basenameOfKeycloakDirInPublicDir, resourcesCommonDirPathRelativeToPublicDir)),
+        "destDirPath": pathJoin(resourcesPath, resources_common),
         "transformSourceCode":
             usedResources === undefined
                 ? undefined

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

@@ -1,4 +1,4 @@
-import type { ThemeType } from "../generateFtl";
+import type { ThemeType } from "../../constants";
 import { crawl } from "../../tools/crawl";
 import { join as pathJoin } from "path";
 import { readFileSync } from "fs";