Bump version

Fix-broken-jar

.github/workflows/ci.yaml

@@ -17,44 +17,32 @@ jobs:
     - uses: actions/setup-node@v3
     - uses: bahmutov/npm-install@v1
     - name: If this step fails run 'yarn format' then commit again.
-      run: |
-        PACKAGE_MANAGER=npm
-        if [ -f "./yarn.lock" ]; then
-            PACKAGE_MANAGER=yarn
-        fi
-        $PACKAGE_MANAGER run format:check
+      run: yarn format:check
   test:
     runs-on: ${{ matrix.os }}
     needs: test_lint
     strategy:
       matrix:
-        node: [ '16' ]
+        node: [ '18' ]
         os: [ ubuntu-latest ]
     name: Test with Node v${{ matrix.node }} on ${{ matrix.os }}
     steps:
-    - name: Tell if project is using npm or yarn
-      id: step1
-      uses: garronej/ts-ci@v2.0.2
-      with: 
-        action_name: tell_if_project_uses_npm_or_yarn
     - uses: actions/checkout@v3
     - uses: actions/setup-node@v3
       with:
         node-version: ${{ matrix.node }}
     - uses: bahmutov/npm-install@v1
-    - if: steps.step1.outputs.npm_or_yarn == 'yarn'
-      run: |
-        yarn build
-        yarn test
-    - if: steps.step1.outputs.npm_or_yarn == 'npm'
-      run: |
-        npm run build
-        npm test
+    - run: yarn build
+    - run: yarn test
+    - run: yarn test:keycloakify-starter
+
   check_if_version_upgraded:
     name: Check if version upgrade
-    # We run this only if it's a push on the default branch or if it's a PR from a 
-    # branch (meaning not a PR from a fork). It would be more straightforward to test if secrets.NPM_TOKEN is 
-    # defined but GitHub Action don't allow it yet.
+    # When someone forks the repo and opens a PR we want to enables the tests to be run (the previous jobs)
+    # but obviously only us should be allowed to release.
+    # In the following check we make sure that we own the branch this CI workflow is running on before continuing.
+    # Without this check, trying to release would fail anyway because only us have the correct secret.NPM_TOKEN but
+    # it's cleaner to stop the execution instead of letting the CI crash.
     if: |
       github.event_name == 'push' || 
       github.event.pull_request.head.repo.owner.login == github.event.pull_request.base.repo.owner.login 
@@ -66,7 +54,7 @@ jobs:
       is_upgraded_version: ${{ steps.step1.outputs.is_upgraded_version }}
       is_pre_release: ${{steps.step1.outputs.is_pre_release }}
     steps:
-    - uses: garronej/ts-ci@v2.0.2
+    - uses: garronej/ts-ci@v2.1.0
       id: step1
       with: 
         action_name: is_package_json_version_upgraded
@@ -74,8 +62,8 @@ jobs:
 
   create_github_release:
     runs-on: ubuntu-latest
-    # We create a release only if the version have been upgraded and we are on the main branch
-    # or if we are on a branch of the repo that has an PR open on main.
+    # We create release only if the version in the package.json have been upgraded and this CI is running against the main branch.
+    # We allow branches with a PR open on main to publish pre-release (x.y.z-rc.u) but not actual releases.
     if: |
       needs.check_if_version_upgraded.outputs.is_upgraded_version == 'true' &&
       (
@@ -109,15 +97,13 @@ jobs:
       with:
         registry-url: https://registry.npmjs.org/
     - uses: bahmutov/npm-install@v1
-    - run: |
-        PACKAGE_MANAGER=npm
-        if [ -f "./yarn.lock" ]; then
-            PACKAGE_MANAGER=yarn
-        fi
-        $PACKAGE_MANAGER run build
-    - run: npx -y -p denoify@1.2.2 enable_short_npm_import_path
+    - run: yarn build
+    - run: npx -y -p denoify@1.3.0 enable_short_npm_import_path
       env:
         DRY_RUN: "0"
+    - uses: garronej/ts-ci@v2.1.0
+      with: 
+        action_name: remove_dark_mode_specific_images_from_readme
     - name: Publishing on NPM
       run: |
         if [ "$(npm show . version)" = "$VERSION" ]; then

.gitignore

@@ -41,14 +41,15 @@ jspm_packages
 .DS_Store
 
 /dist
-/dist_test
-
+/keycloakify_starter_test/
+/sample_custom_react_project/
 /sample_react_project/
 /.yarn_home/
 
 .idea
 
-/keycloak_email
-/build_keycloak
 /src/login/i18n/baseMessages/
-/src/account/i18n/baseMessages/
+/src/account/i18n/baseMessages/
+
+# VS Code devcontainers
+.devcontainer

.prettierignore

@@ -1,12 +1,15 @@
 node_modules/
 /dist/
-/dist_test/
 /CHANGELOG.md
 /.yarn_home/
 /src/test/apps/
 /src/tools/types/
-/sample_react_project
 /build_keycloak/
 /.vscode/
 /src/login/i18n/baseMessages/
 /src/account/i18n/baseMessages/
+# Test Build Directories
+/dist_test
+/sample_react_project/
+/sample_custom_react_project/
+/keycloakify_starter_test/

README.md

@@ -31,11 +31,15 @@
     </p>
 </p>
 
+> 🗣️🔈 Sorry the latest release is broken, fixing ASAP
+
 <p align="center">
     <i>Ultimately this build tool generates a Keycloak theme <a href="https://www.keycloakify.dev">Learn more</a></i>
     <img src="https://user-images.githubusercontent.com/6702424/110260457-a1c3d380-7fac-11eb-853a-80459b65626b.png">
 </p>
 
+The more ⭐️ the project gets, the more time I spend improving and maintaining it. Thank you for your support 😊
+
 > 🗣 V7 have been released 🎉  
 > [It features major improvements](https://github.com/keycloakify/keycloakify#70-).  
 > Checkout [the migration guide](https://docs.keycloakify.dev/migration-guides/v6-greater-than-v7).

keycloakify-json-schema.json

@@ -0,0 +1,91 @@
+{
+    "allOf": [
+        {
+            "$ref": "https://json.schemastore.org/package.json"
+        },
+        {
+            "$ref": "keycloakifyPackageJsonSchema"
+        }
+    ],
+    "$ref": "#/definitions/keycloakifyPackageJsonSchema",
+    "definitions": {
+        "keycloakifyPackageJsonSchema": {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "version": {
+                    "type": "string"
+                },
+                "homepage": {
+                    "type": "string"
+                },
+                "keycloakify": {
+                    "type": "object",
+                    "properties": {
+                        "extraPages": {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            }
+                        },
+                        "extraLoginPages": {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            }
+                        },
+                        "extraAccountPages": {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            }
+                        },
+                        "extraThemeProperties": {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            }
+                        },
+                        "areAppAndKeycloakServerSharingSameDomain": {
+                            "type": "boolean"
+                        },
+                        "artifactId": {
+                            "type": "string"
+                        },
+                        "groupId": {
+                            "type": "string"
+                        },
+                        "bundler": {
+                            "type": "string",
+                            "enum": ["mvn", "keycloakify", "none"]
+                        },
+                        "keycloakVersionDefaultAssets": {
+                            "type": "string"
+                        },
+                        "reactAppBuildDirPath": {
+                            "type": "string"
+                        },
+                        "keycloakifyBuildDirPath": {
+                            "type": "string"
+                        },
+                        "customUserAttributes": {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            }
+                        },
+                        "themeName": {
+                            "type": "string"
+                        }
+                    },
+                    "additionalProperties": false
+                }
+            },
+            "required": ["name", "version"],
+            "additionalProperties": false
+        }
+    },
+    "$schema": "http://json-schema.org/draft-07/schema#"
+}

package.json

@@ -1,6 +1,6 @@
 {
     "name": "keycloakify",
-    "version": "7.2.1",
+    "version": "7.6.5",
     "description": "Create Keycloak themes using React",
     "repository": {
         "type": "git",
@@ -12,11 +12,12 @@
         "prepare": "yarn generate-i18n-messages",
         "build": "rimraf dist/ && tsc -p src/bin && tsc -p src/tsconfig.json && tsc-alias -p src/tsconfig.json && yarn grant-exec-perms && yarn copy-files dist/",
         "build:watch": "tsc -p src/tsconfig.json && (concurrently \"tsc -p src/tsconfig.json -w\" \"tsc-alias -p src/tsconfig.json\")",
-        "build:test": "rimraf dist_test/ && tsc -p test/tsconfig.json && tsc-alias -p test/tsconfig.json && yarn copy-files dist_test/src",
+        "generate:json-schema": "ts-node scripts/generate-json-schema.ts",
         "grant-exec-perms": "node dist/bin/tools/grant-exec-perms.js",
         "copy-files": "copyfiles -u 1 src/**/*.ftl",
-        "test": "yarn build:test && node dist_test/test/bin && node dist_test/test/lib",
-        "test:sample-app": "yarn build:test && node dist_test/test/bin/main.js",
+        "test": "yarn test:types && vitest run",
+        "test:keycloakify-starter": "ts-node scripts/test-keycloakify-starter",
+        "test:types": "tsc -p test/tsconfig.json --noEmit",
         "_format": "prettier '**/*.{ts,tsx,json,md}'",
         "format": "yarn _format --write",
         "format:check": "yarn _format --list-different",
@@ -69,6 +70,7 @@
         "@types/minimist": "^1.2.2",
         "@types/node": "^18.15.3",
         "@types/react": "18.0.9",
+        "@types/yauzl": "^2.10.0",
         "concurrently": "^7.6.0",
         "copyfiles": "^2.4.1",
         "husky": "^4.3.8",
@@ -80,10 +82,13 @@
         "scripting-tools": "^0.19.13",
         "ts-node": "^10.9.1",
         "tsc-alias": "^1.8.3",
-        "typescript": "^5.0.1-rc"
+        "typescript": "^5.0.1-rc",
+        "vitest": "^0.29.8",
+        "zod-to-json-schema": "^3.20.4"
     },
     "dependencies": {
         "@octokit/rest": "^18.12.0",
+        "@types/yazl": "^2.4.2",
         "cheerio": "^1.0.0-rc.5",
         "cli-select": "^1.1.2",
         "evt": "^2.4.18",
@@ -94,6 +99,8 @@
         "react-markdown": "^5.0.3",
         "rfc4648": "^1.5.2",
         "tsafe": "^1.6.0",
+        "yauzl": "^2.10.0",
+        "yazl": "^2.5.1",
         "zod": "^3.17.10"
     }
 }

scripts/generate-i18n-messages.ts

@@ -1,13 +1,13 @@
 import "minimal-polyfills/Object.fromEntries";
 import * as fs from "fs";
-import { join as pathJoin, relative as pathRelative, dirname as pathDirname } from "path";
+import { join as pathJoin, relative as pathRelative, dirname as pathDirname, sep as pathSep } from "path";
 import { crawl } from "../src/bin/tools/crawl";
 import { downloadBuiltinKeycloakTheme } from "../src/bin/download-builtin-keycloak-theme";
 import { getProjectRoot } from "../src/bin/tools/getProjectRoot";
 import { getCliOptions } from "../src/bin/tools/cliOptions";
 import { getLogger } from "../src/bin/tools/logger";
 
-//NOTE: To run without argument when we want to generate src/i18n/generated_kcMessages files,
+// NOTE: To run without argument when we want to generate src/i18n/generated_kcMessages files,
 // update the version array for generating for newer version.
 
 //@ts-ignore
@@ -16,7 +16,7 @@ const propertiesParser = require("properties-parser");
 const { isSilent } = getCliOptions(process.argv.slice(2));
 const logger = getLogger({ isSilent });
 
-(async () => {
+async function main() {
     const keycloakVersion = "21.0.1";
 
     const tmpDirPath = pathJoin(getProjectRoot(), "tmp_xImOef9dOd44");
@@ -35,9 +35,10 @@ const logger = getLogger({ isSilent });
 
     {
         const baseThemeDirPath = pathJoin(tmpDirPath, "base");
+        const re = new RegExp(`^([^\\${pathSep}]+)\\${pathSep}messages\\${pathSep}messages_([^.]+).properties$`);
 
         crawl(baseThemeDirPath).forEach(filePath => {
-            const match = filePath.match(/^([^/]+)\/messages\/messages_([^.]+)\.properties$/);
+            const match = filePath.match(re);
 
             if (match === null) {
                 return;
@@ -114,4 +115,8 @@ const logger = getLogger({ isSilent });
             )
         );
     });
-})();
+}
+
+if (require.main === module) {
+    main();
+}

scripts/generate-json-schema.ts

@@ -0,0 +1,14 @@
+import fs from "fs";
+import path from "path";
+import zodToJsonSchema from "zod-to-json-schema";
+import { zParsedPackageJson } from "../src/bin/keycloakify/parsedPackageJson";
+
+const jsonSchemaName = "keycloakifyPackageJsonSchema";
+const jsonSchema = zodToJsonSchema(zParsedPackageJson, jsonSchemaName);
+
+const baseProperties = {
+    // merges package.json schema with keycloakify properties
+    "allOf": [{ "$ref": "https://json.schemastore.org/package.json" }, { "$ref": jsonSchemaName }]
+};
+
+fs.writeFileSync(path.join(process.cwd(), "keycloakify-json-schema.json"), JSON.stringify({ ...baseProperties, ...jsonSchema }, null, 2));

scripts/test-keycloakify-starter.ts

@@ -0,0 +1,29 @@
+import { execSync } from "child_process";
+import { existsSync, readFileSync, rmSync, writeFileSync } from "fs";
+import path from "path";
+
+const testDir = "keycloakify_starter_test";
+
+if (existsSync(path.join(process.cwd(), testDir))) {
+    rmSync(path.join(process.cwd(), testDir), { recursive: true });
+}
+// Build and link package
+execSync("yarn build");
+const pkgJSON = JSON.parse(readFileSync(path.join(process.cwd(), "package.json")).toString("utf8"));
+pkgJSON.main = "./index.js";
+pkgJSON.types = "./index.d.ts";
+pkgJSON.scripts.prepare = undefined;
+writeFileSync(path.join(process.cwd(), "dist", "package.json"), JSON.stringify(pkgJSON));
+// Wrapped in a try/catch because unlink errors if the package isn't linked
+try {
+    execSync("yarn unlink");
+} catch {}
+execSync("yarn link", { "cwd": path.join(process.cwd(), "dist") });
+
+// Clone latest keycloakify-starter and link to keycloakify output
+execSync(`git clone https://github.com/keycloakify/keycloakify-starter.git ${testDir}`);
+execSync("yarn install", { "cwd": path.join(process.cwd(), testDir) });
+execSync("yarn link keycloakify", { "cwd": path.join(process.cwd(), testDir) });
+
+//Ensure keycloak theme can be built
+execSync("yarn build-keycloak-theme", { "cwd": path.join(process.cwd(), testDir) });

src/account/kcContext/KcContext.ts

@@ -6,6 +6,7 @@ export type KcContext = KcContext.Password | KcContext.Account;
 
 export declare namespace KcContext {
     export type Common = {
+        keycloakifyVersion: string;
         locale?: {
             supported: {
                 url: string;

src/account/kcContext/getKcContext.ts

@@ -7,6 +7,8 @@ import { pathBasename } from "keycloakify/tools/pathBasename";
 import { mockTestingResourcesCommonPath } from "keycloakify/bin/mockTestingResourcesPath";
 import { symToStr } from "tsafe/symToStr";
 import { kcContextMocks, kcContextCommonMock } from "keycloakify/account/kcContext/kcContextMocks";
+import { id } from "tsafe/id";
+import { accountThemePageIds } from "keycloakify/bin/keycloakify/generateFtl/pageId";
 
 export function getKcContext<KcContextExtension extends { pageId: string } = never>(params?: {
     mockPageId?: ExtendKcContext<KcContextExtension>["pageId"];
@@ -62,7 +64,7 @@ export function getKcContext<KcContextExtension extends { pageId: string } = nev
         return { "kcContext": undefined };
     }
 
-    if (!("account" in realKcContext)) {
+    if (id<readonly string[]>(accountThemePageIds).indexOf(realKcContext.pageId) < 0 && !("account" in realKcContext)) {
         return { "kcContext": undefined };
     }
 

src/account/kcContext/kcContextMocks.ts

@@ -7,6 +7,7 @@ import type { KcContext } from "./KcContext";
 const PUBLIC_URL = process.env["PUBLIC_URL"] ?? "/";
 
 export const kcContextCommonMock: KcContext.Common = {
+    "keycloakifyVersion": "0.0.0",
     "url": {
         "resourcesPath": pathJoin(PUBLIC_URL, mockTestingResourcesPath),
         "resourcesCommonPath": pathJoin(PUBLIC_URL, mockTestingResourcesCommonPath),

src/bin/download-builtin-keycloak-theme.ts

@@ -1,42 +1,51 @@
 #!/usr/bin/env node
-
-import { keycloakThemeBuildingDirPath } from "./keycloakify";
 import { join as pathJoin } from "path";
 import { downloadAndUnzip } from "./tools/downloadAndUnzip";
 import { promptKeycloakVersion } from "./promptKeycloakVersion";
 import { getCliOptions } from "./tools/cliOptions";
 import { getLogger } from "./tools/logger";
+import { readBuildOptions } from "./keycloakify/BuildOptions";
 
 export async function downloadBuiltinKeycloakTheme(params: { keycloakVersion: string; destDirPath: string; isSilent: boolean }) {
-    const { keycloakVersion, destDirPath, isSilent } = params;
+    const { keycloakVersion, destDirPath } = params;
 
     await Promise.all(
         ["", "-community"].map(ext =>
             downloadAndUnzip({
                 "destDirPath": destDirPath,
                 "url": `https://github.com/keycloak/keycloak/archive/refs/tags/${keycloakVersion}.zip`,
-                "pathOfDirToExtractInArchive": `keycloak-${keycloakVersion}/themes/src/main/resources${ext}/theme`,
-                "cacheDirPath": pathJoin(keycloakThemeBuildingDirPath, ".cache"),
-                isSilent
+                "pathOfDirToExtractInArchive": `keycloak-${keycloakVersion}/themes/src/main/resources${ext}/theme`
             })
         )
     );
 }
 
-if (require.main === module) {
-    (async () => {
-        const { isSilent } = getCliOptions(process.argv.slice(2));
-        const logger = getLogger({ isSilent });
-        const { keycloakVersion } = await promptKeycloakVersion();
+async function main() {
+    const { isSilent } = getCliOptions(process.argv.slice(2));
+    const logger = getLogger({ isSilent });
+    const { keycloakVersion } = await promptKeycloakVersion();
 
-        const destDirPath = pathJoin(keycloakThemeBuildingDirPath, "src", "main", "resources", "theme");
+    const destDirPath = pathJoin(
+        readBuildOptions({
+            "isSilent": true,
+            "isExternalAssetsCliParamProvided": false,
+            "projectDirPath": process.cwd()
+        }).keycloakifyBuildDirPath,
+        "src",
+        "main",
+        "resources",
+        "theme"
+    );
 
-        logger.log(`Downloading builtins theme of Keycloak ${keycloakVersion} here ${destDirPath}`);
+    logger.log(`Downloading builtins theme of Keycloak ${keycloakVersion} here ${destDirPath}`);
 
-        await downloadBuiltinKeycloakTheme({
-            keycloakVersion,
-            destDirPath,
-            isSilent
-        });
-    })();
+    await downloadBuiltinKeycloakTheme({
+        keycloakVersion,
+        destDirPath,
+        isSilent
+    });
+}
+
+if (require.main === module) {
+    main();
 }

src/bin/eject-keycloak-page.ts

@@ -9,17 +9,16 @@ import {
     type AccountThemePageId,
     themeTypes,
     type ThemeType
-} from "./keycloakify/generateFtl/generateFtl";
+} from "./keycloakify/generateFtl";
 import { capitalize } from "tsafe/capitalize";
 import { readFile, writeFile } from "fs/promises";
 import { existsSync } from "fs";
 import { join as pathJoin, relative as pathRelative } from "path";
 import { kebabCaseToCamelCase } from "./tools/kebabCaseToSnakeCase";
 import { assert, Equals } from "tsafe/assert";
+import { getThemeSrcDirPath } from "./getSrcDirPath";
 
 (async () => {
-    const projectRootDir = getProjectRoot();
-
     console.log("Select a theme type");
 
     const { value: themeType } = await cliSelect<ThemeType>({
@@ -50,7 +49,13 @@ import { assert, Equals } from "tsafe/assert";
 
     const pageBasename = capitalize(kebabCaseToCamelCase(pageId)).replace(/ftl$/, "tsx");
 
-    const targetFilePath = pathJoin(process.cwd(), "src", "keycloak-theme", themeType, "pages", pageBasename);
+    const { themeSrcDirPath } = getThemeSrcDirPath({ "projectDirPath": process.cwd() });
+
+    if (themeSrcDirPath === undefined) {
+        throw new Error("Couldn't locate your theme sources");
+    }
+
+    const targetFilePath = pathJoin(themeSrcDirPath, themeType, "pages", pageBasename);
 
     if (existsSync(targetFilePath)) {
         console.log(`${pageId} is already ejected, ${pathRelative(process.cwd(), targetFilePath)} already exists`);
@@ -58,7 +63,7 @@ import { assert, Equals } from "tsafe/assert";
         process.exit(-1);
     }
 
-    writeFile(targetFilePath, await readFile(pathJoin(projectRootDir, "src", themeType, "pages", pageBasename)));
+    await writeFile(targetFilePath, await readFile(pathJoin(getProjectRoot(), "src", themeType, "pages", pageBasename)));
 
     console.log(`${pathRelative(process.cwd(), targetFilePath)} created`);
 })();

src/bin/getSrcDirPath.ts

@@ -0,0 +1,43 @@
+import * as fs from "fs";
+import { exclude } from "tsafe";
+import { crawl } from "./tools/crawl";
+import { join as pathJoin } from "path";
+
+const themeSrcDirBasename = "keycloak-theme";
+
+export function getThemeSrcDirPath(params: { projectDirPath: string }) {
+    const { projectDirPath } = params;
+
+    const srcDirPath = pathJoin(projectDirPath, "src");
+
+    const themeSrcDirPath: string | undefined = crawl(srcDirPath)
+        .map(fileRelativePath => {
+            const split = fileRelativePath.split(themeSrcDirBasename);
+
+            if (split.length !== 2) {
+                return undefined;
+            }
+
+            return pathJoin(srcDirPath, split[0] + themeSrcDirBasename);
+        })
+        .filter(exclude(undefined))[0];
+
+    if (themeSrcDirPath === undefined) {
+        if (fs.existsSync(pathJoin(srcDirPath, "login")) || fs.existsSync(pathJoin(srcDirPath, "account"))) {
+            return { "themeSrcDirPath": srcDirPath };
+        }
+        return { "themeSrcDirPath": undefined };
+    }
+
+    return { themeSrcDirPath };
+}
+
+export function getEmailThemeSrcDirPath(params: { projectDirPath: string }) {
+    const { projectDirPath } = params;
+
+    const { themeSrcDirPath } = getThemeSrcDirPath({ projectDirPath });
+
+    const emailThemeSrcDirPath = themeSrcDirPath === undefined ? undefined : pathJoin(themeSrcDirPath, "email");
+
+    return { emailThemeSrcDirPath };
+}

src/bin/initialize-email-theme.ts

@@ -7,54 +7,18 @@ import { promptKeycloakVersion } from "./promptKeycloakVersion";
 import * as fs from "fs";
 import { getCliOptions } from "./tools/cliOptions";
 import { getLogger } from "./tools/logger";
-import { crawl } from "./tools/crawl";
-import { exclude } from "tsafe/exclude";
+import { getEmailThemeSrcDirPath } from "./getSrcDirPath";
 
-const reactProjectDirPath = process.cwd();
-
-const themeSrcDirBasename = "keycloak-theme";
-
-function getThemeSrcDirPath() {
-    const srcDirPath = pathJoin(reactProjectDirPath, "src");
-
-    const themeSrcDirPath: string | undefined = crawl(srcDirPath)
-        .map(fileRelativePath => {
-            const split = fileRelativePath.split(themeSrcDirBasename);
-
-            if (split.length !== 2) {
-                return undefined;
-            }
-
-            return pathJoin(srcDirPath, split[0] + themeSrcDirBasename);
-        })
-        .filter(exclude(undefined))[0];
-
-    if (themeSrcDirBasename === undefined) {
-        if (fs.existsSync(pathJoin(srcDirPath, "login")) || fs.existsSync(pathJoin(srcDirPath, "account"))) {
-            return { "themeSrcDirPath": srcDirPath };
-        }
-        return { "themeSrcDirPath": undefined };
-    }
-
-    return { themeSrcDirPath };
-}
-
-export function getEmailThemeSrcDirPath() {
-    const { themeSrcDirPath } = getThemeSrcDirPath();
-
-    const emailThemeSrcDirPath = themeSrcDirPath === undefined ? undefined : pathJoin(themeSrcDirPath, "email");
-
-    return { emailThemeSrcDirPath };
-}
-
-async function main() {
+export async function main() {
     const { isSilent } = getCliOptions(process.argv.slice(2));
     const logger = getLogger({ isSilent });
 
-    const { emailThemeSrcDirPath } = getEmailThemeSrcDirPath();
+    const { emailThemeSrcDirPath } = getEmailThemeSrcDirPath({
+        "projectDirPath": process.cwd()
+    });
 
     if (emailThemeSrcDirPath === undefined) {
-        logger.warn(`Couldn't locate you ${themeSrcDirBasename} directory`);
+        logger.warn("Couldn't locate your theme source directory");
 
         process.exit(-1);
     }

src/bin/keycloakify/BuildOptions.ts

@@ -1,51 +1,11 @@
-import { z } from "zod";
 import { assert } from "tsafe/assert";
-import type { Equals } from "tsafe";
 import { id } from "tsafe/id";
 import { parse as urlParse } from "url";
 import { typeGuard } from "tsafe/typeGuard";
 import { symToStr } from "tsafe/symToStr";
-
-const bundlers = ["mvn", "keycloakify", "none"] as const;
-type Bundler = (typeof bundlers)[number];
-type ParsedPackageJson = {
-    name: string;
-    version: string;
-    homepage?: string;
-    keycloakify?: {
-        /** @deprecated: use extraLoginPages instead */
-        extraPages?: string[];
-        extraLoginPages?: string[];
-        extraAccountPages?: string[];
-        extraThemeProperties?: string[];
-        areAppAndKeycloakServerSharingSameDomain?: boolean;
-        artifactId?: string;
-        groupId?: string;
-        bundler?: Bundler;
-        keycloakVersionDefaultAssets?: string;
-    };
-};
-
-const zParsedPackageJson = z.object({
-    "name": z.string(),
-    "version": z.string(),
-    "homepage": z.string().optional(),
-    "keycloakify": z
-        .object({
-            "extraPages": z.array(z.string()).optional(),
-            "extraLoginPages": z.array(z.string()).optional(),
-            "extraAccountPages": z.array(z.string()).optional(),
-            "extraThemeProperties": z.array(z.string()).optional(),
-            "areAppAndKeycloakServerSharingSameDomain": z.boolean().optional(),
-            "artifactId": z.string().optional(),
-            "groupId": z.string().optional(),
-            "bundler": z.enum(bundlers).optional(),
-            "keycloakVersionDefaultAssets": z.string().optional()
-        })
-        .optional()
-});
-
-assert<Equals<ReturnType<(typeof zParsedPackageJson)["parse"]>, ParsedPackageJson>>();
+import { bundlers, getParsedPackageJson, type Bundler } from "./parsedPackageJson";
+import * as fs from "fs";
+import { join as pathJoin, sep as pathSep } from "path";
 
 /** Consolidated build option gathered form CLI arguments and config in package.json */
 export type BuildOptions = BuildOptions.Standalone | BuildOptions.ExternalAssets;
@@ -53,7 +13,7 @@ export type BuildOptions = BuildOptions.Standalone | BuildOptions.ExternalAssets
 export namespace BuildOptions {
     export type Common = {
         isSilent: boolean;
-        version: string;
+        themeVersion: string;
         themeName: string;
         extraLoginPages: string[] | undefined;
         extraAccountPages: string[] | undefined;
@@ -62,6 +22,11 @@ export namespace BuildOptions {
         artifactId: string;
         bundler: Bundler;
         keycloakVersionDefaultAssets: string;
+        /** Directory of your built react project. Defaults to {cwd}/build */
+        reactAppBuildDirPath: string;
+        /** Directory that keycloakify outputs to. Defaults to {cwd}/build_keycloak */
+        keycloakifyBuildDirPath: string;
+        customUserAttributes: string[];
     };
 
     export type Standalone = Common & {
@@ -88,15 +53,10 @@ export namespace BuildOptions {
     }
 }
 
-export function readBuildOptions(params: {
-    packageJson: string;
-    CNAME: string | undefined;
-    isExternalAssetsCliParamProvided: boolean;
-    isSilent: boolean;
-}): BuildOptions {
-    const { packageJson, CNAME, isExternalAssetsCliParamProvided, isSilent } = params;
+export function readBuildOptions(params: { projectDirPath: string; isExternalAssetsCliParamProvided: boolean; isSilent: boolean }): BuildOptions {
+    const { projectDirPath, isExternalAssetsCliParamProvided, isSilent } = params;
 
-    const parsedPackageJson = zParsedPackageJson.parse(JSON.parse(packageJson));
+    const parsedPackageJson = getParsedPackageJson({ projectDirPath });
 
     const url = (() => {
         const { homepage } = parsedPackageJson;
@@ -107,6 +67,16 @@ export function readBuildOptions(params: {
             url = new URL(homepage);
         }
 
+        const CNAME = (() => {
+            const cnameFilePath = pathJoin(projectDirPath, "public", "CNAME");
+
+            if (!fs.existsSync(cnameFilePath)) {
+                return undefined;
+            }
+
+            return fs.readFileSync(cnameFilePath).toString("utf8");
+        })();
+
         if (CNAME !== undefined) {
             url = new URL(`https://${CNAME.replace(/\s+$/, "")}`);
         }
@@ -131,10 +101,12 @@ export function readBuildOptions(params: {
         const { extraPages, extraLoginPages, extraAccountPages, extraThemeProperties, groupId, artifactId, bundler, keycloakVersionDefaultAssets } =
             keycloakify ?? {};
 
-        const themeName = name
-            .replace(/^@(.*)/, "$1")
-            .split("/")
-            .join("-");
+        const themeName =
+            keycloakify.themeName ??
+            name
+                .replace(/^@(.*)/, "$1")
+                .split("/")
+                .join("-");
 
         return {
             themeName,
@@ -167,12 +139,47 @@ export function readBuildOptions(params: {
                               .join(".") ?? fallbackGroupId) + ".keycloak"
                 );
             })(),
-            "version": process.env.KEYCLOAKIFY_VERSION ?? version,
+            "themeVersion": process.env.KEYCLOAKIFY_THEME_VERSION ?? process.env.KEYCLOAKIFY_VERSION ?? version ?? "0.0.0",
             "extraLoginPages": [...(extraPages ?? []), ...(extraLoginPages ?? [])],
             extraAccountPages,
             extraThemeProperties,
             isSilent,
-            "keycloakVersionDefaultAssets": keycloakVersionDefaultAssets ?? "11.0.3"
+            "keycloakVersionDefaultAssets": keycloakVersionDefaultAssets ?? "11.0.3",
+            "reactAppBuildDirPath": (() => {
+                let { reactAppBuildDirPath = undefined } = parsedPackageJson.keycloakify ?? {};
+
+                if (reactAppBuildDirPath === undefined) {
+                    return pathJoin(projectDirPath, "build");
+                }
+
+                if (pathSep === "\\") {
+                    reactAppBuildDirPath = reactAppBuildDirPath.replace(/\//g, pathSep);
+                }
+
+                if (reactAppBuildDirPath.startsWith(`.${pathSep}`)) {
+                    return pathJoin(projectDirPath, reactAppBuildDirPath);
+                }
+
+                return reactAppBuildDirPath;
+            })(),
+            "keycloakifyBuildDirPath": (() => {
+                let { keycloakifyBuildDirPath = undefined } = parsedPackageJson.keycloakify ?? {};
+
+                if (keycloakifyBuildDirPath === undefined) {
+                    return pathJoin(projectDirPath, "build_keycloak");
+                }
+
+                if (pathSep === "\\") {
+                    keycloakifyBuildDirPath = keycloakifyBuildDirPath.replace(/\//g, pathSep);
+                }
+
+                if (keycloakifyBuildDirPath.startsWith(`.${pathSep}`)) {
+                    return pathJoin(projectDirPath, keycloakifyBuildDirPath);
+                }
+
+                return keycloakifyBuildDirPath;
+            })(),
+            "customUserAttributes": keycloakify.customUserAttributes ?? []
         };
     })();
 

src/bin/keycloakify/generateFtl/ftl_object_to_js_code_declaring_an_object.ftl

@@ -1,5 +1,4 @@
 <script>const _= 
-<#assign pageId="PAGE_ID_xIgLsPgGId9D8e">
 (()=>{
 
     const out = ${ftl_object_to_js_code_declaring_an_object(.data_model, [])?no_esc};
@@ -13,7 +12,7 @@
             "totp", "totpSecret", "SAMLRequest", "SAMLResponse", "relayState", "device_user_code", "code", 
             "password-new", "rememberMe", "login", "authenticationExecution", "cancel-aia", "clientDataJSON", 
             "authenticatorData", "signature", "credentialId", "userHandle", "error", "authn_use_chk", "authenticationExecution", 
-            "isSetRetry", "try-again", "attestationObject", "publicKeyCredentialId", "authenticatorLabel"
+            "isSetRetry", "try-again", "attestationObject", "publicKeyCredentialId", "authenticatorLabel"CUSTOM_USER_ATTRIBUTES_eKsIY4ZsZ4xeM
         ]>
     
         <#attempt>
@@ -119,7 +118,9 @@
         };
     </#if>
 
-    out["pageId"] = "${pageId}";
+    out["keycloakifyVersion"] = "KEYCLOAKIFY_VERSION_xEdKd3xEdr";
+    out["themeVersion"] = "KEYCLOAKIFY_THEME_VERSION_sIgKd3xEdr3dx";
+    out["pageId"] = "PAGE_ID_xIgLsPgGId9D8e";
 
     return out;
 

src/bin/keycloakify/generateFtl/generateFtl.ts

@@ -8,45 +8,20 @@ import { objectKeys } from "tsafe/objectKeys";
 import { ftlValuesGlobalName } from "../ftlValuesGlobalName";
 import type { BuildOptions } from "../BuildOptions";
 import { assert } from "tsafe/assert";
-import { Reflect } from "tsafe/Reflect";
 
 export const themeTypes = ["login", "account"] as const;
 
 export type ThemeType = (typeof themeTypes)[number];
 
-export const loginThemePageIds = [
-    "login.ftl",
-    "login-username.ftl",
-    "login-password.ftl",
-    "webauthn-authenticate.ftl",
-    "register.ftl",
-    "register-user-profile.ftl",
-    "info.ftl",
-    "error.ftl",
-    "login-reset-password.ftl",
-    "login-verify-email.ftl",
-    "terms.ftl",
-    "login-otp.ftl",
-    "login-update-profile.ftl",
-    "login-update-password.ftl",
-    "login-idp-link-confirm.ftl",
-    "login-idp-link-email.ftl",
-    "login-page-expired.ftl",
-    "login-config-totp.ftl",
-    "logout-confirm.ftl",
-    "update-user-profile.ftl",
-    "idp-review-user-profile.ftl"
-] as const;
-
-export const accountThemePageIds = ["password.ftl", "account.ftl"] as const;
-
-export type LoginThemePageId = (typeof loginThemePageIds)[number];
-export type AccountThemePageId = (typeof accountThemePageIds)[number];
-
 export type BuildOptionsLike = BuildOptionsLike.Standalone | BuildOptionsLike.ExternalAssets;
 
 export namespace BuildOptionsLike {
-    export type Standalone = {
+    export type Common = {
+        customUserAttributes: string[];
+        themeVersion: string;
+    };
+
+    export type Standalone = Common & {
         isStandalone: true;
         urlPathname: string | undefined;
     };
@@ -58,31 +33,30 @@ export namespace BuildOptionsLike {
             isStandalone: false;
         };
 
-        export type SameDomain = CommonExternalAssets & {
-            areAppAndKeycloakServerSharingSameDomain: true;
-        };
+        export type SameDomain = Common &
+            CommonExternalAssets & {
+                areAppAndKeycloakServerSharingSameDomain: true;
+            };
 
-        export type DifferentDomains = CommonExternalAssets & {
-            areAppAndKeycloakServerSharingSameDomain: false;
-            urlOrigin: string;
-            urlPathname: string | undefined;
-        };
+        export type DifferentDomains = Common &
+            CommonExternalAssets & {
+                areAppAndKeycloakServerSharingSameDomain: false;
+                urlOrigin: string;
+                urlPathname: string | undefined;
+            };
     }
 }
 
-{
-    const buildOptions = Reflect<BuildOptions>();
-
-    assert<typeof buildOptions extends BuildOptionsLike ? true : false>();
-}
+assert<BuildOptions extends BuildOptionsLike ? true : false>();
 
 export function generateFtlFilesCodeFactory(params: {
     indexHtmlCode: string;
     //NOTE: Expected to be an empty object if external assets mode is enabled.
     cssGlobalsToDefine: Record<string, string>;
     buildOptions: BuildOptionsLike;
+    keycloakifyVersion: string;
 }) {
-    const { cssGlobalsToDefine, indexHtmlCode, buildOptions } = params;
+    const { cssGlobalsToDefine, indexHtmlCode, buildOptions, keycloakifyVersion } = params;
 
     const $ = cheerio.load(indexHtmlCode);
 
@@ -152,7 +126,13 @@ export function generateFtlFilesCodeFactory(params: {
         '{ "x": "vIdLqMeOed9sdLdIdOxdK0d" }': fs
             .readFileSync(pathJoin(__dirname, "ftl_object_to_js_code_declaring_an_object.ftl"))
             .toString("utf8")
-            .match(/^<script>const _=((?:.|\n)+)<\/script>[\n]?$/)![1],
+            .match(/^<script>const _=((?:.|\n)+)<\/script>[\n]?$/)![1]
+            .replace(
+                "CUSTOM_USER_ATTRIBUTES_eKsIY4ZsZ4xeM",
+                buildOptions.customUserAttributes.length === 0 ? "" : ", " + buildOptions.customUserAttributes.map(name => `"${name}"`).join(", ")
+            )
+            .replace("KEYCLOAKIFY_VERSION_xEdKd3xEdr", keycloakifyVersion)
+            .replace("KEYCLOAKIFY_THEME_VERSION_sIgKd3xEdr3dx", buildOptions.themeVersion),
         "<!-- xIdLqMeOedErIdLsPdNdI9dSlxI -->": [
             "<#if scripts??>",
             "    <#list scripts as script>",
@@ -185,7 +165,6 @@ export function generateFtlFilesCodeFactory(params: {
 
         Object.entries({
             ...replaceValueBySearchValue,
-            //If updated, don't forget to change in the ftl script as well.
             "PAGE_ID_xIgLsPgGId9D8e": pageId
         }).map(([searchValue, replaceValue]) => (ftlCode = ftlCode.replace(searchValue, replaceValue)));
 

src/bin/keycloakify/generateFtl/index.ts

@@ -1 +1,2 @@
 export * from "./generateFtl";
+export * from "./pageId";

src/bin/keycloakify/generateFtl/pageId.ts

@@ -0,0 +1,30 @@
+export const loginThemePageIds = [
+    "login.ftl",
+    "login-username.ftl",
+    "login-password.ftl",
+    "webauthn-authenticate.ftl",
+    "register.ftl",
+    "register-user-profile.ftl",
+    "info.ftl",
+    "error.ftl",
+    "login-reset-password.ftl",
+    "login-verify-email.ftl",
+    "terms.ftl",
+    "login-otp.ftl",
+    "login-update-profile.ftl",
+    "login-update-password.ftl",
+    "login-idp-link-confirm.ftl",
+    "login-idp-link-email.ftl",
+    "login-page-expired.ftl",
+    "login-config-totp.ftl",
+    "logout-confirm.ftl",
+    "update-user-profile.ftl",
+    "idp-review-user-profile.ftl",
+    "update-email.ftl",
+    "select-authenticator.ftl"
+] as const;
+
+export const accountThemePageIds = ["password.ftl", "account.ftl"] as const;
+
+export type LoginThemePageId = (typeof loginThemePageIds)[number];
+export type AccountThemePageId = (typeof accountThemePageIds)[number];

src/bin/keycloakify/generateJavaStackFiles.ts

@@ -9,7 +9,7 @@ export type BuildOptionsLike = {
     themeName: string;
     groupId: string;
     artifactId?: string;
-    version: string;
+    themeVersion: string;
 };
 
 {
@@ -26,7 +26,7 @@ export function generateJavaStackFiles(params: {
     jarFilePath: string;
 } {
     const {
-        buildOptions: { groupId, themeName, version, artifactId },
+        buildOptions: { groupId, themeName, themeVersion, artifactId },
         keycloakThemeBuildingDirPath,
         doBundlesEmailTemplate
     } = params;
@@ -43,7 +43,7 @@ export function generateJavaStackFiles(params: {
                 `	<modelVersion>4.0.0</modelVersion>`,
                 `	<groupId>${groupId}</groupId>`,
                 `	<artifactId>${artifactId}</artifactId>`,
-                `	<version>${version}</version>`,
+                `	<version>${themeVersion}</version>`,
                 `	<name>${artifactId}</name>`,
                 `	<description />`,
                 `</project>`
@@ -83,6 +83,6 @@ export function generateJavaStackFiles(params: {
     }
 
     return {
-        "jarFilePath": pathJoin(keycloakThemeBuildingDirPath, "target", `${artifactId}-${version}.jar`)
+        "jarFilePath": pathJoin(keycloakThemeBuildingDirPath, "target", `${artifactId}-${themeVersion}.jar`)
     };
 }

src/bin/keycloakify/generateKeycloakThemeResources.ts

@@ -9,7 +9,6 @@ import { mockTestingResourcesCommonPath, mockTestingResourcesPath, mockTestingSu
 import { isInside } from "../tools/isInside";
 import type { BuildOptions } from "./BuildOptions";
 import { assert } from "tsafe/assert";
-import { Reflect } from "tsafe/Reflect";
 
 export type BuildOptionsLike = BuildOptionsLike.Standalone | BuildOptionsLike.ExternalAssets;
 
@@ -20,6 +19,8 @@ export namespace BuildOptionsLike {
         extraAccountPages?: string[];
         extraThemeProperties?: string[];
         isSilent: boolean;
+        customUserAttributes: string[];
+        themeVersion: string;
     };
 
     export type Standalone = Common & {
@@ -46,11 +47,7 @@ export namespace BuildOptionsLike {
     }
 }
 
-{
-    const buildOptions = Reflect<BuildOptions>();
-
-    assert<typeof buildOptions extends BuildOptionsLike ? true : false>();
-}
+assert<BuildOptions extends BuildOptionsLike ? true : false>();
 
 export async function generateKeycloakThemeResources(params: {
     reactAppBuildDirPath: string;
@@ -58,8 +55,9 @@ export async function generateKeycloakThemeResources(params: {
     emailThemeSrcDirPath: string | undefined;
     keycloakVersion: string;
     buildOptions: BuildOptionsLike;
+    keycloakifyVersion: string;
 }): Promise<{ doBundlesEmailTemplate: boolean }> {
-    const { reactAppBuildDirPath, keycloakThemeBuildingDirPath, emailThemeSrcDirPath, keycloakVersion, buildOptions } = params;
+    const { reactAppBuildDirPath, keycloakThemeBuildingDirPath, emailThemeSrcDirPath, keycloakVersion, buildOptions, keycloakifyVersion } = params;
 
     const getThemeDirPath = (themeType: ThemeType | "email") =>
         pathJoin(keycloakThemeBuildingDirPath, "src", "main", "resources", "theme", buildOptions.themeName, themeType);
@@ -142,7 +140,8 @@ export async function generateKeycloakThemeResources(params: {
             const { generateFtlFilesCode } = generateFtlFilesCodeFactory({
                 "indexHtmlCode": fs.readFileSync(pathJoin(reactAppBuildDirPath, "index.html")).toString("utf8"),
                 "cssGlobalsToDefine": allCssGlobalsToDefine,
-                "buildOptions": buildOptions
+                buildOptions,
+                keycloakifyVersion
             });
 
             return generateFtlFilesCode;

src/bin/keycloakify/index.ts

@@ -4,5 +4,5 @@ export * from "./keycloakify";
 import { main } from "./keycloakify";
 
 if (require.main === module) {
-    main().catch(e => console.error(e));
+    main();
 }

src/bin/keycloakify/keycloakify.ts

@@ -10,36 +10,26 @@ import { getCliOptions } from "../tools/cliOptions";
 import jar from "../tools/jar";
 import { assert } from "tsafe/assert";
 import { Equals } from "tsafe";
-import { getEmailThemeSrcDirPath } from "../initialize-email-theme";
-
-const reactProjectDirPath = process.cwd();
-
-export const keycloakThemeBuildingDirPath = pathJoin(reactProjectDirPath, "build_keycloak");
+import { getEmailThemeSrcDirPath } from "../getSrcDirPath";
+import { getProjectRoot } from "../tools/getProjectRoot";
 
 export async function main() {
     const { isSilent, hasExternalAssets } = getCliOptions(process.argv.slice(2));
     const logger = getLogger({ isSilent });
     logger.log("🔏 Building the keycloak theme...⌚");
 
+    const projectDirPath = process.cwd();
+
     const buildOptions = readBuildOptions({
-        "packageJson": fs.readFileSync(pathJoin(reactProjectDirPath, "package.json")).toString("utf8"),
-        "CNAME": (() => {
-            const cnameFilePath = pathJoin(reactProjectDirPath, "public", "CNAME");
-
-            if (!fs.existsSync(cnameFilePath)) {
-                return undefined;
-            }
-
-            return fs.readFileSync(cnameFilePath).toString("utf8");
-        })(),
+        projectDirPath,
         "isExternalAssetsCliParamProvided": hasExternalAssets,
         "isSilent": isSilent
     });
 
     const { doBundlesEmailTemplate } = await generateKeycloakThemeResources({
-        keycloakThemeBuildingDirPath,
+        keycloakThemeBuildingDirPath: buildOptions.keycloakifyBuildDirPath,
         "emailThemeSrcDirPath": (() => {
-            const { emailThemeSrcDirPath } = getEmailThemeSrcDirPath();
+            const { emailThemeSrcDirPath } = getEmailThemeSrcDirPath({ projectDirPath });
 
             if (emailThemeSrcDirPath === undefined || !fs.existsSync(emailThemeSrcDirPath)) {
                 return;
@@ -47,13 +37,20 @@ export async function main() {
 
             return emailThemeSrcDirPath;
         })(),
-        "reactAppBuildDirPath": pathJoin(reactProjectDirPath, "build"),
+        "reactAppBuildDirPath": buildOptions.reactAppBuildDirPath,
         buildOptions,
-        "keycloakVersion": buildOptions.keycloakVersionDefaultAssets
+        "keycloakVersion": buildOptions.keycloakVersionDefaultAssets,
+        "keycloakifyVersion": (() => {
+            const version = JSON.parse(fs.readFileSync(pathJoin(getProjectRoot(), "package.json")).toString("utf8"))["version"];
+
+            assert(typeof version === "string");
+
+            return version;
+        })()
     });
 
     const { jarFilePath } = generateJavaStackFiles({
-        keycloakThemeBuildingDirPath,
+        keycloakThemeBuildingDirPath: buildOptions.keycloakifyBuildDirPath,
         doBundlesEmailTemplate,
         buildOptions
     });
@@ -65,8 +62,8 @@ export async function main() {
         case "keycloakify":
             logger.log("🫶 Let keycloakify do its thang");
             await jar({
-                "rootPath": pathJoin(keycloakThemeBuildingDirPath, "src", "main", "resources"),
-                "version": buildOptions.version,
+                "rootPath": pathJoin(buildOptions.keycloakifyBuildDirPath, "src", "main", "resources"),
+                "version": buildOptions.themeVersion,
                 "groupId": buildOptions.groupId,
                 "artifactId": buildOptions.artifactId,
                 "targetPath": jarFilePath
@@ -74,7 +71,7 @@ export async function main() {
             break;
         case "mvn":
             logger.log("🫙 Run maven to deliver a jar");
-            child_process.execSync("mvn package", { "cwd": keycloakThemeBuildingDirPath });
+            child_process.execSync("mvn package", { "cwd": buildOptions.keycloakifyBuildDirPath });
             break;
         default:
             assert<Equals<typeof buildOptions.bundler, never>>(false);
@@ -84,7 +81,7 @@ export async function main() {
     const containerKeycloakVersion = "20.0.1";
 
     generateStartKeycloakTestingContainer({
-        keycloakThemeBuildingDirPath,
+        keycloakThemeBuildingDirPath: buildOptions.keycloakifyBuildDirPath,
         "keycloakVersion": containerKeycloakVersion,
         buildOptions
     });
@@ -92,7 +89,7 @@ export async function main() {
     logger.log(
         [
             "",
-            `✅ Your keycloak theme has been generated and bundled into ./${pathRelative(reactProjectDirPath, jarFilePath)} 🚀`,
+            `✅ Your keycloak theme has been generated and bundled into .${pathSep}${pathRelative(projectDirPath, jarFilePath)} 🚀`,
             `It is to be placed in "/opt/keycloak/providers" in the container running a quay.io/keycloak/keycloak Docker image.`,
             "",
             //TODO: Restore when we find a good Helm chart for Keycloak.
@@ -127,8 +124,8 @@ export async function main() {
             `To test your theme locally you can spin up a Keycloak ${containerKeycloakVersion} container image with the theme pre loaded by running:`,
             "",
             `👉 $ .${pathSep}${pathRelative(
-                reactProjectDirPath,
-                pathJoin(keycloakThemeBuildingDirPath, generateStartKeycloakTestingContainer.basename)
+                projectDirPath,
+                pathJoin(buildOptions.keycloakifyBuildDirPath, generateStartKeycloakTestingContainer.basename)
             )} 👈`,
             "",
             `Test with different Keycloak versions by editing the .sh file. see available versions here: https://quay.io/repository/keycloak/keycloak?tab=tags`,

src/bin/keycloakify/parsedPackageJson.ts

@@ -0,0 +1,64 @@
+import * as fs from "fs";
+import { assert } from "tsafe";
+import type { Equals } from "tsafe";
+import { z } from "zod";
+import { pathJoin } from "../tools/pathJoin";
+
+export const bundlers = ["mvn", "keycloakify", "none"] as const;
+export type Bundler = (typeof bundlers)[number];
+export type ParsedPackageJson = {
+    name: string;
+    version?: string;
+    homepage?: string;
+    keycloakify?: {
+        /** @deprecated: use extraLoginPages instead */
+        extraPages?: string[];
+        extraLoginPages?: string[];
+        extraAccountPages?: string[];
+        extraThemeProperties?: string[];
+        areAppAndKeycloakServerSharingSameDomain?: boolean;
+        artifactId?: string;
+        groupId?: string;
+        bundler?: Bundler;
+        keycloakVersionDefaultAssets?: string;
+        reactAppBuildDirPath?: string;
+        keycloakifyBuildDirPath?: string;
+        customUserAttributes?: string[];
+        themeName?: string;
+    };
+};
+
+export const zParsedPackageJson = z.object({
+    "name": z.string(),
+    "version": z.string().optional(),
+    "homepage": z.string().optional(),
+    "keycloakify": z
+        .object({
+            "extraPages": z.array(z.string()).optional(),
+            "extraLoginPages": z.array(z.string()).optional(),
+            "extraAccountPages": z.array(z.string()).optional(),
+            "extraThemeProperties": z.array(z.string()).optional(),
+            "areAppAndKeycloakServerSharingSameDomain": z.boolean().optional(),
+            "artifactId": z.string().optional(),
+            "groupId": z.string().optional(),
+            "bundler": z.enum(bundlers).optional(),
+            "keycloakVersionDefaultAssets": z.string().optional(),
+            "reactAppBuildDirPath": z.string().optional(),
+            "keycloakifyBuildDirPath": z.string().optional(),
+            "customUserAttributes": z.array(z.string()).optional(),
+            "themeName": z.string().optional()
+        })
+        .optional()
+});
+
+assert<Equals<ReturnType<(typeof zParsedPackageJson)["parse"]>, ParsedPackageJson>>();
+
+let parsedPackageJson: undefined | ReturnType<(typeof zParsedPackageJson)["parse"]>;
+export function getParsedPackageJson(params: { projectDirPath: string }) {
+    const { projectDirPath } = params;
+    if (parsedPackageJson) {
+        return parsedPackageJson;
+    }
+    parsedPackageJson = zParsedPackageJson.parse(JSON.parse(fs.readFileSync(pathJoin(projectDirPath, "package.json")).toString("utf8")));
+    return parsedPackageJson;
+}

src/bin/tools/downloadAndUnzip.ts

@@ -1,15 +1,13 @@
-import { dirname as pathDirname, basename as pathBasename, join as pathJoin, join } from "path";
-import { createReadStream, createWriteStream } from "fs";
-import { stat, mkdir, unlink, writeFile } from "fs/promises";
-import { transformCodebase } from "./transformCodebase";
-import { createHash } from "crypto";
-import fetch from "make-fetch-happen";
-import { createInflateRaw } from "zlib";
-import type { Readable } from "stream";
-import { homedir } from "os";
-import { FetchOptions } from "make-fetch-happen";
 import { exec as execCallback } from "child_process";
+import { createHash } from "crypto";
+import { mkdir, stat, writeFile } from "fs/promises";
+import fetch, { type FetchOptions } from "make-fetch-happen";
+import { dirname as pathDirname, join as pathJoin } from "path";
+import { assert } from "tsafe";
 import { promisify } from "util";
+import { getProjectRoot } from "./getProjectRoot";
+import { transformCodebase } from "./transformCodebase";
+import { unzip } from "./unzip";
 
 const exec = promisify(execCallback);
 
@@ -17,25 +15,27 @@ function hash(s: string) {
     return createHash("sha256").update(s).digest("hex");
 }
 
-async function maybeStat(path: string) {
+async function exists(path: string) {
     try {
-        return await stat(path);
+        await stat(path);
+        return true;
     } catch (error) {
-        if ((error as Error & { code: string }).code === "ENOENT") return undefined;
+        if ((error as Error & { code: string }).code === "ENOENT") return false;
         throw error;
     }
 }
 
 /**
- * Get an npm configuration value as string, undefined if not set.
- *
- * @param key
- * @returns string or undefined
+ * Get npm configuration as map
  */
-async function getNmpConfig(key: string): Promise<string | undefined> {
-    const { stdout } = await exec(`npm config get ${key}`);
-    const value = stdout.trim();
-    return value && value !== "null" ? value : undefined;
+async function getNmpConfig(): Promise<Record<string, string>> {
+    const { stdout } = await exec("npm config get", { encoding: "utf8" });
+    return stdout
+        .split("\n")
+        .filter(line => !line.startsWith(";"))
+        .map(line => line.trim())
+        .map(line => line.split("=", 2))
+        .reduce((cfg, [key, value]) => ({ ...cfg, [key]: value }), {});
 }
 
 /**
@@ -45,233 +45,43 @@ async function getNmpConfig(key: string): Promise<string | undefined> {
  * @returns proxy configuration
  */
 async function getNpmProxyConfig(): Promise<Pick<FetchOptions, "proxy" | "noProxy">> {
-    const proxy = (await getNmpConfig("https-proxy")) ?? (await getNmpConfig("proxy"));
-    const noProxy = (await getNmpConfig("noproxy")) ?? (await getNmpConfig("no-proxy"));
+    const cfg = await getNmpConfig();
+
+    const proxy = cfg["https-proxy"] ?? cfg["proxy"];
+    const noProxy = cfg["noproxy"] ?? cfg["no-proxy"];
 
     return { proxy, noProxy };
 }
 
-/**
- * Download a file from `url` to `dir`. Will try to avoid downloading existing
- * files by using the cache directory ~/.keycloakify/cache
- *
- * If the target directory does not exist, it will be created.
- *
- * If the target file exists, it will be overwritten.
- *
- * We use make-fetch-happen's internal file cache here, so we don't need to
- * worry about redownloading the same file over and over. Unfortunately, that
- * cache does not have a single file per entry, but bundles and indexes them,
- * so we still need to write the contents to the target directory (possibly
- * over and over), cause the current unzip implementation wants random access.
- *
- * @param url download url
- * @param dir target directory
- * @param filename target filename
- * @returns promise for the full path of the downloaded file
- */
-async function download(url: string, dir: string, filename: string): Promise<string> {
-    const proxyOpts = await getNpmProxyConfig();
-    const cacheRoot = process.env.XDG_CACHE_HOME ?? homedir();
-    const cachePath = join(cacheRoot, ".keycloakify/cache");
-    const opts: FetchOptions = { cachePath, ...proxyOpts };
-    const response = await fetch(url, opts);
-    const filepath = pathJoin(dir, filename);
-    await mkdir(dir, { recursive: true });
-    await writeFile(filepath, response.body);
-    return filepath;
-}
+export async function downloadAndUnzip(params: { url: string; destDirPath: string; pathOfDirToExtractInArchive?: string }) {
+    const { url, destDirPath, pathOfDirToExtractInArchive } = params;
 
-/**
- * @typedef
- * @type MultiError = Error & { cause: Error[] }
- */
+    const downloadHash = hash(JSON.stringify({ url })).substring(0, 15);
+    const projectRoot = getProjectRoot();
+    const cacheRoot = process.env.XDG_CACHE_HOME ?? pathJoin(projectRoot, "node_modules", ".cache");
+    const zipFilePath = pathJoin(cacheRoot, "keycloakify", "zip", `_${downloadHash}.zip`);
+    const extractDirPath = pathJoin(cacheRoot, "keycloakify", "unzip", `_${downloadHash}`);
 
-/**
- * Extract the archive `zipFile` into the directory `dir`. If `archiveDir` is given,
- * only that directory will be extracted, stripping the given path components.
- *
- * If dir does not exist, it will be created.
- *
- * If any archive file exists, it will be overwritten.
- *
- * Will unzip using all available nodejs worker threads.
- *
- * Will try to clean up extracted files on failure.
- *
- * If unpacking fails, will either throw an regular error, or
- * possibly an `MultiError`, which contains a `cause` field with
- * a number of root cause errors.
- *
- * Warning this method is not optimized for continuous reading of the zip
- * archive, but is a trade-off between simplicity and allowing extraction
- * of a single directory from the archive.
- *
- * @param zipFile the file to unzip
- * @param dir the target directory
- * @param archiveDir if given, unpack only files from this archive directory
- * @throws {MultiError} error
- * @returns Promise for a list of full file paths pointing to actually extracted files
- */
-async function unzip(zipFile: string, dir: string, archiveDir?: string): Promise<string[]> {
-    await mkdir(dir, { recursive: true });
-    const promises: Promise<string>[] = [];
-
-    // Iterate over all files in the zip, skip files which are not in archiveDir,
-    // if given.
-    for await (const record of iterateZipArchive(zipFile)) {
-        const { path: recordPath, createReadStream: createRecordReadStream } = record;
-        const filePath = pathJoin(dir, recordPath);
-        const parent = pathDirname(filePath);
-        if (archiveDir && !recordPath.startsWith(archiveDir)) continue;
-        promises.push(
-            new Promise<string>(async (resolve, reject) => {
-                await mkdir(parent, { recursive: true });
-                // Pull the file out of the archive, write it to the target directory
-                const input = createRecordReadStream();
-                const output = createWriteStream(filePath);
-                output.setMaxListeners(Infinity);
-                output.on("error", e => reject(Object.assign(e, { filePath })));
-                output.on("finish", () => resolve(filePath));
-                input.pipe(output);
-            })
-        );
+    if (!(await exists(zipFilePath))) {
+        const proxyOpts = await getNpmProxyConfig();
+        const response = await fetch(url, proxyOpts);
+        await mkdir(pathDirname(zipFilePath), { "recursive": true });
+        /**
+         * The correct way to fix this is to upgrade node-fetch beyond 3.2.5
+         * (see https://github.com/node-fetch/node-fetch/issues/1295#issuecomment-1144061991.)
+         * Unfortunately, octokit (a dependency of keycloakify) also uses node-fetch, and
+         * does not support node-fetch 3.x. So we stick around with this band-aid until
+         * octokit upgrades.
+         */
+        response.body?.setMaxListeners(Number.MAX_VALUE);
+        assert(typeof response.body !== "undefined" && response.body != null);
+        await writeFile(zipFilePath, response.body);
     }
 
-    // Wait until _all_ files are either extracted or failed
-    const results = await Promise.allSettled(promises);
-    const success = results.filter(r => r.status === "fulfilled").map(r => (r as PromiseFulfilledResult<string>).value);
-    const failure = results.filter(r => r.status === "rejected").map(r => (r as PromiseRejectedResult).reason);
+    await unzip(zipFilePath, extractDirPath, pathOfDirToExtractInArchive);
 
-    // If any extraction failed, try to clean up, then throw a MultiError,
-    // which has a `cause` field, containing a list of root cause errors.
-    if (failure.length) {
-        await Promise.all(success.map(path => unlink(path)));
-        await Promise.all(failure.map(e => e && e.path && unlink(e.path as string)));
-        const e = new Error("Failed to extract: " + failure.map(e => e.message).join(";"));
-        (e as any).cause = failure;
-        throw e;
-    }
-
-    return success;
-}
-
-/**
- *
- * @param file file to read
- * @param start first byte to read
- * @param end last byte to read
- * @returns Promise of a buffer of read bytes
- */
-async function readFileChunk(file: string, start: number, end: number): Promise<Buffer> {
-    const chunks: Buffer[] = [];
-    return new Promise((resolve, reject) => {
-        const stream = createReadStream(file, { start, end });
-        stream.setMaxListeners(Infinity);
-        stream.on("error", e => reject(e));
-        stream.on("end", () => resolve(Buffer.concat(chunks)));
-        stream.on("data", chunk => chunks.push(chunk as Buffer));
+    transformCodebase({
+        "srcDirPath": extractDirPath,
+        "destDirPath": destDirPath
     });
 }
-
-type ZipRecord = {
-    path: string;
-    createReadStream: () => Readable;
-    compressionMethod: "deflate" | undefined;
-};
-
-type ZipRecordGenerator = AsyncGenerator<ZipRecord, void, unknown>;
-
-/**
- * Iterate over all records of a zipfile, and yield a ZipRecord.
- * Use `record.createReadStream()` to actually read the file.
- *
- * Warning this method will only work with single-disk zip files.
- * Warning this method may fail if the zip archive has an crazy amount
- * of files and the central directory is not fully contained within the
- * last 65k bytes of the zip file.
- *
- * @param zipFile
- * @returns AsyncGenerator which will yield ZipRecords
- */
-async function* iterateZipArchive(zipFile: string): ZipRecordGenerator {
-    // Need to know zip file size before we can do anything  else
-    const { size } = await stat(zipFile);
-    const chunkSize = 65_535 + 22 + 1; // max comment size + end header size + wiggle
-    // Read last ~65k bytes. Zip files have an comment up to 65_535 bytes at the very end,
-    // before that comes the zip central directory end header.
-    let chunk = await readFileChunk(zipFile, size - chunkSize, size);
-    const unread = size - chunk.length;
-    let i = chunk.length - 4;
-    let found = false;
-    // Find central directory end header, reading backwards from the end
-    while (!found && i-- > 0) if (chunk[i] === 0x50 && chunk.readUInt32LE(i) === 0x06054b50) found = true;
-    if (!found) throw new Error("Not a zip file");
-    // This method will fail on a multi-disk zip, so bail early.
-    if (chunk.readUInt16LE(i + 4) !== 0) throw new Error("Multi-disk zip not supported");
-    let nFiles = chunk.readUint16LE(i + 10);
-    // Get the position of the central directory
-    const directorySize = chunk.readUint32LE(i + 12);
-    const directoryOffset = chunk.readUint32LE(i + 16);
-    if (directoryOffset === 0xffff_ffff) throw new Error("zip64 not supported");
-    if (directoryOffset > size) throw new Error(`Central directory offset ${directoryOffset} is outside file`);
-    i = directoryOffset - unread;
-    // If i < 0, it means that the central directory is not contained within `chunk`
-    if (i < 0) {
-        chunk = await readFileChunk(zipFile, directoryOffset, directoryOffset + directorySize);
-        i = 0;
-    }
-    // Now iterate the central directory records, yield an `ZipRecord` for every entry
-    while (nFiles-- > 0) {
-        // Check for marker bytes
-        if (chunk.readUInt32LE(i) !== 0x02014b50) throw new Error("No central directory record at position " + (unread + i));
-        const compressionMethod = ({ 8: "deflate" } as const)[chunk.readUint16LE(i + 10)];
-        const compressedFileSize = chunk.readUint32LE(i + 20);
-        const filenameLength = chunk.readUint16LE(i + 28);
-        const extraLength = chunk.readUint16LE(i + 30);
-        const commentLength = chunk.readUint16LE(i + 32);
-        // Start of the actual content byte stream is after the 'local' record header,
-        // which is  30 bytes long plus filename and extra field
-        const start = chunk.readUint32LE(i + 42) + 30 + filenameLength + extraLength;
-        const end = start + compressedFileSize;
-        const filename = chunk.slice(i + 46, i + 46 + filenameLength).toString("utf-8");
-        const createRecordReadStream = () => {
-            const input = createReadStream(zipFile, { start, end });
-            if (compressionMethod === "deflate") {
-                const inflate = createInflateRaw();
-                input.pipe(inflate);
-                return inflate;
-            }
-            return input;
-        };
-        if (end > start) yield { path: filename, createReadStream: createRecordReadStream, compressionMethod };
-        // advance pointer to next central directory entry
-        i += 46 + filenameLength + extraLength + commentLength;
-    }
-}
-
-export async function downloadAndUnzip({
-    url,
-    destDirPath,
-    pathOfDirToExtractInArchive,
-    cacheDirPath
-}: {
-    isSilent: boolean;
-    url: string;
-    destDirPath: string;
-    pathOfDirToExtractInArchive?: string;
-    cacheDirPath: string;
-}) {
-    const downloadHash = hash(JSON.stringify({ url, pathOfDirToExtractInArchive })).substring(0, 15);
-    const extractDirPath = pathJoin(cacheDirPath, `_${downloadHash}`);
-
-    const filename = pathBasename(url);
-    const zipFilepath = await download(url, cacheDirPath, filename);
-    const zipMtime = (await stat(zipFilepath)).mtimeMs;
-    const unzipMtime = (await maybeStat(extractDirPath))?.mtimeMs;
-
-    if (!unzipMtime || zipMtime > unzipMtime) await unzip(zipFilepath, extractDirPath, pathOfDirToExtractInArchive);
-
-    const srcDirPath = pathOfDirToExtractInArchive === undefined ? extractDirPath : pathJoin(extractDirPath, pathOfDirToExtractInArchive);
-    transformCodebase({ srcDirPath, destDirPath });
-}

src/bin/tools/jar.ts

@@ -1,102 +1,87 @@
-import { Readable, Transform } from "stream";
 import { dirname, relative, sep } from "path";
 import { createWriteStream } from "fs";
 
 import walk from "./walk";
-import type { ZipSource } from "./zip";
-import zip from "./zip";
+import { ZipFile } from "yazl";
 import { mkdir } from "fs/promises";
+import trimIndent from "./trimIndent";
 
-/** Trim leading whitespace from every line */
-const trimIndent = (s: string) => s.replace(/(\n)\s+/g, "$1");
+export type ZipEntry = { zipPath: string } & ({ fsPath: string } | { buffer: Buffer });
+export type ZipEntryGenerator = AsyncGenerator<ZipEntry, void, unknown>;
 
-type JarArgs = {
-    rootPath: string;
-    targetPath: string;
+type CommonJarArgs = {
     groupId: string;
     artifactId: string;
     version: string;
 };
 
+export type JarStreamArgs = CommonJarArgs & {
+    asyncPathGeneratorFn(): ZipEntryGenerator;
+};
+
+export type JarArgs = CommonJarArgs & {
+    targetPath: string;
+    rootPath: string;
+};
+
+export async function jarStream({ groupId, artifactId, version, asyncPathGeneratorFn }: JarStreamArgs) {
+    const manifestPath = "META-INF/MANIFEST.MF";
+    const manifestData = Buffer.from(trimIndent`
+            Manifest-Version: 1.0
+            Archiver-Version: Plexus Archiver
+            Created-By: Keycloakify
+            Built-By: unknown
+            Build-Jdk: 19.0.0
+            `);
+
+    const pomPropsPath = `META-INF/maven/${groupId}/${artifactId}/pom.properties`;
+    const pomPropsData = Buffer.from(trimIndent`
+            # Generated by keycloakify
+            # ${new Date()}
+            artifactId=${artifactId}
+            groupId=${groupId}
+            version=${version}
+            `);
+
+    const zipFile = new ZipFile();
+
+    for await (const entry of asyncPathGeneratorFn()) {
+        if ("buffer" in entry) {
+            zipFile.addBuffer(entry.buffer, entry.zipPath);
+        } else if ("fsPath" in entry && !entry.fsPath.endsWith(sep)) {
+            zipFile.addFile(entry.fsPath, entry.zipPath);
+        }
+    }
+
+    zipFile.addBuffer(manifestData, manifestPath);
+    zipFile.addBuffer(pomPropsData, pomPropsPath);
+
+    zipFile.end();
+
+    return zipFile;
+}
+
 /**
  * Create a jar archive, using the resources found at `rootPath` (a directory) and write the
  * archive to `targetPath` (a file). Use `groupId`, `artifactId` and `version` to define
  * the contents of the pom.properties file which is going to be added to the archive.
  */
 export default async function jar({ groupId, artifactId, version, rootPath, targetPath }: JarArgs) {
-    const manifest: ZipSource = {
-        path: "META-INF/MANIFEST.MF",
-        data: Buffer.from(
-            trimIndent(
-                `Manifest-Version: 1.0
-                 Archiver-Version: Plexus Archiver
-                 Created-By: Keycloakify
-                 Built-By: unknown
-                 Build-Jdk: 19.0.0`
-            )
-        )
-    };
-
-    const pomProps: ZipSource = {
-        path: `META-INF/maven/${groupId}/${artifactId}/pom.properties`,
-        data: Buffer.from(
-            trimIndent(
-                `# Generated by keycloakify
-                 # ${new Date()}
-                 artifactId=${artifactId}
-                 groupId=${groupId}
-                 version=${version}`
-            )
-        )
-    };
-
-    /**
-     * Convert every path entry to a ZipSource record, and when all records are
-     * processed, append records for MANIFEST.mf and pom.properties
-     */
-    const pathToRecord = () =>
-        new Transform({
-            objectMode: true,
-            transform: function (fsPath, _, cb) {
-                const path = relative(rootPath, fsPath).split(sep).join("/");
-                this.push({ path, fsPath });
-                cb();
-            },
-            final: function () {
-                this.push(manifest);
-                this.push(pomProps);
-                this.push(null);
-            }
-        });
-
     await mkdir(dirname(targetPath), { recursive: true });
 
-    // Create an async pipeline, wait until everything is fully processed
-    await new Promise<void>((resolve, reject) => {
-        // walk all files in `rootPath` recursively
-        Readable.from(walk(rootPath))
-            // transform every path into a ZipSource object
-            .pipe(pathToRecord())
-            // let the zip lib convert all ZipSource objects into a byte stream
-            .pipe(zip())
-            // write that byte stream to targetPath
+    const asyncPathGeneratorFn = async function* (): ZipEntryGenerator {
+        for await (const fsPath of walk(rootPath)) {
+            const zipPath = relative(rootPath, fsPath).split(sep).join("/");
+            yield { fsPath, zipPath };
+        }
+    };
+
+    const zipFile = await jarStream({ groupId, artifactId, version, asyncPathGeneratorFn });
+
+    await new Promise<void>(async (resolve, reject) => {
+        zipFile.outputStream
             .pipe(createWriteStream(targetPath, { encoding: "binary" }))
-            .on("finish", () => resolve())
+            .on("close", () => resolve())
             .on("error", e => reject(e));
     });
 }
-
-/**
- * Standalone usage, call e.g. `ts-node jar.ts dirWithSources some-jar.jar`
- */
-if (require.main === module) {
-    const main = () =>
-        jar({
-            rootPath: process.argv[2],
-            targetPath: process.argv[3],
-            artifactId: process.env.ARTIFACT_ID ?? "artifact",
-            groupId: process.env.GROUP_ID ?? "group",
-            version: process.env.VERSION ?? "1.0.0"
-        });
-    main().catch(e => console.error(e));
-}

src/bin/tools/partitionPromiseSettledResults.ts

@@ -0,0 +1,11 @@
+export type PromiseSettledAndPartitioned<T> = [T[], any[]];
+
+export function partitionPromiseSettledResults<T>() {
+    return [
+        ([successes, failures]: PromiseSettledAndPartitioned<T>, item: PromiseSettledResult<T>) =>
+            item.status === "rejected"
+                ? ([successes, [item.reason, ...failures]] as PromiseSettledAndPartitioned<T>)
+                : ([[item.value, ...successes], failures] as PromiseSettledAndPartitioned<T>),
+        [[], []] as PromiseSettledAndPartitioned<T>
+    ] as const;
+}

src/bin/tools/tee.ts

@@ -7,6 +7,8 @@ export default function tee(input: Readable) {
     let aFull = false;
     let bFull = false;
 
+    a.setMaxListeners(Infinity);
+
     a.on("drain", () => {
         aFull = false;
         if (!aFull && !bFull) input.resume();

src/bin/tools/trimIndent.ts

@@ -0,0 +1,46 @@
+/**
+ * Concatenate the string fragments and interpolated values
+ * to get a single string.
+ */
+function populateTemplate(strings: TemplateStringsArray, ...args: unknown[]) {
+    const chunks: string[] = [];
+    for (let i = 0; i < strings.length; i++) {
+        let lastStringLineLength = 0;
+        if (strings[i]) {
+            chunks.push(strings[i]);
+            // remember last indent of the string portion
+            lastStringLineLength = strings[i].split("\n").at(-1)?.length ?? 0;
+        }
+        if (args[i]) {
+            // if the interpolation value has newlines, indent the interpolation values
+            // using the last known string indent
+            const chunk = String(args[i]).replace(/([\r?\n])/g, "$1" + " ".repeat(lastStringLineLength));
+            chunks.push(chunk);
+        }
+    }
+    return chunks.join("");
+}
+
+/**
+ * Shift all lines left by the *smallest* indentation level,
+ * and remove initial newline and all trailing spaces.
+ */
+export default function trimIndent(strings: TemplateStringsArray, ...args: any[]) {
+    // Remove initial and final newlines
+    let string = populateTemplate(strings, ...args)
+        .replace(/^[\r\n]/, "")
+        .replace(/\r?\n *$/, "");
+    const dents =
+        string
+            .match(/^([ \t])+/gm)
+            ?.filter(s => /^\s+$/.test(s))
+            ?.map(s => s.length) ?? [];
+    // No dents? no change required
+    if (!dents || dents.length == 0) return string;
+    const minDent = Math.min(...dents);
+    // The min indentation is 0, no change needed
+    if (!minDent) return string;
+    const re = new RegExp(`^${" ".repeat(minDent)}`, "gm");
+    const dedented = string.replace(re, "");
+    return dedented;
+}

src/bin/tools/unzip.ts

@@ -0,0 +1,92 @@
+import fsp from "node:fs/promises";
+import fs from "fs";
+import path from "node:path";
+import yauzl from "yauzl";
+import stream from "node:stream";
+import { promisify } from "node:util";
+
+const pipeline = promisify(stream.pipeline);
+
+async function pathExists(path: string) {
+    try {
+        await fsp.stat(path);
+        return true;
+    } catch (error) {
+        if ((error as { code: string }).code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+
+export async function unzip(file: string, targetFolder: string, unzipSubPath?: string) {
+    // add trailing slash to unzipSubPath and targetFolder
+    if (unzipSubPath && (!unzipSubPath.endsWith("/") || !unzipSubPath.endsWith("\\"))) {
+        unzipSubPath += "/";
+    }
+
+    if (!targetFolder.endsWith("/") || !targetFolder.endsWith("\\")) {
+        targetFolder += "/";
+    }
+    if (!fs.existsSync(targetFolder)) {
+        fs.mkdirSync(targetFolder, { recursive: true });
+    }
+
+    return new Promise<void>((resolve, reject) => {
+        yauzl.open(file, { lazyEntries: true }, async (err, zipfile) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+
+            zipfile.readEntry();
+
+            zipfile.on("entry", async entry => {
+                if (unzipSubPath) {
+                    // Skip files outside of the unzipSubPath
+                    if (!entry.fileName.startsWith(unzipSubPath)) {
+                        zipfile.readEntry();
+                        return;
+                    }
+
+                    // Remove the unzipSubPath from the file name
+                    entry.fileName = entry.fileName.substring(unzipSubPath.length);
+                }
+
+                const target = path.join(targetFolder, entry.fileName);
+
+                // Directory file names end with '/'.
+                // Note that entries for directories themselves are optional.
+                // An entry's fileName implicitly requires its parent directories to exist.
+                if (/[\/\\]$/.test(target)) {
+                    await fsp.mkdir(target, { recursive: true });
+
+                    zipfile.readEntry();
+                    return;
+                }
+
+                // Skip existing files
+                if (await pathExists(target)) {
+                    zipfile.readEntry();
+                    return;
+                }
+
+                zipfile.openReadStream(entry, async (err, readStream) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+
+                    await pipeline(readStream, fs.createWriteStream(target));
+
+                    zipfile.readEntry();
+                });
+            });
+
+            zipfile.once("end", function () {
+                zipfile.close();
+                resolve();
+            });
+        });
+    });
+}

src/bin/tools/walk.ts

@@ -1,19 +1,19 @@
 import { readdir } from "fs/promises";
-import { resolve } from "path";
+import { resolve, sep } from "path";
 
 /**
  * Asynchronously and recursively walk a directory tree, yielding every file and directory
- * found
+ * found. Directory paths will _always_ end with a path separator.
  *
  * @param root the starting directory
  * @returns AsyncGenerator
  */
-export default async function* walk(root: string): AsyncGenerator<string, void, void> {
+export default async function* walk(root: string): AsyncGenerator<string, void, unknown> {
     for (const entry of await readdir(root, { withFileTypes: true })) {
         const absolutePath = resolve(root, entry.name);
         if (entry.isDirectory()) {
-            yield absolutePath;
+            yield absolutePath.endsWith(sep) ? absolutePath : absolutePath + sep;
             yield* walk(absolutePath);
-        } else yield absolutePath;
+        } else yield absolutePath.endsWith(sep) ? absolutePath.substring(0, absolutePath.length - 1) : absolutePath;
     }
 }

src/bin/tools/zip.ts

@@ -1,246 +0,0 @@
-import { Transform, TransformOptions } from "stream";
-import { createReadStream } from "fs";
-import { stat } from "fs/promises";
-import { Blob } from "buffer";
-
-import { deflateBuffer, deflateStream } from "./deflate";
-
-/**
- * Zip source
- * @property filename the name of the entry in the archie
- * @property path of the source file, if the source is an actual file
- * @property data the actual data buffer, if the source is constructed in-memory
- */
-export type ZipSource = { path: string } & ({ fsPath: string } | { data: Buffer });
-
-export type ZipRecord = {
-    path: string;
-    compression: "deflate" | undefined;
-    uncompressedSize: number;
-    compressedSize?: number;
-    crc32?: number;
-    offset?: number;
-};
-
-/**
- * @returns the actual byte size of an string
- */
-function utf8size(s: string) {
-    return new Blob([s]).size;
-}
-
-/**
- * @param record
- * @returns a buffer representing a Zip local header
- * @link https://en.wikipedia.org/wiki/ZIP_(file_format)#Local_file_header
- */
-function localHeader(record: ZipRecord) {
-    const { path, compression, uncompressedSize } = record;
-    const filenameSize = utf8size(path);
-    const buf = Buffer.alloc(30 + filenameSize);
-
-    buf.writeUInt32LE(0x04_03_4b_50, 0); // local header signature
-    buf.writeUInt16LE(10, 4); // min version
-    // we write 0x08 because crc and compressed size are unknown at
-    buf.writeUInt16LE(0x08, 6); // general purpose bit flag
-    buf.writeUInt16LE(compression ? ({ "deflate": 8 } as const)[compression] : 0, 8);
-    buf.writeUInt16LE(0, 10); // modified time
-    buf.writeUInt16LE(0, 12); // modified date
-    buf.writeUInt32LE(0, 14); // crc unknown
-    buf.writeUInt32LE(0, 18); // compressed size unknown
-    buf.writeUInt32LE(uncompressedSize, 22);
-    buf.writeUInt16LE(filenameSize, 26);
-    buf.writeUInt16LE(0, 28); // extra field length
-    buf.write(path, 30, "utf-8");
-
-    return buf;
-}
-
-/**
- * @param record
- * @returns a buffer representing a Zip central header
- * @link https://en.wikipedia.org/wiki/ZIP_(file_format)#Central_directory_file_header
- */
-function centralHeader(record: ZipRecord) {
-    const { path, compression, crc32, compressedSize, uncompressedSize, offset } = record;
-    const filenameSize = utf8size(path);
-    const buf = Buffer.alloc(46 + filenameSize);
-    const isFile = !path.endsWith("/");
-
-    if (typeof offset === "undefined") throw new Error("Illegal argument");
-
-    // we don't want to deal with possibly messed up file or directory
-    // permissions, so we ignore the original permissions
-    const externalAttr = isFile ? 0x81a40000 : 0x41ed0000;
-
-    buf.writeUInt32LE(0x0201_4b50, 0); // central header signature
-    buf.writeUInt16LE(10, 4); // version
-    buf.writeUInt16LE(10, 6); // min version
-    buf.writeUInt16LE(0, 8); // general purpose bit flag
-    buf.writeUInt16LE(compression ? ({ "deflate": 8 } as const)[compression] : 0, 10);
-    buf.writeUInt16LE(0, 12); // modified time
-    buf.writeUInt16LE(0, 14); // modified date
-    buf.writeUInt32LE(crc32 || 0, 16);
-    buf.writeUInt32LE(compressedSize || 0, 20);
-    buf.writeUInt32LE(uncompressedSize, 24);
-    buf.writeUInt16LE(filenameSize, 28);
-    buf.writeUInt16LE(0, 30); // extra field length
-    buf.writeUInt16LE(0, 32); // comment field length
-    buf.writeUInt16LE(0, 34); // disk number
-    buf.writeUInt16LE(0, 36); // internal
-    buf.writeUInt32LE(externalAttr, 38); // external
-    buf.writeUInt32LE(offset, 42); // offset where file starts
-    buf.write(path, 46, "utf-8");
-
-    return buf;
-}
-
-/**
- * @returns a buffer representing an Zip End-Of-Central-Directory block
- * @link https://en.wikipedia.org/wiki/ZIP_(file_format)#End_of_central_directory_record_(EOCD)
- */
-function eocd({ offset, cdSize, nRecords }: { offset: number; cdSize: number; nRecords: number }) {
-    const buf = Buffer.alloc(22);
-    buf.writeUint32LE(0x06054b50, 0); // eocd signature
-    buf.writeUInt16LE(0, 4); // disc number
-    buf.writeUint16LE(0, 6); // disc where central directory starts
-    buf.writeUint16LE(nRecords, 8); // records on this disc
-    buf.writeUInt16LE(nRecords, 10); // records total
-    buf.writeUInt32LE(cdSize, 12); // byte size of cd
-    buf.writeUInt32LE(offset, 16); // cd offset
-    buf.writeUint16LE(0, 20); // comment length
-
-    return buf;
-}
-
-/**
- * @returns a stream Transform, which reads a stream of ZipRecords and
- * writes a bytestream
- */
-export default function zip() {
-    /**
-     * This is called when the input stream of ZipSource items is finished.
-     * Will write central directory and end-of-central-direcotry blocks.
-     */
-    const final = () => {
-        // write central directory
-        let cdSize = 0;
-        for (const record of records) {
-            const head = centralHeader(record);
-            zipTransform.push(head);
-            cdSize += head.length;
-        }
-
-        // write end-of-central-directory
-        zipTransform.push(eocd({ offset, cdSize, nRecords: records.length }));
-        // signal stream end
-        zipTransform.push(null);
-    };
-
-    /**
-     * Write a directory entry to the archive
-     * @param path
-     */
-    const writeDir = async (path: string) => {
-        const record: ZipRecord = {
-            path: path + "/",
-            offset,
-            compression: undefined,
-            uncompressedSize: 0
-        };
-        const head = localHeader(record);
-        zipTransform.push(head);
-        records.push(record);
-        offset += head.length;
-    };
-
-    /**
-     * Write a file entry to the archive
-     * @param archivePath path of the file in archive
-     * @param fsPath path to file on filesystem
-     * @param size of the actual, uncompressed, file
-     */
-    const writeFile = async (archivePath: string, fsPath: string, size: number) => {
-        const record: ZipRecord = {
-            path: archivePath,
-            offset,
-            compression: "deflate",
-            uncompressedSize: size
-        };
-        const head = localHeader(record);
-        zipTransform.push(head);
-
-        const { crc32, compressedSize } = await deflateStream(createReadStream(fsPath), chunk => zipTransform.push(chunk));
-
-        record.crc32 = crc32;
-        record.compressedSize = compressedSize;
-        records.push(record);
-        offset += head.length + compressedSize;
-    };
-
-    /**
-     * Write archive record based on filesystem file or directory
-     * @param archivePath path of item in archive
-     * @param fsPath path to item on filesystem
-     */
-    const writeFromPath = async (archivePath: string, fsPath: string) => {
-        const fileStats = await stat(fsPath);
-        fileStats.isDirectory() ? await writeDir(archivePath) /**/ : await writeFile(archivePath, fsPath, fileStats.size) /**/;
-    };
-
-    /**
-     * Write archive record based on data in a buffer
-     * @param path
-     * @param data
-     */
-    const writeFromBuffer = async (path: string, data: Buffer) => {
-        const { deflated, crc32 } = await deflateBuffer(data);
-        const record: ZipRecord = {
-            path,
-            compression: "deflate",
-            crc32,
-            uncompressedSize: data.length,
-            compressedSize: deflated.length,
-            offset
-        };
-        const head = localHeader(record);
-        zipTransform.push(head);
-        zipTransform.push(deflated);
-        records.push(record);
-        offset += head.length + deflated.length;
-    };
-
-    /**
-     * Write an archive record
-     * @param source
-     */
-    const writeRecord = async (source: ZipSource) => {
-        if ("fsPath" in source) await writeFromPath(source.path, source.fsPath);
-        else if ("data" in source) await writeFromBuffer(source.path, source.data);
-        else throw new Error("Illegal argument " + typeof source + "  " + JSON.stringify(source));
-    };
-
-    /**
-     * The actual stream transform function
-     * @param source
-     * @param _ encoding, ignored
-     * @param cb
-     */
-    const transform: TransformOptions["transform"] = async (source: ZipSource, _, cb) => {
-        await writeRecord(source);
-        cb();
-    };
-
-    /** offset and records keep local state during processing */
-    let offset = 0;
-    const records: ZipRecord[] = [];
-
-    const zipTransform = new Transform({
-        readableObjectMode: false,
-        writableObjectMode: true,
-        transform,
-        final
-    });
-
-    return zipTransform;
-}

src/login/Fallback.tsx

@@ -25,6 +25,8 @@ const LoginConfigTotp = lazy(() => import("keycloakify/login/pages/LoginConfigTo
 const LogoutConfirm = lazy(() => import("keycloakify/login/pages/LogoutConfirm"));
 const UpdateUserProfile = lazy(() => import("keycloakify/login/pages/UpdateUserProfile"));
 const IdpReviewUserProfile = lazy(() => import("keycloakify/login/pages/IdpReviewUserProfile"));
+const UpdateEmail = lazy(() => import("keycloakify/login/pages/UpdateEmail"));
+const SelectAuthenticator = lazy(() => import("keycloakify/login/pages/SelectAuthenticator"));
 
 export default function Fallback(props: PageProps<KcContext, I18n>) {
     const { kcContext, ...rest } = props;
@@ -75,6 +77,10 @@ export default function Fallback(props: PageProps<KcContext, I18n>) {
                         return <UpdateUserProfile kcContext={kcContext} {...rest} />;
                     case "idp-review-user-profile.ftl":
                         return <IdpReviewUserProfile kcContext={kcContext} {...rest} />;
+                    case "update-email.ftl":
+                        return <UpdateEmail kcContext={kcContext} {...rest} />;
+                    case "select-authenticator.ftl":
+                        return <SelectAuthenticator kcContext={kcContext} {...rest} />;
                 }
                 assert<Equals<typeof kcContext, never>>(false);
             })()}

src/login/kcContext/KcContext.ts

@@ -30,10 +30,13 @@ export type KcContext =
     | KcContext.LoginConfigTotp
     | KcContext.LogoutConfirm
     | KcContext.UpdateUserProfile
-    | KcContext.IdpReviewUserProfile;
+    | KcContext.IdpReviewUserProfile
+    | KcContext.UpdateEmail
+    | KcContext.SelectAuthenticator;
 
 export declare namespace KcContext {
     export type Common = {
+        keycloakifyVersion: string;
         url: {
             loginAction: string;
             resourcesPath: string;
@@ -183,6 +186,9 @@ export declare namespace KcContext {
         realm: {
             loginWithEmailAllowed: boolean;
         };
+        url: {
+            loginResetCredentialsUrl: string;
+        };
     };
 
     export type LoginVerifyEmail = Common & {
@@ -378,6 +384,46 @@ export declare namespace KcContext {
             attributesByName: Record<string, Attribute>;
         };
     };
+
+    export type UpdateEmail = Common & {
+        pageId: "update-email.ftl";
+        email: {
+            value?: string;
+        };
+    };
+
+    export type SelectAuthenticator = Common & {
+        pageId: "select-authenticator.ftl";
+        auth: {
+            authenticationSelections: SelectAuthenticator.AuthenticationSelection[];
+        };
+    };
+
+    export namespace SelectAuthenticator {
+        export type AuthenticationSelection = {
+            authExecId: string;
+            displayName:
+                | "otp-display-name"
+                | "password-display-name"
+                | "auth-username-form-display-name"
+                | "auth-username-password-form-display-name"
+                | "webauthn-display-name"
+                | "webauthn-passwordless-display-name";
+            helpText:
+                | "otp-help-text"
+                | "password-help-text"
+                | "auth-username-form-help-text"
+                | "auth-username-password-form-help-text"
+                | "webauthn-help-text"
+                | "webauthn-passwordless-help-text";
+            iconCssClass?:
+                | "kcAuthenticatorDefaultClass"
+                | "kcAuthenticatorPasswordClass"
+                | "kcAuthenticatorOTPClass"
+                | "kcAuthenticatorWebAuthnClass"
+                | "kcAuthenticatorWebAuthnPasswordlessClass";
+        };
+    }
 }
 
 export type Attribute = {

src/login/kcContext/getKcContext.ts

@@ -11,6 +11,7 @@ import { pathJoin } from "keycloakify/bin/tools/pathJoin";
 import { pathBasename } from "keycloakify/tools/pathBasename";
 import { mockTestingResourcesCommonPath } from "keycloakify/bin/mockTestingResourcesPath";
 import { symToStr } from "tsafe/symToStr";
+import { loginThemePageIds } from "keycloakify/bin/keycloakify/generateFtl/pageId";
 
 export function getKcContext<KcContextExtension extends { pageId: string } = never>(params?: {
     mockPageId?: ExtendKcContext<KcContextExtension>["pageId"];
@@ -121,7 +122,7 @@ export function getKcContext<KcContextExtension extends { pageId: string } = nev
         return { "kcContext": undefined };
     }
 
-    if (!("login" in realKcContext)) {
+    if (id<readonly string[]>(loginThemePageIds).indexOf(realKcContext.pageId) < 0 && !("login" in realKcContext)) {
         return { "kcContext": undefined };
     }
 

src/login/kcContext/kcContextMocks.ts

@@ -101,6 +101,7 @@ const attributes: Attribute[] = [
 const attributesByName = Object.fromEntries(attributes.map(attribute => [attribute.name, attribute])) as any;
 
 export const kcContextCommonMock: KcContext.Common = {
+    "keycloakifyVersion": "0.0.0",
     "url": {
         "loginAction": "#",
         "resourcesPath": pathJoin(PUBLIC_URL, mockTestingResourcesPath),
@@ -329,7 +330,8 @@ export const kcContextMocks: KcContext[] = [
         "realm": {
             ...kcContextCommonMock.realm,
             "loginWithEmailAllowed": false
-        }
+        },
+        url: loginUrl
     }),
     id<KcContext.LoginVerifyEmail>({
         ...kcContextCommonMock,
@@ -490,5 +492,32 @@ export const kcContextMocks: KcContext[] = [
             attributes,
             attributesByName
         }
+    }),
+    id<KcContext.UpdateEmail>({
+        ...kcContextCommonMock,
+        "pageId": "update-email.ftl",
+        "email": {
+            value: "email@example.com"
+        }
+    }),
+    id<KcContext.SelectAuthenticator>({
+        ...kcContextCommonMock,
+        pageId: "select-authenticator.ftl",
+        auth: {
+            authenticationSelections: [
+                {
+                    authExecId: "f607f83c-537e-42b7-99d7-c52d459afe84",
+                    displayName: "otp-display-name",
+                    helpText: "otp-help-text",
+                    iconCssClass: "kcAuthenticatorOTPClass"
+                },
+                {
+                    authExecId: "5ed881b1-84cd-4e9b-b4d9-f329ea61a58c",
+                    displayName: "webauthn-display-name",
+                    helpText: "webauthn-help-text",
+                    iconCssClass: "kcAuthenticatorWebAuthnClass"
+                }
+            ]
+        }
     })
 ];

src/login/lib/useDownloadTerms.ts

@@ -10,7 +10,7 @@ import { KcContext } from "../kcContext";
 export const evtTermMarkdown = Evt.create<string | undefined>(undefined);
 
 export type KcContextLike = {
-    pageId: KcContext["pageId"];
+    pageId: string;
     locale?: {
         currentLanguageTag: string;
     };

src/login/pages/SelectAuthenticator.tsx

@@ -0,0 +1,73 @@
+import type { PageProps } from "keycloakify/login/pages/PageProps";
+import { useGetClassName } from "keycloakify/login/lib/useGetClassName";
+import type { KcContext } from "keycloakify/login/kcContext";
+import type { I18n } from "keycloakify/login/i18n";
+import { MouseEvent, useRef } from "react";
+import { useConstCallback } from "keycloakify/tools/useConstCallback";
+
+export default function SelectAuthenticator(props: PageProps<Extract<KcContext, { pageId: "select-authenticator.ftl" }>, I18n>) {
+    const { kcContext, i18n, doUseDefaultCss, Template, classes } = props;
+    const { url, auth } = kcContext;
+
+    const { getClassName } = useGetClassName({ doUseDefaultCss, classes });
+    const { msg } = i18n;
+
+    const selectCredentialsForm = useRef<HTMLFormElement>(null);
+    const authExecIdInput = useRef<HTMLInputElement>(null);
+
+    const submitForm = useConstCallback(() => {
+        selectCredentialsForm.current?.submit();
+    });
+
+    const onSelectedAuthenticator = useConstCallback((event: MouseEvent<HTMLDivElement>) => {
+        const divElement = event.currentTarget;
+        const authExecId = divElement.dataset.authExecId;
+
+        if (!authExecIdInput.current || !authExecId) {
+            return;
+        }
+
+        authExecIdInput.current.value = authExecId;
+        submitForm();
+    });
+
+    return (
+        <Template {...{ kcContext, i18n, doUseDefaultCss, classes }} headerNode={msg("loginChooseAuthenticator")}>
+            <form
+                id="kc-select-credential-form"
+                className={getClassName("kcFormClass")}
+                ref={selectCredentialsForm}
+                action={url.loginAction}
+                method="post"
+            >
+                <div className={getClassName("kcSelectAuthListClass")}>
+                    {auth.authenticationSelections.map((authenticationSelection, index) => (
+                        <div key={index} className={getClassName("kcSelectAuthListItemClass")}>
+                            <div
+                                style={{ cursor: "pointer" }}
+                                onClick={onSelectedAuthenticator}
+                                data-auth-exec-id={authenticationSelection.authExecId}
+                                className={getClassName("kcSelectAuthListItemInfoClass")}
+                            >
+                                <div className={getClassName("kcSelectAuthListItemLeftClass")}>
+                                    <span className={getClassName(authenticationSelection.iconCssClass ?? "kcAuthenticatorDefaultClass")}></span>
+                                </div>
+                                <div className={getClassName("kcSelectAuthListItemBodyClass")}>
+                                    <div className={getClassName("kcSelectAuthListItemDescriptionClass")}>
+                                        <div className={getClassName("kcSelectAuthListItemHeadingClass")}>
+                                            {msg(authenticationSelection.displayName)}
+                                        </div>
+                                        <div className={getClassName("kcSelectAuthListItemHelpTextClass")}>
+                                            {msg(authenticationSelection.helpText)}
+                                        </div>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                    ))}
+                    <input type="hidden" id="authexec-hidden-input" name="authenticationExecution" ref={authExecIdInput} />
+                </div>
+            </form>
+        </Template>
+    );
+}

src/login/pages/Terms.tsx

@@ -21,13 +21,17 @@ export default function Terms(props: PageProps<Extract<KcContext, { pageId: "ter
 
     const { url } = kcContext;
 
-    if (evtTermMarkdown.state === undefined) {
+    const termMarkdown = evtTermMarkdown.state;
+
+    if (termMarkdown === undefined) {
         return null;
     }
 
     return (
         <Template {...{ kcContext, i18n, doUseDefaultCss, classes }} displayMessage={false} headerNode={msg("termsTitle")}>
-            <div id="kc-terms-text">{evtTermMarkdown.state && <Markdown>{evtTermMarkdown.state}</Markdown>}</div>
+            <div id="kc-terms-text">
+                <Markdown>{termMarkdown}</Markdown>
+            </div>
             <form className="form-actions" action={url.loginAction} method="POST">
                 <input
                     className={clsx(

src/login/pages/UpdateEmail.tsx

@@ -0,0 +1,88 @@
+import { clsx } from "keycloakify/tools/clsx";
+import type { PageProps } from "keycloakify/login/pages/PageProps";
+import { useGetClassName } from "keycloakify/login/lib/useGetClassName";
+import type { KcContext } from "../kcContext";
+import type { I18n } from "../i18n";
+
+export default function UpdateEmail(props: PageProps<Extract<KcContext, { pageId: "update-email.ftl" }>, I18n>) {
+    const { kcContext, i18n, doUseDefaultCss, Template, classes } = props;
+
+    const { getClassName } = useGetClassName({
+        doUseDefaultCss,
+        classes
+    });
+
+    const { msg, msgStr } = i18n;
+
+    const { url, messagesPerField, isAppInitiatedAction, email } = kcContext;
+
+    return (
+        <Template {...{ kcContext, i18n, doUseDefaultCss, classes }} headerNode={msg("updateEmailTitle")}>
+            <form id="kc-update-email-form" className={getClassName("kcFormClass")} action={url.loginAction} method="post">
+                <div
+                    className={clsx(getClassName("kcFormGroupClass"), messagesPerField.printIfExists("email", getClassName("kcFormGroupErrorClass")))}
+                >
+                    <div className={getClassName("kcLabelWrapperClass")}>
+                        <label htmlFor="email" className={getClassName("kcLabelClass")}>
+                            {msg("email")}
+                        </label>
+                    </div>
+                    <div className={getClassName("kcInputWrapperClass")}>
+                        <input
+                            type="text"
+                            id="email"
+                            name="email"
+                            defaultValue={email.value ?? ""}
+                            className={getClassName("kcInputClass")}
+                            aria-invalid={messagesPerField.existsError("email")}
+                        />
+                    </div>
+                </div>
+
+                <div className={getClassName("kcFormGroupClass")}>
+                    <div id="kc-form-options" className={getClassName("kcFormOptionsClass")}>
+                        <div className={getClassName("kcFormOptionsWrapperClass")}></div>
+                    </div>
+                    <div id="kc-form-buttons" className={getClassName("kcFormButtonsClass")}>
+                        {isAppInitiatedAction ? (
+                            <>
+                                <input
+                                    className={clsx(
+                                        getClassName("kcButtonClass"),
+                                        getClassName("kcButtonPrimaryClass"),
+                                        getClassName("kcButtonLargeClass")
+                                    )}
+                                    type="submit"
+                                    defaultValue={msgStr("doSubmit")}
+                                />
+                                <button
+                                    className={clsx(
+                                        getClassName("kcButtonClass"),
+                                        getClassName("kcButtonDefaultClass"),
+                                        getClassName("kcButtonLargeClass")
+                                    )}
+                                    type="submit"
+                                    name="cancel-aia"
+                                    value="true"
+                                >
+                                    {msg("doCancel")}
+                                </button>
+                            </>
+                        ) : (
+                            <input
+                                className={clsx(
+                                    getClassName("kcButtonClass"),
+                                    getClassName("kcButtonPrimaryClass"),
+                                    getClassName("kcButtonBlockClass"),
+                                    getClassName("kcButtonLargeClass")
+                                )}
+                                type="submit"
+                                defaultValue={msgStr("doSubmit")}
+                            />
+                        )}
+                    </div>
+                </div>
+            </form>
+        </Template>
+    );
+}

test/bin/generateKeycloakThemeResources.ts

@@ -1,20 +0,0 @@
-import { join as pathJoin } from "path";
-import { generateKeycloakThemeResources } from "keycloakify/bin/keycloakify/generateKeycloakThemeResources";
-import { setupSampleReactProject, sampleReactProjectDirPath } from "./setupSampleReactProject";
-
-setupSampleReactProject();
-
-generateKeycloakThemeResources({
-    "reactAppBuildDirPath": pathJoin(sampleReactProjectDirPath, "build"),
-    "keycloakThemeBuildingDirPath": pathJoin(sampleReactProjectDirPath, "build_keycloak_theme"),
-    "emailThemeSrcDirPath": undefined,
-    "keycloakVersion": "11.0.3",
-    "buildOptions": {
-        "themeName": "keycloakify-demo-app",
-        "extraLoginPages": ["my-custom-page.ftl"],
-        "extraThemeProperties": ["env=test"],
-        "isStandalone": true,
-        "urlPathname": "/keycloakify-demo-app/",
-        "isSilent": false
-    }
-});

test/bin/index.ts

@@ -1 +0,0 @@
-import "./replaceImportFromStatic";

test/bin/jar.spec.ts

@@ -0,0 +1,125 @@
+import jar, { jarStream, type ZipEntryGenerator } from "keycloakify/bin/tools/jar";
+import { fromBuffer, Entry, ZipFile } from "yauzl";
+import { it, describe, assert, afterAll } from "vitest";
+import { Readable } from "stream";
+import { tmpdir } from "os";
+import { mkdtemp, cp, mkdir, rm } from "fs/promises";
+import path from "path";
+import { createReadStream } from "fs";
+import walk from "keycloakify/bin/tools/walk";
+
+type AsyncIterable<T> = {
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+};
+
+async function arrayFromAsync<T>(asyncIterable: AsyncIterable<T>) {
+    const chunks: T[] = [];
+    for await (const chunk of asyncIterable) chunks.push(chunk);
+    return chunks;
+}
+
+async function readToBuffer(stream: NodeJS.ReadableStream) {
+    return Buffer.concat(await arrayFromAsync(stream as AsyncIterable<Buffer>));
+}
+
+function unzipBuffer(buffer: Buffer) {
+    return new Promise<ZipFile>((resolve, reject) =>
+        fromBuffer(buffer, { lazyEntries: true }, (err, zipFile) => {
+            if (err !== null) {
+                reject(err);
+            } else {
+                resolve(zipFile);
+            }
+        })
+    );
+}
+
+function readEntry(zipFile: ZipFile, entry: Entry): Promise<Readable> {
+    return new Promise<Readable>((resolve, reject) => {
+        zipFile.openReadStream(entry, (err, stream) => {
+            if (err !== null) {
+                reject(err);
+            } else {
+                resolve(stream);
+            }
+        });
+    });
+}
+
+function readAll(zipFile: ZipFile): Promise<Map<string, Buffer>> {
+    return new Promise<Map<string, Buffer>>((resolve, reject) => {
+        const entries1: Map<string, Buffer> = new Map();
+        zipFile.on("entry", async (entry: Entry) => {
+            const stream = await readEntry(zipFile, entry);
+            const buffer = await readToBuffer(stream);
+            entries1.set(entry.fileName, buffer);
+            zipFile.readEntry();
+        });
+        zipFile.on("end", () => resolve(entries1));
+        zipFile.on("error", e => reject(e));
+        zipFile.readEntry();
+    });
+}
+
+describe("jar", () => {
+    const coords = { artifactId: "someArtifactId", groupId: "someGroupId", version: "1.2.3" };
+
+    const tmpDirs: string[] = [];
+
+    afterAll(async () => {
+        await Promise.all(tmpDirs.map(dir => rm(dir, { force: true, recursive: true })));
+    });
+
+    it("creates jar artifacts without error", async () => {
+        async function* mockFiles(): ZipEntryGenerator {
+            yield { zipPath: "foo", buffer: Buffer.from("foo") };
+        }
+
+        const zipped = await jarStream({ ...coords, asyncPathGeneratorFn: mockFiles });
+        const buffered = await readToBuffer(zipped.outputStream);
+        const unzipped = await unzipBuffer(buffered);
+        const entries = await readAll(unzipped);
+
+        assert.equal(entries.size, 3);
+        assert.isOk(entries.has("foo"));
+        assert.isOk(entries.has("META-INF/MANIFEST.MF"));
+        assert.isOk(entries.has("META-INF/maven/someGroupId/someArtifactId/pom.properties"));
+
+        assert.equal("foo", entries.get("foo")?.toString("utf-8"));
+
+        const manifest = entries.get("META-INF/MANIFEST.MF")?.toString("utf-8");
+        const pomProperties = entries.get("META-INF/maven/someGroupId/someArtifactId/pom.properties")?.toString("utf-8");
+
+        assert.isOk(manifest?.includes("Created-By: Keycloakify"));
+        assert.isOk(pomProperties?.includes("1.2.3"));
+        assert.isOk(pomProperties?.includes("someGroupId"));
+        assert.isOk(pomProperties?.includes("someArtifactId"));
+    });
+
+    it("creates a jar from _real_ files without error", async () => {
+        const tmp = await mkdtemp(path.join(tmpdir(), "kc-jar-test-"));
+        tmpDirs.push(tmp);
+        const rootPath = path.join(tmp, "src");
+        const targetPath = path.join(tmp, "jar.jar");
+        await mkdir(rootPath);
+
+        await cp(path.dirname(__dirname), rootPath, { recursive: true });
+
+        await jar({ ...coords, rootPath, targetPath });
+
+        const buffered = await readToBuffer(createReadStream(targetPath));
+        const unzipped = await unzipBuffer(buffered);
+        const entries = await readAll(unzipped);
+        const zipPaths = Array.from(entries.keys());
+
+        assert.isOk(entries.has("META-INF/MANIFEST.MF"));
+        assert.isOk(entries.has("META-INF/maven/someGroupId/someArtifactId/pom.properties"));
+
+        for await (const fsPath of walk(rootPath)) {
+            if (!fsPath.endsWith(path.sep)) {
+                const rel = path.relative(rootPath, fsPath).replace(path.sep === "/" ? /\//g : /\\/g, "/");
+                assert.isOk(zipPaths.includes(rel), `missing ${rel} (${rel}, ${zipPaths.join(", ")})`);
+            }
+        }
+    });
+});

test/bin/main.ts

@@ -1,26 +0,0 @@
-import "./replaceImportFromStatic";
-import { setupSampleReactProject, sampleReactProjectDirPath } from "./setupSampleReactProject";
-import * as st from "scripting-tools";
-import * as fs from "fs";
-import { join as pathJoin } from "path";
-import { getProjectRoot } from "keycloakify/bin/tools/getProjectRoot.js";
-
-(async () => {
-    fs.rmSync(sampleReactProjectDirPath, { "recursive": true });
-
-    await setupSampleReactProject();
-
-    const binDirPath = pathJoin(getProjectRoot(), "dist_test", "src", "bin");
-
-    fs.mkdirSync(pathJoin(sampleReactProjectDirPath, "src", "keycloak-theme"), { "recursive": true });
-
-    st.execSyncTrace(`node ${pathJoin(binDirPath, "initialize-email-theme")}`, { "cwd": sampleReactProjectDirPath });
-
-    st.execSyncTrace(`node ${pathJoin(binDirPath, "download-builtin-keycloak-theme")}`, { "cwd": sampleReactProjectDirPath });
-
-    st.execSyncTrace(
-        //`node ${pathJoin(binDirPath, "keycloakify")} --external-assets`,
-        `node ${pathJoin(binDirPath, "keycloakify")}`,
-        { "cwd": sampleReactProjectDirPath }
-    );
-})();

test/bin/replaceImportFromStatic.spec.ts

@@ -1,11 +1,12 @@
 import { replaceImportsFromStaticInJsCode } from "keycloakify/bin/keycloakify/replacers/replaceImportsFromStaticInJsCode";
 import { generateCssCodeToDefineGlobals, replaceImportsInCssCode } from "keycloakify/bin/keycloakify/replacers/replaceImportsInCssCode";
 import { replaceImportsInInlineCssCode } from "keycloakify/bin/keycloakify/replacers/replaceImportsInInlineCssCode";
-import { assert } from "tsafe/assert";
 import { same } from "evt/tools/inDepth/same";
-import { assetIsSameCode } from "../tools/assertIsSameCode";
+import { expect, it, describe } from "vitest";
 
-{
+import { isSameCode } from "../tools/isSameCode";
+
+describe("bin/js-transforms", () => {
     const jsCodeUntransformed = `
         function f() {
             return a.p+"static/js/" + ({}[e] || e) + "." + {
@@ -32,8 +33,7 @@ import { assetIsSameCode } from "../tools/assertIsSameCode";
             }[e]+".chunk.css"
         }
     `;
-
-    {
+    it("transforms standalone code properly", () => {
         const { fixedJsCode } = replaceImportsFromStaticInJsCode({
             "jsCode": jsCodeUntransformed,
             "buildOptions": {
@@ -89,10 +89,9 @@ import { assetIsSameCode } from "../tools/assertIsSameCode";
 
         `;
 
-        assetIsSameCode(fixedJsCode, fixedJsCodeExpected);
-    }
-
-    {
+        expect(isSameCode(fixedJsCode, fixedJsCodeExpected)).toBe(true);
+    });
+    it("transforms external app code properly", () => {
         const { fixedJsCode } = replaceImportsFromStaticInJsCode({
             "jsCode": jsCodeUntransformed,
             "buildOptions": {
@@ -150,126 +149,128 @@ import { assetIsSameCode } from "../tools/assertIsSameCode";
             }
         `;
 
-        assetIsSameCode(fixedJsCode, fixedJsCodeExpected);
-    }
-}
+        expect(isSameCode(fixedJsCode, fixedJsCodeExpected)).toBe(true);
+    });
+});
 
-{
-    const { fixedCssCode, cssGlobalsToDefine } = replaceImportsInCssCode({
-        "cssCode": `
+describe("bin/css-transforms", () => {
+    it("transforms absolute urls to css globals properly with no urlPathname", () => {
+        const { fixedCssCode, cssGlobalsToDefine } = replaceImportsInCssCode({
+            "cssCode": `
+                .my-div {
+                    background: url(/logo192.png) no-repeat center center;
+                }
+    
+                .my-div2 {
+                    background: url(/logo192.png) no-repeat center center;
+                }
+    
+                .my-div {
+                    background-image: url(/static/media/something.svg);
+                }
+            `
+        });
+
+        const fixedCssCodeExpected = `
             .my-div {
-                background: url(/logo192.png) no-repeat center center;
+                background: var(--url1f9ef5a892c104c);
             }
-
+    
             .my-div2 {
-                background: url(/logo192.png) no-repeat center center;
+                background: var(--url1f9ef5a892c104c);
             }
-
+    
             .my-div {
-                background-image: url(/static/media/something.svg);
+                background-image: var(--urldd75cab58377c19);
             }
-        `
+        `;
+
+        expect(isSameCode(fixedCssCode, fixedCssCodeExpected)).toBe(true);
+
+        const cssGlobalsToDefineExpected = {
+            "url1f9ef5a892c104c": "url(/logo192.png) no-repeat center center",
+            "urldd75cab58377c19": "url(/static/media/something.svg)"
+        };
+
+        expect(same(cssGlobalsToDefine, cssGlobalsToDefineExpected)).toBe(true);
+
+        const { cssCodeToPrependInHead } = generateCssCodeToDefineGlobals({
+            cssGlobalsToDefine,
+            "buildOptions": {
+                "urlPathname": undefined
+            }
+        });
+
+        const cssCodeToPrependInHeadExpected = `
+            :root {
+                --url1f9ef5a892c104c: url(\${url.resourcesPath}/build/logo192.png) no-repeat center center;
+                --urldd75cab58377c19: url(\${url.resourcesPath}/build/static/media/something.svg);
+            }
+        `;
+
+        expect(isSameCode(cssCodeToPrependInHead, cssCodeToPrependInHeadExpected)).toBe(true);
     });
+    it("transforms absolute urls to css globals properly with custom urlPathname", () => {
+        const { fixedCssCode, cssGlobalsToDefine } = replaceImportsInCssCode({
+            "cssCode": `
+                .my-div {
+                    background: url(/x/y/z/logo192.png) no-repeat center center;
+                }
+    
+                .my-div2 {
+                    background: url(/x/y/z/logo192.png) no-repeat center center;
+                }
+    
+                .my-div {
+                    background-image: url(/x/y/z/static/media/something.svg);
+                }
+            `
+        });
 
-    const fixedCssCodeExpected = `
-        .my-div {
-            background: var(--url1f9ef5a892c104c);
-        }
-
-        .my-div2 {
-            background: var(--url1f9ef5a892c104c);
-        }
-
-        .my-div {
-            background-image: var(--urldd75cab58377c19);
-        }
-    `;
-
-    assetIsSameCode(fixedCssCode, fixedCssCodeExpected);
-
-    const cssGlobalsToDefineExpected = {
-        "url1f9ef5a892c104c": "url(/logo192.png) no-repeat center center",
-        "urldd75cab58377c19": "url(/static/media/something.svg)"
-    };
-
-    assert(same(cssGlobalsToDefine, cssGlobalsToDefineExpected));
-
-    const { cssCodeToPrependInHead } = generateCssCodeToDefineGlobals({
-        cssGlobalsToDefine,
-        "buildOptions": {
-            "urlPathname": undefined
-        }
-    });
-
-    const cssCodeToPrependInHeadExpected = `
-        :root {
-            --url1f9ef5a892c104c: url(\${url.resourcesPath}/build/logo192.png) no-repeat center center;
-            --urldd75cab58377c19: url(\${url.resourcesPath}/build/static/media/something.svg);
-        }
-    `;
-
-    assetIsSameCode(cssCodeToPrependInHead, cssCodeToPrependInHeadExpected);
-}
-
-{
-    const { fixedCssCode, cssGlobalsToDefine } = replaceImportsInCssCode({
-        "cssCode": `
+        const fixedCssCodeExpected = `
             .my-div {
-                background: url(/x/y/z/logo192.png) no-repeat center center;
+                background: var(--urlf8277cddaa2be78);
             }
-
+    
             .my-div2 {
-                background: url(/x/y/z/logo192.png) no-repeat center center;
+                background: var(--urlf8277cddaa2be78);
             }
-
+    
             .my-div {
-                background-image: url(/x/y/z/static/media/something.svg);
+                background-image: var(--url8bdc0887b97ac9a);
             }
-        `
+        `;
+
+        expect(isSameCode(fixedCssCode, fixedCssCodeExpected)).toBe(true);
+
+        const cssGlobalsToDefineExpected = {
+            "urlf8277cddaa2be78": "url(/x/y/z/logo192.png) no-repeat center center",
+            "url8bdc0887b97ac9a": "url(/x/y/z/static/media/something.svg)"
+        };
+
+        expect(same(cssGlobalsToDefine, cssGlobalsToDefineExpected)).toBe(true);
+
+        const { cssCodeToPrependInHead } = generateCssCodeToDefineGlobals({
+            cssGlobalsToDefine,
+            "buildOptions": {
+                "urlPathname": "/x/y/z/"
+            }
+        });
+
+        const cssCodeToPrependInHeadExpected = `
+            :root {
+                --urlf8277cddaa2be78: url(\${url.resourcesPath}/build/logo192.png) no-repeat center center;
+                --url8bdc0887b97ac9a: url(\${url.resourcesPath}/build/static/media/something.svg);
+            }
+        `;
+
+        expect(isSameCode(cssCodeToPrependInHead, cssCodeToPrependInHeadExpected)).toBe(true);
     });
+});
 
-    const fixedCssCodeExpected = `
-        .my-div {
-            background: var(--urlf8277cddaa2be78);
-        }
-
-        .my-div2 {
-            background: var(--urlf8277cddaa2be78);
-        }
-
-        .my-div {
-            background-image: var(--url8bdc0887b97ac9a);
-        }
-    `;
-
-    assetIsSameCode(fixedCssCode, fixedCssCodeExpected);
-
-    const cssGlobalsToDefineExpected = {
-        "urlf8277cddaa2be78": "url(/x/y/z/logo192.png) no-repeat center center",
-        "url8bdc0887b97ac9a": "url(/x/y/z/static/media/something.svg)"
-    };
-
-    assert(same(cssGlobalsToDefine, cssGlobalsToDefineExpected));
-
-    const { cssCodeToPrependInHead } = generateCssCodeToDefineGlobals({
-        cssGlobalsToDefine,
-        "buildOptions": {
-            "urlPathname": "/x/y/z/"
-        }
-    });
-
-    const cssCodeToPrependInHeadExpected = `
-        :root {
-            --urlf8277cddaa2be78: url(\${url.resourcesPath}/build/logo192.png) no-repeat center center;
-            --url8bdc0887b97ac9a: url(\${url.resourcesPath}/build/static/media/something.svg);
-        }
-    `;
-
-    assetIsSameCode(cssCodeToPrependInHead, cssCodeToPrependInHeadExpected);
-}
-
-{
-    const cssCode = `
+describe("bin/css-inline-transforms", () => {
+    describe("no url pathName", () => {
+        const cssCode = `
         @font-face {
           font-family: "Work Sans";
           font-style: normal;
@@ -299,17 +300,16 @@ import { assetIsSameCode } from "../tools/assertIsSameCode";
           src: url("/fonts/WorkSans/worksans-bold-webfont.woff2") format("woff2");
         }
     `;
+        it("transforms css for standalone app properly", () => {
+            const { fixedCssCode } = replaceImportsInInlineCssCode({
+                cssCode,
+                "buildOptions": {
+                    "isStandalone": true,
+                    "urlPathname": undefined
+                }
+            });
 
-    {
-        const { fixedCssCode } = replaceImportsInInlineCssCode({
-            cssCode,
-            "buildOptions": {
-                "isStandalone": true,
-                "urlPathname": undefined
-            }
-        });
-
-        const fixedCssCodeExpected = `
+            const fixedCssCodeExpected = `
             @font-face {
               font-family: "Work Sans";
               font-style: normal;
@@ -344,20 +344,19 @@ import { assetIsSameCode } from "../tools/assertIsSameCode";
             }
         `;
 
-        assetIsSameCode(fixedCssCode, fixedCssCodeExpected);
-    }
-
-    {
-        const { fixedCssCode } = replaceImportsInInlineCssCode({
-            cssCode,
-            "buildOptions": {
-                "isStandalone": false,
-                "urlOrigin": "https://demo-app.keycloakify.dev",
-                "urlPathname": undefined
-            }
+            expect(isSameCode(fixedCssCode, fixedCssCodeExpected)).toBe(true);
         });
+        it("transforms css for external app properly", () => {
+            const { fixedCssCode } = replaceImportsInInlineCssCode({
+                cssCode,
+                "buildOptions": {
+                    "isStandalone": false,
+                    "urlOrigin": "https://demo-app.keycloakify.dev",
+                    "urlPathname": undefined
+                }
+            });
 
-        const fixedCssCodeExpected = `
+            const fixedCssCodeExpected = `
             @font-face {
               font-family: "Work Sans";
               font-style: normal;
@@ -392,12 +391,12 @@ import { assetIsSameCode } from "../tools/assertIsSameCode";
             }
         `;
 
-        assetIsSameCode(fixedCssCode, fixedCssCodeExpected);
-    }
-}
+            expect(isSameCode(fixedCssCode, fixedCssCodeExpected)).toBe(true);
+        });
+    });
 
-{
-    const cssCode = `
+    describe("with url pathName", () => {
+        const cssCode = `
         @font-face {
           font-family: "Work Sans";
           font-style: normal;
@@ -427,101 +426,98 @@ import { assetIsSameCode } from "../tools/assertIsSameCode";
           src: url("/x/y/z/fonts/WorkSans/worksans-bold-webfont.woff2") format("woff2");
         }
     `;
+        it("transforms css for standalone app properly", () => {
+            const { fixedCssCode } = replaceImportsInInlineCssCode({
+                cssCode,
+                "buildOptions": {
+                    "isStandalone": true,
+                    "urlPathname": "/x/y/z/"
+                }
+            });
 
-    {
-        const { fixedCssCode } = replaceImportsInInlineCssCode({
-            cssCode,
-            "buildOptions": {
-                "isStandalone": true,
-                "urlPathname": "/x/y/z/"
-            }
+            const fixedCssCodeExpected = `
+                @font-face {
+                  font-family: "Work Sans";
+                  font-style: normal;
+                  font-weight: 400;
+                  font-display: swap;
+                  src: url(\${url.resourcesPath}/build/fonts/WorkSans/worksans-regular-webfont.woff2)
+                    format("woff2");
+                }
+                @font-face {
+                  font-family: "Work Sans";
+                  font-style: normal;
+                  font-weight: 500;
+                  font-display: swap;
+                  src: url(\${url.resourcesPath}/build/fonts/WorkSans/worksans-medium-webfont.woff2)
+                    format("woff2");
+                }
+                @font-face {
+                  font-family: "Work Sans";
+                  font-style: normal;
+                  font-weight: 600;
+                  font-display: swap;
+                  src: url(\${url.resourcesPath}/build/fonts/WorkSans/worksans-semibold-webfont.woff2)
+                    format("woff2");
+                }
+                @font-face {
+                  font-family: "Work Sans";
+                  font-style: normal;
+                  font-weight: 700;
+                  font-display: swap;
+                  src: url(\${url.resourcesPath}/build/fonts/WorkSans/worksans-bold-webfont.woff2)
+                    format("woff2");
+                }
+            `;
+
+            expect(isSameCode(fixedCssCode, fixedCssCodeExpected)).toBe(true);
         });
+        it("transforms css for external app properly", () => {
+            const { fixedCssCode } = replaceImportsInInlineCssCode({
+                cssCode,
+                "buildOptions": {
+                    "isStandalone": false,
+                    "urlOrigin": "https://demo-app.keycloakify.dev",
+                    "urlPathname": "/x/y/z/"
+                }
+            });
 
-        const fixedCssCodeExpected = `
-            @font-face {
-              font-family: "Work Sans";
-              font-style: normal;
-              font-weight: 400;
-              font-display: swap;
-              src: url(\${url.resourcesPath}/build/fonts/WorkSans/worksans-regular-webfont.woff2)
-                format("woff2");
-            }
-            @font-face {
-              font-family: "Work Sans";
-              font-style: normal;
-              font-weight: 500;
-              font-display: swap;
-              src: url(\${url.resourcesPath}/build/fonts/WorkSans/worksans-medium-webfont.woff2)
-                format("woff2");
-            }
-            @font-face {
-              font-family: "Work Sans";
-              font-style: normal;
-              font-weight: 600;
-              font-display: swap;
-              src: url(\${url.resourcesPath}/build/fonts/WorkSans/worksans-semibold-webfont.woff2)
-                format("woff2");
-            }
-            @font-face {
-              font-family: "Work Sans";
-              font-style: normal;
-              font-weight: 700;
-              font-display: swap;
-              src: url(\${url.resourcesPath}/build/fonts/WorkSans/worksans-bold-webfont.woff2)
-                format("woff2");
-            }
-        `;
+            const fixedCssCodeExpected = `
+                @font-face {
+                  font-family: "Work Sans";
+                  font-style: normal;
+                  font-weight: 400;
+                  font-display: swap;
+                  src: url(https://demo-app.keycloakify.dev/x/y/z/fonts/WorkSans/worksans-regular-webfont.woff2)
+                    format("woff2");
+                }
+                @font-face {
+                  font-family: "Work Sans";
+                  font-style: normal;
+                  font-weight: 500;
+                  font-display: swap;
+                  src: url(https://demo-app.keycloakify.dev/x/y/z/fonts/WorkSans/worksans-medium-webfont.woff2)
+                    format("woff2");
+                }
+                @font-face {
+                  font-family: "Work Sans";
+                  font-style: normal;
+                  font-weight: 600;
+                  font-display: swap;
+                  src: url(https://demo-app.keycloakify.dev/x/y/z/fonts/WorkSans/worksans-semibold-webfont.woff2)
+                    format("woff2");
+                }
+                @font-face {
+                  font-family: "Work Sans";
+                  font-style: normal;
+                  font-weight: 700;
+                  font-display: swap;
+                  src: url(https://demo-app.keycloakify.dev/x/y/z/fonts/WorkSans/worksans-bold-webfont.woff2)
+                    format("woff2");
+                }
+            `;
 
-        assetIsSameCode(fixedCssCode, fixedCssCodeExpected);
-    }
-
-    {
-        const { fixedCssCode } = replaceImportsInInlineCssCode({
-            cssCode,
-            "buildOptions": {
-                "isStandalone": false,
-                "urlOrigin": "https://demo-app.keycloakify.dev",
-                "urlPathname": "/x/y/z/"
-            }
+            expect(isSameCode(fixedCssCode, fixedCssCodeExpected)).toBe(true);
         });
-
-        const fixedCssCodeExpected = `
-            @font-face {
-              font-family: "Work Sans";
-              font-style: normal;
-              font-weight: 400;
-              font-display: swap;
-              src: url(https://demo-app.keycloakify.dev/x/y/z/fonts/WorkSans/worksans-regular-webfont.woff2)
-                format("woff2");
-            }
-            @font-face {
-              font-family: "Work Sans";
-              font-style: normal;
-              font-weight: 500;
-              font-display: swap;
-              src: url(https://demo-app.keycloakify.dev/x/y/z/fonts/WorkSans/worksans-medium-webfont.woff2)
-                format("woff2");
-            }
-            @font-face {
-              font-family: "Work Sans";
-              font-style: normal;
-              font-weight: 600;
-              font-display: swap;
-              src: url(https://demo-app.keycloakify.dev/x/y/z/fonts/WorkSans/worksans-semibold-webfont.woff2)
-                format("woff2");
-            }
-            @font-face {
-              font-family: "Work Sans";
-              font-style: normal;
-              font-weight: 700;
-              font-display: swap;
-              src: url(https://demo-app.keycloakify.dev/x/y/z/fonts/WorkSans/worksans-bold-webfont.woff2)
-                format("woff2");
-            }
-        `;
-
-        assetIsSameCode(fixedCssCode, fixedCssCodeExpected);
-    }
-}
-
-console.log("PASS replace import from static");
+    });
+});

test/bin/setupSampleReactProject.spec.ts

@@ -0,0 +1,96 @@
+import * as fs from "fs";
+import { getProjectRoot } from "keycloakify/bin/tools/getProjectRoot.js";
+import { join as pathJoin } from "path";
+import { downloadAndUnzip } from "keycloakify/bin/tools/downloadAndUnzip";
+import { main as initializeEmailTheme } from "keycloakify/bin/initialize-email-theme";
+import { it, describe, afterAll, beforeAll, beforeEach, vi } from "vitest";
+import { downloadBuiltinKeycloakTheme } from "keycloakify/bin/download-builtin-keycloak-theme";
+import { readBuildOptions } from "keycloakify/bin/keycloakify/BuildOptions";
+
+export const sampleReactProjectDirPath = pathJoin(getProjectRoot(), "sample_react_project");
+
+async function setupSampleReactProject(destDir: string) {
+    await downloadAndUnzip({
+        "url": "https://github.com/keycloakify/keycloakify/releases/download/v0.0.1/sample_build_dir_and_package_json.zip",
+        "destDirPath": destDir
+    });
+}
+let parsedPackageJson: Record<string, unknown> = {};
+vi.mock("keycloakify/bin/keycloakify/parsed-package-json", async () => ({
+    ...((await vi.importActual("keycloakify/bin/keycloakify/parsed-package-json")) as Record<string, unknown>),
+    getParsedPackageJson: () => parsedPackageJson
+}));
+
+vi.mock("keycloakify/bin/promptKeycloakVersion", async () => ({
+    ...((await vi.importActual("keycloakify/bin/promptKeycloakVersion")) as Record<string, unknown>),
+    promptKeycloakVersion: () => ({ keycloakVersion: "11.0.3" })
+}));
+
+const nativeCwd = process.cwd;
+
+describe("Sample Project", () => {
+    beforeAll(() => {
+        // Monkey patching the cwd to the app location for the duration of this test
+        process.cwd = () => sampleReactProjectDirPath;
+    });
+    afterAll(() => {
+        fs.rmSync(sampleReactProjectDirPath, { "recursive": true });
+        process.cwd = nativeCwd;
+    });
+    beforeEach(() => {
+        if (fs.existsSync(sampleReactProjectDirPath)) {
+            fs.rmSync(sampleReactProjectDirPath, { "recursive": true });
+        }
+
+        fs.mkdirSync(pathJoin(sampleReactProjectDirPath, "src", "keycloak-theme"), { "recursive": true });
+        fs.mkdirSync(pathJoin(sampleReactProjectDirPath, "src", "login"), { "recursive": true });
+    });
+    it(
+        "Sets up the project without error",
+        async () => {
+            await setupSampleReactProject(sampleReactProjectDirPath);
+            await initializeEmailTheme();
+
+            const destDirPath = pathJoin(
+                readBuildOptions({
+                    "isExternalAssetsCliParamProvided": false,
+                    "isSilent": true,
+                    "projectDirPath": process.cwd()
+                }).keycloakifyBuildDirPath,
+                "src",
+                "main",
+                "resources",
+                "theme"
+            );
+            await downloadBuiltinKeycloakTheme({ destDirPath, keycloakVersion: "11.0.3", isSilent: false });
+        },
+        { timeout: 90000 }
+    );
+    it(
+        "Sets up the project with a custom input and output directory without error",
+        async () => {
+            parsedPackageJson = {
+                "keycloakify": {
+                    "reactAppBuildDirPath": "./custom_input/build",
+                    "keycloakBuildDir": "./custom_output"
+                }
+            };
+            await setupSampleReactProject(pathJoin(sampleReactProjectDirPath, "custom_input"));
+            await initializeEmailTheme();
+
+            const destDirPath = pathJoin(
+                readBuildOptions({
+                    "isExternalAssetsCliParamProvided": false,
+                    "isSilent": true,
+                    "projectDirPath": process.cwd()
+                }).keycloakifyBuildDirPath,
+                "src",
+                "main",
+                "resources",
+                "theme"
+            );
+            await downloadBuiltinKeycloakTheme({ destDirPath, keycloakVersion: "11.0.3", isSilent: false });
+        },
+        { timeout: 90000 }
+    );
+});

test/bin/setupSampleReactProject.ts

@@ -1,14 +1,8 @@
-import { getProjectRoot } from "keycloakify/bin/tools/getProjectRoot.js";
-import { join as pathJoin } from "path";
 import { downloadAndUnzip } from "keycloakify/bin/tools/downloadAndUnzip";
 
-export const sampleReactProjectDirPath = pathJoin(getProjectRoot(), "sample_react_project");
-
-export async function setupSampleReactProject() {
+export async function setupSampleReactProject(destDirPath: string) {
     await downloadAndUnzip({
         "url": "https://github.com/keycloakify/keycloakify/releases/download/v0.0.1/sample_build_dir_and_package_json.zip",
-        "destDirPath": sampleReactProjectDirPath,
-        "cacheDirPath": pathJoin(sampleReactProjectDirPath, "build_keycloak", ".cache"),
-        "isSilent": false
+        "destDirPath": destDirPath
     });
 }

test/bin/tools/trimIndet.spec.ts

@@ -0,0 +1,65 @@
+import trimIndent from "keycloakify/bin/tools/trimIndent";
+import { it, describe, assert } from "vitest";
+
+describe("trimIndent", () => {
+    it("does not change a left-aligned string as expected", () => {
+        const txt = trimIndent`lorem
+ipsum`;
+        assert.equal(txt, ["lorem", "ipsum"].join("\n"));
+    });
+
+    it("removes leading and trailing empty lines from a left-aligned string", () => {
+        const txt = trimIndent`
+lorem
+ipsum
+`;
+        assert.equal(txt, ["lorem", "ipsum"].join("\n"));
+    });
+
+    it("removes indent from an aligned string", () => {
+        const txt = trimIndent`
+            lorem
+            ipsum
+        `;
+        assert.equal(txt, ["lorem", "ipsum"].join("\n"));
+    });
+
+    it("removes indent from unaligned string", () => {
+        const txt = trimIndent`
+            lorem
+                ipsum
+        `;
+        assert.equal(txt, ["lorem", "    ipsum"].join("\n"));
+    });
+
+    it("removes only first and last empty line", () => {
+        const txt = trimIndent`
+
+            lorem
+            ipsum
+
+            `;
+
+        assert.equal(txt, ["", "lorem", "ipsum", ""].join("\n"));
+    });
+
+    it("interpolates non-strings", () => {
+        const d = new Date();
+        const txt = trimIndent`
+            lorem
+            ${d}
+            ipsum`;
+
+        assert.equal(txt, ["lorem", String(d), "ipsum"].join("\n"));
+    });
+
+    it("inderpolates preserving new-lines in the interpolated bits", () => {
+        const a = ["ipsum", "dolor", "sit"].join("\n");
+        const txt = trimIndent`
+            lorem
+            ${a}
+            amet
+            `;
+        assert.equal(txt, ["lorem", "ipsum", "dolor", "sit", "amet"].join("\n"));
+    });
+});

test/lib/getKcContext.spec.ts

@@ -1,13 +1,14 @@
-import { getKcContext } from "../../src/login/kcContext/getKcContext";
-import type { ExtendKcContext } from "../../src/login/kcContext/getKcContextFromWindow";
-import type { KcContext } from "../../src/login/kcContext";
+import { getKcContext } from "keycloakify/login/kcContext/getKcContext";
+import type { ExtendKcContext } from "keycloakify/login/kcContext/getKcContextFromWindow";
+import type { KcContext } from "keycloakify/login/kcContext";
 import { same } from "evt/tools/inDepth";
 import { assert } from "tsafe/assert";
 import type { Equals } from "tsafe";
-import { kcContextMocks, kcContextCommonMock } from "../../src/login/kcContext/kcContextMocks";
-import { deepClone } from "../../src/tools/deepClone";
+import { kcContextMocks, kcContextCommonMock } from "keycloakify/login/kcContext/kcContextMocks";
+import { deepClone } from "keycloakify/tools/deepClone";
+import { expect, it, describe } from "vitest";
 
-{
+describe("getKcContext", () => {
     const authorizedMailDomains = ["example.com", "another-example.com", "*.yet-another-example.com", "*.example.com", "hello-world.com"];
 
     const displayName = "this is an overwritten common value";
@@ -59,8 +60,7 @@ import { deepClone } from "../../src/tools/deepClone";
 
         return { kcContext };
     };
-
-    {
+    it("has proper API for login.ftl", () => {
         const pageId = "login.ftl";
 
         const { kcContext } = getKcContextProxy({ "mockPageId": pageId });
@@ -69,7 +69,7 @@ import { deepClone } from "../../src/tools/deepClone";
 
         assert<Equals<typeof kcContext, KcContext.Login>>();
 
-        assert(
+        expect(
             same(
                 //NOTE: deepClone for printIfExists or other functions...
                 deepClone(kcContext),
@@ -81,12 +81,10 @@ import { deepClone } from "../../src/tools/deepClone";
                     return mock;
                 })()
             )
-        );
+        ).toBe(true);
+    });
 
-        console.log(`PASS ${pageId}`);
-    }
-
-    {
+    it("has a proper API for info.ftl", () => {
         const pageId = "info.ftl";
 
         const { kcContext } = getKcContextProxy({ "mockPageId": pageId });
@@ -104,7 +102,7 @@ import { deepClone } from "../../src/tools/deepClone";
             >
         >();
 
-        assert(
+        expect(
             same(
                 deepClone(kcContext),
                 (() => {
@@ -115,12 +113,9 @@ import { deepClone } from "../../src/tools/deepClone";
                     return mock;
                 })()
             )
-        );
-
-        console.log(`PASS ${pageId}`);
-    }
-
-    {
+        ).toBe(true);
+    });
+    it("has a proper API for register.ftl", () => {
         const pageId = "register.ftl";
 
         const { kcContext } = getKcContextProxy({ "mockPageId": pageId });
@@ -138,7 +133,7 @@ import { deepClone } from "../../src/tools/deepClone";
             >
         >();
 
-        assert(
+        expect(
             same(
                 deepClone(kcContext),
                 (() => {
@@ -149,12 +144,9 @@ import { deepClone } from "../../src/tools/deepClone";
                     return mock;
                 })()
             )
-        );
-
-        console.log(`PASS ${pageId}`);
-    }
-
-    {
+        ).toBe(true);
+    });
+    it("has a proper API for my-extra-page-2.ftl", () => {
         const pageId = "my-extra-page-2.ftl";
 
         const { kcContext } = getKcContextProxy({ "mockPageId": pageId });
@@ -173,7 +165,7 @@ import { deepClone } from "../../src/tools/deepClone";
 
         kcContext.aNonStandardValue2;
 
-        assert(
+        expect(
             same(
                 deepClone(kcContext),
                 (() => {
@@ -184,12 +176,9 @@ import { deepClone } from "../../src/tools/deepClone";
                     return mock;
                 })()
             )
-        );
-
-        console.log(`PASS ${pageId}`);
-    }
-
-    {
+        ).toBe(true);
+    });
+    it("has a proper API for my-extra-page-1.ftl", () => {
         const pageId = "my-extra-page-1.ftl";
 
         console.log("We expect a warning here =>");
@@ -200,7 +189,7 @@ import { deepClone } from "../../src/tools/deepClone";
 
         assert<Equals<typeof kcContext, KcContext.Common & { pageId: typeof pageId }>>();
 
-        assert(
+        expect(
             same(
                 deepClone(kcContext),
                 (() => {
@@ -211,32 +200,24 @@ import { deepClone } from "../../src/tools/deepClone";
                     return mock;
                 })()
             )
-        );
-
-        console.log(`PASS ${pageId}`);
-    }
-}
-
-{
-    const pageId = "login.ftl";
-
-    const { kcContext } = getKcContext({
-        "mockPageId": pageId
+        ).toBe(true);
     });
+    it("returns the proper mock for login.ftl", () => {
+        const pageId = "login.ftl";
 
-    assert<Equals<typeof kcContext, KcContext | undefined>>();
+        const { kcContext } = getKcContext({
+            "mockPageId": pageId
+        });
 
-    assert(same(deepClone(kcContext), deepClone(kcContextMocks.find(({ pageId: pageId_i }) => pageId_i === pageId)!)));
+        assert<Equals<typeof kcContext, KcContext | undefined>>();
 
-    console.log("PASS no extension");
-}
+        assert(same(deepClone(kcContext), deepClone(kcContextMocks.find(({ pageId: pageId_i }) => pageId_i === pageId)!)));
+    });
+    it("returns the proper mock for login.ftl", () => {
+        const { kcContext } = getKcContext();
 
-{
-    const { kcContext } = getKcContext();
+        assert<Equals<typeof kcContext, KcContext | undefined>>();
 
-    assert<Equals<typeof kcContext, KcContext | undefined>>();
-
-    assert(kcContext === undefined);
-
-    console.log("PASS no extension, no mock");
-}
+        assert(kcContext === undefined);
+    });
+});

test/lib/index.ts

@@ -1 +0,0 @@
-import "./getKcContext";

test/lib/tools/AndByDiscriminatingKey.ts

@@ -1,4 +1,4 @@
-import { AndByDiscriminatingKey } from "../../../src/tools/AndByDiscriminatingKey";
+import { AndByDiscriminatingKey } from "keycloakify/tools/AndByDiscriminatingKey";
 import { assert } from "tsafe/assert";
 import type { Equals } from "tsafe";
 

test/tools/assertIsSameCode.ts

@@ -1,7 +0,0 @@
-import { assert } from "tsafe/assert";
-
-export function assetIsSameCode(code1: string, code2: string, message?: string): void {
-    const removeSpacesAndNewLines = (code: string) => code.replace(/\s/g, "").replace(/\n/g, "");
-
-    assert(removeSpacesAndNewLines(code1) === removeSpacesAndNewLines(code2), message);
-}

test/tools/isSameCode.ts

@@ -0,0 +1,5 @@
+export function isSameCode(code1: string, code2: string): boolean {
+    const removeSpacesAndNewLines = (code: string) => code.replace(/\s/g, "").replace(/\n/g, "");
+
+    return removeSpacesAndNewLines(code1) === removeSpacesAndNewLines(code2);
+}

test/tsconfig.json

@@ -10,7 +10,7 @@
         "newLine": "LF",
         "noUnusedLocals": true,
         "noUnusedParameters": true,
-        "incremental": true,
+        "incremental": false,
         "strict": true,
         "downlevelIteration": true,
         "jsx": "react-jsx",

vitest.config.ts

@@ -0,0 +1,12 @@
+/// <reference types="vitest" />
+import { defineConfig } from "vite";
+import path from "path";
+
+export default defineConfig({
+    "test": {
+        "alias": {
+            "keycloakify": path.resolve(__dirname, "./src")
+        },
+        "watchExclude": ["**/node_modules/**", "**/dist/**", "**/sample_react_project/**"]
+    }
+});