souls 2.0.4 → 3.0.0

data/lib/souls/cli/delete/job_rbs.rb

@@ -1,22 +0,0 @@
-module SOULs
-  class Delete < Thor
-    desc "job_rbs [CLASS_NAME]", "Delete SOULs Job Mutation RBS Template"
-    def job_rbs(class_name)
-      file_path = ""
-      worker_name = FileUtils.pwd.split("/").last
-      if worker_name == "api" || FileUtils.pwd.split("/")[-2] != "apps"
-        raise(SOULs::CLIException, "This task must be run from within a worker directory")
-      end
-
-      Dir.chdir(SOULs.get_mother_path.to_s) do
-        singularized_class_name = class_name.underscore.singularize
-        file_dir = "./sig/#{worker_name}/app/graphql/queries/"
-        FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
-        file_path = "#{file_dir}#{singularized_class_name}.rbs"
-        FileUtils.rm_f(file_path)
-        SOULs::Painter.delete_file(file_path.to_s)
-      end
-      file_path
-    end
-  end
-end

data/lib/souls/cli/delete/manager_rbs.rb

@@ -1,17 +0,0 @@
-module SOULs
-  class Delete < Thor
-    desc "manager_rbs [CLASS_NAME]", "Delete SOULs Manager RBS Template"
-    method_option :mutation, aliases: "--mutation", required: true, desc: "Mutation File Name"
-    def manager_rbs(class_name)
-      file_path = ""
-      singularized_class_name = class_name.underscore.singularize
-      Dir.chdir(SOULs.get_mother_path.to_s) do
-        file_dir = "./sig/api/app/graphql/mutations/managers/#{singularized_class_name}_manager"
-        file_path = "#{file_dir}/#{options[:mutation]}.rbs"
-        FileUtils.rm_f(file_path)
-        SOULs::Painter.delete_file(file_path.to_s)
-      end
-      file_path
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module SOULs
-  class Delete < Thor
-    desc "mutation_rbs [CLASS_NAME]", "Delete GraphQL Mutation RBS"
-    def mutation_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/mutations/base/#{singularized_class_name}"
-        FileUtils.rm_rf(file_dir)
-      end
-      SOULs::Painter.delete_file(file_path.to_s)
-      file_path
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-module SOULs
-  class Delete < Thor
-    desc "query_rbs [CLASS_NAME]", "Delete GraphQL Query RBS"
-    def query_rbs(class_name)
-      file_path = ""
-      Dir.chdir(SOULs.get_mother_path.to_s) do
-        file_dir = "./sig/api/app/graphql/queries/"
-        singularized_class_name = class_name.underscore.singularize
-        file_path = "#{file_dir}#{singularized_class_name}*.rbs"
-        FileUtils.rm_f(file_path)
-        SOULs::Painter.delete_file(file_path.to_s)
-        file_path
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-module SOULs
-  class Delete < Thor
-    desc "resolver_rbs [CLASS_NAME]", "Delete GraphQL Resolver RBS"
-    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"
-        file_path = "#{file_dir}/#{singularized_class_name}_search.rbs"
-        FileUtils.rm_f(file_path)
-      end
-      SOULs::Painter.delete_file(file_path.to_s)
-      file_path
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-module SOULs
-  class Delete < Thor
-    desc "type_rbs [CLASS_NAME]", "Delete GraphQL Type RBS"
-    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"
-        file_path = "#{file_dir}/#{singularized_class_name}_type.rbs"
-        FileUtils.rm_f(file_path)
-      end
-      SOULs::Painter.delete_file(file_path.to_s)
-      file_path
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-module SOULs
-  class Generate < Thor
-    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 self.edge_type: (*untyped) -> untyped
-              end
-            end
-          TEXT
-        end
-        SOULs::Painter.create_file(file_path.to_s)
-      end
-      file_path
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-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 < Types::BaseEdge
-                def self.edge_type: (*untyped) -> untyped
-                def self.node_type: (*untyped) -> untyped
-                def self.global_id_field: (*untyped) -> untyped
-                def self.connection_type: ()-> untyped
-              end
-            end
-          TEXT
-        end
-        SOULs::Painter.create_file(file_path.to_s)
-      end
-      file_path
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-module SOULs
-  class Generate < Thor
-    desc "job_rbs [CLASS_NAME]", "Generate SOULs Job Mutation RBS Template"
-    def job_rbs(class_name)
-      file_path = ""
-      worker_name = FileUtils.pwd.split("/").last
-      Dir.chdir(SOULs.get_mother_path.to_s) do
-        singularized_class_name = class_name.underscore.singularize
-        file_dir = "./sig/#{worker_name}/app/graphql/queries/"
-        FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
-        file_path = "#{file_dir}#{singularized_class_name}.rbs"
-        sig_type_path = "./sig/#{worker_name}/app/graphql/types"
-        FileUtils.mkdir_p(sig_type_path) unless Dir.exist?(sig_type_path)
-        type_file_path = "#{sig_type_path}/#{singularized_class_name}_type.rbs"
-        File.open(file_path, "w") do |f|
-          f.write(<<~TEXT)
-            module Queries
-              class #{singularized_class_name.camelize} < BaseQuery
-                def self.description: (String) -> untyped
-                def self.field: (:response, String, null: false) -> untyped
-                def self.type: (untyped, null: false) -> untyped
-              end
-            end
-          TEXT
-        end
-        File.open(type_file_path, "w") do |f|
-          f.write(<<~TEXT)
-            module Types
-              class #{singularized_class_name.camelize}Type < SOULs::Types::BaseObject
-                def self.field: (:response, String, null: true) -> untyped
-              end
-            end
-          TEXT
-        end
-        SOULs::Painter.create_file(file_path.to_s)
-      end
-      file_path
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-module SOULs
-  class Generate < Thor
-    desc "manager_rbs [CLASS_NAME]", "Generate SOULs Manager RBS Template"
-    method_option :mutation, aliases: "--mutation", required: true, desc: "Mutation File Name"
-    def manager_rbs(class_name)
-      file_path = ""
-      singularized_class_name = class_name.underscore.singularize
-      Dir.chdir(SOULs.get_mother_path.to_s) do
-        file_dir = "./sig/api/app/graphql/mutations/managers/#{singularized_class_name}_manager"
-        FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
-        file_path = "#{file_dir}/#{options[:mutation]}.rbs"
-        File.open(file_path, "w") do |f|
-          f.write(<<~TEXT)
-            module Mutations
-              module Managers
-                module #{singularized_class_name.camelize}Manager
-                  class #{options[:mutation].singularize.camelize} < BaseMutation
-                    def self.description: (String)-> untyped
-                    def self.argument: (untyped, untyped, untyped)-> untyped
-                    def self.field: (untyped, untyped, untyped)-> untyped
-                  end
-                end
-              end
-            end
-          TEXT
-          SOULs::Painter.create_file(file_path.to_s)
-        end
-      end
-      file_path
-    end
-  end
-end

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