@simplysm/sd-cli 7.0.263 → 7.0.266

package/src/build-tool/SdCliIndexFileGenerator.ts

@@ -1,80 +1,79 @@
-import { ITsconfig } from "../commons";
-import path from "path";
-import { FsUtil, PathUtil } from "@simplysm/sd-core-node";
-import os from "os";
-import chokidar from "chokidar";
-
-export class SdCliIndexFileGenerator {
-  private readonly _indexFilePath = path.resolve(this.rootPath, "src/index.ts");
-  private _contentCache: string | undefined;
-
-  public constructor(public readonly rootPath: string,
-                     public readonly config: ISdAutoIndexConfig) {
-    this._contentCache = FsUtil.exists(this._indexFilePath) ? FsUtil.readFile(this._indexFilePath) : undefined;
-  }
-
-  public async watchAsync(): Promise<void> {
-    const watcher = chokidar.watch([path.resolve(this.rootPath, "src")], { persistent: true });
-    watcher.on("add", async (filePath) => {
-      if (filePath.endsWith(".ts")) {
-        await this.runAsync();
-      }
-    });
-    watcher.on("unlink", async (filePath) => {
-      if (filePath.endsWith(".ts")) {
-        await this.runAsync();
-      }
-    });
-
-    await this.runAsync();
-  }
-
-  public async runAsync(): Promise<void> {
-    const importTexts: string[] = [];
-
-    // 옵션의 polyfills 를 모두 import
-    if (this.config.polyfills) {
-      for (const polyfill of this.config.polyfills) {
-        importTexts.push(`import "${polyfill}";`);
-      }
-    }
-
-    // 내부 파일들 import
-    const filePaths = await this._getFilePathsAsync();
-    for (const filePath of filePaths) {
-      const requirePath = PathUtil.posix(path.relative(path.dirname(this._indexFilePath), filePath))
-        .replace(/\.ts$/, "")
-        .replace(/\/index$/, "");
-
-      const sourceTsFileContent = await FsUtil.readFileAsync(filePath);
-      if (sourceTsFileContent.split("\n").some((line) => line.startsWith("export "))) {
-        importTexts.push(`export * from "./${requirePath}";`);
-      }
-      else {
-        importTexts.push(`import "./${requirePath}";`);
-      }
-    }
-
-    const content = importTexts.join(os.EOL) + os.EOL;
-    const prevContent = this._contentCache;
-    this._contentCache = content;
-    if (content.trim() !== prevContent?.trim()) {
-      await FsUtil.writeFileAsync(this._indexFilePath, content);
-    }
-  }
-
-  private async _getFilePathsAsync(): Promise<string[]> {
-    const tsconfig: ITsconfig = await FsUtil.readJsonAsync(path.resolve(this.rootPath, "tsconfig.json"));
-    const entryFilePaths = tsconfig.files?.map((item) => path.resolve(this.rootPath, item)) ?? [];
-
-    return (await FsUtil.globAsync(path.resolve(this.rootPath, "src/**/*.ts"), { nodir: true }))
-      .filter((item) => (
-        !entryFilePaths.includes(item)
-        && item !== this._indexFilePath
-      ));
-  }
-}
-
-export interface ISdAutoIndexConfig {
-  polyfills?: string[];
-}
+import { ITsconfig } from "../commons";
+import path from "path";
+import { FsUtil, PathUtil } from "@simplysm/sd-core-node";
+import chokidar from "chokidar";
+
+export class SdCliIndexFileGenerator {
+  private readonly _indexFilePath = path.resolve(this.rootPath, "src/index.ts");
+  private _contentCache: string | undefined;
+
+  public constructor(public readonly rootPath: string,
+                     public readonly config: ISdAutoIndexConfig) {
+    this._contentCache = FsUtil.exists(this._indexFilePath) ? FsUtil.readFile(this._indexFilePath) : undefined;
+  }
+
+  public async watchAsync(): Promise<void> {
+    const watcher = chokidar.watch([path.resolve(this.rootPath, "src")], { persistent: true });
+    watcher.on("add", async (filePath) => {
+      if (filePath.endsWith(".ts")) {
+        await this.runAsync();
+      }
+    });
+    watcher.on("unlink", async (filePath) => {
+      if (filePath.endsWith(".ts")) {
+        await this.runAsync();
+      }
+    });
+
+    await this.runAsync();
+  }
+
+  public async runAsync(): Promise<void> {
+    const importTexts: string[] = [];
+
+    // 옵션의 polyfills 를 모두 import
+    if (this.config.polyfills) {
+      for (const polyfill of this.config.polyfills) {
+        importTexts.push(`import "${polyfill}";`);
+      }
+    }
+
+    // 내부 파일들 import
+    const filePaths = await this._getFilePathsAsync();
+    for (const filePath of filePaths) {
+      const requirePath = PathUtil.posix(path.relative(path.dirname(this._indexFilePath), filePath))
+        .replace(/\.ts$/, "")
+        .replace(/\/index$/, "");
+
+      const sourceTsFileContent = await FsUtil.readFileAsync(filePath);
+      if (sourceTsFileContent.split("\n").some((line) => line.startsWith("export "))) {
+        importTexts.push(`export * from "./${requirePath}";`);
+      }
+      else {
+        importTexts.push(`import "./${requirePath}";`);
+      }
+    }
+
+    const content = importTexts.join("\n") + "\n";
+    const prevContent = this._contentCache;
+    this._contentCache = content;
+    if (content.trim() !== prevContent?.trim()) {
+      await FsUtil.writeFileAsync(this._indexFilePath, content);
+    }
+  }
+
+  private async _getFilePathsAsync(): Promise<string[]> {
+    const tsconfig: ITsconfig = await FsUtil.readJsonAsync(path.resolve(this.rootPath, "tsconfig.json"));
+    const entryFilePaths = tsconfig.files?.map((item) => path.resolve(this.rootPath, item)) ?? [];
+
+    return (await FsUtil.globAsync(path.resolve(this.rootPath, "src/**/*.ts"), { nodir: true }))
+      .filter((item) => (
+        !entryFilePaths.includes(item)
+        && item !== this._indexFilePath
+      ));
+  }
+}
+
+export interface ISdAutoIndexConfig {
+  polyfills?: string[];
+}

package/src/build-tool/SdCliNgCacheCompilerHost.ts

@@ -1,58 +1,58 @@
-import ts from "typescript";
-import { PathUtil } from "@simplysm/sd-core-node";
-import sass from "sass";
-import { fileURLToPath, pathToFileURL, URL } from "url";
-
-export class SdCliNgCacheCompilerHost {
-  public static wrap(compilerHost: ts.CompilerHost,
-                     sourceFileCache: Map<string, IFileCache>): ts.CompilerHost {
-    const cacheCompilerHost = { ...compilerHost };
-
-    cacheCompilerHost["readResource"] = (fileName: string) => {
-      const cache = sourceFileCache.getOrCreate(PathUtil.posix(fileName), {});
-      if (cache.content === undefined) {
-        cache.content = compilerHost.readFile.call(cacheCompilerHost, fileName);
-      }
-      return cache.content;
-    };
-
-    cacheCompilerHost["transformResource"] = async (data, context) => {
-      if (context.resourceFile != null || context.type !== "style") {
-        return null;
-      }
-
-      const cache = sourceFileCache.getOrCreate(PathUtil.posix(context.containingFile), {});
-      if (cache.styleContent === undefined) {
-        const scssResult = await sass.compileStringAsync(data, {
-          url: new URL((context.containingFile as string) + ".sd.scss"),
-          importer: {
-            findFileUrl: (url) => {
-              if (!url.startsWith("~")) return pathToFileURL(url);
-              return new URL(url.substring(1), pathToFileURL("node_modules"));
-            }
-          }
-        });
-
-        cache.styleContent = scssResult.css.toString();
-
-        const deps = scssResult.loadedUrls.slice(1).map((item) => PathUtil.posix(fileURLToPath(item.href)));
-        for (const dep of deps) {
-          const depCache = sourceFileCache.getOrCreate(dep, {});
-          depCache.importerSet = depCache.importerSet ?? new Set<string>();
-          depCache.importerSet.add(PathUtil.posix(context.containingFile));
-        }
-      }
-      return { content: cache.styleContent };
-    };
-
-    return cacheCompilerHost;
-  }
-}
-
-interface IFileCache {
-  exists?: boolean;
-  sourceFile?: ts.SourceFile;
-  content?: string;
-  styleContent?: string;
-  importerSet?: Set<string>;
-}
+import ts from "typescript";
+import { PathUtil } from "@simplysm/sd-core-node";
+import sass from "sass";
+import { fileURLToPath, pathToFileURL, URL } from "url";
+
+export class SdCliNgCacheCompilerHost {
+  public static wrap(compilerHost: ts.CompilerHost,
+                     sourceFileCache: Map<string, IFileCache>): ts.CompilerHost {
+    const cacheCompilerHost = { ...compilerHost };
+
+    cacheCompilerHost["readResource"] = (fileName: string) => {
+      const cache = sourceFileCache.getOrCreate(PathUtil.posix(fileName), {});
+      if (cache.content === undefined) {
+        cache.content = compilerHost.readFile.call(cacheCompilerHost, fileName);
+      }
+      return cache.content;
+    };
+
+    cacheCompilerHost["transformResource"] = async (data, context) => {
+      if (context.resourceFile != null || context.type !== "style") {
+        return null;
+      }
+
+      const cache = sourceFileCache.getOrCreate(PathUtil.posix(context.containingFile), {});
+      if (cache.styleContent === undefined) {
+        const scssResult = await sass.compileStringAsync(data, {
+          url: new URL((context.containingFile as string) + ".sd.scss"),
+          importer: {
+            findFileUrl: (url) => {
+              if (!url.startsWith("~")) return pathToFileURL(url);
+              return new URL(url.substring(1), pathToFileURL("node_modules"));
+            }
+          }
+        });
+
+        cache.styleContent = scssResult.css.toString();
+
+        const deps = scssResult.loadedUrls.slice(1).map((item) => PathUtil.posix(fileURLToPath(item.href)));
+        for (const dep of deps) {
+          const depCache = sourceFileCache.getOrCreate(dep, {});
+          depCache.importerSet = depCache.importerSet ?? new Set<string>();
+          depCache.importerSet.add(PathUtil.posix(context.containingFile));
+        }
+      }
+      return { content: cache.styleContent };
+    };
+
+    return cacheCompilerHost;
+  }
+}
+
+interface IFileCache {
+  exists?: boolean;
+  sourceFile?: ts.SourceFile;
+  content?: string;
+  styleContent?: string;
+  importerSet?: Set<string>;
+}

package/src/build-tool/SdCliPackageLinter.ts

@@ -1,74 +1,74 @@
-import { ISdCliPackageBuildResult } from "../commons";
-import ts from "typescript";
-import { FsUtil } from "@simplysm/sd-core-node";
-import path from "path";
-import { ESLint } from "eslint";
-
-export class SdCliPackageLinter {
-  private readonly _lintResultCache = new Map<string, ISdCliPackageBuildResult[]>();
-
-  public constructor(private readonly _rootPath: string) {
-  }
-
-  public async lintAsync(filePaths: string[], program?: ts.Program): Promise<ISdCliPackageBuildResult[]> {
-    if (!FsUtil.exists(path.resolve(this._rootPath, ".eslintrc.cjs"))) return [];
-
-    const linter = new ESLint(
-      program && filePaths.some((item) => item.endsWith(".ts")) ? {
-        overrideConfig: {
-          overrides: [
-            {
-              files: ["*.ts"],
-              parserOptions: {
-                /*programs: [program],
-                tsconfigRootDir: null,
-                project: null*/
-                tsconfigRootDir: this._rootPath,
-                project: "tsconfig-build.json"
-              },
-              settings: {
-                "import/resolver": {
-                  "typescript": {
-                    /*programs: [program],
-                    project: null*/
-                    project: path.resolve(this._rootPath, "tsconfig-build.json")
-                  }
-                }
-              }
-            }
-          ]
-        }
-      } : {}
-    );
-
-    const lintFilePaths = await filePaths
-      .filterAsync(async (filePath) => (
-        !filePath.endsWith(".d.ts") &&
-        /\.[cm]?[tj]sx?$/.test(filePath) &&
-        !(await linter.isPathIgnored(filePath))
-      ));
-    for (const lintFilePath of lintFilePaths) {
-      this._lintResultCache.delete(lintFilePath);
-    }
-
-    const lintResults = await linter.lintFiles(lintFilePaths);
-
-    const result = lintResults.map((lintResult) => ({
-      filePath: lintResult.filePath,
-      results: lintResult.messages.map((msg) => ({
-        filePath: lintResult.filePath,
-        line: msg.line,
-        char: msg.column,
-        code: msg.ruleId ?? undefined,
-        severity: msg.severity === 1 ? "warning" as const : "error" as const,
-        message: msg.message
-      }))
-    }));
-
-    for (const resultItem of result) {
-      this._lintResultCache.set(resultItem.filePath, resultItem.results);
-    }
-
-    return Array.from(this._lintResultCache.values()).mapMany();
-  }
-}
+import { ISdCliPackageBuildResult } from "../commons";
+import ts from "typescript";
+import { FsUtil } from "@simplysm/sd-core-node";
+import path from "path";
+import { ESLint } from "eslint";
+
+export class SdCliPackageLinter {
+  private readonly _lintResultCache = new Map<string, ISdCliPackageBuildResult[]>();
+
+  public constructor(private readonly _rootPath: string) {
+  }
+
+  public async lintAsync(filePaths: string[], program?: ts.Program): Promise<ISdCliPackageBuildResult[]> {
+    if (!FsUtil.exists(path.resolve(this._rootPath, ".eslintrc.cjs"))) return [];
+
+    const linter = new ESLint(
+      program && filePaths.some((item) => item.endsWith(".ts")) ? {
+        overrideConfig: {
+          overrides: [
+            {
+              files: ["*.ts"],
+              parserOptions: {
+                /*programs: [program],
+                tsconfigRootDir: null,
+                project: null*/
+                tsconfigRootDir: this._rootPath,
+                project: "tsconfig-build.json"
+              },
+              settings: {
+                "import/resolver": {
+                  "typescript": {
+                    /*programs: [program],
+                    project: null*/
+                    project: path.resolve(this._rootPath, "tsconfig-build.json")
+                  }
+                }
+              }
+            }
+          ]
+        }
+      } : {}
+    );
+
+    const lintFilePaths = await filePaths
+      .filterAsync(async (filePath) => (
+        !filePath.endsWith(".d.ts") &&
+        /\.[cm]?[tj]sx?$/.test(filePath) &&
+        !(await linter.isPathIgnored(filePath))
+      ));
+    for (const lintFilePath of lintFilePaths) {
+      this._lintResultCache.delete(lintFilePath);
+    }
+
+    const lintResults = await linter.lintFiles(lintFilePaths);
+
+    const result = lintResults.map((lintResult) => ({
+      filePath: lintResult.filePath,
+      results: lintResult.messages.map((msg) => ({
+        filePath: lintResult.filePath,
+        line: msg.line,
+        char: msg.column,
+        code: msg.ruleId ?? undefined,
+        severity: msg.severity === 1 ? "warning" as const : "error" as const,
+        message: msg.message
+      }))
+    }));
+
+    for (const resultItem of result) {
+      this._lintResultCache.set(resultItem.filePath, resultItem.results);
+    }
+
+    return Array.from(this._lintResultCache.values()).mapMany();
+  }
+}

package/src/builder/SdCliClientBuilder.ts

@@ -46,6 +46,8 @@ export class SdCliClientBuilder extends EventEmitter {
 
   private readonly _hasAngularRoute: boolean;
 
+  private readonly _cacheBasePath = path.resolve(this._rootPath, ".cache");
+
   public constructor(private readonly _rootPath: string,
                      private readonly _config: ISdCliClientPackageConfig,
                      private readonly _workspaceRootPath: string) {
@@ -92,11 +94,39 @@ export class SdCliClientBuilder extends EventEmitter {
     return super.on(event, listener);
   }
 
+  private async _checkCacheAsync(watch: boolean): Promise<void> {
+    const workspacePkgLockContent = await FsUtil.readFileAsync(path.resolve(this._workspaceRootPath, "package-lock.json"));
+
+    // const cachePath = path.resolve(cacheBasePath, pkgVersion);
+
+    const versionHash = createHash("sha1")
+      .update(workspacePkgLockContent)
+      .update(JSON.stringify(this._parsedTsconfig.options))
+      .update(JSON.stringify(this._config))
+      .update(watch.toString())
+      .digest("hex");
+    if (
+      !FsUtil.exists(path.resolve(this._cacheBasePath, "version")) // 버전파일이 없거나
+      || (
+        FsUtil.exists(path.resolve(this._cacheBasePath, "version")) &&
+        await FsUtil.readFileAsync(path.resolve(this._cacheBasePath, "version")) !== versionHash
+      ) // 버전이 현재 버전과 다르면
+    ) {
+      // 캐시 삭제
+      await FsUtil.removeAsync(path.resolve(this._cacheBasePath));
+    }
+    // 버전쓰기
+    await FsUtil.writeFileAsync(path.resolve(this._cacheBasePath, "version"), versionHash);
+  }
+
   public async watchAsync(): Promise<void> {
     // DIST 비우기
     await FsUtil.removeAsync(path.resolve(this._rootPath, ".electron"));
     await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
 
+    // 캐시체크
+    await this._checkCacheAsync(true);
+
     // NgModule 생성
     await this._ngModuleGenerator.runAsync();
 
@@ -176,6 +206,9 @@ export class SdCliClientBuilder extends EventEmitter {
     this._logger.debug("removeAsync:2");
     await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
 
+    // 캐시체크
+    await this._checkCacheAsync(false);
+
     // NgModule 생성
     this._logger.debug("ngModule");
     await this._ngModuleGenerator.runAsync();
@@ -215,7 +248,7 @@ export class SdCliClientBuilder extends EventEmitter {
       await augmentAppWithServiceWorker(
         PathUtil.posix(path.relative(this._workspaceRootPath, this._rootPath)) as any,
         PathUtil.posix(path.relative(this._workspaceRootPath, path.resolve(this._parsedTsconfig.options.outDir!))) as any,
-        `/${packageKey}/`,
+        `/${packageKey}/` as any,
         PathUtil.posix(path.relative(this._workspaceRootPath, path.resolve(this._rootPath, "ngsw-config.json")))
       );
     }
@@ -333,8 +366,6 @@ export class SdCliClientBuilder extends EventEmitter {
     const pkgKey = npmConfig.name.split("/").last()!;
     const publicPath = builderType === "web" ? `/${pkgKey}/` : watch ? `/${pkgKey}/${builderType}/` : ``;
 
-    const cacheBasePath = path.resolve(this._rootPath, ".cache");
-
     const distPath = (builderType === "cordova" && !watch) ? path.resolve(this._cordova!.cordovaPath, "www")
       : (builderType === "electron" && !watch) ? path.resolve(this._rootPath, ".electron/src")
         : builderType === "web" ? this._parsedTsconfig.options.outDir
@@ -346,6 +377,25 @@ export class SdCliClientBuilder extends EventEmitter {
     const polyfillsFilePath = path.resolve(this._rootPath, "src/polyfills.ts");
     const stylesFilePath = path.resolve(this._rootPath, "src/styles.scss");
 
+    const versionHash = createHash("sha1")
+      .update(workspacePkgLockContent)
+      .update(JSON.stringify(this._parsedTsconfig.options))
+      .update(JSON.stringify(this._config))
+      .update(watch.toString())
+      .digest("hex");
+    if (
+      !FsUtil.exists(path.resolve(this._cacheBasePath, "version")) // 버전파일이 없거나
+      || (
+        FsUtil.exists(path.resolve(this._cacheBasePath, "version")) &&
+        FsUtil.readFile(path.resolve(this._cacheBasePath, "version")) !== versionHash
+      ) // 버전이 현재 버전과 다르면
+    ) {
+      // 캐시 삭제
+      FsUtil.remove(path.resolve(this._cacheBasePath));
+    }
+    // 버전쓰기
+    FsUtil.writeFile(path.resolve(this._cacheBasePath, "version"), versionHash);
+
     let prevProgressMessage = "";
     return {
       mode: watch ? "development" : "production",
@@ -400,14 +450,9 @@ export class SdCliClientBuilder extends EventEmitter {
       cache: {
         type: "filesystem",
         profile: undefined,
-        cacheDirectory: path.resolve(cacheBasePath, "angular-webpack"),
+        cacheDirectory: this._cacheBasePath,
         maxMemoryGenerations: 1,
-        name: createHash("sha1")
-          .update(workspacePkgLockContent)
-          .update(JSON.stringify(this._parsedTsconfig.options))
-          .update(JSON.stringify(this._config))
-          .update(watch.toString())
-          .digest("hex")
+        name: "webpack"
       },
       snapshot: {
         immutablePaths: internalModuleCachePaths,
@@ -487,7 +532,7 @@ export class SdCliClientBuilder extends EventEmitter {
               {
                 loader: "@angular-devkit/build-angular/src/babel/webpack-loader",
                 options: {
-                  cacheDirectory: path.resolve(cacheBasePath, "babel-webpack"),
+                  cacheDirectory: path.resolve(this._cacheBasePath, "webpack-babel"),
                   scriptTarget: ts.ScriptTarget.ES2017,
                   aot: true,
                   optimize: !watch,
@@ -694,8 +739,8 @@ export class SdCliClientBuilder extends EventEmitter {
           sri: false,
           cache: {
             enabled: true,
-            basePath: cacheBasePath,
-            path: path.resolve(cacheBasePath, "index-webpack")
+            basePath: this._cacheBasePath,
+            path: path.resolve(this._cacheBasePath, "webpack-html")
           },
           postTransform: undefined,
           optimization: {

package/src/builder/SdCliServerBuilder.ts

@@ -24,6 +24,8 @@ export class SdCliServerBuilder extends EventEmitter {
   private readonly _parsedTsconfig: ts.ParsedCommandLine;
   private readonly _npmConfigMap = new Map<string, INpmConfig>();
 
+  private readonly _cacheBasePath = path.resolve(this._rootPath, ".cache");
+
   public constructor(private readonly _rootPath: string,
                      private readonly _config: ISdCliServerPackageConfig,
                      private readonly _workspaceRootPath: string) {
@@ -41,10 +43,38 @@ export class SdCliServerBuilder extends EventEmitter {
     return super.on(event, listener);
   }
 
+  private async _checkCacheAsync(watch: boolean): Promise<void> {
+    const workspacePkgLockContent = await FsUtil.readFileAsync(path.resolve(this._workspaceRootPath, "package-lock.json"));
+
+    // const cachePath = path.resolve(cacheBasePath, pkgVersion);
+
+    const versionHash = createHash("sha1")
+      .update(workspacePkgLockContent)
+      .update(JSON.stringify(this._parsedTsconfig.options))
+      .update(JSON.stringify(this._config))
+      .update(watch.toString())
+      .digest("hex");
+    if (
+      !FsUtil.exists(path.resolve(this._cacheBasePath, "version")) // 버전파일이 없거나
+      || (
+        FsUtil.exists(path.resolve(this._cacheBasePath, "version")) &&
+        await FsUtil.readFileAsync(path.resolve(this._cacheBasePath, "version")) !== versionHash
+      ) // 버전이 현재 버전과 다르면
+    ) {
+      // 캐시 삭제
+      await FsUtil.removeAsync(path.resolve(this._cacheBasePath));
+    }
+    // 버전쓰기
+    await FsUtil.writeFileAsync(path.resolve(this._cacheBasePath, "version"), versionHash);
+  }
+
   public async watchAsync(): Promise<void> {
     // DIST 비우기
     await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
 
+    // 캐시체크
+    await this._checkCacheAsync(true);
+
     // 빌드 준비
     const extModules = this._getExternalModules();
     const webpackConfig = this._getWebpackConfig(true, extModules);
@@ -233,11 +263,6 @@ export class SdCliServerBuilder extends EventEmitter {
     const pkgKey = npmConfig.name.split("/").last()!;
     // const pkgVersion = npmConfig.version;
 
-    const workspacePkgLockContent = FsUtil.readFile(path.resolve(this._workspaceRootPath, "package-lock.json"));
-
-    const cacheBasePath = path.resolve(this._rootPath, ".cache");
-    // const cachePath = path.resolve(cacheBasePath, pkgVersion);
-
     let prevProgressMessage = "";
     return {
       mode: watch ? "development" : "production",
@@ -291,14 +316,9 @@ export class SdCliServerBuilder extends EventEmitter {
       cache: {
         type: "filesystem",
         profile: watch ? undefined : false,
-        cacheDirectory: path.resolve(cacheBasePath, "server-webpack"),
+        cacheDirectory: this._cacheBasePath,
         maxMemoryGenerations: 1,
-        name: createHash("sha1")
-          .update(workspacePkgLockContent)
-          .update(JSON.stringify(this._parsedTsconfig.options))
-          .update(JSON.stringify(this._config))
-          .update(watch.toString())
-          .digest("hex")
+        name: "webpack"
       },
       snapshot: {
         immutablePaths: internalModuleCachePaths,
@@ -474,7 +494,7 @@ export class SdCliServerBuilder extends EventEmitter {
           continue;
         }
 
-        if (FsUtil.exists(path.resolve(modulePath, "binding.gyp"))) {
+        if (FsUtil.glob(path.resolve(modulePath, "**/binding.gyp")).length > 0) {
           results.push({ name: moduleName, exists: true });
         }
 
@@ -495,7 +515,7 @@ export class SdCliServerBuilder extends EventEmitter {
           continue;
         }
 
-        if (FsUtil.exists(path.resolve(optModulePath, "binding.gyp"))) {
+        if (FsUtil.glob(path.resolve(optModulePath, "**/binding.gyp")).length > 0) {
           results.push({ name: optModuleName, exists: true });
         }