rhino_project_core 0.20.0.alpha.0

data/lib/rhino/resource/active_record_extension/properties.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "properties_describe"
+
+module Rhino
+  module Resource
+    module ActiveRecordExtension
+      module Properties
+        extend ActiveSupport::Concern
+
+        include Rhino::Resource::ActiveRecordExtension::PropertiesDescribe
+
+        class_methods do # rubocop:disable Metrics/BlockLength
+          def identifier_property
+            primary_key
+          end
+
+          def readable_properties
+            props = attribute_names - foreign_key_properties
+
+            props.concat(reference_properties)
+
+            props.map(&:to_s)
+          end
+
+          def creatable_properties
+            writeable_properties
+          end
+
+          def updatable_properties
+            # https://api.rubyonrails.org/classes/ActiveRecord/ReadonlyAttributes/ClassMethods.html#method-i-readonly_attributes
+            writeable_properties - readonly_attributes.to_a
+          end
+
+          private
+            # FIXME: Duplicated in params.rb
+            def reference_to_sym(reference)
+              reference.is_a?(Hash) ? reference.keys.first : reference
+            end
+
+            # FIXME: Include counter caches as well
+            def automatic_properties
+              [identifier_property] + send(:all_timestamp_attributes_in_model)
+            end
+
+            def virtual_properties
+              columns.select(&:virtual?).map(&:name) # rubocop:todo Performance/SelectMap
+            end
+
+            def foreign_key_properties
+              reflect_on_all_associations(:belongs_to).map(&:foreign_key).map(&:to_s)
+            end
+
+            # rubocop:todo Style/OptionalBooleanParameter
+            def reference_properties(read = true)
+              references.filter_map do |r|
+                sym = reference_to_sym(r)
+
+                # All references are readable
+                next sym if read
+
+                # Writeable if a one type or accepting nested
+                association = reflect_on_association(sym)
+                # rubocop:todo Performance/CollectionLiteralInLoop, Layout/LineLength
+                if %i[has_one belongs_to].include?(association.macro) || nested_attributes_options.key?(sym) || association.class_name == "ActiveStorage::Attachment"
+                  sym
+                end
+                # rubocop:enable Performance/CollectionLiteralInLoop, Layout/LineLength
+              end
+            end
+            # rubocop:enable Style/OptionalBooleanParameter
+
+            def writeable_properties
+              # Direct properties for this model
+              props = attribute_names - automatic_properties - virtual_properties - foreign_key_properties
+
+              props.concat(reference_properties(false))
+
+              props.map(&:to_s)
+            end
+        end
+      end
+    end
+  end
+end

data/lib/rhino/resource/active_record_extension/properties_describe.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require "js_regex"
+
+module Rhino
+  module Resource
+    module ActiveRecordExtension
+      module PropertiesDescribe # rubocop:disable Metrics/ModuleLength
+        extend ActiveSupport::Concern
+
+        class_methods do # rubocop:disable Metrics/BlockLength
+          def describe_property(property) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+            name = property_name(property).to_s
+            raise StandardError, "#{name} is not a valid property" unless property?(name)
+
+            {
+              "x-rhino-attribute": {
+                name:,
+                readableName: name.titleize,
+                readable: read_properties.include?(property),
+                creatable: create_properties.include?(property),
+                updatable: update_properties.include?(property)
+              },
+              readOnly: property_read_only?(name),
+              writeOnly: property_write_only?(name),
+              nullable: property_nullable?(name),
+              default: property_default(name)
+            }
+              .merge(property_type_and_format(property))
+              .merge(property_validations(property))
+              .deep_merge(property_overrides(property))
+              .compact
+          end
+
+          private
+          # FIXME: It can be a hash if passed in from a reference which might have something like
+          # rhino_references %i[{blog_posts: [:comments]}]
+          # but I cannot find current spot where it is used like that currently
+          def property_name(property)
+            property.is_a?(Hash) ? property.keys.first : property
+          end
+
+          def ref_descriptor(names)
+            {
+              type: :reference,
+              anyOf: names.map { |name| { :$ref => "#/components/schemas/#{name.singularize}" } }
+            }
+          end
+
+          def property_type_and_format_attr(name) # rubocop:todo Metrics/MethodLength
+            atype = attribute_types[name.to_s].type
+
+            # The PG array delegates type to "subtype" which is the actual type of the array elements
+            if attribute_types[name.to_s].is_a? ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array
+              return {
+                type: :array,
+                items: {
+                  type: atype
+                }
+              }
+            end
+
+            if %i[datetime date time].include?(atype)
+              return {
+                type: 'string',
+                format: atype
+              }
+            end
+
+            { type: atype }
+          end
+
+          def nested_array_options(name)
+            ref_sym = name.to_sym
+
+            array_options = {}
+
+            if nested_attributes_options[ref_sym]
+              array_options[:creatable] = true
+              array_options[:updatable] = true
+              array_options[:destroyable] = nested_attributes_options[ref_sym][:allow_destroy]
+            end
+
+            { "x-rhino-attribute-array": array_options.merge(_properties_array[ref_sym] || {}) }
+          end
+
+          # rubocop:todo Metrics/PerceivedComplexity
+          # rubocop:todo Metrics/AbcSize
+          def property_type_and_format_ref(name) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+            assoc = reflections[name]
+            klasses = if assoc.options[:polymorphic]
+             assoc.active_record.send("#{assoc.name}_types").map(&:constantize).map { |m| m.model_name.singular }
+            else
+              # FIXME: The tr hack is to match how model_name in rails handles modularized classes
+              [assoc.options[:class_name]&.underscore&.tr('/', '_') || name]
+            end
+
+            return ref_descriptor(klasses) unless reflections[name].macro == :has_many
+
+            {
+              type: :array,
+              items: ref_descriptor(klasses).merge(nested_array_options(name))
+            }
+          end
+          # rubocop:enable Metrics/AbcSize
+          # rubocop:enable Metrics/PerceivedComplexity
+
+          def property_type_and_format(name) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+            # Special cases
+            return { type: :identifier } if name == identifier_property
+            return { type: :string } if defined_enums.key?(name)
+
+            # FIXME: Hack for tags for now
+            if attribute_types.key?(name.to_s) && attribute_types[name.to_s].class.to_s == 'ActsAsTaggableOn::Taggable::TagListType'
+              return {
+                type: :array,
+                items: {
+                  type: 'string'
+                }
+              }
+            end
+
+            # Use the attribute type if possible
+            return property_type_and_format_attr(name) if attribute_types.key?(name.to_s)
+
+            return property_type_and_format_ref(name) if reflections.key?(name)
+
+            # FIXME: There may be no way to reach this
+            # raise UnknownpropertyType
+            { type: :unknown }
+          end
+
+          def property_overrides(property)
+            return {} unless _properties_overrides.key?(property)
+
+            _properties_overrides[property].deep_symbolize_keys
+          end
+
+          def property_validations(property) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+            constraint_hash = {}
+
+            # https://swagger.io/specification/
+
+            validators_on(property).each do |v|
+              if v.is_a? ActiveModel::Validations::NumericalityValidator
+                if v.options.key?(:greater_than)
+                  constraint_hash[:minimum] = v.options[:greater_than]
+                  constraint_hash[:exclusiveMinimum] = true
+                end
+
+                if v.options.key?(:less_than)
+                  constraint_hash[:maximum] = v.options[:less_than]
+                  constraint_hash[:exclusiveMaximum] = true
+                end
+
+                constraint_hash[:minimum] = v.options[:greater_than_or_equal_to] if v.options.key?(:greater_than_or_equal_to)
+                constraint_hash[:maximum] = v.options[:less_than_or_equal_to] if v.options.key?(:less_than_or_equal_to)
+
+                if v.options.key?(:in)
+                  constraint_hash[:minimum] = v.options[:in].min
+                  constraint_hash[:maximum] = v.options[:in].max
+                end
+              end
+
+              if v.is_a? ::ActiveRecord::Validations::LengthValidator
+                constraint_hash[:minLength] = v.options[:minimum] || v.options[:is]
+                constraint_hash[:maxLength] = v.options[:maximum] || v.options[:is]
+              end
+
+              constraint_hash[:pattern] = JsRegex.new(v.options[:with]).source if v.is_a? ::ActiveModel::Validations::FormatValidator
+
+              constraint_hash[:enum] = v.options[:in] if v.is_a? ActiveModel::Validations::InclusionValidator
+            end
+
+            constraint_hash[:enum] = defined_enums[property].keys if defined_enums.key?(property)
+
+            constraint_hash.compact
+          end
+
+          # If there is a presence validator in the model it is not nullable.
+          # if there is no optional: true on an association, rails will add a
+          # presence validator automatically
+          # Otherwise check the db for the actual column or foreign key setting
+          # Return nil instead of false for compaction
+          def property_nullable?(name) # rubocop:todo Metrics/AbcSize
+            # Check for any presence validator
+            return false if validators_on(name).any?(::ActiveRecord::Validations::PresenceValidator)
+
+            # https://guides.rubyonrails.org/active_record_validations.html#numericality
+            # By default, numericality doesn't allow nil values. You can use allow_nil: true option to permit it.
+            validators_on(name).select { |v| v.is_a? ::ActiveRecord::Validations::NumericalityValidator }.each do |v|
+              return false unless v.options[:allow_nil]
+            end
+
+            name = reflections[name].foreign_key if reflections.key?(name)
+
+            # Check the column null setting
+            return columns_hash[name].null if columns_hash.key?(name)
+
+            true
+          end
+
+          # Return nil instead of false for compaction
+          def property_read_only?(name)
+            return unless read_properties.include?(name) && (create_properties.exclude?(name) && update_properties.exclude?(name))
+
+            true
+          end
+
+          # Return nil instead of false for compaction
+          def property_write_only?(name)
+            return unless (create_properties.include?(name) || update_properties.include?(name)) && read_properties.exclude?(name)
+
+            true
+          end
+
+          def property_default(name)
+            # FIXME: This will not handle datetime fields
+            # https://github.com/rails/rails/issues/27077 sets the default in the db
+            # but Blog.new does not set the default value like other attributes
+            # https://nubinary.atlassian.net/browse/NUB-298
+            _default_attributes[name].type_cast(_default_attributes[name].value_before_type_cast)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rhino/resource/active_record_extension/reference.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module ActiveRecordExtension
+      module Reference
+        extend ActiveSupport::Concern
+
+        included do
+          scope :eager_load_refs, -> { includes(klass.references) } if defined?(scope)
+
+          def references_for_serialization
+            serialize_references(references)
+          end
+
+          private
+          # FIXME: Duplicated in params.rb
+          def reference_to_sym(reference)
+            reference.is_a?(Hash) ? reference.keys.first : reference
+          end
+
+          # FIXME: Duplicated in params.rb
+          def reference_from_sym(sym)
+            ref = try(sym)
+            return unless ref
+
+            # This is mostly how serializable_hash does it
+            # Get the first object
+            return ref.first if ref.respond_to?(:to_ary)
+
+            ref
+          end
+
+          def serialize_references(references)
+            hash = {}
+            references.each do |ref_item|
+              sym = reference_to_sym(ref_item)
+
+              hash[sym] = {}
+              hash[sym][:methods] = :display_name
+              hash[sym][:include] = serialize_references(ref_item[sym]) if ref_item.is_a?(Hash)
+            end.flatten.compact
+
+            hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rhino/resource/active_record_extension/routing.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module ActiveRecordExtension
+      module Routing
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def route_key
+            if route_singular?
+              model_name.singular_route_key
+            else
+              model_name.route_key
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rhino/resource/active_record_extension/search.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module ActiveRecordExtension
+      module Search
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def rhino_search(fields, associated_fields = {})
+            include PgSearch::Model
+            # stores the searchable fields so it is possible to retrieve them
+            # in the open API model description
+            @rhino_is_searchable = fields.present? || associated_fields.present?
+            # FIXME: We can't autodiscover text fields because it causes a very
+            # slow reload in the development server with bigger apps
+            pg_search_scope :search_text_fields, against: fields, associated_against: associated_fields, using: { tsearch: { prefix: true } }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rhino/resource/active_record_extension/serialization.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module ActiveRecordExtension
+      module Serialization
+        extend ActiveSupport::Concern
+
+        def to_caching_json
+          serializable_hash(methods: :display_name, include: references_for_serialization)
+          # JSON.generate(hash)
+        end
+      end
+    end
+  end
+end

data/lib/rhino/resource/active_record_extension/super_admin.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module ActiveRecordExtension
+      module SuperAdmin
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def ransackable_attributes(_auth_object = nil)
+            authorizable_ransackable_attributes & read_properties
+          end
+
+          def ransackable_associations(_auth_object = nil)
+            authorizable_ransackable_associations & references.map(&:to_s)
+          end
+
+          def ransackable_filters(auth_object = nil)
+            ransackable_attributes(auth_object) + ransackable_associations
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rhino/resource/active_record_extension.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../resource'
+require_relative 'active_record_extension/properties'
+require_relative 'active_record_extension/reference'
+require_relative 'active_record_extension/describe'
+require_relative 'active_record_extension/routing'
+require_relative 'active_record_extension/params'
+require_relative 'active_record_extension/serialization'
+require_relative 'active_record_extension/search'
+require_relative 'active_record_extension/super_admin'
+
+module Rhino
+  module Resource
+    module ActiveRecordExtension
+      extend ActiveSupport::Concern
+
+      # Base
+      include Rhino::Resource
+
+      # Active Record implementations
+      include Rhino::Resource::ActiveRecordExtension::Properties
+      include Rhino::Resource::ActiveRecordExtension::Reference
+      include Rhino::Resource::ActiveRecordExtension::Describe
+      include Rhino::Resource::ActiveRecordExtension::Routing
+      include Rhino::Resource::ActiveRecordExtension::Params
+      include Rhino::Resource::ActiveRecordExtension::Serialization
+      include Rhino::Resource::ActiveRecordExtension::Search
+      include Rhino::Resource::ActiveRecordExtension::SuperAdmin
+    end
+  end
+end

data/lib/rhino/resource/active_record_tree.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module ActiveRecordTree
+      extend ActiveSupport::Concern
+
+      # Base
+      include Rhino::Resource::ActiveRecordExtension unless Rhino.auto_include_active_record
+
+      included do
+        has_ancestry
+      end
+
+      class_methods do
+        def readable_properties
+          super + ["children"]
+        end
+
+        def describe_property(property)
+          return super unless property == "children"
+
+          super.deep_merge({ type: :array, items: ref_descriptor([model_name.element]) })
+        end
+
+        # FIXME: Need to recurse to a MAX DEPTH
+        def readable_params(type, refs = references)
+          # Remove the base children property and replace with hash
+          base_show = super - ["children"]
+          base_show + [children: [base_show]]
+        end
+
+        # FIXME: Need writeable params override
+      end
+
+      def serializable_hash(options = nil)
+        super(options).merge(children: arrange_serializable_with_options(options))
+      end
+
+      private
+        # We do this to carry things like methods all the way through the
+        # serialization
+        def arrange_serializable_with_options(options = nil)
+          children.arrange_serializable do |parent, _children|
+            parent.serializable_hash(options)
+          end
+        end
+    end
+  end
+end

data/lib/rhino/resource/active_storage_extension.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module ActiveStorageExtension
+      extend ActiveSupport::Concern
+
+      # Base
+      include Rhino::Resource::ActiveRecordExtension unless Rhino.auto_include_active_record
+
+      included do
+        attribute :url
+        attribute :url_attachment
+
+        rhino_policy :active_storage_attachment
+
+        def url
+          Rails.application.routes.url_helpers.rails_blob_url(self, only_path: false)
+        end
+
+        def url_attachment
+          Rails.application.routes.url_helpers.rails_blob_url(self, only_path: false, disposition: :attachment)
+        end
+
+        def display_name
+          filename.to_s
+        end
+      end
+
+      class_methods do
+        def readable_properties
+          super + ["signed_id"]
+        end
+      end
+
+      def serializable_hash(options = nil)
+        super(options).merge("signed_id" => signed_id)
+      end
+    end
+  end
+end

data/lib/rhino/resource/describe.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module Describe
+      extend ActiveSupport::Concern
+
+      included do
+        delegate :describe, to: :class
+      end
+
+      class_methods do
+        def describe
+          raise NotImplementedError, '#describe is not implemented'
+        end
+      end
+    end
+  end
+end