souls 0.44.5 → 0.45.2

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

@@ -1,7 +1,7 @@
 module Souls
   module Api::Generate
     ## Generate Policy
-    def self.policy(class_name: "souls")
+    def self.policy(class_name: "user")
       dir_name = "./app/policies"
       FileUtils.mkdir_p(dir_name) unless Dir.exist?(dir_name)
       file_path = "#{dir_name}/#{class_name.singularize}_policy.rb"

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

@@ -1,66 +1,68 @@
 module Souls
   module Api::Generate
     ## Generate Query / Queries
-    def self.create_queries(class_name: "souls")
-      file_path = "./app/graphql/queries/#{class_name.pluralize}.rb"
-      return "Query already exist! #{file_path}" if File.exist?(file_path)
+    class << self
+      def create_queries(class_name: "user")
+        file_path = "./app/graphql/queries/#{class_name.pluralize}.rb"
+        return "Query already exist! #{file_path}" if File.exist?(file_path)
 
-      File.open(file_path, "w") do |f|
-        f.write(<<~TEXT)
-          module Queries
-            class #{class_name.camelize.pluralize} < Queries::BaseQuery
-              type [Types::#{class_name.camelize}Type], null: false
+        File.open(file_path, "w") do |f|
+          f.write(<<~TEXT)
+            module Queries
+              class #{class_name.camelize.pluralize} < Queries::BaseQuery
+                type [Types::#{class_name.camelize}Type], null: false
 
-              def resolve
-                ::#{class_name.camelize}.all
-              rescue StandardError => error
-                GraphQL::ExecutionError.new error
+                def resolve
+                  ::#{class_name.camelize}.all
+                rescue StandardError => error
+                  GraphQL::ExecutionError.new error
+                end
               end
             end
-          end
-        TEXT
+          TEXT
+        end
+        puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
+        file_path
+      rescue StandardError => e
+        raise(StandardError, e)
       end
-      puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
-      file_path
-    rescue StandardError => e
-      raise(StandardError, e)
-    end
 
-    def self.create_query(class_name: "souls")
-      file_path = "./app/graphql/queries/#{class_name}.rb"
-      return "Query already exist! #{file_path}" if File.exist?(file_path)
+      def create_query(class_name: "user")
+        file_path = "./app/graphql/queries/#{class_name}.rb"
+        return "Query already exist! #{file_path}" if File.exist?(file_path)
 
-      File.open(file_path, "w") do |f|
-        f.write(<<~TEXT)
-          module Queries
-            class #{class_name.camelize} < Queries::BaseQuery
-              type Types::#{class_name.camelize}Type, null: false
-              argument :id, String, required: true
+        File.open(file_path, "w") do |f|
+          f.write(<<~TEXT)
+            module Queries
+              class #{class_name.camelize} < Queries::BaseQuery
+                type Types::#{class_name.camelize}Type, null: false
+                argument :id, String, required: true
 
-              def resolve **args
-                _, data_id = SoulsApiSchema.from_global_id args[:id]
-                ::#{class_name.camelize}.find(data_id)
-              rescue StandardError => error
-                GraphQL::ExecutionError.new error
+                def resolve **args
+                  _, data_id = SoulsApiSchema.from_global_id args[:id]
+                  ::#{class_name.camelize}.find(data_id)
+                rescue StandardError => error
+                  GraphQL::ExecutionError.new error
+                end
               end
             end
-          end
-        TEXT
-        puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
-        file_path
+          TEXT
+          puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
+          file_path
+        rescue StandardError => e
+          raise(StandardError, e)
+        end
+      end
+
+      def query(class_name: "user")
+        file_dir = "./app/graphql/queries/"
+        FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
+        singularized_class_name = class_name.singularize
+        create_query(class_name: singularized_class_name)
+        create_queries(class_name: singularized_class_name)
       rescue StandardError => e
         raise(StandardError, e)
       end
     end
-
-    def self.query(class_name: "souls")
-      file_dir = "./app/graphql/queries/"
-      FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
-      singularized_class_name = class_name.singularize
-      create_query(class_name: singularized_class_name)
-      create_queries(class_name: singularized_class_name)
-    rescue StandardError => e
-      raise(StandardError, e)
-    end
   end
 end

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

@@ -1,156 +1,158 @@
 module Souls
   module Api::Generate
     ## Generate Resolver
-    def self.resolver_head(class_name: "souls")
-      FileUtils.mkdir_p("./app/graphql/resolvers") unless Dir.exist?("./app/graphql/resolvers")
-      file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
-      @relation_params = []
-      File.open(file_path, "w") do |f|
-        f.write(<<~TEXT)
-          module Resolvers
-            class #{class_name.camelize}Search < Base
-              include SearchObject.module(:graphql)
-              scope { ::#{class_name.camelize}.all }
-              type Types::#{class_name.camelize}Type.connection_type, null: false
-              description "Search #{class_name.camelize}"
+    class << self
+      def resolver_head(class_name: "user")
+        FileUtils.mkdir_p("./app/graphql/resolvers") unless Dir.exist?("./app/graphql/resolvers")
+        file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
+        @relation_params = []
+        File.open(file_path, "w") do |f|
+          f.write(<<~TEXT)
+            module Resolvers
+              class #{class_name.camelize}Search < Base
+                include SearchObject.module(:graphql)
+                scope { ::#{class_name.camelize}.all }
+                type Types::#{class_name.camelize}Type.connection_type, null: false
+                description "Search #{class_name.camelize}"
 
-              class #{class_name.camelize}Filter < ::Types::BaseInputObject
-                argument :OR, [self], required: false
-        TEXT
+                class #{class_name.camelize}Filter < ::Types::BaseInputObject
+                  argument :OR, [self], required: false
+          TEXT
+        end
       end
-    end
 
-    def self.resolver_params(class_name: "souls")
-      file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
-      path = "./db/schema.rb"
-      @on = false
-      @user_exist = false
-      @relation_params = []
-      File.open(file_path, "a") do |new_line|
-        File.open(path, "r") do |f|
-          f.each_line.with_index do |line, _i|
-            if @on
-              break if line.include?("t.index") || line.strip == "end"
+      def resolver_params(class_name: "user")
+        file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
+        path = "./db/schema.rb"
+        @on = false
+        @user_exist = false
+        @relation_params = []
+        File.open(file_path, "a") do |new_line|
+          File.open(path, "r") do |f|
+            f.each_line.with_index do |line, _i|
+              if @on
+                break if line.include?("t.index") || line.strip == "end"
 
-              field = "[String]" if line.include?("array: true")
-              type, name = get_type_and_name(line)
-              field ||= type_check(type)
-              case name
-              when "user_id"
-                @user_exist = true
-              when /$*_id\z/
-                @relation_params << name
-                new_line.write("      argument :#{name}, String, required: false\n")
-              when "created_at", "updated_at"
-                next
-              else
-                new_line.write("      argument :#{name}, #{field}, required: false\n")
+                field = "[String]" if line.include?("array: true")
+                type, name = get_type_and_name(line)
+                field ||= type_check(type)
+                case name
+                when "user_id"
+                  @user_exist = true
+                when /$*_id\z/
+                  @relation_params << name
+                  new_line.write("      argument :#{name}, String, required: false\n")
+                when "created_at", "updated_at"
+                  next
+                else
+                  new_line.write("      argument :#{name}, #{field}, required: false\n")
+                end
               end
+              @on = true if table_check(line: line, class_name: class_name)
             end
-            @on = true if table_check(line: line, class_name: class_name)
           end
         end
       end
-    end
 
-    def self.resolver_after_params(class_name: "souls")
-      file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
-      File.open(file_path, "a") do |f|
-        f.write(<<-TEXT)
-      argument :start_date, String, required: false
-      argument :end_date, String, required: false
-    end
+      def resolver_after_params(class_name: "user")
+        file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
+        File.open(file_path, "a") do |f|
+          f.write(<<-TEXT)
+        argument :start_date, String, required: false
+        argument :end_date, String, required: false
+      end
 
-    option :filter, type: #{class_name.camelize}Filter, with: :apply_filter
-    option :first, type: types.Int, with: :apply_first
-    option :skip, type: types.Int, with: :apply_skip
+      option :filter, type: #{class_name.camelize}Filter, with: :apply_filter
+      option :first, type: types.Int, with: :apply_first
+      option :skip, type: types.Int, with: :apply_skip
 
-    def apply_filter(scope, value)
-      branches = normalize_filters(value).inject { |a, b| a.or(b) }
-      scope.merge branches
-    end
+      def apply_filter(scope, value)
+        branches = normalize_filters(value).inject { |a, b| a.or(b) }
+        scope.merge branches
+      end
 
-    def normalize_filters(value, branches = [])
-      scope = ::#{class_name.camelize}.all
-        TEXT
+      def normalize_filters(value, branches = [])
+        scope = ::#{class_name.camelize}.all
+          TEXT
+        end
       end
-    end
 
-    def self.resolver_before_end(class_name: "souls")
-      file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
-      path = "./db/schema.rb"
-      @on = false
-      @user_exist = false
-      @relation_params = []
-      File.open(file_path, "a") do |new_line|
-        File.open(path, "r") do |f|
-          f.each_line.with_index do |line, _i|
-            if @on
-              break if line.include?("t.index") || line.strip == "end"
+      def resolver_before_end(class_name: "user")
+        file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
+        path = "./db/schema.rb"
+        @on = false
+        @user_exist = false
+        @relation_params = []
+        File.open(file_path, "a") do |new_line|
+          File.open(path, "r") do |f|
+            f.each_line.with_index do |line, _i|
+              if @on
+                break if line.include?("t.index") || line.strip == "end"
 
-              type, name = get_type_and_name(line)
-              if line.include?("array: true")
-                new_line.write(
-                  "      scope = scope.where(\"#{name} @> ARRAY[?]::text[]\", value[:#{name}]) if value[:#{name}]\n"
-                )
-                next
-              end
-              case name
-              when "user_id"
-                @user_exist = true
-              when /$*_id\z/
-                @relation_params << name
-                new_line.write(
-                  "      scope = scope.where(#{name}: decode_global_key(value[:#{name}])) if value[:#{name}]\n"
-                )
-              when "created_at", "updated_at"
-                next
-              else
-                case type
-                when "boolean"
-                  new_line.write("      scope = scope.where(#{name}: value[:#{name}]) unless value[:#{name}].nil?\n")
+                type, name = get_type_and_name(line)
+                if line.include?("array: true")
+                  new_line.write(
+                    "      scope = scope.where(\"#{name} @> ARRAY[?]::text[]\", value[:#{name}]) if value[:#{name}]\n"
+                  )
+                  next
+                end
+                case name
+                when "user_id"
+                  @user_exist = true
+                when /$*_id\z/
+                  @relation_params << name
+                  new_line.write(
+                    "      scope = scope.where(#{name}: decode_global_key(value[:#{name}])) if value[:#{name}]\n"
+                  )
+                when "created_at", "updated_at"
+                  next
                 else
-                  new_line.write("      scope = scope.where(#{name}: value[:#{name}]) if value[:#{name}]\n")
+                  case type
+                  when "boolean"
+                    new_line.write("      scope = scope.where(#{name}: value[:#{name}]) unless value[:#{name}].nil?\n")
+                  else
+                    new_line.write("      scope = scope.where(#{name}: value[:#{name}]) if value[:#{name}]\n")
+                  end
                 end
               end
+              @on = true if table_check(line: line, class_name: class_name)
             end
-            @on = true if table_check(line: line, class_name: class_name)
           end
         end
       end
-    end
 
-    def self.resolver_end(class_name: "souls")
-      file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
-      File.open(file_path, "a") do |f|
-        f.write(<<~TEXT)
-                scope = scope.where("created_at >= ?", value[:start_date]) if value[:start_date]
-                scope = scope.where("created_at <= ?", value[:end_date]) if value[:end_date]
-                branches << scope
-                value[:OR].inject(branches) { |s, v| normalize_filters(v, s) } if value[:OR].present?
-                branches
+      def resolver_end(class_name: "user")
+        file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
+        File.open(file_path, "a") do |f|
+          f.write(<<~TEXT)
+                  scope = scope.where("created_at >= ?", value[:start_date]) if value[:start_date]
+                  scope = scope.where("created_at <= ?", value[:end_date]) if value[:end_date]
+                  branches << scope
+                  value[:OR].inject(branches) { |s, v| normalize_filters(v, s) } if value[:OR].present?
+                  branches
+                end
               end
             end
-          end
-        TEXT
+          TEXT
+        end
+        file_path
       end
-      file_path
-    end
 
-    def self.resolver(class_name: "souls")
-      singularized_class_name = class_name.singularize.underscore
-      file_path = "./app/graphql/resolvers/#{singularized_class_name}_search.rb"
-      raise(StandardError, "Resolver already exist! #{file_path}") if File.exist?(file_path)
+      def resolver(class_name: "user")
+        singularized_class_name = class_name.singularize.underscore
+        file_path = "./app/graphql/resolvers/#{singularized_class_name}_search.rb"
+        raise(StandardError, "Resolver already exist! #{file_path}") if File.exist?(file_path)
 
-      resolver_head(class_name: singularized_class_name)
-      resolver_params(class_name: singularized_class_name)
-      resolver_after_params(class_name: singularized_class_name)
-      resolver_before_end(class_name: singularized_class_name)
-      resolver_end(class_name: singularized_class_name)
-      puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
-      file_path
-    rescue StandardError => e
-      raise(StandardError, e)
+        resolver_head(class_name: singularized_class_name)
+        resolver_params(class_name: singularized_class_name)
+        resolver_after_params(class_name: singularized_class_name)
+        resolver_before_end(class_name: singularized_class_name)
+        resolver_end(class_name: singularized_class_name)
+        puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
+        file_path
+      rescue StandardError => e
+        raise(StandardError, e)
+      end
     end
   end
 end

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

@@ -1,65 +1,67 @@
 module Souls
   module Api::Generate
     ## Generate Rspec Factory
-    def self.rspec_factory_head(class_name: "souls")
-      file_path = "./spec/factories/#{class_name.pluralize}.rb"
-      FileUtils.mkdir_p("./spec/factories/") unless Dir.exist?("./spec/factories/")
-      File.open(file_path, "w") do |f|
-        f.write(<<~TEXT)
-          FactoryBot.define do
-            factory :#{class_name} do
-        TEXT
+    class << self
+      def rspec_factory_head(class_name: "user")
+        file_path = "./spec/factories/#{class_name.pluralize}.rb"
+        FileUtils.mkdir_p("./spec/factories/") unless Dir.exist?("./spec/factories/")
+        File.open(file_path, "w") do |f|
+          f.write(<<~TEXT)
+            FactoryBot.define do
+              factory :#{class_name} do
+          TEXT
+        end
       end
-    end
 
-    def self.rspec_factory_params(class_name: "souls")
-      file_path = "./spec/factories/#{class_name.pluralize}.rb"
-      path = "./db/schema.rb"
-      @on = false
-      File.open(file_path, "a") do |new_line|
-        File.open(path, "r") do |f|
-          f.each_line.with_index do |line, _i|
-            if @on
-              new_line.write("\n" && break) if line.include?("t.index") || line.strip == "end"
-              field = '["tag1", "tag2", "tag3"]' if line.include?("array: true")
-              type, name = line.split(",")[0].gsub("\"", "").scan(/((?<=t\.).+(?=\s)) (.+)/)[0]
-              field ||= get_test_type(type)
-              if type == "bigint" && name.include?("_id")
-                id_name = name.gsub("_id", "")
-                new_line.write("    association :#{id_name}, factory: :#{id_name}\n")
-              else
-                new_line.write("    #{name} { #{field} }\n")
+      def rspec_factory_params(class_name: "user")
+        file_path = "./spec/factories/#{class_name.pluralize}.rb"
+        path = "./db/schema.rb"
+        @on = false
+        File.open(file_path, "a") do |new_line|
+          File.open(path, "r") do |f|
+            f.each_line.with_index do |line, _i|
+              if @on
+                new_line.write("\n" && break) if line.include?("t.index") || line.strip == "end"
+                field = '["tag1", "tag2", "tag3"]' if line.include?("array: true")
+                type, name = line.split(",")[0].gsub("\"", "").scan(/((?<=t\.).+(?=\s)) (.+)/)[0]
+                field ||= get_test_type(type)
+                if type == "bigint" && name.include?("_id")
+                  id_name = name.gsub("_id", "")
+                  new_line.write("    association :#{id_name}, factory: :#{id_name}\n")
+                else
+                  new_line.write("    #{name} { #{field} }\n")
+                end
               end
+              @on = true if table_check(line: line, class_name: class_name)
             end
-            @on = true if table_check(line: line, class_name: class_name)
           end
         end
       end
-    end
 
-    def self.rspec_factory_end(class_name: "souls")
-      file_path = "./spec/factories/#{class_name.pluralize}.rb"
-      File.open(file_path, "a") do |f|
-        f.write(<<~TEXT)
+      def rspec_factory_end(class_name: "user")
+        file_path = "./spec/factories/#{class_name.pluralize}.rb"
+        File.open(file_path, "a") do |f|
+          f.write(<<~TEXT)
+              end
             end
-          end
-        TEXT
+          TEXT
+        end
+        file_path
       end
-      file_path
-    end
 
-    def self.rspec_factory(class_name: "souls")
-      file_path = "./spec/factories/#{class_name.pluralize}.rb"
-      return "RspecFactory already exist! #{file_path}" if File.exist?(file_path)
+      def rspec_factory(class_name: "user")
+        file_path = "./spec/factories/#{class_name.pluralize}.rb"
+        return "RspecFactory already exist! #{file_path}" if File.exist?(file_path)
 
-      singularized_class_name = class_name.singularize
-      rspec_factory_head(class_name: singularized_class_name)
-      rspec_factory_params(class_name: singularized_class_name)
-      rspec_factory_end(class_name: singularized_class_name)
-      puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
-      file_path
-    rescue StandardError => e
-      raise(StandardError, e)
+        singularized_class_name = class_name.singularize
+        rspec_factory_head(class_name: singularized_class_name)
+        rspec_factory_params(class_name: singularized_class_name)
+        rspec_factory_end(class_name: singularized_class_name)
+        puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
+        file_path
+      rescue StandardError => e
+        raise(StandardError, e)
+      end
     end
   end
 end