keycloakify 7.13.2 → 7.14.1

package/src/bin/keycloakify/generateTheme/readExtraPageNames.ts

@@ -0,0 +1,38 @@
+import { crawl } from "../../tools/crawl";
+import { type ThemeType, accountThemePageIds, loginThemePageIds } from "../generateFtl";
+import { id } from "tsafe/id";
+import { removeDuplicates } from "evt/tools/reducers/removeDuplicates";
+import * as fs from "fs";
+import { join as pathJoin } from "path";
+
+export function readExtraPagesNames(params: { themeSrcDirPath: string; themeType: ThemeType }): string[] {
+    const { themeSrcDirPath, themeType } = params;
+
+    const filePaths = crawl({
+        "dirPath": pathJoin(themeSrcDirPath, themeType),
+        "returnedPathsType": "absolute"
+    }).filter(filePath => /\.(ts|tsx|js|jsx)$/.test(filePath));
+
+    const candidateFilePaths = filePaths.filter(filePath => /kcContext\.[^.]+$/.test(filePath));
+
+    if (candidateFilePaths.length === 0) {
+        candidateFilePaths.push(...filePaths);
+    }
+
+    const extraPages: string[] = [];
+
+    for (const candidateFilPath of candidateFilePaths) {
+        const rawSourceFile = fs.readFileSync(candidateFilPath).toString("utf8");
+
+        extraPages.push(...Array.from(rawSourceFile.matchAll(/["']?pageId["']?\s*:\s*["']([^.]+.ftl)["']/g), m => m[1]));
+    }
+
+    return extraPages.reduce(...removeDuplicates<string>()).filter(pageId => {
+        switch (themeType) {
+            case "account":
+                return !id<readonly string[]>(accountThemePageIds).includes(pageId);
+            case "login":
+                return !id<readonly string[]>(loginThemePageIds).includes(pageId);
+        }
+    });
+}

package/src/bin/keycloakify/generateTheme/readFieldNameUsage.ts

@@ -5,77 +5,16 @@ import * as fs from "fs";
 import type { ThemeType } from "../generateFtl";
 import { exclude } from "tsafe/exclude";
 
-export function readFieldNameUsage(params: {
-    keycloakifySrcDirPath: string;
-    themeSrcDirPath: string | undefined;
-    themeType: ThemeType | "email";
-}): string[] {
+/** Assumes the theme type exists */
+export function readFieldNameUsage(params: { keycloakifySrcDirPath: string; themeSrcDirPath: string; themeType: ThemeType }): string[] {
     const { keycloakifySrcDirPath, themeSrcDirPath, themeType } = params;
 
     const fieldNames: string[] = [];
 
-    if (themeSrcDirPath === undefined) {
-        //If we can't detect the user theme directory we restore the fieldNames we had previously to prevent errors.
-        fieldNames.push(
-            ...[
-                "global",
-                "userLabel",
-                "username",
-                "email",
-                "firstName",
-                "lastName",
-                "password",
-                "password-confirm",
-                "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"
-            ]
-        );
-    }
-
-    for (const srcDirPath of (
-        [
-            pathJoin(keycloakifySrcDirPath, themeType),
-            (() => {
-                if (themeSrcDirPath === undefined) {
-                    return undefined;
-                }
-
-                const srcDirPath = pathJoin(themeSrcDirPath, themeType);
-
-                if (!fs.existsSync(srcDirPath)) {
-                    return undefined;
-                }
-
-                return srcDirPath;
-            })()
-        ] as const
-    ).filter(exclude(undefined))) {
-        const filePaths = crawl(srcDirPath)
-            .filter(filePath => /\.(ts|tsx|js|jsx)$/.test(filePath))
-            .map(filePath => pathJoin(srcDirPath, filePath));
+    for (const srcDirPath of ([pathJoin(keycloakifySrcDirPath, themeType), pathJoin(themeSrcDirPath, themeType)] as const).filter(
+        exclude(undefined)
+    )) {
+        const filePaths = crawl({ "dirPath": srcDirPath, "returnedPathsType": "absolute" }).filter(filePath => /\.(ts|tsx|js|jsx)$/.test(filePath));
 
         for (const filePath of filePaths) {
             const rawSourceFile = fs.readFileSync(filePath).toString("utf8");

package/src/bin/keycloakify/keycloakify.ts

@@ -57,12 +57,6 @@ export async function main() {
                 "email": false
             };
 
-            if (themeSrcDirPath === undefined) {
-                implementedThemeTypes["login"] = true;
-                implementedThemeTypes["account"] = true;
-                return implementedThemeTypes;
-            }
-
             for (const themeType of objectKeys(implementedThemeTypes)) {
                 if (!fs.existsSync(pathJoin(themeSrcDirPath, themeType))) {
                     continue;

package/src/bin/keycloakify/parsedPackageJson.ts

@@ -11,10 +11,6 @@ export type ParsedPackageJson = {
     version?: string;
     homepage?: string;
     keycloakify?: {
-        /** @deprecated: use extraLoginPages instead */
-        extraPages?: string[];
-        extraLoginPages?: string[];
-        extraAccountPages?: string[];
         extraThemeProperties?: string[];
         areAppAndKeycloakServerSharingSameDomain?: boolean;
         artifactId?: string;
@@ -34,9 +30,6 @@ export const zParsedPackageJson = z.object({
     "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(),

package/src/bin/tools/crawl.ts

@@ -1,27 +1,32 @@
 import * as fs from "fs";
 import * as path from "path";
 
-/** List all files in a given directory return paths relative to the dir_path */
-export const crawl = (() => {
-    const crawlRec = (dir_path: string, paths: string[]) => {
-        for (const file_name of fs.readdirSync(dir_path)) {
-            const file_path = path.join(dir_path, file_name);
-
-            if (fs.lstatSync(file_path).isDirectory()) {
-                crawlRec(file_path, paths);
+const crawlRec = (dir_path: string, paths: string[]) => {
+    for (const file_name of fs.readdirSync(dir_path)) {
+        const file_path = path.join(dir_path, file_name);
 
-                continue;
-            }
+        if (fs.lstatSync(file_path).isDirectory()) {
+            crawlRec(file_path, paths);
 
-            paths.push(file_path);
+            continue;
         }
-    };
 
-    return function crawl(dir_path: string): string[] {
-        const paths: string[] = [];
+        paths.push(file_path);
+    }
+};
+
+/** List all files in a given directory return paths relative to the dir_path */
+export function crawl(params: { dirPath: string; returnedPathsType: "absolute" | "relative to dirPath" }): string[] {
+    const { dirPath, returnedPathsType } = params;
+
+    const filePaths: string[] = [];
 
-        crawlRec(dir_path, paths);
+    crawlRec(dirPath, filePaths);
 
-        return paths.map(file_path => path.relative(dir_path, file_path));
-    };
-})();
+    switch (returnedPathsType) {
+        case "absolute":
+            return filePaths;
+        case "relative to dirPath":
+            return filePaths.map(filePath => path.relative(dirPath, filePath));
+    }
+}

package/src/bin/tools/transformCodebase.ts

@@ -20,12 +20,12 @@ export function transformCodebase(params: { srcDirPath: string; destDirPath: str
         }))
     } = params;
 
-    for (const file_relative_path of crawl(srcDirPath)) {
+    for (const file_relative_path of crawl({ "dirPath": srcDirPath, "returnedPathsType": "relative to dirPath" })) {
         const filePath = path.join(srcDirPath, file_relative_path);
 
         const transformSourceCodeResult = transformSourceCode({
             "sourceCode": fs.readFileSync(filePath),
-            "filePath": path.join(srcDirPath, file_relative_path)
+            filePath
         });
 
         if (transformSourceCodeResult === undefined) {