ibrain-core 0.1.0

data/lib/generators/ibrain/graphql/object_generator.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative 'type_generator'
+
+module Ibrain
+  module Graphql
+    # Generate an object type by name,
+    # with the specified fields.
+    #
+    # ```
+    # rails g graphql:object PostType name:String!
+    # ```
+    #
+    # Add the Node interface with `--node`.
+    class ObjectGenerator < TypeGeneratorBase
+      desc "Create a GraphQL::ObjectType with the given name and fields." \
+           "If the given type name matches an existing ActiveRecord model, the generated type will automatically include fields for the models database columns."
+      source_root File.expand_path('templates', __dir__)
+
+      argument :custom_fields,
+               type: :array,
+               default: [],
+               banner: "name:type name:type ...",
+               desc: "Fields for this object (type may be expressed as Ruby or GraphQL)"
+
+      class_option :node,
+                   type: :boolean,
+                   default: false,
+                   desc: "Include the Relay Node interface"
+
+      def create_type_file
+        template "object.erb", "#{options[:directory]}/types/objects/#{type_file_name}.rb"
+      end
+
+      def fields
+        columns = []
+        columns += klass.columns.map { |c| generate_column_string(c) } if class_exists?
+        columns + custom_fields
+      end
+
+      def self.normalize_type_expression(type_expression, mode:, null: true)
+        case type_expression
+        when "Text", "Json", "json"
+          ["String", null]
+        when "Decimal"
+          ["Float", null]
+        when "DateTime", "Datetime"
+          ["GraphQL::Types::ISO8601DateTime", null]
+        when "Date"
+          ["GraphQL::Types::ISO8601Date", null]
+        else
+          super
+        end
+      end
+
+      private
+
+      def generate_column_string(column)
+        name = column.name
+        required = column.null ? "" : "!"
+        type = column_type_string(column)
+        "#{name}:#{required}#{type}"
+      end
+
+      def column_type_string(column)
+        column.name == "id" ? "ID" : column.type.to_s.camelize
+      end
+
+      def class_exists?
+        klass.is_a?(Class) && klass.ancestors.include?(ActiveRecord::Base)
+      rescue NameError
+        false
+      end
+
+      def klass
+        @klass ||= Module.const_get(type_name.camelize)
+      end
+    end
+  end
+end

data/lib/generators/ibrain/graphql/resolver_generator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# frozen_string_literal: true'
+
+require_relative 'resolvers_generator'
+
+module Ibrain
+  module Graphql
+    # TODO: What other options should be supported?
+    #
+    # @example Generate a `GraphQL::Schema::Resolver` by name
+    #     rails g graphql:resolver PostsResolver
+    class ResolverGenerator < ResolversGenerator
+      source_root File.expand_path('templates', __dir__)
+
+      def create_resolver_file
+        if @behavior == :revoke
+          log :gsub, "#{options[:directory]}/types/query_type.rb"
+        else
+          create_resolver_root_type
+        end
+
+        template "resolver.erb", "#{options[:directory]}/resolvers/#{file_name}.rb"
+
+        sentinel = /class .*QueryType\s*<\s*[^\s]+?\n/m
+        in_root do
+          gsub_file "#{options[:directory]}/types/query_type.rb", /  \# TODO: Add Resolvers as fields\s*\n/m, ""
+          inject_into_file "#{options[:directory]}/types/query_type.rb", "    field :#{field_name}, resolver: Resolvers::#{resolver_name}\n\n", after: sentinel, verbose: false, force: false
+        end
+      end
+    end
+  end
+end

data/lib/generators/ibrain/graphql/resolvers_generator.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/named_base'
+require_relative 'core'
+
+module Ibrain
+  module Graphql
+    # TODO: What other options should be supported?
+    #
+    # @example Generate a `GraphQL::Schema::Resolver` by name
+    #     rails g graphql:resolver PostsResolver
+    class ResolversGenerator < Rails::Generators::Base
+      include Core
+
+      desc "Create a resolver by name"
+      source_root File.expand_path('templates', __dir__)
+
+      argument :name, type: :string
+      class_option :model, type: :string, default: nil
+
+      def initialize(args, *options) # :nodoc:
+        # Unfreeze name in case it's given as a frozen string
+        args[0] = args[0].dup if args[0].is_a?(String) && args[0].frozen?
+        super
+
+        assign_names!(name)
+      end
+
+      attr_reader :file_name, :resolver_name, :field_name, :model_name
+
+      def create_resolver_file
+        if @behavior == :revoke
+          log :gsub, "#{options[:directory]}/types/query_type.rb"
+        else
+          create_resolver_root_type
+        end
+
+        template "resolvers.erb", "#{options[:directory]}/resolvers/#{file_name}.rb"
+        template "aggregate.erb", "#{options[:directory]}/resolvers/#{file_name}_aggregate.rb"
+
+        sentinel = /class .*QueryType\s*<\s*[^\s]+?\n/m
+        in_root do
+          gsub_file "#{options[:directory]}/types/query_type.rb", /  \# TODO: Add Resolvers as fields\s*\n/m, ""
+          inject_into_file "#{options[:directory]}/types/query_type.rb", "    field :#{field_name}, resolver: Resolvers::#{resolver_name}\n    field :#{field_name}_aggregate, resolver: Resolvers::#{resolver_name}Aggregate\n\n", after: sentinel, verbose: false, force: false
+        end
+      end
+
+      private
+
+      def assign_names!(name)
+        @field_name = name.camelize.underscore
+        @resolver_name = name.camelize(:upper)
+        @file_name = name.camelize.underscore
+        @model_name = options[:model].blank? ? 'Post' : options[:model].capitalize
+      end
+    end
+  end
+end

data/lib/generators/ibrain/graphql/templates/aggregate.erb

@@ -0,0 +1,10 @@
+<% module_namespacing_when_supported do -%>
+module Resolvers
+  class <%= "#{resolver_name}Aggregate" %> < Ibrain::Resolvers::BaseAggregate
+    # define resolve method
+    def resolve(args)
+      <%= model_name.capitalize %>.ransack(args[:filter]).result
+    end
+  end
+end
+<% end -%>

data/lib/generators/ibrain/graphql/templates/mutation.erb

@@ -0,0 +1,16 @@
+<% module_namespacing_when_supported do -%>
+module Mutations
+  class <%= mutation_name %> < Ibrain::Mutations::BaseMutation
+    # TODO: define return fields
+    field :<%= model_name.underscore %>, Types::<%= model_name %>Type, null: false
+
+    # TODO: define arguments
+    # argument :name, String, required: true
+
+    # TODO: define resolve method
+    def resolve(args)
+      # TODO: define logic
+    end
+  end
+end
+<% end -%>

data/lib/generators/ibrain/graphql/templates/object.erb

@@ -0,0 +1,11 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  module Objects
+    class <%= type_ruby_name.split('::')[-1] %> < Ibrain::Types::BaseObject
+      implements Ibrain::Interfaces::RecordInterface
+      
+    <% normalized_fields.each do |f| %>  <%= f.to_ruby %>
+    <% end %>end
+  end
+end
+<% end -%>

data/lib/generators/ibrain/graphql/templates/resolver.erb

@@ -0,0 +1,15 @@
+<% module_namespacing_when_supported do -%>
+module Resolvers
+  class <%= resolver_name %> < Ibrain::Resolvers::BaseResolver
+    # TODO: define return fields
+    type Types::Objects::<%= model_name.capitalize %>Type, null: false
+
+    argument :id, ID, required: false
+
+    # TODO: define resolve method
+    def resolve(args)
+      <%= model_name.capitalize %>.find args[:id]
+    end
+  end
+end
+<% end -%>

data/lib/generators/ibrain/graphql/templates/resolvers.erb

@@ -0,0 +1,13 @@
+<% module_namespacing_when_supported do -%>
+module Resolvers
+  class <%= resolver_name %> < <%= "#{resolver_name}Aggregate" %>
+    # TODO: define return fields
+    type [Types::Objects::<%= model_name.capitalize %>Type], null: false
+
+    # TODO: define resolve method
+    def resolve(args)
+      super(args).limit(args[:limit]).offset(args[:offset])
+    end
+  end
+end
+<% end -%>

data/lib/generators/ibrain/graphql/type_generator.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/base'
+require 'graphql'
+require 'active_support'
+require 'active_support/core_ext/string/inflections'
+require_relative 'core'
+
+module Ibrain
+  module Graphql
+    class TypeGeneratorBase < Rails::Generators::Base
+      include Core
+
+      argument :type_name,
+               type: :string,
+               banner: "TypeName",
+               desc: "Name of this object type (expressed as Ruby or GraphQL)"
+
+      # Take a type expression in any combination of GraphQL or Ruby styles
+      # and return it in a specified output style
+      # TODO: nullability / list with `mode: :graphql` doesn't work
+      # @param type_expresson [String]
+      # @param mode [Symbol]
+      # @param null [Boolean]
+      # @return [(String, Boolean)] The type expression, followed by `null:` value
+      def self.normalize_type_expression(type_expression, mode:, null: true)
+        if type_expression.start_with?("!")
+          normalize_type_expression(type_expression[1..-1], mode: mode, null: false)
+        elsif type_expression.end_with?("!")
+          normalize_type_expression(type_expression[0..-2], mode: mode, null: false)
+        elsif type_expression.start_with?("[") && type_expression.end_with?("]")
+          name, is_null = normalize_type_expression(type_expression[1..-2], mode: mode, null: null)
+          ["[#{name}]", is_null]
+        elsif type_expression.end_with?("Type")
+          normalize_type_expression(type_expression[0..-5], mode: mode, null: null)
+        elsif type_expression.start_with?("Types::")
+          normalize_type_expression(type_expression[7..-1], mode: mode, null: null)
+        elsif type_expression.start_with?("types.")
+          normalize_type_expression(type_expression[6..-1], mode: mode, null: null)
+        else
+          case mode
+          when :ruby
+            case type_expression
+            when "Int"
+              ["Integer", null]
+            when "Integer", "Float", "Boolean", "String", "ID"
+              [type_expression, null]
+            else
+              ["Types::#{type_expression.camelize}Type", null]
+            end
+          when :graphql
+            [type_expression.camelize, null]
+          else
+            raise "Unexpected normalize mode: #{mode}"
+          end
+        end
+      end
+
+      private
+
+      # @return [String] The user-provided type name, normalized to Ruby code
+      def type_ruby_name
+        @type_ruby_name ||= self.class.normalize_type_expression(type_name, mode: :ruby)[0]
+      end
+
+      # @return [String] The user-provided type name, as a GraphQL name
+      def type_graphql_name
+        @type_graphql_name ||= self.class.normalize_type_expression(type_name, mode: :graphql)[0]
+      end
+
+      # @return [String] The user-provided type name, as a file name (without extension)
+      def type_file_name
+        @type_file_name ||= "#{type_graphql_name}Type".underscore
+      end
+
+      # @return [Array<NormalizedField>] User-provided fields, in `(name, Ruby type name)` pairs
+      def normalized_fields
+        skip_fields = ["created_at:!Datetime", "updated_at:!Datetime"]
+
+        @normalized_fields ||= fields.reject { |f| skip_fields.include?(f) }.map { |f|
+          name, raw_type = f.split(":", 2)
+          type_expr, null = self.class.normalize_type_expression(raw_type, mode: :ruby)
+          NormalizedField.new(name, type_expr, null)
+        }
+      end
+
+      class NormalizedField
+        def initialize(name, type_expr, null)
+          @name = name
+          @type_expr = type_expr
+          @null = null
+        end
+
+        def to_ruby
+          "field :#{@name}, #{@type_expr}, null: #{@null}"
+        end
+      end
+    end
+  end
+end

data/lib/generators/ibrain/install/install_generator.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'ibrain/logger'
+
+module Ibrain
+  # @private
+  class InstallGenerator < Rails::Generators::Base
+    CORE_MOUNT_ROUTE = "mount Ibrain::Core::Engine"
+    source_root File.expand_path('templates', __dir__)
+
+    class_option :user_class, type: :string
+    class_option :with_authentication, type: :boolean, default: true
+    class_option :with_rubocop, type: :boolean, default: true
+    class_option :with_graphql, type: :boolean, default: false
+    class_option :with_annotation, type: :boolean, default: true
+    class_option :with_sendgrid, type: :boolean, default: false
+    class_option :enforce_available_locales, type: :boolean, default: nil
+    class_option :with_ridgepole, type: :boolean, default: true
+
+    def additional_tweaks
+      return unless File.exist? 'public/robots.txt'
+
+      append_file "public/robots.txt", <<-ROBOTS.strip_heredoc
+        User-agent: *
+        Disallow: /user
+        Disallow: /account
+        Disallow: /api
+        Disallow: /password
+      ROBOTS
+    end
+
+    def create_overrides_directory
+      empty_directory "app/overrides"
+    end
+
+    def configure_application
+      application <<-RUBY
+        # Load application's model / class decorators
+        initializer 'ibrain.decorators' do |app|
+          config.to_prepare do
+            Dir.glob(Rails.root.join('app/**/*_decorator*.rb')) do |path|
+              require_dependency(path)
+            end
+          end
+        end
+      RUBY
+
+      if !options[:enforce_available_locales].nil?
+        application <<-RUBY
+          I18n.enforce_available_locales = #{options[:enforce_available_locales]}
+        RUBY
+      end
+    end
+
+    def plugin_install_preparation
+      @plugins_to_be_installed = []
+      @plugin_generators_to_run = []
+    end
+
+    def install_auth_plugin
+      if options[:with_authentication] && (options[:auto_accept] || !no?("
+        Ibrain has a default authentication extension that uses Devise.
+        You can find more info at https://github.com/john-techfox/ibrain-auth.git.
+
+        Would you like to install it? (Y/n)"))
+
+        @plugins_to_be_installed << 'ibrain-auth' unless system('gem list | grep ibrain-auth')
+        @plugin_generators_to_run << 'ibrain:auth:install'
+      end
+    end
+
+    def run_bundle_install_if_needed_by_plugins
+      @plugins_to_be_installed.each do |plugin_name|
+        gem plugin_name
+      end
+
+      if options[:with_rubocop]
+        append_gem('rubocop', '1.23.0', 'development')
+        append_gem('rubocop-performance', '1.12.0', 'development')
+        append_gem('rubocop-rails', '2.12.4', 'development')
+      end
+
+      if options[:with_graphql]
+        append_gem('graphql', '1.12.6')
+        append_gem('graphql-batch', '0.4.3')
+        append_gem('graphql-guard', '2.0.0')
+        append_gem('graphql-rails-generators', '1.1.2', 'development')
+        append_gem('graphiql-rails', '1.8.0', 'development')
+      end
+
+      append_gem('annotate', '3.1.1', 'development') if options[:with_annotation]
+      append_gem('sendgrid-ruby', '6.6.0') if options[:with_sendgrid]
+
+      if options[:with_ridgepole]
+        append_gem('ridgepole', '1.0.0', 'development')
+      else
+        remove_gem('ridgepole')
+      end
+
+      bundle_cleanly{ run "bundle install" } if @plugins_to_be_installed.any?
+      run "spring stop" if defined?(Spring)
+
+      @plugin_generators_to_run.each do |plugin_generator_name|
+        generate plugin_generator_name.to_s
+      end
+    end
+
+    def install_routes
+      routes_file_path = File.join('config', 'routes.rb')
+      unless File.read(routes_file_path).include? CORE_MOUNT_ROUTE
+        insert_into_file routes_file_path, after: "Rails.application.routes.draw do\n" do
+          <<-RUBY
+            # This line mounts Ibrain's routes at the root of your application.
+            # This means, any requests to URLs such as /graphql, will go to Ibrain::GraphqlController,
+            # any requests to URLS such as /auth, will go to Ibrain::AuthController,
+            # If you would like to change where this engine is mounted, simply change the :at option to something different.
+            #
+            # We ask that you don't use the :as option here, as Ibrain relies on it being the default of "ibrain"
+            #{CORE_MOUNT_ROUTE}, at: '/'
+
+            # Please contact to Tai Nguyen Van <tainv@its-global.vn> if you have any question?
+          RUBY
+        end
+      end
+
+      unless options[:quiet]
+        Ibrain::Logger.info "*" * 50
+        Ibrain::Logger.info "We added the following line to your application's config/routes.rb file:"
+        Ibrain::Logger.info " "
+        Ibrain::Logger.info "    #{CORE_MOUNT_ROUTE}, at: '/'"
+      end
+    end
+
+    def add_files
+      template 'config/initializers/ibrain.rb.tt', 'config/initializers/ibrain.rb', { skip: true }
+      template 'config/initializers/cors.tt', 'config/initializers/cors.rb', { skip: true }
+      template 'config/puma.tt', 'config/puma.rb', { skip: true }
+      yml_template 'config/database.tt', 'config/database.yml', { skip: true }
+      template '.rubocop.yml.tt', '.rubocop.yml', { skip: true } if options[:with_rubocop]
+
+      if options[:with_graphql]
+        template 'graphql/app_schema.rb.tt', 'app/graphql/app_schema.rb', { skip: true }
+        template 'graphql/types/mutation_type.rb.tt', 'app/graphql/types/mutation_type.rb', { skip: true }
+        template 'graphql/types/query_type.rb.tt', 'app/graphql/types/query_type.rb', { skip: true }
+      end
+    end
+
+    def complete
+      unless options[:quiet]
+        Ibrain::Logger.info "*" * 50
+        Ibrain::Logger.info "Ibrain has been installed successfully. You're all ready to go!"
+        Ibrain::Logger.info " "
+        Ibrain::Logger.info "Enjoy!"
+      end
+    end
+
+    private
+
+    def bundle_cleanly(&block)
+      Bundler.respond_to?(:with_unbundled_env) ? Bundler.with_unbundled_env(&block) : Bundler.with_clean_env(&block)
+    end
+
+    def append_gem(name, version, group_name = nil)
+      shell_command = ["\ngem '#{name}', '~> #{version}'"]
+      shell_command.push("group: :#{group_name}") if group_name.present?
+      string_command = shell_command.join(', ')
+      gems = Gem.loaded_specs.values.map(&:full_name).join(' ')
+
+      system( `echo "#{string_command}" >> Gemfile` ) unless gems.include?("#{name}-")
+    end
+
+    def remove_gem(name)
+      gems = Gem.loaded_specs.values.map(&:full_name).join(' ')
+
+      system( "bundle remove #{name}" ) if gems.include?("#{name}-")
+    end
+
+    def yml_template(source, *args)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      destination = args.first || source.sub(/#{TEMPLATE_EXTNAME}$/o, "")
+      source = File.expand_path(find_in_source_paths(source.to_s))
+
+      create_file destination, nil, config do
+        File.read(source)
+      end
+    end
+  end
+end

data/lib/generators/ibrain/install/templates/config/database.tt

@@ -0,0 +1,23 @@
+default: &default
+  adapter: <%= ENV.fetch("DATABASE_ADAPTER") { 'postgresql' } %>
+  encoding: utf8mb4
+  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+  host: <%= ENV.fetch('DATABASE_HOSTNAME') { 'localhost' }%>
+  username: <%= ENV.fetch('DATABASE_USERNAME') { 'ibrain' }%>
+  password: <%= ENV.fetch('DATABASE_PASSWORD') { 'ibrain-password' }%>
+
+development:
+  <<: *default
+  database: <%= ENV.fetch('DATABASE_NAME') { 'ibrain_development' }%>
+
+staging:
+  <<: *default
+  database: <%= ENV.fetch('DATABASE_NAME') { 'ibrain_staging' }%>
+
+test:
+  <<: *default
+  database: <%= ENV.fetch('DATABASE_NAME') { 'ibrain_test' }%>
+
+production:
+  <<: *default
+  database: <%= ENV.fetch('DATABASE_NAME') { 'ibrain_production' }%>

data/lib/generators/ibrain/install/templates/config/initializers/cors.tt

@@ -0,0 +1,25 @@
+# Be sure to restart your server when you modify this file.
+
+# Avoid CORS issues when API is called from the frontend app.
+# Handle Cross-Origin Resource Sharing (CORS) in order to accept cross-origin AJAX requests.
+
+# Read more: https://github.com/cyu/rack-cors
+
+Rails.application.config.middleware.insert_before 0, Rack::Cors do
+  allow do
+    origins '*'
+
+    resource '*',
+      headers: :any,
+      methods: [:get, :post, :put, :patch, :delete, :options, :head],
+      expose: %w[
+        X-Requested-With
+        Content-Type
+        Authorization
+        Accept
+        Accept-Encoding
+        Access-Control-Allow-Credentials
+      ],
+      credentials: true
+  end
+end

data/lib/generators/ibrain/install/templates/config/initializers/ibrain.rb.tt

@@ -0,0 +1,55 @@
+# Ibrain version defaults for preferences that are not overridden
+Ibrain.load_defaults '<%= Ibrain.ibrain_version %>'
+
+Ibrain.config do |config|
+  # Core:
+  # from address for emails
+  config.mails_from = "info@example.com"
+
+  # Uncomment to stop tracking inventory levels in the application
+  # config.track_inventory_levels = false
+
+  # When set, data caches are only invalidated when they fall below or rise
+  # above the inventory_cache_threshold that is set. Default is to invalidate cache on
+  # any inventory changes.
+  # config.inventory_cache_threshold = 3
+
+  # Defaults
+  # Permission Sets:
+
+  # Uncomment and customize the following line to add custom permission sets
+  # to a custom users role:
+  # config.roles.assign_permissions :role_name, ['Ibrain::PermissionSets::CustomPermissionSet']
+
+  # @!attribute [rw] guest_token_cookie_options
+  # @return [Hash] Add additional guest_token cookie options here (ie. domain or path)
+  # config.guest_token_cookie_options = {}
+
+  # @!attribute [rw] generate_api_key_for_all_roles
+  # @return [Boolean] Allow generating api key automatically for user
+  # at role_user creation for all roles. (default: +false+)
+  # config.generate_api_key_for_all_roles = false
+
+  # Graphql Policy Object
+  # config.graphql_policy = 'Ibrain::Policies::GraphqlPolicy'
+
+  # Api version for route config
+  # config.api_version = 'v1'
+
+  # Graphql Schema name
+  # config.graphql_schema = 'Ibrain::BaseSchema'
+
+  # Graphql Encryptor key
+  # config.ibrain_encryptor_key = Rails.application.secrets.secret_key_base.byteslice(0..31)
+end
+
+<% if defined?(Ibrain::Api::Engine) -%>
+  Ibrain::Api::Config.configure do |config|
+    # Localization
+    config.locale = 'en'
+
+    config.requires_authentication = true
+  end
+<% end -%>
+
+Ibrain.user_class = <%= (options[:user_class].blank? ? "Ibrain::LegacyUser" : options[:user_class]).inspect %>