souls 0.55.2 → 0.56.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cadd8e85a9df7d2bbc5b4a276d163e2fde33ce2549f12505f624c3f16d297585
-  data.tar.gz: 0c7f9f8e2139a2fc37271fcce9e60ac65e5b437c6b425be7cd30bdee269f95c5
+  metadata.gz: 8b11027355d2156abdaa8807eda594fd4ba96fde1fdb0cf546e6f5f1cd34487a
+  data.tar.gz: cba26dd0ea25bafe8ecce20ef66a10f1f2ef86f0bfb0b5f6c54594d332c3400c
 SHA512:
-  metadata.gz: c1cff34a13bab301ea31b905e3a75f05b401c60a1a2d94800e3d2ff49a47f21a2ade571df14b0ac916c3b50c3e1fa8336703232c7606b1dd64c5233f9fb8d2e0
-  data.tar.gz: bcef4c3899794142b56a89ae306490be66661d60ebd841e815a24415c6200330211ff5824a1eb1ab600dd3eccbec3561078f3f20649e4cb30151a35811f53d95
+  metadata.gz: 5bd75f70b0284d5ecab2a2eda7a013557db7578d69caec27dd9296c3649838413bfe011ea573a63fb8ce94cb9469bb7882b37951de7ec18ff84dd87e03de94ca
+  data.tar.gz: 61b91ab91c7cd6b277718b3f9f6bba5451d956d386099a941e2f0f9e4632ad69cec3d897804b36fc0ebb9c0a528d6f2008fdc1140d2e3b01bd7d93874f7aba42

data/README.md

@@ -84,7 +84,7 @@ And Create Your APP
 
 Check your GraphQL PlayGround
 
-(localhost:4000/playground)[localhost:4000/playground]
+[localhost:4000/playground](localhost:4000/playground)
 
 ## Gemfile 自動更新アップデート
 

data/exe/souls

@@ -3,18 +3,7 @@ require "souls"
 require "thor"
 begin
   souls_command = ARGV[0]
-  require("./config/souls") unless [
-    "new",
-    "docker",
-    "-v",
-    "deploy",
-    "help",
-    "api",
-    "create",
-    "worker",
-    "",
-    nil
-  ].include?(souls_command)
+  require("./config/souls") unless ["new", "docker", "-v", "help", "", nil].include?(souls_command)
 rescue StandardError
   raise(StandardError, "No confif! Please make `./config/souls.rb` File!")
 end

data/lib/souls/api/generate/application.rb

@@ -4,18 +4,26 @@ module Souls
     def scaffold(class_name)
       singularized_class_name = class_name.singularize
       model(singularized_class_name)
+      model_rbs(singularized_class_name)
       type(singularized_class_name)
+      type_rbs(singularized_class_name)
+      query(singularized_class_name)
+      query_rbs(singularized_class_name)
+      mutation(singularized_class_name)
+      mutation_rbs(singularized_class_name)
+      policy(singularized_class_name)
+      policy_rbs(singularized_class_name)
       edge(singularized_class_name)
+      edge_rbs(singularized_class_name)
       connection(singularized_class_name)
+      connection_rbs(singularized_class_name)
       resolver(singularized_class_name)
+      resolver_rbs(singularized_class_name)
       rspec_factory(singularized_class_name)
       rspec_model(singularized_class_name)
       rspec_mutation(singularized_class_name)
       rspec_query(singularized_class_name)
       rspec_resolver(singularized_class_name)
-      query(singularized_class_name)
-      mutation(singularized_class_name)
-      policy(singularized_class_name)
       rspec_policy(singularized_class_name)
       true
     rescue Thor::Error => e

data/lib/souls/api/generate/connection_rbs.rb

@@ -1,19 +1,24 @@
 module Souls
   class Generate < Thor
-    desc "connection [CLASS_NAME]", "Generate GraphQL Connection from schema.rb"
-    def connection(class_name)
-      file_dir = "./app/graphql/types/connections/"
-      FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
-      singularized_class_name = class_name.underscore.singularize
-      file_path = "./app/graphql/types/connections/#{singularized_class_name}_connection.rb"
-      File.open(file_path, "w") do |f|
-        f.write(<<~TEXT)
-          class Types::#{singularized_class_name.camelize}Connection < Types::BaseConnection
-            edge_type(Types::#{singularized_class_name.camelize}Edge)
-          end
-        TEXT
+    desc "connection_rbs [CLASS_NAME]", "Generate GraphQL Connection RBS from schema.rb"
+    def connection_rbs(class_name)
+      file_path = ""
+      Dir.chdir(Souls.get_mother_path.to_s) do
+        file_dir = "./sig/api/app/graphql/types/connections/"
+        FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
+        singularized_class_name = class_name.underscore.singularize
+        file_path = "#{file_dir}#{singularized_class_name}_connection.rbs"
+        File.open(file_path, "w") do |f|
+          f.write(<<~TEXT)
+            module Types
+              class #{singularized_class_name.camelize}Connection < Types::BaseConnection
+                def edge_type: (*untyped) -> untyped
+              end
+            end
+          TEXT
+        end
+        puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
       end
-      puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
       file_path
     rescue Thor::Error => e
       raise(Thor::Error, e)

data/lib/souls/api/generate/edge_rbs.rb

@@ -0,0 +1,30 @@
+module Souls
+  class Generate < Thor
+    desc "edge_rbs [CLASS_NAME]", "Generate GraphQL Edge RBS from schema.rb"
+    def edge_rbs(class_name)
+      file_path = ""
+      Dir.chdir(Souls.get_mother_path.to_s) do
+        file_dir = "./sig/api/app/graphql/types/edges/"
+        FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
+        singularized_class_name = class_name.underscore.singularize
+        file_path = "#{file_dir}#{singularized_class_name}_edge.rbs"
+        File.open(file_path, "w") do |f|
+          f.write(<<~TEXT)
+            module Types
+              class #{singularized_class_name.camelize}Edge < BaseObject
+                def self.implements: (*untyped) -> untyped
+                def self.global_id_field: (*untyped) -> untyped
+                def self.field: (*untyped) -> untyped
+                def self.connection_type: ()-> untyped
+              end
+            end
+          TEXT
+        end
+        puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
+      end
+      file_path
+    rescue Thor::Error => e
+      raise(Thor::Error, e)
+    end
+  end
+end

data/lib/souls/api/generate/index.rb

@@ -1,26 +1,12 @@
-require_relative "./model"
-require_relative "./mutation"
-require_relative "./policy"
-require_relative "./query"
-require_relative "./resolver"
-require_relative "./rspec_factory"
-require_relative "./rspec_model"
-require_relative "./rspec_mutation"
-require_relative "./rspec_policy"
-require_relative "./rspec_query"
-require_relative "./rspec_resolver"
-require_relative "./type"
-require_relative "./edge"
-require_relative "./connection"
-require_relative "./application"
-require_relative "./manager"
+require_paths = []
+dev_path = "lib/souls/api/generate/*"
+gem_path = "#{Gem.dir}/gems/souls-#{Souls::VERSION}/lib/souls/api/generate/*"
+file_paths = File.exist?("souls.gemspec") ? dev_path : gem_path
+Dir[file_paths].map do |n|
+  next if n.include?("index.rb")
 
-# require_paths = []
-# Dir["lib/souls/api/generate/*"].map do |n|
-#   next if n.include?("index.rb")
-
-#   require_paths << n.split("/").last.gsub(".rb", "")
-# end
-# require_paths.each do |path|
-#   require_relative "./#{path}"
-# end
+  require_paths << n.split("/").last.gsub(".rb", "")
+end
+require_paths.each do |path|
+  require_relative "./#{path}"
+end

data/lib/souls/api/generate/model_rbs.rb

@@ -0,0 +1,26 @@
+module Souls
+  class Generate < Thor
+    desc "model_rbs [CLASS_NAME]", "Generate GraphQL Model RBS from schema.rb"
+    def model_rbs(class_name)
+      file_path = ""
+      Dir.chdir(Souls.get_mother_path.to_s) do
+        file_dir = "./sig/api/app/graphql/types/models/"
+        FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
+        singularized_class_name = class_name.underscore.singularize
+        file_path = "#{file_dir}#{singularized_class_name}_model.rbs"
+        File.open(file_path, "w") do |f|
+          f.write(<<~TEXT)
+            module Types
+              class #{singularized_class_name.camelize} < ActiveRecord::Base
+              end
+            end
+          TEXT
+        end
+        puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
+      end
+      file_path
+    rescue Thor::Error => e
+      raise(Thor::Error, e)
+    end
+  end
+end

data/lib/souls/api/generate/mutation.rb

@@ -56,7 +56,8 @@ module Souls
                   new_line.write(<<-TEXT)
 
       def resolve args
-        args[:user_id] = context[:user].id
+        params = args.dup
+        params[:user_id] = context[:user][:id]
                   TEXT
                 else
                   new_line.write(<<-TEXT)
@@ -150,14 +151,15 @@ module Souls
                   new_line.write(<<-TEXT)
 
       def resolve args
-        args[:user_id] = context[:user].id
-        _, args[:id] = SoulsApiSchema.from_global_id(args[:id])
+        params = args.dup
+        params[:user_id] = context[:user][:id]
+        _, params[:id] = SoulsApiSchema.from_global_id(args[:id])
                   TEXT
                 else
                   new_line.write(<<-TEXT)
 
       def resolve args
-        _, args[:id] = SoulsApiSchema.from_global_id(args[:id])
+        _, params[:id] = SoulsApiSchema.from_global_id(args[:id])
                   TEXT
                 end
                 break
@@ -190,7 +192,7 @@ module Souls
       file_path = "./app/graphql/mutations/base/#{class_name}/update_#{class_name}.rb"
       relation_params.each do |params_name|
         File.open(file_path, "a") do |new_line|
-          new_line.write("        _, args[:#{params_name}] = SoulsApiSchema.from_global_id(args[:#{params_name}])\n")
+          new_line.write("        _, params[:#{params_name}] = SoulsApiSchema.from_global_id(args[:#{params_name}])\n")
         end
       end
       true
@@ -200,9 +202,9 @@ module Souls
       file_path = "./app/graphql/mutations/base/#{class_name}/update_#{class_name}.rb"
       File.open(file_path, "a") do |new_line|
         new_line.write(<<~TEXT)
-                  #{class_name} = ::#{class_name.camelize}.find args[:id]
-                  #{class_name}.update args
-                  { #{class_name}_edge: { node: ::#{class_name.camelize}.find(args[:id]) } }
+                  #{class_name} = ::#{class_name.camelize}.find params[:id]
+                  #{class_name}.update params
+                  { #{class_name}_edge: { node: ::#{class_name.camelize}.find(params[:id]) } }
                 rescue StandardError => error
                   GraphQL::ExecutionError.new(error.message)
                 end

data/lib/souls/api/generate/mutation_rbs.rb

@@ -0,0 +1,220 @@
+module Souls
+  class Generate < Thor
+    desc "mutation_rbs [CLASS_NAME]", "Generate GraphQL Mutation RBS from schema.rb"
+    def mutation_rbs(class_name)
+      singularized_class_name = class_name.underscore.singularize
+      create_rbs_mutation(class_name: singularized_class_name)
+      update_rbs_mutation(class_name: singularized_class_name)
+      delete_rbs_mutation(class_name: singularized_class_name)
+      destroy_delete_rbs_mutation(class_name: singularized_class_name)
+    rescue Thor::Error => e
+      raise(Thor::Error, e)
+    end
+
+    private
+
+    def create_rbs_mutation(class_name: "user")
+      file_path = ""
+      Dir.chdir(Souls.get_mother_path.to_s) do
+        file_dir = "./sig/api/app/graphql/mutations/base/#{class_name}"
+        FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
+        file_path = "#{file_dir}/create_#{class_name}.rbs"
+        raise(Thor::Error, "Mutation RBS already exist! #{file_path}") if File.exist?(file_path)
+
+        params = Souls.get_relation_params(class_name: class_name, col: "mutation")
+        File.open(file_path, "w") do |f|
+          f.write(<<~TEXT)
+            class Boolean
+            end
+            module Mutations
+              module Base
+                module #{class_name.camelize}
+                  class Create#{class_name.camelize} < BaseMutation
+                    String: String
+                    Boolean: Boolean
+                    Integer: Integer
+                    def resolve:  ({
+          TEXT
+        end
+        File.open(file_path, "a") do |f|
+          params[:params].each_with_index do |param, i|
+            type = Souls.rbs_type_check(param[:type])
+            type = "[#{type}]" if param[:array]
+            if i == params[:params].size - 1
+              f.write("                          #{param[:column_name]}: #{type}?\n")
+            else
+              f.write("                          #{param[:column_name]}: #{type}?,\n")
+            end
+          end
+        end
+        # rubocop:disable Layout/LineLength
+        File.open(file_path, "a") do |f|
+          f.write("                      }) -> ({ :#{class_name}_edge => { :node => String } } | ::GraphQL::ExecutionError )\n\n")
+        end
+        # rubocop:enable Layout/LineLength
+
+        File.open(file_path, "a") do |f|
+          params[:params].each_with_index do |param, i|
+            type = Souls.type_check(param[:type])
+            rbs_type = Souls.rbs_type_check(param[:type])
+            type = "[#{type}]" if param[:array]
+            if i.zero?
+              f.write("        def self.argument: (:#{param[:column_name]}, #{type}, required: false ) -> #{rbs_type}\n")
+            else
+              f.write("                         | (:#{param[:column_name]}, #{type}, required: false ) -> #{rbs_type}\n")
+            end
+          end
+        end
+
+        File.open(file_path, "a") do |f|
+          f.write(<<~TEXT)
+
+                    def self.field: (*untyped) -> String
+                    attr_accessor context: {user:{
+                      id: Integer,
+                      username: String,
+                      email: String
+                    }}
+                  end
+                end
+              end
+            end
+          TEXT
+        end
+      end
+      puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
+      file_path
+    rescue Thor::Error => e
+      raise(Thor::Error, e)
+    end
+
+    def update_rbs_mutation(class_name: "user")
+      file_path = ""
+      Dir.chdir(Souls.get_mother_path.to_s) do
+        file_dir = "./sig/api/app/graphql/mutations/base/#{class_name}"
+        FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
+        file_path = "#{file_dir}/update_#{class_name}.rbs"
+        params = Souls.get_relation_params(class_name: class_name, col: "mutation")
+        params[:params] << { column_name: "id", type: "string", array: false }
+        File.open(file_path, "w") do |f|
+          f.write(<<~TEXT)
+            module Mutations
+              module Base
+                module #{class_name.camelize}
+                  class Update#{class_name.camelize} < BaseMutation
+                    def resolve:  ({
+          TEXT
+        end
+        File.open(file_path, "a") do |f|
+          params[:params].each_with_index do |param, i|
+            type = Souls.rbs_type_check(param[:type])
+            type = "[#{type}]" if param[:array]
+            if i == params[:params].size - 1
+              f.write("                          #{param[:column_name]}: #{type}?\n")
+            else
+              f.write("                          #{param[:column_name]}: #{type}?,\n")
+            end
+          end
+        end
+        # rubocop:disable Layout/LineLength
+        File.open(file_path, "a") do |f|
+          f.write("                      }) -> ({ :#{class_name}_edge => { :node => String } } | ::GraphQL::ExecutionError )\n\n")
+        end
+        # rubocop:enable Layout/LineLength
+
+        File.open(file_path, "a") do |f|
+          params[:params].each_with_index do |param, i|
+            type = Souls.type_check(param[:type])
+            rbs_type = Souls.rbs_type_check(param[:type])
+            type = "[#{type}]" if param[:array]
+            if i.zero?
+              f.write("        def self.argument: (:#{param[:column_name]}, #{type}, required: false ) -> #{rbs_type}\n")
+            else
+              f.write("                         | (:#{param[:column_name]}, #{type}, required: false ) -> #{rbs_type}\n")
+            end
+          end
+        end
+
+        File.open(file_path, "a") do |f|
+          f.write(<<~TEXT)
+
+                    def self.field: (*untyped) -> String
+                    attr_accessor context: {user:{
+                      id: Integer,
+                      username: String,
+                      email: String
+                    }}
+                  end
+                end
+              end
+            end
+          TEXT
+        end
+      end
+      puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
+      file_path
+    end
+
+    def delete_rbs_mutation(class_name: "user")
+      file_path = ""
+      Dir.chdir(Souls.get_mother_path.to_s) do
+        file_dir = "./sig/api/app/graphql/mutations/base/#{class_name}"
+        FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
+        file_path = "#{file_dir}/delete_#{class_name}.rbs"
+        File.open(file_path, "w") do |f|
+          f.write(<<~TEXT)
+            module Mutations
+              module Base
+                module #{class_name.camelize}
+                  class Delete#{class_name.camelize}
+                    def resolve:  ({
+                                      id: String
+                                   }) -> ( Hash[Symbol, untyped] | ::GraphQL::ExecutionError )
+            #{'        '}
+                    def self.argument: (*untyped) -> String
+                    def self.field: (*untyped) -> String
+                  end
+                end
+              end
+            end
+          TEXT
+        end
+        puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
+      end
+      file_path
+    rescue Thor::Error => e
+      raise(Thor::Error, e)
+    end
+
+    def destroy_delete_rbs_mutation(class_name: "user")
+      file_path = ""
+      Dir.chdir(Souls.get_mother_path.to_s) do
+        file_dir = "./sig/api/app/graphql/mutations/base/#{class_name}"
+        FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
+        file_path = "#{file_dir}/destroy_delete_#{class_name}.rbs"
+        File.open(file_path, "w") do |f|
+          f.write(<<~TEXT)
+            module Mutations
+              module Base
+                module #{class_name.camelize}
+                  class DestroyDelete#{class_name.camelize}
+                    def resolve:  ({
+                                      id: String
+                                   }) -> ( Hash[Symbol, untyped] | ::GraphQL::ExecutionError )
+            #{'        '}
+                    def self.argument: (*untyped) -> String
+                    def self.field: (*untyped) -> String
+                  end
+                end
+              end
+            end
+          TEXT
+        end
+        puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
+      end
+      file_path
+    rescue Thor::Error => e
+      raise(Thor::Error, e)
+    end
+  end
+end

data/lib/souls/api/generate/policy_rbs.rb

@@ -0,0 +1,35 @@
+module Souls
+  class Generate < Thor
+    desc "policy_rbs [CLASS_NAME]", "Generate Policy RBS"
+    def policy_rbs(class_name)
+      file_path = ""
+      Dir.chdir(Souls.get_mother_path.to_s) do
+        file_dir = "./sig/api/app/graphql/types/policies/"
+        FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
+        singularized_class_name = class_name.underscore.singularize
+        file_path = "#{file_dir}#{singularized_class_name}_policy.rbs"
+        File.open(file_path, "w") do |f|
+          f.write(<<~TEXT)
+            class #{singularized_class_name.camelize}Policy
+              @user: untyped
+
+              def show?: -> true
+              def index?: -> true
+              def create?: -> bool
+              def update?: -> bool
+              def delete?: -> bool
+
+              private
+              def user_permissions?: -> untyped
+              def admin_permissions?: -> untyped
+            end
+          TEXT
+        end
+        puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
+      end
+      file_path
+    rescue Thor::Error => e
+      raise(Thor::Error, e)
+    end
+  end
+end

data/lib/souls/api/generate/query_rbs.rb

@@ -0,0 +1,67 @@
+module Souls
+  class Generate < Thor
+    desc "query_rbs [CLASS_NAME]", "Generate GraphQL Query RBS"
+    def query_rbs(class_name)
+      single_query_rbs(class_name)
+      queries_rbs(class_name)
+    end
+
+    private
+
+    def single_query_rbs(class_name)
+      file_path = ""
+      Dir.chdir(Souls.get_mother_path.to_s) do
+        file_dir = "./sig/api/app/graphql/queries/"
+        FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
+        singularized_class_name = class_name.underscore.singularize
+        file_path = "#{file_dir}#{singularized_class_name}.rbs"
+        File.open(file_path, "w") do |f|
+          f.write(<<~TEXT)
+            module Queries
+              class BaseQuery
+              end
+              class #{singularized_class_name.camelize} < Queries::BaseQuery
+                def resolve:  ({
+                                id: String?
+                              }) -> ( Hash[Symbol, ( String | Integer | bool )] | ::GraphQL::ExecutionError )
+
+                def self.argument: (*untyped) -> String
+                def self.type: (*untyped) -> String
+              end
+            end
+          TEXT
+        end
+        puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
+      end
+      file_path
+    rescue Thor::Error => e
+      raise(Thor::Error, e)
+    end
+
+    def queries_rbs(class_name)
+      file_path = ""
+      Dir.chdir(Souls.get_mother_path.to_s) do
+        file_dir = "./sig/api/app/graphql/queries/"
+        FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
+        pluralized_class_name = class_name.underscore.pluralize
+        file_path = "#{file_dir}#{pluralized_class_name}.rbs"
+        File.open(file_path, "w") do |f|
+          f.write(<<~TEXT)
+            module Queries
+              class BaseQuery
+              end
+              class #{pluralized_class_name.camelize} < Queries::BaseQuery
+                def resolve:  () -> ( Hash[Symbol, ( String | Integer | bool )] | ::GraphQL::ExecutionError)
+                def self.type: (*untyped) -> String
+              end
+            end
+          TEXT
+        end
+        puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
+      end
+      file_path
+    rescue Thor::Error => e
+      raise(Thor::Error, e)
+    end
+  end
+end

data/lib/souls/api/generate/resolver_rbs.rb

@@ -0,0 +1,67 @@
+module Souls
+  class Generate < Thor
+    desc "resolver_rbs [CLASS_NAME]", "Generate GraphQL Resolver RBS from schema.rb"
+    def resolver_rbs(class_name)
+      singularized_class_name = class_name.underscore.singularize
+      file_path = ""
+      Dir.chdir(Souls.get_mother_path.to_s) do
+        file_dir = "./sig/api/app/graphql/resolvers"
+        FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
+        file_path = "#{file_dir}/#{singularized_class_name}_search.rbs"
+        raise(Thor::Error, "Mutation RBS already exist! #{file_path}") if File.exist?(file_path)
+
+        params = Souls.get_relation_params(class_name: singularized_class_name)
+        File.open(file_path, "w") do |f|
+          f.write(<<~TEXT)
+            class Base
+            end
+            class #{singularized_class_name.camelize}Search < Base
+              def self.scope: () ?{ () -> nil } -> [Hash[Symbol, untyped]]
+              def self.type: (*untyped) -> String
+              def self.option: (:filter, type: untyped, with: :apply_filter) -> String
+                              | (:first, type: untyped, with: :apply_first) -> String
+                              | (:skip, type: untyped, with: :apply_skip) -> String
+              def self.description: (String) -> String
+              def self.types: (*untyped) -> String
+              def decode_global_key: (String value) -> Integer
+              def apply_filter: (untyped scope, untyped value) -> untyped
+              def normalize_filters: (untyped value, ?Array[untyped] branches) -> Array[untyped]
+
+              class #{singularized_class_name.camelize}Filter
+                String: String
+                Boolean: Boolean
+                Integer: Integer
+          TEXT
+        end
+        File.open(file_path, "a") do |f|
+          params[:params].each_with_index do |param, i|
+            type = Souls.rbs_type_check(param[:type])
+            type = "[#{type}]" if param[:array]
+            rbs_type = Souls.rbs_type_check(param[:type])
+            if i.zero?
+              f.write("    def self.argument: (:OR, [self], required: false) -> String\n")
+            else
+              f.write("                     | (:#{param[:column_name]}, #{type}, required: false) -> #{rbs_type}\n")
+            end
+          end
+        end
+
+        File.open(file_path, "a") do |f|
+          f.write(<<~TEXT)
+                end
+              end
+            end
+            module Types
+              class BaseBaseInputObject
+              end
+            end
+          TEXT
+        end
+      end
+      puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
+      file_path
+    rescue Thor::Error => e
+      raise(Thor::Error, e)
+    end
+  end
+end

data/lib/souls/api/generate/type_rbs.rb

@@ -0,0 +1,50 @@
+module Souls
+  class Generate < Thor
+    desc "type_rbs [CLASS_NAME]", "Generate GraphQL Type RBS from schema.rb"
+    def type_rbs(class_name)
+      singularized_class_name = class_name.underscore.singularize
+      file_path = ""
+      Dir.chdir(Souls.get_mother_path.to_s) do
+        file_dir = "./sig/api/app/graphql/types"
+        FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
+        file_path = "#{file_dir}/#{singularized_class_name}_type.rbs"
+        raise(Thor::Error, "Type RBS already exist! #{file_path}") if File.exist?(file_path)
+
+        params = Souls.get_relation_params(class_name: singularized_class_name)
+        File.open(file_path, "w") do |f|
+          f.write(<<~TEXT)
+            module Types
+              class #{singularized_class_name.camelize}Type < BaseObject
+                def self.implements: (*untyped) -> untyped
+                def self.global_id_field: (:id) -> String
+          TEXT
+        end
+        File.open(file_path, "a") do |f|
+          params[:params].each_with_index do |param, i|
+            type = Souls.rbs_type_check(param[:type])
+            type = "[#{type}]" if param[:array]
+            rbs_type = Souls.rbs_type_check(param[:type])
+            if i.zero?
+              f.write("    def self.field: (:#{param[:column_name]}, #{type}, null: false) -> #{rbs_type}\n")
+            else
+              f.write("                  | (:#{param[:column_name]}, #{type}, null: false) -> #{rbs_type}\n")
+            end
+          end
+        end
+
+        File.open(file_path, "a") do |f|
+          f.write(<<~TEXT)
+              def self.edge_type: () -> void
+                def self.connection_type: () -> void
+              end
+            end
+          TEXT
+        end
+      end
+      puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
+      file_path
+    rescue Thor::Error => e
+      raise(Thor::Error, e)
+    end
+  end
+end

data/lib/souls/cli.rb

@@ -44,15 +44,17 @@ module Souls
       puts(Souls::VERSION)
     end
 
-    desc "test", "Run (Rspec & steep check & Rubocop)"
+    desc "test", "Run Rspec & Rubocop"
     def test
       system("rubocop -A")
-      system("steep check")
       system("bundle exec rspec")
     end
 
-    desc "test_all", "Run Rspec & Rubocop"
+    desc "test_all", "Run (Rspec & steep check & Rubocop)"
     def test_all
+      Dir.chdir(Souls.get_mother_path.to_s) do
+        system("steep check")
+      end
       system("rubocop -A")
       system("bundle exec rspec")
     end

data/lib/souls/utils/index.rb

@@ -21,6 +21,19 @@ module Souls
       }[type.to_sym]
     end
 
+    def rbs_type_check(type)
+      {
+        bigint: "Integer",
+        string: "String",
+        float: "Float",
+        text: "String",
+        datetime: "String",
+        date: "String",
+        boolean: "bool",
+        integer: "Integer"
+      }[type.to_sym]
+    end
+
     def get_type_and_name(line)
       line.split(",")[0].gsub("\"", "").scan(/((?<=t\.).+(?=\s)) (.+)/)[0]
     end
@@ -98,13 +111,30 @@ module Souls
       end
     end
 
+    def get_relation_params(class_name: "user", col: "")
+      cols =
+        if col == "mutation"
+          get_columns_num_no_timestamp(class_name: class_name)
+        else
+          get_columns_num(class_name: class_name)
+        end
+      relation_params = cols.select { |col| col[:column_name].match?(/_id$/) }
+      user_check =
+        relation_params.map do |param|
+          param[:column_name] == "user_id"
+        end
+      user_exist = user_check.include?(true)
+      { user_exist: user_exist, params: cols, relation_params: relation_params }
+    end
+
     def get_columns_num(class_name: "user")
+      pluralized_class_name = class_name.pluralize
       file_path = "./db/schema.rb"
       class_check_flag = false
       cols = []
       File.open(file_path, "r") do |f|
         f.each_line.with_index do |line, _i|
-          class_check_flag = true if line.include?("create_table") && line.include?(class_name)
+          class_check_flag = true if line.include?("create_table") && line.include?(pluralized_class_name)
           if class_check_flag == true && !line.include?("create_table")
             return cols if line.include?("t.index") || line.strip == "end"
 
@@ -117,6 +147,29 @@ module Souls
       cols
     end
 
+    def get_columns_num_no_timestamp(class_name: "user")
+      pluralized_class_name = class_name.pluralize
+      file_path = "./db/schema.rb"
+      class_check_flag = false
+      cols = []
+      File.open(file_path, "r") do |f|
+        f.each_line.with_index do |line, _i|
+          class_check_flag = true if line.include?("create_table") && line.include?(pluralized_class_name)
+          if class_check_flag == true && !line.include?("create_table")
+            return cols if line.include?("t.index") || line.strip == "end"
+
+            types = Souls.get_type_and_name(line)
+            array = line.include?("array: true")
+            cols << { column_name: types[1], type: types[0], array: array } unless %w[
+              created_at
+              updated_at
+            ].include?(types[1])
+          end
+        end
+      end
+      cols
+    end
+
     def get_create_migration_type(class_name: "user")
       pluralized_class_name = class_name.pluralize
       file_path = Dir["db/migrate/*_create_#{pluralized_class_name}.rb"][0]

data/lib/souls/version.rb

@@ -1,4 +1,4 @@
 module Souls
-  VERSION = "0.55.2".freeze
+  VERSION = "0.56.0".freeze
   public_constant :VERSION
 end

data/lib/souls/versions/.souls_api_version

@@ -1 +1 @@
-0.34.2
+0.35.0

data/lib/souls/versions/.souls_worker_version

@@ -1 +1 @@
-0.34.2
+0.35.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: souls
 version: !ruby/object:Gem::Version
-  version: 0.55.2
+  version: 0.56.0
 platform: ruby
 authors:
 - POPPIN-FUMI
@@ -131,13 +131,19 @@ files:
 - lib/souls/api/generate/connection.rb
 - lib/souls/api/generate/connection_rbs.rb
 - lib/souls/api/generate/edge.rb
+- lib/souls/api/generate/edge_rbs.rb
 - lib/souls/api/generate/index.rb
 - lib/souls/api/generate/manager.rb
 - lib/souls/api/generate/model.rb
+- lib/souls/api/generate/model_rbs.rb
 - lib/souls/api/generate/mutation.rb
+- lib/souls/api/generate/mutation_rbs.rb
 - lib/souls/api/generate/policy.rb
+- lib/souls/api/generate/policy_rbs.rb
 - lib/souls/api/generate/query.rb
+- lib/souls/api/generate/query_rbs.rb
 - lib/souls/api/generate/resolver.rb
+- lib/souls/api/generate/resolver_rbs.rb
 - lib/souls/api/generate/rspec_factory.rb
 - lib/souls/api/generate/rspec_model.rb
 - lib/souls/api/generate/rspec_mutation.rb
@@ -145,6 +151,7 @@ files:
 - lib/souls/api/generate/rspec_query.rb
 - lib/souls/api/generate/rspec_resolver.rb
 - lib/souls/api/generate/type.rb
+- lib/souls/api/generate/type_rbs.rb
 - lib/souls/api/index.rb
 - lib/souls/api/update/index.rb
 - lib/souls/api/update/mutation.rb