@simplysm/sd-cli 7.0.19 → 7.0.23

package/dist/bin/sd-cli.d.ts

@@ -1,2 +1,2 @@
-#!/usr/bin/env node
+#!/usr/bin/env node --experimental-specifier-resolution=node
 export {};

package/dist/bin/sd-cli.mjs

@@ -1,9 +1,11 @@
-#!/usr/bin/env node
+#!/usr/bin/env node --experimental-specifier-resolution=node
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { Logger, LoggerSeverity } from "@simplysm/sd-core-node";
 import { SdCliWorkspace } from "../entry-points/SdCliWorkspace";
 import { SdCliLocalUpdate } from "../entry-points/SdCliLocalUpdate";
+import sourceMapSupport from "source-map-support";
+sourceMapSupport.install();
 Error.stackTraceLimit = Infinity;
 const argv = yargs(hideBin(process.argv))
     .version(false)
@@ -28,6 +30,11 @@ const argv = yargs(hideBin(process.argv))
     config: {
         type: "string",
         describe: "simplysm.json 파일 경로"
+    },
+    options: {
+        type: "string",
+        array: true,
+        describe: "옵션 설정 (설정파일에서 @로 시작하는 부분)"
     }
 }))
     .command("build", "프로젝트의 각 패키지에 대한 빌드를 수행합니다.", (cmd) => cmd.version(false)
@@ -35,18 +42,28 @@ const argv = yargs(hideBin(process.argv))
     config: {
         type: "string",
         describe: "simplysm.json 파일 경로"
+    },
+    options: {
+        type: "string",
+        array: true,
+        describe: "옵션 설정 (설정파일에서 @로 시작하는 부분)"
     }
 }))
     .command("publish", "프로젝트의 각 패키지를 배포합니다.", (cmd) => cmd.version(false)
     .options({
+    noBuild: {
+        type: "boolean",
+        describe: "빌드를 하지않고 배포합니다.",
+        default: false
+    },
     config: {
         type: "string",
         describe: "simplysm.json 파일 경로"
     },
-    "noBuild": {
-        type: "boolean",
-        describe: "빌드를 하지않고 배포합니다.",
-        default: false
+    options: {
+        type: "string",
+        array: true,
+        describe: "옵션 설정 (설정파일에서 @로 시작하는 부분)"
     }
 }))
     .parseSync();
@@ -66,21 +83,31 @@ else {
 const logger = Logger.get(["simplysm", "sd-cli", "bin", "sd-cli"]);
 (async () => {
     if (argv._[0] === "local-update") {
-        await new SdCliLocalUpdate(process.cwd(), argv.config)
-            .runAsync();
+        await new SdCliLocalUpdate(process.cwd())
+            .runAsync({
+            confFileRelPath: argv.config ?? "simplysm.json"
+        });
     }
     else if (argv._[0] === "watch") {
-        await new SdCliWorkspace(process.cwd(), argv.config)
-            .watchAsync();
+        await new SdCliWorkspace(process.cwd())
+            .watchAsync({
+            confFileRelPath: argv.config ?? "simplysm.json",
+            optNames: argv.options ?? []
+        });
     }
     else if (argv._[0] === "build") {
-        await new SdCliWorkspace(process.cwd(), argv.config)
-            .buildAsync();
+        await new SdCliWorkspace(process.cwd())
+            .buildAsync({
+            confFileRelPath: argv.config ?? "simplysm.json",
+            optNames: argv.options ?? []
+        });
     }
     else if (argv._[0] === "publish") {
-        await new SdCliWorkspace(process.cwd(), argv.config)
+        await new SdCliWorkspace(process.cwd())
             .publishAsync({
-            noBuild: argv.noBuild
+            noBuild: argv.noBuild,
+            confFileRelPath: argv.config ?? "simplysm.json",
+            optNames: argv.options ?? []
         });
     }
     else {
@@ -89,4 +116,4 @@ const logger = Logger.get(["simplysm", "sd-cli", "bin", "sd-cli"]);
 })().catch((err) => {
     logger.error(err);
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commons.d.ts

@@ -34,7 +34,7 @@ export interface ISdCliConfig {
     packages: Record<string, TSdCliPackageConfig | undefined>;
     localUpdates?: Record<string, string>;
 }
-export declare type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliNgLibPackageConfig;
+export declare type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliNgLibPackageConfig | ISdCliServerPackageConfig;
 export interface ISdCliLibPackageConfig {
     type: "library";
     publish?: "npm";

package/dist/entry-points/SdCliLocalUpdate.d.ts

@@ -1,10 +1,13 @@
 export declare class SdCliLocalUpdate {
     private readonly _rootPath;
-    private readonly _configFilePath?;
     private readonly _logger;
-    constructor(_rootPath: string, _configFilePath?: string | undefined);
-    runAsync(): Promise<void>;
-    watchAsync(): Promise<void>;
+    constructor(_rootPath: string);
+    runAsync(opt: {
+        confFileRelPath: string;
+    }): Promise<void>;
+    watchAsync(opt: {
+        confFileRelPath: string;
+    }): Promise<void>;
     private _getUpdatePathInfosAsync;
     protected _getWatchPathsAsync(sourcePath: string): Promise<string[]>;
 }

package/dist/entry-points/SdCliLocalUpdate.mjs

@@ -2,14 +2,13 @@ import { SdCliConfigUtil } from "../utils/SdCliConfigUtil";
 import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
 import * as path from "path";
 export class SdCliLocalUpdate {
-    constructor(_rootPath, _configFilePath) {
+    constructor(_rootPath) {
         this._rootPath = _rootPath;
-        this._configFilePath = _configFilePath;
         this._logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
     }
-    async runAsync() {
+    async runAsync(opt) {
         this._logger.debug("프로젝트 설정 가져오기...");
-        const conf = SdCliConfigUtil.loadConfig(path.resolve(this._rootPath, this._configFilePath ?? "simplysm.json"), false);
+        const conf = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), false);
         if (!conf.localUpdates)
             return;
         const updatePathInfos = await this._getUpdatePathInfosAsync(conf.localUpdates);
@@ -26,9 +25,9 @@ export class SdCliLocalUpdate {
         }
         this._logger.info("로컬 라이브러리 업데이트 완료");
     }
-    async watchAsync() {
+    async watchAsync(opt) {
         this._logger.debug("프로젝트 설정 가져오기...");
-        const conf = SdCliConfigUtil.loadConfig(path.resolve(this._rootPath, this._configFilePath ?? "simplysm.json"), false);
+        const conf = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), false);
         if (!conf.localUpdates)
             return;
         const updatePathInfos = await this._getUpdatePathInfosAsync(conf.localUpdates);
@@ -87,4 +86,4 @@ export class SdCliLocalUpdate {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/entry-points/SdCliWorkspace.d.ts

@@ -1,15 +1,22 @@
 export declare class SdCliWorkspace {
     private readonly _rootPath;
-    private readonly _configFilePath?;
     private readonly _logger;
     private readonly _npmConfig;
-    private readonly _config;
-    constructor(_rootPath: string, _configFilePath?: string | undefined);
-    watchAsync(): Promise<void>;
-    buildAsync(): Promise<void>;
+    private readonly _serverInfoMap;
+    constructor(_rootPath: string);
+    watchAsync(opt: {
+        confFileRelPath: string;
+        optNames: string[];
+    }): Promise<void>;
+    buildAsync(opt: {
+        confFileRelPath: string;
+        optNames: string[];
+    }): Promise<void>;
     private _buildPkgsAsync;
     publishAsync(opt: {
         noBuild: boolean;
+        confFileRelPath: string;
+        optNames: string[];
     }): Promise<void>;
     private _upgradeVersionAsync;
     private _waitSecMessageAsync;

package/dist/entry-points/SdCliWorkspace.mjs

@@ -5,18 +5,21 @@ import { Wait } from "@simplysm/sd-core-common";
 import os from "os";
 import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
 import semver from "semver/preload";
+import { SdCliConfigUtil } from "../utils/SdCliConfigUtil";
+import decache from "decache";
 export class SdCliWorkspace {
-    constructor(_rootPath, _configFilePath) {
+    constructor(_rootPath) {
         this._rootPath = _rootPath;
-        this._configFilePath = _configFilePath;
         this._logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
+        this._serverInfoMap = new Map();
         const npmConfigFilePath = path.resolve(this._rootPath, "package.json");
         this._npmConfig = FsUtil.readJson(npmConfigFilePath);
-        this._config = FsUtil.readJson(path.resolve(this._rootPath, this._configFilePath ?? "simplysm.json"));
     }
-    async watchAsync() {
+    async watchAsync(opt) {
+        this._logger.debug("프로젝트 설정 가져오기...");
+        const config = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), true, opt.optNames);
         this._logger.debug("패키지 목록 구성...");
-        const pkgs = await this._getPackagesAsync();
+        const pkgs = await this._getPackagesAsync(config);
         this._logger.debug("패키지 이벤트 설정...");
         let changeCount = 0;
         const totalResultMap = new Map();
@@ -40,6 +43,33 @@ export class SdCliWorkspace {
                     }
                 }, 500);
             });
+            if (pkg.type === "server") {
+                pkg.on("complete", async (results) => {
+                    if (results.some((item) => item.severity === "error")) {
+                        return;
+                    }
+                    const entryFileRelPath = pkg.main;
+                    if (entryFileRelPath === undefined) {
+                        this._logger.error(`서버패키지(${pkg.name})의 'package.json'에서 'main'필드를 찾을 수 없습니다.`);
+                        return;
+                    }
+                    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;
+                        decache(entryFilePath);
+                    }
+                    serverInfo.server = (await import(entryFilePath));
+                    if (serverInfo.server === undefined) {
+                        this._logger.error(`${entryFilePath}(0, 0): 'SdServiceServer'를 'export'해야 합니다.`);
+                        return;
+                    }
+                    await Wait.until(() => serverInfo.server.isOpen);
+                    this._logger.log(`서버(${pkg.name}) 재시작 완료`);
+                });
+            }
         }
         this._logger.debug("빌드를 시작합니다...");
         const pkgNames = pkgs.map((item) => item.name);
@@ -50,9 +80,11 @@ export class SdCliWorkspace {
             buildCompletedPackageNames.push(pkg.name);
         });
     }
-    async buildAsync() {
+    async buildAsync(opt) {
+        this._logger.debug("프로젝트 설정 가져오기...");
+        const config = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), false, opt.optNames);
         this._logger.debug("패키지 목록 구성...");
-        const pkgs = await this._getPackagesAsync();
+        const pkgs = await this._getPackagesAsync(config);
         this._logger.debug("프로젝트 및 패키지 버전 설정...");
         await this._upgradeVersionAsync(pkgs);
         // 빌드
@@ -79,6 +111,8 @@ export class SdCliWorkspace {
         }
     }
     async publishAsync(opt) {
+        this._logger.debug("프로젝트 설정 가져오기...");
+        const config = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), false, opt.optNames);
         if (opt.noBuild) {
             this._logger.warn("빌드하지 않고, 배포하는것은 상당히 위험합니다.");
             await this._waitSecMessageAsync("프로세스를 중지하려면, 'CTRL+C'를 누르세요.", 5);
@@ -92,7 +126,7 @@ export class SdCliWorkspace {
             }
         }
         this._logger.debug("패키지 목록 구성...");
-        const pkgs = await this._getPackagesAsync();
+        const pkgs = await this._getPackagesAsync(config);
         this._logger.debug("프로젝트 및 패키지 버전 설정...");
         await this._upgradeVersionAsync(pkgs);
         // 빌드
@@ -151,13 +185,13 @@ export class SdCliWorkspace {
         process.stdout.cursorTo(0);
         process.stdout.clearLine(0);
     }
-    async _getPackagesAsync() {
+    async _getPackagesAsync(conf) {
         const pkgRootPaths = await this._npmConfig.workspaces?.mapManyAsync(async (item) => await FsUtil.globAsync(item));
         if (!pkgRootPaths) {
             throw new Error("최상위 'package.json'에서 'workspaces'를 찾을 수 없습니다.");
         }
         return pkgRootPaths.map((pkgRootPath) => {
-            const pkgConfig = this._config.packages[path.basename(pkgRootPath)];
+            const pkgConfig = conf.packages[path.basename(pkgRootPath)];
             return pkgConfig ? new SdCliPackage(this._rootPath, pkgRootPath, pkgConfig) : undefined;
         }).filterExists();
     }
@@ -190,4 +224,4 @@ export class SdCliWorkspace {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SdCliWorkspace.js","sourceRoot":"","sources":["../../src/entry-points/SdCliWorkspace.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SdCliWorkspace.js","sourceRoot":"","sources":["../../src/entry-points/SdCliWorkspace.ts"],"names":[],"mappings":"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"}

package/dist/packages/SdCliPackage.d.ts

@@ -3,12 +3,15 @@ import { ISdCliPackageBuildResult, TSdCliPackageConfig } from "../commons";
 import { EventEmitter } from "events";
 export declare class SdCliPackage extends EventEmitter {
     private readonly _workspaceRootPath;
-    private readonly _rootPath;
+    readonly rootPath: string;
     private readonly _config;
     private readonly _npmConfig;
+    get basename(): string;
     get name(): string;
+    get main(): string | undefined;
+    get type(): TSdCliPackageConfig["type"];
     get allDependencies(): string[];
-    constructor(_workspaceRootPath: string, _rootPath: string, _config: TSdCliPackageConfig);
+    constructor(_workspaceRootPath: string, rootPath: string, _config: TSdCliPackageConfig);
     on(event: "change", listener: () => void): this;
     on(event: "complete", listener: (results: ISdCliPackageBuildResult[]) => void): this;
     setNewVersionAsync(newVersion: string, pkgNames: string[]): Promise<void>;

package/dist/packages/SdCliPackage.mjs

@@ -5,17 +5,26 @@ import { ObjectUtil } from "@simplysm/sd-core-common";
 import { SdCliTsLibBuilder } from "../builder/SdCliTsLibBuilder";
 import { SdCliJsLibBuilder } from "../builder/SdCliJsLibBuilder";
 export class SdCliPackage extends EventEmitter {
-    constructor(_workspaceRootPath, _rootPath, _config) {
+    constructor(_workspaceRootPath, rootPath, _config) {
         super();
         this._workspaceRootPath = _workspaceRootPath;
-        this._rootPath = _rootPath;
+        this.rootPath = rootPath;
         this._config = _config;
-        const npmConfigFilePath = path.resolve(this._rootPath, "package.json");
+        const npmConfigFilePath = path.resolve(this.rootPath, "package.json");
         this._npmConfig = FsUtil.readJson(npmConfigFilePath);
     }
+    get basename() {
+        return path.basename(this._workspaceRootPath);
+    }
     get name() {
         return this._npmConfig.name;
     }
+    get main() {
+        return this._npmConfig.main;
+    }
+    get type() {
+        return this._config.type;
+    }
     get allDependencies() {
         return [
             ...Object.keys(this._npmConfig.dependencies ?? {}),
@@ -42,16 +51,16 @@ export class SdCliPackage extends EventEmitter {
         updateDepVersion(this._npmConfig.optionalDependencies);
         updateDepVersion(this._npmConfig.devDependencies);
         updateDepVersion(this._npmConfig.peerDependencies);
-        const npmConfigFilePath = path.resolve(this._rootPath, "package.json");
+        const npmConfigFilePath = path.resolve(this.rootPath, "package.json");
         await FsUtil.writeJsonAsync(npmConfigFilePath, this._npmConfig, { space: 2 });
     }
     async watchAsync() {
-        const isTs = FsUtil.exists(path.resolve(this._rootPath, "tsconfig.json"));
+        const isTs = FsUtil.exists(path.resolve(this.rootPath, "tsconfig.json"));
         if (isTs) {
             await this._genBuildTsconfigAsync();
         }
         const isAngular = isTs && this.allDependencies.includes("@angular/core");
-        const builder = !isTs ? new SdCliJsLibBuilder(this._rootPath) : new SdCliTsLibBuilder(this._rootPath, isAngular);
+        const builder = !isTs ? new SdCliJsLibBuilder(this.rootPath) : new SdCliTsLibBuilder(this.rootPath, isAngular);
         await builder
             .on("change", () => {
             this.emit("change");
@@ -62,28 +71,28 @@ export class SdCliPackage extends EventEmitter {
             .watchAsync();
     }
     async buildAsync() {
-        const isTs = FsUtil.exists(path.resolve(this._rootPath, "tsconfig.json"));
+        const isTs = FsUtil.exists(path.resolve(this.rootPath, "tsconfig.json"));
         if (isTs) {
             await this._genBuildTsconfigAsync();
         }
         const isAngular = isTs && this.allDependencies.includes("@angular/core");
-        const builder = isTs ? new SdCliTsLibBuilder(this._rootPath, isAngular) : new SdCliJsLibBuilder(this._rootPath);
+        const builder = isTs ? new SdCliTsLibBuilder(this.rootPath, isAngular) : new SdCliJsLibBuilder(this.rootPath);
         return await builder.buildAsync();
     }
     async publishAsync() {
         if (this._config.type === "library" && this._config.publish === "npm") {
-            await SdProcess.execAsync("npm publish --quiet --access public", { cwd: this._rootPath });
+            await SdProcess.execAsync("npm publish --quiet --access public", { cwd: this.rootPath });
         }
     }
     async _genBuildTsconfigAsync() {
-        const baseTsconfigFilePath = path.resolve(this._rootPath, "tsconfig.json");
+        const baseTsconfigFilePath = path.resolve(this.rootPath, "tsconfig.json");
         const baseTsconfig = await FsUtil.readJsonAsync(baseTsconfigFilePath);
         const buildTsconfig = ObjectUtil.clone(baseTsconfig);
         buildTsconfig.compilerOptions = buildTsconfig.compilerOptions ?? {};
         delete buildTsconfig.compilerOptions.baseUrl;
         delete buildTsconfig.compilerOptions.paths;
-        const buildTsconfigFilePath = path.resolve(this._rootPath, "tsconfig-build.json");
+        const buildTsconfigFilePath = path.resolve(this.rootPath, "tsconfig-build.json");
         await FsUtil.writeJsonAsync(buildTsconfigFilePath, buildTsconfig, { space: 2 });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/SdCliConfigUtil.d.ts

@@ -1,6 +1,6 @@
 import { ISdCliConfig } from "../commons";
 export declare class SdCliConfigUtil {
-    static loadConfig(confFilePath: string, isDev: boolean, opts?: string[]): ISdCliConfig;
+    static loadConfigAsync(confFilePath: string, isDev: boolean, opts?: string[]): Promise<ISdCliConfig>;
     private static _getConfigFromFileContent;
     private static _getPkgConfigFromFileContent;
     private static _mergeObj;

package/dist/utils/SdCliConfigUtil.mjs

@@ -2,14 +2,14 @@ import { FsUtil } from "@simplysm/sd-core-node";
 import { ObjectUtil } from "@simplysm/sd-core-common";
 import path from "path";
 export class SdCliConfigUtil {
-    static loadConfig(confFilePath, isDev, opts) {
-        const confFileCont = FsUtil.readJson(confFilePath);
+    static async loadConfigAsync(confFilePath, isDev, opts) {
+        const confFileCont = await FsUtil.readJsonAsync(confFilePath);
         let conf = this._getConfigFromFileContent(confFileCont, isDev, opts);
         // extends
         if (conf.extends) {
             for (const extConfFilePath of conf.extends) {
-                const extConf = this.loadConfig(path.resolve(path.dirname(confFilePath), extConfFilePath), isDev, opts);
-                conf = this._mergeObj(conf, extConf);
+                const extConf = await this.loadConfigAsync(path.resolve(path.dirname(confFilePath), extConfFilePath), isDev, opts);
+                conf = this._mergeObj(extConf, conf);
             }
         }
         delete conf["extends"];
@@ -66,4 +66,4 @@ export class SdCliConfigUtil {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplysm/sd-cli",
-  "version": "7.0.19",
+  "version": "7.0.23",
   "description": "심플리즘 패키지 - CLI",
   "author": "김석래",
   "repository": {
@@ -20,22 +20,25 @@
     "node": "^16"
   },
   "dependencies": {
-    "ts-node": "^10.4.0",
-    "tsconfig-paths": "^3.12.0",
-    "yargs": "^17.3.1",
+    "@angular/compiler-cli": "^13.2.0",
     "chokidar": "^3.5.3",
-    "typescript": "~4.5.5",
     "eslint": "^8.7.0",
-    "@angular/compiler-cli": "^13.2.0",
     "sass": "^1.49.0",
-    "semver": "^7.3.5"
+    "semver": "^7.3.5",
+    "source-map-support": "^0.5.21",
+    "ts-node": "^10.4.0",
+    "tsconfig-paths": "^3.12.0",
+    "typescript": "~4.5.5",
+    "yargs": "^17.3.1",
+    "decache": "^4.6.1"
   },
   "devDependencies": {
-    "@types/yargs": "^17.0.8",
-    "@types/semver": "^7.3.9"
+    "@types/semver": "^7.3.9",
+    "@types/yargs": "^17.0.8"
   },
   "peerDependencies": {
-    "@simplysm/sd-core-common": "7.0.19",
-    "@simplysm/sd-core-node": "7.0.19"
+    "@simplysm/sd-core-common": "7.0.23",
+    "@simplysm/sd-core-node": "7.0.23",
+    "@simplysm/sd-service": "7.0.23"
   }
 }

package/src/bin/sd-cli.ts

@@ -1,10 +1,13 @@
-#!/usr/bin/env node
+#!/usr/bin/env node --experimental-specifier-resolution=node
 
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { Logger, LoggerSeverity } from "@simplysm/sd-core-node";
 import { SdCliWorkspace } from "../entry-points/SdCliWorkspace";
 import { SdCliLocalUpdate } from "../entry-points/SdCliLocalUpdate";
+import sourceMapSupport from "source-map-support";
+
+sourceMapSupport.install();
 
 Error.stackTraceLimit = Infinity;
 
@@ -38,6 +41,11 @@ const argv = yargs(hideBin(process.argv))
         config: {
           type: "string",
           describe: "simplysm.json 파일 경로"
+        },
+        options: {
+          type: "string",
+          array: true,
+          describe: "옵션 설정 (설정파일에서 @로 시작하는 부분)"
         }
       })
   )
@@ -49,6 +57,11 @@ const argv = yargs(hideBin(process.argv))
         config: {
           type: "string",
           describe: "simplysm.json 파일 경로"
+        },
+        options: {
+          type: "string",
+          array: true,
+          describe: "옵션 설정 (설정파일에서 @로 시작하는 부분)"
         }
       })
   )
@@ -57,14 +70,19 @@ const argv = yargs(hideBin(process.argv))
     "프로젝트의 각 패키지를 배포합니다.",
     (cmd) => cmd.version(false)
       .options({
+        noBuild: {
+          type: "boolean",
+          describe: "빌드를 하지않고 배포합니다.",
+          default: false
+        },
         config: {
           type: "string",
           describe: "simplysm.json 파일 경로"
         },
-        "noBuild": {
-          type: "boolean",
-          describe: "빌드를 하지않고 배포합니다.",
-          default: false
+        options: {
+          type: "string",
+          array: true,
+          describe: "옵션 설정 (설정파일에서 @로 시작하는 부분)"
         }
       })
   )
@@ -89,21 +107,31 @@ const logger = Logger.get(["simplysm", "sd-cli", "bin", "sd-cli"]);
 
 (async () => {
   if (argv._[0] === "local-update") {
-    await new SdCliLocalUpdate(process.cwd(), argv.config)
-      .runAsync();
+    await new SdCliLocalUpdate(process.cwd())
+      .runAsync({
+        confFileRelPath: argv.config ?? "simplysm.json"
+      });
   }
   else if (argv._[0] === "watch") {
-    await new SdCliWorkspace(process.cwd(), argv.config)
-      .watchAsync();
+    await new SdCliWorkspace(process.cwd())
+      .watchAsync({
+        confFileRelPath: argv.config ?? "simplysm.json",
+        optNames: argv.options ?? []
+      });
   }
   else if (argv._[0] === "build") {
-    await new SdCliWorkspace(process.cwd(), argv.config)
-      .buildAsync();
+    await new SdCliWorkspace(process.cwd())
+      .buildAsync({
+        confFileRelPath: argv.config ?? "simplysm.json",
+        optNames: argv.options ?? []
+      });
   }
   else if (argv._[0] === "publish") {
-    await new SdCliWorkspace(process.cwd(), argv.config)
+    await new SdCliWorkspace(process.cwd())
       .publishAsync({
-        noBuild: argv.noBuild
+        noBuild: argv.noBuild,
+        confFileRelPath: argv.config ?? "simplysm.json",
+        optNames: argv.options ?? []
       });
   }
   else {

package/src/commons.ts

@@ -39,7 +39,7 @@ export interface ISdCliConfig {
   localUpdates?: Record<string, string>;
 }
 
-export type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliNgLibPackageConfig;
+export type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliNgLibPackageConfig | ISdCliServerPackageConfig;
 
 export interface ISdCliLibPackageConfig {
   type: "library";

package/src/entry-points/SdCliLocalUpdate.ts

@@ -5,13 +5,12 @@ import * as path from "path";
 export class SdCliLocalUpdate {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
 
-  public constructor(private readonly _rootPath: string,
-                     private readonly _configFilePath?: string) {
+  public constructor(private readonly _rootPath: string) {
   }
 
-  public async runAsync(): Promise<void> {
+  public async runAsync(opt: { confFileRelPath: string }): Promise<void> {
     this._logger.debug("프로젝트 설정 가져오기...");
-    const conf = SdCliConfigUtil.loadConfig(path.resolve(this._rootPath, this._configFilePath ?? "simplysm.json"), false);
+    const conf = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), false);
     if (!conf.localUpdates) return;
 
     const updatePathInfos = await this._getUpdatePathInfosAsync(conf.localUpdates);
@@ -31,9 +30,9 @@ export class SdCliLocalUpdate {
     this._logger.info("로컬 라이브러리 업데이트 완료");
   }
 
-  public async watchAsync(): Promise<void> {
+  public async watchAsync(opt: { confFileRelPath: string }): Promise<void> {
     this._logger.debug("프로젝트 설정 가져오기...");
-    const conf = SdCliConfigUtil.loadConfig(path.resolve(this._rootPath, this._configFilePath ?? "simplysm.json"), false);
+    const conf = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), false);
     if (!conf.localUpdates) return;
 
     const updatePathInfos = await this._getUpdatePathInfosAsync(conf.localUpdates);

package/src/entry-points/SdCliWorkspace.ts

@@ -6,24 +6,27 @@ import { Wait } from "@simplysm/sd-core-common";
 import os from "os";
 import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
 import semver from "semver/preload";
+import { SdCliConfigUtil } from "../utils/SdCliConfigUtil";
+import { SdServiceServer } from "@simplysm/sd-service/server";
+import decache from "decache";
 
 export class SdCliWorkspace {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
 
   private readonly _npmConfig: INpmConfig;
-  private readonly _config: ISdCliConfig;
+  private readonly _serverInfoMap = new Map<string, IServerInfo>();
 
-  public constructor(private readonly _rootPath: string,
-                     private readonly _configFilePath?: string) {
+  public constructor(private readonly _rootPath: string) {
     const npmConfigFilePath = path.resolve(this._rootPath, "package.json");
     this._npmConfig = FsUtil.readJson(npmConfigFilePath);
-
-    this._config = FsUtil.readJson(path.resolve(this._rootPath, this._configFilePath ?? "simplysm.json"));
   }
 
-  public async watchAsync(): Promise<void> {
+  public async watchAsync(opt: { confFileRelPath: string; optNames: string[] }): Promise<void> {
+    this._logger.debug("프로젝트 설정 가져오기...");
+    const config = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), true, opt.optNames);
+
     this._logger.debug("패키지 목록 구성...");
-    const pkgs = await this._getPackagesAsync();
+    const pkgs = await this._getPackagesAsync(config);
 
     this._logger.debug("패키지 이벤트 설정...");
     let changeCount = 0;
@@ -49,6 +52,40 @@ export class SdCliWorkspace {
             }
           }, 500);
         });
+
+
+      if (pkg.type === "server") {
+        pkg.on("complete", async (results) => {
+          if (results.some((item) => item.severity === "error")) {
+            return;
+          }
+
+          const entryFileRelPath = pkg.main;
+          if (entryFileRelPath === undefined) {
+            this._logger.error(`서버패키지(${pkg.name})의 'package.json'에서 'main'필드를 찾을 수 없습니다.`);
+            return;
+          }
+          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;
+            decache(entryFilePath);
+          }
+
+          serverInfo.server = (await import(entryFilePath)) as SdServiceServer | undefined;
+          if (serverInfo.server === undefined) {
+            this._logger.error(`${entryFilePath}(0, 0): 'SdServiceServer'를 'export'해야 합니다.`);
+            return;
+          }
+
+          await Wait.until(() => serverInfo.server!.isOpen);
+
+          this._logger.log(`서버(${pkg.name}) 재시작 완료`);
+        });
+      }
     }
 
     this._logger.debug("빌드를 시작합니다...");
@@ -61,9 +98,12 @@ export class SdCliWorkspace {
     });
   }
 
-  public async buildAsync(): Promise<void> {
+  public async buildAsync(opt: { confFileRelPath: string; optNames: string[] }): Promise<void> {
+    this._logger.debug("프로젝트 설정 가져오기...");
+    const config = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), false, opt.optNames);
+
     this._logger.debug("패키지 목록 구성...");
-    const pkgs = await this._getPackagesAsync();
+    const pkgs = await this._getPackagesAsync(config);
 
     this._logger.debug("프로젝트 및 패키지 버전 설정...");
     await this._upgradeVersionAsync(pkgs);
@@ -96,7 +136,10 @@ export class SdCliWorkspace {
     }
   }
 
-  public async publishAsync(opt: { noBuild: boolean }): Promise<void> {
+  public async publishAsync(opt: { noBuild: boolean; confFileRelPath: string; optNames: string[] }): Promise<void> {
+    this._logger.debug("프로젝트 설정 가져오기...");
+    const config = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), false, opt.optNames);
+
     if (opt.noBuild) {
       this._logger.warn("빌드하지 않고, 배포하는것은 상당히 위험합니다.");
       await this._waitSecMessageAsync("프로세스를 중지하려면, 'CTRL+C'를 누르세요.", 5);
@@ -112,7 +155,7 @@ export class SdCliWorkspace {
     }
 
     this._logger.debug("패키지 목록 구성...");
-    const pkgs = await this._getPackagesAsync();
+    const pkgs = await this._getPackagesAsync(config);
 
     this._logger.debug("프로젝트 및 패키지 버전 설정...");
     await this._upgradeVersionAsync(pkgs);
@@ -182,14 +225,14 @@ export class SdCliWorkspace {
     process.stdout.clearLine(0);
   }
 
-  private async _getPackagesAsync(): Promise<SdCliPackage[]> {
+  private async _getPackagesAsync(conf: ISdCliConfig): Promise<SdCliPackage[]> {
     const pkgRootPaths = await this._npmConfig.workspaces?.mapManyAsync(async (item) => await FsUtil.globAsync(item));
     if (!pkgRootPaths) {
       throw new Error("최상위 'package.json'에서 'workspaces'를 찾을 수 없습니다.");
     }
 
     return pkgRootPaths.map((pkgRootPath) => {
-      const pkgConfig = this._config.packages[path.basename(pkgRootPath)];
+      const pkgConfig = conf.packages[path.basename(pkgRootPath)];
       return pkgConfig ? new SdCliPackage(this._rootPath, pkgRootPath, pkgConfig) : undefined;
     }).filterExists();
   }
@@ -227,3 +270,7 @@ export class SdCliWorkspace {
     }
   }
 }
+
+interface IServerInfo {
+  server?: SdServiceServer;
+}

package/src/packages/SdCliPackage.ts

@@ -9,10 +9,22 @@ import { SdCliJsLibBuilder } from "../builder/SdCliJsLibBuilder";
 export class SdCliPackage extends EventEmitter {
   private readonly _npmConfig: INpmConfig;
 
+  public get basename(): string {
+    return path.basename(this._workspaceRootPath);
+  }
+
   public get name(): string {
     return this._npmConfig.name;
   }
 
+  public get main(): string | undefined {
+    return this._npmConfig.main;
+  }
+
+  public get type(): TSdCliPackageConfig["type"] {
+    return this._config.type;
+  }
+
   public get allDependencies(): string[] {
     return [
       ...Object.keys(this._npmConfig.dependencies ?? {}),
@@ -23,11 +35,11 @@ export class SdCliPackage extends EventEmitter {
   }
 
   public constructor(private readonly _workspaceRootPath: string,
-                     private readonly _rootPath: string,
+                     public readonly rootPath: string,
                      private readonly _config: TSdCliPackageConfig) {
     super();
 
-    const npmConfigFilePath = path.resolve(this._rootPath, "package.json");
+    const npmConfigFilePath = path.resolve(this.rootPath, "package.json");
     this._npmConfig = FsUtil.readJson(npmConfigFilePath);
   }
 
@@ -53,19 +65,19 @@ export class SdCliPackage extends EventEmitter {
     updateDepVersion(this._npmConfig.devDependencies);
     updateDepVersion(this._npmConfig.peerDependencies);
 
-    const npmConfigFilePath = path.resolve(this._rootPath, "package.json");
+    const npmConfigFilePath = path.resolve(this.rootPath, "package.json");
     await FsUtil.writeJsonAsync(npmConfigFilePath, this._npmConfig, { space: 2 });
   }
 
   public async watchAsync(): Promise<void> {
-    const isTs = FsUtil.exists(path.resolve(this._rootPath, "tsconfig.json"));
+    const isTs = FsUtil.exists(path.resolve(this.rootPath, "tsconfig.json"));
 
     if (isTs) {
       await this._genBuildTsconfigAsync();
     }
 
     const isAngular = isTs && this.allDependencies.includes("@angular/core");
-    const builder = !isTs ? new SdCliJsLibBuilder(this._rootPath) : new SdCliTsLibBuilder(this._rootPath, isAngular);
+    const builder = !isTs ? new SdCliJsLibBuilder(this.rootPath) : new SdCliTsLibBuilder(this.rootPath, isAngular);
 
     await builder
       .on("change", () => {
@@ -78,26 +90,26 @@ export class SdCliPackage extends EventEmitter {
   }
 
   public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
-    const isTs = FsUtil.exists(path.resolve(this._rootPath, "tsconfig.json"));
+    const isTs = FsUtil.exists(path.resolve(this.rootPath, "tsconfig.json"));
 
     if (isTs) {
       await this._genBuildTsconfigAsync();
     }
 
     const isAngular = isTs && this.allDependencies.includes("@angular/core");
-    const builder = isTs ? new SdCliTsLibBuilder(this._rootPath, isAngular) : new SdCliJsLibBuilder(this._rootPath);
+    const builder = isTs ? new SdCliTsLibBuilder(this.rootPath, isAngular) : new SdCliJsLibBuilder(this.rootPath);
 
     return await builder.buildAsync();
   }
 
   public async publishAsync(): Promise<void> {
     if (this._config.type === "library" && this._config.publish === "npm") {
-      await SdProcess.execAsync("npm publish --quiet --access public", { cwd: this._rootPath });
+      await SdProcess.execAsync("npm publish --quiet --access public", { cwd: this.rootPath });
     }
   }
 
   private async _genBuildTsconfigAsync(): Promise<void> {
-    const baseTsconfigFilePath = path.resolve(this._rootPath, "tsconfig.json");
+    const baseTsconfigFilePath = path.resolve(this.rootPath, "tsconfig.json");
     const baseTsconfig: ITsconfig = await FsUtil.readJsonAsync(baseTsconfigFilePath);
 
     const buildTsconfig: ITsconfig = ObjectUtil.clone(baseTsconfig);
@@ -105,7 +117,7 @@ export class SdCliPackage extends EventEmitter {
     delete buildTsconfig.compilerOptions.baseUrl;
     delete buildTsconfig.compilerOptions.paths;
 
-    const buildTsconfigFilePath = path.resolve(this._rootPath, "tsconfig-build.json");
+    const buildTsconfigFilePath = path.resolve(this.rootPath, "tsconfig-build.json");
     await FsUtil.writeJsonAsync(buildTsconfigFilePath, buildTsconfig, { space: 2 });
   }
 }

package/src/utils/SdCliConfigUtil.ts

@@ -4,15 +4,15 @@ import { ObjectUtil } from "@simplysm/sd-core-common";
 import path from "path";
 
 export class SdCliConfigUtil {
-  public static loadConfig(confFilePath: string, isDev: boolean, opts?: string[]): ISdCliConfig {
-    const confFileCont = FsUtil.readJson(confFilePath);
+  public static async loadConfigAsync(confFilePath: string, isDev: boolean, opts?: string[]): Promise<ISdCliConfig> {
+    const confFileCont = await FsUtil.readJsonAsync(confFilePath);
     let conf = this._getConfigFromFileContent(confFileCont, isDev, opts);
 
     // extends
     if (conf.extends) {
       for (const extConfFilePath of conf.extends) {
-        const extConf = this.loadConfig(path.resolve(path.dirname(confFilePath), extConfFilePath), isDev, opts);
-        conf = this._mergeObj(conf, extConf);
+        const extConf = await this.loadConfigAsync(path.resolve(path.dirname(confFilePath), extConfFilePath), isDev, opts);
+        conf = this._mergeObj(extConf, conf);
       }
     }
     delete conf["extends"];

package/tsconfig.json

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