@simplysm/sd-cli 6.4.6 → 7.0.12

package/src/entry-points/SdCliWorkspace.ts

@@ -0,0 +1,229 @@
+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 os from "os";
+import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
+import semver from "semver/preload";
+
+export class SdCliWorkspace {
+  private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
+
+  private readonly _npmConfig: INpmConfig;
+  private readonly _config: ISdCliConfig;
+
+  public constructor(private readonly _rootPath: string,
+                     private readonly _configFilePath?: 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> {
+    this._logger.debug("패키지 목록 구성...");
+    const pkgs = await this._getPackagesAsync();
+
+    this._logger.debug("패키지 이벤트 설정...");
+    let changeCount = 0;
+    const totalResultMap = new Map<string, ISdCliPackageBuildResult[]>();
+    for (const pkg of pkgs) {
+      pkg
+        .on("change", () => {
+          if (changeCount === 0) {
+            this._logger.log("빌드를 시작합니다...");
+          }
+          changeCount++;
+          this._logger.debug(`[${pkg.name}] 빌드를 시작합니다...`);
+        })
+        .on("complete", (results) => {
+          this._logger.debug(`[${pkg.name}] 빌드가 완료되었습니다.`);
+          totalResultMap.set(pkg.name, results);
+
+          setTimeout(() => {
+            changeCount--;
+            if (changeCount === 0) {
+              this._loggingResults(totalResultMap);
+              this._logger.info("모든 빌드가 완료되었습니다.");
+            }
+          }, 500);
+        });
+    }
+
+    this._logger.debug("빌드를 시작합니다...");
+    const pkgNames = pkgs.map((item) => item.name);
+    const buildCompletedPackageNames: string[] = [];
+    await pkgs.parallelAsync(async (pkg) => {
+      await Wait.until(() => !pkg.allDependencies.some((dep) => pkgNames.includes(dep) && !buildCompletedPackageNames.includes(dep)));
+      await pkg.watchAsync();
+      buildCompletedPackageNames.push(pkg.name);
+    });
+  }
+
+  public async buildAsync(): Promise<void> {
+    this._logger.debug("패키지 목록 구성...");
+    const pkgs = await this._getPackagesAsync();
+
+    this._logger.debug("프로젝트 및 패키지 버전 설정...");
+    await this._upgradeVersionAsync(pkgs);
+
+    // 빌드
+    await this._buildPkgsAsync(pkgs);
+  }
+
+  private async _buildPkgsAsync(pkgs: SdCliPackage[]): Promise<void> {
+    this._logger.debug("빌드를 시작합니다...");
+    const pkgNames = pkgs.map((item) => item.name);
+    const buildCompletedPackageNames: string[] = [];
+    const totalResultMap = new Map<string, ISdCliPackageBuildResult[]>();
+    await pkgs.parallelAsync(async (pkg) => {
+      await Wait.until(() => !pkg.allDependencies.some((dep) => pkgNames.includes(dep) && !buildCompletedPackageNames.includes(dep)));
+
+      this._logger.debug(`[${pkg.name}] 빌드를 시작합니다...`);
+      totalResultMap.set(pkg.name, await pkg.buildAsync());
+      this._logger.debug(`[${pkg.name}] 빌드가 완료되었습니다.`);
+
+      buildCompletedPackageNames.push(pkg.name);
+    });
+
+    this._loggingResults(totalResultMap);
+    if (Array.from(totalResultMap.values()).mapMany().some((item) => item.severity === "error")) {
+      throw new Error("빌드중 오류가 발생하였습니다.");
+    }
+    else {
+      this._logger.info("모든 빌드가 완료되었습니다.");
+    }
+  }
+
+  public async publishAsync(opt: { noBuild: boolean }): Promise<void> {
+    if (opt.noBuild) {
+      this._logger.warn("빌드하지 않고, 배포하는것은 상당히 위험합니다.");
+      await this._waitSecMessageAsync("프로세스를 중지하려면, 'CTRL+C'를 누르세요.", 5);
+    }
+
+    // GIT 사용중일 경우, 커밋되지 않은 수정사항이 있는지 확인
+    if (FsUtil.exists(path.resolve(process.cwd(), ".git"))) {
+      this._logger.debug("GIT 커밋여부 확인...");
+      const gitStatusResult = await SdProcess.execAsync("git status");
+      if (gitStatusResult.includes("Changes") || gitStatusResult.includes("Untracked")) {
+        throw new Error("커밋되지 않은 정보가 있습니다.");
+      }
+    }
+
+    this._logger.debug("패키지 목록 구성...");
+    const pkgs = await this._getPackagesAsync();
+
+    this._logger.debug("프로젝트 및 패키지 버전 설정...");
+    await this._upgradeVersionAsync(pkgs);
+
+    // 빌드
+    if (!opt.noBuild) {
+      this._logger.debug("빌드를 시작합니다...");
+      await this._buildPkgsAsync(pkgs);
+    }
+
+    // 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}"`);
+    }
+
+    this._logger.debug("배포 시작...");
+    await pkgs.parallelAsync(async (pkg) => {
+      this._logger.debug(`[${pkg.name}] 배포를 시작합니다...`);
+      await pkg.publishAsync();
+      this._logger.debug(`[${pkg.name}] 배포가 완료되었습니다.`);
+    });
+    this._logger.info(`모든 배포가 완료되었습니다. (v${this._npmConfig.version})`);
+  }
+
+  private async _upgradeVersionAsync(pkgs: SdCliPackage[]): Promise<void> {
+    // 작업공간 package.json 버전 설정
+    const newVersion = semver.inc(this._npmConfig.version, "patch")!;
+    this._npmConfig.version = newVersion;
+
+    const pkgNames = pkgs.map((item) => item.name);
+
+    const updateDepVersion = (deps: Record<string, string> | undefined): void => {
+      if (!deps) return;
+      for (const depName of Object.keys(deps)) {
+        if (pkgNames.includes(depName)) {
+          deps[depName] = newVersion;
+        }
+      }
+    };
+    updateDepVersion(this._npmConfig.dependencies);
+    updateDepVersion(this._npmConfig.optionalDependencies);
+    updateDepVersion(this._npmConfig.devDependencies);
+    updateDepVersion(this._npmConfig.peerDependencies);
+
+    const npmConfigFilePath = path.resolve(this._rootPath, "package.json");
+    await FsUtil.writeJsonAsync(npmConfigFilePath, this._npmConfig, { space: 2 });
+
+    // 각 패키지 package.json 버전 설정
+    await pkgs.parallelAsync(async (pkg) => {
+      await pkg.setNewVersionAsync(newVersion, pkgNames);
+    });
+  }
+
+  private async _waitSecMessageAsync(msg: string, sec: number): Promise<void> {
+    for (let i = sec; i > 0; i--) {
+      if (i !== sec) {
+        process.stdout.cursorTo(0);
+      }
+      process.stdout.write(msg + " " + i);
+      await Wait.time(1000);
+    }
+
+    process.stdout.cursorTo(0);
+    process.stdout.clearLine(0);
+  }
+
+  private async _getPackagesAsync(): 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)];
+      return pkgConfig ? new SdCliPackage(this._rootPath, pkgRootPath, pkgConfig) : undefined;
+    }).filterExists();
+  }
+
+  private _loggingResults(totalResultMap: Map<string, ISdCliPackageBuildResult[]>): void {
+    const totalResults = Array.from(totalResultMap.entries())
+      .mapMany((item) => item[1].map((item1) => ({
+        pkgName: item[0],
+        ...item1
+      })))
+      .orderBy((item) => item.pkgName + "_" + item.filePath);
+
+    const warnings = totalResults
+      .filter((item) => item.severity === "warning")
+      .map((item) => `${SdCliBuildResultUtil.getMessage(item)} (${item.pkgName})`)
+      .distinct();
+
+    const errors = totalResults
+      .filter((item) => item.severity === "error")
+      .map((item) => `${SdCliBuildResultUtil.getMessage(item)} (${item.pkgName})`)
+      .distinct();
+
+    if (warnings.length > 0) {
+      this._logger.warn(`경고 발생${os.EOL}`, warnings.join(os.EOL));
+    }
+    if (errors.length > 0) {
+      this._logger.error(`오류 발생${os.EOL}`, errors.join(os.EOL));
+    }
+
+    if (errors.length > 0) {
+      this._logger.error(`경고: ${warnings.length}건, 오류: ${errors.length}건`);
+    }
+    else if (warnings.length > 0) {
+      this._logger.warn(`경고: ${warnings.length}건, 오류: ${errors.length}건`);
+    }
+  }
+}

package/src/packages/SdCliPackage.ts

@@ -0,0 +1,111 @@
+import { INpmConfig, ISdCliPackageBuildResult, ITsconfig, TSdCliPackageConfig } from "../commons";
+import path from "path";
+import { FsUtil, SdProcess } from "@simplysm/sd-core-node";
+import { EventEmitter } from "events";
+import { ObjectUtil } from "@simplysm/sd-core-common";
+import { SdCliTsLibBuilder } from "../builder/SdCliTsLibBuilder";
+import { SdCliJsLibBuilder } from "../builder/SdCliJsLibBuilder";
+
+export class SdCliPackage extends EventEmitter {
+  private readonly _npmConfig: INpmConfig;
+
+  public get name(): string {
+    return this._npmConfig.name;
+  }
+
+  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();
+  }
+
+  public constructor(private readonly _workspaceRootPath: string,
+                     private readonly _rootPath: string,
+                     private readonly _config: TSdCliPackageConfig) {
+    super();
+
+    const npmConfigFilePath = path.resolve(this._rootPath, "package.json");
+    this._npmConfig = FsUtil.readJson(npmConfigFilePath);
+  }
+
+  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 setNewVersionAsync(newVersion: string, pkgNames: string[]): Promise<void> {
+    this._npmConfig.version = newVersion;
+
+    const updateDepVersion = (deps: Record<string, string> | undefined): void => {
+      if (!deps) return;
+      for (const depName of Object.keys(deps)) {
+        if (pkgNames.includes(depName)) {
+          deps[depName] = newVersion;
+        }
+      }
+    };
+    updateDepVersion(this._npmConfig.dependencies);
+    updateDepVersion(this._npmConfig.optionalDependencies);
+    updateDepVersion(this._npmConfig.devDependencies);
+    updateDepVersion(this._npmConfig.peerDependencies);
+
+    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"));
+
+    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
+      .on("change", () => {
+        this.emit("change");
+      })
+      .on("complete", (results) => {
+        this.emit("complete", results);
+      })
+      .watchAsync();
+  }
+
+  public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
+    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 });
+    }
+  }
+
+  private async _genBuildTsconfigAsync(): Promise<void> {
+    const baseTsconfigFilePath = path.resolve(this._rootPath, "tsconfig.json");
+    const baseTsconfig: ITsconfig = await FsUtil.readJsonAsync(baseTsconfigFilePath);
+
+    const buildTsconfig: ITsconfig = ObjectUtil.clone(baseTsconfig);
+    buildTsconfig.compilerOptions = buildTsconfig.compilerOptions ?? {};
+    delete buildTsconfig.compilerOptions.baseUrl;
+    delete buildTsconfig.compilerOptions.paths;
+
+    const buildTsconfigFilePath = path.resolve(this._rootPath, "tsconfig-build.json");
+    await FsUtil.writeJsonAsync(buildTsconfigFilePath, buildTsconfig, { space: 2 });
+  }
+}

package/src/utils/SdCliBuildResultUtil.ts

@@ -0,0 +1,43 @@
+import ts from "typescript";
+import * as os from "os";
+import * as path from "path";
+import { ISdCliPackageBuildResult } from "../commons";
+
+export class SdCliBuildResultUtil {
+  public static convertDiagsToResult(diag: ts.Diagnostic): ISdCliPackageBuildResult | undefined {
+    const severity = diag.category === ts.DiagnosticCategory.Error ? "error"
+      : diag.category === ts.DiagnosticCategory.Warning ? "warning"
+        : undefined;
+    if (!severity) return undefined;
+
+    const code = "TS" + diag.code;
+    const message = ts.flattenDiagnosticMessageText(diag.messageText, os.EOL);
+
+
+    const filePath = diag.file ? path.resolve(diag.file.fileName) : undefined;
+    const position = diag.file && diag.start !== undefined ? diag.file.getLineAndCharacterOfPosition(diag.start) : undefined;
+    const line = position ? position.line + 1 : undefined;
+    const char = position ? position.character + 1 : undefined;
+
+    return {
+      filePath,
+      line,
+      char,
+      code,
+      severity,
+      message
+    };
+  }
+
+  public static getMessage(result: ISdCliPackageBuildResult): string {
+    let str = "";
+    if (result.filePath !== undefined) {
+      str += `${result.filePath}(${result.line ?? 0}, ${result.char ?? 0}): `;
+    }
+    if (result.code !== undefined) {
+      str += `${result.code}: `;
+    }
+    str += `${result.severity} ${result.message}`;
+    return str;
+  }
+}

package/src/utils/SdCliConfigUtil.ts

@@ -0,0 +1,94 @@
+import { ISdCliConfig, TSdCliPackageConfig } from "../commons";
+import { FsUtil } from "@simplysm/sd-core-node";
+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);
+    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);
+      }
+    }
+    delete conf["extends"];
+
+    return conf as ISdCliConfig;
+  }
+
+  private static _getConfigFromFileContent(confFileCont: ISdCliConfigFileContent, isDev?: boolean, opts?: string[]): ISdCliConfigFileContent {
+    const conf = ObjectUtil.clone(confFileCont);
+
+    if (conf.packages) {
+      for (const pkgName of Object.keys(conf.packages)) {
+        conf.packages[pkgName] = this._getPkgConfigFromFileContent(conf, conf.packages[pkgName], isDev, opts);
+      }
+    }
+    return conf;
+  }
+
+  private static _getPkgConfigFromFileContent(confFileCont: ISdCliConfigFileContent, pkgConfFileCont: TSdCliPackageConfigFileContent, isDev?: boolean, opts?: string[]): TSdCliPackageConfig {
+    let pkgConf = ObjectUtil.clone(pkgConfFileCont);
+
+    // override
+    const pkgOvrNames = pkgConf.overrides;
+    if (pkgOvrNames) {
+      for (const pkgOvrName of pkgOvrNames) {
+        const rootOvr = confFileCont.overrides?.[pkgOvrName];
+        if (rootOvr) {
+          const ovrConf = this._getPkgConfigFromFileContent(confFileCont, rootOvr, isDev, opts);
+          pkgConf = this._mergeObj(pkgConf, ovrConf);
+        }
+      }
+      delete pkgConf.overrides;
+    }
+
+
+    // mode 처리
+    const mode = isDev ? "dev" : "prod";
+    if (pkgConf[mode] !== undefined) {
+      const modeConf = this._getPkgConfigFromFileContent(confFileCont, pkgConf[mode], isDev, opts);
+      pkgConf = this._mergeObj(pkgConf, modeConf);
+    }
+    delete pkgConf["dev"];
+    delete pkgConf["prod"];
+
+    // options
+    if (opts && opts.length > 0) {
+      const pkgOpts = Object.keys(pkgConf).filter((key) => key.startsWith("@") && opts.some((opt) => opt === key.slice(1)));
+
+      for (const pkgOpt of pkgOpts) {
+        const optConf = this._getPkgConfigFromFileContent(confFileCont, pkgConf[pkgOpt], isDev, opts);
+        pkgConf = this._mergeObj(pkgConf, optConf);
+      }
+
+      for (const optKey of Object.keys(pkgConf).filter((item) => item.startsWith("@"))) {
+        delete pkgConf[optKey];
+      }
+    }
+
+    return pkgConf;
+  }
+
+  private static _mergeObj<A, B>(org: A, target: B): A & B {
+    return ObjectUtil.merge(org, target, {
+      arrayProcess: "replace",
+      useDelTargetUndefined: true
+    });
+  }
+}
+
+interface ISdCliConfigFileContent {
+  packages?: Record<string, TSdCliPackageConfigFileContent>;
+  overrides?: Record<string, TSdCliPackageConfigFileContent>;
+  extends?: string[];
+}
+
+type TSdCliPackageConfigFileContent =
+  TSdCliPackageConfig
+  & { overrides?: string[] }
+  & Record<string, any>;

package/tsconfig-build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "lib": [
+      "ES2020"
+    ],
+    "outDir": "./dist"
+  }
+}

package/tsconfig.json

@@ -1,29 +1,18 @@
 {
-  "extends": "../../tsconfig-base.json",
+  "extends": "../../tsconfig.json",
   "compilerOptions": {
-    "target": "es2020",
     "lib": [
-      "es2020"
+      "ES2020"
     ],
+    "outDir": "./dist",
     "baseUrl": ".",
     "paths": {
-      "@simplysm/sd-core-common": [
-        "../sd-core-common/src/index.ts"
-      ],
       "@simplysm/sd-core-node": [
         "../sd-core-node/src/index.ts"
       ],
-      "@simplysm/sd-server-node": [
-        "../sd-server-node/src/index.ts"
-      ],
-      "@simplysm/sd-storage": [
-        "../sd-storage/src/index.ts"
+      "@simplysm/sd-core-common": [
+        "../sd-core-common/src/index.ts"
       ]
     }
-  },
-  "files": [
-    "src/bin/sd-cli.ts",
-    "src/workers/lib-build-worker.ts",
-    "src/workers/client-ng-gen-worker.ts"
-  ]
-}
+  }
+}

package/.eslintrc.js

@@ -1,19 +0,0 @@
-module.exports = {
-  overrides: [
-    {
-      files: ["*.ts"],
-      extends: ["../eslint-plugin/src/configs/typescript"],
-      parserOptions: {
-        tsconfigRootDir: __dirname,
-        project: "tsconfig.json"
-      },
-      settings: {
-        "import/resolver": {
-          typescript: {
-            project: require("path").join(__dirname, "tsconfig.json")
-          }
-        }
-      }
-    }
-  ]
-};