keycloakify 11.5.2 → 11.5.4

package/bin/{682.index.js → 153.index.js}

@@ -1,9 +1,9 @@
 "use strict";
-exports.id = 682;
-exports.ids = [682];
+exports.id = 153;
+exports.ids = [153];
 exports.modules = {
 
-/***/ 6682:
+/***/ 43153:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 // ESM COMPAT FLAG
@@ -271,9 +271,7 @@ function startViteDevServer(params) {
 //# sourceMappingURL=startViteDevServer.js.map
 // EXTERNAL MODULE: ./node_modules/tsafe/esm/is.mjs
 var is = __webpack_require__(16453);
-;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson.js
-
-
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson/ParsedRealmJson.js
 
 
 
@@ -325,6 +323,12 @@ const zParsedRealmJson = (() => {
     assert/* assert */.h;
     return (0,id.id)(zTargetType);
 })();
+//# sourceMappingURL=ParsedRealmJson.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson/readRealmJsonFile.js
+
+
+
+
 function readRealmJsonFile(params) {
     const { realmJsonFilePath } = params;
     const parsedRealmJson = JSON.parse(external_fs_.readFileSync(realmJsonFilePath).toString("utf8"));
@@ -332,7 +336,7 @@ function readRealmJsonFile(params) {
     (0,assert/* assert */.h)((0,is.is)(parsedRealmJson));
     return parsedRealmJson;
 }
-//# sourceMappingURL=ParsedRealmJson.js.map
+//# sourceMappingURL=readRealmJsonFile.js.map
 ;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/defaultConfig/defaultConfig.js
 
 
@@ -556,8 +560,6 @@ const { getCachedValue, setCachedValue } = (() => {
     };
 })();
 //# sourceMappingURL=getSupportedDockerImageTags.js.map
-// EXTERNAL MODULE: ./dist/bin/tools/runPrettier.js
-var runPrettier = __webpack_require__(48433);
 // EXTERNAL MODULE: ./node_modules/tsafe/esm/objectKeys.mjs
 var objectKeys = __webpack_require__(23483);
 // EXTERNAL MODULE: ./node_modules/evt/tools/inDepth/same.js
@@ -774,7 +776,7 @@ function editAccountConsoleAndSecurityAdminConsole(params) {
                 "claim.value": '["*"]',
                 "userinfo.token.claim": "true",
                 "id.token.claim": "false",
-                "lightweight.claim": "false",
+                "lightweight.claim": "true",
                 "access.token.claim": "true",
                 "claim.name": "allowed-origins",
                 "jsonType.label": "JSON",
@@ -802,6 +804,203 @@ function editAccountConsoleAndSecurityAdminConsole(params) {
     }
 }
 //# sourceMappingURL=prepareRealmConfig.js.map
+// EXTERNAL MODULE: ./dist/bin/tools/runPrettier.js
+var runPrettier = __webpack_require__(48433);
+;// CONCATENATED MODULE: ./dist/bin/tools/Stringifyable.js
+
+
+
+
+const zStringifyableAtomic = (() => {
+    const zTargetType = lib.z.union([lib.z.string(), lib.z.number(), lib.z.boolean(), lib.z["null"]()]);
+    (0,assert/* assert */.h)();
+    return (0,id.id)(zTargetType);
+})();
+const zStringifyable = lib.z.any()
+    .superRefine((val, ctx) => {
+    const isStringifyable = (0,same.same)(JSON.parse(JSON.stringify(val)), val);
+    if (!isStringifyable) {
+        ctx.addIssue({
+            code: lib.z.ZodIssueCode.custom,
+            message: "Not stringifyable"
+        });
+    }
+});
+function getIsAtomic(stringifyable) {
+    return (["string", "number", "boolean"].includes(typeof stringifyable) ||
+        stringifyable === null);
+}
+const { getValueAtPath } = (() => {
+    function getValueAtPath_rec(stringifyable, path) {
+        if (path.length === 0) {
+            return stringifyable;
+        }
+        if (getIsAtomic(stringifyable)) {
+            return undefined;
+        }
+        const [first, ...rest] = path;
+        let dereferenced;
+        if (stringifyable instanceof Array) {
+            if (typeof first !== "number") {
+                return undefined;
+            }
+            dereferenced = stringifyable[first];
+        }
+        else {
+            if (typeof first !== "string") {
+                return undefined;
+            }
+            dereferenced = stringifyable[first];
+        }
+        if (dereferenced === undefined) {
+            return undefined;
+        }
+        return getValueAtPath_rec(dereferenced, rest);
+    }
+    function getValueAtPath(stringifyableObjectOrArray, path) {
+        return getValueAtPath_rec(stringifyableObjectOrArray, path);
+    }
+    return { getValueAtPath };
+})();
+//# sourceMappingURL=Stringifyable.js.map
+;// CONCATENATED MODULE: ./dist/bin/tools/canonicalStringify.js
+
+function canonicalStringify(params) {
+    const { data, referenceData } = params;
+    return JSON.stringify(makeDeterministicCopy({
+        path: [],
+        data,
+        getCanonicalKeys: path => {
+            const referenceValue = (() => {
+                const path_patched = [];
+                for (let i = 0; i < path.length; i++) {
+                    let value_i = getValueAtPath(referenceData, [
+                        ...path_patched,
+                        path[i]
+                    ]);
+                    if (value_i !== undefined) {
+                        path_patched.push(path[i]);
+                        continue;
+                    }
+                    if (typeof path[i] !== "number") {
+                        return undefined;
+                    }
+                    value_i = getValueAtPath(referenceData, [...path_patched, 0]);
+                    if (value_i !== undefined) {
+                        path_patched.push(0);
+                        continue;
+                    }
+                    return undefined;
+                }
+                return getValueAtPath(referenceData, path_patched);
+            })();
+            if (referenceValue === undefined) {
+                return undefined;
+            }
+            if (getIsAtomic(referenceValue)) {
+                return undefined;
+            }
+            if (referenceValue instanceof Array) {
+                return undefined;
+            }
+            return Object.keys(referenceValue);
+        }
+    }), null, 2);
+}
+function makeDeterministicCopy(params) {
+    const { path, data, getCanonicalKeys } = params;
+    if (getIsAtomic(data)) {
+        return data;
+    }
+    if (data instanceof Array) {
+        return makeDeterministicCopy_array({
+            path,
+            data,
+            getCanonicalKeys
+        });
+    }
+    return makeDeterministicCopy_record({
+        path,
+        data,
+        getCanonicalKeys
+    });
+}
+function makeDeterministicCopy_record(params) {
+    const { path, data, getCanonicalKeys } = params;
+    const keysOfAtomicValues = [];
+    const keysOfNonAtomicValues = [];
+    for (const [key, value] of Object.entries(data)) {
+        if (getIsAtomic(value)) {
+            keysOfAtomicValues.push(key);
+        }
+        else {
+            keysOfNonAtomicValues.push(key);
+        }
+    }
+    keysOfAtomicValues.sort();
+    keysOfNonAtomicValues.sort();
+    const keys = [...keysOfAtomicValues, ...keysOfNonAtomicValues];
+    reorder_according_to_canonical: {
+        const canonicalKeys = getCanonicalKeys(path);
+        if (canonicalKeys === undefined) {
+            break reorder_according_to_canonical;
+        }
+        const keys_toPrepend = [];
+        for (const key of canonicalKeys) {
+            const indexOfKey = keys.indexOf(key);
+            if (indexOfKey === -1) {
+                continue;
+            }
+            keys.splice(indexOfKey, 1);
+            keys_toPrepend.push(key);
+        }
+        keys.unshift(...keys_toPrepend);
+    }
+    const result = {};
+    for (const key of keys) {
+        result[key] = makeDeterministicCopy({
+            path: [...path, key],
+            data: data[key],
+            getCanonicalKeys
+        });
+    }
+    return result;
+}
+function makeDeterministicCopy_array(params) {
+    const { path, data, getCanonicalKeys } = params;
+    return [...data].map((entry, i) => makeDeterministicCopy({
+        path: [...path, i],
+        data: entry,
+        getCanonicalKeys
+    }));
+}
+//# sourceMappingURL=canonicalStringify.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson/writeRealmJsonFile.js
+
+
+
+
+async function writeRealmJsonFile(params) {
+    const { realmJsonFilePath, parsedRealmJson, keycloakMajorVersionNumber } = params;
+    let sourceCode = canonicalStringify({
+        data: parsedRealmJson,
+        referenceData: getDefaultConfig({
+            keycloakMajorVersionNumber
+        })
+    });
+    if (await (0,runPrettier/* getIsPrettierAvailable */.MT)()) {
+        sourceCode = await (0,runPrettier/* runPrettier */.eY)({
+            sourceCode: sourceCode,
+            filePath: realmJsonFilePath
+        });
+    }
+    await promises_.writeFile(realmJsonFilePath, Buffer.from(sourceCode, "utf8"));
+}
+//# sourceMappingURL=writeRealmJsonFile.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson/index.js
+
+
+//# sourceMappingURL=index.js.map
 ;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/dumpContainerConfig.js
 
 
@@ -849,7 +1048,7 @@ async function dumpContainerConfig(params) {
                     ...["--db", "dev-file"],
                     ...[
                         "--db-url",
-                        "'jdbc:h2:file:/tmp/h2/keycloakdb;NON_KEYWORDS=VALUE'"
+                        '"jdbc:h2:file:/tmp/h2/keycloakdb;NON_KEYWORDS=VALUE"'
                     ]
                 ])
         ], { shell: true });
@@ -947,7 +1146,6 @@ async function dumpContainerConfig(params) {
 
 
 
-
 assert/* assert */.h;
 async function getRealmConfig(params) {
     const { keycloakMajorVersionNumber, realmJsonFilePath_userProvided, buildContext } = params;
@@ -976,18 +1174,11 @@ async function getRealmConfig(params) {
             external_fs_.mkdirSync(dirPath, { recursive: true });
         }
     }
-    const writeRealmJsonFile = async (params) => {
-        const { parsedRealmJson } = params;
-        let sourceCode = JSON.stringify(parsedRealmJson, null, 2);
-        if (await (0,runPrettier/* getIsPrettierAvailable */.MT)()) {
-            sourceCode = await (0,runPrettier/* runPrettier */.eY)({
-                sourceCode,
-                filePath: realmJsonFilePath
-            });
-        }
-        external_fs_.writeFileSync(realmJsonFilePath, sourceCode);
-    };
-    await writeRealmJsonFile({ parsedRealmJson });
+    await writeRealmJsonFile({
+        realmJsonFilePath,
+        parsedRealmJson,
+        keycloakMajorVersionNumber
+    });
     const { onRealmConfigChange } = (() => {
         const run = runExclusive.build(async () => {
             const start = Date.now();
@@ -1004,7 +1195,11 @@ async function getRealmConfig(params) {
                 console.log(source_default().red(`Failed to backup '${realmName}' config:`));
                 return;
             }
-            await writeRealmJsonFile({ parsedRealmJson });
+            await writeRealmJsonFile({
+                realmJsonFilePath,
+                parsedRealmJson,
+                keycloakMajorVersionNumber
+            });
             console.log([
                 source_default().grey(`Save changed to \`.${external_path_.sep}${(0,external_path_.relative)(buildContext.projectDirPath, realmJsonFilePath)}\``),
                 source_default().grey(`Next time you'll be running \`keycloakify start-keycloak\`, the realm '${realmName}' will be restored to this state.`),

package/bin/main.js

@@ -16201,7 +16201,7 @@ program
     .task({
     skip,
     handler: async ({ projectDirPath, keycloakVersion, port, realmJsonFilePath }) => {
-        const { command } = await Promise.all(/* import() */[__nccwpck_require__.e(805), __nccwpck_require__.e(525), __nccwpck_require__.e(33), __nccwpck_require__.e(503), __nccwpck_require__.e(682)]).then(__nccwpck_require__.bind(__nccwpck_require__, 6682));
+        const { command } = await Promise.all(/* import() */[__nccwpck_require__.e(805), __nccwpck_require__.e(525), __nccwpck_require__.e(33), __nccwpck_require__.e(503), __nccwpck_require__.e(153)]).then(__nccwpck_require__.bind(__nccwpck_require__, 43153));
         await command({
             buildContext: getBuildContext({ projectDirPath }),
             cliCommandOptions: {

package/bin/start-keycloak/realmConfig/{ParsedRealmJson.d.ts → ParsedRealmJson/ParsedRealmJson.d.ts}

@@ -1,3 +1,4 @@
+import { z } from "zod";
 export type ParsedRealmJson = {
     realm: string;
     loginTheme?: string;
@@ -40,6 +41,4 @@ export type ParsedRealmJson = {
         }[];
     }[];
 };
-export declare function readRealmJsonFile(params: {
-    realmJsonFilePath: string;
-}): ParsedRealmJson;
+export declare const zParsedRealmJson: z.ZodType<ParsedRealmJson, z.ZodTypeDef, ParsedRealmJson>;

package/bin/start-keycloak/realmConfig/ParsedRealmJson/index.d.ts

@@ -0,0 +1,3 @@
+export type { ParsedRealmJson } from "./ParsedRealmJson";
+export { readRealmJsonFile } from "./readRealmJsonFile";
+export { writeRealmJsonFile } from "./writeRealmJsonFile";

package/bin/start-keycloak/realmConfig/ParsedRealmJson/readRealmJsonFile.d.ts

@@ -0,0 +1,4 @@
+import { type ParsedRealmJson } from "./ParsedRealmJson";
+export declare function readRealmJsonFile(params: {
+    realmJsonFilePath: string;
+}): ParsedRealmJson;

package/bin/start-keycloak/realmConfig/ParsedRealmJson/writeRealmJsonFile.d.ts

@@ -0,0 +1,6 @@
+import type { ParsedRealmJson } from "./ParsedRealmJson";
+export declare function writeRealmJsonFile(params: {
+    realmJsonFilePath: string;
+    parsedRealmJson: ParsedRealmJson;
+    keycloakMajorVersionNumber: number;
+}): Promise<void>;

package/bin/start-keycloak/realmConfig/defaultConfig/defaultConfig.d.ts

@@ -1,7 +1,4 @@
-import { type ParsedRealmJson } from "../ParsedRealmJson";
-export declare function getDefaultRealmJsonFilePath(params: {
-    keycloakMajorVersionNumber: number;
-}): string;
+import type { ParsedRealmJson } from "../ParsedRealmJson/ParsedRealmJson";
 export declare const getSupportedKeycloakMajorVersions: () => number[];
 export declare function getDefaultConfig(params: {
     keycloakMajorVersionNumber: number;

package/bin/tools/Stringifyable.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export type Stringifyable = StringifyableAtomic | StringifyableObject | StringifyableArray;
+export type StringifyableAtomic = string | number | boolean | null;
+interface StringifyableObject {
+    [key: string]: Stringifyable;
+}
+interface StringifyableArray extends Array<Stringifyable> {
+}
+export declare const zStringifyableAtomic: z.ZodType<StringifyableAtomic, z.ZodTypeDef, StringifyableAtomic>;
+export declare const zStringifyable: z.ZodType<Stringifyable>;
+export declare function getIsAtomic(stringifyable: Stringifyable): stringifyable is StringifyableAtomic;
+export declare const getValueAtPath: (stringifyableObjectOrArray: Record<string, Stringifyable> | Stringifyable[], path: (string | number)[]) => Stringifyable | undefined;
+export {};

package/bin/tools/canonicalStringify.d.ts

@@ -0,0 +1,5 @@
+import { type Stringifyable } from "./Stringifyable";
+export declare function canonicalStringify(params: {
+    data: Record<string, Stringifyable> | Stringifyable[];
+    referenceData: Record<string, Stringifyable> | Stringifyable[];
+}): string;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "keycloakify",
-    "version": "11.5.2",
+    "version": "11.5.4",
     "description": "Framework to create custom Keycloak UIs",
     "repository": {
         "type": "git",
@@ -704,7 +704,10 @@
         "src/bin/start-keycloak/index.ts",
         "src/bin/start-keycloak/keycloakify-logging-1.0.3.jar",
         "src/bin/start-keycloak/keycloakifyBuild.ts",
-        "src/bin/start-keycloak/realmConfig/ParsedRealmJson.ts",
+        "src/bin/start-keycloak/realmConfig/ParsedRealmJson/ParsedRealmJson.ts",
+        "src/bin/start-keycloak/realmConfig/ParsedRealmJson/index.ts",
+        "src/bin/start-keycloak/realmConfig/ParsedRealmJson/readRealmJsonFile.ts",
+        "src/bin/start-keycloak/realmConfig/ParsedRealmJson/writeRealmJsonFile.ts",
         "src/bin/start-keycloak/realmConfig/defaultConfig/defaultConfig.ts",
         "src/bin/start-keycloak/realmConfig/defaultConfig/index.ts",
         "src/bin/start-keycloak/realmConfig/defaultConfig/realm-kc-18.json",
@@ -724,7 +727,9 @@
         "src/bin/tools/OptionalIfCanBeUndefined.ts",
         "src/bin/tools/SemVer.ts",
         "src/bin/tools/String.prototype.replaceAll.ts",
+        "src/bin/tools/Stringifyable.ts",
         "src/bin/tools/assertNoPnpmDlx.ts",
+        "src/bin/tools/canonicalStringify.ts",
         "src/bin/tools/crawl.ts",
         "src/bin/tools/crawlAsync.ts",
         "src/bin/tools/crc32.ts",
@@ -1080,12 +1085,16 @@
         "bin/start-keycloak/realmConfig/defaultConfig/index.d.ts",
         "bin/start-keycloak/realmConfig/dumpContainerConfig.d.ts",
         "bin/start-keycloak/realmConfig/index.d.ts",
-        "bin/start-keycloak/realmConfig/ParsedRealmJson.d.ts",
+        "bin/start-keycloak/realmConfig/ParsedRealmJson/index.d.ts",
+        "bin/start-keycloak/realmConfig/ParsedRealmJson/ParsedRealmJson.d.ts",
+        "bin/start-keycloak/realmConfig/ParsedRealmJson/readRealmJsonFile.d.ts",
+        "bin/start-keycloak/realmConfig/ParsedRealmJson/writeRealmJsonFile.d.ts",
         "bin/start-keycloak/realmConfig/prepareRealmConfig.d.ts",
         "bin/start-keycloak/realmConfig/realmConfig.d.ts",
         "bin/start-keycloak/start-keycloak.d.ts",
         "bin/start-keycloak/startViteDevServer.d.ts",
         "bin/tools/assertNoPnpmDlx.d.ts",
+        "bin/tools/canonicalStringify.d.ts",
         "bin/tools/crawl.d.ts",
         "bin/tools/crawlAsync.d.ts",
         "bin/tools/crc32.d.ts",
@@ -1114,12 +1123,14 @@
         "bin/tools/runPrettier.d.ts",
         "bin/tools/SemVer.d.ts",
         "bin/tools/String.prototype.replaceAll.d.ts",
+        "bin/tools/Stringifyable.d.ts",
         "bin/tools/tee.d.ts",
         "bin/tools/transformCodebase.d.ts",
         "bin/tools/trimIndent.d.ts",
         "bin/tools/untrackFromGit.d.ts",
         "bin/update-kc-gen.d.ts",
         "bin/main.js",
+        "bin/153.index.js",
         "bin/266.index.js",
         "bin/304.index.js",
         "bin/33.index.js",
@@ -1133,7 +1144,6 @@
         "bin/573.index.js",
         "bin/653.index.js",
         "bin/658.index.js",
-        "bin/682.index.js",
         "bin/720.index.js",
         "bin/735.index.js",
         "bin/743.index.js",

package/src/bin/start-keycloak/realmConfig/{ParsedRealmJson.ts → ParsedRealmJson/ParsedRealmJson.ts}

@@ -1,8 +1,6 @@
 import { z } from "zod";
 import { assert, type Equals } from "tsafe/assert";
-import { is } from "tsafe/is";
 import { id } from "tsafe/id";
-import * as fs from "fs";
 
 export type ParsedRealmJson = {
     realm: string;
@@ -50,7 +48,7 @@ export type ParsedRealmJson = {
     }[];
 };
 
-const zParsedRealmJson = (() => {
+export const zParsedRealmJson = (() => {
     type TargetType = ParsedRealmJson;
 
     const zTargetType = z.object({
@@ -118,19 +116,3 @@ const zParsedRealmJson = (() => {
 
     return id<z.ZodType<TargetType>>(zTargetType);
 })();
-
-export function readRealmJsonFile(params: {
-    realmJsonFilePath: string;
-}): ParsedRealmJson {
-    const { realmJsonFilePath } = params;
-
-    const parsedRealmJson = JSON.parse(
-        fs.readFileSync(realmJsonFilePath).toString("utf8")
-    ) as unknown;
-
-    zParsedRealmJson.parse(parsedRealmJson);
-
-    assert(is<ParsedRealmJson>(parsedRealmJson));
-
-    return parsedRealmJson;
-}

package/src/bin/start-keycloak/realmConfig/ParsedRealmJson/index.ts

@@ -0,0 +1,3 @@
+export type { ParsedRealmJson } from "./ParsedRealmJson";
+export { readRealmJsonFile } from "./readRealmJsonFile";
+export { writeRealmJsonFile } from "./writeRealmJsonFile";

package/src/bin/start-keycloak/realmConfig/ParsedRealmJson/readRealmJsonFile.ts

@@ -0,0 +1,20 @@
+import { assert } from "tsafe/assert";
+import { is } from "tsafe/is";
+import * as fs from "fs";
+import { type ParsedRealmJson, zParsedRealmJson } from "./ParsedRealmJson";
+
+export function readRealmJsonFile(params: {
+    realmJsonFilePath: string;
+}): ParsedRealmJson {
+    const { realmJsonFilePath } = params;
+
+    const parsedRealmJson = JSON.parse(
+        fs.readFileSync(realmJsonFilePath).toString("utf8")
+    ) as unknown;
+
+    zParsedRealmJson.parse(parsedRealmJson);
+
+    assert(is<ParsedRealmJson>(parsedRealmJson));
+
+    return parsedRealmJson;
+}

package/src/bin/start-keycloak/realmConfig/ParsedRealmJson/writeRealmJsonFile.ts

@@ -0,0 +1,29 @@
+import * as fsPr from "fs/promises";
+import { getIsPrettierAvailable, runPrettier } from "../../../tools/runPrettier";
+import { canonicalStringify } from "../../../tools/canonicalStringify";
+import type { ParsedRealmJson } from "./ParsedRealmJson";
+import { getDefaultConfig } from "../defaultConfig";
+
+export async function writeRealmJsonFile(params: {
+    realmJsonFilePath: string;
+    parsedRealmJson: ParsedRealmJson;
+    keycloakMajorVersionNumber: number;
+}): Promise<void> {
+    const { realmJsonFilePath, parsedRealmJson, keycloakMajorVersionNumber } = params;
+
+    let sourceCode = canonicalStringify({
+        data: parsedRealmJson,
+        referenceData: getDefaultConfig({
+            keycloakMajorVersionNumber
+        })
+    });
+
+    if (await getIsPrettierAvailable()) {
+        sourceCode = await runPrettier({
+            sourceCode: sourceCode,
+            filePath: realmJsonFilePath
+        });
+    }
+
+    await fsPr.writeFile(realmJsonFilePath, Buffer.from(sourceCode, "utf8"));
+}

package/src/bin/start-keycloak/realmConfig/defaultConfig/defaultConfig.ts

@@ -3,11 +3,10 @@ import { getThisCodebaseRootDirPath } from "../../../tools/getThisCodebaseRootDi
 import * as fs from "fs";
 import { exclude } from "tsafe/exclude";
 import { assert } from "tsafe/assert";
-import { type ParsedRealmJson, readRealmJsonFile } from "../ParsedRealmJson";
+import { readRealmJsonFile } from "../ParsedRealmJson/readRealmJsonFile";
+import type { ParsedRealmJson } from "../ParsedRealmJson/ParsedRealmJson";
 
-export function getDefaultRealmJsonFilePath(params: {
-    keycloakMajorVersionNumber: number;
-}) {
+function getDefaultRealmJsonFilePath(params: { keycloakMajorVersionNumber: number }) {
     const { keycloakMajorVersionNumber } = params;
 
     return pathJoin(