@simplysm/sd-cli 12.5.20 → 12.5.22

package/src/types/build-plugin.type.ts

@@ -0,0 +1,16 @@
+import esbuild from "esbuild";
+import { TNormPath } from "@simplysm/sd-core-node";
+
+export interface ISdCliServerPluginResultCache {
+  watchFileSet?: Set<TNormPath>;
+  affectedFileSet?: Set<TNormPath>;
+  outputFiles?: esbuild.OutputFile[];
+  metafile?: esbuild.Metafile;
+}
+
+export interface ISdCliNgPluginResultCache {
+  watchFileSet?: Set<TNormPath>;
+  affectedFileSet?: Set<TNormPath>;
+  outputFiles?: esbuild.OutputFile[];
+  metafile?: esbuild.Metafile;
+}

package/src/types/build.type.ts

@@ -0,0 +1,17 @@
+import { TNormPath } from "@simplysm/sd-core-node";
+
+export interface ISdBuildRunnerResult {
+  affectedFilePathSet: Set<TNormPath>;
+  buildMessages: ISdBuildMessage[];
+  emitFileSet: Set<TNormPath>;
+}
+
+export interface ISdBuildMessage {
+  filePath: TNormPath | undefined;
+  line: number | undefined;
+  char: number | undefined;
+  code: string | undefined;
+  severity: "error" | "warning" | "suggestion" | "message";
+  message: string;
+  type: string | undefined;
+}

package/src/types/common-configs.type.ts

@@ -0,0 +1,27 @@
+export interface INpmConfig {
+  name: string;
+  description?: string;
+  version: string;
+  workspaces?: string[];
+
+  dependencies?: Record<string, string>;
+  optionalDependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  peerDependenciesMeta?: Record<
+    string,
+    {
+      optional?: boolean;
+    }
+  >;
+
+  resolutions?: Record<string, string>;
+
+  scripts?: Record<string, string>;
+}
+
+export interface ITsConfig {
+  files?: string[];
+  compilerOptions: { lib: string[] };
+  angularCompilerOptions?: {};
+}

package/src/types/sd-configs.type.ts

@@ -0,0 +1,114 @@
+export interface ISdProjectConfig {
+  packages: Record<string, TSdPackageConfig | undefined>;
+  localUpdates?: Record<string, string>;
+  postPublish?: TSdPostPublishConfig[];
+}
+
+export type TSdProjectConfigFn = (isDev: boolean, opts?: string[]) => ISdProjectConfig;
+
+export type TSdPackageConfig = ISdLibPackageConfig | ISdServerPackageConfig | ISdClientPackageConfig;
+
+export interface ISdLibPackageConfig {
+  type: "library";
+  publish?: "npm";
+  polyfills?: string[];
+  noGenIndex?: boolean;
+}
+
+export interface ISdServerPackageConfig {
+  type: "server";
+  externals?: string[];
+  publish?: ISdLocalDirectoryPublishConfig | ISdFtpPublishConfig;
+  configs?: Record<string, any>;
+  env?: Record<string, string>;
+  pm2?: {
+    name?: string;
+    ignoreWatchPaths?: string[];
+    noInterpreter?: boolean;
+    noStartScript?: boolean;
+  };
+  iis?: {
+    nodeExeFilePath?: string;
+  };
+}
+
+export interface ISdClientPackageConfig {
+  type: "client";
+  server?: string | { port: number };
+  publish?: ISdLocalDirectoryPublishConfig | ISdFtpPublishConfig;
+  env?: Record<string, string>;
+  configs?: Record<string, any>;
+  noLazyRoute?: boolean;
+  forceProductionMode?: boolean;
+
+  builder?: {
+    web?: ISdClientBuilderWebConfig;
+    electron?: ISdClientBuilderElectronConfig;
+    cordova?: ISdClientBuilderCordovaConfig;
+  };
+}
+
+export interface ISdLocalDirectoryPublishConfig {
+  type: "local-directory";
+  path: string;
+}
+
+export interface ISdFtpPublishConfig {
+  type: "ftp" | "ftps" | "sftp";
+  host: string;
+  port?: number;
+  path?: string;
+  user?: string;
+  pass?: string;
+}
+
+export interface ISdClientBuilderElectronConfig {
+  appId: string;
+  installerIcon?: string;
+  postInstallScript?: string;
+  // devServerHost?: string;
+  // devServerPort?: number;
+  reinstallDependencies?: string[];
+  env?: Record<string, string>;
+}
+
+export interface ISdClientBuilderWebConfig {
+  // devServerHost?: string;
+  // devServerPort?: number;
+  env?: Record<string, string>;
+}
+
+export interface ISdClientBuilderCordovaConfig {
+  appId: string;
+  appName: string;
+  plugins?: string[];
+  icon?: string;
+  debug?: boolean;
+  platform?: {
+    browser?: {};
+    android?: {
+      bundle?: boolean;
+      sign?: {
+        keystore: string;
+        storePassword: string;
+        alias: string;
+        password: string;
+        keystoreType: string;
+      };
+      sdkVersion?: number;
+      permissions?: {
+        name: string;
+        maxSdkVersion?: number;
+      }[];
+    };
+  };
+  env?: Record<string, string>;
+  browserslist?: string[];
+}
+
+export type TSdPostPublishConfig = ISdPostPublishScriptConfig;
+
+export interface ISdPostPublishScriptConfig {
+  type: "script";
+  script: string;
+}

package/src/types/ts-compiler.type.ts

@@ -0,0 +1,29 @@
+import { CompilerOptions } from "typescript";
+import esbuild from "esbuild";
+import { ISdBuildMessage } from "./build.type";
+import { TNormPath } from "@simplysm/sd-core-node";
+
+export interface SdTsCompilerOptions {
+  pkgPath: TNormPath;
+  additionalOptions: CompilerOptions;
+  isForBundle: boolean;
+  isDevMode: boolean;
+  watchScopePaths: TNormPath[];
+  globalStyleFilePath?: TNormPath;
+}
+
+export interface ISdTsCompilerResult {
+  messages: ISdBuildMessage[];
+  stylesheetBundlingResultMap: Map<TNormPath, IStylesheetBundlingResult>;
+  emittedFilesCacheMap: Map<TNormPath, { outAbsPath?: TNormPath; text: string }[]>;
+  emitFileSet: Set<TNormPath>;
+  watchFileSet: Set<TNormPath>;
+  affectedFileSet: Set<TNormPath>;
+}
+
+export interface IStylesheetBundlingResult {
+  outputFiles: esbuild.OutputFile[];
+  metafile?: esbuild.Metafile;
+  errors?: esbuild.Message[];
+  warnings?: esbuild.Message[];
+}

package/src/types/workers.type.ts

@@ -0,0 +1,27 @@
+import { ESLint } from "eslint";
+import { ISdTsCompilerResult, SdTsCompilerOptions } from "./ts-compiler.type";
+import { TNormPath } from "@simplysm/sd-core-node";
+
+export interface TServerWorkerType {
+  methods: {
+    listen: { params: [{ path: string } | { port: number }]; returnType: number };
+    setPathProxy: { params: [Record<string, string | number>]; returnType: void };
+    broadcastReload: { params: [Set<string>]; returnType: void };
+  };
+  events: {};
+}
+
+export interface TSdLintWorkerType {
+  methods: {
+    lint: { params: [{ cwd: string; fileSet: Set<string> }]; returnType: ESLint.LintResult[] };
+  };
+  events: {};
+}
+
+export interface TSdTsCompileWorkerType {
+  methods: {
+    initialize: { params: [SdTsCompilerOptions]; returnType: void };
+    compile: { params: [Set<TNormPath>?]; returnType: ISdTsCompilerResult };
+  };
+  events: {};
+}

package/src/utils/SdCliConvertMessageUtil.ts

@@ -0,0 +1,177 @@
+import ts from "typescript";
+import os from "os";
+import path from "path";
+import { PartialMessage } from "esbuild";
+import { ESLint } from "eslint";
+import { ISdBuildMessage } from "../types/build.type";
+import { PathUtil } from "@simplysm/sd-core-node";
+
+export class SdCliConvertMessageUtil {
+  static convertToBuildMessagesFromTsDiag(diags: ts.Diagnostic[]): ISdBuildMessage[] {
+    return diags.map((diag) => {
+      const severity =
+        diag.category === ts.DiagnosticCategory.Error
+          ? ("error" as const)
+          : diag.category === ts.DiagnosticCategory.Warning
+            ? ("warning" as const)
+            : diag.category === ts.DiagnosticCategory.Suggestion
+              ? ("suggestion" as const)
+              : ("message" as const);
+
+      const code = `TS${diag.code}`;
+      const message = ts.flattenDiagnosticMessageText(diag.messageText, os.EOL);
+
+      const filePath = diag.file ? PathUtil.norm(path.resolve(diag.file.fileName)) : undefined;
+      const position =
+        diag.file && diag.start !== undefined ? diag.file.getLineAndCharacterOfPosition(diag.start) : undefined;
+      const line = position ? position.line + 1 : undefined;
+      const char = position ? position.character + 1 : undefined;
+
+      return {
+        filePath,
+        line,
+        char,
+        code,
+        severity,
+        message,
+        type: "compile",
+      };
+    });
+  }
+
+  static convertToBuildMessagesFromEsbuild(
+    result: {
+      errors?: PartialMessage[];
+      warnings?: PartialMessage[];
+    },
+    orgPath: string,
+  ): ISdBuildMessage[] {
+    const convertFn = (msg: PartialMessage, severity: "error" | "warning") => {
+      const filePath = msg.location?.file != null ? PathUtil.norm(orgPath, msg.location.file) : undefined;
+      const line = msg.location?.line;
+      const char = msg.location?.column;
+      const code = msg.text!.slice(0, msg.text!.indexOf(":"));
+      const message = `${msg.text!.slice(msg.text!.indexOf(":") + 1)}${Boolean(msg.id) ? ` (${msg.id})` : ``}`;
+
+      return {
+        filePath,
+        line,
+        char,
+        code,
+        severity,
+        message,
+        type: msg.pluginName,
+      };
+    };
+
+    return [
+      ...(result.errors?.map((msg) => convertFn(msg, "error")) ?? []),
+      ...(result.warnings?.map((msg) => convertFn(msg, "warning")) ?? []),
+    ];
+  }
+
+  static convertToBuildMessagesFromEslint(results: ESLint.LintResult[]): ISdBuildMessage[] {
+    return results.mapMany((result) =>
+      result.messages.map((msg) => ({
+        filePath: PathUtil.norm(result.filePath),
+        line: msg.line,
+        char: msg.column,
+        code: msg.messageId,
+        severity: msg.severity === 1 ? ("warning" as const) : ("error" as const),
+        message: msg.message + (Boolean(msg.ruleId) ? ` (${msg.ruleId})` : ``),
+        type: "lint" as const,
+      })),
+    );
+  }
+
+  static convertToEsbuildFromBuildMessages(
+    messages: ISdBuildMessage[],
+    orgPath: string,
+  ): {
+    errors: PartialMessage[];
+    warnings: PartialMessage[];
+  } {
+    return {
+      errors: messages
+        .filter((msg) => msg.severity === "error")
+        .map((msg) => ({
+          id: msg.code,
+          pluginName: msg.type,
+          text: msg.message,
+          location: {
+            file: Boolean(msg.filePath) ? path.relative(orgPath, msg.filePath!) : undefined,
+            line: msg.line,
+            column: msg.char,
+          },
+        })),
+      warnings: messages
+        .filter((msg) => msg.severity !== "error")
+        .map((msg) => ({
+          id: msg.code,
+          pluginName: msg.type,
+          text: msg.message,
+          location: {
+            file: Boolean(msg.filePath) ? path.relative(orgPath, msg.filePath!) : undefined,
+            line: msg.line,
+            column: msg.char,
+          },
+        })),
+    };
+  }
+
+  static convertToEsbuildFromEslint(
+    results: ESLint.LintResult[],
+    orgPath: string,
+  ): {
+    errors: PartialMessage[];
+    warnings: PartialMessage[];
+  } {
+    return {
+      errors: results.mapMany((r) =>
+        r.messages
+          .filter((m) => m.severity === 2)
+          .map((m) => {
+            return {
+              pluginName: "lint",
+              text: m.messageId + ": " + m.message + (Boolean(m.ruleId) ? ` (${m.ruleId})` : ``),
+              location: {
+                file: path.relative(orgPath, r.filePath),
+                line: m.line,
+                column: m.column,
+              },
+            };
+          }),
+      ),
+      warnings: results.mapMany((r) =>
+        r.messages
+          .filter((m) => m.severity !== 2)
+          .map((m) => {
+            return {
+              pluginName: "lint",
+              text: m.messageId + ": " + m.message + (Boolean(m.ruleId) ? ` (${m.ruleId})` : ``),
+              location: {
+                file: path.relative(orgPath, r.filePath),
+                line: m.line,
+                column: m.column,
+              },
+            };
+          }),
+      ),
+    };
+  }
+
+  static getBuildMessageString(result: ISdBuildMessage): string {
+    let str = "";
+    if (result.filePath !== undefined) {
+      str += `${result.filePath}(${result.line ?? 0}, ${result.char ?? 0}): `;
+    }
+    str += `[${result.type}] `;
+    str += `${result.severity} `;
+    if (result.code !== undefined) {
+      str += `${result.code} `;
+    }
+    str += `: ${result.message}`;
+
+    return str;
+  }
+}

package/src/workers/compile-worker.ts

@@ -0,0 +1,31 @@
+import { createSdWorker, Logger, LoggerSeverity, TNormPath } from "@simplysm/sd-core-node";
+import { EventEmitter } from "events";
+import { SdTsCompiler } from "../ts-builder/SdTsCompiler";
+import { TSdTsCompileWorkerType } from "../types/workers.type";
+import { SdTsCompilerOptions } from "../types/ts-compiler.type";
+
+Error.stackTraceLimit = Infinity;
+EventEmitter.defaultMaxListeners = 0;
+
+if (process.env["SD_DEBUG"] != null) {
+  Logger.setConfig({
+    console: {
+      level: LoggerSeverity.debug,
+    },
+  });
+} else {
+  Logger.setConfig({
+    dot: true,
+  });
+}
+
+let compiler: SdTsCompiler;
+
+createSdWorker<TSdTsCompileWorkerType>({
+  initialize(opt: SdTsCompilerOptions) {
+    compiler = new SdTsCompiler(opt);
+  },
+  async compile(modifiedFileSet?: Set<TNormPath>) {
+    return await compiler.compileAsync(modifiedFileSet);
+  },
+});

package/src/workers/lint-worker.ts

@@ -0,0 +1,44 @@
+import { createSdWorker, FsUtil, Logger, LoggerSeverity, PathUtil } from "@simplysm/sd-core-node";
+import path from "path";
+import { ESLint } from "eslint";
+import { EventEmitter } from "events";
+import { TSdLintWorkerType } from "../types/workers.type";
+
+Error.stackTraceLimit = Infinity;
+EventEmitter.defaultMaxListeners = 0;
+
+if (process.env["SD_DEBUG"] != null) {
+  Logger.setConfig({
+    console: {
+      level: LoggerSeverity.debug,
+    },
+  });
+} else {
+  Logger.setConfig({
+    dot: true,
+  });
+}
+
+createSdWorker<TSdLintWorkerType>({
+  async lint(opt: { cwd: string; fileSet: Set<string> }) {
+    const isTsPackage = FsUtil.exists(path.resolve(opt.cwd, "tsconfig.json"));
+
+    const lintFilePaths = Array.from(opt.fileSet)
+      .filter((item) => PathUtil.isChildPath(item, opt.cwd))
+      .filter(
+        (item) =>
+          (isTsPackage && !item.endsWith(".d.ts") && item.endsWith(".ts")) ||
+          item.endsWith(".js") ||
+          item.endsWith(".tsx") ||
+          item.endsWith(".jsx"),
+      )
+      .filter((item) => FsUtil.exists(item));
+
+    if (lintFilePaths.length === 0) {
+      return [];
+    }
+
+    const linter = new ESLint({ cwd: opt.cwd, cache: false });
+    return await linter.lintFiles(lintFilePaths);
+  },
+});

package/src/workers/server-worker.ts

@@ -0,0 +1,52 @@
+import path from "path";
+import { pathToFileURL } from "url";
+import { SdServiceServer } from "@simplysm/sd-service-server";
+import { createSdWorker, Logger, LoggerSeverity } from "@simplysm/sd-core-node";
+import { EventEmitter } from "events";
+import { TServerWorkerType } from "../types/workers.type";
+
+Error.stackTraceLimit = Infinity;
+EventEmitter.defaultMaxListeners = 0;
+
+if (process.env["SD_DEBUG"] != null) {
+  Logger.setConfig({
+    console: {
+      level: LoggerSeverity.debug,
+    },
+  });
+} else {
+  Logger.setConfig({
+    dot: true,
+  });
+}
+
+let server: SdServiceServer;
+
+createSdWorker<TServerWorkerType>({
+  async listen(pkgInfo: { path: string } | { port: number }) {
+    if ("path" in pkgInfo) {
+      const mainFilePath = path.resolve(pkgInfo.path, "dist/main.js");
+      const serverModule = await import(pathToFileURL(mainFilePath).href);
+      const currServer = serverModule.default as SdServiceServer | undefined;
+      if (currServer == null) {
+        throw new Error(`${mainFilePath}(0, 0): 'SdServiceServer'를 'export'해야 합니다.`);
+      }
+      server = currServer;
+    } else {
+      server = new SdServiceServer({
+        rootPath: process.cwd(),
+        services: [],
+        port: pkgInfo.port,
+      });
+      await server.listenAsync();
+    }
+
+    return server.options.port;
+  },
+  setPathProxy(pathProxy: Record<string, string | number>) {
+    server.pathProxy = pathProxy;
+  },
+  broadcastReload(changedFileSet: Set<string>) {
+    server.broadcastReload(changedFileSet);
+  },
+});

package/tsconfig.json

@@ -5,5 +5,11 @@
     "outDir": "./dist",
     "types": ["node", "eslint", "yargs"]
   },
-  "files": ["./src/index.ts", "./src/sd-cli.ts", "./src/build-cluster.ts", "./src/server-worker.ts"]
+  "files": [
+    "./src/index.ts",
+    "./src/sd-cli.ts",
+    "./src/workers/compile-worker.ts",
+    "./src/workers/lint-worker.ts",
+    "./src/workers/server-worker.ts"
+  ]
 }