ibrain-core 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e306b2238fba539d079c52bbb0c6b6bb2ff1092e9f950c4c6fd85065b2325fa3
+  data.tar.gz: d9ae60e6b5769f14339bcdba97ed42538523c34aa9d382454496d0ac49f1d320
+SHA512:
+  metadata.gz: 3ae2d1c79c5931769a432d6532f104c88245afb7df5dc3d0af557b3496b215548cbae686203f229c7d5bac7226000e39caad0ffe42fae0361fe19b1ca64f38df
+  data.tar.gz: 6b34268ff18f1eb0daafcd47d2b7a32f48360370ddc7367c18d5399048b69ca391758b4e0fdaa137a3a6f9d73d7cf02c84d828fe000a0ba7911d99d934dabe7e

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2021 TODO: Write your name
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,75 @@
+# Ibrain::Core
+This is core plugin for rails api project
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ibrain-core'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install ibrain-core
+```
+
+Please install plugin after install this gem
+```bash
+$ bundle exec rails generate ibrain:install
+```
+# Migration
+Default migration engine is [ridgepole](https://github.com/ridgepole/ridgepole), using this command line to migrate database:
+```bash
+bundle exec rails ridgpole:apply
+```
+To use default migration plugin, please disable ridgepole
+```bash
+bundle exec rails generate ibrain::install --with-ridgepole=false
+```
+# GraphQL API
+If you use graphql for rails please add this option when install plugin
+```bash
+$ bundle exec rails generate ibrain::install --with-graphql
+```
+To generate graphql type
+```bash
+bundle exec rails generate ibrain:graphql:object user
+```
+To generate graphql resolver single query to get user data
+```bash
+bundle exec rails generate ibrain:graphql:resolver user --model=User
+```
+To generate graphql resolvers query to get users list
+```bash
+bundle exec rails generate ibrain:graphql:resolvers users --model=User
+```
+For pagination please using aggregate body query, something like
+```
+query users($offset: Int, $limit: Int, $filter: Filter) {
+    users(offset: $offset, limit: $limit, filter: $filter) {
+        id
+        first_name
+    }
+
+    users_aggregate(filter: $filter) {
+        total_count
+    }
+}
+```
+To generate graphql mutation to insert, update, delete user
+```bash
+bundle exec rails generate ibrain:graphql:mutation insert_user --model=User
+```
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"

data/app/controllers/concerns/ibrain_errors.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module IbrainErrors
+  extend ActiveSupport::Concern
+
+  class PermissionError < StandardError; end
+
+  class UnknownError < StandardError
+    def initialize(message)
+      super
+
+      @message = message
+    end
+
+    def details
+      message
+    end
+
+    private
+
+    attr_accessor :message
+  end
+end

data/app/controllers/concerns/ibrain_handler.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module IbrainHandler
+  extend ActiveSupport::Concern
+
+  included do
+    rescue_from StandardError, with: :standard_handler
+    rescue_from ActionController::ParameterMissing, with: :parameter_handler
+    rescue_from ActiveRecord::RecordNotFound, with: :not_found_handler
+    rescue_from ActiveRecord::RecordInvalid, with: :bad_request_handler
+    rescue_from IbrainErrors::PermissionError, with: :permission_denied_handler
+    rescue_from IbrainErrors::UnknownError, with: :bad_request_handler
+    rescue_from ActionController::InvalidAuthenticityToken, with: :unauthorized_handler
+    rescue_from ActiveSupport::MessageVerifier::InvalidSignature, with: :unauthorized_handler
+  end
+
+  private
+
+  def standard_handler(errors)
+    render_json_error(errors, 500)
+  end
+
+  def bad_request_handler(errors)
+    render_json_error(errors, 400)
+  end
+
+  def parameter_handler(errors)
+    render_json_error(errors, 400)
+  end
+
+  def not_found_handler(errors)
+    render_json_error(errors, 404)
+  end
+
+  def permission_denied_handler(errors)
+    render_json_error(errors, 405)
+  end
+
+  def unauthorized_handler(errors)
+    render_json_error(errors, 401)
+  end
+end

data/app/controllers/ibrain/base_controller.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Ibrain
+  class BaseController < ActionController::API
+    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
+
+    protected
+
+    def operation_name
+      params[:operationName]
+    end
+
+    def skip_operations
+      []
+    end
+
+    def cryptor
+      Ibrain::Encryptor.new
+    end
+  end
+end

data/app/controllers/ibrain/graphql_controller.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Ibrain
+  class GraphqlController < Ibrain::BaseController
+    def execute
+      query, variables, operation_name = normalize_entity
+
+      result = schema.execute(
+        query,
+        variables: variables,
+        context: {
+          session: session,
+          current_user: current_ibrain_user
+        },
+        operation_name: operation_name
+      )
+
+      render_json_ok(result['data'], nil, result['errors'])
+    end
+
+    protected
+
+    def normalize_entity
+      query = params[:query]
+      operation_name = params[:operationName]
+      variables = prepare_variables(params[:variables])
+
+      [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
+          {}
+        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
+  end
+end

data/app/graphql/ibrain/base_schema.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Ibrain
+  class BaseSchema < ::GraphQL::Schema
+    use GraphQL::Batch
+
+    use GraphQL::Guard.new(
+      policy_object: ::Ibrain::Config.graphql_policy.safe_constantize,
+      not_authorized: ->(type, field) { GraphQL::ExecutionError.new("Not authorized 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
+end

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

@@ -0,0 +1,15 @@
+# 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
+    end
+  end
+end

data/app/graphql/ibrain/interfaces/base_interface.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ibrain::Interfaces::BaseInterface
+  include ::GraphQL::Schema::Interface
+end

data/app/graphql/ibrain/interfaces/person_interface.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Ibrain::Interfaces::PersonInterface
+  include Ibrain::Types::BaseInterface
+
+  description 'Person Interface'
+
+  field :first_name, String, null: true
+  field :last_name, String, null: true
+  field :full_name, String, null: true
+
+  def full_name
+    [object.try(:first_name), object.try(:last_name)].compact.join(' ')
+  end
+end

data/app/graphql/ibrain/interfaces/record_interface.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Ibrain::Interfaces::RecordInterface
+  include Ibrain::Types::BaseInterface
+
+  description 'Common Interface'
+
+  field :created_at, ::GraphQL::Types::ISO8601DateTime, null: false
+  field :updated_at, ::GraphQL::Types::ISO8601DateTime, null: false
+end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Lazy
+    class Base < GraphQL::Function
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# 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
+    end
+  end
+end

data/app/graphql/ibrain/mutations/base_mutation.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Mutations
+    class BaseMutation < GraphQL::Schema::RelayClassicMutation
+      argument_class Types::BaseArgument
+      field_class Types::BaseField
+      input_object_class Types::BaseInputObject
+      object_class Types::BaseObject
+
+      argument :attribute, Types::AttributeType, required: false
+      argument :attributes, [Types::AttributeType], required: false
+
+      def resolve(args)
+        @params = ::ActionController::Parameters.new(args)
+      end
+
+      protected
+
+      attr_reader :params
+
+      def upload_permitted
+        %i[content_type headers original_filename tempfile]
+      end
+
+      def cryptor
+        ::Ibrain::Encryptor.new
+      end
+
+      def current_user
+        context[:current_user]
+      end
+    end
+  end
+end

data/app/graphql/ibrain/policies/base_policy.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Policies
+    class BasePolicy
+      IBRAIN_QUERY_RULES = {
+        '*': {
+          guard: ->(_obj, _args, _ctx) { true }
+        }
+      }
+
+      IBRAIN_MUTATION_RULES = {
+        '*': {
+          guard: ->(_obj, _args, ctx) { roles.include?(ctx[:current_user].try(:role)) }
+        }
+      }
+
+      RULES = {
+        'Query' => IBRAIN_QUERY_RULES,
+        'Mutation' => IBRAIN_MUTATION_RULES
+      }.freeze
+
+      class << self
+        def roles
+          Ibrain::Config.ibrain_roles
+        end
+
+        def has_permission?(current_user, resource)
+          return false if current_user.blank?
+          return true if current_user.super_admin?
+
+          current_user.try(:scope).to_s.split(',').include?(resource)
+        end
+
+        def guard(type, field)
+          RULES.dig(type.name, field, :guard)
+        end
+
+        def not_authorized_handler(type, field)
+          RULES.dig(type, field, :not_authorized) || RULES.dig(type, :*, :not_authorized)
+        end
+      end
+    end
+  end
+end

data/app/graphql/ibrain/policies/graphql_policy.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Policies
+    class GraphqlPolicy < BasePolicy
+    end
+  end
+end

data/app/graphql/ibrain/resolvers/base_aggregate.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Resolvers
+    class BaseAggregate < BaseResolver
+      type Ibrain::Types::AggregateType.connection_type, null: false
+    end
+  end
+end

data/app/graphql/ibrain/resolvers/base_resolver.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Resolvers
+    class BaseResolver < GraphQL::Schema::Resolver
+      argument :filter, Ibrain::Types::FilterType, required: false, default_value: nil
+      argument :offset, Int, required: false, default_value: 0
+      argument :limit, Int, required: false, default_value: 10
+
+      def current_user
+        context.fetch(:current_user)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Types
+    class AggregateType < BaseObject
+      field :total_count, Int, null: false, default_value: 0
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Types
+    class BaseArgument < GraphQL::Schema::Argument
+      def initialize(*args, **kwargs, &block)
+        super(*args, camelize: false, **kwargs, &block)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Types
+    class BaseConnection < Types::BaseObject
+      # add `nodes` and `pageInfo` fields, as well as `edge_type(...)` and `node_nullable(...)` overrides
+      include GraphQL::Types::Relay::ConnectionBehaviors
+
+      field :total_count, Integer, null: false, camelize: false
+
+      def total_count
+        object.items.size
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Types
+    class BaseEdge < Types::BaseObject
+      # add `node` and `cursor` fields, as well as `node_type(...)` override
+      include GraphQL::Types::Relay::EdgeBehaviors
+    end
+  end
+end

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

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

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Types
+    class BaseField < GraphQL::Schema::Field
+      argument_class ::Ibrain::Types::BaseArgument
+
+      def initialize(*args, default_value: nil, **kwargs, &block)
+        super(*args, camelize: false, **kwargs, &block)
+
+        extension(::Ibrain::Extentions::DefaultValue, default_value: default_value) unless default_value.nil?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Types
+    class BaseInputObject < GraphQL::Schema::InputObject
+      argument_class Ibrain::Types::BaseArgument
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module Types
+    module BaseInterface
+      include GraphQL::Schema::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_node.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Ibrain::Types::BaseNode < Types::BaseObject
+  implements ::GraphQL::Relay::Node.interface
+  implements ::Ibrain::Interfaces::RecordInterface
+
+  global_id_field :id
+  field_class ::Ibrain::Types::BaseField
+
+  def self.field(*args, camelize: false, **kwargs, &block)
+    super
+  end
+end