@simplysm/sd-cli 12.5.21 → 12.5.23

package/src/{builders/SdCliServerBuilder.ts → pkg-builders/server/SdServerBuildRunner.ts}

@@ -1,34 +1,28 @@
 import { EventEmitter } from "events";
-import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
-import {
-  INpmConfig,
-  ISdCliBuilderResult,
-  ISdCliConfig,
-  ISdCliPackageBuildResult,
-  ISdCliServerPackageConfig,
-  ITsConfig,
-} from "../commons";
+import { FsUtil, Logger, PathUtil, SdFsWatcher, TNormPath } from "@simplysm/sd-core-node";
 import path from "path";
-import { SdLinter } from "../build-tools/SdLinter";
-import { FunctionQueue, ObjectUtil, StringUtil } from "@simplysm/sd-core-common";
-import { SdServerBundler } from "../build-tools/SdServerBundler";
-
-export class SdCliServerBuilder extends EventEmitter {
-  #logger = Logger.get(["simplysm", "sd-cli", "SdCliServerBuilder"]);
-  #pkgConf: ISdCliServerPackageConfig;
-  #builder?: SdServerBundler;
+import { ObjectUtil, StringUtil } from "@simplysm/sd-core-common";
+import { SdServerBundler } from "./SdServerBundler";
+import { ISdProjectConfig, ISdServerPackageConfig } from "../../types/sd-configs.type";
+import { ISdBuildMessage, ISdBuildRunnerResult } from "../../types/build.type";
+import { INpmConfig, ITsConfig } from "../../types/common-configs.type";
+
+export class SdServerBuildRunner extends EventEmitter {
+  #logger = Logger.get(["simplysm", "sd-cli", "SdCliServerBuildRunner"]);
+  #pkgConf: ISdServerPackageConfig;
+  #serverBundler?: SdServerBundler;
   #extModules?: { name: string; exists: boolean }[];
 
   public constructor(
-    private readonly _projConf: ISdCliConfig,
-    private readonly _pkgPath: string,
+    private readonly _projConf: ISdProjectConfig,
+    private readonly _pkgPath: TNormPath,
   ) {
     super();
-    this.#pkgConf = this._projConf.packages[path.basename(_pkgPath)] as ISdCliServerPackageConfig;
+    this.#pkgConf = this._projConf.packages[path.basename(_pkgPath)] as ISdServerPackageConfig;
   }
 
   public override on(event: "change", listener: () => void): this;
-  public override on(event: "complete", listener: (result: ISdCliBuilderResult) => 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;
@@ -38,53 +32,47 @@ export class SdCliServerBuilder extends EventEmitter {
     this.emit("change");
 
     this._debug("dist 초기화...");
-    await FsUtil.removeAsync(path.resolve(this._pkgPath, "dist"));
+    FsUtil.remove(path.resolve(this._pkgPath, "dist"));
 
     this._debug("GEN .config...");
     const confDistPath = path.resolve(this._pkgPath, "dist/.config.json");
-    await FsUtil.writeFileAsync(confDistPath, JSON.stringify(this.#pkgConf.configs ?? {}, undefined, 2));
+    FsUtil.writeFile(confDistPath, JSON.stringify(this.#pkgConf.configs ?? {}, undefined, 2));
 
-    const result = await this._runAsync({ dev: true });
-    this.emit("complete", {
-      affectedFilePaths: Array.from(result.affectedFileSet),
-      buildResults: result.buildResults,
-    });
+    const result = await this._runAsync(true);
+    const res: ISdBuildRunnerResult = {
+      affectedFilePathSet: result.affectedFileSet,
+      buildMessages: result.buildMessages,
+      emitFileSet: result.emitFileSet,
+    };
+    this.emit("complete", res);
 
     this._debug("WATCH...");
-    let changeFiles: string[] = [];
-    const fnQ = new FunctionQueue();
-    const watcher = SdFsWatcher.watch(Array.from(result.watchFileSet)).onChange({ delay: 100 }, (changeInfos) => {
-      changeFiles.push(...changeInfos.map((item) => item.path));
-
-      fnQ.runLast(async () => {
-        const currChangeFiles = [...changeFiles];
-        changeFiles = [];
-
-        this.emit("change");
-
-        this.#builder!.markForChanges(currChangeFiles);
+    const watcher = SdFsWatcher.watch(Array.from(result.watchFileSet)).onChange({ delay: 100 }, async (changeInfos) => {
+      this.emit("change");
+
+      const watchResult = await this._runAsync(true, new Set(changeInfos.map((item) => PathUtil.norm(item.path))));
+      const watchRes: ISdBuildRunnerResult = {
+        affectedFilePathSet: watchResult.affectedFileSet,
+        buildMessages: watchResult.buildMessages,
+        emitFileSet: watchResult.emitFileSet,
+      };
 
-        const watchResult = await this._runAsync({ dev: true });
-        this.emit("complete", {
-          affectedFilePaths: Array.from(watchResult.affectedFileSet),
-          buildResults: watchResult.buildResults,
-        });
+      this.emit("complete", watchRes);
 
-        watcher.add(watchResult.watchFileSet);
-      });
+      watcher.replaceWatchPaths(watchResult.watchFileSet);
     });
   }
 
-  public async buildAsync(): Promise<ISdCliBuilderResult> {
-    const npmConfig = (await FsUtil.readJsonAsync(path.resolve(this._pkgPath, "package.json"))) as INpmConfig;
+  public async buildAsync(): Promise<ISdBuildRunnerResult> {
+    const npmConfig = FsUtil.readJson(path.resolve(this._pkgPath, "package.json")) as INpmConfig;
     const extModules = await this._getExternalModulesAsync();
 
     this._debug("dist 초기화...");
-    await FsUtil.removeAsync(path.resolve(this._pkgPath, "dist"));
+    FsUtil.remove(path.resolve(this._pkgPath, "dist"));
 
     this._debug("GEN .config.json...");
     const confDistPath = path.resolve(this._pkgPath, "dist/.config.json");
-    await FsUtil.writeJsonAsync(confDistPath, this.#pkgConf.configs ?? {}, { space: 2 });
+    FsUtil.writeJson(confDistPath, this.#pkgConf.configs ?? {}, { space: 2 });
 
     this._debug("GEN package.json...");
     {
@@ -103,12 +91,12 @@ export class SdCliServerBuilder extends EventEmitter {
         distNpmConfig.scripts = { start: "pm2 start pm2.json" };
       }
 
-      await FsUtil.writeJsonAsync(path.resolve(this._pkgPath, "dist/package.json"), distNpmConfig, { space: 2 });
+      FsUtil.writeJson(path.resolve(this._pkgPath, "dist/package.json"), distNpmConfig, { space: 2 });
     }
 
     this._debug("GEN openssl.cnf...");
     {
-      await FsUtil.writeFileAsync(
+      FsUtil.writeFile(
         path.resolve(this._pkgPath, "dist/openssl.cnf"),
         `
 nodejs_conf = openssl_init
@@ -138,7 +126,7 @@ Options = UnsafeLegacyRenegotiation`.trim(),
     if (this.#pkgConf.pm2) {
       this._debug("GEN pm2.json...");
 
-      await FsUtil.writeJsonAsync(
+      FsUtil.writeJson(
         path.resolve(this._pkgPath, "dist/pm2.json"),
         {
           name: this.#pkgConf.pm2.name ?? npmConfig.name.replace(/@/g, "").replace(/\//g, "-"),
@@ -172,7 +160,7 @@ Options = UnsafeLegacyRenegotiation`.trim(),
 
       const iisDistPath = path.resolve(this._pkgPath, "dist/web.config");
       const serverExeFilePath = this.#pkgConf.iis.nodeExeFilePath ?? "C:\\Program Files\\nodejs\\node.exe";
-      await FsUtil.writeFileAsync(
+      FsUtil.writeFile(
         iisDistPath,
         `
 <configuration>
@@ -207,17 +195,22 @@ Options = UnsafeLegacyRenegotiation`.trim(),
       );
     }
 
-    const result = await this._runAsync({ dev: false });
+    const result = await this._runAsync(false);
     return {
-      affectedFilePaths: Array.from(result.affectedFileSet),
-      buildResults: result.buildResults,
+      affectedFilePathSet: result.affectedFileSet,
+      buildMessages: result.buildMessages,
+      emitFileSet: result.emitFileSet,
     };
   }
 
-  private async _runAsync(opt: { dev: boolean }): Promise<{
-    watchFileSet: Set<string>;
-    affectedFileSet: Set<string>;
-    buildResults: ISdCliPackageBuildResult[];
+  private async _runAsync(
+    dev: boolean,
+    modifiedFileSet?: Set<TNormPath>,
+  ): 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)),
@@ -226,38 +219,36 @@ Options = UnsafeLegacyRenegotiation`.trim(),
     this._debug(`BUILD 준비...`);
     const tsConfig = FsUtil.readJson(path.resolve(this._pkgPath, "tsconfig.json")) as ITsConfig;
     this.#extModules = this.#extModules ?? (await this._getExternalModulesAsync());
-    this.#builder =
-      this.#builder ??
+    this.#serverBundler =
+      this.#serverBundler ??
       new SdServerBundler({
-        dev: opt.dev,
+        dev,
         pkgPath: this._pkgPath,
         entryPoints: tsConfig.files
           ? tsConfig.files.map((item) => path.resolve(this._pkgPath, item))
           : [path.resolve(this._pkgPath, "src/main.ts")],
         external: this.#extModules.map((item) => item.name),
-        watchScopePaths: [path.resolve(this._pkgPath, "../"), ...localUpdatePaths],
+        watchScopePaths: [path.resolve(this._pkgPath, "../"), ...localUpdatePaths].map((item) => PathUtil.norm(item)),
       });
 
-    this._debug(`BUILD & CHECK...`);
-    const buildResult = await this.#builder.bundleAsync();
+    this._debug(`BUILD...`);
+    const bundleResult = await this.#serverBundler.bundleAsync(modifiedFileSet);
 
     //-- filePaths
     const watchFileSet = new Set(
-      Array.from(buildResult.watchFileSet).filter(
+      Array.from(bundleResult.watchFileSet).filter(
         (item) =>
           PathUtil.isChildPath(item, path.resolve(this._pkgPath, "../")) ||
           localUpdatePaths.some((lu) => PathUtil.isChildPath(item, lu)),
       ),
     );
 
-    this._debug(`LINT...`);
-    const lintResults = await SdLinter.lintAsync(this._pkgPath, buildResult.affectedFileSet, buildResult.program);
-
     this._debug(`빌드 완료`);
     return {
       watchFileSet,
-      affectedFileSet: buildResult.affectedFileSet,
-      buildResults: [...buildResult.results, ...lintResults],
+      affectedFileSet: bundleResult.affectedFileSet,
+      buildMessages: bundleResult.results,
+      emitFileSet: bundleResult.emitFileSet,
     };
   }
 
@@ -276,10 +267,7 @@ Options = UnsafeLegacyRenegotiation`.trim(),
     const npmConfigMap = new Map<string, INpmConfig>();
 
     const fn = async (currPath: string): Promise<void> => {
-      const npmConfig = npmConfigMap.getOrCreate(
-        currPath,
-        await FsUtil.readJsonAsync(path.resolve(currPath, "package.json")),
-      );
+      const npmConfig = npmConfigMap.getOrCreate(currPath, FsUtil.readJson(path.resolve(currPath, "package.json")));
 
       const deps = {
         defaults: [

package/src/{build-tools → pkg-builders/server}/SdServerBundler.ts

@@ -1,40 +1,44 @@
-import { ISdCliPackageBuildResult } from "../commons";
 import esbuild from "esbuild";
 import path from "path";
-import { IServerPluginResultCache, sdServerPlugin } from "../bundle-plugins/sdServerPlugin";
-import ts from "typescript";
-import { Logger } from "@simplysm/sd-core-node";
+import { FsUtil, Logger, PathUtil, TNormPath } from "@simplysm/sd-core-node";
+import { SdCliConvertMessageUtil } from "../../utils/SdCliConvertMessageUtil";
+import { ISdCliServerPluginResultCache } from "../../types/build-plugin.type";
+import { ISdBuildMessage } from "../../types/build.type";
+import { createSdServerPlugin } from "./createSdServerPlugin";
+import { BuildOutputFile, BuildOutputFileType } from "@angular/build/src/tools/esbuild/bundler-context";
+import { convertOutputFile } from "@angular/build/src/tools/esbuild/utils";
 
 export class SdServerBundler {
   readonly #logger = Logger.get(["simplysm", "sd-cli", "SdServerBundler"]);
 
   #context?: esbuild.BuildContext;
 
-  #modifiedFileSet = new Set<string>();
-  #resultCache: IServerPluginResultCache = {};
+  readonly #modifiedFileSet = new Set<TNormPath>();
+  readonly #resultCache: ISdCliServerPluginResultCache = {};
+
+  readonly #outputCache = new Map<TNormPath, string | number>();
 
   constructor(
     private readonly _opt: {
       dev: boolean;
-      pkgPath: string;
+      pkgPath: TNormPath;
       entryPoints: string[];
       external?: string[];
-      watchScopePaths: string[];
+      watchScopePaths: TNormPath[];
     },
   ) {}
 
-  public markForChanges(filePaths: string[]): void {
-    for (const filePath of filePaths) {
-      this.#modifiedFileSet.add(path.normalize(filePath));
+  async bundleAsync(modifiedFileSet?: Set<TNormPath>): Promise<{
+    watchFileSet: Set<TNormPath>;
+    affectedFileSet: Set<TNormPath>;
+    results: ISdBuildMessage[];
+    emitFileSet: Set<TNormPath>;
+  }> {
+    this.#modifiedFileSet.clear();
+    if (modifiedFileSet) {
+      this.#modifiedFileSet.adds(...modifiedFileSet);
     }
-  }
 
-  async bundleAsync(): Promise<{
-    program: ts.Program;
-    watchFileSet: Set<string>;
-    affectedFileSet: Set<string>;
-    results: ISdCliPackageBuildResult[];
-  }> {
     if (!this.#context) {
       this.#context = await esbuild.context({
         entryPoints: this._opt.entryPoints,
@@ -45,7 +49,7 @@ export class SdServerBundler {
         mainFields: ["es2020", "es2015", "module", "main"],
         conditions: ["es2020", "es2015", "module"],
         tsconfig: path.resolve(this._opt.pkgPath, "tsconfig.json"),
-        write: true,
+        write: false,
         metafile: true,
         outdir: path.resolve(this._opt.pkgPath, "dist"),
         format: "esm",
@@ -92,7 +96,7 @@ const __filename = __fileURLToPath__(import.meta.url);
 const __dirname = __path__.dirname(__filename);`.trim(),
         },
         plugins: [
-          sdServerPlugin({
+          createSdServerPlugin({
             modifiedFileSet: this.#modifiedFileSet,
             dev: this._opt.dev,
             pkgPath: this._opt.pkgPath,
@@ -103,9 +107,23 @@ const __dirname = __path__.dirname(__filename);`.trim(),
       });
     }
 
+    const emitFileSet = new Set<TNormPath>();
     let result: esbuild.BuildResult | esbuild.BuildFailure;
     try {
       result = await this.#context.rebuild();
+
+      const outputFiles: BuildOutputFile[] =
+        result.outputFiles?.map((file) => convertOutputFile(file, BuildOutputFileType.Root)) ?? [];
+
+      for (const outputFile of outputFiles) {
+        const distFilePath = PathUtil.norm(this._opt.pkgPath, outputFile.path);
+        const prev = this.#outputCache.get(distFilePath);
+        if (prev !== Buffer.from(outputFile.contents).toString("base64")) {
+          FsUtil.writeFile(distFilePath, outputFile.contents);
+          this.#outputCache.set(distFilePath, Buffer.from(outputFile.contents).toString("base64"));
+          emitFileSet.add(distFilePath);
+        }
+      }
     } catch (err) {
       result = err;
       for (const e of err.errors) {
@@ -116,29 +134,10 @@ const __dirname = __path__.dirname(__filename);`.trim(),
     }
 
     return {
-      program: this.#resultCache.program!,
       watchFileSet: this.#resultCache.watchFileSet!,
       affectedFileSet: this.#resultCache.affectedFileSet!,
-      results: [
-        ...result.warnings.map((warn) => ({
-          type: "build" as const,
-          filePath: warn.location?.file !== undefined ? path.resolve(warn.location.file) : undefined,
-          line: warn.location?.line,
-          char: warn.location?.column,
-          code: warn.text.slice(0, warn.text.indexOf(":")),
-          severity: "warning" as const,
-          message: `(${warn.pluginName}) ${warn.text.slice(warn.text.indexOf(":") + 1)}`,
-        })),
-        ...result.errors.map((err) => ({
-          type: "build" as const,
-          filePath: err.location?.file !== undefined ? path.resolve(err.location.file) : undefined,
-          line: err.location?.line,
-          char: err.location?.column !== undefined ? err.location.column + 1 : undefined,
-          code: err.text.slice(0, err.text.indexOf(":")),
-          severity: "error" as const,
-          message: `(${err.pluginName}) ${err.text.slice(err.text.indexOf(":") + 1)}`,
-        })),
-      ],
+      results: SdCliConvertMessageUtil.convertToBuildMessagesFromEsbuild(result, this._opt.pkgPath),
+      emitFileSet: emitFileSet,
     };
   }
 }

package/src/pkg-builders/server/createSdServerPlugin.ts

@@ -0,0 +1,77 @@
+import esbuild from "esbuild";
+import { SdCliConvertMessageUtil } from "../../utils/SdCliConvertMessageUtil";
+import { ISdCliServerPluginResultCache } from "../../types/build-plugin.type";
+import { PathUtil, TNormPath } from "@simplysm/sd-core-node";
+import { SdTsCompileWorker } from "../../ts-builder/SdTsCompileWorker";
+import { ISdTsCompilerResult } from "../../types/ts-compiler.type";
+
+export function createSdServerPlugin(conf: {
+  pkgPath: TNormPath;
+  dev: boolean;
+  modifiedFileSet: Set<TNormPath>;
+  result: ISdCliServerPluginResultCache;
+  watchScopePaths: TNormPath[];
+}): esbuild.Plugin {
+  return {
+    name: "sd-server-compile",
+    setup: async (build: esbuild.PluginBuild) => {
+      const tsCompiler = await SdTsCompileWorker.new({
+        pkgPath: conf.pkgPath,
+        additionalOptions: { declaration: false },
+        isDevMode: conf.dev,
+        isForBundle: true,
+        watchScopePaths: conf.watchScopePaths,
+      });
+
+      let tsCompileResult: ISdTsCompilerResult;
+
+      build.onStart(async () => {
+        tsCompileResult = await tsCompiler.compileAsync(conf.modifiedFileSet);
+
+        conf.result.watchFileSet = tsCompileResult.watchFileSet;
+        conf.result.affectedFileSet = tsCompileResult.affectedFileSet;
+
+        //-- return err/warn
+        return SdCliConvertMessageUtil.convertToEsbuildFromBuildMessages(tsCompileResult.messages, conf.pkgPath);
+      });
+
+      build.onLoad({ filter: /\.ts$/ }, (args) => {
+        const emittedJsFile = tsCompileResult.emittedFilesCacheMap.get(PathUtil.norm(args.path))?.last();
+        if (!emittedJsFile) {
+          throw new Error(`ts 빌더 결과 emit 파일이 존재하지 않습니다. ${args.path}`);
+        }
+
+        const contents = emittedJsFile.text;
+        return { contents, loader: "js" };
+      });
+
+      build.onLoad({ filter: /\.[cm]?js$/ }, (args) => {
+        conf.result.watchFileSet!.add(PathUtil.norm(args.path));
+        return null;
+      });
+
+      build.onLoad(
+        {
+          filter: new RegExp(
+            "(" +
+              Object.keys(build.initialOptions.loader!)
+                .map((item) => "\\" + item)
+                .join("|") +
+              ")$",
+          ),
+        },
+        (args) => {
+          conf.result.watchFileSet!.add(PathUtil.norm(args.path));
+          return null;
+        },
+      );
+
+      build.onEnd((result) => {
+        conf.result.outputFiles = result.outputFiles;
+        conf.result.metafile = result.metafile;
+
+        conf.modifiedFileSet.clear();
+      });
+    },
+  };
+}