keycloakify 7.16.0-rc.0 → 8.0.0-rc.0

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

@@ -12,46 +12,20 @@ import { downloadKeycloakStaticResources } from "./downloadKeycloakStaticResourc
 import { readFieldNameUsage } from "./readFieldNameUsage";
 import { readExtraPagesNames } from "./readExtraPageNames";
 import { generateMessageProperties } from "./generateMessageProperties";
-import { accountV1Keycloak } from "../generateJavaStackFiles/generateJavaStackFiles";
-
-export type BuildOptionsLike = BuildOptionsLike.Standalone | BuildOptionsLike.ExternalAssets;
-
-export namespace BuildOptionsLike {
-    export type Common = {
-        themeName: string;
-        extraThemeProperties: string[] | undefined;
-        isSilent: boolean;
-        themeVersion: string;
-        keycloakVersionDefaultAssets: string;
-    };
-
-    export type Standalone = Common & {
-        isStandalone: true;
-        urlPathname: string | undefined;
-    };
-
-    export type ExternalAssets = ExternalAssets.SameDomain | ExternalAssets.DifferentDomains;
-
-    export namespace ExternalAssets {
-        export type CommonExternalAssets = Common & {
-            isStandalone: false;
-        };
-
-        export type SameDomain = CommonExternalAssets & {
-            areAppAndKeycloakServerSharingSameDomain: true;
-        };
-
-        export type DifferentDomains = CommonExternalAssets & {
-            areAppAndKeycloakServerSharingSameDomain: false;
-            urlOrigin: string;
-            urlPathname: string | undefined;
-        };
-    }
-}
+import { readStaticResourcesUsage } from "./readStaticResourcesUsage";
+
+export type BuildOptionsLike = {
+    themeName: string;
+    extraThemeProperties: string[] | undefined;
+    themeVersion: string;
+    keycloakVersionDefaultAssets: string;
+    urlPathname: string | undefined;
+};
 
 assert<BuildOptions extends BuildOptionsLike ? true : false>();
 
 export async function generateTheme(params: {
+    projectDirPath: string;
     reactAppBuildDirPath: string;
     keycloakThemeBuildingDirPath: string;
     themeSrcDirPath: string;
@@ -59,7 +33,15 @@ export async function generateTheme(params: {
     buildOptions: BuildOptionsLike;
     keycloakifyVersion: string;
 }): Promise<void> {
-    const { reactAppBuildDirPath, keycloakThemeBuildingDirPath, themeSrcDirPath, keycloakifySrcDirPath, buildOptions, keycloakifyVersion } = params;
+    const {
+        projectDirPath,
+        reactAppBuildDirPath,
+        keycloakThemeBuildingDirPath,
+        themeSrcDirPath,
+        keycloakifySrcDirPath,
+        buildOptions,
+        keycloakifyVersion
+    } = params;
 
     const getThemeDirPath = (themeType: ThemeType | "email") =>
         pathJoin(keycloakThemeBuildingDirPath, "src", "main", "resources", "theme", buildOptions.themeName, themeType);
@@ -78,17 +60,16 @@ export async function generateTheme(params: {
         copy_app_resources_to_theme_path: {
             const isFirstPass = themeType.indexOf(themeType) === 0;
 
-            if (!isFirstPass && !buildOptions.isStandalone) {
+            if (!isFirstPass) {
                 break copy_app_resources_to_theme_path;
             }
 
             transformCodebase({
-                "destDirPath": buildOptions.isStandalone ? pathJoin(themeDirPath, "resources", "build") : reactAppBuildDirPath,
+                "destDirPath": pathJoin(themeDirPath, "resources", "build"),
                 "srcDirPath": reactAppBuildDirPath,
                 "transformSourceCode": ({ filePath, sourceCode }) => {
                     //NOTE: Prevent cycles, excludes the folder we generated for debug in public/
                     if (
-                        buildOptions.isStandalone &&
                         isInside({
                             "dirPath": pathJoin(reactAppBuildDirPath, basenameOfKeycloakDirInPublicDir),
                             filePath
@@ -98,10 +79,6 @@ export async function generateTheme(params: {
                     }
 
                     if (/\.css?$/i.test(filePath)) {
-                        if (!buildOptions.isStandalone) {
-                            return undefined;
-                        }
-
                         const { cssGlobalsToDefine, fixedCssCode } = replaceImportsInCssCode({
                             "cssCode": sourceCode.toString("utf8")
                         });
@@ -121,19 +98,14 @@ export async function generateTheme(params: {
                     }
 
                     if (/\.js?$/i.test(filePath)) {
-                        if (!buildOptions.isStandalone && buildOptions.areAppAndKeycloakServerSharingSameDomain) {
-                            return undefined;
-                        }
-
                         const { fixedJsCode } = replaceImportsFromStaticInJsCode({
-                            "jsCode": sourceCode.toString("utf8"),
-                            buildOptions
+                            "jsCode": sourceCode.toString("utf8")
                         });
 
                         return { "modifiedSourceCode": Buffer.from(fixedJsCode, "utf8") };
                     }
 
-                    return buildOptions.isStandalone ? { "modifiedSourceCode": sourceCode } : undefined;
+                    return { "modifiedSourceCode": sourceCode };
                 }
             });
         }
@@ -198,10 +170,11 @@ export async function generateTheme(params: {
             }
 
             await downloadKeycloakStaticResources({
-                "isSilent": buildOptions.isSilent,
+                projectDirPath,
                 "keycloakVersion": buildOptions.keycloakVersionDefaultAssets,
                 "themeDirPath": keycloakDirInPublicDir,
-                themeType
+                themeType,
+                "usedResources": undefined
             });
 
             if (themeType !== themeTypes[0]) {
@@ -223,28 +196,20 @@ export async function generateTheme(params: {
         }
 
         await downloadKeycloakStaticResources({
-            "isSilent": buildOptions.isSilent,
+            projectDirPath,
             "keycloakVersion": buildOptions.keycloakVersionDefaultAssets,
             themeDirPath,
-            themeType
+            themeType,
+            "usedResources": readStaticResourcesUsage({
+                keycloakifySrcDirPath,
+                themeSrcDirPath,
+                themeType
+            })
         });
 
         fs.writeFileSync(
             pathJoin(themeDirPath, "theme.properties"),
-            Buffer.from(
-                [
-                    `parent=${(() => {
-                        switch (themeType) {
-                            case "login":
-                                return "keycloak";
-                            case "account":
-                                return accountV1Keycloak;
-                        }
-                    })()}`,
-                    ...(buildOptions.extraThemeProperties ?? [])
-                ].join("\n\n"),
-                "utf8"
-            )
+            Buffer.from([`parent=keycloak`, ...(buildOptions.extraThemeProperties ?? [])].join("\n\n"), "utf8")
         );
     }
 

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

@@ -3,7 +3,6 @@ import { removeDuplicates } from "evt/tools/reducers/removeDuplicates";
 import { join as pathJoin } from "path";
 import * as fs from "fs";
 import type { ThemeType } from "../generateFtl";
-import { exclude } from "tsafe/exclude";
 
 /** Assumes the theme type exists */
 export function readFieldNameUsage(params: { keycloakifySrcDirPath: string; themeSrcDirPath: string; themeType: ThemeType }): string[] {
@@ -11,9 +10,7 @@ export function readFieldNameUsage(params: { keycloakifySrcDirPath: string; them
 
     const fieldNames: string[] = [];
 
-    for (const srcDirPath of ([pathJoin(keycloakifySrcDirPath, themeType), pathJoin(themeSrcDirPath, themeType)] as const).filter(
-        exclude(undefined)
-    )) {
+    for (const srcDirPath of [pathJoin(keycloakifySrcDirPath, themeType), pathJoin(themeSrcDirPath, themeType)]) {
         const filePaths = crawl({ "dirPath": srcDirPath, "returnedPathsType": "absolute" }).filter(filePath => /\.(ts|tsx|js|jsx)$/.test(filePath));
 
         for (const filePath of filePaths) {

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

@@ -0,0 +1,83 @@
+import { crawl } from "../../tools/crawl";
+import { join as pathJoin } from "path";
+import * as fs from "fs";
+import type { ThemeType } from "../generateFtl";
+
+/** Assumes the theme type exists */
+export function readStaticResourcesUsage(params: { keycloakifySrcDirPath: string; themeSrcDirPath: string; themeType: ThemeType }): {
+    resourcesCommonFilePaths: string[];
+    resourcesFilePaths: string[];
+} {
+    const { keycloakifySrcDirPath, themeSrcDirPath, themeType } = params;
+
+    const resourcesCommonFilePaths = new Set<string>();
+    const resourcesFilePaths = new Set<string>();
+
+    for (const srcDirPath of [pathJoin(keycloakifySrcDirPath, themeType), pathJoin(themeSrcDirPath, themeType)]) {
+        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");
+
+            if (!rawSourceFile.includes("resourcesCommonPath") && !rawSourceFile.includes("resourcesPath")) {
+                continue;
+            }
+
+            const wrap = readPaths({ rawSourceFile });
+
+            wrap.resourcesCommonFilePaths.forEach(filePath => resourcesCommonFilePaths.add(filePath));
+            wrap.resourcesFilePaths.forEach(filePath => resourcesFilePaths.add(filePath));
+        }
+    }
+
+    return {
+        "resourcesCommonFilePaths": Array.from(resourcesCommonFilePaths),
+        "resourcesFilePaths": Array.from(resourcesFilePaths)
+    };
+}
+
+/** Exported for testing purpose */
+export function readPaths(params: { rawSourceFile: string }): {
+    resourcesCommonFilePaths: string[];
+    resourcesFilePaths: string[];
+} {
+    const { rawSourceFile } = params;
+
+    const resourcesCommonFilePaths = new Set<string>();
+    const resourcesFilePaths = new Set<string>();
+
+    for (const isCommon of [true, false]) {
+        const set = isCommon ? resourcesCommonFilePaths : resourcesFilePaths;
+
+        {
+            const regexp = new RegExp(`resources${isCommon ? "Common" : ""}Path\\s*}([^\`]+)\``, "g");
+
+            const matches = [...rawSourceFile.matchAll(regexp)];
+
+            for (const match of matches) {
+                const filePath = match[1];
+
+                set.add(filePath);
+            }
+        }
+
+        {
+            const regexp = new RegExp(`resources${isCommon ? "Common" : ""}Path\\s*[+,]\\s*["']([^"'\`]+)["'\`]`, "g");
+
+            const matches = [...rawSourceFile.matchAll(regexp)];
+
+            for (const match of matches) {
+                const filePath = match[1];
+
+                set.add(filePath);
+            }
+        }
+    }
+
+    const removePrefixSlash = (filePath: string) => (filePath.startsWith("/") ? filePath.slice(1) : filePath);
+
+    return {
+        "resourcesCommonFilePaths": Array.from(resourcesCommonFilePaths).map(removePrefixSlash),
+        "resourcesFilePaths": Array.from(resourcesFilePaths).map(removePrefixSlash)
+    };
+}

package/src/bin/keycloakify/keycloakify.ts

@@ -30,6 +30,7 @@ export async function main() {
 
     for (const themeName of [buildOptions.themeName, ...buildOptions.extraThemeNames]) {
         await generateTheme({
+            projectDirPath,
             "keycloakThemeBuildingDirPath": buildOptions.keycloakifyBuildDirPath,
             themeSrcDirPath,
             "keycloakifySrcDirPath": pathJoin(keycloakifyDirPath, "src"),
@@ -48,7 +49,7 @@ export async function main() {
         });
     }
 
-    const { jarFilePath } = await generateJavaStackFiles({
+    const { jarFilePath } = generateJavaStackFiles({
         "keycloakThemeBuildingDirPath": buildOptions.keycloakifyBuildDirPath,
         "implementedThemeTypes": (() => {
             const implementedThemeTypes = {

package/src/bin/keycloakify/replacers/replaceImportsFromStaticInJsCode.ts

@@ -1,31 +1,6 @@
 import { ftlValuesGlobalName } from "../ftlValuesGlobalName";
-import type { BuildOptions } from "../BuildOptions";
-import { assert } from "tsafe/assert";
-import { is } from "tsafe/is";
-import { Reflect } from "tsafe/Reflect";
 
-export type BuildOptionsLike = BuildOptionsLike.Standalone | BuildOptionsLike.ExternalAssets;
-
-export namespace BuildOptionsLike {
-    export type Standalone = {
-        isStandalone: true;
-    };
-
-    export type ExternalAssets = {
-        isStandalone: false;
-        urlOrigin: string;
-    };
-}
-
-{
-    const buildOptions = Reflect<BuildOptions>();
-
-    assert(!is<BuildOptions.ExternalAssets.CommonExternalAssets>(buildOptions));
-
-    assert<typeof buildOptions extends BuildOptionsLike ? true : false>();
-}
-
-export function replaceImportsFromStaticInJsCode(params: { jsCode: string; buildOptions: BuildOptionsLike }): { fixedJsCode: string } {
+export function replaceImportsFromStaticInJsCode(params: { jsCode: string }): { fixedJsCode: string } {
     /* 
 	NOTE:
 
@@ -38,7 +13,7 @@ export function replaceImportsFromStaticInJsCode(params: { jsCode: string; build
 	will always run in keycloak context.
 	*/
 
-    const { jsCode, buildOptions } = params;
+    const { jsCode } = params;
 
     const getReplaceArgs = (language: "js" | "css"): Parameters<typeof String.prototype.replace> => [
         new RegExp(`([a-zA-Z_]+)\\.([a-zA-Z]+)=function\\(([a-zA-Z]+)\\){return"static\\/${language}\\/"`, "g"),
@@ -46,40 +21,23 @@ export function replaceImportsFromStaticInJsCode(params: { jsCode: string; build
 			${n}[(function(){
                 var pd= Object.getOwnPropertyDescriptor(${n}, "p");
                 if( pd === undefined || pd.configurable ){
-                ${
-                    buildOptions.isStandalone
-                        ? `
-                        Object.defineProperty(${n}, "p", {
-                            get: function() { return window.${ftlValuesGlobalName}.url.resourcesPath; },
-                            set: function (){}
-                        });
-                    `
-                        : `
-                    var p= "";
                     Object.defineProperty(${n}, "p", {
-                        get: function() { return "${ftlValuesGlobalName}" in window ? "${buildOptions.urlOrigin}/" : p; },
-                        set: function (value){ p = value;}
+                        get: function() { return window.${ftlValuesGlobalName}.url.resourcesPath; },
+                        set: function (){}
                     });
-                    `
-                }
                 }
 				return "${u}";
-			})()] = function(${e}) { return "${buildOptions.isStandalone ? "/build/" : ""}static/${language}/"`
+			})()] = function(${e}) { return "${true ? "/build/" : ""}static/${language}/"`
     ];
 
     const fixedJsCode = jsCode
         .replace(...getReplaceArgs("js"))
         .replace(...getReplaceArgs("css"))
-        .replace(/([a-zA-Z]+\.[a-zA-Z]+)\+"static\//g, (...[, group]) =>
-            buildOptions.isStandalone
-                ? `window.${ftlValuesGlobalName}.url.resourcesPath + "/build/static/`
-                : `("${ftlValuesGlobalName}" in window ? "${buildOptions.urlOrigin}/" : ${group}) + "static/`
-        )
+        .replace(/[a-zA-Z]+\.[a-zA-Z]+\+"static\//g, `window.${ftlValuesGlobalName}.url.resourcesPath + "/build/static/`)
         //TODO: Write a test case for this
-        .replace(/".chunk.css",([a-zA-Z])+=([a-zA-Z]+\.[a-zA-Z]+)\+([a-zA-Z]+),/, (...[, group1, group2, group3]) =>
-            buildOptions.isStandalone
-                ? `".chunk.css",${group1} = window.${ftlValuesGlobalName}.url.resourcesPath + "/build/" + ${group3},`
-                : `".chunk.css",${group1} = ("${ftlValuesGlobalName}" in window ? "${buildOptions.urlOrigin}/" : ${group2}) + ${group3},`
+        .replace(
+            /".chunk.css",([a-zA-Z])+=[a-zA-Z]+\.[a-zA-Z]+\+([a-zA-Z]+),/,
+            (...[, group1, group2]) => `".chunk.css",${group1} = window.${ftlValuesGlobalName}.url.resourcesPath + "/build/" + ${group2},`
         );
 
     return { fixedJsCode };

package/src/bin/keycloakify/replacers/replaceImportsInCssCode.ts

@@ -1,20 +1,12 @@
 import * as crypto from "crypto";
 import type { BuildOptions } from "../BuildOptions";
 import { assert } from "tsafe/assert";
-import { is } from "tsafe/is";
-import { Reflect } from "tsafe/Reflect";
 
 export type BuildOptionsLike = {
     urlPathname: string | undefined;
 };
 
-{
-    const buildOptions = Reflect<BuildOptions>();
-
-    assert(!is<BuildOptions.ExternalAssets.CommonExternalAssets>(buildOptions));
-
-    assert<typeof buildOptions extends BuildOptionsLike ? true : false>();
-}
+assert<BuildOptions extends BuildOptionsLike ? true : false>();
 
 export function replaceImportsInCssCode(params: { cssCode: string }): {
     fixedCssCode: string;

package/src/bin/keycloakify/replacers/replaceImportsInInlineCssCode.ts

@@ -1,32 +1,11 @@
 import type { BuildOptions } from "../BuildOptions";
 import { assert } from "tsafe/assert";
-import { is } from "tsafe/is";
-import { Reflect } from "tsafe/Reflect";
 
-export type BuildOptionsLike = BuildOptionsLike.Standalone | BuildOptionsLike.ExternalAssets;
+export type BuildOptionsLike = {
+    urlPathname: string | undefined;
+};
 
-export namespace BuildOptionsLike {
-    export type Common = {
-        urlPathname: string | undefined;
-    };
-
-    export type Standalone = Common & {
-        isStandalone: true;
-    };
-
-    export type ExternalAssets = Common & {
-        isStandalone: false;
-        urlOrigin: string;
-    };
-}
-
-{
-    const buildOptions = Reflect<BuildOptions>();
-
-    assert(!is<BuildOptions.ExternalAssets.CommonExternalAssets>(buildOptions));
-
-    assert<typeof buildOptions extends BuildOptionsLike ? true : false>();
-}
+assert<BuildOptions extends BuildOptionsLike ? true : false>();
 
 export function replaceImportsInInlineCssCode(params: { cssCode: string; buildOptions: BuildOptionsLike }): {
     fixedCssCode: string;
@@ -37,10 +16,7 @@ export function replaceImportsInInlineCssCode(params: { cssCode: string; buildOp
         buildOptions.urlPathname === undefined
             ? /url\(["']?\/([^/][^)"']+)["']?\)/g
             : new RegExp(`url\\(["']?${buildOptions.urlPathname}([^)"']+)["']?\\)`, "g"),
-        (...[, group]) =>
-            `url(${
-                buildOptions.isStandalone ? "${url.resourcesPath}/build/" + group : buildOptions.urlOrigin + (buildOptions.urlPathname ?? "/") + group
-            })`
+        (...[, group]) => `url(\${url.resourcesPath}/build/${group})`
     );
 
     return { fixedCssCode };

package/src/bin/tools/downloadAndUnzip.ts

@@ -1,18 +1,55 @@
 import { exec as execCallback } from "child_process";
 import { createHash } from "crypto";
-import { mkdir, readFile, stat, writeFile } from "fs/promises";
+import { mkdir, readFile, stat, writeFile, unlink, rm } from "fs/promises";
 import fetch, { type FetchOptions } from "make-fetch-happen";
 import { dirname as pathDirname, join as pathJoin, resolve as pathResolve, sep as pathSep } from "path";
 import { assert } from "tsafe/assert";
 import { promisify } from "util";
-import { getProjectRoot } from "./getProjectRoot";
 import { transformCodebase } from "./transformCodebase";
-import { unzip } from "./unzip";
+import { unzip, zip } from "./unzip";
 
 const exec = promisify(execCallback);
 
-function hash(s: string) {
-    return createHash("sha256").update(s).digest("hex");
+function generateFileNameFromURL(params: {
+    url: string;
+    preCacheTransform:
+        | {
+              actionCacheId: string;
+              actionFootprint: string;
+          }
+        | undefined;
+}): string {
+    const { preCacheTransform } = params;
+
+    // Parse the URL
+    const url = new URL(params.url);
+
+    // Extract pathname and remove leading slashes
+    let fileName = url.pathname.replace(/^\//, "").replace(/\//g, "_");
+
+    // Optionally, add query parameters replacing special characters
+    if (url.search) {
+        fileName += url.search.replace(/[&=?]/g, "-");
+    }
+
+    // Replace any characters that are not valid in filenames
+    fileName = fileName.replace(/[^a-zA-Z0-9-_]/g, "");
+
+    // Trim or pad the fileName to a specific length
+    fileName = fileName.substring(0, 50);
+
+    add_pre_cache_transform: {
+        if (preCacheTransform === undefined) {
+            break add_pre_cache_transform;
+        }
+
+        // Sanitize actionCacheId the same way as other components
+        const sanitizedActionCacheId = preCacheTransform.actionCacheId.replace(/[^a-zA-Z0-9-_]/g, "_");
+
+        fileName += `_${sanitizedActionCacheId}_${createHash("sha256").update(preCacheTransform.actionFootprint).digest("hex").substring(0, 5)}`;
+    }
+
+    return fileName;
 }
 
 async function exists(path: string) {
@@ -57,8 +94,6 @@ function readNpmConfig(): Promise<string> {
         try {
             stdout = await exec("npm config get", { "encoding": "utf8", cwd }).then(({ stdout }) => stdout);
         } catch (error) {
-            console.log(String(error), error);
-
             if (String(error).includes("ENOWORKSPACES")) {
                 assert(cwd !== pathSep);
 
@@ -115,14 +150,43 @@ async function getFetchOptions(): Promise<Pick<FetchOptions, "proxy" | "noProxy"
     return { proxy, noProxy, strictSSL, cert, ca: ca.length === 0 ? undefined : ca };
 }
 
-export async function downloadAndUnzip(params: { url: string; destDirPath: string; pathOfDirToExtractInArchive?: string }) {
-    const { url, destDirPath, pathOfDirToExtractInArchive } = params;
+export async function downloadAndUnzip(
+    params: {
+        url: string;
+        destDirPath: string;
+        specificDirsToExtract?: string[];
+        preCacheTransform?: {
+            actionCacheId: string;
+            action: (params: { destDirPath: string }) => Promise<void>;
+        };
+    } & (
+        | {
+              doUseCache: true;
+              projectDirPath: string;
+          }
+        | {
+              doUseCache: false;
+          }
+    )
+) {
+    const { url, destDirPath, specificDirsToExtract, preCacheTransform, ...rest } = params;
+
+    const zipFileBasename = generateFileNameFromURL({
+        url,
+        "preCacheTransform":
+            preCacheTransform === undefined
+                ? undefined
+                : {
+                      "actionCacheId": preCacheTransform.actionCacheId,
+                      "actionFootprint": preCacheTransform.action.toString()
+                  }
+    });
 
-    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}`);
+    const cacheRoot = !rest.doUseCache
+        ? `tmp_${Math.random().toString().slice(2, 12)}`
+        : pathJoin(process.env.XDG_CACHE_HOME ?? pathJoin(rest.projectDirPath, "node_modules", ".cache"), "keycloakify");
+    const zipFilePath = pathJoin(cacheRoot, `${zipFileBasename}.zip`);
+    const extractDirPath = pathJoin(cacheRoot, `tmp_unzip_${zipFileBasename}`);
 
     if (!(await exists(zipFilePath))) {
         const opts = await getFetchOptions();
@@ -138,12 +202,32 @@ export async function downloadAndUnzip(params: { url: string; destDirPath: strin
         response.body?.setMaxListeners(Number.MAX_VALUE);
         assert(typeof response.body !== "undefined" && response.body != null);
         await writeFile(zipFilePath, response.body);
+
+        if (specificDirsToExtract !== undefined || preCacheTransform !== undefined) {
+            await unzip(zipFilePath, extractDirPath, specificDirsToExtract);
+
+            await preCacheTransform?.action({
+                "destDirPath": extractDirPath
+            });
+
+            await unlink(zipFilePath);
+
+            await zip(extractDirPath, zipFilePath);
+
+            await rm(extractDirPath, { "recursive": true });
+        }
     }
 
-    await unzip(zipFilePath, extractDirPath, pathOfDirToExtractInArchive);
+    await unzip(zipFilePath, extractDirPath);
 
     transformCodebase({
         "srcDirPath": extractDirPath,
         "destDirPath": destDirPath
     });
+
+    if (!rest.doUseCache) {
+        await rm(cacheRoot, { "recursive": true });
+    } else {
+        await rm(extractDirPath, { "recursive": true });
+    }
 }

package/src/bin/tools/transformCodebase.ts

@@ -3,7 +3,7 @@ import * as path from "path";
 import { crawl } from "./crawl";
 import { id } from "tsafe/id";
 
-type TransformSourceCode = (params: { sourceCode: Buffer; filePath: string }) =>
+type TransformSourceCode = (params: { sourceCode: Buffer; filePath: string; fileRelativePath: string }) =>
     | {
           modifiedSourceCode: Buffer;
           newFileName?: string;
@@ -20,26 +20,27 @@ export function transformCodebase(params: { srcDirPath: string; destDirPath: str
         }))
     } = params;
 
-    for (const file_relative_path of crawl({ "dirPath": srcDirPath, "returnedPathsType": "relative to dirPath" })) {
-        const filePath = path.join(srcDirPath, file_relative_path);
+    for (const fileRelativePath of crawl({ "dirPath": srcDirPath, "returnedPathsType": "relative to dirPath" })) {
+        const filePath = path.join(srcDirPath, fileRelativePath);
 
         const transformSourceCodeResult = transformSourceCode({
             "sourceCode": fs.readFileSync(filePath),
-            filePath
+            filePath,
+            fileRelativePath
         });
 
         if (transformSourceCodeResult === undefined) {
             continue;
         }
 
-        fs.mkdirSync(path.dirname(path.join(destDirPath, file_relative_path)), {
+        fs.mkdirSync(path.dirname(path.join(destDirPath, fileRelativePath)), {
             "recursive": true
         });
 
         const { newFileName, modifiedSourceCode } = transformSourceCodeResult;
 
         fs.writeFileSync(
-            path.join(path.dirname(path.join(destDirPath, file_relative_path)), newFileName ?? path.basename(file_relative_path)),
+            path.join(path.dirname(path.join(destDirPath, fileRelativePath)), newFileName ?? path.basename(fileRelativePath)),
             modifiedSourceCode
         );
     }