nxt_schema 0.1.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09685f892e03e96e13235c9f5d98c78ddbacd8118a47062c3a4417530cd2a3b0'
-  data.tar.gz: ec1b647208395d39dc5f61639dcfdfa1ea65caadfa9cd9011414ed9a5a5d9430
+  metadata.gz: a4076ec4518cc51176684f4bb04fca5bcff3554835016f57cce322debf3e9b8c
+  data.tar.gz: 336acbce68af2023b714b2b023d732575138968279efebc74b984b51ff33de13
 SHA512:
-  metadata.gz: 56489e75d59dc6f21f8237fcebc14236113c2e14cb47adb986989f819d0937353b1dd37763b522737923e3a87966eda2bf339f42055383fc8d174d536f1d32e5
-  data.tar.gz: 1f595737e27ff2c874c807b2339eee3781799a64cac27bd3724642898db6200ec60279edd72b50f100d3a52ff4f8ef155e97392b8738186258d8fd93dbdd65b0
+  metadata.gz: 4947f05400dd492a8bed83ae2b0c42110c75ebd6fd495bdcdcef10871f7715c6d69797ab95291006df759945551c0f92869e29f5b03f0343af49f4bcf6aa3497
+  data.tar.gz: 8ed842b8144aacd64f880e3ff7c74c64a9ae218f598522a60f26fb7a0aa2829fb3deaaf93ea0b8600a6346adb6f921d2e56e2249d1ab18e4b5c6427d25bf8759

data/.ruby-version

@@ -0,0 +1 @@
+2.7.0

data/Gemfile

@@ -1,6 +1,5 @@
 source "https://rubygems.org"
 
 git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
-
 # Specify your gem's dependencies in nxt_schema.gemspec
 gemspec

data/Gemfile.lock

@@ -1,75 +1,73 @@
 PATH
   remote: .
   specs:
-    nxt_schema (0.1.0)
+    nxt_schema (1.0.2)
       activesupport
       dry-types
+      nxt_init
       nxt_registry
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.2.1)
+    activesupport (6.1.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-      zeitwerk (~> 2.2)
-    coderay (1.1.2)
-    concurrent-ruby (1.1.6)
-    diff-lcs (1.3)
-    dry-configurable (0.11.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.8)
+    diff-lcs (1.4.4)
+    dry-configurable (0.12.1)
       concurrent-ruby (~> 1.0)
-      dry-core (~> 0.4, >= 0.4.7)
-      dry-equalizer (~> 0.2)
+      dry-core (~> 0.5, >= 0.5.0)
     dry-container (0.7.2)
       concurrent-ruby (~> 1.0)
       dry-configurable (~> 0.1, >= 0.1.3)
-    dry-core (0.4.9)
+    dry-core (0.5.0)
       concurrent-ruby (~> 1.0)
-    dry-equalizer (0.3.0)
     dry-inflector (0.2.0)
-    dry-logic (1.0.6)
+    dry-logic (1.1.0)
       concurrent-ruby (~> 1.0)
-      dry-core (~> 0.2)
-      dry-equalizer (~> 0.2)
-    dry-types (1.3.1)
+      dry-core (~> 0.5, >= 0.5)
+    dry-types (1.5.1)
       concurrent-ruby (~> 1.0)
       dry-container (~> 0.3)
-      dry-core (~> 0.4, >= 0.4.4)
-      dry-equalizer (~> 0.3)
+      dry-core (~> 0.5, >= 0.5)
       dry-inflector (~> 0.1, >= 0.1.2)
       dry-logic (~> 1.0, >= 1.0.2)
     hirb (0.7.3)
-    i18n (1.8.2)
+    i18n (1.8.9)
       concurrent-ruby (~> 1.0)
     method_profiler (2.0.1)
       hirb (>= 0.6.0)
-    method_source (0.9.2)
-    minitest (5.14.0)
-    nxt_registry (0.1.4)
+    method_source (1.0.0)
+    minitest (5.14.4)
+    nxt_init (0.1.5)
       activesupport
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
+    nxt_registry (0.3.9)
+      activesupport
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
     rake (12.3.3)
-    rspec (3.8.0)
-      rspec-core (~> 3.8.0)
-      rspec-expectations (~> 3.8.0)
-      rspec-mocks (~> 3.8.0)
-    rspec-core (3.8.2)
-      rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.4)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.0)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.1)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.2)
-    thread_safe (0.3.6)
-    tzinfo (1.2.6)
-      thread_safe (~> 0.1)
-    zeitwerk (2.2.2)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.0)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.4.2)
 
 PLATFORMS
   ruby

data/README.md

@@ -16,138 +16,200 @@ Or install it yourself as:
 
     $ gem install nxt_schema
 
-## Usage
+## What is it for?
+
+NxtSchema is a type coercion and validation framework that allows you to coerce and validate arbitrary nested 
+structures of data. The original idea is taken from https://dry-rb.org/gems/dry-schema and 
+https://dry-rb.org/gems/dry-validation from the amazing dry.rb eco system. In contrast to dry-schema, 
+NxtSchema aims to be a simpler solution that hopefully is easier to understand and debug. 
+It also ships with some handy features that dry-schema does not implement. 
+
+### Usage
 
 ```ruby
-# Schema with hash root
-schema = NxtSchema.root(:company) do 
-  requires(:name, :String)  
-  requires(:value, :Integer).maybe(nil)  
-  present(:stock_options, :Bool).default(false)
-  
-  schema(:address) do
-    requires(:street, :String)
-    requires(:street_number, :Integer)
-  end
-    
-  nodes(:employees) do
-    hash(:employee) do
-      POSITIONS = %w[senior junior intern]
-
-      requires(:first_name, :String)
-      requires(:last_name, :String)
-      optional(:email, :String).validate(:format, /\A.*@.*\z/)
-      requires(:position, NxtSchema::Types::Enums[*POSITIONS])
-    end
-  end
-end
-  
-# Schema with array root
-schema = NxtSchema.roots(:companies) do
-  schema(:company) do
-    requires(:name, :String)  
-    requires(:value, :Integer).maybe(nil)
-  end
+PERSON = NxtSchema.schema(:person) do
+  node(:first_name, :String)
+  node(:last_name, :String)
+  node(:email, :String, optional: true).validate(:includes, '@')
 end
 
-schema.apply(your: 'values here')
-schema.errors # { 'name.spaced.key': ['all the errors'] }
+input = {
+  first_name: 'Ändy',
+  last_name: 'Robecke',
+  email: 'andreas@robecke.de'
+}
+
+result = PERSON.apply(input: input)
+
+result.valid? # => true
+result.output # => input
+```  
+
+### Nodes
+
+A schema consists of a number of nodes. Every node has a name and an associated type for casting it's input when the 
+schema is applied. Schemas can consist of 4 different kinds of nodes: 
+
+```ruby
+NxtSchema::Node::Schema # => Hash of values 
+NxtSchema::Node::Collection # => Array of values
+NxtSchema::Node::AnyOf # => Any of the defined schemas
+NxtSchema::Node::Leaf # => Node without sub nodes
 ```
 
-### DSL
+The kind of node dictates how the schema is applied to the input. On the root level the following methods are available
+to create schemas:
+
+```ruby
+  NxtSchema.schema { ... } # => Creates a schema node 
+  NxtSchema.collection { ... } # => Creates an array of nodes
+  NxtSchema.any_of { ... } # => Creates a collection of allowed schemas
+```
 
-Create a new schema with `NxtSchema.root { ... }` or in case you have an array node as root, 
-use `NxtSchema.roots { ... }`. Within the schema you can create node simply with the `node(name, type_or_node, **options)` 
-method. Each node requires a name and a type and accepts additional options. Node are required per default. 
-But you can make them optional by providing the optional option.  
+#### Node predicate aliases
 
-#### Nodes
+Of course these nodes can be combined and nested in arbitrary manner. When defining nodes within a schema, nodes are 
+always required per default. You can create nodes with the node method or several useful helper methods. 
 
 ```ruby
-NxtSchema.root do
-  node(:first_name, :String)
-  node(:last_name, :String, optional: true)
-  node(:email, :String, presence: true)
+NxtSchema.schema(:person) do
+  required(:first_name, :String) # => same as node(:first_name, :String)
+  optional(:last_name, :String) # => same as node(:first_name, :String, optional: true)
+  omnipresent(:email, :String) # => same as node(:first_name, :String, omnipresent: true)
 end
 ```
 
-In order to make the schema more readable you can make use of several predicate aliases to create required, optional or 
-(omni)present nodes.  
+**NOTE: The methods above only apply to the keys of your schema and do not make any assumptions about values!**
 
-#### Predicate aliases
+In other word this means that making a node optional only makes your node optional. When your input contains the key but
+the value is nil, you will still get an error in case there is no default or maybe expression that applies. Omnipresent
+node also only inject the node into the schema but do not inject a default value. In order to inject a key with value 
+into a schema you also have to combine the node predicates with default value method described below. For clarification
+check out the examples below:
 
 ```ruby
-NxtSchema.root do
-  required(:first_name, :String)
-  optional(:last_name, :String)
-  present(:email, :String)
+# Optional node without default value
+
+schema = NxtSchema.schema(:person) do
+  optional(:email, :String)
 end
+
+result = schema.apply(input: { email: nil })
+result.errors # => {"person.email"=>["nil violates constraints (type?(String, nil) failed)"]}
+result.output # => {:email=>nil}
+
+result = schema.apply(input: {})
+result.errors # => {}
+result.output # => {}
 ```
 
-### Nodes
+```ruby
+# Optional node with default value
 
-The following types of nodes exist
+schema = NxtSchema.schema(:person) do
+  optional(:email, :String).default('andreas@robecke.de')
+end
 
-#### Schema Nodes
+result = schema.apply(input: { email: nil })
+result.errors # => {}
+result.output # => {:email=>"andreas@robecke.de"}
 
-```ruby
-# Create schema nodes with:
-required(:test, :Schema) do ... end
-schema(:test) do ... end
-hash(:test) do ... end
+result = schema.apply(input: {})
+result.errors # => {}
+result.output # => {}
 ```
 
-#### Collection Nodes
+```ruby
+# Omnipresent node without default value
+
+schema = NxtSchema.schema(:person) do
+  omnipresent(:email, :String)
+end
+
+result = schema.apply(input: {})
+result.errors # => {}
+result.output # => {:email=>NxtSchema::Undefined}
+```
 
 ```ruby
-# Create collection (array) nodes with:
-required(:test, :Collection) do ... end
+# Omnipresent node with default value and maybe expression to allow default value to break type contract.
 
-nodes(:test) do
-  # For type checking of array items you can simply add a node with the expected type. 
-  # As always you need to give it a name. This would result in an array of string items  
-  required(:item, :String) 
+schema = NxtSchema.schema(:person) do
+  omnipresent(:email, :String).default(nil).maybe(:nil?)
 end
 
-array(:test) do ... end
+result = schema.apply(input: {})
+result.errors # => {}
+result.output # => {:email=>nil}
+
+result = schema.apply(input: { email: 'andreas@robecke.de' })
+result.errors # => {}
+result.output # => {:email=>"andreas@robecke.de"}
 ```
 
-#### Leaf Nodes
+##### Conditionally optional nodes
+
+You can also pass a proc as the optional option. This is a shortcut for adding a validation to the parent node 
+that will result in a validation error in case the optional condition does not apply and the parent node does not 
+contain a sub node with that name (here contact schema not including an email node). 
 
 ```ruby
-# Create leaf nodes with a basic type 
-required(:test, :String) do ... end
-```
+schema = NxtSchema.schema(:contact) do
+  required(:first_name, :String)
+  required(:last_name, :String)
+  node(:email, :String, optional: ->(node) { node.up[:last_name].input == 'Robecke' })
+end
+
+result = schema.apply(input: { first_name: 'Andy', last_name: 'Other' })
+result.errors # => {"contact"=>["Required key :email is missing"]}
+
+result = schema.apply(input: { first_name: 'Andy', last_name: 'Robecke' })
+result.errors # => {}
+```  
+
+#### Combining Schemas
 
-#### Struct Nodes
+You can also simply reuse a schema by passing it to the node method as the type of a node. When doing so the schema 
+will be cloned with the same options and configuration as the schema passed in. 
 
 ```ruby
-# Create structs from hash inputs 
-struct(:test) do ... end  
+ADDRESS = NxtSchema.schema(:address) do
+  required(:street, :String)
+  required(:town, :String)
+  required(:zip_code, :String)
+end 
+
+PERSON = NxtSchema.schema(:person) do
+  required(:first_name, :String)
+  required(:last_name, :String)
+  optional(:address, ADDRESS)
+end
 ```
 
 ### Types
 
-The type system is built with dry-types from the amazing https://dry-rb.org/ eco system. Even though dry-types also
+The type system is built with dry-types from the amazing https://dry-rb.org eco system. Even though dry-types also
 offers features such as default values for types as well as maybe types, these features are built directly into 
-NxtSchema. Dry.rb also has a gem for schemas and another one dedicated to validations. You should probably
-check those out! However, in NxtSchema every node has a type and you can either provide a symbol that will be resolved 
-through the type system of the schema. But you can also directly provide an instance of dry type and thus use your 
-custom types.    
+NxtSchema. 
+
+In NxtSchema every node has a type and you can either provide a symbol that will be resolved 
+through the type system of the schema or you can directly provide an instance of dry type and thus use your 
+custom types. This means you can basically build any kind of objects such as structs and models from your data and 
+you are not limited to just hashes arrays and primitives.  
 
 #### Default type system
 
 You can tell your schema which default type system it should use. Dry-Types comes with a few built in type systems.
 Per default NxtSchema will use nominal types if not specified otherwise. If the type cannot be resolved from the default
-type system that was specified, NxtSchema will again try to fallback to nominal types. In theory you can provide
-a separate type system per node if that's what you want :-D
+type system that was specified NxtSchema will always fallback to nominal types. In theory you can provide
+a separate type system per node if that's what you need. 
                                
 ```ruby
-NxtSchema.root do
+NxtSchema.schema do
   required(:test, :String) # The :String will resolve to NxtSchema::Types::Nominal::String
 end
 
-NxtSchema.root(type_system: NxtSchema::Types::JSON) do
+NxtSchema.schema(type_system: NxtSchema::Types::JSON) do
   required(:test, :Date) # The :Date will resolve to NxtSchema::Types::JSON::Date
   # When the type does not exist in the default type system (there is non JSON::String) we fallback to nominal types
   required(:test, :String) 
@@ -163,10 +225,42 @@ This is suitable to validate and coerce your query params.
 NxtSchema.params do
   required(:effective_at, :DateTime) # would resolve to Types::Params::DateTime 
   required(:test, :String) # The :String will resolve to NxtSchema::Types::Nominal::String
-  required(:advanced, NxtSchema::Types::Params::Bool) # long version of required(:advanced, :Bool)
+  required(:advanced, NxtSchema::Types::Registry::Bool) # long version of required(:advanced, :Bool)
 end
 ```
 
+#### NxtSchema::Registry
+
+To make use of NxtSchema.params in your controller you can simply include the `NxtSchema::Registry` to easily register 
+and apply schemas: 
+
+```ruby
+class UsersController < ApplicationController
+  include NxtSchema::Registry
+  
+  # register the schema for the :create action
+  schemas.register(
+    :create, 
+    NxtSchema.params do
+      required(:first_name, :String)
+      required(:last_name, :String)
+    end
+  )
+  
+  def create
+    User.create!(**create_params) 
+  end
+  
+  private
+
+  def create_params
+    # apply the registered schema  
+    schemas.apply!(:create, params.fetch(:user))
+  end
+end
+
+```
+
 #### Custom types
 
 You can also register custom types. In order to check out all the cool things you can do with dry types you should 
@@ -180,8 +274,8 @@ NxtSchema.register_type(
 
 # once registered you can use the type in your schema
 
-NxtSchema.root(:company) do
-  required(:name, NxtSchema::Types::MyCustomStrippedString)
+NxtSchema.schema(:company) do
+  required(:name, :MyCustomStrippedString)
 end
 ```
 
@@ -190,35 +284,44 @@ end
 #### Default values
 
 ```ruby
-# Define default values as options or with the default method
-required(:test, :String).default(value_or_proc)
-required(:test, :String, default: value_or_proc) do ... end
+# Define default values with the default method
+required(:test, :DateTime).default(nil)
+required(:test, :DateTime).default(-> { Time.current })
 ```
 
 #### Maybe values 
 
-Allow specific values that are not being coerced
+With maybe expressions you can halt coercion and allow your values to break the type contract. 
+**Note: This means that your output will simply be set to the input without coercing the value!**
 
 ```ruby
 # Define maybe values (values that do not match the type)
-required(:test, :String).maybe(value_or_proc)
-required(:test, :String, maybe: value_or_proc) do ... end
+required(:test, :String).maybe(:nil?)
+
+nodes(:tests).maybe(:empty?) do # will allow the collection to be empty and thus not contain strings
+  required(:test, :String)
+end
+
 ```  
 
 ### Validations
 
 NxtSchema comes with a simple validation system and ships with a small set of useful validators. Every node in a schema
 implements the `:validate` method. Similar to ActiveModel::Validations it allows you to simply add errors to a node
-based on some condition. 
+based on some condition. When the node is yielded to your validation proc you have access to the nodes input with
+`node.input` and `node.index` when the node is within a collection of nodes as well as `node.name`. Furthermore you have 
+access to the context that was passed in when defining the schema or passed to the apply method later.
+
+**NOTE: Validations only run when no maybe expression applies and the node input could be coerced successfully**
 
 ```ruby
-  # Simple validation
-  required(:test, :String).validate -> (node, value) { node.add_error("#{value} is not valid") if value == 'not allowed' }
+  # Simple custom validation
+  required(:test, :String).validate(-> (node) { node.add_error("#{node.input} is not valid") if node.input == 'not allowed' })
   # Built in validations
   required(:test, :String).validate(:attribute, :size, ->(s) { s < 7 }) 
-  required(:test, :String).validate(:equality, 'same') 
-  required(:test, :String).validate(:excluded, %w[not_allowed]) # excluded in the target: %w[not_allowed]
-  required(:test, :String).validate(:included, %w[allowed]) # included in the target: %w[allowed]
+  required(:test, :String).validate(:equal_to, 'same') 
+  required(:test, :String).validate(:excluded_in, %w[not_allowed]) # excluded in the target: %w[not_allowed]
+  required(:test, :String).validate(:included_in, %w[allowed]) # included in the target: %w[allowed]
   required(:test, :Array).validate(:excludes, 'excluded') # array value itself must exclude 'excluded' 
   required(:test, :Array).validate(:includes, 'included') # array value itself must include 'included'
   required(:test, :Integer).validate(:greater_than, 1) 
@@ -259,7 +362,7 @@ end
 NxtSchema.register_validator(MyCustomExclusionValidator, :my_custom_exclusion_validator)
 
 # and then simply reference it with the key you've registered it
-schema = NxtSchema.root(:company) do
+schema = NxtSchema.schema(:company) do
   requires(:name, :String).validate(:my_custom_exclusion_validator, %w[lemonade])
 end
 
@@ -272,25 +375,24 @@ schema.apply(name: 'lemonade').valid? # => false
 - Add translated errors
 - Interpolate with actual vs. expected 
 
-#### Combining validators with custom logic
+#### Combining validators
 
 `node(:test, String).validate(...)` basically adds a validator to the node. Of course you can add multiple validators.
-But that means that they will all be executed and errors aggregated. If you want your validator to only run in case 
+But that means that they will all be executed. If you want your validator to only run in case 
 another was false, you can use `:validat_with do ... end` in order to combine validators based on custom logic. 
 
  ```ruby
-NxtSchema.root do
+NxtSchema.schema do
   required(:test, :Integer).validate_with do
     validator(:greater_than, 5) &&
-      validator(:greater_than, 6) &&
+      validator(:greater_than, 6) ||
       validator(:greater_than, 7)
   end
 end
 ```
 
-This has one drawback however. Let's say your test value is 4. This would only run your first validator and then exit 
-from the logic since validators are combined with &&. In this example it might not make much sense, but it basically 
-means that you might not have the full validation errors when combining validations with `:validate_with` 
+Note that this will not run subsequent validators once one was valuated to false and thus might not contain all error 
+messages of all validators that would have failed.  
 
 
 ### Schema options
@@ -302,21 +404,21 @@ You can change this behaviour by providing a strategy for the `:additional_keys`
 
 ```ruby
 # This will simply ignore any other key except test 
-NxtSchema.root(additional_keys: :ignore) do
+NxtSchema.schema(additional_keys: :ignore) do
   required(:test, :String) 
 end
 
 # This would give you an error in case you apply anything other than { test: '...' }
-NxtSchema.root(additional_keys: :restrict) do
+NxtSchema.schema(additional_keys: :restrict) do
   required(:test, :String) 
 end
 
 # This will merge other keys into your output
-schema = NxtSchema.root(additional_keys: :allow) do
+schema = NxtSchema.schema(additional_keys: :allow) do
   required(:test, :String) 
 end
 
-schema.apply(test: 'getsafe', other: 'Heidelberg')
+schema.apply(input: {test: 'getsafe', other: 'Heidelberg'})
 schema.valid? # => true
 schema.value # => { test: 'getsafe', other: 'Heidelberg' }
 ```
@@ -327,12 +429,12 @@ You may want to transform the keys from your input. Therefore specify the transf
 when you want your schema to return only symbolized keys for example. 
 
 ```ruby
-schema = NxtSchema.root(transform_keys: :to_sym) do
+schema = NxtSchema.schema(transform_keys: ->(key) { key.to_sym}) do
   required(:test, :String)
 end
 
-schema.apply('test' => 'getsafe') # => {:test=>"getsafe"}
-schema.apply(test: 'getsafe') # => {:test=>"getsafe"}
+schema.apply(input: { 'test' => 'getsafe' }) # => {:test=>"getsafe"}
+schema.apply(input: { test: 'getsafe' }) # => {:test=>"getsafe"}
 ``` 
 
 #### Adding meta data to nodes
@@ -341,7 +443,7 @@ You want to give nodes an ID or some other meta data? You can use the meta metho
 information onto any node.  
 
 ```ruby
-schema = NxtSchema.root do
+schema = NxtSchema.schema do
   ERROR_MESSAGES = {
     test: 'This is always broken'
   }
@@ -349,10 +451,49 @@ schema = NxtSchema.root do
   required(:test, :String).meta(ERROR_MESSAGES).validate ->(node) { node.add_error(node.meta.fetch(node.name)) }
 end
 
-schema.apply(test: 'getsafe') 
+schema.apply(input: { test: 'getsafe' }) 
 schema.error #  {"root.test"=>["This is always broken"]}
 ```
 
+#### Contexts
+
+When defining a schema it is possible to pass in a context option. This can be anything that you would like to access
+during building your schema. A context could provide custom validators or default values depending of the name of your
+nodes for instance.  
+
+##### Build time
+
+```ruby
+context = OpenStruct.new(email_validator: ->(node) { node.input && node.input.includes?('@') }) 
+
+NxtSchema.schema(:developers, context: context) do
+  required(:first_name, :String)
+  required(:last_name, :String)
+  required(:email, :String).validate(context.email_validator)
+end
+```
+
+##### Apply time
+
+You can also pass in a context at apply time. If you do not pass in a specific 
+context at apply time you can still access the context passed in at build time. 
+Basically passing in a context at apply time will overwrite the context from before. You can access it simply through
+the node.  
+
+```ruby
+build_context = OpenStruct.new(email_validator: ->(node) { node.input.includes?('@') })
+apply_context = OpenStruct.new(default_role: 'BOSS')
+
+schema = NxtSchema.schema(:developers, context: build_context) do
+  # context at build time
+  required(:email, :String).validate(context.email_validator) # 
+  # access the context at apply time through the node 
+  required(:role, :String).default { |_, node| node.context.default_role }
+end
+
+schema.apply(input: input, context: apply_context)
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -361,16 +502,21 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/nxt_schema.
+Bug reports and pull requests are welcome on GitHub at https://github.com/getand.
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
-# TODO:    
-
-- Explain the difference between array nodes and typed array nodes
-- Should we translate coercion errors as well?
-- Test the different scenarios of merging schemas array, hash, ...
-- Structure Errors 
-- NxtSchema::Json => Use json types, maybe even parse Json with Oj
+## TODO:
+
+- Explain node interface
+- Add apply! method to readme
+- Allow to disable validation when applying 
+    --> Are there attributes that should be moved to apply time?
+- Should we have a global and a local registry for validators?
+    --> Would be cool to register things for the schema only
+    --> Would be cool if this was extendable 
+- Do we need all off in order to combine multiple schemas?
+- Allow custom errors
+- Spec inheritance of params