keycloakify 10.0.0-rc.99 → 10.0.0

package/src/bin/shared/buildContext.ts

@@ -13,18 +13,17 @@ import * as fs from "fs";
 import { assert, type Equals } from "tsafe/assert";
 import * as child_process from "child_process";
 import {
-    vitePluginSubScriptEnvNames,
-    buildForKeycloakMajorVersionEnvName
+    VITE_PLUGIN_SUB_SCRIPTS_ENV_NAMES,
+    BUILD_FOR_KEYCLOAK_MAJOR_VERSION_ENV_NAME,
+    LOGIN_THEME_RESOURCES_FROMkEYCLOAK_VERSION_DEFAULT
 } from "./constants";
 import type { KeycloakVersionRange } from "./KeycloakVersionRange";
 import { exclude } from "tsafe";
 import { crawl } from "../tools/crawl";
-import { themeTypes } from "./constants";
-import { objectFromEntries } from "tsafe/objectFromEntries";
+import { THEME_TYPES } from "./constants";
 import { objectEntries } from "tsafe/objectEntries";
 import { type ThemeType } from "./constants";
 import { id } from "tsafe/id";
-import { symToStr } from "tsafe/symToStr";
 import chalk from "chalk";
 import { getProxyFetchOptions, type ProxyFetchOptions } from "../tools/fetchProxyOptions";
 
@@ -49,22 +48,36 @@ export type BuildContext = {
     kcContextExclusionsFtlCode: string | undefined;
     environmentVariables: { name: string; default: string }[];
     themeSrcDirPath: string;
-    recordIsImplementedByThemeType: Readonly<Record<ThemeType | "email", boolean>>;
+    implementedThemeTypes: {
+        login: { isImplemented: boolean };
+        email: { isImplemented: boolean };
+        account:
+            | { isImplemented: false }
+            | { isImplemented: true; type: "Single-Page" | "Multi-Page" };
+    };
+    packageJsonFilePath: string;
+    bundler: "vite" | "webpack";
     jarTargets: {
         keycloakVersionRange: KeycloakVersionRange;
         jarFileBasename: string;
     }[];
-    bundler:
-        | {
-              type: "vite";
-          }
-        | {
-              type: "webpack";
-              packageJsonDirPath: string;
-              packageJsonScripts: Record<string, string>;
-          };
+    startKeycloakOptions: {
+        dockerImage:
+            | {
+                  reference: string;
+                  tag: string;
+              }
+            | undefined;
+        dockerExtraArgs: string[];
+        keycloakExtraArgs: string[];
+        extensionJars: ({ type: "path"; path: string } | { type: "url"; url: string })[];
+        realmJsonFilePath: string | undefined;
+        port: number | undefined;
+    };
 };
 
+assert<Equals<keyof BuildContext["implementedThemeTypes"], ThemeType | "email">>();
+
 export type BuildOptions = {
     themeName?: string | string[];
     themeVersion?: string;
@@ -75,20 +88,38 @@ export type BuildOptions = {
     loginThemeResourcesFromKeycloakVersion?: string;
     keycloakifyBuildDirPath?: string;
     kcContextExclusionsFtl?: string;
-    /** https://docs.keycloakify.dev/v/v10/targetting-specific-keycloak-versions */
-    keycloakVersionTargets?: BuildOptions.KeycloakVersionTargets;
-};
+    startKeycloakOptions?: {
+        dockerImage?: string;
+        dockerExtraArgs?: string[];
+        keycloakExtraArgs?: string[];
+        extensionJars?: string[];
+        realmJsonFilePath?: string;
+        port?: number;
+    };
+} & BuildOptions.AccountThemeImplAndKeycloakVersionTargets;
 
 export namespace BuildOptions {
-    export type KeycloakVersionTargets =
-        | ({ hasAccountTheme: true } & Record<
-              KeycloakVersionRange.WithAccountTheme,
-              string | boolean
-          >)
-        | ({ hasAccountTheme: false } & Record<
-              KeycloakVersionRange.WithoutAccountTheme,
-              string | boolean
-          >);
+    export type AccountThemeImplAndKeycloakVersionTargets =
+        | AccountThemeImplAndKeycloakVersionTargets.MultiPageApp
+        | AccountThemeImplAndKeycloakVersionTargets.SinglePageAppOrNone;
+
+    export namespace AccountThemeImplAndKeycloakVersionTargets {
+        export type MultiPageApp = {
+            accountThemeImplementation: "Multi-Page";
+            keycloakVersionTargets?: Record<
+                KeycloakVersionRange.WithAccountV1Theme,
+                string | boolean
+            >;
+        };
+
+        export type SinglePageAppOrNone = {
+            accountThemeImplementation: "Single-Page" | "none";
+            keycloakVersionTargets?: Record<
+                KeycloakVersionRange.WithoutAccountV1Theme,
+                string | boolean
+            >;
+        };
+    }
 }
 
 export type ResolvedViteConfig = {
@@ -134,7 +165,7 @@ export function getBuildContext(params: {
             return { themeSrcDirPath };
         }
 
-        for (const themeType of [...themeTypes, "email"]) {
+        for (const themeType of [...THEME_TYPES, "email"]) {
             if (!fs.existsSync(pathJoin(srcDirPath, themeType))) {
                 continue;
             }
@@ -169,18 +200,18 @@ export function getBuildContext(params: {
                 cwd: projectDirPath,
                 env: {
                     ...process.env,
-                    [vitePluginSubScriptEnvNames.resolveViteConfig]: "true"
+                    [VITE_PLUGIN_SUB_SCRIPTS_ENV_NAMES.RESOLVE_VITE_CONFIG]: "true"
                 }
             })
             .toString("utf8");
 
         assert(
-            output.includes(vitePluginSubScriptEnvNames.resolveViteConfig),
+            output.includes(VITE_PLUGIN_SUB_SCRIPTS_ENV_NAMES.RESOLVE_VITE_CONFIG),
             "Seems like the Keycloakify's Vite plugin is not installed."
         );
 
         const resolvedViteConfigStr = output
-            .split(vitePluginSubScriptEnvNames.resolveViteConfig)
+            .split(VITE_PLUGIN_SUB_SCRIPTS_ENV_NAMES.RESOLVE_VITE_CONFIG)
             .reverse()[0];
 
         const resolvedViteConfig: ResolvedViteConfig = JSON.parse(resolvedViteConfigStr);
@@ -238,84 +269,138 @@ export function getBuildContext(params: {
             keycloakify?: BuildOptions_packageJson;
         };
 
-        const zParsedPackageJson = z.object({
-            name: z.string().optional(),
-            version: z.string().optional(),
-            homepage: z.string().optional(),
-            keycloakify: id<z.ZodType<BuildOptions_packageJson>>(
-                (() => {
-                    const zBuildOptions_packageJson = z.object({
-                        extraThemeProperties: z.array(z.string()).optional(),
-                        artifactId: z.string().optional(),
-                        groupId: z.string().optional(),
-                        loginThemeResourcesFromKeycloakVersion: z.string().optional(),
-                        projectBuildDirPath: z.string().optional(),
-                        keycloakifyBuildDirPath: z.string().optional(),
-                        kcContextExclusionsFtl: z.string().optional(),
-                        environmentVariables: z
-                            .array(
-                                z.object({
-                                    name: z.string(),
-                                    default: z.string()
-                                })
-                            )
-                            .optional(),
-                        themeName: z.union([z.string(), z.array(z.string())]).optional(),
-                        themeVersion: z.string().optional(),
-                        staticDirPathInProjectBuildDirPath: z.string().optional(),
-                        publicDirPath: z.string().optional(),
-                        keycloakVersionTargets: id<
-                            z.ZodType<BuildOptions.KeycloakVersionTargets>
-                        >(
-                            (() => {
-                                const zKeycloakVersionTargets = z.union([
-                                    z.object({
-                                        hasAccountTheme: z.literal(true),
-                                        "21-and-below": z.union([
-                                            z.boolean(),
-                                            z.string()
-                                        ]),
-                                        "23": z.union([z.boolean(), z.string()]),
-                                        "24": z.union([z.boolean(), z.string()]),
-                                        "25-and-above": z.union([z.boolean(), z.string()])
-                                    }),
-                                    z.object({
-                                        hasAccountTheme: z.literal(false),
-                                        "21-and-below": z.union([
-                                            z.boolean(),
-                                            z.string()
-                                        ]),
-                                        "22-and-above": z.union([z.boolean(), z.string()])
-                                    })
-                                ]);
-
-                                {
-                                    type Got = z.infer<typeof zKeycloakVersionTargets>;
-                                    type Expected = BuildOptions.KeycloakVersionTargets;
-                                    assert<Equals<Got, Expected>>();
-                                }
-
-                                return zKeycloakVersionTargets;
-                            })()
-                        ).optional()
-                    });
+        const zMultiPageApp = (() => {
+            type TargetType =
+                BuildOptions.AccountThemeImplAndKeycloakVersionTargets.MultiPageApp;
+
+            const zTargetType = z.object({
+                accountThemeImplementation: z.literal("Multi-Page"),
+                keycloakVersionTargets: z
+                    .object({
+                        "21-and-below": z.union([z.boolean(), z.string()]),
+                        "23": z.union([z.boolean(), z.string()]),
+                        "24": z.union([z.boolean(), z.string()]),
+                        "25-and-above": z.union([z.boolean(), z.string()])
+                    })
+                    .optional()
+            });
+
+            assert<Equals<z.infer<typeof zTargetType>, TargetType>>();
+
+            return id<z.ZodType<TargetType>>(zTargetType);
+        })();
 
-                    {
-                        type Got = z.infer<typeof zBuildOptions_packageJson>;
-                        type Expected = BuildOptions_packageJson;
-                        assert<Equals<Got, Expected>>();
-                    }
+        const zSinglePageApp = (() => {
+            type TargetType =
+                BuildOptions.AccountThemeImplAndKeycloakVersionTargets.SinglePageAppOrNone;
+
+            const zTargetType = z.object({
+                accountThemeImplementation: z.union([
+                    z.literal("Single-Page"),
+                    z.literal("none")
+                ]),
+                keycloakVersionTargets: z
+                    .object({
+                        "21-and-below": z.union([z.boolean(), z.string()]),
+                        "22-and-above": z.union([z.boolean(), z.string()])
+                    })
+                    .optional()
+            });
+
+            assert<Equals<z.infer<typeof zTargetType>, TargetType>>();
+
+            return id<z.ZodType<TargetType>>(zTargetType);
+        })();
 
-                    return zBuildOptions_packageJson;
-                })()
-            ).optional()
-        });
+        const zAccountThemeImplAndKeycloakVersionTargets = (() => {
+            type TargetType = BuildOptions.AccountThemeImplAndKeycloakVersionTargets;
 
-        {
-            type Got = z.infer<typeof zParsedPackageJson>;
-            type Expected = ParsedPackageJson;
-            assert<Equals<Got, Expected>>();
-        }
+            const zTargetType = z.union([zMultiPageApp, zSinglePageApp]);
+
+            assert<Equals<z.infer<typeof zTargetType>, TargetType>>();
+
+            return id<z.ZodType<TargetType>>(zTargetType);
+        })();
+
+        const zStartKeycloakOptions = (() => {
+            type TargetType = NonNullable<BuildOptions["startKeycloakOptions"]>;
+
+            const zTargetType = z.object({
+                dockerImage: z.string().optional(),
+                extensionJars: z.array(z.string()).optional(),
+                realmJsonFilePath: z.string().optional(),
+                dockerExtraArgs: z.array(z.string()).optional(),
+                keycloakExtraArgs: z.array(z.string()).optional(),
+                port: z.number().optional()
+            });
+
+            assert<Equals<z.infer<typeof zTargetType>, TargetType>>();
+
+            return id<z.ZodType<TargetType>>(zTargetType);
+        })();
+
+        const zBuildOptions = (() => {
+            type TargetType = BuildOptions;
+
+            const zTargetType = z.intersection(
+                z.object({
+                    themeName: z.union([z.string(), z.array(z.string())]).optional(),
+                    themeVersion: z.string().optional(),
+                    environmentVariables: z
+                        .array(
+                            z.object({
+                                name: z.string(),
+                                default: z.string()
+                            })
+                        )
+                        .optional(),
+                    extraThemeProperties: z.array(z.string()).optional(),
+                    artifactId: z.string().optional(),
+                    groupId: z.string().optional(),
+                    loginThemeResourcesFromKeycloakVersion: z.string().optional(),
+                    keycloakifyBuildDirPath: z.string().optional(),
+                    kcContextExclusionsFtl: z.string().optional(),
+                    startKeycloakOptions: zStartKeycloakOptions.optional()
+                }),
+                zAccountThemeImplAndKeycloakVersionTargets
+            );
+
+            assert<Equals<z.infer<typeof zTargetType>, TargetType>>();
+
+            return id<z.ZodType<TargetType>>(zTargetType);
+        })();
+
+        const zBuildOptions_packageJson = (() => {
+            type TargetType = BuildOptions_packageJson;
+
+            const zTargetType = z.intersection(
+                zBuildOptions,
+                z.object({
+                    projectBuildDirPath: z.string().optional(),
+                    staticDirPathInProjectBuildDirPath: z.string().optional(),
+                    publicDirPath: z.string().optional()
+                })
+            );
+
+            assert<Equals<z.infer<typeof zTargetType>, TargetType>>();
+
+            return id<z.ZodType<TargetType>>(zTargetType);
+        })();
+
+        const zParsedPackageJson = (() => {
+            type TargetType = ParsedPackageJson;
+
+            const zTargetType = z.object({
+                name: z.string().optional(),
+                version: z.string().optional(),
+                homepage: z.string().optional(),
+                keycloakify: zBuildOptions_packageJson.optional()
+            });
+
+            assert<Equals<z.infer<typeof zTargetType>, TargetType>>();
+
+            return id<z.ZodType<TargetType>>(zTargetType);
+        })();
 
         const configurationPackageJsonFilePath = (() => {
             const rootPackageJsonFilePath = pathJoin(projectDirPath, "package.json");
@@ -330,17 +415,63 @@ export function getBuildContext(params: {
         );
     })();
 
-    const buildOptions = {
-        ...parsedPackageJson.keycloakify,
-        ...resolvedViteConfig?.buildOptions
+    const bundler = resolvedViteConfig !== undefined ? "vite" : "webpack";
+
+    if (bundler === "vite" && parsedPackageJson.keycloakify !== undefined) {
+        console.error(
+            chalk.red(
+                `In vite projects, provide your Keycloakify options in vite.config.ts, not in package.json`
+            )
+        );
+        process.exit(-1);
+    }
+
+    const buildOptions: BuildOptions = (() => {
+        switch (bundler) {
+            case "vite":
+                assert(resolvedViteConfig !== undefined);
+                return resolvedViteConfig.buildOptions;
+            case "webpack":
+                assert(parsedPackageJson.keycloakify !== undefined);
+                return parsedPackageJson.keycloakify;
+        }
+        assert<Equals<typeof bundler, never>>(false);
+    })();
+
+    const implementedThemeTypes: BuildContext["implementedThemeTypes"] = {
+        login: {
+            isImplemented: fs.existsSync(pathJoin(themeSrcDirPath, "login"))
+        },
+        email: {
+            isImplemented: fs.existsSync(pathJoin(themeSrcDirPath, "email"))
+        },
+        account: (() => {
+            if (buildOptions.accountThemeImplementation === "none") {
+                return { isImplemented: false };
+            }
+
+            return {
+                isImplemented: true,
+                type: buildOptions.accountThemeImplementation
+            };
+        })()
     };
 
-    const recordIsImplementedByThemeType = objectFromEntries(
-        (["login", "account", "email"] as const).map(themeType => [
-            themeType,
-            fs.existsSync(pathJoin(themeSrcDirPath, themeType))
-        ])
-    );
+    if (
+        implementedThemeTypes.account.isImplemented &&
+        !fs.existsSync(pathJoin(themeSrcDirPath, "account"))
+    ) {
+        console.error(
+            chalk.red(
+                [
+                    `You have set 'accountThemeImplementation' to '${implementedThemeTypes.account.type}'`,
+                    `but the 'account' directory is missing in your theme source directory`,
+                    "Use the `npx keycloakify initialize-account-theme` command to create it"
+                ].join(" ")
+            )
+        );
+        process.exit(-1);
+    }
 
     const themeNames = ((): [string, ...string[]] => {
         if (buildOptions.themeName === undefined) {
@@ -367,13 +498,15 @@ export function getBuildContext(params: {
 
     const projectBuildDirPath = (() => {
         webpack: {
-            if (resolvedViteConfig !== undefined) {
+            if (bundler !== "webpack") {
                 break webpack;
             }
 
-            if (buildOptions.projectBuildDirPath !== undefined) {
+            assert(parsedPackageJson.keycloakify !== undefined);
+
+            if (parsedPackageJson.keycloakify.projectBuildDirPath !== undefined) {
                 return getAbsoluteAndInOsFormatPath({
-                    pathIsh: buildOptions.projectBuildDirPath,
+                    pathIsh: parsedPackageJson.keycloakify.projectBuildDirPath,
                     cwd: projectDirPath
                 });
             }
@@ -381,32 +514,15 @@ export function getBuildContext(params: {
             return pathJoin(projectDirPath, "build");
         }
 
+        assert(bundler === "vite");
+        assert(resolvedViteConfig !== undefined);
+
         return pathJoin(projectDirPath, resolvedViteConfig.buildDir);
     })();
 
-    const bundler = resolvedViteConfig !== undefined ? "vite" : "webpack";
-
     return {
-        bundler:
-            resolvedViteConfig !== undefined
-                ? { type: "vite" }
-                : (() => {
-                      const { scripts } = z
-                          .object({
-                              scripts: z.record(z.string()).optional()
-                          })
-                          .parse(
-                              JSON.parse(
-                                  fs.readFileSync(packageJsonFilePath).toString("utf8")
-                              )
-                          );
-
-                      return {
-                          type: "webpack",
-                          packageJsonDirPath: pathDirname(packageJsonFilePath),
-                          packageJsonScripts: scripts ?? {}
-                      };
-                  })(),
+        bundler,
+        packageJsonFilePath,
         themeVersion: buildOptions.themeVersion ?? parsedPackageJson.version ?? "0.0.0",
         themeNames,
         extraThemeProperties: buildOptions.extraThemeProperties,
@@ -430,7 +546,8 @@ export function getBuildContext(params: {
             buildOptions.artifactId ??
             `${themeNames[0]}-keycloak-theme`,
         loginThemeResourcesFromKeycloakVersion:
-            buildOptions.loginThemeResourcesFromKeycloakVersion ?? "24.0.4",
+            buildOptions.loginThemeResourcesFromKeycloakVersion ??
+            LOGIN_THEME_RESOURCES_FROMkEYCLOAK_VERSION_DEFAULT,
         projectDirPath,
         projectBuildDirPath,
         keycloakifyBuildDirPath: (() => {
@@ -457,13 +574,15 @@ export function getBuildContext(params: {
             }
 
             webpack: {
-                if (resolvedViteConfig !== undefined) {
+                if (bundler !== "webpack") {
                     break webpack;
                 }
 
-                if (buildOptions.publicDirPath !== undefined) {
+                assert(parsedPackageJson.keycloakify !== undefined);
+
+                if (parsedPackageJson.keycloakify.publicDirPath !== undefined) {
                     return getAbsoluteAndInOsFormatPath({
-                        pathIsh: buildOptions.publicDirPath,
+                        pathIsh: parsedPackageJson.keycloakify.publicDirPath,
                         cwd: projectDirPath
                     });
                 }
@@ -471,32 +590,31 @@ export function getBuildContext(params: {
                 return pathJoin(projectDirPath, "public");
             }
 
+            assert(bundler === "vite");
+            assert(resolvedViteConfig !== undefined);
+
             return pathJoin(projectDirPath, resolvedViteConfig.publicDir);
         })(),
-        cacheDirPath: (() => {
-            const cacheDirPath = pathJoin(
-                (() => {
-                    if (process.env.XDG_CACHE_HOME !== undefined) {
-                        return getAbsoluteAndInOsFormatPath({
-                            pathIsh: process.env.XDG_CACHE_HOME,
-                            cwd: process.cwd()
-                        });
-                    }
-
-                    return pathJoin(
-                        pathDirname(packageJsonFilePath),
-                        "node_modules",
-                        ".cache"
-                    );
-                })(),
-                "keycloakify"
-            );
+        cacheDirPath: pathJoin(
+            (() => {
+                if (process.env.XDG_CACHE_HOME !== undefined) {
+                    return getAbsoluteAndInOsFormatPath({
+                        pathIsh: process.env.XDG_CACHE_HOME,
+                        cwd: process.cwd()
+                    });
+                }
 
-            return cacheDirPath;
-        })(),
+                return pathJoin(
+                    pathDirname(packageJsonFilePath),
+                    "node_modules",
+                    ".cache"
+                );
+            })(),
+            "keycloakify"
+        ),
         urlPathname: (() => {
             webpack: {
-                if (resolvedViteConfig !== undefined) {
+                if (bundler !== "webpack") {
                     break webpack;
                 }
 
@@ -516,23 +634,35 @@ export function getBuildContext(params: {
                 return out === "/" ? undefined : out;
             }
 
+            assert(bundler === "vite");
+            assert(resolvedViteConfig !== undefined);
+
             return resolvedViteConfig.urlPathname;
         })(),
         assetsDirPath: (() => {
             webpack: {
-                if (resolvedViteConfig !== undefined) {
+                if (bundler !== "webpack") {
                     break webpack;
                 }
 
-                if (buildOptions.staticDirPathInProjectBuildDirPath !== undefined) {
+                assert(parsedPackageJson.keycloakify !== undefined);
+
+                if (
+                    parsedPackageJson.keycloakify.staticDirPathInProjectBuildDirPath !==
+                    undefined
+                ) {
                     getAbsoluteAndInOsFormatPath({
-                        pathIsh: buildOptions.staticDirPathInProjectBuildDirPath,
+                        pathIsh:
+                            parsedPackageJson.keycloakify
+                                .staticDirPathInProjectBuildDirPath,
                         cwd: projectBuildDirPath
                     });
                 }
 
                 return pathJoin(projectBuildDirPath, "static");
             }
+            assert(bundler === "vite");
+            assert(resolvedViteConfig !== undefined);
 
             return pathJoin(projectBuildDirPath, resolvedViteConfig.assetsDir);
         })(),
@@ -553,7 +683,7 @@ export function getBuildContext(params: {
             return buildOptions.kcContextExclusionsFtl;
         })(),
         environmentVariables: buildOptions.environmentVariables ?? [],
-        recordIsImplementedByThemeType,
+        implementedThemeTypes,
         themeSrcDirPath,
         fetchOptions: getProxyFetchOptions({
             npmConfigGetCwd: (function callee(upCount: number): string {
@@ -569,7 +699,7 @@ export function getBuildContext(params: {
                 try {
                     child_process.execSync("npm config get", {
                         cwd: dirPath,
-                        stdio: "ignore"
+                        stdio: "pipe"
                     });
                 } catch (error) {
                     if (String(error).includes("ENOWORKSPACES")) {
@@ -588,7 +718,8 @@ export function getBuildContext(params: {
 
             build_for_specific_keycloak_major_version: {
                 const buildForKeycloakMajorVersionNumber = (() => {
-                    const envValue = process.env[buildForKeycloakMajorVersionEnvName];
+                    const envValue =
+                        process.env[BUILD_FOR_KEYCLOAK_MAJOR_VERSION_ENV_NAME];
 
                     if (envValue === undefined) {
                         return undefined;
@@ -606,10 +737,10 @@ export function getBuildContext(params: {
                 }
 
                 const keycloakVersionRange: KeycloakVersionRange = (() => {
-                    const doesImplementAccountTheme =
-                        recordIsImplementedByThemeType.account;
-
-                    if (doesImplementAccountTheme) {
+                    if (
+                        implementedThemeTypes.account.isImplemented &&
+                        implementedThemeTypes.account.type === "Multi-Page"
+                    ) {
                         const keycloakVersionRange = (() => {
                             if (buildForKeycloakMajorVersionNumber <= 21) {
                                 return "21-and-below" as const;
@@ -631,7 +762,7 @@ export function getBuildContext(params: {
                         assert<
                             Equals<
                                 typeof keycloakVersionRange,
-                                KeycloakVersionRange.WithAccountTheme
+                                KeycloakVersionRange.WithAccountV1Theme
                             >
                         >();
 
@@ -648,7 +779,7 @@ export function getBuildContext(params: {
                         assert<
                             Equals<
                                 typeof keycloakVersionRange,
-                                KeycloakVersionRange.WithoutAccountTheme
+                                KeycloakVersionRange.WithoutAccountV1Theme
                             >
                         >();
 
@@ -696,7 +827,10 @@ export function getBuildContext(params: {
             const jarTargets_default = (() => {
                 const jarTargets: BuildContext["jarTargets"] = [];
 
-                if (recordIsImplementedByThemeType.account) {
+                if (
+                    implementedThemeTypes.account.isImplemented &&
+                    implementedThemeTypes.account.type === "Multi-Page"
+                ) {
                     for (const keycloakVersionRange of [
                         "21-and-below",
                         "23",
@@ -706,7 +840,7 @@ export function getBuildContext(params: {
                         assert<
                             Equals<
                                 typeof keycloakVersionRange,
-                                KeycloakVersionRange.WithAccountTheme
+                                KeycloakVersionRange.WithAccountV1Theme
                             >
                         >(true);
                         jarTargets.push({
@@ -723,7 +857,7 @@ export function getBuildContext(params: {
                         assert<
                             Equals<
                                 typeof keycloakVersionRange,
-                                KeycloakVersionRange.WithoutAccountTheme
+                                KeycloakVersionRange.WithoutAccountV1Theme
                             >
                         >(true);
                         jarTargets.push({
@@ -741,78 +875,11 @@ export function getBuildContext(params: {
                 return jarTargets_default;
             }
 
-            if (
-                buildOptions.keycloakVersionTargets.hasAccountTheme !==
-                recordIsImplementedByThemeType.account
-            ) {
-                console.log(
-                    chalk.red(
-                        (() => {
-                            const { keycloakVersionTargets } = buildOptions;
-
-                            let message = `Bad ${symToStr({ keycloakVersionTargets })} configuration.\n`;
-
-                            if (keycloakVersionTargets.hasAccountTheme) {
-                                message +=
-                                    "Your codebase does not seem to implement an account theme ";
-                            } else {
-                                message += "Your codebase implements an account theme ";
-                            }
-
-                            const { hasAccountTheme } = keycloakVersionTargets;
-
-                            message += `but you have set ${symToStr({ keycloakVersionTargets })}.${symToStr({ hasAccountTheme })}`;
-                            message += ` to ${hasAccountTheme} in your `;
-                            message += (() => {
-                                switch (bundler) {
-                                    case "vite":
-                                        return "vite.config.ts";
-                                    case "webpack":
-                                        return "package.json";
-                                }
-                                assert<Equals<typeof bundler, never>>(false);
-                            })();
-                            message += `. Please set it to ${!hasAccountTheme} `;
-                            message +=
-                                "and fill up the relevant keycloak version ranges.\n";
-                            message += "Example:\n";
-                            message += JSON.stringify(
-                                id<Pick<BuildOptions, "keycloakVersionTargets">>({
-                                    keycloakVersionTargets: {
-                                        hasAccountTheme:
-                                            recordIsImplementedByThemeType.account,
-                                        ...objectFromEntries(
-                                            jarTargets_default.map(
-                                                ({
-                                                    keycloakVersionRange,
-                                                    jarFileBasename
-                                                }) => [
-                                                    keycloakVersionRange,
-                                                    jarFileBasename
-                                                ]
-                                            )
-                                        )
-                                    }
-                                }),
-                                null,
-                                2
-                            );
-                            message +=
-                                "\nSee: https://docs.keycloakify.dev/v/v10/targetting-specific-keycloak-versions";
-
-                            return message;
-                        })()
-                    )
-                );
-
-                process.exit(1);
-            }
-
             const jarTargets: BuildContext["jarTargets"] = [];
 
-            const { hasAccountTheme, ...rest } = buildOptions.keycloakVersionTargets;
-
-            for (const [keycloakVersionRange, jarNameOrBoolean] of objectEntries(rest)) {
+            for (const [keycloakVersionRange, jarNameOrBoolean] of objectEntries(
+                buildOptions.keycloakVersionTargets
+            )) {
                 if (jarNameOrBoolean === false) {
                     continue;
                 }
@@ -863,6 +930,48 @@ export function getBuildContext(params: {
             }
 
             return jarTargets;
-        })()
+        })(),
+        startKeycloakOptions: {
+            dockerImage: (() => {
+                if (buildOptions.startKeycloakOptions?.dockerImage === undefined) {
+                    return undefined;
+                }
+
+                const [reference, tag, ...rest] =
+                    buildOptions.startKeycloakOptions.dockerImage.split(":");
+
+                assert(
+                    reference !== undefined && tag !== undefined && rest.length === 0,
+                    `Invalid docker image: ${buildOptions.startKeycloakOptions.dockerImage}`
+                );
+
+                return { reference, tag };
+            })(),
+            dockerExtraArgs: buildOptions.startKeycloakOptions?.dockerExtraArgs ?? [],
+            keycloakExtraArgs: buildOptions.startKeycloakOptions?.keycloakExtraArgs ?? [],
+            extensionJars: (buildOptions.startKeycloakOptions?.extensionJars ?? []).map(
+                urlOrPath => {
+                    if (/^https?:\/\//.test(urlOrPath)) {
+                        return { type: "url", url: urlOrPath };
+                    }
+
+                    return {
+                        type: "path",
+                        path: getAbsoluteAndInOsFormatPath({
+                            pathIsh: urlOrPath,
+                            cwd: projectDirPath
+                        })
+                    };
+                }
+            ),
+            realmJsonFilePath:
+                buildOptions.startKeycloakOptions?.realmJsonFilePath === undefined
+                    ? undefined
+                    : getAbsoluteAndInOsFormatPath({
+                          pathIsh: buildOptions.startKeycloakOptions.realmJsonFilePath,
+                          cwd: projectDirPath
+                      }),
+            port: buildOptions.startKeycloakOptions?.port
+        }
     };
 }