ibrain-core 0.1.0

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

@@ -0,0 +1,43 @@
+# Puma can serve each request in a thread from an internal thread pool.
+# The `threads` method setting takes two numbers: a minimum and maximum.
+# Any libraries that use thread pools should be configured to match
+# the maximum value specified for Puma. Default is set to 5 threads for minimum
+# and maximum; this matches the default thread size of Active Record.
+#
+max_threads_count = ENV.fetch("RAILS_MAX_THREADS") { 5 }
+min_threads_count = ENV.fetch("RAILS_MIN_THREADS") { max_threads_count }
+threads min_threads_count, max_threads_count
+
+# Specifies the `worker_timeout` threshold that Puma will use to wait before
+# terminating a worker in development environments.
+#
+worker_timeout 3600 if ENV.fetch("RAILS_ENV", "development") == "development"
+
+# Specifies the `port` that Puma will listen on to receive requests; default is 3000.
+#
+port ENV.fetch("PORT") { 3000 }
+
+# Specifies the `environment` that Puma will run in.
+#
+environment ENV.fetch("RAILS_ENV") { "development" }
+
+# Specifies the `pidfile` that Puma will use.
+pidfile ENV.fetch("PIDFILE") { "tmp/pids/server.pid" }
+
+# Specifies the number of `workers` to boot in clustered mode.
+# Workers are forked web server processes. If using threads and workers together
+# the concurrency of the application would be max `threads` * `workers`.
+# Workers do not work on JRuby or Windows (both of which do not support
+# processes).
+#
+# workers ENV.fetch("WEB_CONCURRENCY") { 2 }
+
+# Use the `preload_app!` method when specifying a `workers` number.
+# This directive tells Puma to first boot the application and load code
+# before forking the application. This takes advantage of Copy On Write
+# process behavior so workers use less memory.
+#
+# preload_app!
+
+# Allow puma to be restarted by `rails restart` command.
+plugin :tmp_restart

data/lib/generators/ibrain/install/templates/graphql/app_schema.rb.tt

@@ -0,0 +1,4 @@
+class AppSchema < Ibrain::BaseSchema
+  mutation(Types::MutationType)
+  query(Types::QueryType)
+end

data/lib/generators/ibrain/install/templates/graphql/types/mutation_type.rb.tt

@@ -0,0 +1,10 @@
+module Types
+  class MutationType < Ibrain::Types::BaseObject
+    # TODO: remove me
+    field :test_field, String, null: false,
+                               description: 'An example field added by the generator'
+    def test_field
+      'Hello World'
+    end
+  end
+end

data/lib/generators/ibrain/install/templates/graphql/types/query_type.rb.tt

@@ -0,0 +1,13 @@
+module Types
+  class QueryType < Ibrain::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.
+
+    # Example with user resolvers
+    # field :users, resolver: Resolvers::UsersResolver
+  end
+end

data/lib/ibrain/app_configuration.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# This is the primary location for defining ibrain preferences
+#
+# The expectation is that this is created once and stored in
+# the ibrain environment
+#
+# setters:
+# a.color = :blue
+# a[:color] = :blue
+# a.set :color = :blue
+# a.preferred_color = :blue
+#
+# getters:
+# a.color
+# a[:color]
+# a.get :color
+# a.preferred_color
+#
+require 'ibrain/preferences/configuration'
+require 'ibrain/core/environment'
+
+module Ibrain
+  class AppConfiguration < Preferences::Configuration
+    # Preferences (alphabetized to more easily lookup particular preferences)
+
+    # @!attribute [rw] guest_token_cookie_options
+    #   @return [Hash] Add additional guest_token cookie options here (ie. domain or path)
+    preference :guest_token_cookie_options, :hash, default: {}
+
+    # @!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+)
+    preference :generate_api_key_for_all_roles, :boolean, default: false
+
+    # @!attribute [rw] mails_from
+    #   @return [String] Email address used as +From:+ field in transactional emails.
+    preference :mails_from, :string, default: 'ibrain@example.com'
+
+    preference :graphql_policy, :string, default: 'Ibrain::Policies::GraphqlPolicy'
+
+    # Api version for route config
+    preference :api_version, :string, default: 'v1'
+
+    # Graphql Schema name
+    preference :graphql_schema, :string, default: 'Ibrain::BaseSchema'
+
+    # Graphql Encryptor key
+    preference :ibrain_encryptor_key, :string, default: nil
+
+    def static_model_preferences
+      @static_model_preferences ||= Ibrain::Preferences::StaticModelPreferences.new
+    end
+
+    def roles
+      @roles ||= Ibrain::RoleConfiguration.new.tap do |roles|
+        roles.assign_permissions :default, ['Ibrain::PermissionSets::DefaultCustomer']
+        roles.assign_permissions :admin, ['Ibrain::PermissionSets::SuperUser']
+      end
+    end
+
+    def environment
+      @environment ||= Ibrain::Core::Environment.new(self)
+    end
+  end
+end

data/lib/ibrain/config.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'ibrain/app_configuration'
+
+Ibrain::Config = Ibrain::AppConfiguration.new

data/lib/ibrain/core/class_constantizer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module'
+
+module Ibrain
+  module Core
+    module ClassConstantizer
+      class Set
+        include Enumerable
+
+        def initialize
+          @collection = ::Set.new
+        end
+
+        def <<(klass)
+          @collection << klass.to_s
+        end
+
+        def concat(klasses)
+          klasses.each do |klass|
+            self << klass
+          end
+
+          self
+        end
+
+        delegate :clear, :empty?, to: :@collection
+
+        def delete(object)
+          @collection.delete(object.to_s)
+        end
+
+        def each
+          @collection.each do |klass|
+            yield klass.constantize
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ibrain/core/controller_helpers/auth.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Core
+    module ControllerHelpers
+      module Auth
+        extend ActiveSupport::Concern
+        include Response
+
+        # @!attribute [rw] fallback_on_unauthorized
+        #   @!scope class
+        #   Extension point for overriding behaviour of access denied errors.
+        #   Default behaviour is to redirect back or to "/unauthorized" with a flash
+        #   message.
+        #   @return [Proc] action to take when access denied error is raised.
+
+        included do
+          before_action :set_guest_token
+          helper_method :try_ibrain_current_user
+
+          class_attribute :fallback_on_unauthorized
+          self.fallback_on_unauthorized = -> do
+            error = ::Struct.new(
+              message: I18n.t('ibrain.authorization_failure')
+                                     )
+
+            render_json_error(error, :unauthorized)
+          end
+
+          rescue_from CanCan::AccessDenied do
+            instance_exec(&fallback_on_unauthorized)
+          end
+        end
+
+        # Needs to be overriden so that we use Brain's Ability rather than anyone else's.
+        def current_ability
+          @current_ability ||= Ibrain::Ability.new(try_ibrain_current_user)
+        end
+
+        def set_guest_token
+          # if cookies.signed[:guest_token].blank?
+          #   cookies.permanent.signed[:guest_token] = Ibrain::Config[:guest_token_cookie_options].merge(
+          #     value: SecureRandom.urlsafe_base64(nil, false),
+          #     httponly: true
+          #   )
+          # end
+        end
+
+        # proxy method to *possible* ibrain_current_user method
+        # Authentication extensions (such as ibrain-auth) are meant to provide ibrain_current_user
+        def try_ibrain_current_user
+          # This one will be defined by apps looking to hook into Ibrain
+          # As per authentication_helpers.rb
+          if respond_to?(:ibrain_current_user, true)
+            ibrain_current_user
+          # This one will be defined by Devise
+          elsif respond_to?(:current_ibrain_user, true)
+            current_ibrain_user
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ibrain/core/controller_helpers/current_host.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Core
+    module ControllerHelpers
+      module CurrentHost
+        extend ActiveSupport::Concern
+
+        included do
+          before_action do
+            ActiveStorage::Current.host = request.base_url
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ibrain/core/controller_helpers/response.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Core
+    module ControllerHelpers
+      module Response
+        extend ActiveSupport::Concern
+
+        included do
+          helper_method :render_json_error
+          helper_method :render_json_ok
+        end
+
+        protected
+
+        def render_json_error(error, status)
+          e_message = error.try(:record).try(:errors).try(:full_messages).try(:first)
+          e_message = error.try(:message) if e_message.blank?
+
+          backtrace = error.try(:backtrace).try(:join, "\n")
+
+          Ibrain::Logger.error e_message
+          Ibrain::Logger.error backtrace
+
+          render json: {
+            errors: [{
+              message: e_message,
+              extensions: {
+                code: status,
+                exception: {
+                  stacktrace: [
+                    backtrace
+                  ]
+                }
+              }
+            }],
+            message: e_message,
+            data: nil
+          }, status: status
+        end
+
+        def render_json_ok(data, message, errors = [])
+          render json: {
+            errors: errors,
+            message: message || I18n.t('ibrain.system.message.ok'),
+            data: data.as_json
+          }, status: :ok
+        end
+      end
+    end
+  end
+end

data/lib/ibrain/core/controller_helpers/strong_parameters.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Core
+    module ControllerHelpers
+      module StrongParameters
+        def permitted_attributes
+          Ibrain::PermittedAttributes
+        end
+
+        delegate(*Ibrain::PermittedAttributes::ATTRIBUTES,
+                 to: :permitted_attributes,
+                 prefix: :permitted)
+
+        def permitted_user_attributes
+          permitted_attributes.user_attributes
+        end
+      end
+    end
+  end
+end

data/lib/ibrain/core/engine.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'ibrain/config'
+
+module Ibrain
+  module Core
+    class Engine < ::Rails::Engine
+      isolate_namespace Ibrain
+      config.generators.api_only = true
+
+      initializer "ibrain.environment", before: :load_config_initializers do |app|
+        app.config.ibrain = Ibrain::Config.environment
+      end
+    end
+  end
+end

data/lib/ibrain/core/environment.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'ibrain/core/environment_extension'
+
+module Ibrain
+  module Core
+    class Environment
+      include EnvironmentExtension
+
+      attr_accessor :preferences
+
+      def initialize(ibrain_config)
+        @preferences = ibrain_config
+      end
+    end
+  end
+end

data/lib/ibrain/core/environment_extension.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'ibrain/core/class_constantizer'
+
+module Ibrain
+  module Core
+    module EnvironmentExtension
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def add_class_set(name)
+          define_method(name) do
+            set = instance_variable_get("@#{name}")
+            set ||= send("#{name}=", [])
+            set
+          end
+
+          define_method("#{name}=") do |klasses|
+            set = ClassConstantizer::Set.new
+            set.concat(klasses)
+            instance_variable_set("@#{name}", set)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ibrain/core/role_configuration.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'ibrain/core/class_constantizer'
+
+module Ibrain
+  # A class responsible for associating {Ibrain::Role} with a list of permission sets.
+  #
+  # @see Ibrain::PermissionSets
+  #
+  # @example Adding order, data, and user display to customer service users.
+  #   Ibrain::RoleConfiguration.configure do |config|
+  #     config.assign_permissions :customer_service, [
+  #       Ibrain::PermissionSets::UserDisplay,
+  #     ]
+  #   end
+  class RoleConfiguration
+    # An internal structure for the association between a role and a
+    # set of permissions.
+    class Role
+      attr_reader :name, :permission_sets
+
+      def initialize(name, permission_sets)
+        @name = name
+        @permission_sets = Ibrain::Core::ClassConstantizer::Set.new
+        @permission_sets.concat permission_sets
+      end
+    end
+
+    attr_accessor :roles
+
+    # Given a CanCan::Ability, and a user, determine what permissions sets can
+    # be activated on the ability, then activate them.
+    #
+    # This performs can/cannot declarations on the ability, and can modify its
+    # internal permissions.
+    #
+    # @param ability [CanCan::Ability] the ability to invoke declarations on
+    # @param user [#roles] the user that holds the roles association.
+    def activate_permissions!(ability, user)
+      ibrain_roles = ['default'] | user.roles.map(&:name)
+      applicable_permissions = Set.new
+
+      ibrain_roles.each do |role_name|
+        applicable_permissions |= roles[role_name].permission_sets
+      end
+
+      applicable_permissions.each do |permission_set|
+        permission_set.new(ability).activate!
+      end
+    end
+
+    # Not public due to the fact this class is a Singleton
+    # @!visibility private
+    def initialize
+      @roles = Hash.new do |hash, name|
+        hash[name] = Role.new(name, Set.new)
+      end
+    end
+
+    # Assign permission sets for a {Ibrain::Role} that has the name of role_name
+    # @param role_name [Symbol, String] The name of the role to associate permissions with
+    # @param permission_sets [Array<Ibrain::PermissionSets::Base>, Set<Ibrain::PermissionSets::Base>]
+    #   A list of permission sets to activate if the user has the role indicated by role_name
+    def assign_permissions(role_name, permission_sets)
+      name = role_name.to_s
+
+      roles[name].permission_sets.concat permission_sets
+      roles[name]
+    end
+  end
+end

data/lib/ibrain/core/validators/email.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Ibrain
+  # == An ActiveModel Email Validator
+  #
+  # === Usage
+  #
+  #     require 'ibrain/core/validators/email'
+  #
+  #     class Person < ApplicationRecord
+  #       validates :email_address, 'ibrain/email' => true
+  #     end
+  #
+  class EmailValidator < ActiveModel::EachValidator
+    EMAIL_REGEXP = URI::MailTo::EMAIL_REGEXP
+
+    def validate_each(record, attribute, value)
+      unless EMAIL_REGEXP.match? value
+        record.errors.add(attribute, :invalid, **{ value: value }.merge!(options))
+      end
+    end
+  end
+end

data/lib/ibrain/core/version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ibrain
+  VERSION = "0.1.0"
+
+  def self.ibrain_version
+    VERSION
+  end
+
+  def self.previous_ibrain_minor_version
+    '0.1.0'
+  end
+
+  def self.ibrain_gem_version
+    Gem::Version.new(ibrain_version)
+  end
+end

data/lib/ibrain/core/versioned_value.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Core
+    # Wrapper for a value that can be different depending on the Ibrain version
+    #
+    # Some configuration defaults can be added or changed when a new Ibrain
+    # version is released. This class encapsulates getting the correct value for a
+    # given Ibrain version.
+    #
+    # The way it works is you provide an initial value in time, plus the version
+    # boundary where it got changed. Then you can fetch the value providing the
+    # desired Ibrain version:
+    #
+    # @example
+    #   value = VersionedValue.new(true, "3.0.0" => false)
+    #   value.call("2.7.0") # => true
+    #   value.call("3.0.0") # => false
+    #   value.call("3.1.0") # => false
+    #
+    # Remember that you must provide the exact boundary when a value got changed,
+    # which could easily be during a pre-release:
+    #
+    # @example
+    #   value = VersionedValue.new(true, "3.0.0" => false)
+    #   value.call("3.0.0.alpha") # => true
+    #
+    #   value = VersionedValue.new(true, "3.0.0.alpha" => false)
+    #   value.call("3.0.0.alpha") # => false
+    #
+    # Multiple boundaries can also be provided:
+    #
+    # @example
+    #   value = VersionedValue.new(0, "2.0.0" => 1, "3.0.0" => 2)
+    #   value.call("1.0.0") # => 0
+    #   value.call("2.1.0") # => 1
+    #   value.call("3.0.0") # => 2
+    class VersionedValue
+      attr_reader :boundaries
+
+      # @param initial_value [Any]
+      # @param boundary [Hash<String, Any>] Map from version number to new value
+      def initialize(initial_value, boundaries = {})
+        @boundaries = { '0' => initial_value }
+                        .merge(boundaries)
+                        .transform_keys { |version| to_gem_version(version) }
+                        .sort.to_h
+      end
+
+      # @param ibrain_version [String]
+      def call(ibrain_version = Ibrain.ibrain_version)
+        ibrain_version = to_gem_version(ibrain_version)
+        boundaries.fetch(
+          boundaries
+            .keys
+            .reduce do |target, following|
+              if target <= ibrain_version && ibrain_version < following
+                target
+              else
+                following
+              end
+            end
+        )
+      end
+
+      private
+
+      def to_gem_version(string)
+        Gem::Version.new(string)
+      end
+    end
+  end
+end

data/lib/ibrain/core.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "action_controller/railtie"
+require "action_mailer/railtie"
+require "active_job/railtie"
+require "active_model/railtie"
+require "active_record/railtie"
+require "active_storage/engine"
+require 'activerecord/session_store'
+
+require 'awesome_nested_set'
+require 'cancan'
+require 'friendly_id'
+require 'kaminari/activerecord'
+require 'rack/cors'
+require 'ransack'
+
+module Ibrain
+  mattr_accessor :user_class
+
+  def self.user_class
+    case @@user_class
+    when Class
+      raise "Ibrain.user_class MUST be a String or Symbol object, not a Class object."
+    when String, Symbol
+      @@user_class.to_s.constantize
+    end
+  end
+
+  # Load the same version defaults for all available Ibrain components
+  #
+  # @see Ibrain::Preferences::Configuration#load_defaults
+  def self.load_defaults(version)
+    Ibrain::Config.load_defaults(version)
+    Ibrain::Api::Config.load_defaults(version) if defined?(Ibrain::Api::Config)
+  end
+
+  # Used to configure Ibrain.
+  #
+  # Example:
+  #
+  #   Ibrain.config do |config|
+  #     config.track_inventory_levels = false
+  #   end
+  #
+  # This method is defined within the core gem on purpose.
+  # Some people may only wish to use the Core part of Ibrain.
+  def self.config(&_block)
+    yield(Ibrain::Config)
+  end
+
+  module Core
+    def self.does_ibrain_initializer_exist?(rails_paths, initializer_name)
+      rails_paths['config/initializers'].any? do |path|
+        File.exist?(Pathname.new(path).join(initializer_name))
+      end
+    end
+
+    private_class_method :does_ibrain_initializer_exist?
+
+    class GatewayError < RuntimeError; end
+  end
+end
+
+require "ibrain/core/version"
+
+require 'ibrain/core/class_constantizer'
+require 'ibrain/core/environment_extension'
+require 'ibrain/core/environment'
+
+require "ibrain/core/engine"
+
+require 'ibrain/i18n'
+require 'ibrain/permitted_attributes'
+require 'ibrain/permission_sets'
+require 'ibrain/logger'
+
+require 'ibrain/core/controller_helpers/response'
+require 'ibrain/core/controller_helpers/current_host'
+require 'ibrain/core/controller_helpers/strong_parameters'
+require 'ibrain/core/controller_helpers/auth'
+require 'ibrain/core/role_configuration'
+
+require 'ibrain/core/validators/email'
+require 'ibrain/user_class_handle'
+require 'ibrain/encryptor'