shakapacker 8.4.0 → 9.7.0

data/test/configExporter/configFile.test.js

@@ -0,0 +1,393 @@
+/* eslint-disable no-template-curly-in-string */
+const {
+  writeFileSync,
+  mkdirSync,
+  rmSync,
+  existsSync,
+  symlinkSync
+} = require("fs")
+const { resolve, join } = require("path")
+const { tmpdir } = require("os")
+const {
+  ConfigFileLoader,
+  generateSampleConfigFile
+} = require("../../package/configExporter")
+
+describe("ConfigFileLoader", () => {
+  const testDir = resolve(__dirname, "../tmp/config-file-test")
+  let configPath
+
+  beforeEach(() => {
+    // Create test directory
+    if (!existsSync(testDir)) {
+      mkdirSync(testDir, { recursive: true })
+    }
+    mkdirSync(join(testDir, "config"), { recursive: true })
+    configPath = join(testDir, "config/shakapacker-builds.yml")
+  })
+
+  afterEach(() => {
+    // Clean up test directory
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true })
+    }
+  })
+
+  describe("validateConfigPath", () => {
+    it("should reject path traversal attempts with ..", () => {
+      // Use a path that's definitely outside the project
+      const maliciousPath = "/etc/passwd"
+      expect(() => {
+        // eslint-disable-next-line no-new
+        new ConfigFileLoader(maliciousPath)
+      }).toThrow(/Config file must be within project directory/)
+    })
+
+    it("should reject symlink traversal to files outside project", async () => {
+      const outsideFile = join(tmpdir(), `test-outside-${Date.now()}.yml`)
+      const symlinkPath = join(testDir, "symlink-config.yml")
+
+      const cleanup = () => {
+        try {
+          rmSync(symlinkPath, { force: true })
+          // eslint-disable-next-line no-empty
+        } catch {}
+        try {
+          rmSync(outsideFile, { force: true })
+          // eslint-disable-next-line no-empty
+        } catch {}
+      }
+
+      try {
+        // Create a real file outside the project (in system temp dir)
+        writeFileSync(
+          outsideFile,
+          "builds:\n  test:\n    outputs:\n      - client\n"
+        )
+
+        // Attempt to create symlink
+        try {
+          symlinkSync(outsideFile, symlinkPath)
+        } catch (error) {
+          // Skip test if symlinks aren't supported or require elevated permissions
+          const skipCodes = ["EPERM", "ENOSYS", "EACCES"]
+          cleanup()
+          // eslint-disable-next-line jest/no-conditional-expect
+          expect(skipCodes).toContain(error.code)
+          return
+        }
+
+        // Verify that loading via symlink is rejected
+        expect(() => {
+          // eslint-disable-next-line no-new
+          new ConfigFileLoader(symlinkPath)
+        }).toThrow(/Config file must be within project directory/)
+
+        cleanup()
+      } catch (error) {
+        cleanup()
+        throw error
+      }
+    })
+
+    it("should accept paths within the project directory", () => {
+      expect(() => {
+        // eslint-disable-next-line no-new
+        new ConfigFileLoader(configPath)
+      }).not.toThrow()
+    })
+  })
+
+  describe("exists", () => {
+    it("should return false when config file does not exist", () => {
+      const loader = new ConfigFileLoader(configPath)
+      expect(loader.exists()).toBe(false)
+    })
+
+    it("should return true when config file exists", () => {
+      writeFileSync(configPath, "default_bundler: webpack\nbuilds: {}")
+      const loader = new ConfigFileLoader(configPath)
+      expect(loader.exists()).toBe(true)
+    })
+  })
+
+  describe("load", () => {
+    it("should load valid YAML config", () => {
+      writeFileSync(
+        configPath,
+        `
+default_bundler: rspack
+builds:
+  dev:
+    description: Development build
+    environment:
+      NODE_ENV: development
+    outputs:
+      - client
+      - server
+`
+      )
+      const loader = new ConfigFileLoader(configPath)
+      const loaded = loader.load()
+      expect(loaded.default_bundler).toBe("rspack")
+      expect(loaded.builds.dev).toBeDefined()
+      expect(loaded.builds.dev.description).toBe("Development build")
+    })
+
+    it("should throw error for malformed YAML", () => {
+      writeFileSync(configPath, "invalid: yaml: content:\n  - broken")
+      const loader = new ConfigFileLoader(configPath)
+      expect(() => loader.load()).toThrow(Error)
+    })
+
+    it("should throw error if builds key is missing", () => {
+      writeFileSync(configPath, "default_bundler: webpack")
+      const loader = new ConfigFileLoader(configPath)
+      expect(() => loader.load()).toThrow(/must contain a 'builds'/)
+    })
+
+    it("should throw error if builds is not an object", () => {
+      writeFileSync(configPath, "builds: []")
+      const loader = new ConfigFileLoader(configPath)
+      expect(() => loader.load()).toThrow(/must contain at least one build/)
+    })
+  })
+
+  describe("resolveBuild", () => {
+    beforeEach(() => {
+      writeFileSync(
+        configPath,
+        `
+default_bundler: rspack
+builds:
+  dev:
+    description: Development build
+    environment:
+      NODE_ENV: development
+      RAILS_ENV: development
+    outputs:
+      - client
+      - server
+  prod:
+    description: Production build
+    bundler: webpack
+    environment:
+      NODE_ENV: production
+    outputs:
+      - client
+`
+      )
+    })
+
+    it("should throw error for non-existent build", () => {
+      const loader = new ConfigFileLoader(configPath)
+      expect(() => {
+        loader.resolveBuild("nonexistent", {}, "webpack")
+      }).toThrow(/Build 'nonexistent' not found/)
+    })
+
+    it("should resolve build with environment variables", () => {
+      const loader = new ConfigFileLoader(configPath)
+      const resolved = loader.resolveBuild("dev", {}, "webpack")
+      expect(resolved.name).toBe("dev")
+      expect(resolved.environment.NODE_ENV).toBe("development")
+      expect(resolved.environment.RAILS_ENV).toBe("development")
+      expect(resolved.outputs).toStrictEqual(["client", "server"])
+    })
+
+    it("should use build-specific bundler over default", () => {
+      const loader = new ConfigFileLoader(configPath)
+      const resolved = loader.resolveBuild("prod", {}, "rspack")
+      expect(resolved.bundler).toBe("webpack")
+    })
+
+    it("should use CLI bundler option over everything", () => {
+      const loader = new ConfigFileLoader(configPath)
+      const resolved = loader.resolveBuild(
+        "prod",
+        { bundler: "rspack" },
+        "webpack"
+      )
+      expect(resolved.bundler).toBe("rspack")
+    })
+  })
+
+  describe("edge case validation", () => {
+    it("should throw error for empty outputs array", () => {
+      writeFileSync(
+        configPath,
+        `
+builds:
+  bad:
+    environment:
+      NODE_ENV: development
+    outputs: []
+`
+      )
+      const loader = new ConfigFileLoader(configPath)
+      expect(() => {
+        loader.resolveBuild("bad", {}, "webpack")
+      }).toThrow(/empty outputs array/)
+    })
+
+    it("should throw error for duplicate outputs", () => {
+      writeFileSync(
+        configPath,
+        `
+builds:
+  bad:
+    environment:
+      NODE_ENV: development
+    outputs:
+      - client
+      - client
+      - server
+`
+      )
+      const loader = new ConfigFileLoader(configPath)
+      expect(() => {
+        loader.resolveBuild("bad", {}, "webpack")
+      }).toThrow(/duplicate output types/)
+    })
+
+    it("should throw error for invalid config file path with path traversal", () => {
+      writeFileSync(
+        configPath,
+        `
+builds:
+  bad:
+    environment:
+      NODE_ENV: development
+    config: ../../../malicious.js
+    outputs:
+      - client
+`
+      )
+      const loader = new ConfigFileLoader(configPath)
+      expect(() => {
+        loader.resolveBuild("bad", {}, "webpack")
+      }).toThrow(/Invalid config file path/)
+    })
+  })
+
+  describe("environment variable expansion", () => {
+    beforeEach(() => {
+      process.env.TEST_VAR = "test-value"
+      process.env.BUNDLER_VAR = "should-not-be-used"
+    })
+
+    afterEach(() => {
+      delete process.env.TEST_VAR
+      delete process.env.BUNDLER_VAR
+    })
+
+    it("should expand ${BUNDLER} variable", () => {
+      writeFileSync(
+        configPath,
+        "builds:\n  test:\n    environment:\n      CONFIG_PATH: config/${BUNDLER}/config.js\n    outputs:\n      - client\n"
+      )
+      const loader = new ConfigFileLoader(configPath)
+      const resolved = loader.resolveBuild("test", {}, "rspack")
+      expect(resolved.environment.CONFIG_PATH).toBe("config/rspack/config.js")
+    })
+
+    it("should expand ${VAR} from environment", () => {
+      writeFileSync(
+        configPath,
+        "builds:\n  test:\n    environment:\n      CUSTOM: ${TEST_VAR}\n    outputs:\n      - client\n"
+      )
+      const loader = new ConfigFileLoader(configPath)
+      const resolved = loader.resolveBuild("test", {}, "webpack")
+      expect(resolved.environment.CUSTOM).toBe("test-value")
+    })
+
+    it("should expand ${VAR:-default} with default value", () => {
+      writeFileSync(
+        configPath,
+        "builds:\n  test:\n    environment:\n      WITH_DEFAULT: ${NONEXISTENT:-fallback-value}\n    outputs:\n      - client\n"
+      )
+      const loader = new ConfigFileLoader(configPath)
+      const resolved = loader.resolveBuild("test", {}, "webpack")
+      expect(resolved.environment.WITH_DEFAULT).toBe("fallback-value")
+    })
+
+    it("should use environment value over default in ${VAR:-default}", () => {
+      writeFileSync(
+        configPath,
+        "builds:\n  test:\n    environment:\n      WITH_DEFAULT: ${TEST_VAR:-fallback-value}\n    outputs:\n      - client\n"
+      )
+      const loader = new ConfigFileLoader(configPath)
+      const resolved = loader.resolveBuild("test", {}, "webpack")
+      expect(resolved.environment.WITH_DEFAULT).toBe("test-value")
+    })
+
+    it("should reject invalid environment variable names", () => {
+      writeFileSync(
+        configPath,
+        "builds:\n  test:\n    environment:\n      BAD: ${Invalid-Var-Name}\n    outputs:\n      - client\n"
+      )
+      const loader = new ConfigFileLoader(configPath)
+      const resolved = loader.resolveBuild("test", {}, "webpack")
+      // Should not expand invalid var names (contains hyphen)
+      expect(resolved.environment.BAD).toBe("${Invalid-Var-Name}")
+    })
+  })
+
+  describe("bundler_env conversion", () => {
+    it("should convert bundler_env to CLI arguments", () => {
+      writeFileSync(
+        configPath,
+        `
+builds:
+  test:
+    environment:
+      NODE_ENV: production
+    bundler_env:
+      target: modern
+      instrumented: true
+      disabled: false
+    outputs:
+      - client
+`
+      )
+      const loader = new ConfigFileLoader(configPath)
+      const resolved = loader.resolveBuild("test", {}, "webpack")
+
+      // YAML parses booleans as true/false, or as strings "true"/"false"
+      // The code handles both cases: true or "true" becomes a flag, false/"false" is ignored
+      // Expected format: ['--env', 'target=modern', '--env', 'instrumented']
+      expect(resolved.bundlerEnvArgs).toContain("--env")
+      expect(resolved.bundlerEnvArgs).toContain("target=modern")
+
+      // Boolean true becomes a flag (--env key), false is ignored
+      const argsString = resolved.bundlerEnvArgs.join(" ")
+      expect(argsString).toContain("--env instrumented")
+      expect(argsString).not.toContain("disabled")
+    })
+  })
+})
+
+describe("generateSampleConfigFile", () => {
+  it("should generate valid YAML string", () => {
+    const content = generateSampleConfigFile()
+    expect(content).toContain("builds:")
+    expect(content).toContain("dev-hmr:")
+    expect(content).toContain("dev_server: true")
+    expect(content).toContain("dev:")
+    expect(content).toContain("prod:")
+  })
+
+  it("should include documentation comments", () => {
+    const content = generateSampleConfigFile()
+    expect(content).toContain("# Bundler Build Configurations")
+    expect(content).toContain("HMR")
+    expect(content).toContain("production")
+  })
+
+  it("should escape template literal variables correctly", () => {
+    const content = generateSampleConfigFile()
+    // Should have ${BUNDLER} not actual 'webpack' or 'rspack'
+    expect(content).toContain("${BUNDLER}")
+    expect(content).toContain("${RAILS_ENV:-staging}")
+  })
+})

data/test/configExporter/integration.test.js

@@ -0,0 +1,262 @@
+const {
+  writeFileSync,
+  mkdirSync,
+  rmSync,
+  existsSync,
+  readdirSync
+} = require("fs")
+const { resolve, join } = require("path")
+const { execSync } = require("child_process")
+
+describe("Config Exporter Integration Tests", () => {
+  const testDir = resolve(__dirname, "../tmp/integration-test")
+  const configPath = join(testDir, "config/shakapacker-builds.yml")
+  const outputDir = join(testDir, "output")
+  const binPath = resolve(__dirname, "../../bin/shakapacker-config")
+
+  beforeEach(() => {
+    // Create test directory
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true })
+    }
+    mkdirSync(testDir, { recursive: true })
+    mkdirSync(join(testDir, "config"), { recursive: true })
+
+    // Create minimal package.json
+    writeFileSync(
+      join(testDir, "package.json"),
+      JSON.stringify({ name: "test-app", private: true })
+    )
+
+    // Create minimal shakapacker.yml
+    writeFileSync(
+      join(testDir, "shakapacker.yml"),
+      `default: &default
+  source_path: app/javascript
+  source_entry_path: /
+  public_root_path: public
+  public_output_path: packs
+
+development:
+  <<: *default
+  compile: true
+
+production:
+  <<: *default
+  compile: true
+`
+    )
+
+    // Create minimal webpack config that doesn't require shakapacker
+    mkdirSync(join(testDir, "config", "webpack"), { recursive: true })
+    writeFileSync(
+      join(testDir, "config", "webpack", "webpack.config.js"),
+      `module.exports = {
+  mode: process.env.NODE_ENV || 'development',
+  entry: './app/javascript/application.js',
+  output: {
+    path: require('path').resolve(__dirname, '../../public/packs'),
+    filename: '[name].js'
+  }
+}\n`
+    )
+
+    // Create minimal entry file
+    mkdirSync(join(testDir, "app", "javascript"), { recursive: true })
+    writeFileSync(
+      join(testDir, "app", "javascript", "application.js"),
+      "// Test entry file\nconsole.log('test');\n"
+    )
+  })
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true })
+    }
+  })
+
+  describe("--all-builds with environment variable isolation", () => {
+    it("should isolate environment variables between builds", () => {
+      // Create config with builds that have different env vars
+      const configContent = `
+default_bundler: webpack
+
+builds:
+  dev-hmr:
+    description: Development with HMR
+    environment:
+      NODE_ENV: development
+      RAILS_ENV: development
+      WEBPACK_SERVE: "true"
+    outputs:
+      - client
+
+  dev:
+    description: Development without HMR
+    environment:
+      NODE_ENV: development
+      RAILS_ENV: development
+    outputs:
+      - client
+
+  prod:
+    description: Production
+    environment:
+      NODE_ENV: production
+      RAILS_ENV: production
+    outputs:
+      - client
+`
+      writeFileSync(configPath, configContent)
+
+      // Run --all-builds command
+      const result = execSync(
+        `cd "${testDir}" && node "${binPath}" --all-builds --save-dir="${outputDir}"`,
+        { encoding: "utf8" }
+      )
+
+      // Verify output
+      expect(result).toContain("Exporting 3 builds")
+      expect(result).toContain("dev-hmr")
+      expect(result).toContain("dev")
+      expect(result).toContain("prod")
+
+      // Verify files were created
+      expect(existsSync(outputDir)).toBe(true)
+      const files = readdirSync(outputDir)
+
+      // Should have 3 files (one per build)
+      expect(files).toHaveLength(3)
+      expect(files).toContain("webpack-dev-hmr-client.yml")
+      expect(files).toContain("webpack-dev-client.yml")
+      expect(files).toContain("webpack-prod-client.yml")
+
+      // Verify files have different content (proving environment isolation)
+      const devHmrContent = require("fs").readFileSync(
+        join(outputDir, "webpack-dev-hmr-client.yml"),
+        "utf8"
+      )
+      const devContent = require("fs").readFileSync(
+        join(outputDir, "webpack-dev-client.yml"),
+        "utf8"
+      )
+      const prodContent = require("fs").readFileSync(
+        join(outputDir, "webpack-prod-client.yml"),
+        "utf8"
+      )
+
+      // All three files should be different (proving isolation)
+      expect(devHmrContent).not.toBe(devContent)
+      expect(devContent).not.toBe(prodContent)
+      expect(devHmrContent).not.toBe(prodContent)
+
+      // Verify environment-specific values
+      expect(devContent).toContain("mode: development")
+      expect(prodContent).toContain("mode: production")
+    })
+  })
+
+  describe("--doctor mode with config file", () => {
+    it("should always use config file builds when config exists", () => {
+      // Create config with custom builds
+      const configContent = `
+builds:
+  custom-dev:
+    description: Custom development
+    environment:
+      NODE_ENV: development
+      RAILS_ENV: development
+    outputs:
+      - client
+
+  custom-prod:
+    description: Custom production
+    environment:
+      NODE_ENV: production
+      RAILS_ENV: production
+    outputs:
+      - client
+`
+      writeFileSync(configPath, configContent)
+
+      // Run --doctor command
+      const result = execSync(
+        `cd "${testDir}" && node "${binPath}" --doctor --save-dir="${outputDir}"`,
+        { encoding: "utf8" }
+      )
+
+      // Verify it used config builds
+      expect(result).toContain(
+        "Using builds from config/shakapacker-builds.yml"
+      )
+      expect(result).toContain("custom-dev")
+      expect(result).toContain("custom-prod")
+
+      // Verify files
+      expect(existsSync(outputDir)).toBe(true)
+      const files = readdirSync(outputDir)
+      expect(files).toContain("webpack-custom-dev-client.yml")
+      expect(files).toContain("webpack-custom-prod-client.yml")
+    })
+
+    it("should use fallback builds when no config file exists", () => {
+      // Don't create config file
+
+      // Run --doctor command
+      const result = execSync(
+        `cd "${testDir}" && node "${binPath}" --doctor --save-dir="${outputDir}"`,
+        { encoding: "utf8" }
+      )
+
+      // Verify it warns and uses hardcoded fallback builds
+      expect(result).toContain("No build config file found")
+      expect(result).toContain("bin/shakapacker-config --init")
+      expect(result).toContain("development (HMR)")
+      expect(result).toContain("development")
+      expect(result).toContain("production")
+    })
+  })
+
+  describe("hMR config generation", () => {
+    it("should generate HMR client config with correct metadata", () => {
+      const configContent = `
+default_bundler: webpack
+
+builds:
+  dev-hmr:
+    description: Development with HMR
+    environment:
+      NODE_ENV: development
+      RAILS_ENV: development
+      WEBPACK_SERVE: "true"
+    outputs:
+      - client
+`
+      writeFileSync(configPath, configContent)
+
+      // Run command
+      execSync(
+        `cd "${testDir}" && node "${binPath}" --build=dev-hmr --save-dir="${outputDir}"`,
+        { encoding: "utf8" }
+      )
+
+      // Verify HMR file was created with correct naming
+      expect(existsSync(outputDir)).toBe(true)
+      const files = readdirSync(outputDir)
+
+      // Should create file with -hmr suffix or similar indicator
+      expect(files).toHaveLength(1)
+      const filename = files[0]
+
+      // Read content and verify it's a valid webpack config
+      const content = require("fs").readFileSync(
+        join(outputDir, filename),
+        "utf8"
+      )
+      // Verify it contains webpack config content
+      expect(content).toContain("mode: development")
+      expect(content).toContain("entry:")
+      expect(content).toContain("output:")
+    })
+  })
+})

data/test/helpers.js

@@ -43,7 +43,7 @@ const createTestCompiler = (config, fs = createInMemoryFs()) => {
 const chdirTestApp = () => {
   try {
     return process.chdir("spec/shakapacker/test_app")
-  } catch (e) {
+  } catch {
     return null
   }
 }