@simplysm/sd-cli 7.0.23 → 7.0.24

package/src/builder/SdCliServerBuilder.ts

@@ -0,0 +1,287 @@
+import { INpmConfig, ISdCliPackageBuildResult, ISdCliServerPackageConfig } from "../commons";
+import { EventEmitter } from "events";
+import { FsUtil, Logger, PathUtil } from "@simplysm/sd-core-node";
+import webpack from "webpack";
+import path from "path";
+import ts from "typescript";
+import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
+import { ErrorInfo } from "ts-loader/dist/interfaces";
+import os from "os";
+import { ESLint } from "eslint";
+import webpackMerge from "webpack-merge";
+import TerserPlugin from "terser-webpack-plugin";
+import { StringUtil } from "@simplysm/sd-core-common";
+import { SdCliNpmConfigUtil } from "../utils/SdCliNpmConfigUtil";
+import ESLintWebpackPlugin from "eslint-webpack-plugin";
+import CopyWebpackPlugin from "copy-webpack-plugin";
+import LintResult = ESLint.LintResult;
+
+export class SdCliServerBuilder extends EventEmitter {
+  private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
+
+  private readonly _parsedTsconfig: ts.ParsedCommandLine;
+  private readonly _npmConfigMap = new Map<string, INpmConfig>();
+
+  public constructor(private readonly _rootPath: string,
+                     private readonly _config: ISdCliServerPackageConfig,
+                     private readonly _workspaceRootPath: string) {
+    super();
+
+    // tsconfig
+    const tsconfigFilePath = path.resolve(this._rootPath, "tsconfig-build.json");
+    const tsconfig = FsUtil.readJson(tsconfigFilePath);
+    this._parsedTsconfig = ts.parseJsonConfigFileContent(tsconfig, ts.sys, this._rootPath);
+  }
+
+  public override on(event: "change", listener: () => void): this;
+  public override on(event: "complete", listener: (results: ISdCliPackageBuildResult[]) => void): this;
+  public override on(event: string | symbol, listener: (...args: any[]) => void): this {
+    return super.on(event, listener);
+  }
+
+  public async watchAsync(): Promise<void> {
+  }
+
+  public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
+    // DIST 비우기
+    await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
+
+    // 빌드 준비
+    const extModuleNames = this._findExternalModules(false).map((item) => item.name);
+
+    // 빌드
+    this._logger.debug("Webpack 빌드 수행...");
+    const webpackConfig = this._getWebpackBuildConfig(extModuleNames);
+    const compiler = webpack(webpackConfig);
+    const buildResults = await new Promise<ISdCliPackageBuildResult[]>((resolve, reject) => {
+      compiler.run((err, stats) => {
+        if (err != null || stats == null) {
+          reject(err);
+          return;
+        }
+
+        // 결과 리턴
+        const results = SdCliBuildResultUtil.convertFromWebpackStats(stats);
+        resolve(results);
+      });
+    });
+    this._logger.debug("Webpack 빌드 완료");
+
+    return buildResults;
+  }
+
+  private get _webpackCommonConfig(): webpack.Configuration {
+    return {
+      devtool: false,
+      target: ["node", "es2020"],
+      profile: false,
+      resolve: {
+        roots: [this._rootPath],
+        extensions: [".ts", ".js", ".mjs", ".cjs"],
+        symlinks: true,
+        mainFields: ["es2020", "default", "module", "main"]
+      },
+      context: this._workspaceRootPath,
+      entry: {
+        main: [
+          path.resolve(this._rootPath, "src/main.ts")
+        ]
+      },
+      output: {
+        clean: true,
+        path: this._parsedTsconfig.options.outDir,
+        filename: "[name].js",
+        chunkFilename: "[name].js",
+        assetModuleFilename: "resources/[name][ext][query]"
+      },
+      performance: { hints: false },
+      node: false,
+      stats: "errors-warnings",
+      module: {
+        strictExportPresence: true,
+        rules: [
+          {
+            test: /\.ts$/,
+            exclude: /node_modules/,
+            loader: "ts-loader",
+            options: {
+              compilerOptions: this._parsedTsconfig.options,
+              errorFormatter: (msg: ErrorInfo) => {
+                return SdCliBuildResultUtil.getMessage({
+                  filePath: msg.file,
+                  line: msg.line,
+                  char: msg.character,
+                  code: "TS" + msg.code.toString(),
+                  severity: msg.severity,
+                  message: msg.content
+                });
+              }
+            }
+          },
+          {
+            test: /\.(png|jpe?g|gif|svg|woff|woff2|ttf|eot|ico|otf|xlsx?|pptx?|docx?|zip|pfx|pkl)$/,
+            type: "asset/resource"
+          }
+        ]
+      },
+      plugins: [
+        new CopyWebpackPlugin({
+          patterns: ["assets/"].map((item) => ({
+            context: this._rootPath,
+            to: item,
+            from: `src/${item}`,
+            noErrorOnMissing: true,
+            force: true,
+            globOptions: {
+              dot: true,
+              followSymbolicLinks: false,
+              ignore: [
+                ".gitkeep",
+                "**/.DS_Store",
+                "**/Thumbs.db"
+              ].map((i) => PathUtil.posix(this._rootPath, i))
+            },
+            priority: 0
+          }))
+        }),
+        new webpack.EnvironmentPlugin({
+          SD_VERSION: this._getNpmConfig(this._rootPath)!.version,
+          ...this._config.env
+        }),
+        new ESLintWebpackPlugin({
+          context: this._rootPath,
+          extensions: ["ts", "js", "mjs", "cjs"],
+          fix: false,
+          threads: false,
+          formatter: (results: LintResult[]) => {
+            const resultMessages: string[] = [];
+            for (const result of results) {
+              for (const msg of result.messages) {
+                const severity = msg.severity === 1 ? "warning" : msg.severity === 2 ? "error" : undefined;
+                if (severity === undefined) continue;
+
+                resultMessages.push(SdCliBuildResultUtil.getMessage({
+                  filePath: result.filePath,
+                  line: msg.line,
+                  char: msg.column,
+                  code: msg.ruleId?.toString(),
+                  severity,
+                  message: msg.message
+                }));
+              }
+            }
+            return resultMessages.join(os.EOL);
+          }
+        }),
+        new webpack.ProgressPlugin({
+          handler: (per: number, msg: string, ...args: string[]) => {
+            const phaseText = msg ? ` - phase: ${msg}` : "";
+            const argsText = args.length > 0 ? ` - args: [${args.join(", ")}]` : "";
+            this._logger.debug(`Webpack 빌드 수행중...(${Math.round(per * 100)}%)${phaseText}${argsText}`);
+          }
+        })
+      ]
+    };
+  }
+
+  private _getWebpackWatchConfig(extModuleNames: string[]): webpack.Configuration {
+    const internalModuleCachePaths = FsUtil.findAllParentChildDirPaths("node_modules/!(@simplysm)", this._rootPath, this._workspaceRootPath);
+
+    return webpackMerge(this._webpackCommonConfig, {
+      mode: "development",
+      output: {
+        libraryTarget: "umd"
+      },
+      module: {
+        rules: [
+          {
+            test: /\.m?js$/,
+            enforce: "pre",
+            loader: "source-map-loader",
+            options: {
+              filterSourceMappingUrl: (mapUri: string, resourcePath: string) => {
+                return !resourcePath.includes("node_modules") || (/@simplysm[\\/]sd/).test(resourcePath);
+              }
+            }
+          }
+        ]
+      },
+      cache: { type: "memory", maxGenerations: 1 },
+      snapshot: {
+        immutablePaths: internalModuleCachePaths,
+        managedPaths: internalModuleCachePaths
+      },
+      optimization: {
+        moduleIds: "deterministic",
+        chunkIds: "named",
+        emitOnErrors: true
+      },
+      externals: extModuleNames
+    });
+  }
+
+  private _getWebpackBuildConfig(extModuleNames: string[]): webpack.Configuration {
+    return webpackMerge(this._webpackCommonConfig, {
+      mode: "production",
+      output: {
+        libraryTarget: "module"
+      },
+      cache: false,
+      optimization: {
+        minimizer: [
+          new TerserPlugin({
+            terserOptions: {
+              ecma: 2020,
+              sourceMap: false,
+              keep_classnames: true,
+              keep_fnames: true,
+              ie8: false,
+              safari10: false,
+              module: true
+            }
+          })
+        ],
+        moduleIds: "deterministic",
+        chunkIds: "deterministic",
+        emitOnErrors: false
+      },
+      externals: extModuleNames
+    });
+  }
+
+  private _findExternalModules(all: boolean): { name: string; path: string }[] {
+    const loadedModuleNames: string[] = [];
+    const externalModules: { name: string; path: string }[] = [];
+
+    const fn = (currPath: string): void => {
+      const npmConfig = this._getNpmConfig(currPath);
+      if (!npmConfig) return;
+
+
+      for (const moduleName of SdCliNpmConfigUtil.getAllDependencies(npmConfig)) {
+        if (loadedModuleNames.includes(moduleName)) continue;
+        loadedModuleNames.push(moduleName);
+
+        const modulePath = FsUtil.findAllParentChildDirPaths("node_modules/" + moduleName, currPath, this._workspaceRootPath).first();
+        if (StringUtil.isNullOrEmpty(modulePath)) continue;
+
+        if (all || FsUtil.exists(path.resolve(modulePath, "binding.gyp"))) {
+          externalModules.push({ path: modulePath, name: moduleName });
+        }
+
+        fn(modulePath);
+      }
+    };
+
+    fn(this._rootPath);
+
+    return externalModules.distinct();
+  }
+
+  private _getNpmConfig(pkgPath: string): INpmConfig | undefined {
+    if (!this._npmConfigMap.has(pkgPath)) {
+      this._npmConfigMap.set(pkgPath, FsUtil.readJson(path.resolve(pkgPath, "package.json")));
+    }
+    return this._npmConfigMap.get(pkgPath);
+  }
+}

package/src/builder/SdCliTsLibBuilder.ts

@@ -165,7 +165,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
       results.push(
         ...diagnostics
           .filter((item) => [ts.DiagnosticCategory.Error, ts.DiagnosticCategory.Warning].includes(item.category))
-          .map((item) => SdCliBuildResultUtil.convertDiagsToResult(item))
+          .map((item) => SdCliBuildResultUtil.convertFromTsDiag(item))
           .filterExists()
       );
 

package/src/commons.ts

@@ -39,17 +39,14 @@ export interface ISdCliConfig {
   localUpdates?: Record<string, string>;
 }
 
-export type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliNgLibPackageConfig | ISdCliServerPackageConfig;
+export type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliServerPackageConfig;
 
 export interface ISdCliLibPackageConfig {
   type: "library";
   publish?: "npm";
 }
 
-export interface ISdCliNgLibPackageConfig {
-  type: "angular";
-}
-
 export interface ISdCliServerPackageConfig {
   type: "server";
+  env?: Record<string, string>;
 }

package/src/entry-points/SdCliNpm.ts

@@ -0,0 +1,22 @@
+import { Logger, SdProcess } from "@simplysm/sd-core-node";
+import { SdCliPrepare } from "./SdCliPrepare";
+
+export class SdCliNpm {
+  private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
+
+  public constructor(private readonly _rootPath: string) {
+  }
+
+  public async updateAsync(): Promise<void> {
+    this._logger.debug("업데이트할 패키지 확인...");
+    await SdProcess.execAsync("npm outdated", { cwd: this._rootPath });
+
+    this._logger.debug("업데이트 시작...");
+    await SdProcess.execAsync("npm update", { cwd: this._rootPath });
+
+    this._logger.debug("sd-cli 준비...");
+    await new SdCliPrepare().prepareAsync();
+
+    this._logger.info("노드 패키지 업데이트 완료");
+  }
+}

package/src/entry-points/SdCliPrepare.ts

@@ -0,0 +1,54 @@
+import { FsUtil, Logger } from "@simplysm/sd-core-node";
+
+export class SdCliPrepare {
+  private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
+
+  public async prepareAsync(): Promise<void> {
+    // 타입체크 속도 지연 메시지 추가
+    const r1 = await this._modifyTypescriptCodeForTypeCheckPerformanceWarning();
+    this._logger.log(`[모듈수정] 타입체크 속도 지연 메시지 추가 (${r1 ? "O" : "X"})`);
+  }
+
+  private async _modifyTypescriptCodeForTypeCheckPerformanceWarning(): Promise<boolean> {
+    const fileUrl = await import.meta.resolve!("typescript");
+    const filePath = fileUrl.replace(/^file:\/\/\//, "");
+    const fileContent = await FsUtil.readFileAsync(filePath);
+    const modifiedFileContent = fileContent.replace(`
+        function checkSourceElement(node) {
+            if (node) {
+                var saveCurrentNode = currentNode;
+                currentNode = node;
+                instantiationCount = 0;
+                checkSourceElementWorker(node);
+                currentNode = saveCurrentNode;
+            }
+        }`, `
+        function checkSourceElement(node) {
+            if (node) {
+                const prevUsage = process.cpuUsage();
+
+                var saveCurrentNode = currentNode;
+                currentNode = node;
+                instantiationCount = 0;
+                checkSourceElementWorker(node);
+                currentNode = saveCurrentNode;
+
+                const usage = process.cpuUsage(prevUsage);
+                if (node.hasChildPerformanceWarning) {
+                    node.parent.hasChildPerformanceWarning = true;
+                }
+                else if (usage.user + usage.system > 2000 * 1000 && node.kind !== 253) {
+                    error(node, {
+                        code: 9000,
+                        category: ts.DiagnosticCategory.Warning,
+                        key: "simplysm_check_source_element_performance_slow",
+                        message: "소스코드 타입분석에 너무 오랜 시간이 소요됩니다. [" + Math.round((usage.user + usage.system) / 1000) + "ms/cpu, KIND: " + node.kind + "]"
+                    });
+                    node.parent.hasChildPerformanceWarning = true;
+                }
+            }
+        }`);
+    await FsUtil.writeFileAsync(filePath, modifiedFileContent);
+    return fileContent !== modifiedFileContent;
+  }
+}

package/src/entry-points/SdCliWorkspace.ts

@@ -2,13 +2,13 @@ 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";
 
 export class SdCliWorkspace {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
@@ -40,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);
 
@@ -52,40 +60,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 +72,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 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);
@@ -160,6 +160,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("빌드를 시작합니다...");

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 { SdCliNpmConfigUtil } from "../utils/SdCliNpmConfigUtil";
+import { SdCliServerBuilder } from "../builder/SdCliServerBuilder";
 
 export class SdCliPackage extends EventEmitter {
   private readonly _npmConfig: INpmConfig;
@@ -26,12 +28,7 @@ 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 ?? {})
-    ].distinct();
+    return SdCliNpmConfigUtil.getAllDependencies(this._npmConfig);
   }
 
   public constructor(private readonly _workspaceRootPath: string,
@@ -76,8 +73,15 @@ export class SdCliPackage extends EventEmitter {
       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", () => {

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/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();
+  }
+}