keycloakify 11.4.5 → 11.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "keycloakify",
-    "version": "11.4.5",
+    "version": "11.5.1",
     "description": "Framework to create custom Keycloak UIs",
     "repository": {
         "type": "git",
@@ -700,16 +700,25 @@
         "src/bin/shared/metaInfKeycloakThemes.ts",
         "src/bin/shared/promptKeycloakVersion.ts",
         "src/bin/start-keycloak/appBuild.ts",
+        "src/bin/start-keycloak/getSupportedDockerImageTags.ts",
         "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/myrealm-realm-18.json",
-        "src/bin/start-keycloak/myrealm-realm-19.json",
-        "src/bin/start-keycloak/myrealm-realm-20.json",
-        "src/bin/start-keycloak/myrealm-realm-21.json",
-        "src/bin/start-keycloak/myrealm-realm-23.json",
-        "src/bin/start-keycloak/myrealm-realm-24.json",
-        "src/bin/start-keycloak/myrealm-realm-25.json",
-        "src/bin/start-keycloak/myrealm-realm-26.json",
+        "src/bin/start-keycloak/realmConfig/ParsedRealmJson.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",
+        "src/bin/start-keycloak/realmConfig/defaultConfig/realm-kc-19.json",
+        "src/bin/start-keycloak/realmConfig/defaultConfig/realm-kc-20.json",
+        "src/bin/start-keycloak/realmConfig/defaultConfig/realm-kc-21.json",
+        "src/bin/start-keycloak/realmConfig/defaultConfig/realm-kc-23.json",
+        "src/bin/start-keycloak/realmConfig/defaultConfig/realm-kc-24.json",
+        "src/bin/start-keycloak/realmConfig/defaultConfig/realm-kc-25.json",
+        "src/bin/start-keycloak/realmConfig/defaultConfig/realm-kc-26.json",
+        "src/bin/start-keycloak/realmConfig/dumpContainerConfig.ts",
+        "src/bin/start-keycloak/realmConfig/index.ts",
+        "src/bin/start-keycloak/realmConfig/prepareRealmConfig.ts",
+        "src/bin/start-keycloak/realmConfig/realmConfig.ts",
         "src/bin/start-keycloak/start-keycloak.ts",
         "src/bin/start-keycloak/startViteDevServer.ts",
         "src/bin/tools/OptionalIfCanBeUndefined.ts",
@@ -1064,8 +1073,16 @@
         "bin/shared/metaInfKeycloakThemes.d.ts",
         "bin/shared/promptKeycloakVersion.d.ts",
         "bin/start-keycloak/appBuild.d.ts",
+        "bin/start-keycloak/getSupportedDockerImageTags.d.ts",
         "bin/start-keycloak/index.d.ts",
         "bin/start-keycloak/keycloakifyBuild.d.ts",
+        "bin/start-keycloak/realmConfig/defaultConfig/defaultConfig.d.ts",
+        "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/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",
@@ -1103,19 +1120,20 @@
         "bin/tools/untrackFromGit.d.ts",
         "bin/update-kc-gen.d.ts",
         "bin/main.js",
-        "bin/20.index.js",
         "bin/266.index.js",
         "bin/304.index.js",
         "bin/33.index.js",
         "bin/356.index.js",
-        "bin/36.index.js",
-        "bin/392.index.js",
+        "bin/375.index.js",
         "bin/40.index.js",
-        "bin/450.index.js",
         "bin/453.index.js",
+        "bin/490.index.js",
+        "bin/503.index.js",
+        "bin/525.index.js",
         "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",
@@ -1125,7 +1143,6 @@
         "bin/854.index.js",
         "bin/877.index.js",
         "bin/921.index.js",
-        "bin/932.index.js",
         "bin/97.index.js",
         "bin/shared/constants.js",
         "bin/shared/constants.js.map",

package/src/bin/shared/constants.ts

@@ -81,3 +81,9 @@ export const CUSTOM_HANDLER_ENV_NAMES = {
 export const KEYCLOAK_THEME = "keycloak-theme";
 
 export const KEYCLOAKIFY_SPA_DEV_SERVER_PORT = "KEYCLOAKIFY_SPA_DEV_SERVER_PORT";
+
+export const KEYCLOAKIFY_LOGGING_VERSION = "1.0.3";
+
+export const KEYCLOAKIFY_LOGIN_JAR_BASENAME = `keycloakify-logging-${KEYCLOAKIFY_LOGGING_VERSION}.jar`;
+
+export const TEST_APP_URL = "https://my-theme.keycloakify.dev";

package/src/bin/start-keycloak/getSupportedDockerImageTags.ts

@@ -0,0 +1,230 @@
+import fetch from "make-fetch-happen";
+import type { BuildContext } from "../shared/buildContext";
+import { assert, type Equals } from "tsafe/assert";
+import { id } from "tsafe/id";
+import { z } from "zod";
+import { SemVer } from "../tools/SemVer";
+import { exclude } from "tsafe/exclude";
+import { getSupportedKeycloakMajorVersions } from "./realmConfig/defaultConfig";
+import { join as pathJoin, dirname as pathDirname } from "path";
+import * as fs from "fs/promises";
+import { existsAsync } from "../tools/fs.existsAsync";
+import { readThisNpmPackageVersion } from "../tools/readThisNpmPackageVersion";
+
+export type BuildContextLike = {
+    fetchOptions: BuildContext["fetchOptions"];
+    cacheDirPath: string;
+};
+
+assert<BuildContext extends BuildContextLike ? true : false>;
+
+export async function getSupportedDockerImageTags(params: {
+    buildContext: BuildContextLike;
+}) {
+    const { buildContext } = params;
+
+    {
+        const result = await getCachedValue({ cacheDirPath: buildContext.cacheDirPath });
+
+        if (result !== undefined) {
+            return result;
+        }
+    }
+
+    const tags: string[] = [];
+
+    await (async function callee(url: string) {
+        const r = await fetch(url, buildContext.fetchOptions);
+
+        await Promise.all([
+            (async () => {
+                tags.push(
+                    ...z
+                        .object({
+                            tags: z.array(z.string())
+                        })
+                        .parse(await r.json()).tags
+                );
+            })(),
+            (async () => {
+                const link = r.headers.get("link");
+
+                if (link === null) {
+                    return;
+                }
+
+                const split = link.split(";").map(s => s.trim());
+
+                assert(split.length === 2);
+
+                assert(split[1] === 'rel="next"');
+
+                const match = split[0].match(/^<(.+)>$/);
+
+                assert(match !== null);
+
+                const nextUrl = new URL(url).origin + match[1];
+
+                await callee(nextUrl);
+            })()
+        ]);
+    })("https://quay.io/v2/keycloak/keycloak/tags/list");
+
+    const arr = tags
+        .map(tag => ({
+            tag,
+            version: (() => {
+                if (tag.includes("-")) {
+                    return undefined;
+                }
+
+                let version: SemVer;
+
+                try {
+                    version = SemVer.parse(tag);
+                } catch {
+                    return undefined;
+                }
+
+                return version;
+            })()
+        }))
+        .map(({ tag, version }) => (version === undefined ? undefined : { tag, version }))
+        .filter(exclude(undefined));
+
+    const versionByMajor: Record<number, SemVer | undefined> = {};
+
+    for (const { version } of arr) {
+        const version_current = versionByMajor[version.major];
+
+        if (
+            version_current === undefined ||
+            SemVer.compare(version_current, version) === -1
+        ) {
+            versionByMajor[version.major] = version;
+        }
+    }
+
+    const supportedKeycloakMajorVersions = getSupportedKeycloakMajorVersions();
+
+    const result = Object.entries(versionByMajor)
+        .sort(([a], [b]) => parseInt(b) - parseInt(a))
+        .map(([, version]) => version)
+        .map(version => {
+            assert(version !== undefined);
+
+            if (!supportedKeycloakMajorVersions.includes(version.major)) {
+                return undefined;
+            }
+
+            return SemVer.stringify(version);
+        })
+        .filter(exclude(undefined));
+
+    await setCachedValue({ cacheDirPath: buildContext.cacheDirPath, result });
+
+    return result;
+}
+
+const { getCachedValue, setCachedValue } = (() => {
+    type Cache = {
+        keycloakifyVersion: string;
+        time: number;
+        result: string[];
+    };
+
+    const zCache = (() => {
+        type TargetType = Cache;
+
+        const zTargetType = z.object({
+            keycloakifyVersion: z.string(),
+            time: z.number(),
+            result: z.array(z.string())
+        });
+
+        type InferredType = z.infer<typeof zTargetType>;
+
+        assert<Equals<TargetType, InferredType>>;
+
+        return id<z.ZodType<TargetType>>(zTargetType);
+    })();
+
+    let inMemoryCachedResult: Cache["result"] | undefined = undefined;
+
+    function getCacheFilePath(params: { cacheDirPath: string }) {
+        const { cacheDirPath } = params;
+
+        return pathJoin(cacheDirPath, "supportedDockerImageTags.json");
+    }
+
+    async function getCachedValue(params: { cacheDirPath: string }) {
+        const { cacheDirPath } = params;
+
+        if (inMemoryCachedResult !== undefined) {
+            return inMemoryCachedResult;
+        }
+
+        const cacheFilePath = getCacheFilePath({ cacheDirPath });
+
+        if (!(await existsAsync(cacheFilePath))) {
+            return undefined;
+        }
+
+        let cache: Cache | undefined;
+
+        try {
+            cache = zCache.parse(JSON.parse(await fs.readFile(cacheFilePath, "utf8")));
+        } catch {
+            return undefined;
+        }
+
+        if (cache.keycloakifyVersion !== readThisNpmPackageVersion()) {
+            return undefined;
+        }
+
+        if (Date.now() - cache.time > 3_600 * 24) {
+            return undefined;
+        }
+
+        inMemoryCachedResult = cache.result;
+
+        return cache.result;
+    }
+
+    async function setCachedValue(params: {
+        cacheDirPath: string;
+        result: Cache["result"];
+    }) {
+        const { cacheDirPath, result } = params;
+
+        inMemoryCachedResult = result;
+
+        const cacheFilePath = getCacheFilePath({ cacheDirPath });
+
+        {
+            const dirPath = pathDirname(cacheFilePath);
+
+            if (!(await existsAsync(dirPath))) {
+                await fs.mkdir(dirPath, { recursive: true });
+            }
+        }
+
+        await fs.writeFile(
+            cacheFilePath,
+            JSON.stringify(
+                zCache.parse({
+                    keycloakifyVersion: readThisNpmPackageVersion(),
+                    time: Date.now(),
+                    result
+                }),
+                null,
+                2
+            )
+        );
+    }
+
+    return {
+        getCachedValue,
+        setCachedValue
+    };
+})();

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

@@ -0,0 +1,136 @@
+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;
+    loginTheme?: string;
+    accountTheme?: string;
+    adminTheme?: string;
+    emailTheme?: string;
+    eventsListeners: string[];
+    users: {
+        id: string;
+        email: string;
+        username: string;
+        credentials: {
+            type: string /* "password" or something else */;
+        }[];
+        clientRoles?: Record<string, string[]>;
+    }[];
+    roles: {
+        client: Record<
+            string,
+            {
+                name: string;
+                containerId: string; // client id
+            }[]
+        >;
+    };
+    clients: {
+        id: string;
+        clientId: string; // example: realm-management
+        baseUrl?: string;
+        redirectUris?: string[];
+        webOrigins?: string[];
+        attributes?: {
+            "post.logout.redirect.uris"?: string;
+        };
+        protocol?: string;
+        protocolMappers?: {
+            id: string;
+            name: string;
+            protocol: string; // "openid-connect" or something else
+            protocolMapper: string; // "oidc-hardcoded-claim-mapper" or something else
+            consentRequired: boolean;
+            config?: Record<string, string>;
+        }[];
+    }[];
+};
+
+const zParsedRealmJson = (() => {
+    type TargetType = ParsedRealmJson;
+
+    const zTargetType = z.object({
+        realm: z.string(),
+        loginTheme: z.string().optional(),
+        accountTheme: z.string().optional(),
+        adminTheme: z.string().optional(),
+        emailTheme: z.string().optional(),
+        eventsListeners: z.array(z.string()),
+        users: z.array(
+            z.object({
+                id: z.string(),
+                email: z.string(),
+                username: z.string(),
+                credentials: z.array(
+                    z.object({
+                        type: z.string()
+                    })
+                ),
+                clientRoles: z.record(z.array(z.string())).optional()
+            })
+        ),
+        roles: z.object({
+            client: z.record(
+                z.array(
+                    z.object({
+                        name: z.string(),
+                        containerId: z.string()
+                    })
+                )
+            )
+        }),
+        clients: z.array(
+            z.object({
+                id: z.string(),
+                clientId: z.string(),
+                baseUrl: z.string().optional(),
+                redirectUris: z.array(z.string()).optional(),
+                webOrigins: z.array(z.string()).optional(),
+                attributes: z
+                    .object({
+                        "post.logout.redirect.uris": z.string().optional()
+                    })
+                    .optional(),
+                protocol: z.string().optional(),
+                protocolMappers: z
+                    .array(
+                        z.object({
+                            id: z.string(),
+                            name: z.string(),
+                            protocol: z.string(),
+                            protocolMapper: z.string(),
+                            consentRequired: z.boolean(),
+                            config: z.record(z.string()).optional()
+                        })
+                    )
+                    .optional()
+            })
+        )
+    });
+
+    type InferredType = z.infer<typeof zTargetType>;
+
+    assert<Equals<TargetType, InferredType>>;
+
+    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/defaultConfig/defaultConfig.ts

@@ -0,0 +1,75 @@
+import { join as pathJoin, dirname as pathDirname } from "path";
+import { getThisCodebaseRootDirPath } from "../../../tools/getThisCodebaseRootDirPath";
+import * as fs from "fs";
+import { exclude } from "tsafe/exclude";
+import { assert } from "tsafe/assert";
+import { type ParsedRealmJson, readRealmJsonFile } from "../ParsedRealmJson";
+
+export function getDefaultRealmJsonFilePath(params: {
+    keycloakMajorVersionNumber: number;
+}) {
+    const { keycloakMajorVersionNumber } = params;
+
+    return pathJoin(
+        getThisCodebaseRootDirPath(),
+        "src",
+        "bin",
+        "start-keycloak",
+        "realmConfig",
+        "defaultConfig",
+        `realm-kc-${keycloakMajorVersionNumber}.json`
+    );
+}
+
+export const { getSupportedKeycloakMajorVersions } = (() => {
+    let cache: number[] | undefined = undefined;
+
+    function getSupportedKeycloakMajorVersions(): number[] {
+        if (cache !== undefined) {
+            return cache;
+        }
+
+        cache = fs
+            .readdirSync(
+                pathDirname(
+                    getDefaultRealmJsonFilePath({ keycloakMajorVersionNumber: 0 })
+                )
+            )
+            .map(fileBasename => {
+                const match = fileBasename.match(/^realm-kc-(\d+)\.json$/);
+
+                if (match === null) {
+                    return undefined;
+                }
+
+                const n = parseInt(match[1]);
+
+                assert(!isNaN(n));
+
+                return n;
+            })
+            .filter(exclude(undefined))
+            .sort((a, b) => b - a);
+
+        return cache;
+    }
+
+    return { getSupportedKeycloakMajorVersions };
+})();
+
+export function getDefaultConfig(params: {
+    keycloakMajorVersionNumber: number;
+}): ParsedRealmJson {
+    const { keycloakMajorVersionNumber } = params;
+
+    assert(
+        getSupportedKeycloakMajorVersions().includes(keycloakMajorVersionNumber),
+        `We do not have a default config for Keycloak ${keycloakMajorVersionNumber}`
+    );
+
+    return readRealmJsonFile({
+        realmJsonFilePath: getDefaultRealmJsonFilePath({
+            keycloakMajorVersionNumber
+        })
+    });
+}

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

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