keycloakify 10.0.0-rc.9 → 10.0.0-rc.91

package/src/bin/shared/promptKeycloakVersion.ts

@@ -7,19 +7,27 @@ import * as fs from "fs";
 import type { ReturnType } from "tsafe";
 import { id } from "tsafe/id";
 
-export async function promptKeycloakVersion(params: { startingFromMajor: number | undefined; cacheDirPath: string }) {
-    const { startingFromMajor, cacheDirPath } = params;
+export async function promptKeycloakVersion(params: {
+    startingFromMajor: number | undefined;
+    excludeMajorVersions: number[];
+    cacheDirPath: string;
+}) {
+    const { startingFromMajor, excludeMajorVersions, cacheDirPath } = params;
 
     const { getLatestsSemVersionedTag } = (() => {
         const { octokit } = (() => {
             const githubToken = process.env.GITHUB_TOKEN;
 
-            const octokit = new Octokit(githubToken === undefined ? undefined : { "auth": githubToken });
+            const octokit = new Octokit(
+                githubToken === undefined ? undefined : { auth: githubToken }
+            );
 
             return { octokit };
         })();
 
-        const { getLatestsSemVersionedTag } = getLatestsSemVersionedTagFactory({ octokit });
+        const { getLatestsSemVersionedTag } = getLatestsSemVersionedTagFactory({
+            octokit
+        });
 
         return { getLatestsSemVersionedTag };
     })();
@@ -39,7 +47,9 @@ export async function promptKeycloakVersion(params: { startingFromMajor: number
                 break use_cache;
             }
 
-            const cache: Cache = JSON.parse(fs.readFileSync(cacheFilePath).toString("utf8"));
+            const cache: Cache = JSON.parse(
+                fs.readFileSync(cacheFilePath).toString("utf8")
+            );
 
             if (Date.now() - cache.time > 3_600_000) {
                 fs.unlinkSync(cacheFilePath);
@@ -50,16 +60,16 @@ export async function promptKeycloakVersion(params: { startingFromMajor: number
         }
 
         const semVersionedTags = await getLatestsSemVersionedTag({
-            "count": 50,
-            "owner": "keycloak",
-            "repo": "keycloak"
+            count: 50,
+            owner: "keycloak",
+            repo: "keycloak"
         });
 
         {
             const dirPath = pathDirname(cacheFilePath);
 
             if (!fs.existsSync(dirPath)) {
-                fs.mkdirSync(dirPath, { "recursive": true });
+                fs.mkdirSync(dirPath, { recursive: true });
             }
         }
 
@@ -67,7 +77,7 @@ export async function promptKeycloakVersion(params: { startingFromMajor: number
             cacheFilePath,
             JSON.stringify(
                 id<Cache>({
-                    "time": Date.now(),
+                    time: Date.now(),
                     semVersionedTags
                 }),
                 null,
@@ -79,23 +89,37 @@ export async function promptKeycloakVersion(params: { startingFromMajor: number
     })();
 
     semVersionedTags.forEach(semVersionedTag => {
-        if (startingFromMajor !== undefined && semVersionedTag.version.major < startingFromMajor) {
+        if (
+            startingFromMajor !== undefined &&
+            semVersionedTag.version.major < startingFromMajor
+        ) {
             return;
         }
 
-        const currentSemVersionedTag = semVersionedTagByMajor.get(semVersionedTag.version.major);
+        if (excludeMajorVersions.includes(semVersionedTag.version.major)) {
+            return;
+        }
+
+        const currentSemVersionedTag = semVersionedTagByMajor.get(
+            semVersionedTag.version.major
+        );
 
-        if (currentSemVersionedTag !== undefined && SemVer.compare(semVersionedTag.version, currentSemVersionedTag.version) === -1) {
+        if (
+            currentSemVersionedTag !== undefined &&
+            SemVer.compare(semVersionedTag.version, currentSemVersionedTag.version) === -1
+        ) {
             return;
         }
 
         semVersionedTagByMajor.set(semVersionedTag.version.major, semVersionedTag);
     });
 
-    const lastMajorVersions = Array.from(semVersionedTagByMajor.values()).map(({ tag }) => tag);
+    const lastMajorVersions = Array.from(semVersionedTagByMajor.values()).map(
+        ({ tag }) => tag
+    );
 
     const { value } = await cliSelect<string>({
-        "values": lastMajorVersions
+        values: lastMajorVersions
     }).catch(() => {
         process.exit(-1);
     });

package/src/bin/start-keycloak/appBuild.ts

@@ -0,0 +1,169 @@
+import * as child_process from "child_process";
+import { Deferred } from "evt/tools/Deferred";
+import { assert } from "tsafe/assert";
+import type { BuildContext } from "../shared/buildContext";
+import chalk from "chalk";
+import { sep as pathSep, join as pathJoin } from "path";
+
+export type BuildContextLike = {
+    projectDirPath: string;
+    keycloakifyBuildDirPath: string;
+    bundler: BuildContext["bundler"];
+    projectBuildDirPath: string;
+};
+
+assert<BuildContext extends BuildContextLike ? true : false>();
+
+export async function appBuild(params: {
+    buildContext: BuildContextLike;
+}): Promise<{ isAppBuildSuccess: boolean }> {
+    const { buildContext } = params;
+
+    switch (buildContext.bundler.type) {
+        case "vite":
+            return appBuild_vite({ buildContext });
+        case "webpack":
+            return appBuild_webpack({ buildContext });
+    }
+}
+
+async function appBuild_vite(params: {
+    buildContext: BuildContextLike;
+}): Promise<{ isAppBuildSuccess: boolean }> {
+    const { buildContext } = params;
+
+    assert(buildContext.bundler.type === "vite");
+
+    const dResult = new Deferred<{ isSuccess: boolean }>();
+
+    const child = child_process.spawn("npx", ["vite", "build"], {
+        cwd: buildContext.projectDirPath,
+        shell: true
+    });
+
+    child.stdout.on("data", data => {
+        if (data.toString("utf8").includes("gzip:")) {
+            return;
+        }
+
+        process.stdout.write(data);
+    });
+
+    child.stderr.on("data", data => process.stderr.write(data));
+
+    child.on("exit", code => dResult.resolve({ isSuccess: code === 0 }));
+
+    const { isSuccess } = await dResult.pr;
+
+    return { isAppBuildSuccess: isSuccess };
+}
+
+async function appBuild_webpack(params: {
+    buildContext: BuildContextLike;
+}): Promise<{ isAppBuildSuccess: boolean }> {
+    const { buildContext } = params;
+
+    assert(buildContext.bundler.type === "webpack");
+
+    const entries = Object.entries(buildContext.bundler.packageJsonScripts).filter(
+        ([, scriptCommand]) => scriptCommand.includes("keycloakify build")
+    );
+
+    if (entries.length === 0) {
+        console.log(
+            chalk.red(
+                [
+                    `You should have a script in your package.json at ${buildContext.bundler.packageJsonDirPath}`,
+                    `that includes the 'keycloakify build' command`
+                ].join(" ")
+            )
+        );
+        process.exit(-1);
+    }
+
+    const entry =
+        entries.length === 1
+            ? entries[0]
+            : entries.find(([scriptName]) => scriptName === "build-keycloak-theme");
+
+    if (entry === undefined) {
+        console.log(
+            chalk.red(
+                "There's multiple candidate script for building your app, name one 'build-keycloak-theme'"
+            )
+        );
+        process.exit(-1);
+    }
+
+    const [scriptName, scriptCommand] = entry;
+
+    const { appBuildSubCommands } = (() => {
+        const appBuildSubCommands: string[] = [];
+
+        for (const subCmd of scriptCommand.split("&&").map(s => s.trim())) {
+            if (subCmd.includes("keycloakify build")) {
+                break;
+            }
+
+            appBuildSubCommands.push(subCmd);
+        }
+
+        return { appBuildSubCommands };
+    })();
+
+    if (appBuildSubCommands.length === 0) {
+        console.log(
+            chalk.red(
+                `Your ${scriptName} script should look like "... && keycloakify build ..."`
+            )
+        );
+        process.exit(-1);
+    }
+
+    for (const subCommand of appBuildSubCommands) {
+        const dIsSuccess = new Deferred<boolean>();
+
+        child_process.exec(
+            subCommand,
+            {
+                cwd: buildContext.bundler.packageJsonDirPath,
+                env: {
+                    ...process.env,
+                    PATH: (() => {
+                        const separator = pathSep === "/" ? ":" : ";";
+
+                        return [
+                            pathJoin(
+                                buildContext.bundler.packageJsonDirPath,
+                                "node_modules",
+                                ".bin"
+                            ),
+                            ...(process.env.PATH ?? "").split(separator)
+                        ].join(separator);
+                    })()
+                }
+            },
+            (error, stdout, stderr) => {
+                if (error) {
+                    dIsSuccess.resolve(false);
+
+                    console.log(chalk.red(`Error running: '${subCommand}'`));
+                    console.log(stdout);
+                    console.log(stderr);
+
+                    return;
+                }
+
+                dIsSuccess.resolve(true);
+            }
+        );
+
+        const isSuccess = await dIsSuccess.pr;
+
+        if (!isSuccess) {
+            return { isAppBuildSuccess: false };
+        }
+    }
+
+    return { isAppBuildSuccess: true };
+}

package/src/bin/start-keycloak/index.ts

@@ -0,0 +1 @@
+export * from "./start-keycloak";

package/src/bin/start-keycloak/keycloakifyBuild.ts

@@ -0,0 +1,40 @@
+import { buildForKeycloakMajorVersionEnvName } from "../shared/constants";
+import * as child_process from "child_process";
+import { Deferred } from "evt/tools/Deferred";
+import { assert } from "tsafe/assert";
+import type { BuildContext } from "../shared/buildContext";
+
+export type BuildContextLike = {
+    projectDirPath: string;
+    keycloakifyBuildDirPath: string;
+};
+
+assert<BuildContext extends BuildContextLike ? true : false>();
+
+export async function keycloakifyBuild(params: {
+    buildForKeycloakMajorVersionNumber: number;
+    buildContext: BuildContextLike;
+}): Promise<{ isKeycloakifyBuildSuccess: boolean }> {
+    const { buildForKeycloakMajorVersionNumber, buildContext } = params;
+
+    const dResult = new Deferred<{ isSuccess: boolean }>();
+
+    const child = child_process.spawn("npx", ["keycloakify", "build"], {
+        cwd: buildContext.projectDirPath,
+        env: {
+            ...process.env,
+            [buildForKeycloakMajorVersionEnvName]: `${buildForKeycloakMajorVersionNumber}`
+        },
+        shell: true
+    });
+
+    child.stdout.on("data", data => process.stdout.write(data));
+
+    child.stderr.on("data", data => process.stderr.write(data));
+
+    child.on("exit", code => dResult.resolve({ isSuccess: code === 0 }));
+
+    const { isSuccess } = await dResult.pr;
+
+    return { isKeycloakifyBuildSuccess: isSuccess };
+}