@simplysm/sd-cli 7.0.37 → 7.0.41

package/src/builder/SdCliServerBuilder.ts

@@ -50,9 +50,8 @@ export class SdCliServerBuilder extends EventEmitter {
     await new Promise<void>((resolve, reject) => {
       compiler.hooks.watchRun.tapAsync(this.constructor.name, (args, callback) => {
         this.emit("change");
-        callback();
-
         this._logger.debug("Webpack 빌드 수행...");
+        callback();
       });
 
       compiler.watch({}, async (err, stats) => {
@@ -65,11 +64,9 @@ export class SdCliServerBuilder extends EventEmitter {
         await this._writeDistConfigFileAsync();
 
         // 결과 반환
+        this._logger.debug("Webpack 빌드 완료");
         const results = SdCliBuildResultUtil.convertFromWebpackStats(stats);
         this.emit("complete", results);
-
-        // 마무리
-        this._logger.debug("Webpack 빌드 완료");
         resolve();
       });
     });
@@ -239,7 +236,9 @@ export class SdCliServerBuilder extends EventEmitter {
         outputModule: true
       },
       performance: { hints: false },
-      node: false,
+      node: {
+        __dirname: true
+      },
       stats: "errors-warnings",
       externals: extModuleNames,
       ...watch ? {

package/src/builder/SdCliTsLibBuilder.ts

@@ -33,7 +33,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
 
   private readonly _isAngular: boolean;
 
-  public constructor(private readonly _rootPath) {
+  public constructor(private readonly _rootPath: string) {
     super();
     this._linter = new SdCliPackageLinter(this._rootPath);
 
@@ -66,7 +66,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
 
     const relatedPaths = await this.getAllRelatedPathsAsync();
     const watcher = SdFsWatcher.watch(relatedPaths);
-    watcher.onChange(async (changeInfos) => {
+    watcher.onChange({}, async (changeInfos) => {
       const changeFilePaths = changeInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
       if (changeFilePaths.length === 0) return;
 
@@ -194,7 +194,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
     }
     catch (err) {
       if (err instanceof sass.Exception) {
-        const matches = err.sassStack.match(/^(.*\.sd\.scss) ([0-9]*):([0-9]*)/)!;
+        const matches = (/^(.*\.sd\.scss) ([0-9]*):([0-9]*)/).exec(err.sassStack)!;
         const filePath = path.resolve(matches[1].replace(/\.sd\.scss/, "").replace(/^\.:/, item => item.toUpperCase()));
         const scssLine = matches[2];
         const scssChar = matches[3];
@@ -206,7 +206,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
           char: undefined,
           code: undefined,
           severity: "error",
-          message: `스타일(${scssLine}:${scssChar}): ${message}`
+          message: `스타일(${scssLine}:${scssChar}): ${message}\n${err.message}`
         }];
       }
 
@@ -234,7 +234,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
     const affectedSourceFileSet: Set<ts.SourceFile> = new Set<ts.SourceFile>();
     while (true) {
       const result = this._builder.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => {
-        if (ngCompiler && ngCompiler.ignoreForDiagnostics.has(sourceFile) && sourceFile.fileName.endsWith(".ngtypecheck.ts")) {
+        if (ngCompiler?.ignoreForDiagnostics.has(sourceFile) && sourceFile.fileName.endsWith(".ngtypecheck.ts")) {
           const orgFileName = sourceFile.fileName.slice(0, -15) + ".ts";
           const orgSourceFile = this._builder!.getSourceFile(orgFileName);
           if (orgSourceFile) {

package/src/commons.ts

@@ -40,7 +40,7 @@ export interface ISdCliConfig {
   localUpdates?: Record<string, string>;
 }
 
-export type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliServerPackageConfig;
+export type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliServerPackageConfig | ISdCliClientPackageConfig;
 
 export interface ISdCliLibPackageConfig {
   type: "library";
@@ -54,3 +54,8 @@ export interface ISdCliServerPackageConfig {
   pm2?: Record<string, any> | boolean;
   iis?: { serverExeFilePath?: string } | boolean;
 }
+
+export interface ISdCliClientPackageConfig {
+  type: "client";
+  server: string;
+}

package/src/entry-points/SdCliLocalUpdate.ts

@@ -40,19 +40,25 @@ export class SdCliLocalUpdate {
     const watchPaths = (await updatePathInfos.mapManyAsync(async (item) => await this._getWatchPathsAsync(item.source))).distinct();
 
     const watcher = SdFsWatcher.watch(watchPaths);
-    watcher.onChange(async (changeInfos) => {
+    watcher.onChange({ delay: 1000 }, async (changeInfos) => {
       const changeFilePaths = changeInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
       if (changeFilePaths.length === 0) return;
 
       this._logger.log("로컬 라이브러리 변경감지...");
       for (const changedFilePath of changeFilePaths) {
-        const currentUpdatePathInfos = updatePathInfos.filter((item) => PathUtil.isChildPath(changedFilePath, item.source));
-        const targetFilePaths = currentUpdatePathInfos.map((item) => path.resolve(item.target, path.relative(item.source, changedFilePath)));
-        if (FsUtil.exists(changedFilePath)) {
-          this._logger.debug(`변경파일감지(복사): ${changedFilePath}`);
-          for (const targetFilePath of targetFilePaths) {
-            await FsUtil.copyAsync(changedFilePath, targetFilePath);
-          }
+        if (!FsUtil.exists(changedFilePath)) continue;
+
+        for (const updatePathInfo of updatePathInfos) {
+          if (!PathUtil.isChildPath(changedFilePath, updatePathInfo.source)) continue;
+
+          const sourceRelPath = path.relative(updatePathInfo.source, changedFilePath);
+          if (sourceRelPath.includes("node_modules")) continue;
+          if (sourceRelPath.includes("package.json")) continue;
+
+          const targetFilePath = path.resolve(updatePathInfo.target, sourceRelPath);
+
+          this._logger.debug(`변경파일감지(복사): ${changedFilePath} => ${targetFilePath}`);
+          await FsUtil.copyAsync(changedFilePath, targetFilePath);
         }
       }
 

package/src/entry-points/SdCliPrepare.ts

@@ -1,4 +1,5 @@
 import { FsUtil, Logger } from "@simplysm/sd-core-node";
+import { fileURLToPath } from "url";
 
 export class SdCliPrepare {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
@@ -11,7 +12,7 @@ export class SdCliPrepare {
 
   private async _modifyTypescriptCodeForTypeCheckPerformanceWarning(): Promise<boolean> {
     const fileUrl = await import.meta.resolve!("typescript");
-    const filePath = fileUrl.replace(/^file:\/\/\//, "");
+    const filePath = fileURLToPath(fileUrl);
     const fileContent = await FsUtil.readFileAsync(filePath);
     const modifiedFileContent = fileContent.replace(`
         function checkSourceElement(node) {

package/src/entry-points/SdCliWorkspace.ts

@@ -10,6 +10,7 @@ import { SdCliConfigUtil } from "../utils/SdCliConfigUtil";
 import { SdServiceServer } from "@simplysm/sd-service/server";
 import { SdCliNpm } from "./SdCliNpm";
 import { SdCliLocalUpdate } from "./SdCliLocalUpdate";
+import { NextHandleFunction } from "connect";
 
 export class SdCliWorkspace {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
@@ -47,11 +48,7 @@ export class SdCliWorkspace {
           this._logger.debug(`[${pkg.name}] 빌드를 시작합니다...`);
         })
         .on("complete", async (results) => {
-          if (pkg.type === "server") {
-            if (results.some((item) => item.severity === "error")) {
-              return;
-            }
-
+          if (pkg.config.type === "server" && !results.some((item) => item.severity === "error")) {
             await this._restartServerAsync(pkg);
           }
 
@@ -62,6 +59,7 @@ export class SdCliWorkspace {
             changeCount--;
             if (changeCount === 0) {
               this._loggingResults(totalResultMap);
+              this._loggingOpenClientHrefs();
               this._logger.info("모든 빌드가 완료되었습니다.");
             }
           }, 500);
@@ -73,7 +71,16 @@ export class SdCliWorkspace {
     const buildCompletedPackageNames: string[] = [];
     await pkgs.parallelAsync(async (pkg) => {
       await Wait.until(() => !pkg.allDependencies.some((dep) => pkgNames.includes(dep) && !buildCompletedPackageNames.includes(dep)));
-      await pkg.watchAsync();
+      if (pkg.config.type === "client") {
+        const middlewares = (await pkg.watchAsync()) as NextHandleFunction[];
+
+        const serverInfo = this._serverInfoMap.getOrCreate(pkg.config.server, { middlewares: [], clientInfos: [] });
+        serverInfo.middlewares.push(...middlewares);
+        serverInfo.clientInfos.push({ pkgKey: pkg.name.split("/").last()! });
+      }
+      else {
+        await pkg.watchAsync();
+      }
       buildCompletedPackageNames.push(pkg.name);
     });
   }
@@ -87,21 +94,26 @@ export class SdCliWorkspace {
     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) {
-      this._logger.error(`${entryFilePath}(0, 0): 'SdServiceServer'를 'export'해야 합니다.`);
-      return;
-    }
+    try {
+      const serverInfo = this._serverInfoMap.getOrCreate(pkg.name, { middlewares: [], clientInfos: [] });
+      if (serverInfo.server) {
+        await serverInfo.server.closeAsync();
+        delete serverInfo.server;
+      }
 
-    await Wait.until(() => serverInfo.server!.isOpen);
+      serverInfo.server = (await import("file:///" + entryFilePath + "?update=" + Uuid.new().toString())).default as SdServiceServer | undefined;
+      if (!serverInfo.server) {
+        this._logger.error(`${entryFilePath}(0, 0): 'SdServiceServer'를 'export'해야 합니다.`);
+        return;
+      }
+      serverInfo.server.devMiddlewares = serverInfo.middlewares;
+      await Wait.until(() => serverInfo.server!.isOpen);
 
-    this._logger.log(`서버(${pkg.name}) 재시작 완료`);
+      this._logger.log(`서버(${pkg.name}) 재시작 완료`);
+    }
+    catch (err) {
+      this._logger.error(`서버(${pkg.name}) 재시작중 오류 발생`, err);
+    }
   }
 
   public async buildAsync(opt: { confFileRelPath: string; optNames: string[] }): Promise<void> {
@@ -226,7 +238,7 @@ export class SdCliWorkspace {
       if (i !== sec) {
         process.stdout.cursorTo(0);
       }
-      process.stdout.write(msg + " " + i);
+      process.stdout.write(`${msg} ${i}`);
       await Wait.time(1000);
     }
 
@@ -252,7 +264,7 @@ export class SdCliWorkspace {
         pkgName: item[0],
         ...item1
       })))
-      .orderBy((item) => item.pkgName + "_" + item.filePath);
+      .orderBy((item) => `${item.pkgName}_${item.filePath}`);
 
     const warnings = totalResults
       .filter((item) => item.severity === "warning")
@@ -278,8 +290,29 @@ export class SdCliWorkspace {
       this._logger.warn(`경고: ${warnings.length}건, 오류: ${errors.length}건`);
     }
   }
+
+  private _loggingOpenClientHrefs(): void {
+    const clientHrefs: string[] = [];
+
+    const serverInfos = Array.from(this._serverInfoMap.values());
+    for (const serverInfo of serverInfos) {
+      if (!serverInfo.server) continue;
+
+      const protocolStr = serverInfo.server.options.ssl ? "https" : "http";
+      const portStr = serverInfo.server.options.port.toString();
+
+      for (const clientInfo of serverInfo.clientInfos) {
+        clientHrefs.push(`${protocolStr}://localhost:${portStr}/${clientInfo.pkgKey}/`);
+      }
+    }
+    if (clientHrefs.length > 0) {
+      this._logger.log(`오픈된 클라이언트: ${clientHrefs.join(", ")}`);
+    }
+  }
 }
 
 interface IServerInfo {
   server?: SdServiceServer;
+  middlewares: NextHandleFunction[];
+  clientInfos: { pkgKey: string }[];
 }

package/src/packages/SdCliPackage.ts

@@ -7,6 +7,8 @@ import { SdCliTsLibBuilder } from "../builder/SdCliTsLibBuilder";
 import { SdCliJsLibBuilder } from "../builder/SdCliJsLibBuilder";
 import { SdCliServerBuilder } from "../builder/SdCliServerBuilder";
 import { SdCliNpmConfigUtil } from "../utils/SdCliNpmConfigUtil";
+import { SdCliClientBuilder } from "../builder/SdCliClientBuilder";
+import { NextHandleFunction } from "connect";
 
 export class SdCliPackage extends EventEmitter {
   private readonly _npmConfig: INpmConfig;
@@ -23,10 +25,6 @@ export class SdCliPackage extends EventEmitter {
     return this._npmConfig.main;
   }
 
-  public get type(): TSdCliPackageConfig["type"] {
-    return this._config.type;
-  }
-
   public get allDependencies(): string[] {
     return [
       ...SdCliNpmConfigUtil.getDependencies(this._npmConfig).defaults,
@@ -36,7 +34,7 @@ export class SdCliPackage extends EventEmitter {
 
   public constructor(private readonly _workspaceRootPath: string,
                      public readonly rootPath: string,
-                     private readonly _config: TSdCliPackageConfig) {
+                     public readonly config: TSdCliPackageConfig) {
     super();
 
     const npmConfigFilePath = path.resolve(this.rootPath, "package.json");
@@ -69,8 +67,8 @@ export class SdCliPackage extends EventEmitter {
     await FsUtil.writeJsonAsync(npmConfigFilePath, this._npmConfig, { space: 2 });
   }
 
-  public async watchAsync(): Promise<void> {
-    await (await this._createBuilderAsync())
+  public async watchAsync(): Promise<NextHandleFunction[] | void> {
+    return await (await this._createBuilderAsync())
       .on("change", () => {
         this.emit("change");
       })
@@ -85,24 +83,27 @@ export class SdCliPackage extends EventEmitter {
   }
 
   public async publishAsync(): Promise<void> {
-    if (this._config.type === "library" && this._config.publish === "npm") {
+    if (this.config.type === "library" && this.config.publish === "npm") {
       await SdProcess.spawnAsync("npm publish --quiet --access public", { cwd: this.rootPath });
     }
   }
 
-  private async _createBuilderAsync(): Promise<SdCliJsLibBuilder | SdCliTsLibBuilder | SdCliServerBuilder> {
+  private async _createBuilderAsync(): Promise<SdCliJsLibBuilder | SdCliTsLibBuilder | SdCliServerBuilder | SdCliClientBuilder> {
     const isTs = FsUtil.exists(path.resolve(this.rootPath, "tsconfig.json"));
 
     if (isTs) {
       await this._genBuildTsconfigAsync();
     }
 
-    if (this._config.type === "library") {
+    if (this.config.type === "library") {
       // const isAngular = isTs && this.allDependencies.includes("@angular/core");
       return isTs ? new SdCliTsLibBuilder(this.rootPath) : new SdCliJsLibBuilder(this.rootPath);
     }
+    else if (this.config.type === "server") {
+      return new SdCliServerBuilder(this.rootPath, this.config, this._workspaceRootPath);
+    }
     else {
-      return new SdCliServerBuilder(this.rootPath, this._config, this._workspaceRootPath);
+      return new SdCliClientBuilder(this.rootPath, this.config, this._workspaceRootPath);
     }
   }
 

package/src/utils/SdCliBuildResultUtil.ts

@@ -11,7 +11,7 @@ export class SdCliBuildResultUtil {
         : undefined;
     if (!severity) return undefined;
 
-    const code = "TS" + diag.code;
+    const code = `TS${diag.code}`;
     const message = ts.flattenDiagnosticMessageText(diag.messageText, os.EOL);
 
 
@@ -49,8 +49,8 @@ export class SdCliBuildResultUtil {
   private static _convertFromWebpackError(severity: "warning" | "error", err: webpack.WebpackError): ISdCliPackageBuildResult {
     return {
       filePath: err.file,
-      line: err.loc["start"].line,
-      char: err.loc["start"].column,
+      line: err.file ? err.loc["start"]?.line : undefined,
+      char: err.file ? err.loc["start"]?.column : undefined,
       code: err.name,
       severity,
       message: err.message

package/tsconfig.json

@@ -14,7 +14,7 @@
         "../sd-core-common/src/index.ts"
       ],
       "@simplysm/sd-service/server": [
-        "../sd-service/src/server.ts"
+        "../sd-service/src/server/index.ts"
       ]
     }
   }