@simplysm/sd-cli 7.3.1 → 10.0.4

package/src/build-cluster.ts

@@ -0,0 +1,82 @@
+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 });
+    }
+  }
+}

package/src/builders/SdCliJsLibLinter.ts

@@ -0,0 +1,84 @@
+import { FsUtil, Logger, SdFsWatcher } from "@simplysm/sd-core-node";
+import path from "path";
+import { ISdCliPackageBuildResult } from "../commons";
+import { EventEmitter } from "events";
+import { ESLint } from "eslint";
+
+export class SdCliJsLibLinter extends EventEmitter {
+  private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdCliJsLibLinter"]);
+  private readonly _pkgName: string;
+
+  public constructor(private readonly _pkgPath: string) {
+    super();
+    this._pkgName = path.basename(_pkgPath);
+  }
+
+  public override on(event: "change", listener: () => void): this;
+  public override on(event: "complete", listener: (result: { affectedFilePaths: string[]; buildResults: ISdCliPackageBuildResult[] }) => void): this;
+  public override on(event: string | symbol, listener: (...args: any[]) => void): this {
+    super.on(event, listener);
+    return this;
+  }
+
+  public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
+    this._debug("LINT...");
+    const srcGlobPath = path.resolve(this._pkgPath, "src/**/*.+(js|cjs|mjs)");
+    const srcFilePaths = await FsUtil.globAsync(srcGlobPath);
+    const lintResults = await this._lintAsync(srcFilePaths);
+
+    this._debug(`LINT 완료`);
+    return lintResults;
+  }
+
+  public async watchAsync(): Promise<void> {
+    this.emit("change");
+    this._debug("LINT...");
+    const srcGlobPath = path.resolve(this._pkgPath, "src/**/*.+(js|cjs|mjs)");
+    const srcFilePaths = await FsUtil.globAsync(srcGlobPath);
+    const lintResults = await this._lintAsync(srcFilePaths);
+
+    this._debug(`LINT 완료`);
+    this.emit("complete", {
+      affectedFilePaths: srcFilePaths,
+      buildResults: lintResults
+    });
+
+    SdFsWatcher
+      .watch([srcGlobPath])
+      .onChange({
+        delay: 100
+      }, async (changeInfos) => {
+        const watchFilePaths = changeInfos.filter((item) => FsUtil.exists(item.path)).map((item) => item.path);
+        if (watchFilePaths.length < 1) return;
+
+        this.emit("change");
+        this._debug("LINT...");
+        const watchLintResults = await this._lintAsync(watchFilePaths);
+
+        this._debug(`LINT 완료`);
+        this.emit("complete", {
+          affectedFilePaths: changeInfos.map((item) => item.path),
+          buildResults: watchLintResults
+        });
+      });
+  }
+
+  private async _lintAsync(srcFilePaths: string[]): Promise<ISdCliPackageBuildResult[]> {
+    const linter = new ESLint();
+
+    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" as const : "error" as const,
+      message: msg.message
+    })));
+  }
+
+  private _debug(msg: string): void {
+    this._logger.debug(`[${this._pkgName}] ${msg}`);
+  }
+}

package/src/builders/SdCliTsLibBuilder.ts

@@ -0,0 +1,265 @@
+import ts from "typescript";
+import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
+import path from "path";
+import { ISdCliPackageBuildResult } from "../commons";
+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 {
+  private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdCliTsLibBuilder"]);
+  private readonly _pkgName: string;
+  private readonly _writeFileCache = new Map<string, string>();
+
+  public constructor(private readonly _pkgPath: string) {
+    super();
+    this._pkgName = path.basename(_pkgPath);
+  }
+
+  public override on(event: "change", listener: () => void): this;
+  public override on(event: "complete", listener: (result: { affectedFilePaths: string[]; buildResults: ISdCliPackageBuildResult[] }) => void): this;
+  public override on(event: string | symbol, listener: (...args: any[]) => void): this {
+    super.on(event, listener);
+    return this;
+  }
+
+  public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
+    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];
+  }
+
+  public async watchAsync(): Promise<void> {
+    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]
+          });
+        });
+      });
+  }
+
+  private _emitIncrementalProgram(opt: {
+    rootNames: string[];
+    options: ts.CompilerOptions;
+    host: ts.CompilerHost;
+  }): {
+    program: ts.SemanticDiagnosticsBuilderProgram;
+    buildResults: ISdCliPackageBuildResult[];
+    affectedFileNames: string[];
+  } {
+    const program = ts.createIncrementalProgram({
+      rootNames: opt.rootNames,
+      options: opt.options,
+      host: opt.host,
+      createProgram: ts.createSemanticDiagnosticsBuilderProgram
+    });
+
+    const diagnostics: ts.Diagnostic[] = [];
+    const affectedFileNames: string[] = [];
+
+    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")
+              }
+            }
+          }
+        }
+      ]
+    }
+  });*/
+
+  private async _lintAsync(program: ts.Program, srcFilePaths: string[]): Promise<ISdCliPackageBuildResult[]> {
+    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" as const : "error" as const,
+      message: msg.message
+    })));
+  }
+
+  private _debug(msg: string): void {
+    this._logger.debug(`[${this._pkgName}] ${msg}`);
+  }
+}

package/src/commons.ts

@@ -1,22 +1,7 @@
 export interface INpmConfig {
   name: string;
   version: string;
-  description?: string;
-  author?: string;
-  license?: string;
-  repository?: {
-    type: string;
-    url: string;
-    directory?: string;
-  };
-  type?: "module";
   workspaces?: string[];
-  main?: string;
-  types?: string;
-  exports?: Record<string, {
-    types?: string;
-  }>;
-  scripts?: Record<string, string>;
 
   dependencies?: Record<string, string>;
   optionalDependencies?: Record<string, string>;
@@ -25,127 +10,22 @@ export interface INpmConfig {
   peerDependenciesMeta?: Record<string, { optional?: boolean }>;
 }
 
-export interface ITsconfig {
-  compilerOptions?: {
-    module?: string;
-    lib?: string[];
-    outDir?: string;
-    baseUrl?: string;
-    paths?: Record<string, string[]>;
-    declaration?: boolean;
-  };
-  files?: string[];
-  angularCompilerOptions?: Record<string, any>;
-}
-
 export interface ISdCliPackageBuildResult {
   filePath: string | undefined;
   line: number | undefined;
   char: number | undefined;
   code: string | undefined;
-  severity: "error" | "warning";
+  severity: "error" | "warning" | "suggestion" | "message";
   message: string;
 }
 
 export interface ISdCliConfig {
   packages: Record<string, TSdCliPackageConfig | undefined>;
-  localUpdates?: Record<string, string>;
 }
 
-export type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliServerPackageConfig | ISdCliClientPackageConfig;
+export type TSdCliPackageConfig = ISdCliLibPackageConfig;
 
 export interface ISdCliLibPackageConfig {
   type: "library";
-  angular?: boolean;
-  autoIndex?: {
-    polyfills?: string[];
-  };
-  publish?: "npm";
-}
-
-export interface ISdCliServerPackageConfig {
-  type: "server";
-  env?: Record<string, string>;
-  configs?: Record<string, any>;
-  pm2?: {
-    fileName?: string;
-    noInterpreter?: boolean;
-    noStartScript?: boolean;
-    config: Record<string, any>;
-  } | boolean;
-  iis?: boolean | { serverExeFilePath?: string };
-  externalNodeModules?: string[];
-  publish?: TSdCliPublishConfig;
-}
-
-export interface ISdCliClientPackageConfig {
-  type: "client";
-  builder?: {
-    web?: ISdCliClientBuilderWebConfig;
-    cordova?: ISdCliClientBuilderCordovaConfig;
-    electron?: ISdCliClientBuilderElectronConfig;
-  };
-  server: string | { port: number };
-  env?: Record<string, string>;
-  configs?: Record<string, any>;
-  publish?: TSdCliPublishConfig;
-}
-
-export type TSdCliPublishConfig =
-  ISdCliFtpPublishConfig
-  | ISdCliLocalDirectoryPublishConfig
-  | ISdCliGithubPublishConfig;
-
-export interface ISdCliFtpPublishConfig {
-  type: "ftp" | "ftps" | "sftp";
-  host: string;
-  port?: number;
-  path: string;
-  user: string;
-  pass: string;
-}
-
-export interface ISdCliLocalDirectoryPublishConfig {
-  type: "local-directory";
-  path: string;
-}
-
-export interface ISdCliGithubPublishConfig {
-  type: "github";
-  apiKey: string;
-  files: { from: string; to: string }[];
-}
-
-export interface ISdCliClientBuilderWebConfig {
-  env?: Record<string, string>;
-}
-
-export interface ISdCliClientBuilderCordovaConfig {
-  env?: Record<string, string>;
-  appId: string;
-  appName: string;
-  plugins?: string[];
-  icon?: string;
-  debug?: boolean;
-  target?: {
-    browser?: {};
-    android?: {
-      bundle?: boolean;
-      sign?: {
-        keystore: string;
-        storePassword: string;
-        alias: string;
-        password: string;
-        keystoreType: string;
-      };
-    };
-  };
-}
-
-export interface ISdCliClientBuilderElectronConfig {
-  env?: Record<string, string>;
-  externalNodeModules?: string[];
-  appId: string;
-  icon?: string;
-  installerIcon?: string;
+  publish: "npm";
 }