shakapacker 9.0.0.beta.3 → 9.0.0.beta.5

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
-}
+}

data/package/webpack-types.d.ts

@@ -0,0 +1,32 @@
+import type { Configuration, RuleSetRule, RuleSetUseItem } from 'webpack'
+
+export interface ShakapackerWebpackConfig extends Configuration {
+  module?: Configuration['module'] & {
+    rules?: RuleSetRule[]
+  }
+}
+
+export interface ShakapackerRule extends RuleSetRule {
+  test: RegExp
+  use: RuleSetUseItem[]
+}
+
+export interface ShakapackerLoaderOptions {
+  [key: string]: any
+}
+
+export interface ShakapackerLoader {
+  loader: string
+  options?: ShakapackerLoaderOptions
+}
+
+export type LoaderType = string | ShakapackerLoader
+
+export interface LoaderUtils {
+  resolveLoader(name: string): string
+  createRule(test: RegExp, loaders: LoaderType[]): ShakapackerRule
+  getStyleLoader(extract?: boolean): LoaderType
+  getCssLoader(modules?: boolean): LoaderType
+  getPostCssLoader(): LoaderType
+  getSassLoader(): LoaderType
+}

data/package/webpackDevServerConfig.ts

@@ -0,0 +1,117 @@
+import { DevServerConfig } from "./types"
+const snakeToCamelCase = require("./utils/snakeToCamelCase")
+
+const shakapackerDevServerYamlConfig = require("./dev_server") as DevServerConfig
+const { outputPath: contentBase, publicPath } = require("./config") as {
+  outputPath: string
+  publicPath: string
+}
+
+interface WebpackDevServerConfig {
+  devMiddleware?: {
+    publicPath?: string
+  }
+  hot?: boolean | string
+  liveReload?: boolean
+  historyApiFallback?: boolean | {
+    disableDotRule?: boolean
+  }
+  static?: {
+    publicPath?: string
+    [key: string]: unknown
+  }
+  client?: Record<string, unknown>
+  allowedHosts?: "all" | "auto" | string | string[]
+  bonjour?: boolean | Record<string, unknown>
+  compress?: boolean
+  headers?: Record<string, unknown> | (() => Record<string, unknown>)
+  host?: "local-ip" | "local-ipv4" | "local-ipv6" | string
+  http2?: boolean
+  https?: boolean | Record<string, unknown>
+  ipc?: boolean | string
+  magicHtml?: boolean
+  onAfterSetupMiddleware?: (devServer: unknown) => void
+  onBeforeSetupMiddleware?: (devServer: unknown) => void
+  open?: boolean | string | string[] | Record<string, unknown> | Record<string, unknown>[]
+  port?: "auto" | string | number
+  proxy?: unknown
+  server?: string | boolean | Record<string, unknown>
+  setupExitSignals?: boolean
+  setupMiddlewares?: (middlewares: unknown[], devServer: unknown) => unknown[]
+  watchFiles?: string | string[] | unknown
+  webSocketServer?: string | boolean | Record<string, unknown>
+  [key: string]: unknown
+}
+
+const webpackDevServerMappedKeys = new Set([
+  // client, server, liveReload, devMiddleware are handled separately
+  "allowedHosts",
+  "bonjour",
+  "compress",
+  "headers",
+  "historyApiFallback",
+  "host",
+  "hot",
+  "http2",
+  "https",
+  "ipc",
+  "magicHtml",
+  "onAfterSetupMiddleware",
+  "onBeforeSetupMiddleware",
+  "open",
+  "port",
+  "proxy",
+  "server",
+  "setupExitSignals",
+  "setupMiddlewares",
+  "watchFiles",
+  "webSocketServer"
+])
+
+function createDevServerConfig(): WebpackDevServerConfig {
+  const devServerYamlConfig = { ...shakapackerDevServerYamlConfig } as DevServerConfig & Record<string, unknown>
+  const liveReload =
+    devServerYamlConfig.live_reload !== undefined
+      ? devServerYamlConfig.live_reload
+      : !devServerYamlConfig.hmr
+  delete devServerYamlConfig.live_reload
+
+  const config: WebpackDevServerConfig = {
+    devMiddleware: {
+      publicPath
+    },
+    hot: devServerYamlConfig.hmr,
+    liveReload,
+    historyApiFallback: {
+      disableDotRule: true
+    },
+    static: {
+      publicPath: contentBase
+    }
+  }
+  delete devServerYamlConfig.hmr
+
+  if (devServerYamlConfig.static) {
+    config.static = { 
+      ...config.static, 
+      ...(typeof devServerYamlConfig.static === 'object' ? devServerYamlConfig.static as Record<string, unknown> : {})
+    }
+    delete devServerYamlConfig.static
+  }
+
+  if (devServerYamlConfig.client) {
+    config.client = devServerYamlConfig.client
+    delete devServerYamlConfig.client
+  }
+
+  Object.keys(devServerYamlConfig).forEach((yamlKey) => {
+    const camelYamlKey = snakeToCamelCase(yamlKey)
+    if (webpackDevServerMappedKeys.has(camelYamlKey)) {
+      config[camelYamlKey] = devServerYamlConfig[yamlKey]
+    }
+  })
+
+  return config
+}
+
+export = createDevServerConfig

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shakapacker",
-  "version": "9.0.0-beta.3",
+  "version": "9.0.0-beta.5",
   "description": "Use webpack to manage app-like JavaScript modules in Rails",
   "homepage": "https://github.com/shakacode/shakapacker",
   "bugs": {
@@ -29,8 +29,12 @@
     "lib/install/config/shakapacker.yml"
   ],
   "scripts": {
+    "clean:ts": "find package -name '*.ts' -not -name '*.d.ts' | sed 's/\\.ts$//' | xargs -I {} rm -f {}.js {}.d.ts {}.d.ts.map {}.js.map",
+    "build": "tsc",
+    "build:types": "tsc",
     "lint": "eslint .",
-    "test": "jest"
+    "test": "jest",
+    "type-check": "tsc --noEmit"
   },
   "dependencies": {
     "js-yaml": "^4.1.0",