feat(hooks): developers can dynamically add or remove smart actions fields (#465)

BREAKING CHANGE: fields parameters on hook function is no longer a map of field, it is now an array.
change hook is no longer choosen by the field name, field need to have hook defined inside it definition by addin a props hook.

Author: jeffladiray

app/controllers/forest_liana/actions_controller.rb

@@ -27,34 +27,45 @@ def get_record
     end
 
     def get_smart_action_load_ctx(fields)
-      fields = fields.reduce({}) do |p, c|
-        ForestLiana::WidgetsHelper.set_field_widget(c)
-        p.update(c[:field] => c.merge!(value: nil))
+      fields = fields.map do |field|
+        ForestLiana::WidgetsHelper.set_field_widget(field)
+        field[:value] = nil unless field[:value]
+        field
       end
       {:record => get_record, :fields => fields}
     end
 
-    def get_smart_action_change_ctx(fields)
-      fields = fields.reduce({}) do |p, c|
-        field = c.permit!.to_h.symbolize_keys
+    def get_smart_action_change_ctx(fields, field_changed)
+      found_field_changed = fields.find{|field| field[:field] == field_changed}
+      fields = fields.map do |field|
+        field = field.permit!.to_h.symbolize_keys
         ForestLiana::WidgetsHelper.set_field_widget(field)
-        p.update(c[:field] => field)
+        field
       end
-      {:record => get_record, :fields => fields}
+      {:record => get_record,  :field_changed => found_field_changed, :fields => fields}
     end
 
-    def handle_result(result, formatted_fields, action)
-      if result.nil? || !result.is_a?(Hash)
-        return render status: 500, json: { error: 'Error in smart action load hook: hook must return an object' }
+    def handle_result(result, action)
+      if result.nil? || !result.is_a?(Array)
+        return render status: 500, json: { error: 'Error in smart action load hook: hook must return an array of fields' }
       end
-      is_same_data_structure = ForestLiana::IsSameDataStructureHelper::Analyser.new(formatted_fields, result, 1)
-      unless is_same_data_structure.perform
-        return render status: 500, json: { error: 'Error in smart action hook: fields must be unchanged (no addition nor deletion allowed)' }
+
+      # Validate that the fields are well formed.
+      begin
+        # action.hooks[:change] is a hashmap here
+        # to do the validation, only the hook names are require
+        change_hooks_name = action.hooks[:change].nil? ? nil : action.hooks[:change].keys
+        ForestLiana::SmartActionFieldValidator.validate_smart_action_fields(result, action.name, change_hooks_name)
+      rescue ForestLiana::Errors::SmartActionInvalidFieldError => invalid_field_error
+        FOREST_LOGGER.warn invalid_field_error.message
+      rescue ForestLiana::Errors::SmartActionInvalidFieldHookError => invalid_hook_error
+        FOREST_LOGGER.error invalid_hook_error.message
+        return render status: 500, json: { error: invalid_hook_error.message }
       end
 
       # Apply result on fields (transform the object back to an array), preserve order.
-      fields = action.fields.map do |field|
-        updated_field = result[field[:field]]
+      fields = result.map do |field|
+        updated_field = result.find{|f| f[:field] == field[:field]}
 
         # Reset `value` when not present in `enums` (which means `enums` has changed).
         if updated_field[:enums].is_a?(Array)
@@ -72,7 +83,7 @@ def handle_result(result, formatted_fields, action)
         updated_field
       end
 
-      render serializer: nil, json: { fields: fields}, status: :ok
+      render serializer: nil, json: { fields: fields }, status: :ok
     end
 
     def load
@@ -81,32 +92,36 @@ def load
       if !action
         render status: 500, json: {error: 'Error in smart action load hook: cannot retrieve action from collection'}
       else
-        # Transform fields from array to an object to ease usage in hook, adds null value.
+        # Get the smart action hook load context
         context = get_smart_action_load_ctx(action.fields)
-        formatted_fields = context[:fields].clone # clone for following test on is_same_data_structure
 
         # Call the user-defined load hook.
         result = action.hooks[:load].(context)
 
-        handle_result(result, formatted_fields, action)
+        handle_result(result, action)
       end
     end
 
     def change
       action = get_action(params[:collectionName])
 
       if !action
-        render status: 500, json: {error: 'Error in smart action change hook: cannot retrieve action from collection'}
-      else
-        # Transform fields from array to an object to ease usage in hook.
-        context = get_smart_action_change_ctx(params[:fields])
-        formatted_fields = context[:fields].clone # clone for following test on is_same_data_structure
+        return render status: 500, json: {error: 'Error in smart action change hook: cannot retrieve action from collection'}
+      elsif params[:fields].nil?
+        return render status: 500, json: {error: 'Error in smart action change hook: fields params is mandatory'}
+      elsif !params[:fields].is_a?(Array)
+        return render status: 500, json: {error: 'Error in smart action change hook: fields params must be an array'}
+      end
 
-        # Call the user-defined change hook.
-        result = action.hooks[:change][params[:changedField]].(context)
+      # Get the smart action hook change context
+      context = get_smart_action_change_ctx(params[:fields], params[:changedField])
 
-        handle_result(result, formatted_fields, action)
-      end
+      field_changed_hook = context[:field_changed][:hook]
+
+      # Call the user-defined change hook.
+      result = action.hooks[:change][field_changed_hook].(context)
+
+      handle_result(result, action)
     end
   end
 end

app/helpers/forest_liana/is_same_data_structure_helper.rb

@@ -52,6 +52,7 @@ class ApimapSorter
       'description',
       'position',
       'widget',
+      'hook',
     ]
     KEYS_SEGMENT = ['name']
 

app/services/forest_liana/apimap_sorter.rb

@@ -0,0 +1,49 @@
+module ForestLiana
+  class SmartActionFieldValidator
+
+    @@accepted_primitive_field_type = [
+      'String',
+      'Number',
+      'Date',
+      'Boolean',
+      'File',
+      'Enum',
+      'Json',
+      'Dateonly',
+    ]
+
+    @@accepted_array_field_type = [
+      'String',
+      'Number',
+      'Date',
+      'boolean',
+      'File',
+      'Enum',
+    ]
+
+    def self.validate_field(field, action_name)
+      raise ForestLiana::Errors::SmartActionInvalidFieldError.new(action_name, nil, "The field attribute must be defined") if !field || field[:field].nil?
+      raise ForestLiana::Errors::SmartActionInvalidFieldError.new(action_name, nil, "The field attribute must be a string.") if !field[:field].is_a?(String)
+      raise ForestLiana::Errors::SmartActionInvalidFieldError.new(action_name, field[:field], "The description attribute must be a string.") if field[:description] && !field[:description].is_a?(String)
+      raise ForestLiana::Errors::SmartActionInvalidFieldError.new(action_name, field[:field], "The enums attribute must be an array.") if field[:enums] && !field[:enums].is_a?(Array)
+      raise ForestLiana::Errors::SmartActionInvalidFieldError.new(action_name, field[:field], "The reference attribute must be a string.") if field[:reference] && !field[:reference].is_a?(String)
+
+      is_type_valid = field[:type].is_a?(Array) ?
+        @@accepted_array_field_type.include?(field[:type][0]) :
+        @@accepted_primitive_field_type.include?(field[:type])
+        
+      raise ForestLiana::Errors::SmartActionInvalidFieldError.new(action_name, field[:field], "The type attribute must be a valid type. See the documentation for more information. https://docs.forestadmin.com/documentation/reference-guide/fields/create-and-manage-smart-fields#available-field-options.") if !is_type_valid
+    end
+
+    def self.validate_field_change_hook(field, action_name, hooks)
+      raise ForestLiana::Errors::SmartActionInvalidFieldHookError.new(action_name, field[:field], field[:hook]) if field[:hook] && !hooks.find{|hook| hook == field[:hook]}
+    end
+
+    def self.validate_smart_action_fields(fields, action_name, change_hooks)
+      fields.map{|field|
+        self.validate_field(field.symbolize_keys, action_name)
+        self.validate_field_change_hook(field.symbolize_keys, action_name, change_hooks) if change_hooks
+      }
+    end
+  end
+end

app/services/forest_liana/smart_action_field_validator.rb

@@ -13,6 +13,23 @@ def initialize(message="Invalid SQL query for this Live Query")
       end
     end
 
+    class SmartActionInvalidFieldError < StandardError
+      def initialize(action_name=nil, field_name=nil, message=nil)
+        error_message = ""
+        error_message << "Error while parsing action \"#{action_name}\"" if !action_name.nil?
+        error_message << " on field \"#{field_name}\"" if !field_name.nil?
+        error_message << ": " if !field_name.nil? || !action_name.nil?
+        error_message << message if !message.nil?
+        super(error_message)
+      end
+    end
+
+    class SmartActionInvalidFieldHookError < StandardError
+      def initialize(action_name=nil, field_name=nil, hook_name=nil)
+        super("The hook \"#{hook_name}\" of \"#{field_name}\" field on the smart action \"#{action_name}\" is not defined.")
+      end
+    end
+
     class ExpectedError < StandardError
       attr_reader :error_code, :status, :message, :name
 

config/initializers/errors.rb

@@ -60,7 +60,7 @@ def generate_action_hooks()
           a = get_action(c, action['name'])
           load = !a.hooks.nil? && a.hooks.key?(:load) && a.hooks[:load].is_a?(Proc)
           change = !a.hooks.nil? && a.hooks.key?(:change) && a.hooks[:change].is_a?(Hash) ? a.hooks[:change].keys : []
-          action['hooks'] = {:load => load, :change => change}
+          action['hooks'] = {'load' => load, 'change' => change}
         end
       end
     end

lib/forest_liana/bootstrapper.rb

@@ -63,6 +63,7 @@ class SchemaFileUpdater
       'description',
       'position',
       'widget',
+      'hook',
     ]
     KEYS_SEGMENT = ['name']
 
@@ -96,6 +97,13 @@ def initialize filename, collections, meta
         end
 
         collection['actions'] = collection['actions'].map do |action|
+          begin
+            SmartActionFieldValidator.validate_smart_action_fields(action['fields'], action['name'], action['hooks']['change'])
+          rescue ForestLiana::Errors::SmartActionInvalidFieldError => invalid_field_error
+            FOREST_LOGGER.warn invalid_field_error.message
+          rescue ForestLiana::Errors::SmartActionInvalidFieldHookError => invalid_hook_error
+            FOREST_LOGGER.error invalid_hook_error.message
+          end
           action['fields'] = action['fields'].map { |field| field.slice(*KEYS_ACTION_FIELD) }
           action.slice(*KEYS_ACTION)
         end