forest_liana 6.6.0 → 7.0.0.beta.3

data/app/services/forest_liana/permissions_formatter.rb

@@ -13,7 +13,7 @@ module ForestLiana
             'actions' => convert_actions_permissions_to_new_format(permissions[collection_name]['actions'])
           }
 
-          permissions_new_format['renderings'][rendering_id][collection_name] = { 'scope' => permissions[collection_name]['scope'] }
+          permissions_new_format['renderings'][rendering_id][collection_name] = { 'segments' => permissions[collection_name]['segments'] }
         }
 
         permissions_new_format

data/app/services/forest_liana/permissions_getter.rb

@@ -26,10 +26,7 @@ module ForestLiana
       # rederings => {
       #   {rendering_id} => {
       #       {collection_id} => {
-      #         scope => {
-      #           dynamicScopesValues => {},
-      #           filter => {}
-      #         }
+      #         segments => ['query1', 'query2']
       #       }
       #     }
       #   }

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/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.6.0"
+  VERSION = "7.0.0.beta.3"
 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/permissions_checker_acl_disabled_spec.rb

@@ -75,7 +75,7 @@ module ForestLiana
                 "users" => nil
               },
             },
-            "scope" => nil
+            "segments" => nil
           },
           "no_rights_collection" => {
             "collection" => {
@@ -93,7 +93,7 @@ module ForestLiana
                 "users" => nil
               }
             },
-            "scope" => nil
+            "segments" => nil
           },
         },
         "meta" => {
@@ -146,6 +146,8 @@ module ForestLiana
 
       context 'with permissions coming from 2 different renderings' do
         let(:collection_name) { 'custom' }
+
+        let(:segments_permissions) { nil }
         let(:api_permissions_rendering_1) {
           {
             "data" => {
@@ -160,7 +162,7 @@ module ForestLiana
                   "searchToEdit" => true
                 },
                 "actions" => { },
-                "scope" => nil
+                "segments" => segments_permissions
               },
             },
             "meta" => {
@@ -190,11 +192,11 @@ module ForestLiana
     end
 
 
-    context 'scopes cache' do
+    context 'renderings cache' do
       let(:fake_ressource) { collection_name }
       let(:rendering_id) { 1 }
       let(:collection_name) { 'custom' }
-      let(:scope_permissions) { { rendering_id => { 'custom' => nil } } }
+      let(:segments_permissions) { { rendering_id => { 'custom' => nil } } }
       let(:api_permissions) {
         {
           "data" => {
@@ -209,7 +211,7 @@ module ForestLiana
                 "searchToEdit" => true
               },
               "actions" => { },
-              "scope" => nil
+              "segments" => nil
             },
           },
           "meta" => {
@@ -217,11 +219,11 @@ module ForestLiana
           }
         }
       }
-      let(:api_permissions_scope_only) {
+      let(:api_permissions_rendering_only) {
         {
           "data" => {
             'collections' => { },
-            'renderings' => scope_permissions
+            'renderings' => segments_permissions
           },
           "meta" => {
             "rolesACLActivated" => false
@@ -233,13 +235,13 @@ module ForestLiana
         # clones is called to duplicate the returned value and not use to same (which results in an error
         # as the permissions is edited through the formatter)
         allow(ForestLiana::PermissionsGetter).to receive(:get_permissions_for_rendering).with(rendering_id) { api_permissions.clone }
-        allow(ForestLiana::PermissionsGetter).to receive(:get_permissions_for_rendering).with(rendering_id, rendering_specific_only: true).and_return(api_permissions_scope_only)
+        allow(ForestLiana::PermissionsGetter).to receive(:get_permissions_for_rendering).with(rendering_id, rendering_specific_only: true).and_return(api_permissions_rendering_only)
       end
 
       context 'when checking once for authorization' do
         context 'when checking browseEnabled' do
           context 'when expiration value is set to its default' do
-            it 'should not call the API to refresh the scopes cache' do
+            it 'should not call the API to refresh the renderings cache' do
               described_class.new(fake_ressource, 'browseEnabled', rendering_id, user_id: user_id).is_authorized?
 
               expect(ForestLiana::PermissionsGetter).to have_received(:get_permissions_for_rendering).with(rendering_id).once
@@ -254,7 +256,7 @@ module ForestLiana
               described_class.empty_cache
             end
 
-            it 'should call the API to refresh the scopes cache' do
+            it 'should call the API to refresh the renderings cache' do
               described_class.new(fake_ressource, 'browseEnabled', rendering_id, user_id: user_id).is_authorized?
 
               expect(ForestLiana::PermissionsGetter).to have_received(:get_permissions_for_rendering).with(rendering_id).once
@@ -263,7 +265,7 @@ module ForestLiana
           end
         end
 
-        # Only browse permission requires scopes
+        # Only browse permission requires segments
         context 'when checking exportEnabled' do
           context 'when expiration value is set in the past' do
             before do
@@ -273,7 +275,7 @@ module ForestLiana
             end
           end
 
-          it 'should NOT call the API to refresh the scopes cache' do
+          it 'should NOT call the API to refresh the renderings cache' do
             described_class.new(fake_ressource, 'exportEnabled', rendering_id, user_id: user_id).is_authorized?
 
             expect(ForestLiana::PermissionsGetter).to have_received(:get_permissions_for_rendering).with(rendering_id).once
@@ -284,8 +286,8 @@ module ForestLiana
 
       context 'when checking twice for authorization' do
         context 'on the same rendering' do
-          context 'when scopes permission has NOT expired' do
-            it 'should NOT call the API to refresh the scopes permissions' do
+          context 'when renderings permission has NOT expired' do
+            it 'should NOT call the API to refresh the renderings permissions' do
               described_class.new(fake_ressource, 'browseEnabled', rendering_id, user_id: user_id).is_authorized?
               described_class.new(fake_ressource, 'browseEnabled', rendering_id, user_id: user_id).is_authorized?
 
@@ -294,14 +296,14 @@ module ForestLiana
             end
           end
 
-          context 'when scopes permission has expired' do
+          context 'when renderings permission has expired' do
             before do
               allow(ENV).to receive(:[]).with('FOREST_PERMISSIONS_EXPIRATION_IN_SECONDS').and_return('-1')
               # Needed to enforce ENV stub
               described_class.empty_cache
             end
 
-            it 'should call the API to refresh the scopes permissions' do
+            it 'should call the API to refresh the renderings permissions' do
               described_class.new(fake_ressource, 'browseEnabled', rendering_id, user_id: user_id).is_authorized?
               described_class.new(fake_ressource, 'browseEnabled', rendering_id, user_id: user_id).is_authorized?
 
@@ -313,7 +315,7 @@ module ForestLiana
 
         context 'on two different renderings' do
           let(:other_rendering_id) { 2 }
-          let(:api_permissions_scope_only) {
+          let(:api_permissions_rendering_only) {
             {
               "data" => {
                 'collections' => { },
@@ -330,10 +332,10 @@ module ForestLiana
 
           before do
             allow(ForestLiana::PermissionsGetter).to receive(:get_permissions_for_rendering).with(other_rendering_id).and_return(api_permissions_copy)
-            allow(ForestLiana::PermissionsGetter).to receive(:get_permissions_for_rendering).with(other_rendering_id, rendering_specific_only: true).and_return(api_permissions_scope_only)
+            allow(ForestLiana::PermissionsGetter).to receive(:get_permissions_for_rendering).with(other_rendering_id, rendering_specific_only: true).and_return(api_permissions_rendering_only)
           end
 
-          it 'should not call the API to refresh the scopes permissions' do
+          it 'should not call the API to refresh the rederings permissions' do
             described_class.new(fake_ressource, 'browseEnabled', rendering_id, user_id: user_id).is_authorized?
             described_class.new(fake_ressource, 'browseEnabled', other_rendering_id, user_id: user_id).is_authorized?
 
@@ -350,7 +352,7 @@ module ForestLiana
       # Resource is only used to retrieve the collection name as it's stubbed it does not
       # need to be defined
       let(:fake_ressource) { collection_name }
-      let(:default_rendering_id) { nil }
+      let(:default_rendering_id) { 1 }
       let(:api_permissions) { default_api_permissions }
       let(:collection_name) { 'all_rights_collection' }
 
@@ -380,14 +382,14 @@ module ForestLiana
         describe 'browseEnabled permission' do
           let(:collection_name) { 'custom' }
           subject { described_class.new(fake_ressource, 'browseEnabled', default_rendering_id, user_id: user_id) }
-          let(:scope_permissions) { nil }
+          let(:segments_permissions) { nil }
           let(:default_api_permissions) {
             {
               "data" => {
                 "custom" => {
                   "collection" => collection_permissions,
                   "actions" => { },
-                  "scope" => scope_permissions
+                  "segments" => segments_permissions
                 },
               },
               "meta" => {
@@ -480,6 +482,26 @@ module ForestLiana
               end
             end
 
+            context 'when segments are defined' do
+              let(:segments_permissions) { ['SELECT * FROM products;', 'SELECT * FROM sellers;'] }
+              let(:collection_list_parameters) { { :user_id => "1", :segmentQuery => segmentQuery } }
+
+              context 'when segments are passing validation' do
+                  let(:segmentQuery) { 'SELECT * FROM products;' }
+                  it 'should return true' do
+                    expect(subject.is_authorized?).to be true
+                  end
+              end
+
+              context 'when segments are NOT passing validation' do
+                let(:segmentQuery) { 'SELECT * FROM rockets WHERE name = "Starship";' }
+                it 'should return false' do
+                  expect(subject.is_authorized?).to be false
+                end
+              end
+            
+            end
+
             context 'when user has not the required permission' do
               let(:collection_permissions) {
                 {
@@ -498,52 +520,6 @@ module ForestLiana
               end
             end
 
-            context 'when scopes are defined' do
-              let(:scope_permissions) { { 'dynamicScopesValues' => {}, 'filter' => { 'aggregator' => 'and', 'conditions' => [condition] } }}
-              let(:collection_list_parameters) { { :user_id => "1", :filters => JSON.generate(condition) } }
-
-              context 'when scopes are passing validation' do
-                context 'when scope value is a string' do
-                  let(:condition) { { 'field' => 'field_1', 'operator' => 'equal', 'value' => true } }
-
-                  it 'should return true' do
-                    expect(subject.is_authorized?).to be true
-                  end
-                end
-
-                context 'when scope value is a boolean' do
-                  let(:condition) { { 'field' => 'field_1', 'operator' => 'equal', 'value' => 'true' } }
-
-                  it 'should return true' do
-                    expect(subject.is_authorized?).to be true
-                  end
-                end
-              end
-
-              context 'when scopes are NOT passing validation' do
-                let(:condition) { { 'field' => 'field_1', 'operator' => 'equal', 'value' => true } }
-                let(:other_condition) {
-                  {
-                    aggregator: 'and',
-                    conditions: [
-                      { field: 'name', value: 'john', operator: 'equal' },
-                      { field: 'price', value: '2500', operator: 'equal' }
-                    ]
-                  }
-                }
-                let(:collection_list_parameters) {
-                  {
-                    :user_id => "1",
-                    :filters => JSON.generate(other_condition)
-                  }
-                }
-
-
-                it 'should return false' do
-                  expect(subject.is_authorized?).to be false
-                end
-              end
-            end
           end
         end