keycloakify 9.3.1 → 9.4.0-rc.1

package/src/bin/promptKeycloakVersion.ts

@@ -23,7 +23,6 @@ export async function promptKeycloakVersion() {
     const tags = [
         ...(await getLatestsSemVersionedTag({
             "count": 10,
-            "doIgnoreBeta": true,
             "owner": "keycloak",
             "repo": "keycloak"
         }).then(arr => arr.map(({ tag }) => tag))),

package/src/bin/tools/OptionalIfCanBeUndefined.ts

@@ -0,0 +1,12 @@
+type PropertiesThatCanBeUndefined<T extends Record<string, unknown>> = {
+    [Key in keyof T]: undefined extends T[Key] ? Key : never;
+}[keyof T];
+
+/**
+ * 	OptionalIfCanBeUndefined<{ p1: string | undefined; p2: string; }>
+ *  is
+ * 	{ p1?: string | undefined; p2: string }
+ */
+export type OptionalIfCanBeUndefined<T extends Record<string, unknown>> = {
+    [K in PropertiesThatCanBeUndefined<T>]?: T[K];
+} & { [K in Exclude<keyof T, PropertiesThatCanBeUndefined<T>>]: T[K] };

package/src/bin/tools/SemVer.ts

@@ -0,0 +1,99 @@
+export type SemVer = {
+    major: number;
+    minor: number;
+    patch: number;
+    rc?: number;
+    parsedFrom: string;
+};
+
+export namespace SemVer {
+    const bumpTypes = ["major", "minor", "patch", "rc", "no bump"] as const;
+
+    export type BumpType = (typeof bumpTypes)[number];
+
+    export function parse(versionStr: string): SemVer {
+        const match = versionStr.match(/^v?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-rc.([0-9]+))?$/);
+
+        if (!match) {
+            throw new Error(`${versionStr} is not a valid semantic version`);
+        }
+
+        const semVer: Omit<SemVer, "parsedFrom"> = {
+            "major": parseInt(match[1]),
+            "minor": parseInt(match[2]),
+            "patch": (() => {
+                const str = match[3];
+
+                return str === undefined ? 0 : parseInt(str);
+            })(),
+            ...(() => {
+                const str = match[4];
+                return str === undefined ? {} : { "rc": parseInt(str) };
+            })()
+        };
+
+        const initialStr = stringify(semVer);
+
+        Object.defineProperty(semVer, "parsedFrom", {
+            "enumerable": true,
+            "get": function () {
+                const currentStr = stringify(this);
+
+                if (currentStr !== initialStr) {
+                    throw new Error(`SemVer.parsedFrom can't be read anymore, the version have been modified from ${initialStr} to ${currentStr}`);
+                }
+
+                return versionStr;
+            }
+        });
+
+        return semVer as any;
+    }
+
+    export function stringify(v: Omit<SemVer, "parsedFrom">): string {
+        return `${v.major}.${v.minor}.${v.patch}${v.rc === undefined ? "" : `-rc.${v.rc}`}`;
+    }
+
+    /**
+     *
+     * v1  <  v2  => -1
+     * v1 === v2  => 0
+     * v1  >  v2  => 1
+     *
+     */
+    export function compare(v1: SemVer, v2: SemVer): -1 | 0 | 1 {
+        const sign = (diff: number): -1 | 0 | 1 => (diff === 0 ? 0 : diff < 0 ? -1 : 1);
+        const noUndefined = (n: number | undefined) => n ?? Infinity;
+
+        for (const level of ["major", "minor", "patch", "rc"] as const) {
+            if (noUndefined(v1[level]) !== noUndefined(v2[level])) {
+                return sign(noUndefined(v1[level]) - noUndefined(v2[level]));
+            }
+        }
+
+        return 0;
+    }
+
+    /*
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0-rc.4")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("4.0.0")) === -1 )
+    */
+
+    export function bumpType(params: { versionBehind: string | SemVer; versionAhead: string | SemVer }): BumpType | "no bump" {
+        const versionAhead = typeof params.versionAhead === "string" ? parse(params.versionAhead) : params.versionAhead;
+        const versionBehind = typeof params.versionBehind === "string" ? parse(params.versionBehind) : params.versionBehind;
+
+        if (compare(versionBehind, versionAhead) === 1) {
+            throw new Error(`Version regression ${stringify(versionBehind)} -> ${stringify(versionAhead)}`);
+        }
+
+        for (const level of ["major", "minor", "patch", "rc"] as const) {
+            if (versionBehind[level] !== versionAhead[level]) {
+                return level;
+            }
+        }
+
+        return "no bump";
+    }
+}

package/src/bin/tools/String.prototype.replaceAll.ts

@@ -0,0 +1,30 @@
+export function replaceAll(string: string, searchValue: string | RegExp, replaceValue: string): string {
+    if ((string as any).replaceAll !== undefined) {
+        return (string as any).replaceAll(searchValue, replaceValue);
+    }
+
+    // If the searchValue is a string
+    if (typeof searchValue === "string") {
+        // Escape special characters in the string to be used in a regex
+        var escapedSearchValue = searchValue.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        var regex = new RegExp(escapedSearchValue, "g");
+
+        return string.replace(regex, replaceValue);
+    }
+
+    // If the searchValue is a global RegExp, use it directly
+    if (searchValue instanceof RegExp && searchValue.global) {
+        return string.replace(searchValue, replaceValue);
+    }
+
+    // If the searchValue is a non-global RegExp, throw an error
+    if (searchValue instanceof RegExp) {
+        throw new TypeError("replaceAll must be called with a global RegExp");
+    }
+
+    // Convert searchValue to string if it's not a string or RegExp
+    var searchString = String(searchValue);
+    var regexFromString = new RegExp(searchString.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g");
+
+    return string.replace(regexFromString, replaceValue);
+}

package/src/bin/tools/crawl.ts

@@ -1,17 +1,17 @@
 import * as fs from "fs";
-import * as path from "path";
+import { join as pathJoin, relative as pathRelative } from "path";
 
-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);
+const crawlRec = (dirPath: string, filePaths: string[]) => {
+    for (const basename of fs.readdirSync(dirPath)) {
+        const fileOrDirPath = pathJoin(dirPath, basename);
 
-        if (fs.lstatSync(file_path).isDirectory()) {
-            crawlRec(file_path, paths);
+        if (fs.lstatSync(fileOrDirPath).isDirectory()) {
+            crawlRec(fileOrDirPath, filePaths);
 
             continue;
         }
 
-        paths.push(file_path);
+        filePaths.push(fileOrDirPath);
     }
 };
 
@@ -27,6 +27,6 @@ export function crawl(params: { dirPath: string; returnedPathsType: "absolute" |
         case "absolute":
             return filePaths;
         case "relative to dirPath":
-            return filePaths.map(filePath => path.relative(dirPath, filePath));
+            return filePaths.map(filePath => pathRelative(dirPath, filePath));
     }
 }

package/src/bin/tools/downloadAndUnzip.ts

@@ -1,12 +1,14 @@
 import { exec as execCallback } from "child_process";
 import { createHash } from "crypto";
-import { mkdir, readFile, stat, writeFile, unlink, rm } from "fs/promises";
+import { mkdir, readFile, stat, writeFile, unlink } 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 { dirname as pathDirname, join as pathJoin, resolve as pathResolve, sep as pathSep, basename as pathBasename } from "path";
 import { assert } from "tsafe/assert";
 import { promisify } from "util";
 import { transformCodebase } from "./transformCodebase";
 import { unzip, zip } from "./unzip";
+import { rm } from "../tools/fs.rm";
+import * as child_process from "child_process";
 
 const exec = promisify(execCallback);
 
@@ -187,10 +189,31 @@ export async function downloadAndUnzip(
     const zipFilePath = pathJoin(cacheDirPath, `${zipFileBasename}.zip`);
     const extractDirPath = pathJoin(cacheDirPath, `tmp_unzip_${zipFileBasename}`);
 
-    if (!(await exists(zipFilePath))) {
+    download_zip_and_transform: {
+        if (await exists(zipFilePath)) {
+            break download_zip_and_transform;
+        }
+
         const opts = await getFetchOptions();
-        const response = await fetch(url, opts);
+
+        const { response, isFromRemoteCache } = await (async () => {
+            const response = await fetch(`https://github.com/keycloakify/keycloakify/releases/download/v0.0.1/${pathBasename(zipFilePath)}`, opts);
+
+            if (response.status === 200) {
+                return {
+                    response,
+                    "isFromRemoteCache": true
+                };
+            }
+
+            return {
+                "response": await fetch(url, opts),
+                "isFromRemoteCache": false
+            };
+        })();
+
         await mkdir(pathDirname(zipFilePath), { "recursive": true });
+
         /**
          * The correct way to fix this is to upgrade node-fetch beyond 3.2.5
          * (see https://github.com/node-fetch/node-fetch/issues/1295#issuecomment-1144061991.)
@@ -200,20 +223,66 @@ export async function downloadAndUnzip(
          */
         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);
+        if (isFromRemoteCache) {
+            break download_zip_and_transform;
+        }
 
+        if (specificDirsToExtract === undefined && preCacheTransform === undefined) {
+            break download_zip_and_transform;
+        }
+
+        await unzip(zipFilePath, extractDirPath, specificDirsToExtract);
+
+        try {
             await preCacheTransform?.action({
                 "destDirPath": extractDirPath
             });
+        } catch (error) {
+            await Promise.all([rm(extractDirPath, { "recursive": true }), unlink(zipFilePath)]);
+
+            throw error;
+        }
 
-            await unlink(zipFilePath);
+        await unlink(zipFilePath);
+
+        await zip(extractDirPath, zipFilePath);
+
+        await rm(extractDirPath, { "recursive": true });
 
-            await zip(extractDirPath, zipFilePath);
+        upload_to_remot_cache_if_admin: {
+            const githubToken = process.env["KEYCLOAKIFY_ADMIN_GITHUB_PERSONAL_ACCESS_TOKEN"];
 
-            await rm(extractDirPath, { "recursive": true });
+            if (githubToken === undefined) {
+                break upload_to_remot_cache_if_admin;
+            }
+
+            console.log("uploading to remote cache");
+
+            try {
+                child_process.execSync(`which putasset`);
+            } catch {
+                child_process.execSync(`npm install -g putasset`);
+            }
+
+            try {
+                child_process.execFileSync("putasset", [
+                    "--owner",
+                    "keycloakify",
+                    "--repo",
+                    "keycloakify",
+                    "--tag",
+                    "v0.0.1",
+                    "--filename",
+                    zipFilePath,
+                    "--token",
+                    githubToken
+                ]);
+            } catch {
+                console.log("upload failed, asset probably already exists in remote cache");
+            }
         }
     }
 

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

@@ -0,0 +1,43 @@
+import * as fs from "fs/promises";
+import { join as pathJoin } from "path";
+import { SemVer } from "./SemVer";
+
+/**
+ * Polyfill of fs.rm(dirPath, { "recursive": true })
+ * For older version of Node
+ */
+export async function rm(dirPath: string, options: { recursive: true; force?: true }) {
+    if (SemVer.compare(SemVer.parse(process.version), SemVer.parse("14.14.0")) > 0) {
+        return fs.rm(dirPath, options);
+    }
+
+    const { force = true } = options;
+
+    if (force && !(await checkDirExists(dirPath))) {
+        return;
+    }
+
+    const removeDir_rec = async (dirPath: string) =>
+        Promise.all(
+            (await fs.readdir(dirPath)).map(async basename => {
+                const fileOrDirpath = pathJoin(dirPath, basename);
+
+                if ((await fs.lstat(fileOrDirpath)).isDirectory()) {
+                    await removeDir_rec(fileOrDirpath);
+                } else {
+                    await fs.unlink(fileOrDirpath);
+                }
+            })
+        );
+
+    await removeDir_rec(dirPath);
+}
+
+async function checkDirExists(dirPath: string) {
+    try {
+        await fs.access(dirPath, fs.constants.F_OK);
+        return true;
+    } catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,34 @@
+import * as fs from "fs";
+import { join as pathJoin } from "path";
+import { SemVer } from "./SemVer";
+
+/**
+ * Polyfill of fs.rmSync(dirPath, { "recursive": true })
+ * For older version of Node
+ */
+export function rmSync(dirPath: string, options: { recursive: true; force?: true }) {
+    if (SemVer.compare(SemVer.parse(process.version), SemVer.parse("14.14.0")) > 0) {
+        fs.rmSync(dirPath, options);
+        return;
+    }
+
+    const { force = true } = options;
+
+    if (force && !fs.existsSync(dirPath)) {
+        return;
+    }
+
+    const removeDir_rec = (dirPath: string) =>
+        fs.readdirSync(dirPath).forEach(basename => {
+            const fileOrDirpath = pathJoin(dirPath, basename);
+
+            if (fs.lstatSync(fileOrDirpath).isDirectory()) {
+                removeDir_rec(fileOrDirpath);
+                return;
+            } else {
+                fs.unlinkSync(fileOrDirpath);
+            }
+        });
+
+    removeDir_rec(dirPath);
+}

package/src/bin/tools/getAbsoluteAndInOsFormatPath.ts

@@ -7,6 +7,8 @@ export function getAbsoluteAndInOsFormatPath(params: { pathIsh: string; cwd: str
 
     pathOut = pathOut.replace(/\//g, pathSep);
 
+    pathOut = pathOut.endsWith(pathSep) ? pathOut.slice(0, -1) : pathOut;
+
     if (!pathIsAbsolute(pathOut)) {
         pathOut = pathJoin(cwd, pathOut);
     }

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

@@ -1,39 +1,39 @@
 import { listTagsFactory } from "./listTags";
 import type { Octokit } from "@octokit/rest";
-import { NpmModuleVersion } from "../NpmModuleVersion";
+import { SemVer } from "../SemVer";
 
 export function getLatestsSemVersionedTagFactory(params: { octokit: Octokit }) {
     const { octokit } = params;
 
-    async function getLatestsSemVersionedTag(params: { owner: string; repo: string; doIgnoreBeta: boolean; count: number }): Promise<
+    async function getLatestsSemVersionedTag(params: { owner: string; repo: string; count: number }): Promise<
         {
             tag: string;
-            version: NpmModuleVersion;
+            version: SemVer;
         }[]
     > {
-        const { owner, repo, doIgnoreBeta, count } = params;
+        const { owner, repo, count } = params;
 
-        const semVersionedTags: { tag: string; version: NpmModuleVersion }[] = [];
+        const semVersionedTags: { tag: string; version: SemVer }[] = [];
 
         const { listTags } = listTagsFactory({ octokit });
 
         for await (const tag of listTags({ owner, repo })) {
-            let version: NpmModuleVersion;
+            let version: SemVer;
 
             try {
-                version = NpmModuleVersion.parse(tag.replace(/^[vV]?/, ""));
+                version = SemVer.parse(tag.replace(/^[vV]?/, ""));
             } catch {
                 continue;
             }
 
-            if (doIgnoreBeta && version.betaPreRelease !== undefined) {
+            if (version.rc !== undefined) {
                 continue;
             }
 
             semVersionedTags.push({ tag, version });
         }
 
-        return semVersionedTags.sort(({ version: vX }, { version: vY }) => NpmModuleVersion.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/transformCodebase.ts

@@ -1,7 +1,7 @@
 import * as fs from "fs";
 import * as path from "path";
 import { crawl } from "./crawl";
-import { id } from "tsafe/id";
+import { rmSync } from "../tools/fs.rmSync";
 
 type TransformSourceCode = (params: { sourceCode: Buffer; filePath: string; fileRelativePath: string }) =>
     | {
@@ -10,18 +10,36 @@ type TransformSourceCode = (params: { sourceCode: Buffer; filePath: string; file
       }
     | undefined;
 
-/** Apply a transformation function to every file of directory */
+/**
+ * Apply a transformation function to every file of directory
+ * 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 }) {
-    const {
-        srcDirPath,
-        destDirPath,
-        transformSourceCode = id<TransformSourceCode>(({ sourceCode }) => ({
-            "modifiedSourceCode": sourceCode
-        }))
-    } = params;
+    const { srcDirPath, transformSourceCode } = params;
+    let { destDirPath } = params;
+
+    const isTargetSameAsSource = path.relative(srcDirPath, destDirPath) === "";
+
+    if (isTargetSameAsSource) {
+        destDirPath = path.join(srcDirPath, "..", "tmp_xOsPdkPsTdzPs34sOkHs");
+    }
 
     for (const fileRelativePath of crawl({ "dirPath": srcDirPath, "returnedPathsType": "relative to dirPath" })) {
         const filePath = path.join(srcDirPath, fileRelativePath);
+        const destFilePath = path.join(destDirPath, fileRelativePath);
+
+        // NOTE: Optimization, if we don't need to transform the file, just copy
+        // it using the lower level implementation.
+        if (transformSourceCode === undefined) {
+            fs.mkdirSync(path.dirname(destFilePath), {
+                "recursive": true
+            });
+
+            fs.copyFileSync(filePath, destFilePath);
+
+            continue;
+        }
 
         const transformSourceCodeResult = transformSourceCode({
             "sourceCode": fs.readFileSync(filePath),
@@ -33,15 +51,18 @@ export function transformCodebase(params: { srcDirPath: string; destDirPath: str
             continue;
         }
 
-        fs.mkdirSync(path.dirname(path.join(destDirPath, fileRelativePath)), {
+        fs.mkdirSync(path.dirname(destFilePath), {
             "recursive": true
         });
 
         const { newFileName, modifiedSourceCode } = transformSourceCodeResult;
 
-        fs.writeFileSync(
-            path.join(path.dirname(path.join(destDirPath, fileRelativePath)), newFileName ?? path.basename(fileRelativePath)),
-            modifiedSourceCode
-        );
+        fs.writeFileSync(path.join(path.dirname(destFilePath), newFileName ?? path.basename(destFilePath)), modifiedSourceCode);
+    }
+
+    if (isTargetSameAsSource) {
+        rmSync(srcDirPath, { "recursive": true });
+
+        fs.renameSync(destDirPath, srcDirPath);
     }
 }

package/src/login/kcContext/getKcContextFromWindow.ts

@@ -1,11 +1,11 @@
 import type { KcContext } from "./KcContext";
 import type { AndByDiscriminatingKey } from "keycloakify/tools/AndByDiscriminatingKey";
-import { ftlValuesGlobalName } from "keycloakify/bin/keycloakify/ftlValuesGlobalName";
+import { nameOfTheGlobal } from "keycloakify/bin/constants";
 
 export type ExtendKcContext<KcContextExtension extends { pageId: string }> = [KcContextExtension] extends [never]
     ? KcContext
     : AndByDiscriminatingKey<"pageId", KcContextExtension & KcContext.Common, KcContext>;
 
 export function getKcContextFromWindow<KcContextExtension extends { pageId: string } = never>(): ExtendKcContext<KcContextExtension> | undefined {
-    return typeof window === "undefined" ? undefined : (window as any)[ftlValuesGlobalName];
+    return typeof window === "undefined" ? undefined : (window as any)[nameOfTheGlobal];
 }

package/src/tsconfig.json

@@ -14,7 +14,7 @@
         "jsx": "react-jsx",
         "allowSyntheticDefaultImports": true
     },
-    "exclude": ["./bin"],
+    "exclude": ["./bin", "./vite-plugin"],
     "references": [
         {
             "path": "./bin"