<p>Two days ago I released the first major version in almost 2 years for <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-web-client">shlink-web-client</a>, a web UI for <a target="_blank" rel="noopener noreferrer" href="https://shlink.io">shlink</a>, my self-hosted URL shortener.</p><p>This new version introduces several improvements to the project, and I thought it was worth writing a post to explain all of them in depth.</p><h3>New design</h3><p>The project has been using the same design almost since the beginning. It was clean, but it laked a bit of contrast and consistency in many sections.</p><p>Now the main background is light-gray, with components composed in white cards with a slight box shadow, that makes them easier to spot inside the app.</p><p>Also, the main area has now a max-width that prevents components from stretching too much on wide screens.</p><div class="row"><div class="col-md-6  "><img alt="Before" src="/assets/img/shlink-web-client-3/design-before.png" class="gallery-item"/><p class="text-center"><small>Before</small></p></div><div class="col-md-6  "><img alt="After" src="/assets/img/shlink-web-client-3/design-after.png" class="gallery-item"/><p class="text-center"><small>After</small></p></div></div><h3>Overview page</h3><p>Up until now, after connecting to a Shlink server, you went directly to the list of short URLs.</p><p>With this new version, you now see an overview page first, which displays some general stats, a quick short URL creation form, and the latest 5 short URLs.</p><p>From there, you can navigate to the full list of short URLs, with filtering capabilities, or go to the advanced short URL creation form.</p><div class="row"><div class="col-md-8 col-md-offset-2 "><img alt="Overview" src="/assets/img/shlink-web-client-3/overview.png" class="gallery-item"/><p class="text-center"><small>Overview</small></p></div></div><h3>Improved short URL creation form</h3><p>One of the sections with more room for improvement was the short URL creation form. It had all the inputs mixed, displaying just the &quot;long url&quot; one, with the option to un-collapsing the rest at will.</p><p>The new design groups the inputs by context, which makes it more clear. It also displays the inputs all the time, since the &quot;quick form&quot; is now located in the overview page.</p><div class="row"><div class="col-md-6  "><img alt="Before" src="/assets/img/shlink-web-client-3/creation-form-before.png" class="gallery-item"/><p class="text-center"><small>Before</small></p></div><div class="col-md-6  "><img alt="After" src="/assets/img/shlink-web-client-3/creation-form-after.png" class="gallery-item"/><p class="text-center"><small>After</small></p></div></div><h3>Enhanced visits page</h3><p>The visits page had a problem, it was trying to display too much information in a single place.</p><ul><li>Visits over time</li><li>Visits from every platform</li><li>Visits from every location</li><li>A list of visits as a table</li></ul><p>The new approach splits those in subsections with their own sub-route each (<code>/by-location</code>, <code>/by-context</code>, etc). This helps to render a smaller amount of charts at once, since they are a bit CPU greedy.</p><p>Also, only the visits from the last 30 days are loaded by default, making it load way faster for URLs with a lot of visits.</p><div class="row"><div class="col-md-6  "><img alt="Before" src="/assets/img/shlink-web-client-3/visits-before.png" class="gallery-item"/><p class="text-center"><small>Before</small></p></div><div class="col-md-6  "><img alt="After" src="/assets/img/shlink-web-client-3/visits-after.png" class="gallery-item"/><p class="text-center"><small>After</small></p></div></div><h3>Outer sections</h3><p>The app has some sections which are not related to a specific server, like creating/editing servers, or the settings page.</p><p>These sections have also been adapted to the new style, and they also have a max-width for wide screens.</p><div class="row"><div class="col-md-6  "><img alt="Before" src="/assets/img/shlink-web-client-3/create-server-before.png" class="gallery-item"/><p class="text-center"><small>Before</small></p></div><div class="col-md-6  "><img alt="After" src="/assets/img/shlink-web-client-3/create-server-after.png" class="gallery-item"/><p class="text-center"><small>After</small></p></div></div><h3>Date range selector</h3><p>A new component allows selecting date ranges either by relative time ranges (last 30 days, last 90 days...) or by selecting absolute start and end dates.</p><p>This component is used to filter both short URL lists and visits lists.</p><div class="row"><div class="col-md-6  col-md-offset-3"><img alt="Date range selector" src="/assets/img/shlink-web-client-3/date-range-selector.png" class=""/><p class="text-center"><small>Date range selector</small></p></div></div><h3>Domain selector</h3><p>Shlink has had multi-domain support for some versions, but changing the domain from the web client required to set the value manually, which is a bit error-prone.</p><p>This version introduces a new component which allows selecting from domains already used in the past (which is what you will want in most of the cases), preventing accidental typos.</p><p>It also allows setting new values in case you want to use a new domain that you never used before. This domain will then appear in the list the next time.</p><div class="row"><div class="col-md-6  "><img alt="Existing domains" src="/assets/img/shlink-web-client-3/domains-existing.png" class=""/><p class="text-center"><small>Existing domains</small></p></div><div class="col-md-6  "><img alt="New domain" src="/assets/img/shlink-web-client-3/domains-new.png" class=""/><p class="text-center"><small>New domain</small></p></div></div><h3>Other improvements</h3><p>The changes described so far were the major ones. However, v3.0.0 includes a few other minor improvements.</p><ul><li>Result and loading messages have been standardized: They are now more consistent and use the same set of components, which also ensures consistency in the future.</li><li>Error messages are now more descriptive: Instead of showing generic error messages when API calls fail, the actual error message is now always displayed, so that it&#x27;s easier to know what failed.</li><li>Dropped support for Shlink v1: All major versions come with some breaking changes that improve code maintainability. This one drops Shlink v1 support, which allows removing some conditional paths here and there.</li></ul><p>Other than the last point, Shlink v3.0.0 is mostly backwards compatible, so it&#x27;s safe to upgrade if you are already using Shlink v2.x</p><h3>Next steps</h3><p>Of course this doesn&#x27;t end here, and I have a lot of ideas to improve it even further.</p><ul><li>Dark theme: It&#x27;s what the cool kids do these days, and I have already done some experiments around it.</li><li>Shlink dashboard: Next gen web app for Shlink. You can read the whole reasoning in <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-web-client/issues/338">this issue</a>.</li><li>Filtering in lists added to URL: Many sections allow filtering lists, but the state is saved in memory, which means it gets lost if the page is refreshed, and it cannot be bookmarked. The intention is to make all filtering params to become part of the URL.</li><li>Exporting visits in CSV: It&#x27;s cool to see charts full of info, but sometimes admins need to feed other services with the data, and consuming the original API is not always an option. Exporting visits to a CSV file will be supported soon by shlink-web-client.</li></ul>

Released shlink-web-client v3.0.0

<p>Let&#x27;s not deny that <a target="_blank" rel="noopener noreferrer" href="https://github.com/features/actions">GitHub actions</a> are hitting hard in the tech community, and many projects are transitioning from other continuous integration systems like <a target="_blank" rel="noopener noreferrer" href="https://circleci.com/">Circle CI</a> or <a target="_blank" rel="noopener noreferrer" href="https://travis-ci.org/">Travis CI</a>.</p><p>Personally I have been using Travis a lot during the past years, for all my OSS projects, and I have gotten very used to it.</p><p>However, people seem to be &quot;abandoning&quot; travis in favor of GitHub Actions, for different reasons. &quot;It&#x27;s faster&quot;, &quot;I can run smaller tasks in parallel&quot;, etc.</p><p>In my case, I have moved a few very specific tasks there, where travis was becoming a bottleneck, but I still have mixed feelings about the very-verbose yaml-based config needed to configure a few GitHub Actions, compared to the more concise travis one.</p><p>In this article I&#x27;ll explain how I improved a travis build to run several smaller tasks in parallel jobs, without having to completely move away from it.</p><h3>Initial state</h3><p>This project&#x27;s travis config is relatively simple. It is used to build a JS project for the web browser, and it has to run the next tasks:</p><ul><li>Lint the code, to make sure it fulfils the project&#x27;s coding standards.</li><li>Run unit tests.</li><li>Run mutation tests.</li><li>Build the docker image, to make sure none of the new changes broke it.</li><li>Conditionally publish a release on GitHub, with a dist file attached to it, if the build is being run for a git tag.</li></ul><pre><pre><code class="language-yaml">dist: bionic

language: node_js

branches:
  only:
    - /.*/

cache:
  directories:
    - node_modules

services:
  - docker

node_js:
  - &#x27;12.16.3&#x27;

install: npm ci

before_script:
  - echo &quot;Building commit range ${TRAVIS_COMMIT_RANGE}&quot;
  - export MUTATION_FILES=$(git diff ${TRAVIS_COMMIT_RANGE:-origin/main} --name-only | grep -E &#x27;src\/(.*).(ts|tsx)$&#x27; | paste -sd &quot;,&quot;)

script:
  - npm run lint
  - npm run test:ci
  - npm run mutate:ci
  - docker build -t project:test .

after_success:
  - node_modules/.bin/ocular coverage/clover.xml

before_deploy: npm run build ${TRAVIS_TAG#?}

deploy:
  - provider: releases
    api_key:
      secure: &lt;key&gt;
    file: &quot;./dist/project_${TRAVIS_TAG#?}_dist.zip&quot;
    skip_cleanup: true
    on:
      tags: true
</code></pre></pre><h3>Problems with this approach</h3><p>This is more or less ok, but the last two commands in <code>script</code> can be relatively slow and can delay the whole process.</p><p>Also, specially the mutation tests one, which is currently always considered successful regardless the result, can make the build reach the maximum run time allowed by travis, making the whole build falsely fail.</p><blockquote><p>The reason for the <code>before_script</code> step is to determine which source code files changed, and run mutation tests on them only, in order to mitigate this.</p></blockquote><p>Other than this, the build config defines &quot;global&quot; customizations that are actually only used for some tasks:</p><ul><li>Running <code>npm ci</code> is not required for the <code>docker build</code> task.</li><li>Getting the <code>docker</code> service is not required by any of the other tasks.</li><li>Determining changed files is only used by the <code>mutation tests</code> task.</li></ul><h3>Making use of jobs</h3><p>One cool feature travis supports is the use of a job <a target="_blank" rel="noopener noreferrer" href="https://docs.travis-ci.com/user/build-matrix/">build matrix</a>, that lets you define multiple jobs that run in parallel as part of the same build, and make each one of them do unrelated tasks.</p><p>Using this feature it is possible to improve the <code>.travis.yml</code> file, making it look like this:</p><pre><pre><code class="language-yaml">dist: bionic

language: node_js

branches:
  only:
    - /.*/

cache:
  directories:
    - node_modules

node_js:
  - &#x27;12.16.3&#x27;

jobs:
  fast_finish: true
  allow_failures:
    - name: &#x27;Mutation tests&#x27;
  include:

    - name: &#x27;Lint&#x27;
      install: npm ci
      script: npm run lint

    - name: &#x27;Unit tests&#x27;
      install: npm ci
      script: npm run test:ci
      after_success:
        - node_modules/.bin/ocular coverage/clover.xml

    - name: &#x27;Mutation tests&#x27;
      install: npm ci
      before_script:
        - echo &quot;Building commit range ${TRAVIS_COMMIT_RANGE}&quot;
        - export MUTATION_FILES=$(git diff ${TRAVIS_COMMIT_RANGE:-origin/main} --name-only | grep -E &#x27;src\/(.*).(ts|tsx)$&#x27; | paste -sd &quot;,&quot;)
      script: npm run mutate:ci

    - name: &#x27;Build docker image&#x27;
      services:
        - docker
      install: skip
      script: docker build -t project:test .

    - name: &#x27;Publish release&#x27;
      if: tag IS present
      install: skip
      script: skip
      before_deploy: npm run build ${TRAVIS_TAG#?}
      deploy:
        - provider: releases
          api_key:
            secure: &lt;key&gt;
          file: &quot;./dist/project_${TRAVIS_TAG#?}_dist.zip&quot;
          skip_cleanup: true
          on:
            tags: true
</code></pre></pre><p>This approach introduces all these benefits:</p><ul><li>Now linting, testing, mutation testing and building the docker image run in parallel, making the build finish earlier.</li><li>The mutation testing step is allowed to fail, and thanks to the <code>fast_finish</code> flag, travis won&#x27;t even wait for it to finish, considering the build successful once the rest have passed.</li><li>Configs that are only meaningful for certain jobs are defined in the job itself, instead of globally.</li><li>The &quot;publish release&quot; job only runs conditionally if the build is for a tag, thanks to the <code>if: tag IS present</code> condition. (More info about <a target="_blank" rel="noopener noreferrer" href="https://docs.travis-ci.com/user/conditional-builds-stages-jobs/">conditional jobs</a> in travis).</li><li>As soon as any of the jobs fails, the whole build fails and you don&#x27;t have to continue waiting. Before this, if the third task failed, you still had to wait for the previous two to finish.</li><li>Each job can have a name, making it more clear in travis UI what tasks are being run:</li></ul><p><img src="/assets/img/travis-multiple-jobs/travis-jobs.png" alt="Travis CI jobs"/></p><h3>Conclusion</h3><p>The main purpose of this article was to showcase that travis still has a lot to give. Github Actions are definitely cool, but there&#x27;s usually no silver bullet for everything, and a combination with other tools might be more suitable.</p><p>Also, this allows people using travis to improve their builds without having to change everything. Then, once you have split your tasks, if you still want to move to Github Actions, it should be easier.</p><blockquote><p>If you are curious, this is the project in which I use this travis configuration: <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-web-client">shlinkio/shlink-web-client</a>.</p></blockquote>

Running several steps of a Travis CI build in parallel

<p>Asynchronous and non-blocking runtimes are pretty usual in many programming languages, as well as long-lived web apps that stay in memory and are capable of dispatching multiple HTTP requests without having to be fully bootstrapped every time. This has not been traditionally the case with PHP apps. </p><p>However, many projects are starting to get some adoption, that bring this long-lived approach to the PHP world.</p><p>The problem with this is that PHP developers are not used to this, and they tend to continue acting as they have always done. Also, libraries might have made some assumptions, making them not work as expected when used under this context.</p><p>Some of these projects are <a target="_blank" rel="noopener noreferrer" href="https://www.swoole.co.uk">swoole</a>, <a target="_blank" rel="noopener noreferrer" href="https://reactphp.org/">ReactPHP</a> or <a target="_blank" rel="noopener noreferrer" href="https://amphp.org/">Amphp</a>, to give some examples.</p><p>In this article, I will be focusing on the first one, and explain how to approach some of the pain points I have found after using it for a year and a half on an <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink">existing PHP project</a>.</p><h3>Introducing Swoole</h3><p>The main difference swoole has compared to other similar projects is that it&#x27;s written as a native PHP extension, and needs to be installed with <code>pecl</code>.</p><p>This is obviously a bit cumbersome, but the benefit is that, since it&#x27;s written in C++, it has a better handling of memory allocation, which is very important to achieve what it tries to do.</p><p>What swoole does is running a main process which bootstraps the PHP application once, and then keeps it in memory so that it can continue dispatching requests without having to load resources every time. This makes it really fast.</p><p>Those HTTP requests are handled by a set of child processes called &quot;web workers&quot;. Swoole forks the contents in memory for the main process to each one of the workers, so each worker has a &quot;copy&quot; of the application in memory.</p><p>Each worker is independent, but each one of them can only handle one request at a time, so you have to increase the number of workers if you expect a lot of concurrent traffic.</p><p>Other than web workers, swoole also has another set of child processes called &quot;task workers&quot;, which can be used to delegate long tasks at runtime to prevent web workers from getting blocked.</p><p>Here you can see a diagram of swoole&#x27;s architecture.</p><p><img src="https://www.swoole.co.uk/images/how-swoole-works.png" alt="How Swoole works"/></p><blockquote><p>More information can be found in <a target="_blank" rel="noopener noreferrer" href="https://www.swoole.co.uk/how-it-works">Swoole&#x27;s website</a>.</p></blockquote><h3>Problems to solve</h3><p>Now that we know how swoole works, let&#x27;s see some of the challanges I have faced in th past, which are usually not that ovbious when you are used to think in terms of &quot;blocking&quot; and &quot;short-lived&quot;.</p><h4>Database connections are kept open</h4><p>One of the first things you find out is that, since the application stays in memory, any database connection that has been opened by a worker (either web or task worker), will be kept open and reused in subsequent executions or HTTP requests served by the app.</p><p>This, which is in theory good, has a side effect, which is not obvious during development: <strong>the opened connection will eventually expire</strong>.</p><p>Since most of the popular database abstraction layers in PHP are coming from the times in which PHP was just a bootstrap-on-every-request technology, they never cared too much about expired database connections, as they would be opened again on next request.</p><p>However, when using swoole and the like, you have to implement some mechanism which takes care of reconnecting or gracefully recovering when this happens.</p><blockquote><p>I wrote an article explaining how I solved this on a middleware-based app served with swoole and using doctrine: <a href="/2019/11/04/how-to-properly-handle-a-doctrine-entity-manager-on-an-expressive-application-served-with-swoole/">How to properly handle a doctrine entity manager on an expressive application served with swoole</a></p></blockquote><p>Obviously, swoole (and also others) provides some tools to work with databases (like this <a target="_blank" rel="noopener noreferrer" href="https://www.swoole.co.uk/docs/modules/swoole-async-mysql-client">MySQL client</a>), which I&#x27;m sure do not have this problem (although, I haven&#x27;t personally tried this), but they are more limited than other well adopted libraries.</p><h4>In-memory caches don&#x27;t behave as expected</h4><p>It is a frequent practice to use local in-memory caches, like APCu, to improve applications performance in production.</p><p>Usually APCu is faster than other options, like redis or memcached, so it&#x27;s the choice when you only have one instance of your app running (meaning, you don&#x27;t have a cluster behind a load balancer).</p><p>However, even if you are running your app on just one server with swoole, because of the web worker system explained earlier, you actually have several copies of your app in memory, and each one of them will have a separated and not shared cache when using APCu.</p><p>This can lead to inconsistencies which are hard to debug, so you need to have it in mind.</p><p>Also, since the information that is being loaded is kept in memory anyway, you will not notice such a big improvement by using APCu or other in-memory caches.</p><blockquote><p>Notice that this problem does not happen when using distributed/centralized caching solutions, such as redis or memcached, as in that case, the caching technology is shared by all workers.</p></blockquote><h4>No need to optimize file including/requiring</h4><p>Many projects have complex configuration systems which are spread into several files. While this make it more maintainable, it also has a performance impact when all those files need to be loaded on every request.</p><p>Because of that, there are libraries like <a target="_blank" rel="noopener noreferrer" href="https://github.com/laminas/laminas-config-aggregator">laminas-config-aggregator</a> that can dynamically load config from many sources and, if some conditions are met, they can merge the result in a single bigger file that can be used in later requests.</p><p>In the case of swoole, as all the files will be kept in memory once loaded for the first time, there&#x27;s no need for this kind of optimization.</p><h4>Class autoloading happens once</h4><p>This point is very related with the previous one.</p><p>Composer offers a lot of optimization options so that class autoloading is faster in production. While you usually will still want to use some of those so that the first time a class is being loaded it is still reasonably fast, any subsequent hits will just use the class which is already in memory.</p><p>One of the composer flags you will probably don&#x27;t want use with swoole is <code>--apcu-autoloader</code>, because of the reasons mentioned two points above this one.</p><h4>Services should be truly stateless</h4><p>This is something that you should always do anyway, but it&#x27;s specially important when a service instance is kept in memory between HTTP requests.</p><p>Sometimes it&#x27;s easy to end up having some small piece of internal state on a service, where we save something as a side effect of a method call, to end up using it when another one of the public methods is invoked.</p><p>While this could seem harmless when the whole app is bootstrapped on every request, it can have very dangerous side effects when the app is served with swoole, because the instance will persist until another request is dispatched by the same web worker.</p><p>Just imagine you saved some user data on a service, and it ends up being served to another user on the next request. That won&#x27;t look good.</p><p>Because of this, make sure your services are truly stateless, and if for any reason that&#x27;s not possible, at least remember to have some mechanism in place that flushes the data just before finishing the request.</p><h4>Hot reloading for dev envs is not that good</h4><p>One thing we usually take for granted is that we can modify a PHP file and just by making a new request, the new code will be executed. However, when the code is kept in memory, it&#x27;s not that straightforward.</p><p>When you are developing a project which is served with swoole, you will have to restart the server every time to get your changes applied.</p><p>Swoole has a mechanism to do a light server reload, which is faster. You can find the docs in <a target="_blank" rel="noopener noreferrer" href="https://www.swoole.co.uk/docs/modules/swoole-server-reload">it&#x27;s website</a>.</p><p>The problem with this is that you need to implement the mechanism to invoke that when a file is changed, or use some library that does it for you.</p><p>Also, I have noticed that even calling that and seeing that the server is reloaded, does not always have the expected effect, and you have to still end up doing a hard reload. It&#x27;s something I don&#x27;t fully understand and I still need to investigate a bit further.</p><h3>Conclusion</h3><p>As it always happens when new technologies appear, it takes some time to get used to them, but I strongly suggest you to give a try to swoole or any other non-blocking runtime, because it makes your apps super fast.</p><p>Just remember to have all of the above in mind ;-)</p><p>That said, here you can find some libraries that will make your life easier when trying to serve existing projects with swoole, without having to couple with it and being able to continue using your favourite framework:</p><ul><li>IDE helper: <a target="_blank" rel="noopener noreferrer" href="https://github.com/swoft-cloud/swoole-ide-helper">https://github.com/swoft-cloud/swoole-ide-helper</a></li><li>Mezzio (formerly Zend Expressive): <a target="_blank" rel="noopener noreferrer" href="https://github.com/mezzio/mezzio-swoole">https://github.com/mezzio/mezzio-swoole</a></li><li>Symfony: <a target="_blank" rel="noopener noreferrer" href="https://github.com/k911/swoole-bundle">https://github.com/k911/swoole-bundle</a></li><li>Laravel: <a target="_blank" rel="noopener noreferrer" href="https://github.com/swooletw/laravel-swoole">https://github.com/swooletw/laravel-swoole</a></li></ul><p>Also, here you can find some more articles talking about this topic:</p><ul><li><a target="_blank" rel="noopener noreferrer" href="https://www.zend.com/blog/why-you-should-use-asynchronous-php">https://www.zend.com/blog/why-you-should-use-asynchronous-php</a></li><li><a target="_blank" rel="noopener noreferrer" href="https://samsonasik.wordpress.com/2020/04/05/using-swoole-in-mezzio-application-with-sdebug/">https://samsonasik.wordpress.com/2020/04/05/using-swoole-in-mezzio-application-with-sdebug/</a></li></ul>

Considerations when working with async PHP runtimes like swoole

<p>Some of you probably know that I have a pet project in which I like to work from time to time. This project is a self-hosted URL shortener called <a target="_blank" rel="noopener noreferrer" href="https://shlink.io">Shlink</a>.</p><p>Shlink is built using expressive as the base framework for the HTTP-dispatching task. A while ago, an expressive module was released to officially support serving expressive apps with <a target="_blank" rel="noopener noreferrer" href="https://www.swoole.co.uk/">swoole</a>, and I decided to include it on Shlink.</p><h3>How does swoole work?</h3><p>Swoole is an asynchronous non-blocking I/O framework which works in a similar way as node.js, but for PHP apps.</p><p>It has been conceived in a way that the app stays in memory between requests, removing the bootstrapping step and making apps to be served much faster.</p><p>Swoole can serve as many simultaneous requests as you tell it to. For this it makes use of workers. Each worker can serve one request at a time, and every worker has a separate instance of the app loaded in memory (this is something I <a target="_blank" rel="noopener noreferrer" href="https://twitter.com/dominikzogg/status/1189403552399134720">learned recently</a>).</p><p>Because of this, you have to sometimes change a bit the way you design your code. For example, if a service needs to be stateful (it shouldn&#x27;t, but shit happens), you will have to remember that the state will persist between requests, and you will want to somehow reset it to avoid unexpected side effects.</p><h3>How does this affect the EntityManager?</h3><p>One of the main services that keeps this internal state in Shlink is the doctrine <a target="_blank" rel="noopener noreferrer" href="https://www.doctrine-project.org/projects/doctrine-orm/en/current/tutorials/getting-started.html#obtaining-the-entitymanager">EntityManager</a>.</p><p>Due to the fact that it was originally designed to be used on a classical web server + CGI context, assuming it would be recreated on every request, there are a few considerations to take into account:</p><ul><li>It implements the unit of work pattern. It internally keeps track of all the entities that have been created/changed until you decide to flush it.</li><li>If something fails, the <code>EntityManager</code> can get closed, which makes it unusable after that moment.</li><li>If the database connection expires, the <code>EntityManager</code> will not gracefully recover. Instead, it will fail, since it&#x27;s not aware of the connection not being usable, getting yourself in previous point.</li></ul><h3>How to workaround it</h3><p>I learned about these issues by try and error, by using it on the app and getting the failures. Now, I want to share how I workaround those issues.</p><p>The first one I faced was the one making the app unusable after the <code>EntityManager</code> was closed. In order to solve this I created a decorated instance (naming, an object implementing <code>EntityManagerInterface</code> which in turn was wrapping an actual <code>EntityManager</code>), which was making sure the wrapped instance was transparently recreated if at some point it was closed.</p><p>However, this caused some side effects, and I finally realized that it was better to make the <code>EntityManager</code> to have to be reopened from the outside, and only once per request (this is closer to how it would behave on a classical set-up).</p><p>That&#x27;s how I came up with the <code>ReopeningEntityManager</code> Shlink is currently using (as of v1.20.0):</p><pre><pre><code class="language-php">&lt;?php

declare(strict_types=1);

namespace Shlinkio\Shlink\Common\Doctrine;

use Doctrine\ORM\Decorator\EntityManagerDecorator;

class ReopeningEntityManager extends EntityManagerDecorator
{
    /** @var callable */
    private $createEm;

    public function __construct(callable $createEm)
    {
        parent::__construct($createEm());
        $this-&gt;createEm = $createEm;
    }

    public function open(): void
    {
        if (! $this-&gt;wrapped-&gt;isOpen()) {
            $this-&gt;wrapped = ($this-&gt;createEm)();
        }
    }
}
</code></pre></pre><blockquote><p>You can find the actual code in <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-common/blob/master/src/Doctrine/ReopeningEntityManager.php">shlink-common</a>.</p></blockquote><p>It just expects a factory that creates the actual <code>EntityManager</code>, and exposes an <code>open</code> public method which re-creates the wrapped instance if closed.</p><p>This method is called from a <a target="_blank" rel="noopener noreferrer" href="https://www.php-fig.org/psr/psr-15/">PSR-15</a> middleware which needs to be registered early in the middleware pipeline. It makes sure the method is called before the next middleware on the stack is invoked:</p><pre><pre><code class="language-php">&lt;?php

declare(strict_types=1);

namespace Shlinkio\Shlink\Common\Middleware;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Shlinkio\Shlink\Common\Doctrine\ReopeningEntityManager;

class CloseDbConnectionMiddleware implements MiddlewareInterface
{
    /** @var ReopeningEntityManager */
    private $em;

    public function __construct(ReopeningEntityManager $em)
    {
        $this-&gt;em = $em;
    }

    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        $this-&gt;em-&gt;open();

        try {
            return $handler-&gt;handle($request);
        } finally {
            $this-&gt;em-&gt;getConnection()-&gt;close();
            $this-&gt;em-&gt;clear();
        }
    }
}
</code></pre></pre><blockquote><p>Again, the code can be found in <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-common/blob/master/src/Middleware/CloseDbConnectionMiddleware.php">shlink-common</a></p></blockquote><p>This middleware also does two more things (this time, after calling the next middleware on the stack, and making sure it does it even if an exception is thrown).</p><ul><li>It first closes the database connection. By doing it so, we make sure the <code>EntityManager</code> will reconnect the next time it needs to interact with the database, and therefore, we avoid the &quot;expired connection&quot; issue.</li><li>Then it clears the <code>EntityManager</code> itself. This avoids memory leaks, and also prevents that any orphan/non-flushed entity &quot;transcends&quot; to the next request, solving the first problem.</li></ul><h3>Further considerations</h3><p>This approach has been working well so far, but it&#x27;s important to assume that the <code>EntityManager</code> was not really designed for this non-blocking kind of context.</p><p>You need to know that the worker making use of it will not be able to serve any request until the <code>EntityManager</code> finishes its job. Because of this you might want to increase the number of swoole workers.</p><p>Also, closing the DB connection on every request is not the most optimal approach. It would be perfect to have a connection pool that was able to recreate connections when expired, and to keep them open as long as possible for faster operations. However, the <code>EntityManager</code> was not designed for that, so it&#x27;s better to close it.</p><p>You also need a <code>callable</code> to pass to the <code>ReopeningEntityManager</code>. The way you solve this depends on your implementation and the dependencies you use.</p><p>In my case, in Shlink I make use of the <code>ServiceManager</code>, so I have a delegator factory which takes the actual factory and passes it to the <code>ReopeningEntityManager</code>:</p><pre><pre><code class="language-php">&lt;?php

declare(strict_types=1);

namespace Shlinkio\Shlink\Common\Doctrine;

use Psr\Container\ContainerInterface;

class ReopeningEntityManagerDelegator
{
    public function __invoke(ContainerInterface $container, string $name, callable $createEm): ReopeningEntityManager
    {
        return new ReopeningEntityManager($createEm);
    }
}
</code></pre></pre><blockquote><p>You can find the actual code in <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-common/blob/master/src/Doctrine/ReopeningEntityManagerDelegator.php">shlink-common</a>.</p></blockquote><h3>Conclusion</h3><p>I wanted to write this article as a recap for myself too, since I had to ask and investigate many times, and I couldn&#x27;t find a single source of truth explaining everything.</p><p>I hope that, if you ended up here, this article served you well.</p>

How to properly handle a doctrine entity manager on an expressive application served with swoole

<p>For a long time, I have been trying to include tests in every project in which I&#x27;ve worked on.</p><p>There are several types of automated tests (or what should actually be called <a target="_blank" rel="noopener noreferrer" href="https://abstracta.us/insights/guide-continuous-testing/automated-checks">automated checks</a>). From unit tests, integration and functional tests, to end-to-end tests.</p><p>Each one of them differs from the rest by the scope they try to cover. From small units of code which are tested completely detached from external dependencies, to a whole app which is tested as a black box like if an end consumer was using it.</p><p>I&#x27;m not going to deeply discuss the semantics behind this, or where an integration test ends and an end-to-end test starts, because it&#x27;s quite frequently a blurry line.</p><p>I want to focus on unit tests, and a frequently used practice (even in my own tests), which I have read (and felt) several times, it might not be the best approach.</p><blockquote><p>This article is not focused on any particular technology, since I have found this in a lot of different projects.</p></blockquote><h3>What&#x27;s a unit test</h3><p>According to <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Unit_testing">Wikipedia</a>, unit testing is a &quot;method by which individual units of source code [...] are tested to determine whether they are fit for use&quot;.</p><p>While this might look like a clear definition, it&#x27;s actually quite open because, what&#x27;s a &quot;unit&quot; in the context of unit testing?</p><p>Very often, in object oriented programming projects, people take a class as a unit to test, and create a unit test for every class. In other paradigms, like functional programming, you might consider a function as the unit to be tested, or a set of functions which you have decided to put together in a module.</p><p>This is not really important for the purpose of this article. What&#x27;s really important is to take into account that, in order to properly &quot;unit test&quot; a &quot;unit of source code&quot;, you have to do it by isolating it from any dependency of that unit.</p><p>One of the better ways to achieve this is by following the <strong><a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Dependency_inversion_principle">Dependency Injection Principle</a></strong>. Without it you will probably end up trying to hack yourself in order to detach a &quot;unit&quot; from its dependencies.</p><blockquote><p>You can find other articles about <a href="/tag/dependency-injection/">Dependency Injection</a> in my blog.</p></blockquote><h3>Replacing dependencies</h3><p>A very frequent practice when unit testing a unit of source code is to replace its dependencies with <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Test_double">test doubles</a>, in order to properly isolate every unit when testing it.</p><p>Test doubles are basically objects compatible with the dependencies of the subject under test, that are created just for the purpose of the test and have some useful capabilities, like capturing how they have been called, or what should they return when called.</p><p>When you use one of those test doubles to assert how they were called as part of the test itself, you are using them as &quot;spies&quot;.</p><h3>Over-trusting spies</h3><p>All this introduction and contextualization had a single purpose.</p><p>I find myself (and others) in the situation in which you prepare a test double to behave in a certain way, then you call your subject under test, and then assert that your expectations on how the test double was called are correct, by spying on it.</p><p>This sometimes feels wrong, since it seems you are testing the test double/s instead of the subject under test.</p><p>I have read many times that, in a unit test, we should not actually know the internal implementation of the subject under test, but only test that, based on certain input, the expected output is returned (so, trust its public API).</p><p>However, there are cases in which some function/method does not really have any output, and we can only verify everything is going right by spying on the test doubles.</p><p>So, at the end of the day, I have mixed feelings about this practice.</p><h3>Conclusion</h3><p>Sadly, I cannot state a clear conclusion. This is actually an open article, and I would love to get your point of view in the form of a <a href="#comments-box">comment</a>.</p><p>It would be great to see how others face this, if you use other kinds of test doubles instead of spies, or if you are just ok with the implications.</p>

Is spying on mocks a bad practice for unit tests?

<p>One of the trending topics in the PHP world nowadays is the one about microframeworks. It started some years ago with <a target="_blank" rel="noopener noreferrer" href="http://www.slimframework.com/">Slim</a> and <a target="_blank" rel="noopener noreferrer" href="http://silex.sensiolabs.org/">Silex</a>, but recently it has been an explossion of new microframeworks.</p><p>First, Slim&#x27;s team announced the third version of its own framework, which implemented the psr-7 HTTP standard by taking advantage of the middleware concept. The previos version works with Middleware too, but psr-7 looks to be designed to be used with middleware.</p><p>Then, Laravel launched the <a target="_blank" rel="noopener noreferrer" href="https://lumen.laravel.com/">Lumen</a> project, which is another microframework based on Laravel components, similar to Silex, which is based on Symfony components.</p><p>And finally, Zend framework&#x27;s team launched <a target="_blank" rel="noopener noreferrer" href="https://github.com/zendframework/zend-expressive">Zend Expressive</a>, which is similar to Slim 3 in the fact that it works with middleware and psr-7, built on top of <a target="_blank" rel="noopener noreferrer" href="https://github.com/zendframework/zend-stratigility">zend-stratigility</a> and <a target="_blank" rel="noopener noreferrer" href="https://github.com/zendframework/zend-diactoros">zend-diactoros</a>.</p><p>Recently, after playing with Slim 3 and Zend Expressive, I decided to use the last one to rebuild my website, which used to be a ZF2 application.</p><p>It is open source and you can find it <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/website-expressive">here</a>.</p><h3>Why microframeworks</h3><p>I have said several times that composer has completely changed PHP. Now it is possible to access to any package or component in any application, which is a really big advantage. You don&#x27;t have to stick to certain framework&#x27;s implementation if there is another one that you like better.</p><p>That&#x27;s made possible to start working with a framework that doesn&#x27;t have a solution for everything, and your poroject can still scale thanks to the fact that composer gives you access to almost anything.</p><p>There is where microframeworks have their power.</p><p>Also, having in mind that every time more and more packages depend on common abstractions (like the psr abstractions, psr-3 or psr-7, or the new <a target="_blank" rel="noopener noreferrer" href="https://github.com/container-interop/container-interop">container interop</a>), those small frameworks can work with many existing powerful components.</p><h3>Why Zend Expressive</h3><p>The first thing that I liked in Zend Expressive is that it doesn&#x27;t force you to use an implementaiton for common tasks. </p><p>The router, the templates engine and the service container are based on abstractions, which means that you can virtually use whichever fits you the most. It comes with support for two or three of each one, but you could integrate any third party component by implementing an interface.</p><p>Also, since this framework has been created by the ZF team, it comes with support for ZF2 components, which I am more used to. Specially I like to be able to use the <code>Zend\ServiceManager</code>, like in Slim 3.</p><h3>Configuration driven apps</h3><p>All of the microframeworks that I&#x27;ve already mentioned have something in common. They work on top of the main <code>Application</code> object, which usually implements methods to define routes and add middleware.</p><p>For example, in Slim 3, you can do something like this to dispatch a request:</p><pre><pre><code class="language-php">$app = new Slim\App();
$app-&gt;get(&#x27;/hello/:name&#x27;, function ($req, $res, $args) {
    echo &#x27;Hello, &#x27; . $args[&#x27;name&#x27;] . &#x27;!!&#x27;;
});
$app-&gt;run();
</code></pre></pre><p>The same thing can be done like this with Silex:</p><pre><pre><code class="language-php">$app = new Silex\Application(); 
$app-&gt;get(&#x27;/hello/{name}&#x27;, function ($name) use($app) { 
    return &#x27;Hello, &#x27; . $app-&gt;escape($name) . &#x27;!!&#x27;; 
}); 
$app-&gt;run(); 
</code></pre></pre><p>And also, with Expressive, you do it like this:</p><pre><pre><code class="language-php">$app = Zend\Expressive\AppFactory::create();
$app-&gt;get(&#x27;/hello/{name}&#x27;, function ($request, $response, $next) {
    $response-&gt;write(&#x27;Hello, &#x27; . $request-&gt;getAttribute(&#x27;name&#x27;) . &#x27;!!&#x27;);
    return $response;
});
$app-&gt;run();
</code></pre></pre><p>It is very similar in every case, and it is good enough for prototyping and small applications. However this is not my favourite approach. I prefer to use the service container as the <strong>main</strong> object, and fetch the <code>Application</code> in the front controller as a regular service. The best microframework to work like this is Expressive.</p><p>For example, in my website, the front controller looks like this.</p><pre><pre><code class="language-php">chdir(dirname(__DIR__));

// [...]

/** @var Interop\Container\ContainerInterface $container */
$container = include &#x27;config/container.php&#x27;;
/** @var Zend\Expressive\Application $app */
$app = $container-&gt;get(Zend\Expressive\Application::class);
$app-&gt;run();
</code></pre></pre><p>This approach allows me to define some configuration files that are consumed by factories while creating services, and the Application object is treated like another Service, injecting middlewares and routes from config files.</p><p>You don&#x27;t even have to define the factory yourself, since Expressive includes an <code>ApplicationFactory</code> that can be registered and it fetches the outstanding configuration for you.</p><p>Another cool thing in Expressive is that the <code>Application</code> itself is middleware, and so, it can pipe nested <code>Applications</code>. It also treats routes as a middleware that is registered to be resolved as a result of certain route, instead of being resolved for every route.</p><p>So, in Expressive, everything is middleware lazily fetched from a service container to dispatch HTTP requests.</p><h3>Router</h3><p>Currently, Expressive includes implementations to integrate with three routers. <a target="_blank" rel="noopener noreferrer" href="https://github.com/auraphp/Aura.Router">Aura.Router</a>, <a target="_blank" rel="noopener noreferrer" href="https://github.com/nikic/FastRoute">FastRoute</a> and <a target="_blank" rel="noopener noreferrer" href="https://framework.zend.com/manual/current/en/modules/zend.mvc.routing.html">ZF2 MVC router</a>. The first is used by default.</p><p>For small applications like my website, any of them should be good enough, but I needed routes to support optional params at the beginning of the path (the language). Neither Aura.Router or FastRoute do it, so I had to stick with ZF2&#x27;s router in combination with a custom Segment route that allows to skip certain parts of the route, otherwise I would have been forced to define the same route with different names, which would have made assembling routes with param inheritance much harder.</p><p>The fun thing is that Slim&#x27;s router does support optional route params at the beginning of the path, at least in version 2. Maybe I try to integrate it in the future with Expressive, since I don&#x27;t need all the power provided by ZF2&#x27;s router.</p><blockquote><p><strong>Update 2015-09-20:</strong> I have finally created a Slim&#x27;s router integration library and I&#x27;m now using it. You can find it here <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/expressive-slim-router">https://github.com/acelaya/expressive-slim-router</a>.</p></blockquote><p>To make a router other than Aura.Router to be automatically injected in the Applicaiton when using the container&#x27;s <code>ApplicationFactory</code>, you need to register a service with the <code>Zend\Expressive\Router\RouterInterface</code> name.</p><h3>Template engine</h3><p>Similarly to the routers, Expressive works with an abstraction layer which eases the task of using any template engine with it. It comes with <a target="_blank" rel="noopener noreferrer" href="http://twig.sensiolabs.org/">Twig</a>, <a target="_blank" rel="noopener noreferrer" href="http://platesphp.com/engine/">Plates</a> and <a target="_blank" rel="noopener noreferrer" href="http://framework.zend.com/manual/current/en/modules/zend.view.quick-start.html">Zend\View</a> integration, using the second one by default, but it shouldn&#x27;t be hard to use anyone else, like <a target="_blank" rel="noopener noreferrer" href="http://laravel.com/docs/5.0/templates">Blade</a>.</p><p>I have used twig for my website, because I&#x27;ve been using it lately, and I really like it.</p><p>The template engine will be injected in the Applicaiton by fetching the <code>Zend\Expressive\Template\TemplateInterface</code> service.</p><h3>Service container</h3><p>The service container is very important in Expressive. All the services, middlewares and configurations are fetched from it. Expressive expects an <code>Interop\Container\ContainerInterface</code> object, which is implemented by the most used service containers (or dependency injection containers if you prefer so).</p><p>Documentation on how to use <a target="_blank" rel="noopener noreferrer" href="https://framework.zend.com/manual/current/en/modules/zend.service-manager.html">Zend\ServiceManager</a>, <a target="_blank" rel="noopener noreferrer" href="http://pimple.sensiolabs.org/">Pimple</a> and <a target="_blank" rel="noopener noreferrer" href="https://github.com/auraphp/Aura.Di">Aura.Di</a> is included in the project. Depending on how big you expect your application to become, you can use one or another, but you should be able to replace it in case of need.</p><p>If no container is provided, the Application will use the first one. Also, it has been my choice, and as I said earlier, everything in my website&#x27;s project is managed by the ServiceManager, even the <code>Application</code> object itself.</p><p>It&#x27;s one of my favourite PHP components and I use it whenever I can.</p><h3>Error management</h3><p>Another thing that any framework has to provide is a way to catch requests to invalid routes or uncaught exceptions and errors. In Expressive that&#x27;s made by the so called <code>FinalHandler</code>.</p><p>By default it just displays plain text errors, and returns the proper status code (404 or 500). If you want certain template to be rendered, you have to register a <code>TemplateErrorHandler</code> in your container, via the <code>Zend\Expressive\Container\TemplatedErrorHandlerFactory</code>. It will use a configuration block to know which template has to be rendered in each case, and use the registered template engine to render them.</p><p>In development, a <code>WhoopsErrorHandler</code> can be used too. It extends the functionality of the <code>TemplatedErrorHandler</code> by using <a target="_blank" rel="noopener noreferrer" href="https://filp.github.io/whoops/">Whoops</a> to display nice errors. Make sure to never use it in production.</p><h3>Other considerations</h3><p>You know now how to use the main components in the framework, but you need to know how <a target="_blank" rel="noopener noreferrer" href="http://www.php-fig.org/psr/psr-7/">psr-7</a> works and how to use middleware. You should read these articles if you are not familiar with those concepts, since the whole framework is built on top of them.</p><ul><li><a target="_blank" rel="noopener noreferrer" href="https://mwop.net/blog/2015-01-26-psr-7-by-example.html">PSR-7 By Example</a></li><li><a target="_blank" rel="noopener noreferrer" href="https://mwop.net/blog/2015-01-08-on-http-middleware-and-psr-7.html">On HTTP, Middleware, and PSR-7</a></li></ul><p>You should also take a look at the official documentation. It is not very long and it&#x27;s very well structured. <a target="_blank" rel="noopener noreferrer" href="http://zend-expressive.readthedocs.org/en/stable/">https://zend-expressive.readthedocs.org/en/stable/</a></p><h3>Conclusion</h3><p>Those are all the things that can be done with Expressive. It could seem too basic, but it is also very extensible via composer. That&#x27;s its forte.</p><p>Probably, for my website I could have used any other microframework (Indeed I was planning to use Slim 3 before Expressive was launched), but I liked Expressive from the beginning and decided to go with it despite it is not stable yet.</p>

My first approach to Zend Expressive

<p>About a year ago I wrote two articles discussing the best way to work with modules with sub-namespaces in Zend Framework 2.</p><p>Here you can find <a href="/2014/05/21/create-modules-with-sub-namespaces-in-zend-framework-2/">Part 1</a> and <a target="_blank" rel="noopener noreferrer" href="http://alejandrocelaya.blog/2014/06/21/create-modules-with-sub-namespaces-in-zend-framework-2-part-ii/">Part 2</a></p><p>The solution provided in those articles was functional, but it introduced some new problems to deal with. It happens that after some time working with sub-namespaced modules I have found the best way to solve those new problems, and I wanted to write this new article explaining it.</p><p>For this article I&#x27;m going to use the example namespace <code>ZasDev\AtomicReader</code>, which belongs to a real <a target="_blank" rel="noopener noreferrer" href="https://github.com/zasDev/atomic-reader">application</a> I&#x27;m working on. For example, in my <code>Auth</code> module, a real fully qualified class name could be <code>ZasDev\AtomicReader\Auth\Controller\LoginController</code>.</p><h3>The problems</h3><h4>Autoloading</h4><p>By default, ZF2 uses a psr-0-like way to perform autoloading. This would force us to create a new folder per namespace level in our module, but since <code>Module</code> classes &quot;are loaded&quot; from the root of the module and the rest of the classes are loaded from the nested src folder, it would be 2 new folders per namespace instead.</p><p>With the previously mentioned namespace, the module&#x27;s folder structure would be this.</p><pre><pre><code>modules
└── ZasDev
    └── AtomicReader
        └── Auth
            ├── config
            │   └── ...
            ├── view
            │   └── ...
            ├── src
            │   └── ZasDev
            │       └── AtomicReader
            │           └── Auth
            │               ├── Controller
            │               │   └── LoginController.php
            │               ├── Form
            │               │   └── ...
            │               └── Service
            │                   └── ...
            └── Module.php
</code></pre></pre><p>There are people that think that is the correct way to work, but I don&#x27;t like to have so many &quot;empty&quot; folders.</p><h4>View scripts resolution</h4><p>As I mentioned in previous articles, the automatic view script resolution in Zend Framework 2 when a controller&#x27;s action returns a <code>ViewModel</code> instance is to use the action&#x27;s name as the script name, the controllers&#x27; class name as the parent folder, and the first level namespace as the root folder. That is a problem when all the modules have a common top-level namespace.</p><p>In the original articles we found that the solution was to use the <code>controller_map</code> option for the <code>view_manager</code> configuration like this.</p><pre><pre><code class="language-php">&lt;?php
return [
    &#x27;view_manager&#x27; =&gt; [
        &#x27;controller_map&#x27; =&gt; [
            &#x27;ZasDev&#x27; =&gt; true
        ]
    ]
];
</code></pre></pre><p>That will make the view resolver to use all the controller&#x27;s namespace levels as folders, which solves the original problem but generates a similar problem as in the autoloading case, by making us to have a lot of empty folders.</p><p>The last example would produce this folder structure for view scripts.</p><pre><pre><code>modules
└── ZasDev
    └── AtomicReader
        └── Auth
            ├── config
            │   └── ...
            ├── view
            │   └── zas-dev
            │       └── atomic-reader
            │           └── auth
            │               └── login
            │                   └── index.phtml
            ├── src
            │   └── ...
            └── Module.php
</code></pre></pre><h3>The solutions</h3><p>It turns out that the solution to both problems is really easy.</p><p>This days everybody uses <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/">composer</a> on their PHP projects. Using composer&#x27;s autoloading we can solve the first problem.</p><p>By having this module&#x27;s folder structure, which is much more usable.</p><pre><pre><code>modules
└── Auth
    ├── config
    │   └── ...
    ├── view
    │   └── ...
    └── src
        ├── Controller
        │   └── LoginController.php
        ├── Form
        │   └── ...
        ├── Service
        │   └── ...
        └── Module.php
</code></pre></pre><p>We just need to define this psr-4 autoloading strategy in our composer.json and all the classes will be properly loaded.</p><pre><pre><code class="language-javascript">// composer.json
{
    &quot;autoload&quot; : {
        &quot;psr-4&quot; : {
            &quot;ZasDev\\AtomicReader\\Auth\\&quot; : &quot;modules/Auth/src&quot;
        }
    }
}
</code></pre></pre><p>And then just refresh the autoloader by running <code>composer dumpautoload</code>.</p><p>Repeat that for each module and that&#x27;s it. Also you won&#x27;t need to define the module&#x27;s autoloading in the <code>Module</code> class.</p><p>The problem with the view scripts resolution can be fixed by changing the <code>controller_map</code> configuration a little bit. It turns out that it allows to map module namespaces to folder structures, so that not all the levels are replaced by folders in the path resolution.</p><p>With this configuration, we will get controllers in the <code>ZasDev\AtomicReader\Auth</code> namespace to be resolved to the <code>auth</code> folder.</p><pre><pre><code class="language-php">&lt;?php
return [
    &#x27;view_manager&#x27; =&gt; [
        &#x27;controller_map&#x27; =&gt; [
            &#x27;ZasDev\AtomicReader\Auth&#x27; =&gt; &#x27;auth&#x27;,
            // ...
        ]
    ]
];
</code></pre></pre><p>And our complete module&#x27;s folder structure will end like this.</p><pre><pre><code>modules
└── Auth
    ├── config
    │   └── ...
    ├── view
    │   └── auth
    │       └── login
    │           └── index.phtml
    └── src
        ├── Controller
        │   └── LoginController.php
        ├── Form
        │   └── ...
        ├── Service
        │   └── ...
        └── Module.php
</code></pre></pre><h3>Other approaches</h3><p>Of course, even though I think this is the best solution, it is not the only one.</p><p>For the templates problem, you could use a <code>template_map</code> to get view scripts resolved, but during development that&#x27;s not the best scenario, since you will be forced to update that map every time you create a new template file.</p><p>Also, you could think that the first approach with a lot of folders is the best one. Be free to use it if you are more confortable with it.</p><p>Another solution would be to &quot;pack&quot; all the namespaces in a unique namespace that includes the vendor name, the applicaton name and the module name, like <code>ZasDevAtomicReaderAuth</code>, with classes like <code>ZasDevAtomicReaderAuth\Controller\LoginController</code>, but I don&#x27;t think that&#x27;s the best solution either.</p><p>Anyway, following this rules, you will be able to use sub-namespaces in modules in a very easy way. </p>

Working with sub-namespaced modules in Zend Framework 2 the right way

<p>Doctrine is currently the most used ORM in PHP. It makes it very easy to work with databases in an object oriented way.</p><p>It comes with a set of built-in column types that map database types with PHP types. For example, the <strong>datetime</strong> column type, persists the value of an entity column as a datetime in the database and handles it as a <code>DateTime</code> object when the entity is hydrated.</p><p>Type conversions work both ways, so column types take care of casting database to PHP types and vice versa.</p><p>In this article I&#x27;m going to explain how to define custom column types so that we can persist our own objects into the database and hydrate them back.</p><h3>PHP enums</h3><p>One of the features that PHP lacks of, is a consistent enumerations API. You can always define a class full of constants, but PHP constants can only be scalars, so we can&#x27;t define custom methods. Also, it is not possible to limit the values of an enumeration or typehint arguments and return types when using those constants.</p><p>For this purpose I recently discovered the <a target="_blank" rel="noopener noreferrer" href="https://github.com/myclabs/php-enum">myclabs/php-enum</a> package. It provides a very good way to mimic Java enumerations in PHP.</p><p>Using this package, we can limit the values of properties in doctrine entities, but we need to tell doctrine how to persist those enumerations.</p><h3>Custom Doctrine type</h3><p>Let&#x27;s imagine we have this enum, and we want it to be a valid doctrine type.</p><pre><pre><code class="language-php">&lt;?php
namespace Acelaya\Enum;

use MyCLabs\Enum\Enum;

class Action extends Enum
{
    const CREATE    = &#x27;create&#x27;;
    const READ      = &#x27;read&#x27;;
    const UPDATE    = &#x27;update&#x27;;
    const DELETE    = &#x27;delete&#x27;;
}
</code></pre></pre><p>We also have this entity with a column of type <code>Acelaya\Enum\Action</code>.</p><pre><pre><code class="language-php">&lt;?php
namespace Acelaya\Entity;

use Acelaya\Enum\Action;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity()
 * @ORM\Table(name=&quot;my_entities&quot;)
 */
class MyEntity
{
    /**
     * @var int
     *
     * @ORM\Id
     * @ORM\Column(type=&quot;integer&quot;)
     * @ORM\GeneratedValue(strategy=&quot;AUTO&quot;)
     */
    protected $id;
    /**
     * @var string
     *
     * @ORM\Column()
     */
    protected $name;
    /**
     * @var Action
     *
     * @ORM\Column(type=&quot;php_enum_action&quot;)
     */
    protected $action;

    // Getters and setters...
}
</code></pre></pre><p>We have used the column type <strong>php_enum_action</strong> in the <code>Doctrine\ORM\Mapping\Column</code> annotation for the <code>$action</code> property. We now need to tell doctrine how to convert that type from PHP to database and how to hydrate the column back.</p><p>Defining a custom type in doctrine is as easy as creating a class extending <code>Doctrine\DBAL\Types\Type</code>, and overwriting the methods <code>getName</code>, <code>getSQLDeclaration</code>, <code>convertToPHPValue</code> and <code>convertToDatabaseValue</code>.</p><pre><pre><code class="language-php">&lt;?php
namespace Acelaya\Type;

use Doctrine\DBAL\Platforms\AbstractPlatform;
use Doctrine\DBAL\Types\Type;
use Acelaya\Enum\Action;

class ActionEnumType extends Type
{        
    /**
     * Gets the name of this type.
     *
     * @return string
     */
    public function getName()
    {
        return &#x27;php_enum_action&#x27;;
    }
    
    /**
     * Gets the SQL declaration snippet for a field of this type.
     *
     * @param array $fieldDeclaration The field declaration.
     * @param \Doctrine\DBAL\Platforms\AbstractPlatform $platform The currently used database platform.
     *
     * @return string
     */
    public function getSQLDeclaration(array $fieldDeclaration, AbstractPlatform $platform)
    {
        return &#x27;VARCHAR(256) COMMENT &quot;php_enum_action&quot;&#x27;;
    }
    
    public function convertToPHPValue($value, AbstractPlatform $platform)
    {
        if (! Action::isValid($value)) {
            throw new \InvalidArgumentException(sprintf(
                &#x27;The value &quot;%s&quot; is not valid for the enum &quot;%s&quot;. Expected one of [&quot;%s&quot;]&#x27;,
                $value,
                Action::class,
                implode(&#x27;&quot;, &quot;&#x27;, Action::keys())
            ));
        }
        return new Action($value);
    }
    
    public function convertToDatabaseValue($value, AbstractPlatform $platform)
    {
        return (string) $value;
    }
}
</code></pre></pre><p>This is what each method does:</p><ul><li><strong><code>getName</code></strong>: It just returns the name of the type that is used in the <code>Doctrine\ORM\Mapping\Column</code> annotation.</li><li><strong><code>getSQLDeclaration</code></strong>: Returns the SQL code used to create a field that is going to store the value of the enum in the database. A simple VARCHAR is enough in our case.</li><li><strong><code>convertToPHPValue</code></strong>: Gets the value of the database and casts it to a PHP value. In this case it is going to get a string (from the VARCHAR field) and return an <code>Acelaya\Enum\Action</code> instance with the correct value. It also checks that the value from the database is valid for the enum.</li><li><strong><code>convertToDatabaseValue</code></strong>: Finally this method casts the objects of type <code>Acelaya\Enum\Action</code> to something that can be stored in a VARCHAR column. Since objects of type <code>MyCLabs\Enum\Enum</code> implement the <code>__toString()</code> method, which returns the value of the corresponding constant, this operation is as simple as casting the value to string.</li></ul><p>We now have to register this custom type so that doctrine is able to handle it.</p><p>At your application&#x27;s bootstrap, make this call.</p><pre><pre><code class="language-php">// [...]

use Doctrine\DBAL\Types\Type;
use Acelaya\Type\ActionEnumType;

// [...]

Type::addType(&#x27;php_enum_action&#x27;, ActionEnumType::class);
</code></pre></pre><p>And that&#x27;s it! You can use your custom type wherever you want, and be sure that your entity properties will be objects properly persisted into the database.</p><h3>The Doctrine enum type package</h3><p>I couldn&#x27;t finish this article without mentioning a package that I published two days ago, the <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/doctrine-enum-type">acelaya/doctrine-enum-type</a>.</p><p>You have probably seen that the previous process needs to be done once per enum, since each custom type will need to return a different object type and have a different name.</p><p>This package eases that process, by providing a base abstract class, the <code>Acelaya\Doctrine\Type\AbstractPhpEnumType</code>, which implements the common parts. You will just need to define the name and the enum&#x27;s object type, and then register each type.</p><p>For example, using this package, the <code>Acelaya\Type\ActionEnumType</code> would have been like this:</p><pre><pre><code class="language-php">&lt;?php
namespace Acelaya\Type;

use Acelaya\Doctrine\Type\AbstractPhpEnumType;
use Acelaya\Enum\Action;

class ActionEnumType extends AbstractPhpEnumType
{
    /**
     * You have to define this so that type mapping is properly performed
     */
    protected $enumType = Action::class;

    /**
     * @return string
     */
    protected function getSpecificName()
    {
        return &#x27;action&#x27;;
    }
}
</code></pre></pre><p>The rest of the process is the same.</p>

Working with custom column types in Doctrine. Enums.

<p>About a month ago I released the Zend Framework 2 module <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/ZF2-AcMailer">ZF2-AcMailer</a> version 5.0.0. This new major version includes some important improvements, and a new configuration system that allows multiple mail services to be registered.</p><p>When this module was on its first version, I wrote <a href="/2014/03/02/send-emails-in-a-zend-framework-2-application-using-zf2-acmailer-module/">an article</a> explaining how to use it, but a lot has changed since then, so I thought it was a good idea to write a new one with updated information.</p><p>With this article I&#x27;m going to explain all the new features of the module.</p><h3>Installation</h3><p>One of the main changes is that <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/">composer</a> is now the only supported installation method. The ZF2 autoloading files have been removed, and it no longer depends on the Zend\Load component, so it is not possible to use it (or at least, it is very hard) without using composer.</p><p>It is also important to know that the minimum PHP version is now PHP 5.4. I&#x27;ve dropped support for PHP 5.3 because it is no longer maintained, and it&#x27;s safer to stick with the latest versions.</p><p>This said, in a composer-based project, installing this module is as easy as running the command <code>composer require acelaya/zf2-acmailer</code>, and the last version will be installed.</p><p>Also, this module uses <a target="_blank" rel="noopener noreferrer" href="http://semver.org/">Semantic Versioning</a>, so it is safe to use the default version notation, which should be ~5.0.</p><p>Finally, enable the module in your application configuration file.</p><pre><pre><code class="language-php">return [
    &#x27;modules&#x27; =&gt; [
        &#x27;Application&#x27;,
        &#x27;AcMailer&#x27; // &lt;- Add this line
    ],
]
</code></pre></pre><h3>The new configuration structure</h3><p>This module used to allow to configure only one service that was meant to be used to send emails. The problem was that some users were asking to configure other different services, because they needed to use different transports for different purposes and such.</p><p>That was hard to achieve with earlier versions, because you had to update the configuration at runtime.</p><p>This version now allows to configure multiple services, in a similar way as the <a target="_blank" rel="noopener noreferrer" href="https://github.com/doctrine/DoctrineORMModule">DoctrineORMModule</a> creates multiple <code>EntityManagers</code>, by using composed configuration blocks consumed by abstract factories instead of concrete factories.</p><p>This made me change the configuration structure, in order to wrap each specific configuration under the service name, so that the factory was able to know which block to consume.</p><p>Since I was going to change that, I took the opportunity to make other naming changes and refactor everything, wrapping related configuration keys under common blocks, and dropping custom <code>AbstractOptions</code> objects in order to use standard ZF2 options objects.</p><p>The result was an structure like this.</p><pre><pre><code class="language-php">return [
    &#x27;acmailer_options&#x27; =&gt; [

        // Default mail service
        &#x27;default&#x27; =&gt; [
            &#x27;extends&#x27; =&gt; null,

            &#x27;mail_adapter&#x27; =&gt; &#x27;\Zend\Mail\Transport\Sendmail&#x27;,

            &#x27;smtp_options&#x27; =&gt; [
                &#x27;host&#x27; =&gt; &#x27;localhost&#x27;,
                &#x27;port&#x27; =&gt; 25,
                &#x27;connection_class&#x27; =&gt; &#x27;smtp&#x27;,
                &#x27;connection_config&#x27; =&gt; [
                    &#x27;username&#x27; =&gt; &#x27;&#x27;,
                    &#x27;password&#x27; =&gt; &#x27;&#x27;,
                    &#x27;ssl&#x27; =&gt; false,
                ],
            ],

            &#x27;file_options&#x27; =&gt; [
                &#x27;path&#x27; =&gt; &#x27;data/mail/output&#x27;,
                &#x27;callback&#x27; =&gt; null,
            ],

            &#x27;message_options&#x27; =&gt; [
                &#x27;from&#x27; =&gt; &#x27;&#x27;,
                &#x27;from_name&#x27; =&gt; &#x27;&#x27;,
                &#x27;to&#x27; =&gt; [],
                &#x27;cc&#x27; =&gt; [],
                &#x27;bcc&#x27; =&gt; [],
                &#x27;subject&#x27; =&gt; &#x27;&#x27;,
                &#x27;body&#x27; =&gt; [
                    &#x27;content&#x27; =&gt; &#x27;&#x27;,
                    &#x27;charset&#x27; =&gt; &#x27;utf-8&#x27;,
                    &#x27;use_template&#x27; =&gt; false,
                    &#x27;template&#x27; =&gt; [
                        &#x27;path&#x27;          =&gt; &#x27;ac-mailer/mail-templates/layout&#x27;,
                        &#x27;params&#x27;        =&gt; [],
                        &#x27;children&#x27;      =&gt; [
                            &#x27;content&#x27;   =&gt; [
                                &#x27;path&#x27;   =&gt; &#x27;ac-mailer/mail-templates/mail&#x27;,
                                &#x27;params&#x27; =&gt; [],
                            ]
                        ],
                        &#x27;default_layout&#x27; =&gt; [
                            &#x27;path&#x27; =&gt; null,
                            &#x27;params&#x27; =&gt; [],
                            &#x27;template_capture_to&#x27; =&gt; &#x27;content&#x27;
                        ]
                    ],
                ],

                &#x27;attachments&#x27; =&gt; [
                    &#x27;files&#x27; =&gt; [],
                    &#x27;dir&#x27; =&gt; [
                        &#x27;iterate&#x27;   =&gt; false,
                        &#x27;path&#x27;      =&gt; &#x27;data/mail/attachments&#x27;,
                        &#x27;recursive&#x27; =&gt; false,
                    ],
                ],
            ],

            &#x27;mail_listeners&#x27; =&gt; []
        ],

        // Another mail service
        &#x27;christmas&#x27; =&gt; [
            &#x27;extends&#x27; =&gt; &#x27;default&#x27;
        ]
    ]
];
</code></pre></pre><p>The first change that can be seen is that the top level configuration key is no longer <code>mail_options</code>, but <code>acmailer_options</code>. I thought it was safer to use the module name, in order to prevent naming collisions. However, the old configuration key will keep working, but it&#x27;s deprecated and will be removed in the next major version.</p><p>Then, the next level defines each individual mail service. In this case there are two services defined, the <strong>&#x27;default&#x27;</strong> service and the <strong>&#x27;christmas&#x27;</strong> service.</p><p>Each one of the services can contain any of the concrete configuration entries.</p><p>There are 5 main configuration blocks.</p><ul><li><strong>mail_adapter</strong>: The transport object to be used by the mail service. It can be either a <code>Zend\Mail\Transport\TransportInterface</code> instance, a fully qualified class name as string, or a service name as string. You can also use aliases for the standard ZF2 transports.<ul><li><em>sendmail</em>: To use a <code>Zend\Mail\Transport\Sendmail</code>.</li><li><em>smtp</em>: To use a <code>Zend\Mail\Transport\Smtp</code>. </li><li><em>file</em>: To use a <code>Zend\Mail\Transport\File</code>.</li><li><em>null</em> or <em>in_memory</em>: To use a <code>Zend\Mail\Transport\InMemory</code> (or a <code>Zend\Mail\Transport\Null</code> in ZF2.3 and earlier).</li></ul></li><li><strong>smtp_options</strong>: This block is only used when using a <code>Zend\Mail\Transport\Smtp</code> transport, and defines the SMTP connection configuration, as in the <a target="_blank" rel="noopener noreferrer" href="https://github.com/zendframework/zend-mail/blob/master/src/Transport/SmtpOptions.php"><code>Zend\Mail\Transport\SmtpOptions</code></a> class.</li><li><strong>file_options</strong>: This block is only used when using a <code>Zend\Mail\Transport\File</code> transport, and defines the configuration, as in the <a target="_blank" rel="noopener noreferrer" href="https://github.com/zendframework/zend-mail/blob/master/src/Transport/FileOptions.php"><code>Zend\Mail\Transport\FileOptions</code></a> class.</li><li><strong>message_options</strong>: This block defines how the message is going to be created, from simple headers like the recipients, the sender and the subject, to the way to create the body. The body can be defined as a raw content using the <strong>&#x27;content&#x27;</strong> configuration, but it can be rendered from a template too using the <strong>&#x27;template&#x27;</strong> configuration, which is disabled by default, but will overwrite the <strong>&#x27;content&#x27;</strong> if enabled using the <strong>&#x27;use_template&#x27;</strong> configuration.<ul><li><em>template</em>: The template config wraps the information to create the body from templates that will be rendered at runtime. It can define a simple template with no children, or a layout with nested children that will be recursively rendered inside of it. Also, a <strong>&#x27;default_layout&#x27;</strong> can be difined that will be used as the parent template for all the emails sent with this service.</li><li><em>attachments</em>: Defines a list of files or a directory containing files that will be attached to the email at runtime.</li></ul></li><li><strong>mail_listeners</strong>: It is a list of mail listeners that will be attached to the mail service at creation time. They can be either <code>AcMailer\Event\MailListenerInterface</code> instances, fully qualified class names as string, or service names as string that return <code>AcMailer\Event\MailListenerInterface</code> instances.</li></ul><p>There is another new configuration block, the <strong>extends</strong>. It defines another configuration block from wich this one should extend its configuration. This way, there is no need to repeat the same configuration over and over if it is going to be the same in more than one mail service.</p><p>For example, in the example, the christmas service will have the same configuration as the default service.</p><p>Any configuration that is redefined will overwrite the extended configuration.</p><h4>Migrate from old configurations</h4><p>In order to ease the migration from older versions, it is possible to automatically generate the new configuration from the old one by using a CLI entry point.</p><p>You just have to have the old <strong>&#x27;mail_options&#x27;</strong> configuration in the global config, so that it can be read from there, and then, this tool will output the result with the new structure, in phpArray, json, ini or xml format. It can be directly dumped into a file if you prefer so.</p><p>Just run this command:</p><pre><pre><code class="language-bash">php public/index.php acmailer parse-config
</code></pre></pre><p>This will output the new configuration in phpArray format. To define another format, use the <code>format</code> value flag. like this.</p><pre><pre><code class="language-bash">php public/index.php acmailer parse-config --format=ini
</code></pre></pre><p>To directly dump the configuration into a config file, use the <code>outputFile</code> value flag.</p><pre><pre><code class="language-bash">php public/index.php acmailer parse-config --outputFile=&quot;config/autoload/new_mail.global.php&quot;
</code></pre></pre><p>Take into account that you will loose any business logic in your config files, since this consumes the generated configuration. For example, if you are reading a password from an environment variable, you will have to manually check the output of this command to fix that, because the password will be now hardcoded in your new config file.</p><p>Also, since this version supports multiple mail services, the old configuration will be wrapped into the <strong>&#x27;default&#x27;</strong> mail service.</p><h3>Fetch mail services</h3><p>As I&#x27;ve mentioned earlier in this article, it is possible to define multiple mail services now. With previous versions, there was just one mail service under the <code>AcMailer\Service\MailService</code> key.</p><p>Now, there is a simple namespaced syntax to fetch any mail service from the <code>ServiceManager</code>. Use the <code>acmailer.mailservice.</code> prefix followed by the concrete mail service name.</p><p>For example, <code>acmailer.mailservice.default</code> or <code>acmailer.mailservice.christmas</code>.</p><p>If you try to use a name that wasn&#x27;t defined in the configuration, the <code>ServiceManager</code> will throw an exception.</p><p>Additionally, the <code>AcMailer\Service\MailService</code> will keep working as an alias of the <code>acmailer.mailservice.default</code> service, to make migration easier.</p><h3>Using mail services</h3><p>Once you have fetched a mail service, any configuration automatically set at creation time can be overwritten by any dynamically generated value. Also, there is a public <code>send()</code> method that will send the final message by using the configured transport.</p><h4>Send the email</h4><p>In order to send the email, just fetch the service and call to the <code>send()</code> method. It will return a <code>AcMailer\Result\MailResult</code> instance.</p><pre><pre><code class="language-php">$mailService = $sm-&gt;get(&#x27;acmailer.mailservice.default&#x27;);
$mailService-&gt;setBody(&#x27;This is the body&#x27;);

$result = $mailService-&gt;send();
if ($result-&gt;isValid()) {
    echo &#x27;Message sent. Congratulations!&#x27;;
} else {
    if ($result-&gt;hasException()) {
        echo sprintf(
            &#x27;An error occurred. Exception: \n %s&#x27;,
            $result-&gt;getException()-&gt;getTraceAsString()
        );
    } else {
        echo sprintf(&#x27;An error occurred. Message: %s&#x27;, $result-&gt;getMessage());
    }
}
</code></pre></pre><h4>Customize the message</h4><p>It is very probable that the recipients of the message (for example) have to be dynamically set from the information of a form.</p><p>Use the <code>getMessage()</code> method to get the wrapped <code>Zend\Mail\Message</code> instance and customize it.</p><pre><pre><code class="language-php">$mailService = $sm-&gt;get(&#x27;acmailer.mailservice.default&#x27;);

$message = $mailService-&gt;getMessage();
$message-&gt;setSubject(&#x27;This is the subject&#x27;)
        -&gt;addTo(&#x27;foobar@example.com&#x27;)
        -&gt;addTo(&#x27;another@example.com&#x27;)
        -&gt;addBcc(&#x27;hidden@domain.com&#x27;);
</code></pre></pre><h4>Customize the body</h4><p>The recommended way to set the body is by using the <code>setBody()</code> or <code>setTemplate()</code> methods of the mail service, depending if you want to set a raw body or a template to be rendered.</p><p>In any case, the charset can be provided.</p><p>Raw bodies:</p><pre><pre><code class="language-php">$mailService-&gt;setBody(&#x27;Hello!!&#x27;);
$mailService-&gt;setBody(&#x27;Hello!!&#x27;, &#x27;utf-8&#x27;);
$mailService-&gt;setBody(&#x27;&lt;h1&gt;Hello!!&lt;/h1&gt;&#x27;, &#x27;utf-8&#x27;);

$part = new \Zend\Mime\Part();
$part-&gt;charset = &#x27;utf-8&#x27;;
$mailService-&gt;setBody($part);

$mailService-&gt;setBody($part, &#x27;utf-8&#x27;);
</code></pre></pre><p>Templates:</p><pre><pre><code class="language-php">$mailService-&gt;setTemplate(new Zend\View\Model\ViewModel(), [&#x27;charset&#x27; =&gt; &#x27;utf-8&#x27;]);
$mailService-&gt;setTemplate(&#x27;application/emails/my-template&#x27;, [
    &#x27;charset&#x27; =&gt; &#x27;utf-8&#x27;,
    &#x27;date&#x27; =&gt; date(&#x27;Y-m-d&#x27;),
    &#x27;foo&#x27; =&gt; &#x27;bar&#x27;,
]);
</code></pre></pre><p>Complex templates:</p><pre><pre><code class="language-php">$layout = new \Zend\View\Model\ViewModel([
    &#x27;name&#x27; =&gt; &#x27;John Doe&#x27;,
    &#x27;date&#x27; =&gt; date(&#x27;Y-m-d&#x27;)
]);
$layout-&gt;setTemplate(&#x27;application/emails/merry-christmas&#x27;);

$footer = new \Zend\View\Model\ViewModel();
$footer-&gt;setTemplate(&#x27;application/emails/footer&#x27;);

$layout-&gt;addChild($footer, &#x27;footer&#x27;);

$mailService-&gt;setTemplate($layout);
</code></pre></pre><p>There is also a <code>setSubject()</code> public method, but it is marked as deprecated in this version and will be removed in the future. Use the <code>$message-&gt;setSubject()</code> method instead.</p><h4>Set attachments</h4><p>It is possible to add attachments or clean the attachments list before sending the message, by using the setter and adder methods.</p><pre><pre><code class="language-php">$mailService-&gt;addAttachment(&#x27;data/mail/attachments/file1.pdf&#x27;);
$mailService-&gt;addAttachment(&#x27;data/mail/attachments/file2.pdf&#x27;, &#x27;different-filename.pdf&#x27;);

// Add two more attachments to the list
$mailService-&gt;addAttachments([
    &#x27;another-name.pdf&#x27; =&gt; &#x27;data/mail/attachments/file3.pdf&#x27;,
    &#x27;data/mail/attachments/file4.zip&#x27;
]);
// At this point there are 4 attachments ready to be sent with the email

// If we call this, all previous attachments will be discarded
$mailService-&gt;setAttachments([
    &#x27;data/mail/attachments/another-file1.pdf&#x27;,
    &#x27;name-to-be-displayed.png&#x27; =&gt; &#x27;data/mail/attachments/another-file2.png&#x27;
]);

// A good way to remove all attachments is to call this
$mailService-&gt;setAttachments([]);
</code></pre></pre><h3>Events layer</h3><p>This module comes with its own events layer.</p><p>The mail services wrap a list of event managers that listen to three different events in the send process. When you call the method <code>send()</code>, just after trying to use the transport to send the message, the event <code>MailEvent::EVENT_MAIL_PRE_SEND</code> is triggered.</p><p>If everything works fine and the message is dispatched, the event <code>MailEvent::EVENT_MAIL_POST_SEND</code> is triggered. In this case, the result will be valid.</p><p>Finally, if an error occurs and an exception is thrown, the event <code>MailEvent::EVENT_MAIL_SEND_ERROR</code> is triggered. In this case the result won&#x27;t be valid, and it will wrap the produced exception.</p><p>The mail listeners are attached and detached with two simple methods.</p><pre><pre><code class="language-php">$mailListener = new \Application\Event\MyMailListener();
$mailService-&gt;attachMailListener($mailListener);

if ($foo) {
    // If foo, I want to detach the listener
    $mailService-&gt;detachMailListener($mailListener);
}

$mailService-&gt;send();
</code></pre></pre><p>This module doesn&#x27;t come with any built-in mail listener, you will have to create your own listeners by extending <code>AcMailer\Event\AbstractMailListener</code> and implementing the <code>onPreSend</code>, <code>onPostSend</code> and <code>onSendError</code> methods, which receive a <code>AcMailer\Event\MailEvent</code> object as an argument, which in turn wraps the mail service itself, so that you can customize anything at any of those points.</p><h3>Others</h3><p>Other minor changes are that the license has been changed from BSD to MIT, and that the build is running under PHP7, as well as 5.4, 5.5, 5.6 and hhvm. It is currently passing, so the module should theoretically work in all of those environments.</p><p>This is not the best module in the world, but it will help you send emails from Zend Framework 2 based applications.</p>

Emails in Zend Framework 2 with ZF2-AcMailer version 5

<p><a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/">Composer</a> is <strong>The Tool</strong> in any modern PHP project. Nowadays I can&#x27;t imagine to work without it.</p><p>It is much more powerful than some people think, easily solving the integration of third party components in our projects, but there are some advanced features that are less known.</p><p>I&#x27;m going to try to explain some of the best practices and mechanisms bundled with composer.</p><blockquote><p>If you are not familiar with composer, some time ago I wrote an introduction article that you should read before continuing with this one. <a href="/2014/07/19/dependency-management-and-autoloading-in-php-projects-with-composer/">Dependency management and autoloading in php projects with composer</a>.</p></blockquote><h3>Globally installing composer</h3><p>It is a good practice to have composer installed globally, instead of having a binary file per project.</p><p>After downloading the <code>composer.phar</code> file from the <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/download/">composer</a> website, you can start using it by running <code>php composer.phar [...]</code>. Instead, we are going to place it in a global location so that we can run the command <code>composer [...]</code> from this moment on.</p><p>In UNIX systems, just make the file executable and move it to a folder that&#x27;s already in the path.</p><pre><pre><code class="language-bash">sudo chmod +x composer.phar
sudo mv composer.phar /usr/local/bin/composer
</code></pre></pre><p>Under Windows systems, there is an installer that will make the work for you. Download it <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/doc/00-intro.md#installation-windows">here</a>.</p><p>Now, go to any location and run <code>composer</code>. You should see composer&#x27;s help.</p><h3>Create the composer.json file</h3><p>The first thing you should do when starting a new PHP project is to create the composer.json file. It is the main configuration file, where metadata, dependencies and autoloading are defined.</p><p>You probably don&#x27;t remember the main parts of this file, and end up copying the file from othe projects. There is no need to do that, just run <code>composer init</code> and the Composer config generator will be executed, guiding you over the process of creating the file.</p><h3>Add dependencies to an existing composer.json file</h3><p>In the documentation of many libraries, they tell you to manually edit your composer.json file to add new dependencies. That can be problematic, because you could have a syntax error, forget to add a trailing comma, etc.</p><p>The best practice to add dependencies to your composer.json file is to run the command <code>composer require vendor-name/library-name ~3.0</code>. That will add the new dependency to your file (avoiding syntax errors) and then install it.</p><p>If you don&#x27;t include the version name, composer will try to find out what&#x27;s the best version to use, by following <a target="_blank" rel="noopener noreferrer" href="http://semver.org/">Semantic Versioning</a>. If it is not able to know which version to use, it will ask you to decide.</p><h3>Production environments</h3><p>The management of dependencies and new classes is not the same in our development environment and the production environment. In development we need new classes to be automatically autoloaded, and we want to have certain dependencies, like phpunit or php code sniffer that are not of any use in production.</p><p>In development we will usually install or update dependencies by running <code>composer install</code> or <code>composer update</code>. That will include all dependencies in <strong>require</strong> and <strong>require-dev</strong> blocks, and generate an autoloader by following different strategies. Some of those autoloading strategies imply the iteration of directories in order to find class files.</p><p>That is ok for development, but in production we need something more efficient than that, and also, we don&#x27;t want <strong>require-dev</strong> dependencies to be installed.</p><p>To get this done, in a deployment process, we should run this command instead.</p><pre><pre><code class="language-bash">composer install --no-dev --optimize-autoloader --prefer-dist --no-interaction
</code></pre></pre><p>This is what each flag makes:</p><ul><li><strong><code>--no-dev</code></strong>: prevents dependencies defined in the <strong>requre-dev</strong> block to be installed.</li><li><strong><code>--optimize-autoloader</code></strong>: generates a classmap autoloader, that will map each class with the file that contains it, preventing unnecessary directory iterations.</li><li><strong><code>--prefer-dist</code></strong>: installs distributable versions of the libraries, instead of source code, when possible.</li><li><strong><code>--no-interaction</code></strong>: will always try to make the proper decission in case any &quot;conflict&quot; is produced, so that the process is completly unatended.</li></ul><p>This is the command you should use when deploying a project, just after clonning a clean repository.</p><h3>Private repositories</h3><p>This is probably one of the most powerful features while working on many private projects that depend on each other.</p><p>By default, composer fetches dependencies from a single repository, <a target="_blank" rel="noopener noreferrer" href="https://packagist.org/">Packagist</a>, which needs to have access to a public repository (usually github). But what happens if my code is private, and I don&#x27;t want to (or can&#x27;t) open source it? May I use composer to install private dependencies? The answer is yes.</p><p>The composer.json file can include a <strong>repositories</strong> block, where we define other repositories (either public or private) where composer will try to find dependencies.</p><p>There are several repository types supported by composer, from a VCS repository to a plain local directory containing zip files.</p><pre><pre><code class="language-javascript">{
    &quot;repositories&quot;: [
        {
            &quot;type&quot;: &quot;vcs&quot;,
            &quot;url&quot;: &quot;https://my-repos.com/something-private&quot;
        },
        {
            &quot;type&quot;: &quot;pear&quot;,
            &quot;url&quot;: &quot;http://pear2.php.net&quot;
        },
        {
            &quot;type&quot;: &quot;artifact&quot;,
            &quot;url&quot;: &quot;path/to/directory/with/zips/&quot;
        }
    ]
}
</code></pre></pre><p>Composer will look for dependencies on each defined repository in order, and Packagist as a last resource.</p><p>Defining repositories is very flexible and a little bit complex in some cases, so I recommend you to read the <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/doc/05-repositories.md">documentation</a>.</p><h3>CLI scripts</h3><p>Sometimes a library includes some command line interface scripts that the user can use to automate configuring some stuff.</p><p>If you want to include your own CLI scripts and allow any user to find them when installing your library as a dependency, you will want to define them in the <strong>bin</strong> block.</p><pre><pre><code class="language-javascript">{
    &quot;bin&quot;: [
        &quot;scripts/generate-foo&quot;,
        &quot;scripts/create-bar&quot;,
        &quot;scripts/do-something&quot;
    ]
}
</code></pre></pre><p>It is just a list of script paths that composer will &quot;copy&quot; to the <code>vendor/bin</code> directory after installation (it doesn&#x27;t really copy them, it creates symlinks in UNIX systems and generates bat files under Windows).</p><p>This makes all the CLI scripts of all dependencies to be &quot;placed&quot; in the same location, so it is easier to find them.</p><p>This makes sense only in non-root projects (those that will be installed as dependencies of other projects and are not base applications).</p><h3>Events</h3><p>Composer will trigger some events during the process of installing dependencies, generating autoloaders and such. You can define some scripts or code snippets that will be automatically executed when those events are triggered.</p><p>These event listeners are defined in the <strong>scripts</strong> block. They can be either CLI commands or static class methods.</p><pre><pre><code class="language-javascript">{
    &quot;scripts&quot;: {
        &quot;post-package-install&quot;: &quot;Acelaya\\MyClass::postPkgInstall&quot;,
        &quot;post-install-cmd&quot;: [
            &quot;Acelaya\\MyClass::postInstall&quot;,
            &quot;phpunit -c app/&quot;
        ]
    }
}
</code></pre></pre><p>The complete list of events can be found in composer&#x27;s <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/doc/articles/scripts.md#event-names">documentation</a>. Take a look at them and see if you can optimize your workflow.</p><h3>Applications installation</h3><p>At this point we all know that we can use composer to install libraries at project level, but what happens with applications, known as <strong>root projects</strong> in composer&#x27;s terms.</p><p>We can also use composer to distribute complete applications, allowing them to be easily installed by using this command.</p><pre><pre><code class="language-bash">composer create-project vendor-name/app-name
</code></pre></pre><p>This will download the application (as if we would have cloned the repository) and then install its dependencies. We could even take advantage of composer&#x27;s events, and initialize a database or create some non-tracked directories.</p><h3>Conclusion</h3><p>And that&#x27;s pretty much all.</p><p>Use composer, it will improve your PHP projects.</p>

Alejandro Celaya | Blog

Software development, agile methodologies and open source projects.

My first approach to Zend Expressive

Working with sub-namespaced modules in Zend Framework 2 the right way

Working with custom column types in Doctrine. Enums.

Emails in Zend Framework 2 with ZF2-AcMailer version 5

Composer advanced concepts