rhino_project_core 0.20.0.alpha.0

data/lib/rhino/resource/owner.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module Owner
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :resource_owned_by, default: nil
+
+        delegate :auth_owner?, :base_owner?, :global_owner?, to: :class
+        delegate :joins_for, :joins_for_auth_owner, :joins_for_base_owner, to: :class
+      end
+
+      def base_owner_ids
+        owner_ids(:joins_for_base_owner)
+      end
+
+      def auth_owner_ids
+        owner_ids(:joins_for_auth_owner)
+      end
+
+      # The self is actually required to work with class_attribute properly
+      # rubocop:disable Style/RedundantSelf
+      class_methods do # rubocop:disable  Metrics/BlockLength
+        # Test if rhino_owner[rdoc-ref:rhino_owner] is the auth owner
+        # Also available on the instance
+        def auth_owner?
+          self == Rhino.auth_owner
+        end
+
+        # Test if rhino_owner[rdoc-ref:rhino_owner] is the base owner
+        # Also available on the instance
+        def base_owner?
+          self == Rhino.base_owner
+        end
+
+        # Test if rhino_owner[rdoc-ref:rhino_owner] is the base owner
+        # Also available on the instance
+        def global_owner?
+          self.resource_owned_by == :global
+        end
+
+        # Test if rhino_owner[rdoc-ref:rhino_owner] is the base owner
+        # Also available on the instance
+        def global_owned?
+          chained_scope = self
+          while !chained_scope.auth_owner? && !chained_scope.base_owner? && !chained_scope.global_owner?
+            chained_scope = chained_scope.resource_owned_by.to_s.classify.safe_constantize
+          end
+
+          chained_scope.global_owner?
+        end
+
+        # In Rhino the owner specifies which reference is next in the hierarchy.
+        # A resource can only have one owned.  This owner will either be global
+        # for resources that are not owned by the base owner or a belongs to
+        # reference that will eventually lead to the base owner.  The resource
+        # must respond to send(:owner_name) on the instance unless it is global.
+        # Such as:
+        #
+        #   rhino_owner :user
+        #
+        # Will indicate the resource has a has_one reference to user
+        #
+        # === Examples
+        #
+        #   # Blog is owned by user
+        #   class Blog < ApplicationRecord
+        #     include Rhino::Resource::ActiveRecord
+        #
+        #     rhino_owner :user
+        #   end
+        #
+        #   # BlogPost is owned by Blog
+        #   class Blog < ApplicationRecord
+        #     include Rhino::Resource::ActiveRecord
+        #
+        #     rhino_owner :blog
+        #   end
+        #
+        #   # Category is global
+        #   class Category < ApplicationRecord
+        #     include Rhino::Resource::ActiveRecord
+        #
+        #     # Can also use rhino_owner_global as a short cut
+        #     rhino_owner :global
+        #   end
+        #
+        def rhino_owner(name, **_options)
+          self.resource_owned_by = name
+          rhino_policy :global if global_owned?
+        end
+
+        # Sets rhino_owner[rdoc-ref:rhino_owner] to be the base owner
+        def rhino_owner_base(...)
+          rhino_owner(Rhino.base_owner.model_name.i18n_key, ...)
+        end
+
+        # Sets rhino_owner[rdoc-ref:rhino_owner] to be global
+        def rhino_owner_global(...)
+          rhino_owner(:global, ...)
+        end
+
+        def joins_for_auth_owner
+          return {} if auth_owner?
+
+          # Find the reflection to the auth owner
+          return Rhino.base_to_auth if base_owner?
+
+          joins = simple_joins_for_base_owner
+
+          # Only chain extra to auth if its not the same
+          joins.inject(Rhino.same_owner? ? {} : Rhino.base_to_auth) { |a, n| { n => a } }
+        end
+
+        def joins_for_base_owner
+          return {} if base_owner?
+
+          return Rhino.auth_to_base if auth_owner?
+
+          joins = simple_joins_for_base_owner
+
+          joins.inject({}) { |a, n| { n => a } }
+        end
+
+        def joins_for(parent)
+          return {} if parent.to_s.classify == self.to_s.classify
+
+          joins = simple_joins_for(parent)
+
+          joins.inject({}) { |a, n| { n => a } }
+        end
+
+        private
+        def simple_joins_for(parent)
+          # FIXME: There is probably a more rubyish way to do this
+          chained_scope = self
+          joins = []
+
+          # The ownership could be a many, so we classify first
+          while chained_scope.resource_owned_by.to_s.classify != parent.to_s.classify
+            joins << chained_scope.resource_owned_by
+            chained_scope = chained_scope.resource_owned_by.to_s.classify.constantize
+          end
+          joins << chained_scope.resource_owned_by
+
+          joins.reverse
+        end
+
+        def simple_joins_for_base_owner
+          simple_joins_for(Rhino.base_owner)
+        end
+      end
+      # rubocop:enable Style/RedundantSelf
+    end
+
+    private
+    # We use the parent as the starting point because if the record is not
+    # persisted yet, we won't be able to find it
+    def owner_ids(joins)
+      bo = Rhino.base_owner
+
+      return [] unless owner
+
+      parent_klass = owner.class
+      pk = parent_klass.primary_key
+
+      parent_klass.joins(parent_klass.send(joins)).where("#{pk}": owner[pk]).pluck("#{bo.table_name}.#{bo.primary_key}")
+    end
+  end
+end

data/lib/rhino/resource/params.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module Params
+      extend ActiveSupport::Concern
+
+      included do
+        delegate :create_params, :show_params, :update_params, :transform_params, to: :class
+      end
+
+      class_methods do
+        def create_params
+          raise NotImplementedError, "#create_params is not implemented"
+        end
+
+        def show_params
+          raise NotImplementedError, "#show_params is not implemented"
+        end
+
+        def update_params
+          raise NotImplementedError, "#update_params is not implemented"
+        end
+
+        def transform_params(params)
+          params
+        end
+      end
+    end
+  end
+end

data/lib/rhino/resource/properties.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    # == Rhino \Resource \Properties
+    #
+    # Provides a way to control what properties are exposed on resources as well
+    # as an interface for resource implementations to implement and existence
+    # utilities.
+    #
+    # Read, create and update properties can be constrained with only and except
+    # directives:
+    #
+    #   class User
+    #     include ActiveModel::AttributeMethods
+    #
+    #     rhino_properties_read except: :password
+    #     rhino_properties_create only: [:email]
+    #     rhino_properties_update only: [:name]
+    #   end
+    #
+    # rdoc-ref:rhino_properties_write constrains both create and update.
+    #
+    # Resource implementations need to implement the following methods:
+    #   identifier_property
+    #   readable_properties
+    #   creatable_properties
+    #   updatable_properties
+    module Properties # rubocop:todo Metrics/ModuleLength
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_read_properties, default: nil
+        class_attribute :_read_properties_only, default: nil
+        class_attribute :_read_properties_except, default: []
+
+        class_attribute :_create_properties, default: nil
+        class_attribute :_create_properties_only, default: nil
+        class_attribute :_create_properties_except, default: []
+
+        class_attribute :_update_properties, default: nil
+        class_attribute :_update_properties_only, default: nil
+        class_attribute :_update_properties_except, default: []
+
+        class_attribute :_all_properties, default: nil
+
+        class_attribute :_properties_overrides, default: ActiveSupport::HashWithIndifferentAccess.new
+        class_attribute :_properties_array, default: {}
+
+        delegate :identifier_property, to: :class
+        delegate :read_properties, :create_properties, :update_properties, to: :class
+        delegate :all_properties, to: :class
+
+        delegate :describe_property, to: :class
+      end
+
+      # rubocop:disable Style/RedundantSelf
+      class_methods do # rubocop:disable Metrics/BlockLength
+        def rhino_properties_read(**options)
+          self._read_properties_only = Array.wrap(options[:only]).map(&:to_s) if options.key?(:only)
+          self._read_properties_except = Array.wrap(options[:except]).map(&:to_s) if options.key?(:except)
+        end
+
+        def rhino_properties_create(**options)
+          self._create_properties_only = Array.wrap(options[:only]).map(&:to_s) if options.key?(:only)
+          self._create_properties_except = Array.wrap(options[:except]).map(&:to_s) if options.key?(:except)
+        end
+
+        def rhino_properties_update(**options)
+          self._update_properties_only = Array.wrap(options[:only]).map(&:to_s) if options.key?(:only)
+          self._update_properties_except = Array.wrap(options[:except]).map(&:to_s) if options.key?(:except)
+        end
+
+        # Constrain create and update properties
+        # Accepts only: and except: as either a single property or an array of
+        # properties
+        def rhino_properties_write(...)
+          rhino_properties_create(...)
+          rhino_properties_update(...)
+        end
+
+        def rhino_properties_format(formats)
+          formats.each do |property, format|
+            self._properties_overrides = self._properties_overrides.deep_merge(property => { format: })
+          end
+        end
+
+        def rhino_properties_readable_name(readable_names)
+          readable_names.each do |property, readable_name|
+            self._properties_overrides = self._properties_overrides.deep_merge(property => { "x-rhino-attribute": { readableName: readable_name } })
+          end
+        end
+
+        def rhino_properties_array(options)
+          self._properties_array = options
+        end
+
+        def identifier_property
+          raise NotImplementedError, '#identifier_property is not implemented'
+        end
+
+        def readable_properties
+          raise NotImplementedError, '#readable_properties is not implemented'
+        end
+
+        def creatable_properties
+          raise NotImplementedError, '#creatable_properties is not implemented'
+        end
+
+        def updatable_properties
+          raise NotImplementedError, '#updatable_properties is not implemented'
+        end
+
+        # Return list of read properties for the resource (show and index)
+        def read_properties
+          # If :only was not set explicitly, select only the default includables
+          # and extended models, leaving out the excepted models
+          unless self._read_properties
+            # If only was set, use that
+            return self._read_properties_only if self._read_properties_only
+
+            self._read_properties = readable_properties.select do |property|
+              # And its not excepted
+              self._read_properties_except.exclude?(property)
+            end
+          end
+
+          self._read_properties
+        end
+
+        # Check if read property exists
+        def read_property?(property)
+          read_properties.include?(property)
+        end
+
+        # Return list of create properties for the resource
+        def create_properties
+          unless self._create_properties
+            # If create only was set, use that
+            return self._create_properties_only if self._create_properties_only
+
+            self._create_properties = creatable_properties.select do |property|
+              self._create_properties_except.exclude?(property)
+            end
+          end
+
+          self._create_properties
+        end
+
+        # Check if create property exists
+        def create_property?(property)
+          create_properties.include?(property)
+        end
+
+        # Return list of update properties for the resource
+        def update_properties
+          unless self._update_properties
+            # If update only was set, use that
+            return self._update_properties_only if self._update_properties_only
+
+            self._update_properties = updatable_properties.select do |property|
+              self._update_properties_except.exclude?(property)
+            end
+          end
+
+          self._update_properties
+        end
+
+        # Check if update property exists
+        def update_property?(property)
+          update_properties.include?(property)
+        end
+
+        def all_properties
+          self._all_properties = (read_properties + create_properties + update_properties).uniq.map(&:to_s) unless self._all_properties
+
+          self._all_properties
+        end
+
+        # Check if property exists
+        def property?(property)
+          all_properties.include?(property)
+        end
+
+        def describe_property(property)
+          raise NotImplementedError, "#describe_property is not implemented for #{property}"
+        end
+      end
+      # rubocop:enable Style/RedundantSelf
+    end
+  end
+end

data/lib/rhino/resource/reference.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module Reference
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_references, default: []
+
+        delegate :references, to: :class
+
+        def references_for_serialization
+          raise NotImplementedError, '#references_for_serialization is not implemented'
+        end
+      end
+
+      class_methods do
+        def rhino_references(references)
+          self._references = references
+        end
+
+        def references
+          self._references # rubocop:disable Style/RedundantSelf
+        end
+      end
+    end
+  end
+end

data/lib/rhino/resource/routing.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module Routing
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_route_key, default: nil
+        class_attribute :_route_path, default: nil
+        class_attribute :_route_singular, default: false
+
+        class_attribute :_rhino_routes, default: nil
+        class_attribute :_rhino_routes_except, default: []
+
+        class_attribute :controller_name, default: 'rhino/crud'
+
+        delegate :routes, to: :class
+      end
+
+      # rubocop:disable Style/RedundantSelf, Metrics/BlockLength
+      class_methods do
+        def route_key
+          self._route_key ||= if route_singular?
+            name.demodulize.underscore
+          else
+            name.demodulize.underscore.pluralize
+          end
+        end
+
+        def route_path
+          self._route_path ||= route_key
+        end
+
+        def route_singular?
+          self._route_singular
+        end
+
+        def route_path_frontend
+          route_path.camelize(:lower)
+        end
+
+        def route_frontend
+          "/#{route_path_frontend}"
+        end
+
+        def route_api
+          "/#{Rhino.namespace}/#{route_path}"
+        end
+
+        def routes
+          unless self._rhino_routes
+            if global_owner? # rubocop:disable Style/ConditionalAssignment
+              self._rhino_routes = %i[index show]
+            else
+              self._rhino_routes = %i[index create show update destroy]
+            end
+          end
+          self._rhino_routes - self._rhino_routes_except
+        end
+
+        def rhino_routing(**options)
+          self._route_key = options.delete(:key) if options.key?(:key)
+          self._route_path = options.delete(:path) if options.key?(:path)
+          self._route_singular = options.delete(:singular) if options.key?(:singular)
+
+          self._rhino_routes = options.delete(:only) if options.key?(:only)
+          self._rhino_routes_except = options.delete(:except) if options.key?(:except)
+        end
+
+        def rhino_controller(controller)
+          self.controller_name = "rhino/#{controller}"
+        end
+      end
+      # rubocop:enable Style/RedundantSelf, Metrics/BlockLength
+    end
+
+    def route_frontend # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      base_owner_pk = "#{Rhino.base_owner.table_name}.#{Rhino.base_owner.primary_key}"
+
+      joins = joins_for_base_owner
+      base_owner_id = if joins.empty?
+        # if this is Model is the base owner, we don't to include it in frontend url
+        nil
+      else
+        base_owner_ids = self.class.joins(joins).where(id:).pluck(base_owner_pk)
+        if base_owner_ids.length == 1
+          base_owner_ids.first
+        else
+          # if this Model doesn't have a clear single path to the base owner Model,
+          # we shouldn't include it in the frontend url
+          nil
+        end
+      end
+
+      if base_owner_id.nil?
+        "#{self.class.route_frontend}/#{id}"
+      else
+        "/#{base_owner_id}#{self.class.route_frontend}/#{id}"
+      end
+    end
+
+    def route_api
+      "#{self.class.route_api}/#{id}"
+    end
+  end
+end

data/lib/rhino/resource/serialization.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module Serialization
+      extend ActiveSupport::Concern
+
+      def to_caching_json
+        raise NotImplementedError, '#to_caching_json is not implemented'
+      end
+    end
+  end
+end

data/lib/rhino/resource/sieves.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module Sieves
+      extend ActiveSupport::Concern
+      include ArelHelpers::ArelTable
+
+      included do
+        class_attribute :_sieves
+        class_attribute :_built_sieves
+
+        delegate :sieves, to: :class
+      end
+
+      # rubocop:disable Style/RedundantSelf
+      class_methods do
+        def rhino_sieves
+          self._sieves = Rhino.sieves.dup unless self._sieves
+          self._sieves
+        end
+
+        def sieves
+          self._built_sieves = rhino_sieves.build(self) unless self._built_sieves
+
+          self._built_sieves
+        end
+
+        def resolve(scope, _params)
+          scope
+        end
+      end
+      # rubocop:enable Style/RedundantSelf
+    end
+  end
+end

data/lib/rhino/resource.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative 'resource/owner'
+require_relative 'resource/properties'
+require_relative 'resource/reference'
+require_relative 'resource/describe'
+require_relative 'resource/routing'
+require_relative 'resource/params'
+require_relative 'resource/serialization'
+require_relative 'resource/sieves'
+
+require_relative '../../app/policies/rhino/crud_policy'
+
+module Rhino
+  module Resource
+    extend ActiveSupport::Concern
+
+    include Rhino::Resource::Owner
+    include Rhino::Resource::Properties
+    include Rhino::Resource::Reference
+    include Rhino::Resource::Describe
+    include Rhino::Resource::Routing
+    include Rhino::Resource::Params
+    include Rhino::Resource::Serialization
+    include Rhino::Resource::Sieves
+
+    included do
+      class_attribute :_policy_class, default: Rhino::CrudPolicy
+
+      def owner
+        send self.class.resource_owned_by
+      end
+
+      def display_name
+        return name if respond_to? :name
+        return title if respond_to? :title
+
+        nil
+      end
+    end
+
+    class_methods do
+      def policy_class
+        _policy_class
+      end
+
+      def rhino_policy(policy)
+        # Look for local policy first, then look in the rhino namespace
+        self._policy_class = "#{policy}_policy".classify.safe_constantize || "rhino/#{policy}_policy".classify.safe_constantize
+
+        raise "Policy #{policy} not found for #{name}" unless _policy_class
+      end
+    end
+  end
+end