ibrain-core 0.4.5 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0dfff268b752582b0733cd99f43f0784e20061a2898e29a0c779000e7a07cce
-  data.tar.gz: b42ec5acdd8014ea314e3adacf6bbe6b470720d30aafa84d3b729efbc2d9f913
+  metadata.gz: bc329cadb1dbc83c7e0ea6e2a2e9f4eb6ef1ad3b74c8955e0f8ebb376ab329f2
+  data.tar.gz: 7371a38a6e0b9f531851e4b5ddf046a8e245fcd540211e1b3d51ce3a3dabb1be
 SHA512:
-  metadata.gz: e618a908b94991ade401094a790c46815421f752b451ba481626075860723f059a8d9413b586f8ffe39fd9234b671ee264a500eb0b4de5fe9941a4f610ac6ba6
-  data.tar.gz: 1e0ed241b8efc3c4f3545b88513d300a93702cbc7b65401764e562d9ec4322f84f2ae479b19247f212581cc43d6b40ab90163e7b5a3d5548f702c7a981fb63eb
+  metadata.gz: d69016d5aa23c6d5ea594298713db38c410087c56d3d7700302289ecd7e8bfa1d1db0eea2577cabf39036c37c9816f91a2e3f452cbb24161321d2f95f7af6be8
+  data.tar.gz: 3b1a1bf408ee1ce1ba4d53fcbd0d41042dddd45fd45854cd9cefa93c5b2e6e8ff6317e8153309fbf94a0d3ef929b7424187593a8535cc05e12d42dbdab224a13

data/app/controllers/ibrain/base_controller.rb

@@ -1,20 +1,18 @@
 # frozen_string_literal: true
 
-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
+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
 
-    include IbrainErrors
-    include IbrainHandler
+  include IbrainErrors
+  include IbrainHandler
 
-    protected
+  protected
 
-    def cryptor
-      Ibrain::Encryptor.new
-    end
+  def cryptor
+    Ibrain::Encryptor.new
   end
-end
+end

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

@@ -1,103 +1,99 @@
 # frozen_string_literal: true
 
-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
+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
 
-      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')
+  protected
 
-        operations = prepare_variables(params[:operations])
-        query = operations['query'] || params[:query]
-        variables = operations['variables'] || params[:variables]
-        operation_name = operations['operationName'] || params[:operationName]
+  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')
 
-        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?
+    operations = prepare_variables(params[:operations])
+    query = operations['query'] || params[:query]
+    variables = operations['variables'] || params[:variables]
+    operation_name = operations['operationName'] || params[:operationName]
 
-            file = params[k]
+    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 variables[argument_name].blank?
-              variables[argument_name] = variables[argument_name].is_a?(Array) ? [file] : file
+        file = params[k]
 
-              next
-            end
+        if variables[argument_name].blank?
+          variables[argument_name] = variables[argument_name].is_a?(Array) ? [file] : file
 
-            unless variables[argument_name].is_a?(Array)
-              variables[argument_name] = [variables[argument_name]]
-            end
+          next
+        end
 
-            variables[argument_name] = variables[argument_name].concat([file]).compact
-          end
+        unless variables[argument_name].is_a?(Array)
+          variables[argument_name] = [variables[argument_name]]
         end
 
-        [query, variables, operation_name]
+        variables[argument_name] = variables[argument_name].concat([file]).compact
       end
+    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
-            {}
-          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
+    [query, variables, operation_name]
+  end
 
-      def schema
-        Ibrain::Config.graphql_schema.safe_constantize
+  # 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
 
-      def map_user_class_to_request
-        return if request.env['devise.mapping'].present?
+  def schema
+    Ibrain::Config.graphql_schema.safe_constantize
+  end
 
-        request.env['devise.mapping'] = Ibrain.user_class
-      end
+  def map_user_class_to_request
+    return if request.env['devise.mapping'].present?
 
-      def max_depth(operation_name)
-        operation_name == 'IntrospectionQuery' ? nil : Ibrain::Config.graphql_max_depth
-      end
-    end
+    request.env['devise.mapping'] = Ibrain.user_class
+  end
+
+  def max_depth(operation_name)
+    operation_name == 'IntrospectionQuery' ? nil : Ibrain::Config.graphql_max_depth
   end
-end
+end

data/app/graphql/ibrain/base_schema.rb

@@ -1,55 +1,53 @@
 # frozen_string_literal: true
 
-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
+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)
   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

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

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

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

@@ -1,27 +1,22 @@
 # 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)
 
-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
+    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
-      end
-    end
+    true
   end
-end
+end

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

@@ -1,20 +1,16 @@
 # frozen_string_literal: true
 
-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)
+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)
 
-        # 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)
-      end
-    end
+  def is_invalid_session(object)
+    object.try(:context).try(:fetch, :current_user, nil).blank? && options.try(:fetch, :session_required, false)
   end
-end
+end

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

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

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

@@ -2,60 +2,56 @@
 
 # ref: https://zenn.dev/necocoa/articles/setup-graphql-batch
 
-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
+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}"
     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