keycloakify 11.6.0 → 11.6.2

package/src/bin/tools/npmInstall.ts

@@ -9,8 +9,9 @@ import { objectKeys } from "tsafe/objectKeys";
 import { getAbsoluteAndInOsFormatPath } from "./getAbsoluteAndInOsFormatPath";
 import { exclude } from "tsafe/exclude";
 import { rmSync } from "./fs.rmSync";
+import { Deferred } from "evt/tools/Deferred";
 
-export function npmInstall(params: { packageJsonDirPath: string }) {
+export async function npmInstall(params: { packageJsonDirPath: string }) {
     const { packageJsonDirPath } = params;
 
     const packageManagerBinName = (() => {
@@ -68,7 +69,7 @@ export function npmInstall(params: { packageJsonDirPath: string }) {
 
         console.log(chalk.green("Installing in a way that won't break the links..."));
 
-        installWithoutBreakingLinks({
+        await installWithoutBreakingLinks({
             packageJsonDirPath,
             garronejLinkInfos
         });
@@ -77,9 +78,9 @@ export function npmInstall(params: { packageJsonDirPath: string }) {
     }
 
     try {
-        child_process.execSync(`${packageManagerBinName} install`, {
-            cwd: packageJsonDirPath,
-            stdio: "inherit"
+        await runPackageManagerInstall({
+            packageManagerBinName,
+            cwd: packageJsonDirPath
         });
     } catch {
         console.log(
@@ -90,6 +91,42 @@ export function npmInstall(params: { packageJsonDirPath: string }) {
     }
 }
 
+async function runPackageManagerInstall(params: {
+    packageManagerBinName: string;
+    cwd: string;
+}) {
+    const { packageManagerBinName, cwd } = params;
+
+    const dCompleted = new Deferred<void>();
+
+    const child = child_process.spawn(packageManagerBinName, ["install"], {
+        cwd,
+        env: process.env,
+        shell: true
+    });
+
+    child.stdout.on("data", data => process.stdout.write(data));
+
+    child.stderr.on("data", data => {
+        if (data.toString("utf8").includes("peer dependency")) {
+            return;
+        }
+
+        process.stderr.write(data);
+    });
+
+    child.on("exit", code => {
+        if (code !== 0) {
+            dCompleted.reject(new Error(`Failed with code ${code}`));
+            return;
+        }
+
+        dCompleted.resolve();
+    });
+
+    await dCompleted.pr;
+}
+
 function getGarronejLinkInfos(params: {
     packageJsonDirPath: string;
 }): { linkedModuleNames: string[]; yarnHomeDirPath: string } | undefined {
@@ -180,7 +217,7 @@ function getGarronejLinkInfos(params: {
     return { linkedModuleNames, yarnHomeDirPath };
 }
 
-function installWithoutBreakingLinks(params: {
+async function installWithoutBreakingLinks(params: {
     packageJsonDirPath: string;
     garronejLinkInfos: Exclude<ReturnType<typeof getGarronejLinkInfos>, undefined>;
 }) {
@@ -261,9 +298,9 @@ function installWithoutBreakingLinks(params: {
         pathJoin(tmpProjectDirPath, YARN_LOCK)
     );
 
-    child_process.execSync(`yarn install`, {
-        cwd: tmpProjectDirPath,
-        stdio: "inherit"
+    await runPackageManagerInstall({
+        packageManagerBinName: "yarn",
+        cwd: tmpProjectDirPath
     });
 
     // NOTE: Moving the modules from the tmp project to the actual project

package/src/bin/tools/untrackFromGit.ts

@@ -1,15 +1,31 @@
 import * as child_process from "child_process";
-import { dirname as pathDirname, basename as pathBasename } from "path";
+import {
+    dirname as pathDirname,
+    basename as pathBasename,
+    join as pathJoin,
+    sep as pathSep
+} from "path";
 import { Deferred } from "evt/tools/Deferred";
+import { existsAsync } from "./fs.existsAsync";
 
 export async function untrackFromGit(params: { filePath: string }): Promise<void> {
     const { filePath } = params;
 
     const dDone = new Deferred<void>();
 
+    let relativePath = pathBasename(filePath);
+
+    let dirPath = pathDirname(filePath);
+
+    while (!(await existsAsync(dirPath))) {
+        relativePath = pathJoin(pathBasename(dirPath), relativePath);
+
+        dirPath = pathDirname(dirPath);
+    }
+
     child_process.exec(
-        `git rm --cached ${pathBasename(filePath)}`,
-        { cwd: pathDirname(filePath) },
+        `git rm --cached '${relativePath.split(pathSep).join("/")}'`,
+        { cwd: dirPath },
         error => {
             if (error !== null) {
                 dDone.reject(error);