@simplysm/sd-cli 7.0.20 → 7.0.24

package/src/entry-points/SdCliWorkspace.ts

@@ -2,28 +2,31 @@ 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 { SdCliNpm } from "./SdCliNpm";
 
 export class SdCliWorkspace {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
 
   private readonly _npmConfig: INpmConfig;
-  private readonly _config: ISdCliConfig;
+  private readonly _serverInfoMap = new Map<string, IServerInfo>();
 
-  public constructor(private readonly _rootPath: string,
-                     private readonly _configFilePath?: string) {
+  public constructor(private readonly _rootPath: string) {
     const npmConfigFilePath = path.resolve(this._rootPath, "package.json");
     this._npmConfig = FsUtil.readJson(npmConfigFilePath);
-
-    this._config = FsUtil.readJson(path.resolve(this._rootPath, this._configFilePath ?? "simplysm.json"));
   }
 
-  public async watchAsync(): Promise<void> {
+  public async watchAsync(opt: { confFileRelPath: string; optNames: string[] }): Promise<void> {
+    this._logger.debug("프로젝트 설정 가져오기...");
+    const config = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), true, opt.optNames);
+
     this._logger.debug("패키지 목록 구성...");
-    const pkgs = await this._getPackagesAsync();
+    const pkgs = await this._getPackagesAsync(config);
 
     this._logger.debug("패키지 이벤트 설정...");
     let changeCount = 0;
@@ -37,7 +40,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);
 
@@ -61,9 +72,38 @@ export class SdCliWorkspace {
     });
   }
 
-  public async buildAsync(): Promise<void> {
+  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 instanceof SdServiceServer)) {
+      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);
+
     this._logger.debug("패키지 목록 구성...");
-    const pkgs = await this._getPackagesAsync();
+    const pkgs = await this._getPackagesAsync(config);
 
     this._logger.debug("프로젝트 및 패키지 버전 설정...");
     await this._upgradeVersionAsync(pkgs);
@@ -96,7 +136,10 @@ export class SdCliWorkspace {
     }
   }
 
-  public async publishAsync(opt: { noBuild: boolean }): Promise<void> {
+  public async publishAsync(opt: { noBuild: boolean; confFileRelPath: string; optNames: string[] }): Promise<void> {
+    this._logger.debug("프로젝트 설정 가져오기...");
+    const config = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), false, opt.optNames);
+
     if (opt.noBuild) {
       this._logger.warn("빌드하지 않고, 배포하는것은 상당히 위험합니다.");
       await this._waitSecMessageAsync("프로세스를 중지하려면, 'CTRL+C'를 누르세요.", 5);
@@ -112,11 +155,14 @@ export class SdCliWorkspace {
     }
 
     this._logger.debug("패키지 목록 구성...");
-    const pkgs = await this._getPackagesAsync();
+    const pkgs = await this._getPackagesAsync(config);
 
     this._logger.debug("프로젝트 및 패키지 버전 설정...");
     await this._upgradeVersionAsync(pkgs);
 
+    this._logger.debug("노드패키지 업데이트...");
+    await new SdCliNpm(this._rootPath).updateAsync();
+
     // 빌드
     if (!opt.noBuild) {
       this._logger.debug("빌드를 시작합니다...");
@@ -182,14 +228,14 @@ export class SdCliWorkspace {
     process.stdout.clearLine(0);
   }
 
-  private async _getPackagesAsync(): Promise<SdCliPackage[]> {
+  private async _getPackagesAsync(conf: ISdCliConfig): Promise<SdCliPackage[]> {
     const pkgRootPaths = await this._npmConfig.workspaces?.mapManyAsync(async (item) => await FsUtil.globAsync(item));
     if (!pkgRootPaths) {
       throw new Error("최상위 'package.json'에서 'workspaces'를 찾을 수 없습니다.");
     }
 
     return pkgRootPaths.map((pkgRootPath) => {
-      const pkgConfig = this._config.packages[path.basename(pkgRootPath)];
+      const pkgConfig = conf.packages[path.basename(pkgRootPath)];
       return pkgConfig ? new SdCliPackage(this._rootPath, pkgRootPath, pkgConfig) : undefined;
     }).filterExists();
   }
@@ -227,3 +273,7 @@ export class SdCliWorkspace {
     }
   }
 }
+
+interface IServerInfo {
+  server?: SdServiceServer;
+}

package/src/packages/SdCliPackage.ts

@@ -5,29 +5,38 @@ import { EventEmitter } from "events";
 import { ObjectUtil } from "@simplysm/sd-core-common";
 import { SdCliTsLibBuilder } from "../builder/SdCliTsLibBuilder";
 import { SdCliJsLibBuilder } from "../builder/SdCliJsLibBuilder";
+import { SdCliNpmConfigUtil } from "../utils/SdCliNpmConfigUtil";
+import { SdCliServerBuilder } from "../builder/SdCliServerBuilder";
 
 export class SdCliPackage extends EventEmitter {
   private readonly _npmConfig: INpmConfig;
 
+  public get basename(): string {
+    return path.basename(this._workspaceRootPath);
+  }
+
   public get name(): string {
     return this._npmConfig.name;
   }
 
+  public get main(): string | undefined {
+    return this._npmConfig.main;
+  }
+
+  public get type(): TSdCliPackageConfig["type"] {
+    return this._config.type;
+  }
+
   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 ?? {})
-    ].distinct();
+    return SdCliNpmConfigUtil.getAllDependencies(this._npmConfig);
   }
 
   public constructor(private readonly _workspaceRootPath: string,
-                     private readonly _rootPath: string,
+                     public readonly rootPath: string,
                      private readonly _config: TSdCliPackageConfig) {
     super();
 
-    const npmConfigFilePath = path.resolve(this._rootPath, "package.json");
+    const npmConfigFilePath = path.resolve(this.rootPath, "package.json");
     this._npmConfig = FsUtil.readJson(npmConfigFilePath);
   }
 
@@ -53,19 +62,26 @@ export class SdCliPackage extends EventEmitter {
     updateDepVersion(this._npmConfig.devDependencies);
     updateDepVersion(this._npmConfig.peerDependencies);
 
-    const npmConfigFilePath = path.resolve(this._rootPath, "package.json");
+    const npmConfigFilePath = path.resolve(this.rootPath, "package.json");
     await FsUtil.writeJsonAsync(npmConfigFilePath, this._npmConfig, { space: 2 });
   }
 
   public async watchAsync(): Promise<void> {
-    const isTs = FsUtil.exists(path.resolve(this._rootPath, "tsconfig.json"));
+    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);
+    let builder: SdCliJsLibBuilder | SdCliTsLibBuilder | SdCliServerBuilder;
+
+    if (this._config.type === "library") {
+      const isAngular = isTs && this.allDependencies.includes("@angular/core");
+      builder = !isTs ? new SdCliJsLibBuilder(this.rootPath) : new SdCliTsLibBuilder(this.rootPath, isAngular);
+    }
+    else {
+      builder = new SdCliServerBuilder(this.rootPath, this._config, this._workspaceRootPath);
+    }
 
     await builder
       .on("change", () => {
@@ -78,26 +94,26 @@ export class SdCliPackage extends EventEmitter {
   }
 
   public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
-    const isTs = FsUtil.exists(path.resolve(this._rootPath, "tsconfig.json"));
+    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);
+    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 });
+      await SdProcess.execAsync("npm publish --quiet --access public", { cwd: this.rootPath });
     }
   }
 
   private async _genBuildTsconfigAsync(): Promise<void> {
-    const baseTsconfigFilePath = path.resolve(this._rootPath, "tsconfig.json");
+    const baseTsconfigFilePath = path.resolve(this.rootPath, "tsconfig.json");
     const baseTsconfig: ITsconfig = await FsUtil.readJsonAsync(baseTsconfigFilePath);
 
     const buildTsconfig: ITsconfig = ObjectUtil.clone(baseTsconfig);
@@ -105,7 +121,7 @@ export class SdCliPackage extends EventEmitter {
     delete buildTsconfig.compilerOptions.baseUrl;
     delete buildTsconfig.compilerOptions.paths;
 
-    const buildTsconfigFilePath = path.resolve(this._rootPath, "tsconfig-build.json");
+    const buildTsconfigFilePath = path.resolve(this.rootPath, "tsconfig-build.json");
     await FsUtil.writeJsonAsync(buildTsconfigFilePath, buildTsconfig, { space: 2 });
   }
 }

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,35 @@ 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 {
+    console.log(err);
+    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/SdCliConfigUtil.ts

@@ -4,15 +4,15 @@ import { ObjectUtil } from "@simplysm/sd-core-common";
 import path from "path";
 
 export class SdCliConfigUtil {
-  public static loadConfig(confFilePath: string, isDev: boolean, opts?: string[]): ISdCliConfig {
-    const confFileCont = FsUtil.readJson(confFilePath);
+  public static async loadConfigAsync(confFilePath: string, isDev: boolean, opts?: string[]): Promise<ISdCliConfig> {
+    const confFileCont = await FsUtil.readJsonAsync(confFilePath);
     let conf = this._getConfigFromFileContent(confFileCont, isDev, opts);
 
     // extends
     if (conf.extends) {
       for (const extConfFilePath of conf.extends) {
-        const extConf = this.loadConfig(path.resolve(path.dirname(confFilePath), extConfFilePath), isDev, opts);
-        conf = this._mergeObj(conf, extConf);
+        const extConf = await this.loadConfigAsync(path.resolve(path.dirname(confFilePath), extConfFilePath), isDev, opts);
+        conf = this._mergeObj(extConf, conf);
       }
     }
     delete conf["extends"];

package/src/utils/SdCliNpmConfigUtil.ts

@@ -0,0 +1,12 @@
+import { INpmConfig } from "../commons";
+
+export class SdCliNpmConfigUtil {
+  public static getAllDependencies(npmConfig: INpmConfig): string[] {
+    return [
+      ...Object.keys(npmConfig.dependencies ?? {}),
+      ...Object.keys(npmConfig.optionalDependencies ?? {}),
+      ...Object.keys(npmConfig.devDependencies ?? {}),
+      ...Object.keys(npmConfig.peerDependencies ?? {})
+    ].distinct();
+  }
+}

package/tsconfig.json

@@ -12,7 +12,10 @@
       ],
       "@simplysm/sd-core-common": [
         "../sd-core-common/src/index.ts"
+      ],
+      "@simplysm/sd-service/server": [
+        "../sd-service/src/server.ts"
       ]
     }
   }
-}
+}