forest_admin_datasource_active_record 1.8.7 → 1.8.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6274fc08a8aa3d54112238d7d3833075f01da3096c30902fdd54e81dc87d1e6
-  data.tar.gz: 3504022220f66b1a92a36b47aeab1f4975173a18cde7178cf59bae3c616db2c2
+  metadata.gz: b16fe13a23203f8a9cd4fc0d2d6d2d2ea0e6ae67199eeb3f24e532f5b48ba6b5
+  data.tar.gz: 443f1a78c1b248ccd87bf47a9389384ca734c971930afe328370a79b549a0c4d
 SHA512:
-  metadata.gz: 41532c05b4cbc18da0aa6123f7ccd4b7675da006601cfdbf899b520eb0c799e7a8f95ea771e00f686f5d2e55a8325cc91e96b4bb78c9f8499a969fb1608782ec
-  data.tar.gz: 52ada4e24b67a6fe15de5d9faf88850dea62b16627c54ed409638c8a00f32f8037da93a8ccb02f9352120a6f1a2fbd23ef68ba0ef09be63f1da562cbc19e7e47
+  metadata.gz: e5753a7d39a2bbb7b32e88b4ba0aaf0953c57ea926f2674669d633ab85b70422cc0428afeb3d64838f27a2ebb6b468ea85e1e6d30dbf154b659966663f5b9503
+  data.tar.gz: 2e1e77c261b33343aebcfd94172c843031249d8e61fc6f0a7a3ec2d0219f12ea420c2fdceb4ba8082c5435069ab6068f2704361b7935514b303b8e1a638ac298

data/lib/forest_admin_datasource_active_record/collection.rb

@@ -31,17 +31,23 @@ module ForestAdminDatasourceActiveRecord
     end
 
     def create(_caller, data)
-      Utils::ActiveRecordSerializer.new(@model.create(data)).to_hash(ProjectionFactory.all(self))
+      Utils::ErrorHandler.handle_errors(:create) do
+        Utils::ActiveRecordSerializer.new(@model.create!(data)).to_hash(ProjectionFactory.all(self))
+      end
     end
 
     def update(_caller, filter, data)
-      entity = Utils::Query.new(self, nil, filter).build.first
-      entity&.update(data)
+      Utils::ErrorHandler.handle_errors(:update) do
+        entity = Utils::Query.new(self, nil, filter).build.first
+        entity&.update!(data)
+      end
     end
 
     def delete(_caller, filter)
-      entities = Utils::Query.new(self, nil, filter).build
-      entities&.each(&:destroy)
+      Utils::ErrorHandler.handle_errors(:delete) do
+        entities = Utils::Query.new(self, nil, filter).build
+        entities&.each(&:destroy)
+      end
     end
 
     private

data/lib/forest_admin_datasource_active_record/parser/column.rb

@@ -61,10 +61,49 @@ module ForestAdminDatasourceActiveRecord
       def operators_for_column_type(type)
         result = [Operators::PRESENT, Operators::BLANK, Operators::MISSING]
         equality = [Operators::EQUAL, Operators::NOT_EQUAL, Operators::IN, Operators::NOT_IN]
+        orderables = [
+          Operators::LESS_THAN,
+          Operators::GREATER_THAN,
+          Operators::LESS_THAN_OR_EQUAL,
+          Operators::GREATER_THAN_OR_EQUAL
+        ]
+        strings = [
+          Operators::LIKE,
+          Operators::I_LIKE,
+          Operators::CONTAINS,
+          Operators::I_CONTAINS,
+          Operators::NOT_CONTAINS,
+          Operators::NOT_I_CONTAINS,
+          Operators::STARTS_WITH,
+          Operators::I_STARTS_WITH,
+          Operators::ENDS_WITH,
+          Operators::I_ENDS_WITH,
+          Operators::SHORTER_THAN,
+          Operators::LONGER_THAN
+        ]
 
         if type.is_a? String
-          orderables = [Operators::LESS_THAN, Operators::GREATER_THAN]
-          strings = [Operators::LIKE, Operators::I_LIKE, Operators::NOT_CONTAINS]
+          orderables = [
+            Operators::LESS_THAN,
+            Operators::GREATER_THAN,
+            Operators::LESS_THAN_OR_EQUAL,
+            Operators::GREATER_THAN_OR_EQUAL
+          ]
+          strings = [
+            Operators::CONTAINS,
+            Operators::I_CONTAINS,
+            Operators::NOT_CONTAINS,
+            Operators::NOT_I_CONTAINS,
+            Operators::STARTS_WITH,
+            Operators::I_STARTS_WITH,
+            Operators::ENDS_WITH,
+            Operators::I_ENDS_WITH,
+            Operators::LIKE,
+            Operators::I_LIKE,
+            Operators::MATCH,
+            Operators::SHORTER_THAN,
+            Operators::LONGER_THAN
+          ]
 
           result += equality if %w[Boolean Binary Enum Uuid].include?(type)
 
@@ -73,7 +112,7 @@ module ForestAdminDatasourceActiveRecord
           result = result + equality + orderables + strings if %w[String].include?(type)
         end
 
-        result = result + equality + ['Includes_All'] if type.is_a? Array
+        result += [Operators::EQUAL, Operators::NOT_EQUAL, Operators::INCLUDES_ALL] if type.is_a?(Array)
 
         result
       end

data/lib/forest_admin_datasource_active_record/utils/error_handler.rb

@@ -0,0 +1,39 @@
+module ForestAdminDatasourceActiveRecord
+  module Utils
+    class ErrorHandler
+      # Handle errors from ActiveRecord operations and convert them to ValidationErrors
+      # @param method [Symbol] The operation type: :create, :update, or :delete
+      # @return The result of the block execution
+      # @raise [ForestAdminDatasourceToolkit::Exceptions::ValidationError] When a database constraint is violated
+      def self.handle_errors(method)
+        yield
+      rescue ActiveRecord::RecordNotUnique => _e
+        message = 'The query violates a unicity constraint in the database. ' \
+                  'Please ensure that you are not duplicating information across records.'
+
+        raise ForestAdminDatasourceToolkit::Exceptions::ValidationError, message
+      rescue ActiveRecord::InvalidForeignKey => _e
+        message = build_foreign_key_message(method)
+
+        raise ForestAdminDatasourceToolkit::Exceptions::ValidationError, message
+      rescue ActiveRecord::RecordInvalid => e
+        raise ForestAdminDatasourceToolkit::Exceptions::ValidationError, e.message
+      rescue StandardError => e # rubocop:disable Lint/DuplicateBranch
+        raise ForestAdminDatasourceToolkit::Exceptions::ValidationError, e.message
+      end
+
+      def self.build_foreign_key_message(method)
+        base_message = 'The query violates a foreign key constraint in the database. '
+
+        case method
+        when :create, :update
+          "#{base_message}Please ensure that you are not linking to a relation which was deleted."
+        when :delete
+          "#{base_message}Please ensure that no records are linked to the one that you wish to delete."
+        else
+          base_message
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_active_record/utils/query.rb

@@ -93,16 +93,79 @@ module ForestAdminDatasourceActiveRecord
         when Operators::NOT_EQUAL, Operators::NOT_IN
           @query = query_aggregator(aggregator, @collection.model.where.not({ field => value }))
         when Operators::GREATER_THAN
-          @query = query_aggregator(aggregator, @collection.model.where(@arel_table[field.to_sym].gt(value)))
+          @query = query_aggregator(aggregator, build_comparison_query(condition_tree.field, field, value, :gt))
+        when Operators::GREATER_THAN_OR_EQUAL
+          @query = query_aggregator(aggregator, build_comparison_query(condition_tree.field, field, value, :gteq))
         when Operators::LESS_THAN
-          @query = query_aggregator(aggregator, @collection.model.where(@arel_table[field.to_sym].lt(value)))
+          @query = query_aggregator(aggregator, build_comparison_query(condition_tree.field, field, value, :lt))
+        when Operators::LESS_THAN_OR_EQUAL
+          @query = query_aggregator(aggregator, build_comparison_query(condition_tree.field, field, value, :lteq))
+        when Operators::CONTAINS
+          @query = query_aggregator(aggregator,
+                                    @collection.model.where(@arel_table[field.to_sym].matches("%#{value}%")))
+        when Operators::I_CONTAINS
+          lower_field = Arel::Nodes::NamedFunction.new('LOWER', [@arel_table[field.to_sym]])
+          @query = query_aggregator(aggregator,
+                                    @collection.model.where(lower_field.matches("%#{value.to_s.downcase}%")))
         when Operators::NOT_CONTAINS
           @query = query_aggregator(aggregator,
                                     @collection.model.where.not(@arel_table[field.to_sym].matches("%#{value}%")))
+        when Operators::NOT_I_CONTAINS
+          lower_field = Arel::Nodes::NamedFunction.new('LOWER', [@arel_table[field.to_sym]])
+          @query = query_aggregator(aggregator,
+                                    @collection.model.where.not(lower_field.matches("%#{value.to_s.downcase}%")))
+        when Operators::STARTS_WITH
+          @query = query_aggregator(aggregator,
+                                    @collection.model.where(@arel_table[field.to_sym].matches("#{value}%")))
+        when Operators::I_STARTS_WITH
+          lower_field = Arel::Nodes::NamedFunction.new('LOWER', [@arel_table[field.to_sym]])
+          @query = query_aggregator(aggregator,
+                                    @collection.model.where(lower_field.matches("#{value.to_s.downcase}%")))
+        when Operators::ENDS_WITH
+          @query = query_aggregator(aggregator,
+                                    @collection.model.where(@arel_table[field.to_sym].matches("%#{value}")))
+        when Operators::I_ENDS_WITH
+          lower_field = Arel::Nodes::NamedFunction.new('LOWER', [@arel_table[field.to_sym]])
+          @query = query_aggregator(aggregator,
+                                    @collection.model.where(lower_field.matches("%#{value.to_s.downcase}")))
         when Operators::LIKE
           @query = query_aggregator(aggregator, @collection.model.where(@arel_table[field.to_sym].matches(value)))
+        when Operators::I_LIKE
+          lower_field = Arel::Nodes::NamedFunction.new('LOWER', [@arel_table[field.to_sym]])
+          @query = query_aggregator(aggregator,
+                                    @collection.model.where(lower_field.matches(value.to_s.downcase)))
+        when Operators::MATCH
+          # Match operator supports:
+          # - Regexp objects from pattern transformations: Regexp.new("pattern")
+          # - JavaScript regex strings from comparison transformations: "/(pattern)/g"
+          pattern = if value.is_a?(Regexp)
+                      value.source
+                    elsif (match = value.to_s.match(%r{^/(.+)/[gim]*$}))
+                      match[1]
+                    else
+                      value.to_s
+                    end
+
+          # Use database-specific regex syntax
+          adapter_name = @collection.model.connection.adapter_name.downcase
+          regex_clause = case adapter_name
+                         when 'postgresql'
+                           "#{@arel_table.name}.#{field} ~ ?"
+                         when 'mysql2', 'mysql', 'sqlite', 'sqlite3'
+                           "#{@arel_table.name}.#{field} REGEXP ?"
+                         else
+                           raise ArgumentError, "Match operator is not supported for database adapter '#{adapter_name}'"
+                         end
+
+          @query = query_aggregator(aggregator, @collection.model.where(regex_clause, pattern))
         when Operators::INCLUDES_ALL
           @query = query_aggregator(aggregator, @collection.model.where(@arel_table[field.to_sym].matches_all(value)))
+        when Operators::SHORTER_THAN
+          length_func = Arel::Nodes::NamedFunction.new('LENGTH', [@arel_table[field.to_sym]])
+          @query = query_aggregator(aggregator, @collection.model.where(length_func.lt(value)))
+        when Operators::LONGER_THAN
+          length_func = Arel::Nodes::NamedFunction.new('LENGTH', [@arel_table[field.to_sym]])
+          @query = query_aggregator(aggregator, @collection.model.where(length_func.gt(value)))
         end
 
         @query
@@ -161,6 +224,20 @@ module ForestAdminDatasourceActiveRecord
         field
       end
 
+      def build_comparison_query(original_field, formatted_field, value, operator)
+        # When comparing a String field with a numeric value, compare the length of the string
+        # Otherwise, do a lexicographic comparison
+        if value.is_a?(Numeric)
+          field_schema = ForestAdminDatasourceToolkit::Utils::Collection.get_field_schema(@collection, original_field)
+          if field_schema.column_type == 'String'
+            length_func = Arel::Nodes::NamedFunction.new('LENGTH', [@arel_table[formatted_field.to_sym]])
+            return @collection.model.where(length_func.send(operator, value))
+          end
+        end
+
+        @collection.model.where(@arel_table[formatted_field.to_sym].send(operator, value))
+      end
+
       def query_aggregator(aggregator, query)
         if !@query.respond_to?(:where_clause) || @query.where_clause.empty?
           query

data/lib/forest_admin_datasource_active_record/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminDatasourceActiveRecord
-  VERSION = "1.8.7"
+  VERSION = "1.8.8"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_datasource_active_record
 version: !ruby/object:Gem::Version
-  version: 1.8.7
+  version: 1.8.8
 platform: ruby
 authors:
 - Matthieu
@@ -74,6 +74,7 @@ files:
 - lib/forest_admin_datasource_active_record/parser/relation.rb
 - lib/forest_admin_datasource_active_record/parser/validation.rb
 - lib/forest_admin_datasource_active_record/utils/active_record_serializer.rb
+- lib/forest_admin_datasource_active_record/utils/error_handler.rb
 - lib/forest_admin_datasource_active_record/utils/query.rb
 - lib/forest_admin_datasource_active_record/utils/query_aggregate.rb
 - lib/forest_admin_datasource_active_record/version.rb