keycloakify 11.8.37 → 11.8.38

package/src/bin/keycloakify/generateResources/generateResources.ts

@@ -37,6 +37,7 @@ import { createObjectThatThrowsIfAccessed } from "../../tools/createObjectThatTh
 import { listInstalledModules } from "../../tools/listInstalledModules";
 import { isInside } from "../../tools/isInside";
 import { id } from "tsafe/id";
+import { KEYCLOAK_THEME } from "../../shared/constants";
 
 export type BuildContextLike = BuildContextLike_kcContextExclusionsFtlCode &
     BuildContextLike_generateMessageProperties & {
@@ -44,6 +45,7 @@ export type BuildContextLike = BuildContextLike_kcContextExclusionsFtlCode &
         extraThemeProperties: string[] | undefined;
         projectDirPath: string;
         projectBuildDirPath: string;
+        publicDirPath: string;
         environmentVariables: { name: string; default: string }[];
         implementedThemeTypes: BuildContext["implementedThemeTypes"];
         themeSrcDirPath: string;
@@ -153,10 +155,14 @@ export async function generateResources(params: {
                 break apply_replacers_and_move_to_theme_resources;
             }
 
-            {
+            for (const directoryBasename of [
+                KEYCLOAK_THEME,
+                // NOTE: This is legacy and should eventually be removed
+                WELL_KNOWN_DIRECTORY_BASE_NAME.KEYCLOAKIFY_DEV_RESOURCES
+            ]) {
                 const dirPath = pathJoin(
                     buildContext.projectBuildDirPath,
-                    WELL_KNOWN_DIRECTORY_BASE_NAME.KEYCLOAKIFY_DEV_RESOURCES
+                    directoryBasename
                 );
 
                 if (fs.existsSync(dirPath)) {
@@ -164,7 +170,7 @@ export async function generateResources(params: {
 
                     throw new Error(
                         [
-                            `Keycloakify build error: The ${WELL_KNOWN_DIRECTORY_BASE_NAME.KEYCLOAKIFY_DEV_RESOURCES} directory shouldn't exist in your build directory.`,
+                            `Keycloakify build error: The ${directoryBasename} directory shouldn't exist in your build directory.`,
                             `(${pathRelative(process.cwd(), dirPath)}).\n`,
                             `Theses assets are only required for local development with Storybook.",
                             "Please remove this directory as an additional step of your command.\n`,
@@ -569,6 +575,7 @@ export async function generateResources(params: {
             };
         }
 
+        // NOTE: Legacy
         keycloak_static_resources: {
             if (isNative) {
                 break keycloak_static_resources;
@@ -578,6 +585,8 @@ export async function generateResources(params: {
                 break keycloak_static_resources;
             }
 
+            // TODO: Implement a check to skip that.
+
             transformCodebase({
                 srcDirPath: pathJoin(
                     getThisCodebaseRootDirPath(),
@@ -590,6 +599,37 @@ export async function generateResources(params: {
             });
         }
 
+        extensions_static_resources: {
+            if (isNative) {
+                break extensions_static_resources;
+            }
+
+            if (isSpa) {
+                break extensions_static_resources;
+            }
+
+            const dirPath = pathJoin(
+                buildContext.publicDirPath,
+                KEYCLOAK_THEME,
+                themeType
+            );
+
+            if (!fs.existsSync(dirPath)) {
+                break extensions_static_resources;
+            }
+
+            transformCodebase({
+                srcDirPath: dirPath,
+                destDirPath: pathJoin(
+                    themeTypeDirPath,
+                    "resources",
+                    WELL_KNOWN_DIRECTORY_BASE_NAME.DIST,
+                    KEYCLOAK_THEME,
+                    themeType
+                )
+            });
+        }
+
         bring_in_account_v1: {
             if (isNative) {
                 break bring_in_account_v1;

package/src/bin/main.ts

@@ -281,6 +281,7 @@ program
     .command<{
         path: string;
         revert: boolean;
+        public: boolean;
     }>({
         name: "own",
         description: [
@@ -331,14 +332,30 @@ program
         ].join(" "),
         defaultValue: false
     })
+    .option({
+        key: "public",
+        name: (() => {
+            const long = "public";
+            const short = "p";
+
+            optionsKeys.push(long, short);
+
+            return { long, short };
+        })(),
+        description: [
+            "Flag to use when targeting a file or directory in the public directory",
+            "instead of the src"
+        ].join(" "),
+        defaultValue: false
+    })
     .task({
         skip,
-        handler: async ({ projectDirPath, path, revert }) => {
+        handler: async ({ projectDirPath, path, revert, public: public_params }) => {
             const { command } = await import("./own");
 
             await command({
                 buildContext: getBuildContext({ projectDirPath }),
-                cliCommandOptions: { path, isRevert: revert }
+                cliCommandOptions: { path, isRevert: revert, isPublic: public_params }
             });
         }
     });

package/src/bin/own.ts

@@ -3,15 +3,17 @@ import { getExtensionModuleFileSourceCodeReadyToBeCopied } from "./sync-extensio
 import type { ExtensionModuleMeta } from "./sync-extensions/extensionModuleMeta";
 import { command as command_syncExtensions } from "./sync-extensions/sync-extension";
 import {
-    readManagedGitignoreFile,
-    writeManagedGitignoreFile
-} from "./sync-extensions/managedGitignoreFile";
+    readManagedGitignoresFile,
+    writeManagedGitignoreFiles
+} from "./sync-extensions/managedGitignoreFiles";
 import { getExtensionModuleMetas } from "./sync-extensions/extensionModuleMeta";
 import { getAbsoluteAndInOsFormatPath } from "./tools/getAbsoluteAndInOsFormatPath";
 import { relative as pathRelative, dirname as pathDirname, join as pathJoin } from "path";
 import { getInstalledModuleDirPath } from "./tools/getInstalledModuleDirPath";
 import * as fsPr from "fs/promises";
 import { isInside } from "./tools/isInside";
+import { KEYCLOAK_THEME } from "./shared/constants";
+import { same } from "evt/tools/inDepth/same";
 import chalk from "chalk";
 
 export async function command(params: {
@@ -19,6 +21,7 @@ export async function command(params: {
     cliCommandOptions: {
         path: string;
         isRevert: boolean;
+        isPublic: boolean;
     };
 }) {
     const { buildContext, cliCommandOptions } = params;
@@ -26,27 +29,34 @@ export async function command(params: {
     const extensionModuleMetas = await getExtensionModuleMetas({ buildContext });
 
     const { targetFileRelativePathsByExtensionModuleMeta } = await (async () => {
-        const fileOrDirectoryRelativePath = pathRelative(
-            buildContext.themeSrcDirPath,
-            getAbsoluteAndInOsFormatPath({
-                cwd: buildContext.themeSrcDirPath,
-                pathIsh: cliCommandOptions.path
-            })
-        );
+        const fileOrDirectoryRelativePath = (() => {
+            const dirPath_ctx = cliCommandOptions.isPublic
+                ? pathJoin(buildContext.publicDirPath, KEYCLOAK_THEME)
+                : buildContext.themeSrcDirPath;
+
+            return pathRelative(
+                dirPath_ctx,
+                getAbsoluteAndInOsFormatPath({
+                    cwd: dirPath_ctx,
+                    pathIsh: cliCommandOptions.path
+                })
+            );
+        })();
 
         const arr = extensionModuleMetas
             .map(extensionModuleMeta => ({
                 extensionModuleMeta,
                 fileRelativePaths: extensionModuleMeta.files
-                    .map(({ fileRelativePath }) => fileRelativePath)
                     .filter(
-                        fileRelativePath =>
-                            fileRelativePath === fileOrDirectoryRelativePath ||
-                            isInside({
-                                dirPath: fileOrDirectoryRelativePath,
-                                filePath: fileRelativePath
-                            })
+                        ({ fileRelativePath, isPublic }) =>
+                            cliCommandOptions.isPublic === isPublic &&
+                            (fileRelativePath === fileOrDirectoryRelativePath ||
+                                isInside({
+                                    dirPath: fileOrDirectoryRelativePath,
+                                    filePath: fileRelativePath
+                                }))
                     )
+                    .map(({ fileRelativePath }) => fileRelativePath)
             }))
             .filter(({ fileRelativePaths }) => fileRelativePaths.length !== 0);
 
@@ -75,12 +85,13 @@ export async function command(params: {
     }
 
     const { ownedFilesRelativePaths: ownedFilesRelativePaths_current } =
-        await readManagedGitignoreFile({
+        await readManagedGitignoresFile({
             buildContext
         });
 
     await (cliCommandOptions.isRevert ? command_revert : command_own)({
         extensionModuleMetas,
+        isPublic: cliCommandOptions.isPublic,
         targetFileRelativePathsByExtensionModuleMeta,
         ownedFilesRelativePaths_current,
         buildContext
@@ -89,20 +100,22 @@ export async function command(params: {
 
 type Params_subcommands = {
     extensionModuleMetas: ExtensionModuleMeta[];
+    isPublic: boolean;
     targetFileRelativePathsByExtensionModuleMeta: Map<ExtensionModuleMeta, string[]>;
-    ownedFilesRelativePaths_current: string[];
+    ownedFilesRelativePaths_current: { isPublic: boolean; fileRelativePath: string }[];
     buildContext: BuildContext;
 };
 
 async function command_own(params: Params_subcommands) {
     const {
         extensionModuleMetas,
+        isPublic,
         targetFileRelativePathsByExtensionModuleMeta,
         ownedFilesRelativePaths_current,
         buildContext
     } = params;
 
-    await writeManagedGitignoreFile({
+    await writeManagedGitignoreFiles({
         buildContext,
         extensionModuleMetas,
         ownedFilesRelativePaths: [
@@ -111,8 +124,11 @@ async function command_own(params: Params_subcommands) {
                 .flat()
                 .filter(
                     fileRelativePath =>
-                        !ownedFilesRelativePaths_current.includes(fileRelativePath)
+                        !ownedFilesRelativePaths_current.some(entry =>
+                            same(entry, { isPublic, fileRelativePath })
+                        )
                 )
+                .map(fileRelativePath => ({ isPublic, fileRelativePath }))
         ]
     });
 
@@ -128,7 +144,11 @@ async function command_own(params: Params_subcommands) {
         });
 
         for (const fileRelativePath of fileRelativePaths) {
-            if (ownedFilesRelativePaths_current.includes(fileRelativePath)) {
+            if (
+                ownedFilesRelativePaths_current.some(entry =>
+                    same(entry, { isPublic, fileRelativePath })
+                )
+            ) {
                 console.log(
                     chalk.grey(`You already have ownership over '${fileRelativePath}'.`)
                 );
@@ -138,6 +158,7 @@ async function command_own(params: Params_subcommands) {
             writeActions.push(async () => {
                 const sourceCode = await getExtensionModuleFileSourceCodeReadyToBeCopied({
                     buildContext,
+                    isPublic,
                     fileRelativePath,
                     isOwnershipAction: true,
                     extensionModuleName: extensionModuleMeta.moduleName,
@@ -146,7 +167,12 @@ async function command_own(params: Params_subcommands) {
                 });
 
                 await fsPr.writeFile(
-                    pathJoin(buildContext.themeSrcDirPath, fileRelativePath),
+                    pathJoin(
+                        isPublic
+                            ? pathJoin(buildContext.publicDirPath, KEYCLOAK_THEME)
+                            : buildContext.themeSrcDirPath,
+                        fileRelativePath
+                    ),
                     sourceCode
                 );
 
@@ -166,6 +192,7 @@ async function command_own(params: Params_subcommands) {
 async function command_revert(params: Params_subcommands) {
     const {
         extensionModuleMetas,
+        isPublic,
         targetFileRelativePathsByExtensionModuleMeta,
         ownedFilesRelativePaths_current,
         buildContext
@@ -176,7 +203,11 @@ async function command_revert(params: Params_subcommands) {
     )
         .flat()
         .filter(fileRelativePath => {
-            if (!ownedFilesRelativePaths_current.includes(fileRelativePath)) {
+            if (
+                !ownedFilesRelativePaths_current.some(entry =>
+                    same(entry, { isPublic, fileRelativePath })
+                )
+            ) {
                 console.log(
                     chalk.grey(`Ownership over '${fileRelativePath}' wasn't claimed.`)
                 );
@@ -195,12 +226,14 @@ async function command_revert(params: Params_subcommands) {
         return;
     }
 
-    await writeManagedGitignoreFile({
+    await writeManagedGitignoreFiles({
         buildContext,
         extensionModuleMetas,
         ownedFilesRelativePaths: ownedFilesRelativePaths_current.filter(
-            fileRelativePath =>
-                !ownedFilesRelativePaths_toRemove.includes(fileRelativePath)
+            entry =>
+                !ownedFilesRelativePaths_toRemove.some(fileRelativePath =>
+                    same(entry, { isPublic, fileRelativePath })
+                )
         )
     });
 

package/src/bin/sync-extensions/extensionModuleMeta.ts

@@ -1,7 +1,12 @@
 import { assert, type Equals, is } from "tsafe/assert";
 import { id } from "tsafe/id";
 import { z } from "zod";
-import { join as pathJoin, dirname as pathDirname } from "path";
+import {
+    join as pathJoin,
+    dirname as pathDirname,
+    relative as pathRelative,
+    sep as pathSep
+} from "path";
 import * as fsPr from "fs/promises";
 import type { BuildContext } from "../shared/buildContext";
 import { existsAsync } from "../tools/fs.existsAsync";
@@ -22,6 +27,7 @@ export type ExtensionModuleMeta = {
     moduleName: string;
     version: string;
     files: {
+        isPublic: boolean;
         fileRelativePath: string;
         hash: string;
         copyableFilePath: string;
@@ -37,6 +43,7 @@ const zExtensionModuleMeta = (() => {
         version: z.string(),
         files: z.array(
             z.object({
+                isPublic: z.boolean(),
                 fileRelativePath: z.string(),
                 hash: z.string(),
                 copyableFilePath: z.string()
@@ -222,49 +229,55 @@ export async function getExtensionModuleMetas(params: {
 
                 const files: ExtensionModuleMeta["files"] = [];
 
-                {
-                    const srcDirPath = pathJoin(dirPath, KEYCLOAK_THEME);
-
-                    await crawlAsync({
-                        dirPath: srcDirPath,
-                        returnedPathsType: "relative to dirPath",
-                        onFileFound: async fileRelativePath => {
-                            const sourceCode =
-                                await getExtensionModuleFileSourceCodeReadyToBeCopied({
-                                    buildContext,
-                                    fileRelativePath,
-                                    isOwnershipAction: false,
-                                    extensionModuleDirPath: dirPath,
-                                    extensionModuleName: moduleName,
-                                    extensionModuleVersion: version
-                                });
-
-                            const hash = computeHash(sourceCode);
-
-                            const copyableFilePath = pathJoin(
-                                pathDirname(cacheFilePath),
-                                KEYCLOAK_THEME,
-                                fileRelativePath
-                            );
-
-                            {
-                                const dirPath = pathDirname(copyableFilePath);
-
-                                if (!(await existsAsync(dirPath))) {
-                                    await fsPr.mkdir(dirPath, { recursive: true });
-                                }
-                            }
+                await crawlAsync({
+                    dirPath: pathJoin(dirPath, KEYCLOAK_THEME),
+                    returnedPathsType: "relative to dirPath",
+                    onFileFound: async fileRelativePath_fromReservedDir => {
+                        const isPublic = fileRelativePath_fromReservedDir.startsWith(
+                            `public${pathSep}`
+                        );
 
-                            fsPr.writeFile(copyableFilePath, sourceCode);
+                        const fileRelativePath = isPublic
+                            ? pathRelative("public", fileRelativePath_fromReservedDir)
+                            : fileRelativePath_fromReservedDir;
 
-                            files.push({
+                        const sourceCode =
+                            await getExtensionModuleFileSourceCodeReadyToBeCopied({
+                                buildContext,
+                                isPublic,
                                 fileRelativePath,
-                                hash,
-                                copyableFilePath
+                                isOwnershipAction: false,
+                                extensionModuleDirPath: dirPath,
+                                extensionModuleName: moduleName,
+                                extensionModuleVersion: version
                             });
+
+                        const hash = computeHash(sourceCode);
+
+                        const copyableFilePath = pathJoin(
+                            pathDirname(cacheFilePath),
+                            KEYCLOAK_THEME,
+                            fileRelativePath_fromReservedDir
+                        );
+
+                        {
+                            const dirPath = pathDirname(copyableFilePath);
+
+                            if (!(await existsAsync(dirPath))) {
+                                await fsPr.mkdir(dirPath, { recursive: true });
+                            }
                         }
-                    });
-                }
+
+                        fsPr.writeFile(copyableFilePath, sourceCode);
+
+                        files.push({
+                            isPublic,
+                            fileRelativePath,
+                            hash,
+                            copyableFilePath
+                        });
+                    }
+                });
 
                 return id<ExtensionModuleMeta>({
                     moduleName,