@simplysm/sd-cli 13.0.99 → 14.0.1

package/src/engines/ServerEsbuildEngine.ts

@@ -0,0 +1,195 @@
+import { Worker, type WorkerProxy } from "@simplysm/core-node";
+import { consola } from "consola";
+import type * as ServerBuildWorkerModule from "../workers/server-build.worker";
+import type { BuildResult, ResultCollector } from "../infra/ResultCollector";
+import type { RebuildManager } from "../utils/rebuild-manager";
+import type { BuildEngine, BuildOutput, EngineResult, ServerPackageInfo } from "./types";
+
+const logger = consola.withTag("sd:cli:engine:server");
+
+/**
+ * ServerEsbuildEngine options
+ */
+export interface ServerEsbuildEngineOptions {
+  cwd: string;
+  pkg: ServerPackageInfo;
+  /** ResultCollector for watch mode rebuild reporting */
+  resultCollector?: ResultCollector;
+  /** RebuildManager for watch mode batch coordination */
+  rebuildManager?: RebuildManager;
+}
+
+/**
+ * Esbuild-based build engine for Server packages
+ *
+ * Wraps a single server-build.worker that combines esbuild (JS bundle)
+ * + tsc (typecheck) in one Worker thread.
+ */
+export class ServerEsbuildEngine implements BuildEngine {
+  private readonly _cwd: string;
+  private readonly _pkg: ServerPackageInfo;
+  private readonly _resultCollector: ResultCollector | undefined;
+  private readonly _rebuildManager: RebuildManager | undefined;
+
+  private _worker: WorkerProxy<typeof ServerBuildWorkerModule> | undefined;
+  private _isWatchMode = false;
+
+  constructor(options: ServerEsbuildEngineOptions) {
+    this._cwd = options.cwd;
+    this._pkg = options.pkg;
+    this._resultCollector = options.resultCollector;
+    this._rebuildManager = options.rebuildManager;
+  }
+
+  /**
+   * One-time build (production)
+   */
+  async run(output: BuildOutput): Promise<EngineResult> {
+    this._createWorker();
+
+    const result = await this._worker!.build({
+      name: this._pkg.name,
+      cwd: this._cwd,
+      pkgDir: this._pkg.dir,
+      output,
+      env: this._pkg.config.env,
+      configs: this._pkg.config.configs,
+      externals: this._pkg.config.externals,
+      pm2: this._pkg.config.pm2,
+      packageManager: this._pkg.config.packageManager,
+    });
+
+    return {
+      success: result.js.success && result.dts.success,
+      js: {
+        success: result.js.success,
+        errors: result.js.errors ?? [],
+        warnings: result.js.warnings ?? [],
+      },
+      dts: {
+        success: result.dts.success,
+        errors: result.dts.errors ?? [],
+        warnings: [],
+        diagnostics: result.dts.diagnostics,
+      },
+    };
+  }
+
+  /**
+   * Start watch mode
+   * Promise resolves when initial build completes.
+   */
+  async startWatch(output: BuildOutput): Promise<void> {
+    this._isWatchMode = true;
+    this._createWorker();
+
+    return new Promise<void>((resolve) => {
+      let isInitialBuild = true;
+      const workerKey = `${this._pkg.name}:build`;
+
+      this._worker!.on("buildStart", () => {
+        if (!isInitialBuild && this._rebuildManager != null) {
+          this._rebuildManager.registerBuild(workerKey, `${this._pkg.name} (server)`);
+        }
+      });
+
+      this._worker!.on("build", (data) => {
+        const event = data;
+
+        if (event.js.warnings != null && event.js.warnings.length > 0) {
+          logger.warn(`${this._pkg.name}: ${event.js.warnings.join(", ")}`);
+        }
+
+        // Report JS result
+        const buildResult: BuildResult = {
+          name: this._pkg.name,
+          target: "server",
+          type: "build",
+          status: event.js.success ? "success" : "error",
+          message: event.js.errors?.join("\n"),
+        };
+        this._resultCollector?.add(buildResult);
+
+        // Report DTS result
+        const dtsResult: BuildResult = {
+          name: this._pkg.name,
+          target: "server",
+          type: "dts",
+          status: event.dts.success ? "success" : "error",
+          message: event.dts.errors?.join("\n"),
+        };
+        this._resultCollector?.add(dtsResult);
+
+        if (isInitialBuild) {
+          isInitialBuild = false;
+          resolve();
+        }
+      });
+
+      this._worker!.on("error", (data) => {
+        const event = data as { message: string };
+        const result: BuildResult = {
+          name: this._pkg.name,
+          target: "server",
+          type: "build",
+          status: "error",
+          message: event.message,
+        };
+        this._resultCollector?.add(result);
+
+        if (isInitialBuild) {
+          isInitialBuild = false;
+          resolve();
+        }
+      });
+
+      this._worker!
+        .startWatch({
+          name: this._pkg.name,
+          cwd: this._cwd,
+          pkgDir: this._pkg.dir,
+          output,
+          env: this._pkg.config.env,
+          configs: this._pkg.config.configs,
+          externals: this._pkg.config.externals,
+        })
+        .catch(() => {
+          if (isInitialBuild) {
+            isInitialBuild = false;
+            resolve();
+          }
+        });
+    });
+  }
+
+  /**
+   * Stop engine and clean up resources
+   */
+  async stop(): Promise<void> {
+    const shutdownTimeout = 3000;
+
+    if (this._isWatchMode && this._worker != null) {
+      try {
+        await Promise.race([
+          this._worker.stopWatch(),
+          new Promise<void>((resolve) => setTimeout(resolve, shutdownTimeout)),
+        ]);
+      } catch {
+        // Continue even if stopWatch fails
+      }
+    }
+
+    if (this._worker != null) {
+      await this._worker.terminate();
+      this._worker = undefined;
+    }
+  }
+
+  /**
+   * Create worker instance
+   */
+  private _createWorker(): void {
+    const workerPath = import.meta.resolve("../workers/server-build.worker");
+    this._worker = Worker.create<typeof ServerBuildWorkerModule>(workerPath);
+  }
+}

package/src/engines/TscEngine.ts

@@ -0,0 +1,189 @@
+import { Worker, type WorkerProxy } from "@simplysm/core-node";
+import { consola } from "consola";
+import type * as LibraryBuildWorkerModule from "../workers/library-build.worker";
+import type { BuildResult, ResultCollector } from "../infra/ResultCollector";
+import type { RebuildManager } from "../utils/rebuild-manager";
+import type { BuildEngine, BuildOutput, BuildPackageInfo, EngineResult } from "./types";
+
+const logger = consola.withTag("sd:cli:engine");
+
+/**
+ * TscEngine options
+ */
+export interface TscEngineOptions {
+  cwd: string;
+  pkg: BuildPackageInfo;
+  /** ResultCollector for watch mode rebuild reporting */
+  resultCollector?: ResultCollector;
+  /** RebuildManager for watch mode batch coordination */
+  rebuildManager?: RebuildManager;
+}
+
+/**
+ * tsc-based build engine for Library packages (node/browser/neutral)
+ *
+ * Wraps a single library-build.worker that uses tsc for JS + DTS emit
+ * in one Worker thread.
+ */
+export class TscEngine implements BuildEngine {
+  private readonly _cwd: string;
+  private readonly _pkg: BuildPackageInfo;
+  private readonly _resultCollector: ResultCollector | undefined;
+  private readonly _rebuildManager: RebuildManager | undefined;
+
+  private _worker: WorkerProxy<typeof LibraryBuildWorkerModule> | undefined;
+  private _isWatchMode = false;
+
+  constructor(options: TscEngineOptions) {
+    this._cwd = options.cwd;
+    this._pkg = options.pkg;
+    this._resultCollector = options.resultCollector;
+    this._rebuildManager = options.rebuildManager;
+  }
+
+  /**
+   * One-time build (production)
+   */
+  async run(output: BuildOutput): Promise<EngineResult> {
+    this._createWorker();
+
+    const result = await this._worker!.build({
+      name: this._pkg.name,
+      config: this._pkg.config,
+      cwd: this._cwd,
+      pkgDir: this._pkg.dir,
+      output,
+    });
+
+    return {
+      success: result.js.success && result.dts.success,
+      js: {
+        success: result.js.success,
+        errors: result.js.errors ?? [],
+        warnings: result.js.warnings ?? [],
+      },
+      dts: {
+        success: result.dts.success,
+        errors: result.dts.errors ?? [],
+        warnings: [],
+        diagnostics: result.dts.diagnostics,
+      },
+    };
+  }
+
+  /**
+   * Start watch mode
+   * Promise resolves when initial build completes.
+   */
+  async startWatch(output: BuildOutput): Promise<void> {
+    this._isWatchMode = true;
+    this._createWorker();
+
+    return new Promise<void>((resolve) => {
+      let isInitialBuild = true;
+      const workerKey = `${this._pkg.name}:build`;
+
+      this._worker!.on("buildStart", () => {
+        if (!isInitialBuild && this._rebuildManager != null) {
+          this._rebuildManager.registerBuild(workerKey, `${this._pkg.name} (${this._pkg.config.target})`);
+        }
+      });
+
+      this._worker!.on("build", (data) => {
+        const event = data;
+
+        if (event.js.warnings != null && event.js.warnings.length > 0) {
+          logger.warn(`${this._pkg.name}: ${event.js.warnings.join(", ")}`);
+        }
+
+        // Report JS result
+        const buildResult: BuildResult = {
+          name: this._pkg.name,
+          target: this._pkg.config.target,
+          type: "build",
+          status: event.js.success ? "success" : "error",
+          message: event.js.errors?.join("\n"),
+        };
+        this._resultCollector?.add(buildResult);
+
+        // Report DTS result
+        const dtsResult: BuildResult = {
+          name: this._pkg.name,
+          target: this._pkg.config.target,
+          type: "dts",
+          status: event.dts.success ? "success" : "error",
+          message: event.dts.errors?.join("\n"),
+        };
+        this._resultCollector?.add(dtsResult);
+
+        if (isInitialBuild) {
+          isInitialBuild = false;
+          resolve();
+        }
+      });
+
+      this._worker!.on("error", (data) => {
+        const event = data as { message: string };
+        const result: BuildResult = {
+          name: this._pkg.name,
+          target: this._pkg.config.target,
+          type: "build",
+          status: "error",
+          message: event.message,
+        };
+        this._resultCollector?.add(result);
+
+        if (isInitialBuild) {
+          isInitialBuild = false;
+          resolve();
+        }
+      });
+
+      this._worker!
+        .startWatch({
+          name: this._pkg.name,
+          config: this._pkg.config,
+          cwd: this._cwd,
+          pkgDir: this._pkg.dir,
+          output,
+        })
+        .catch(() => {
+          if (isInitialBuild) {
+            isInitialBuild = false;
+            resolve();
+          }
+        });
+    });
+  }
+
+  /**
+   * Stop engine and clean up resources
+   */
+  async stop(): Promise<void> {
+    const shutdownTimeout = 3000;
+
+    if (this._isWatchMode && this._worker != null) {
+      try {
+        await Promise.race([
+          this._worker.stopWatch(),
+          new Promise<void>((resolve) => setTimeout(resolve, shutdownTimeout)),
+        ]);
+      } catch {
+        // Continue even if stopWatch fails
+      }
+    }
+
+    if (this._worker != null) {
+      await this._worker.terminate();
+      this._worker = undefined;
+    }
+  }
+
+  /**
+   * Create worker instance
+   */
+  private _createWorker(): void {
+    const workerPath = import.meta.resolve("../workers/library-build.worker");
+    this._worker = Worker.create<typeof LibraryBuildWorkerModule>(workerPath);
+  }
+}

package/src/engines/ViteEngine.ts

@@ -0,0 +1,203 @@
+import { Worker, type WorkerProxy } from "@simplysm/core-node";
+import { consola } from "consola";
+import type * as ViteBuildWorkerModule from "../workers/vite-build.worker";
+import type { BuildResult, ResultCollector } from "../infra/ResultCollector";
+import type { RebuildManager } from "../utils/rebuild-manager";
+import type { BuildEngine, BuildOutput, ClientPackageInfo, EngineResult } from "./types";
+
+const logger = consola.withTag("sd:cli:engine:vite");
+
+/**
+ * ViteEngine options
+ */
+export interface ViteEngineOptions {
+  cwd: string;
+  pkg: ClientPackageInfo;
+  /** ResultCollector for watch mode rebuild reporting */
+  resultCollector?: ResultCollector;
+  /** RebuildManager for watch mode batch coordination */
+  rebuildManager?: RebuildManager;
+}
+
+/**
+ * Vite-based build engine for Angular Client packages
+ *
+ * Wraps a single vite-build.worker that uses Angular's buildApplicationInternal
+ * for production builds and serveWithVite for dev server.
+ */
+export class ViteEngine implements BuildEngine {
+  private readonly _cwd: string;
+  private readonly _pkg: ClientPackageInfo;
+  private readonly _resultCollector: ResultCollector | undefined;
+  private readonly _rebuildManager: RebuildManager | undefined;
+
+  private _worker: WorkerProxy<typeof ViteBuildWorkerModule> | undefined;
+  private _isWatchMode = false;
+
+  /** Dev server port (populated by serverReady event in watch mode) */
+  port: number | undefined;
+
+  constructor(options: ViteEngineOptions) {
+    this._cwd = options.cwd;
+    this._pkg = options.pkg;
+    this._resultCollector = options.resultCollector;
+    this._rebuildManager = options.rebuildManager;
+  }
+
+  /**
+   * One-time build (production)
+   */
+  async run(output: BuildOutput): Promise<EngineResult> {
+    this._createWorker();
+
+    const result = await this._worker!.build({
+      name: this._pkg.name,
+      cwd: this._cwd,
+      pkgDir: this._pkg.dir,
+      output,
+    });
+
+    return {
+      success: result.js.success,
+      js: {
+        success: result.js.success,
+        errors: result.js.errors ?? [],
+        warnings: result.js.warnings ?? [],
+      },
+      dts: {
+        success: result.dts.success,
+        errors: result.dts.errors ?? [],
+        warnings: [],
+        diagnostics: result.dts.diagnostics,
+      },
+    };
+  }
+
+  /**
+   * Start watch mode (Vite dev server)
+   * Promise resolves when initial build completes.
+   */
+  async startWatch(output: BuildOutput): Promise<void> {
+    this._isWatchMode = true;
+    this._createWorker();
+
+    return new Promise<void>((resolve) => {
+      let isInitialBuild = true;
+      const workerKey = `${this._pkg.name}:build`;
+
+      this._worker!.on("buildStart", () => {
+        if (!isInitialBuild && this._rebuildManager != null) {
+          this._rebuildManager.registerBuild(
+            workerKey,
+            `${this._pkg.name} (client)`,
+          );
+        }
+      });
+
+      this._worker!.on("build", (data) => {
+        const event = data;
+
+        if (event.js.warnings != null && event.js.warnings.length > 0) {
+          logger.warn(`${this._pkg.name}: ${event.js.warnings.join(", ")}`);
+        }
+
+        // Report JS result
+        const buildResult: BuildResult = {
+          name: this._pkg.name,
+          target: "client",
+          type: "build",
+          status: event.js.success ? "success" : "error",
+          message: event.js.errors?.join("\n"),
+        };
+        this._resultCollector?.add(buildResult);
+
+        // Report DTS result (always success for client)
+        const dtsResult: BuildResult = {
+          name: this._pkg.name,
+          target: "client",
+          type: "dts",
+          status: event.dts.success ? "success" : "error",
+          message: event.dts.errors?.join("\n"),
+        };
+        this._resultCollector?.add(dtsResult);
+
+        if (isInitialBuild) {
+          isInitialBuild = false;
+          resolve();
+        }
+      });
+
+      this._worker!.on("error", (data) => {
+        const event = data as { message: string };
+        const result: BuildResult = {
+          name: this._pkg.name,
+          target: "client",
+          type: "build",
+          status: "error",
+          message: event.message,
+        };
+        this._resultCollector?.add(result);
+
+        if (isInitialBuild) {
+          isInitialBuild = false;
+          resolve();
+        }
+      });
+
+      this._worker!.on("serverReady", (data) => {
+        const event = data as { port: number };
+        this.port = event.port;
+      });
+
+      const port = typeof this._pkg.config.server === "number"
+        ? this._pkg.config.server
+        : undefined;
+
+      this._worker!
+        .startWatch({
+          name: this._pkg.name,
+          cwd: this._cwd,
+          pkgDir: this._pkg.dir,
+          output,
+          port,
+        })
+        .catch(() => {
+          if (isInitialBuild) {
+            isInitialBuild = false;
+            resolve();
+          }
+        });
+    });
+  }
+
+  /**
+   * Stop engine and clean up resources
+   */
+  async stop(): Promise<void> {
+    const shutdownTimeout = 3000;
+
+    if (this._isWatchMode && this._worker != null) {
+      try {
+        await Promise.race([
+          this._worker.stopWatch(),
+          new Promise<void>((resolve) => setTimeout(resolve, shutdownTimeout)),
+        ]);
+      } catch {
+        // Continue even if stopWatch fails
+      }
+    }
+
+    if (this._worker != null) {
+      await this._worker.terminate();
+      this._worker = undefined;
+    }
+  }
+
+  /**
+   * Create worker instance
+   */
+  private _createWorker(): void {
+    const workerPath = import.meta.resolve("../workers/vite-build.worker");
+    this._worker = Worker.create<typeof ViteBuildWorkerModule>(workerPath);
+  }
+}

package/src/engines/index.ts

@@ -0,0 +1,49 @@
+import type { ResultCollector } from "../infra/ResultCollector";
+import type { RebuildManager } from "../utils/rebuild-manager";
+import { hasAngularCompilerOptions } from "../utils/tsconfig";
+import { NgtscEngine } from "./NgtscEngine";
+import { ServerEsbuildEngine } from "./ServerEsbuildEngine";
+import { TscEngine } from "./TscEngine";
+import { ViteEngine } from "./ViteEngine";
+import type { BuildEngine, BuildPackageInfo, ClientPackageInfo, ServerPackageInfo } from "./types";
+
+export { NgtscEngine } from "./NgtscEngine";
+export type { NgtscEngineOptions } from "./NgtscEngine";
+export { ServerEsbuildEngine } from "./ServerEsbuildEngine";
+export type { ServerEsbuildEngineOptions } from "./ServerEsbuildEngine";
+export { TscEngine } from "./TscEngine";
+export type { TscEngineOptions } from "./TscEngine";
+export { ViteEngine } from "./ViteEngine";
+export type { ViteEngineOptions } from "./ViteEngine";
+export type { BuildEngine, BuildOutput, BuildPackageInfo, ClientPackageInfo, EngineResult, PackageInfo, ServerPackageInfo } from "./types";
+
+/**
+ * Create a BuildEngine for the given package.
+ *
+ * Client packages use ViteEngine (Angular buildApplicationInternal / serveWithVite).
+ * Server packages use ServerEsbuildEngine.
+ * Angular Library packages (detected by angularCompilerOptions in tsconfig.json) use NgtscEngine.
+ * Other Library packages (node/browser/neutral) use TscEngine.
+ */
+export function createBuildEngine(
+  pkg: BuildPackageInfo | ServerPackageInfo | ClientPackageInfo,
+  options: {
+    cwd: string;
+    resultCollector?: ResultCollector;
+    rebuildManager?: RebuildManager;
+  },
+): BuildEngine {
+  if (pkg.config.target === "client") {
+    return new ViteEngine({ ...options, pkg: pkg as ClientPackageInfo });
+  }
+
+  if (pkg.config.target === "server") {
+    return new ServerEsbuildEngine({ ...options, pkg: pkg as ServerPackageInfo });
+  }
+
+  if (hasAngularCompilerOptions(pkg.dir)) {
+    return new NgtscEngine({ ...options, pkg: pkg as BuildPackageInfo });
+  }
+
+  return new TscEngine({ ...options, pkg: pkg as BuildPackageInfo });
+}

package/src/engines/types.ts

@@ -0,0 +1,79 @@
+import type { SdBuildPackageConfig, SdClientPackageConfig, SdPackageConfig, SdServerPackageConfig } from "../sd-config.types";
+import type { SerializedDiagnostic } from "../utils/typecheck-serialization";
+
+/**
+ * Package information
+ */
+export interface PackageInfo {
+  name: string;
+  dir: string;
+  config: SdPackageConfig;
+}
+
+/**
+ * PackageInfo narrowed for build packages (node/browser/neutral)
+ */
+export type BuildPackageInfo = PackageInfo & { config: SdBuildPackageConfig };
+
+/**
+ * PackageInfo narrowed for server packages
+ */
+export type ServerPackageInfo = PackageInfo & { config: SdServerPackageConfig };
+
+/**
+ * PackageInfo narrowed for client packages
+ */
+export type ClientPackageInfo = PackageInfo & { config: SdClientPackageConfig };
+
+/**
+ * Build output control flags
+ */
+export interface BuildOutput {
+  js: boolean;
+  dts: boolean;
+}
+
+/**
+ * BuildEngine.run() return value
+ */
+export interface EngineResult {
+  success: boolean;
+  js: {
+    success: boolean;
+    errors: string[];
+    warnings: string[];
+  };
+  dts: {
+    success: boolean;
+    errors: string[];
+    warnings: string[];
+    diagnostics: SerializedDiagnostic[];
+  };
+}
+
+/**
+ * Build engine interface
+ *
+ * Common contract for all build engines.
+ * typecheck (diagnostics) is always included — not optional.
+ */
+export interface BuildEngine {
+  /**
+   * One-time build (for production builds)
+   * Creates workers, runs build, returns combined result.
+   * Call stop() after to clean up resources.
+   */
+  run(output: BuildOutput): Promise<EngineResult>;
+
+  /**
+   * Start watch mode
+   * Promise resolves when initial build is complete.
+   * Subsequent rebuilds are reported via injected ResultCollector.
+   */
+  startWatch(output: BuildOutput): Promise<void>;
+
+  /**
+   * Stop engine and clean up resources (workers, esbuild contexts)
+   */
+  stop(): Promise<void>;
+}