ibrain-core 0.4.6 → 0.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc329cadb1dbc83c7e0ea6e2a2e9f4eb6ef1ad3b74c8955e0f8ebb376ab329f2
-  data.tar.gz: 7371a38a6e0b9f531851e4b5ddf046a8e245fcd540211e1b3d51ce3a3dabb1be
+  metadata.gz: '09278662f5dace559b2b93ed9a45f39ef9ca822643b31e0e50b44e923e1027dc'
+  data.tar.gz: 8f19875c9383f8235aaf53596978f7ab0fb568924a312d018e867fe5b4ae2957
 SHA512:
-  metadata.gz: d69016d5aa23c6d5ea594298713db38c410087c56d3d7700302289ecd7e8bfa1d1db0eea2577cabf39036c37c9816f91a2e3f452cbb24161321d2f95f7af6be8
-  data.tar.gz: 3b1a1bf408ee1ce1ba4d53fcbd0d41042dddd45fd45854cd9cefa93c5b2e6e8ff6317e8153309fbf94a0d3ef929b7424187593a8535cc05e12d42dbdab224a13
+  metadata.gz: b68fc74e862182d9295200edb26eced011eccd9f7e6b93b994a8392127a9ecb29e1a4e26405238ce4e450e76b1b86ccbf54a5c3f334752fdae6a04999dc708a2
+  data.tar.gz: 31d6e746ca29c99508950469e01e36b98279098cd7d6b97220a1a77de568c0e10da90fa9b0d877fa16375d48852e386f2b25db7f80b1aeb02b2bb60266402de7

data/app/controllers/ibrain/base_controller.rb

@@ -1,18 +1,20 @@
 # frozen_string_literal: true
 
-class Ibrain::BaseController < Ibrain::Config.parent_controller.constantize
-  include ActionController::Helpers
-  include Ibrain::Core::ControllerHelpers::Response
-  include Ibrain::Core::ControllerHelpers::StrongParameters
-  include Ibrain::Core::ControllerHelpers::CurrentHost
-  include Ibrain::Core::ControllerHelpers::Auth
+module Ibrain
+  class BaseController < Ibrain::Config.parent_controller.constantize
+    include ActionController::Helpers
+    include Ibrain::Core::ControllerHelpers::Response
+    include Ibrain::Core::ControllerHelpers::StrongParameters
+    include Ibrain::Core::ControllerHelpers::CurrentHost
+    include Ibrain::Core::ControllerHelpers::Auth
 
-  include IbrainErrors
-  include IbrainHandler
+    include IbrainErrors
+    include IbrainHandler
 
-  protected
+    protected
 
-  def cryptor
-    Ibrain::Encryptor.new
+    def cryptor
+      Ibrain::Encryptor.new
+    end
   end
-end
+end

data/app/controllers/ibrain/core/graphql_controller.rb

@@ -1,99 +1,103 @@
 # frozen_string_literal: true
 
-class Ibrain::Core::GraphqlController < Ibrain::BaseController
-  include Devise::Controllers::ScopedViews
-
-  before_action :map_user_class_to_request
-
-  helpers = %w(resource scope_name resource_name signed_in_resource
-               resource_class resource_params devise_mapping)
-  helper_method(*helpers)
-
-  def execute
-    query, variables, operation_name = normalize_entity
-
-    result = schema.execute(
-      query,
-      variables: variables,
-      context: {
-        session: session,
-        current_user: try_ibrain_current_user,
-        controller: self,
-        request: request
-      },
-      operation_name: operation_name,
-      max_depth: max_depth(operation_name)
-    )
-
-    render_json_ok(result['data'], nil, result['errors'])
-  end
+module Ibrain
+  module Core
+    class GraphqlController < ::Ibrain::BaseController
+      include Devise::Controllers::ScopedViews
+
+      before_action :map_user_class_to_request
+
+      helpers = %w(resource scope_name resource_name signed_in_resource
+                   resource_class resource_params devise_mapping)
+      helper_method(*helpers)
+
+      def execute
+        query, variables, operation_name = normalize_entity
+
+        result = schema.execute(
+          query,
+          variables: variables,
+          context: {
+            session: session,
+            current_user: try_ibrain_current_user,
+            controller: self,
+            request: request
+          },
+          operation_name: operation_name,
+          max_depth: max_depth(operation_name)
+        )
+
+        render_json_ok(result['data'], nil, result['errors'])
+      end
 
-  protected
+      protected
 
-  def normalize_entity
-    return [params[:query], prepare_variables(params[:variables]), params[:operationName]] if params[:variables].present?
-    return [params[:query], prepare_variables(params[:variables]), 'IntrospectionQuery'] if params[:query].try(:include?, 'IntrospectionQuery')
+      def normalize_entity
+        return [params[:query], prepare_variables(params[:variables]), params[:operationName]] if params[:variables].present?
+        return [params[:query], prepare_variables(params[:variables]), 'IntrospectionQuery'] if params[:query].try(:include?, 'IntrospectionQuery')
 
-    operations = prepare_variables(params[:operations])
-    query = operations['query'] || params[:query]
-    variables = operations['variables'] || params[:variables]
-    operation_name = operations['operationName'] || params[:operationName]
+        operations = prepare_variables(params[:operations])
+        query = operations['query'] || params[:query]
+        variables = operations['variables'] || params[:variables]
+        operation_name = operations['operationName'] || params[:operationName]
 
-    if params[:map].present?
-      JSON.parse(params[:map]).each do |k, arguments|
-        argument_name = arguments.try(:first).try(:split, '.').try(:second)
-        next if argument_name.blank?
+        if params[:map].present?
+          JSON.parse(params[:map]).each do |k, arguments|
+            argument_name = arguments.try(:first).try(:split, '.').try(:second)
+            next if argument_name.blank?
 
-        file = params[k]
+            file = params[k]
 
-        if variables[argument_name].blank?
-          variables[argument_name] = variables[argument_name].is_a?(Array) ? [file] : file
+            if variables[argument_name].blank?
+              variables[argument_name] = variables[argument_name].is_a?(Array) ? [file] : file
 
-          next
-        end
+              next
+            end
+
+            unless variables[argument_name].is_a?(Array)
+              variables[argument_name] = [variables[argument_name]]
+            end
 
-        unless variables[argument_name].is_a?(Array)
-          variables[argument_name] = [variables[argument_name]]
+            variables[argument_name] = variables[argument_name].concat([file]).compact
+          end
         end
 
-        variables[argument_name] = variables[argument_name].concat([file]).compact
+        [query, variables, operation_name]
       end
-    end
-
-    [query, variables, operation_name]
-  end
 
-  # Handle variables in form data, JSON body, or a blank value
-  def prepare_variables(variables_param)
-    case variables_param
-    when String
-      if variables_param.present?
-        JSON.parse(variables_param) || {}
-      else
-        {}
+      # Handle variables in form data, JSON body, or a blank value
+      def prepare_variables(variables_param)
+        case variables_param
+        when String
+          if variables_param.present?
+            JSON.parse(variables_param) || {}
+          else
+            {}
+          end
+        when Hash
+          variables_param
+        when ActionController::Parameters
+          variables_param.to_unsafe_hash # GraphQLRuby will validate name and type of incoming variables.
+        when nil
+          {}
+        else
+          raise ArgumentError, "Unexpected parameter: #{variables_param}"
+        end
       end
-    when Hash
-      variables_param
-    when ActionController::Parameters
-      variables_param.to_unsafe_hash # GraphQLRuby will validate name and type of incoming variables.
-    when nil
-      {}
-    else
-      raise ArgumentError, "Unexpected parameter: #{variables_param}"
-    end
-  end
 
-  def schema
-    Ibrain::Config.graphql_schema.safe_constantize
-  end
+      def schema
+        Ibrain::Config.graphql_schema.safe_constantize
+      end
 
-  def map_user_class_to_request
-    return if request.env['devise.mapping'].present?
+      def map_user_class_to_request
+        return if request.env['devise.mapping'].present?
 
-    request.env['devise.mapping'] = Ibrain.user_class
-  end
+        request.env['devise.mapping'] = Ibrain.user_class
+      end
 
-  def max_depth(operation_name)
-    operation_name == 'IntrospectionQuery' ? nil : Ibrain::Config.graphql_max_depth
+      def max_depth(operation_name)
+        operation_name == 'IntrospectionQuery' ? nil : Ibrain::Config.graphql_max_depth
+      end
+    end
   end
-end
+end

data/app/graphql/ibrain/base_schema.rb

@@ -1,53 +1,55 @@
 # frozen_string_literal: true
 
-class Ibrain::BaseSchema < GraphQL::Schema
-  use GraphQL::Batch
-
-  max_depth Ibrain::Config.graphql_max_depth
-  query_analyzer(Ibrain::LogQueryDepth)
-
-  # use GraphQL::Guard.new(
-  #   policy_object: ::Ibrain::Config.graphql_policy.safe_constantize,
-  #   not_authorized: ->(type, field) { raise IbrainErrors::PermissionError.new("You not have permission to access #{type}.#{field}") }
-  # )
-
-  # Union and Interface Resolution
-  def self.resolve_type(_abstract_type, _obj, _ctx)
-    # TODO: Implement this function
-    # to return the correct object type for `obj`
-    raise(GraphQL::RequiredImplementationMissingError)
+module Ibrain
+  class BaseSchema < ::GraphQL::Schema
+    use GraphQL::Batch
+
+    max_depth Ibrain::Config.graphql_max_depth
+    query_analyzer(Ibrain::LogQueryDepth)
+
+    # use GraphQL::Guard.new(
+    #   policy_object: ::Ibrain::Config.graphql_policy.safe_constantize,
+    #   not_authorized: ->(type, field) { raise IbrainErrors::PermissionError.new("You not have permission to access #{type}.#{field}") }
+    # )
+
+    # Union and Interface Resolution
+    def self.resolve_type(_abstract_type, _obj, _ctx)
+      # TODO: Implement this function
+      # to return the correct object type for `obj`
+      raise(GraphQL::RequiredImplementationMissingError)
+    end
+
+    # Relay-style Object Identification:
+
+    # Return a string UUID for `object`
+    def self.id_from_object(object, type_definition, query_ctx)
+      # Here's a simple implementation which:
+      # - joins the type name & object.id
+      # - encodes it with base64:
+      # GraphQL::Schema::UniqueWithinType.encode(type_definition.name, object.id)
+    end
+
+    # Given a string UUID, find the object
+    def self.object_from_id(id, query_ctx)
+      # For example, to decode the UUIDs generated above:
+      # type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(id)
+      #
+      # Then, based on `type_name` and `id`
+      # find an object in your application
+      # ...
+    end
+
+    def self.field(*args, camelize: false, **kwargs, &block)
+      # if camelize == false
+      #   # Also make a camelized field:
+      #   field(*args, camelize: false, **kwargs, &block)
+      # end
+      super
+    end
+
+    rescue_from(ActiveRecord::RecordNotFound) do |_err, _obj, _args, _ctx, field|
+      # Raise a graphql-friendly error with a custom message
+      raise GraphQL::ExecutionError, "#{field.type.unwrap.graphql_name} not found"
+    end
   end
-
-  # Relay-style Object Identification:
-
-  # Return a string UUID for `object`
-  def self.id_from_object(object, type_definition, query_ctx)
-    # Here's a simple implementation which:
-    # - joins the type name & object.id
-    # - encodes it with base64:
-    # GraphQL::Schema::UniqueWithinType.encode(type_definition.name, object.id)
-  end
-
-  # Given a string UUID, find the object
-  def self.object_from_id(id, query_ctx)
-    # For example, to decode the UUIDs generated above:
-    # type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(id)
-    #
-    # Then, based on `type_name` and `id`
-    # find an object in your application
-    # ...
-  end
-
-  def self.field(*args, camelize: false, **kwargs, &block)
-    # if camelize == false
-    #   # Also make a camelized field:
-    #   field(*args, camelize: false, **kwargs, &block)
-    # end
-    super
-  end
-
-  rescue_from(ActiveRecord::RecordNotFound) do |_err, _obj, _args, _ctx, field|
-    # Raise a graphql-friendly error with a custom message
-    raise GraphQL::ExecutionError, "#{field.type.unwrap.graphql_name} not found"
-  end
-end
+end

data/app/graphql/ibrain/extentions/default_value.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
-class Ibrain::Extentions::DefaultValue < GraphQL::Schema::FieldExtension
-  def after_resolve(value:, **_rest)
-    if value.nil?
-      options[:default_value]
-    else
-      value
+module Ibrain
+  module Extentions
+    class DefaultValue < GraphQL::Schema::FieldExtension
+      def after_resolve(value:, **_rest)
+        if value.nil?
+          options[:default_value]
+        else
+          value
+        end
+      end
     end
   end
-end
+end

data/app/graphql/ibrain/extentions/roles.rb

@@ -1,22 +1,27 @@
 # frozen_string_literal: true
-class Ibrain::Extentions::Roles < GraphQL::Schema::FieldExtension
-  def after_resolve(object:, value:, **_rest)
-    raise IbrainErrors::PermissionError.new("You not have permission to access #{field&.name}") if is_invalid_role(object)
 
-    value
-  end
+module Ibrain
+  module Extentions
+    class Roles < GraphQL::Schema::FieldExtension
+      def after_resolve(object:, value:, **_rest)
+        raise IbrainErrors::PermissionError.new("You not have permission to access #{field&.name}") if is_invalid_role(object)
+
+        value
+      end
 
-  private
+      private
 
-  def is_invalid_role(object)
-    roles = options.try(:fetch, :roles, [])
-    current_user = object.try(:context).try(:fetch, :current_user, nil)
-    role = current_user.try(:role) || current_user.try(:graphql_role)
+      def is_invalid_role(object)
+        roles = options.try(:fetch, :roles, [])
+        current_user = object.try(:context).try(:fetch, :current_user, nil)
+        role = current_user.try(:role) || current_user.try(:graphql_role)
 
-    return if roles.blank?
-    return true if current_user.blank?
-    return false if roles.include?(role)
+        return if roles.blank?
+        return true if current_user.blank?
+        return false if roles.include?(role)
 
-    true
+        true
+      end
+    end
   end
-end
+end

data/app/graphql/ibrain/extentions/session_required.rb

@@ -1,16 +1,20 @@
 # frozen_string_literal: true
 
-class Ibrain::Extentions::SessionRequired < GraphQL::Schema::FieldExtension
-  def resolve(object:, arguments:, **rest)
-    raise ActionController::InvalidAuthenticityToken, I18n.t('ibrain.errors.session.invalid_session') if is_invalid_session(object)
+module Ibrain
+  module Extentions
+    class SessionRequired < GraphQL::Schema::FieldExtension
+      def resolve(object:, arguments:, **rest)
+        raise ActionController::InvalidAuthenticityToken, I18n.t('ibrain.errors.session.invalid_session') if is_invalid_session(object)
 
-    # yield the current time as `memo`
-    yield(object, arguments, rest)
-  end
+        # yield the current time as `memo`
+        yield(object, arguments, rest)
+      end
 
-  private
+      private
 
-  def is_invalid_session(object)
-    object.try(:context).try(:fetch, :current_user, nil).blank? && options.try(:fetch, :session_required, false)
+      def is_invalid_session(object)
+        object.try(:context).try(:fetch, :current_user, nil).blank? && options.try(:fetch, :session_required, false)
+      end
+    end
   end
-end
+end

data/app/graphql/ibrain/lazy/base.rb

@@ -1,4 +1,8 @@
 # frozen_string_literal: true
 
-class Ibrain::Lazy::Base < GraphQL::Schema::Resolver
-end
+module Ibrain
+  module Lazy
+    class Base < GraphQL::Schema::Resolver
+    end
+  end
+end

data/app/graphql/ibrain/loaders/association_loader.rb

@@ -2,56 +2,60 @@
 
 # ref: https://zenn.dev/necocoa/articles/setup-graphql-batch
 
-class Ibrain::Loaders::AssociationLoader < GraphQL::Batch::Loader
-  def self.validate(model, association_name)
-    new(model, association_name)
-    nil
-  end
-
-  def initialize(model, association_name)
-    super()
-    @model = model
-    @association_name = association_name
-    validate
-  end
-
-  def load(record)
-    unless record.is_a?(@model)
-      raise TypeError,
-            "#{@model} loader can't load association for #{record.class}"
+module Ibrain
+  module Loaders
+    class AssociationLoader < GraphQL::Batch::Loader
+      def self.validate(model, association_name)
+        new(model, association_name)
+        nil
+      end
+
+      def initialize(model, association_name)
+        super()
+        @model = model
+        @association_name = association_name
+        validate
+      end
+
+      def load(record)
+        unless record.is_a?(@model)
+          raise TypeError,
+                "#{@model} loader can't load association for #{record.class}"
+        end
+        return Promise.resolve(read_association(record)) if association_loaded?(record)
+
+        super
+      end
+
+      # We want to load the associations on all records, even if they have the same id
+      def cache_key(record)
+        record.object_id
+      end
+
+      def perform(records)
+        preload_association(records)
+        records.each { |record| fulfill(record, read_association(record)) }
+      end
+
+      private
+
+      def validate
+        return if @model.reflect_on_association(@association_name)
+
+        raise ArgumentError, "No association #{@association_name} on #{@model}"
+      end
+
+      def preload_association(records)
+        ::ActiveRecord::Associations::Preloader.new.preload(records, @association_name)
+      end
+
+      def read_association(record)
+        record.public_send(@association_name)
+      end
+
+      def association_loaded?(record)
+        record.association(@association_name).loaded?
+      end
     end
-    return Promise.resolve(read_association(record)) if association_loaded?(record)
-
-    super
-  end
-
-  # We want to load the associations on all records, even if they have the same id
-  def cache_key(record)
-    record.object_id
-  end
-
-  def perform(records)
-    preload_association(records)
-    records.each { |record| fulfill(record, read_association(record)) }
-  end
-
-  private
-
-  def validate
-    return if @model.reflect_on_association(@association_name)
-
-    raise ArgumentError, "No association #{@association_name} on #{@model}"
-  end
-
-  def preload_association(records)
-    ::ActiveRecord::Associations::Preloader.new.preload(records, @association_name)
-  end
-
-  def read_association(record)
-    record.public_send(@association_name)
-  end
-
-  def association_loaded?(record)
-    record.association(@association_name).loaded?
   end
-end
+end