keycloakify 10.0.0-rc.8 → 10.0.0-rc.80

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,129 @@
+import * as child_process from "child_process";
+import { Deferred } from "evt/tools/Deferred";
+import { assert } from "tsafe/assert";
+import { is } from "tsafe/is";
+import type { BuildContext } from "../shared/buildContext";
+import * as fs from "fs";
+import { join as pathJoin } from "path";
+
+export type BuildContextLike = {
+    projectDirPath: string;
+    keycloakifyBuildDirPath: string;
+    bundler: "vite" | "webpack";
+    npmWorkspaceRootDirPath: string;
+    projectBuildDirPath: string;
+};
+
+assert<BuildContext extends BuildContextLike ? true : false>();
+
+export async function appBuild(params: {
+    buildContext: BuildContextLike;
+}): Promise<{ isAppBuildSuccess: boolean }> {
+    const { buildContext } = params;
+
+    const { bundler } = buildContext;
+
+    const { command, args, cwd } = (() => {
+        switch (bundler) {
+            case "vite":
+                return {
+                    command: "npx",
+                    args: ["vite", "build"],
+                    cwd: buildContext.projectDirPath
+                };
+            case "webpack": {
+                for (const dirPath of [
+                    buildContext.projectDirPath,
+                    buildContext.npmWorkspaceRootDirPath
+                ]) {
+                    try {
+                        const parsedPackageJson = JSON.parse(
+                            fs
+                                .readFileSync(pathJoin(dirPath, "package.json"))
+                                .toString("utf8")
+                        );
+
+                        const [scriptName] =
+                            Object.entries(parsedPackageJson.scripts).find(
+                                ([, scriptValue]) => {
+                                    assert(is<string>(scriptValue));
+                                    if (
+                                        scriptValue.includes("webpack") &&
+                                        scriptValue.includes("--mode production")
+                                    ) {
+                                        return true;
+                                    }
+
+                                    if (
+                                        scriptValue.includes("react-scripts") &&
+                                        scriptValue.includes("build")
+                                    ) {
+                                        return true;
+                                    }
+
+                                    if (
+                                        scriptValue.includes("react-app-rewired") &&
+                                        scriptValue.includes("build")
+                                    ) {
+                                        return true;
+                                    }
+
+                                    if (
+                                        scriptValue.includes("craco") &&
+                                        scriptValue.includes("build")
+                                    ) {
+                                        return true;
+                                    }
+
+                                    if (
+                                        scriptValue.includes("ng") &&
+                                        scriptValue.includes("build")
+                                    ) {
+                                        return true;
+                                    }
+
+                                    return false;
+                                }
+                            ) ?? [];
+
+                        if (scriptName === undefined) {
+                            continue;
+                        }
+
+                        return {
+                            command: "npm",
+                            args: ["run", scriptName],
+                            cwd: dirPath
+                        };
+                    } catch {
+                        continue;
+                    }
+                }
+
+                throw new Error(
+                    "Keycloakify was unable to determine which script is responsible for building the app."
+                );
+            }
+        }
+    })();
+
+    const dResult = new Deferred<{ isSuccess: boolean }>();
+
+    const child = child_process.spawn(command, args, { cwd, 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 };
+}

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

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

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

@@ -0,0 +1,42 @@
+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;
+    bundler: "vite" | "webpack";
+    npmWorkspaceRootDirPath: 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 };
+}