forest_admin_agent 1.0.0.pre.beta.29 → 1.0.0.pre.beta.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c5ae106d439132bfc53a11f1fe055e58922dda5140812af1a83851d49ef8961
-  data.tar.gz: 594d82ff7aa21eb7d1f8f4d0ed203d3f7530784fffd4361d49dd04e0e0710783
+  metadata.gz: 7c8589b7ac5d1648ad10bebc5e3e2d8f55b176a4804f44f0d1b7dce77a747646
+  data.tar.gz: bfbb688a7c3bd8acb6849379757bf9255ae65a4ce272611d724122332d7774dc
 SHA512:
-  metadata.gz: b10a66bdd437914e823fbfaee379f206eb1646a50743a3854f7490357dc0e33d58315429e45ef1eb652e9c926f876535afebb779f908c370181e3d2729415a96
-  data.tar.gz: b5bf01858bf6dd700dad161214b5875dcc430d8b7ddbee8c333c4c32baa36b5135442449f6a0c96f2848a36b49ba43262bd75c54cf4a08f21249aaa760f031fa
+  metadata.gz: 206fc75159915647d7a7f895439d7ceb4e58baceade060b08853f2fdfcc27ac6dcaab0b20ffd6902b3bc96be3bc8915a7aad9f16332a946a3109f0a5a53def21
+  data.tar.gz: 653dec755d3dc730b9f84404f3d22430e729732e2e31dbea46d6b06b3e2e069e8db9f1e7dffc4a77be6d04ff682bfa3f69963d281599fae4b45c402def701606

data/README.md

@@ -32,4 +32,4 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/[USERN
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [GPL-3.0 License](https://www.gnu.org/licenses/gpl-3.0.en.html).

data/forest_admin_agent.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.summary      = "Ruby agent for Forest Admin."
   spec.description  = "Forest is a modern admin interface that works on all major web frameworks. This gem makes Forest
 admin work on any Ruby application."
-  spec.license = "MIT"
+  spec.license = "GPL-3.0"
   spec.required_ruby_version = ">= 3.0.0"
 
   spec.metadata["homepage_uri"] = spec.homepage

data/lib/forest_admin_agent/http/router.rb

@@ -5,7 +5,7 @@ module ForestAdminAgent
 
       def self.routes
         [
-          # actions_routes,
+          actions_routes,
           # api_charts_routes,
           System::HealthCheck.new.routes,
           Security::Authentication.new.routes,
@@ -25,14 +25,14 @@ module ForestAdminAgent
       end
 
       def self.actions_routes
-        routes = []
-        # TODO
-        # AgentFactory.get('datasource').collections.each do |collection|
-        #   collection.get_actions.each do |action_name, action|
-        #     routes << Actions.new(collection, action_name).routes
-        #   end
-        # end
-        routes.flatten
+        routes = {}
+        Facades::Container.datasource.collections.each_value do |collection|
+          collection.schema[:actions].each_key do |action_name|
+            routes.merge!(Action::Action.new(collection, action_name).routes)
+          end
+        end
+
+        routes
       end
 
       def self.api_charts_routes

data/lib/forest_admin_agent/routes/action/action.rb

@@ -0,0 +1,137 @@
+require 'jsonapi-serializers'
+require 'active_support/inflector'
+
+module ForestAdminAgent
+  module Routes
+    module Action
+      class Action < AbstractAuthenticatedRoute
+        include ForestAdminAgent::Builder
+        include ForestAdminAgent::Utils
+        include ForestAdminDatasourceToolkit::Components::Query
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+        include ForestAdminDatasourceCustomizer::Decorators::Action
+
+        def initialize(collection, action)
+          @action_name = action
+          @collection = collection
+          super()
+        end
+
+        def setup_routes
+          action_index = @collection.schema[:actions].keys.index(@action_name)
+          slug = ForestAdminAgent::Utils::Schema::GeneratorAction.get_action_slug(@action_name)
+          route_name = "forest_action_#{@collection.name}_#{action_index}_#{slug}"
+          path = "/_actions/:collection_name/#{action_index}/#{slug}"
+
+          add_route(route_name, 'post', path, proc { |args| handle_request(args) })
+          add_route(
+            "#{route_name}_load",
+            'post',
+            "#{path}/hooks/load",
+            proc { |args| handle_hook_request(args) }
+          )
+          add_route(
+            "#{route_name}_change",
+            'post',
+            "#{path}/hooks/change",
+            proc { |args| handle_hook_request(args) }
+          )
+          self
+        end
+
+        def handle_request(args = {})
+          build(args)
+          filter_for_caller = get_record_selection(args)
+          get_record_selection(args, include_user_scope: false)
+
+          # TODO: permission
+
+          raw_data = args.dig(:params, :data, :attributes, :values)
+
+          # As forms are dynamic, we don't have any way to ensure that we're parsing the data correctly
+          # better send invalid data to the getForm() customer handler than to the execute() one.
+          unsafe_data = Schema::ForestValueConverter.make_form_data_unsafe(raw_data)
+
+          fields = @collection.get_form(
+            @caller,
+            @action_name,
+            unsafe_data,
+            filter_for_caller,
+            { include_hidden_fields: true } # during execute, we need all possible fields
+          )
+
+          # Now that we have the field list, we can parse the data again.
+          data = Schema::ForestValueConverter.make_form_data(@datasource, raw_data, fields)
+
+          { content: @collection.execute(@caller, @action_name, data, filter_for_caller) }
+        end
+
+        def handle_hook_request(args = {})
+          build(args)
+          forest_fields = args.dig(:params, :data, :attributes, :fields)
+          data = (Schema::ForestValueConverter.make_form_data_from_fields(@datasource, forest_fields) if forest_fields)
+          filter = get_record_selection(args)
+
+          fields = @collection.get_form(
+            @caller,
+            @action_name,
+            data,
+            filter,
+            {
+              change_field: nil,
+              search_field: nil,
+              search_values: {},
+              includeHiddenFields: false
+            }
+          )
+
+          {
+            content: {
+              fields: fields&.map { |field| Schema::GeneratorAction.build_field_schema(@datasource, field) } || {}
+            }
+          }
+        end
+
+        private
+
+        def get_record_selection(args, include_user_scope: true)
+          attributes = args.dig(:params, :data, :attributes)
+
+          # Match user filter + search + scope? + segment
+          scope = include_user_scope ? @permissions.get_scope(@collection) : nil
+          filter = Filter.new(
+            condition_tree: ConditionTreeFactory.intersect(
+              [
+                scope,
+                ForestAdminAgent::Utils::QueryStringParser.parse_condition_tree(
+                  @collection, args
+                )
+              ]
+            )
+          )
+
+          # Restrict the filter to the selected records for single or bulk actions
+          if @collection.schema[:actions][@action_name].scope != Types::ActionScope::GLOBAL
+            selection_ids = Utils::Id.parse_selection_ids(@collection, args[:params])
+            selected_ids = ConditionTreeFactory.match_ids(@collection, selection_ids[:ids])
+            selected_ids = selected_ids.inverse if selection_ids[:are_excluded]
+            filter = filter.override(
+              condition_tree: ConditionTreeFactory.intersect([filter.condition_tree, selected_ids])
+            )
+          end
+
+          # Restrict the filter further for the "related data" page
+          unless attributes[:parent_association_name].nil?
+            relation = attributes[:parent_association_name]
+            parent = @datasource.get_collection(attributes[:parent_collection_name])
+            parent_id = Utils::Id.unpack_id(parent, attributes[:parent_collection_id])
+
+            filter = FilterFactory.make_foreign_filter(parent, parent_id, relation, @caller, filter)
+          end
+
+          filter
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_agent/utils/id.rb

@@ -41,16 +41,16 @@ module ForestAdminAgent
 
       def self.parse_selection_ids(collection, params, with_key: false)
         attributes = begin
-          params.dig('data', 'attributes')
+          params.dig(:data, :attributes)
         rescue StandardError
           nil
         end
 
-        are_excluded = attributes&.key?('all_records') ? attributes['all_records'] : false
-        input_ids = attributes&.key?('ids') ? attributes['ids'] : params['data'].map { |item| item['id'] }
+        are_excluded = attributes&.key?(:all_records) ? attributes[:all_records] : false
+        input_ids = attributes&.key?(:ids) ? attributes[:ids] : params[:data].map { |item| item['id'] }
         ids = unpack_ids(
           collection,
-          are_excluded ? attributes['all_records_ids_excluded'] : input_ids,
+          are_excluded ? attributes[:all_records_ids_excluded] : input_ids,
           with_key: with_key
         )
 

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

@@ -0,0 +1,27 @@
+module ForestAdminAgent
+  module Utils
+    module Schema
+      class ActionFields
+        def self.collection_field?(field)
+          field&.type == 'Collection'
+        end
+
+        def self.enum_field?(field)
+          field&.type == 'Enum'
+        end
+
+        def self.enum_list_field?(field)
+          field&.type == 'EnumList'
+        end
+
+        def self.file_field?(field)
+          field&.type == 'File'
+        end
+
+        def self.file_list_field?(field)
+          field&.type == 'FileList'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+module ForestAdminAgent
+  module Utils
+    module Schema
+      class ForestValueConverter
+        #  This last form data parser tries to guess the types from the data itself.
+        #
+        #  - Fields with type "Collection" which target collections where the pk is not a string or
+        #  derivative (mongoid, uuid, ...) won't be parser correctly, as we don't have enough information
+        #  to properly guess the type
+        #  - Fields of type "String" but where the final user entered a data-uri manually in the frontend
+        #  will be wrongfully parsed.
+        def self.make_form_data_unsafe(raw_data)
+          data = {}
+          raw_data.each do |key, value|
+            # Skip fields from the default form
+            next if Schema::GeneratorAction::DEFAULT_FIELDS.map { |f| f[:field] }.include?(key)
+
+            data[key] = if value.is_a?(Array) && value.all? { |v| data_uri?(v) }
+                          value.map { |uri| parse_data_uri(uri) }
+                        elsif data_uri?(value)
+                          parse_data_uri(value)
+                        else
+                          value
+                        end
+          end
+
+          data
+        end
+
+        def self.make_form_data_from_fields(datasource, fields)
+          data = {}
+          fields.each_value do |field|
+            next if Schema::GeneratorAction::DEFAULT_FIELDS.map { |f| f[:field] }.include?(field.field)
+
+            if field.reference && field.value
+              collection_name = field.reference.split('.').first
+              collection = datasource.get_collection(collection_name)
+              data[field.field] = Utils::Id.unpack_id(collection, field.value)
+            elsif field.type == 'File'
+              data[field.field] = parse_data_uri(field.value)
+            elsif field.type.is_a?(Array) && field.type[0] == 'File'
+              data[field.field] = field.value.map { |v| parse_data_uri(v) }
+            else
+              data[field.field] = field.value
+            end
+          end
+
+          data
+        end
+
+        # Proper form data parser which converts data from an action form result to the format
+        # that is internally used in datasources.
+        def self.make_form_data(datasource, raw_data, fields)
+          data = {}
+          raw_data.each do |key, value|
+            field = fields.find { |f| f.label == key }
+            # Skip fields from the default form
+            next if Schema::GeneratorAction::DEFAULT_FIELDS.map { |f| f[:field] }.include?(key)
+
+            if ActionFields.collection_field?(field) && !value.nil?
+              collection = datasource.get_collection(field.collection_name)
+              data[key] = Utils::Id.unpack_id(collection, value)
+            elsif ActionFields.file_field?(field)
+              data[key] = parse_data_uri(value)
+            elsif ActionFields.file_list_field?(field)
+              data[key] = value.map { |v| parse_data_uri(v) }
+            else
+              data[key] = value
+            end
+          end
+
+          data
+        end
+
+        def self.data_uri?(value)
+          value.is_a?(String) && value.start_with?('data:')
+        end
+
+        def self.value_to_forest(field)
+          if ActionFields.enum_field?(field)
+            return field.enum_values.include?(field.value) ? field.value : nil
+          end
+
+          return field.value.select { |v| field.enum_values.include?(v) } if ActionFields.enum_list_field?(field)
+
+          return field.value.join('|') if ActionFields.collection_field?(field)
+
+          # return make_data_uri(field.value) if ActionFields.file_field?(field)
+          #
+          # return value.map { |f| make_data_uri(f) } if ActionFields.file_list_field?(field)
+
+          field.value
+        end
+
+        def self.make_data_uri(file)
+          # TODO: to implement
+        end
+
+        def self.parse_data_uri(file)
+          # TODO: to implement
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+module ForestAdminAgent
+  module Utils
+    module Schema
+      class GeneratorAction
+        DEFAULT_FIELDS = [
+          {
+            field: 'Loading...',
+            type: 'String',
+            isReadOnly: true,
+            defaultValue: 'Form is loading',
+            value: nil,
+            description: '',
+            enums: nil,
+            hook: nil,
+            isRequired: false,
+            reference: nil,
+            widgetEdit: nil
+          }
+        ].freeze
+
+        def self.get_action_slug(name)
+          name.downcase.strip.tr(' ', '-').gsub(/[^\w-]/, '')
+        end
+
+        def self.build_schema(collection, name)
+          schema = collection.schema[:actions][name]
+          action_index = collection.schema[:actions].keys.index(name)
+          slug = get_action_slug(name)
+          fields = build_fields(collection, name, schema)
+
+          {
+            id: "#{collection.name}-#{action_index}-#{slug}",
+            name: name,
+            type: schema.scope.downcase,
+            baseUrl: nil,
+            endpoint: "/forest/_actions/#{collection.name}/#{action_index}/#{slug}",
+            httpMethod: 'POST',
+            redirect: nil, # frontend ignores this attribute
+            download: schema.is_generate_file,
+            fields: fields,
+            hooks: {
+              load: !schema.static_form?,
+              # Always registering the change hook has no consequences, even if we don't use it.
+              change: ['changeHook']
+            }
+          }
+        end
+
+        def self.build_field_schema(datasource, field)
+          output = {
+            description: field.description,
+            isRequired: field.is_required,
+            isReadOnly: field.is_read_only,
+            field: field.label,
+            value: ForestValueConverter.value_to_forest(field)
+          }
+
+          output[:hook] = 'changeHook' if field.respond_to?(:watch_changes) && field.watch_changes
+
+          if ActionFields.collection_field?(field)
+            collection = datasource.get_collection(field.collection_name)
+            pk = ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(collection)
+            pk_schema = collection.schema[:fields][pk]
+
+            output[:type] = pk_schema.column_type
+            output[:reference] = "#{collection.name}.#{pk}"
+          elsif field.type.end_with?('List')
+            output[:type] = [field.type.delete_suffix('List')]
+          else
+            output[:type] = field.type
+          end
+
+          output[:enums] = field.enum_values if ActionFields.enum_field?(field) || ActionFields.enum_list_field?(field)
+
+          output
+        end
+
+        class << self
+          private
+
+          def build_fields(collection, name, action)
+            return DEFAULT_FIELDS unless action.static_form?
+
+            fields = collection.get_form(nil, name)
+            if fields
+              return fields.map do |field|
+                new_field = build_field_schema(collection.datasource, field)
+                new_field[:default_value] = new_field[:value]
+                new_field.delete(:value)
+
+                new_field
+              end
+            end
+
+            []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module ForestAdminAgent
 
         def self.build_schema(collection)
           {
-            actions: {},
+            actions: build_actions(collection),
             fields: build_fields(collection),
             icon: nil,
             integration: nil,
@@ -29,6 +29,14 @@ module ForestAdminAgent
           fields.map { |name, _field| GeneratorField.build_schema(collection, name) }
                 .sort_by { |v| v[:field] }
         end
+
+        def self.build_actions(collection)
+          if collection.schema[:actions]
+            collection.schema[:actions].keys.sort.map { |name| GeneratorAction.build_schema(collection, name) }
+          else
+            {}
+          end
+        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.29"
+        LIANA_VERSION = "1.0.0-beta.30"
 
         def self.get_serialized_schema(datasource)
           schema_path = Facades::Container.cache(:schema_path)
@@ -75,7 +75,7 @@ module ForestAdminAgent
                   attributes: collection,
                   relationships: {
                     actions: { data: get_smart_features_by_collection('actions', collection_actions) },
-                    segments: { data: get_smart_features_by_collection('segments', collection_actions) }
+                    segments: { data: get_smart_features_by_collection('segments', collection_segments) }
                   }
                 }
               )
@@ -83,7 +83,7 @@ module ForestAdminAgent
 
             {
               data: data,
-              included: included.reject!(&:empty?),
+              included: included.reject!(&:empty?)&.flatten,
               meta: schema[:meta]
             }
           end
@@ -95,6 +95,8 @@ module ForestAdminAgent
               smart_feature[:attributes] = value if with_attributes
               smart_features << smart_feature
             end
+
+            smart_features
           end
         end
       end

data/lib/forest_admin_agent/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminAgent
-  VERSION = "1.0.0-beta.29"
+  VERSION = "1.0.0-beta.30"
 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.29
+  version: 1.0.0.pre.beta.30
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-01-24 00:00:00.000000000 Z
+date: 2024-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -242,6 +242,7 @@ files:
 - lib/forest_admin_agent/routes/abstract_authenticated_route.rb
 - lib/forest_admin_agent/routes/abstract_related_route.rb
 - lib/forest_admin_agent/routes/abstract_route.rb
+- lib/forest_admin_agent/routes/action/action.rb
 - lib/forest_admin_agent/routes/charts/charts.rb
 - lib/forest_admin_agent/routes/resources/count.rb
 - lib/forest_admin_agent/routes/resources/delete.rb
@@ -270,7 +271,10 @@ files:
 - lib/forest_admin_agent/utils/error_messages.rb
 - lib/forest_admin_agent/utils/id.rb
 - lib/forest_admin_agent/utils/query_string_parser.rb
+- lib/forest_admin_agent/utils/schema/action_fields.rb
+- lib/forest_admin_agent/utils/schema/forest_value_converter.rb
 - lib/forest_admin_agent/utils/schema/frontend_filterable.rb
+- lib/forest_admin_agent/utils/schema/generator_action.rb
 - lib/forest_admin_agent/utils/schema/generator_collection.rb
 - lib/forest_admin_agent/utils/schema/generator_field.rb
 - lib/forest_admin_agent/utils/schema/schema_emitter.rb
@@ -288,7 +292,7 @@ files:
 - sig/forest_admin_agent/routes/system/health_check.rbs
 homepage: https://www.forestadmin.com
 licenses:
-- MIT
+- GPL-3.0
 metadata:
   homepage_uri: https://www.forestadmin.com
   source_code_uri: https://github.com/ForestAdmin/agent-ruby