rhino_project_core 0.20.0.beta.18

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

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