Introduction to building web applications with dry-rb gems

1. 1/131

2. Me
Nikita Shilnikov
• github.com/flash-gordon
• Whatever developer
• dry-rb and rom-rb core team member
2/131

3. dry-rb
3/131

4. Thank you!
4/131

5. Web-application
5/131

6. request -> (application) -> response
6/131

7. response = application(request)
7/131

8. response = application.call(request)
8/131

9. 9/131

10. class User < ApplicationRecord
before_save :set_name
def set_name
self.name = [first_name, last_name].join(' ')
end
end
10/131

11. class User < ApplicationRecord
before_save :set_name, unless: -> u { u.source == 'github' }
def set_name
self.name = [first_name, last_name].join(' ')
end
end
11/131

12. class CreateUserFromGithub
# ...
end
class CreateUser
# ...
end
12/131

13. class CreateUser
def call(params)
User.create(params) do |user|
user.name = build_name(user)
end
end
def build_name(user)
[user.first_name, user.last_name].join(' ')
end
end
13/131

14. Single responsibility principle
14/131

15. def create
user = CreateUser.new.call(params)
end
15/131

16. def create
create_user = CreateUser.new
user = create_user.call(params)
end
16/131

17. object + SRP = function
17/131

18. def create
create_user = proc do |params|
name = params.values_at(:first_name, :last_name).join(' ')
User.create(params.merge(name: name))
end
user = create_user.call(params)
end
18/131

19. def create
user = create_user.call(params)
end
def create_user
delimiter = ' '
proc do |params|
name = params.values_at(:first_name, :last_name).join(delimiter)
User.create(params.merge(name: name))
end
end
19/131

20. dry-rb
20/131

21. ~20 gems
21/131

22. Each gem serves one purpose
22/131

23. Not a left-pad
23/131

24. Principles
• Functional objects
• Immutability
24/131

25. Functional objects
class CreateUser
attr_reader :repo
def initialize(repo)
@repo = repo
end
def call(data)
repo.create(data)
end
end
25/131

26. create_user = CreateUser.new(repo)
26/131

27. create_user.call(name: 'John')
27/131

28. create_user.call(name: 'John')
^^^^^^^^^^^ ^^^^^^^^^^^^^
28/131

29. create_user.call(name: 'John')
^^^^^^^^^^^| |^^^^^^^^^^^^^
object | | data
29/131

30. create_user.(name: 'John')
^^^^^^^^^^^|^^^^^^^^^^^^^^
function | data
30/131

31. create_user.(name: 'Wilhelm')
create_user.(name: 'Hendrik')
create_user.(name: 'Pieter')
create_user.(name: 'Pierre')
create_user.(name: 'Maria')
create_user.(name: 'Philipp')
create_user.(name: 'Albert')
create_user.(name: 'Karl')
31/131

32. app = Application.new
app.call(request_1)
app.call(request_2)
app.call(request_3)
app.call(request_4)
app.call(request_5)
app.call(request_6)
app.call(request_7)
app.call(request_8)
app.call(request_9)
32/131

33. application -> ... -> create_user -> ...
33/131

34. The big picture
app = Application.new
status, headers, body = app.call(request_1)
34/131

35. Stack
1. Route
2. Validate
3. Issue updates (if any)
4. Fetch data
5. Render
35/131

36. Route with dry-web-roda
36/131

37. dry-web-roda = dry-web + Roda
37/131

38. dry-web-roda
class Shop::Application < Dry::Web::Roda::Application
end
38/131

39. dry-web-roda
class Shop::Application < Dry::Web::Roda::Application
route 'users' do |r|
r.is do
r.post do
# create user
end
end
end
end
39/131

40. dry-web-roda
r.post do
create_user = CreateUser.new
create_user.call(r.params['user'])
end
40/131

41. class CreateUser
def call(input)
end
end
41/131

42. class CreateUser
def call(input)
validate(input)
end
end
42/131

43. class CreateUser
def call(input)
something.call(input)
end
end
43/131

44. Something is a schema
44/131

45. Validate with
dry-validation
45/131

46. dry-validation
validate and coerce
46/131

47. Coercion
params[:user_id]
47/131

48. Coercion
params[:user_id].class # => ???
48/131

49. Coercion
params[:user_id].class
# => String | Fixnum | Hash | Array
49/131

50. Coercion
params[:user_id].to_i
50/131

51. Coercion
'abyr'.to_i # => 0
51/131

52. 52/131

53. Coercion
Integer('40') # => 40
53/131

54. Coercion
Integer('abyr') # => ArgumentError
54/131

55. Coercion
Integer('050') # => 40
55/131

56. Coercion
Integer('050', 10) # => 50
56/131

57. Coercion
Integer(50, 10) # => ArgumentError
57/131

58. dry-validation
class CreateUser
Schema = Dry::Validation.Form do
end
end
58/131

59. dry-validation
class CreateUser
Schema = Dry::Validation.Form do
required(:name).filled(:str?)
end
end
59/131

60. dry-validation
class CreateUser
Schema = Dry::Validation.Form do
required(:name).filled(:str?)
required(:age).filled(:int?, gteq?: 18)
end
end
60/131

61. dry-validation
CreateUser::Schema.('name' => 'John', 'age' => '20').to_h
=> { name: "John", age: 20 }
61/131

62. dry-validation
CreateUser::Schema.('name' => 'John', 'age' => '20').to_h
=> { name: "John", age: 20 }
^^^^^^^
62/131

63. dry-validation
CreateUser::Schema.('name' => 'John', 'age' => '16').errors
=> { age: ["must be greater than or equal to 18"] }
63/131

64. dry-validation
CreateUser::Schema.('name' => 'John', 'age' => 'abyr').errors
=> { age: ["must be an integer"] }
64/131

65. dry-validation
Replaces Strong Parameters and ActiveModel::Validations
65/131

66. class CreateUser
def call(input)
validation = Schema.(input)
if validation.success?
create_from_data(validation.output)
end
end
end
66/131

67. def create_from_data(data)
user_repo = ???
user_repo.create(data)
end
67/131

68. def create_from_data(data)
user_repo = User
user_repo.create(data)
end
68/131

69. def create_from_data(data)
user_repo = UserRepository.new(rom)
user_repo.create(data)
end
69/131

70. dry-container
70/131

71. dry-container
Shop::Container = Dry::Container.new
Shop::Container.register(:user_repo) do
UserRepository.new(rom)
end
71/131

72. dry-container
def create_from_data(data)
user_repo = Shop::Container.resolve(:user_repo)
user_repo.create(data)
end
72/131

73. class CreateUser
attr_reader :user_repo
def initialize
@user_repo = Shop::Container.resolve(:user_repo)
end
# ...
def create_from_data(data)
user_repo.create(data)
end
end
73/131

74. dry-auto_inject
DI tool for Ruby
74/131

75. dry-auto_inject
Shop::Import = Dry::AutoInject(Shop::Container)
75/131

76. dry-auto_inject
class CreateUser
include Shop::Import[repo: 'repositories.user']
def call(input)
validation = Schema.(input)
if validation.success?
repo.create(validation.output)
end
end
end
76/131

77. dry-auto_inject
create_user = CreateUser.new
77/131

78. dry-auto_inject
create_user = CreateUser.new(repo: injection)
78/131

79. Shop::Container.namespace(:operations) do
register(:create_user) do
Operations::CreateUser.new
end
end
79/131

80. Shop::Container.namespace(:operations) do
register(:create_user) do
Shop::Operations::CreateUser.new
end
register(:create_post) do
Shop::Operations::CreatePost.new
end
register(:create_tag) do
Shop::Operations::CreateTag.new
end
register(:create_account) do
Shop::Operations::CreateAccount.new
end
register(:update_user) do
Shop::Operations::UpdateUser.new
end
register(:update_post) do
Shop::Operations::UpdatePost.new
end
register(:update_tag) do
Shop::Operations::UpdateTag.new
end
register(:update_account) do
Shop::Operations::UpdateAccount.new
end
end
80/131

81. dry-system
81/131

82. dry-system
module Shop
class Container < Dry::Web::Container
configure do
config.auto_register = 'lib'.freeze
config.system_dir = 'system'.freeze
config.root = Pathname(__FILE__).dirname.join('../..')
end
load_paths! 'lib' # Adds to $LOAD_PATH
end
end
82/131

83. dry-system
r.post do
r.resolve 'operations.create_user' do |create|
create.(r.params['user'])
end
end
83/131

84. dry-system
r.resolve
1. Uses require
2. Searches for operations/create_user.rb
3. Creates Operations::CreateUser
84/131

85. r.post do
r.resolve 'operations.create_user' do |create|
user = create.(r.params['user'])
r.redirect_to "/users/#{ user.id }"
end
end
85/131

86. class CreateUser
def call(input)
validation = Schema.(input)
if validation.success?
repo.create(validation.output)
else
# ???
end
end
end
86/131

87. class CreateUser
def call(input)
validation = Schema.(input)
if validation.success?
repo.create(validation.output)
else
validation
end
end
end
87/131

88. dry-monads
88/131

89. dry-monads
89/131

90. dry-monads
Either = Left | Right
Right(user)
Left(error)
90/131

91. dry-monads
def call(input)
validation = Schema.(input)
if validation.success?
user = repo.create(validation.output)
Right(user)
else
Left(validation)
end
end
91/131

92. dry-matcher
92/131

93. dry-matcher
class CreateUser
include Dry::Matcher.for(:call, with: Dry::Matcher::EitherMatcher)
def call(input)
validation = Schema.(input)
if validation.success?
user = repo.create(validation.output)
Right(user)
else
Left(validation)
end
end
end
93/131

94. dry-matcher
r.post do
r.resolve 'operations.create_user' do |create|
create.(r.params['user']) do |m|
m.success do |user|
r.redirect_to "/users/#{ user.id }"
end
m.failure do |validation|
# render errors
end
end
end
end
94/131

95. Render with dry-view
95/131

96. dry-view
r.post do
r.resolve 'operations.create_user' do |create|
create.(r.params['user']) do |m|
m.success do |user|
r.redirect_to "/users/#{ user.id }"
end
m.failure do |validation|
r.view 'users.new', validation: validation
end
end
end
end
96/131

97. dry-view
module Views
module Users
class New < Shop::ViewController
configure do |config|
config.template = "users/new"
end
expose :validation
end
end
end
97/131

98. Business logic with
dry-transaction
98/131

99. CreateUser = ValidateUser + PersistUser
99/131

100. dry-transaction
class CreateUser
Transaction = Dry::Transaction(container: Shop::Container) do
end
end
100/131

101. dry-transaction
class CreateUser
Transaction = Dry::Transaction(container: Shop::Container) do
step :validate, with: 'operations.validate'
step :persist, with: 'persistance.commands.create_user'
end
end
101/131

102. dry-transaction
class CreateUser
Transaction = Dry::Transaction(container: Shop::Container) do
step :validate, with: 'operations.validate'
step :persist, with: 'persistance.commands.create_user'
end
def call(input, &block)
Transaction.(input, validate: [Schema], &block)
end
end
102/131

103. dry-transaction
class CreateUser
Transaction = Dry::Transaction(container: Shop::Container) do
step :validate, with: 'operations.validate'
step :persist, with: 'persistance.commands.create_user'
end
def call(input, &block)
Transaction.(input, validate: [Schema], &block)
end ^^^^^^^^^^^^^^^^^^
end
103/131

104. dry-transaction
class Validate
def call(input, schema)
validation = schema.call(input)
if validation.success?
Right(validation.output)
else
Left(validation)
end
end
end
104/131

105. Data objects with dry-struct
105/131

106. dry-struct
class User < Dry::Struct
attribute :name, Types::Strict::String
attribute :email, Types::Strict::String
attribute :age, Types::Strict::Int
end
106/131

107. dry-struct
user = User.new(name: 'John', email: 'john@doe.com', age: 33)
=> #<User name="John" email="john@doe.com" age=33>
user.name # => "John"
user.email # => "john@doe.com"
107/131

108. dry-struct
User.new(name: nil, email: 'john@doe.com', age: 33)
# => Dry::Struct::Error: [User.new]
# nil (NilClass) has invalid type for :name
108/131

109. dry-struct
class User < Dry::Struct
Name = Types::Strict::String
attribute :name, Name
attribute :email, Types::Strict::String
attribute :age, Types::Strict::Int
end
109/131

110. dry-types
Name = Types::Strict::String.constrained(min_size: 3)
Name['Li']
# => Dry::Types::ConstraintError:
# "Li" violates constraints (min_size?(3, "Li") failed)
110/131

111. dry-types
Source = Types::Strict::String.enum('web', 'github')
Source['web'] # => "web"
Source['foo']
# => Dry::Types::ConstraintError: "foo" violates constraints
111/131

112. Recap
response = application.call(request)
action = router.call(env)
data = Schema.call(params)
user = create_user.call(data)
html = template.call(user)
112/131

113. Recap
response = application.call(request)
^^^^^^^^^^^
action = router.call(env)
^^^^^^
data = Schema.call(params)
^^^^^^
user = create_user.call(data)
^^^^^^^^^^^
html = template.call(user)
^^^^^^^^
113/131

114. Recap
• dry-web-roda
• dry-validation
• dry-container
• dry-auto_inject
• dry-system
• dry-monads
• dry-matcher
• dry-view
• dry-transaction
• dry-struct
• dry-types
114/131

115. A new wave
115/131

116. No mutable state
116/131

117. No monkey patching
117/131

118. Toolset
118/131

119. Stuff that works
119/131

120. 120/131

121. Can I use it? (Yes!)
121/131

122. 122/131

123. Easy start with dry-validation and
dry-container
123/131

124. Choose what works for you
124/131

125. 125/131

126. Get involved!
• dry-rb.org
• discuss.dry-rb.org
• gitter.im/dry-rb/chat
126/131

127. Ruby doesn't suck (anymore)
127/131

128. Ruby = Smalltalk + ...
128/131

129. Ruby = Smalltalk + Perl + ...
129/131

130. Ruby = Smalltalk + Perl + Lisp
130/131

131. Thank you
• github.com/flash-gordon
• @NikitaShilnikov
• github.com/dry-rb
• icelab/dry-web-skeleton
• icelab/berg
131/131