@sfdc-webapps/cli 1.0.2

package/src/commands/apply-patches.ts

@@ -0,0 +1,594 @@
+import { cpSync, existsSync, rmSync, readdirSync, statSync, mkdirSync, unlinkSync } from 'fs';
+import { join, relative, basename, dirname, isAbsolute } from 'path';
+import { tmpdir } from 'os';
+import { randomBytes } from 'crypto';
+import { validateAndResolveFeaturePath, validateAndResolveAppPath, getWebApplicationPath } from '../utils/validation.js';
+import { resolveDependencies, type ResolvedFeature } from '../core/dependency-resolver.js';
+import { applyFile, deleteFile, prependToFile, appendToFile } from '../core/file-operations.js';
+import { mergePackageJson } from '../core/package-json-merger.js';
+import { getMonorepoRoot, translatePathToBaseApp, translatePathToTargetApp } from '../utils/paths.js';
+import { getEffectivePathMappings, applyPathMappings } from '../utils/path-mappings.js';
+import * as logger from '../utils/logger.js';
+
+/**
+ * Recursively discover all files in a directory
+ */
+function discoverFiles(dir: string, baseDir: string = dir): string[] {
+  const files: string[] = [];
+  const entries = readdirSync(dir);
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    const stat = statSync(fullPath);
+
+    if (stat.isDirectory()) {
+      files.push(...discoverFiles(fullPath, baseDir));
+    } else if (stat.isFile()) {
+      // Get relative path from baseDir
+      files.push(relative(baseDir, fullPath));
+    }
+  }
+
+  return files;
+}
+
+const DELETE_PREFIX = '__delete__';
+const INHERIT_PREFIX = '__inherit__';
+const PREPEND_PREFIX = '__prepend__';
+const APPEND_PREFIX = '__append__';
+
+/**
+ * Check if a path component has the delete prefix and return the actual path
+ * Returns null if no delete prefix is found, otherwise returns the actual path
+ *
+ * Examples:
+ * - "src/__delete__routes.tsx" -> "src/routes.tsx"
+ * - "src/__delete__pages" -> "src/pages"
+ * - "__delete__src/routes.tsx" -> "src/routes.tsx"
+ * - "src/routes.tsx" -> null (no prefix)
+ */
+function extractDeletePath(relativePath: string): string | null {
+  const parts = relativePath.split('/');
+  let hasDeletePrefix = false;
+
+  const transformedParts = parts.map(part => {
+    if (part.startsWith(DELETE_PREFIX)) {
+      hasDeletePrefix = true;
+      return part.substring(DELETE_PREFIX.length);
+    }
+    return part;
+  });
+
+  return hasDeletePrefix ? transformedParts.join('/') : null;
+}
+
+/**
+ * Check if a path component has the inherit prefix and return the actual path
+ * Returns null if no inherit prefix is found, otherwise returns the actual path
+ *
+ * Examples:
+ * - "src/__inherit__routes.tsx" -> "src/routes.tsx"
+ * - "__inherit__src/routes.tsx" -> "src/routes.tsx"
+ * - "src/routes.tsx" -> null (no prefix)
+ */
+function extractInheritPath(relativePath: string): string | null {
+  const parts = relativePath.split('/');
+  let hasInheritPrefix = false;
+
+  const transformedParts = parts.map(part => {
+    if (part.startsWith(INHERIT_PREFIX)) {
+      hasInheritPrefix = true;
+      return part.substring(INHERIT_PREFIX.length);
+    }
+    return part;
+  });
+
+  return hasInheritPrefix ? transformedParts.join('/') : null;
+}
+
+/**
+ * Check if a path component has the prepend prefix and return the actual path
+ * Returns null if no prepend prefix is found, otherwise returns the actual path
+ *
+ * Examples:
+ * - "src/styles/__prepend__global.css" -> "src/styles/global.css"
+ * - "__prepend__file.txt" -> "file.txt"
+ * - "src/file.tsx" -> null (no prefix)
+ */
+function extractPrependPath(relativePath: string): string | null {
+  const parts = relativePath.split('/');
+  let hasPrependPrefix = false;
+
+  const transformedParts = parts.map(part => {
+    if (part.startsWith(PREPEND_PREFIX)) {
+      hasPrependPrefix = true;
+      return part.substring(PREPEND_PREFIX.length);
+    }
+    return part;
+  });
+
+  return hasPrependPrefix ? transformedParts.join('/') : null;
+}
+
+/**
+ * Check if a path component has the append prefix and return the actual path
+ * Returns null if no append prefix is found, otherwise returns the actual path
+ *
+ * Examples:
+ * - "src/styles/__append__global.css" -> "src/styles/global.css"
+ * - "__append__file.txt" -> "file.txt"
+ * - "src/file.tsx" -> null (no prefix)
+ */
+function extractAppendPath(relativePath: string): string | null {
+  const parts = relativePath.split('/');
+  let hasAppendPrefix = false;
+
+  const transformedParts = parts.map(part => {
+    if (part.startsWith(APPEND_PREFIX)) {
+      hasAppendPrefix = true;
+      return part.substring(APPEND_PREFIX.length);
+    }
+    return part;
+  });
+
+  return hasAppendPrefix ? transformedParts.join('/') : null;
+}
+
+/**
+ * Apply a single feature's files to the target directory
+ * This is the core application logic extracted for reuse
+ */
+async function applySingleFeature(
+  resolvedFeature: ResolvedFeature,
+  baseAppPath: string,
+  targetDir: string,
+  targetAppName: string
+): Promise<void> {
+  const { featureDir, config, featurePath } = resolvedFeature;
+  const { templateDir, routeFilePath, pathMappings } = config;
+
+  // Extract feature name for path translation
+  const featureName = basename(featurePath);
+
+  // Get effective path mappings for this feature
+  const effectiveMappings = getEffectivePathMappings(featureName, pathMappings);
+
+  // Discover and apply files from feature's template directory
+  const templatePath = join(featureDir, templateDir);
+
+  if (!existsSync(templatePath)) {
+    throw new Error(`Template directory '${templateDir}' does not exist in feature path '${featurePath}'`);
+  }
+
+  logger.heading(`\nApplying: ${featurePath}`);
+  logger.info('Discovering files...');
+  const discoveredFiles = discoverFiles(templatePath);
+
+  if (discoveredFiles.length === 0) {
+    throw new Error(`Feature '${featurePath}' has no files in ${templateDir} directory`);
+  }
+
+  logger.info(`Found ${discoveredFiles.length} file(s)`);
+
+  // Validate that there are no conflicting paths and that base files exist
+  logger.info('Validating paths...');
+  const normalizedPaths = new Map<string, { path: string, type: 'normal' | 'delete' | 'inherit' | 'prepend' | 'append' }>();
+  const deleteFiles: string[] = [];
+  const inheritFiles: string[] = [];
+  const prependFiles: string[] = [];
+  const appendFiles: string[] = [];
+
+  for (const relativePath of discoveredFiles) {
+    // Apply path mappings to transform template path
+    const mappedPath = applyPathMappings(relativePath, effectiveMappings);
+
+    const deleteTargetPath = extractDeletePath(mappedPath);
+    const inheritTargetPath = extractInheritPath(mappedPath);
+    const prependTargetPath = extractPrependPath(mappedPath);
+    const appendTargetPath = extractAppendPath(mappedPath);
+
+    let normalizedPath: string;
+    let type: 'normal' | 'delete' | 'inherit' | 'prepend' | 'append';
+
+    if (deleteTargetPath) {
+      normalizedPath = deleteTargetPath;
+      type = 'delete';
+      deleteFiles.push(deleteTargetPath);
+    } else if (inheritTargetPath) {
+      normalizedPath = inheritTargetPath;
+      type = 'inherit';
+      inheritFiles.push(inheritTargetPath);
+    } else if (prependTargetPath) {
+      normalizedPath = prependTargetPath;
+      type = 'prepend';
+      prependFiles.push(prependTargetPath);
+    } else if (appendTargetPath) {
+      normalizedPath = appendTargetPath;
+      type = 'append';
+      appendFiles.push(appendTargetPath);
+    } else {
+      normalizedPath = mappedPath;
+      type = 'normal';
+    }
+
+    // Check for conflicts
+    if (normalizedPaths.has(normalizedPath)) {
+      const existing = normalizedPaths.get(normalizedPath)!;
+      logger.error('\nPath conflict detected!\n');
+      logger.info(`The following paths resolve to the same target file:`);
+      logger.info(`  1. ${existing.path} (${existing.type})`);
+      logger.info(`  2. ${relativePath} (${type})`);
+      logger.info(`  → Both target: ${normalizedPath}\n`);
+      logger.warning('You cannot have multiple files targeting the same path.');
+      logger.info('Please remove one of these files from the template directory.\n');
+      throw new Error('Path conflict - cannot proceed');
+    }
+
+    normalizedPaths.set(normalizedPath, { path: relativePath, type });
+  }
+
+  // Validate that files marked for deletion exist
+  // Note: Files may exist in target (from dependencies) or will be inherited from base app
+  for (const deleteFile of deleteFiles) {
+    // Translate feature path to target app path
+    const targetPath = translatePathToTargetApp(deleteFile, featureName, targetAppName);
+    const targetFilePath = join(targetDir, targetPath);
+
+    // If file doesn't exist in target yet, check if it will be copied from base app during deletion
+    if (!existsSync(targetFilePath)) {
+      // Check if file exists in base app (will be inherited during delete operation)
+      const translatedPath = translatePathToBaseApp(deleteFile, featureName, baseAppPath);
+      const baseFilePath = join(baseAppPath, translatedPath);
+
+      if (!existsSync(baseFilePath)) {
+        logger.error(`\nValidation error: Cannot delete file that doesn't exist!\n`);
+        logger.info(`File marked for deletion: ${deleteFile}`);
+        logger.info(`Not found in target: ${targetFilePath}`);
+        logger.info(`Not found in base app: ${baseFilePath}`);
+        logger.warning(`The file must exist in target or base app to be deleted.\n`);
+        throw new Error('Delete validation failed - cannot proceed');
+      }
+    }
+  }
+
+  // Validate that files marked for inheritance exist in base app
+  for (const inheritFile of inheritFiles) {
+
+    // Translate feature path to target app path
+    const targetPath = translatePathToTargetApp(inheritFile, featureName, targetAppName);
+    const targetFilePath = join(targetDir, targetPath);
+
+    // If file doesn't exist in target yet, check if it will be copied from base app during inheritance
+    if (!existsSync(targetFilePath)) {
+
+      // Translate feature path to base app path (we inherit from base app)
+      const translatedPath = translatePathToBaseApp(inheritFile, featureName, baseAppPath);
+      const baseFilePath = join(baseAppPath, translatedPath);
+      if (!existsSync(baseFilePath)) {
+        logger.error(`\nValidation error: Cannot inherit file that doesn't exist!\n`);
+        logger.info(`File marked for inheritance: ${inheritFile}`);
+        logger.info(`Translated to: ${translatedPath}`);
+        logger.info(`Expected location in base app: ${baseFilePath}`);
+        logger.warning(`The file doesn't exist in the base app.\n`);
+        throw new Error('Inherit validation failed - cannot proceed');
+      }
+    }
+  }
+
+  // Validate that files marked for prepending exist in base app
+  for (const prependFile of prependFiles) {
+    // Translate feature path to base app path (we prepend to base app files)
+    const translatedPath = translatePathToBaseApp(prependFile, featureName, baseAppPath);
+    const baseFilePath = join(baseAppPath, translatedPath);
+    if (!existsSync(baseFilePath)) {
+      logger.error(`\nValidation error: Cannot prepend to file that doesn't exist!\n`);
+      logger.info(`File marked for prepending: ${prependFile}`);
+      logger.info(`Translated to: ${translatedPath}`);
+      logger.info(`Expected location in base app: ${baseFilePath}`);
+      logger.warning(`The file doesn't exist in the base app.\n`);
+      throw new Error('Prepend validation failed - cannot proceed');
+    }
+  }
+
+  // Validate that files marked for appending exist in base app
+  for (const appendFile of appendFiles) {
+    // Translate feature path to base app path (we append to base app files)
+    const translatedPath = translatePathToBaseApp(appendFile, featureName, baseAppPath);
+    const baseFilePath = join(baseAppPath, translatedPath);
+    if (!existsSync(baseFilePath)) {
+      logger.error(`\nValidation error: Cannot append to file that doesn't exist!\n`);
+      logger.info(`File marked for appending: ${appendFile}`);
+      logger.info(`Translated to: ${translatedPath}`);
+      logger.info(`Expected location in base app: ${baseFilePath}`);
+      logger.warning(`The file doesn't exist in the base app.\n`);
+      throw new Error('Append validation failed - cannot proceed');
+    }
+  }
+
+  logger.success('Paths validated');
+
+  // Apply each discovered file
+  for (const relativePath of discoveredFiles) {
+    // Apply path mappings to transform template path
+    const mappedPath = applyPathMappings(relativePath, effectiveMappings);
+
+    // Translate feature path to base app path (for finding base files)
+    const translatedPath = translatePathToBaseApp(mappedPath, featureName, baseAppPath);
+    // Translate feature path to target app path (for writing files)
+    const targetPath = translatePathToTargetApp(mappedPath, featureName, targetAppName);
+
+    // Check if this is a special operation
+    const deleteTargetPath = extractDeletePath(mappedPath);
+    const inheritTargetPath = extractInheritPath(mappedPath);
+    const prependTargetPath = extractPrependPath(mappedPath);
+    const appendTargetPath = extractAppendPath(mappedPath);
+
+    if (deleteTargetPath) {
+      // This is a delete operation - delete the target file/directory
+      const targetDeletePath = translatePathToTargetApp(deleteTargetPath, featureName, targetAppName);
+      const targetFilePath = join(targetDir, targetDeletePath);
+      await deleteFile(targetFilePath, targetDeletePath);
+    } else if (inheritTargetPath) {
+      // This is an inherit operation - copy from base app if target doesn't have it
+      const targetInheritPath = translatePathToTargetApp(inheritTargetPath, featureName, targetAppName);
+      const targetFilePath = join(targetDir, targetInheritPath);
+      if (!existsSync(targetFilePath)) {
+        // Copy from base app to preserve inherited file in new target structure
+        const translatedInheritPath = translatePathToBaseApp(inheritTargetPath, featureName, baseAppPath);
+        const baseFilePath = join(baseAppPath, translatedInheritPath);
+        if (existsSync(baseFilePath)) {
+          const targetFileDir = dirname(targetFilePath);
+          if (!existsSync(targetFileDir)) {
+            mkdirSync(targetFileDir, { recursive: true });
+          }
+          cpSync(baseFilePath, targetFilePath);
+          logger.info(`Copied ${targetInheritPath} (inherited from base app)`);
+        } else {
+          logger.info(`Skipped ${targetInheritPath} (file not in base app)`);
+        }
+      } else {
+        logger.info(`Skipped ${targetInheritPath} (already exists in target)`);
+      }
+    } else if (prependTargetPath) {
+      // This is a prepend operation - ensure target file exists first
+      const featureFilePath = join(templatePath, relativePath);
+      const targetPrependPath = translatePathToTargetApp(prependTargetPath, featureName, targetAppName);
+      const targetFilePath = join(targetDir, targetPrependPath);
+
+      // Copy from base app if target doesn't have the file yet
+      if (!existsSync(targetFilePath)) {
+        const translatedPrependPath = translatePathToBaseApp(prependTargetPath, featureName, baseAppPath);
+        const baseFilePath = join(baseAppPath, translatedPrependPath);
+        if (existsSync(baseFilePath)) {
+          const targetFileDir = dirname(targetFilePath);
+          if (!existsSync(targetFileDir)) {
+            mkdirSync(targetFileDir, { recursive: true });
+          }
+          cpSync(baseFilePath, targetFilePath);
+        }
+      }
+
+      await prependToFile(featureFilePath, targetFilePath, targetPrependPath);
+    } else if (appendTargetPath) {
+      // This is an append operation - ensure target file exists first
+      const featureFilePath = join(templatePath, relativePath);
+      const targetAppendPath = translatePathToTargetApp(appendTargetPath, featureName, targetAppName);
+      const targetFilePath = join(targetDir, targetAppendPath);
+
+      // Copy from base app if target doesn't have the file yet
+      if (!existsSync(targetFilePath)) {
+        const translatedAppendPath = translatePathToBaseApp(appendTargetPath, featureName, baseAppPath);
+        const baseFilePath = join(baseAppPath, translatedAppendPath);
+        if (existsSync(baseFilePath)) {
+          const targetFileDir = dirname(targetFilePath);
+          if (!existsSync(targetFileDir)) {
+            mkdirSync(targetFileDir, { recursive: true });
+          }
+          cpSync(baseFilePath, targetFilePath);
+        }
+      }
+
+      await appendToFile(featureFilePath, targetFilePath, targetAppendPath);
+    } else {
+      // Normal file operation - add/update/merge
+      const patchFilePath = join(templatePath, relativePath);
+      // Use target app path to ensure all features write to same location
+      const targetFilePath = join(targetDir, targetPath);
+
+      // Determine if this should be merged (only for the routes file)
+      // The routeFilePath from config includes the full path from template root
+      const shouldMerge = mappedPath === routeFilePath;
+
+      // For route merging with dependencies:
+      // - Use target file as base if it exists (accumulates routes from previous features)
+      // - Otherwise use base app file (first feature merges with base app)
+      // Create a temp copy of target to avoid ts-morph issues with same file as base and target
+      let baseFilePath = join(baseAppPath, translatedPath);
+      let tempFilePath: string | undefined;
+
+      if (shouldMerge && existsSync(targetFilePath)) {
+        // Create temp copy of target to use as base
+        tempFilePath = join(tmpdir(), `route-merge-${randomBytes(8).toString('hex')}.tsx`);
+        cpSync(targetFilePath, tempFilePath);
+        baseFilePath = tempFilePath;
+      }
+
+      try {
+        await applyFile(patchFilePath, baseFilePath, targetFilePath, targetPath, shouldMerge);
+      } finally {
+        // Clean up temp file
+        if (tempFilePath && existsSync(tempFilePath)) {
+          unlinkSync(tempFilePath);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Apply feature patches to create a new app
+ *
+ * @param featurePath - Path to the feature directory containing feature.ts
+ * @param appPath - Path to the base app directory (used as reference, remains unchanged)
+ * @param options - Configuration options
+ * @param options.targetDirName - Required. Target directory where feature will be applied
+ * @param options.skipDependencyChanges - Optional. Skip npm dependency installation
+ * @param options.clean - Optional. Clean target directory before applying
+ *
+ * @example
+ * await applyPatchesCommand(
+ *   'packages/feature-navigation-menu',
+ *   'packages/base-react-app',
+ *   { targetDirName: 'my-app' }
+ * );
+ */
+export async function applyPatchesCommand(
+  featurePath: string,
+  appPath: string,
+  options: { targetDirName: string; skipDependencyChanges?: boolean; clean?: boolean; }
+): Promise<void> {
+  try {
+    logger.heading(`Applying patches: ${featurePath} → ${options.targetDirName}`);
+
+    // Step 1: Validate inputs
+    logger.info('Validating paths...');
+    validateAndResolveFeaturePath(featurePath);  // Fast-fail validation
+    const baseAppPath = validateAndResolveAppPath(appPath);
+    logger.success('Validation passed');
+
+    // Step 2: Prepare target directory
+    // Extract target app name from the main feature path for nested structure
+    const mainFeatureName = basename(featurePath);
+    const targetAppName: string = mainFeatureName;
+
+    // Resolve target directory - if absolute, use as-is; otherwise resolve relative to monorepo root
+    const resolvedTargetDir = isAbsolute(options.targetDirName)
+      ? options.targetDirName
+      : join(getMonorepoRoot(), options.targetDirName);
+
+    if (existsSync(resolvedTargetDir)) {
+      if (options.clean) {
+        logger.info(`Cleaning existing directory ${options.targetDirName}...`);
+        rmSync(resolvedTargetDir, { recursive: true, force: true });
+        logger.success('Directory cleaned');
+      }
+    } else {
+      logger.info(`Creating target directory ${options.targetDirName}...`);
+      mkdirSync(resolvedTargetDir, { recursive: true });
+      logger.success('Target directory created');
+    }
+
+    // Copy base app to target directory with nested structure
+    logger.info(`Copying base app to ${options.targetDirName}...`);
+    const targetAppDir = join(resolvedTargetDir, 'digitalExperiences/webApplications', targetAppName);
+    const sourceWebAppPath = getWebApplicationPath(baseAppPath);
+    mkdirSync(dirname(targetAppDir), { recursive: true });
+    cpSync(sourceWebAppPath, targetAppDir, { recursive: true });
+    logger.success('Base app copied');
+
+    const targetDir = resolvedTargetDir;
+
+    // Step 3: Resolve dependencies
+    logger.heading('\nResolving Dependencies');
+    const { orderedFeatures } = await resolveDependencies(featurePath);
+
+    if (orderedFeatures.length > 1) {
+      logger.info(`Resolved dependency chain (${orderedFeatures.length} features):`);
+      for (let i = 0; i < orderedFeatures.length; i++) {
+        const { featurePath: path } = orderedFeatures[i];
+        const isMainFeature = i === orderedFeatures.length - 1;
+        const prefix = isMainFeature ? '└─' : '├─';
+        const label = isMainFeature ? ' (main)' : ' (dependency)';
+        logger.info(`  ${prefix} ${path}${label}`);
+      }
+      logger.success('Dependency resolution complete');
+    } else {
+      logger.info('No dependencies found');
+    }
+
+    // Step 4: Apply all features in dependency order
+    for (const resolvedFeature of orderedFeatures) {
+      await applySingleFeature(resolvedFeature, baseAppPath, targetDir, targetAppName);
+    }
+
+    // Step 5: Aggregate and install all dependencies once
+    if (options.skipDependencyChanges) {
+      logger.info('\n⏭  Skipping dependency installation');
+    } else {
+      // Aggregate all dependencies from all resolved features, checking for conflicts
+      const aggregatedDependencies: Record<string, string> = {};
+      const aggregatedDevDependencies: Record<string, string> = {};
+
+      // Collect all features from all resolved features
+      const allFeatures = orderedFeatures.flatMap(rf => rf.config.features);
+
+      // First pass: collect all regular dependencies
+      for (const feature of allFeatures) {
+        if (feature.packageJson?.dependencies) {
+          for (const [name, version] of Object.entries(feature.packageJson.dependencies)) {
+            if (aggregatedDependencies[name] && aggregatedDependencies[name] !== version) {
+              throw new Error(
+                `Dependency version conflict for '${name}': feature requires '${version}' but another feature requires '${aggregatedDependencies[name]}'`
+              );
+            }
+            aggregatedDependencies[name] = version;
+          }
+        }
+      }
+
+      // Second pass: collect dev dependencies (skip if already in dependencies)
+      for (const feature of allFeatures) {
+        if (feature.packageJson?.devDependencies) {
+          for (const [name, version] of Object.entries(feature.packageJson.devDependencies)) {
+            // Skip if already in regular dependencies
+            if (aggregatedDependencies[name]) {
+              continue;
+            }
+
+            if (aggregatedDevDependencies[name] && aggregatedDevDependencies[name] !== version) {
+              throw new Error(
+                `Dev dependency version conflict for '${name}': feature requires '${version}' but another feature requires '${aggregatedDevDependencies[name]}'`
+              );
+            }
+            aggregatedDevDependencies[name] = version;
+          }
+        }
+      }
+
+      const hasAnyDependencies =
+        Object.keys(aggregatedDependencies).length > 0 ||
+        Object.keys(aggregatedDevDependencies).length > 0;
+
+      if (hasAnyDependencies) {
+        logger.heading('\nInstalling Dependencies');
+        await mergePackageJson(targetDir, {
+          dependencies: Object.keys(aggregatedDependencies).length > 0 ? aggregatedDependencies : undefined,
+          devDependencies: Object.keys(aggregatedDevDependencies).length > 0 ? aggregatedDevDependencies : undefined
+        }, targetAppDir);
+      } else {
+        logger.info('\n✓ No dependencies to install');
+      }
+    }
+
+    // Step 6: Success message
+    logger.heading('\n✓ Success');
+    logger.success(`Created: ${targetDir}`);
+
+  } catch (err) {
+    // Only log error if it's not already been logged (check for our custom error messages)
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    const skipLogging = [
+      'Path conflict - cannot proceed',
+      'Delete validation failed - cannot proceed',
+      'Inherit validation failed - cannot proceed',
+      'Prepend validation failed - cannot proceed',
+      'Append validation failed - cannot proceed',
+      'Route deletion failed - cannot proceed'
+    ].includes(errorMessage);
+
+    if (!skipLogging) {
+      logger.error(`Failed to apply feature: ${errorMessage}`);
+    }
+    throw err;
+  }
+}