@simplysm/sd-cli 7.3.4 → 10.0.21

package/src/commons.ts

@@ -1,22 +1,7 @@
 export interface INpmConfig {
   name: string;
   version: string;
-  description?: string;
-  author?: string;
-  license?: string;
-  repository?: {
-    type: string;
-    url: string;
-    directory?: string;
-  };
-  type?: "module";
   workspaces?: string[];
-  main?: string;
-  types?: string;
-  exports?: Record<string, {
-    types?: string;
-  }>;
-  scripts?: Record<string, string>;
 
   dependencies?: Record<string, string>;
   optionalDependencies?: Record<string, string>;
@@ -25,17 +10,22 @@ export interface INpmConfig {
   peerDependenciesMeta?: Record<string, { optional?: boolean }>;
 }
 
-export interface ITsconfig {
-  compilerOptions?: {
-    module?: string;
-    lib?: string[];
-    outDir?: string;
-    baseUrl?: string;
-    paths?: Record<string, string[]>;
-    declaration?: boolean;
-  };
-  files?: string[];
-  angularCompilerOptions?: Record<string, any>;
+export interface ISdCliBuildClusterReqMessage {
+  cmd: "watch" | "build";
+  pkgPath: string;
+  pkgConf: TSdCliPackageConfig
+}
+
+export interface ISdCliBuildClusterResMessage {
+  req: ISdCliBuildClusterReqMessage;
+  type: "change" | "complete" | "ready";
+  result?: ISdCliBuilderResult;
+}
+
+export interface ISdCliBuilderResult {
+  port?: number;
+  affectedFilePaths: string[];
+  buildResults: ISdCliPackageBuildResult[];
 }
 
 export interface ISdCliPackageBuildResult {
@@ -43,110 +33,29 @@ export interface ISdCliPackageBuildResult {
   line: number | undefined;
   char: number | undefined;
   code: string | undefined;
-  severity: "error" | "warning";
+  severity: "error" | "warning" | "suggestion" | "message";
   message: string;
 }
 
 export interface ISdCliConfig {
   packages: Record<string, TSdCliPackageConfig | undefined>;
-  localUpdates?: Record<string, string>;
 }
 
 export type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliServerPackageConfig | ISdCliClientPackageConfig;
 
 export interface ISdCliLibPackageConfig {
   type: "library";
-  angular?: boolean;
-  autoIndex?: {
-    polyfills?: string[];
-  };
   publish?: "npm";
 }
 
 export interface ISdCliServerPackageConfig {
   type: "server";
-  env?: Record<string, string>;
-  configs?: Record<string, any>;
-  pm2?: {
-    fileName?: string;
-    noInterpreter?: boolean;
-    noStartScript?: boolean;
-    config: Record<string, any>;
-  } | boolean;
-  iis?: boolean | { serverExeFilePath?: string };
-  externalNodeModules?: string[];
-  publish?: TSdCliPublishConfig;
+  externals?: string[];
+  publish?: any;
 }
 
 export interface ISdCliClientPackageConfig {
   type: "client";
-  builder?: {
-    web?: ISdCliClientBuilderWebConfig;
-    cordova?: ISdCliClientBuilderCordovaConfig;
-    electron?: ISdCliClientBuilderElectronConfig;
-  };
-  server: string | { port: number };
-  env?: Record<string, string>;
-  configs?: Record<string, any>;
-  publish?: TSdCliPublishConfig;
-}
-
-export type TSdCliPublishConfig =
-  ISdCliFtpPublishConfig
-  | ISdCliLocalDirectoryPublishConfig
-  | ISdCliGithubPublishConfig;
-
-export interface ISdCliFtpPublishConfig {
-  type: "ftp" | "ftps" | "sftp";
-  host: string;
-  port?: number;
-  path: string;
-  user: string;
-  pass: string;
-}
-
-export interface ISdCliLocalDirectoryPublishConfig {
-  type: "local-directory";
-  path: string;
-}
-
-export interface ISdCliGithubPublishConfig {
-  type: "github";
-  apiKey: string;
-  files: { from: string; to: string }[];
-}
-
-export interface ISdCliClientBuilderWebConfig {
-  env?: Record<string, string>;
-}
-
-export interface ISdCliClientBuilderCordovaConfig {
-  env?: Record<string, string>;
-  appId: string;
-  appName: string;
-  plugins?: string[];
-  icon?: string;
-  debug?: boolean;
-  target?: {
-    browser?: {};
-    android?: {
-      bundle?: boolean;
-      sign?: {
-        keystore: string;
-        storePassword: string;
-        alias: string;
-        password: string;
-        keystoreType: string;
-      };
-    };
-  };
-}
-
-export interface ISdCliClientBuilderElectronConfig {
-  env?: Record<string, string>;
-  externalNodeModules?: string[];
-  appId: string;
-  icon?: string;
-  installerIcon?: string;
-  postinstall?: string;
+  server?: string;
+  publish?: any;
 }

package/src/entry/SdCliProject.ts

@@ -0,0 +1,467 @@
+import path from "path";
+import { FsUtil, Logger, SdProcess } from "@simplysm/sd-core-node";
+import { SdCliConfigUtil } from "../utils/SdCliConfigUtil";
+import {
+  INpmConfig,
+  ISdCliBuildClusterReqMessage,
+  ISdCliBuildClusterResMessage,
+  ISdCliPackageBuildResult,
+  TSdCliPackageConfig
+} from "../commons";
+import cp from "child_process";
+import { fileURLToPath } from "url";
+import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
+import semver from "semver";
+import { NotImplementError, Wait } from "@simplysm/sd-core-common";
+
+export class SdCliProject {
+  public static async watchAsync(opt: {
+    rootPath: string;
+    confFileRelPath: string;
+    optNames: string[];
+    pkgNames: string[];
+  }): Promise<void> {
+    const logger = Logger.get(["simplysm", "sd-cli", "SdCliProject", "watchAsync"]);
+
+    logger.debug("프로젝트 설정 가져오기...");
+    const projConf = await SdCliConfigUtil.loadConfigAsync(path.resolve(opt.rootPath, opt.confFileRelPath), false, opt.optNames);
+
+    logger.debug("프로젝트 package.json 가져오기...");
+    const projNpmConf = FsUtil.readJson(path.resolve(opt.rootPath, "package.json"));
+
+    logger.debug("패키지 목록 구성...");
+    const allPkgPaths = await projNpmConf.workspaces?.mapManyAsync(async (item) => await FsUtil.globAsync(item));
+    let pkgPaths = allPkgPaths.filter((pkgPath) => path.basename(pkgPath) in projConf.packages);
+    if (opt.pkgNames.length !== 0) {
+      pkgPaths = pkgPaths.filter((pkgPath) => opt.pkgNames.includes(path.basename(pkgPath)));
+    }
+
+    logger.debug("빌드 프로세스 준비...");
+    const cluster = await this._prepareClusterAsync();
+
+    logger.debug("빌드 프로세스 이벤트 준비...");
+    const resultCache = new Map<string, ISdCliPackageBuildResult[]>();
+    let busyCount = 0;
+    const serverInfoMap = new Map<string, {
+      // server
+      pkgPath?: string; // persist
+      worker?: cp.ChildProcess; // persist
+      port?: number;
+      hasChanges: boolean;
+
+      //client
+      pathProxy: Record<string, number | undefined>; // persist
+      changeFilePaths: string[];
+    }>();
+    cluster.on("message", (message: ISdCliBuildClusterResMessage) => {
+      if (message.type === "change") {
+        if (busyCount === 0) {
+          logger.log("빌드를 시작합니다...");
+        }
+        busyCount++;
+      }
+      else if (message.type === "complete") {
+        for (const affectedFilePath of message.result!.affectedFilePaths) {
+          resultCache.delete(affectedFilePath);
+        }
+
+        for (const buildResult of message.result!.buildResults) {
+          const cacheItem = resultCache.getOrCreate(buildResult.filePath ?? "none", []);
+          cacheItem.push(buildResult);
+        }
+
+        if (message.req.pkgConf.type === "server") {
+          const pkgName = path.basename(message.req.pkgPath);
+          const serverInfo = serverInfoMap.getOrCreate(pkgName, {
+            hasChanges: false,
+            pathProxy: {},
+            changeFilePaths: []
+          });
+          serverInfo.pkgPath = message.req.pkgPath;
+          serverInfo.hasChanges = true;
+        }
+
+        if (message.req.pkgConf.type === "client" && message.req.pkgConf.server !== undefined) {
+          const pkgName = path.basename(message.req.pkgPath);
+          const serverInfo = serverInfoMap.getOrCreate(message.req.pkgConf.server, {
+            hasChanges: false,
+            pathProxy: {},
+            changeFilePaths: []
+          });
+          serverInfo.pathProxy[pkgName] = message.result!.port;
+          serverInfo.changeFilePaths.push(...message.result!.affectedFilePaths);
+        }
+
+        setTimeout(async () => {
+          busyCount--;
+          if (busyCount === 0) {
+            for (const serverPkgName of serverInfoMap.keys()) {
+              const serverInfo = serverInfoMap.get(serverPkgName)!;
+              if (serverInfo.pkgPath !== undefined && serverInfo.hasChanges) {
+                logger.debug("서버 재시작...");
+                try {
+                  const restartServerResult = await this._restartServerAsync(serverInfo.pkgPath, serverInfo.worker);
+                  serverInfo.worker = restartServerResult.worker;
+                  serverInfo.port = restartServerResult.port;
+                  serverInfo.hasChanges = false;
+                }
+                catch (err) {
+                  logger.error(err);
+                }
+              }
+
+              if (serverInfo.worker) {
+                logger.debug("클라이언트 설정...");
+                serverInfo.worker.send({
+                  type: "setPathProxy",
+                  pathProxy: serverInfo.pathProxy
+                });
+              }
+            }
+
+            const clientPaths: string[] = [];
+            for (const serverInfo of serverInfoMap.values()) {
+              for (const proxyPath of Object.keys(serverInfo.pathProxy)) {
+                clientPaths.push(`http://localhost:${serverInfo.port}/${proxyPath}/`);
+              }
+            }
+            if (clientPaths.length > 0) {
+              logger.info("클라이언트 개발 서버 접속 주소\n" + clientPaths.join("\n"));
+            }
+
+            const buildResults = Array.from(resultCache.values()).mapMany();
+            this._logging(buildResults, logger);
+          }
+        }, 300);
+      }
+    });
+
+    logger.debug("빌드 프로세스 명령 전송...");
+    busyCount++;
+    logger.log("빌드를 시작합니다...");
+
+    await pkgPaths.parallelAsync(async (pkgPath) => {
+      await this._runCommandAsync(cluster, "watch", pkgPath, projConf.packages[path.basename(pkgPath)]!);
+    });
+
+    busyCount--;
+    if (busyCount === 0) {
+      const buildResults = Array.from(resultCache.values()).mapMany();
+      this._logging(buildResults, logger);
+    }
+  }
+
+  public static async buildAsync(opt: {
+    rootPath: string;
+    confFileRelPath: string;
+    optNames: string[];
+    pkgNames: string[];
+  }): Promise<void> {
+    const logger = Logger.get(["simplysm", "sd-cli", "SdCliProject", "buildAsync"]);
+
+    logger.debug("프로젝트 설정 가져오기...");
+    const projConf = await SdCliConfigUtil.loadConfigAsync(path.resolve(opt.rootPath, opt.confFileRelPath), false, opt.optNames);
+
+    logger.debug("프로젝트 package.json 가져오기...");
+    const projNpmConf = FsUtil.readJson(path.resolve(opt.rootPath, "package.json"));
+
+    logger.debug("패키지 목록 구성...");
+    const allPkgPaths = await projNpmConf.workspaces?.mapManyAsync(async (item) => await FsUtil.globAsync(item));
+    let pkgPaths = allPkgPaths.filter((pkgPath) => path.basename(pkgPath) in projConf.packages);
+    if (opt.pkgNames.length !== 0) {
+      pkgPaths = pkgPaths.filter((pkgPath) => opt.pkgNames.includes(path.basename(pkgPath)));
+    }
+
+    logger.debug("프로젝트 및 패키지 버전 설정...");
+    await this._upgradeVersionAsync(opt.rootPath, projNpmConf, allPkgPaths);
+
+    logger.debug("빌드 프로세스 준비...");
+    const cluster = await this._prepareClusterAsync();
+
+    logger.debug("빌드 프로세스 명령 전달...");
+    const results = (
+      await pkgPaths.parallelAsync(async (pkgPath) => {
+        return await this._runCommandAsync(cluster, "build", pkgPath, projConf.packages[path.basename(pkgPath)]!);
+      })
+    ).mapMany();
+
+    logger.debug("빌드 프로세스 닫기...");
+    this._closeCluster(cluster);
+
+    this._logging(results, logger);
+  }
+
+  public static async publishAsync(opt: {
+    rootPath: string;
+    noBuild: boolean;
+    confFileRelPath: string;
+    optNames: string[];
+    pkgNames: string[]
+  }): Promise<void> {
+    const logger = Logger.get(["simplysm", "sd-cli", "SdCliProject", "publishAsync"]);
+
+    logger.debug("프로젝트 설정 가져오기...");
+    const projConf = await SdCliConfigUtil.loadConfigAsync(path.resolve(opt.rootPath, opt.confFileRelPath), false, opt.optNames);
+
+    logger.debug("프로젝트 package.json 가져오기...");
+    const projNpmConf = FsUtil.readJson(path.resolve(opt.rootPath, "package.json"));
+
+    if (opt.noBuild) {
+      logger.warn("빌드하지 않고, 배포하는것은 상당히 위험합니다.");
+      await this._waitSecMessageAsync("프로세스를 중지하려면, 'CTRL+C'를 누르세요.", 5);
+    }
+
+    // GIT 사용중일 경우, 커밋되지 않은 수정사항이 있는지 확인
+    if (FsUtil.exists(path.resolve(process.cwd(), ".git"))) {
+      logger.debug("GIT 커밋여부 확인...");
+      const gitStatusResult = await SdProcess.spawnAsync("git status");
+      if (gitStatusResult.includes("Changes") || gitStatusResult.includes("Untracked")) {
+        throw new Error("커밋되지 않은 정보가 있습니다.\n" + gitStatusResult);
+      }
+    }
+
+    logger.debug("패키지 목록 구성...");
+    const allPkgPaths = await projNpmConf.workspaces?.mapManyAsync(async (item) => await FsUtil.globAsync(item));
+    let pkgPaths = allPkgPaths.filter((pkgPath) => path.basename(pkgPath) in projConf.packages);
+    if (opt.pkgNames.length !== 0) {
+      pkgPaths = pkgPaths.filter((pkgPath) => opt.pkgNames.includes(path.basename(pkgPath)));
+    }
+
+    logger.debug("프로젝트 및 패키지 버전 설정...");
+    await this._upgradeVersionAsync(opt.rootPath, projNpmConf, allPkgPaths);
+
+    // 빌드
+    if (!opt.noBuild) {
+      logger.debug("빌드 프로세스 준비...");
+      const cluster = await this._prepareClusterAsync();
+
+      logger.debug("빌드 프로세스 명령 전달...");
+      const results = (
+        await pkgPaths.parallelAsync(async (pkgPath) => {
+          return await this._runCommandAsync(cluster, "build", pkgPath, projConf.packages[path.basename(pkgPath)]!);
+        })
+      ).mapMany();
+
+      logger.debug("빌드 프로세스 닫기...");
+      this._closeCluster(cluster);
+
+      this._logging(results, logger);
+    }
+
+    // GIT 사용중일경우, 새 버전 커밋 및 TAG 생성
+    if (FsUtil.exists(path.resolve(process.cwd(), ".git"))) {
+      logger.debug("새 버전 커밋 및 TAG 생성...");
+      await SdProcess.spawnAsync("git add .");
+      await SdProcess.spawnAsync(`git commit -m "v${projNpmConf.version}"`);
+      await SdProcess.spawnAsync(`git tag -a "v${projNpmConf.version}" -m "v${projNpmConf.version}"`);
+
+      logger.debug("새 버전 푸쉬...");
+      await SdProcess.spawnAsync("git push");
+      await SdProcess.spawnAsync("git push --tags");
+    }
+
+    logger.debug("배포 시작...");
+    await pkgPaths.parallelAsync(async (pkgPath) => {
+      const pkgName = path.basename(pkgPath);
+      const pkgConf = projConf.packages[pkgName];
+      if (pkgConf?.publish == null) return;
+
+      logger.debug(`[${pkgName}] 배포 시작...`);
+      await this._publishPkgAsync(pkgPath, pkgConf.publish);
+      logger.debug(`[${pkgName}] 배포 완료`);
+    });
+
+    logger.info(`모든 배포가 완료되었습니다. (v${projNpmConf.version})`);
+  }
+
+  private static async _publishPkgAsync(pkgPath: string, pkgPubConf: TSdCliPackageConfig["publish"]): Promise<void> {
+    if (pkgPubConf === "npm") {
+      await SdProcess.spawnAsync("yarn npm publish --access public", { cwd: pkgPath });
+    }
+    else {
+      throw new NotImplementError();
+    }
+  }
+
+  private static 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 static async _upgradeVersionAsync(projPath: string, projNpmConf: INpmConfig, allPkgPaths: string[]): Promise<void> {
+    // 작업공간 package.json 버전 설정
+    const newVersion = semver.inc(projNpmConf.version, "patch")!;
+    projNpmConf.version = newVersion;
+
+    const pkgNames = await allPkgPaths.mapAsync(async (pkgPath) => {
+      const pkgNpmConf = await FsUtil.readJsonAsync(path.resolve(pkgPath, "package.json"));
+      return pkgNpmConf.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(projNpmConf.dependencies);
+    updateDepVersion(projNpmConf.optionalDependencies);
+    updateDepVersion(projNpmConf.devDependencies);
+    updateDepVersion(projNpmConf.peerDependencies);
+
+    const projNpmConfFilePath = path.resolve(projPath, "package.json");
+    await FsUtil.writeJsonAsync(projNpmConfFilePath, projNpmConf, { space: 2 });
+
+    // 각 패키지 package.json 버전 설정
+    await allPkgPaths.parallelAsync(async (pkgPath) => {
+      const pkgNpmConfFilePath = path.resolve(pkgPath, "package.json");
+      const pkgNpmConf = await FsUtil.readJsonAsync(pkgNpmConfFilePath);
+      pkgNpmConf.version = newVersion;
+
+      updateDepVersion(pkgNpmConf.dependencies);
+      updateDepVersion(pkgNpmConf.optionalDependencies);
+      updateDepVersion(pkgNpmConf.devDependencies);
+      updateDepVersion(pkgNpmConf.peerDependencies);
+
+      await FsUtil.writeJsonAsync(pkgNpmConfFilePath, pkgNpmConf, { space: 2 });
+    });
+  }
+
+  private static _logging(buildResults: ISdCliPackageBuildResult[], logger: Logger): void {
+    const messages = buildResults.filter((item) => item.severity === "message");
+    const suggestions = buildResults.filter((item) => item.severity === "suggestion");
+    const warnings = buildResults.filter((item) => item.severity === "warning");
+    const errors = buildResults.filter((item) => item.severity === "error");
+
+    if (messages.length > 0) {
+      logger.log("\n" + messages.map((item) => SdCliBuildResultUtil.getMessage(item)).join("\n"));
+    }
+    if (suggestions.length > 0) {
+      logger.info("\n" + suggestions.map((item) => SdCliBuildResultUtil.getMessage(item)).join("\n"));
+    }
+    if (warnings.length > 0) {
+      logger.warn("\n" + warnings.map((item) => SdCliBuildResultUtil.getMessage(item)).join("\n"));
+    }
+    if (errors.length > 0) {
+      logger.error("\n" + errors.map((item) => SdCliBuildResultUtil.getMessage(item)).join("\n"));
+    }
+
+    logger.info("모든 빌드가 완료되었습니다.");
+  }
+
+  private static async _prepareClusterAsync(): Promise<cp.ChildProcess> {
+    const logger = Logger.get(["simplysm", "sd-cli", "SdCliProject", "_runBuildClusterAsync"]);
+
+    return await new Promise<cp.ChildProcess>(async (resolve, reject) => {
+      const cluster = cp.fork(
+        fileURLToPath(await import.meta.resolve!("../build-cluster")),
+        [],
+        {
+          stdio: ["pipe", "pipe", "pipe", "ipc"],
+          env: process.env
+        }
+      );
+
+      cluster.stdout!.pipe(process.stdout);
+      cluster.stderr!.pipe(process.stderr);
+
+      cluster.on("exit", (code) => {
+        if (code != null && code !== 0) {
+          const err = new Error(`오류와 함께 닫힘 (${code})`);
+          logger.error(err);
+          reject(err);
+          return;
+        }
+      });
+
+      cluster.on("error", (err) => {
+        logger.error(err);
+        reject(err);
+      });
+
+      cluster.on("message", (message) => {
+        if (message === "ready") {
+          logger.debug("빌드 클러스터 프로세스가 준비되었습니다.");
+          resolve(cluster);
+        }
+      });
+    });
+  }
+
+  private static async _runCommandAsync(cluster: cp.ChildProcess, cmd: "watch", pkgPath: string, pkgConf: TSdCliPackageConfig): Promise<void>;
+  private static async _runCommandAsync(cluster: cp.ChildProcess, cmd: "build", pkgPath: string, pkgConf: TSdCliPackageConfig): Promise<ISdCliPackageBuildResult[]>;
+  private static async _runCommandAsync(cluster: cp.ChildProcess, cmd: "watch" | "build", pkgPath: string, pkgConf: TSdCliPackageConfig): Promise<ISdCliPackageBuildResult[] | void> {
+    return await new Promise<ISdCliPackageBuildResult[] | void>((resolve) => {
+      const cb = (message: ISdCliBuildClusterResMessage): void => {
+        if (cmd === "watch" && message.type === "ready" && message.req.cmd === cmd && message.req.pkgPath === pkgPath) {
+          cluster.off("message", cb);
+          resolve();
+        }
+        else if (cmd === "build" && message.type === "complete" && message.req.cmd === cmd && message.req.pkgPath === pkgPath) {
+          cluster.off("message", cb);
+          resolve(message.result?.buildResults);
+        }
+      };
+      cluster.on("message", cb);
+
+      cluster.send({ cmd, pkgPath, pkgConf } as ISdCliBuildClusterReqMessage);
+    });
+  }
+
+  private static _closeCluster(cluster: cp.ChildProcess): void {
+    cluster.kill("SIGKILL");
+  }
+
+  private static async _restartServerAsync(pkgPath: string, prevServerProcess?: cp.ChildProcess): Promise<{ worker: cp.ChildProcess, port: number }> {
+    const logger = Logger.get(["simplysm", "sd-cli", "SdCliProject", "_restartServerAsync"]);
+
+    if (prevServerProcess) {
+      prevServerProcess.kill("SIGKILL");
+    }
+
+    return await new Promise<{ worker: cp.ChildProcess, port: number }>(async (resolve, reject) => {
+      const worker = cp.fork(
+        fileURLToPath(await import.meta.resolve!("../server-worker")),
+        [pkgPath],
+        {
+          stdio: ["pipe", "pipe", "pipe", "ipc"],
+          env: process.env
+        }
+      );
+
+      worker.stdout!.pipe(process.stdout);
+      worker.stderr!.pipe(process.stderr);
+
+      worker.on("exit", (code) => {
+        if (code != null && code !== 0) {
+          const err = new Error(`오류와 함께 닫힘 (${code})`);
+          logger.error(err);
+          reject(err);
+          return;
+        }
+      });
+
+      worker.on("error", (err) => {
+        logger.error(err);
+        reject(err);
+      });
+
+      worker.on("message", (message: any) => {
+        if ("port" in message) {
+          logger.debug("서버가 시작되었습니다.");
+          resolve({ worker, port: message.port });
+        }
+      });
+    });
+  }
+}