@simplysm/sd-cli 12.5.20 → 12.5.22

package/src/pkg-builders/SdMultiBuildRunner.ts

@@ -0,0 +1,250 @@
+import { FsUtil, Logger, PathUtil, SdWorker, TNormPath } from "@simplysm/sd-core-node";
+import path from "path";
+import { EventEmitter } from "events";
+import { SdServerBuildRunner } from "./server/SdServerBuildRunner";
+import { SdClientBuildRunner } from "./client/SdClientBuildRunner";
+import { SdTsLibBuildRunner } from "./lib/SdTsLibBuildRunner";
+import { SdJsLibBuildRunner } from "./lib/SdJsLibBuildRunner";
+import { ISdProjectConfig, ISdServerPackageConfig } from "../types/sd-configs.type";
+import { ISdBuildMessage, ISdBuildRunnerResult } from "../types/build.type";
+import { TServerWorkerType } from "../types/workers.type";
+import { INpmConfig } from "../types/common-configs.type";
+
+export class SdMultiBuildRunner extends EventEmitter {
+  #logger = Logger.get(["simplysm", "sd-cli", "SdMultiBuildRunner"]);
+
+  #busyCount = 0;
+
+  #resultCache = new Map<TNormPath, ISdBuildMessage[]>();
+  #serverInfoMap = new Map<
+    string,
+    {
+      pkgInfo?: { path: string; conf: ISdServerPackageConfig } | { port: number }; // persist
+      worker?: SdWorker<TServerWorkerType>; // persist
+      port?: number; // run server result
+      hasChanges: boolean;
+      clientChangedFileSet: Set<string>;
+
+      // from client
+      clients: Record<
+        string,
+        {
+          buildTypes: ("web" | "electron" | "cordova")[];
+          path: string;
+        }
+      >; // persist
+    }
+  >();
+
+  public override on(event: "change", listener: () => void): this;
+  public override on(event: "complete", listener: (result: ISdBuildMessage[]) => void): this;
+  public override on(event: string | symbol, listener: (...args: any[]) => void): this {
+    super.on(event, listener);
+    return this;
+  }
+
+  async runAsync(req: IRequest & { cmd: "watch" }): Promise<void>;
+  async runAsync(req: IRequest & { cmd: "build" }): Promise<ISdBuildMessage[]>;
+  async runAsync(req: IRequest): Promise<ISdBuildMessage[] | void> {
+    const pkgConf = req.projConf.packages[path.basename(req.pkgPath)]!;
+
+    const buildRunnerType =
+      pkgConf.type === "server"
+        ? SdServerBuildRunner
+        : pkgConf.type === "client"
+          ? SdClientBuildRunner
+          : FsUtil.exists(path.resolve(req.pkgPath, "tsconfig.json"))
+            ? SdTsLibBuildRunner
+            : SdJsLibBuildRunner;
+
+    const builder = new buildRunnerType(req.projConf, req.pkgPath)
+      .on("change", () => this.#onMessage(req, { type: "change" }))
+      .on("complete", (result) => this.#onMessage(req, { type: "complete", result }));
+
+    if (req.cmd === "build") {
+      const res = await builder.buildAsync();
+      return res.buildMessages;
+    } else {
+      await builder.watchAsync();
+      return;
+    }
+  }
+
+  #onMessage(req: IRequest, res: TResponse) {
+    if (res.type === "change") {
+      if (this.#busyCount === 0) {
+        this.emit("change");
+      }
+      this.#busyCount++;
+    } else {
+      this.#resultCache.delete(req.pkgPath);
+      for (const affectedFilePath of res.result.affectedFilePathSet) {
+        if (PathUtil.isChildPath(affectedFilePath, req.pkgPath)) {
+          this.#resultCache.delete(affectedFilePath);
+        }
+      }
+
+      for (const buildMessage of res.result.buildMessages) {
+        const cacheItem = this.#resultCache.getOrCreate(buildMessage.filePath ?? req.pkgPath, []);
+        cacheItem.push(buildMessage);
+      }
+
+      const pkgConf = req.projConf.packages[path.basename(req.pkgPath)]!;
+
+      if (pkgConf.type === "server") {
+        const pkgName = path.basename(req.pkgPath);
+        const serverInfo = this.#serverInfoMap.getOrCreate(pkgName, {
+          hasChanges: true,
+          clientChangedFileSet: new Set(),
+          clients: {},
+        });
+
+        const serverPkgConf = req.projConf.packages[pkgName] as ISdServerPackageConfig;
+        serverInfo.pkgInfo = {
+          path: req.pkgPath,
+          conf: serverPkgConf,
+        };
+
+        serverInfo.hasChanges = true;
+      } else if (pkgConf.type === "client") {
+        const pkgName = path.basename(req.pkgPath);
+
+        if (pkgConf.server !== undefined) {
+          const serverInfo = this.#serverInfoMap.getOrCreate(
+            typeof pkgConf.server === "string" ? pkgConf.server : pkgConf.server.port.toString(),
+            {
+              hasChanges: true,
+              clientChangedFileSet: new Set(),
+              clients: {},
+            },
+          );
+
+          if (typeof pkgConf.server !== "string") {
+            serverInfo.pkgInfo = pkgConf.server;
+          }
+
+          serverInfo.clients[pkgName] = {
+            path: path.resolve(req.pkgPath, "dist"),
+            buildTypes: (pkgConf.builder ? Object.keys(pkgConf.builder) : ["web"]) as any,
+          };
+
+          serverInfo.clientChangedFileSet.adds(...res.result.emitFileSet);
+        } else {
+          const serverInfo = this.#serverInfoMap.getOrCreate(pkgName, {
+            hasChanges: true,
+            clientChangedFileSet: new Set(),
+            clients: {},
+          });
+
+          serverInfo.clientChangedFileSet.adds(...res.result.emitFileSet);
+        }
+      }
+
+      setTimeout(async () => {
+        this.#busyCount--;
+        if (this.#busyCount === 0) {
+          for (const serverPkgNameOrPort of this.#serverInfoMap.keys()) {
+            const serverInfo = this.#serverInfoMap.get(serverPkgNameOrPort)!;
+            if (serverInfo.pkgInfo && serverInfo.hasChanges) {
+              this.#logger.debug("서버 재시작...");
+              try {
+                const restartServerResult = await this.#restartServerAsync(serverInfo.pkgInfo, serverInfo.worker);
+                serverInfo.worker = restartServerResult.worker;
+                serverInfo.port = restartServerResult.port;
+                serverInfo.hasChanges = false;
+              } catch (err) {
+                this.#logger.error(err);
+              }
+            }
+
+            if (serverInfo.worker) {
+              this.#logger.debug("클라이언트 설정...");
+              await serverInfo.worker.run("setPathProxy", [
+                {
+                  ...Object.keys(serverInfo.clients).toObject(
+                    (key) => key,
+                    (key) => serverInfo.clients[key].path,
+                  ),
+                  node_modules: path.resolve(process.cwd(), "node_modules"),
+                },
+              ]);
+
+              if (serverInfo.clientChangedFileSet.size > 0) {
+                this.#logger.debug("클라이언트 새로고침...");
+                await serverInfo.worker.run("broadcastReload", [serverInfo.clientChangedFileSet]);
+              }
+            }
+          }
+
+          const clientPaths: string[] = [];
+          for (const serverInfo of this.#serverInfoMap.values()) {
+            if (Object.keys(serverInfo.clients).length > 0) {
+              for (const clientPkgName of Object.keys(serverInfo.clients)) {
+                for (const buildType of serverInfo.clients[clientPkgName].buildTypes) {
+                  if (buildType === "web") {
+                    clientPaths.push(`http://localhost:${serverInfo.port}/${clientPkgName}/`);
+                  } else {
+                    clientPaths.push(`http://localhost:${serverInfo.port}/${clientPkgName}/${buildType}/`);
+                  }
+                }
+              }
+            } else {
+              clientPaths.push(`http://localhost:${serverInfo.port}/`);
+            }
+          }
+          if (clientPaths.length > 0) {
+            this.#logger.info("클라이언트 개발 서버 접속 주소\n" + clientPaths.join("\n"));
+          }
+
+          const messages = Array.from(this.#resultCache.values()).mapMany();
+          this.emit("complete", messages);
+        }
+      }, 300);
+    }
+  }
+
+  async #restartServerAsync(
+    pkgInfo: { path: string; conf: ISdServerPackageConfig } | { port: number },
+    prevWorker?: SdWorker<TServerWorkerType>,
+  ): Promise<{
+    worker: SdWorker<TServerWorkerType>;
+    port: number;
+  }> {
+    const logger = Logger.get(["simplysm", "sd-cli", "SdMultiBuildRunner", "#restartServerAsync"]);
+
+    if (prevWorker) {
+      prevWorker.kill();
+    }
+
+    const npmConf =
+      "path" in pkgInfo ? (FsUtil.readJson(path.resolve(pkgInfo.path, "package.json")) as INpmConfig) : undefined;
+
+    const worker = new SdWorker<TServerWorkerType>(import.meta.resolve("../workers/server-worker"), {
+      env: {
+        NODE_ENV: "development",
+        TZ: "Asia/Seoul",
+        SD_VERSION: npmConf?.version ?? "serverless",
+        ...("path" in pkgInfo ? pkgInfo.conf.env : {}),
+      },
+    });
+    const port = await worker.run("listen", [pkgInfo]);
+    logger.debug("서버가 시작되었습니다.");
+
+    return { worker, port };
+  }
+}
+
+interface IRequest {
+  cmd: "watch" | "build";
+  pkgPath: TNormPath;
+  projConf: ISdProjectConfig;
+}
+
+type TResponse =
+  | {
+      type: "change";
+    }
+  | {
+      type: "complete";
+      result: ISdBuildRunnerResult;
+    };

package/src/{build-tools → pkg-builders/client}/SdCliNgRoutesFileGenerator.ts

@@ -3,24 +3,24 @@ import { FsUtil, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
 import { StringUtil } from "@simplysm/sd-core-common";
 
 export class SdCliNgRoutesFileGenerator {
-  public static async watchAsync(pkgPath: string, noLazyRoute?: boolean): Promise<void> {
+  static watch(pkgPath: string, noLazyRoute?: boolean) {
     const routesFilePath = path.resolve(pkgPath, "src/routes.ts");
     let cache = FsUtil.exists(routesFilePath) ? FsUtil.readFile(routesFilePath) : undefined;
 
-    SdFsWatcher.watch([path.resolve(pkgPath, "src")]).onChange({}, async () => {
-      cache = await this.runAsync(pkgPath, cache, noLazyRoute);
+    SdFsWatcher.watch([path.resolve(pkgPath, "src")]).onChange({ delay: 100 }, () => {
+      cache = this.run(pkgPath, cache, noLazyRoute);
     });
 
-    cache = await this.runAsync(pkgPath, cache, noLazyRoute);
+    cache = this.run(pkgPath, cache, noLazyRoute);
   }
 
-  public static async runAsync(pkgPath: string, cache?: string, noLazyRoute?: boolean): Promise<string> {
+  static run(pkgPath: string, cache?: string, noLazyRoute?: boolean): string {
     const appDirPath = path.resolve(pkgPath, "src/app");
     const routesFilePath = path.resolve(pkgPath, "src/routes.ts");
 
     // 내부 파일들 import
     const result: TInfo = new Map();
-    const filePaths = await FsUtil.globAsync(path.resolve(appDirPath, "**/*Page.ts"));
+    const filePaths = FsUtil.glob(path.resolve(appDirPath, "**/*Page.ts"));
     for (const filePath of filePaths.orderBy()) {
       const relModulePath = PathUtil.posix(path.relative(appDirPath, filePath)).slice(0, -3);
       const codes = relModulePath
@@ -76,7 +76,7 @@ export const routes: Routes = [
 ${routes}
 ];`.trim();
     if (content !== cache) {
-      await FsUtil.writeFileAsync(routesFilePath, content);
+      FsUtil.writeFile(routesFilePath, content);
     }
     return content;
   }

package/src/pkg-builders/client/SdClientBuildRunner.ts

@@ -0,0 +1,191 @@
+import { EventEmitter } from "events";
+import { FsUtil, Logger, PathUtil, SdFsWatcher, TNormPath } from "@simplysm/sd-core-node";
+import path from "path";
+import { SdNgBundler } from "./SdNgBundler";
+import { SdCliNgRoutesFileGenerator } from "./SdCliNgRoutesFileGenerator";
+import { SdCliCordova } from "../../entry/SdCliCordova";
+import { SdCliElectron } from "../../entry/SdCliElectron";
+import { ISdClientPackageConfig, ISdProjectConfig } from "../../types/sd-configs.type";
+import { INpmConfig } from "../../types/common-configs.type";
+import { ISdBuildMessage, ISdBuildRunnerResult } from "../../types/build.type";
+
+export class SdClientBuildRunner extends EventEmitter {
+  private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdClientBuildRunner"]);
+  private readonly _pkgConf: ISdClientPackageConfig;
+  private readonly _npmConf: INpmConfig;
+  private _ngBundlers?: SdNgBundler[];
+  private _cordova?: SdCliCordova;
+
+  public constructor(
+    private readonly _projConf: ISdProjectConfig,
+    private readonly _pkgPath: TNormPath,
+  ) {
+    super();
+    this._pkgConf = this._projConf.packages[path.basename(_pkgPath)] as ISdClientPackageConfig;
+    this._npmConf = FsUtil.readJson(path.resolve(_pkgPath, "package.json")) as INpmConfig;
+  }
+
+  public override on(event: "change", listener: () => void): this;
+  public override on(event: "complete", listener: (result: ISdBuildRunnerResult) => void): this;
+  public override on(event: string | symbol, listener: (...args: any[]) => void): this {
+    super.on(event, listener);
+    return this;
+  }
+
+  public async buildAsync(): Promise<ISdBuildRunnerResult> {
+    this._debug("dist 초기화...");
+    FsUtil.remove(path.resolve(this._pkgPath, "dist"));
+
+    if (this._npmConf.dependencies && Object.keys(this._npmConf.dependencies).includes("@angular/router")) {
+      this._debug(`GEN routes.ts...`);
+      SdCliNgRoutesFileGenerator.run(this._pkgPath, undefined, this._pkgConf.noLazyRoute);
+    }
+
+    this._debug("GEN .config...");
+    const confDistPath = path.resolve(this._pkgPath, "dist/.config.json");
+    FsUtil.writeFile(confDistPath, JSON.stringify(this._pkgConf.configs ?? {}, undefined, 2));
+
+    const result = await this._runAsync({ dev: false });
+    return {
+      affectedFilePathSet: result.affectedFileSet,
+      buildMessages: result.buildMessages,
+      emitFileSet: result.emitFileSet,
+    };
+  }
+
+  public async watchAsync() {
+    this.emit("change");
+
+    this._debug("dist 초기화...");
+    FsUtil.remove(path.resolve(this._pkgPath, "dist"));
+
+    if (this._npmConf.dependencies && Object.keys(this._npmConf.dependencies).includes("@angular/router")) {
+      this._debug(`WATCH GEN routes.ts...`);
+      SdCliNgRoutesFileGenerator.watch(this._pkgPath, this._pkgConf.noLazyRoute);
+    }
+
+    this._debug("GEN .config...");
+    const confDistPath = path.resolve(this._pkgPath, "dist/.config.json");
+    FsUtil.writeFile(confDistPath, JSON.stringify(this._pkgConf.configs ?? {}, undefined, 2));
+
+    const result = await this._runAsync({ dev: !this._pkgConf.forceProductionMode });
+    const res: ISdBuildRunnerResult = {
+      affectedFilePathSet: result.affectedFileSet,
+      buildMessages: result.buildMessages,
+      emitFileSet: result.emitFileSet,
+    };
+    this.emit("complete", res);
+
+    this._debug("WATCH...");
+    const watcher = SdFsWatcher.watch(Array.from(result.watchFileSet)).onChange({ delay: 300 }, async (changeInfos) => {
+      this.emit("change");
+
+      for (const ngBundler of this._ngBundlers!) {
+        ngBundler.markForChanges(changeInfos.map((item) => item.path));
+      }
+
+      const watchResult = await this._runAsync({ dev: !this._pkgConf.forceProductionMode });
+      const watchRes: ISdBuildRunnerResult = {
+        affectedFilePathSet: watchResult.affectedFileSet,
+        buildMessages: watchResult.buildMessages,
+        emitFileSet: watchResult.emitFileSet,
+      };
+      this.emit("complete", watchRes);
+
+      watcher.replaceWatchPaths(watchResult.watchFileSet);
+    });
+  }
+
+  private async _runAsync(opt: { dev: boolean }): Promise<{
+    watchFileSet: Set<TNormPath>;
+    affectedFileSet: Set<TNormPath>;
+    buildMessages: ISdBuildMessage[];
+    emitFileSet: Set<TNormPath>;
+  }> {
+    const localUpdatePaths = Object.keys(this._projConf.localUpdates ?? {}).mapMany((key) =>
+      FsUtil.glob(path.resolve(this._pkgPath, "../../node_modules", key)),
+    );
+
+    const ngBundlerBuilderTypes = Object.keys(this._pkgConf.builder ?? { web: {} }) as (
+      | "web"
+      | "electron"
+      | "cordova"
+    )[];
+    if (this._pkgConf.builder?.cordova && !this._cordova) {
+      this._debug("CORDOVA 준비...");
+      this._cordova = new SdCliCordova({
+        pkgPath: this._pkgPath,
+        config: this._pkgConf.builder.cordova,
+      });
+      await this._cordova.initializeAsync();
+    }
+
+    if (!this._ngBundlers) {
+      this._debug(`BUILD 준비...`);
+
+      this._ngBundlers = ngBundlerBuilderTypes.map(
+        (ngBundlerBuilderType) =>
+          new SdNgBundler({
+            dev: opt.dev,
+            builderType: ngBundlerBuilderType,
+            pkgPath: this._pkgPath,
+            outputPath:
+              ngBundlerBuilderType === "web"
+                ? PathUtil.norm(this._pkgPath, "dist")
+                : ngBundlerBuilderType === "electron" && !opt.dev
+                  ? PathUtil.norm(this._pkgPath, ".electron/src")
+                  : ngBundlerBuilderType === "cordova" && !opt.dev
+                    ? PathUtil.norm(this._pkgPath, ".cordova/www")
+                    : PathUtil.norm(this._pkgPath, "dist", ngBundlerBuilderType),
+            env: {
+              ...this._pkgConf.env,
+              ...this._pkgConf.builder?.[ngBundlerBuilderType]?.env,
+            },
+            cordovaConfig: ngBundlerBuilderType === "cordova" ? this._pkgConf.builder!.cordova : undefined,
+            watchScopePaths: [path.resolve(this._pkgPath, "../"), ...localUpdatePaths].map((item) =>
+              PathUtil.norm(item),
+            ),
+          }),
+      );
+    }
+
+    this._debug(`BUILD...`);
+    const buildResults = await Promise.all(this._ngBundlers.map((builder) => builder.bundleAsync()));
+    const watchFileSet = new Set(buildResults.mapMany((item) => Array.from(item.watchFileSet)));
+    const affectedFileSet = new Set(buildResults.mapMany((item) => Array.from(item.affectedFileSet)));
+    const emitFileSet = new Set(buildResults.mapMany((item) => Array.from(item.emitFileSet)));
+    const results = buildResults.mapMany((item) => item.results).distinct();
+
+    if (!opt.dev && this._cordova) {
+      this._debug("CORDOVA BUILD...");
+      await this._cordova.buildAsync(path.resolve(this._pkgPath, "dist"));
+    }
+
+    if (!opt.dev && this._pkgConf.builder?.electron) {
+      this._debug("ELECTRON BUILD...");
+      await SdCliElectron.buildAsync({
+        pkgPath: this._pkgPath,
+        config: this._pkgConf.builder.electron,
+      });
+    }
+
+    this._debug(`빌드 완료`);
+    const currWatchFileSet = new Set(
+      Array.from(watchFileSet).filter(
+        (item) =>
+          PathUtil.isChildPath(item, path.resolve(this._pkgPath, "../")) ||
+          localUpdatePaths.some((lu) => PathUtil.isChildPath(item, lu)),
+      ),
+    );
+    return {
+      watchFileSet: currWatchFileSet,
+      affectedFileSet,
+      buildMessages: results, //.filter((item) => item.filePath !== path.resolve(this._pkgPath, "src/routes.ts")),
+      emitFileSet,
+    };
+  }
+
+  private _debug(msg: string): void {
+    this._logger.debug(`[${path.basename(this._pkgPath)}] ${msg}`);
+  }
+}