forest_admin_datasource_toolkit 1.0.0.pre.beta.28 → 1.0.0.pre.beta.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac62d583445015740cf9755d82d742e7e1afbdf7f06a522e993cb9db6bc9afbc
-  data.tar.gz: '094c6d02689766596720110469317254aa1e3f45fa0a61555d8b50de5f91eb50'
+  metadata.gz: eb59a941fffbdba03d6ce1966b69d7ce5415507d120591e7b76f3d642b6d83ec
+  data.tar.gz: d5519a29087ec84a16dc0d4ccc433168f31e7d68a7e1906ff4a9e4fc882cc35c
 SHA512:
-  metadata.gz: 88c76ae3ab88b6a888a9aa41f785ba6c53545d28fc7029b66e4870ef90436bb4d6d92fff5296fc53637c537bf7e44559bbb660c49439cd0e2ca83d612e0c79b0
-  data.tar.gz: 3a741eb0906ac2d8f25faaabfe0006d403a0dee569bb8f677e72204c8d392d07ef10119fdcacc1d0fc0e29467c9b0e6ec85fdd0a234b80ccd8380e03ea797239
+  metadata.gz: e30897a61d2675a5f63bc0cce508f3779b3c7e7c56c1b5b67051c4217216d47e3aa1c820c7e863c864864fc7357d0be14a0b6b1f422e82815ec7ac1cfbdb0531
+  data.tar.gz: efdbf2b8d9f8603a803c6c5cbe5c8092a2cdd5da4dd4c4f9258311653c9278b889d1e2304e6c9a9e87781cb607a583a86e41a3713dc5f68c79bb96a06711ac08

data/lib/forest_admin_datasource_toolkit/components/query/projection.rb

@@ -36,6 +36,28 @@ module ForestAdminDatasourceToolkit
         def nest(prefix: nil)
           prefix ? Projection.new(map { |path| "#{prefix}:#{path}" }) : self
         end
+
+        def unnest
+          prefix = first.split(':')[0]
+          raise 'Cannot unnest projection.' unless all? { |path| path.start_with?(prefix) }
+
+          Projection.new(map { |path| path[prefix.length + 1, path.length - prefix.length - 1] })
+        end
+
+        def replace(...)
+          Projection.new(
+            map(...)
+            .reduce(Projection.new) do |memo, path|
+              return memo.union([path]) if path.is_a?(String)
+
+              memo.union(path)
+            end
+          )
+        end
+
+        def equals(other)
+          length == other.length && all? { |field| other.include?(field) }
+        end
       end
     end
   end

data/lib/forest_admin_datasource_toolkit/decorators/collection_decorator.rb

@@ -2,24 +2,14 @@ module ForestAdminDatasourceToolkit
   module Decorators
     class CollectionDecorator < Collection
       attr_reader :datasource, :child_collection, :last_schema
+      attr_writer :parent
 
       def initialize(child_collection, datasource)
         super
         @child_collection = child_collection
         @datasource = datasource
 
-        # When the child collection invalidates its schema, we also invalidate ours.
-        # This is done like this, and not in the markSchemaAsDirty method, because we don't have
-        # a reference to parent collections from children.
-        return unless child_collection.is_a?(CollectionDecorator)
-
-        child_collection.define_singleton_method(:mark_schema_as_dirty) do
-          # Call the original method (the child)
-          original_child_mark_schema_as_dirty.call(child_collection)
-
-          # Invalidate our schema (the parent)
-          mark_schema_as_dirty
-        end
+        child_collection.parent = self if child_collection.is_a?(CollectionDecorator)
       end
 
       def native_driver
@@ -87,6 +77,7 @@ module ForestAdminDatasourceToolkit
 
       def mark_schema_as_dirty
         @last_schema = nil
+        @parent&.mark_schema_as_dirty
       end
 
       def refine_filter(_caller, filter = nil)
@@ -96,14 +87,6 @@ module ForestAdminDatasourceToolkit
       def refine_schema(sub_schema)
         sub_schema
       end
-
-      private
-
-      def push_customization(customization)
-        @stack.queue_customization(customization)
-
-        self
-      end
     end
   end
 end

data/lib/forest_admin_datasource_toolkit/exceptions/validation_error.rb

@@ -0,0 +1,9 @@
+module ForestAdminDatasourceToolkit
+  module Exceptions
+    class ValidationError < ForestException
+      def initialize(msg = '')
+        super
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/schema/concerns/primitive_types.rb

@@ -0,0 +1,19 @@
+module ForestAdminDatasourceToolkit
+  module Schema
+    module Concerns
+      class PrimitiveTypes
+        BINARY = 'Binary'.freeze
+        BOOLEAN = 'Boolean'.freeze
+        DATE = 'Date'.freeze
+        DATE_ONLY = 'Dateonly'.freeze
+        ENUM = 'Enum'.freeze
+        JSON = 'Json'.freeze
+        NUMBER = 'Number'.freeze
+        POINT = 'Point'.freeze
+        STRING = 'String'.freeze
+        TIME_ONLY = 'Timeonly'.freeze
+        UUID = 'Uuid'.freeze
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/validations/field_validator.rb

@@ -0,0 +1,80 @@
+module ForestAdminDatasourceToolkit
+  module Validations
+    class FieldValidator
+      include ForestAdminDatasourceToolkit::Schema
+
+      def self.validate(collection, field, values = nil)
+        dot_index = field.index(':')
+
+        if dot_index.nil?
+          schema = collection.schema[:fields][field]
+
+          raise Exceptions::ValidationError, "Column not found: '#{collection.name}.#{field}'" if schema.nil?
+
+          if schema.type != 'Column'
+            raise Exceptions::ValidationError,
+                  "Unexpected field type: '#{collection.name}.#{field}' (found '#{schema.type}' expected 'Column')"
+          end
+
+          values&.each do |value|
+            validate_value(field, schema, value)
+          end
+        else
+          prefix = field[0, dot_index]
+          schema = collection.schema[:fields][prefix]
+
+          raise Exceptions::ValidationError, "Relation not found: '#{collection.name}.#{prefix}'" if schema.nil?
+
+          if schema.type != 'ManyToOne' && schema.type != 'OneToOne'
+            raise Exceptions::ValidationError,
+                  "Unexpected field type: '#{collection.name}.#{prefix}' (found '#{schema.type}' expected 'ManyToOne' or 'OneToOne')"
+          end
+
+          suffix = field[dot_index + 1, field.length - dot_index - 1]
+          association = collection.datasource.get_collection(schema.foreign_collection)
+          validate(association, suffix, values)
+        end
+      end
+
+      def self.validate_value_for_id(field, schema, value)
+        validate_value(field, schema, value, [schema.column_type])
+      end
+
+      def self.validate_value(field, schema, value, allowed_types = nil)
+        allowed_types ||= Rules.get_allowed_types_for_column_type(schema.column_type)
+
+        # TODO: FIXME: handle complex type from ColumnType
+        # if schema.column_type != PrimitiveType::STRING
+        # end
+
+        type = TypeGetter.get(value, schema.column_type)
+
+        unless allowed_types.include?(type)
+          raise Exceptions::ValidationError,
+                "The given value has a wrong type for '#{field}': #{value}.\n Expects #{allowed_types}"
+        end
+
+        return unless value && schema.column_type == PrimitiveType::ENUM
+
+        check_enum_value(schema, value)
+      end
+
+      def self.validate_name(collection_name, name)
+        return unless name.include?(' ')
+
+        sanitized_name = name.gsub(/ (.)/, &:upcase)
+        raise Exceptions::ValidationError,
+              "The name of field '#{name}' you configured on '#{collection_name}' must not contain space. Something like '#{sanitized_name}' should work has expected."
+      end
+
+      def self.check_enum_value(column_schema, enum_value)
+        is_enum_allowed = column_schema.enum_values.include?(enum_value)
+
+        return if is_enum_allowed
+
+        raise Exceptions::ValidationError,
+              "The given enum value(s) #{enum_value} is not listed in #{column_schema.enum_values}"
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/validations/rules.rb

@@ -0,0 +1,144 @@
+module ForestAdminDatasourceToolkit
+  module Validations
+    class Rules
+      include ForestAdminDatasourceToolkit::Schema
+      include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+
+      BASE_OPERATORS = [Operators::BLANK, Operators::EQUAL, Operators::MISSING, Operators::NOT_EQUAL,
+                        Operators::PRESENT].freeze
+
+      ARRAY_OPERATORS = [Operators::IN, Operators::NOT_IN, Operators::INCLUDES_ALL].freeze
+
+      BASE_DATEONLY_OPERATORS = [
+        Operators::TODAY,
+        Operators::YESTERDAY,
+        Operators::PREVIOUS_X_DAYS,
+        Operators::PREVIOUS_WEEK,
+        Operators::PREVIOUS_MONTH,
+        Operators::PREVIOUS_QUARTER,
+        Operators::PREVIOUS_YEAR,
+        Operators::PREVIOUS_X_DAYS_TO_DATE,
+        Operators::PREVIOUS_WEEK_TO_DATE,
+        Operators::PREVIOUS_MONTH_TO_DATE,
+        Operators::PREVIOUS_QUARTER_TO_DATE,
+        Operators::PREVIOUS_YEAR_TO_DATE,
+        Operators::PAST,
+        Operators::FUTURE,
+        Operators::BEFORE,
+        Operators::AFTER
+      ].freeze
+
+      def self.get_allowed_operators_for_column_type(primitive_type = nil)
+        allowed_operators = {
+          PrimitiveType::STRING => [
+            *Rules::BASE_OPERATORS,
+            *Rules::ARRAY_OPERATORS,
+            Operators::CONTAINS,
+            Operators::NOT_CONTAINS,
+            Operators::ENDS_WITH,
+            Operators::STARTS_WITH,
+            Operators::LONGER_THAN,
+            Operators::SHORTER_THAN,
+            Operators::LIKE,
+            Operators::I_LIKE,
+            Operators::I_CONTAINS,
+            Operators::I_ENDS_WITH,
+            Operators::I_STARTS_WITH
+          ],
+          PrimitiveType::NUMBER => [
+            *Rules::BASE_OPERATORS,
+            *Rules::ARRAY_OPERATORS,
+            Operators::GREATER_THAN,
+            Operators::LESS_THAN
+          ],
+          PrimitiveType::DATE => [
+            *Rules::BASE_OPERATORS,
+            *Rules::BASE_DATEONLY_OPERATORS,
+            Operators::BEFORE_X_HOURS_AGO,
+            Operators::AFTER_X_HOURS_AGO
+          ],
+          PrimitiveType::TIMEONLY => [
+            *Rules::BASE_OPERATORS,
+            Operators::LESS_THAN,
+            Operators::GREATER_THAN
+          ],
+          PrimitiveType::JSON => [
+            Operators::BLANK,
+            Operators::MISSING,
+            Operators::PRESENT
+          ],
+          PrimitiveType::DATEONLY => [*Rules::BASE_OPERATORS, *Rules::BASE_DATEONLY_OPERATORS],
+          PrimitiveType::ENUM => [*Rules::BASE_OPERATORS, *Rules::ARRAY_OPERATORS],
+          PrimitiveType::UUID => [*Rules::BASE_OPERATORS, *Rules::ARRAY_OPERATORS],
+          PrimitiveType::BOOLEAN => Rules::BASE_OPERATORS,
+          PrimitiveType::POINT => Rules::BASE_OPERATORS
+        }
+
+        primitive_type ? allowed_operators[primitive_type] : allowed_operators
+      end
+
+      def self.get_allowed_types_for_column_type(primitive_type = nil)
+        allowed_types = {
+          PrimitiveType::STRING => [PrimitiveType::STRING, nil],
+          PrimitiveType::NUMBER => [PrimitiveType::NUMBER, nil],
+          PrimitiveType::DATEONLY => [PrimitiveType::DATEONLY, nil],
+          PrimitiveType::DATE => [PrimitiveType::DATE, nil],
+          PrimitiveType::TIMEONLY => [PrimitiveType::TIMEONLY, nil],
+          PrimitiveType::ENUM => [PrimitiveType::ENUM, nil],
+          PrimitiveType::UUID => [PrimitiveType::UUID, nil],
+          PrimitiveType::JSON => [PrimitiveType::JSON, nil],
+          PrimitiveType::BOOLEAN => [PrimitiveType::BOOLEAN, nil],
+          PrimitiveType::POINT => [PrimitiveType::POINT, nil]
+        }
+
+        primitive_type ? allowed_types[primitive_type] : allowed_types
+      end
+
+      def self.compute_allowed_types_for_operators
+        get_allowed_operators_for_column_type.keys.reduce do |result, type|
+          allowed_operators = get_allowed_operators_for_column_type(type)
+          allowed_operators.each do |operator|
+            if result[operator]
+              result[operator] << type
+            else
+              result[operator] = [type]
+            end
+          end
+
+          result
+        end
+      end
+
+      def self.get_allowed_types_for_operator(operator = nil)
+        no_type_allowed = [nil]
+        allowed_types = compute_allowed_types_for_operators
+        merged = allowed_types.merge(
+          Operators::IN => allowed_types[Operators::IN] + [nil],
+          Operators::NOT_IN => allowed_types[Operators::NOT_IN] + [nil],
+          Operators::INCLUDES_ALL => allowed_types[Operators::INCLUDES_ALL] + [nil],
+          Operators::BLANK => no_type_allowed,
+          Operators::MISSING => no_type_allowed,
+          Operators::PRESENT => no_type_allowed,
+          Operators::YESTERDAY => no_type_allowed,
+          Operators::TODAY => no_type_allowed,
+          Operators::PREVIOUS_QUARTER => no_type_allowed,
+          Operators::PREVIOUS_YEAR => no_type_allowed,
+          Operators::PREVIOUS_MONTH => no_type_allowed,
+          Operators::PREVIOUS_WEEK => no_type_allowed,
+          Operators::PAST => no_type_allowed,
+          Operators::FUTURE => no_type_allowed,
+          Operators::PREVIOUS_WEEK_TO_DATE => no_type_allowed,
+          Operators::PREVIOUS_MONTH_TO_DATE => no_type_allowed,
+          Operators::PREVIOUS_QUARTER_TO_DATE => no_type_allowed,
+          Operators::PREVIOUS_YEAR_TO_DATE => no_type_allowed,
+          Operators::PREVIOUS_X_DAYS_TO_DATE => ['Number'],
+          Operators::PREVIOUS_X_DAYS => ['Number'],
+          Operators::BEFORE_X_HOURS_AGO => ['Number'],
+          Operators::AFTER_X_HOURS_AGO => ['Number']
+        )
+
+        operator ? merged[operator] : merged
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/validations/type_getter.rb

@@ -0,0 +1,97 @@
+require 'date'
+require 'time'
+require 'openssl'
+
+module ForestAdminDatasourceToolkit
+  module Validations
+    class TypeGetter
+      include ForestAdminDatasourceToolkit::Schema::Concerns
+      def self.get(value, type_context)
+        return PrimitiveTypes::JSON if type_context == PrimitiveTypes::JSON
+
+        return get_type_from_string(value, type_context) if value.is_a?(String)
+
+        return PrimitiveTypes::NUMBER if value.is_a?(Numeric)
+
+        return PrimitiveTypes::DATE if value.is_a?(Date)
+
+        return PrimitiveTypes::BOOLEAN if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+
+        return PrimitiveTypes::BINARY if value.is_a?(buffer)
+
+        nil
+      end
+
+      class << self
+        include ForestAdminDatasourceToolkit::Schema::Concerns
+        def get_date_type(value)
+          return PrimitiveTypes::DATE_ONLY if date?(value) && Date.parse(value).iso8601 == value
+
+          if time?(value) && (Time.parse(value).strftime('%H:%M:%S.%L') == value ||
+            Time.parse(value).strftime('%H:%M:%S') == value)
+            return PrimitiveTypes::TIME_ONLY
+          end
+
+          PrimitiveTypes::DATE
+        end
+
+        def get_type_from_string(value, type_context)
+          return type_context if [PrimitiveTypes::ENUM, PrimitiveTypes::STRING].include?(type_context)
+
+          return PrimitiveTypes::UUID if uuid?(value)
+
+          return get_date_type(value) if valid_date?(value) && [PrimitiveTypes::DATE, PrimitiveTypes::DATE_ONLY,
+                                                                PrimitiveTypes::TIME_ONLY].include?(type_context)
+
+          return PrimitiveTypes::POINT if point?(value, type_context)
+
+          PrimitiveTypes::STRING
+        end
+
+        def valid_date?(value)
+          date?(value) || time?(value)
+        end
+
+        def date?(value)
+          true if Date.parse(value)
+        rescue ArgumentError
+          false
+        end
+
+        def time?(value)
+          true if Time.parse(value)
+        rescue ArgumentError
+          false
+        end
+
+        def number?(value)
+          true if Float(value)
+        rescue ArgumentError
+          false
+        end
+
+        def point?(value, type_context)
+          potential_point = value.split(',')
+
+          potential_point.length == 2 && type_context == PrimitiveTypes::POINT && potential_point.all? do |point|
+            number?(point) && get(point.to_i, PrimitiveTypes::NUMBER) == PrimitiveTypes::NUMBER
+          end
+        end
+
+        def uuid?(uuid)
+          format = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+
+          true if format.match?(uuid.to_s.downcase)
+        end
+
+        def buffer
+          if defined?(IO::Buffer)
+            IO::Buffer
+          else
+            OpenSSL::Buffering::Buffer
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminDatasourceToolkit
-  VERSION = "1.0.0-beta.28"
+  VERSION = "1.0.0-beta.29"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_datasource_toolkit
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.beta.28
+  version: 1.0.0.pre.beta.29
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-01-19 00:00:00.000000000 Z
+date: 2024-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -85,7 +85,9 @@ files:
 - lib/forest_admin_datasource_toolkit/decorators/collection_decorator.rb
 - lib/forest_admin_datasource_toolkit/decorators/datasource_decorator.rb
 - lib/forest_admin_datasource_toolkit/exceptions/forest_exception.rb
+- lib/forest_admin_datasource_toolkit/exceptions/validation_error.rb
 - lib/forest_admin_datasource_toolkit/schema/column_schema.rb
+- lib/forest_admin_datasource_toolkit/schema/concerns/primitive_types.rb
 - lib/forest_admin_datasource_toolkit/schema/primitive_type.rb
 - lib/forest_admin_datasource_toolkit/schema/relation_schema.rb
 - lib/forest_admin_datasource_toolkit/schema/relations/many_to_many_schema.rb
@@ -96,6 +98,9 @@ files:
 - lib/forest_admin_datasource_toolkit/utils/record.rb
 - lib/forest_admin_datasource_toolkit/utils/schema.rb
 - lib/forest_admin_datasource_toolkit/validations/chart_validator.rb
+- lib/forest_admin_datasource_toolkit/validations/field_validator.rb
+- lib/forest_admin_datasource_toolkit/validations/rules.rb
+- lib/forest_admin_datasource_toolkit/validations/type_getter.rb
 - lib/forest_admin_datasource_toolkit/version.rb
 - sig/forest_admin_datasource_toolkit.rbs
 - sig/forest_admin_datasource_toolkit/collection.rbs