@simplysm/sd-cli 13.0.99 → 14.0.1

package/src/workers/ngtsc-build.worker.ts

@@ -0,0 +1,146 @@
+import path from "path";
+import { createWorker, FsWatcher } from "@simplysm/core-node";
+import { err as errNs } from "@simplysm/core-common";
+import { consola } from "consola";
+import { registerCleanupHandlers, createOnceGuard, applyDebugLevel } from "../utils/worker-utils";
+import {
+  runNgtscBuild,
+  runNgtscRebuild,
+  type NgtscBuildInfo,
+  type NgtscBuildResult,
+  type NgtscCombinedBuildEvent,
+} from "../utils/ngtsc-build-core";
+import type { NgtscProgram } from "../utils/angular-build";
+import { collectDeps } from "../utils/package-utils";
+
+applyDebugLevel();
+
+//#region Types (re-export for worker interface)
+
+export type { NgtscBuildInfo, NgtscBuildResult, NgtscCombinedBuildEvent };
+
+export interface NgtscBuildWorkerEvents extends Record<string, unknown> {
+  buildStart: Record<string, never>;
+  build: NgtscCombinedBuildEvent;
+  error: { message: string };
+}
+
+//#endregion
+
+//#region Resource Management
+
+const logger = consola.withTag("sd:cli:ngtsc-build:worker");
+
+let fsWatcher: FsWatcher | undefined;
+
+async function cleanup(): Promise<void> {
+  const watcherToClose = fsWatcher;
+  fsWatcher = undefined;
+
+  if (watcherToClose != null) {
+    await watcherToClose.close();
+  }
+}
+
+registerCleanupHandlers(cleanup, logger);
+
+//#endregion
+
+//#region build (one-time build)
+
+async function build(info: NgtscBuildInfo): Promise<NgtscBuildResult> {
+  return runNgtscBuild(info);
+}
+
+//#endregion
+
+//#region startWatch (watch mode)
+
+const guardStartWatch = createOnceGuard("startWatch");
+
+let watchInfo: NgtscBuildInfo | undefined;
+let oldProgram: NgtscProgram | undefined;
+let currentScssDependencies: Map<string, Set<string>> | undefined;
+
+async function startWatch(info: NgtscBuildInfo): Promise<void> {
+  guardStartWatch();
+  watchInfo = info;
+
+  try {
+    // Initial build
+    const { result: initialResult, program, scssDependencies: initialDeps } =
+      await runNgtscRebuild(info);
+    oldProgram = program;
+    currentScssDependencies = initialDeps;
+    sender.send("build", initialResult);
+
+    // Collect workspace dependency paths
+    const { workspaceDeps } = collectDeps(info.pkgDir, info.cwd);
+
+    // Start FsWatcher — own src/ + scss/ + workspace deps' src/ + scss/
+    const watchPaths = [
+      path.join(info.pkgDir, "src", "**", "*.{ts,tsx,scss,css}"),
+      path.join(info.pkgDir, "scss", "**", "*.{scss,css}"),
+      ...workspaceDeps.flatMap((d) => {
+        const depDir = path.join(info.cwd, "packages", d);
+        return [
+          path.join(depDir, "src", "**", "*.{ts,tsx,scss,css}"),
+          path.join(depDir, "scss", "**", "*.{scss,css}"),
+        ];
+      }),
+    ];
+    fsWatcher = await FsWatcher.watch(watchPaths);
+
+    fsWatcher.onChange({ delay: 300 }, async (changedFiles) => {
+      try {
+        sender.send("buildStart", {});
+
+        // Collect modified resource files (.scss/.css)
+        const modifiedResourceFiles = new Set<string>();
+        for (const f of changedFiles) {
+          if (f.path.endsWith(".scss") || f.path.endsWith(".css")) {
+            modifiedResourceFiles.add(f.path);
+            // Also add files that depend on this changed file
+            if (currentScssDependencies != null) {
+              for (const [containingFile, deps] of currentScssDependencies) {
+                if (deps.has(f.path)) {
+                  modifiedResourceFiles.add(containingFile);
+                }
+              }
+            }
+          }
+        }
+
+        const { result, program: newProgram, scssDependencies: newDeps } = await runNgtscRebuild(
+          watchInfo!,
+          oldProgram,
+          modifiedResourceFiles.size > 0 ? modifiedResourceFiles : undefined,
+        );
+        oldProgram = newProgram;
+        currentScssDependencies = newDeps;
+        sender.send("build", result);
+      } catch (err) {
+        sender.send("error", { message: errNs.message(err) });
+      }
+    });
+  } catch (err) {
+    sender.send("error", { message: errNs.message(err) });
+  }
+}
+
+async function stopWatch(): Promise<void> {
+  await cleanup();
+}
+
+//#endregion
+
+const sender = createWorker<
+  { build: typeof build; startWatch: typeof startWatch; stopWatch: typeof stopWatch },
+  NgtscBuildWorkerEvents
+>({
+  build,
+  startWatch,
+  stopWatch,
+});
+
+export default sender;

package/src/workers/server-build.worker.ts

@@ -0,0 +1,565 @@
+import path from "path";
+import fs from "fs";
+import { execaSync } from "execa";
+import esbuild from "esbuild";
+import { createWorker, FsWatcher, pathx } from "@simplysm/core-node";
+import { err as errNs } from "@simplysm/core-common";
+import { consola } from "consola";
+import type { BuildOutput } from "../engines/types";
+import type { SerializedDiagnostic } from "../utils/typecheck-serialization";
+import {
+  parseTsconfig,
+  getPackageSourceFiles,
+} from "../utils/tsconfig";
+import {
+  createServerEsbuildOptions,
+  collectUninstalledOptionalPeerDeps,
+  collectNativeModuleExternals,
+  writeChangedOutputFiles,
+} from "../utils/esbuild-config";
+import { runTscPackageBuild } from "../utils/tsc-build";
+import { registerCleanupHandlers, createOnceGuard, applyDebugLevel } from "../utils/worker-utils";
+import { collectDeps } from "../utils/package-utils";
+import { copyPublicFiles, watchPublicFiles } from "../utils/copy-public";
+
+//#region Types
+
+/**
+ * Server build information (one-time build)
+ */
+export interface ServerBuildInfo {
+  name: string;
+  cwd: string;
+  pkgDir: string;
+  output: BuildOutput;
+  /** Environment variables to substitute during build */
+  env?: Record<string, string>;
+  /** Runtime configuration (recorded in dist/.config.json) */
+  configs?: Record<string, unknown>;
+  /** External modules manually specified in sd.config.ts */
+  externals?: string[];
+  /** PM2 configuration (generates dist/pm2.config.cjs when specified) */
+  pm2?: {
+    name?: string;
+    ignoreWatchPaths?: string[];
+  };
+  /** Package manager to use (affects mise.toml or volta settings generation) */
+  packageManager?: "volta" | "mise";
+}
+
+/**
+ * Server watch information
+ */
+export interface ServerWatchInfo {
+  name: string;
+  cwd: string;
+  pkgDir: string;
+  output: BuildOutput;
+  /** Environment variables to substitute during build */
+  env?: Record<string, string>;
+  /** Runtime configuration (recorded in dist/.config.json) */
+  configs?: Record<string, unknown>;
+  /** External modules manually specified in sd.config.ts */
+  externals?: string[];
+  /** replaceDeps configuration from sd.config.ts */
+  replaceDeps?: Record<string, string>;
+}
+
+/**
+ * Server build result (aligned with LibraryBuildResult + mainJsPath)
+ */
+export interface ServerBuildResult {
+  js: { success: boolean; errors?: string[]; warnings?: string[] };
+  dts: { success: boolean; errors?: string[]; diagnostics: SerializedDiagnostic[] };
+  mainJsPath: string;
+}
+
+/**
+ * Combined build event for watch mode
+ */
+export interface ServerCombinedBuildEvent {
+  js: { success: boolean; errors?: string[]; warnings?: string[] };
+  dts: { success: boolean; errors?: string[] };
+  mainJsPath: string;
+}
+
+/**
+ * Worker event types
+ */
+export interface ServerBuildWorkerEvents extends Record<string, unknown> {
+  buildStart: Record<string, never>;
+  build: ServerCombinedBuildEvent;
+  error: { message: string };
+}
+
+//#endregion
+
+//#region Resource Management
+
+applyDebugLevel();
+
+const logger = consola.withTag("sd:cli:server-build:worker");
+
+/** esbuild build context (to be cleaned up) */
+let esbuildContext: esbuild.BuildContext | undefined;
+
+/** Last build metafile (for filtering changed files on rebuild) */
+let lastMetafile: esbuild.Metafile | undefined;
+
+/** Public files watcher (to be cleaned up) */
+let publicWatcher: FsWatcher | undefined;
+
+/** Source + scope packages watcher (to be cleaned up) */
+let srcWatcher: FsWatcher | undefined;
+
+async function cleanup(): Promise<void> {
+  const contextToDispose = esbuildContext;
+  esbuildContext = undefined;
+  lastMetafile = undefined;
+
+  const watcherToClose = publicWatcher;
+  publicWatcher = undefined;
+
+  const srcWatcherToClose = srcWatcher;
+  srcWatcher = undefined;
+
+  if (contextToDispose != null) {
+    await contextToDispose.dispose();
+  }
+  if (watcherToClose != null) {
+    await watcherToClose.close();
+  }
+  if (srcWatcherToClose != null) {
+    await srcWatcherToClose.close();
+  }
+}
+
+/**
+ * Collect external modules from three sources and merge them.
+ */
+function collectAllExternals(pkgDir: string, manualExternals?: string[]): string[] {
+  logger.debug("[externals] Scanning optional peer deps...");
+  const optionalPeerDeps = collectUninstalledOptionalPeerDeps(pkgDir);
+
+  logger.debug("[externals] Scanning native modules...");
+  const nativeModules = collectNativeModuleExternals(pkgDir);
+
+  const manual = manualExternals ?? [];
+  return [...new Set([...optionalPeerDeps, ...nativeModules, ...manual])];
+}
+
+/**
+ * Generate files for production deployment
+ */
+function generateProductionFiles(
+  info: ServerBuildInfo,
+  externals: string[],
+): void {
+  const distDir = path.join(info.pkgDir, "dist");
+  const pkgJson = JSON.parse(fs.readFileSync(path.join(info.pkgDir, "package.json"), "utf-8"));
+
+  // dist/package.json
+  const distPkgJson: Record<string, unknown> = {
+    name: pkgJson.name,
+    version: pkgJson.version,
+    type: pkgJson.type,
+  };
+  if (externals.length > 0) {
+    const deps: Record<string, string> = {};
+    for (const ext of externals) {
+      deps[ext] = "*";
+    }
+    distPkgJson["dependencies"] = deps;
+  }
+  if (info.packageManager === "volta") {
+    const nodeVersion = execaSync("node", ["-v"]).stdout.trim();
+    distPkgJson["volta"] = { node: nodeVersion };
+  }
+  fs.writeFileSync(path.join(distDir, "package.json"), JSON.stringify(distPkgJson, undefined, 2));
+
+  // dist/mise.toml
+  if (info.packageManager === "mise") {
+    const rootMiseTomlPath = path.join(info.cwd, "mise.toml");
+    let nodeVersion = "20";
+    if (fs.existsSync(rootMiseTomlPath)) {
+      const miseContent = fs.readFileSync(rootMiseTomlPath, "utf-8");
+      const match = /node\s*=\s*"([^"]+)"/.exec(miseContent);
+      if (match != null) {
+        nodeVersion = match[1];
+      }
+    }
+    fs.writeFileSync(path.join(distDir, "mise.toml"), `[tools]\nnode = "${nodeVersion}"\n`);
+  }
+
+  // dist/openssl.cnf
+  fs.writeFileSync(
+    path.join(distDir, "openssl.cnf"),
+    [
+      "nodejs_conf = openssl_init",
+      "",
+      "[openssl_init]",
+      "providers = provider_sect",
+      "ssl_conf = ssl_sect",
+      "",
+      "[provider_sect]",
+      "default = default_sect",
+      "legacy = legacy_sect",
+      "",
+      "[default_sect]",
+      "activate = 1",
+      "",
+      "[legacy_sect]",
+      "activate = 1",
+      "",
+      "[ssl_sect]",
+      "system_default = system_default_sect",
+      "",
+      "[system_default_sect]",
+      "Options = UnsafeLegacyRenegotiation",
+    ].join("\n"),
+  );
+
+  // dist/pm2.config.cjs
+  if (info.pm2 != null) {
+    const pm2Name = info.pm2.name ?? pkgJson.name.replace(/@/g, "").replace(/[/\\]/g, "-");
+    const ignoreWatch = JSON.stringify([
+      "node_modules",
+      "www",
+      ...(info.pm2.ignoreWatchPaths ?? []),
+    ]);
+    const envObj: Record<string, string> = {
+      NODE_ENV: "production",
+      TZ: "Asia/Seoul",
+      ...(info.env ?? {}),
+    };
+    const envStr = JSON.stringify(envObj, undefined, 4);
+
+    const useInterpreter = info.packageManager !== "volta";
+
+    const pm2Config = [
+      ...(useInterpreter ? [`const cp = require("child_process");`, ``] : []),
+      `module.exports = {`,
+      `  name: ${JSON.stringify(pm2Name)},`,
+      `  script: "main.js",`,
+      `  watch: true,`,
+      `  watch_delay: 2000,`,
+      `  ignore_watch: ${ignoreWatch},`,
+      ...(useInterpreter ? [`  interpreter: cp.execSync("mise which node").toString().trim(),`] : []),
+      `  interpreter_args: "--openssl-config=openssl.cnf",`,
+      `  env: ${envStr.replace(/\n/g, "\n  ")},`,
+      `  arrayProcess: "concat",`,
+      `  useDelTargetNull: true,`,
+      `};`,
+    ].join("\n");
+
+    fs.writeFileSync(path.join(distDir, "pm2.config.cjs"), pm2Config);
+  }
+}
+
+registerCleanupHandlers(cleanup, logger);
+
+//#endregion
+
+//#region Worker
+
+/**
+ * One-time build (production)
+ */
+async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
+  const mainJsPath = path.join(info.pkgDir, "dist", "main.js");
+
+  try {
+    // Parse tsconfig
+    const parsedConfig = parseTsconfig(info.pkgDir);
+    const entryPoints = getPackageSourceFiles(info.pkgDir, parsedConfig);
+
+    // Collect externals
+    const external = collectAllExternals(info.pkgDir, info.externals);
+
+    // esbuild (async) ‖ tsc (sync) in parallel
+    const esbuildOptions = createServerEsbuildOptions({
+      pkgDir: info.pkgDir,
+      entryPoints,
+      env: info.env,
+      external,
+    });
+
+    const esbuildPromise = info.output.js
+      ? esbuild.build(esbuildOptions).then(async (result) => {
+          if (result.outputFiles) {
+            await writeChangedOutputFiles(result.outputFiles);
+          }
+          const errors = result.errors.map((e) => e.text);
+          const warnings = result.warnings.map((w) => w.text);
+          return {
+            success: result.errors.length === 0,
+            errors: errors.length > 0 ? errors : undefined,
+            warnings: warnings.length > 0 ? warnings : undefined,
+          };
+        }).catch((err) => ({
+          success: false,
+          errors: [errNs.message(err)],
+          warnings: undefined,
+        }))
+      : null;
+
+    // tsc typecheck (always runs, emit controlled by output.dts)
+    const tscResult = runTscPackageBuild({
+      pkgDir: info.pkgDir,
+      cwd: info.cwd,
+      output: { js: false, dts: info.output.dts },
+      parsedConfig,
+    });
+
+    const jsResult = esbuildPromise
+      ? await esbuildPromise
+      : { success: true, errors: undefined, warnings: undefined };
+
+    // Generate production artifacts only when JS output is requested
+    if (info.output.js) {
+      const confDistPath = path.join(info.pkgDir, "dist", ".config.json");
+      fs.writeFileSync(confDistPath, JSON.stringify(info.configs ?? {}, undefined, 2));
+
+      await copyPublicFiles(info.pkgDir, false);
+
+      generateProductionFiles(info, external);
+    }
+
+    return {
+      js: {
+        success: jsResult.success,
+        errors: jsResult.errors,
+        warnings: jsResult.warnings,
+      },
+      dts: {
+        success: tscResult.success,
+        errors: tscResult.errors,
+        diagnostics: tscResult.diagnostics,
+      },
+      mainJsPath,
+    };
+  } catch (err) {
+    return {
+      js: { success: false, errors: [errNs.message(err)] },
+      dts: { success: false, errors: [errNs.message(err)], diagnostics: [] },
+      mainJsPath,
+    };
+  }
+}
+
+const guardStartWatch = createOnceGuard("startWatch");
+
+// Mutable state for watch mode
+let watchInfo: ServerWatchInfo | undefined;
+
+/**
+ * Rebuild esbuild + tsc in parallel (watch mode)
+ */
+async function rebuildAll(): Promise<ServerCombinedBuildEvent> {
+  const info = watchInfo!;
+  const mainJsPath = path.join(info.pkgDir, "dist", "main.js");
+  const parsedConfig = parseTsconfig(info.pkgDir);
+
+  // esbuild rebuild (async)
+  let esbuildPromise: Promise<{ success: boolean; errors?: string[]; warnings?: string[] }> | null = null;
+  if (info.output.js && esbuildContext != null) {
+    esbuildPromise = esbuildContext.rebuild().then(async (result) => {
+      // Save metafile
+      if (result.metafile != null) {
+        lastMetafile = result.metafile;
+      }
+
+      if (result.outputFiles) {
+        await writeChangedOutputFiles(result.outputFiles);
+      }
+      const errors = result.errors.map((e) => e.text);
+      const warnings = result.warnings.map((w) => w.text);
+      return {
+        success: result.errors.length === 0,
+        errors: errors.length > 0 ? errors : undefined,
+        warnings: warnings.length > 0 ? warnings : undefined,
+      };
+    });
+  }
+
+  // tsc rebuild (sync, incremental)
+  const tscResult = runTscPackageBuild({
+    pkgDir: info.pkgDir,
+    cwd: info.cwd,
+    output: { js: false, dts: info.output.dts },
+    parsedConfig,
+  });
+
+  const jsResult = esbuildPromise
+    ? await esbuildPromise
+    : { success: true, errors: undefined, warnings: undefined };
+
+  return {
+    js: { success: jsResult.success, errors: jsResult.errors, warnings: jsResult.warnings },
+    dts: { success: tscResult.success, errors: tscResult.errors },
+    mainJsPath,
+  };
+}
+
+/**
+ * Create esbuild context for watch mode
+ */
+async function createEsbuildWatchContext(
+  info: ServerWatchInfo,
+  entryPoints: string[],
+  external: string[],
+): Promise<esbuild.BuildContext> {
+  const baseOptions = createServerEsbuildOptions({
+    pkgDir: info.pkgDir,
+    entryPoints,
+    env: info.env,
+    external,
+    dev: true,
+  });
+
+  return esbuild.context({
+    ...baseOptions,
+    metafile: true,
+    write: false,
+  });
+}
+
+/**
+ * Start watch mode
+ */
+async function startWatch(info: ServerWatchInfo): Promise<void> {
+  guardStartWatch();
+  watchInfo = info;
+
+  try {
+    const parsedConfig = parseTsconfig(info.pkgDir);
+    const entryPoints = getPackageSourceFiles(info.pkgDir, parsedConfig);
+
+    // Collect externals
+    const external = collectAllExternals(info.pkgDir, info.externals);
+
+    // Create esbuild context (if JS output needed)
+    if (info.output.js) {
+      esbuildContext = await createEsbuildWatchContext(info, entryPoints, external);
+    }
+
+    // Initial build: esbuild + tsc parallel
+    const initialResult = await rebuildAll();
+
+    // Write .config.json on first build
+    const confDistPath = path.join(info.pkgDir, "dist", ".config.json");
+    fs.writeFileSync(confDistPath, JSON.stringify(info.configs ?? {}, undefined, 2));
+
+    sender.send("build", initialResult);
+
+    // Watch public/ + public-dev/
+    publicWatcher = await watchPublicFiles(info.pkgDir, true);
+
+    // Collect watch paths based on dependencies
+    const { workspaceDeps, replaceDeps } = collectDeps(info.pkgDir, info.cwd, info.replaceDeps);
+
+    const watchPaths: string[] = [];
+
+    // Server package itself + workspace dependency packages source
+    const watchDirs = [
+      info.pkgDir,
+      ...workspaceDeps.map((d) => path.join(info.cwd, "packages", d)),
+    ];
+    for (const dir of watchDirs) {
+      watchPaths.push(path.join(dir, "src", "**", "*"));
+      watchPaths.push(path.join(dir, "*.{ts,js,css}"));
+    }
+
+    // ReplaceDeps dependency packages dist
+    for (const pkg of replaceDeps) {
+      watchPaths.push(path.join(info.cwd, "node_modules", ...pkg.split("/"), "dist", "**", "*.js"));
+      watchPaths.push(
+        path.join(info.pkgDir, "node_modules", ...pkg.split("/"), "dist", "**", "*.js"),
+      );
+    }
+
+    // Start FsWatcher
+    srcWatcher = await FsWatcher.watch(watchPaths);
+
+    srcWatcher.onChange({ delay: 300 }, async (changes) => {
+      try {
+        const hasFileAddOrRemove = changes.some((c) => c.event === "add" || c.event === "unlink");
+
+        if (hasFileAddOrRemove) {
+          sender.send("buildStart", {});
+
+          // Recreate context on file add/remove
+          const newParsedConfig = parseTsconfig(info.pkgDir);
+          const newEntryPoints = getPackageSourceFiles(info.pkgDir, newParsedConfig);
+          const newExternal = collectAllExternals(info.pkgDir, info.externals);
+
+          const oldContext = esbuildContext;
+          if (info.output.js) {
+            esbuildContext = await createEsbuildWatchContext(info, newEntryPoints, newExternal);
+          }
+          if (oldContext != null) {
+            await oldContext.dispose();
+          }
+
+          const result = await rebuildAll();
+          sender.send("build", result);
+          return;
+        }
+
+        // Only file changes: filter by metafile
+        if (esbuildContext == null) {
+          sender.send("buildStart", {});
+          const result = await rebuildAll();
+          sender.send("build", result);
+          return;
+        }
+
+        if (lastMetafile == null) {
+          sender.send("buildStart", {});
+          const result = await rebuildAll();
+          sender.send("build", result);
+          return;
+        }
+
+        // Filter by metafile inputs
+        const metafileAbsPaths = new Set(
+          Object.keys(lastMetafile.inputs).map((key) => pathx.norm(info.cwd, key)),
+        );
+
+        const hasRelevantChange = changes.some((c) => metafileAbsPaths.has(c.path));
+
+        if (hasRelevantChange) {
+          sender.send("buildStart", {});
+          const result = await rebuildAll();
+          sender.send("build", result);
+        } else {
+          logger.debug("Changed files not included in build, skipping rebuild");
+        }
+      } catch (err) {
+        sender.send("error", { message: errNs.message(err) });
+      }
+    });
+  } catch (err) {
+    sender.send("error", { message: errNs.message(err) });
+  }
+}
+
+/**
+ * Stop watch
+ */
+async function stopWatch(): Promise<void> {
+  await cleanup();
+}
+
+const sender = createWorker<
+  { build: typeof build; startWatch: typeof startWatch; stopWatch: typeof stopWatch },
+  ServerBuildWorkerEvents
+>({
+  build,
+  startWatch,
+  stopWatch,
+});
+
+export default sender;
+
+//#endregion