forest_liana 6.3.8 → 7.0.0.beta.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0fd5ef4e67fd45b6a701da7dbf8da36d6f6abb3d9e2be4d0031d0495a10727a
-  data.tar.gz: 9c823060491af5ff42f098e041ffe9f2ac672865c4a790e4b8bb3f1bb1e7447b
+  metadata.gz: 6be4888e921b11142c5bc7774e6a0c9ce9a91b7e0b8ceb8a812cff8e297b540a
+  data.tar.gz: '043584e75c96d49b34a4ab6ec0e0f0315700eb86a7d061fb03de66c095840b1c'
 SHA512:
-  metadata.gz: c6a0639f27ebecd6f7e66e83bbdc527a08e0483435e6485c80ed66f45832c886ef50cb46402a4b74b1ff8cc6b8f284419f53fd1ebebf532c57fe089d2d0bdec6
-  data.tar.gz: 0e329ab499ed3b2414c50097f3b2cad74733c0bc51db835b25bb1a9713229f8feb6f42ad1b7fa3a038f73e357dc46bc3cad0fc6f6ad61224f306c644d02fbf1e
+  metadata.gz: bfc23dfba08023225f17e44860caf95dc2fe041bcf81a1d61651ee96cea59563aa2c97ee6a1bcdc2e38e2e56a0f9c7c5e144b64583286af70864ec4d636a5795
+  data.tar.gz: 2cc2bf17cc1a235264db9981e33e99b22c23468514bf136e3379523020ca1efd906b792b46c45b6893f0edb279d8845c79e2e14ee8821ee47db6fc87d4992692

data/app/controllers/forest_liana/actions_controller.rb

@@ -27,34 +27,45 @@ module ForestLiana
     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 @@ module ForestLiana
         updated_field
       end
 
-      render serializer: nil, json: { fields: fields}, status: :ok
+      render serializer: nil, json: { fields: fields }, status: :ok
     end
 
     def load
@@ -81,14 +92,13 @@ module ForestLiana
       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
 
@@ -96,17 +106,22 @@ module ForestLiana
       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

data/app/controllers/forest_liana/application_controller.rb

@@ -34,14 +34,14 @@ module ForestLiana
 
     def serialize_model(record, options = {})
       options[:is_collection] = false
-      json = JSONAPI::Serializer.serialize(record, options)
+      json = ForestAdmin::JSONAPI::Serializer.serialize(record, options)
 
       force_utf8_encoding(json)
     end
 
     def serialize_models(records, options = {}, fields_searched = [])
       options[:is_collection] = true
-      json = JSONAPI::Serializer.serialize(records, options)
+      json = ForestAdmin::JSONAPI::Serializer.serialize(records, options)
 
       if options[:params] && options[:params][:search]
         # NOTICE: Add the Smart Fields with a 'String' type.

data/app/controllers/forest_liana/associations_controller.rb

@@ -41,7 +41,7 @@ module ForestLiana
         updater.perform
 
         if updater.errors
-          render serializer: nil, json: JSONAPI::Serializer.serialize_errors(
+          render serializer: nil, json: ForestAdmin::JSONAPI::Serializer.serialize_errors(
             updater.errors), status: 422
         else
           head :no_content

data/app/controllers/forest_liana/base_controller.rb

@@ -24,7 +24,7 @@ module ForestLiana
           end
         end
       rescue ForestLiana::Errors::ExpectedError => exception
-        error_data = JSONAPI::Serializer.serialize_errors([{
+        error_data = ForestAdmin::JSONAPI::Serializer.serialize_errors([{
           status: exception.error_code,
           detail: exception.message
         }])

data/app/controllers/forest_liana/resources_controller.rb

@@ -41,7 +41,7 @@ module ForestLiana
           status: :unprocessable_entity, serializer: nil
       rescue ForestLiana::Errors::ExpectedError => error
         error.display_error
-        error_data = JSONAPI::Serializer.serialize_errors([{
+        error_data = ForestAdmin::JSONAPI::Serializer.serialize_errors([{
           status: error.error_code,
           detail: error.message
         }])
@@ -73,7 +73,7 @@ module ForestLiana
           status: :unprocessable_entity, serializer: nil
       rescue ForestLiana::Errors::ExpectedError => error
         error.display_error
-        error_data = JSONAPI::Serializer.serialize_errors([{
+        error_data = ForestAdmin::JSONAPI::Serializer.serialize_errors([{
           status: error.error_code,
           detail: error.message
         }])
@@ -108,12 +108,12 @@ module ForestLiana
         creator.perform
 
         if creator.errors
-          render serializer: nil, json: JSONAPI::Serializer.serialize_errors(
+          render serializer: nil, json: ForestAdmin::JSONAPI::Serializer.serialize_errors(
             creator.errors), status: 400
         elsif creator.record.valid?
           render serializer: nil, json: render_record_jsonapi(creator.record)
         else
-          render serializer: nil, json: JSONAPI::Serializer.serialize_errors(
+          render serializer: nil, json: ForestAdmin::JSONAPI::Serializer.serialize_errors(
             creator.record.errors), status: 400
         end
       rescue => error
@@ -131,12 +131,12 @@ module ForestLiana
         updater.perform
 
         if updater.errors
-          render serializer: nil, json: JSONAPI::Serializer.serialize_errors(
+          render serializer: nil, json: ForestAdmin::JSONAPI::Serializer.serialize_errors(
             updater.errors), status: 400
         elsif updater.record.valid?
           render serializer: nil, json: render_record_jsonapi(updater.record)
         else
-          render serializer: nil, json: JSONAPI::Serializer.serialize_errors(
+          render serializer: nil, json: ForestAdmin::JSONAPI::Serializer.serialize_errors(
             updater.record.errors), status: 400
         end
       rescue => error

data/app/serializers/forest_liana/intercom_attribute_serializer.rb

@@ -1,6 +1,6 @@
 module ForestLiana
   class IntercomAttributeSerializer
-    include JSONAPI::Serializer
+    include ForestAdmin::JSONAPI::Serializer
 
     attribute :session_count
     attribute :last_seen_ip

data/app/serializers/forest_liana/intercom_conversation_serializer.rb

@@ -1,6 +1,6 @@
 module ForestLiana
   class IntercomConversationSerializer
-    include JSONAPI::Serializer
+    include ForestAdmin::JSONAPI::Serializer
 
     attribute :created_at
     attribute :updated_at

data/app/serializers/forest_liana/mixpanel_event_serializer.rb

@@ -1,6 +1,6 @@
 module ForestLiana
   class MixpanelEventSerializer
-    include JSONAPI::Serializer
+    include ForestAdmin::JSONAPI::Serializer
 
     attribute :id
     attribute :event

data/app/serializers/forest_liana/serializer_factory.rb

@@ -53,7 +53,7 @@ module ForestLiana
 
     def serializer_for(active_record_class)
       serializer = Class.new {
-        include JSONAPI::Serializer
+        include ForestAdmin::JSONAPI::Serializer
 
         def self_link
           "/forest#{super.underscore}"

data/app/serializers/forest_liana/stat_serializer.rb

@@ -1,6 +1,6 @@
 module ForestLiana
   class StatSerializer
-    include JSONAPI::Serializer
+    include ForestAdmin::JSONAPI::Serializer
 
     attribute :value
 

data/app/serializers/forest_liana/stripe_bank_account_serializer.rb

@@ -1,6 +1,6 @@
 module ForestLiana
   class StripeBankAccountSerializer
-    include JSONAPI::Serializer
+    include ForestAdmin::JSONAPI::Serializer
 
     attribute :account_holder_name
     attribute :account_holder_type

data/app/serializers/forest_liana/stripe_card_serializer.rb

@@ -1,6 +1,6 @@
 module ForestLiana
   class StripeCardSerializer
-    include JSONAPI::Serializer
+    include ForestAdmin::JSONAPI::Serializer
 
     attribute :last4
     attribute :brand

data/app/serializers/forest_liana/stripe_invoice_serializer.rb

@@ -1,6 +1,6 @@
 module ForestLiana
   class StripeInvoiceSerializer
-    include JSONAPI::Serializer
+    include ForestAdmin::JSONAPI::Serializer
 
     attribute :amount_due
     attribute :amount_paid

data/app/serializers/forest_liana/stripe_payment_serializer.rb

@@ -1,6 +1,6 @@
 module ForestLiana
   class StripePaymentSerializer
-    include JSONAPI::Serializer
+    include ForestAdmin::JSONAPI::Serializer
 
     attribute :description
     attribute :refunded

data/app/serializers/forest_liana/stripe_subscription_serializer.rb

@@ -1,6 +1,6 @@
 module ForestLiana
   class StripeSubscriptionSerializer
-    include JSONAPI::Serializer
+    include ForestAdmin::JSONAPI::Serializer
 
     attribute :cancel_at_period_end
     attribute :canceled_at

data/app/services/forest_liana/apimap_sorter.rb

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

data/app/services/forest_liana/smart_action_field_validator.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

data/config/initializers/errors.rb

@@ -13,6 +13,23 @@ module ForestLiana
       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
 

data/config/initializers/logger.rb

@@ -3,21 +3,24 @@ module ForestLiana
   class Logger
     class << self
       def log
-        logger = ::Logger.new(STDOUT)
-        logger_colors = {
-          DEBUG: 34,
-          WARN: 33,
-          ERROR: 31,
-          INFO: 37
-        }
+        if ForestLiana.logger != nil
+          logger = ForestLiana.logger
+        else
+          logger = ::Logger.new(STDOUT)
+          logger_colors = {
+            DEBUG: 34,
+            WARN: 33,
+            ERROR: 31,
+            INFO: 37
+          }
 
-        logger.formatter = proc do |severity, datetime, progname, message|
-          displayed_message = "[#{datetime.to_s(:db)}] Forest 🌳🌳🌳  " \
-            "#{message}\n"
-          "\e[#{logger_colors[severity.to_sym]}m#{displayed_message}\033[0m"
+          logger.formatter = proc do |severity, datetime, progname, message|
+            displayed_message = "[#{datetime.to_s(:db)}] Forest 🌳🌳🌳  " \
+                  "#{message}\n"
+                "\e[#{logger_colors[severity.to_sym]}m#{displayed_message}\033[0m"
+            end
+          logger
         end
-
-        logger
       end
     end
   end

data/lib/forest_liana.rb

@@ -27,6 +27,7 @@ module ForestLiana
   mattr_accessor :user_class_name
   mattr_accessor :names_overriden
   mattr_accessor :meta
+  mattr_accessor :logger
   # TODO: Remove once lianas prior to 2.0.0 are not supported anymore.
   mattr_accessor :names_old_overriden
 
@@ -38,6 +39,7 @@ module ForestLiana
   self.user_class_name = nil
   self.names_overriden = {}
   self.meta = {}
+  self.logger = nil
 
   @config_dir = 'lib/forest_liana/**/*.rb'
 

data/lib/forest_liana/bootstrapper.rb

@@ -60,7 +60,7 @@ module ForestLiana
           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
@@ -139,7 +139,7 @@ module ForestLiana
 
       # Monkey patch the find_serializer_class_name method to specify the
       # good serializer to use.
-      ::JSONAPI::Serializer.class_eval do
+      ::ForestAdmin::JSONAPI::Serializer.class_eval do
         def self.find_serializer_class_name(record, options)
           if record.respond_to?(:jsonapi_serializer_class_name)
             record.jsonapi_serializer_class_name.to_s

data/lib/forest_liana/schema_file_updater.rb

@@ -63,6 +63,7 @@ module ForestLiana
       'description',
       'position',
       'widget',
+      'hook',
     ]
     KEYS_SEGMENT = ['name']
 
@@ -96,6 +97,13 @@ module ForestLiana
         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

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "6.3.8"
+  VERSION = "7.0.0.beta.2"
 end

data/spec/config/initializers/logger_spec.rb

@@ -0,0 +1,30 @@
+module ForestLiana
+  describe Logger do
+    describe 'self.log' do
+      describe 'with a logger overload' do
+        it 'should return the given logger' do
+          logger = ActiveSupport::Logger.new($stdout)
+          logger.formatter = proc do |severity, datetime, progname, msg|
+            {:message => msg}.to_json
+          end
+          ForestLiana.logger = logger
+
+          expect(Logger.log.is_a?(ActiveSupport::Logger)).to be_truthy
+          expect { Logger.log.error "[error] override logger" }.to output({:message => "[error] override logger"}.to_json).to_stdout_from_any_process
+          expect { Logger.log.info "[info] override logger" }.to output({:message => "[info] override logger"}.to_json).to_stdout_from_any_process
+        end
+      end
+
+      describe 'with no logger overload' do
+        it 'should return an instance of ::Logger' do
+          ForestLiana.logger = nil
+
+          expect(Logger.log.is_a?(::Logger)).to be_truthy
+          # RegExp is used to check for the forestadmin logger format
+          expect { Logger.log.error "[error] default logger" }.to output(/\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\] Forest .* \[error\]/).to_stdout_from_any_process
+          expect { Logger.log.info "[info] default logger" }.to output(/\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\] Forest .* \[info\]/).to_stdout_from_any_process
+        end
+      end
+    end
+  end
+end

data/spec/lib/forest_liana/schema_file_updater_spec.rb

@@ -0,0 +1,94 @@
+module ForestLiana
+  describe SchemaFileUpdater do
+    describe "initialize" do
+      describe "without any collections nor meta" do
+        it "should set collections as an empty array and meta as an empty object" do
+          schema_file_updater = ForestLiana::SchemaFileUpdater.new("test.txt", [], {})
+          expect(schema_file_updater.instance_variable_get(:@collections)).to eq([])
+          expect(schema_file_updater.instance_variable_get(:@meta)).to eq({})
+        end
+      end
+
+      describe "with a given collection" do
+        describe "when the collection has a smart action action" do
+          it "should save the smart action" do
+            collections = [{
+              "fields" => [],
+              "actions" => [{
+                "fields" => [],
+                "name" => "test",
+                "hooks" => {
+                  "change" => []
+                }
+              }],
+              "segments" => []
+            }]
+            schema_file_updater = ForestLiana::SchemaFileUpdater.new("test.txt", collections, {})
+            expect(schema_file_updater.instance_variable_get(:@collections))
+              .to eq(collections)
+          end
+
+          describe "when a smart action field is malformed" do
+            it "should display a warning message" do
+              collections = [{
+                "fields" => [],
+                "actions" => [{
+                  "fields" => [{}],
+                  "name" => "test",
+                  "hooks" => {
+                    "change" => []
+                  }
+                }],
+                "segments" => []
+              }]
+              allow(FOREST_LOGGER).to receive(:warn)
+              schema_file_updater = ForestLiana::SchemaFileUpdater.new("test.txt", collections, {})
+              expect(FOREST_LOGGER).to have_received(:warn).with('Error while parsing action "test": The field attribute must be defined')
+            end
+          end
+
+          describe "when a smart action change field hook does not exist" do
+            it "should display an error message" do
+              collections = [{
+                "fields" => [],
+                "actions" => [{
+                  "fields" => [{
+                    "field" => "testField",
+                    "hook" => "undefinedHook",
+                    "type" => "String",
+                  }],
+                  "name" => "test",
+                  "hooks" => {
+                    "change" => []
+                  }
+                }],
+                "segments" => []
+              }]
+
+              allow(FOREST_LOGGER).to receive(:error)
+              schema_file_updater = ForestLiana::SchemaFileUpdater.new("test.txt", collections, {})
+              expect(FOREST_LOGGER).to have_received(:error).with('The hook "undefinedHook" of "testField" field on the smart action "test" is not defined.')
+            end
+          end
+        end
+      end
+    end
+
+    describe "perform" do
+      it "should call file puts with pretty printed data" do
+        file = instance_double(File, read: "stubbed read")
+
+        allow(File).to receive(:open).with("test.txt", "w") { |&block| block.call(file) }
+
+        schema_file_updater = ForestLiana::SchemaFileUpdater.new("test.txt", [], {})
+        expected_result = schema_file_updater.pretty_print({
+          "collections" => [],
+          "meta" => {}
+        })
+
+        expect(file).to receive(:puts).with(expected_result)
+        schema_file_updater.perform
+      end
+    end
+  end
+end

data/spec/requests/actions_controller_spec.rb

@@ -30,6 +30,7 @@ describe 'Requesting Actions routes', :type => :request  do
         reference: nil,
         description: nil,
         widget: nil,
+        hook: 'on_foo_changed'
     }
     enum = {
         field: 'enum',
@@ -50,10 +51,10 @@ describe 'Requesting Actions routes', :type => :request  do
               context[:fields]
             },
             :change => {
-              'foo' => -> (context) {
-                fields = context[:fields]
-                fields['foo'][:value] = 'baz'
-                return fields
+              'on_foo_changed' => -> (context) {
+                foo = context[:fields].find{|field| field[:field] == 'foo'}
+                foo[:value] = 'baz'
+                context[:fields]
               }
             }
         }
@@ -66,7 +67,7 @@ describe 'Requesting Actions routes', :type => :request  do
               1
             },
             :change => {
-                'foo' => -> (context) {
+                'on_foo_changed' => -> (context) {
                   1
                 }
             }
@@ -77,11 +78,10 @@ describe 'Requesting Actions routes', :type => :request  do
         fields: [foo],
         hooks: {
             :load => -> (context) {
-              context[:fields]['baz'] = foo.clone.update({field: 'baz'})
-              context[:fields]
+              {}
             },
             :change => {
-                'foo' => -> (context) {
+                'on_foo_changed' => -> (context) {
                   context[:fields]['baz'] = foo.clone.update({field: 'baz'})
                   context[:fields]
                 }
@@ -93,10 +93,11 @@ describe 'Requesting Actions routes', :type => :request  do
       fields: [foo, enum],
       hooks: {
         :change => {
-          'foo' => -> (context) {
+          'on_foo_changed' => -> (context) {
             fields = context[:fields]
-            fields['enum'][:enums] = %w[c d e]
-            return fields
+            enum_field = fields.find{|field| field[:field] == 'enum'}
+            enum_field[:enums] = %w[c d e]
+            fields
           }
         }
       }
@@ -107,10 +108,11 @@ describe 'Requesting Actions routes', :type => :request  do
         fields: [foo, multiple_enum],
         hooks: {
             :change => {
-                'foo' => -> (context) {
+                'on_foo_changed' => -> (context) {
                   fields = context[:fields]
-                  fields['multipleEnum'][:enums] = %w[c d z]
-                  return fields
+                  enum_field = fields.find{|field| field[:field] == 'multipleEnum'}
+                  enum_field[:enums] = %w[c d z]
+                  fields
                 }
             }
         }
@@ -136,16 +138,19 @@ describe 'Requesting Actions routes', :type => :request  do
       it 'should respond 500 with bad params' do
         post '/forest/actions/my_action/hooks/load', params: {}
         expect(response.status).to eq(500)
+        expect(JSON.parse(response.body)).to eq({'error' => 'Error in smart action load hook: cannot retrieve action from collection'})
       end
 
       it 'should respond 500 with bad hook result type' do
         post '/forest/actions/fail_action/hooks/load', params: JSON.dump(params), headers: { 'CONTENT_TYPE' => 'application/json' }
         expect(response.status).to eq(500)
+        expect(JSON.parse(response.body)).to eq({'error' => 'Error in smart action load hook: hook must return an array of fields'})
       end
 
       it 'should respond 500 with bad hook result data structure' do
         post '/forest/actions/cheat_action/hooks/load', params: JSON.dump(params), headers: { 'CONTENT_TYPE' => 'application/json' }
         expect(response.status).to eq(500)
+        expect(JSON.parse(response.body)).to eq({'error' => 'Error in smart action load hook: hook must return an array of fields'})
       end
     end
 
@@ -163,18 +168,15 @@ describe 'Requesting Actions routes', :type => :request  do
       end
 
       it 'should respond 500 with bad params' do
-        post '/forest/actions/my_action/hooks/change', params: {}
+        post '/forest/actions/my_action/hooks/change', params: JSON.dump({collectionName: 'Island'}), headers: { 'CONTENT_TYPE' => 'application/json' }
         expect(response.status).to eq(500)
+        expect(JSON.parse(response.body)).to eq({'error' => 'Error in smart action change hook: fields params is mandatory'})
       end
 
       it 'should respond 500 with bad hook result type' do
         post '/forest/actions/fail_action/hooks/change', params: JSON.dump(params), headers: { 'CONTENT_TYPE' => 'application/json' }
         expect(response.status).to eq(500)
-      end
-
-      it 'should respond 500 with bad hook result data structure' do
-        post '/forest/actions/cheat_action/hooks/change', params: JSON.dump(params), headers: { 'CONTENT_TYPE' => 'application/json' }
-        expect(response.status).to eq(500)
+        expect(JSON.parse(response.body)).to eq({'error' => 'Error in smart action load hook: hook must return an array of fields'})
       end
 
       it 'should reset value when enums has changed' do

data/spec/services/forest_liana/smart_action_field_validator_spec.rb

@@ -0,0 +1,70 @@
+module ForestLiana
+  describe SmartActionFieldValidator do
+    describe "self.validate_field" do
+      it "should raise an SmartActionInvalidFieldError with nil field" do
+        expect { SmartActionFieldValidator.validate_field(nil, "actionName") }.to raise_error(ForestLiana::Errors::SmartActionInvalidFieldError, 'Error while parsing action "actionName": The field attribute must be defined')
+      end
+
+      it "should raise an SmartActionInvalidFieldError with a field that is not a string" do
+        expect { SmartActionFieldValidator.validate_field({
+          :field => 5
+        }, "actionName") }.to raise_error(ForestLiana::Errors::SmartActionInvalidFieldError, 'Error while parsing action "actionName": The field attribute must be a string.')
+      end
+
+      it "should raise an SmartActionInvalidFieldError with description that is not a string" do
+        expect { SmartActionFieldValidator.validate_field({
+          :field => "field",
+          :description => 5
+        }, "actionName") }.to raise_error(ForestLiana::Errors::SmartActionInvalidFieldError, 'Error while parsing action "actionName" on field "field": The description attribute must be a string.')
+      end
+
+      it "should raise an SmartActionInvalidFieldError with an enums that is not an array" do
+        expect { SmartActionFieldValidator.validate_field({
+          :field => "field",
+          :enums => "NotAnArray"
+        }, "actionName") }.to raise_error(ForestLiana::Errors::SmartActionInvalidFieldError, 'Error while parsing action "actionName" on field "field": The enums attribute must be an array.')
+      end
+
+      it "should raise an SmartActionInvalidFieldError with a reference that is not a string" do
+        expect { SmartActionFieldValidator.validate_field({
+          :field => "field",
+          :type => "String",
+          :reference => 5
+        }, "actionName") }.to raise_error(ForestLiana::Errors::SmartActionInvalidFieldError, 'Error while parsing action "actionName" on field "field": The reference attribute must be a string.')
+      end
+
+      it "should raise an SmartActionInvalidFieldError with an invalid type" do
+        expect { SmartActionFieldValidator.validate_field({
+          :field => "field",
+          :type => "AbsolutelyNotAValidType"
+        }, "actionName") }.to raise_error(ForestLiana::Errors::SmartActionInvalidFieldError, 'Error while parsing action "actionName" on 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.')
+      end
+
+      it "should not raise any error when everything is configured correctly" do
+        expect { SmartActionFieldValidator.validate_field({
+          :field => "field",
+          :type => "String",
+          :description => "field description"
+        }, "actionName") }.not_to raise_error
+      end
+    end
+
+    describe "self.validate_field_change_hook" do
+      it "should raise an SmartActionInvalidFieldHookError with an invalid type" do
+        expect { SmartActionFieldValidator.validate_field_change_hook({
+          :field => "field",
+          :type => "AbsolutelyNotAValidType",
+          :hook => "hookThatDoesNotExist"
+        }, "actionName", []) }.to raise_error(ForestLiana::Errors::SmartActionInvalidFieldHookError)
+      end
+
+      it "should not raise any error when everything is configured correctly" do
+        expect { SmartActionFieldValidator.validate_field_change_hook({
+          :field => "field",
+          :type => "AbsolutelyNotAValidType",
+          :hook => "on_field_changed"
+        }, "actionName", ["on_field_changed"]) }.not_to raise_error
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forest_liana
 version: !ruby/object:Gem::Version
-  version: 6.3.8
+  version: 7.0.0.beta.2
 platform: ruby
 authors:
 - Sandro Munda
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-26 00:00:00.000000000 Z
+date: 2021-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '4.0'
 - !ruby/object:Gem::Dependency
-  name: jsonapi-serializers
+  name: forestadmin-jsonapi-serializers
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -225,7 +225,6 @@ files:
 - app/helpers/forest_liana/adapter_helper.rb
 - app/helpers/forest_liana/application_helper.rb
 - app/helpers/forest_liana/decoration_helper.rb
-- app/helpers/forest_liana/is_same_data_structure_helper.rb
 - app/helpers/forest_liana/query_helper.rb
 - app/helpers/forest_liana/schema_helper.rb
 - app/helpers/forest_liana/widgets_helper.rb
@@ -283,6 +282,7 @@ files:
 - app/services/forest_liana/schema_utils.rb
 - app/services/forest_liana/scope_validator.rb
 - app/services/forest_liana/search_query_builder.rb
+- app/services/forest_liana/smart_action_field_validator.rb
 - app/services/forest_liana/stat_getter.rb
 - app/services/forest_liana/stripe_base_getter.rb
 - app/services/forest_liana/stripe_invoice_getter.rb
@@ -316,6 +316,7 @@ files:
 - lib/generators/forest_liana/install_generator.rb
 - lib/tasks/display_apimap.rake
 - lib/tasks/send_apimap.rake
+- spec/config/initializers/logger_spec.rb
 - spec/dummy/README.rdoc
 - spec/dummy/Rakefile
 - spec/dummy/app/assets/config/manifest.js
@@ -367,9 +368,9 @@ files:
 - spec/dummy/db/schema.rb
 - spec/dummy/lib/forest_liana/collections/location.rb
 - spec/dummy/lib/forest_liana/collections/user.rb
-- spec/helpers/forest_liana/is_same_data_structure_helper_spec.rb
 - spec/helpers/forest_liana/query_helper_spec.rb
 - spec/helpers/forest_liana/schema_helper_spec.rb
+- spec/lib/forest_liana/schema_file_updater_spec.rb
 - spec/rails_helper.rb
 - spec/requests/actions_controller_spec.rb
 - spec/requests/authentications_spec.rb
@@ -386,6 +387,7 @@ files:
 - spec/services/forest_liana/permissions_getter_spec.rb
 - spec/services/forest_liana/resources_getter_spec.rb
 - spec/services/forest_liana/schema_adapter_spec.rb
+- spec/services/forest_liana/smart_action_field_validator_spec.rb
 - spec/spec_helper.rb
 - test/dummy/README.rdoc
 - test/dummy/Rakefile
@@ -494,9 +496,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.1.2
 signing_key: 
@@ -602,12 +604,13 @@ test_files:
 - spec/services/forest_liana/permissions_checker_acl_enabled_spec.rb
 - spec/services/forest_liana/filters_parser_spec.rb
 - spec/services/forest_liana/schema_adapter_spec.rb
+- spec/services/forest_liana/smart_action_field_validator_spec.rb
 - spec/services/forest_liana/line_stat_getter_spec.rb
 - spec/services/forest_liana/permissions_formatter_spec.rb
 - spec/services/forest_liana/permissions_checker_live_queries_spec.rb
 - spec/services/forest_liana/apimap_sorter_spec.rb
 - spec/services/forest_liana/permissions_checker_acl_disabled_spec.rb
-- spec/helpers/forest_liana/is_same_data_structure_helper_spec.rb
+- spec/config/initializers/logger_spec.rb
 - spec/helpers/forest_liana/schema_helper_spec.rb
 - spec/helpers/forest_liana/query_helper_spec.rb
 - spec/dummy/db/schema.rb
@@ -661,6 +664,7 @@ test_files:
 - spec/dummy/app/models/location.rb
 - spec/dummy/app/models/island.rb
 - spec/dummy/app/models/reference.rb
+- spec/lib/forest_liana/schema_file_updater_spec.rb
 - spec/rails_helper.rb
 - spec/requests/stats_spec.rb
 - spec/requests/resources_spec.rb

data/app/helpers/forest_liana/is_same_data_structure_helper.rb

@@ -1,44 +0,0 @@
-require 'set'
-
-module ForestLiana
-  module IsSameDataStructureHelper
-    class Analyser
-      def initialize(object, other, deep = 0)
-        @object = object
-        @other = other
-        @deep = deep
-      end
-
-      def are_objects(object, other)
-        object && other && object.is_a?(Hash) && other.is_a?(Hash)
-      end
-
-      def check_keys(object, other, step = 0)
-        unless are_objects(object, other)
-          return false
-        end
-
-        object_keys = object.keys
-        other_keys = other.keys
-
-        if object_keys.length != other_keys.length
-          return false
-        end
-
-        object_keys_set = object_keys.to_set
-        other_keys.each { |key|
-          if !object_keys_set.member?(key) || (step + 1 <= @deep && !check_keys(object[key], other[key], step + 1))
-            return false
-          end
-        }
-
-        return true
-      end
-
-      def perform
-        check_keys(@object, @other)
-      end
-    end
-  end
-end
-

data/spec/helpers/forest_liana/is_same_data_structure_helper_spec.rb

@@ -1,87 +0,0 @@
-module ForestLiana
-  context 'IsSameDataStructure class' do
-    it 'should: be valid with simple data' do
-      object = {:a => 'a', :b => 'b'}
-      other = {:a => 'a', :b => 'b'}
-      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
-      expect(result).to be true
-    end
-
-    it 'should: be invalid with simple data' do
-      object = {:a => 'a', :b => 'b'}
-      other = {:a => 'a', :c => 'c'}
-      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
-      expect(result).to be false
-    end
-
-    it 'should: be invalid with not same hash' do
-      object = {:a => 'a', :b => 'b'}
-      other = {:a => 'a', :b => 'b', :c => 'c'}
-      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
-      expect(result).to be false
-    end
-
-    it 'should: be invalid with nil' do
-      object = nil
-      other = {:a => 'a', :b => 'b', :c => 'c'}
-      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
-      expect(result).to be false
-    end
-
-    it 'should: be invalid with not hash' do
-      object = nil
-      other = {:a => 'a', :b => 'b', :c => 'c'}
-      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
-      expect(result).to be false
-    end
-
-    it 'should: be invalid with integer' do
-      object = 1
-      other = {:a => 'a', :b => 'b', :c => 'c'}
-      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
-      expect(result).to be false
-    end
-
-    it 'should: be invalid with string' do
-      object = 'a'
-      other = {:a => 'a', :b => 'b', :c => 'c'}
-      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
-      expect(result).to be false
-    end
-
-    it 'should: be valid with depth 1' do
-      object = {:a => {:c => 'c'}, :b => {:d => 'd'}}
-      other = {:a => {:c => 'c'}, :b => {:d => 'd'}}
-      result = IsSameDataStructureHelper::Analyser.new(object, other, 1).perform
-      expect(result).to be true
-    end
-
-    it 'should: be invalid with depth 1' do
-      object = {:a => {:c => 'c'}, :b => {:d => 'd'}}
-      other = {:a => {:c => 'c'}, :b => {:e => 'e'}}
-      result = IsSameDataStructureHelper::Analyser.new(object, other, 1).perform
-      expect(result).to be false
-    end
-
-    it 'should: be invalid with depth 1 and nil' do
-      object = {:a => {:c => 'c'}, :b => {:d => 'd'}}
-      other = {:a => {:c => 'c'}, :b => nil}
-      result = IsSameDataStructureHelper::Analyser.new(object, other, 1).perform
-      expect(result).to be false
-    end
-
-    it 'should: be invalid with depth 1 and integer' do
-      object = {:a => {:c => 'c'}, :b => {:d => 'd'}}
-      other = {:a => {:c => 'c'}, :b => 1}
-      result = IsSameDataStructureHelper::Analyser.new(object, other, 1).perform
-      expect(result).to be false
-    end
-
-    it 'should: be invalid with depth 1 and string' do
-      object = {:a => {:c => 'c'}, :b => {:d => 'd'}}
-      other = {:a => {:c => 'c'}, :b => 'b'}
-      result = IsSameDataStructureHelper::Analyser.new(object, other, 1).perform
-      expect(result).to be false
-    end
-  end
-end