rhino_project_core 0.20.0.alpha.0

data/lib/rhino/resource/active_model_extension/params.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module ActiveModelExtension
+      module Params
+        extend ActiveSupport::Concern
+
+        class_methods do # rubocop:todo Metrics/BlockLength
+          def create_params
+            writeable_params("create")
+          end
+
+          def show_params
+            readable_params("show")
+          end
+
+          def update_params
+            writeable_params("update")
+          end
+
+          protected
+            def props_by_type(type)
+              # FIXME: Direct attributes for this model we want a copy, not to
+              # alter the class_attribute itself
+              send("#{type}_properties").dup
+            end
+
+            # FIXME: Refs are not handled
+            def readable_params(_type, _refs = references)
+              params = []
+              props_by_type("read").each do |prop|
+                desc = describe_property(prop)
+
+                # Generic array of scalars
+                next params << { prop => [] } if desc[:type] == :array
+
+                # Otherwise prop and param are equivalent
+                params << prop
+              end
+
+              # Display name is always allowed
+              params << "display_name"
+            end
+
+            # FIXME: Refs are not handled
+            def writeable_params(type, _refs = references)
+              params = []
+
+              props_by_type(type).each do |prop|
+                desc = describe_property(prop)
+
+                # Generic array of scalars
+                next params << { prop => [] } if desc[:type] == :array
+
+                # Otherwise prop and param are equivalent
+                # We also accept the ref name as the foreign key if its a singular resource
+                params << prop
+              end
+
+              # Allow id in if its an update so we can find the original record
+              params << identifier_property if type == "update"
+
+              params
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require "js_regex"
+
+module Rhino
+  module Resource
+    module ActiveModelExtension
+      module Properties # rubocop:disable Metrics/ModuleLength
+        extend ActiveSupport::Concern
+
+        class_methods do # rubocop:disable Metrics/BlockLength
+          def identifier_property
+            "id"
+          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
+            writeable_properties
+          end
+
+          def describe_property(property) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+            name = property_name(property).to_s
+            {
+              "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(property))
+              .merge(property_validations(property))
+              .compact
+          end
+
+          private
+            # FIXME: Duplicated in params.rb
+            def reference_to_sym(reference)
+              reference.is_a?(Hash) ? reference.keys.first : reference
+            end
+
+            def automatic_properties
+              [identifier_property]
+            end
+
+            def foreign_key_properties
+              # reflect_on_all_associations(:belongs_to).map(&:foreign_key).map(&:to_s)
+              []
+            end
+
+            def reference_properties(read = true) # rubocop:todo Style/OptionalBooleanParameter
+              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
+                sym if %i[has_one belongs_to].include?(association.macro) || nested_attributes_options.key?(sym)
+                # rubocop:enable Performance/CollectionLiteralInLoop
+              end
+            end
+
+            def writeable_properties
+              # Direct properties for this model
+              props = attribute_names - automatic_properties - foreign_key_properties
+
+              props.concat(reference_properties(false))
+
+              props.map(&:to_s)
+            end
+
+            def property_name(property)
+              property.is_a?(Hash) ? property.keys.first : property
+            end
+
+            def ref_descriptor(name)
+              {
+                type: :reference,
+                anyOf: [
+                  { :$ref => "#/components/schemas/#{name.singularize}" }
+                ]
+              }
+            end
+
+            def property_type_raw(property)
+              name = property_name(property)
+              return :identifier if name == identifier_property
+
+              # return :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 attribute_types[name.to_s].type if attribute_types.key?(name.to_s)
+
+              # if reflections.key?(name)
+              #   # FIXME: The tr hack is to match how model_name in rails handles modularized classes
+              #   class_name = reflections[name].options[:class_name]&.underscore&.tr('/', '_') || name
+              #   return ref_descriptor(class_name) unless reflections[name].macro == :has_many
+              #
+              #   return {
+              #     type: :array,
+              #     items: ref_descriptor(class_name)
+              #   }
+              # end
+
+              # raise UnknownpropertyType
+              "unknown"
+            end
+
+            def property_type(property)
+              pt = property_type_raw(property)
+
+              return pt if pt.is_a? Hash
+
+              { type: property_type_raw(property) }
+            end
+
+            # rubocop:todo Metrics/PerceivedComplexity
+            def property_validations(property) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
+              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? ::ActiveModel::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.compact
+            end
+            # rubocop:enable Metrics/PerceivedComplexity
+
+            # 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)
+              # Check for presence validator
+              if validators.select { |v| v.is_a? ::ActiveModel::Validations::PresenceValidator }.flat_map(&:attributes).include?(name.to_sym)
+                return false
+              end
+
+              # 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? ::ActiveModel::Validations::NumericalityValidator }.each do |v|
+                return false unless v.options[:allow_nil]
+              end
+
+              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_model_extension/reference.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module ActiveModelExtension
+      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_model_extension/routing.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module ActiveModelExtension
+      module Routing
+        extend ActiveSupport::Concern
+
+        class_methods do
+          delegate :route_key, to: :model_name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module ActiveModelExtension
+      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_model_extension.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../resource"
+require_relative "active_model_extension/properties"
+require_relative "active_model_extension/reference"
+require_relative "active_model_extension/describe"
+require_relative "active_model_extension/routing"
+require_relative "active_model_extension/params"
+require_relative "active_model_extension/serialization"
+require_relative "active_model_extension/backing_store"
+
+module Rhino
+  module Resource
+    module ActiveModelExtension
+      extend ActiveSupport::Concern
+
+      # The minimum needed to make this work
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+      include ActiveModel::Serializers::JSON
+
+      # Base
+      include Rhino::Resource
+
+      # Active Model implementations
+      include Rhino::Resource::ActiveModelExtension::Properties
+      include Rhino::Resource::ActiveModelExtension::Reference
+      include Rhino::Resource::ActiveModelExtension::Describe
+      include Rhino::Resource::ActiveModelExtension::Routing
+      include Rhino::Resource::ActiveModelExtension::Params
+      include Rhino::Resource::ActiveModelExtension::Serialization
+
+      included do
+        rhino_controller :active_model_extension
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module ActiveRecordExtension
+      module Describe
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def describe # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+            properties = all_properties.index_with { |p| describe_property(p) }
+
+            required = properties.reject { |_p, d| d[:nullable] || d[:readOnly] }.keys
+            # required: [] is not valid and will be compacted away
+            required = nil unless required.present?
+
+            {
+              "x-rhino-model": {
+                model: model_name.singular,
+                modelPlural: model_name.collection,
+                name: model_name.name.camelize(:lower),
+                pluralName: model_name.name.camelize(:lower).pluralize,
+                readableName: model_name.human,
+                pluralReadableName: model_name.human.pluralize,
+                ownedBy: resource_owned_by,
+                singular: route_singular?,
+                path: route_api,
+                searchable: searchable?
+              },
+              type: :object,
+              properties:,
+              required:
+            }.compact
+          end
+
+          # returns true if the model's rhino_search is set with at least one field
+          def searchable?
+            @rhino_is_searchable == true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module ActiveRecordExtension
+      module Params # rubocop:todo Metrics/ModuleLength
+        extend ActiveSupport::Concern
+
+        class_methods do # rubocop:todo Metrics/BlockLength
+          def create_params
+            writeable_params("create")
+          end
+
+          def show_params
+            readable_params("show")
+          end
+
+          def update_params
+            writeable_params("update")
+          end
+
+          def transform_params(params)
+            transform_params_recursive(params)
+          end
+
+          protected
+            def reference_to_sym(reference)
+              reference.is_a?(Hash) ? reference.keys.first : reference
+            end
+
+            def assoc_from_sym(sym, base = self)
+              assoc = base.reflect_on_association(sym)
+
+              # Delegate types support bolstered by rhino/rhino/app/overrides/active_record/delegated_type_override.rb
+              return assoc.active_record.send("#{assoc.name}_types").map(&:constantize) if assoc.options[:polymorphic]
+
+              [assoc.klass]
+            end
+
+            def props_by_type(type)
+              # FIXME: Direct attributes for this model we want a copy, not to
+              # alter the class_attribute itself
+              send("#{type}_properties").dup
+            end
+
+            def readable_params(type, refs = references) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+              params = []
+
+              refs_index = refs.index_by { |r| reference_to_sym(r) }
+
+              props_by_type("read").each do |prop|
+                desc = describe_property(prop)
+                prop_sym = prop.to_sym
+
+                # If its a reference or an array of references
+                # FIXME: anyOf is a hack for now
+                if desc[:type] == :reference || (desc[:type] == :array && (desc[:items].key?(:$ref) || desc[:items].key?(:anyOf)))
+                  next unless refs_index.key?(prop_sym)
+
+                  next_refs = refs_index[prop_sym].is_a?(Hash) ? refs_index[prop_sym][prop_sym] : []
+                  klasses = assoc_from_sym(prop_sym)
+
+                  assoc_params = klasses.map { |klass| klass.send(:readable_params, type, next_refs) }
+
+                  next params << { prop.to_s => assoc_params.flatten.uniq }
+                end
+
+                # JSON columns need special handling - allow all the nested params
+                next params << { prop => {} } if desc[:type].in?(%i[json jsonb])
+
+                # Generic array of scalars
+                next params << { prop => [] } if desc[:type] == :array
+
+                # Otherwise prop and param are equivalent
+                params << prop
+              end
+
+              # Display name is always allowed
+              params << "display_name"
+            end
+
+            def writeable_params(type, _refs = references) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+              params = []
+
+              props_by_type(type).each do |prop| # rubocop:disable Metrics/BlockLength
+                desc = describe_property(prop)
+                prop_sym = prop.to_sym
+
+                # An array of references
+                if desc[:type] == :array && (desc[:items].key?(:$ref) || desc[:items].key?(:anyOf))
+                  # FIXME: Hack for has_many_attached
+                  next params << { prop => [] } if desc.dig(:items, :anyOf)[0]&.dig(:$ref) == "#/components/schemas/active_storage_attachment"
+
+                  # We only accept if the active record accepts it
+                  next unless nested_attributes_options.key?(prop_sym) || desc.dig(:items, :anyOf)[0]&.dig(:$ref)
+
+                  assoc = assoc_from_sym(prop_sym).first
+
+                  # This does not handle nested for a polymorphic model, but neither does rails
+                  # FIXME: Do we need to handle :update_only option?
+                  # FIXME: If a nested resource attribute is create only, the backend will allow it to be
+                  # updated because create/update are merged together - the frontedn UI shows the right
+                  # thing though NUB-844
+                  assoc_params = []
+
+                  array_attributes = desc[:items][:"x-rhino-attribute-array"]
+
+                  if array_attributes[:updatable]
+                    # If the attribute is updatable, we need to accept the id param
+                    assoc_params << assoc.identifier_property
+
+                    # If the attribute is updatable, we need to accept its updatable params
+                    assoc_params << assoc.send(:writeable_params, "update")
+                  end
+
+                  # If the attribute is creatable, we need to accept its creatable params
+                  assoc_params << assoc.send(:writeable_params, "create") if array_attributes[:creatable]
+
+                  # If its destroyable, accept the _destroy param
+                  assoc_params << "_destroy" if nested_attributes_options[prop_sym][:allow_destroy]
+
+                  next params << { prop => assoc_params.flatten.uniq }
+                end
+
+                # JSON columns need special handling - allow all the nested params
+                next params << { prop => {} } if desc[:type].in?(%i[json jsonb])
+
+                # Generic array of scalars
+                next params << { prop => [] } if desc[:type] == :array
+
+                # Accept { blog_post: { :id }} as well as { blog_post: 3 } below
+                if desc[:type] == :reference
+                  klasses = assoc_from_sym(prop_sym)
+
+                  params << if nested_attributes_options.key?(prop_sym)
+                    assoc_params = klasses.map(&:identifier_property)
+                    assoc_params << klasses.map { |klass| klass.send(:writeable_params, "update") }
+
+                    { prop => assoc_params.flatten.uniq }
+                  else
+                    { prop => klasses.map(&:identifier_property).uniq }
+                  end
+                end
+
+                # Otherwise prop and param are equivalent
+                # We also accept the ref name as the foreign key if its a singular resource
+                params << prop
+              end
+
+              params
+            end
+
+            # Rebuild the params
+            # rubocop:todo Metrics/CyclomaticComplexity
+            def transform_params_recursive(params, parent = self) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity
+              hash = {}
+              params.each do |param_key, param_value|
+                association = parent.reflect_on_association(param_key)
+
+                # Its a regular attribute
+                next hash[param_key] = param_value unless association
+
+                # FIXME
+                # Hack to rewrite for attachment/attachments and guard against object resubmission
+                if param_key.end_with?("_attachment")
+                  hash[param_key.remove("_attachment")] = param_value if param_value.is_a?(String) || param_value.nil?
+
+                  next
+                end
+                if param_key.end_with?("_attachments")
+                  hash[param_key.remove("_attachments")] = param_value if param_value.is_a?(Array) || param_value.nil?
+
+                  next
+                end
+
+                # Transform the nested attributes as well
+                # Nested need _attributes - we don't want the client to have to do that
+                if parent.nested_attributes_options.key?(param_key.to_sym)
+                  attr_key = "#{param_key}_attributes"
+
+                  # has_many nested should be an array
+                  if association.macro == :has_many
+                    next hash[attr_key] = param_value.map { |pv| parent.transform_params_recursive(pv, association.klass) }
+                  end
+
+                  # has_one/belongs_to is just the values
+                  # if its a cardinal though, such as blog: 1 instead of blog: {name : 'my blog' }
+                  # fallback to transforming to the foreign key
+                  if param_value.is_a?(ActionController::Parameters)
+                    klasses = assoc_from_sym(param_key, parent)
+
+                    next hash[attr_key] = klasses.map { |klass| parent.transform_params_recursive(param_value, klass) }.reduce(:merge)
+                  end
+                end
+
+                # Map association name to foreign key, ie blog => blog_id
+                # or blog: { id: } => blog_id
+                if param_value.is_a?(ActionController::Parameters)
+                  next hash[association.foreign_key] = param_value[association.klass.identifier_property]
+                end
+
+                hash[association.foreign_key] = param_value
+              end
+
+              # Force permit since we should have already been permitted at this point
+              ActionController::Parameters.new(hash).permit!
+            end
+          # rubocop:enable Metrics/CyclomaticComplexity
+        end
+      end
+    end
+  end
+end