<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[LaravelTips - Medium]]></title>
        <description><![CDATA[Um repositório de publicações com dicas aplicáveis aos casos reais de desenvolvimento de publicações com Laravel Framework. Core, serviços, banco de dados, padrões, técnicas e muito mais. - Medium]]></description>
        <link>https://medium.com/laraveltips?source=rss----1ac5836ec91a---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>LaravelTips - Medium</title>
            <link>https://medium.com/laraveltips?source=rss----1ac5836ec91a---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 01:22:29 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/laraveltips" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Monitorando queries do banco de dados]]></title>
            <link>https://medium.com/laraveltips/monitorando-queries-do-banco-de-dados-759417bcdb4b?source=rss----1ac5836ec91a---4</link>
            <guid isPermaLink="false">https://medium.com/p/759417bcdb4b</guid>
            <category><![CDATA[artisan]]></category>
            <category><![CDATA[command-line]]></category>
            <category><![CDATA[laravel]]></category>
            <category><![CDATA[cli]]></category>
            <category><![CDATA[kernel]]></category>
            <dc:creator><![CDATA[Mauricio Rodrigues]]></dc:creator>
            <pubDate>Wed, 20 Jun 2018 11:16:02 GMT</pubDate>
            <atom:updated>2018-06-20T11:16:02.307Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wHzos-2R0vv19zeqxgyfLg.png" /></figure><p>#shotTip: Um comando do artisan para fazer tailing das consultas executadas pela sua aplicação Laravel.</p><p>O Laravel possui um excelente arquivo de Log e uma API bacana para gerarmos alguns logs, mas nada voltado para o banco de dados. Pelo menos não conheço, até o momento que escrevo esta publicação.</p><p>Há um tempo atrás precisei ficar monitorando uma série de consultas que uma aplicação estava fazendo no banco, mas de forma rápida, sem precisar acessar um container… o banco de dados, alterar a configuração do banco, para habilitar a saída dos logs, etc…</p><p>Pra minimizar esse trabalho recorrente (e chato), criei um command simples, que gera um arquivo de log e faz o tailing.</p><h3>Criando o comando</h3><p>Pra começar, precisei criar um Service Provider que, ao ser “bootada”, que insere os logs no arquivo de log, caso o arquivo exista.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c108000b3de14a10d9e8d8edb695577e/href">https://medium.com/media/c108000b3de14a10d9e8d8edb695577e/href</a></iframe><blockquote>Depois de criá-lo, inclua-o na lista de providers do seu config/app.php</blockquote><p>Em seguida, foi criada a classe de comando. Ela, em síntese, cria um comando db::log que pode receber dois argumentos:</p><pre><strong>--start </strong># cria o arquivo de log<strong><br>--stop  </strong># remove o arquivo de log</pre><p>Veja o código:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0e7cd202605a50af428ea0aab2d99f2d/href">https://medium.com/media/0e7cd202605a50af428ea0aab2d99f2d/href</a></iframe><p>Agora, basta adicionar a classe DBLogCommand à lista $commands = [] de Console/Kernel.php</p><pre><strong>protected </strong>$commands = [<br>  // other commands...<br>  DBLogCommand::<em>class,</em><br>];</pre><p>Voilà! O comando de tailing está pronto pra ser usado.</p><p>Gostou? Espero que sim e que ele lhe seja tão útil quanto foi pra mim. Se tiver alguma dúvida, dica ou sugestão, deixa aqui nos comentário.</p><p>Forte abraço e até a próxima publicação.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=759417bcdb4b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/laraveltips/monitorando-queries-do-banco-de-dados-759417bcdb4b">Monitorando queries do banco de dados</a> was originally published in <a href="https://medium.com/laraveltips">LaravelTips</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Eloquent ORM Prático: Collections — Part 5/7]]></title>
            <link>https://medium.com/laraveltips/eloquent-avan%C3%A7ado-collections-part-4-7-2a91faef022b?source=rss----1ac5836ec91a---4</link>
            <guid isPermaLink="false">https://medium.com/p/2a91faef022b</guid>
            <category><![CDATA[orm]]></category>
            <category><![CDATA[laravel]]></category>
            <category><![CDATA[advanced-laravel]]></category>
            <category><![CDATA[collection]]></category>
            <category><![CDATA[eloquent]]></category>
            <dc:creator><![CDATA[Mauricio Rodrigues]]></dc:creator>
            <pubDate>Sat, 16 Jun 2018 18:37:42 GMT</pubDate>
            <atom:updated>2018-06-16T21:29:47.400Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qUdwifPOyihuqABxZsXTew.png" /></figure><p>Um dos melhores recursos existentes no Eloquent.</p><p>Esta publicação faz parte da série de publicações sobre Eloquent Avançado. Nesta série abordaremos os seguintes assuntos:</p><ol><li>Introdução</li><li>Eloquent accessors</li><li>Eloquent mutator</li><li>Relacionamentos com Eager Loading</li><li>Usando Collections nos resultados do Eloquent (você está aqui)</li><li>Eventos do Eloquent e</li><li>Eloquent Query Scopes.</li></ol><h3>Usando Collections</h3><p>Sempre que você executar uma query num Model que retornar mais de um registro, você irá receber um objeto Collection do Eloquent. Esta Collection extende a <a href="https://laravel.com/docs/5.6/collections">base collection</a> do Laravel. Isso significa que as Collections do Eloquent herdam uma série de métodos para lidar com os dados de suas coleções.</p><blockquote>Tip #1: Eloquent Collections são imutáveis. Então, sempre que executar uma operação, uma nova instância será retornada.</blockquote><blockquote>Tip #2: Para operações com pluck, keys, zip, collapse, flatten e flip, uma base collection sempre será retornada, ao invés de uma Eloquent Collection.</blockquote><blockquote>Tip #3: Sempre atribua a saída de uma Eloquent Collection a uma variável e use ela para qualquer outra coisa, do momento da atribuição em diante.</blockquote><p>Por exemplo, vamos assumir que você queira receber somente Orders que tenham sido entregues e que, somente para estas, você queira atribuir um valor atribuir um status. Faríamos assim:</p><pre>$orders = \App\Order::all()-&gt;reject(function ($order) {<br>  return $order-&gt;is_delivered == false;<br>})<br>-&gt;map(function ($order) {<br>  $order-&gt;status = &quot;Realizada&quot;;<br>  return $order;<br>});</pre><p>Assim, $orders conterá somente as Orders que foram marcadas como entregue.</p><p>Agora, digamos que você queira retornar uma coleção com Orders agrupadas: $delivered = [] e $undelivered = [], você poderia fazer assim:</p><pre>$orders = \App\Order::all()-&gt;map(function ($order) {<br>  $order-&gt;status = $order-&gt;is_delivered ? &quot;delivered&quot; : &quot;undelivered&quot;;<br><br>  return $order;<br>})-&gt;mapToGroups(function ($item, $key) {<br>  return [$item[&#39;status&#39;] =&gt; $item];<br>});</pre><p>Se você quiser uma lista chave-valor de produtos e preços, você poderia fazer algo como isso:</p><pre>$products = \App\Product::all()-&gt;mapWithKeys(function ($item) {<br>  return [$item[&#39;name&#39;] =&gt; $item[&#39;price&#39;]];<br>});<br><br>foreach($products as $key =&gt; $value) {<br>  echo &quot;{$key}: {$value}&quot;;<br>}</pre><p>Se você quiser recuperar todas as Orders entregues num determinado dia:</p><pre>public function orderOnDate(Request $request){<br>  $orders = \App\Order::all()-&gt;filter(function ($order) use ($request) {<br>    return $order-&gt;delivered_at == $request-&gt;date;<br>  });<br>}</pre><p>Collection é uma das funcionalidades mais robustas do Laravel e você deve dar bastante atenção para ela. Você pode ler mais sobre Collections <a href="https://laravel.com/docs/5.6/collections">aqui</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2a91faef022b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/laraveltips/eloquent-avan%C3%A7ado-collections-part-4-7-2a91faef022b">Eloquent ORM Prático: Collections — Part 5/7</a> was originally published in <a href="https://medium.com/laraveltips">LaravelTips</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Eloquent ORM Prático: Eager Loading — Part 4/7]]></title>
            <link>https://medium.com/laraveltips/eloquent-avan%C3%A7ado-part-4-7-4108e9ef3df9?source=rss----1ac5836ec91a---4</link>
            <guid isPermaLink="false">https://medium.com/p/4108e9ef3df9</guid>
            <category><![CDATA[advanced-laravel]]></category>
            <category><![CDATA[eager-loading]]></category>
            <category><![CDATA[orm]]></category>
            <category><![CDATA[laravel]]></category>
            <dc:creator><![CDATA[Mauricio Rodrigues]]></dc:creator>
            <pubDate>Thu, 14 Jun 2018 21:08:51 GMT</pubDate>
            <atom:updated>2018-06-16T21:28:38.548Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z4hhuOuX_3jt9w2xaqreaw.png" /></figure><p>Conheça algumas das maneiras de utilização de eager loading no Laravel, para lidar com relacionamentos entre Models.</p><p>Esta publicação faz parte da série de publicações sobre Eloquent Avançado. Nesta série abordaremos os seguintes assuntos:</p><ol><li>Introdução</li><li>Eloquent accessors</li><li>Eloquent mutator</li><li>Relacionamentos com Eager Loading (você está aqui)</li><li>Usando Collections nos resultados do Eloquent</li><li>Eventos do Eloquent e</li><li>Eloquent Query Scopes.</li></ol><h3>Relacionamentos com Eager Loading</h3><p>Quando você está acessando um Eloquent Model, os Models relacionados não são carregados por default. O Laravel utiliza do artefato Lazy Load, para que os relacionamentos só sejam carregados quando solicitados. Isso é útil para que haja uma economia (significativa) no uso de memória. Entretanto, se você realmente precisar de todo o relacionamento? É aí que o Eager Loading entra.</p><p>Uma outra vantagem do eager loading é que ele resolve o problema causado por queries N+1.</p><p>Considere o seguinte caso:</p><pre>$orders = \App\Order::all();</pre><pre>foreach($orders as $order) {<br>  echo $order-&gt;user-&gt;name;<br>}</pre><p>O exemplo acima irá executar duas queries no banco de dados:</p><ol><li>Para recuperar todas as Orders; e</li><li>Outra(s) para recuperar todos os usuários relacionados às Orders.</li></ol><p>Isso significa que se você possuir 1000 Orders, 1001 consultas serão feitas no banco de dados 😱</p><p>Isso mesmo! A primeira consulta será para recuperar todas as Orders, já as demais serão executadas sempre que o laço acima se repetir e tentarmos acessar o atributo nome do Model usuário relacionado. Será algo como isso:</p><pre>select * from orders;<br>select * from users where users.id = [user_id];<br>select * from users where users.id = [user_id];<br>select * from users where users.id = [user_id];<br>select * from users where users.id = [user_id];<br>...</pre><p>Para reduzir o tempo e a memória gasta com este tipo de operação, nós podemos solicitar ao Eloquent que inclua imediatamente todos os usuários relacionados às Orders:</p><pre>$orders = \App\Order::with(&#39;user&#39;)-&gt;get();</pre><pre>foreach($orders as $order){<br>  echo $order-&gt;user-&gt;name;<br>}</pre><p>Desta maneira, o Eloquent irá fazer somente duas consultas:</p><ol><li>Para recuperar todas as Orders; e</li><li>Outra para recuperar todos os usuários relacionados com as orders previamente recuperadas.</li></ol><p>No final, as consultas ficarão semelhantes a isto:</p><pre>select * from orders;<br>select * from users where users.id in ([user_id],[user_id],[user_id],[user_id],[user_id], ...);</pre><p>Onde, logicamente, [user_id] será uma lista de códigos de usuários extraídos da consulta anterior.</p><p>Internamente, o ORM cuidará de relacionar cada Order com seu respectivo User, para que você possa acessa-lo.</p><p>Observe que utilizamos o método with(). Ele pode ser utilizado de algumas maneiras. No último exemplo, foi passado para ele o nome do relacionamento a ser incluído à recuperação de Orders e os campos que deveriam ser retornados, que, no caso, foram user:id,name.</p><p>Agora considere que você deseja recuperar a lista de cupons utilizados por um usuário. O mesmo método poderá ser utilizado da seguinte forma:</p><pre>$orders = \App\Order::with(&#39;user.coupons&#39;)-&gt;get();</pre><pre>foreach($orders as $order){<br>  echo $order-&gt;user-&gt;coupons;<br>}</pre><p>O with também aceita passar um array com uma lista de relações que deverão ser carregadas de forma imediata:</p><pre>$orders = \App\Order::with([&#39;user&#39;, &#39;product&#39;])-&gt;get();</pre><pre>foreach($orders as $order){<br>  echo $order-&gt;user-&gt;first_name;<br>}</pre><p>Eager Loading é bastante usual também, quando você precisa enviar dados através de recursos de uma API. Para este caso, há uma economia significativa do trabalho de construção de recursos e diminuição de chamadas na API.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4108e9ef3df9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/laraveltips/eloquent-avan%C3%A7ado-part-4-7-4108e9ef3df9">Eloquent ORM Prático: Eager Loading — Part 4/7</a> was originally published in <a href="https://medium.com/laraveltips">LaravelTips</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Eloquent ORM Prático: Mutators — Part 3/7]]></title>
            <link>https://medium.com/laraveltips/eloquent-avan%C3%A7ado-part-1-7-b76970ec608f?source=rss----1ac5836ec91a---4</link>
            <guid isPermaLink="false">https://medium.com/p/b76970ec608f</guid>
            <category><![CDATA[laravel]]></category>
            <category><![CDATA[mutator]]></category>
            <category><![CDATA[orm]]></category>
            <category><![CDATA[advanced-laravel]]></category>
            <dc:creator><![CDATA[Mauricio Rodrigues]]></dc:creator>
            <pubDate>Thu, 14 Jun 2018 20:59:17 GMT</pubDate>
            <atom:updated>2018-06-16T21:27:35.416Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JGjGN3Z3xyEsWxdW5obIaw.png" /></figure><p>Conheça os mutator, a operação oposta dos accessors, e veja como ele pode lhe ajudar a normalizar os dados da sua aplicação.</p><p>Esta publicação faz parte da série de publicações sobre Eloquent Avançado. Nesta série abordaremos os seguintes assuntos:</p><ol><li>Introdução</li><li>Eloquent accessors</li><li>Eloquent mutator (você está aqui)</li><li>Relacionamentos com Eager Loading</li><li>Usando Collections nos resultados do Eloquent</li><li>Eventos do Eloquent e</li><li>Eloquent Query Scopes.</li></ol><h3>Usando Eloquent Mutators</h3><p>Mutators são como accessors, mas simplesmente trabalhando de forma oposta. Eles são usados para modificar dados que serão armazenados no banco de dados e são chamados no exato momento que você atribui um valor à uma propriedade do Model.</p><p>Você pode definir um mutator da seguinte forma, considerando, neste caso, que desejamos modificar uma data do formato DD/MM/AAAA para o formato:</p><pre><strong>public function </strong>setDateAttribute($value)<br>{<br>    <strong>list</strong>($day, $month, $year) = explode(&#39;/&#39;, $value);<br>    $this-&gt;attributes[&#39;date&#39;] = &quot;{$year}-{$month}-{$day}&quot;;<br>}</pre><p>Sendo assim, se atribuirmos uma data ao atributo order_date:</p><pre>$order-&gt;date = date(&#39;d/m/Y&#39;);</pre><p>Essa data será transformada em:</p><pre>2018-06-05 // data do dia que esta publicação está sendo escrita ;)</pre><p>Mutators são simples e fundamentais para os projetos em Laravel. Use bastante. Eles resolverão muitos dos seus problemas relacionados à normalização dos dados.</p><p>E aí, está gostando das publicações? Comenta aqui em baixo o que tem achado. Sugira publicações, mande suas dúvidas, conte com a gente! Estamos aqui pra te ajudar.</p><p>Um abraço e até a próxima publicação, que falará sobre <a href="https://medium.com/laraveltips/eloquent-avan%C3%A7ado-part-4-7-4108e9ef3df9">Eager Loading</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b76970ec608f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/laraveltips/eloquent-avan%C3%A7ado-part-1-7-b76970ec608f">Eloquent ORM Prático: Mutators — Part 3/7</a> was originally published in <a href="https://medium.com/laraveltips">LaravelTips</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Eloquent ORM Prático: Accessors — Part 2/7]]></title>
            <link>https://medium.com/laraveltips/eloquent-avan%C3%A7ado-part-1-7-f47f83f9c581?source=rss----1ac5836ec91a---4</link>
            <guid isPermaLink="false">https://medium.com/p/f47f83f9c581</guid>
            <category><![CDATA[orm]]></category>
            <category><![CDATA[eloquent]]></category>
            <category><![CDATA[accessor]]></category>
            <category><![CDATA[advanced-laravel]]></category>
            <category><![CDATA[laravel]]></category>
            <dc:creator><![CDATA[Mauricio Rodrigues]]></dc:creator>
            <pubDate>Thu, 14 Jun 2018 20:49:11 GMT</pubDate>
            <atom:updated>2018-06-16T21:26:47.266Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UrNeeiki7fAWdFELkWwZTw.png" /></figure><p>Conheça um pouco dos benefícios de se utilizar accessors no Laravel.</p><p>Esta publicação faz parte da série de publicações sobre Eloquent Avançado. Nesta série abordaremos os seguintes assuntos:</p><ol><li>Introdução</li><li>Eloquent accessors (você está aqui)</li><li>Eloquent mutator</li><li>Relacionamentos com Eager Loading</li><li>Usando Collections nos resultados do Eloquent</li><li>Eventos do Eloquent e</li><li>Eloquent Query Scopes.</li></ol><h3>Usando Eloquent Accessors</h3><p>Os accessors permitem que você formate os valores recebidos do banco de dados, para serem apresentados de uma determinada forma. Por exemplo, você precisa que em sua aplicação, o valor de uma ordem de serviço seja prefixado por ‘R$’ ou o código de uma ordem de serviço seja formatado para o padrão da sua empresa que é ORD-AAAAMM-ID. Para garantir que isso aconteça, você pode trabalhar com accessors, da seguinte forma:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9b292f17ad26fb4649dcdc396701527b/href">https://medium.com/media/9b292f17ad26fb4649dcdc396701527b/href</a></iframe><p>Acima, nós definimos um accessor para amount. A forma de fazer isso é criando, dentro do Model, um método com o formato getFooAttribute, onde Foo representa o nome do atributo que deve ser acessado e que também recebe no seu único argumento um valor ($value) representando o valor do atributo acessado. O nome do método DEVE ser em camelCase.</p><p>Para acessar o valor do atributo, fazemos o seguinte:</p><pre>$order = \App\Order::find(1);<br>$order-&gt;amount;</pre><p>O accessor vai ser chamado a cada vez que você tentar recuperar o valor do atributo amount.</p><p>Agora, para acessarmos o código da Order, faremos:</p><pre>$order-&gt;code;</pre><p>Code é um campo que não existe na tabela orders no banco de dados (considere isso, já que não definimos isso antes). Mas, mesmo assim, nós conseguimos criar um accessor para o atributo code e ele passará a fazer parte do Model Order.</p><p>Isso acontece porque o Laravel lida magicamente com os seu atributos. Ele não vai ao banco de dados verificar se há algum campo correspondente ao que foi definido no Model. Pelo contrário, nós não precisamos definir nenhum atributo dentro do Model. Quando chamamos um atributo, caso ele exista, seu valor será retornado (ou, antes disso, será passado por um accessor, como é o nosso caso), mas, caso ele não exista, null será retornado.</p><p>Esse caso também é útil, quando você tem um ID público e um privado. Digamos o ID público de uma Order seja um UUID e o privado seja um inteiro de um campo auto_increment ou para casos que é necessário computar alguns dados, como calcular taxas, etc.</p><p>Accessors são bastante úteis quando precisamos tratar os dados que serão apresentados em nossa aplicação. É interessante considerar a aplicação de Presenter Pattern, para que haja uma separação das responsabilidade e para evitar que os Models inflem.</p><p><a href="https://medium.com/laraveltips/eloquent-avan%C3%A7ado-part-1-7-b76970ec608f">Na próxima publicação</a>, vamos falar sobre os <a href="https://medium.com/laraveltips/eloquent-avan%C3%A7ado-part-1-7-b76970ec608f">mutators</a>, recurso bastante útil quando pensamos em normalização de dados.</p><p>E aí, quando você utliza accessors e quais suas dúvidas sobre ele? Comenta ou pergunta aqui em baixo, que a gente te responde.</p><p>Um abraço e até breve.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f47f83f9c581" width="1" height="1" alt=""><hr><p><a href="https://medium.com/laraveltips/eloquent-avan%C3%A7ado-part-1-7-f47f83f9c581">Eloquent ORM Prático: Accessors — Part 2/7</a> was originally published in <a href="https://medium.com/laraveltips">LaravelTips</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Eloquent ORM Prático — Introdução]]></title>
            <link>https://medium.com/laraveltips/eloquent-avan%C3%A7ado-introdu%C3%A7%C3%A3o-d0515fe0f3c6?source=rss----1ac5836ec91a---4</link>
            <guid isPermaLink="false">https://medium.com/p/d0515fe0f3c6</guid>
            <category><![CDATA[eloquent]]></category>
            <category><![CDATA[advanced-laravel]]></category>
            <category><![CDATA[laravel-avançado]]></category>
            <category><![CDATA[orm]]></category>
            <dc:creator><![CDATA[Mauricio Rodrigues]]></dc:creator>
            <pubDate>Thu, 14 Jun 2018 20:47:21 GMT</pubDate>
            <atom:updated>2018-06-16T21:24:41.606Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qUdwifPOyihuqABxZsXTew.png" /></figure><p>Conheça um pouco mais dos recursos disponíveis no Eloquent, ORM nativo do Laravel.</p><p>Laravel faz com que o desenvolvimento de aplicações em PHP seja leve. Ele foi desenvolvido para permitir que suas aplicações lide facilmente com questões com o banco de dados, rotas, sessões, cache entre outras coisas. Ele tem um provedor de serviço (Service Provider, que não é o mesmo que o conceito de Service Layer) que lhe permite carregar (bootar ou fazer boot) de configurações customizadas e extender o Laravel, de acordo com a sua necessidade.</p><p>Nesta série de publicações, nós vamos nos aprofundar no ORM (Object Relational Mapper) utilizado pelo Laravel: o Eloquent. Nós vamos falar sobre recursos menos usados do Eloquent e como eles podem deixar o processo de desenvolvimento mais fácil.</p><h3>Requisitos</h3><p>Para acompanhar esta publicação, você deve:</p><ol><li>Ter boas noções de PHP;</li><li>Ter conhecimentos de como o Laravel funciona;</li><li>Ter familiaridade com a sintaxe do Eloquent; e, por fim</li><li>Opcionalmente: criar um novo projeto Laravel, para testar as dicas que darei aqui. 😉</li></ol><h3>O que é o Eloquent?</h3><p>O Eloquent é ORM embutido no Laravel, que fornece uma simples e linda implementação do ActiveRecord Pattern, para interagir com um banco de dados. Cada Model do Eloquent cria um wrapper sobre a tabela no banco de dados que a ele está associado. Isso faz com que cada instância de um Model seja uma representação de uma linha da tabela associada.</p><p>O Eloquent fornece métodos assessores (accessors methods) e propriedades que correspondem a cada célula de uma linha. Ele também fornece métodos para estabelecer relacionamentos com outros Models, que lhe permitem acessar métodos desses Models relacionados também.</p><p>Quando uma instância de um Model é atualizada no banco de dados, o registro (linha) que está relacionado ao Model também será atualizado. O mesmo serve para as deleções, quando um Model é deletado, o registro (linha) também é removido do banco de dados.</p><p>O Eloquent também fornece uma série de funcionalidades para trabalhar com o banco de dados. Nesta série de publicações, nós vamos explorar algumas delas:</p><ol><li><a href="https://medium.com/laraveltips/eloquent-avan%C3%A7ado-part-1-7-f47f83f9c581">Eloquent accessor</a></li><li><a href="https://medium.com/laraveltips/eloquent-avan%C3%A7ado-part-1-7-b76970ec608f">Eloquent mutator</a></li><li><a href="https://medium.com/laraveltips/eloquent-avan%C3%A7ado-part-4-7-4108e9ef3df9?source=collection_home---4------0----------------">Relacionamentos com Eager Loading</a></li><li><a href="https://medium.com/laraveltips/eloquent-avan%C3%A7ado-collections-part-4-7-2a91faef022b">Usando Collections nos resultados do Eloquent</a></li><li>Eventos do Eloquent (em breve) e</li><li>Eloquent Query Scopes (em breve).</li></ol><p>Vamos começar? Clique <a href="https://medium.com/laraveltips/eloquent-avan%C3%A7ado-part-1-7-f47f83f9c581?source=collection_home---4------2----------------">aqui</a> para ir para o assunto: <a href="https://medium.com/laraveltips/eloquent-avan%C3%A7ado-part-1-7-f47f83f9c581">Eloquent Accessors</a>. Se preferir, você pode navegar diretamente para uma das publicações da série, clicando no menu acima.</p><p>Ademais, já aproveito para agradecer a todas as pessoas que estão lendo, curtindo, compartilhando e me dando feedback. Agradeço, em especial, à <a href="https://medium.com/u/eec9dc2814c8">Saulo Gomes</a> pelos (muitos) feedbacks e pela sugestão de título menos sensacionalista hahahaha. Valeu, Saulo.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0515fe0f3c6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/laraveltips/eloquent-avan%C3%A7ado-introdu%C3%A7%C3%A3o-d0515fe0f3c6">Eloquent ORM Prático — Introdução</a> was originally published in <a href="https://medium.com/laraveltips">LaravelTips</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Single Sign-On (SSO) Server + Laravel 5]]></title>
            <link>https://medium.com/laraveltips/single-sign-on-sso-server-laravel-5-6c7c70858c63?source=rss----1ac5836ec91a---4</link>
            <guid isPermaLink="false">https://medium.com/p/6c7c70858c63</guid>
            <category><![CDATA[laravel]]></category>
            <category><![CDATA[sso]]></category>
            <category><![CDATA[single-sign-on]]></category>
            <dc:creator><![CDATA[Mauricio Rodrigues]]></dc:creator>
            <pubDate>Thu, 14 Jun 2018 18:23:04 GMT</pubDate>
            <atom:updated>2017-07-26T16:16:28.542Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*Hxlcm86K1_DsbLWZY7ajNA.png" /></figure><p>Deixei o monolítico de lado, parti pros microsserviços, o <strong>Single Sign-On (SSO) </strong>tá no meio de campo e o <strong>Laravel </strong>tá sendo Laravel =D</p><p>De antemão, eu quero dizer algo para você que chegou aqui através de buscas ou por ter encontrado esse link compartilhado em alguma rede social: <strong>não desista! </strong>Lidar com desafios tecnológicos é algo bastante desafiador. Andamos em muitos terrenos desconhecidos, afim de alcançar um objetivo. Alcançar um resultado é maravilhoso quando conseguimos, porém perturbador enquanto ainda não chegamos lá, eu sei. Insista e não desista, pois se fosse fácil todo mundo faria. Pode demorar, mas você vai conseguir se quiser.</p><p>Estou fazendo essa introdução melancólica e motivacional (hahaha), porque passei por um bom perrengue até encontrar a melhor alternativa para o meu caso, e isso levou (bastante) tempo. Passei os últimos 5 meses pesquisando sobre a solução, pedindo ajuda a amigos e comunidade (sem muito sucesso aqui, é importante ressaltar), efetuando uma série de testes e ao mesmo tempo dando conta das minhas demandas diárias que não podiam atrasar. Me vi só, perdido num deserto, sem bússola e sem mapa.</p><p>Na verdade, trabalhar em projetos que geram impacto no mercado é assim… É difícil mesmo!!! É desafiador e exigem de você muito esforço, determinação e dedicação. Mas pretendo falar sobre isso em outra publicação, para não me estender demais.</p><h3>O problema de ter uma aplicação monolítica</h3><blockquote><em>Se você já sabe o que é e quais os problemas relacionados a uma aplicação monolítica, pode avançar para o próximo tópico. Caso contrário, leia este tópico e veja um pouco da minha opinião sobre esse tipo de aplicação.</em></blockquote><p>Tá, vamos ao que realmente interessa. Primeiramente preciso falar um pouco do problema, para que depois fale da solução e de como o <strong>SSO</strong> me ajudou nesse caso.</p><p>Estou trabalhando num projeto que roda em cima de um sistema monolítico. Esse monolítico foi um <strong>MVP</strong> que teve uma série de avanços e retrocessos até chegar ao formato que chegou. Ele é o ponto central do negócio e possui regras fundamentais para o funcionamento da empresa. Profissionais mais experientes conseguem perceber claramente os malefícios de uma aplicação monolítica, principalmente quando é algo desenvolvido com versões antigas de frameworks, linguagens, pensamentos, conceitos e padrões.</p><p>Cito alguns aqui:</p><ul><li>É altamente acoplada;</li><li>Custa (muito) caro manter, pois o requisito é alto e a aplicação é extremamente sensível;</li><li>Qualquer nova mudança pode (e na maioria das vezes vai) impactar em algo que já está funcionando;</li><li>Por serem legadas, dificilmente usam bons padrões e são testáveis. Só este ponto já merece um ponto final no texto inteiro (hahahaha), mas ainda tenho mais pra falar.</li></ul><p>Embora seja fácil citar os pontos negativos, precisamos entender e respeitar o fato de que aplicações monolíticas ainda são comuns em <strong>Startups (que é o meu caso), </strong>por ex<strong>.</strong> Antes do “boom” fullstack, os padrões eram outros e aplicações monolíticas eram o caminho mais rápido para a entrega de um produto minimamente viável (leia-se: usável), num intervalo de tempo curto.</p><p>Diante desses aspectos, percebia que essa aplicação poderia virar uma bomba relógio, caso continuasse recebendo atualizações significativas. Nesse momento eu resolvi começar uma mudança silenciosa, mas importante para mim e para a empresa: <strong>trabalhar com Domain-Driven Design (DDD) e microsserviços</strong>. “Por quê, Mauricio?” Porque não fazia sentido ter, por ex., um sistema financeiro, dentro do sistema de artistas ou um sistema de notificações e/ou mensagens dentro do mesmo sistema do produtor de elenco. Eles fazem parte do <strong>domínio principal</strong>, mas são <strong>subdomínio</strong> diferentes; contextos diferentes… que erroneamente faziam parte da aplicação monolítica.</p><p>Não ficou claro? Vou dar outro exemplo… Faz sentido o sistema que recebe <strong>atualizações financeiras</strong> estar junto do <strong>CMS</strong> do site, por ex?</p><p>No meu ponto de vista, não. Entenda:</p><ul><li>Eles tem responsabilidades diferentes;</li><li>são utilizados por pessoas diferentes;</li><li>são requisitados em tempos diferentes;</li><li>tem regras de negócio diferentes;</li><li>demandam recursos de máquina diferentes;</li><li>etc…</li></ul><p>Separar esses contextos traz uma série de benefícios e algumas eu faço questão de citar:</p><ul><li><strong>Custa mais barato, embora pareça mais caro<br></strong>No aspecto infraestrutura, já fica fácil visualizar que o escalonamento da sua aplicação vai acontecer por partes e não integral. Não faz sentido escalar o cache, se o que está precisando ser escalado é o banco de dados.</li><li><strong>O custo com mão de obra pode ser menor e mais direcionado</strong><br>Ora… Num monolítico o profissional vai custar bem mais caro, porque ele precisa <em>manjar dos paranauês do canivete suíço</em>. O cara tem que ser um semideus. De apertar porca com martelo pra cima. O mesmo não acontece quando se trabalha com microsserviços. Você contrata por especialidade. Seu analista especialista em finanças não vai estar lidando com questões relacionadas ao CMS. Com esse mesmo exemplo já fica claro ver que são requisitos diferentes de profissionais. Nesse caso, não seria impossível selecionar um júnior para o CMS e um sênior para o financeiro, por ex.</li><li><strong>Separação das responsabilidades<br></strong>Seu contexto tem uma única responsabilidade: se preocupar com ele mesmo e são bem mais <strong>delimitados</strong>. Ele cuida dos próprios recursos e compete somente a ele o ônus e bônus dos seus resultados.</li></ul><p>Esses são alguns dos muitos outros motivos que podem ser listados aqui.</p><h3>Pensando e criando Microsserviços</h3><p>Diante do problema que tínhamos com a aplicação monolítica, eu tinha o desafio de criar o primeiro microsserviço da plataforma. Comecei pelo sistema financeiro e vou explicar o porque.</p><p>Quando começamos o monolítico recebia todos os cadastros de usuários pelo backend, pois a plataforma só funcionava por meio de convites. Pouco tempo depois, depois que já tínhamos a anatomia da aplicação definida e operante, recebi a notícia de que iríamos passar a trabalhar com assinaturas.</p><p>Como citei no tópico anterior, não fazia sentido fazer toda a implementação financeira dentro do sistema monolítico, pelos motivos que citei (e muitos outros). Optei pelo <strong>Laravel</strong> e criei toda a aplicação para receber e gerenciar as assinaturas de cada novo usuário.</p><p>Aqui temos <strong>APIs</strong>, um backend (<strong>vue.js</strong>) que consome essas APIs. Contamos com Redis, RDS, algumas instâncias de <strong>EC2</strong>, <strong>Linode</strong>, e <strong>droplets</strong> da <strong>Digital Ocean</strong> para rodar tanto a aplicação em produção, quanto os testes, tudo orquestrado com Docker (ambiente de desenvolvimento, <strong>staging</strong> e <strong>deploy</strong>).</p><p>De um modo geral, o processo funciona da seguinte forma: A cada nova assinatura, o <strong>webhook</strong> dispara para o monolítico as informações referentes a assinatura recém criada e ele processa essa informação lá.</p><p>Esta arquitetura separou os processos, nos deu autonomia, mas ainda deixou o monolítico responsável pela autenticação do usuário assinante, o que era algo ruim. Isso aconteceu pelo fato de existirem assinantes convidados cadastrados. O sistema financeiro só recebia novos assinantes, mas os assinantes convidados continuavam no monolítico e isso era um problema. O monolítico não deveria ser mais responsável pelo login do assinante, já que tenho um sistema em outro local que controla a assinatura dele. Ou seja, tínhamos responsabilidades fora de contexto e precisávamos resolver.</p><p>E aí entrou em campo o <strong>SSO</strong>.</p><h3>Single Sign-On (SSO)</h3><p>Você pode não saber o que é SSO, mas com toda certeza já utilizou ferramentas que trabalham com este recurso. O Google é um exemplo. Você se autentica numa conta do Google e através de um único login, você consegue acessar todos os recursos que ele oferece (Gmail, Drive, Blogger, e todos os outros). A Amazon também possui o mesmo recurso. Pra quem tinha a conta da Amazon e passou a utilizar o AWS (como foi o meu caso) se surpreendeu ao ver as contas associadas. A Apple também oferece o mesmo recurso e muitas outras grandes empresas.</p><p>Single Sign-On é isso, é autenticar-se num único lugar e ter acesso a todos os recursos que aquela ferramenta pode te oferecer. E essa era a nossa necessidade. Quando decidimos migrar a autenticação do usuário para o sistema que controla as assinaturas, era indispensável não utilizar SSO, pois o assinante, ao mesmo tempo que pode acessar as informações financeiras dele, também pode editar o seu próprio perfil, acessar suas mensagens, visualizar suas notificações e acessar os conteúdos do CMS. Cada item desse é um microsserviço que requer autenticação para ser utilizado.</p><h3>Trabalhando com Single Sign-On (SSO)</h3><p>Pra mim, mais difícil que implementar foi montar o workflow. Decidir o que é melhor pro seu caso é difícil, principalmente quando a mudança claramente traz uma série de benefícios, mas gera um impacto significativo. Nesse caso o impacto foi pro assinante que obrigatoriamente precisou trocar suas senhas (não preciso dizer o porque, né? ¬¬).</p><p>Observe o diagrama sequencial na imagem abaixo, que eu vou explicar a seguir como cheguei a isso.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lFDI3NkJgyq9pc49bL5zmQ.png" /><figcaption>Single Sign-On Sequence Diagram</figcaption></figure><p>Vamos entender quem é quem, antes de continuar.</p><h3>SSO Server</h3><p>O SSO Server é o serviço responsável pela autenticação do usuário e por registra os Brokers. Somente os Brokers registrados podem tentar fazer login no SSO Server.</p><h3>Broker</h3><p>O Broker é a aplicação (pagina web, api, etc) que você quer permitir que o usuário acesse após se autenticar no SSO Server. Cada Broker possui um ID e uma chave privada que é utilizada para fazer a conexão entre o Broker e o SSO Server.</p><p>Quando uma nova requisição é feita por um Broker, este recebe do SSO Server um token referente a requisição, no ambiente em qual ele foi requisitado. Isso vai ficar mais claro logo abaixo.</p><h3>Client</h3><p>Client é quem deseja se autenticar no SSO Server para acessar conteúdos que são disponibilizados pelos Brokers.</p><h3>Como funciona tudo isso?</h3><p>Um cliente no nosso caso é um assinante. O assinante possui credenciais de acesso a aplicação e elas que são utilizadas para autenticar no SSO Server.</p><p>O assinante só pode se autenticar através de algum Broker. No exemplo que estamos utilizando, nós temos, então, dois Brokers:</p><ol><li>Broker App Financeiro (BAF)</li><li>Broker App Site (BAS)</li></ol><p>Quando um Client instancia um BAF via Browser, por ex., o Broker vai até o SSO Server e se autentica. Após se autenticar, ele devolve para o Client um Cookie com um hash único que o identifica, dentro daquela instância.</p><p>Aqui já posso sentir o cheirinho de dúvida. Você deve estar se perguntando sobre a performance disso, né?</p><p>Então… Se você observar bem o diagrama acima, o primeiro processo se refere à requisição de um conteúdo público. Pode ser algo como a página inicial do site. Ela não precisa de login e está disponível pra todo mundo. O mesmo acontece com as páginas institucionais, formulários de contato e até mesmo a página de login. Para casos que não precisam de identificação, nós não autenticamos o Broker no SSO Server, por que, tendo as aplicações na mesma rede ou não, esse é um típico esforço desnecessário. Logo, se o conteúdo é público, ele não precisa de autenticação e não envolve o SSO Server.</p><blockquote><strong>Mas se o conteúdo for privado, como você faz então?</strong></blockquote><p>Nesse caso, o SSO Server vai ser utilizado, mas um outro personagem entra em ação: o <strong>Broker Session Manager. </strong>Cada aplicação tem sua própria gerência de sessão. Se um Client requisitar um conteúdo privado, o Broker Session Manager é acionado para verificar se o Client possui sessão ativa.</p><p>Vamos entender fluxo, com um passo-a-passo.</p><h3>Caso #1: Usuário não possui sessão ativa</h3><ol><li>O cliente abre o browser e requisita um conteúdo privado;</li><li>O Broker Session Manager entra e ação e verifica se o Client possui sessão ativa;</li><li>Se não possuir, o Client é redirecionado para a página de login. Ele entra com as suas credenciais e submete o formulário;</li><li>Nesse momento, duas autenticações acontecem: <br>1. O Broker se autentica <strong>no</strong> SSO Server; <br>2. O usuário se autentica <strong>pelo</strong> SSO Server. <br>Independente das credenciais do Client serem válidas, o SSO Server retorna para o Broker um token único daquela requisição, que por sua vez é salva num Cookie no navegador do Client.</li><li>Se as credenciais forem válidas, o SSO Server retorna para o Broker um objeto com o Assinante. Considere isso como <strong>primeiro retorno</strong> e ele tem algumas informações importantes. A primeira é que ele contém dados da sessão que foi criada no SSO Server que contem o Objeto Assinante. A segunda é que ela contém m token de acesso que dá permissão para acessar a API do sistema financeiro, que também é um Broker, lembra? Ele é o Broker App Financeiro (BAF).</li><li>O Broker, ao receber o Objeto do Assinante, procura por um cabeçalho do Assinante no próprio Broker. Esse cabeçalho é uma entidade de mapeamento. É como se também houvesse no Broker uma Assinantes com o ID do assinante no Broker e o ID do assinante do SSO Server. Isso nos permite a fazer algo como “Logar Como…” e é isso que o Broker faz. Depois de encontrar o assinante nele mesmo, ele internamente faz uma autenticação por ID. Só que nesse caso o ID utilizado é o ID do artista no SSO Server.</li><li>Por fim, o Broker retorna para o Client Cookies que representam as duas sessões existentes para esse Client.</li></ol><h3>Caso #2: Autenticando em outro Broker</h3><p>Vamos considerar aqui que agora queremos acessar o conteúdo do sistema de Mensagens (Broker App Mensagens — BAM). Para isso, o usuário precisa se autenticar também no sistema de mensagem, mas <strong>NÃO</strong> precisa se autenticar novamente no SSO Server, pois ele já possui uma sessão ativa com o SSO Server.</p><p>Logo, o processo é semelhante ao <strong>Caso #1, </strong>a diferença é que a única coisa que precisamos fazer é recuperar o Objeto Assinante (que o Client já tem) e forçar um novo login no sistema de Mensagens. Ou seja, só precisamos executar o passo 6 e 7 do <strong>Caso #1.</strong> Feito isso, temos um novo login também no Broker App Mensagens e o Client passa a ter um novo Cookie com informações do novo Broker.</p><p>Esse processo se repete para todos os demais Brokers.</p><h3><strong>Caso #3: Brokers que possuem formulário de login</strong></h3><p>Quando se trata de integração com APIs, é fácil de entender o processo, a autenticação forçada para acontecer internamente sem que o usuário perceba, etc. Mas quando temos dois Brokers que possuem formulário de login, como fazemos?</p><p>Esse é um dos grandes trunfos do SSO. Lembra que todos os Brokers são identificáveis no SSO Server? Lembra também que o Client, quando autenticado, possui uma Sessão ativa com o SSO Server? Então… É aqui que a mágica acontece.</p><p>Digamos que vc tem um Broker App Financeiro e outro com o seu CMS. Quando o usuário se autentica pelo Broker App Financeiro, no momento que ele requisitar algo no privado no CMS, o Broker Session Manager do CMS entrará em ação. Ai tudo acontece como disse no <strong>Caso #2 </strong>sem apresentar pro usuário um formulário de login. A autenticação acontece internamente. Simples assim.</p><p>Se o usuário iniciar a sessão no CMS e requisitar algo no Broker App Financeiro, o Broker Session Manager do Financeiro irá agir da mesma maneira e, dessa vez, é o formulário de login do Broker App Financeiro que não será apresentado pro usuário.</p><p>Isso significa que quando o Client se autentica em qualquer um dos Brokers, automaticamente ele estará autenticado no outro.</p><h3>Dicas &amp; Conclusão</h3><p>Deixo aqui algumas dicas e considerações finais sobre a experiência vivenciada nesse processo.</p><ol><li>Pacote <a href="https://github.com/jasny/sso">jasny/sso</a>:<br>O utilizei para gerenciar o SSO Server. Ele é bem completo, simples e bastante utilizado pela comunidade. Existem outros pacotes, inclusive encontrei um para Laravel (que parece ser um fork do jasny/sso), mas optei pelo jasny/sso por ver que há bastante tempo ele vem sendo utilizado e atualizado; pelo fato criador do pacote estar participando do processo de amadurecimento do pacote e participando ativamente das ISSUES. Como se trata de uma parte bem sensível, esse foi o que me deixou mais seguro. Existem outros, mas esse eu achei bem simples e interessante. Optei por ele pela quantidade de utilizações e pelo que vi nas ISSUES.</li><li>Pacote <a href="https://github.com/tymondesigns/jwt-auth">JWT Auth</a>:<br>o JWT é stateless, um requisito indispensável pra trabalhar com SSO, já que um token não pode sobrescrever o outro, como acontece com a API nativa do Laravel.</li><li>Pra trabalhar com esses pacotes precisei fazer algumas modificações em algumas partes dele. Por exemplo, no JWT eu criei um outro Route Middleware para validar o Token que faz um pouco mais do que o jwt.auth. Fiz isso porque a API funciona com autenticação por contexto. Eu posso permitir acesso pro usuário do backend (User model, por exemplo), como também posso permitir pro Assinante (Subscriber model, por exemplo). Esses dois contextos acessam recursos direrentes.</li><li>Outra modificação foi no jasny/sso. Como utilizamos PHP-FPM, tivemos um problema com a função do PHP <a href="http://php.net/manual/en/function.getallheaders.php">getallheaders()</a> que é utilizada pelo pacote. Com isso precisei sobrescrever o método <a href="https://github.com/jasny/sso/blob/master/src/Server.php#L97">getBrokerSessionID()</a> pra usar meu próprio método getallheaders().</li></ol><p>Bom, acho que é isso. Espero que você tenha chegado até aqui o final, que tenha entendido os “Porquês?” das coisas e que esta publicação seja útil pra você também. Confesso que se tivesse encontrado algo desse gênero no começo deste processo, as coisas teriam sido um pouco mais fáceis pra mim. Por esse motivo fiz questão de dedicar algumas poucas horas para a escrita/revisão desta publicação.</p><p>Se não for pedir muito, curte aqui em baixo a publicação. Esse é um dos poucos parâmetros que tenho para saber sobre a relevância deste assunto.</p><p>Comente também. Pergunte, questione, fale. Aproveite. A informação que possuo é tão sua quanto minha. Basta perguntar que terei o prazer em ajudar.</p><p>Obrigado, um abraço e sucesso pra você!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6c7c70858c63" width="1" height="1" alt=""><hr><p><a href="https://medium.com/laraveltips/single-sign-on-sso-server-laravel-5-6c7c70858c63">Single Sign-On (SSO) Server + Laravel 5</a> was originally published in <a href="https://medium.com/laraveltips">LaravelTips</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Você entende Repository Pattern? Você está certo disso?]]></title>
            <link>https://medium.com/laraveltips/voc%C3%AA-entende-repository-pattern-voc%C3%AA-est%C3%A1-certo-disso-d739ecaf544e?source=rss----1ac5836ec91a---4</link>
            <guid isPermaLink="false">https://medium.com/p/d739ecaf544e</guid>
            <dc:creator><![CDATA[Mauricio Rodrigues]]></dc:creator>
            <pubDate>Thu, 14 Jun 2018 18:21:28 GMT</pubDate>
            <atom:updated>2018-06-14T18:37:15.101Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p7u2-Qgw_rnMAY5wb-zZaw.jpeg" /></figure><p>Você está aplicando o padrão da maneira correta ou está somente seguindo o bonde?</p><p>Caí novamente em discussões envolvendo Repository Pattern e o “jeito certo” de implementá-lo, depois de publicar nos grupos que participo um pacote com o <a href="https://github.com/zabaala/scheduler">“meu jeito”</a> de estruturar projetos em Laravel.</p><p>Resolvi escrever essa publicação, por perceber que o tempo fica nublado quando falamos de Repository Pattern. Um outro forte motivo também de estar aqui escrevendo, é que as melhores fontes sobre o assunto estão em inglês. E, pelo que tenho percebido, está rolando uma má interpretação dos artigos.</p><p>Antes de continuar, você precisa saber que a intensão dessa publicação é expressar o meu ponto de vista sobre o padrão, além de tentar apresentá-lo de forma mais transparente.</p><h3>O que é repositório?</h3><blockquote>Repositório é uma interface de consulta e manipulação <strong>ESPECÍFICA (leia-se: abstrata, não!!! Genérica, não!!!) </strong>em<strong> </strong>coleções de dados, independente da sua origem.</blockquote><p>Acho que essa é a melhor definição para <em>Repository Pattern </em>e, se ela tivesse sido feita antes de algumas implementações, muito provavelmente, muitos transtornos e mal entendidos seriam evitados.</p><p>Digo isso porque o que vejo hoje é que as pessoas não entendem “o porquê” da aplicação do padrão no projeto, chegando a utilizá-lo por moda e, o que é pior, de maneira errada. Além de estarem apoiadas no discurso fraco de que Repository é uma maneira de se precaver da troca futura de ORM.</p><p>Observe, o argumento é fraco, mas não irreal, como foi muito bem ressaltado por Shawn McCool <a href="http://shawnmc.cool/the-repository-pattern">neste artigo</a>:</p><blockquote>“Any sufficiently designed object-oriented application automatically comes with this type of advantage. A very central concept to object-orientation is encapsulation. You can expose an API and hide implementation”</blockquote><p>Em outras palavras, o que ele defende é que esse não deve ser o motivo real para a utilização / aplicação do padrão em seus projetos, já que a troca de ORM não acontece assim… num estalar de dedos… e o encapsulamento está ai pra facilitar essa troca, quando esta necessidade realmente existir.</p><h3>Quando utilizar Repository Pattern</h3><p>Na minha opinião, sempre que você quiser deixar as coisas mais organizadas, bem definidas, bem separadas e criar uma barreira (de controle e segurança) entre a aplicação e os seus dados, utilize repositórios. Como eu gosto de fazer isso o tempo todo, eu sempre o aplico nos projetos que participo, ignorando-o somente em casos em realmente não há necessidade e que irão gerar desperdícios (de tempo, esforço, etc).</p><h3>Repositório é um serviço de domínio ou de aplicação?</h3><p>Repositório é ser um <strong>serviço de domínio</strong>, que abstrai a camada de persistência da sua aplicação e atua como API para os <strong>serviços de aplicação </strong>(controllers, CLI, etc). Ou seja, deve ser a única API de acesso confiável aos objetos de domínio e não deve ser responsável por conexões ao banco, envio de e-mail, etc…</p><h3>Não confunda Serviço de Domínio com Service Layer</h3><p>Embora se assemelhem no quesito abstração, uma leve distinção, como mencionado por <a href="https://www.facebook.com/groups/laravelbrasil/permalink/1523420127680037/?comment_id=1523436477678402">Marcelo Rodrigues aqui nesse post:</a></p><blockquote>É preciso separar bem o conceito de “Service” enquanto camada de negócio, a famosa Service Layer, do conceito de “Service”, como instância de uma classe no container de dependência.</blockquote><blockquote>No DDD existem os padrões Service e Repository. O Service do DDD é levemente diferente do Service Layer. No Service Layer cria-se uma “fachada”, usando o padrão Facade (importante não confundir com as Facades do Laravel), isolando e impedindo acesso direto as regras de negócio. Não é necessário saber como ele implementa regras e acesso a dados (por isso o nome Fachada). Numa situação prática, controller ou qualquer outra camada que precisar resolver qualquer coisa de negócio, conversa com a interface da Service Layer. A chance de ter um serviço inchado e com responsabilidades além da conta é alta com esse padrão, se não bem implementado. Sem contar a redundância quando se usa Repository, onde métodos do repositório são replicados no Service.</blockquote><blockquote>No DDD, a coisa é diferente. Repository pode ser acessado independente se ou não dentro de uma Service. Por exemplo, dentro do Controller. Não há violação de regras aqui. Service na verdade só é necessário quando você precisa implementar regras de negócios complexas que envolvem mais de um repositório, outros serviços etc. Nem tudo precisa e deve ser isolado em Services.</blockquote><p>Veja abaixo um exemplo do que Marcelo disse. Foi criado um comando que é responsável pelo registro de um novo Médico e o Controller acessa o serviço, ao invés de um método do repositório:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7e790dfc146c975c22fa2b093c5edb79/href">https://medium.com/media/7e790dfc146c975c22fa2b093c5edb79/href</a></iframe><p><em>A implementação do serviço </em><a href="https://github.com/zabaala/scheduler/blob/master/app/Domains/Doctor/Commands/CreateNewDoctorCommand.php"><em>CreateNewCommand pode ser vista aqui</em></a><em>.</em></p><p>Mas não precisa criar um serviço pra tudo, para que os serviços não se tornem simplesmente “proxies” dos repositórios. No exemplo abaixo, o acesso ao repositório é feito diretamente, ao invés de ser utilizado um Service.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f819fd6475b1807a6aaf206c6dc6ddab/href">https://medium.com/media/f819fd6475b1807a6aaf206c6dc6ddab/href</a></iframe><p><strong>OBS:</strong> Não estranhe eu estar chamando meu serviço de command. Ele pode ser command, service, handler ou semelhantes.</p><h3>Repositórios não são genéricos, são específicos!</h3><p>O maior problema da aplicação do Repository Pattern no Laravel, é que pacotes e “maus entendimentos” tem direcionado os desenvolvedores à construção de repositórios genéricos, que estendem classes abstratas e executam tarefas comuns.</p><p>Se você tem classes com comportamentos genéricos, você está violando o padrão, adicionando mais uma camada na aplicação, perdendo seu tempo e/ou gastando o tempo de alguém.</p><p>Observe:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b5b126d3f540cac793499d9740db8bd7/href">https://medium.com/media/b5b126d3f540cac793499d9740db8bd7/href</a></iframe><p>Para os códigos acima, minhas considerações são as seguintes:</p><ol><li>Você está violando o padrão, por utilizar métodos genéricos;</li><li>Seu repositório está atuando somente como um proxy do ORM, sem oferecer o que o ORM possui. Isso força o repositório a cada vez mais se igualar ao ORM;</li><li>Instâncias do Models do Eloquent não devem ser retornadas pela API do repositório. Para coleções, arrays devem ser retornados e, para objetos, Plain Old PHP Objects.</li></ol><p>Poderia fazer algumas outras considerações, mas, pra mim, essas são fortes o bastante para classificar o exemplo como um mau exemplo.</p><h3>Tá… Mas qual seria o jeito certo, então?</h3><p>É simples! Criar repositórios do jeito certo, é mais fácil que criá-los do jeito errado. Um repositório só precisa, basicamente:</p><ol><li>Possuir uma interface bem definida;</li><li>Não ser ou estender classes abstrata (mais uma vez, genérico não… hahahaha);</li><li>Possuir métodos que dizem claramente o que fazem e refletem regras de negócio da sua aplicação, ao invés de utilizar nomes genéricos ou pouco descritivos (Se você pensou em linguagem ubíqua aqui, você tá entendendo);</li><li>Não ser responsável por instanciar os models; e</li><li>Não retornar Eloquent Models. Ao invés disso, retornar arrays ou Plain Old PHP Objects que não possuam o poder de auto-salvamento;</li></ol><h3>Vamos ao exemplo</h3><p>Primeiramente, você pode criar o model que irá ficar responsável pelo armazenamento dos dados, recebendo-os do repositório e enviando-os para a infraestrutura. Não utilizá-lo é uma questão de escolha. Você pode optar por trabalhar diretamente com o QueryBuilder, ao invés de ter uma instância de UserModel, por exemplo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8cf32acbca37daf956434a4a1a01eb5b/href">https://medium.com/media/8cf32acbca37daf956434a4a1a01eb5b/href</a></iframe><p>Em seguida, criaríamos uma interface do nosso repositório poderia ser semelhante a esta:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bffa982c17ce65d0e42c1df10fc98df3/href">https://medium.com/media/bffa982c17ce65d0e42c1df10fc98df3/href</a></iframe><p>Observe que na assinatura do método construtor, ele espera UserModel e os métodos createNewUser e updateUserById recebem como primeiro parâmetro $user do tipo User.</p><p>User é o nosso Plain Old PHP Object. Será com sua utilização que criaremos o bloqueio de acesso aos dados do UserModel pelas camadas que estiverem acima do repositório.</p><p>Lembre do que mencionei lá em cima, <strong><em>“o repositório deve ser a única camada de acesso aos dados”</em></strong>. Desta forma, garantimos a segurança e o controle do acesso aos dados e, ao mesmo tempo, garantimos também que novos usuários não sejam criados com instâncias de Clientes, por exemplo.</p><p>Conheça, então, o usuário que será visto fora do repositório.</p><p>Como é a proposta, ele é simples e pouco extensivo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/66863eb7d01e49581cdd6abadfab99db/href">https://medium.com/media/66863eb7d01e49581cdd6abadfab99db/href</a></iframe><p>Por fim, o repositório:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8c9cf1b07a6551009afadb95ba528673/href">https://medium.com/media/8c9cf1b07a6551009afadb95ba528673/href</a></iframe><h3>Conclusão</h3><p>Como você viu, a implementação do Pattern não é uma tarefa difícil, embora pareça trabalhosa. Há casos que alguns desenvolvedores preferem violar um pouco o padrão e construi uma classe abstrata que faça trabalhos os mais repetitivos, como os de CRUD.</p><p>Essa é uma licença poética que pode ser permitida, dependendo do nível de maturidade e consciência da equipe. Eu prefiro não fazer; outros preferem criar ou até mesmo utilizar pacotes mais enxutos para tal tarefa; então fica a seu critério.</p><p>Espero que você tenha entendido e que essa publicação te ajude na construção dos seus próprios repositórios.</p><p>Se existirem dúvidas, deixa um comentário.</p><p>Se não for pedir muito, deixa um “clap” aí. Esse é o parâmetro que tenho para medir a qualidade e a relevância do conteúdo.</p><h3>Referências</h3><p>Queria deixar registrado aqui o meu agradecimento ao <a href="https://www.facebook.com/groups/laravelbrasil/">grupo do Laravel Brasil no Facebook</a> e ao grupo do <a href="https://github.com/laravelbrasil/forum">Laravel Brasil no Github</a>. As discussões e a anatomia desses grupos me ajudaram muito não só na construção desta publicação, como também na postura que assumi diante da comunidade. Não consigo mensurar o quanto aprendi, não só fazendo perguntas, mas distribuindo o conhecimento que adquiri. Muito obrigado!</p><p>Queria agradecer também ao <a href="https://medium.com/u/5eb02d2049ce">Paulo Freitas</a> pelo suporte que sempre me deu e por tanta dedicação para construção das respostas bem elaboradas que estão nas referências que listo abaixo. Obrigado, Paulo. Tu é o cara! hahaha</p><p><strong>Principais Referências</strong></p><ul><li><a href="https://laracasts.com/discuss/channels/general-discussion/reasons-i-abondoned-repository-pattern-in-laravel?page=1">Reasons I abandoned repository pattern in Laravel</a></li><li><a href="https://github.com/laravelbrasil/forum/issues/126">Repositories Methods vs Services Classes · Issue #126 · laravelbrasil/forum</a></li><li><a href="https://github.com/laravelbrasil/forum/issues/23">Repositories · Issue #23 · laravelbrasil/forum</a></li><li><a href="https://medium.com/by-vinicius-reis/repository-pattern-n%C3%A3o-precisa-ser-chato-principalmente-com-laravel-d97235b31c7e">Repository Pattern não precisa ser chato, principalmente com Laravel</a></li><li><a href="https://martinfowler.com/eaaCatalog/repository.html">Repository</a></li><li><a href="https://martinfowler.com/bliki/CQRS.html">bliki: CQRS</a></li><li><a href="https://laracasts.com/series/whip-monstrous-code-into-shape/">Whip Monstrous Code Into Shape</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d739ecaf544e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/laraveltips/voc%C3%AA-entende-repository-pattern-voc%C3%AA-est%C3%A1-certo-disso-d739ecaf544e">Você entende Repository Pattern? Você está certo disso?</a> was originally published in <a href="https://medium.com/laraveltips">LaravelTips</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Refatorando métodos com Method Object]]></title>
            <link>https://medium.com/laraveltips/refatorando-m%C3%A9todos-com-method-object-ae746c5c5ee1?source=rss----1ac5836ec91a---4</link>
            <guid isPermaLink="false">https://medium.com/p/ae746c5c5ee1</guid>
            <category><![CDATA[refactoring]]></category>
            <category><![CDATA[method-object]]></category>
            <dc:creator><![CDATA[Mauricio Rodrigues]]></dc:creator>
            <pubDate>Thu, 14 Jun 2018 18:20:12 GMT</pubDate>
            <atom:updated>2018-06-14T18:47:08.636Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8Gy2mvR7MdVop-GDzvlK6g.jpeg" /></figure><p>Substitua seus métodos longos e complexos por Method Objects</p><p>Em algum momento da sua vida (e da aplicação), você vai precisar aplicar técnicas de refatoração de código e, diferente do que muita gente sente/pensa sobre isso, eu, particularmente, gosto de quando esta necessidade surge, pois, pra mim, ela representa o amadurecimento do conhecimento.</p><p>Uma das técnicas de refatoração interessante é o <strong>Method Object</strong>. Essa técnica consiste em decompor o método em um objeto, transformando suas variáveis locais em atributos de um novo objeto de um método.</p><p>Observe o diagrama na imagem a seguir retirada <a href="https://refactoring.com/catalog/replaceMethodWithMethodObject.html">desta publicação do Martin Fowler</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/523/1*WOQAcIYUoPXGTtLY4nhluQ.png" /></figure><p>Uma classe Order possui um método price() que computa o preço de uma Order. No exemplo acima, a refatoração foi aplicada criando uma classe PriceCalculator. Observe que as variáveis locais se tornaram atributos e a classe ganha um novo método compute() que lida com o cálculo.</p><h3>Quando utilizar Method Objects?</h3><p>Eu compartilho do pensamento do Martin Fowler, que diz que sempre não seja possível aplicar <strong>Extract Method</strong>, aplique <strong>Method Object</strong>.</p><blockquote><a href="https://medium.com/u/d587e670d7b8">Dorian Neto</a> <a href="http://dorianneto.com.br/refatoracao/refatorando-codigo-com-extract-method/">escreveu em seu blog</a> um artigo bem bacana sobre Extract Method. Dá uma conferida lá!</blockquote><h3>Aplicando Method Objects em projetos Laravel</h3><p>Vamos trazer o conceito mais para a realidade de projetos Laravel. A seguir, tempos uma classe DbCouponRepository que implementa um método getAllCoupons. Este método é responsável pela recuperação de todos os coupons, baseado no critério especificado.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a3e898af1f2c86054a49be64c35577f0/href">https://medium.com/media/a3e898af1f2c86054a49be64c35577f0/href</a></iframe><p>Observe que o método é bem extenso e possui uma certa complexidade. Ele possui um desvio condicional que podem filtrar registros por palavra-chave; faz um <em>join</em> em plans; faz um parse dos dados, para retornar uma instância de coupons (<a href="https://medium.com/@zabaala/voc%C3%AA-entende-repository-pattern-voc%C3%AA-est%C3%A1-certo-disso-d739ecaf544e">Você pode saber mais sobre isso aqui</a>); e retorna uma os resultados paginados.</p><p>Esse método, simplesmente por sua responsabilidade e extensão, já pode ser transformado num Method Object e é o que faremos agora.</p><p>Primeiro vamos nos atentar às determinações da interface CouponRepositoryInterface. O método getAllCoupons() recebe dois parâmetros. O primeiro, quando não for nulo, deve possuir uma string que irá filtrar os registros por ela. O segundo é um array com informações sobre a ordenação dos registros. Por fim, o método deve retornar uma instância de LengthAwarePaginator:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c4ff6bd829e7bf9acbed84c7a1896efe/href">https://medium.com/media/c4ff6bd829e7bf9acbed84c7a1896efe/href</a></iframe><p>Ciente disso, vamos a nossa refatoração. Primeiro vamos criar uma nova classe FetchAllCouponsMethodObject:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f6d05b9520bbdf469e71fd6dd5681884/href">https://medium.com/media/f6d05b9520bbdf469e71fd6dd5681884/href</a></iframe><p>Feito isso, já podemos utilizar nosso Method Object em DbCouponRepository:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bd2a85b4c138e9d7b8c6b494c6fe65d1/href">https://medium.com/media/bd2a85b4c138e9d7b8c6b494c6fe65d1/href</a></iframe><p>Simples, não?! :)</p><h3>Conclusão</h3><p>A utilização desta técnica é bem interessante para evitar classes infladas.</p><p>Um outro ponto bastante importante é que, nesse caso, <strong>FetchAllCouponsMethodObject</strong> é um Method Object de <strong>DbCouponRepository. </strong>Sabendo que repositórios fazem parte do serviço de domínio, e não do serviço de aplicação, você não deve acessar o Method Object diretamente, sem passar pelo repositório, okay? Method Objects não são Services.</p><p>Fico por aqui.</p><p>Gostou? Deixa seu comentário aqui em baixo.</p><p>Um abraço e até a próxima publicação!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ae746c5c5ee1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/laraveltips/refatorando-m%C3%A9todos-com-method-object-ae746c5c5ee1">Refatorando métodos com Method Object</a> was originally published in <a href="https://medium.com/laraveltips">LaravelTips</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Domínios no Laravel]]></title>
            <link>https://medium.com/laraveltips/dom%C3%ADnios-no-laravel-bc73f025c95d?source=rss----1ac5836ec91a---4</link>
            <guid isPermaLink="false">https://medium.com/p/bc73f025c95d</guid>
            <category><![CDATA[domains]]></category>
            <category><![CDATA[laravel]]></category>
            <category><![CDATA[subdomain]]></category>
            <category><![CDATA[custom-routes]]></category>
            <dc:creator><![CDATA[Mauricio Rodrigues]]></dc:creator>
            <pubDate>Thu, 14 Jun 2018 18:19:36 GMT</pubDate>
            <atom:updated>2018-06-14T18:35:43.258Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FUz-l8Ablh13VxtqkFdf1Q.jpeg" /></figure><p>Usando domínios no ambiente de desenvolvimento e no ambiente de produção.</p><p>Recentemente, precisei fazer a separação de uma aplicação por domínios. Diferente de como a documentação do <a href="https://laravel.com/docs/5.5/routing#route-group-sub-domain-routing">Laravel</a> propõe, eu não podia usar wildcards, já que não estaria lidando somente com aliases para usuários, mas, sim, com sub-domínios que apontam para aplicações diferentes.</p><h3>O problema</h3><p>Colocar as rotas em produção é um problema fácil de resolver. Como a própria documentação sugere, basta “envolver” as rotas atuais com Route::domain(‘…’) e tudo se resolverá. Algo como isso:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7ef961f4d807e8c46c951860faf7722c/href">https://medium.com/media/7ef961f4d807e8c46c951860faf7722c/href</a></iframe><p>Neste caso, a aplicação em produção irá funcionar perfeitamente, <strong>mas como continuar trabalhando com o mesmo domínio no ambiente de desenvolvimento?</strong></p><p>Para este caso, basta usar as informações do seu ambiente. Comumente, o nosso .env define <strong>APP_ENV=local</strong> para o ambiente local e <strong>APP_ENV=production </strong>para o ambiente de produção.</p><p>Ciente disso, podemos pegar esta informação do ambiente e e customizar a configuração da rota, deixando-a assim:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/459ccaaf4e4b50b572234a9ea3d6c6a8/href">https://medium.com/media/459ccaaf4e4b50b572234a9ea3d6c6a8/href</a></iframe><p>Observe que não utilizo env(‘APP_ENV’) para pegar a informação do ambiente. Respeitando às determinações do Laravel, essas informações são recuperadas das configurações, através do helper conf(‘…’).</p><blockquote><strong>TIP:</strong> As informações do ambiente não devem ultrapassar a barreira das configurações. Se ultrapassarem, essa informação poderá não ter sua entrega garantida. Mas, no caso específico do ambiente, há uma possibilidade de usar (App::environment(&#39;local&#39;), mas não há o mesmo para as outras informações.</blockquote><p>Feito isso, pra concluir, basta vc adicionar uma entrada ao seu arquivo de hosts, que aponte para o domínio local. Algo como:</p><p><strong>127.0.0.1 app.system.local</strong></p><p>Acesse o domínio pelo browser <em>voilà</em> e tudo estará funcionando perfeitamente.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bc73f025c95d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/laraveltips/dom%C3%ADnios-no-laravel-bc73f025c95d">Domínios no Laravel</a> was originally published in <a href="https://medium.com/laraveltips">LaravelTips</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>