rbs_ts_generator 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d8212448863dcae6fbb3ddafc3b281fdb3b04eb0886859bda832c0126e145d24
+  data.tar.gz: 715cbeefbfd98e88942ad4b13d9ae8514452a1f7527653218a79ac54a93b2400
+SHA512:
+  metadata.gz: 3703dce9fa9f65e75d1456c429a426ae4c6d26c87d087fe308d2a508d031d6b55a428fc70c1fab38312c1c5ffd2ab2068c9860a9e126419e239f8ea1746984c1
+  data.tar.gz: fdc6850e87c3e89a144e2cb1555e686fda91bab1a2e37ce70de8892cc95824e18880245a42521af86b606c069eb1dc9a2276513c5478f06339d4b257fec6ce54

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 Seiei Miyagi
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,191 @@
+# RbsTsGenerator
+
+Generate TypeScript that includes routes definition and request / response JSON type from type signature of Rails controller actions.
+
+Sample repository: [hanachin/rbs_ts_bbs](https://github.com/hanachin/rbs_ts_bbs)
+
+## Usage
+
+Write type signature of your controller actions in [ruby/rbs](https://github.com/ruby/rbs).
+
+```rbs
+# sig/app/controllers/boards_controller.rbs
+class BoardsController < ApplicationController
+  @board: Board
+  @boards: Board::ActiveRecord_Relation
+
+  def index: () -> Array[{ id: Integer, title: String }]
+  def create: (String title) -> ({ url: String, message: String } | Array[String])
+  def update: (Integer id, String title) -> ({ url: String, message: String } | Array[String])
+  def destroy: (Integer id) -> { url: String, message: String }
+end
+```
+
+The return type of the action method is type of json record.
+But action does not explicitly return json record.
+To pass the ruby type checking, add `| void` to each signatures.
+
+```rbs
+class BoardsController < ApplicationController
+  @board: Board
+  @boards: Board::ActiveRecord_Relation
+
+  def index: () -> (Array[{ id: Integer, title: String }] | void)
+  def create: (String title) -> ({ url: String, message: String } | Array[String] | void)
+  def update: (Integer id, String title) -> ({ url: String, message: String } | Array[String] | void)
+  def destroy: (Integer id) -> ({ url: String, message: String } | void)
+end
+```
+
+I use [Steep](https://github.com/soutaro/steep) to type checking the ruby code.
+Setup the Steepfile like following and run `steep check`.
+
+```ruby
+# Steepfile
+target :app do
+  signature "sig"
+
+  check "app"
+  typing_options :strict
+end
+```
+
+```console
+$ bundle exec steep check
+[Steep 0.17.1] [target=app] [target#type_check(target_sources: [app/channels/application_cable/channel.rb, app/channels/application_cable/connection.rb, app/controllers/application_controller.rb, app/controllers/boards_controller.rb, app/helpers/application_helper.rb, app/helpers/boards_helper.rb, app/jobs/application_job.rb, app/mailers/application_mailer.rb, app/models/application_record.rb, app/models/board.rb, app/mailboxes/application_mailbox.rb], validate_signatures: true)] [synthesize:(1:1)] [synthesize:(2:3)] [synthesize:(2:3)] [(*::Symbol, ?model_name: ::string, **untyped) -> void] Method call with rest keywords type is detected. Rough approximation to be improved.
+```
+
+When you passed the ruby type check, next generate TypeScript from those signatures.
+
+```console
+$ rails generate rbs_ts
+```
+
+This will generate those routes definition in `app/javascript/packs/rbs_ts_routes.ts`.
+
+```typescript
+type BoardsUpdateParams = { id: number; title: string }
+type BoardsDestroyParams = { id: number }
+type BoardsIndexParams = {}
+type BoardsCreateParams = { title: string }
+
+type BoardsUpdateReturn = Exclude<{ url: string; message: string } | string[] | void, void>
+type BoardsDestroyReturn = Exclude<{ url: string; message: string } | void, void>
+type BoardsIndexReturn = Exclude<{ id: number; title: string }[] | void, void>
+type BoardsCreateReturn = Exclude<{ url: string; message: string } | string[] | void, void>
+
+export const boards = {
+  path: ({ format }: any) => "/" + "boards" + (() => { try { return "." + (() => { if (format) return format; throw "format" })() } catch { return "" } })(),
+  names: ["format"]
+} as {
+  path: (args: any) => string
+  names: ["format"]
+  Methods?: "GET" | "POST"
+  Params?: {
+    GET: BoardsIndexParams,
+    POST: BoardsCreateParams
+  }
+  Return?: {
+    GET: BoardsIndexReturn,
+    POST: BoardsCreateReturn
+  }
+}
+export const board = {
+  path: ({ id, format }: any) => "/" + "boards" + "/" + (() => { if (id) return id; throw "id" })() + (() => { try { return "." + (() => { if (format) return format; throw "format" })() } catch { return "" } })(),
+  names: ["id","format"]
+} as {
+  path: (args: any) => string
+  names: ["id","format"]
+  Methods?: "PATCH" | "PUT" | "DELETE"
+  Params?: {
+    PATCH: BoardsUpdateParams,
+    PUT: BoardsUpdateParams,
+    DELETE: BoardsDestroyParams
+  }
+  Return?: {
+    PATCH: BoardsUpdateReturn,
+    PUT: BoardsUpdateReturn,
+    DELETE: BoardsDestroyReturn
+  }
+}
+```
+
+And generate default runtime in `app/javascript/packs/rbs_ts_runtime.ts`
+
+```typescript
+type HttpMethods = 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE'
+type BaseResource = {
+  path: (args: any) => string
+  names: string[]
+  Methods?: any
+  Params?: { [method in HttpMethods]?: any }
+  Return?: { [method in HttpMethods]?: any }
+}
+export async function railsApi<
+  Method extends Exclude<Resource['Methods'], undefined>,
+  Resource extends BaseResource,
+  Params extends Exclude<Resource['Params'], undefined>[Method],
+  Return extends Exclude<Resource['Return'], undefined>[Method]
+>(method: Method, { path, names }: Resource, params: Params): Promise<{ status: number, json: Return }> {
+  const tag = document.querySelector<HTMLMetaElement>('meta[name=csrf-token]')
+  const paramsNotInNames = Object.keys(params).reduce<object>((ps, key) => names.indexOf(key) === - 1 ? { ...ps, [key]: params[key] } : ps, {})
+  const searchParams = new URLSearchParams()
+  for (const name of Object.keys(paramsNotInNames)) {
+    searchParams.append(name, paramsNotInNames[name])
+  }
+  const query = method === 'GET' && Object.keys(paramsNotInNames).length ? `?${searchParams.toString()}` : ''
+  const body = method === 'GET' ? undefined : JSON.stringify(paramsNotInNames)
+  const response = await fetch(path(params) + query, {
+    method,
+    body,
+    headers: {
+      'Accept': 'application/json',
+      'Content-Type': 'application/json',
+      'X-CSRF-Token': tag.content
+    }
+  })
+  const json = await response.json() as Return
+  return new Promise((resolve) => resolve({ status: response.status, json: json }))
+}
+```
+
+In your TypeScript code, you can use those routes definition and the default runtime like following
+
+```typescript
+import { boards } from './rbs_ts_routes'
+import { railsApi } from './rbs_ts_runtime'
+
+const params = { title: 'test' }
+railsApi('POST' as const, boards, params).then(({ json }) => {
+  if (json instanceof Array) {
+    return Promise.reject(json)
+  } else {
+    window.location.href = json.url
+    return Promise.resolve()
+  }
+})
+```
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rbs_ts_generator', group: :development
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install rbs_ts_generator
+```
+
+## Contributing
+
+https://github.com/hanachin/rbs_ts_generator
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,27 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'RbsTsGenerator'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/lib/generators/rbs_ts/USAGE

@@ -0,0 +1,9 @@
+Description:
+    Generate TypeScript routes definition and API request runtime from .rbs
+
+Example:
+    bin/rails generate rbs_ts
+
+    This will create:
+        app/javascript/packs/rbs_ts_routes.ts
+        app/javascript/packs/rbs_ts_runtime.ts

data/lib/generators/rbs_ts/rbs_ts_generator.rb

@@ -0,0 +1,199 @@
+require 'stringio'
+require 'rbs'
+require_relative './rbs_types_convertible'
+require_relative './type_script_visitor'
+
+using RbsTsGenerator::RbsTypesConvertible
+
+using Module.new {
+  refine(Object) do
+    def parse_type_name(string)
+      RBS::Namespace.parse(string).yield_self do |namespace|
+        last = namespace.path.last
+        RBS::TypeName.new(name: last, namespace: namespace.parent)
+      end
+    end
+
+    def type_script_params_type_name(controller, action)
+      "#{controller.to_s.camelcase}#{action.to_s.camelcase}Params"
+    end
+
+    def type_script_return_type_name(controller, action)
+      "#{controller.to_s.camelcase}#{action.to_s.camelcase}Return"
+    end
+
+    def typescript_path_function(route_info, verb_type)
+      name = route_info.fetch(:name).camelize(:lower)
+      parts = route_info.fetch(:parts)
+      body = RbsTsGenerator::TypeScriptVisitor::INSTANCE.accept(route_info.fetch(:spec), '')
+      <<~TS
+      export const #{name} = {
+        path: (#{ parts.empty? ? '' : "{ #{parts.join(', ')} }: any" }) => #{ body },
+        names: [#{ parts.map(&:to_json).join(",") }]
+      } as {
+        path: (args: any) => string
+        names: [#{ parts.map(&:to_json).join(",") }]
+        Methods?: #{verb_type.keys.map(&:to_json).join(' | ')}
+        Params?: {
+      #{verb_type.map { |v, t| "    #{v}: #{t.fetch(:params_type)}" }.join(",\n")}
+        }
+        Return?: {
+      #{verb_type.map { |v, t| "    #{v}: #{t.fetch(:return_type)}" }.join(",\n")}
+        }
+      }
+      TS
+    end
+
+    def routes_info
+      rs = Rails.application.routes.routes.filter_map { |r|
+        {
+          verb: r.verb,
+          name: r.name,
+          parts: r.parts,
+          reqs: r.requirements,
+          spec: r.path.spec
+        } if !r.internal && !r.app.engine?
+      }
+      rs.inject([]) do |new_rs, r|
+        prev_r = new_rs.last
+        if prev_r && r[:name].nil? && r.fetch(:spec).to_s != prev_r.fetch(:spec).to_s
+          # puts prev_r[:name]
+          # puts r.fetch(:spec).to_s
+          # puts prev_r.fetch(:spec).to_s
+          # raise
+          next new_rs
+        end
+        r[:name] = prev_r[:name] if prev_r && r[:name].nil?
+        next new_rs if r[:name].nil?
+        new_rs << r
+      end
+    end
+
+    def rbs_loader
+      RBS::EnvironmentLoader.new.tap do |loader|
+        dir = Pathname('sig')
+        loader.add(path: dir)
+      end
+    end
+
+    def rbs_env
+      RBS::Environment.from_loader(rbs_loader).resolve_type_names
+    end
+
+    def rbs_builder
+      RBS::DefinitionBuilder.new(env: rbs_env)
+    end
+
+    def collect_controller_action_method_type
+      builder = rbs_builder
+      types = {}
+      ApplicationController.subclasses.each do |subclass|
+        subclass_type_name = parse_type_name(subclass.inspect).absolute!
+        definition = builder.build_instance(subclass_type_name)
+        actions = subclass.public_instance_methods(false)
+        actions.each do |action|
+          method = definition.methods[action]
+          next unless method
+          raise 'Unsupported' unless method.method_types.size == 1
+          method_type = method.method_types.first
+          raise 'Unsupported' unless method_type.is_a?(RBS::MethodType)
+          controller = subclass.to_s.sub(/Controller$/, '').underscore.to_s
+          types[controller] ||= {}
+          types[controller][action.to_s] = method_type
+        rescue
+          $stderr.puts $!.backtrace.join("\n")
+          $stderr.puts "#{subclass}##{action} not supported"
+        end
+      end
+      types
+    end
+
+    def collect_controller_action_params_types
+      types = {}
+      collect_controller_action_method_type.each do |controller, action_method_types|
+        action_method_types.each do |action, method_type|
+          type = method_type.to_ts_params_type
+          types[controller] ||= {}
+          types[controller][action] ||= {}
+          types[controller][action] = type.empty? ? '{}' : type
+        end
+      end
+      types
+    end
+
+    def collect_controller_action_return_types
+      types = {}
+      collect_controller_action_method_type.each do |controller, action_method_types|
+        action_method_types.each do |action, method_type|
+          type = method_type.to_ts_return_type
+          types[controller] ||= {}
+          types[controller][action] ||= {}
+          types[controller][action] = type.empty? ? '{}' : type
+        end
+      end
+      types
+    end
+  end
+}
+
+using Module.new {
+  refine(Object) do
+    def generate_params_types
+      output = StringIO.new
+      types = collect_controller_action_params_types
+      types.each do |controller, actions|
+        actions.each do |action, type|
+          output.puts "type #{type_script_params_type_name(controller, action)} = #{type}"
+        end
+      end
+      output.string
+    end
+
+    def generate_return_types
+      output = StringIO.new
+      types = collect_controller_action_return_types
+      types.each do |controller, actions|
+        actions.each do |action, type|
+          output.puts "type #{type_script_return_type_name(controller, action)} = Exclude<#{type}, void>"
+        end
+      end
+      output.string
+    end
+
+    def generate_request_functions
+      output = StringIO.new
+      type = collect_controller_action_params_types
+      routes_info.group_by { |r| r.fetch(:name) }.each do |name, routes|
+        route = routes.first
+        verb_type = routes.each_with_object({}) do |r, vt|
+          controller = r.dig(:reqs, :controller)
+          action = r.dig(:reqs, :action)
+          next unless type.dig(controller, action)
+          vt[r.fetch(:verb)] = {
+            params_type: type_script_params_type_name(controller, action),
+            return_type: type_script_return_type_name(controller, action)
+          }
+        end
+        next if verb_type.empty?
+        output.puts typescript_path_function(route, verb_type)
+      end
+      output.string
+    end
+  end
+}
+
+class RbsTsGenerator < Rails::Generators::Base
+  source_root File.expand_path('templates', __dir__)
+
+  def copy_rbs_ts_runtime_ts
+    copy_file 'rbs_ts_runtime.ts', 'app/javascript/packs/rbs_ts_runtime.ts'
+  end
+
+  def create_rbs_ts_routes_ts
+    Rails.application.eager_load!
+    params_types = generate_params_types
+    return_types = generate_return_types
+    request_functions = generate_request_functions
+    create_file 'app/javascript/packs/rbs_ts_routes.ts', [params_types, return_types, request_functions].join("\n")
+  end
+end

data/lib/generators/rbs_ts/rbs_types_convertible.rb

@@ -0,0 +1,249 @@
+require 'rbs'
+
+unless RBS::Types.constants.sort == [:NoSubst, :NoTypeName, :EmptyEachType, :Literal, :Bases, :Interface, :Tuple, :Union, :ClassSingleton, :Application, :ClassInstance, :Record, :Function, :Optional, :Variable, :Alias, :Proc, :Intersection, :NoFreeVariables].sort
+  raise 'Unsupported'
+end
+
+unless RBS::Types::Bases.constants.sort == [:Instance, :Base, :Class, :Void, :Any, :Nil, :Top, :Bottom, :Self, :Bool].sort
+  raise 'Unsupported'
+end
+
+class RbsTsGenerator < Rails::Generators::Base
+  module RbsTypesConvertible
+    using self
+
+    refine(RBS::MethodType) do
+      def to_ts_params_type
+        raise 'Unsupported' unless type_params.empty?
+
+        s = case
+            when block && block.required
+              raise 'Unsupported'
+            when block
+              raise 'Unsupported'
+            else
+              type.param_to_s
+            end
+
+        if type_params.empty?
+          s
+        else
+          raise 'Unsuported'
+        end
+      end
+
+      def to_ts_return_type
+        type.return_to_s
+      end
+    end
+
+    refine(RBS::Types::Function::Param) do
+      def to_s
+        type.to_s
+      end
+    end
+
+    refine(RBS::Types::Function) do
+      def param_to_s
+        params = []
+        params.push(*required_positionals.map { |param| "#{param.name}: #{param.type}" })
+        params.push(*optional_positionals.map {|param| "#{param.name}?: #{param.type}" })
+        raise 'Unsupported' if rest_positionals
+        params.push(*trailing_positionals.map { |param| "#{param.name}: #{param.type}" })
+        params.push(*required_keywords.map {|name, param| "#{name}: #{param}" })
+        params.push(*optional_keywords.map {|name, param| "#{name}?: #{param}" })
+        raise 'Unsupported' if rest_keywords
+
+        return '' if params.empty?
+
+        "{ #{params.join("; ")} }"
+      end
+
+      def return_to_s
+        return_type.to_s
+      end
+    end
+
+    # RBS::Types.constants.map { RBS::Types.const_get(_1) }.select { _1.public_instance_methods(false).include?(:to_s) }
+    refine(RBS::Types::Literal) do
+      def to_s(level = 0)
+        case literal
+        when Symbol, String
+          literal.to_s.inspect
+        when Integer, TrueClass, FalseClass
+          literal.inspect
+        else
+          raise 'Unsupported'
+        end
+      end
+    end
+
+    refine(RBS::Types::Interface) do
+      def to_s(level = 0)
+        raise 'Unsupported'
+      end
+    end
+
+    refine(RBS::Types::Tuple) do
+      # copy from super to use refinements
+      def to_s(level = 0)
+        if types.empty?
+          "[ ]"
+        else
+          "[ #{types.map(&:to_s).join(", ")} ]"
+        end
+      end
+    end
+
+    refine(RBS::Types::Record) do
+      def to_s(level = 0)
+        return "{ }" if self.fields.empty?
+
+        fields = self.fields.map do |key, type|
+          if key.is_a?(Symbol) && key.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/) && !key.match?(RBS::Parser::KEYWORDS_RE)
+            "#{key.to_s}: #{type}"
+          else
+            "#{key.to_s.inspect}: #{type}"
+          end
+        end
+        "{ #{fields.join("; ")} }"
+      end
+    end
+
+    refine(RBS::Types::Union) do
+      # copy from super to use refinements
+      def to_s(level = 0)
+        if level > 0
+          "(#{types.map(&:to_s).join(" | ")})"
+        else
+          types.map(&:to_s).join(" | ")
+        end
+      end
+    end
+
+    refine(RBS::Types::ClassSingleton) do
+      def to_s(level = 0)
+        raise 'Unsupported'
+      end
+    end
+
+    refine(RBS::Types::Application) do
+      def to_s(level = 0)
+        case name.to_s
+        when '::Integer'
+          'number'
+        when '::String'
+          'string'
+        when '::Array'
+          raise 'Unsupported' unless args.one?
+
+          args[0].to_s + '[]'
+        else
+          raise 'Unsupported'
+        end
+      end
+    end
+
+    refine(RBS::Types::Optional) do
+      # copy from super to use refinements
+      def to_s(level = 0)
+        if type.is_a?(RBS::Types::Literal) && type.literal.is_a?(Symbol)
+          "#{type.to_s(1)} ?"
+        else
+          "#{type.to_s(1)}?"
+        end
+      end
+    end
+
+    refine(RBS::Types::Variable) do
+      def to_s(level = 0)
+        raise 'Unsupported'
+      end
+    end
+
+    refine(RBS::Types::Alias) do
+      def to_s(level = 0)
+        raise 'Unsupported'
+      end
+    end
+
+    refine(RBS::Types::Proc) do
+      def to_s(level = 0)
+        raise 'Unsupported'
+      end
+    end
+
+    refine(RBS::Types::Intersection) do
+      # copy from super to use refinements
+      def to_s(level = 0)
+        strs = types.map {|ty| ty.to_s(2) }
+        if level > 0
+          "(#{strs.join(" & ")})"
+        else
+          strs.join(" & ")
+        end
+      end
+    end
+
+    # RBS::Types::Bases.constants.map { RBS::Types::Bases.const_get(_1) }
+    refine(RBS::Types::Bases::Instance) do
+      def to_s(level = 0)
+        raise 'Unsupported'
+      end
+    end
+
+    refine(RBS::Types::Bases::Base) do
+      def to_s(level = 0)
+        raise 'Unsupported'
+      end
+    end
+
+    refine(RBS::Types::Bases::Class) do
+      def to_s(level = 0)
+        raise 'Unsupported'
+      end
+    end
+
+    refine(RBS::Types::Bases::Void) do
+      def to_s(level = 0)
+        'void'
+      end
+    end
+
+    refine(RBS::Types::Bases::Any) do
+      def to_s(level = 0)
+        'any'
+      end
+    end
+
+    refine(RBS::Types::Bases::Nil) do
+      def to_s(level = 0)
+        'null'
+      end
+    end
+
+    refine(RBS::Types::Bases::Top) do
+      def to_s(level = 0)
+        raise 'Unsupported'
+      end
+    end
+
+    refine(RBS::Types::Bases::Bottom) do
+      def to_s(level = 0)
+        raise 'Unsupported'
+      end
+    end
+
+    refine(RBS::Types::Bases::Self) do
+      def to_s(level = 0)
+        raise 'Unsupported'
+      end
+    end
+
+    refine(RBS::Types::Bases::Bool) do
+      def to_s(level = 0)
+        'boolean'
+      end
+    end
+  end
+end

data/lib/generators/rbs_ts/templates/rbs_ts_runtime.ts

@@ -0,0 +1,34 @@
+type HttpMethods = 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE'
+type BaseResource = {
+  path: (args: any) => string
+  names: string[]
+  Methods?: any
+  Params?: { [method in HttpMethods]?: any }
+  Return?: { [method in HttpMethods]?: any }
+}
+export async function railsApi<
+  Method extends Exclude<Resource['Methods'], undefined>,
+  Resource extends BaseResource,
+  Params extends Exclude<Resource['Params'], undefined>[Method],
+  Return extends Exclude<Resource['Return'], undefined>[Method]
+>(method: Method, { path, names }: Resource, params: Params): Promise<{ status: number, json: Return }> {
+  const tag = document.querySelector<HTMLMetaElement>('meta[name=csrf-token]')
+  const paramsNotInNames = Object.keys(params).reduce<object>((ps, key) => names.indexOf(key) === - 1 ? { ...ps, [key]: params[key] } : ps, {})
+  const searchParams = new URLSearchParams()
+  for (const name of Object.keys(paramsNotInNames)) {
+    searchParams.append(name, paramsNotInNames[name])
+  }
+  const query = method === 'GET' && Object.keys(paramsNotInNames).length ? `?${searchParams.toString()}` : ''
+  const body = method === 'GET' ? undefined : JSON.stringify(paramsNotInNames)
+  const response = await fetch(path(params) + query, {
+    method,
+    body,
+    headers: {
+      'Accept': 'application/json',
+      'Content-Type': 'application/json',
+      'X-CSRF-Token': tag.content
+    }
+  })
+  const json = await response.json() as Return
+  return new Promise((resolve) => resolve({ status: response.status, json: json }))
+}

data/lib/generators/rbs_ts/type_script_visitor.rb

@@ -0,0 +1,40 @@
+class RbsTsGenerator < Rails::Generators::Base
+  class TypeScriptVisitor < ActionDispatch::Journey::Visitors::FunctionalVisitor
+    private
+
+    def binary(node, seed)
+      visit(node.right, visit(node.left, seed) + ' + ')
+    end
+
+    def nary(node, seed)
+      last_child = node.children.last
+      node.children.inject(seed) { |s, c|
+        string = visit(c, s)
+        string << '|' unless last_child == c
+        string
+      }
+    end
+
+    def terminal(node, seed)
+      seed + node.left.to_s.to_json
+    end
+
+    def visit_GROUP(node, seed)
+      # TODO: support nested level 2
+      visit(node.left, seed.dup << '(() => { try { return ') << ' } catch { return "" } })()'
+    end
+
+    def visit_SYMBOL(n, seed);  variable(n, seed); end
+
+    def variable(node, seed)
+      if node.left.to_s[0] == '*'
+        seed + '(' + node.left.to_s[1..-1] + ' ?? "")'
+      else
+        v = node.left.to_s[1..-1]
+        seed + "(() => { if (#{v}) return #{v}; throw #{v.to_json} })()"
+      end
+    end
+
+    INSTANCE = new
+  end
+end

data/lib/tasks/rbs_ts_generator_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :rbs_ts_generator do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: rbs_ts_generator
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Seiei Miyagi
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-07-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 6.1.0.alpha
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 6.1.0.alpha
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.1
+- !ruby/object:Gem::Dependency
+  name: rbs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- hanachin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/generators/rbs_ts/USAGE
+- lib/generators/rbs_ts/rbs_ts_generator.rb
+- lib/generators/rbs_ts/rbs_types_convertible.rb
+- lib/generators/rbs_ts/templates/rbs_ts_runtime.ts
+- lib/generators/rbs_ts/type_script_visitor.rb
+- lib/rbs_ts_generator.rb
+- lib/tasks/rbs_ts_generator_tasks.rake
+homepage: https://github.com/hanachin/rbs_ts_generator
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Generate TypeScript that includes routes definition and request / response
+  JSON type from type signature of Rails controller actions.
+test_files: []