@simplysm/sd-cli 7.0.23 → 7.0.37

package/src/entry-points/SdCliWorkspace.ts

@@ -2,13 +2,14 @@ import { FsUtil, Logger, SdProcess } from "@simplysm/sd-core-node";
 import path from "path";
 import { INpmConfig, ISdCliConfig, ISdCliPackageBuildResult } from "../commons";
 import { SdCliPackage } from "../packages/SdCliPackage";
-import { Wait } from "@simplysm/sd-core-common";
+import { Uuid, Wait } from "@simplysm/sd-core-common";
 import os from "os";
 import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
 import semver from "semver/preload";
 import { SdCliConfigUtil } from "../utils/SdCliConfigUtil";
 import { SdServiceServer } from "@simplysm/sd-service/server";
-import decache from "decache";
+import { SdCliNpm } from "./SdCliNpm";
+import { SdCliLocalUpdate } from "./SdCliLocalUpdate";
 
 export class SdCliWorkspace {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
@@ -25,6 +26,11 @@ export class SdCliWorkspace {
     this._logger.debug("프로젝트 설정 가져오기...");
     const config = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), true, opt.optNames);
 
+    if (config.localUpdates) {
+      this._logger.debug("로컬 라이브러리 업데이트 변경감지 시작...");
+      await new SdCliLocalUpdate(this._rootPath).watchAsync({ confFileRelPath: opt.confFileRelPath });
+    }
+
     this._logger.debug("패키지 목록 구성...");
     const pkgs = await this._getPackagesAsync(config);
 
@@ -40,7 +46,15 @@ export class SdCliWorkspace {
           changeCount++;
           this._logger.debug(`[${pkg.name}] 빌드를 시작합니다...`);
         })
-        .on("complete", (results) => {
+        .on("complete", async (results) => {
+          if (pkg.type === "server") {
+            if (results.some((item) => item.severity === "error")) {
+              return;
+            }
+
+            await this._restartServerAsync(pkg);
+          }
+
           this._logger.debug(`[${pkg.name}] 빌드가 완료되었습니다.`);
           totalResultMap.set(pkg.name, results);
 
@@ -52,40 +66,6 @@ export class SdCliWorkspace {
             }
           }, 500);
         });
-
-
-      if (pkg.type === "server") {
-        pkg.on("complete", async (results) => {
-          if (results.some((item) => item.severity === "error")) {
-            return;
-          }
-
-          const entryFileRelPath = pkg.main;
-          if (entryFileRelPath === undefined) {
-            this._logger.error(`서버패키지(${pkg.name})의 'package.json'에서 'main'필드를 찾을 수 없습니다.`);
-            return;
-          }
-          const entryFilePath = path.resolve(pkg.rootPath, entryFileRelPath);
-
-          this._logger.log(`서버(${pkg.name}) 재시작...`);
-          const serverInfo = this._serverInfoMap.getOrCreate(pkg.name, {});
-          if (serverInfo.server) {
-            await serverInfo.server.closeAsync();
-            delete serverInfo.server;
-            decache(entryFilePath);
-          }
-
-          serverInfo.server = (await import(entryFilePath)) as SdServiceServer | undefined;
-          if (serverInfo.server === undefined) {
-            this._logger.error(`${entryFilePath}(0, 0): 'SdServiceServer'를 'export'해야 합니다.`);
-            return;
-          }
-
-          await Wait.until(() => serverInfo.server!.isOpen);
-
-          this._logger.log(`서버(${pkg.name}) 재시작 완료`);
-        });
-      }
     }
 
     this._logger.debug("빌드를 시작합니다...");
@@ -98,6 +78,32 @@ export class SdCliWorkspace {
     });
   }
 
+  private async _restartServerAsync(pkg: SdCliPackage): Promise<void> {
+    const entryFileRelPath = pkg.main;
+    if (entryFileRelPath === undefined) {
+      this._logger.error(`서버패키지(${pkg.name})의 'package.json'에서 'main'필드를 찾을 수 없습니다.`);
+      return;
+    }
+    const entryFilePath = path.resolve(pkg.rootPath, entryFileRelPath);
+
+    this._logger.log(`서버(${pkg.name}) 재시작...`);
+    const serverInfo = this._serverInfoMap.getOrCreate(pkg.name, {});
+    if (serverInfo.server) {
+      await serverInfo.server.closeAsync();
+      delete serverInfo.server;
+    }
+
+    serverInfo.server = (await import("file:///" + entryFilePath + "?update=" + Uuid.new().toString())).default as SdServiceServer | undefined;
+    if (!serverInfo.server) {
+      this._logger.error(`${entryFilePath}(0, 0): 'SdServiceServer'를 'export'해야 합니다.`);
+      return;
+    }
+
+    await Wait.until(() => serverInfo.server!.isOpen);
+
+    this._logger.log(`서버(${pkg.name}) 재시작 완료`);
+  }
+
   public async buildAsync(opt: { confFileRelPath: string; optNames: string[] }): Promise<void> {
     this._logger.debug("프로젝트 설정 가져오기...");
     const config = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), false, opt.optNames);
@@ -148,9 +154,9 @@ export class SdCliWorkspace {
     // GIT 사용중일 경우, 커밋되지 않은 수정사항이 있는지 확인
     if (FsUtil.exists(path.resolve(process.cwd(), ".git"))) {
       this._logger.debug("GIT 커밋여부 확인...");
-      const gitStatusResult = await SdProcess.execAsync("git status");
+      const gitStatusResult = await SdProcess.spawnAsync("git status");
       if (gitStatusResult.includes("Changes") || gitStatusResult.includes("Untracked")) {
-        throw new Error("커밋되지 않은 정보가 있습니다.");
+        throw new Error("커밋되지 않은 정보가 있습니다.\n" + gitStatusResult);
       }
     }
 
@@ -160,6 +166,9 @@ export class SdCliWorkspace {
     this._logger.debug("프로젝트 및 패키지 버전 설정...");
     await this._upgradeVersionAsync(pkgs);
 
+    this._logger.debug("노드패키지 업데이트...");
+    await new SdCliNpm(this._rootPath).updateAsync();
+
     // 빌드
     if (!opt.noBuild) {
       this._logger.debug("빌드를 시작합니다...");
@@ -169,9 +178,9 @@ export class SdCliWorkspace {
     // GIT 사용중일경우, 새 버전 커밋 및 TAG 생성
     if (FsUtil.exists(path.resolve(process.cwd(), ".git"))) {
       this._logger.debug("새 버전 커밋 및 TAG 생성...");
-      await SdProcess.execAsync("git add .");
-      await SdProcess.execAsync(`git commit -m "v${this._npmConfig.version}"`);
-      await SdProcess.execAsync(`git tag -a "v${this._npmConfig.version}" -m "v${this._npmConfig.version}"`);
+      await SdProcess.spawnAsync("git add .");
+      await SdProcess.spawnAsync(`git commit -m "v${this._npmConfig.version}"`);
+      await SdProcess.spawnAsync(`git tag -a "v${this._npmConfig.version}" -m "v${this._npmConfig.version}"`);
     }
 
     this._logger.debug("배포 시작...");

package/src/packages/SdCliPackage.ts

@@ -5,6 +5,8 @@ import { EventEmitter } from "events";
 import { ObjectUtil } from "@simplysm/sd-core-common";
 import { SdCliTsLibBuilder } from "../builder/SdCliTsLibBuilder";
 import { SdCliJsLibBuilder } from "../builder/SdCliJsLibBuilder";
+import { SdCliServerBuilder } from "../builder/SdCliServerBuilder";
+import { SdCliNpmConfigUtil } from "../utils/SdCliNpmConfigUtil";
 
 export class SdCliPackage extends EventEmitter {
   private readonly _npmConfig: INpmConfig;
@@ -27,10 +29,8 @@ export class SdCliPackage extends EventEmitter {
 
   public get allDependencies(): string[] {
     return [
-      ...Object.keys(this._npmConfig.dependencies ?? {}),
-      ...Object.keys(this._npmConfig.optionalDependencies ?? {}),
-      ...Object.keys(this._npmConfig.devDependencies ?? {}),
-      ...Object.keys(this._npmConfig.peerDependencies ?? {})
+      ...SdCliNpmConfigUtil.getDependencies(this._npmConfig).defaults,
+      ...SdCliNpmConfigUtil.getDependencies(this._npmConfig).optionals
     ].distinct();
   }
 
@@ -70,16 +70,7 @@ export class SdCliPackage extends EventEmitter {
   }
 
   public async watchAsync(): Promise<void> {
-    const isTs = FsUtil.exists(path.resolve(this.rootPath, "tsconfig.json"));
-
-    if (isTs) {
-      await this._genBuildTsconfigAsync();
-    }
-
-    const isAngular = isTs && this.allDependencies.includes("@angular/core");
-    const builder = !isTs ? new SdCliJsLibBuilder(this.rootPath) : new SdCliTsLibBuilder(this.rootPath, isAngular);
-
-    await builder
+    await (await this._createBuilderAsync())
       .on("change", () => {
         this.emit("change");
       })
@@ -90,21 +81,28 @@ export class SdCliPackage extends EventEmitter {
   }
 
   public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
+    return await (await this._createBuilderAsync()).buildAsync();
+  }
+
+  public async publishAsync(): Promise<void> {
+    if (this._config.type === "library" && this._config.publish === "npm") {
+      await SdProcess.spawnAsync("npm publish --quiet --access public", { cwd: this.rootPath });
+    }
+  }
+
+  private async _createBuilderAsync(): Promise<SdCliJsLibBuilder | SdCliTsLibBuilder | SdCliServerBuilder> {
     const isTs = FsUtil.exists(path.resolve(this.rootPath, "tsconfig.json"));
 
     if (isTs) {
       await this._genBuildTsconfigAsync();
     }
 
-    const isAngular = isTs && this.allDependencies.includes("@angular/core");
-    const builder = isTs ? new SdCliTsLibBuilder(this.rootPath, isAngular) : new SdCliJsLibBuilder(this.rootPath);
-
-    return await builder.buildAsync();
-  }
-
-  public async publishAsync(): Promise<void> {
-    if (this._config.type === "library" && this._config.publish === "npm") {
-      await SdProcess.execAsync("npm publish --quiet --access public", { cwd: this.rootPath });
+    if (this._config.type === "library") {
+      // const isAngular = isTs && this.allDependencies.includes("@angular/core");
+      return isTs ? new SdCliTsLibBuilder(this.rootPath) : new SdCliJsLibBuilder(this.rootPath);
+    }
+    else {
+      return new SdCliServerBuilder(this.rootPath, this._config, this._workspaceRootPath);
     }
   }
 

package/src/utils/SdCliBuildResultUtil.ts

@@ -2,9 +2,10 @@ import ts from "typescript";
 import * as os from "os";
 import * as path from "path";
 import { ISdCliPackageBuildResult } from "../commons";
+import webpack from "webpack";
 
 export class SdCliBuildResultUtil {
-  public static convertDiagsToResult(diag: ts.Diagnostic): ISdCliPackageBuildResult | undefined {
+  public static convertFromTsDiag(diag: ts.Diagnostic): ISdCliPackageBuildResult | undefined {
     const severity = diag.category === ts.DiagnosticCategory.Error ? "error"
       : diag.category === ts.DiagnosticCategory.Warning ? "warning"
         : undefined;
@@ -29,6 +30,34 @@ export class SdCliBuildResultUtil {
     };
   }
 
+  public static convertFromWebpackStats(stats: webpack.Stats): ISdCliPackageBuildResult[] {
+    const results: ISdCliPackageBuildResult[] = [];
+
+    for (const statWarn of stats.compilation.warnings) {
+      if (stats.compilation.options.ignoreWarnings?.some((ignoreWarning) => ignoreWarning(statWarn, stats.compilation))) continue;
+
+      results.push(this._convertFromWebpackError("warning", statWarn));
+    }
+
+    for (const statErr of stats.compilation.errors) {
+      results.push(this._convertFromWebpackError("error", statErr));
+    }
+
+    return results;
+  }
+
+  private static _convertFromWebpackError(severity: "warning" | "error", err: webpack.WebpackError): ISdCliPackageBuildResult {
+    return {
+      filePath: err.file,
+      line: err.loc["start"].line,
+      char: err.loc["start"].column,
+      code: err.name,
+      severity,
+      message: err.message
+    };
+  }
+
+
   public static getMessage(result: ISdCliPackageBuildResult): string {
     let str = "";
     if (result.filePath !== undefined) {

package/src/utils/SdCliNpmConfigUtil.ts

@@ -0,0 +1,16 @@
+import { INpmConfig } from "../commons";
+
+export class SdCliNpmConfigUtil {
+  public static getDependencies(npmConfig: INpmConfig): { defaults: string[]; optionals: string[] } {
+    return {
+      defaults: [
+        ...Object.keys(npmConfig.dependencies ?? {}),
+        ...Object.keys(npmConfig.peerDependencies ?? {}).filter((item) => !npmConfig.peerDependenciesMeta?.[item].optional)
+      ].distinct(),
+      optionals: [
+        ...Object.keys(npmConfig.optionalDependencies ?? {}),
+        ...Object.keys(npmConfig.peerDependencies ?? {}).filter((item) => npmConfig.peerDependenciesMeta?.[item].optional)
+      ].distinct()
+    };
+  }
+}