forest_admin_agent 1.0.0.pre.beta.21

data/lib/forest_admin_agent/routes/abstract_route.rb

@@ -0,0 +1,27 @@
+module ForestAdminAgent
+  module Routes
+    class AbstractRoute
+      def initialize
+        @routes = {}
+        setup_routes
+      end
+
+      def build(args)
+        @datasource = ForestAdminAgent::Facades::Container.datasource
+        @collection = @datasource.collection(args[:params]['collection_name'])
+      end
+
+      def routes
+        @routes ||= {}
+      end
+
+      def add_route(name, method, uri, closure)
+        @routes[name] = { method: method, uri: uri, closure: closure }
+      end
+
+      def setup_routes
+        raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'jsonapi-serializers'
+
+module ForestAdminAgent
+  module Routes
+    module Resources
+      class Count < AbstractRoute
+        include ForestAdminAgent::Builder
+        def setup_routes
+          add_route('forest_count', 'get', '/:collection_name/count', ->(args) { handle_request(args) })
+
+          self
+        end
+
+        def handle_request(args = {})
+          build(args)
+
+          if @collection.is_countable?
+            caller = ForestAdminAgent::Utils::QueryStringParser.parse_caller(args)
+            filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new
+            aggregation = ForestAdminDatasourceToolkit::Components::Query::Aggregation.new(operation: 'Count')
+            result = @collection.aggregate(caller, filter, aggregation)
+
+            return {
+              name: args[:params]['collection_name'],
+              content: {
+                count: result[0][:value]
+              }
+            }
+          end
+
+          {
+            name: args[:params]['collection_name'],
+            content: {
+              count: 'deactivated'
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'jsonapi-serializers'
+require 'ostruct'
+
+module ForestAdminAgent
+  module Routes
+    module Resources
+      class Delete < AbstractAuthenticatedRoute
+        include ForestAdminAgent::Builder
+        include ForestAdminDatasourceToolkit::Components::Query
+
+        def setup_routes
+          add_route('forest_delete_bulk', 'delete', '/:collection_name', ->(args) { handle_request_bulk(args) })
+          add_route('forest_delete', 'delete', '/:collection_name/:id', ->(args) { handle_request(args) })
+
+          self
+        end
+
+        def handle_request(args = {})
+          build(args)
+          id = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+          delete_records(args, { ids: [id], are_excluded: false })
+
+          { content: nil, status: 204 }
+        end
+
+        def handle_request_bulk(args = {})
+          build(args)
+          selection_ids = Utils::Id.parse_selection_ids(@collection, args[:params], with_key: true)
+          delete_records(args, selection_ids)
+
+          { content: nil, status: 204 }
+        end
+
+        def delete_records(args, selection_ids)
+          condition_tree_ids = ConditionTree::ConditionTreeFactory.match_records(@collection, selection_ids[:ids])
+          condition_tree_ids = condition_tree_ids.inverse if selection_ids[:are_excluded]
+          filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
+            condition_tree: ConditionTree::ConditionTreeFactory.intersect(
+              [
+                Utils::QueryStringParser.parse_condition_tree(@collection, args),
+                condition_tree_ids
+              ]
+            )
+          )
+
+          @collection.delete(@caller, filter)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'jsonapi-serializers'
+
+module ForestAdminAgent
+  module Routes
+    module Resources
+      class List < AbstractAuthenticatedRoute
+        include ForestAdminAgent::Builder
+        def setup_routes
+          add_route('forest_list', 'get', '/:collection_name', ->(args) { handle_request(args) })
+
+          self
+        end
+
+        def handle_request(args = {})
+          build(args)
+          caller = ForestAdminAgent::Utils::QueryStringParser.parse_caller(args)
+
+          filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
+            condition_tree: ForestAdminAgent::Utils::QueryStringParser.parse_condition_tree(@collection, args),
+            page: ForestAdminAgent::Utils::QueryStringParser.parse_pagination(args)
+          )
+          projection = ForestAdminAgent::Utils::QueryStringParser.parse_projection_with_pks(@collection, args)
+          records = @collection.list(caller, filter, projection)
+
+          {
+            name: args[:params]['collection_name'],
+            content: JSONAPI::Serializer.serialize(
+              records,
+              is_collection: true,
+              serializer: Serializer::ForestSerializer,
+              include: projection.relations.keys
+            )
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'jsonapi-serializers'
+
+module ForestAdminAgent
+  module Routes
+    module Resources
+      module Related
+        class AssociateRelated < AbstractRelatedRoute
+          include ForestAdminAgent::Builder
+          include ForestAdminDatasourceToolkit::Utils
+          include ForestAdminDatasourceToolkit::Components::Query
+          def setup_routes
+            add_route(
+              'forest_related_associate',
+              'post',
+              '/:collection_name/:id/relationships/:relation_name',
+              ->(args) { handle_request(args) }
+            )
+
+            self
+          end
+
+          def handle_request(args = {})
+            build(args)
+
+            parent_id = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+            target_relation_id = Utils::Id.unpack_id(@child_collection, args[:params]['data'][0]['id'], with_key: true)
+            relation = Schema.get_to_many_relation(@collection, args[:params]['relation_name'])
+
+            if relation.type == 'OneToMany'
+              associate_one_to_many(relation, parent_id, target_relation_id)
+            else
+              associate_many_to_many(relation, parent_id, target_relation_id)
+            end
+
+            { content: nil, status: 204 }
+          end
+
+          private
+
+          def associate_one_to_many(relation, parent_id, target_relation_id)
+            id = Schema.primary_keys(@child_collection)[0]
+            value = Collection.get_value(@child_collection, @caller, target_relation_id, id)
+            filter = Filter.new(condition_tree: ConditionTree::Nodes::ConditionTreeLeaf.new(id, 'Equal', value))
+            value = Collection.get_value(@collection, @caller, parent_id, relation.origin_key_target)
+
+            @child_collection.update(@caller, filter, { relation.origin_key => value })
+          end
+
+          def associate_many_to_many(relation, parent_id, target_relation_id)
+            id = Schema.primary_keys(@child_collection)[0]
+            foreign_value = Collection.get_value(@child_collection, @caller, target_relation_id, id)
+            id = Schema.primary_keys(@collection)[0]
+            origin_value = Collection.get_value(@collection, @caller, parent_id, id)
+            record = { relation.origin_key => origin_value, relation.foreign_key => foreign_value }
+
+            through_collection = @datasource.collection(relation.through_collection)
+            through_collection.create(@caller, record)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'jsonapi-serializers'
+
+module ForestAdminAgent
+  module Routes
+    module Resources
+      module Related
+        class CountRelated < AbstractRelatedRoute
+          include ForestAdminAgent::Builder
+          include ForestAdminDatasourceToolkit::Utils
+          include ForestAdminDatasourceToolkit::Components::Query
+          def setup_routes
+            add_route(
+              'forest_related_count',
+              'get',
+              '/:collection_name/:id/relationships/:relation_name/count',
+              ->(args) { handle_request(args) }
+            )
+
+            self
+          end
+
+          def handle_request(args = {})
+            build(args)
+
+            if @child_collection.is_countable?
+              filter = Filter.new
+              id = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+              result = Collection.aggregate_relation(
+                @collection,
+                id,
+                args[:params]['relation_name'],
+                @caller,
+                filter,
+                Aggregation.new(operation: 'Count')
+              )
+
+              return {
+                name: @child_collection.name,
+                content: {
+                  count: result[0][:value]
+                }
+              }
+            end
+
+            {
+              name: @child_collection.name,
+              content: {
+                count: 'deactivated'
+              }
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+require 'jsonapi-serializers'
+
+module ForestAdminAgent
+  module Routes
+    module Resources
+      module Related
+        class DissociateRelated < AbstractRelatedRoute
+          include ForestAdminAgent::Builder
+          include ForestAdminDatasourceToolkit::Utils
+          include ForestAdminDatasourceToolkit::Components::Query
+          def setup_routes
+            add_route(
+              'forest_related_dissociate',
+              'delete',
+              '/:collection_name/:id/relationships/:relation_name',
+              ->(args) { handle_request(args) }
+            )
+
+            self
+          end
+
+          def handle_request(args = {})
+            build(args)
+
+            parent_id = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+            is_delete_mode = !args.dig(:params, :delete).nil?
+            filter = get_base_foreign_filter(args)
+            relation = Schema.get_to_many_relation(@collection, args[:params]['relation_name'])
+
+            if relation.type == 'OneToMany'
+              dissociate_or_delete_one_to_many(relation, args[:params]['relation_name'], parent_id, is_delete_mode,
+                                               filter)
+            else
+              dissociate_or_delete_many_to_many(relation, args[:params]['relation_name'], parent_id, is_delete_mode,
+                                                filter)
+            end
+
+            { content: nil, status: 204 }
+          end
+
+          private
+
+          def dissociate_or_delete_one_to_many(relation, relation_name, parent_id, is_delete_mode, filter)
+            foreign_filter = FilterFactory.make_foreign_filter(@collection, parent_id, relation_name, @caller, filter)
+
+            if is_delete_mode
+              @child_collection.delete(@caller, foreign_filter)
+            else
+              @child_collection.update(@caller, foreign_filter, { relation.origin_key => nil })
+            end
+          end
+
+          def dissociate_or_delete_many_to_many(relation, relation_name, parent_id, is_delete_mode, filter)
+            through_collection = @datasource.collection(relation.through_collection)
+
+            if is_delete_mode
+              # Generate filters _BEFORE_ deleting stuff, otherwise things break.
+              foreign_filter = FilterFactory.make_foreign_filter(@collection, parent_id, relation_name, @caller, filter)
+              through_filter = FilterFactory.make_through_filter(@collection, parent_id, relation_name, @caller, filter)
+
+              # Delete records from through collection
+              through_collection.delete(@caller, through_filter)
+
+              # Let the datasource crash when:
+              # - the records in the foreignCollection are linked to other records in the origin collection
+              # - the underlying database/api is not cascading deletes
+              @child_collection.delete(@caller, foreign_filter)
+            else
+              through_filter = FilterFactory.make_through_filter(@collection, parent_id, relation_name, @caller, filter)
+              through_collection.delete(@caller, through_filter)
+            end
+          end
+
+          def get_base_foreign_filter(args)
+            selection_ids = Utils::Id.parse_selection_ids(@child_collection, args[:params])
+            selected_ids = ConditionTree::ConditionTreeFactory.match_ids(@child_collection, selection_ids[:ids])
+
+            selected_ids = selected_ids.inverse if selection_ids[:are_excluded]
+
+            if selection_ids[:ids].empty? && !selection_ids[:are_excluded]
+              raise ForestAdminDatasourceToolkit::Exceptions::ForestException, 'Expected no empty id list'
+            end
+
+            Filter.new(
+              condition_tree: ConditionTree::ConditionTreeFactory.intersect(
+                [
+                  Utils::QueryStringParser.parse_condition_tree(@child_collection, args),
+                  selected_ids
+                ]
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'jsonapi-serializers'
+
+module ForestAdminAgent
+  module Routes
+    module Resources
+      module Related
+        class ListRelated < AbstractRelatedRoute
+          include ForestAdminAgent::Builder
+          include ForestAdminDatasourceToolkit::Utils
+          def setup_routes
+            add_route(
+              'forest_related_list',
+              'get',
+              '/:collection_name/:id/relationships/:relation_name',
+              ->(args) { handle_request(args) }
+            )
+
+            self
+          end
+
+          def handle_request(args = {})
+            build(args)
+            # TODO: add csv behaviour
+
+            filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
+              condition_tree: ForestAdminAgent::Utils::QueryStringParser.parse_condition_tree(@child_collection, args),
+              page: ForestAdminAgent::Utils::QueryStringParser.parse_pagination(args)
+            )
+            projection = ForestAdminAgent::Utils::QueryStringParser.parse_projection_with_pks(@child_collection, args)
+            id = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+            records = Collection.list_relation(
+              @collection,
+              id,
+              args[:params]['relation_name'],
+              @caller,
+              filter,
+              projection
+            )
+
+            {
+              name: @child_collection.name,
+              content: JSONAPI::Serializer.serialize(
+                records,
+                is_collection: true,
+                serializer: Serializer::ForestSerializer,
+                include: projection.relations.keys
+              )
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+require 'jsonapi-serializers'
+
+module ForestAdminAgent
+  module Routes
+    module Resources
+      module Related
+        class UpdateRelated < AbstractRelatedRoute
+          include ForestAdminAgent::Builder
+          include ForestAdminDatasourceToolkit::Utils
+          include ForestAdminDatasourceToolkit::Components::Query
+          def setup_routes
+            add_route(
+              'forest_related_update',
+              'put',
+              '/:collection_name/:id/relationships/:relation_name',
+              ->(args) { handle_request(args) }
+            )
+
+            self
+          end
+
+          def handle_request(args = {})
+            build(args)
+
+            relation = @collection.fields[args[:params]['relation_name']]
+            parent_id = Utils::Id.unpack_id(@collection, args[:params]['id'])
+
+            linked_id = if (id = args.dig(:params, :data, :id))
+                          Utils::Id.unpack_id(@child_collection, id)
+                        end
+
+            if relation.type == 'ManyToOne'
+              update_many_to_one(relation, parent_id, linked_id)
+            elsif relation.type == 'OneToOne'
+              update_one_to_one(relation, parent_id, linked_id)
+            end
+
+            { content: nil, status: 204 }
+          end
+
+          private
+
+          def update_many_to_one(relation, parent_id, linked_id)
+            foreign_value = if linked_id
+                              Collection.get_value(@child_collection, @caller, linked_id, relation.foreign_key_target)
+                            end
+            fk_owner = ConditionTree::ConditionTreeFactory.match_ids(@collection, [parent_id])
+            @collection.update(@caller, Filter.new(condition_tree: fk_owner), { relation.foreign_key => foreign_value })
+          end
+
+          def update_one_to_one(relation, parent_id, linked_id)
+            origin_value = Collection.get_value(@collection, @caller, parent_id, relation.origin_key_target)
+
+            break_old_one_to_one_relationship(nil, relation, origin_value, linked_id)
+            create_new_one_to_one_relationship(nil, relation, origin_value, linked_id)
+          end
+
+          def break_old_one_to_one_relationship(_scope, relation, origin_value, linked_id)
+            linked_id ||= []
+
+            old_fk_owner_filter = Filter.new(
+              condition_tree: ConditionTree::ConditionTreeFactory.intersect(
+                [
+                  ConditionTree::Nodes::ConditionTreeLeaf.new(
+                    relation.origin_key,
+                    ConditionTree::Operators::EQUAL,
+                    origin_value
+                  )
+                ].push(
+                  # Don't set the new record's field to null
+                  # if it's already initialized with the right value
+                  ConditionTree::ConditionTreeFactory.match_ids(@child_collection, [linked_id]).inverse
+                )
+              )
+            )
+
+            result = @child_collection.aggregate(@caller, old_fk_owner_filter, Aggregation.new(operation: 'Count'), 1)
+
+            return unless (result[0][:value]).positive?
+
+            # Avoids updating records to null if it's not authorized by the ORM
+            # and if there is no record to update (the filter returns no record)
+
+            @child_collection.update(@caller, old_fk_owner_filter, { relation.origin_key => nil })
+          end
+
+          def create_new_one_to_one_relationship(_scope, relation, origin_value, linked_id)
+            return unless linked_id
+
+            new_fk_owner = ConditionTree::ConditionTreeFactory.match_ids(@child_collection, [linked_id])
+
+            @child_collection.update(
+              @caller,
+              Filter.new(condition_tree: new_fk_owner),
+              { relation.origin_key => origin_value }
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'jsonapi-serializers'
+require 'ostruct'
+
+module ForestAdminAgent
+  module Routes
+    module Resources
+      class Show < AbstractAuthenticatedRoute
+        include ForestAdminAgent::Builder
+        include ForestAdminDatasourceToolkit::Components::Query
+        def setup_routes
+          add_route('forest_show', 'get', '/:collection_name/:id', ->(args) { handle_request(args) })
+
+          self
+        end
+
+        def handle_request(args = {})
+          build(args)
+          id = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+          caller = ForestAdminAgent::Utils::QueryStringParser.parse_caller(args)
+          condition_tree = ConditionTree::ConditionTreeFactory.match_records(@collection, [id])
+          filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
+            condition_tree: condition_tree,
+            page: ForestAdminAgent::Utils::QueryStringParser.parse_pagination(args)
+          )
+          projection = ProjectionFactory.all(@collection)
+
+          records = @collection.list(caller, filter, projection)
+
+          raise Http::Exceptions::NotFoundError, 'Record does not exists' unless records.size.positive?
+
+          {
+            name: args[:params]['collection_name'],
+            content: JSONAPI::Serializer.serialize(
+              records[0],
+              is_collection: false,
+              serializer: Serializer::ForestSerializer,
+              include: projection.relations.keys
+            )
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'jsonapi-serializers'
+require 'ostruct'
+
+module ForestAdminAgent
+  module Routes
+    module Resources
+      class Store < AbstractAuthenticatedRoute
+        include ForestAdminAgent::Builder
+        include ForestAdminDatasourceToolkit::Components::Query
+        def setup_routes
+          add_route('forest_store', 'post', '/:collection_name', ->(args) { handle_request(args) })
+
+          self
+        end
+
+        def handle_request(args = {})
+          build(args)
+          data = format_attributes(args)
+          record = @collection.create(@caller, data)
+          link_one_to_one_relations(args, record)
+
+          {
+            name: args[:params]['collection_name'],
+            content: JSONAPI::Serializer.serialize(
+              record,
+              is_collection: false,
+              serializer: Serializer::ForestSerializer
+            )
+          }
+        end
+
+        def link_one_to_one_relations(args, record)
+          args[:params][:data][:relationships]&.map do |field, value|
+            schema = @collection.fields[field]
+            if schema.type == 'OneToOne'
+              id = Utils::Id.unpack_id(@collection, value['data']['id'], with_key: true)
+              foreign_collection = @datasource.collection(schema.foreign_collection)
+              # Load the value that will be used as origin_key
+              origin_value = record[schema.origin_key_target]
+
+              # update new relation (may update zero or one records).
+              condition_tree = ConditionTree::ConditionTreeFactory.match_records(foreign_collection, [id])
+              filter = Filter.new(condition_tree: condition_tree)
+              foreign_collection.update(@caller, filter, { schema.origin_key => origin_value })
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'jsonapi-serializers'
+require 'ostruct'
+
+module ForestAdminAgent
+  module Routes
+    module Resources
+      class Update < AbstractAuthenticatedRoute
+        include ForestAdminAgent::Builder
+        include ForestAdminDatasourceToolkit::Components::Query
+
+        def setup_routes
+          add_route('forest_update', 'put', '/:collection_name/:id', ->(args) { handle_request(args) })
+
+          self
+        end
+
+        def handle_request(args = {})
+          build(args)
+          id = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+          caller = ForestAdminAgent::Utils::QueryStringParser.parse_caller(args)
+          condition_tree = ConditionTree::ConditionTreeFactory.match_records(@collection, [id])
+          filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
+            condition_tree: condition_tree,
+            page: ForestAdminAgent::Utils::QueryStringParser.parse_pagination(args)
+          )
+          data = format_attributes(args)
+          @collection.update(@caller, filter, data)
+          records = @collection.list(caller, filter, ProjectionFactory.all(@collection))
+
+          {
+            name: args[:params]['collection_name'],
+            content: JSONAPI::Serializer.serialize(
+              records[0],
+              is_collection: false,
+              serializer: Serializer::ForestSerializer
+            )
+          }
+        end
+      end
+    end
+  end
+end