forest_admin_agent 1.0.0.pre.beta.26 → 1.0.0.pre.beta.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20188623cbbdcb4d7ce701bfda5d0c4f841d547bf6fe38612f4276182eaa437a
-  data.tar.gz: 73f8b529249cc8be259e628f1c8e75721b59c2fb645cc544246c19130ecd1106
+  metadata.gz: e2ae114be4b54df0354aca036cdc18ca08ab1c78b72d6975b3002179cea93a18
+  data.tar.gz: fd369183191175beb32c586bd98f2c67ccd21a7438e5b41741c0a5f0667985ce
 SHA512:
-  metadata.gz: 3d5a14eb9fa6b8d8af91a7ad6efb33927d5773b762ff82fb73574a858a7d46c252aaad3cc19a2ba026dc1ed65ec0548ba360b90b4fb7baf357a588a66fe442d1
-  data.tar.gz: 4822e1f4b72633515287e9a5637d4a42914ae233f5baca6f912ffaa90d15db0141c6dc783dd141f23cc3fccebca79552d95a0c3ee829b469ecb6b43f1e089209
+  metadata.gz: 2465a1fb919eccdd5daef0183cf0bc371d312b6fa8462dfcbb6096e587376efad479184269b32617143e53d321c0208b361d99af66eabbeea299c6050dd87e3c
+  data.tar.gz: e8ee04c59cbc81fa1b38478e40507d94434b68e2be5009a7b6403731ac117793b9aa462c567704125a7a96264eee46123c7c915979f91ec20042fea2620dc361

data/lib/forest_admin_agent/routes/resources/list.rb

@@ -15,7 +15,6 @@ module ForestAdminAgent
         def handle_request(args = {})
           build(args)
           @permissions.can?(:browse, @collection)
-
           filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
             condition_tree: ConditionTreeFactory.intersect([
                                                              @permissions.get_scope(@collection),
@@ -23,8 +22,11 @@ module ForestAdminAgent
                                                                @collection, args
                                                              )
                                                            ]),
-            page: ForestAdminAgent::Utils::QueryStringParser.parse_pagination(args)
+            page: ForestAdminAgent::Utils::QueryStringParser.parse_pagination(args),
+            search: ForestAdminAgent::Utils::QueryStringParser.parse_search(@collection, args),
+            search_extended: ForestAdminAgent::Utils::QueryStringParser.parse_search_extended(args)
           )
+
           projection = ForestAdminAgent::Utils::QueryStringParser.parse_projection_with_pks(@collection, args)
           records = @collection.list(@caller, filter, projection)
 
@@ -32,12 +34,33 @@ module ForestAdminAgent
             name: args[:params]['collection_name'],
             content: JSONAPI::Serializer.serialize(
               records,
+              class_name: @collection.name,
               is_collection: true,
               serializer: Serializer::ForestSerializer,
-              include: projection.relations.keys
+              include: projection.relations.keys,
+              meta: handle_search_decorator(args[:params]['search'], records)
             )
           }
         end
+
+        def handle_search_decorator(search_value, records)
+          decorator = { decorators: [] }
+          unless search_value.nil?
+            records.each_with_index do |entry, index|
+              decorator[:decorators][index] = { id: Utils::Id.pack_id(@collection, entry), search: [] }
+              # attributes method is defined on ActiveRecord::Base model
+              attributes = entry.respond_to?(:attributes) ? entry.attributes : entry
+
+              attributes.each do |field_key, field_value|
+                if !field_value.is_a?(Array) && field_value.to_s.downcase.include?(search_value.downcase)
+                  decorator[:decorators][index][:search] << field_key
+                end
+              end
+            end
+          end
+
+          decorator
+        end
       end
     end
   end

data/lib/forest_admin_agent/routes/resources/related/list_related.rb

@@ -50,6 +50,7 @@ module ForestAdminAgent
               content: JSONAPI::Serializer.serialize(
                 records,
                 is_collection: true,
+                class_name: @child_collection.name,
                 serializer: Serializer::ForestSerializer,
                 include: projection.relations.keys
               )

data/lib/forest_admin_agent/routes/resources/show.rb

@@ -34,6 +34,7 @@ module ForestAdminAgent
             name: args[:params]['collection_name'],
             content: JSONAPI::Serializer.serialize(
               records[0],
+              class_name: @collection.name,
               is_collection: false,
               serializer: Serializer::ForestSerializer,
               include: projection.relations.keys

data/lib/forest_admin_agent/routes/resources/store.rb

@@ -25,6 +25,7 @@ module ForestAdminAgent
             content: JSONAPI::Serializer.serialize(
               record,
               is_collection: false,
+              class_name: @collection.name,
               serializer: Serializer::ForestSerializer
             )
           }

data/lib/forest_admin_agent/routes/resources/update.rb

@@ -33,6 +33,7 @@ module ForestAdminAgent
             content: JSONAPI::Serializer.serialize(
               records[0],
               is_collection: false,
+              class_name: @collection.name,
               serializer: Serializer::ForestSerializer
             )
           }

data/lib/forest_admin_agent/serializer/forest_serializer.rb

@@ -20,8 +20,17 @@ module ForestAdminAgent
       end
 
       def type
-        class_name = object.class.name
-        @@class_names[class_name] ||= class_name.demodulize.underscore.freeze
+        class_name = @options[:class_name]
+        @@class_names[class_name] ||= class_name
+      end
+
+      def id
+        forest_collection = ForestAdminAgent::Facades::Container.datasource.get_collection(@options[:class_name])
+        primary_keys = ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(forest_collection)
+        id = []
+        primary_keys.each { |key| id << @object[key] }
+
+        id.join('|')
       end
 
       def format_name(attribute_name)
@@ -41,7 +50,7 @@ module ForestAdminAgent
       end
 
       def attributes
-        forest_collection = ForestAdminAgent::Facades::Container.datasource.get_collection(object.class.name.demodulize.underscore)
+        forest_collection = ForestAdminAgent::Facades::Container.datasource.get_collection(@options[:class_name])
         fields = forest_collection.schema[:fields].select { |_field_name, field| field.type == 'Column' }
         fields.each { |field_name, _field| add_attribute(field_name) }
         return {} if attributes_map.nil?
@@ -61,11 +70,7 @@ module ForestAdminAgent
           instance_eval(&attr_or_block)
         else
           # Default behavior, call a method by the name of the attribute.
-          begin
-            object.try(attr_or_block)
-          rescue
-            nil
-          end
+          object[attr_or_block]
         end
       end
 
@@ -104,7 +109,8 @@ module ForestAdminAgent
       end
 
       def relationships
-        forest_collection = ForestAdminAgent::Facades::Container.datasource.get_collection(object.class.name.demodulize.underscore)
+        datasource = ForestAdminAgent::Facades::Container.datasource
+        forest_collection = datasource.get_collection(@options[:class_name])
         relations_to_many = forest_collection.schema[:fields].select { |_field_name, field| field.type == 'OneToMany' || field.type == 'ManyToMany' }
         relations_to_one = forest_collection.schema[:fields].select { |_field_name, field| field.type == 'OneToOne' || field.type == 'ManyToOne' }
 
@@ -124,10 +130,13 @@ module ForestAdminAgent
           end
 
           object = has_one_relationship(attribute_name, attr_data)
-          if object.nil?
+          if object.nil? || object.empty?
             data[formatted_attribute_name]['data'] = nil
           else
-            related_object_serializer = ForestSerializer.new(object, @options)
+            relation = datasource.get_collection(@options[:class_name]).schema[:fields][attribute_name.to_s]
+            options = @options.clone
+            options[:class_name] = datasource.get_collection(relation.foreign_collection).name
+            related_object_serializer = ForestSerializer.new(object, options)
             data[formatted_attribute_name]['data'] = {
               'type' => related_object_serializer.type.to_s,
               'id' => related_object_serializer.id.to_s,
@@ -152,6 +161,9 @@ module ForestAdminAgent
           if @_include_linkages.include?(formatted_attribute_name) || attr_data[:options][:include_data]
             data[formatted_attribute_name]['data'] = []
             objects = has_many_relationship(attribute_name, attr_data) || []
+            relation = datasource.get_collection(@options[:class_name]).schema[:fields][attribute_name.to_s]
+            options = @options.clone
+            options[:class_name] = datasource.get_collection(relation.foreign_collection).name
             objects.each do |obj|
               related_object_serializer = JSONAPI::Serializer.find_serializer(obj, @options)
               data[formatted_attribute_name]['data'] << {

data/lib/forest_admin_agent/serializer/forest_serializer_override.rb

@@ -48,7 +48,7 @@ module ForestAdminAgent
               end
 
               # We're finding relationships for compound documents, so skip anything that doesn't exist.
-              next if object.nil?
+              next if object.nil? || object.empty?
 
               # Full linkage: a request for comments.author MUST automatically include comments
               # in the response.
@@ -58,6 +58,8 @@ module ForestAdminAgent
                 # If it is not set, that indicates that this is an inner path and not a leaf and will
                 # be followed by the recursion below.
                 objects.each do |obj|
+                  relation = ForestAdminAgent::Facades::Container.datasource.get_collection(options[:class_name]).schema[:fields][attribute_name]
+                  relation_class_name = ForestAdminAgent::Facades::Container.datasource.get_collection(relation.foreign_collection).name
                   obj_serializer = JSONAPI::Serializer.find_serializer(obj, options)
                   # Use keys of ['posts', '1'] for the results to enforce uniqueness.
                   # Spec: A compound document MUST NOT include more than one resource object for each
@@ -82,7 +84,8 @@ module ForestAdminAgent
                   # so merge the include_linkages each time we see it to load all the relevant linkages.
                   current_child_includes += (results[key] && results[key][:include_linkages]) || []
                   current_child_includes.uniq!
-                  results[key] = { object: obj, include_linkages: current_child_includes }
+
+                  results[key] = { object: obj, include_linkages: current_child_includes, class_name: relation_class_name }
                 end
               end
 
@@ -96,6 +99,123 @@ module ForestAdminAgent
             end
             nil
           end
+
+          def self.serialize(objects, options = {})
+            # Normalize option strings to symbols.
+            options[:is_collection] = options.delete('is_collection') || options[:is_collection] || false
+            options[:include] = options.delete('include') || options[:include]
+            options[:serializer] = options.delete('serializer') || options[:serializer]
+            options[:namespace] = options.delete('namespace') || options[:namespace]
+            options[:context] = options.delete('context') || options[:context] || {}
+            options[:skip_collection_check] = options.delete('skip_collection_check') || options[:skip_collection_check] || false
+            options[:base_url] = options.delete('base_url') || options[:base_url]
+            options[:jsonapi] = options.delete('jsonapi') || options[:jsonapi]
+            options[:meta] = options.delete('meta') || options[:meta]
+            options[:links] = options.delete('links') || options[:links]
+            options[:fields] = options.delete('fields') || options[:fields] || {}
+
+            # Deprecated: use serialize_errors method instead
+            options[:errors] = options.delete('errors') || options[:errors]
+
+            # Normalize includes.
+            includes = options[:include]
+            includes = (includes.is_a?(String) ? includes.split(',') : includes).uniq if includes
+
+            # Transforms input so that the comma-separated fields are separate symbols in array
+            # and keys are stringified
+            # Example:
+            # {posts: 'title,author,long_comments'} => {'posts' => [:title, :author, :long_comments]}
+            # {posts: ['title', 'author', 'long_comments'} => {'posts' => [:title, :author, :long_comments]}
+            #
+            fields = {}
+            # Normalize fields to accept a comma-separated string or an array of strings.
+            options[:fields].map do |type, whitelisted_fields|
+              whitelisted_fields = [whitelisted_fields] if whitelisted_fields.is_a?(Symbol)
+              whitelisted_fields = whitelisted_fields.split(',') if whitelisted_fields.is_a?(String)
+              fields[type.to_s] = whitelisted_fields.map(&:to_sym)
+            end
+
+            # An internal-only structure that is passed through serializers as they are created.
+            passthrough_options = {
+              context: options[:context],
+              serializer: options[:serializer],
+              namespace: options[:namespace],
+              include: includes,
+              fields: fields,
+              base_url: options[:base_url],
+              class_name: options[:class_name]
+            }
+
+            if !options[:skip_collection_check] && options[:is_collection] && !objects.respond_to?(:each)
+              raise JSONAPI::Serializer::AmbiguousCollectionError.new(
+                'Attempted to serialize a single object as a collection.')
+            end
+
+            # Automatically include linkage data for any relation that is also included.
+            if includes
+              include_linkages = includes.map { |key| key.to_s.split('.').first }
+              passthrough_options[:include_linkages] = include_linkages
+            end
+
+            # Spec: Primary data MUST be either:
+            # - a single resource object or null, for requests that target single resources.
+            # - an array of resource objects or an empty array ([]), for resource collections.
+            # http://jsonapi.org/format/#document-structure-top-level
+            if options[:is_collection] && !objects.any?
+              primary_data = []
+            elsif !options[:is_collection] && objects.nil?
+              primary_data = nil
+            elsif options[:is_collection]
+              # Have object collection.
+              primary_data = serialize_primary_multi(objects, passthrough_options)
+            else
+              # Duck-typing check for a collection being passed without is_collection true.
+              # We always must be told if serializing a collection because the JSON:API spec distinguishes
+              # how to serialize null single resources vs. empty collections.
+              if !options[:skip_collection_check] && objects.is_a?(Array)
+                raise JSONAPI::Serializer::AmbiguousCollectionError.new(
+                  'Must provide `is_collection: true` to `serialize` when serializing collections.')
+              end
+              # Have single object.
+              primary_data = serialize_primary(objects, passthrough_options)
+            end
+            result = {
+              'data' => primary_data,
+            }
+            result['jsonapi'] = options[:jsonapi] if options[:jsonapi]
+            result['meta'] = options[:meta] if options[:meta]
+            result['links'] = options[:links] if options[:links]
+            result['errors'] = options[:errors] if options[:errors]
+
+            # If 'include' relationships are given, recursively find and include each object.
+            if includes
+              relationship_data = {}
+              inclusion_tree = parse_relationship_paths(includes)
+
+              # Given all the primary objects (either the single root object or collection of objects),
+              # recursively search and find related associations that were specified as includes.
+              objects = options[:is_collection] ? objects.to_a : [objects]
+              objects.compact.each do |obj|
+                # Use the mutability of relationship_data as the return datastructure to take advantage
+                # of the internal special merging logic.
+                find_recursive_relationships(obj, inclusion_tree, relationship_data, passthrough_options)
+              end
+
+              result['included'] = relationship_data.map do |_, data|
+                included_passthrough_options = {}
+                included_passthrough_options[:base_url] = passthrough_options[:base_url]
+                included_passthrough_options[:context] = passthrough_options[:context]
+                included_passthrough_options[:fields] = passthrough_options[:fields]
+                included_passthrough_options[:serializer] = find_serializer_class(data[:object], options)
+                included_passthrough_options[:namespace] = passthrough_options[:namespace]
+                included_passthrough_options[:include_linkages] = data[:include_linkages]
+                included_passthrough_options[:class_name] = data[:class_name]
+
+                serialize_primary(data[:object], included_passthrough_options)
+              end
+            end
+            result
+          end
         end
       end
     end

data/lib/forest_admin_agent/utils/id.rb

@@ -3,6 +3,19 @@ module ForestAdminAgent
     class Id
       include ForestAdminDatasourceToolkit::Utils
       include ForestAdminDatasourceToolkit
+
+      def self.pack_ids(schema, records)
+        records.map { |packed_id| pack_id(schema, packed_id) }
+      end
+
+      def self.pack_id(schema, record)
+        pk_names = ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(schema)
+
+        raise Exceptions::ForestException, 'This collection has no primary key' if pk_names.empty?
+
+        pk_names.map { |pk| record[pk].to_s }.join('|')
+      end
+
       def self.unpack_id(collection, packed_id, with_key: false)
         primary_keys = ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(collection)
         primary_key_values = packed_id.to_s.split('|')

data/lib/forest_admin_agent/utils/query_string_parser.rb

@@ -85,6 +85,23 @@ module ForestAdminAgent
 
         Page.new(offset: offset, limit: items_per_pages.to_i)
       end
+
+      def self.parse_search(collection, args)
+        search = args.dig(:params, :data, :attributes, :all_records_subset_query, :search) || args.dig(:params, :search)
+
+        raise ForestException, 'Collection is not searchable' if search && !collection.is_searchable?
+
+        search
+      end
+
+      def self.parse_search_extended(args)
+        extended = args.dig(:params, :data, :attributes, :all_records_subset_query,
+                            :searchExtended) || args.dig(:params, :searchExtended)
+
+        return false if extended.nil?
+
+        extended != '0'
+      end
     end
   end
 end

data/lib/forest_admin_agent/utils/schema/schema_emitter.rb

@@ -7,7 +7,7 @@ module ForestAdminAgent
       class SchemaEmitter
         LIANA_NAME = "forest-rails"
 
-        LIANA_VERSION = "1.0.0-beta.26"
+        LIANA_VERSION = "1.0.0-beta.28"
 
         def self.get_serialized_schema(datasource)
           schema_path = Facades::Container.cache(:schema_path)

data/lib/forest_admin_agent/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminAgent
-  VERSION = "1.0.0-beta.26"
+  VERSION = "1.0.0-beta.28"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_agent
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.beta.26
+  version: 1.0.0.pre.beta.28
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-01-02 00:00:00.000000000 Z
+date: 2024-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport