@simplysm/sd-cli 13.0.99 → 14.0.1

package/dist/orchestrators/BuildOrchestrator.js

@@ -1,338 +1,343 @@
 import path from "path";
 import ts from "typescript";
 import { Worker, fsx } from "@simplysm/core-node";
-import { err as errNs } from "@simplysm/core-common";
 import { consola } from "consola";
 import { loadSdConfig } from "../utils/sd-config.js";
 import { getVersion } from "../utils/build-env.js";
 import { deserializeDiagnostic } from "../utils/typecheck-serialization.js";
-import { Capacitor } from "../capacitor/capacitor.js";
-import { Electron } from "../electron/electron.js";
 import { copySrcFiles } from "../utils/copy-src.js";
 import { formatBuildMessages } from "../utils/output-utils.js";
-function classifyPackages(packages, targets) {
-  const buildPackages = [];
-  const clientPackages = [];
-  const serverPackages = [];
-  for (const [name, config] of Object.entries(packages)) {
-    if (config == null) continue;
-    if (config.target === "scripts") continue;
-    if (targets.length > 0 && !targets.includes(name)) continue;
-    if (config.target === "client") {
-      clientPackages.push({ name, config });
-    } else if (config.target === "server") {
-      serverPackages.push({ name, config });
-    } else {
-      buildPackages.push({ name, config });
+import { createBuildEngine } from "../engines/index.js";
+import { runWithConcurrency, getMaxConcurrency } from "../utils/concurrency.js";
+import { validateTargets } from "../utils/package-utils.js";
+//#endregion
+//#region Utilities
+/**
+ * Classify packages by target
+ * - node/browser/neutral: buildPackages (JS + dts)
+ * - server: serverPackages (JS build, no dts)
+ * - client: clientPackages (Vite production build, no dts)
+ * - scripts: excluded
+ */
+export function classifyPackages(packages, targets) {
+    const buildPackages = [];
+    const serverPackages = [];
+    const clientPackages = [];
+    for (const [name, config] of Object.entries(packages)) {
+        if (config == null)
+            continue;
+        if (config.target === "scripts")
+            continue;
+        // Include only specified packages if targets is specified
+        if (targets.length > 0 && !targets.includes(name))
+            continue;
+        if (config.target === "client") {
+            clientPackages.push({ name, config });
+        }
+        else if (config.target === "server") {
+            serverPackages.push({ name, config });
+        }
+        else {
+            buildPackages.push({ name, config });
+        }
     }
-  }
-  return { buildPackages, clientPackages, serverPackages };
+    return { buildPackages, serverPackages, clientPackages };
 }
+/**
+ * Delete dist folders
+ */
 async function cleanDistFolders(cwd, packageNames) {
-  await Promise.all(packageNames.map((name) => fsx.rm(path.join(cwd, "packages", name, "dist"))));
+    await Promise.all(packageNames.map((name) => fsx.rm(path.join(cwd, "packages", name, "dist"))));
 }
-class BuildOrchestrator {
-  _cwd;
-  _options;
-  _logger = consola.withTag("sd:cli:build");
-  _sdConfig;
-  _classified;
-  _allPackageNames = [];
-  _baseEnv;
-  constructor(options) {
-    this._cwd = process.cwd();
-    this._options = options;
-  }
-  /**
-   * Initialize Orchestrator
-   * - Load sd.config.ts
-   * - Configure replaceDeps
-   * - Classify packages
-   * - Prepare environment variables
-   */
-  async initialize() {
-    this._logger.debug("build started", { targets: this._options.targets });
-    try {
-      this._sdConfig = await loadSdConfig({
-        cwd: this._cwd,
-        dev: false,
-        options: this._options.options
-      });
-      this._logger.debug("sd.config.ts loaded");
-    } catch (err) {
-      this._logger.error(`sd.config.ts load failed: ${err instanceof Error ? err.message : err}`);
-      process.exitCode = 1;
-      throw err;
-    }
-    const version = await getVersion(this._cwd);
-    this._baseEnv = { VER: version, DEV: "false" };
-    this._classified = classifyPackages(this._sdConfig.packages, this._options.targets);
-    this._allPackageNames = [
-      ...this._classified.buildPackages.map((p) => p.name),
-      ...this._classified.clientPackages.map((p) => p.name),
-      ...this._classified.serverPackages.map((p) => p.name)
-    ];
-    if (this._allPackageNames.length === 0) {
-      process.stdout.write("\u2714 No packages to build.\n");
-      return;
+//#endregion
+//#region BuildOrchestrator
+/**
+ * Orchestrator for coordinating production builds
+ *
+ * Classifies packages based on sd.config.ts and executes builds.
+ * - Clean dist folders (clean build)
+ * - Run lint + build concurrently
+ * - node/browser/neutral targets: esbuild JS build + dts generation
+ * - server targets: esbuild JS build
+ * - client targets: Vite production build
+ */
+export class BuildOrchestrator {
+    _cwd;
+    _options;
+    _logger = consola.withTag("sd:cli:build");
+    _sdConfig;
+    _classified;
+    _allPackageNames = [];
+    _baseEnv;
+    constructor(options) {
+        this._cwd = process.cwd();
+        this._options = options;
     }
-    this._logger.debug("package classification complete", {
-      buildPackages: this._classified.buildPackages.map((p) => p.name),
-      clientPackages: this._classified.clientPackages.map((p) => p.name),
-      serverPackages: this._classified.serverPackages.map((p) => p.name)
-    });
-  }
-  /**
-   * Execute build
-   * - Clean
-   * - Lint + Build (concurrent)
-   * - Output results
-   *
-   * @returns whether errors occurred (true: errors present)
-   */
-  async start() {
-    if (this._allPackageNames.length === 0) {
-      return false;
-    }
-    const classified = this._classified;
-    const baseEnv = this._baseEnv;
-    const results = [];
-    const state = { hasError: false };
-    const libraryWorkerPath = import.meta.resolve("../workers/library.worker");
-    const serverWorkerPath = import.meta.resolve("../workers/server.worker");
-    const clientWorkerPath = import.meta.resolve("../workers/client.worker");
-    const dtsWorkerPath = import.meta.resolve("../workers/dts.worker");
-    const lintWorkerPath = import.meta.resolve("../workers/lint.worker");
-    const fileCache = /* @__PURE__ */ new Map();
-    const formatHost = {
-      getCanonicalFileName: (f) => f,
-      getCurrentDirectory: () => this._cwd,
-      getNewLine: () => ts.sys.newLine
-    };
-    const lintOptions = {
-      targets: this._allPackageNames.map((name) => `packages/${name}`),
-      fix: false,
-      timing: false
-    };
-    this._logger.start("Clean");
-    await cleanDistFolders(this._cwd, this._allPackageNames);
-    this._logger.success("Clean");
-    this._logger.start("Lint + Build");
-    const buildTasks = [];
-    for (const { name, config } of classified.buildPackages) {
-      const pkgDir = path.join(this._cwd, "packages", name);
-      const env = config.target === "node" ? "node" : "browser";
-      buildTasks.push(async () => {
-        this._logger.debug(`${name} (${config.target}) started`);
-        const libraryWorker = Worker.create(libraryWorkerPath);
-        const dtsWorker = Worker.create(dtsWorkerPath);
+    /**
+     * Initialize Orchestrator
+     * - Load sd.config.ts
+     * - Configure replaceDeps
+     * - Classify packages
+     * - Prepare environment variables
+     */
+    async initialize() {
+        this._logger.debug("build started", { targets: this._options.targets });
+        // Load sd.config.ts
         try {
-          const [buildResult, dtsResult] = await Promise.all([
-            // JS build
-            libraryWorker.build({ name, config, cwd: this._cwd, pkgDir }),
-            // DTS generation
-            dtsWorker.build({ name, cwd: this._cwd, pkgDir, env, emit: true })
-          ]);
-          results.push({
-            name,
-            target: config.target,
-            type: "js",
-            success: buildResult.success,
-            errors: buildResult.errors,
-            warnings: buildResult.warnings
-          });
-          if (!buildResult.success) state.hasError = true;
-          const diagnostics = dtsResult.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
-          results.push({
-            name,
-            target: config.target,
-            type: "dts",
-            success: dtsResult.success,
-            errors: dtsResult.errors,
-            diagnostics
-          });
-          if (!dtsResult.success) state.hasError = true;
-        } finally {
-          await Promise.all([libraryWorker.terminate(), dtsWorker.terminate()]);
+            this._sdConfig = await loadSdConfig({
+                cwd: this._cwd,
+                dev: false,
+                options: this._options.options,
+            });
+            this._logger.debug("sd.config.ts loaded");
         }
-        if (config.copySrc != null && config.copySrc.length > 0) {
-          await copySrcFiles(pkgDir, config.copySrc);
+        catch (err) {
+            this._logger.error(`sd.config.ts load failed: ${err instanceof Error ? err.message : err}`);
+            process.exitCode = 1;
+            throw err;
         }
-        this._logger.debug(`${name} (${config.target}) completed`);
-      });
+        // Validate targets
+        validateTargets(this._options.targets, this._sdConfig.packages);
+        // Prepare VER and DEV environment variables
+        const version = await getVersion(this._cwd);
+        this._baseEnv = { VER: version, DEV: "false" };
+        // Classify packages
+        this._classified = classifyPackages(this._sdConfig.packages, this._options.targets);
+        this._allPackageNames = [
+            ...this._classified.buildPackages.map((p) => p.name),
+            ...this._classified.serverPackages.map((p) => p.name),
+            ...this._classified.clientPackages.map((p) => p.name),
+        ];
+        if (this._allPackageNames.length === 0) {
+            process.stdout.write("✔ No packages to build.\n");
+            return;
+        }
+        this._logger.debug("package classification complete", {
+            buildPackages: this._classified.buildPackages.map((p) => p.name),
+            serverPackages: this._classified.serverPackages.map((p) => p.name),
+            clientPackages: this._classified.clientPackages.map((p) => p.name),
+        });
     }
-    for (const { name, config } of classified.clientPackages) {
-      const pkgDir = path.join(this._cwd, "packages", name);
-      buildTasks.push(async () => {
-        this._logger.debug(`${name} (client) started`);
-        const clientWorker = Worker.create(clientWorkerPath);
-        const dtsWorker = Worker.create(dtsWorkerPath);
-        try {
-          const clientConfig = {
-            ...config,
-            env: { ...baseEnv, ...config.env }
-          };
-          const [clientResult, dtsResult] = await Promise.all([
-            // Vite production build
-            clientWorker.build({ name, config: clientConfig, cwd: this._cwd, pkgDir }),
-            // typecheck (without dts)
-            dtsWorker.build({
-              name,
-              cwd: this._cwd,
-              pkgDir,
-              env: "browser",
-              emit: false
-            })
-          ]);
-          results.push({
-            name,
-            target: "client",
-            type: "vite",
-            success: clientResult.success,
-            errors: clientResult.errors
-          });
-          if (!clientResult.success) state.hasError = true;
-          const diagnostics = dtsResult.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
-          results.push({
-            name,
-            target: "client",
-            type: "dts",
-            success: dtsResult.success,
-            errors: dtsResult.errors,
-            diagnostics
-          });
-          if (!dtsResult.success) state.hasError = true;
-        } finally {
-          await Promise.all([clientWorker.terminate(), dtsWorker.terminate()]);
+    /**
+     * Execute build
+     * - Clean
+     * - Lint + Build (concurrent)
+     * - Output results
+     *
+     * @returns whether errors occurred (true: errors present)
+     */
+    async start() {
+        if (this._allPackageNames.length === 0) {
+            return false;
         }
-        if (config.capacitor != null) {
-          const outPath = path.join(pkgDir, "dist");
-          try {
-            const cap = await Capacitor.create(pkgDir, config.capacitor, config.exclude);
-            await cap.initialize();
-            await cap.build(outPath);
-            results.push({
-              name,
-              target: "client",
-              type: "capacitor",
-              success: true
+        const classified = this._classified;
+        const baseEnv = this._baseEnv;
+        // Collect results
+        const results = [];
+        // Track errors (wrapped in object to allow mutation tracking in callbacks)
+        const state = { hasError: false };
+        // Worker path (lint only — library/server are handled by BuildEngine)
+        const lintWorkerPath = import.meta.resolve("../workers/lint.worker");
+        // File cache (for diagnostics output)
+        const fileCache = new Map();
+        // formatHost (for diagnostics output)
+        const formatHost = {
+            getCanonicalFileName: (f) => f,
+            getCurrentDirectory: () => this._cwd,
+            getNewLine: () => ts.sys.newLine,
+        };
+        // Lint options (target all packages)
+        const lintOptions = {
+            targets: this._allPackageNames.map((name) => `packages/${name}`),
+            fix: false,
+            timing: false,
+        };
+        // Phase 1: Clean (must complete before build writes to dist)
+        this._logger.start("Clean");
+        await cleanDistFolders(this._cwd, this._allPackageNames);
+        this._logger.success("Clean");
+        // Phase 2: Lint + Build (concurrent)
+        this._logger.start("Lint + Build");
+        // Create list of build tasks
+        const buildTasks = [];
+        // buildPackages: JS build + dts generation via BuildEngine
+        for (const { name, config } of classified.buildPackages) {
+            const pkgDir = path.join(this._cwd, "packages", name);
+            buildTasks.push(async () => {
+                this._logger.debug(`${name} (${config.target}) started`);
+                const engine = createBuildEngine({ name, dir: pkgDir, config }, { cwd: this._cwd });
+                try {
+                    const engineResult = await engine.run({ js: true, dts: true });
+                    // Handle JS build results
+                    results.push({
+                        name,
+                        target: config.target,
+                        type: "js",
+                        success: engineResult.js.success,
+                        errors: engineResult.js.errors.length > 0 ? engineResult.js.errors : undefined,
+                        warnings: engineResult.js.warnings.length > 0 ? engineResult.js.warnings : undefined,
+                    });
+                    if (!engineResult.js.success)
+                        state.hasError = true;
+                    // Handle DTS results
+                    const diagnostics = engineResult.dts.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
+                    results.push({
+                        name,
+                        target: config.target,
+                        type: "dts",
+                        success: engineResult.dts.success,
+                        errors: engineResult.dts.errors.length > 0 ? engineResult.dts.errors : undefined,
+                        diagnostics,
+                    });
+                    if (!engineResult.dts.success)
+                        state.hasError = true;
+                }
+                finally {
+                    await engine.stop();
+                }
+                // Copy copySrc files
+                if (config.copySrc != null && config.copySrc.length > 0) {
+                    await copySrcFiles(pkgDir, config.copySrc);
+                }
+                this._logger.debug(`${name} (${config.target}) completed`);
             });
-          } catch (err) {
-            results.push({
-              name,
-              target: "client",
-              type: "capacitor",
-              success: false,
-              errors: [errNs.message(err)]
-            });
-            state.hasError = true;
-          }
         }
-        if (config.electron != null) {
-          const outPath = path.join(pkgDir, "dist");
-          try {
-            const electron = await Electron.create(pkgDir, config.electron, config.exclude);
-            await electron.initialize();
-            await electron.build(outPath);
-            results.push({
-              name,
-              target: "client",
-              type: "electron",
-              success: true
+        // serverPackages: JS build + typecheck via BuildEngine
+        for (const { name, config } of classified.serverPackages) {
+            const pkgDir = path.join(this._cwd, "packages", name);
+            buildTasks.push(async () => {
+                this._logger.debug(`${name} (server) started`);
+                const engine = createBuildEngine({ name, dir: pkgDir, config: { ...config, env: { ...baseEnv, ...config.env } } }, { cwd: this._cwd });
+                try {
+                    const engineResult = await engine.run({ js: true, dts: false });
+                    // Handle JS build results
+                    results.push({
+                        name,
+                        target: "server",
+                        type: "js",
+                        success: engineResult.js.success,
+                        errors: engineResult.js.errors.length > 0 ? engineResult.js.errors : undefined,
+                        warnings: engineResult.js.warnings.length > 0 ? engineResult.js.warnings : undefined,
+                    });
+                    if (!engineResult.js.success)
+                        state.hasError = true;
+                    // Handle DTS/typecheck results
+                    const diagnostics = engineResult.dts.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
+                    results.push({
+                        name,
+                        target: "server",
+                        type: "dts",
+                        success: engineResult.dts.success,
+                        errors: engineResult.dts.errors.length > 0 ? engineResult.dts.errors : undefined,
+                        diagnostics,
+                    });
+                    if (!engineResult.dts.success)
+                        state.hasError = true;
+                }
+                finally {
+                    await engine.stop();
+                }
+                this._logger.debug(`${name} (server) completed`);
             });
-          } catch (err) {
-            results.push({
-              name,
-              target: "client",
-              type: "electron",
-              success: false,
-              errors: [errNs.message(err)]
+        }
+        // clientPackages: Vite production build via ViteEngine (no dts, no env injection)
+        for (const { name, config } of classified.clientPackages) {
+            const pkgDir = path.join(this._cwd, "packages", name);
+            buildTasks.push(async () => {
+                this._logger.debug(`${name} (client) started`);
+                const engine = createBuildEngine({ name, dir: pkgDir, config }, { cwd: this._cwd });
+                try {
+                    const engineResult = await engine.run({ js: true, dts: false });
+                    // Handle JS build results
+                    results.push({
+                        name,
+                        target: "client",
+                        type: "js",
+                        success: engineResult.js.success,
+                        errors: engineResult.js.errors.length > 0 ? engineResult.js.errors : undefined,
+                        warnings: engineResult.js.warnings.length > 0 ? engineResult.js.warnings : undefined,
+                    });
+                    if (!engineResult.js.success)
+                        state.hasError = true;
+                    // Handle DTS results (always success for client)
+                    const diagnostics = engineResult.dts.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
+                    results.push({
+                        name,
+                        target: "client",
+                        type: "dts",
+                        success: engineResult.dts.success,
+                        errors: engineResult.dts.errors.length > 0 ? engineResult.dts.errors : undefined,
+                        diagnostics,
+                    });
+                    if (!engineResult.dts.success)
+                        state.hasError = true;
+                }
+                finally {
+                    await engine.stop();
+                }
+                this._logger.debug(`${name} (client) completed`);
             });
-            state.hasError = true;
-          }
         }
-        this._logger.debug(`${name} (client) completed`);
-      });
-    }
-    for (const { name, config } of classified.serverPackages) {
-      const pkgDir = path.join(this._cwd, "packages", name);
-      buildTasks.push(async () => {
-        this._logger.debug(`${name} (server) started`);
-        const serverWorker = Worker.create(serverWorkerPath);
-        try {
-          const buildResult = await serverWorker.build({
-            name,
-            cwd: this._cwd,
-            pkgDir,
-            env: { ...baseEnv, ...config.env },
-            configs: config.configs,
-            externals: config.externals,
-            pm2: config.pm2,
-            packageManager: config.packageManager
-          });
-          results.push({
-            name,
-            target: "server",
-            type: "js",
-            success: buildResult.success,
-            errors: buildResult.errors,
-            warnings: buildResult.warnings
-          });
-          if (!buildResult.success) state.hasError = true;
-        } finally {
-          await serverWorker.terminate();
+        // Run Lint + all builds in parallel
+        // Lint runs independently; build tasks use concurrency limit (PERF-001)
+        const lintWorker = Worker.create(lintWorkerPath);
+        const lintTask = async () => {
+            try {
+                const result = await lintWorker.lint(lintOptions);
+                if (!result.success)
+                    state.hasError = true;
+            }
+            finally {
+                await lintWorker.terminate();
+            }
+        };
+        const buildPromise = runWithConcurrency(buildTasks, getMaxConcurrency());
+        await Promise.allSettled([lintTask(), buildPromise]);
+        this._logger.success("Lint + Build");
+        // Output results
+        const allDiagnostics = [];
+        for (const result of results) {
+            const typeLabel = result.type === "dts" ? "dts" : result.target;
+            // Output warnings
+            if (result.warnings != null) {
+                this._logger.warn(formatBuildMessages(result.name, typeLabel, result.warnings));
+            }
+            // Output errors
+            if (!result.success) {
+                if (result.errors != null) {
+                    this._logger.error(formatBuildMessages(result.name, typeLabel, result.errors));
+                }
+                else {
+                    this._logger.error(`${result.name} (${typeLabel})`);
+                }
+            }
+            if (result.diagnostics != null) {
+                allDiagnostics.push(...result.diagnostics);
+            }
         }
-        this._logger.debug(`${name} (server) completed`);
-      });
-    }
-    const lintWorker = Worker.create(lintWorkerPath);
-    const lintTask = async () => {
-      try {
-        const result = await lintWorker.lint(lintOptions);
-        if (!result.success) state.hasError = true;
-      } finally {
-        await lintWorker.terminate();
-      }
-    };
-    await Promise.allSettled([lintTask(), ...buildTasks.map((task) => task())]);
-    this._logger.success("Lint + Build");
-    const allDiagnostics = [];
-    for (const result of results) {
-      const typeLabel = result.type === "dts" ? "dts" : result.target;
-      if (result.warnings != null) {
-        this._logger.warn(formatBuildMessages(result.name, typeLabel, result.warnings));
-      }
-      if (!result.success) {
-        if (result.errors != null) {
-          this._logger.error(formatBuildMessages(result.name, typeLabel, result.errors));
-        } else {
-          this._logger.error(`${result.name} (${typeLabel})`);
+        // Output diagnostics (deduplicated)
+        if (allDiagnostics.length > 0) {
+            const uniqueDiagnostics = ts.sortAndDeduplicateDiagnostics(allDiagnostics);
+            const message = ts.formatDiagnosticsWithColorAndContext(uniqueDiagnostics, formatHost);
+            process.stdout.write(message);
         }
-      }
-      if (result.diagnostics != null) {
-        allDiagnostics.push(...result.diagnostics);
-      }
-    }
-    if (allDiagnostics.length > 0) {
-      const uniqueDiagnostics = ts.sortAndDeduplicateDiagnostics(allDiagnostics);
-      const message = ts.formatDiagnosticsWithColorAndContext(uniqueDiagnostics, formatHost);
-      process.stdout.write(message);
+        // Output result log
+        if (state.hasError) {
+            this._logger.error("Build failed");
+        }
+        else {
+            this._logger.info("Build completed");
+        }
+        return state.hasError;
     }
-    if (state.hasError) {
-      this._logger.error("Build failed");
-    } else {
-      this._logger.info("Build completed");
+    /**
+     * Shutdown Orchestrator (no resources to clean up currently)
+     */
+    async shutdown() {
+        // Production builds are one-time operations, so there are no resources to clean up at shutdown
+        // Workers are cleaned up with terminate() within each build task
+        await Promise.resolve();
     }
-    return state.hasError;
-  }
-  /**
-   * Shutdown Orchestrator (no resources to clean up currently)
-   */
-  async shutdown() {
-    await Promise.resolve();
-  }
 }
-export {
-  BuildOrchestrator
-};
-//# sourceMappingURL=BuildOrchestrator.js.map
+//#endregion
+//# sourceMappingURL=BuildOrchestrator.js.map