ibrain-core 0.1.0

data/app/graphql/ibrain/types/base_object.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Types
+    class BaseObject < GraphQL::Schema::Object
+      implements GraphQL::Relay::Node.interface
+
+      edge_type_class(Ibrain::Types::BaseEdge)
+      connection_type_class(Ibrain::Types::BaseConnection)
+
+      field_class ::Ibrain::Types::BaseField
+    end
+  end
+end

data/app/graphql/ibrain/types/base_query_type.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Types
+    class BaseQueryType < Types::BaseObject
+      # Add `node(id: ID!) and `nodes(ids: [ID!]!)`
+      include GraphQL::Types::Relay::HasNodeField
+      include GraphQL::Types::Relay::HasNodesField
+
+      # Add root-level fields here.
+      # They will be entry points for queries on your schema.
+    end
+  end
+end

data/app/graphql/ibrain/types/base_scalar.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Types
+    class BaseScalar < GraphQL::Schema::Scalar
+    end
+  end
+end

data/app/graphql/ibrain/types/base_union.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Types
+    class BaseUnion < GraphQL::Schema::Union
+      edge_type_class(Ibrain::Types::BaseEdge)
+      connection_type_class(Ibrain::Types::BaseConnection)
+    end
+  end
+end

data/app/graphql/ibrain/types/filter_type.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Types
+    class FilterType < GraphQL::Schema::Scalar
+    end
+  end
+end

data/app/graphql/ibrain/types/node_type.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Types
+    module NodeType
+      include Ibrain::Types::BaseInterface
+      # Add the `id` field
+      include GraphQL::Types::Relay::NodeBehaviors
+    end
+  end
+end

data/app/graphql/ibrain/util/field_combiner.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Util
+    class FieldCombiner
+      def self.combine(query_types)
+        Array(query_types).inject({}) do |acc, query_type|
+          acc.merge!(query_type.fields)
+        end
+      end
+    end
+  end
+end

data/app/graphql/ibrain/util/query_combiner.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Util
+    class QueryCombiner
+      def self.combine(query_types)
+        Array(query_types).inject({}) do |acc, query_type|
+          acc.merge!(query_type.fields)
+        end
+      end
+    end
+  end
+end

data/app/graphql/mutations/insert_user.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Mutations
+    class InsertUser < Ibrain::Mutations::BaseMutation
+      # TODO: define return fields
+      # field :post, Types::PostType, null: false
+
+      # TODO: define arguments
+      # argument :name, String, required: true
+
+      # TODO: define resolve method
+      # def resolve(name:)
+      #   { post: ... }
+      # end
+    end
+  end
+end

data/app/models/ibrain/ability.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Implementation class for Cancan gem.  Instead of overriding this class, consider adding new permissions
+# using the special +register_ability+ method which allows extensions to add their own abilities.
+#
+# See http://github.com/ryanb/cancan for more details on cancan.
+require 'cancan'
+module Ibrain
+  class Ability
+    include CanCan::Ability
+
+    class_attribute :abilities
+    self.abilities = Set.new
+
+    attr_reader :user
+
+    # Allows us to go beyond the standard cancan initialize method which makes it difficult for engines to
+    # modify the default +Ability+ of an application.  The +ability+ argument must be a class that includes
+    # the +CanCan::Ability+ module.  The registered ability should behave properly as a stand-alone class
+    # and therefore should be easy to test in isolation.
+    def self.register_ability(ability)
+      abilities.add(ability)
+    end
+
+    def self.remove_ability(ability)
+      abilities.delete(ability)
+    end
+
+    def initialize(current_user)
+      @user = current_user || Ibrain.user_class.new
+
+      activate_permission_sets
+      register_extension_abilities
+    end
+
+    private
+
+    # Before, this was the only way to extend this ability. Permission sets have been added since.
+    # It is recommended to use them instead for extension purposes if possible.
+    def register_extension_abilities
+      Ability.abilities.each do |clazz|
+        ability = clazz.send(:new, user)
+        merge(ability)
+      end
+    end
+
+    def activate_permission_sets
+      Ibrain::Config.roles.activate_permissions! self, user
+    end
+  end
+end

data/app/models/ibrain/application_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Ibrain
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/ibrain/base.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class Ibrain::Base < Ibrain::ApplicationRecord
+  include ActionView::Helpers::DateHelper
+
+  self.abstract_class = true
+
+  def self.adjust_date_for_cdt(datetime)
+    datetime.in_time_zone('UTC')
+  end
+
+  def string_id
+    try(:id).try(:to_s)
+  end
+
+  scope :graphql_ransack, lambda { |params|
+    ransack(params).result(distinct: true)
+  }
+
+  scope :reverse_scope, lambda {
+    order(created_at: :desc)
+  }
+
+  scope :ransack_query, lambda { |params, page, per_page = 10|
+    ransack(params).
+      result.
+      page(page).
+      per(per_page)
+  }
+
+  def cryptor
+    ::Ibrain::Encryptor.new
+  end
+
+  def created_in_word
+    time_ago_in_words(created_at)
+  end
+
+  # Provides a scope that should be included any time data
+  # are fetched with the intention of displaying to the user.
+  #
+  # Allows individual stores to include any active record scopes or joins
+  # when data are displayed.
+  def self.display_includes
+    where(nil)
+  end
+end

data/app/models/ibrain/concerns/ransackable_attributes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Ibrain::RansackableAttributes
+  extend ActiveSupport::Concern
+  included do
+    class_attribute :whitelisted_ransackable_associations
+    class_attribute :whitelisted_ransackable_attributes
+
+    class_attribute :default_ransackable_attributes
+    self.default_ransackable_attributes = %w[id]
+  end
+
+  class_methods do
+    def ransackable_associations(*_args)
+      whitelisted_ransackable_associations || []
+    end
+
+    def ransackable_attributes(*_args)
+      default_ransackable_attributes | (whitelisted_ransackable_attributes || [])
+    end
+  end
+end

data/app/models/ibrain/concerns/soft_deletable.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'discard'
+
+module Ibrain
+  module SoftDeletable
+    extend ActiveSupport::Concern
+
+    included do
+      include Discard::Model
+      self.discard_column = :deleted_at
+
+      default_scope { kept }
+    end
+  end
+end

data/app/models/ibrain/concerns/user_api_authentication.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module UserApiAuthentication
+    def generate_ibrain_api_key!
+      generate_ibrain_api_key
+      save!
+    end
+
+    def generate_ibrain_api_key
+      self.ibrain_api_key = SecureRandom.hex(24)
+    end
+
+    def clear_ibrain_api_key!
+      clear_ibrain_api_key
+      save!
+    end
+
+    def clear_ibrain_api_key
+      self.ibrain_api_key = nil
+    end
+  end
+end

data/app/models/ibrain/concerns/user_methods.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module UserMethods
+    extend ActiveSupport::Concern
+
+    include Ibrain::UserApiAuthentication
+    include Ibrain::UserReporting
+
+    included do
+      extend Ibrain::DisplayMoney
+      after_create :auto_generate_ibrain_api_key
+
+      include Ibrain::RansackableAttributes unless included_modules.include?(Ibrain::RansackableAttributes)
+    end
+
+    def auto_generate_ibrain_api_key
+      return if !respond_to?(:ibrain_api_key) || ibrain_api_key.present?
+
+      if Ibrain::Config.generate_api_key_for_all_roles || (ibrain_roles.map(&:name) & Ibrain::Config.roles_for_auto_api_key).any?
+        generate_ibrain_api_key!
+      end
+    end
+  end
+end

data/app/models/ibrain/legacy_user.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Ibrain
+  # Default implementation of User.
+  #
+  # @note This class is intended to be modified by extensions (ex.
+  #   ibrain-auth)
+  class LegacyUser < Ibrain::Base
+    include UserMethods
+
+    self.table_name = 'ibrain_users'
+
+    def self.model_name
+      ActiveModel::Name.new Ibrain::LegacyUser, Ibrain, 'user'
+    end
+
+    attr_accessor :password, :password_confirmation
+  end
+end

data/app/models/ibrain/role.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Ibrain
+  class Role < Ibrain::Base
+    has_many :role_users, class_name: "Ibrain::RoleUser", dependent: :destroy
+    has_many :users, through: :role_users
+
+    validates :name, uniqueness: { case_sensitive: true }
+
+    def admin?
+      name == "admin"
+    end
+  end
+end

data/app/models/ibrain/role_user.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Ibrain
+  class RoleUser < Ibrain::Base
+    belongs_to :role, class_name: "Ibrain::Role", optional: true
+    belongs_to :user, class_name: Ibrain::UserClassHandle.new, optional: true
+
+    after_create :auto_generate_ibrain_api_key
+
+    validates :role_id, uniqueness: { scope: :user_id }
+
+    private
+
+    def auto_generate_ibrain_api_key
+      user.try(:auto_generate_ibrain_api_key)
+    end
+  end
+end

data/config/initializers/friendly_id.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+# FriendlyId Global Configuration
+#
+# Use this to set up shared configuration options for your entire application.
+# Any of the configuration options shown here can also be applied to single
+# models by passing arguments to the `friendly_id` class method or defining
+# methods in your model.
+#
+# To learn more, check out the guide:
+#
+# http://norman.github.io/friendly_id/file.Guide.html
+
+FriendlyId.defaults do |config|
+  # ## Reserved Words
+  #
+  # Some words could conflict with Rails's routes when used as slugs, or are
+  # undesirable to allow as slugs. Edit this list as needed for your app.
+  config.use :reserved
+
+  #  ## Friendly Finders
+  #
+  # Uncomment this to use friendly finders in all models. By default, if
+  # you wish to find a record by its friendly id, you must do:
+  #
+  #    MyModel.friendly.find('foo')
+  #
+  # If you uncomment this, you can do:
+  #
+  #    MyModel.find('foo')
+  #
+  # This is significantly more convenient but may not be appropriate for
+  # all applications, so you must explicity opt-in to this behavior. You can
+  # always also configure it on a per-model basis if you prefer.
+  #
+  # Something else to consider is that using the :finders addon boosts
+  # performance because it will avoid Rails-internal code that makes runtime
+  # calls to `Module.extend`.
+  #
+  # config.use :finders
+  #
+  # ## Slugs
+  #
+  # Most applications will use the :slugged module everywhere. If you wish
+  # to do so, uncomment the following line.
+  #
+  # config.use :slugged
+  #
+  # By default, FriendlyId's :slugged addon expects the slug column to be named
+  # 'slug', but you can change it if you wish.
+  #
+  # config.slug_column = 'slug'
+  #
+  # When FriendlyId can not generate a unique ID from your base method, it appends
+  # a UUID, separated by a single dash. You can configure the character used as the
+  # separator. If you're upgrading from FriendlyId 4, you may wish to replace this
+  # with two dashes.
+  #
+  # config.sequence_separator = '-'
+  #
+  #  ## Tips and Tricks
+  #
+  #  ### Controlling when slugs are generated
+  #
+  # As of FriendlyId 5.0, new slugs are generated only when the slug field is
+  # nil, but if you're using a column as your base method can change this
+  # behavior by overriding the `should_generate_new_friendly_id` method that
+  # FriendlyId adds to your model. The change below makes FriendlyId 5.0 behave
+  # more like 4.0.
+  #
+  # config.use Module.new {
+  #   def should_generate_new_friendly_id?
+  #     slug.blank? || <your_column_name_here>_changed?
+  #   end
+  # }
+  #
+  # FriendlyId uses Rails's `parameterize` method to generate slugs, but for
+  # languages that don't use the Roman alphabet, that's not usually suffient. Here
+  # we use the Babosa library to transliterate Russian Cyrillic slugs to ASCII. If
+  # you use this, don't forget to add "babosa" to your Gemfile.
+  #
+  # config.use Module.new {
+  #   def normalize_friendly_id(text)
+  #     text.to_slug.normalize! transliterations: [:russian, :latin]
+  #   end
+  # }
+end

data/config/locales/en.yml

@@ -0,0 +1,10 @@
+en:
+  ibrain:
+    system:
+      message:
+        success: Fetch data successful
+        ok: Fetch data successful
+    errors:
+      session:
+        invalid_session: Login session is invalid. Please try again!
+        expired_session: Login session is expired.

data/config/locales/jp.yml

@@ -0,0 +1,10 @@
+jp:
+  ibrain:
+    system:
+      message:
+        success: Fetch data successful
+        ok: Fetch data successful
+    errors:
+      session:
+        invalid_session: Login session is invalid. Please try again!
+        expired_session: Login session is expired.

data/config/locales/vi.yml

@@ -0,0 +1,10 @@
+vi:
+  ibrain:
+    system:
+      message:
+        success: Lấy dữ liệu thành công
+        ok: Lấy dữ liệu thành công
+    errors:
+      session:
+        invalid_session: Phiên đăng nhập không hợp lệ. Vui lòng thử lại!
+        expired_session: Phiên đăng nhập đã hết hạn.

data/config/routes.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+Ibrain::Core::Engine.routes.draw do
+  if ::Ibrain::Config.api_version.blank?
+    post '/api/graphql', to: 'graphql#execute'
+  else
+    post "/api/#{::Ibrain::Config.api_version.downcase}/graphql", controller: 'graphql', action: 'execute'
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'rails/generators/base'
+
+module Ibrain
+  module Graphql
+    module Core
+      def self.included(base)
+        base.send(
+          :class_option,
+          :directory,
+          type: :string,
+          default: "app/graphql",
+          desc: "Directory where generated files should be saved"
+        )
+      end
+
+      def insert_root_type(type, name)
+        log :add_root_type, type
+        sentinel = /< GraphQL::Schema\s*\n/m
+
+        in_root do
+          if File.exist?(schema_file_path)
+            inject_into_file schema_file_path, "  #{type}(Types::#{name})\n", after: sentinel, verbose: false, force: false
+          end
+        end
+      end
+
+      def create_mutation_root_type
+        create_dir("#{options[:directory]}/mutations")
+        insert_root_type('mutation', 'MutationType')
+      end
+
+      def create_resolver_root_type
+        create_dir("#{options[:directory]}/resolvers")
+        insert_root_type('query', 'QueryType')
+      end
+
+      def schema_file_path
+        "#{options[:directory]}/#{schema_name.underscore}.rb"
+      end
+
+      def create_dir(dir)
+        empty_directory(dir)
+        if !options[:skip_keeps]
+          create_file("#{dir}/.keep")
+        end
+      end
+
+      def module_namespacing_when_supported(&block)
+        if defined?(module_namespacing)
+          module_namespacing(&block)
+        else
+          yield
+        end
+      end
+
+      private
+
+      def schema_name
+        @schema_name ||= options[:schema] || "#{parent_name}Schema"
+      end
+
+      def parent_name
+        require File.expand_path("config/application", destination_root)
+
+        if Rails.application.class.respond_to?(:module_parent_name)
+          Rails.application.class.module_parent_name
+        else
+          Rails.application.class.parent_name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# 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::RelayClassicMutation` by name
+    #     rails g graphql:mutation CreatePostMutation
+    class MutationGenerator < Rails::Generators::Base
+      include Core
+
+      desc "Create a Relay Classic mutation 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, :mutation_name, :field_name, :model_name
+
+      def create_mutation_file
+        if @behavior == :revoke
+          log :gsub, "#{options[:directory]}/types/mutation_type.rb"
+        else
+          create_mutation_root_type
+        end
+
+        template "mutation.erb", "#{options[:directory]}/mutations/#{file_name}.rb"
+
+        sentinel = /class .*MutationType\s*<\s*[^\s]+?\n/m
+        in_root do
+          gsub_file "#{options[:directory]}/types/mutation_type.rb", /  \# TODO: Add Mutations as fields\s*\n/m, ""
+          inject_into_file "#{options[:directory]}/types/mutation_type.rb", "    field :#{field_name}, mutation: Mutations::#{mutation_name}\n", after: sentinel, verbose: false, force: false
+        end
+      end
+
+      private
+
+      def assign_names!(name)
+        @field_name = name.camelize.underscore
+        @mutation_name = name.camelize(:upper)
+        @file_name = name.camelize.underscore
+        @model_name = options[:model].blank? ? 'Post' : options[:model].capitalize
+      end
+    end
+  end
+end