@simplysm/sd-cli 10.0.4 → 10.0.22

package/src/server-worker.ts

@@ -0,0 +1,45 @@
+import { EventEmitter } from "events";
+import { Logger, LoggerSeverity } from "@simplysm/sd-core-node";
+import path from "path";
+import { pathToFileURL } from "url";
+import { SdServiceServer } from "@simplysm/sd-service-server";
+
+Error.stackTraceLimit = Infinity;
+EventEmitter.defaultMaxListeners = 0;
+
+if (Boolean(process.env["SD_DEBUG"])) {
+  Logger.setConfig({
+    console: {
+      level: LoggerSeverity.debug
+    }
+  });
+}
+else {
+  Logger.setConfig({
+    dot: true
+  });
+}
+
+const logger = Logger.get(["simplysm", "sd-cli", "server-worker"]);
+
+const pkgPath = process.argv[2];
+
+const mainFilePath = path.resolve(pkgPath, "dist/main.mjs");
+
+const serverModule = await import(pathToFileURL(mainFilePath).href);
+
+const server = serverModule.default as SdServiceServer | undefined;
+if (server === undefined) {
+  logger.error(`${mainFilePath}(0, 0): 'SdServiceServer'를 'export'해야 합니다.`);
+  process.exit();
+}
+
+server.on("ready", () => {
+  process.send!({ port: server.options.port });
+});
+
+process.on("message", (message: any) => {
+  if (message.type === "setPathProxy") {
+    server.pathProxy = message.pathProxy;
+  }
+});

package/tsconfig.json

@@ -4,15 +4,6 @@
     "lib": [
       "ES2021"
     ],
-    "outDir": "./dist",
-    "baseUrl": ".",
-    "paths": {
-      "@simplysm/sd-core-common": [
-        "../sd-core-common/src/index.ts"
-      ],
-      "@simplysm/sd-core-node": [
-        "../sd-core-node/src/index.ts"
-      ]
-    }
+    "outDir": "./dist"
   }
 }

package/dist/build-cluster.js

@@ -1,75 +0,0 @@
-import cluster from "node:cluster";
-import { SdCliTsLibBuilder } from "./builders/SdCliTsLibBuilder";
-import { FsUtil, Logger, LoggerSeverity } from "@simplysm/sd-core-node";
-import path from "path";
-import { SdCliJsLibLinter } from "./builders/SdCliJsLibLinter";
-if (Boolean(process.env["SD_DEBUG"])) {
-    Logger.setConfig({
-        console: {
-            level: LoggerSeverity.debug
-        }
-    });
-}
-else {
-    Logger.setConfig({
-        dot: true
-    });
-}
-const logger = Logger.get(["simplysm", "sd-cli", "build-cluster"]);
-if (cluster.isPrimary) {
-    logger.debug(`메인 프로세스 ${process.pid} 시작`);
-    cluster.on("exit", (worker, code) => {
-        logger.debug(`워커 프로세스 ${worker.process.pid} 종료 (code: ${code})`);
-    });
-    cluster.on("message", (worker, message) => {
-        process.send(message);
-    });
-    process.on("message", (message) => {
-        cluster.fork({
-            "SD_CLUSTER_MESSAGE": JSON.stringify(message)
-        });
-    });
-    process.send("ready");
-}
-else {
-    const message = JSON.parse(process.env["SD_CLUSTER_MESSAGE"]);
-    if (message.cmd === "watch") {
-        // javascript
-        if (!FsUtil.exists(path.resolve(message.pkgPath, "tsconfig.json"))) {
-            await new SdCliJsLibLinter(message.pkgPath)
-                .on("change", () => {
-                process.send({ type: "change", ...message });
-            })
-                .on("complete", (result) => {
-                process.send({ type: "complete", result, ...message });
-            })
-                .watchAsync();
-            process.send({ type: "ready", ...message });
-        }
-        // typescript
-        else {
-            await new SdCliTsLibBuilder(message.pkgPath)
-                .on("change", () => {
-                process.send({ type: "change", ...message });
-            })
-                .on("complete", (result) => {
-                process.send({ type: "complete", result, ...message });
-            })
-                .watchAsync();
-            process.send({ type: "ready", ...message });
-        }
-    }
-    else { // build
-        // javascript
-        if (!FsUtil.exists(path.resolve(message.pkgPath, "tsconfig.json"))) {
-            const result = await new SdCliJsLibLinter(message.pkgPath).buildAsync();
-            process.send({ type: "complete", result, ...message });
-        }
-        // typescript
-        else {
-            const result = await new SdCliTsLibBuilder(message.pkgPath).buildAsync();
-            process.send({ type: "complete", result, ...message });
-        }
-    }
-}
-//# sourceMappingURL=build-cluster.js.map

package/dist/builders/SdCliTsLibBuilder.js

@@ -1,205 +0,0 @@
-import ts from "typescript";
-import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
-import path from "path";
-import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
-import { EventEmitter } from "events";
-import { ESLint } from "eslint";
-import { FunctionQueue } from "@simplysm/sd-core-common";
-export class SdCliTsLibBuilder extends EventEmitter {
-    constructor(_pkgPath) {
-        super();
-        this._pkgPath = _pkgPath;
-        this._logger = Logger.get(["simplysm", "sd-cli", "SdCliTsLibBuilder"]);
-        this._writeFileCache = new Map();
-        this._pkgName = path.basename(_pkgPath);
-    }
-    on(event, listener) {
-        super.on(event, listener);
-        return this;
-    }
-    async buildAsync() {
-        this._debug("빌드 준비...");
-        const srcGlobPath = path.resolve(this._pkgPath, "src/**/*.ts");
-        const parsedTsConfig = ts.parseJsonConfigFileContent(await FsUtil.readJsonAsync(path.resolve(this._pkgPath, "tsconfig.json")), ts.sys, this._pkgPath, {
-            outDir: path.resolve(this._pkgPath, "dist"),
-            incremental: true,
-            tsBuildInfoFile: path.resolve(this._pkgPath, ".cache/tsbuildinfo.json"),
-        });
-        const host = ts.createIncrementalCompilerHost(parsedTsConfig.options, ts.sys);
-        this._debug("dist 초기화...");
-        await FsUtil.removeAsync(path.resolve(this._pkgPath, "dist"));
-        this._debug("빌드...");
-        const srcFilePaths = await FsUtil.globAsync(srcGlobPath);
-        const emitResult = this._emitIncrementalProgram({
-            rootNames: srcFilePaths,
-            options: parsedTsConfig.options,
-            host: host
-        });
-        this._debug("LINT...");
-        const lintResults = await this._lintAsync(emitResult.program.getProgram(), srcFilePaths);
-        this._debug(`빌드 완료`);
-        return [...emitResult.buildResults, ...lintResults];
-    }
-    async watchAsync() {
-        this.emit("change");
-        this._debug("빌드 준비...");
-        const srcGlobPath = path.resolve(this._pkgPath, "src/**/*.ts");
-        const parsedTsConfig = ts.parseJsonConfigFileContent(await FsUtil.readJsonAsync(path.resolve(this._pkgPath, "tsconfig.json")), ts.sys, this._pkgPath, {
-            outDir: path.resolve(this._pkgPath, "dist"),
-            incremental: true,
-            tsBuildInfoFile: path.resolve(this._pkgPath, ".cache/tsbuildinfo.json"),
-        });
-        const host = ts.createIncrementalCompilerHost(parsedTsConfig.options, ts.sys);
-        this._debug("dist 초기화...");
-        await FsUtil.removeAsync(path.resolve(this._pkgPath, "dist"));
-        this._debug("빌드...");
-        const srcFilePaths = await FsUtil.globAsync(srcGlobPath);
-        const emitResult = this._emitIncrementalProgram({
-            rootNames: srcFilePaths,
-            options: parsedTsConfig.options,
-            host: host
-        });
-        this._debug("LINT...");
-        const lintResults = await this._lintAsync(emitResult.program.getProgram(), srcFilePaths);
-        this._debug(`빌드 완료`);
-        this.emit("complete", {
-            affectedFilePaths: srcFilePaths,
-            buildResults: [...emitResult.buildResults, ...lintResults]
-        });
-        const fnQ = new FunctionQueue();
-        SdFsWatcher
-            .watch([
-            ...emitResult.program.getSourceFiles().map((item) => item.fileName),
-            srcGlobPath
-        ])
-            .onChange({
-            delay: 100
-        }, () => {
-            fnQ.runLast(async () => {
-                this.emit("change");
-                this._debug(`빌드...`);
-                const watchSrcFilePaths = await FsUtil.globAsync(srcGlobPath);
-                const watchResult = this._emitIncrementalProgram({
-                    rootNames: await FsUtil.globAsync(srcGlobPath),
-                    options: parsedTsConfig.options,
-                    host: host
-                });
-                const watchAffectedSrcFilePaths = watchResult.affectedFileNames.map((item) => path.resolve(item)).filter((item) => watchSrcFilePaths.includes(item));
-                this._debug("LINT...");
-                const watchLintResults = await this._lintAsync(watchResult.program.getProgram(), watchAffectedSrcFilePaths);
-                this._debug(`빌드 완료`);
-                this.emit("complete", {
-                    affectedFilePaths: watchAffectedSrcFilePaths,
-                    buildResults: [...watchResult.buildResults, ...watchLintResults]
-                });
-            });
-        });
-    }
-    _emitIncrementalProgram(opt) {
-        const program = ts.createIncrementalProgram({
-            rootNames: opt.rootNames,
-            options: opt.options,
-            host: opt.host,
-            createProgram: ts.createSemanticDiagnosticsBuilderProgram
-        });
-        const diagnostics = [];
-        const affectedFileNames = [];
-        diagnostics.push(...program.getOptionsDiagnostics(), ...program.getGlobalDiagnostics());
-        while (true) {
-            const semanticResult = program.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => {
-                return !opt.rootNames.includes(path.resolve(sourceFile.fileName));
-            });
-            if (!semanticResult)
-                break;
-            diagnostics.push(...semanticResult.result);
-            /*const result = program.emitNextAffectedFile((filePath, data, writeByteOrderMark) => {
-              if (this._writeFileCache.get(filePath) !== data) {
-                ts.sys.writeFile(filePath, data, writeByteOrderMark);
-              }
-              this._writeFileCache.set(filePath, data);
-            });
-            if (!result) break;*/
-            if ("fileName" in semanticResult.affected) {
-                const emitResult = program.emit(program.getSourceFile(semanticResult.affected.fileName), (filePath, data, writeByteOrderMark) => {
-                    let realFilePath = filePath;
-                    if (PathUtil.isChildPath(realFilePath, path.resolve(this._pkgPath, "dist", this._pkgName, "src"))) {
-                        realFilePath = path.resolve(this._pkgPath, "dist", path.relative(path.resolve(this._pkgPath, "dist", this._pkgName, "src"), realFilePath));
-                    }
-                    if (this._writeFileCache.get(realFilePath) !== data) {
-                        ts.sys.writeFile(realFilePath, data, writeByteOrderMark);
-                    }
-                    this._writeFileCache.set(realFilePath, data);
-                });
-                diagnostics.push(...emitResult.diagnostics);
-                affectedFileNames.push(semanticResult.affected.fileName);
-                diagnostics.push(...program.getSyntacticDiagnostics(semanticResult.affected));
-            }
-        }
-        const buildResults = diagnostics.map((item) => SdCliBuildResultUtil.convertFromTsDiag(item));
-        return {
-            program,
-            buildResults,
-            affectedFileNames
-        };
-    }
-    /*private readonly _linter = new ESLint({
-      overrideConfig: {
-        overrides: [
-          {
-            files: ["*.ts"],
-            parserOptions: {
-              tsconfigRootDir: this._pkgPath,
-              project: "tsconfig.json"
-            },
-            settings: {
-              "import/resolver": {
-                "typescript": {
-                  project: path.resolve(this._pkgPath, "tsconfig.json")
-                }
-              }
-            }
-          }
-        ]
-      }
-    });*/
-    async _lintAsync(program, srcFilePaths) {
-        const linter = new ESLint({
-            overrideConfig: {
-                overrides: [
-                    {
-                        files: ["*.ts"],
-                        parserOptions: {
-                            programs: [program],
-                            tsconfigRootDir: null,
-                            project: null,
-                            // tsconfigRootDir: this._pkgPath,
-                            // project: "tsconfig.json"
-                        },
-                        settings: {
-                            "import/resolver": {
-                                "typescript": {
-                                    programs: [program],
-                                    project: null,
-                                    // project: path.resolve(this._pkgPath, "tsconfig.json"),
-                                }
-                            }
-                        }
-                    }
-                ]
-            }
-        });
-        const lintResults = await linter.lintFiles(srcFilePaths);
-        return lintResults.mapMany((lintResult) => lintResult.messages.map((msg) => ({
-            filePath: lintResult.filePath,
-            line: msg.line,
-            char: msg.column,
-            code: msg.ruleId ?? undefined,
-            severity: msg.severity === 1 ? "warning" : "error",
-            message: msg.message
-        })));
-    }
-    _debug(msg) {
-        this._logger.debug(`[${this._pkgName}] ${msg}`);
-    }
-}
-//# sourceMappingURL=SdCliTsLibBuilder.js.map