keycloakify 10.0.0-rc.5 → 10.0.0-rc.51

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

@@ -1,50 +1,55 @@
 import * as fs from "fs";
 import { join as pathJoin } from "path";
 import { assert } from "tsafe/assert";
-import type { BuildOptions } from "../../shared/buildOptions";
-import { resources_common, lastKeycloakVersionWithAccountV1, accountV1ThemeName } from "../../shared/constants";
-import { downloadBuiltinKeycloakTheme } from "../../shared/downloadBuiltinKeycloakTheme";
+import type { BuildContext } from "../../shared/buildContext";
+import {
+    resources_common,
+    lastKeycloakVersionWithAccountV1,
+    accountV1ThemeName
+} from "../../shared/constants";
+import { downloadKeycloakDefaultTheme } from "../../shared/downloadKeycloakDefaultTheme";
 import { transformCodebase } from "../../tools/transformCodebase";
-import { rmSync } from "../../tools/fs.rmSync";
 
-type BuildOptionsLike = {
+export type BuildContextLike = {
     cacheDirPath: string;
     npmWorkspaceRootDirPath: string;
-    keycloakifyBuildDirPath: string;
 };
 
-assert<BuildOptions extends BuildOptionsLike ? true : false>();
+assert<BuildContext extends BuildContextLike ? true : false>();
 
-export async function bringInAccountV1(params: { buildOptions: BuildOptionsLike }) {
-    const { buildOptions } = params;
+export async function bringInAccountV1(params: {
+    resourcesDirPath: string;
+    buildContext: BuildContextLike;
+}) {
+    const { resourcesDirPath, buildContext } = params;
 
-    const builtinKeycloakThemeTmpDirPath = pathJoin(buildOptions.cacheDirPath, "bringInAccountV1_tmp");
-
-    await downloadBuiltinKeycloakTheme({
-        "destDirPath": builtinKeycloakThemeTmpDirPath,
-        "keycloakVersion": lastKeycloakVersionWithAccountV1,
-        buildOptions
+    const { defaultThemeDirPath } = await downloadKeycloakDefaultTheme({
+        keycloakVersion: lastKeycloakVersionWithAccountV1,
+        buildContext
     });
 
-    const accountV1DirPath = pathJoin(buildOptions.keycloakifyBuildDirPath, "src", "main", "resources", "theme", accountV1ThemeName, "account");
+    const accountV1DirPath = pathJoin(
+        resourcesDirPath,
+        "theme",
+        accountV1ThemeName,
+        "account"
+    );
 
     transformCodebase({
-        "srcDirPath": pathJoin(builtinKeycloakThemeTmpDirPath, "base", "account"),
-        "destDirPath": accountV1DirPath
+        srcDirPath: pathJoin(defaultThemeDirPath, "base", "account"),
+        destDirPath: accountV1DirPath
     });
 
     transformCodebase({
-        "srcDirPath": pathJoin(builtinKeycloakThemeTmpDirPath, "keycloak", "account", "resources"),
-        "destDirPath": pathJoin(accountV1DirPath, "resources")
+        srcDirPath: pathJoin(defaultThemeDirPath, "keycloak", "account", "resources"),
+        destDirPath: pathJoin(accountV1DirPath, "resources")
     });
 
     transformCodebase({
-        "srcDirPath": pathJoin(builtinKeycloakThemeTmpDirPath, "keycloak", "common", "resources"),
-        "destDirPath": pathJoin(accountV1DirPath, "resources", resources_common)
+        srcDirPath: pathJoin(defaultThemeDirPath, "keycloak", "common", "resources"),
+        destDirPath: pathJoin(accountV1DirPath, "resources", resources_common)
     });
 
-    rmSync(builtinKeycloakThemeTmpDirPath, { "recursive": true });
-
     fs.writeFileSync(
         pathJoin(accountV1DirPath, "theme.properties"),
         Buffer.from(
@@ -58,8 +63,13 @@ export async function bringInAccountV1(params: { buildOptions: BuildOptionsLike
                         "css/account.css",
                         "img/icon-sidebar-active.png",
                         "img/logo.png",
-                        ...["patternfly.min.css", "patternfly-additions.min.css", "patternfly-additions.min.css"].map(
-                            fileBasename => `${resources_common}/node_modules/patternfly/dist/css/${fileBasename}`
+                        ...[
+                            "patternfly.min.css",
+                            "patternfly-additions.min.css",
+                            "patternfly-additions.min.css"
+                        ].map(
+                            fileBasename =>
+                                `${resources_common}/node_modules/patternfly/dist/css/${fileBasename}`
                         )
                     ].join(" "),
                 "",

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

@@ -8,6 +8,7 @@ import * as recast from "recast";
 import * as babelParser from "@babel/parser";
 import babelGenerate from "@babel/generator";
 import * as babelTypes from "@babel/types";
+import { escapeStringForPropertiesFile } from "../../tools/escapeStringForPropertiesFile";
 
 export function generateMessageProperties(params: {
     themeSrcDirPath: string;
@@ -16,8 +17,8 @@ export function generateMessageProperties(params: {
     const { themeSrcDirPath, themeType } = params;
 
     let files = crawl({
-        "dirPath": pathJoin(themeSrcDirPath, themeType),
-        "returnedPathsType": "absolute"
+        dirPath: pathJoin(themeSrcDirPath, themeType),
+        returnedPathsType: "absolute"
     });
 
     files = files.filter(file => {
@@ -34,7 +35,9 @@ export function generateMessageProperties(params: {
 
     files = files.sort((a, b) => a.length - b.length);
 
-    files = files.filter(file => readFileSync(file).toString("utf8").includes("createUseI18n"));
+    files = files.filter(file =>
+        readFileSync(file).toString("utf8").includes("createUseI18n")
+    );
 
     if (files.length === 0) {
         return [];
@@ -43,18 +46,25 @@ export function generateMessageProperties(params: {
     const extraMessages = files
         .map(file => {
             const root = recast.parse(readFileSync(file).toString("utf8"), {
-                "parser": {
-                    "parse": (code: string) => babelParser.parse(code, { "sourceType": "module", "plugins": ["typescript"] }),
-                    "generator": babelGenerate,
-                    "types": babelTypes
+                parser: {
+                    parse: (code: string) =>
+                        babelParser.parse(code, {
+                            sourceType: "module",
+                            plugins: ["typescript"]
+                        }),
+                    generator: babelGenerate,
+                    types: babelTypes
                 }
             });
 
             const codes: string[] = [];
 
             recast.visit(root, {
-                "visitCallExpression": function (path) {
-                    if (path.node.callee.type === "Identifier" && path.node.callee.name === "createUseI18n") {
+                visitCallExpression: function (path) {
+                    if (
+                        path.node.callee.type === "Identifier" &&
+                        path.node.callee.name === "createUseI18n"
+                    ) {
                         codes.push(babelGenerate(path.node.arguments[0] as any).code);
                     }
                     this.traverse(path);
@@ -65,7 +75,9 @@ export function generateMessageProperties(params: {
         })
         .flat()
         .map(code => {
-            let extraMessages: { [languageTag: string]: Record<string, string> } = {};
+            let extraMessages: {
+                [languageTag: string]: Record<string, string>;
+            } = {};
 
             try {
                 eval(`${symToStr({ extraMessages })} = ${code}`);
@@ -135,45 +147,21 @@ export function generateMessageProperties(params: {
 
     for (const [languageTag, keyValueMap] of Object.entries(keyValueMapByLanguageTag)) {
         const propertiesFileSource = Object.entries(keyValueMap)
-            .map(([key, value]) => `${key}=${escapeString(value)}`)
+            .map(([key, value]) => `${key}=${escapeStringForPropertiesFile(value)}`)
             .join("\n");
 
         out.push({
             languageTag,
-            "propertiesFileSource": ["# This file was generated by keycloakify", "", "parent=base", "", propertiesFileSource, ""].join("\n")
+            propertiesFileSource: [
+                "# This file was generated by keycloakify",
+                "",
+                "parent=base",
+                "",
+                propertiesFileSource,
+                ""
+            ].join("\n")
         });
     }
 
     return out;
 }
-
-// Convert a JavaScript string to UTF-16 encoding
-function toUTF16(codePoint: number): string {
-    if (codePoint <= 0xffff) {
-        // BMP character
-        return "\\u" + codePoint.toString(16).padStart(4, "0");
-    } else {
-        // Non-BMP character
-        codePoint -= 0x10000;
-        let highSurrogate = (codePoint >> 10) + 0xd800;
-        let lowSurrogate = (codePoint % 0x400) + 0xdc00;
-        return "\\u" + highSurrogate.toString(16).padStart(4, "0") + "\\u" + lowSurrogate.toString(16).padStart(4, "0");
-    }
-}
-
-// Escapes special characters and converts unicode to UTF-16 encoding
-function escapeString(str: string): string {
-    let escapedStr = "";
-    for (const char of [...str]) {
-        const codePoint = char.codePointAt(0);
-        if (!codePoint) continue;
-        if (char === "'") {
-            escapedStr += "''"; // double single quotes
-        } else if (codePoint > 0x7f) {
-            escapedStr += toUTF16(codePoint); // non-ascii characters
-        } else {
-            escapedStr += char;
-        }
-    }
-    return escapedStr;
-}

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

@@ -1,32 +1,42 @@
-import type { BuildOptions } from "../../shared/buildOptions";
+import type { BuildContext } from "../../shared/buildContext";
 import { assert } from "tsafe/assert";
 import {
     generateSrcMainResourcesForMainTheme,
-    type BuildOptionsLike as BuildOptionsLike_generateSrcMainResourcesForMainTheme
+    type BuildContextLike as BuildContextLike_generateSrcMainResourcesForMainTheme
 } from "./generateSrcMainResourcesForMainTheme";
 import { generateSrcMainResourcesForThemeVariant } from "./generateSrcMainResourcesForThemeVariant";
+import fs from "fs";
+import { rmSync } from "../../tools/fs.rmSync";
 
-export type BuildOptionsLike = BuildOptionsLike_generateSrcMainResourcesForMainTheme & {
+export type BuildContextLike = BuildContextLike_generateSrcMainResourcesForMainTheme & {
     themeNames: string[];
 };
 
-assert<BuildOptions extends BuildOptionsLike ? true : false>();
+assert<BuildContext extends BuildContextLike ? true : false>();
 
-export async function generateSrcMainResources(params: { buildOptions: BuildOptionsLike }): Promise<void> {
-    const { buildOptions } = params;
+export async function generateSrcMainResources(params: {
+    buildContext: BuildContextLike;
+    resourcesDirPath: string;
+}): Promise<void> {
+    const { resourcesDirPath, buildContext } = params;
 
-    const [themeName, ...themeVariantNames] = buildOptions.themeNames;
+    const [themeName, ...themeVariantNames] = buildContext.themeNames;
+
+    if (fs.existsSync(resourcesDirPath)) {
+        rmSync(resourcesDirPath, { recursive: true });
+    }
 
     await generateSrcMainResourcesForMainTheme({
+        resourcesDirPath,
         themeName,
-        buildOptions
+        buildContext
     });
 
     for (const themeVariantName of themeVariantNames) {
         generateSrcMainResourcesForThemeVariant({
+            resourcesDirPath,
             themeName,
-            themeVariantName,
-            buildOptions
+            themeVariantName
         });
     }
 }

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

@@ -3,61 +3,77 @@ import * as fs from "fs";
 import { join as pathJoin, resolve as pathResolve } from "path";
 import { replaceImportsInJsCode } from "../replacers/replaceImportsInJsCode";
 import { replaceImportsInCssCode } from "../replacers/replaceImportsInCssCode";
-import { generateFtlFilesCodeFactory } from "../generateFtl";
-import { loginThemePageIds, accountThemePageIds } from "../../shared/pageIds";
+import {
+    generateFtlFilesCodeFactory,
+    type BuildContextLike as BuildContextLike_kcContextExclusionsFtlCode
+} from "../generateFtl";
 import {
     type ThemeType,
     lastKeycloakVersionWithAccountV1,
     keycloak_resources,
     accountV1ThemeName,
-    basenameOfTheKeycloakifyResourcesDir
+    basenameOfTheKeycloakifyResourcesDir,
+    loginThemePageIds,
+    accountThemePageIds
 } from "../../shared/constants";
 import { isInside } from "../../tools/isInside";
-import type { BuildOptions } from "../../shared/buildOptions";
+import type { BuildContext } from "../../shared/buildContext";
 import { assert, type Equals } from "tsafe/assert";
-import { downloadKeycloakStaticResources } from "../../shared/downloadKeycloakStaticResources";
+import {
+    downloadKeycloakStaticResources,
+    type BuildContextLike as BuildContextLike_downloadKeycloakStaticResources
+} from "../../shared/downloadKeycloakStaticResources";
 import { readFieldNameUsage } from "./readFieldNameUsage";
 import { readExtraPagesNames } from "./readExtraPageNames";
 import { generateMessageProperties } from "./generateMessageProperties";
-import { bringInAccountV1 } from "./bringInAccountV1";
+import {
+    bringInAccountV1,
+    type BuildContextLike as BuildContextLike_bringInAccountV1
+} from "./bringInAccountV1";
 import { getThemeSrcDirPath } from "../../shared/getThemeSrcDirPath";
 import { rmSync } from "../../tools/fs.rmSync";
-import { readThisNpmProjectVersion } from "../../tools/readThisNpmProjectVersion";
-import { writeMetaInfKeycloakThemes, type MetaInfKeycloakTheme } from "../../shared/metaInfKeycloakThemes";
+import { readThisNpmPackageVersion } from "../../tools/readThisNpmPackageVersion";
+import {
+    writeMetaInfKeycloakThemes,
+    type MetaInfKeycloakTheme
+} from "../../shared/metaInfKeycloakThemes";
 import { objectEntries } from "tsafe/objectEntries";
+import { escapeStringForPropertiesFile } from "../../tools/escapeStringForPropertiesFile";
+
+export type BuildContextLike = BuildContextLike_kcContextExclusionsFtlCode &
+    BuildContextLike_downloadKeycloakStaticResources &
+    BuildContextLike_bringInAccountV1 & {
+        extraThemeProperties: string[] | undefined;
+        loginThemeResourcesFromKeycloakVersion: string;
+        projectDirPath: string;
+        projectBuildDirPath: string;
+        environmentVariables: { name: string; default: string }[];
+    };
 
-export type BuildOptionsLike = {
-    bundler: "vite" | "webpack";
-    extraThemeProperties: string[] | undefined;
-    themeVersion: string;
-    loginThemeResourcesFromKeycloakVersion: string;
-    reactAppBuildDirPath: string;
-    cacheDirPath: string;
-    assetsDirPath: string;
-    urlPathname: string | undefined;
-    npmWorkspaceRootDirPath: string;
-    reactAppRootDirPath: string;
-    keycloakifyBuildDirPath: string;
-};
-
-assert<BuildOptions extends BuildOptionsLike ? true : false>();
+assert<BuildContext extends BuildContextLike ? true : false>();
 
-export async function generateSrcMainResourcesForMainTheme(params: { themeName: string; buildOptions: BuildOptionsLike }): Promise<void> {
-    const { themeName, buildOptions } = params;
+export async function generateSrcMainResourcesForMainTheme(params: {
+    themeName: string;
+    resourcesDirPath: string;
+    buildContext: BuildContextLike;
+}): Promise<void> {
+    const { themeName, resourcesDirPath, buildContext } = params;
 
-    const { themeSrcDirPath } = getThemeSrcDirPath({ "reactAppRootDirPath": buildOptions.reactAppRootDirPath });
+    const { themeSrcDirPath } = getThemeSrcDirPath({
+        projectDirPath: buildContext.projectDirPath
+    });
 
     const getThemeTypeDirPath = (params: { themeType: ThemeType | "email" }) => {
         const { themeType } = params;
-        return pathJoin(buildOptions.keycloakifyBuildDirPath, "src", "main", "resources", "theme", themeName, themeType);
+        return pathJoin(resourcesDirPath, "theme", themeName, themeType);
     };
 
     const cssGlobalsToDefine: Record<string, string> = {};
 
     const implementedThemeTypes: Record<ThemeType | "email", boolean> = {
-        "login": false,
-        "account": false,
-        "email": false
+        login: false,
+        account: false,
+        email: false
     };
 
     for (const themeType of ["login", "account"] as const) {
@@ -70,18 +86,22 @@ export async function generateSrcMainResourcesForMainTheme(params: { themeName:
         const themeTypeDirPath = getThemeTypeDirPath({ themeType });
 
         apply_replacers_and_move_to_theme_resources: {
-            const destDirPath = pathJoin(themeTypeDirPath, "resources", basenameOfTheKeycloakifyResourcesDir);
+            const destDirPath = pathJoin(
+                themeTypeDirPath,
+                "resources",
+                basenameOfTheKeycloakifyResourcesDir
+            );
 
             // NOTE: Prevent accumulation of files in the assets dir, as names are hashed they pile up.
-            rmSync(destDirPath, { "recursive": true, "force": true });
+            rmSync(destDirPath, { recursive: true, force: true });
 
             if (themeType === "account" && implementedThemeTypes.login) {
                 // NOTE: We prevent doing it twice, it has been done for the login theme.
 
                 transformCodebase({
-                    "srcDirPath": pathJoin(
+                    srcDirPath: pathJoin(
                         getThemeTypeDirPath({
-                            "themeType": "login"
+                            themeType: "login"
                         }),
                         "resources",
                         basenameOfTheKeycloakifyResourcesDir
@@ -93,14 +113,17 @@ export async function generateSrcMainResourcesForMainTheme(params: { themeName:
             }
 
             transformCodebase({
-                "srcDirPath": buildOptions.reactAppBuildDirPath,
+                srcDirPath: buildContext.projectBuildDirPath,
                 destDirPath,
-                "transformSourceCode": ({ filePath, sourceCode }) => {
+                transformSourceCode: ({ filePath, sourceCode }) => {
                     //NOTE: Prevent cycles, excludes the folder we generated for debug in public/
                     // This should not happen if users follow the new instruction setup but we keep it for retrocompatibility.
                     if (
                         isInside({
-                            "dirPath": pathJoin(buildOptions.reactAppBuildDirPath, keycloak_resources),
+                            dirPath: pathJoin(
+                                buildContext.projectBuildDirPath,
+                                keycloak_resources
+                            ),
                             filePath
                         })
                     ) {
@@ -108,39 +131,50 @@ export async function generateSrcMainResourcesForMainTheme(params: { themeName:
                     }
 
                     if (/\.css?$/i.test(filePath)) {
-                        const { cssGlobalsToDefine: cssGlobalsToDefineForThisFile, fixedCssCode } = replaceImportsInCssCode({
-                            "cssCode": sourceCode.toString("utf8")
+                        const {
+                            cssGlobalsToDefine: cssGlobalsToDefineForThisFile,
+                            fixedCssCode
+                        } = replaceImportsInCssCode({
+                            cssCode: sourceCode.toString("utf8")
                         });
 
-                        Object.entries(cssGlobalsToDefineForThisFile).forEach(([key, value]) => {
-                            cssGlobalsToDefine[key] = value;
-                        });
+                        Object.entries(cssGlobalsToDefineForThisFile).forEach(
+                            ([key, value]) => {
+                                cssGlobalsToDefine[key] = value;
+                            }
+                        );
 
-                        return { "modifiedSourceCode": Buffer.from(fixedCssCode, "utf8") };
+                        return {
+                            modifiedSourceCode: Buffer.from(fixedCssCode, "utf8")
+                        };
                     }
 
                     if (/\.js?$/i.test(filePath)) {
                         const { fixedJsCode } = replaceImportsInJsCode({
-                            "jsCode": sourceCode.toString("utf8"),
-                            buildOptions
+                            jsCode: sourceCode.toString("utf8"),
+                            buildContext
                         });
 
-                        return { "modifiedSourceCode": Buffer.from(fixedJsCode, "utf8") };
+                        return {
+                            modifiedSourceCode: Buffer.from(fixedJsCode, "utf8")
+                        };
                     }
 
-                    return { "modifiedSourceCode": sourceCode };
+                    return { modifiedSourceCode: sourceCode };
                 }
             });
         }
 
         const { generateFtlFilesCode } = generateFtlFilesCodeFactory({
             themeName,
-            "indexHtmlCode": fs.readFileSync(pathJoin(buildOptions.reactAppBuildDirPath, "index.html")).toString("utf8"),
+            indexHtmlCode: fs
+                .readFileSync(pathJoin(buildContext.projectBuildDirPath, "index.html"))
+                .toString("utf8"),
             cssGlobalsToDefine,
-            buildOptions,
-            "keycloakifyVersion": readThisNpmProjectVersion(),
+            buildContext,
+            keycloakifyVersion: readThisNpmPackageVersion(),
             themeType,
-            "fieldNames": readFieldNameUsage({
+            fieldNames: readFieldNameUsage({
                 themeSrcDirPath,
                 themeType
             })
@@ -162,9 +196,10 @@ export async function generateSrcMainResourcesForMainTheme(params: { themeName:
         ].forEach(pageId => {
             const { ftlCode } = generateFtlFilesCode({ pageId });
 
-            fs.mkdirSync(themeTypeDirPath, { "recursive": true });
-
-            fs.writeFileSync(pathJoin(themeTypeDirPath, pageId), Buffer.from(ftlCode, "utf8"));
+            fs.writeFileSync(
+                pathJoin(themeTypeDirPath, pageId),
+                Buffer.from(ftlCode, "utf8")
+            );
         });
 
         generateMessageProperties({
@@ -173,25 +208,33 @@ export async function generateSrcMainResourcesForMainTheme(params: { themeName:
         }).forEach(({ languageTag, propertiesFileSource }) => {
             const messagesDirPath = pathJoin(themeTypeDirPath, "messages");
 
-            fs.mkdirSync(pathJoin(themeTypeDirPath, "messages"), { "recursive": true });
+            fs.mkdirSync(pathJoin(themeTypeDirPath, "messages"), {
+                recursive: true
+            });
 
-            const propertiesFilePath = pathJoin(messagesDirPath, `messages_${languageTag}.properties`);
+            const propertiesFilePath = pathJoin(
+                messagesDirPath,
+                `messages_${languageTag}.properties`
+            );
 
-            fs.writeFileSync(propertiesFilePath, Buffer.from(propertiesFileSource, "utf8"));
+            fs.writeFileSync(
+                propertiesFilePath,
+                Buffer.from(propertiesFileSource, "utf8")
+            );
         });
 
         await downloadKeycloakStaticResources({
-            "keycloakVersion": (() => {
+            keycloakVersion: (() => {
                 switch (themeType) {
                     case "account":
                         return lastKeycloakVersionWithAccountV1;
                     case "login":
-                        return buildOptions.loginThemeResourcesFromKeycloakVersion;
+                        return buildContext.loginThemeResourcesFromKeycloakVersion;
                 }
             })(),
-            "themeDirPath": pathResolve(pathJoin(themeTypeDirPath, "..")),
+            themeDirPath: pathResolve(pathJoin(themeTypeDirPath, "..")),
             themeType,
-            buildOptions
+            buildContext
         });
 
         fs.writeFileSync(
@@ -207,7 +250,11 @@ export async function generateSrcMainResourcesForMainTheme(params: { themeName:
                         }
                         assert<Equals<typeof themeType, never>>(false);
                     })()}`,
-                    ...(buildOptions.extraThemeProperties ?? [])
+                    ...(buildContext.extraThemeProperties ?? []),
+                    buildContext.environmentVariables.map(
+                        ({ name, default: defaultValue }) =>
+                            `${name}=\${env.${name}:${escapeStringForPropertiesFile(defaultValue)}}`
+                    )
                 ].join("\n\n"),
                 "utf8"
             )
@@ -224,36 +271,37 @@ export async function generateSrcMainResourcesForMainTheme(params: { themeName:
         implementedThemeTypes.email = true;
 
         transformCodebase({
-            "srcDirPath": emailThemeSrcDirPath,
-            "destDirPath": getThemeTypeDirPath({ "themeType": "email" })
+            srcDirPath: emailThemeSrcDirPath,
+            destDirPath: getThemeTypeDirPath({ themeType: "email" })
         });
     }
 
     if (implementedThemeTypes.account) {
         await bringInAccountV1({
-            buildOptions
+            resourcesDirPath,
+            buildContext
         });
     }
 
     {
-        const metaInfKeycloakThemes: MetaInfKeycloakTheme = { "themes": [] };
+        const metaInfKeycloakThemes: MetaInfKeycloakTheme = { themes: [] };
 
         metaInfKeycloakThemes.themes.push({
-            "name": themeName,
-            "types": objectEntries(implementedThemeTypes)
+            name: themeName,
+            types: objectEntries(implementedThemeTypes)
                 .filter(([, isImplemented]) => isImplemented)
                 .map(([themeType]) => themeType)
         });
 
         if (implementedThemeTypes.account) {
             metaInfKeycloakThemes.themes.push({
-                "name": accountV1ThemeName,
-                "types": ["account"]
+                name: accountV1ThemeName,
+                types: ["account"]
             });
         }
 
         writeMetaInfKeycloakThemes({
-            "keycloakifyBuildDirPath": buildOptions.keycloakifyBuildDirPath,
+            resourcesDirPath,
             metaInfKeycloakThemes
         });
     }