nxt_schema 0.1.0

data/lib/nxt_schema/dsl.rb

@@ -0,0 +1,38 @@
+module NxtSchema
+  def schema(name = :root, **options, &block)
+    Node::Schema.new(name: name, parent_node: nil, **options, &block)
+  end
+
+  def collection(name = :roots, **options, &block)
+    Node::Collection.new(name: name, parent_node: nil, **options, &block)
+  end
+
+  def params(name = :root, **options, &block)
+    Node::Schema.new(
+      name: name,
+      parent_node: nil,
+      **options.merge(
+        type_system: NxtSchema::Types::Params,
+      ).reverse_merge(transform_keys: :to_sym),
+      &block
+    )
+  end
+
+  def json(name = :root, **options, &block)
+    Node::Schema.new(
+      name: name,
+      parent_node: nil,
+      **options.merge(
+        type_system: NxtSchema::Types::JSON,
+      ).reverse_merge(transform_keys: :to_sym),
+      &block
+    )
+  end
+
+  alias_method :node, :schema
+  alias_method :root, :schema
+  alias_method :nodes, :collection
+  alias_method :roots, :collection
+
+  module_function :root, :roots, :node, :nodes, :collection, :schema, :params
+end

data/lib/nxt_schema/error_messages/en.yaml

@@ -0,0 +1,15 @@
+en:
+  required_key_missing: "Required key :%{key} is missing in %{target}"
+  additional_keys_detected: "Additional keys %{keys} not allowed in %{target}"
+  attribute: "%{attribute} has invalid %{attribute_name} attribute of %{value}"
+  equality: "%{actual} does not equal %{expected}"
+  excludes: "%{value} cannot contain %{target}"
+  includes: "%{value} must include %{target}"
+  excluded: "%{value} must be excluded in %{target}"
+  included: "%{value} must be included in %{target}"
+  greater_than: "%{value} must be greater than %{threshold}"
+  greater_than_or_equal: "%{value} must be greater than or equal to %{threshold}"
+  less_than: "%{value} must be less than %{threshold}"
+  less_than_or_equal: "%{value} must be less than or equal to %{threshold}"
+  pattern: "%{value} must match pattern %{pattern}"
+  query: "%{value}.%{query} was %{actual} and must be true"

data/lib/nxt_schema/error_messages.rb

@@ -0,0 +1,40 @@
+module NxtSchema
+  class ErrorMessages
+    class << self
+      def values
+        @values ||= {}
+      end
+
+      def values=(value)
+        @values = value
+      end
+
+      def load(paths = files)
+        Array(paths).each do |path|
+          new_values = YAML.load(ERB.new(File.read(path)).result).with_indifferent_access
+          self.values = values.deep_merge!(new_values)
+        end
+      end
+
+      def resolve(locale, key, **options)
+        message = begin
+          values.fetch(locale).fetch(key)
+        rescue KeyError
+          raise "Could not resolve error message for #{locale}->#{key}"
+        end
+
+        message % options
+      end
+
+      def files
+        @files ||= begin
+          files = Dir.entries(File.expand_path('../error_messages/', __FILE__)).map do |filename|
+            File.expand_path("../error_messages/#{filename}", __FILE__)
+          end
+
+          files.select { |f| !File.directory? f }
+        end
+      end
+    end
+  end
+end

data/lib/nxt_schema/errors/error.rb

@@ -0,0 +1,7 @@
+module NxtSchema
+  module Errors
+    class Error < StandardError
+
+    end
+  end
+end

data/lib/nxt_schema/errors/invalid_options_error.rb

@@ -0,0 +1,5 @@
+module NxtSchema
+  module Errors
+    InvalidOptionsError = Class.new(Error)
+  end
+end

data/lib/nxt_schema/errors/schema_not_applied_error.rb

@@ -0,0 +1,5 @@
+module NxtSchema
+  module Errors
+    SchemaNotAppliedError = Class.new(Error)
+  end
+end

data/lib/nxt_schema/errors.rb

@@ -0,0 +1,4 @@
+module NxtSchema
+  module Errors
+  end
+end

data/lib/nxt_schema/node/base.rb

@@ -0,0 +1,318 @@
+module NxtSchema
+  module Node
+    class Base
+      def initialize(name: name_from_index, type:, parent_node:, **options, &block)
+        @name = name
+        @parent_node = parent_node
+        @options = options
+        @type_system = resolve_type_system
+        @additional_keys_strategy = resolve_additional_keys_strategy
+        @type = type
+        @schema_errors_key = options.fetch(:schema_errors_key, :itself)
+        @validations = []
+        @level = parent_node ? parent_node.level + 1 : 0
+        @all_nodes = parent_node ? (parent_node.all_nodes || {}) : {}
+        @is_root = parent_node.nil?
+        @root = parent_node.nil? ? self : parent_node.root
+        @errors = {}
+        @context = nil
+        @applied = false
+        @input = nil
+        @value = NxtSchema::Undefined.new
+        @locale = options.fetch(:locale) { parent_node&.locale || 'en' }
+
+        # Note that it is not possible to use present? on an instance of NxtSchema::Schema since it inherits from Hash
+        evaluate_block(block) if block_given?
+      end
+
+      attr_accessor :name,
+                    :parent_node,
+                    :options,
+                    :type,
+                    :schema_errors,
+                    :namespace,
+                    :errors,
+                    :validations,
+                    :schema_errors_key,
+                    :level,
+                    :validation_errors,
+                    :all_nodes,
+                    :value,
+                    :type_system,
+                    :root,
+                    :context,
+                    :applied,
+                    :input,
+                    :additional_keys_strategy,
+                    :locale
+
+
+      alias_method :types, :type_system
+
+      def parent(level = 1)
+        level.times.inject(self) { |acc| acc.parent_node }
+      end
+
+      alias_method :up, :parent
+
+      def default(default_value, &block)
+        options.merge!(default: default_value)
+        evaluate_block(block) if block_given?
+        self
+      end
+
+      def meta(value = NxtSchema::Undefined.new)
+        if value.is_a?(NxtSchema::Undefined)
+          @meta
+        else
+          @meta = value
+          self
+        end
+      end
+
+      def value_or_default_value(value)
+        if !value && options.key?(:default)
+          DefaultValueEvaluator.new(self, options.fetch(:default)).call
+        else
+          value
+        end
+      end
+
+      def maybe(maybe_value, &block)
+        options.merge!(maybe: maybe_value)
+        evaluate_block(block) if block_given?
+        self
+      end
+
+      def optional(optional_value, &block)
+        raise ArgumentError, 'Optional nodes can only exist within schemas' unless parent.is_a?(NxtSchema::Node::Schema)
+
+        options.merge!(optional: optional_value)
+        evaluate_block(block) if block_given?
+        self
+      end
+
+      def presence(presence_value, &block)
+        raise ArgumentError, 'Present nodes can only exist within schemas' unless parent.is_a?(NxtSchema::Node::Schema)
+
+        options.merge!(presence: presence_value)
+        evaluate_block(block) if block_given?
+        self
+      end
+
+      def presence?
+        @presence ||= begin
+          presence_option = options[:presence]
+
+          options[:presence] = if presence_option.respond_to?(:call)
+            Callable.new(presence_option).call(self, value)
+          else
+            presence_option
+          end
+        end
+      end
+
+      def validate(key, *args, &block)
+        if key.is_a?(Symbol)
+          validator = validator(key, *args)
+        elsif key.respond_to?(:call)
+          validator = key
+        else
+          raise ArgumentError, "Don't know how to resolve validator from: #{key}"
+        end
+
+        add_validators(validator)
+        evaluate_block(block) if block_given?
+        self
+      end
+
+      def add_error(error, index = schema_errors_key)
+        validation_errors[index] ||= []
+        validation_errors[index] << error
+        false
+      end
+
+      def validate_all_nodes
+        sorted_nodes = all_nodes.values.sort do |node, other_node|
+          [node.level, (!node.leaf?).to_s] <=> [other_node.level, (!other_node.leaf?).to_s]
+        end
+
+        # we have to start from the bottom, leafs before others on the same level
+        sorted_nodes.reverse_each(&:apply_validations)
+      end
+
+      def apply_validations
+        # We don't run validations in case there are schema errors
+        # to avoid weird errors
+        # First reject empty schema_errors
+        schema_errors.reject! { |_, v| v.empty? }
+
+        # TODO: Is this correct? - Do not apply validations when maybe criteria applies?
+        unless schema_errors[schema_errors_key]&.any? && !maybe_criteria_applies?(value)
+          build_validations
+
+          validations.each do |validation|
+            args = [self, value]
+            validation.call(*args.take(validation.arity))
+          end
+        end
+
+        if self.is_a?(NxtSchema::Node::Collection) && value.respond_to?(:each)
+          value.each_with_index do |item, index|
+            validation_errors[index]&.reject! { |_, v| v.empty? }
+          end
+        end
+
+        validation_errors.reject! { |_, v| v.empty? }
+
+        self
+      end
+
+      def build_validations
+        validations_from_options = Array(options.fetch(:validate, []))
+        self.validations = validations_from_options
+      end
+
+      def schema_errors?
+        schema_errors.reject! { |_, v| v.empty? }
+        schema_errors.any?
+      end
+
+      def validation_errors?
+        validation_errors.reject! { |_, v| v.empty? }
+        validation_errors.any?
+      end
+
+      def root?
+        @is_root
+      end
+
+      def leaf?
+        false
+      end
+
+      def valid?
+        raise SchemaNotAppliedError, 'Schema was not applied yet' unless applied?
+
+        validation_errors.empty?
+      end
+
+      def add_validators(validator)
+        options[:validate] ||= []
+        options[:validate] = Array(options.fetch(:validate, []))
+        options[:validate] << validator
+      end
+
+      def validator(key, *args)
+        Validators::Registry::VALIDATORS.resolve(key).new(*args).build
+      end
+
+      def validate_with(&block)
+        add_validators(
+          ->(node) { NxtSchema::Node::ValidateWithProxy.new(node).validate(&block) }
+        )
+      end
+
+      private
+
+      def register_node(context)
+        return if all_nodes.key?(object_id)
+
+        self.context = context
+        all_nodes[object_id] = self
+      end
+
+      def applied?
+        @applied
+      end
+
+      def mark_as_applied
+        self.applied = true
+      end
+
+      def add_schema_error(error, index = schema_errors_key)
+        schema_errors[index] ||= []
+        schema_errors[index] << error
+
+        add_error(error, index)
+      end
+
+      def maybe_criteria_applies?(value)
+        @maybe_criteria_applies ||= begin
+          options.key?(:maybe) && MaybeEvaluator.new(self, options.fetch(:maybe), value).call
+        end
+      end
+
+      def self_without_empty_schema_errors
+        schema_errors.reject! { |_, v| v.empty? }
+        validate_all_nodes if root?
+        self.errors = flat_validation_errors(validation_errors, name)
+        self
+      end
+
+      def flat_validation_errors(errors, namespace, acc = {})
+        errors.each_with_object(acc) do |(key, val), acc|
+          current_namespace = [namespace, key].reject { |namespace| namespace == schema_errors_key }.compact.join('.')
+
+          if val.is_a?(::Hash)
+            flat_validation_errors(val, current_namespace, acc)
+          else
+            acc[current_namespace] ||= []
+            acc[current_namespace] += Array(val)
+          end
+        end
+      end
+
+      def name_from_index
+        if parent_node
+          if parent_node.is_a?(NxtSchema::Node::Collection)
+            size + 1
+          else
+            raise ArgumentError, "Nodes with parent_node: #{parent_node} cannot be anonymous"
+          end
+        else
+          :root
+        end
+      end
+
+      def evaluate_block(block)
+        if block.arity.zero?
+          instance_exec(&block)
+        else
+          evaluator_args = [self, value]
+          block.call(*evaluator_args.take(block.arity))
+        end
+      end
+
+      def resolve_type_system
+        type_system = options.fetch(:type_system) { parent_node&.type_system }
+
+        self.type_system = if type_system.is_a?(Module)
+          type_system
+        elsif type_system.is_a?(Symbol) || type_system.is_a?(String)
+          "NxtSchema::Types::#{type_system.to_s.classify}".constantize
+        else
+          NxtSchema::Types
+        end
+      end
+
+      def resolve_additional_keys_strategy
+        options.fetch(:additional_keys) { parent_node&.send(:resolve_additional_keys_strategy) || :ignore }
+      end
+
+      def type_resolver
+        @type_resolver ||= begin
+          if root?
+            TypeResolver.new
+          else
+            raise NoMethodError, 'type_resolver is only available on root node'
+          end
+        end
+      end
+
+      def coerce_value(value)
+        type[value]
+      end
+    end
+  end
+end

data/lib/nxt_schema/node/collection.rb

@@ -0,0 +1,73 @@
+module NxtSchema
+  module Node
+    class Collection < Node::Base
+      def initialize(name:, type: NxtSchema::Types::Strict::Array, parent_node:, **options, &block)
+        @template_store = TemplateStore.new
+        super
+      end
+
+      def apply(input, parent_node: self.parent_node, context: nil)
+        self.input = input
+        register_node(context)
+
+        self.parent_node = parent_node
+        self.schema_errors = { schema_errors_key => [] }
+        self.validation_errors = { schema_errors_key => [] }
+        self.value_store = []
+        self.value = input
+
+        if maybe_criteria_applies?(value)
+          self.value_store = value
+        else
+          self.value = value_or_default_value(value)
+
+          unless maybe_criteria_applies?(value)
+            self.value = coerce_value(value)
+
+            current_node_store = {}
+
+            value.each_with_index do |item, index|
+              item_schema_errors = schema_errors[index] ||= { schema_errors_key => [] }
+              validation_errors[index] ||= { schema_errors_key => [] }
+
+              template_store.each do |node_name, node|
+                current_node = node.dup
+                current_node_store[node_name] = current_node
+                current_node.apply(item, parent_node: self, context: context)
+                value_store[index] = current_node.value
+
+                # TODO: Extract method here
+                unless current_node.schema_errors?
+                  current_node_store.each do |node_name, node|
+                    node.schema_errors = { }
+                    node.validation_errors = { }
+                    item_schema_errors = schema_errors[index][node_name] = node.schema_errors
+                    validation_errors[index][node_name] = node.validation_errors
+                  end
+
+                  break
+                else
+                  schema_errors[index][node_name] = current_node.schema_errors
+                  validation_errors[index][node_name] = current_node.validation_errors
+                end
+              end
+
+              item_schema_errors.reject! { |_, v| v.empty? }
+            end
+
+            # Once we collected all values ensure type by casting again
+            self.value_store = coerce_value(value_store)
+            self.value = value_store
+          end
+        end
+
+        self_without_empty_schema_errors
+      rescue Dry::Types::ConstraintError, Dry::Types::CoercionError => error
+        add_schema_error(error.message)
+        self_without_empty_schema_errors
+      ensure
+        mark_as_applied
+      end
+    end
+  end
+end

data/lib/nxt_schema/node/constructor.rb

@@ -0,0 +1,9 @@
+module NxtSchema
+  module Node
+    class Constructor < Node::Schema
+      def initialize(name:, type: NxtSchema::Types::Constructor(::OpenStruct), parent_node:, **options, &block)
+        super
+      end
+    end
+  end
+end

data/lib/nxt_schema/node/default_value_evaluator.rb

@@ -0,0 +1,20 @@
+module NxtSchema
+  module Node
+    class DefaultValueEvaluator
+      def initialize(node, evaluator_or_value)
+        @node = node
+        @evaluator_or_value = evaluator_or_value
+      end
+
+      attr_reader :node, :evaluator_or_value
+
+      def call
+        if evaluator_or_value.respond_to?(:call)
+          Callable.new(evaluator_or_value).call(node)
+        else
+          evaluator_or_value
+        end
+      end
+    end
+  end
+end

data/lib/nxt_schema/node/error.rb

@@ -0,0 +1,13 @@
+module NxtSchema
+  module Node
+    class Error
+      def initialize(path, value, message)
+        @path = path
+        @value = value
+        @message = message
+      end
+
+      attr_reader :path, :value, :message
+    end
+  end
+end

data/lib/nxt_schema/node/has_subnodes.rb

@@ -0,0 +1,97 @@
+require_relative 'schema'
+require_relative 'collection'
+require_relative 'constructor'
+require_relative 'leaf'
+
+module NxtSchema
+  module Node
+    module HasSubNodes
+      attr_accessor :template_store, :value_store
+
+      # TODO: Would be cool if we could register custom node types!
+      def node(name, type_or_node, **options, &block)
+        child_node = case type_or_node.to_s.to_sym
+        when :Schema
+          NxtSchema::Node::Schema.new(name: name, type: NxtSchema::Types::Strict::Hash, parent_node: self, **options, &block)
+        when :Collection
+          NxtSchema::Node::Collection.new(name: name, type: NxtSchema::Types::Strict::Array, parent_node: self, **options, &block)
+        when :Struct
+          NxtSchema::Node::Constructor.new(
+            name: name,
+            type: NxtSchema::Types::Constructor(::Struct) { |hash| ::Struct.new(*hash.keys).new(*hash.values) },
+            parent_node: self,
+            **options,
+            &block
+          )
+        when :OpenStruct
+          NxtSchema::Node::Constructor.new(
+            name: name,
+            type: NxtSchema::Types::Constructor(::OpenStruct),
+            parent_node: self,
+            **options,
+            &block
+          )
+        else
+          if type_or_node.is_a?(NxtSchema::Node::Base)
+            node = type_or_node.clone
+            node.options.merge!(options)
+            node.name = name
+            node.parent_node = self
+            node
+          else
+            NxtSchema::Node::Leaf.new(name: name, type: type_or_node, parent_node: self, **options)
+          end
+        end
+
+        # TODO: Should we check if there is a
+        raise KeyError, "Duplicate registration for key: #{name}" if template_store.key?(name)
+        template_store.push(child_node)
+
+        child_node
+      end
+
+      def required(name, type, **options, &block)
+        node(name, type, options, &block)
+      end
+
+      alias_method :requires, :required
+
+      def nodes(name, **options, &block)
+        node(name, :Collection, options, &block)
+      end
+
+      alias_method :array, :nodes
+
+      def schema(name, **options, &block)
+        node(name, :Schema, options, &block)
+      end
+
+      alias_method :hash, :schema
+
+      def struct(name, **options, &block)
+        node(name, NxtSchema::Types::Constructor(::OpenStruct), options, &block)
+      end
+
+      def dup
+        result = super
+        result.template_store = template_store.deep_dup
+        result.options = options.deep_dup
+        result
+      end
+
+      delegate_missing_to :value_store
+
+      private
+
+      def value_violates_emptiness?(value)
+        return true unless value.respond_to?(:empty?)
+
+        value.empty?
+      end
+    end
+  end
+end
+
+NxtSchema::Node::Schema.include(::NxtSchema::Node::HasSubNodes)
+NxtSchema::Node::Collection.include(::NxtSchema::Node::HasSubNodes)
+NxtSchema::Node::Constructor.include(::NxtSchema::Node::HasSubNodes)

data/lib/nxt_schema/node/leaf.rb

@@ -0,0 +1,43 @@
+module NxtSchema
+  module Node
+    class Leaf < Node::Base
+      def initialize(name:, type:, parent_node:, **options, &block)
+        super
+        @type = resolve_type(type)
+      end
+
+      def leaf?
+        true
+      end
+
+      def apply(input, parent_node: self.parent_node, context: nil)
+        self.input = input
+        register_node(context)
+
+        self.parent_node = parent_node
+        self.schema_errors = { schema_errors_key => [] }
+        self.validation_errors = { schema_errors_key => [] }
+
+        if maybe_criteria_applies?(input)
+          self.value = input
+        else
+          self.value = value_or_default_value(input)
+          self.value = coerce_value(value) unless maybe_criteria_applies?(value)
+        end
+
+        self_without_empty_schema_errors
+      rescue Dry::Types::ConstraintError, Dry::Types::CoercionError => error
+        add_schema_error(error.message)
+        self_without_empty_schema_errors
+      ensure
+        mark_as_applied
+      end
+
+      private
+
+      def resolve_type(name_or_type)
+        root.send(:type_resolver).resolve(type_system, name_or_type)
+      end
+    end
+  end
+end