@teardown/cli 1.2.39 → 2.0.42

package/src/pipeline/stages.ts

@@ -0,0 +1,692 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { loadConfig, validateConfig } from "../config";
+import type { FileChange, PrebuildError, PrebuildOptions, PrebuildWarning, ProcessedAppConfig } from "../config/types";
+import type { BasePlugin, PluginConstructor } from "../plugins/base";
+import { createPluginContext, type PluginContext } from "../plugins/context";
+import { DependencyResolver } from "../plugins/resolver";
+import { TemplateGenerator } from "../templates";
+import { GradleTransformer } from "../transformers/android/gradle";
+import { AndroidManifestTransformer } from "../transformers/android/manifest";
+import { EntitlementsTransformer } from "../transformers/ios/entitlements";
+import { PbxprojTransformer } from "../transformers/ios/pbxproj";
+import { PlistTransformer } from "../transformers/ios/plist";
+import { createVirtualFileSystem } from "../utils/fs";
+import { createLogger, type Logger } from "../utils/logger";
+import { IncrementalBuildCache } from "./cache";
+
+/**
+ * Pipeline stage interface
+ */
+export interface PipelineStage {
+	name: string;
+	execute(context: PipelineContext): Promise<void>;
+}
+
+/**
+ * Pipeline execution context
+ */
+export interface PipelineContext {
+	config: ProcessedAppConfig;
+	pluginContext: PluginContext;
+	options: PrebuildOptions;
+	logger: Logger;
+	resolver: DependencyResolver;
+}
+
+/**
+ * Pipeline result
+ */
+export interface PipelineResult {
+	success: boolean;
+	config?: ProcessedAppConfig;
+	changes?: FileChange[];
+	warnings: PrebuildWarning[];
+	errors: PrebuildError[];
+	duration: number;
+}
+
+/**
+ * Main prebuild pipeline
+ */
+export class Pipeline {
+	private stages: PipelineStage[] = [];
+	private resolver: DependencyResolver;
+	private logger: Logger;
+	private cache: IncrementalBuildCache;
+
+	constructor(options: { logger?: Logger } = {}) {
+		this.logger = options.logger ?? createLogger({ prefix: "pipeline" });
+		this.resolver = new DependencyResolver(this.logger);
+		this.cache = new IncrementalBuildCache(this.logger);
+
+		// Initialize default stages
+		this.stages = [
+			new ConfigValidationStage(),
+			new PluginResolutionStage(),
+			new TemplateGenerationStage(),
+			new PluginPreProcessStage(),
+			new PluginTransformStage(),
+			new PluginPostProcessStage(),
+			new iOSGenerationStage(),
+			new IOSPostInstallStage(),
+			new AndroidGenerationStage(),
+		];
+	}
+
+	/**
+	 * Register a plugin with configuration
+	 */
+	registerPlugin<TConfig>(plugin: BasePlugin<TConfig>, config?: TConfig): this {
+		this.resolver.registerPlugin(plugin, config);
+		return this;
+	}
+
+	/**
+	 * Register a plugin from constructor
+	 */
+	registerPluginFromConstructor<TConfig>(Constructor: PluginConstructor<TConfig>, config?: TConfig): this {
+		this.resolver.registerPluginFromConstructor(Constructor, config);
+		return this;
+	}
+
+	/**
+	 * Add a custom stage to the pipeline
+	 */
+	addStage(stage: PipelineStage): this {
+		this.stages.push(stage);
+		return this;
+	}
+
+	/**
+	 * Execute the pipeline
+	 */
+	async execute(options: PrebuildOptions): Promise<PipelineResult> {
+		const startTime = Date.now();
+		const warnings: PrebuildWarning[] = [];
+		const errors: PrebuildError[] = [];
+
+		const projectRoot = options.projectRoot ?? process.cwd();
+
+		this.logger.info("Starting prebuild pipeline...");
+
+		try {
+			// Load configuration
+			const configResult = await loadConfig(projectRoot);
+
+			if (!configResult.success || !configResult.config) {
+				return {
+					success: false,
+					warnings,
+					errors: configResult.errors?.map((e) => ({
+						code: "CONFIG_ERROR",
+						message: e.message,
+					})) ?? [{ code: "CONFIG_ERROR", message: "Failed to load configuration" }],
+					duration: Date.now() - startTime,
+				};
+			}
+
+			// Check cache for incremental build
+			if (!options.clean && (await this.cache.shouldSkip(configResult.config, projectRoot))) {
+				this.logger.info("No changes detected, skipping prebuild");
+				return {
+					success: true,
+					warnings,
+					errors,
+					duration: Date.now() - startTime,
+				};
+			}
+
+			// Create virtual file system
+			const fs = createVirtualFileSystem({
+				dryRun: options.dryRun ?? false,
+				projectRoot,
+			});
+
+			// Create plugin context
+			const pluginContext = createPluginContext({
+				projectRoot,
+				platform: options.platform === "all" ? "both" : options.platform,
+				config: configResult.config,
+				fs,
+				log: this.logger,
+				isDryRun: options.dryRun ?? false,
+				isVerbose: options.verbose ?? false,
+			});
+
+			// Create pipeline context
+			const pipelineContext: PipelineContext = {
+				config: pluginContext.config,
+				pluginContext,
+				options,
+				logger: this.logger,
+				resolver: this.resolver,
+			};
+
+			// Execute stages
+			for (const stage of this.stages) {
+				// Skip platform-specific stages if not targeting that platform
+				if (stage.name === "ios-generation" && options.platform === "android") {
+					continue;
+				}
+				if (stage.name === "ios-postinstall" && options.platform === "android") {
+					continue;
+				}
+				if (stage.name === "android-generation" && options.platform === "ios") {
+					continue;
+				}
+
+				this.logger.debug(`Executing stage: ${stage.name}`);
+
+				try {
+					await stage.execute(pipelineContext);
+				} catch (error) {
+					errors.push({
+						code: "STAGE_ERROR",
+						message: `Stage "${stage.name}" failed: ${error instanceof Error ? error.message : String(error)}`,
+						stack: error instanceof Error ? error.stack : undefined,
+					});
+
+					return {
+						success: false,
+						config: pipelineContext.config,
+						changes: fs.getChanges(),
+						warnings: [...warnings, ...pluginContext.getWarnings()],
+						errors,
+						duration: Date.now() - startTime,
+					};
+				}
+			}
+
+			// Get final changes
+			const changes = fs.getChanges();
+
+			// Update cache
+			if (!options.dryRun) {
+				await this.cache.update(
+					configResult.config,
+					projectRoot,
+					changes.map((c) => c.path)
+				);
+			}
+
+			this.logger.success(`Prebuild completed in ${Date.now() - startTime}ms`);
+
+			return {
+				success: true,
+				config: pipelineContext.config,
+				changes,
+				warnings: [...warnings, ...pluginContext.getWarnings()],
+				errors,
+				duration: Date.now() - startTime,
+			};
+		} catch (error) {
+			errors.push({
+				code: "PIPELINE_ERROR",
+				message: error instanceof Error ? error.message : String(error),
+				stack: error instanceof Error ? error.stack : undefined,
+			});
+
+			return {
+				success: false,
+				warnings,
+				errors,
+				duration: Date.now() - startTime,
+			};
+		}
+	}
+
+	/**
+	 * Get the dependency resolver
+	 */
+	getResolver(): DependencyResolver {
+		return this.resolver;
+	}
+
+	/**
+	 * Clear the build cache
+	 */
+	async clearCache(projectRoot: string): Promise<void> {
+		await this.cache.clear(projectRoot);
+	}
+}
+
+/**
+ * Stage 1: Config Validation
+ */
+class ConfigValidationStage implements PipelineStage {
+	name = "config-validation";
+
+	async execute(context: PipelineContext): Promise<void> {
+		const { logger, options } = context;
+
+		if (options.skipValidation) {
+			logger.debug("Skipping config validation");
+			return;
+		}
+
+		logger.debug("Validating configuration...");
+
+		const validation = validateConfig(context.config);
+
+		if (!validation.success) {
+			const errorMessages = validation.errors?.map((e) => e.message).join(", ");
+			throw new Error(`Configuration validation failed: ${errorMessages}`);
+		}
+	}
+}
+
+/**
+ * Stage 2: Plugin Resolution
+ */
+class PluginResolutionStage implements PipelineStage {
+	name = "plugin-resolution";
+
+	async execute(context: PipelineContext): Promise<void> {
+		const { logger, resolver } = context;
+
+		logger.debug("Resolving plugin dependencies...");
+
+		// Validate all plugin configurations
+		const validationErrors = resolver.validateAllConfigs();
+		if (validationErrors.length > 0) {
+			const messages = validationErrors.map((e) => `${e.plugin}: ${e.error}`);
+			throw new Error(`Plugin configuration errors: ${messages.join("; ")}`);
+		}
+
+		// Resolve execution order (this will throw if there are cycles or missing deps)
+		const orderedPlugins = resolver.resolveOrder();
+		logger.debug(`Plugin execution order: ${orderedPlugins.map((p) => p.name).join(" -> ")}`);
+	}
+}
+
+/**
+ * Stage 3: Template Generation
+ *
+ * Generates native iOS and Android project files from templates
+ * if they don't already exist.
+ */
+class TemplateGenerationStage implements PipelineStage {
+	name = "template-generation";
+
+	async execute(context: PipelineContext): Promise<void> {
+		const { logger, config, options } = context;
+
+		logger.debug("Checking if native projects need to be generated...");
+
+		const projectRoot = options.projectRoot ?? process.cwd();
+
+		// Create template variables from config
+		const variables = {
+			// Common
+			slug: config.slug,
+
+			// iOS
+			appName: config.name,
+			bundleIdentifier:
+				config.ios?.bundleIdentifier ?? `com.example.${config.name.toLowerCase().replace(/[^a-z0-9]/g, "")}`,
+			version: config.version ?? "1.0.0",
+			buildNumber: config.ios?.buildNumber ?? 1,
+
+			// Android
+			packageName: config.android?.packageName ?? `com.example.${config.name.toLowerCase().replace(/[^a-z0-9]/g, "")}`,
+			versionCode: config.android?.versionCode ?? 1,
+			versionName: config.version ?? "1.0.0",
+		};
+
+		const generator = new TemplateGenerator({
+			projectRoot,
+			variables,
+			logger,
+			dryRun: options.dryRun ?? false,
+			force: false, // Don't overwrite existing files
+		});
+
+		// Check if we should generate iOS
+		const shouldGenerateiOS = options.platform !== "android";
+		const shouldGenerateAndroid = options.platform !== "ios";
+
+		if (shouldGenerateiOS) {
+			const iosExists = await generator.iosProjectExists();
+			if (!iosExists) {
+				logger.info("iOS project not found, generating from template...");
+				const result = await generator.generateiOS();
+				if (result.success) {
+					logger.success(`Generated iOS project (${result.filesCreated.length} files)`);
+				} else {
+					logger.warn(`iOS generation had errors: ${result.errors.join(", ")}`);
+				}
+			} else {
+				logger.debug("iOS project already exists, skipping template generation");
+			}
+		}
+
+		if (shouldGenerateAndroid) {
+			const androidExists = await generator.androidProjectExists();
+			if (!androidExists) {
+				logger.info("Android project not found, generating from template...");
+				const result = await generator.generateAndroid();
+				if (result.success) {
+					logger.success(`Generated Android project (${result.filesCreated.length} files)`);
+				} else {
+					logger.warn(`Android generation had errors: ${result.errors.join(", ")}`);
+				}
+			} else {
+				logger.debug("Android project already exists, skipping template generation");
+			}
+		}
+
+		// Generate package.json if it doesn't exist
+		const packageExists = await generator.packageJsonExists();
+		if (!packageExists) {
+			logger.info("package.json not found, generating from template...");
+			const result = await generator.generatePackageJson();
+			if (result.success && result.filesCreated.length > 0) {
+				logger.success("Generated package.json");
+			} else if (result.errors.length > 0) {
+				logger.warn(`package.json generation had errors: ${result.errors.join(", ")}`);
+			}
+		}
+
+		// Generate src folder if it doesn't exist
+		const srcExists = await generator.srcFolderExists();
+		if (!srcExists) {
+			logger.info("src/ folder not found, generating from template...");
+			const result = await generator.generateSrcFolder();
+			if (result.success) {
+				logger.success(`Generated src/ folder (${result.filesCreated.length} files)`);
+			} else {
+				logger.warn(`src/ generation had errors: ${result.errors.join(", ")}`);
+			}
+		}
+
+		// Generate root config files if they don't exist
+		const configResult = await generator.generateRootConfigFiles();
+		if (configResult.filesCreated.length > 0) {
+			logger.success(`Generated config files: ${configResult.filesCreated.map((f) => f.split("/").pop()).join(", ")}`);
+		}
+	}
+}
+
+/**
+ * Stage 4: Plugin Pre-Process
+ */
+class PluginPreProcessStage implements PipelineStage {
+	name = "plugin-preprocess";
+
+	async execute(context: PipelineContext): Promise<void> {
+		const { logger, resolver, pluginContext, options } = context;
+
+		logger.debug("Running plugin pre-process hooks...");
+
+		const plugins = resolver.resolveOrder();
+
+		for (const plugin of plugins) {
+			// Skip plugins that don't support the target platform
+			if (options.platform !== "all") {
+				if (!plugin.supportsPlatform(options.platform)) {
+					logger.debug(`Skipping ${plugin.name} (doesn't support ${options.platform})`);
+					continue;
+				}
+			}
+
+			logger.debug(`Pre-processing: ${plugin.name}`);
+			await plugin.preProcess(pluginContext);
+
+			// Register capabilities
+			for (const capability of plugin.provides) {
+				pluginContext.registerCapability(capability);
+			}
+		}
+	}
+}
+
+/**
+ * Stage 4: Plugin Transform
+ */
+class PluginTransformStage implements PipelineStage {
+	name = "plugin-transform";
+
+	async execute(context: PipelineContext): Promise<void> {
+		const { logger, resolver, pluginContext, options } = context;
+
+		logger.debug("Running plugin transformations...");
+
+		const plugins = resolver.resolveOrder();
+
+		for (const plugin of plugins) {
+			// Skip plugins that don't support the target platform
+			if (options.platform !== "all") {
+				if (!plugin.supportsPlatform(options.platform)) {
+					continue;
+				}
+			}
+
+			const pluginConfig = resolver.getPluginConfig(plugin.name);
+			logger.debug(`Transforming: ${plugin.name}`);
+
+			context.config = plugin.transform(context.config, pluginConfig, pluginContext);
+			pluginContext.config = context.config;
+		}
+	}
+}
+
+/**
+ * Stage 5: Plugin Post-Process
+ */
+class PluginPostProcessStage implements PipelineStage {
+	name = "plugin-postprocess";
+
+	async execute(context: PipelineContext): Promise<void> {
+		const { logger, resolver, pluginContext, options } = context;
+
+		logger.debug("Running plugin post-process hooks...");
+
+		const plugins = resolver.resolveOrder();
+
+		for (const plugin of plugins) {
+			// Skip plugins that don't support the target platform
+			if (options.platform !== "all") {
+				if (!plugin.supportsPlatform(options.platform)) {
+					continue;
+				}
+			}
+
+			logger.debug(`Post-processing: ${plugin.name}`);
+			await plugin.postProcess(pluginContext);
+		}
+	}
+}
+
+/**
+ * Stage 6: iOS Generation
+ */
+class iOSGenerationStage implements PipelineStage {
+	name = "ios-generation";
+
+	async execute(context: PipelineContext): Promise<void> {
+		const { logger, pluginContext, config } = context;
+
+		logger.debug("Generating iOS native files...");
+
+		// Transform Info.plist
+		const plistTransformer = new PlistTransformer();
+		await plistTransformer.transform(pluginContext, config);
+
+		// Transform entitlements
+		const entitlementsTransformer = new EntitlementsTransformer();
+		await entitlementsTransformer.transform(pluginContext, config);
+
+		// Transform pbxproj (Xcode project)
+		const pbxprojTransformer = new PbxprojTransformer();
+		await pbxprojTransformer.transform(pluginContext, config);
+
+		logger.debug("iOS generation complete");
+	}
+}
+
+/**
+ * Stage 7: iOS Post-Install
+ *
+ * Runs `pod install` after iOS project generation to install CocoaPods dependencies
+ * and create the Xcode workspace with proper schemes.
+ */
+class IOSPostInstallStage implements PipelineStage {
+	name = "ios-postinstall";
+
+	async execute(context: PipelineContext): Promise<void> {
+		const { logger, options } = context;
+
+		// Skip in dry-run mode
+		if (options.dryRun) {
+			logger.debug("Skipping pod install (dry-run mode)");
+			return;
+		}
+
+		const projectRoot = options.projectRoot ?? process.cwd();
+		const iosDir = join(projectRoot, "ios");
+		const podfilePath = join(iosDir, "Podfile");
+		const podfileLockPath = join(iosDir, "Podfile.lock");
+
+		// Check if Podfile exists
+		if (!existsSync(podfilePath)) {
+			logger.debug("No Podfile found, skipping pod install");
+			return;
+		}
+
+		// Check if pod command is available
+		const podAvailable = await this.isPodAvailable();
+		if (!podAvailable) {
+			logger.warn("CocoaPods not installed. Run 'pod install' manually in the ios/ directory.");
+			return;
+		}
+
+		// Use --repo-update for fresh installs (no Podfile.lock)
+		const isFreshInstall = !existsSync(podfileLockPath);
+		if (isFreshInstall) {
+			logger.info("Installing CocoaPods dependencies (first time, updating repos)...");
+		} else {
+			logger.info("Installing CocoaPods dependencies...");
+		}
+
+		try {
+			await this.runPodInstall(iosDir, logger, isFreshInstall);
+			logger.success("CocoaPods dependencies installed");
+		} catch (error) {
+			// Surface the error clearly - this is important for debugging
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			logger.error(`pod install failed: ${errorMessage}`);
+			logger.error("To fix this, try running manually:");
+			logger.error("  cd ios && pod install --repo-update");
+			// Don't fail the pipeline, but make it very visible
+		}
+	}
+
+	/**
+	 * Check if CocoaPods is installed
+	 */
+	private async isPodAvailable(): Promise<boolean> {
+		return new Promise((resolve) => {
+			const child = spawn("which", ["pod"], {
+				stdio: ["ignore", "pipe", "pipe"],
+			});
+
+			child.on("close", (code) => {
+				resolve(code === 0);
+			});
+
+			child.on("error", () => {
+				resolve(false);
+			});
+		});
+	}
+
+	/**
+	 * Run pod install in the iOS directory
+	 */
+	private async runPodInstall(iosDir: string, logger: Logger, repoUpdate = false): Promise<void> {
+		return new Promise((resolve, reject) => {
+			// Use --repo-update for fresh installs to ensure specs are up to date
+			const args = repoUpdate ? ["install", "--repo-update"] : ["install"];
+
+			const child = spawn("pod", args, {
+				cwd: iosDir,
+				stdio: ["ignore", "pipe", "pipe"],
+				env: {
+					...process.env,
+					// Required for CocoaPods UTF-8 support
+					LANG: "en_US.UTF-8",
+					LC_ALL: "en_US.UTF-8",
+				},
+			});
+
+			let stdout = "";
+			let stderr = "";
+
+			child.stdout?.on("data", (data) => {
+				stdout += data.toString();
+				// Log progress for verbose output
+				const lines = data.toString().split("\n");
+				for (const line of lines) {
+					if (line.trim()) {
+						logger.debug(`[pod] ${line.trim()}`);
+					}
+				}
+			});
+
+			child.stderr?.on("data", (data) => {
+				stderr += data.toString();
+				// Also log stderr for visibility
+				const lines = data.toString().split("\n");
+				for (const line of lines) {
+					if (line.trim()) {
+						logger.debug(`[pod:err] ${line.trim()}`);
+					}
+				}
+			});
+
+			child.on("close", (code) => {
+				if (code === 0) {
+					resolve();
+				} else {
+					reject(new Error(`pod install exited with code ${code}: ${stderr || stdout}`));
+				}
+			});
+
+			child.on("error", (err) => {
+				reject(err);
+			});
+		});
+	}
+}
+
+/**
+ * Stage 8: Android Generation
+ */
+class AndroidGenerationStage implements PipelineStage {
+	name = "android-generation";
+
+	async execute(context: PipelineContext): Promise<void> {
+		const { logger, pluginContext, config } = context;
+
+		logger.debug("Generating Android native files...");
+
+		// Transform AndroidManifest.xml
+		const manifestTransformer = new AndroidManifestTransformer();
+		await manifestTransformer.transform(pluginContext, config);
+
+		// Transform build.gradle
+		const gradleTransformer = new GradleTransformer();
+		await gradleTransformer.transform(pluginContext, config);
+
+		logger.debug("Android generation complete");
+	}
+}
+
+/**
+ * Create a new pipeline instance
+ */
+export function createPipeline(options?: { logger?: Logger }): Pipeline {
+	return new Pipeline(options);
+}