souls 2.0.4 → 3.0.2

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

@@ -1,241 +0,0 @@
-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)
-    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:, 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")
-            elsif param[:column_name].match?(/$*_id\z/)
-              f.write("                          #{param[:column_name]}: String?,\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?
-              if param[:column_name].match?(/$*_id\z/)
-                f.write(
-                  "        def self.argument: (:#{param[:column_name]}, String, " \
-                                    "required: false ) -> #{rbs_type}\n"
-                )
-              else
-                f.write(
-                  "        def self.argument: (:#{param[:column_name]}, #{type}, " \
-                                    "required: false ) -> #{rbs_type}\n"
-                )
-              end
-            elsif param[:column_name].match?(/$*_id\z/)
-              f.write("                         | (:#{param[:column_name]}, String, 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)
-
-                    def self.field: (*untyped) -> String
-                    attr_accessor context: {user:{
-                      id: Integer,
-                      username: String,
-                      email: String
-                    }}
-                  end
-                end
-              end
-            end
-          TEXT
-        end
-      end
-      SOULs::Painter.create_file(file_path.to_s)
-      file_path
-    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:, 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
-                    String: String
-                    Boolean: Boolean
-                    Integer: Integer
-                    def resolve:  ({
-                                    id: String,
-          TEXT
-        end
-        File.open(file_path, "a") do |f|
-          cols = params[:params].reject { |n| n[:column_name] == "user_id" }
-          cols.each_with_index do |param, i|
-            type = SOULs.rbs_type_check(param[:type])
-            type = "[#{type}]" if param[:array]
-            type = "String" if param[:column_name].match?(/$*_id\z/)
-
-            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|
-          cols = params[:params].reject { |n| n[:column_name] == "user_id" }
-          cols.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]
-            type = "String" if param[:column_name].match?(/$*_id\z/)
-            rbs_type = "String" if param[:column_name].match?(/$*_id\z/)
-
-            required = param[:column_name] == "id" ? "required: true" : "required: false"
-            if i.zero?
-              f.write("        def self.argument: (:#{param[:column_name]}, #{type}, #{required} ) -> #{rbs_type}\n")
-            else
-              f.write("                         | (:#{param[:column_name]}, #{type}, #{required} ) -> #{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
-      SOULs::Painter.create_file(file_path.to_s)
-      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
-        SOULs::Painter.create_file(file_path.to_s)
-      end
-      file_path
-    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
-        SOULs::Painter.create_file(file_path.to_s)
-      end
-      file_path
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-module SOULs
-  class Generate < Thor
-    desc "query_rbs [CLASS_NAME]", "Generate GraphQL Query RBS"
-    def query_rbs(class_name)
-      single_query_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
-        SOULs::Painter.create_file(file_path.to_s)
-      end
-      file_path
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-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)
-
-        File.open(file_path, "w") do |f|
-          f.write(<<~TEXT)
-            module Resolvers
-              class BaseResolver
-              end
-              class #{singularized_class_name.camelize}Search < BaseResolver
-                include SearchObject
-                def self.scope: () ?{ () -> nil } -> [Hash[Symbol, untyped]]
-                def self.type: (*untyped) -> String
-                def self.option: (:filter, type: untyped, with: :apply_filter) -> 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
-
-                class #{singularized_class_name.camelize}Filter
-                  String: String
-                  Boolean: Boolean
-                  Integer: Integer
-                end
-              end
-            end
-          TEXT
-        end
-      end
-      SOULs::Painter.create_file(file_path.to_s)
-      file_path
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-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.type_check(param[:type])
-            type = "[#{type}]" if param[:array]
-            rbs_type = SOULs.rbs_type_check(param[:type])
-            if i.zero?
-              if param[:column_name].match?(/$*_id\z/)
-                col_name = param[:column_name].gsub("_id", "")
-                f.write("    def self.field: (:#{col_name}, untyped, null: false) -> untyped\n")
-              else
-                f.write("    def self.field: (:#{param[:column_name]}, #{type}, null: true) -> #{rbs_type}\n")
-              end
-            elsif param[:column_name].match?(/$*_id\z/)
-              col_name = param[:column_name].gsub("_id", "")
-              f.write("                  | (:#{col_name}, untyped, null: false) -> untyped\n")
-            else
-              f.write("                  | (:#{param[:column_name]}, #{type}, null: true) -> #{rbs_type}\n")
-            end
-          end
-        end
-
-        File.open(file_path, "a") do |f|
-          f.write(<<~TEXT)
-              def self.edge_type: () -> untyped
-                def self.connection_type: () -> untyped
-              end
-            end
-          TEXT
-        end
-      end
-      SOULs::Painter.create_file(file_path.to_s)
-      file_path
-    end
-  end
-end

data/lib/souls/cli/update/mutation_rbs.rb

@@ -1,126 +0,0 @@
-module SOULs
-  class Update < Thor
-    desc "create_mutation_rbs [CLASS_NAME]", "Update GraphQL Type from schema.rb"
-    def create_mutation_rbs(class_name)
-      singularized_class_name = class_name.singularize.underscore
-      new_cols = ""
-      Dir.chdir(SOULs.get_api_path.to_s) do
-        new_cols = SOULs.get_columns_num(class_name: singularized_class_name)
-      end
-      dir_name = "./sig/api/app/graphql/mutations/base/#{singularized_class_name}"
-      file_path = "#{dir_name}/create_#{singularized_class_name}.rbs"
-      argument = false
-      resolve = false
-      write_txt = ""
-      File.open(file_path, "r") do |f|
-        f.each_line do |line|
-          next if line.include?("| (:") && argument
-
-          if line.include?("{ :node => String } } | ::GraphQL::ExecutionError )")
-            write_txt += line
-            resolve = false
-          elsif resolve
-            next
-          elsif line.include?("def resolve:") && !resolve
-            new_cols.each_with_index do |col, i|
-              type = SOULs.type_check(col[:type])
-              type = "[#{type}]" if col[:array]
-              next if col[:column_name] == "created_at" || col[:column_name] == "updated_at"
-
-              write_txt +=
-                if i.zero?
-                  line
-                else
-                  "                          #{col[:column_name]}: #{type}?,\n"
-                end
-            end
-            resolve = true
-          elsif line.include?("def self.argument:") && !argument
-            new_cols.each_with_index do |col, i|
-              type = SOULs.type_check(col[:type])
-              type = "[#{type}]" if col[:array]
-              next if col[:column_name] == "created_at" || col[:column_name] == "updated_at"
-
-              if i.zero?
-                write_txt +=
-                  "        def self.argument: (:#{col[:column_name]}, #{type}, required: false ) -> #{type}\n"
-              else
-                write_txt +=
-                  "                         | (:#{col[:column_name]}, #{type}, required: false ) -> #{type}\n"
-              end
-            end
-            argument = true
-          else
-            write_txt += line
-          end
-        end
-      end
-      File.open(file_path, "w") { |f| f.write(write_txt) }
-      SOULs::Painter.update_file(file_path.to_s)
-    end
-
-    desc "update_mutation [CLASS_NAME]", "Update GraphQL Type from schema.rb"
-    def update_mutation_rbs(class_name)
-      singularized_class_name = class_name.singularize.underscore
-      new_cols = ""
-      Dir.chdir(SOULs.get_api_path.to_s) do
-        new_cols = SOULs.get_columns_num(class_name: singularized_class_name)
-      end
-      dir_name = "./sig/api/app/graphql/mutations/base/#{singularized_class_name}"
-      new_file_path = "config/update_mutation.rbs"
-      file_path = "#{dir_name}/update_#{singularized_class_name}.rbs"
-      argument = false
-      resolve = false
-      File.open(file_path) do |f|
-        File.open(new_file_path, "w") do |new_line|
-          f.each_line do |line|
-            next if line.include?("| (:") && argument
-
-            if line.include?("{ :node => String } } | ::GraphQL::ExecutionError )")
-              new_line.write(line)
-              resolve = false
-            elsif resolve
-              next
-            elsif line.include?("def resolve:") && !resolve
-              new_cols.each_with_index do |col, i|
-                type = SOULs.type_check(col[:type])
-                type = "[#{type}]" if col[:array]
-                next if col[:column_name] == "created_at" || col[:column_name] == "updated_at"
-
-                if i.zero?
-                  new_line.write(line)
-                  new_line.write("                          id: String,\n")
-                else
-                  new_line.write("                          #{col[:column_name]}: #{type}?,\n")
-                end
-              end
-              resolve = true
-            elsif line.include?("def self.argument:") && !argument
-              new_cols.each_with_index do |col, i|
-                type = SOULs.type_check(col[:type])
-                type = "[#{type}]" if col[:array]
-                next if col[:column_name] == "created_at" || col[:column_name] == "updated_at"
-
-                if i.zero?
-                  new_line.write(
-                    "        def self.argument: (:#{col[:column_name]}, #{type}, required: false ) -> #{type}\n"
-                  )
-                else
-                  new_line.write(
-                    "                         | (:#{col[:column_name]}, #{type}, required: false ) -> #{type}\n"
-                  )
-                end
-              end
-              argument = true
-            else
-              new_line.write(line)
-            end
-          end
-        end
-      end
-      FileUtils.rm(file_path)
-      FileUtils.mv(new_file_path, file_path)
-      SOULs::Painter.update_file(file_path.to_s)
-    end
-  end
-end

data/lib/souls/cli/update/type_rbs.rb

@@ -1,44 +0,0 @@
-module SOULs
-  class Update < Thor
-    desc "type_rbs [CLASS_NAME]", "Update GraphQL Type from schema.rb"
-    def type_rbs(class_name)
-      singularized_class_name = class_name.singularize.underscore
-      new_cols = ""
-      Dir.chdir(SOULs.get_api_path.to_s) do
-        new_cols = SOULs.get_columns_num(class_name: singularized_class_name)
-      end
-      dir_name = "./sig/api/app/graphql/types"
-      new_file_path = "config/create_type.rbs"
-      file_path = "#{dir_name}/#{singularized_class_name}_type.rbs"
-      argument = false
-      File.open(file_path) do |f|
-        File.open(new_file_path, "w") do |new_line|
-          f.each_line do |line|
-            next if line.include?("| (:") && argument
-
-            if line.include?("    def self.edge_type:")
-              new_line.write(line)
-              argument = false
-            elsif line.include?("def self.field:") && !argument
-              new_cols.each_with_index do |col, i|
-                type = SOULs.get_type(col[:type])
-                type = "[#{type}]" if col[:array]
-                if i.zero?
-                  new_line.write("    def self.field: (:#{col[:column_name]}, #{type}, null: true) -> #{type}\n")
-                else
-                  new_line.write("                  | (:#{col[:column_name]}, #{type}, null: true) -> #{type}\n")
-                end
-              end
-              argument = true
-            else
-              new_line.write(line)
-            end
-          end
-        end
-      end
-      FileUtils.rm(file_path)
-      FileUtils.mv(new_file_path, file_path)
-      SOULs::Painter.update_file(file_path.to_s)
-    end
-  end
-end

data/lib/souls/cli/upgrade/submodule.rb

@@ -1,8 +0,0 @@
-module SOULs
-  class Upgrade < Thor
-    desc "submodule", "Run git submodule update --init RBS collection"
-    def submodule
-      system("git submodule update --init https://github.com/ruby/gem_rbs_collection.git vendor/rbs/gem_rbs_collection")
-    end
-  end
-end