keycloakify 10.0.0-rc.3 → 10.0.0-rc.30

package/src/bin/tools/fs.rmSync.ts

@@ -20,13 +20,13 @@ export function rmSync(dirPath: string, options: { recursive: true; force?: true
 
     const removeDir_rec = (dirPath: string) =>
         fs.readdirSync(dirPath).forEach(basename => {
-            const fileOrDirpath = pathJoin(dirPath, basename);
+            const fileOrDirPath = pathJoin(dirPath, basename);
 
-            if (fs.lstatSync(fileOrDirpath).isDirectory()) {
-                removeDir_rec(fileOrDirpath);
+            if (fs.lstatSync(fileOrDirPath).isDirectory()) {
+                removeDir_rec(fileOrDirPath);
                 return;
             } else {
-                fs.unlinkSync(fileOrDirpath);
+                fs.unlinkSync(fileOrDirPath);
             }
         });
 

package/src/bin/tools/getAbsoluteAndInOsFormatPath.ts

@@ -1,17 +1,32 @@
-import { isAbsolute as pathIsAbsolute, sep as pathSep, join as pathJoin } from "path";
+import {
+    isAbsolute as pathIsAbsolute,
+    sep as pathSep,
+    join as pathJoin,
+    resolve as pathResolve
+} from "path";
+import * as os from "os";
 
-export function getAbsoluteAndInOsFormatPath(params: { pathIsh: string; cwd: string }): string {
+export function getAbsoluteAndInOsFormatPath(params: {
+    pathIsh: string;
+    cwd: string;
+}): string {
     const { pathIsh, cwd } = params;
 
     let pathOut = pathIsh;
 
     pathOut = pathOut.replace(/\//g, pathSep);
 
+    if (pathOut.startsWith("~")) {
+        pathOut = pathOut.replace("~", os.homedir());
+    }
+
     pathOut = pathOut.endsWith(pathSep) ? pathOut.slice(0, -1) : pathOut;
 
     if (!pathIsAbsolute(pathOut)) {
         pathOut = pathJoin(cwd, pathOut);
     }
 
+    pathOut = pathResolve(pathOut);
+
     return pathOut;
 }

package/src/bin/tools/getNpmWorkspaceRootDirPath.ts

@@ -0,0 +1,73 @@
+import * as child_process from "child_process";
+import { join as pathJoin, resolve as pathResolve, sep as pathSep } from "path";
+import { assert } from "tsafe/assert";
+import * as fs from "fs";
+
+export function getNpmWorkspaceRootDirPath(params: {
+    reactAppRootDirPath: string;
+    dependencyExpected: string;
+}) {
+    const { reactAppRootDirPath, dependencyExpected } = params;
+
+    const npmWorkspaceRootDirPath = (function callee(depth: number): string {
+        const cwd = pathResolve(
+            pathJoin(...[reactAppRootDirPath, ...Array(depth).fill("..")])
+        );
+
+        assert(cwd !== pathSep, "NPM workspace not found");
+
+        try {
+            child_process.execSync("npm config get", {
+                cwd,
+                stdio: "ignore"
+            });
+        } catch (error) {
+            if (String(error).includes("ENOWORKSPACES")) {
+                return callee(depth + 1);
+            }
+
+            throw error;
+        }
+
+        const packageJsonFilePath = pathJoin(cwd, "package.json");
+
+        if (!fs.existsSync(packageJsonFilePath)) {
+            return callee(depth + 1);
+        }
+
+        assert(fs.existsSync(packageJsonFilePath));
+
+        const parsedPackageJson = JSON.parse(
+            fs.readFileSync(packageJsonFilePath).toString("utf8")
+        );
+
+        let isExpectedDependencyFound = false;
+
+        for (const dependenciesOrDevDependencies of [
+            "dependencies",
+            "devDependencies"
+        ] as const) {
+            const dependencies = parsedPackageJson[dependenciesOrDevDependencies];
+
+            if (dependencies === undefined) {
+                continue;
+            }
+
+            assert(dependencies instanceof Object);
+
+            if (dependencies[dependencyExpected] === undefined) {
+                continue;
+            }
+
+            isExpectedDependencyFound = true;
+        }
+
+        if (!isExpectedDependencyFound && parsedPackageJson.name !== dependencyExpected) {
+            return callee(depth + 1);
+        }
+
+        return cwd;
+    })(0);
+
+    return { npmWorkspaceRootDirPath };
+}

package/src/bin/tools/octokit-addons/getLatestsSemVersionedTag.ts

@@ -5,7 +5,11 @@ import { SemVer } from "../SemVer";
 export function getLatestsSemVersionedTagFactory(params: { octokit: Octokit }) {
     const { octokit } = params;
 
-    async function getLatestsSemVersionedTag(params: { owner: string; repo: string; count: number }): Promise<
+    async function getLatestsSemVersionedTag(params: {
+        owner: string;
+        repo: string;
+        count: number;
+    }): Promise<
         {
             tag: string;
             version: SemVer;
@@ -33,7 +37,9 @@ export function getLatestsSemVersionedTagFactory(params: { octokit: Octokit }) {
             semVersionedTags.push({ tag, version });
         }
 
-        return semVersionedTags.sort(({ version: vX }, { version: vY }) => SemVer.compare(vY, vX)).slice(0, count);
+        return semVersionedTags
+            .sort(({ version: vX }, { version: vY }) => SemVer.compare(vY, vX))
+            .slice(0, count);
     }
 
     return { getLatestsSemVersionedTag };

package/src/bin/tools/octokit-addons/listTags.ts

@@ -5,11 +5,19 @@ const per_page = 99;
 export function listTagsFactory(params: { octokit: Octokit }) {
     const { octokit } = params;
 
-    const octokit_repo_listTags = async (params: { owner: string; repo: string; per_page: number; page: number }) => {
+    const octokit_repo_listTags = async (params: {
+        owner: string;
+        repo: string;
+        per_page: number;
+        page: number;
+    }) => {
         return octokit.repos.listTags(params);
     };
 
-    async function* listTags(params: { owner: string; repo: string }): AsyncGenerator<string> {
+    async function* listTags(params: {
+        owner: string;
+        repo: string;
+    }): AsyncGenerator<string> {
         const { owner, repo } = params;
 
         let page = 1;
@@ -19,7 +27,7 @@ export function listTagsFactory(params: { octokit: Octokit }) {
                 owner,
                 repo,
                 per_page,
-                "page": page++
+                page: page++
             });
 
             for (const branch of resp.data.map(({ name }) => name)) {
@@ -33,7 +41,10 @@ export function listTagsFactory(params: { octokit: Octokit }) {
     }
 
     /** Returns the same "latest" tag as deno.land/x, not actually the latest though */
-    async function getLatestTag(params: { owner: string; repo: string }): Promise<string | undefined> {
+    async function getLatestTag(params: {
+        owner: string;
+        repo: string;
+    }): Promise<string | undefined> {
         const { owner, repo } = params;
 
         const itRes = await listTags({ owner, repo }).next();

package/src/bin/tools/partitionPromiseSettledResults.ts

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

package/src/bin/tools/{readThisNpmProjectVersion.ts → readThisNpmPackageVersion.ts}

@@ -3,8 +3,12 @@ import { assert } from "tsafe/assert";
 import * as fs from "fs";
 import { join as pathJoin } from "path";
 
-export function readThisNpmProjectVersion(): string {
-    const version = JSON.parse(fs.readFileSync(pathJoin(getThisCodebaseRootDirPath(), "package.json")).toString("utf8"))["version"];
+export function readThisNpmPackageVersion(): string {
+    const version = JSON.parse(
+        fs
+            .readFileSync(pathJoin(getThisCodebaseRootDirPath(), "package.json"))
+            .toString("utf8")
+    )["version"];
 
     assert(typeof version === "string");
 

package/src/bin/tools/transformCodebase.ts

@@ -3,7 +3,11 @@ import * as path from "path";
 import { crawl } from "./crawl";
 import { rmSync } from "../tools/fs.rmSync";
 
-type TransformSourceCode = (params: { sourceCode: Buffer; filePath: string; fileRelativePath: string }) =>
+type TransformSourceCode = (params: {
+    sourceCode: Buffer;
+    filePath: string;
+    fileRelativePath: string;
+}) =>
     | {
           modifiedSourceCode: Buffer;
           newFileName?: string;
@@ -15,18 +19,27 @@ type TransformSourceCode = (params: { sourceCode: Buffer; filePath: string; file
  * If source and destination are the same this function can be used to apply the transformation in place
  * like filtering out some files or modifying them.
  * */
-export function transformCodebase(params: { srcDirPath: string; destDirPath: string; transformSourceCode?: TransformSourceCode }) {
+export function transformCodebase(params: {
+    srcDirPath: string;
+    destDirPath: string;
+    transformSourceCode?: TransformSourceCode;
+}) {
     const { srcDirPath, transformSourceCode } = params;
 
     const isTargetSameAsSource = path.relative(srcDirPath, params.destDirPath) === "";
 
-    const destDirPath = isTargetSameAsSource ? path.join(srcDirPath, "..", "tmp_xOsPdkPsTdzPs34sOkHs") : params.destDirPath;
+    const destDirPath = isTargetSameAsSource
+        ? path.join(srcDirPath, "..", "tmp_xOsPdkPsTdzPs34sOkHs")
+        : params.destDirPath;
 
     fs.mkdirSync(destDirPath, {
-        "recursive": true
+        recursive: true
     });
 
-    for (const fileRelativePath of crawl({ "dirPath": srcDirPath, "returnedPathsType": "relative to dirPath" })) {
+    for (const fileRelativePath of crawl({
+        dirPath: srcDirPath,
+        returnedPathsType: "relative to dirPath"
+    })) {
         const filePath = path.join(srcDirPath, fileRelativePath);
         const destFilePath = path.join(destDirPath, fileRelativePath);
 
@@ -34,7 +47,7 @@ export function transformCodebase(params: { srcDirPath: string; destDirPath: str
         // it using the lower level implementation.
         if (transformSourceCode === undefined) {
             fs.mkdirSync(path.dirname(destFilePath), {
-                "recursive": true
+                recursive: true
             });
 
             fs.copyFileSync(filePath, destFilePath);
@@ -43,7 +56,7 @@ export function transformCodebase(params: { srcDirPath: string; destDirPath: str
         }
 
         const transformSourceCodeResult = transformSourceCode({
-            "sourceCode": fs.readFileSync(filePath),
+            sourceCode: fs.readFileSync(filePath),
             filePath,
             fileRelativePath
         });
@@ -53,16 +66,22 @@ export function transformCodebase(params: { srcDirPath: string; destDirPath: str
         }
 
         fs.mkdirSync(path.dirname(destFilePath), {
-            "recursive": true
+            recursive: true
         });
 
         const { newFileName, modifiedSourceCode } = transformSourceCodeResult;
 
-        fs.writeFileSync(path.join(path.dirname(destFilePath), newFileName ?? path.basename(destFilePath)), modifiedSourceCode);
+        fs.writeFileSync(
+            path.join(
+                path.dirname(destFilePath),
+                newFileName ?? path.basename(destFilePath)
+            ),
+            modifiedSourceCode
+        );
     }
 
     if (isTargetSameAsSource) {
-        rmSync(srcDirPath, { "recursive": true });
+        rmSync(srcDirPath, { recursive: true });
 
         fs.renameSync(destDirPath, srcDirPath);
     }

package/src/bin/tools/trimIndent.ts

@@ -14,7 +14,10 @@ function populateTemplate(strings: TemplateStringsArray, ...args: unknown[]) {
         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));
+            const chunk = String(args[i]).replace(
+                /([\r?\n])/g,
+                "$1" + " ".repeat(lastStringLineLength)
+            );
             chunks.push(chunk);
         }
     }

package/src/lib/isStorybook.ts

@@ -1 +1,3 @@
-export const isStorybook = typeof window === "object" && Object.keys(window).find(key => key.startsWith("__STORYBOOK")) !== undefined;
+export const isStorybook =
+    typeof window === "object" &&
+    Object.keys(window).find(key => key.startsWith("__STORYBOOK")) !== undefined;

package/src/lib/useGetClassName.ts

@@ -1,14 +1,23 @@
 import { clsx } from "keycloakify/tools/clsx";
 import { useConstCallback } from "keycloakify/tools/useConstCallback";
 
-export function createUseClassName<ClassKey extends string>(params: { defaultClasses: Record<ClassKey, string | undefined> }) {
+export function createUseClassName<ClassKey extends string>(params: {
+    defaultClasses: Record<ClassKey, string | undefined>;
+}) {
     const { defaultClasses } = params;
 
-    function useGetClassName(params: { doUseDefaultCss: boolean; classes: Partial<Record<ClassKey, string>> | undefined }) {
+    function useGetClassName(params: {
+        doUseDefaultCss: boolean;
+        classes: Partial<Record<ClassKey, string>> | undefined;
+    }) {
         const { classes, doUseDefaultCss } = params;
 
         const getClassName = useConstCallback((classKey: ClassKey): string => {
-            return clsx(classKey, doUseDefaultCss ? defaultClasses[classKey] : undefined, classes?.[classKey]);
+            return clsx(
+                classKey,
+                doUseDefaultCss ? defaultClasses[classKey] : undefined,
+                classes?.[classKey]
+            );
         });
 
         return { getClassName };

package/src/login/Fallback.tsx

@@ -1,9 +1,9 @@
 import { lazy, Suspense } from "react";
-import type { PageProps } from "keycloakify/login/pages/PageProps";
 import { assert, type Equals } from "tsafe/assert";
-import type { I18n } from "./i18n";
-import type { KcContext } from "./kcContext";
 import type { LazyOrNot } from "keycloakify/tools/LazyOrNot";
+import type { PageProps } from "keycloakify/login/pages/PageProps";
+import type { KcContext } from "./KcContext";
+import type { I18n } from "./i18n";
 import type { UserProfileFormFieldsProps } from "keycloakify/login/UserProfileFormFields";
 
 const Login = lazy(() => import("keycloakify/login/pages/Login"));

package/src/login/{kcContext → KcContext}/KcContext.ts

@@ -1,10 +1,30 @@
-import type { LoginThemePageId } from "keycloakify/bin/keycloakify/generateFtl";
-import { type ThemeType } from "keycloakify/bin/constants";
+import type {
+    ThemeType,
+    LoginThemePageId,
+    nameOfTheLocalizationRealmOverridesUserProfileProperty
+} from "keycloakify/bin/shared/constants";
+import type { ExtractAfterStartingWith } from "keycloakify/tools/ExtractAfterStartingWith";
+import type { ValueOf } from "keycloakify/tools/ValueOf";
 import { assert } from "tsafe/assert";
 import type { Equals } from "tsafe";
 import type { MessageKey } from "../i18n/i18n";
 
-type ExtractAfterStartingWith<Prefix extends string, StrEnum> = StrEnum extends `${Prefix}${infer U}` ? U : never;
+export type ExtendKcContext<
+    KcContextExtraProperties extends { properties?: Record<string, string | undefined> },
+    KcContextExtraPropertiesPerPage extends Record<string, Record<string, unknown>>
+> = ValueOf<{
+    [PageId in keyof KcContextExtraPropertiesPerPage | KcContext["pageId"]]: Extract<
+        KcContext,
+        { pageId: PageId }
+    > extends never
+        ? KcContext.Common &
+              KcContextExtraProperties & {
+                  pageId: PageId;
+              } & KcContextExtraPropertiesPerPage[PageId]
+        : Extract<KcContext, { pageId: PageId }> &
+              KcContextExtraProperties &
+              KcContextExtraPropertiesPerPage[PageId];
+}>;
 
 /** Take theses type definition with a grain of salt.
  * Some values might be undefined on some pages.
@@ -104,7 +124,10 @@ export declare namespace KcContext {
              * @param text to return
              * @return text if message exists for given field, else undefined
              */
-            printIfExists: <T extends string>(fieldName: string, text: T) => T | undefined;
+            printIfExists: <T extends string>(
+                fieldName: string,
+                text: T
+            ) => T | undefined;
             /**
              * Check if exists error message for given fields
              *
@@ -129,12 +152,13 @@ export declare namespace KcContext {
 
             getFirstError: (...fieldNames: string[]) => string;
         };
-        properties: Record<string, string | undefined>;
         authenticationSession?: {
             authSessionId: string;
             tabId: string;
             ssoLoginInOtherTabsUrl: string;
         };
+        properties: {};
+        __localizationRealmOverridesUserProfile?: Record<string, string>;
     };
 
     export type SamlPostForm = Common & {
@@ -575,7 +599,6 @@ export declare namespace KcContext {
 }
 
 export type UserProfile = {
-    attributes: Attribute[];
     attributesByName: Record<string, Attribute>;
     html5DataAnnotations?: Record<string, string>;
 };
@@ -674,31 +697,31 @@ export type Attribute = {
         | "photo";
 };
 
-export type Validators = Partial<{
-    length: Validators.DoIgnoreEmpty & Validators.Range;
-    integer: Validators.DoIgnoreEmpty & Validators.Range;
-    email: Validators.DoIgnoreEmpty;
-    pattern: Validators.DoIgnoreEmpty & Validators.ErrorMessage & { pattern: string };
-    options: Validators.Options;
-    multivalued: Validators.DoIgnoreEmpty & Validators.Range;
+export type Validators = {
+    length?: Validators.DoIgnoreEmpty & Validators.Range;
+    integer?: Validators.DoIgnoreEmpty & Validators.Range;
+    email?: Validators.DoIgnoreEmpty;
+    pattern?: Validators.DoIgnoreEmpty & Validators.ErrorMessage & { pattern: string };
+    options?: Validators.Options;
+    multivalued?: Validators.DoIgnoreEmpty & Validators.Range;
     // NOTE: Following are the validators for which we don't implement client side validation yet
     // or for which the validation can't be performed on the client side.
     /*
-    double: Validators.DoIgnoreEmpty & Validators.Range;
-    "up-immutable-attribute": {};
-    "up-attribute-required-by-metadata-value": {};
-    "up-username-has-value": {};
-    "up-duplicate-username": {};
-    "up-username-mutation": {};
-    "up-email-exists-as-username": {};
-    "up-blank-attribute-value": Validators.ErrorMessage & { "fail-on-null": boolean; };
-    "up-duplicate-email": {};
-    "local-date": Validators.DoIgnoreEmpty;
-    "person-name-prohibited-characters": Validators.DoIgnoreEmpty & Validators.ErrorMessage;
-    uri: Validators.DoIgnoreEmpty;
-    "username-prohibited-characters": Validators.DoIgnoreEmpty & Validators.ErrorMessage;
+    double?: Validators.DoIgnoreEmpty & Validators.Range;
+    "up-immutable-attribute"?: {};
+    "up-attribute-required-by-metadata-value"?: {};
+    "up-username-has-value"?: {};
+    "up-duplicate-username"?: {};
+    "up-username-mutation"?: {};
+    "up-email-exists-as-username"?: {};
+    "up-blank-attribute-value"?: Validators.ErrorMessage & { "fail-on-null": boolean; };
+    "up-duplicate-email"?: {};
+    "local-date"?: Validators.DoIgnoreEmpty;
+    "person-name-prohibited-characters"?: Validators.DoIgnoreEmpty & Validators.ErrorMessage;
+    uri?: Validators.DoIgnoreEmpty;
+    "username-prohibited-characters"?: Validators.DoIgnoreEmpty & Validators.ErrorMessage;
     */
-}>;
+};
 
 export declare namespace Validators {
     export type DoIgnoreEmpty = {
@@ -745,3 +768,11 @@ export type PasswordPolicies = {
     /** Whether the password can be the email address */
     notEmail?: boolean;
 };
+
+assert<
+    KcContext.Common extends Partial<
+        Record<typeof nameOfTheLocalizationRealmOverridesUserProfileProperty, unknown>
+    >
+        ? true
+        : false
+>();

package/src/login/KcContext/getKcContextMock.ts

@@ -0,0 +1,82 @@
+import type { ExtendKcContext, KcContext as KcContextBase } from "./KcContext";
+import type { LoginThemePageId } from "keycloakify/bin/shared/constants";
+import type { DeepPartial } from "keycloakify/tools/DeepPartial";
+import { deepAssign } from "keycloakify/tools/deepAssign";
+import { structuredCloneButFunctions } from "keycloakify/tools/structuredCloneButFunctions";
+import { kcContextMocks, kcContextCommonMock } from "./kcContextMocks";
+import { exclude } from "tsafe/exclude";
+
+export function createGetKcContextMock<
+    KcContextExtraProperties extends { properties?: Record<string, string | undefined> },
+    KcContextExtraPropertiesPerPage extends Record<
+        `${string}.ftl`,
+        Record<string, unknown>
+    >
+>(params: {
+    kcContextExtraProperties: KcContextExtraProperties;
+    kcContextExtraPropertiesPerPage: KcContextExtraPropertiesPerPage;
+    overrides?: DeepPartial<KcContextExtraProperties & KcContextBase.Common>;
+    overridesPerPage?: {
+        [PageId in
+            | LoginThemePageId
+            | keyof KcContextExtraPropertiesPerPage]?: DeepPartial<
+            Extract<
+                ExtendKcContext<
+                    KcContextExtraProperties,
+                    KcContextExtraPropertiesPerPage
+                >,
+                { pageId: PageId }
+            >
+        >;
+    };
+}) {
+    const {
+        kcContextExtraProperties,
+        kcContextExtraPropertiesPerPage,
+        overrides: overrides_global,
+        overridesPerPage: overridesPerPage_global
+    } = params;
+
+    type KcContext = ExtendKcContext<
+        KcContextExtraProperties,
+        KcContextExtraPropertiesPerPage
+    >;
+
+    function getKcContextMock<
+        PageId extends LoginThemePageId | keyof KcContextExtraPropertiesPerPage
+    >(params: {
+        pageId: PageId;
+        overrides?: DeepPartial<Extract<KcContext, { pageId: PageId }>>;
+        // NOTE: We choose to have a return type less precise than Extract<KcContext, { pageId: PageId }> {
+        // because we want to be able to use the mock just as the real KcContext.
+    }): KcContext {
+        const { pageId, overrides } = params;
+
+        const kcContextMock = structuredCloneButFunctions(
+            kcContextMocks.find(kcContextMock => kcContextMock.pageId === pageId) ?? {
+                ...kcContextCommonMock,
+                pageId
+            }
+        );
+
+        [
+            kcContextExtraProperties,
+            kcContextExtraPropertiesPerPage[pageId],
+            overrides_global,
+            overridesPerPage_global?.[pageId],
+            overrides
+        ]
+            .filter(exclude(undefined))
+            .forEach(overrides =>
+                deepAssign({
+                    target: kcContextMock,
+                    source: overrides
+                })
+            );
+
+        // @ts-expect-error
+        return kcContextMock;
+    }
+
+    return { getKcContextMock };
+}

package/src/login/KcContext/index.ts

@@ -0,0 +1,8 @@
+export type {
+    ExtendKcContext,
+    KcContext,
+    Attribute,
+    PasswordPolicies,
+    Validators
+} from "./KcContext";
+export { createGetKcContextMock } from "./getKcContextMock";