js-routes 1.4.14 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8a952ba9e2f582074e459b770227628ee2cecf37cd50d03978ba9690bac5a94
-  data.tar.gz: 151da0e08b1b47fd6caa3bfbb1a5311ac0a528a9c88bb53b05dea181438823fb
+  metadata.gz: 52b735748b525770a79a5dcb0fe510b50350e3e22541fcb34f39fbc04b9a4f02
+  data.tar.gz: ca5ec3a0e5adcf943854681413dfc11f4da9cd91c46a3bb817ee85ea6da303a0
 SHA512:
-  metadata.gz: 586fc3bcbef2fc96c12b0d53b5f9fd58eb19b8f5987ca7a6dac068ecc6865c363a4207e69afd4d0fe0c6d252d7b0c507428c7257a99cabf6fc34ba0c5afe29ea
-  data.tar.gz: 10276a454e7f07fe6166957c18516214c34853859f4e8645e06105984e80fb18b77016cbc398a1cdd5351eba6f4d38ce78555f34498be04f35e353c341500c75
+  metadata.gz: 820f89d751dfb532235098abcaf5a26e568d5acd34ab469ccf8d61dfaa4427ac59e8597860ce9cd05728869c401d72e5beb6501aac2ee9713772091db80cc0d5
+  data.tar.gz: 0ba55b8c600a1ea89737a860b5ca728572972e149900c35fd39ac439dcae0f9af8541649f356c4341b4331a73ede9382ed20b9c75311cb24c27cb7eebd510c29

data/.eslintrc.js

@@ -0,0 +1,15 @@
+ module.exports = {
+  root: true,
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/eslint-recommended',
+    'plugin:@typescript-eslint/recommended',
+    'prettier/@typescript-eslint',
+  ],
+  parser: '@typescript-eslint/parser',
+  plugins: ['@typescript-eslint'],
+  rules: {
+    '@typescript-eslint/ban-types': 'off',
+    '@typescript-eslint/no-explicit-any': 'off'
+  },
+};

data/.gitignore

@@ -60,3 +60,5 @@ gemfiles/*.lock
 /spec/dummy/app/assets/javascripts/routes.js
 /spec/dummy/logs
 /spec/dummy/tmp
+node_modules
+

data/.nvmrc

@@ -0,0 +1 @@
+14

data/.travis.yml

@@ -5,7 +5,6 @@ before_install:
   - gem install bundler # need for jruby and ruby-head
 
 rvm:
-  - 2.3.1
   - 2.4.1
   - 2.5.3
   - 2.6.0
@@ -22,6 +21,8 @@ gemfile:
   - gemfiles/rails50_sprockets_3.gemfile
   - gemfiles/rails51_sprockets_3.gemfile
   - gemfiles/rails52_sprockets_3.gemfile
+env:
+  TRAVIS_CI: true
 
 sudo: false
 dist: xenial

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 ## master
 
+## v2.0.1
+
+* Fixed backward compatibility issue [#272](https://github.com/railsware/js-routes/issues/272)
+
+## v2.0.0
+
+Version 2.0 has some breaking changes.
+See [UPGRADE TO 2.0](./VERSION_2_UPGRADE.md) for guidance.
+
+* `module_type` option support
+* `documentation` option spport
+* Migrated implementation to typescript
+* ESM tree shaking support
+* Support camel case `toParam` version of `to_param` property
+
 ## v1.4.14
 
 * Fix compatibility with UMD modules #237 [Comment](https://github.com/railsware/js-routes/issues/237#issuecomment-752754679)

data/Readme.md

@@ -4,6 +4,8 @@
 
 Generates javascript file that defines all Rails named routes as javascript helpers
 
+[UPGRADE TO 2.0](./VERSION_2_UPGRADE.md)
+
 ## Intallation
 
 Your Rails Gemfile:
@@ -14,6 +16,8 @@ gem "js-routes"
 
 ## Setup
 
+### Quick Start 
+
 Run:
 
 ```
@@ -23,19 +27,24 @@ rake js:routes
 Make routes available globally in `app/javascript/packs/application.js`: 
 
 ``` javascript
-window.Routes = require('routes');
+import * as Routes from 'routes';
+window.Routes = Routes;
 ```
 
 Individual routes can be imported using:
 
 ``` javascript
-import {edit_post_path, new_post_path} from 'routes';
+import {edit_post_path} from 'routes';
+console.log(edit_post_path(1))
 ```
 
 **Note**: that this setup requires `rake js:routes` to be run each time routes file is updated.
 
+<div id='webpacker'></div>
+
 #### Webpacker + automatic updates
 
+
 This setup can automatically update your routes without `rake js:routes` being called manually.
 It requires [rails-erb-loader](https://github.com/usabilityhub/rails-erb-loader) npm package to work.
 
@@ -62,9 +71,9 @@ module.exports = {
 }
 ```
 
-Enable `erb` extension in `config/webpacker/environment.js`:
+Enable `erb` extension in `config/webpack/environment.js`:
 
-```
+``` javascript
 const erb = require('./loaders/erb')
 environment.loaders.append('erb', erb)
 ```
@@ -78,13 +87,23 @@ Create routes file `app/javascript/routes.js.erb`:
 Use routes wherever you need them `app/javascript/packs/application.js`: 
 
 ``` javascript
-window.Routes = require('routes.js.erb');
+import * as Routes from 'routes.js.erb';
+window.Routes = Routes;
 ```
 
 #### Sprockets (Deprecated)
 
 If you are using [Sprockets](https://github.com/rails/sprockets-rails) you may configure js-routes in the following way.
 
+Setup the initializer (e.g. `config/initializers/js_routes.rb`):
+
+``` ruby
+JsRoutes.setup do |config|
+  config.module_type = nil
+  config.namespace = 'Routes'
+end
+```
+
 Require JsRoutes in `app/assets/javascripts/application.js` or other bundle
 
 ``` js
@@ -114,6 +133,7 @@ end
 Or dynamically in JavaScript, although only [Formatter Options](#formatter-options) are supported (see below)
 
 ``` js
+import * as Routes from 'routes'
 Routes.configure({
   option: value
 });
@@ -126,6 +146,12 @@ Routes.config(); // current config
 
 Options to configure JavaScript file generator. These options are only available in Ruby context but not JavaScript.
 
+* `module_type` - JavaScript module type for generated code. [Article](https://dev.to/iggredible/what-the-heck-are-cjs-amd-umd-and-esm-ikm)
+  * Options: `ESM`, `UMD`, `CJS`, `AMD`, `nil`.
+  * Default: `ESM`
+  * `nil` option can be used in case you don't want generated code to export anything.
+* `documentation` - specifies if each route should be annotated with [JSDoc](https://jsdoc.app/) comment
+  * Default: `true`
 * `exclude` - Array of regexps to exclude from routes.
   * Default: `[]`
   * The regexp applies only to the name before the `_path` suffix, eg: you want to match exactly `settings_path`, the regexp should be `/^settings$/`
@@ -134,11 +160,10 @@ Options to configure JavaScript file generator. These options are only available
   * The regexp applies only to the name before the `_path` suffix, eg: you want to match exactly `settings_path`, the regexp should be `/^settings$/`
 * `namespace` - global object used to access routes.
   * Supports nested namespace like `MyProject.routes`
-  * Default: `Routes`
-* `camel_case` - Generate camel case route names.
+  * Default: `nil`
+* `camel_case` - specifies if route helpers should be generated in camel case instead of underscore case.
   * Default: `false`
-* `url_links` - Generate `*_url` helpers (in addition to the default `*_path` helpers).
-  * Example: `true`
+* `url_links` - specifies if `*_url` helpers should be generated (in addition to the default `*_path` helpers).
   * Default: `false`
   * Note: generated URLs will first use the protocol, host, and port options specified in the route definition. Otherwise, the URL will be based on the option specified in the `default_url_options` config. If no default option has been set, then the URL will fallback to the current URL based on `window.location`.
 * `compact` - Remove `_path` suffix in path routes(`*_url` routes stay untouched if they were enabled)
@@ -173,29 +198,30 @@ Options to configure routes formatting. These options are available both in Ruby
 In case you need multiple route files for different parts of your application, you have to create the files manually.
 If your application has an `admin` and an `application` namespace for example:
 
-```
-# app/javascript/admin/routes.js.erb
-<%= JsRoutes.generate(namespace: "AdminRoutes", include: /admin/) %>
+``` erb
+// app/javascript/admin/routes.js.erb
+<%= JsRoutes.generate(include: /admin/) %>
 ```
 
-```
-# app/javascript/customer/routes.js.erb
-<%= JsRoutes.generate(namespace: "CustomerRoutes", exclude: /admin/) %>
+``` erb
+// app/javascript/customer/routes.js.erb
+<%= JsRoutes.generate(exclude: /admin/) %>
 ```
 
-In order to generate the routes JS code to a string:
+You can manipulate the generated helper manually by injecting ruby into javascript:
 
-``` ruby
-routes_js = JsRoutes.generate(options)
+``` erb
+export const routes = <%= JsRoutes.generate(module_type: nil, namespace: nil) %>
 ```
 
 If you want to generate the routes files outside of the asset pipeline, you can use `JsRoutes.generate!`:
 
 ``` ruby
-path = "app/javascript"
-JsRoutes.generate!("#{path}/app_routes.js", namespace: "AppRoutes", exclude: [/^admin_/, /^api_/])
-JsRoutes.generate!("#{path}/adm_routes.js", namespace: "AdmRoutes", include: /^admin_/)
-JsRoutes.generate!("#{path}/api_routes.js", namespace: "ApiRoutes", include: /^api_/, default_url_options: {format: "json"})
+path = Rails.root.join("app/javascript")
+
+JsRoutes.generate!("#{path}/app_routes.js", exclude: [/^admin_/, /^api_/])
+JsRoutes.generate!("#{path}/adm_routes.js", include: /^admin_/)
+JsRoutes.generate!("#{path}/api_routes.js", include: /^api_/, default_url_options: {format: "json"})
 ```
 
 ## Usage
@@ -203,6 +229,8 @@ JsRoutes.generate!("#{path}/api_routes.js", namespace: "ApiRoutes", include: /^a
 Configuration above will create a nice javascript file with `Routes` object that has all the rails routes available:
 
 ``` js
+import * as Routes from 'routes';
+
 Routes.users_path() // => "/users"
 Routes.user_path(1) // => "/users/1"
 Routes.user_path(1, {format: 'json'}) // => "/users/1.json"
@@ -243,11 +271,11 @@ This function allow to get the same `spec` for route, if you will get string rep
 '' + Routes.user_path // => "/users/:id(.:format)"
 ```
 
-Route function also contain inside attribute `required_params` required param names as array:
+Route function also contain method `requiredParams` inside which returns required param names array:
 
 ```js
-Routes.users_path.required_params // => []
-Routes.user_path.required_params // => ['id']
+Routes.users_path.requiredParams() // => []
+Routes.user_path.requiredParams() // => ['id']
 ```
 
 
@@ -268,9 +296,34 @@ Routes.company_project_path({company_id: 1, id: 2, _options: true}) // => "/comp
 
 ## What about security?
 
-JsRoutes itself does not have security holes. It makes URLs
-without access protection more reachable by potential attacker.
-In order to prevent this use `:exclude` option for sensitive urls like `/admin_/`
+JsRoutes itself does not have security holes. 
+It makes URLs without access protection more reachable by potential attacker.
+If that is an issue for you, you may use one of the following solutions:
+
+### Explicit Import + ESM Tree shaking
+
+Make sure `module_type` is set to `ESM` (the default) and JS files import only required routes into the file like:
+
+``` javascript
+import {
+  inbox_path,
+  inboxes_path,
+  inbox_message_path,
+  inbox_attachment_path,
+  user_path,
+} from 'routes.js.erb'
+```
+
+### Exclude option
+
+Split your routes into multiple files related to each section of your website like:
+
+``` javascript
+// admin-routes.js.erb
+<%= JsRoutes.generate(include: /^admin_/)
+// app-routes.js.erb
+<%= JsRoutes.generate(exclude: /^admin_/)
+```
 
 ## JsRoutes and Heroku
 
@@ -290,11 +343,20 @@ There are some alternatives available. Most of them has only basic feature and d
 Advantages of this one are:
 
 * Rails 4,5,6 support
+* [ESM Tree shaking](https://webpack.js.org/guides/tree-shaking/) support
 * Rich options set
 * Full rails compatibility
 * Support Rails `#to_param` convention for seo optimized paths
 * Well tested
 
+## Version 2 TODO
+
+* Add routes generation .d.ts file
+* Add config option on the output format: js, ts, d.ts
+* Add prettier
+* Add eslint
+* Add development guide
+
 #### Thanks to [contributors](https://github.com/railsware/js-routes/contributors)
 
 #### Have fun

data/VERSION_2_UPGRADE.md

@@ -0,0 +1,61 @@
+## Version 2.0 upgrade notes
+
+### Using ESM module by default
+
+The default setting are now changed:
+
+Setting | Old | New 
+--- | --- | ---
+module\_type | nil | ESM 
+namespace | Routes | nil
+
+This is more optimized setup for WebPacker. You can restore the old configuration like this:
+
+``` ruby
+JsRoutes.setup do |config|
+  config.module_type = nil
+  config.namespace = 'Routes'
+end
+```
+
+However, [ESM+Webpacker](/Readme.md#webpacker) upgrade is recommended. 
+
+### `required_params` renamed
+
+In case you are using `required_params` property, it is now renamed and converted to a method:
+
+``` javascript
+// Old style
+Routes.post_path.required_params  // => ['id']
+// New style
+Routes.post_path.requiredParams() // => ['id']
+```
+
+### ParameterMissing error rework
+
+`ParameterMissing` is renamed to `ParametersMissing` error and now list all missing parameters instead of just first encountered in its message. Missing parameters are now available via `ParametersMissing#keys` property.
+
+``` javascript
+try {
+  return Routes.inbox_path();
+} catch(error) {
+  if (error.name === 'ParametersMissing') {
+    console.warn(`Missing route keys ${error.keys.join(', ')}. Ignoring.`);
+    return "#";
+  } else {
+    throw error;
+  }
+}
+```
+
+### JSDoc comment format
+
+New version of js-routes generates function comment in the [JSDoc](https://jsdoc.app) format.
+If you have any problems with that disable the annotation:
+
+``` ruby
+JsRoutes.setup do |config|
+  config.documentation = false
+end
+```
+

data/js-routes.gemspec

@@ -7,13 +7,16 @@ Gem::Specification.new do |s|
   s.name = %q{js-routes}
   s.version = JsRoutes::VERSION
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  if s.respond_to? :required_rubygems_version=
+    s.required_rubygems_version = Gem::Requirement.new(">= 0")
+  end
   s.authors = ["Bogdan Gusiev"]
   s.description = %q{Generates javascript file that defines all Rails named routes as javascript helpers}
   s.email = %q{agresso@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE.txt"
   ]
+  s.required_ruby_version = '>= 2.4.0'
   s.files = `git ls-files`.split("\n")
   s.homepage = %q{http://github.com/railsware/js-routes}
   s.licenses = ["MIT"]
@@ -24,13 +27,13 @@ Gem::Specification.new do |s|
   s.add_development_dependency(%q<sprockets-rails>)
   s.add_development_dependency(%q<rspec>, [">= 3.0.0"])
   s.add_development_dependency(%q<bundler>, [">= 1.1.0"])
-  s.add_development_dependency(%q<coffee-script>, [">= 0"])
   s.add_development_dependency(%q<appraisal>, [">= 0.5.2"])
+  s.add_development_dependency(%q<bump>, [">= 0.10.0"])
   if defined?(JRUBY_VERSION)
     s.add_development_dependency(%q<therubyrhino>, [">= 2.0.4"])
   else
     s.add_development_dependency(%q<byebug>)
     s.add_development_dependency(%q<pry-byebug>)
-    s.add_development_dependency(%q<mini_racer>, [">= 0.2.4"])
+    s.add_development_dependency(%q<mini_racer>, [">= 0.4.0"])
   end
 end

data/lib/js_routes.rb

@@ -3,6 +3,7 @@ if defined?(::Rails) && defined?(::Sprockets::Railtie)
   require 'js_routes/engine'
 end
 require 'js_routes/version'
+require 'active_support/core_ext/string/indent'
 
 class JsRoutes
 
@@ -19,7 +20,7 @@ class JsRoutes
       sprockets_dir = Rails.root.join('app','assets','javascripts')
       sprockets_file = sprockets_dir.join('routes.js')
       webpacker_file = webpacker_dir.join('routes.js')
-      !Dir.exists?(webpacker_dir) && defined?(::Sprockets) ? sprockets_file : webpacker_file
+      !Dir.exist?(webpacker_dir) && defined?(::Sprockets) ? sprockets_file : webpacker_file
     end,
     prefix: -> { Rails.application.config.relative_url_root || "" },
     url_links: false,
@@ -28,7 +29,9 @@ class JsRoutes
     compact: false,
     serializer: nil,
     special_options_key: "_options",
-    application: -> { Rails.application }
+    application: -> { Rails.application },
+    module_type: 'ESM',
+    documentation: true,
   } #:nodoc:
 
   NODE_TYPES = {
@@ -72,6 +75,10 @@ class JsRoutes
     def to_hash
       Hash[*members.zip(values).flatten(1)].symbolize_keys
     end
+
+    def esm?
+      self.module_type === 'ESM'
+    end
   end
 
   #
@@ -83,11 +90,6 @@ class JsRoutes
       configuration.tap(&block) if block
     end
 
-    def options
-      ActiveSupport::Deprecation.warn('JsRoutes.options method is deprecated use JsRoutes.configuration instead')
-      configuration
-    end
-
     def configuration
       @configuration ||= Configuration.new
     end
@@ -125,8 +127,7 @@ class JsRoutes
 
     {
       'GEM_VERSION'         => JsRoutes::VERSION,
-      'ROUTES'              => js_routes,
-      'NODE_TYPES'          => json(NODE_TYPES),
+      'ROUTES_OBJECT'              => routes_object,
       'RAILS_VERSION'       => ActionPack.version,
       'DEPRECATED_GLOBBING_BEHAVIOR' => ActionPack::VERSION::MAJOR == 4 && ActionPack::VERSION::MINOR == 0,
 
@@ -136,9 +137,12 @@ class JsRoutes
       'PREFIX'              => json(@configuration.prefix),
       'SPECIAL_OPTIONS_KEY' => json(@configuration.special_options_key),
       'SERIALIZER'          => @configuration.serializer || json(nil),
+      'MODULE_TYPE'         => json(@configuration.module_type),
+      'WRAPPER'             => @configuration.esm? ? 'const __jsr = ' : '',
     }.inject(File.read(File.dirname(__FILE__) + "/routes.js")) do |js, (key, value)|
-      js.gsub!(key, value.to_s)
-    end
+      js.gsub!("RubyVariables.#{key}", value.to_s) ||
+        raise("Missing key #{key} in JS template")
+    end + routes_export
   end
 
   def generate!(file_name = nil)
@@ -170,19 +174,37 @@ class JsRoutes
     application.routes.named_routes.to_a
   end
 
-  def js_routes
-    js_routes = named_routes.sort_by(&:first).flat_map do |_, route|
-      [build_route_if_match(route)] + mounted_app_routes(route)
+  def routes_object
+    return json({}) if @configuration.esm?
+    properties = routes_list.map do |comment, name, body|
+      "#{comment}#{name}: #{body}".indent(2)
+    end
+    "{\n" + properties.join(",\n\n") + "}\n"
+  end
+
+  STATIC_EXPORTS = [:configure, :config, :serialize].map do |name|
+    ["", name, "__jsr.#{name}"]
+  end
+
+  def routes_export
+    return "" unless @configuration.esm?
+    [*STATIC_EXPORTS, *routes_list].map do |comment, name, body|
+      "#{comment}export const #{name} = #{body};"
+    end.join("\n\n")
+  end
+
+  def routes_list
+    named_routes.sort_by(&:first).flat_map do |_, route|
+      build_routes_if_match(route) + mounted_app_routes(route)
     end.compact
-    "{\n" + js_routes.join(",\n") + "}\n"
   end
 
   def mounted_app_routes(route)
     rails_engine_app = get_app_from_route(route)
     if rails_engine_app.respond_to?(:superclass) &&
        rails_engine_app.superclass == Rails::Engine && !route.path.anchored
-      rails_engine_app.routes.named_routes.map do |_, engine_route|
-        build_route_if_match(engine_route, route)
+      rails_engine_app.routes.named_routes.flat_map do |_, engine_route|
+        build_routes_if_match(engine_route, route)
       end
     else
       []
@@ -199,12 +221,17 @@ class JsRoutes
     end
   end
 
-  def build_route_if_match(route, parent_route = nil)
+  def build_routes_if_match(route, parent_route = nil)
     if any_match?(route, parent_route, @configuration[:exclude]) ||
        !any_match?(route, parent_route, @configuration[:include])
-      nil
+      []
     else
-      build_js(route, parent_route)
+      name = [parent_route.try(:name), route.name].compact
+      parent_spec = parent_route.try(:path).try(:spec)
+      route_arguments = route_js_arguments(route, parent_spec)
+      return [false, true].map do |absolute|
+        route_js(name, parent_spec, route, route_arguments, absolute)
+      end
     end
   end
 
@@ -215,59 +242,72 @@ class JsRoutes
     matchers.any? { |regex| full_route =~ regex }
   end
 
-  def build_js(route, parent_route)
-    name = [parent_route.try(:name), route.name].compact
-    route_name = generate_route_name(name, (:path unless @configuration[:compact]))
-    parent_spec = parent_route.try(:path).try(:spec)
-    route_arguments = route_js_arguments(route, parent_spec)
-    url_link = generate_url_link(name, route_arguments)
-    <<-JS.strip!
-  // #{name.join('.')} => #{parent_spec}#{route.path.spec}
-  // function(#{build_params(route.required_parts)})
-  #{route_name}: Utils.route(#{route_arguments})#{",\n" + url_link if url_link.length > 0}
-  JS
+  def route_js(name_parts, parent_spec, route, route_arguments, absolute)
+    if absolute
+      return nil unless @configuration[:url_links]
+      route_arguments = route_arguments + [json(true)]
+    end
+    name_suffix = absolute ? :url : @configuration[:compact] ? nil : :path
+    name = generate_route_name(name_parts, name_suffix)
+    body = "__jsr.r(#{route_arguments.join(', ')})"
+    comment = documentation(route, parent_spec)
+    [ comment, name, body ]
+  end
+
+  def documentation(route, parent_spec)
+    return nil unless @configuration[:documentation]
+    <<-JS
+/**
+ * Generates rails route to
+ * #{parent_spec}#{route.path.spec}#{build_params(route.required_parts)}
+ * @param {object | undefined} options
+ * @returns {string} route path
+ */
+JS
   end
 
   def route_js_arguments(route, parent_spec)
     required_parts = route.required_parts
-    parts_table = route.parts.each_with_object({}) do |part, hash|
-      hash[part] = required_parts.include?(part)
+    parts_table = {}
+    route.parts.each do |part, hash|
+      parts_table[part] ||= {}
+      if required_parts.include?(part)
+        # Using shortened keys to reduce js file size
+        parts_table[part][:r] = true
+      end
     end
-    default_options = route.defaults.select do |part, _|
-      FILTERED_DEFAULT_PARTS.exclude?(part) &&
+    route.defaults.each do |part, value|
+      if FILTERED_DEFAULT_PARTS.exclude?(part) &&
         URL_OPTIONS.include?(part) || parts_table[part]
+        parts_table[part] ||= {}
+        # Using shortened keys to reduce js file size
+        parts_table[part][:d] = value
+      end
     end
     [
-      # JS objects don't preserve the order of properties which is crucial,
-      # so array is a better choice.
-      parts_table.to_a,
-      default_options,
+      parts_table,
       serialize(route.path.spec, parent_spec)
     ].map do |argument|
       json(argument)
-    end.join(', ')
-  end
-
-  def generate_url_link(name, route_arguments)
-    return '' unless @configuration[:url_links]
-
-    <<-JS.strip!
-    #{generate_route_name(name, :url)}: Utils.route(#{route_arguments}, true)
-    JS
+    end
   end
 
   def generate_route_name(*parts)
-    route_name = parts.compact.join('_')
-    @configuration[:camel_case] ? route_name.camelize(:lower) : route_name
+    apply_case(parts.compact.join('_'))
   end
 
   def json(string)
     self.class.json(string)
   end
 
+  def apply_case(value)
+    @configuration[:camel_case] ? value.to_s.camelize(:lower) : value
+  end
+
   def build_params(required_parts)
-    params = required_parts + [LAST_OPTIONS_KEY]
-    params.join(', ')
+    required_parts.map do |param|
+      "\n * @param {any} #{apply_case(param)}"
+    end.join
   end
 
   # This function serializes Journey route into JSON structure
@@ -296,7 +336,7 @@ class JsRoutes
     [
       NODE_TYPES[spec.type],
       serialize(spec.left, parent_spec),
-      spec.respond_to?(:right) && serialize(spec.right)
-    ]
+      spec.respond_to?(:right) ? serialize(spec.right) : nil
+    ].compact
   end
 end