@simplysm/sd-cli 7.0.37 → 7.0.38

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> {
@@ -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

@@ -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