{"id":7814,"date":"2022-04-22T00:00:00","date_gmt":"2022-04-21T22:00:00","guid":{"rendered":"https:\/\/blog.ouidou.fr\/?p=7814"},"modified":"2024-11-07T11:45:01","modified_gmt":"2024-11-07T10:45:01","slug":"tour-dhorizon-de-dry-type-dry-struct-et-dry-validation","status":"publish","type":"post","link":"https:\/\/ouidou.fr\/blog\/articles-techniques\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation","title":{"rendered":"Tour d&rsquo;horizon de dry-type, dry-struct et dry-validation"},"content":{"rendered":"<p><em>Article \u00e9crit par Martin Catty<\/em><\/p>\n<p>En attendant la sortie d\u2019Hanami v2, qui poss\u00e8de quelques gems dry-rb en d\u00e9pendances et apr\u00e8s qu\u2019\u00c9milie nous a fait d\u00e9couvrir dry-transformer, passons \u00e0 <a href=\"https:\/\/github.com\/dry-rb\/dry-struct\">dry-struct<\/a>, <a href=\"https:\/\/github.com\/dry-rb\/dry-types\">dry-types<\/a> et <a href=\"https:\/\/github.com\/dry-rb\/dry-validation\">dry-validation<\/a>.<\/p>\n<p>J\u2019ai r\u00e9cemment eu l\u2019occasion de les mettre en \u0153uvre dans le cadre d\u2019une application Ruby on Rails assez cons\u00e9quente.<\/p>\n<p>Je suis toujours frileux \u00e0 l\u2019id\u00e9e d\u2019ajouter de nouvelles d\u00e9pendances, surtout dans des <em>codebases<\/em> d\u00e9j\u00e0 volumineuses\u00a0; mais les gems dry-rb ont cet avantage d\u2019avoir elles-m\u00eames tr\u00e8s peu, voire aucune d\u00e9pendance.<\/p>\n<p>Dans le contexte de dry-struct on a\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"n\">spec<\/span><span class=\"p\">.<\/span><span class=\"nf\">add_runtime_dependency<\/span> <span class=\"s2\">\"dry-core\"<\/span><span class=\"p\">,<\/span> <span class=\"s2\">\"~&gt; 0.5\"<\/span><span class=\"p\">,<\/span> <span class=\"s2\">\"&gt;= 0.5\"<\/span> <span class=\"n\">spec<\/span><span class=\"p\">.<\/span><span class=\"nf\">add_runtime_dependency<\/span> <span class=\"s2\">\"dry-types\"<\/span><span class=\"p\">,<\/span> <span class=\"s2\">\"~&gt; 1.5\"<\/span> <span class=\"n\">spec<\/span><span class=\"p\">.<\/span><span class=\"nf\">add_runtime_dependency<\/span> <span class=\"s2\">\"ice_nine\"<\/span><span class=\"p\">,<\/span> <span class=\"s2\">\"~&gt; 0.11\"<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Sachant que j\u2019avais aussi besoin de <code>dry-types<\/code> ont est somme toute sur un nombre de d\u00e9pendances limit\u00e9 et souvent maintenues par les m\u00eames personnes.<\/p>\n<p>Si vous vous dites que toutes ces gems semblent assez similaires et r\u00e9pondent aux m\u00eames usages c\u2019est tout \u00e0 fait normal pour une premi\u00e8re impression.<\/p>\n<p>Mais dry a cette philosophie tr\u00e8s unixienne d\u2019un outil par usage, quand bien m\u00eame il semble y avoir des recouvrements.<\/p>\n<h2 id=\"pourquoi-utiliser-ces-gems\">Pourquoi utiliser ces gems\u00a0?<\/h2>\n<p>Le contexte m\u00e9tier \u00e9tait de r\u00e9cup\u00e9rer une entr\u00e9e avec plusieurs param\u00e8tres pour \u00e9tablir une simulation financi\u00e8re.<\/p>\n<p>Dans ces entr\u00e9es on pouvait avoir le genre, le m\u00e9tier, les revenus, etc. Certains param\u00e8tres \u00e9taient optionnels, d\u2019autres non. Certaines valeurs \u00e9taient libres, d\u2019autres contraintes. Pour certains param\u00e8tres on voulait des valeurs par d\u00e9faut, mais pas toujours.<\/p>\n<p>Bref rien de tr\u00e8s exotique, mais je voulais \u00e9videmment \u00e9viter de me retrouver avec une action \u00e9norme dans un contr\u00f4leur enchainant les <code>if<\/code> \/ <code>else<\/code> et plut\u00f4t avoir une classe d\u00e9di\u00e9e qui serait facile \u00e0 tester en isolation.<\/p>\n<p>Dans Rails on aurait pu partir sur <code>ActiveModel<\/code>, mais ici j\u2019ai pr\u00e9f\u00e9r\u00e9 m\u2019aventurer avec <code>Dry::Struct<\/code>, dans l\u2019optique de cr\u00e9er un service auquel je passerai directement mon entr\u00e9e depuis mon contr\u00f4leur.<\/p>\n<p>Dans l\u2019action de mon contr\u00f4leur j\u2019ai simplement\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">def<\/span> <span class=\"nf\">controller_action<\/span>   <span class=\"n\">simulator<\/span> <span class=\"o\">=<\/span> <span class=\"no\">RetirementSimulator<\/span><span class=\"p\">.<\/span><span class=\"nf\">build<\/span><span class=\"p\">(<\/span>     <span class=\"ss\">user: <\/span><span class=\"n\">current_user<\/span><span class=\"p\">,<\/span>     <span class=\"ss\">status: <\/span><span class=\"n\">params<\/span><span class=\"p\">.<\/span><span class=\"nf\">dig<\/span><span class=\"p\">(<\/span><span class=\"ss\">:params<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:status<\/span><span class=\"p\">),<\/span>     <span class=\"ss\">gender: <\/span><span class=\"n\">params<\/span><span class=\"p\">.<\/span><span class=\"nf\">dig<\/span><span class=\"p\">(<\/span><span class=\"ss\">:params<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:gender<\/span><span class=\"p\">),<\/span>     <span class=\"ss\">career_start_year: <\/span><span class=\"n\">params<\/span><span class=\"p\">.<\/span><span class=\"nf\">dig<\/span><span class=\"p\">(<\/span><span class=\"ss\">:params<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:career_start_year<\/span><span class=\"p\">),<\/span>     <span class=\"ss\">net_mensual_salary: <\/span><span class=\"n\">params<\/span><span class=\"p\">.<\/span><span class=\"nf\">dig<\/span><span class=\"p\">(<\/span><span class=\"ss\">:params<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:net_mensual_salary<\/span><span class=\"p\">),<\/span>     <span class=\"ss\">forecast_annual_increase_rate: <\/span><span class=\"n\">params<\/span><span class=\"p\">.<\/span><span class=\"nf\">dig<\/span><span class=\"p\">(<\/span><span class=\"ss\">:params<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:forecast_annual_increase_rate<\/span><span class=\"p\">),<\/span>     <span class=\"ss\">executive: <\/span><span class=\"n\">params<\/span><span class=\"p\">.<\/span><span class=\"nf\">dig<\/span><span class=\"p\">(<\/span><span class=\"ss\">:params<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:executive<\/span><span class=\"p\">),<\/span>     <span class=\"ss\">established_official: <\/span><span class=\"n\">params<\/span><span class=\"p\">.<\/span><span class=\"nf\">dig<\/span><span class=\"p\">(<\/span><span class=\"ss\">:params<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:established_official<\/span><span class=\"p\">),<\/span>     <span class=\"ss\">desired_mensual_saving_efforts: <\/span><span class=\"n\">params<\/span><span class=\"p\">.<\/span><span class=\"nf\">dig<\/span><span class=\"p\">(<\/span><span class=\"ss\">:params<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:desired_mensual_saving_efforts<\/span><span class=\"p\">),<\/span>     <span class=\"ss\">desired_age_at_retirement: <\/span><span class=\"n\">params<\/span><span class=\"p\">.<\/span><span class=\"nf\">dig<\/span><span class=\"p\">(<\/span><span class=\"ss\">:params<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:desired_age_at_retirement<\/span><span class=\"p\">)<\/span>   <span class=\"p\">)<\/span>   <span class=\"n\">response<\/span> <span class=\"o\">=<\/span> <span class=\"n\">simulator<\/span><span class=\"p\">.<\/span><span class=\"nf\">call<\/span>   <span class=\"n\">render<\/span> <span class=\"ss\">json: <\/span><span class=\"n\">response<\/span><span class=\"p\">.<\/span><span class=\"nf\">payload<\/span><span class=\"p\">,<\/span> <span class=\"ss\">status: <\/span><span class=\"n\">response<\/span><span class=\"p\">.<\/span><span class=\"nf\">status<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>J\u2019utilise donc uniquement l\u2019action comme un passe-plat. En termes de tests, l\u2019id\u00e9e \u00e9tait de cr\u00e9er des \u00ab profils \u00bb, c\u2019est-\u00e0-dire des jeux de param\u00e8tres, certains coh\u00e9rents, d\u2019autres non et d\u2019en v\u00e9rifier la sortie.<\/p>\n<p>Avec ce <em>setup<\/em> mes tests offrent l\u2019avantage d\u2019\u00eatre compl\u00e8tement ind\u00e9pendants du reste de l\u2019application et je n\u2019ai globalement que ma classe \u00e0 tester pour m\u2019assurer que tout fonctionne comme attendu.<\/p>\n<p><code>RetirementSimulator.build<\/code> renvoie une instance d\u2019objet qui peut varier. Si les param\u00e8tres ne sont pas valides, il s\u2019agira d\u2019un objet de type <code>NullRetirementSimulator<\/code>. Autrement il peut s\u2019agir d\u2019un objet de type <code>OpenStruct<\/code>, qui sera en charge de renvoyer le payload et le statut au m\u00eame format.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">def<\/span> <span class=\"nf\">call<\/span>   <span class=\"n\">save<\/span>   <span class=\"no\">OpenStruct<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"ss\">payload: <\/span><span class=\"n\">as_json<\/span><span class=\"p\">,<\/span> <span class=\"ss\">status: :ok<\/span><span class=\"p\">)<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<h2 id=\"dry-types\">dry-types<\/h2>\n<p><code>dry-types<\/code> va nous permettre, entre autres, de v\u00e9rifier et\/ou caster automatiquement nos param\u00e8tres dans le format attendu.<\/p>\n<p>Dans un mode strict (ex\u00a0: <code>attribute :age,  Types::Strict::Integer<\/code>), si vous passez une valeur non autoris\u00e9e pour votre attribut vous vous ferez jeter.<\/p>\n<p>Dans un mode coercible, <code>dry-types<\/code> essaiera de caster pour vous les valeurs pass\u00e9es. Si vous passez la chaine de caract\u00e8res <code>\"18\"<\/code> pour l\u2019\u00e2ge, il la convertira automatiquement en entier.<\/p>\n<p>Pour cela il utilisera uniquement les m\u00e9thodes mises \u00e0 disposition par Ruby au niveau <em>kernel<\/em>, par exemple <code>\"18\".to_i<\/code>.<\/p>\n<p>Pour les types qui ne sont pas directement convertibles avec Ruby il faut utiliser <code>Types::Params<\/code>, par exemple <code>Types::Params::Bool<\/code> que l\u2019on va retrouver juste apr\u00e8s et qui peut transformer <code>\"1\"<\/code> en <code>true<\/code> par exemple.<\/p>\n<p><code>dry-types<\/code> permet aussi d\u2019ajouter des contraintes sur les valeurs, g\u00e9rer des \u00e9num\u00e9rateurs, des valeurs optionnelles, bref toutes les choses dont on va avoir besoin.<\/p>\n<h2 id=\"dry-struct\">dry-struct<\/h2>\n<p><code>dry-struct<\/code> est lui construit au-dessus de <code>dry-types<\/code>. Au lieu d\u2019utiliser <code>dry-types<\/code> comme un <em>mixin<\/em> vous pouvez cr\u00e9er votre propre classe qui disposera des m\u00e9thodes de <code>dry-types<\/code>.<\/p>\n<p>\u00c9tant donn\u00e9 qu\u2019on cr\u00e9e un service utilisable en isolation, <a href=\"https:\/\/www.youtube.com\/watch?v=VelvguwXntg\">\u00e7a colle plut\u00f4t pas mal<\/a><\/p>\n<p>Voil\u00e0 quelques morceaux choisis de notre code que l\u2019on d\u00e9taillera juste apr\u00e8s\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">RetirementSimulator<\/span> <span class=\"o\">&lt;<\/span> <span class=\"no\">Dry<\/span><span class=\"o\">::<\/span><span class=\"no\">Struct<\/span>   <span class=\"no\">STATUS<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Dry<\/span><span class=\"o\">.<\/span><span class=\"no\">Types<\/span><span class=\"o\">::<\/span><span class=\"no\">String<\/span><span class=\"p\">.<\/span><span class=\"nf\">enum<\/span><span class=\"p\">(<\/span><span class=\"s1\">'employee'<\/span><span class=\"p\">,<\/span> <span class=\"s1\">'independent'<\/span><span class=\"p\">,<\/span> <span class=\"s1\">'official'<\/span><span class=\"p\">)<\/span>    <span class=\"n\">transform_types<\/span> <span class=\"k\">do<\/span> <span class=\"o\">|<\/span><span class=\"n\">type<\/span><span class=\"o\">|<\/span>     <span class=\"k\">if<\/span> <span class=\"n\">type<\/span><span class=\"p\">.<\/span><span class=\"nf\">default?<\/span>       <span class=\"n\">type<\/span><span class=\"p\">.<\/span><span class=\"nf\">constructor<\/span> <span class=\"k\">do<\/span> <span class=\"o\">|<\/span><span class=\"n\">value<\/span><span class=\"o\">|<\/span>         <span class=\"n\">value<\/span><span class=\"p\">.<\/span><span class=\"nf\">nil?<\/span> <span class=\"p\">?<\/span> <span class=\"no\">Dry<\/span><span class=\"o\">::<\/span><span class=\"no\">Types<\/span><span class=\"o\">::<\/span><span class=\"no\">Undefined<\/span> <span class=\"p\">:<\/span> <span class=\"n\">value<\/span>       <span class=\"k\">end<\/span>     <span class=\"k\">else<\/span>       <span class=\"n\">type<\/span>     <span class=\"k\">end<\/span>   <span class=\"k\">end<\/span>    <span class=\"n\">attribute<\/span> <span class=\"ss\">:user<\/span><span class=\"p\">,<\/span> <span class=\"no\">Dry<\/span><span class=\"o\">.<\/span><span class=\"no\">Types<\/span><span class=\"o\">.<\/span><span class=\"no\">Instance<\/span><span class=\"p\">(<\/span><span class=\"no\">User<\/span><span class=\"p\">)<\/span>   <span class=\"n\">attribute<\/span> <span class=\"ss\">:status<\/span><span class=\"p\">,<\/span> <span class=\"no\">STATUS<\/span><span class=\"p\">.<\/span><span class=\"nf\">optional<\/span>   <span class=\"n\">attribute<\/span> <span class=\"ss\">:career_start_year<\/span><span class=\"p\">,<\/span> <span class=\"no\">Dry<\/span><span class=\"o\">.<\/span><span class=\"no\">Types<\/span><span class=\"o\">::<\/span><span class=\"no\">Coercible<\/span><span class=\"o\">::<\/span><span class=\"no\">Integer<\/span><span class=\"p\">.<\/span><span class=\"nf\">optional<\/span>   <span class=\"n\">attribute?<\/span> <span class=\"ss\">:average_annual_increase_rate<\/span><span class=\"p\">,<\/span> <span class=\"no\">Dry<\/span><span class=\"o\">.<\/span><span class=\"no\">Types<\/span><span class=\"o\">::<\/span><span class=\"no\">Coercible<\/span><span class=\"o\">::<\/span><span class=\"no\">Float<\/span><span class=\"p\">.<\/span><span class=\"nf\">default<\/span><span class=\"p\">(<\/span><span class=\"mf\">0.0<\/span><span class=\"p\">)<\/span>   <span class=\"n\">attribute<\/span> <span class=\"ss\">:executive<\/span><span class=\"p\">,<\/span> <span class=\"no\">Dry<\/span><span class=\"o\">.<\/span><span class=\"no\">Types<\/span><span class=\"o\">::<\/span><span class=\"no\">Params<\/span><span class=\"o\">::<\/span><span class=\"no\">Bool<\/span><span class=\"p\">.<\/span><span class=\"nf\">optional<\/span>    <span class=\"n\">delegate<\/span> <span class=\"ss\">:year_of_birth<\/span><span class=\"p\">,<\/span>            <span class=\"ss\">:profile<\/span><span class=\"p\">,<\/span>            <span class=\"ss\">to: :user<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Du c\u00f4t\u00e9 des \u00e9vidences, la partie <code>enum<\/code> nous permet de g\u00e9rer notre attribut <code>status<\/code> qui prendra l\u2019une des valeurs autoris\u00e9es.<\/p>\n<p>On peut bien s\u00fbr demander \u00e0 un attribut d\u2019\u00eatre d\u2019un certain type (interne \u00e0 Ruby ou non), c\u2019est le cas ici avec <code>Dry.Types.Instance(User)<\/code>.<\/p>\n<p>La notion de <code>attribute?<\/code> (avec le\u00a0?) permet de d\u00e9finir qu\u2019un attribut est optionnel, si la cl\u00e9 est absente la validation n\u2019\u00e9chouera pas.<\/p>\n<p>\u00c0 ne pas confondre avec <code>optional<\/code> qui indique que la valeur n\u2019est pas requise, mais dans ce cas la cl\u00e9 doit tout de m\u00eame \u00eatre pr\u00e9sente\u00a0!<\/p>\n<p>Un attribut peut \u00eatre optionnel mais avec une valeur par d\u00e9faut. Si la cl\u00e9 n\u2019est pas pass\u00e9e on utilisera alors la valeur pr\u00e9d\u00e9finie (c\u2019est le cas de <code>average_annual_increase_rate<\/code>).<\/p>\n<p>Dans le cas contraire on utilisera ce qui est pass\u00e9 (si cela respecte le type ou que c\u2019est castable).<\/p>\n<p>Vous voyez dans l\u2019exemple diff\u00e9rents types de donn\u00e9es, <code>Integer<\/code>, <code>String<\/code>, <code>Float<\/code> et <code>Bool<\/code>.<\/p>\n<p>Dans <code>dry-types<\/code> une valeur <code>nil<\/code> est consid\u00e9r\u00e9e comme valable, elle ne sera donc pas r\u00e9solue sur la valeur par d\u00e9faut, ce qui n\u2019est pas forc\u00e9ment ce qu\u2019on veut.<\/p>\n<p>C\u2019est un comportement qui a chang\u00e9 selon les versions et qui a \u00e9t\u00e9 <a href=\"https:\/\/github.com\/dry-rb\/dry-struct\/issues\/90\">sujet \u00e0 discussions<\/a>.<\/p>\n<p>Au passage, c\u2019est un point qui peut \u00eatre irritant dans dry, il faut \u00eatre vigilant sur des comportements qui peuvent changer d\u2019une mineure \u00e0 l\u2019autre et que vous aurez parfois du mal \u00e0 retrouver dans la documentation.<\/p>\n<p>C\u2019est notre bloc <code>transform_types<\/code>, \u00e0 premi\u00e8re vue pas tr\u00e8s \u00e9l\u00e9gant, qui permet de changer ce comportement et d\u2019utiliser la valeur par d\u00e9faut si elle existe quand on re\u00e7oit <code>nil<\/code>.<\/p>\n<p>Je n\u2019ai pas invent\u00e9 l\u2019eau chaude sur ce point, <a href=\"https:\/\/dry-rb.org\/gems\/dry-struct\/1.0\/recipes\/#resolving-default-values-on-code-nil-code\">c\u2019est la m\u00e9thode officielle conseill\u00e9e<\/a>.<\/p>\n<h2 id=\"grer-les-objets-invalides\">G\u00e9rer les objets invalides<\/h2>\n<p>Dans le cas o\u00f9 nos param\u00e8tres ne respecteraient pas notre sp\u00e9cification, le constructeur nous renverra une exception <code>Dry::Struct::Error<\/code>.<\/p>\n<p>Ce qui nous permet dans notre m\u00e9thode build, appel\u00e9e depuis notre constructeur, de g\u00e9rer cela tr\u00e8s simplement\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">def<\/span> <span class=\"nc\">self<\/span><span class=\"o\">.<\/span><span class=\"nf\">build<\/span><span class=\"p\">(<\/span><span class=\"o\">**<\/span><span class=\"n\">args<\/span><span class=\"p\">)<\/span>   <span class=\"n\">simulation<\/span> <span class=\"o\">=<\/span> <span class=\"n\">new<\/span><span class=\"p\">(<\/span><span class=\"n\">args<\/span><span class=\"p\">)<\/span>   <span class=\"c1\"># here comes the magic<\/span> <span class=\"k\">rescue<\/span> <span class=\"no\">Dry<\/span><span class=\"o\">::<\/span><span class=\"no\">Struct<\/span><span class=\"o\">::<\/span><span class=\"no\">Error<\/span>   <span class=\"no\">NullRetirementSimulator<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"ss\">payload: <\/span><span class=\"p\">{},<\/span> <span class=\"ss\">status: :unprocessable_entity<\/span><span class=\"p\">)<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>En effet, en h\u00e9ritant de <code>dry-struct<\/code> j\u2019h\u00e9rite d\u2019un constructeur par d\u00e9faut qui me permet de directement passer mes arguments pour construire un objet disposant d\u2019accesseurs sur les attributs mis en place.<\/p>\n<p>Dans le cas o\u00f9 mon objet est invalide, car ne respectant pas les contraintes d\u00e9finies, j\u2019utilise le pattern <code>Null Object Pattern<\/code> (<code>NullRetirementSimulator<\/code> est une b\u00eate classe avec 2 accesseurs) qui permettra de renvoyer les valeurs et statuts HTTP\u00a0voulus dans le cas o\u00f9 mon entr\u00e9e est invalide, sans avoir \u00e0 le g\u00e9rer comme un cas particulier dans l\u2019action de mon contr\u00f4leur.<\/p>\n<h2 id=\"et-dry-validation-alors\">Et dry-validation alors\u00a0?<\/h2>\n<p><a href=\"https:\/\/www.youtube.com\/watch?v=Ri7GzCUTC5s\">Ah<\/a> ! Je vous ai cach\u00e9 un petit morceau dans le <em>snippet<\/em> ci-dessus, la partie \u00ab<em>here comes the magic<\/em>\u00bb.<\/p>\n<p>Son travail est de, selon les param\u00e8tres pass\u00e9s, appeler le bon simulateur (ce sont des simulateurs diff\u00e9rents selon que la personne ait travaill\u00e9 dans le priv\u00e9 ou dans le public, etc.).<\/p>\n<p>J\u2019utilise donc le pattern adapter en m\u2019assurant que mes simulateurs, quels qu\u2019ils soient, r\u00e9pondent \u00e0 la m\u00eame interface. Ma classe <code>RetirementSimulator<\/code> agit comme un routeur.<\/p>\n<p>Au sein de ces simulateurs sp\u00e9cifiques je veux valider d\u2019autres choses, qui ne sont plus du domaine des param\u00e8tres re\u00e7us via HTTP mais uniquement de la logique m\u00e9tier.<\/p>\n<p>Pour cela on va d\u00e9finir un contrat\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">RetirementSimulatorContract<\/span> <span class=\"o\">&lt;<\/span> <span class=\"no\">Dry<\/span><span class=\"o\">::<\/span><span class=\"no\">Validation<\/span><span class=\"o\">::<\/span><span class=\"no\">Contract<\/span>   <span class=\"no\">STARTING_YEAR_TO_COMPUTE_SUPPLEMENT<\/span> <span class=\"o\">=<\/span> <span class=\"mi\">1973<\/span>    <span class=\"n\">params<\/span> <span class=\"k\">do<\/span>     <span class=\"n\">required<\/span><span class=\"p\">(<\/span><span class=\"ss\">:year_of_birth<\/span><span class=\"p\">).<\/span><span class=\"nf\">value<\/span><span class=\"p\">(<\/span><span class=\"ss\">:integer<\/span><span class=\"p\">)<\/span>     <span class=\"n\">required<\/span><span class=\"p\">(<\/span><span class=\"ss\">:career_start_year<\/span><span class=\"p\">).<\/span><span class=\"nf\">value<\/span><span class=\"p\">(<\/span><span class=\"ss\">:integer<\/span><span class=\"p\">)<\/span>   <span class=\"k\">end<\/span>    <span class=\"n\">rule<\/span><span class=\"p\">(<\/span><span class=\"ss\">:career_start_year<\/span><span class=\"p\">)<\/span> <span class=\"k\">do<\/span>     <span class=\"n\">key<\/span><span class=\"p\">.<\/span><span class=\"nf\">failure<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"career has to start after 1972\"<\/span><span class=\"p\">)<\/span> <span class=\"k\">if<\/span> <span class=\"n\">value<\/span> <span class=\"o\">&lt;<\/span> <span class=\"no\">STARTING_YEAR_TO_COMPUTE_SUPPLEMENT<\/span>   <span class=\"k\">end<\/span>    <span class=\"n\">rule<\/span><span class=\"p\">(<\/span><span class=\"ss\">:career_start_year<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:year_of_birth<\/span><span class=\"p\">)<\/span> <span class=\"k\">do<\/span>     <span class=\"k\">if<\/span> <span class=\"n\">values<\/span><span class=\"p\">[<\/span><span class=\"ss\">:career_start_year<\/span><span class=\"p\">]<\/span> <span class=\"o\">-<\/span> <span class=\"n\">values<\/span><span class=\"p\">[<\/span><span class=\"ss\">:year_of_birth<\/span><span class=\"p\">]<\/span> <span class=\"o\">&lt;<\/span> <span class=\"mi\">14<\/span>       <span class=\"n\">key<\/span><span class=\"p\">.<\/span><span class=\"nf\">failure<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"is too early, can't start working before 14\"<\/span><span class=\"p\">)<\/span>     <span class=\"k\">end<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Notre contrat va valider que la personne qui lance le simulateur n\u2019indique pas avoir commenc\u00e9 \u00e0 travailler avant 14 ans ni avant 1972.<\/p>\n<p>Pour cela <code>Dry::Validation::Contract<\/code> nous permet de d\u00e9finir des <code>rules<\/code> qui vont prendre un ou plusieurs param\u00e8tres en entr\u00e9e.<\/p>\n<p>On mixe ici des valeurs qui viennent d\u2019une part de notre base de donn\u00e9es (<code>year_of_birth<\/code>, qui vient de notre objet <code>user<\/code>) et d\u2019autre part de nos param\u00e8tres (<code>career_start_year<\/code>) ; on voit donc bien qu\u2019on n\u2019est plus uniquement dans une logique de validation d\u2019entr\u00e9e.<\/p>\n<p>Pour invoquer ce contrat c\u2019est aussi simple que\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"n\">contract<\/span> <span class=\"o\">=<\/span> <span class=\"no\">RetirementSimulatorContract<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span> <span class=\"n\">res<\/span> <span class=\"o\">=<\/span> <span class=\"n\">contract<\/span><span class=\"p\">.<\/span><span class=\"nf\">call<\/span><span class=\"p\">(<\/span>   <span class=\"ss\">year_of_birth: <\/span><span class=\"n\">simulation<\/span><span class=\"p\">.<\/span><span class=\"nf\">year_of_birth<\/span><span class=\"p\">,<\/span>   <span class=\"ss\">career_start_year: <\/span><span class=\"n\">simulation<\/span><span class=\"p\">.<\/span><span class=\"nf\">career_start_year<\/span> <span class=\"p\">)<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Les \u00e9ventuelles erreurs se trouveront dans <code>res.errors<\/code>.<\/p>\n<h2 id=\"conclusion\">Conclusion<\/h2>\n<p>Ces gems dry offrent une mani\u00e8re \u00e9l\u00e9gante (\u00e0 mon avis) de garder du code propre et testable de fa\u00e7on isol\u00e9e. Qui plus est, le nombre limit\u00e9 de d\u00e9pendances permet de facilement venir greffer ces outils dans une <em>codebase<\/em> existante.<\/p>\n<p>Cela peut donc \u00eatre un excellent moyen de tirer vers le haut la qualit\u00e9 d\u2019une base de code ayant d\u00e9j\u00e0 un peu de v\u00e9cu de fa\u00e7on progressive et sans avoir \u00e0 modifier l\u2019existant.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Continuons \u00e0 explorer quelques-unes des gems dry-rb<\/p>\n","protected":false},"author":10,"featured_media":12397,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"content-type":"","inline_featured_image":false,"fifu_image_url":"","fifu_image_alt":"","footnotes":""},"categories":[34],"tags":[],"class_list":["post-7814","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-articles-techniques"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v28.9 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Tour d&#039;horizon de dry-type, dry-struct et dry-validation - Ouidou<\/title>\n<meta name=\"description\" content=\"Faites un tour d&#039;horizon de Dry-Type, Dry-Struct et Dry-Validation pour ma\u00eetriser ces outils de validation en Ruby.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/ouidou.fr\/blog\/articles-techniques\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Tour d&#039;horizon de dry-type, dry-struct et dry-validation - Ouidou\" \/>\n<meta property=\"og:description\" content=\"Faites un tour d&#039;horizon de Dry-Type, Dry-Struct et Dry-Validation pour ma\u00eetriser ces outils de validation en Ruby.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/ouidou.fr\/blog\/articles-techniques\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation\" \/>\n<meta property=\"og:site_name\" content=\"Ouidou\" \/>\n<meta property=\"article:published_time\" content=\"2022-04-21T22:00:00+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-11-07T10:45:01+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/Exe\u0301cuter-des-commandes-dans-un-conteneur-avec-ECS-dAWS-1.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1105\" \/>\n\t<meta property=\"og:image:height\" content=\"564\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Sara Lourties\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u00c9crit par\" \/>\n\t<meta name=\"twitter:data1\" content=\"Sara Lourties\" \/>\n\t<meta name=\"twitter:label2\" content=\"Dur\u00e9e de lecture estim\u00e9e\" \/>\n\t<meta name=\"twitter:data2\" content=\"7 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation\"},\"author\":{\"name\":\"Sara Lourties\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/person\\\/e1d66085fb7c22ede319ce56adc373a4\"},\"headline\":\"Tour d&rsquo;horizon de dry-type, dry-struct et dry-validation\",\"datePublished\":\"2022-04-21T22:00:00+00:00\",\"dateModified\":\"2024-11-07T10:45:01+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation\"},\"wordCount\":1427,\"publisher\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/Exe\u0301cuter-des-commandes-dans-un-conteneur-avec-ECS-dAWS-1.png\",\"articleSection\":[\"Articles Techniques\"],\"inLanguage\":\"fr-FR\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation\",\"name\":\"Tour d'horizon de dry-type, dry-struct et dry-validation - Ouidou\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/Exe\u0301cuter-des-commandes-dans-un-conteneur-avec-ECS-dAWS-1.png\",\"datePublished\":\"2022-04-21T22:00:00+00:00\",\"dateModified\":\"2024-11-07T10:45:01+00:00\",\"description\":\"Faites un tour d'horizon de Dry-Type, Dry-Struct et Dry-Validation pour ma\u00eetriser ces outils de validation en Ruby.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation#primaryimage\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/Exe\u0301cuter-des-commandes-dans-un-conteneur-avec-ECS-dAWS-1.png\",\"contentUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/Exe\u0301cuter-des-commandes-dans-un-conteneur-avec-ECS-dAWS-1.png\",\"width\":1105,\"height\":564},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Accueil\",\"item\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Tour d&rsquo;horizon de dry-type, dry-struct et dry-validation\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\",\"name\":\"Blog Ouidou\",\"description\":\"Conseil et expertise en technologies\",\"publisher\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"fr-FR\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\",\"name\":\"Ouidou\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/image_2022-04-13_150237378.png\",\"contentUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/image_2022-04-13_150237378.png\",\"width\":180,\"height\":180,\"caption\":\"Ouidou\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/person\\\/e1d66085fb7c22ede319ce56adc373a4\",\"name\":\"Sara Lourties\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"caption\":\"Sara Lourties\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Tour d'horizon de dry-type, dry-struct et dry-validation - Ouidou","description":"Faites un tour d'horizon de Dry-Type, Dry-Struct et Dry-Validation pour ma\u00eetriser ces outils de validation en Ruby.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/ouidou.fr\/blog\/articles-techniques\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation","og_locale":"fr_FR","og_type":"article","og_title":"Tour d'horizon de dry-type, dry-struct et dry-validation - Ouidou","og_description":"Faites un tour d'horizon de Dry-Type, Dry-Struct et Dry-Validation pour ma\u00eetriser ces outils de validation en Ruby.","og_url":"https:\/\/ouidou.fr\/blog\/articles-techniques\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation","og_site_name":"Ouidou","article_published_time":"2022-04-21T22:00:00+00:00","article_modified_time":"2024-11-07T10:45:01+00:00","og_image":[{"width":1105,"height":564,"url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/Exe\u0301cuter-des-commandes-dans-un-conteneur-avec-ECS-dAWS-1.png","type":"image\/png"}],"author":"Sara Lourties","twitter_card":"summary_large_image","twitter_misc":{"\u00c9crit par":"Sara Lourties","Dur\u00e9e de lecture estim\u00e9e":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation#article","isPartOf":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation"},"author":{"name":"Sara Lourties","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/person\/e1d66085fb7c22ede319ce56adc373a4"},"headline":"Tour d&rsquo;horizon de dry-type, dry-struct et dry-validation","datePublished":"2022-04-21T22:00:00+00:00","dateModified":"2024-11-07T10:45:01+00:00","mainEntityOfPage":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation"},"wordCount":1427,"publisher":{"@id":"https:\/\/ouidou.fr\/blog\/#organization"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation#primaryimage"},"thumbnailUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/Exe\u0301cuter-des-commandes-dans-un-conteneur-avec-ECS-dAWS-1.png","articleSection":["Articles Techniques"],"inLanguage":"fr-FR"},{"@type":"WebPage","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation","url":"https:\/\/ouidou.fr\/blog\/articles-techniques\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation","name":"Tour d'horizon de dry-type, dry-struct et dry-validation - Ouidou","isPartOf":{"@id":"https:\/\/ouidou.fr\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation#primaryimage"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation#primaryimage"},"thumbnailUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/Exe\u0301cuter-des-commandes-dans-un-conteneur-avec-ECS-dAWS-1.png","datePublished":"2022-04-21T22:00:00+00:00","dateModified":"2024-11-07T10:45:01+00:00","description":"Faites un tour d'horizon de Dry-Type, Dry-Struct et Dry-Validation pour ma\u00eetriser ces outils de validation en Ruby.","breadcrumb":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/ouidou.fr\/blog\/articles-techniques\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation"]}]},{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation#primaryimage","url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/Exe\u0301cuter-des-commandes-dans-un-conteneur-avec-ECS-dAWS-1.png","contentUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/Exe\u0301cuter-des-commandes-dans-un-conteneur-avec-ECS-dAWS-1.png","width":1105,"height":564},{"@type":"BreadcrumbList","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/tour-dhorizon-de-dry-type-dry-struct-et-dry-validation#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Accueil","item":"https:\/\/ouidou.fr\/blog\/"},{"@type":"ListItem","position":2,"name":"Tour d&rsquo;horizon de dry-type, dry-struct et dry-validation"}]},{"@type":"WebSite","@id":"https:\/\/ouidou.fr\/blog\/#website","url":"https:\/\/ouidou.fr\/blog\/","name":"Blog Ouidou","description":"Conseil et expertise en technologies","publisher":{"@id":"https:\/\/ouidou.fr\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/ouidou.fr\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"fr-FR"},{"@type":"Organization","@id":"https:\/\/ouidou.fr\/blog\/#organization","name":"Ouidou","url":"https:\/\/ouidou.fr\/blog\/","logo":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/image_2022-04-13_150237378.png","contentUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/image_2022-04-13_150237378.png","width":180,"height":180,"caption":"Ouidou"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/person\/e1d66085fb7c22ede319ce56adc373a4","name":"Sara Lourties","image":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","caption":"Sara Lourties"}}]}},"_links":{"self":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7814","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/users\/10"}],"replies":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/comments?post=7814"}],"version-history":[{"count":3,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7814\/revisions"}],"predecessor-version":[{"id":16644,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7814\/revisions\/16644"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/media\/12397"}],"wp:attachment":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/media?parent=7814"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/categories?post=7814"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/tags?post=7814"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}