keycloak_theme/src/login/kcContext/createGetKcContext.ts

import type { KcContext, Attribute } from "./KcContext";
import { kcContextMocks, kcContextCommonMock } from "./kcContextMocks";
import type { DeepPartial } from "keycloakify/tools/DeepPartial";
import { deepAssign } from "keycloakify/tools/deepAssign";
import { isStorybook } from "keycloakify/lib/isStorybook";
import { id } from "tsafe/id";
import { exclude } from "tsafe/exclude";
import { assert } from "tsafe/assert";
import type { ExtendKcContext } from "./getKcContextFromWindow";
import { getKcContextFromWindow } from "./getKcContextFromWindow";
import { symToStr } from "tsafe/symToStr";

export function createGetKcContext<
    KcContextExtension extends { pageId: string } = never
>(params?: {
    mockData?: readonly DeepPartial<ExtendKcContext<KcContextExtension>>[];
    mockProperties?: Record<string, string>;
}) {
    const { mockData, mockProperties } = params ?? {};

    function getKcContext<
        PageId extends
            | ExtendKcContext<KcContextExtension>["pageId"]
            | undefined = undefined
    >(params?: {
        mockPageId?: PageId;
        storyPartialKcContext?: DeepPartial<
            Extract<ExtendKcContext<KcContextExtension>, { pageId: PageId }>
        >;
    }): {
        kcContext: PageId extends undefined
            ? ExtendKcContext<KcContextExtension> | undefined
            : Extract<ExtendKcContext<KcContextExtension>, { pageId: PageId }>;
    } {
        const { mockPageId, storyPartialKcContext } = params ?? {};

        const realKcContext = getKcContextFromWindow<KcContextExtension>();

        if (mockPageId !== undefined && realKcContext === undefined) {
            //TODO maybe trow if no mock fo custom page

            warn_that_mock_is_enbaled: {
                if (isStorybook) {
                    break warn_that_mock_is_enbaled;
                }

                console.log(
                    `%cKeycloakify: ${symToStr({
                        mockPageId
                    })} set to ${mockPageId}.`,
                    "background: red; color: yellow; font-size: medium"
                );
            }

            const kcContextDefaultMock = kcContextMocks.find(
                ({ pageId }) => pageId === mockPageId
            );

            const partialKcContextCustomMock = (() => {
                const out: DeepPartial<ExtendKcContext<KcContextExtension>> = {};

                const mockDataPick = mockData?.find(
                    ({ pageId }) => pageId === mockPageId
                );

                if (mockDataPick !== undefined) {
                    deepAssign({
                        target: out,
                        source: mockDataPick
                    });
                }

                if (storyPartialKcContext !== undefined) {
                    deepAssign({
                        target: out,
                        source: storyPartialKcContext
                    });
                }

                return Object.keys(out).length === 0 ? undefined : out;
            })();

            if (
                kcContextDefaultMock === undefined &&
                partialKcContextCustomMock === undefined
            ) {
                console.warn(
                    [
                        `WARNING: You declared the non build in page ${mockPageId} but you didn't `,
                        `provide mock data needed to debug the page outside of Keycloak as you are trying to do now.`,
                        `Please check the documentation of the getKcContext function`
                    ].join("\n")
                );
            }

            const kcContext: any = {};

            deepAssign({
                target: kcContext,
                source:
                    kcContextDefaultMock !== undefined
                        ? kcContextDefaultMock
                        : { pageId: mockPageId, ...kcContextCommonMock }
            });

            if (partialKcContextCustomMock !== undefined) {
                deepAssign({
                    target: kcContext,
                    source: partialKcContextCustomMock
                });

                if ("profile" in partialKcContextCustomMock) {
                    assert(
                        kcContextDefaultMock !== undefined &&
                            "profile" in kcContextDefaultMock
                    );

                    const { attributes } = kcContextDefaultMock.profile;

                    id<KcContext.Register>(kcContext).profile.attributes = [];
                    id<KcContext.Register>(kcContext).profile.attributesByName = {};

                    const partialAttributes = [
                        ...((
                            partialKcContextCustomMock as DeepPartial<KcContext.Register>
                        ).profile?.attributes ?? [])
                    ].filter(exclude(undefined));

                    attributes.forEach(attribute => {
                        const partialAttribute = partialAttributes.find(
                            ({ name }) => name === attribute.name
                        );

                        const augmentedAttribute: Attribute = {} as any;

                        deepAssign({
                            target: augmentedAttribute,
                            source: attribute
                        });

                        if (partialAttribute !== undefined) {
                            partialAttributes.splice(
                                partialAttributes.indexOf(partialAttribute),
                                1
                            );

                            deepAssign({
                                target: augmentedAttribute,
                                source: partialAttribute
                            });
                        }

                        id<KcContext.Register>(kcContext).profile.attributes.push(
                            augmentedAttribute
                        );
                        id<KcContext.Register>(kcContext).profile.attributesByName[
                            augmentedAttribute.name
                        ] = augmentedAttribute;
                    });

                    partialAttributes
                        .map(partialAttribute => ({
                            validators: {},
                            ...partialAttribute
                        }))
                        .forEach(partialAttribute => {
                            const { name } = partialAttribute;

                            assert(
                                name !== undefined,
                                "If you define a mock attribute it must have at least a name"
                            );

                            id<KcContext.Register>(kcContext).profile.attributes.push(
                                partialAttribute as any
                            );
                            id<KcContext.Register>(kcContext).profile.attributesByName[
                                name
                            ] = partialAttribute as any;
                        });
                }
            }

            if (mockProperties !== undefined) {
                deepAssign({
                    target: kcContext.properties,
                    source: mockProperties
                });
            }

            return { kcContext };
        }

        if (realKcContext === undefined) {
            return { kcContext: undefined as any };
        }

        if (realKcContext.themeType !== "login") {
            return { kcContext: undefined as any };
        }

        return { kcContext: realKcContext as any };
    }

    return { getKcContext };
}