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

data/package/types.ts

@@ -0,0 +1,108 @@
+import * as https from "node:https"
+
+// Type for the raw YAML config file
+export interface YamlConfig {
+  [environment: string]: Partial<Config>
+}
+
+// Type for backward compatibility
+export interface LegacyConfig extends Config {
+  webpack_loader?: string
+}
+
+export interface Config {
+  source_path: string
+  source_entry_path: string
+  nested_entries: boolean
+  css_extract_ignore_order_warnings: boolean
+  public_root_path: string
+  public_output_path: string
+  private_output_path?: string
+  cache_path: string
+  webpack_compile_output: boolean
+  shakapacker_precompile: boolean
+  additional_paths: string[]
+  cache_manifest: boolean
+  javascript_transpiler: string
+  ensure_consistent_versioning: boolean
+  compiler_strategy: string
+  useContentHash: boolean
+  compile: boolean
+  outputPath: string
+  publicPath: string
+  publicPathWithoutCDN: string
+  manifestPath: string
+  manifest_path?: string
+  assets_bundler?: string
+  dev_server?: DevServerConfig
+  integrity?: {
+    enabled: boolean
+    cross_origin: string
+    hash_functions?: string[]
+  }
+}
+
+export interface Env {
+  railsEnv: string
+  nodeEnv: string
+  isProduction: boolean
+  isDevelopment: boolean
+  runningWebpackDevServer: boolean
+}
+
+type Header =
+  | Array<{ key: string; value: string }>
+  | Record<string, string | string[]>
+type ServerType = "http" | "https" | "spdy"
+type WebSocketType = "sockjs" | "ws"
+
+/**
+ * This has the same keys and behavior as https://webpack.js.org/configuration/dev-server/ except:
+ * 1. `hot` is replaced by `hmr`;
+ * 2. Camel-cased properties are replaced by snake-cased ones.
+ * @see {import('webpack-dev-server').Configuration}
+ */
+export interface DevServerConfig {
+  allowed_hosts?: "all" | "auto" | string | string[]
+  bonjour?: boolean | Record<string, unknown> // bonjour.BonjourOptions
+  client?: Record<string, unknown> // Client
+  compress?: boolean
+  dev_middleware?: Record<string, unknown> // webpackDevMiddleware.Options
+  headers?: Header | (() => Header)
+  history_api_fallback?: boolean | Record<string, unknown> // HistoryApiFallbackOptions
+  hmr?: "only" | boolean
+  host?: "local-ip" | "local-ipv4" | "local-ipv6" | string
+  http2?: boolean
+  https?: boolean | https.ServerOptions
+  ipc?: boolean | string
+  magic_html?: boolean
+  live_reload?: boolean
+  inline_css?: boolean
+  env_prefix?: string
+  open?:
+    | boolean
+    | string
+    | string[]
+    | Record<string, unknown>
+    | Record<string, unknown>[]
+  port?: "auto" | string | number
+  proxy?: unknown // ProxyConfigMap | ProxyConfigArray
+  setup_exit_signals?: boolean
+  static?: boolean | string | unknown // Static | Array<string | Static>
+  watch_files?: string | string[] | unknown // WatchFiles | Array<WatchFiles | string>
+  web_socket_server?:
+    | string
+    | boolean
+    | WebSocketType
+    | {
+        type?: string | boolean | WebSocketType
+        options?: Record<string, unknown>
+      }
+  server?:
+    | string
+    | boolean
+    | ServerType
+    | { type?: string | boolean | ServerType; options?: https.ServerOptions }
+  [otherWebpackDevServerConfigKey: string]: unknown
+}
+

data/package/utils/configPath.ts

@@ -0,0 +1,6 @@
+import { resolve } from "path"
+
+const configPath: string =
+  process.env.SHAKAPACKER_CONFIG || resolve("config", "shakapacker.yml")
+
+export = configPath

data/package/utils/{debug.js → debug.ts}

@@ -3,7 +3,7 @@
  * Provides conditional logging based on environment variables
  */
 
-const isDebugMode = () => {
+const isDebugMode = (): boolean => {
   // Explicitly check for debug mode being disabled
   if (process.env.SHAKAPACKER_DEBUG === "false") {
     return false
@@ -16,34 +16,34 @@ const isDebugMode = () => {
   )
 }
 
-const debug = (message, ...args) => {
+const debug = (message: string, ...args: any[]): void => {
   if (isDebugMode()) {
     // eslint-disable-next-line no-console
     console.log(`[Shakapacker] ${message}`, ...args)
   }
 }
 
-const warn = (message, ...args) => {
+const warn = (message: string, ...args: any[]): void => {
   // eslint-disable-next-line no-console
   console.warn(`[Shakapacker] WARNING: ${message}`, ...args)
 }
 
-const error = (message, ...args) => {
+const error = (message: string, ...args: any[]): void => {
   // eslint-disable-next-line no-console
   console.error(`[Shakapacker] ERROR: ${message}`, ...args)
 }
 
-const info = (message, ...args) => {
+const info = (message: string, ...args: any[]): void => {
   if (isDebugMode()) {
     // eslint-disable-next-line no-console
     console.info(`[Shakapacker] INFO: ${message}`, ...args)
   }
 }
 
-module.exports = {
+export = {
   debug,
   warn,
   error,
   info,
   isDebugMode
-}
+}

data/package/utils/defaultConfigPath.ts

@@ -0,0 +1,4 @@
+import { resolve } from "path"
+
+const path: string = resolve(__dirname, "../../lib/install/config/shakapacker.yml")
+export = path

data/package/utils/errorHelpers.ts

@@ -0,0 +1,77 @@
+/**
+ * Error handling utilities for consistent error management
+ */
+
+/**
+ * Checks if an error is a file not found error (ENOENT)
+ */
+export function isFileNotFoundError(error: unknown): boolean {
+  return (
+    error !== null &&
+    typeof error === 'object' &&
+    'code' in error &&
+    (error as NodeJS.ErrnoException).code === 'ENOENT'
+  )
+}
+
+/**
+ * Checks if an error is a module not found error
+ */
+export function isModuleNotFoundError(error: unknown): boolean {
+  return (
+    error !== null &&
+    typeof error === 'object' &&
+    'code' in error &&
+    (error as NodeJS.ErrnoException).code === 'MODULE_NOT_FOUND'
+  )
+}
+
+/**
+ * Creates a consistent error message for file operations
+ */
+export function createFileOperationError(
+  operation: 'read' | 'write' | 'delete',
+  filePath: string,
+  details?: string
+): Error {
+  const baseMessage = `Failed to ${operation} file at path '${filePath}'`
+  const errorDetails = details ? ` - ${details}` : ''
+  const suggestion = operation === 'read' 
+    ? ' (check if file exists and permissions are correct)'
+    : operation === 'write'
+    ? ' (check write permissions and disk space)'
+    : ' (check permissions)'
+  return new Error(`${baseMessage}${errorDetails}${suggestion}`)
+}
+
+/**
+ * Safely gets error message from unknown error type
+ */
+export function getErrorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    // Include stack trace for better debugging in development
+    const isDev = process.env.NODE_ENV === 'development'
+    return isDev && error.stack ? `${error.message}\n${error.stack}` : error.message
+  }
+  if (typeof error === 'string') {
+    return error
+  }
+  if (error && typeof error === 'object' && 'message' in error) {
+    return String((error as { message: unknown }).message)
+  }
+  // Provide more context for truly unknown errors
+  return `Unknown error occurred (type: ${typeof error}, value: ${JSON.stringify(error)})`
+}
+
+/**
+ * Type guard for NodeJS errors with errno
+ */
+export function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+  return (
+    error instanceof Error &&
+    'code' in error &&
+    typeof (error as any).code === 'string'
+  )
+}
+
+

data/package/utils/{getStyleRule.js → getStyleRule.ts}

@@ -3,12 +3,17 @@ const { canProcess, moduleExists } = require("./helpers")
 const { requireOrError } = require("./requireOrError")
 const config = require("../config")
 const inliningCss = require("./inliningCss")
-const { validateCssModulesConfig } = require("./validateCssModulesConfig")
 
-const getStyleRule = (test, preprocessors = []) => {
+interface StyleRule {
+  test: RegExp
+  use: any[]
+  type?: string
+}
+
+const getStyleRule = (test: RegExp, preprocessors: any[] = []): StyleRule | null => {
   if (moduleExists("css-loader")) {
     const tryPostcss = () =>
-      canProcess("postcss-loader", (loaderPath) => ({
+      canProcess("postcss-loader", (loaderPath: string) => ({
         loader: loaderPath,
         options: { sourceMap: true }
       }))
@@ -20,31 +25,23 @@ const getStyleRule = (test, preprocessors = []) => {
         ? requireOrError("@rspack/core").CssExtractRspackPlugin.loader
         : requireOrError("mini-css-extract-plugin").loader
 
-    const cssLoaderOptions = {
-      sourceMap: true,
-      importLoaders: 2,
-      modules: {
-        auto: true,
-        // v9 defaults: named exports with camelCase conversion
-        namedExport: true,
-        exportLocalsConvention: "camelCase"
-      }
-    }
-
-    // Validate CSS modules configuration
-    validateCssModulesConfig(cssLoaderOptions)
-
     const use = [
       inliningCss ? "style-loader" : extractionPlugin,
       {
         loader: require.resolve("css-loader"),
-        options: cssLoaderOptions
+        options: {
+          sourceMap: true,
+          importLoaders: 2,
+          modules: {
+            auto: true
+          }
+        }
       },
       tryPostcss(),
       ...preprocessors
     ].filter(Boolean)
 
-    const result = {
+    const result: StyleRule = {
       test,
       use
     }
@@ -59,4 +56,4 @@ const getStyleRule = (test, preprocessors = []) => {
   return null
 }
 
-module.exports = { getStyleRule }
+export = { getStyleRule }

data/package/utils/helpers.ts

@@ -0,0 +1,85 @@
+const { isModuleNotFoundError, getErrorMessage } = require("./errorHelpers")
+
+const isBoolean = (str: string): boolean => /^true/.test(str) || /^false/.test(str)
+
+const ensureTrailingSlash = (path: string): string => (path.endsWith("/") ? path : `${path}/`)
+
+const resolvedPath = (packageName: string): string | null => {
+  try {
+    return require.resolve(packageName)
+  } catch (error: unknown) {
+    if (!isModuleNotFoundError(error)) {
+      throw error
+    }
+    return null
+  }
+}
+
+const moduleExists = (packageName: string): boolean => !!resolvedPath(packageName)
+
+const canProcess = <T = unknown>(rule: string, fn: (modulePath: string) => T): T | null => {
+  const modulePath = resolvedPath(rule)
+
+  if (modulePath) {
+    return fn(modulePath)
+  }
+
+  return null
+}
+
+const loaderMatches = <T = unknown>(configLoader: string, loaderToCheck: string, fn: () => T): T | null => {
+  if (configLoader !== loaderToCheck) {
+    return null
+  }
+
+  const loaderName = `${configLoader}-loader`
+
+  if (!moduleExists(loaderName)) {
+    throw new Error(
+      `Your Shakapacker config specified using ${configLoader}, but ${loaderName} package is not installed.\n` +
+      `\nTo fix this issue, run one of the following commands:\n` +
+      `  npm install --save-dev ${loaderName}\n` +
+      `  yarn add --dev ${loaderName}\n` +
+      `\nOr change your 'javascript_transpiler' setting in shakapacker.yml to use a different loader.`
+    )
+  }
+
+  return fn()
+}
+
+const packageFullVersion = (packageName: string): string => {
+  try {
+    // eslint-disable-next-line import/no-dynamic-require
+    const packageJsonPath = require.resolve(`${packageName}/package.json`)
+    // eslint-disable-next-line import/no-dynamic-require, global-require
+    const packageJson = require(packageJsonPath) as { version: string }
+    return packageJson.version
+  } catch (error: any) {
+    // Re-throw the error with proper code to maintain compatibility with babel preset
+    // The preset expects MODULE_NOT_FOUND errors to handle missing core-js gracefully
+    if (error.code === "MODULE_NOT_FOUND") {
+      throw error
+    }
+    // For other errors, warn and re-throw
+    console.warn(
+      `[SHAKAPACKER WARNING] Failed to get version for package ${packageName}: ${getErrorMessage(error)}`
+    )
+    throw error
+  }
+}
+
+const packageMajorVersion = (packageName: string): string => {
+  const match = packageFullVersion(packageName).match(/^\d+/)
+  return match ? match[0] : "0"
+}
+
+export {
+  isBoolean,
+  ensureTrailingSlash,
+  canProcess,
+  moduleExists,
+  loaderMatches,
+  packageFullVersion,
+  packageMajorVersion,
+  resolvedPath
+}

data/package/utils/{inliningCss.js → inliningCss.ts}

@@ -2,7 +2,7 @@ const { runningWebpackDevServer } = require("../env")
 const devServer = require("../dev_server")
 
 // This logic is tied to lib/shakapacker/instance.rb
-const inliningCss =
-  runningWebpackDevServer && devServer.hmr && devServer.inline_css !== false
+const inliningCss: boolean =
+  runningWebpackDevServer && !!devServer.hmr && devServer.inline_css !== false
 
-module.exports = inliningCss
+export = inliningCss

data/package/utils/{requireOrError.js → requireOrError.ts}

@@ -2,7 +2,7 @@
 /* eslint import/no-dynamic-require: 0 */
 const config = require("../config")
 
-const requireOrError = (moduleName) => {
+const requireOrError = (moduleName: string): any => {
   try {
     return require(moduleName)
   } catch (error) {
@@ -12,4 +12,4 @@ const requireOrError = (moduleName) => {
   }
 }
 
-module.exports = { requireOrError }
+export = { requireOrError }

data/package/utils/snakeToCamelCase.ts

@@ -0,0 +1,5 @@
+function snakeToCamelCase(s: string): string {
+  return s.replace(/(_\w)/g, (match) => match[1].toUpperCase())
+}
+
+export = snakeToCamelCase

data/package/utils/typeGuards.ts

@@ -0,0 +1,228 @@
+import { Config, DevServerConfig, YamlConfig } from "../types"
+
+// Cache for validated configs in production
+const validatedConfigs = new WeakMap<object, boolean>()
+
+// Only validate in development or when explicitly enabled
+const shouldValidate = process.env.NODE_ENV !== 'production' || process.env.SHAKAPACKER_STRICT_VALIDATION === 'true'
+
+/**
+ * Type guard to validate Config object at runtime
+ * In production, caches results for performance unless SHAKAPACKER_STRICT_VALIDATION is set
+ */
+export function isValidConfig(obj: unknown): obj is Config {
+  if (typeof obj !== 'object' || obj === null) {
+    return false
+  }
+
+  // Quick return for production with cached results
+  if (!shouldValidate && validatedConfigs.has(obj as object)) {
+    return validatedConfigs.get(obj as object) as boolean
+  }
+
+  const config = obj as Record<string, unknown>
+  
+  // Check required string fields
+  const requiredStringFields = [
+    'source_path',
+    'source_entry_path', 
+    'public_root_path',
+    'public_output_path',
+    'cache_path',
+    'javascript_transpiler'
+  ]
+  
+  for (const field of requiredStringFields) {
+    if (typeof config[field] !== 'string') {
+      // Cache negative result in production
+      if (!shouldValidate) {
+        validatedConfigs.set(obj as object, false)
+      }
+      return false
+    }
+  }
+  
+  // Check required boolean fields
+  const requiredBooleanFields = [
+    'nested_entries',
+    'css_extract_ignore_order_warnings',
+    'webpack_compile_output',
+    'shakapacker_precompile',
+    'cache_manifest',
+    'ensure_consistent_versioning',
+    'useContentHash',
+    'compile'
+  ]
+  
+  for (const field of requiredBooleanFields) {
+    if (typeof config[field] !== 'boolean') {
+      // Cache negative result in production
+      if (!shouldValidate) {
+        validatedConfigs.set(obj as object, false)
+      }
+      return false
+    }
+  }
+  
+  // Check arrays
+  if (!Array.isArray(config.additional_paths)) {
+    // Cache negative result in production
+    if (!shouldValidate) {
+      validatedConfigs.set(obj as object, false)
+    }
+    return false
+  }
+  
+  // Check optional fields
+  if (config.dev_server !== undefined && !isValidDevServerConfig(config.dev_server)) {
+    // Cache negative result in production
+    if (!shouldValidate) {
+      validatedConfigs.set(obj as object, false)
+    }
+    return false
+  }
+  
+  if (config.integrity !== undefined) {
+    const integrity = config.integrity as Record<string, unknown>
+    if (typeof integrity.enabled !== 'boolean' || 
+        typeof integrity.cross_origin !== 'string') {
+      // Cache negative result in production
+      if (!shouldValidate) {
+        validatedConfigs.set(obj as object, false)
+      }
+      return false
+    }
+  }
+  
+  const result = true
+  
+  // Cache result in production
+  if (!shouldValidate) {
+    validatedConfigs.set(obj as object, result)
+  }
+  
+  return result
+}
+
+/**
+ * Type guard to validate DevServerConfig object at runtime
+ * In production, performs minimal validation for performance
+ */
+export function isValidDevServerConfig(obj: unknown): obj is DevServerConfig {
+  if (typeof obj !== 'object' || obj === null) {
+    return false
+  }
+  
+  // In production, skip deep validation unless explicitly enabled
+  if (!shouldValidate) {
+    return true
+  }
+  
+  const config = obj as Record<string, unknown>
+  
+  // All fields are optional, just check types if present
+  if (config.hmr !== undefined && 
+      typeof config.hmr !== 'boolean' && 
+      config.hmr !== 'only') {
+    return false
+  }
+  
+  if (config.port !== undefined && 
+      typeof config.port !== 'number' && 
+      typeof config.port !== 'string' &&
+      config.port !== 'auto') {
+    return false
+  }
+  
+  return true
+}
+
+/**
+ * Type guard to validate YamlConfig structure
+ * In production, performs minimal validation for performance
+ */
+export function isValidYamlConfig(obj: unknown): obj is YamlConfig {
+  if (typeof obj !== 'object' || obj === null) {
+    return false
+  }
+  
+  // In production, skip deep validation unless explicitly enabled
+  if (!shouldValidate) {
+    return true
+  }
+  
+  const config = obj as Record<string, unknown>
+  
+  // Each key should map to an object
+  for (const env of Object.keys(config)) {
+    if (typeof config[env] !== 'object' || config[env] === null) {
+      return false
+    }
+  }
+  
+  return true
+}
+
+/**
+ * Validates partial config used for merging
+ * Ensures that if fields are present, they have the correct types
+ * In production, performs minimal validation for performance
+ */
+export function isPartialConfig(obj: unknown): obj is Partial<Config> {
+  if (typeof obj !== 'object' || obj === null) {
+    return false
+  }
+  
+  // In production, skip deep validation unless explicitly enabled
+  if (!shouldValidate) {
+    return true
+  }
+  
+  const config = obj as Record<string, unknown>
+  
+  // Check string fields if present
+  const stringFields = [
+    'source_path', 'source_entry_path', 'public_root_path',
+    'public_output_path', 'cache_path', 'javascript_transpiler'
+  ]
+  
+  for (const field of stringFields) {
+    if (field in config && typeof config[field] !== 'string') {
+      return false
+    }
+  }
+  
+  // Check boolean fields if present
+  const booleanFields = [
+    'nested_entries', 'css_extract_ignore_order_warnings',
+    'webpack_compile_output', 'shakapacker_precompile',
+    'cache_manifest', 'ensure_consistent_versioning'
+  ]
+  
+  for (const field of booleanFields) {
+    if (field in config && typeof config[field] !== 'boolean') {
+      return false
+    }
+  }
+  
+  // Check arrays if present
+  if ('additional_paths' in config && !Array.isArray(config.additional_paths)) {
+    return false
+  }
+  
+  return true
+}
+
+/**
+ * Creates a validation error with helpful context
+ */
+export function createConfigValidationError(
+  configPath: string,
+  environment: string,
+  details?: string
+): Error {
+  const message = `Invalid configuration in ${configPath} for environment '${environment}'`
+  return new Error(details ? `${message}: ${details}` : message)
+}
+
+

data/package/utils/{validateDependencies.js → validateDependencies.ts}

@@ -5,7 +5,7 @@
 const { moduleExists } = require("./helpers")
 const { error } = require("./debug")
 
-const validateRspackDependencies = () => {
+const validateRspackDependencies = (): void => {
   const requiredDependencies = ["@rspack/core", "rspack-manifest-plugin"]
 
   const missingDependencies = requiredDependencies.filter(
@@ -28,7 +28,7 @@ const validateRspackDependencies = () => {
   }
 }
 
-const validateWebpackDependencies = () => {
+const validateWebpackDependencies = (): void => {
   const requiredDependencies = [
     "webpack",
     "webpack-cli",
@@ -55,7 +55,7 @@ const validateWebpackDependencies = () => {
   }
 }
 
-module.exports = {
+export = {
   validateRspackDependencies,
   validateWebpackDependencies
-}
+}