@simplysm/sd-cli 6.0.28 → 6.0.38

package/src/builders/SdCliServerBuilder.ts

@@ -1,7 +1,7 @@
 import { EventEmitter } from "events";
 import { INpmConfig, ISdPackageBuildResult, ISdServerPackageConfig, ITsconfig } from "../commons";
 import * as ts from "typescript";
-import { FsUtil, Logger, PathUtil } from "@simplysm/sd-core-node";
+import { FsUtil, PathUtil } from "@simplysm/sd-core-node";
 import { ObjectUtil, StringUtil, Wait } from "@simplysm/sd-core-common";
 import * as webpack from "webpack";
 import * as path from "path";
@@ -27,7 +27,8 @@ export class SdCliServerBuilder extends EventEmitter {
   public constructor(public rootPath: string,
                      public tsconfigFilePath: string,
                      public projectRootPath: string,
-                     public config: ISdServerPackageConfig) {
+                     public config: ISdServerPackageConfig,
+                     public useCache: boolean) {
     super();
 
     const tsconfig: ITsconfig = FsUtil.readJson(this.tsconfigFilePath);
@@ -93,13 +94,19 @@ export class SdCliServerBuilder extends EventEmitter {
             ...this.config.env ? this.config.env : {}
           }
         },
-        (typeof this.config.pm2 !== "boolean") ? this.config.pm2 : {}
+        (typeof this.config.pm2 !== "boolean") ? this.config.pm2 : {},
+        {
+          arrayProcess: "concat"
+        }
       ), undefined, 2));
     }
 
     // iis 파일 쓰기
-    if (this.config.iis) {
+    if (this.config.iis !== undefined && this.config.iis !== false) {
       const iisDistPath = path.resolve(this.parsedTsconfig.options.outDir!, "web.config");
+      const serverExeFilePath = (this.config.iis !== true && "serverExeFilePath" in this.config.iis)
+        ? (this.config.iis.serverExeFilePath ?? "C:\\Program Files\\nodejs\\node.exe")
+        : "C:\\Program Files\\nodejs\\node.exe";
       await FsUtil.writeFileAsync(iisDistPath, `
 <configuration>
   <system.webServer>
@@ -107,7 +114,10 @@ export class SdCliServerBuilder extends EventEmitter {
     <handlers>
       <add name="iisnode" path="main.js" verb="*" modules="iisnode" />
     </handlers>
-    <iisnode nodeProcessCommandLine="C:\\Program Files\\nodejs\\node.exe" watchedFiles="web.config;*.js" loggingEnabled="true" />
+    <iisnode nodeProcessCommandLine="${serverExeFilePath}"
+             watchedFiles="web.config;*.js"
+             loggingEnabled="true"
+             devErrorsEnabled="true" />
     <rewrite>
       <rules>
         <rule name="main">
@@ -115,9 +125,10 @@ export class SdCliServerBuilder extends EventEmitter {
         </rule>
       </rules>
     </rewrite>
-    <httpErrors errorMode="Detailed" />  
+    <httpErrors errorMode="Detailed" />
   </system.webServer>
 </configuration>
+
 `.trim());
     }
 
@@ -142,7 +153,6 @@ export class SdCliServerBuilder extends EventEmitter {
     const externalModuleNames = this._findExternalModuleNames(true);
 
     // 빌드
-
     const webpackConfig = this._getWebpackConfig(true, externalModuleNames);
     const compiler = webpack(webpackConfig);
     await new Promise<void>((resolve, reject) => {
@@ -173,11 +183,16 @@ export class SdCliServerBuilder extends EventEmitter {
           await this._startServerAsync();
         }
         catch (error) {
-          results.push({
-            filePath: undefined,
-            severity: "error",
-            message: error.message
-          });
+          if (error instanceof Error) {
+            results.push({
+              filePath: undefined,
+              severity: "error",
+              message: error.message
+            });
+          }
+          else {
+            throw error;
+          }
         }
 
         // 결과 리턴
@@ -203,9 +218,9 @@ export class SdCliServerBuilder extends EventEmitter {
 
     const mainFilePath = path.resolve(this.parsedTsconfig.options.outDir!, "main.js");
 
-    const prevLoggerConfigs = ObjectUtil.clone(Logger.configs);
+    // const prevLoggerConfigs = ObjectUtil.clone(Logger.configs);
     this._server = require(mainFilePath) as SdServiceServer | undefined;
-    Logger.configs = prevLoggerConfigs;
+    // Logger.configs = prevLoggerConfigs;
 
     if (!this._server) {
       throw new Error(`${mainFilePath}(0, 0): 'SdServiceServer'를 'export'해야 합니다.`);
@@ -228,16 +243,16 @@ export class SdCliServerBuilder extends EventEmitter {
       resolve: {
         extensions: [".ts", ".tsx", ".js"],
         symlinks: true,
-        modules: [this.projectRootPath, "node_modules"],
+        // modules: [this.projectRootPath, "node_modules"],
         mainFields: ["es2020", "main", "module"]
       },
-      resolveLoader: {
+      /*resolveLoader: {
         symlinks: true,
         modules: [
           "node_modules",
           ...this._findAllNodeModules(__dirname, this.projectRootPath)
         ]
-      },
+      },*/
       context: this.projectRootPath,
       entry: {
         main: [
@@ -252,6 +267,7 @@ export class SdCliServerBuilder extends EventEmitter {
         // chunkFilename: watch ? "[name].js" : "[name].[chunkhash:20].js",
         filename: "[name].js",
         chunkFilename: "[name].js",
+        assetModuleFilename: "resources/[name][ext][query]",
         libraryTarget: watch ? "umd" : "commonjs"
       },
       performance: { hints: false },
@@ -280,10 +296,14 @@ export class SdCliServerBuilder extends EventEmitter {
                 return `${msg.file}(${msg.line}, ${msg.character}): ${msg.code}: ${msg.severity} ${msg.content}`;
               }
             }
+          },
+          {
+            test: /\.(png|jpe?g|gif|svg|woff|woff2|ttf|eot|ico|otf|xlsx?|pptx?|docx?|zip|pfx|pkl)$/,
+            type: "asset/resource"
           }
         ]
       },
-      cache: watch ? { type: "memory", maxGenerations: 1 } : false,
+      cache: (watch && this.useCache) ? { type: "memory", maxGenerations: 1 } : false,
       optimization: {
         minimizer: watch ? [] : [
           new JavaScriptOptimizerPlugin({
@@ -296,7 +316,7 @@ export class SdCliServerBuilder extends EventEmitter {
         ],
         moduleIds: "deterministic",
         chunkIds: watch ? "named" : "deterministic",
-        emitOnErrors: false
+        emitOnErrors: watch
       },
       plugins: [
         new DedupeModuleResolvePlugin({ verbose: false }) as any,
@@ -358,6 +378,15 @@ export class SdCliServerBuilder extends EventEmitter {
     };
   }
 
+  /*private _findAllInternalModuleCachePaths(): string[] {
+    return this._findAllNodeModules(this.rootPath, this.projectRootPath)
+      .mapMany((item) => (
+        FsUtil.readdir(item)
+          .filter((item1) => !item1.startsWith("@simplysm"))
+          .map((item1) => path.resolve(item, item1))
+      ));
+  }*/
+
   private _findAllNodeModules(from: string, root: string): string[] {
     const nodeModules: string[] = [];
 

package/src/builders/SdCliTypescriptBuilder.ts

@@ -13,30 +13,29 @@ import { ParserOptions } from "@typescript-eslint/types";
 export class SdCliTypescriptBuilder extends EventEmitter {
   protected readonly _logger: Logger;
 
-  protected _parsedTsconfig: ts.ParsedCommandLine;
+  protected _tsconfig: ITsconfig;
   public readonly npmConfig: INpmConfig;
 
   protected _moduleResolutionCache?: ts.ModuleResolutionCache;
   protected _cacheCompilerHost?: ts.CompilerHost;
   protected _program?: ts.Program;
-  protected _builder?: ts.BuilderProgram | ts.EmitAndSemanticDiagnosticsBuilderProgram;
+  protected _builder?: ts.BuilderProgram | ts.SemanticDiagnosticsBuilderProgram;
   protected readonly _fileCache = new Map<string, ITsBuildFileCache>();
 
   private readonly _indexFileGenerator?: SdCliIndexFileGenerator;
 
   private _watcher?: SdFsWatcher;
 
-  public ignoreProcesses: string[];
+  public skipProcesses: string[];
 
   public constructor(public rootPath: string,
                      public tsconfigFilePath: string,
-                     ignoreProcesses: ("emit" | "check" | "lint" | "genIndex")[],
+                     skipProcesses: ("emit" | "check" | "lint" | "genIndex")[],
                      public autoIndexConfig: ISdAutoIndexConfig | undefined) {
     super();
-    this.ignoreProcesses = ignoreProcesses;
+    this.skipProcesses = skipProcesses;
 
-    const tsconfig: ITsconfig = FsUtil.readJson(this.tsconfigFilePath);
-    this._parsedTsconfig = ts.parseJsonConfigFileContent(tsconfig, ts.sys, this.rootPath);
+    this._tsconfig = FsUtil.readJson(this.tsconfigFilePath);
 
     this.npmConfig = FsUtil.readJson(path.resolve(this.rootPath, "package.json"));
     this._logger = Logger.get(["simplysm", "sd-cli", this.constructor.name, this.npmConfig.name]);
@@ -55,10 +54,12 @@ export class SdCliTypescriptBuilder extends EventEmitter {
   public async buildAsync(watch: boolean): Promise<void> {
     this.emit("change");
 
+    const parsedTsconfig = ts.parseJsonConfigFileContent(this._tsconfig, ts.sys, this.rootPath);
+
     // DIST 비우기
-    await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
-    if (this._parsedTsconfig.options.declarationDir !== undefined) {
-      await FsUtil.removeAsync(this._parsedTsconfig.options.declarationDir);
+    await FsUtil.removeAsync(parsedTsconfig.options.outDir!);
+    if (parsedTsconfig.options.declarationDir !== undefined) {
+      await FsUtil.removeAsync(parsedTsconfig.options.declarationDir);
     }
 
     // 프로그램 리로드
@@ -128,11 +129,16 @@ export class SdCliTypescriptBuilder extends EventEmitter {
           this.emit("complete", Array.from(resultMap.values()).mapMany());
         }
         catch (err) {
-          this.emit("complete", [{
-            filePath: undefined,
-            severity: "error",
-            message: err.stack ?? err.message
-          }]);
+          if (err instanceof Error) {
+            this.emit("complete", [{
+              filePath: undefined,
+              severity: "error",
+              message: err.stack ?? err.message
+            }]);
+          }
+          else {
+            throw err;
+          }
         }
       })
       .watch(watchPaths);
@@ -163,7 +169,7 @@ export class SdCliTypescriptBuilder extends EventEmitter {
 
     const result: ITsGenResult = { dirtyFilePaths: [], result: [] };
 
-    if (!this.ignoreProcesses.includes("genIndex") && this._indexFileGenerator && this.autoIndexConfig) {
+    if (!this.skipProcesses.includes("genIndex") && this._indexFileGenerator && this.autoIndexConfig) {
       const generateResult = await this._indexFileGenerator.generateAsync();
       result.result.push(...generateResult.result);
       if (generateResult.changed) {
@@ -192,54 +198,58 @@ export class SdCliTypescriptBuilder extends EventEmitter {
   }
 
   protected async _lintAsync(dirtyFilePaths: string[]): Promise<ISdPackageBuildResult[]> {
-    this._logger.debug("LINT");
-
-    const linter = new ESLint({
-      overrideConfig: {
-        overrides: [
-          {
-            files: ["*.ts"],
-            parserOptions: {
-              program: this._program
-            } as ParserOptions,
-            settings: {
-              "import/resolver": {
-                typescript: {
-                  project: this.tsconfigFilePath
+    if (!this.skipProcesses.includes("lint")) {
+      this._logger.debug("LINT");
+
+      const linter = new ESLint({
+        overrideConfig: {
+          overrides: [
+            {
+              files: ["*.ts"],
+              parserOptions: {
+                program: this._program
+              } as ParserOptions,
+              settings: {
+                "import/resolver": {
+                  typescript: {
+                    project: this.tsconfigFilePath
+                  }
                 }
               }
             }
-          }
-        ]
-      }
-    });
-
-    const filePaths = await dirtyFilePaths
-      .filterAsync(async (item) => (
-        !item.includes("node_modules")
-        && PathUtil.isChildPath(item, this.rootPath)
-        && FsUtil.exists(item)
-        && !FsUtil.isDirectory(item)
-        && !await linter.isPathIgnored(item)
-      ));
-
-    const lintResults = await linter.lintFiles(filePaths);
+          ]
+        }
+      });
 
-    const result = lintResults.mapMany((report) => (
-      report.messages.map((msg) => {
-        const severity: "warning" | "error" = msg.severity === 1 ? "warning" : "error";
+      const filePaths = await dirtyFilePaths
+        .filterAsync(async (item) => (
+          !item.includes("node_modules")
+          && PathUtil.isChildPath(item, this.rootPath)
+          && FsUtil.exists(item)
+          && !FsUtil.isDirectory(item)
+          && !await linter.isPathIgnored(item)
+        ));
+
+      const lintResults = await linter.lintFiles(filePaths);
+
+      const result = lintResults.mapMany((report) => (
+        report.messages.map((msg) => {
+          const severity: "warning" | "error" = msg.severity === 1 ? "warning" : "error";
+
+          return {
+            filePath: report.filePath,
+            severity,
+            message: `${report.filePath}(${msg.line}, ${msg.column}): ${msg.ruleId ?? ""}: ${severity} ${msg.message}`
+          };
+        })
+      ));
 
-        return {
-          filePath: report.filePath,
-          severity,
-          message: `${report.filePath}(${msg.line}, ${msg.column}): ${msg.ruleId ?? ""}: ${severity} ${msg.message}`
-        };
-      })
-    ));
+      this._logger.debug("LINT 결과", result);
 
-    this._logger.debug("LINT 결과", result);
+      return result;
+    }
 
-    return result;
+    return [];
   }
 
   /*protected _getAllDependencies(filePath: string): string[] {
@@ -257,10 +267,10 @@ export class SdCliTypescriptBuilder extends EventEmitter {
   }*/
 
   public getWatchPaths(): string[] {
-    const builder = this._builder as ts.EmitAndSemanticDiagnosticsBuilderProgram;
+    // const builder = this._builder as ts.SemanticDiagnosticsBuilderProgram;
 
     const result: string[] = [];
-    for (const sourceFile of builder.getSourceFiles()) {
+    for (const sourceFile of this._builder!.getSourceFiles()) {
       // result.push(sourceFile.fileName, ...this._getAllDependencies(sourceFile.fileName));
       result.push(sourceFile.fileName);
     }
@@ -295,15 +305,16 @@ export class SdCliTypescriptBuilder extends EventEmitter {
 
     const diagnostics: ts.Diagnostic[] = [];
 
-    if (!this.ignoreProcesses.includes("check")) {
+    if (!this.skipProcesses.includes("check")) {
       diagnostics.push(
         ...this._builder.getOptionsDiagnostics(),
         ...this._builder.getGlobalDiagnostics()
       );
 
-      for (const dirtyFilePath of dirtyFilePaths) {
-        const sourceFile = this._builder.getSourceFile(dirtyFilePath);
-        if (!sourceFile) continue;
+      for (const sourceFile of this._builder.getSourceFiles()) {
+        /*for (const dirtyFilePath of dirtyFilePaths) {
+          const sourceFile = this._builder.getSourceFile(dirtyFilePath);
+          if (!sourceFile) continue;*/
 
         if (sourceFile.isDeclarationFile) continue;
 
@@ -314,7 +325,7 @@ export class SdCliTypescriptBuilder extends EventEmitter {
       }
     }
 
-    if (!this.ignoreProcesses.includes("emit")) {
+    if (!this.skipProcesses.includes("emit")) {
       for (const dirtyFilePath of dirtyFilePaths) {
         const sourceFile = this._builder.getSourceFile(dirtyFilePath);
         if (!sourceFile) continue;
@@ -347,8 +358,8 @@ export class SdCliTypescriptBuilder extends EventEmitter {
       this._reloadWatchPaths();
     }
 
-    dirtyFilePaths.push(...changedFilePaths.filter((key) => this._fileCache.has(key)));
-    dirtyFilePaths.distinctThis();
+    /*dirtyFilePaths.push(...changedFilePaths.filter((key) => this._fileCache.has(key)));
+    dirtyFilePaths.distinctThis();*/
 
     this._logger.debug("변경 프로그램 리로드 결과", dirtyFilePaths);
     return dirtyFilePaths;
@@ -357,12 +368,14 @@ export class SdCliTypescriptBuilder extends EventEmitter {
   public async reloadProgramAsync(watch: boolean): Promise<string[]> {
     this._logger.debug("프로그램 리로드");
 
-    this._moduleResolutionCache = ts.createModuleResolutionCache(this.rootPath, (s) => s, this._parsedTsconfig.options);
-    this._cacheCompilerHost = await this._createCacheCompilerHostAsync(this._parsedTsconfig, this._moduleResolutionCache);
+    const parsedTsconfig = ts.parseJsonConfigFileContent(this._tsconfig, ts.sys, this.rootPath);
+
+    this._moduleResolutionCache = ts.createModuleResolutionCache(this.rootPath, (s) => s, parsedTsconfig.options);
+    this._cacheCompilerHost = await this._createCacheCompilerHostAsync(parsedTsconfig, this._moduleResolutionCache);
 
     this._program = ts.createProgram(
-      this._parsedTsconfig.fileNames,
-      this._parsedTsconfig.options,
+      parsedTsconfig.fileNames,
+      parsedTsconfig.options,
       this._cacheCompilerHost,
       this._program
     );
@@ -381,12 +394,21 @@ export class SdCliTypescriptBuilder extends EventEmitter {
     };
 
     if (watch) {
-      const builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(
-        this._program,
-        this._cacheCompilerHost,
-        this._builder as ts.EmitAndSemanticDiagnosticsBuilderProgram
-      );
-      this._builder = builder;
+      if (this.skipProcesses.includes("emit")) {
+        this._builder = ts.createSemanticDiagnosticsBuilderProgram(
+          this._program,
+          this._cacheCompilerHost,
+          this._builder as ts.SemanticDiagnosticsBuilderProgram
+        );
+      }
+      else {
+        this._builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(
+          this._program,
+          this._cacheCompilerHost,
+          this._builder as ts.EmitAndSemanticDiagnosticsBuilderProgram
+        );
+      }
+      const builder = this._builder as ts.SemanticDiagnosticsBuilderProgram;
 
       const affectedFilePaths: string[] = [];
       while (true) {
@@ -417,7 +439,7 @@ export class SdCliTypescriptBuilder extends EventEmitter {
 
   // eslint-disable-next-line @typescript-eslint/require-await
   protected async _createCacheCompilerHostAsync(parsedTsconfig: ts.ParsedCommandLine, moduleResolutionCache: ts.ModuleResolutionCache): Promise<ts.CompilerHost> {
-    const compilerHost = ts.createCompilerHost(parsedTsconfig.options);
+    const compilerHost = ts.createIncrementalCompilerHost(parsedTsconfig.options);
 
     const cacheCompilerHost = { ...compilerHost };
     cacheCompilerHost.fileExists = (fileName: string) => {
@@ -448,7 +470,9 @@ export class SdCliTypescriptBuilder extends EventEmitter {
         });
       }
 
-      compilerHost.writeFile.call(cacheCompilerHost, fileName, data, writeByteOrderMark, onError, sourceFiles);
+      if (!FsUtil.exists(fileName) || FsUtil.readFile(fileName) !== data) {
+        compilerHost.writeFile.call(cacheCompilerHost, fileName, data, writeByteOrderMark, onError, sourceFiles);
+      }
     };
 
     cacheCompilerHost.readFile = (fileName: string) => {

package/src/commons.ts

@@ -32,7 +32,7 @@ export interface ISdServerPackageConfig {
   externalDependencies?: string[];
   configs?: Record<string, any>;
   pm2?: Record<string, any> | boolean;
-  iis?: boolean;
+  iis?: boolean | { serverExeFilePath?: string };
   publish?: TSdPublishConfig;
 }
 
@@ -74,6 +74,7 @@ export interface ITsconfig {
     strictInputTypes?: boolean;
     strictOutputEventTypes?: boolean;
     compilationMode?: "partial" | "full";
+    disableTypeScriptVersionCheck?: boolean;
   };
   files?: string[];
   include?: string[];

package/src/entry-points/SdCliProject.ts

@@ -34,7 +34,7 @@ export class SdCliProject {
     this.npmConfig = FsUtil.readJson(this.npmConfigFilePath);
   }
 
-  public async buildAsync(opt: { watch?: boolean; packages?: string[]; options?: string[]; config?: string }): Promise<void> {
+  public async buildAsync(opt: { watch?: boolean; packages?: string[]; options?: string[]; config?: string; skipProcesses?: string[]; localUpdate?: boolean }): Promise<{ hasError: boolean }> {
     this._logger.debug("프로젝트 설정 가져오기...");
     const config = await SdProjectConfigUtil.loadConfigAsync(
       this._rootPath,
@@ -43,13 +43,13 @@ export class SdCliProject {
       opt.config
     );
 
-    if (opt.watch && config.localUpdates) {
+    if (opt.watch && opt.localUpdate && config.localUpdates) {
       this._logger.debug("로컬 라이브러리 업데이트 변경감지 시작...");
       await new SdCliLocalUpdater(this._rootPath).localUpdateAsync(true, opt);
     }
 
     this._logger.debug("프로젝트 패키지 목록 구성...");
-    const allPkgs = await this._getAllPackagesAsync(config, opt.packages);
+    const allPkgs = await this._getAllPackagesAsync(config, opt.packages, opt.skipProcesses ?? [], !opt.localUpdate);
     const pkgs = allPkgs.filter((item) => !(item instanceof SdCliUnknownPackage)) as TSdCliBuildablePackage[];
 
     this._logger.debug("프로젝트 및 패키지 버전 설정...");
@@ -141,6 +141,10 @@ export class SdCliProject {
     this._loggingResults(totalResultMap);
     this._logger.info(`모든 빌드가 완료되었습니다.`);
     this._loggingOpenClientHrefs();
+
+    return {
+      hasError: Array.from(totalResultMap.values()).mapMany().some((item) => item.severity === "error")
+    };
   }
 
 
@@ -174,19 +178,22 @@ export class SdCliProject {
     );
 
     this._logger.debug("프로젝트 패키지 목록 구성...");
-    const allPkgs = await this._getAllPackagesAsync(config, opt.packages);
+    const allPkgs = await this._getAllPackagesAsync(config, opt.packages, [], false);
     const pkgs = allPkgs.filter((item) => !(item instanceof SdCliUnknownPackage) && item.config.publish) as TSdCliBuildablePackage[];
 
     // 빌드가 필요하면 빌드함
     if (opt.build) {
       this._logger.debug("빌드 수행...");
-      await this.buildAsync({
+      const buildResult = await this.buildAsync({
         watch: false,
         packages: pkgs.map((item) => item.npmConfig.name)
           .filter((item) => !opt.packages || opt.packages.includes(item)),
         options: opt.options,
         config: opt.config
       });
+      if (buildResult.hasError) {
+        throw new Error("빌드중 에러가 발생했습니다.");
+      }
     }
 
     // 빌드시엔 빌드에서 버전업했고, 빌드가 아닌경우 여기서 버전업
@@ -239,7 +246,7 @@ export class SdCliProject {
     }
   }
 
-  private async _getAllPackagesAsync(config: ISdProjectConfig, packages: string[] | undefined): Promise<TSdCliPackage[]> {
+  private async _getAllPackagesAsync(config: ISdProjectConfig, packages: string[] | undefined, skipProcesses: string[], useCache: boolean): Promise<TSdCliPackage[]> {
     // package.json에서 workspaces를 통해 패키지 경로 목록 가져오기
     const allPkgPaths = await this.npmConfig.workspaces?.mapManyAsync(async (item) => await FsUtil.globAsync(item));
     if (!allPkgPaths) {
@@ -268,32 +275,33 @@ export class SdCliProject {
     }
 
     // 각 package를 위한 worker 준비
-    const workerCount = allPackageInfos.sum((item) => {
+    /*const workerCount = allPackageInfos.sum((item) => {
       if (item.config && item.config.type === "library") {
         return item.config.targets?.length ?? 1;
       }
       return 0;
-    });
+    });*/
 
     const processWorkManager = await SdProcessWorkManager.createAsync(
       path.resolve(__dirname, `../workers/lib-build-worker`),
       [],
+      this._logger/*,
       Math.min(workerCount, Math.max(os.cpus().length - 2, 1)),
-      Math.max(os.cpus().length - 2, 1)
+      Math.max(os.cpus().length - 2, 1)*/
     );
 
     // 패키지 목록 구성
     const pkgs: TSdCliPackage[] = [];
     for (const pkgInfo of allPackageInfos) {
       if (pkgInfo.config?.type === "library") {
-        pkgs.push(new SdCliLibraryPackage(pkgInfo.rootPath, pkgInfo.config, processWorkManager));
+        pkgs.push(new SdCliLibraryPackage(pkgInfo.rootPath, pkgInfo.config, skipProcesses as any, processWorkManager));
       }
       else if (pkgInfo.config?.type === "client") {
         const serverPkgInfo = allPackageInfos.single((item) => item.name === (pkgInfo.config as ISdClientPackageConfig).server);
-        pkgs.push(new SdCliClientPackage(pkgInfo.rootPath, pkgInfo.config, serverPkgInfo?.rootPath));
+        pkgs.push(new SdCliClientPackage(pkgInfo.rootPath, pkgInfo.config, useCache, serverPkgInfo?.rootPath));
       }
       else if (pkgInfo.config?.type === "server") {
-        pkgs.push(new SdCliServerPackage(pkgInfo.rootPath, pkgInfo.config));
+        pkgs.push(new SdCliServerPackage(pkgInfo.rootPath, pkgInfo.config, useCache));
       }
       else {
         pkgs.push(new SdCliUnknownPackage(pkgInfo.rootPath));
@@ -322,12 +330,12 @@ export class SdCliProject {
 
     const warnings = totalResults
       .filter((item) => item.severity === "warning")
-      .map((item) => item.message.trim() + "(" + item.pkgName + ")")
+      .map((item) => item.message.trim() + " (" + item.pkgName + ")")
       .distinct();
 
     const errors = totalResults
       .filter((item) => item.severity === "error")
-      .map((item) => item.message.trim() + "(" + item.pkgName + ")")
+      .map((item) => item.message.trim() + " (" + item.pkgName + ")")
       .distinct();
 
     if (warnings.length > 0) {

package/src/packages/SdCliClientPackage.ts

@@ -16,6 +16,7 @@ export class SdCliClientPackage extends SdCliPackageBase {
 
   public constructor(public readonly rootPath: string,
                      public readonly config: ISdClientPackageConfig,
+                     public readonly useCache: boolean,
                      public readonly _serverPath?: string) {
     super(rootPath);
   }
@@ -24,7 +25,7 @@ export class SdCliClientPackage extends SdCliPackageBase {
     await this._genBuildTsconfigAsync();
 
     const buildTsconfigFilePath = path.resolve(this.rootPath, `sd-tsconfig.json`);
-    const builder = new SdCliNgClientBuilder(this.rootPath, buildTsconfigFilePath, process.cwd(), this.config);
+    const builder = new SdCliNgClientBuilder(this.rootPath, buildTsconfigFilePath, process.cwd(), this.config, this.useCache);
 
     await builder
       .on("change", () => {
@@ -40,7 +41,7 @@ export class SdCliClientPackage extends SdCliPackageBase {
     await this._genBuildTsconfigAsync();
 
     const buildTsconfigFilePath = path.resolve(this.rootPath, `sd-tsconfig.json`);
-    const builder = new SdCliNgClientBuilder(this.rootPath, buildTsconfigFilePath, process.cwd(), this.config);
+    const builder = new SdCliNgClientBuilder(this.rootPath, buildTsconfigFilePath, process.cwd(), this.config, this.useCache);
     return await builder
       .on("change", () => {
         this.emit("change", undefined);
@@ -86,7 +87,8 @@ export class SdCliClientPackage extends SdCliPackageBase {
       strictInputAccessModifiers: true,
       strictTemplates: true,
       strictInputTypes: false,
-      strictOutputEventTypes: false
+      strictOutputEventTypes: false,
+      disableTypeScriptVersionCheck: true
     };
 
     const buildTsconfigFilePath = path.resolve(this.rootPath, `sd-tsconfig.json`);