shakapacker 9.0.0.beta.4 → 9.0.0.beta.6

data/lib/shakapacker/swc_migrator.rb

@@ -0,0 +1,292 @@
+require "yaml"
+require "json"
+require "fileutils"
+require "logger"
+require "pathname"
+
+module Shakapacker
+  class SwcMigrator
+    attr_reader :root_path, :logger
+
+    BABEL_PACKAGES = [
+      "@babel/core",
+      "@babel/plugin-proposal-class-properties",
+      "@babel/plugin-proposal-object-rest-spread",
+      "@babel/plugin-syntax-dynamic-import",
+      "@babel/plugin-transform-destructuring",
+      "@babel/plugin-transform-regenerator",
+      "@babel/plugin-transform-runtime",
+      "@babel/preset-env",
+      "@babel/preset-react",
+      "@babel/preset-typescript",
+      "@babel/runtime",
+      "babel-loader",
+      "babel-plugin-macros",
+      "babel-plugin-transform-react-remove-prop-types"
+    ].freeze
+
+    SWC_PACKAGES = {
+      "@swc/core" => "^1.7.39",
+      "swc-loader" => "^0.2.6"
+    }.freeze
+
+    DEFAULT_SWCRC_CONFIG = {
+      "jsc" => {
+        "parser" => {
+          "syntax" => "ecmascript",
+          "jsx" => true,
+          "dynamicImport" => true
+        },
+        "transform" => {
+          "react" => {
+            "runtime" => "automatic"
+          }
+        },
+        "target" => "es2015"
+      },
+      "module" => {
+        "type" => "es6"
+      }
+    }.freeze
+
+    def initialize(root_path, logger: nil)
+      @root_path = Pathname.new(root_path)
+      @logger = logger || Logger.new($stdout)
+    end
+
+    def migrate_to_swc(run_installer: true)
+      logger.info "🔄 Starting migration from Babel to SWC..."
+
+      results = {
+        config_updated: update_shakapacker_config,
+        packages_installed: install_swc_packages,
+        swcrc_created: create_swcrc,
+        babel_packages_found: find_babel_packages
+      }
+
+      logger.info "🎉 Migration to SWC complete!"
+      logger.info "   Note: SWC is approximately 20x faster than Babel for transpilation."
+      logger.info "   Please test your application thoroughly after migration."
+
+      # Show cleanup recommendations if babel packages found
+      if results[:babel_packages_found].any?
+        logger.info "\n🧹 Cleanup Recommendations:"
+        logger.info "   Found the following Babel packages in your package.json:"
+        results[:babel_packages_found].each do |package|
+          logger.info "   - #{package}"
+        end
+        logger.info "\n   To remove them, run:"
+        logger.info "   rails shakapacker:clean_babel_packages"
+      end
+
+      # Suggest running doctor to verify configuration
+      logger.info "\n🩺 Run 'rails shakapacker:doctor' to verify your configuration"
+
+      # Run package manager install if packages were added
+      if run_installer && results[:packages_installed].any?
+        run_package_manager_install
+      end
+
+      results
+    end
+
+    def clean_babel_packages(run_installer: true)
+      logger.info "🧹 Removing Babel packages..."
+
+      package_json_path = root_path.join("package.json")
+      unless package_json_path.exist?
+        logger.error "❌ No package.json found"
+        return { removed_packages: [], config_files_deleted: [] }
+      end
+
+      removed_packages = remove_babel_from_package_json(package_json_path)
+      deleted_files = delete_babel_config_files
+
+      if removed_packages.any?
+        logger.info "✅ Babel packages removed successfully!"
+        run_package_manager_install if run_installer
+      else
+        logger.info "ℹ️  No Babel packages found to remove"
+      end
+
+      { removed_packages: removed_packages, config_files_deleted: deleted_files }
+    end
+
+    def find_babel_packages
+      package_json_path = root_path.join("package.json")
+      return [] unless package_json_path.exist?
+
+      begin
+        package_json = JSON.parse(File.read(package_json_path))
+        dependencies = package_json["dependencies"] || {}
+        dev_dependencies = package_json["devDependencies"] || {}
+        all_deps = dependencies.merge(dev_dependencies)
+
+        found_packages = BABEL_PACKAGES.select { |pkg| all_deps.key?(pkg) }
+        found_packages
+      rescue JSON::ParserError => e
+        logger.error "Failed to parse package.json: #{e.message}"
+        []
+      end
+    end
+
+    private
+
+      def update_shakapacker_config
+        config_path = root_path.join("config/shakapacker.yml")
+        return false unless config_path.exist?
+
+        logger.info "📝 Updating shakapacker.yml..."
+        config = begin
+          YAML.load_file(config_path, aliases: true)
+        rescue ArgumentError
+          YAML.load_file(config_path)
+        end
+
+        config.each do |env, settings|
+          next unless settings.is_a?(Hash)
+
+          if settings["babel"]
+            logger.info "  - Removing babel config from #{env} environment"
+            settings.delete("babel")
+          end
+
+          settings["swc"] = true
+          logger.info "  - Enabled SWC for #{env} environment"
+        end
+
+        File.write(config_path, config.to_yaml)
+        logger.info "✅ shakapacker.yml updated"
+        true
+      rescue StandardError => e
+        logger.error "Failed to update config: #{e.message}"
+        false
+      end
+
+      def install_swc_packages
+        package_json_path = root_path.join("package.json")
+        return {} unless package_json_path.exist?
+
+        logger.info "📦 Installing SWC dependencies..."
+        package_json = JSON.parse(File.read(package_json_path))
+
+        dependencies = package_json["dependencies"] || {}
+        dev_dependencies = package_json["devDependencies"] || {}
+        installed = {}
+
+        SWC_PACKAGES.each do |package, version|
+          unless dependencies[package] || dev_dependencies[package]
+            logger.info "  - Adding #{package}@#{version}"
+            dev_dependencies[package] = version
+            installed[package] = version
+          else
+            logger.info "  - #{package} already installed"
+          end
+        end
+
+        if installed.any?
+          package_json["devDependencies"] = dev_dependencies
+          File.write(package_json_path, JSON.pretty_generate(package_json) + "\n")
+          logger.info "✅ package.json updated with SWC dependencies"
+        end
+
+        installed
+      rescue StandardError => e
+        logger.error "Failed to install packages: #{e.message}"
+        {}
+      end
+
+      def create_swcrc
+        swcrc_path = root_path.join(".swcrc")
+        if swcrc_path.exist?
+          logger.info "ℹ️  .swcrc already exists"
+          return false
+        end
+
+        logger.info "📄 Creating .swcrc configuration..."
+        File.write(swcrc_path, JSON.pretty_generate(DEFAULT_SWCRC_CONFIG) + "\n")
+        logger.info "✅ .swcrc created"
+        true
+      rescue StandardError => e
+        logger.error "Failed to create .swcrc: #{e.message}"
+        false
+      end
+
+      def remove_babel_from_package_json(package_json_path)
+        package_json = JSON.parse(File.read(package_json_path))
+        dependencies = package_json["dependencies"] || {}
+        dev_dependencies = package_json["devDependencies"] || {}
+        removed_packages = []
+
+        BABEL_PACKAGES.each do |package|
+          if dependencies.delete(package)
+            removed_packages << package
+            logger.info "  - Removed #{package} from dependencies"
+          end
+          if dev_dependencies.delete(package)
+            removed_packages << package
+            logger.info "  - Removed #{package} from devDependencies"
+          end
+        end
+
+        if removed_packages.any?
+          package_json["dependencies"] = dependencies
+          package_json["devDependencies"] = dev_dependencies
+          File.write(package_json_path, JSON.pretty_generate(package_json) + "\n")
+          logger.info "✅ package.json updated"
+        end
+
+        removed_packages.uniq
+      rescue StandardError => e
+        logger.error "Failed to remove packages: #{e.message}"
+        []
+      end
+
+      def delete_babel_config_files
+        deleted_files = []
+        babel_config_files = [".babelrc", "babel.config.js", ".babelrc.js", "babel.config.json"]
+
+        babel_config_files.each do |file|
+          file_path = root_path.join(file)
+          if file_path.exist?
+            logger.info "  - Removing #{file}"
+            File.delete(file_path)
+            deleted_files << file
+          end
+        end
+
+        deleted_files
+      rescue StandardError => e
+        logger.error "Failed to delete config files: #{e.message}"
+        []
+      end
+
+      def run_package_manager_install
+        logger.info "\n🔧 Running npm/yarn install..."
+
+        yarn_lock = root_path.join("yarn.lock")
+        pnpm_lock = root_path.join("pnpm-lock.yaml")
+
+        if yarn_lock.exist?
+          system("yarn install")
+        elsif pnpm_lock.exist?
+          system("pnpm install")
+        else
+          system("npm install")
+        end
+      end
+
+      def package_manager
+        yarn_lock = root_path.join("yarn.lock")
+        pnpm_lock = root_path.join("pnpm-lock.yaml")
+
+        if yarn_lock.exist?
+          "yarn"
+        elsif pnpm_lock.exist?
+          "pnpm"
+        else
+          "npm"
+        end
+      end
+  end
+end

data/lib/shakapacker/version.rb

@@ -1,4 +1,4 @@
 module Shakapacker
   # Change the version in package.json too, please!
-  VERSION = "9.0.0.beta.4".freeze
+  VERSION = "9.0.0.beta.6".freeze
 end

data/lib/shakapacker.rb

@@ -44,6 +44,7 @@ require_relative "shakapacker/manifest"
 require_relative "shakapacker/compiler"
 require_relative "shakapacker/commands"
 require_relative "shakapacker/dev_server"
+require_relative "shakapacker/doctor"
 require_relative "shakapacker/deprecation_helper"
 
 require_relative "shakapacker/railtie" if defined?(Rails)

data/lib/tasks/shakapacker/doctor.rake

@@ -0,0 +1,8 @@
+require "shakapacker/doctor"
+
+namespace :shakapacker do
+  desc "Checks for common Shakapacker configuration issues and missing dependencies"
+  task doctor: :environment do
+    Shakapacker::Doctor.new.run
+  end
+end

data/lib/tasks/shakapacker/migrate_to_swc.rake

@@ -0,0 +1,13 @@
+require "shakapacker/swc_migrator"
+
+namespace :shakapacker do
+  desc "Migrate from Babel to SWC transpiler"
+  task :migrate_to_swc do
+    Shakapacker::SwcMigrator.new(Rails.root).migrate_to_swc
+  end
+
+  desc "Remove Babel packages after migrating to SWC"
+  task :clean_babel_packages do
+    Shakapacker::SwcMigrator.new(Rails.root).clean_babel_packages
+  end
+end

data/lib/tasks/shakapacker.rake

@@ -9,6 +9,7 @@ tasks = {
   "shakapacker:check_binstubs"          => "Verifies that bin/shakapacker is present",
   "shakapacker:binstubs"                => "Installs Shakapacker binstubs in this application",
   "shakapacker:verify_install"          => "Verifies if Shakapacker is installed",
+  "shakapacker:doctor"                  => "Checks for configuration issues and missing dependencies"
 }.freeze
 
 desc "Lists all available tasks in Shakapacker"

data/package/config.ts

@@ -0,0 +1,162 @@
+import { resolve } from "path"
+import { load } from "js-yaml"
+import { existsSync, readFileSync } from "fs"
+import { merge } from "webpack-merge"
+const { ensureTrailingSlash } = require("./utils/helpers")
+const { railsEnv } = require("./env")
+const configPath = require("./utils/configPath")
+const defaultConfigPath = require("./utils/defaultConfigPath")
+import { Config, YamlConfig, LegacyConfig } from "./types"
+const { isValidYamlConfig, createConfigValidationError, isPartialConfig, isValidConfig } = require("./utils/typeGuards")
+const { isFileNotFoundError, createFileOperationError } = require("./utils/errorHelpers")
+
+const loadAndValidateYaml = (path: string): YamlConfig => {
+  const fileContent = readFileSync(path, "utf8")
+  const yamlContent = load(fileContent)
+  
+  if (!isValidYamlConfig(yamlContent)) {
+    throw createConfigValidationError(path, railsEnv, "Invalid YAML structure")
+  }
+  
+  return yamlContent as YamlConfig
+}
+
+const getDefaultConfig = (): Partial<Config> => {
+  try {
+    const defaultConfig = loadAndValidateYaml(defaultConfigPath)
+    return defaultConfig[railsEnv] || defaultConfig.production || {}
+  } catch (error) {
+    if (isFileNotFoundError(error)) {
+      throw createFileOperationError(
+        'read', 
+        defaultConfigPath, 
+        `Default configuration not found at ${defaultConfigPath}. Please ensure Shakapacker is properly installed. You may need to run 'yarn add shakapacker' or 'npm install shakapacker'.`
+      )
+    }
+    throw error
+  }
+}
+
+const defaults = getDefaultConfig()
+let config: Config
+
+if (existsSync(configPath)) {
+  try {
+    const appYmlObject = loadAndValidateYaml(configPath)
+    
+    const envAppConfig = appYmlObject[railsEnv]
+
+    if (!envAppConfig) {
+      /* eslint no-console:0 */
+      console.warn(
+        `[SHAKAPACKER WARNING] Environment '${railsEnv}' not found in ${configPath}\n` +
+        `Available environments: ${Object.keys(appYmlObject).join(', ')}\n` +
+        `Using 'production' configuration as fallback.\n\n` +
+        `To fix this, either:\n` +
+        `  - Add a '${railsEnv}' section to your shakapacker.yml\n` +
+        `  - Set RAILS_ENV to one of the available environments\n` +
+        `  - Copy settings from another environment as a starting point`
+      )
+    }
+
+    // Merge returns the merged type
+    const mergedConfig = merge(defaults, envAppConfig || {})
+    
+    // Validate merged config before type assertion
+    if (!isPartialConfig(mergedConfig)) {
+      throw createConfigValidationError(
+        configPath, 
+        railsEnv, 
+        `Invalid configuration structure in ${configPath}. Please check your shakapacker.yml syntax and ensure all required fields are properly defined.`
+      )
+    }
+    
+    // After merging with defaults, config should be complete
+    // Use type assertion only after validation
+    config = mergedConfig as Config
+  } catch (error) {
+    if (isFileNotFoundError(error)) {
+      // File not found is OK, use defaults
+      if (!isPartialConfig(defaults)) {
+        throw createConfigValidationError(
+          defaultConfigPath, 
+          railsEnv, 
+          `Invalid default configuration. This may indicate a corrupted Shakapacker installation. Try reinstalling with 'yarn add shakapacker --force'.`
+        )
+      }
+      // Using defaults only, might be partial
+      config = defaults as Config
+    } else {
+      throw error
+    }
+  }
+} else {
+  // No user config, use defaults
+  if (!isPartialConfig(defaults)) {
+    throw createConfigValidationError(
+      defaultConfigPath, 
+      railsEnv, 
+      `Invalid default configuration. This may indicate a corrupted Shakapacker installation. Try reinstalling with 'yarn add shakapacker --force'.`
+    )
+  }
+  // Using defaults only, might be partial
+  config = defaults as Config
+}
+
+config.outputPath = resolve(config.public_root_path, config.public_output_path)
+
+// Ensure that the publicPath includes our asset host so dynamic imports
+// (code-splitting chunks and static assets) load from the CDN instead of a relative path.
+const getPublicPath = (): string => {
+  const rootUrl = ensureTrailingSlash(process.env.SHAKAPACKER_ASSET_HOST || "/")
+  return `${rootUrl}${config.public_output_path}/`
+}
+
+config.publicPath = getPublicPath()
+config.publicPathWithoutCDN = `/${config.public_output_path}/`
+
+if (config.manifest_path) {
+  config.manifestPath = resolve(config.manifest_path)
+} else {
+  config.manifestPath = resolve(config.outputPath, "manifest.json")
+}
+// Ensure no duplicate hash functions exist in the returned config object
+if (config.integrity?.hash_functions) {
+  config.integrity.hash_functions = [...new Set(config.integrity.hash_functions)]
+}
+
+// Allow ENV variable to override assets_bundler
+if (process.env.SHAKAPACKER_ASSETS_BUNDLER) {
+  config.assets_bundler = process.env.SHAKAPACKER_ASSETS_BUNDLER
+}
+
+// Define clear defaults
+const DEFAULT_JAVASCRIPT_TRANSPILER =
+  config.assets_bundler === "rspack" ? "swc" : "babel"
+
+// Backward compatibility: Add webpack_loader property that maps to javascript_transpiler
+// Show deprecation warning if webpack_loader is used
+// Use type-safe property check
+const configWithLegacy = config as Config & { webpack_loader?: string }
+const webpackLoader = configWithLegacy.webpack_loader
+
+if (webpackLoader && !config.javascript_transpiler) {
+  console.warn(
+    "[SHAKAPACKER DEPRECATION] The 'webpack_loader' configuration option is deprecated.\n" +
+    "Please use 'javascript_transpiler' instead as it better reflects its purpose of configuring JavaScript transpilation regardless of the bundler used."
+  )
+  config.javascript_transpiler = webpackLoader
+} else if (!config.javascript_transpiler) {
+  config.javascript_transpiler = DEFAULT_JAVASCRIPT_TRANSPILER
+}
+
+// Ensure webpack_loader is always available for backward compatibility
+// Use property assignment instead of type assertion
+Object.defineProperty(config, 'webpack_loader', {
+  value: config.javascript_transpiler,
+  writable: true,
+  enumerable: true,
+  configurable: true
+})
+
+export = config

data/package/{dev_server.js → dev_server.ts}

@@ -1,23 +1,26 @@
 // These are the raw shakapacker dev server config settings from the YML file with ENV overrides applied.
 const { isBoolean } = require("./utils/helpers")
 const config = require("./config")
+import { DevServerConfig } from "./types"
 
-const envFetch = (key) => {
+const envFetch = (key: string): string | boolean | undefined => {
   const value = process.env[key]
+  if (!value) return undefined
   return isBoolean(value) ? JSON.parse(value) : value
 }
 
-const devServerConfig = config.dev_server
+const devServerConfig: DevServerConfig | undefined = config.dev_server
 
 if (devServerConfig) {
-  const envPrefix = config.dev_server.env_prefix || "SHAKAPACKER_DEV_SERVER"
+  const envPrefix = devServerConfig.env_prefix || "SHAKAPACKER_DEV_SERVER"
 
   Object.keys(devServerConfig).forEach((key) => {
     const envValue = envFetch(`${envPrefix}_${key.toUpperCase()}`)
     if (envValue !== undefined) {
-      devServerConfig[key] = envValue
+      // Use bracket notation to avoid ASI issues
+      (devServerConfig as Record<string, unknown>)[key] = envValue
     }
   })
 }
 
-module.exports = devServerConfig || {}
+export = devServerConfig || {}

data/package/env.ts

@@ -0,0 +1,67 @@
+import { load } from "js-yaml"
+import { readFileSync } from "fs"
+const defaultConfigPath = require("./utils/defaultConfigPath")
+const configPath = require("./utils/configPath")
+const { isFileNotFoundError } = require("./utils/errorHelpers")
+
+const NODE_ENVIRONMENTS = ["development", "production", "test"] as const
+const DEFAULT = "production"
+
+const initialRailsEnv = process.env.RAILS_ENV
+const rawNodeEnv = process.env.NODE_ENV
+const nodeEnv =
+  rawNodeEnv && NODE_ENVIRONMENTS.includes(rawNodeEnv as typeof NODE_ENVIRONMENTS[number]) ? rawNodeEnv : DEFAULT
+const isProduction = nodeEnv === "production"
+const isDevelopment = nodeEnv === "development"
+
+interface ConfigFile {
+  [environment: string]: Record<string, unknown>
+}
+
+let config: ConfigFile
+try {
+  config = load(readFileSync(configPath, "utf8")) as ConfigFile
+} catch (error: unknown) {
+  if (isFileNotFoundError(error)) {
+    // File not found, use default configuration
+    try {
+      config = load(readFileSync(defaultConfigPath, "utf8")) as ConfigFile
+    } catch (defaultError) {
+      throw new Error(
+        `Failed to load Shakapacker configuration.\n` +
+        `Neither user config (${configPath}) nor default config (${defaultConfigPath}) could be loaded.\n\n` +
+        `To fix this issue:\n` +
+        `1. Create a config/shakapacker.yml file in your project\n` +
+        `2. Or set the SHAKAPACKER_CONFIG environment variable to point to your config file\n` +
+        `3. Or reinstall Shakapacker to restore the default configuration:\n` +
+        `   npm install shakapacker --force\n` +
+        `   yarn add shakapacker --force`
+      )
+    }
+  } else {
+    throw error
+  }
+}
+
+const availableEnvironments = Object.keys(config).join("|")
+const regex = new RegExp(`^(${availableEnvironments})$`, "g")
+
+const runningWebpackDevServer = process.env.WEBPACK_SERVE === "true"
+
+const validatedRailsEnv = initialRailsEnv && initialRailsEnv.match(regex) ? initialRailsEnv : DEFAULT
+
+if (initialRailsEnv && validatedRailsEnv !== initialRailsEnv) {
+  /* eslint no-console:0 */
+  console.warn(
+    `[SHAKAPACKER WARNING] Environment '${initialRailsEnv}' not found in the configuration.\n` +
+    `Using '${DEFAULT}' configuration as a fallback.`
+  )
+}
+
+export = {
+  railsEnv: validatedRailsEnv,
+  nodeEnv,
+  isProduction,
+  isDevelopment,
+  runningWebpackDevServer
+}