shakapacker 8.0.2 → 9.2.0

data/lib/tasks/shakapacker/switch_bundler.rake

@@ -0,0 +1,82 @@
+require "shakapacker/bundler_switcher"
+
+namespace :shakapacker do
+  desc <<~DESC
+    Switch between webpack and rspack bundlers
+
+    Easily switch your Shakapacker configuration between webpack and rspack bundlers.
+    This task updates config/shakapacker.yml and optionally manages npm dependencies.
+
+    Usage:
+      rails shakapacker:switch_bundler [webpack|rspack] [OPTIONS]
+      rake shakapacker:switch_bundler [webpack|rspack] -- [OPTIONS]
+
+    Options:
+      --install-deps    Automatically install/uninstall bundler dependencies
+      --no-uninstall    Skip uninstalling old bundler packages (faster, keeps both bundlers)
+      --init-config     Create custom dependencies configuration file
+      --help, -h        Show detailed help message
+
+    Examples:
+      # Switch to rspack with automatic dependency management
+      rails shakapacker:switch_bundler rspack --install-deps
+      rake shakapacker:switch_bundler rspack -- --install-deps
+
+      # Fast switching without uninstalling (keeps both bundlers)
+      rails shakapacker:switch_bundler webpack --install-deps --no-uninstall
+      rake shakapacker:switch_bundler rspack -- --install-deps --no-uninstall
+
+      # Switch to rspack (manual dependency management)
+      rails shakapacker:switch_bundler rspack
+      rake shakapacker:switch_bundler rspack
+
+      # Switch back to webpack with dependency management
+      rails shakapacker:switch_bundler webpack --install-deps
+      rake shakapacker:switch_bundler webpack -- --install-deps
+
+      # Create custom dependencies config file
+      rails shakapacker:switch_bundler --init-config
+      rake shakapacker:switch_bundler -- --init-config
+
+      # Show current bundler and usage help
+      rails shakapacker:switch_bundler --help
+      rake shakapacker:switch_bundler -- --help
+
+    Note: When using 'rake', you must use '--' to separate rake options from task arguments.
+
+    What it does:
+      - Updates 'assets_bundler' in config/shakapacker.yml
+      - Preserves YAML comments and structure
+      - Updates 'javascript_transpiler' to 'swc' when switching to rspack
+      - With --install-deps: installs/uninstalls npm dependencies automatically
+      - Without --install-deps: shows manual installation commands
+
+    Custom Dependencies:
+      Create .shakapacker-switch-bundler-dependencies.yml to customize which
+      npm packages are installed/uninstalled during bundler switching.
+
+    See docs/rspack_migration_guide.md for more information.
+  DESC
+  task :switch_bundler do
+    switcher = Shakapacker::BundlerSwitcher.new
+
+    if ARGV.empty? || ARGV.include?("--help") || ARGV.include?("-h")
+      switcher.show_usage
+    elsif ARGV.include?("--init-config")
+      switcher.init_config
+    else
+      bundler = ARGV[1]
+      install_deps = ARGV.include?("--install-deps")
+      no_uninstall = ARGV.include?("--no-uninstall")
+
+      if bundler.nil? || bundler.start_with?("-")
+        switcher.show_usage
+      else
+        switcher.switch_to(bundler, install_deps: install_deps, no_uninstall: no_uninstall)
+      end
+    end
+
+    # Prevent rake from trying to execute arguments as tasks
+    ARGV.each { |arg| task arg.to_sym {} }
+  end
+end

data/lib/tasks/shakapacker.rake

@@ -9,6 +9,8 @@ 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",
+  "shakapacker:switch_bundler"          => "Switch between webpack and rspack bundlers"
 }.freeze
 
 desc "Lists all available tasks in Shakapacker"

data/package/.npmignore

@@ -0,0 +1,4 @@
+# Exclude TypeScript source files from the package directory
+*.ts
+# But keep the TypeScript declaration files
+!*.d.ts

data/package/babel/preset.ts

@@ -0,0 +1,56 @@
+import { moduleExists, packageFullVersion } from "../utils/helpers"
+import type { ConfigAPI, PluginItem } from "@babel/core"
+
+const CORE_JS_VERSION_REGEX = /^\d+\.\d+/
+
+const coreJsVersion = (): string => {
+  try {
+    const version = packageFullVersion("core-js").match(CORE_JS_VERSION_REGEX)
+    return version?.[0] ?? "3.8"
+  } catch (e) {
+    const error = e as NodeJS.ErrnoException
+    if (error.code !== "MODULE_NOT_FOUND") {
+      throw e
+    }
+
+    return "3.8"
+  }
+}
+
+export = function config(api: ConfigAPI): { presets: PluginItem[]; plugins: PluginItem[] } {
+  const validEnv = ["development", "test", "production"]
+  const currentEnv = api.env()
+  const isDevelopmentEnv = api.env("development")
+  const isProductionEnv = api.env("production")
+  const isTestEnv = api.env("test")
+
+  if (!validEnv.includes(currentEnv)) {
+    throw new Error(
+      `Please specify a valid NODE_ENV or BABEL_ENV environment variable. Valid values are "development", "test", and "production". Instead, received: "${currentEnv}".`
+    )
+  }
+
+  const presets: PluginItem[] = [
+    isTestEnv && ["@babel/preset-env", { targets: { node: "current" } }],
+    (isProductionEnv || isDevelopmentEnv) && [
+      "@babel/preset-env",
+      {
+        useBuiltIns: "entry",
+        corejs: coreJsVersion(),
+        modules: "auto",
+        bugfixes: true,
+        exclude: ["transform-typeof-symbol"]
+      }
+    ],
+    moduleExists("@babel/preset-typescript") && "@babel/preset-typescript"
+  ].filter(Boolean) as PluginItem[]
+
+  const plugins: PluginItem[] = [["@babel/plugin-transform-runtime", { helpers: false }]].filter(
+    Boolean
+  ) as PluginItem[]
+
+  return {
+    presets,
+    plugins
+  }
+}

data/package/config.ts

@@ -0,0 +1,175 @@
+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)]
+}
+
+// Ensure assets_bundler has a default value
+if (!config.assets_bundler) {
+  config.assets_bundler = "webpack"
+}
+
+// Allow ENV variable to override assets_bundler  
+if (process.env.SHAKAPACKER_ASSETS_BUNDLER) {
+  config.assets_bundler = process.env.SHAKAPACKER_ASSETS_BUNDLER
+}
+
+// Define clear defaults
+// Keep Babel as default for webpack to maintain backward compatibility
+// Use SWC for rspack as it's a newer bundler where we can set modern defaults
+const DEFAULT_JAVASCRIPT_TRANSPILER = 
+  config.assets_bundler === "rspack" ? "swc" : "babel"
+
+// Backward compatibility: Check for webpack_loader using proper type guard
+function hasWebpackLoader(obj: unknown): obj is Config & { webpack_loader: string } {
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    'webpack_loader' in obj &&
+    typeof (obj as Record<string, unknown>).webpack_loader === 'string'
+  )
+}
+
+// Allow environment variable to override javascript_transpiler
+if (process.env.SHAKAPACKER_JAVASCRIPT_TRANSPILER) {
+  config.javascript_transpiler = process.env.SHAKAPACKER_JAVASCRIPT_TRANSPILER
+} else if (hasWebpackLoader(config) && !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 = config.webpack_loader
+} else if (!config.javascript_transpiler) {
+  config.javascript_transpiler = DEFAULT_JAVASCRIPT_TRANSPILER
+}
+
+// Ensure webpack_loader is always available for backward compatibility
+Object.defineProperty(config, 'webpack_loader', {
+  value: config.javascript_transpiler,
+  writable: true,
+  enumerable: true,
+  configurable: true
+})
+
+export = config