How to reduce duplication in your GitHub Actions workflows

Recently ReactJS v18 was released. I started to look into its improvements, and checked which of my projects could benefit from them.The main react-based project I maintain at the moment of writing this article is <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-web-client">shlink-web-client</a>, so I naturally created a new branch and started the process.The update was quite smooth, as most of the other dependencies I was using from the react ecosystem were already updated to support v18. All but one, <a target="_blank" rel="noopener noreferrer" href="https://enzymejs.github.io/enzyme/">enzyme</a>, the testing framework I was using to unit-test react components.To be precise, I was able to continue running my tests, but some of them (those using <code>mount</code> instead of <code>shallow</code>) were still rendering components with the &quot;old&quot; React v17 approach, causing them to behave as in that version and a warning being printed in the console.<h3>First fix attempt</h3>The way enzyme integrates with the react version you are using is through an adapter library. The last official one supports only React v16, but someone released an <a target="_blank" rel="noopener noreferrer" href="https://github.com/wojtekmaj/enzyme-adapter-react-17">unofficial adapter for v17</a> which, with close to 650k weekly downloads, quickly became the way to go.I checked if there was one for React 18, but sadly there wasn&#x27;t.Also, the author of the adapter for v17 posted an article indicating <a target="_blank" rel="noopener noreferrer" href="https://dev.to/wojtekmaj/enzyme-is-dead-now-what-ekl">enzyme is dead</a>, he was not going to release one for v18, and publishing one for v17 was a mistake.With those facts in mind, I started to face what was probably going to be the moment to migrate to <a target="_blank" rel="noopener noreferrer" href="https://testing-library.com/docs/react-testing-library/intro">react testing library</a>.<h3>Migration strategy</h3>I decided to follow a migration strategy similar to the one suggested in the article above, but with a couple of modifications:<ul><li>I update to React 18 anyway, as tests still pass.</li><li>Migrate right away all tests using <code>mount</code>, as those are the ones behaving differently.</li><li>New tests should be written directly with react testing library (RTL from now on).</li><li>When an existing test needs to be changed, consider migrating it to RTL, and do it if there&#x27;s time.</li><li>Introduce some PR from time to time just migrating a handful of tests.</li><li>Once everything is migrated, get rid of everything related with enzyme.</li></ul><h3>First contact and impressions</h3>I was a bit sceptical with RTL, as it was focused more on integration tests, instead of unit tests, which meant I had to completely change the mindset to write tests.It also didn&#x27;t support shallow rendering, meaning that you will end up sometimes rendering a bigger component tree when testing container-like components, potentially causing side effects that could affect your test.On the other hand there&#x27;s more and more people stating that <a target="_blank" rel="noopener noreferrer" href="https://kentcdodds.com/blog/why-i-never-use-shallow-rendering">shallow rendering is an anti-pattern</a>, and that&#x27;s probably the reason of enzyme getting &quot;discontinued&quot;.Also, RTL has become the <a target="_blank" rel="noopener noreferrer" href="https://reactjs.org/docs/testing.html#tools">officially recommended framework</a> to test react components, it has become very popular, and it has even joined a wider group of testing libraries under the <a target="_blank" rel="noopener noreferrer" href="https://testing-library.com/"><code>@testing-library</code></a> organization.The thing is that I started to use it, and I was quickly surprised with how it felt to work with it, and all the benefits it was bringing to my tests.<h3>Benefits I have experienced</h3>Once I started migrating the first tests I noticed some benefits:<ul><li>Changing my mindset was actually easier than I thought. The docs are very well written, so it&#x27;s relatively easy to start using RTL.</li><li>My tests got simpler, and required less of those nasty global mocks that jest allows (I&#x27;m looking at you, <a target="_blank" rel="noopener noreferrer" href="https://jestjs.io/es-ES/docs/mock-functions#mocking-modules"><code>jest.mock</code></a>).</li><li>Tests were way less coupled with implementation details. I moved from testing the component props, to test what the user would see on the screen.</li><li>Related with previous point, I started to write my tests by looking at the screen instead of the component&#x27;s implementation.</li><li>Changes in source code led to fewer tests requiring to be changed.</li><li>A progressive migration was possible, where some tests still use enzyme and others are already using RTL.</li></ul>And overall, it felt good and I have already dedicated a couple of PRs just to migrate more tests.<h3>Challenges I faced</h3>But of course, migrating to a new tool always comes with its own challenges, and this was not an exception. I&#x27;ll explain the main ones I have faced so far and how I tackled them:<ul><li>RTL lets you do some things in a couple of different ways, and the docs may not be super clear about what&#x27;s the recommended option.For this I recommend reading <a target="_blank" rel="noopener noreferrer" href="https://acel.me/DCMb1">this article</a> from Kent C. Dodds, RTL&#x27;s author, which explains some common mistakes when using the library.</li><li>At first, I struggled a bit with asynchronous side effects and state changes in components, which can easily end up printing a warning like <code>Warning: An update to MyComponent inside a test was not wrapped in act</code>.The warning also explains how you are supposed to solve this by wrapping your code in <code>act()</code>, but this warning comes from React, not RTL, and what it is not telling you is that RTL already wraps all needed operations in <code>act()</code>.What this error usually mean is that you are not waiting for something to happen. <a target="_blank" rel="noopener noreferrer" href="https://acel.me/jnUdT">This other article</a>, also from Kent C. Dodds, explains everything you need to know about the things that can lead to this warning, and how to solve them.</li><li>Since you start testing from the user point of view, some use cases can be challenging to test without coupling with implementation details. For example, when you have a component which dynamically renders different images or icons, I used to directly check the component properties.For this I found the best solution was to use <a target="_blank" rel="noopener noreferrer" href="https://jestjs.io/docs/snapshot-testing">jest snapshots</a>. I didn&#x27;t want to manually check which SVG was being rendered in the DOM, just that different ones were being used in every case.<pre><pre><code class="language-tsx">// I went from this...
test(&#x27;...&#x27;, () =&gt; {
 const wrapper = shallow(&lt;MyComp dynamicValue=&quot;foo&quot; /&gt;);
 expect(wrapper.find(FontAwesomeIcon).prop(&#x27;icon&#x27;)).toEqual(someIcon);
})

// To this
test(&#x27;...&#x27;, () =&gt; {
 const { container } = render(&lt;MyComp dynamicValue=&quot;foo&quot; /&gt;);
 expect(container.firstChild).toMatchSnapshot();
})
</code></pre></pre></li><li>Something very similar happens if you use some library that renders canvas. There&#x27;s no way to test that from a DOM point of view, which is what RTL does.In my case I was using <a target="_blank" rel="noopener noreferrer" href="https://www.chartjs.org/">Chart.js</a> to render some charts, so I used <a target="_blank" rel="noopener noreferrer" href="https://github.com/hustcc/jest-canvas-mock">jest-canvas-mock</a>, which exposes a method on the canvas to see which are all the events invoked from the library.Then I used snapshots again to verify they had the expected &quot;shape&quot;.<pre><pre><code class="language-tsx">// I went from this...
test(&#x27;...&#x27;, () =&gt; {
 const wrapper = shallow(&lt;MyCompWithCanvas /&gt;);
 expect(wrapper.find(Chart).prop(&#x27;data&#x27;).datasets).toEqual(...);
})

// To this
test(&#x27;...&#x27;, () =&gt; {
 const { container } = render(&lt;MyCompWithCanvas /&gt;);
 const events = container.querySelector(&#x27;canvas&#x27;)?.getContext(&#x27;2d&#x27;)?.__getEvents();

 expect(events).toBeTruthy();
 expect(events).toMatchSnapshot();
})
</code></pre></pre></li></ul><h3>Conclusion</h3>For better or worst, enzyme should no longer be considered an option. If you are starting a new project or are using it on small ones, consider migrating to RTL as soon as possible.If you are using it in bigger projects, following the process described in this article will probably help you.In any case, you will get surprised. React testing library is a great tool and provides many benefits over enzyme.Its main issue is that it&#x27;s not a drop-in replacement for enzyme, so you will have to change a bit your mindset.

My experience migrating from enzyme to react testing library

Capturing code coverage for a test suite is a very useful way to know which parts of your source code are actually getting executed by tests.This is useful not only to know if you need to add more tests to your project (in case the coverage is too low), but also, if you want to apply technics like mutation testing, having a properly generated code coverage report will dramatically speed up te execution and help you know if a non-killed mutant is relevant.<h3>Generating the code coverage</h3>Capturing code coverage is usually easy in the most common types of tests, like unit tests, where the source code is executed in the same process.Tools like <a target="_blank" rel="noopener noreferrer" href="https://phpunit.de/">PHPUnit</a>, one of the most extended PHP testing frameworks, ships with tools like <a target="_blank" rel="noopener noreferrer" href="https://github.com/sebastianbergmann/php-code-coverage">php-code-coverage</a>, designed to capture the code under execution, just by providing a couple of lines of configuration.However, generating a reliable code coverage report is not always that easy for other types of tests.In contexts like E2E tests, where you may spin-up an API on a different process, and make your tests just call this API via HTTP and assert on the responses, PHPUnit will not be able to capture the code coverage, because the source code is actually being loaded on a different process.<h3>Remote code coverage</h3>A couple of weeks ago, I faced the issue described above. I had a web service for which I had a decent API test suite, but I wanted to capture code coverage for two main reasons:<ul><li>Be able to merge this coverage with the one generated by other tests suites, to know what&#x27;s the &quot;total&quot; code coverage, regardless the test producing it.</li><li>Apply mutation testing to the API tests, as I was already doing that for the rest of the test suites in the project. For this, I also needed to know exactly what tests were covering every line of the source code.</li></ul>After some investigation, I couldn&#x27;t find a built-in feature, where PHPUnit itself was able to &quot;remotely&quot; capture te code under test, so I had to think on a way to manually use <code>php-code-coverage</code> by myself.<h3>Code coverage reports</h3>In order to be able to capture code coverage, I had to make sure the instances of the objects provided by <code>php-code-coverage</code> where &quot;spin-up&quot; with the server, and then, the code coverage report was dumped at the end.Also, you usually define the code to include/exclude from coverage in PHPUnit&#x27;s config, but since this time we are the ones creating the coverage objects, this was not possible.I tried a couple of different approaches (more on this at the end), but the most accurate one for me, was to define two routes in my server, that were dynamically configured only when running the server in the context of these tests, and were responsible for creating and dumping the code coverage.<pre><pre><code class="language-php">use PHPUnit\Runner\Version;
use SebastianBergmann\CodeCoverage\CodeCoverage;
use SebastianBergmann\CodeCoverage\Driver\Selector;
use SebastianBergmann\CodeCoverage\Filter;
use SebastianBergmann\CodeCoverage\Report\Html\Facade as Html;
use SebastianBergmann\CodeCoverage\Report\PHP;
use SebastianBergmann\CodeCoverage\Report\Xml\Facade as Xml;

// Define directories containing the code you want to cover
$filter = new Filter();
$filter-&gt;includeDirectory(...);
$filter-&gt;includeDirectory(...);
$coverage = new CodeCoverage((new Selector())-&gt;forLineCoverage($filter), $filter);

// This is &quot;pseudo-code&quot;. Defining the routes depends on the framework you use
$app-&gt;get(&#x27;/api-tests/start-coverage&#x27;, function () use (&amp;$coverage) {
 $coverage-&gt;start(&#x27;API tests&#x27;);
 return new EmptyResponse();
});
$app-&gt;get(&#x27;/api-tests/stop-coverage&#x27;, function () use (&amp;$coverage) {
 $basePath = &#x27;...&#x27;; // Wherever you want the reports to be dumped
 $coverage-&gt;stop();

 // I generated coverage reports in a couple of different formats
 (new PHP())-&gt;process($coverage, $basePath . &#x27;/coverage.cov&#x27;);
 (new Xml(Version::getVersionString()))-&gt;process($coverage, $basePath . &#x27;/coverage-xml&#x27;);
 (new Html())-&gt;process($coverage, $basePath . &#x27;/coverage-html&#x27;);

 return new EmptyResponse();
});
</code></pre></pre>Then, I added the next snippet to my PHPUnit <code>bootstrap.php</code> file, to make sure the endpoints configured above are invoked at the proper times:<pre><pre><code class="language-php">// when starting up the test suite, call the endpoint to start collecting coverage
$httpClient-&gt;request(&#x27;GET&#x27;, &#x27;http://localhost:8080/api-tests/start-coverage&#x27;);

// When the tests process shuts down, call the endpoint to stop the coverage
register_shutdown_function(function () use ($httpClient): void {
 $httpClient-&gt;request(&#x27;GET&#x27;, &#x27;http://localhost:8080/api-tests/stop-coverage&#x27;);
});
</code></pre></pre><blockquote>Learn more about how to configure PHPUnit&#x27;s <a target="_blank" rel="noopener noreferrer" href="https://phpunit.readthedocs.io/en/9.5/configuration.html#the-bootstrap-attribute">bootstrap script</a>.</blockquote>This was fine from a pure code coverage point of view, but if you try it yourself, you will notice the report says all the code has been covered by <code>API tests</code>, which is what we provide when calling <code>$coverage-&gt;start(&#x27;API tests&#x27;);</code><img src="/assets/img/remote-coverage/invalid-api-coverage.png" alt="Invalid API coverage"/>To properly do mutation testing we need to know which are the exact tests that cover every part of the code. That requirement took me to the next approach.<h3>Supporting mutation testing</h3>To be more precise with the generated reports, I needed some way to notify the server about the specific test performing the request.One way to do this is by sending a custom header when performing a request from your tests, and registering some event handler or middleware which starts the coverage for that request with the value coming from that header.With that, I evolved the configuration above, and added a middleware handler (the framework I use is <a target="_blank" rel="noopener noreferrer" href="https://www.php-fig.org/psr/psr-15/">PSR-15</a> based, but the framework of your choice will probably have a way to do this).<pre><pre><code class="language-php">use ...

$coverage = new CodeCoverage();

// This ensures the coverage is started and stopped on every request, using the &quot;x-coverage-id&quot; header as the ID.
$app-&gt;middleware(function (ServerRequestInterface $req, RequestHandlerInterface $handler) use (&amp;$coverage) {
$coverage?-&gt;start(&#x27;API Tests&#x27;);
 $coverage-&gt;start($req-&gt;getHeaderLine(&#x27;x-coverage-id&#x27;));

 try {
 return $handler-&gt;handle($req);
 } finally {
 $coverage-&gt;stop();
 }
});

// This route is no longer needed. You can also remove the request from your bootstrap script
// $app-&gt;get(&#x27;/api-tests/start-coverage&#x27;, ...);
$app-&gt;get(&#x27;/api-tests/stop-coverage&#x27;, ...);
</code></pre></pre>Then, inside your test you can do something like this:<pre><pre><code class="language-php">use PHPUnit\Framework\TestCase;

class MyApiTest extends TestCase
{
 private ClientInterface $httpClient;

 public function setUp(): void
 {
 $this-&gt;httpClient = ...;
 }

 public function testMyEndpoint(): void
 {
 $resp = $this-&gt;httpClient-&gt;request(&#x27;POST&#x27;, &#x27;...&#x27;, [
 &#x27;headers&#x27; =&gt; [
 &#x27;x-coverage-id&#x27; =&gt; static::class,
 ],
 ])

 // Asserts go here...
 }
}
</code></pre></pre>After this, the code coverage reports will properly show the actual tests covering them.<img src="/assets/img/remote-coverage/valid-api-coverage.png" alt="Valid API coverage"/><h3>Alternative approach</h3>The approach explained here is functional, but it&#x27;s a bit hacky. I had to do it like this because of limitations with how I serve the API with <a target="_blank" rel="noopener noreferrer" href="https://openswoole.com">openswoole</a>.However, instead of defining routes that need to be actively called to start/stop the code coverage (or just to dump the report, as in the second approach), you could try to register the shutdown function directly in the server side.If that works for you, it&#x27;s much more straightforward, and you won&#x27;t need to bother changing your tests bootstrap script.<h3>Conclusion</h3>Even though there&#x27;s room for improvement, this allows to generate code coverage reports for code that&#x27;s running on a different process.I plan to apply something similar for E2E tests for a command line app, so maybe I extend this article at some point.Also, I decided to write this article, because at the moment of having to implement this myself, I didn&#x27;t find too much useful information out there.I hope this helped you, and now you can collect code coverage reports on your API tests.

Capturing remote code coverage in API tests with PHPUnit

In the last couple of days I have been playing around with the idea of combining GitHub Actions and GitHub Pages to be able to dynamically build preview environments every time a pull request is opened against a repository hosting a client-side web app.The idea is that you can quickly preview the changes made by some contributor, without having to clone their branch and running everything locally, something specially useful for open source projects.In this article I will explain how to set everything up, and what are some considerations and problems you may face during the process.<h3>Enable github pages</h3>The first thing you need to do is enable your project to publish pages on some branch. I recommend creating a new branch for this, let&#x27;s say <code>preview-env</code>, and then enabling publishing on it.In order to do that go to your repository and then Settings -&gt; Pages, look for the Source section, and you should see something like this:<img src="/assets/img/preview-envs/github-pages-before-enabling.png" alt="GitHub pages before enabling"/>Click in the dropdown and select your new branch, <code>preview-env</code>. Then click Save.<img src="/assets/img/preview-envs/github-pages-after-enabling.png" alt="GitHub pages after enabling"/>After saving you will see a message at the top of this section telling you what&#x27;s the URL in which the pages are published. It always follows the same pattern. If your organization is <code>my-org</code> and your repository is <code>my-repo</code>, the url will be <code>https://my-org.github.io/my-repo/</code>.<h3>Configure the workflow</h3>Now we need to configure a workflow that will &quot;deploy&quot; the preview environment for the branch every time a new pull request is created or updated:Let&#x27;s imagine we have a React web app that is built with node.js. The configuration could look like this.<pre><pre><code class="language-yml"># .github/workflows/deploy-preview.yml
name: Deploy preview

on:
 pull_request: null

jobs:
 deploy:
 runs-on: ubuntu-20.04
 continue-on-error: true
 steps:
 - name: Checkout code
 uses: actions/checkout@v2
 - name: Use node.js 14.15
 uses: actions/setup-node@v1
 with:
 node-version: 14.15
 - name: Generate slug
 id: generate_slug
 run: echo &quot;##[set-output name=slug;]$(echo ${GITHUB_HEAD_REF#refs/heads/} | sed -r &#x27;s/[~\^]+//g&#x27; | sed -r &#x27;s/[^a-zA-Z0-9]+/-/g&#x27; | sed -r &#x27;s/^-+\|-+$//g&#x27; | tr A-Z a-z)&quot;
 - name: Build
 run: npm ci &amp;&amp; npm run build
 - name: Deploy
 uses: JamesIves/github-pages-deploy-action@4.1.1
 with:
 branch: preview-env
 folder: build
 target-folder: ${{ steps.generate_slug.outputs.slug }}
 - name: Publish env
 uses: marocchino/sticky-pull-request-comment@v2
 with:
 header: Preview environment
 message: |
 ## Preview environment
 https://my-org.github.io/my-repo/${{ steps.generate_slug.outputs.slug }}/
</code></pre></pre><blockquote>If you are not familiar with GitHub Actions yet, take a look at the <a target="_blank" rel="noopener noreferrer" href="https://docs.github.com/en/actions">official documentation</a>.</blockquote>This workflow will follow the next steps:<ul><li>Checkout the code from the repository.</li><li>Set-up node.js 14.15</li><li>Based on the branch name, generate a slug that we will use to have separated deployment folders for every pull request we receive. The slug is exposed to next steps as an output.</li><li>Build the project. This step will obviously depend on the needs of your project.</li><li>Using <a target="_blank" rel="noopener noreferrer" href="https://github.com/JamesIves/github-pages-deploy-action">JamesIves/github-pages-deploy-action</a>, deploy the contents we previously built in the GitHub page, under a sub-folder matching the slug we generated a few steps above, and under the branch <code>preview-env</code> (remember we enabled GitHub pages for this branch).</li><li>Finally, using <a target="_blank" rel="noopener noreferrer" href="https://github.com/marocchino/sticky-pull-request-comment">marocchino/sticky-pull-request-comment</a>, post a comment in the pull request with a link to the preview environment, so that you can just click on it and see the deployment.</li></ul>The steps may change depending on your needs and how you build your project. For example, I have an extra step to update a property in the <code>package.json</code> that is then used to allow serving the app in a sub-path instead of the root of the domain.You may also not build your site with node.js, as you could be using any of the multiple existing static site generators out there, but you get the idea.Finally, you have probably noticed the config includes <code>continue-on-error: true</code>. This will allow the pull request to be merged even if this process fails for some reason.<h3>Considerations when using forks</h3>While the configuration above will work perfectly when creating pull requests inside the same repository, there are some limitations when the pull request comes from a fork (which is the usual in OSS projects).For security reasons, the <code>GITHUB_TOKEN</code> injected in those cases doesn&#x27;t have write permissions, which will make the &quot;deploy&quot; step fail.Also, you cannot define your own token with more permissions and inject it as a secret, as the secrets are not exposed to workflows running on forks.However, with a couple small config changes, we can work around these limitations:<h4>Change event</h4>The first thing we need to do is use the <code>pull_request_target</code> event instead of the <code>pull_request</code> one.<pre><pre><code class="language-diff">on:
- pull_request: null
+ pull_request_target: null
</code></pre></pre>According to the documentation, this is equivalent to the <code>pull_request</code> event, but it runs in the scope of the base repository.Thanks to this, the <code>GITHUB_TOKEN</code> will come with write permissions, and we will have access to secrets if needed.<h4>Checkout the fork</h4>The second thing we are going to change is that we now need to specify the repository to checkout.In order to do that, we need to add two inputs to the &quot;Checkout code&quot; step, like this:<pre><pre><code class="language-diff"> steps:
 - name: Checkout code
 uses: actions/checkout@v2
+ with:
+ repository: ${{ github.event.pull_request.head.repo.full_name }}
+ ref: ${{ github.event.pull_request.head.ref }}
</code></pre></pre>This will ensure we checkout from the fork repository, instead of the base one, which is the default, as it&#x27;s the one where the <code>pull_request_target</code> event is scoped to.And that&#x27;s it. With these two changes you can now deploy preview environments for pull requests coming from forks.<blockquote>IMPORTANT! The limitations of the <code>pull_request</code> event are there for a reason. People could potentially get access to your secrets or manipulate your code. Proceed at your own risk.</blockquote><h3>Other considerations</h3>Other than the limitations for forks, there are a few other minor things to take into consideration.<ul><li>Changes in GitHub Pages do not reflect immediately. It may take up to a couple of minutes for the deployment to be available, but considering you will usually not review a PR right after it has been created, this should not be a big issue.</li><li>As you have seen, every time a pull request is created, the deployment will generate a new folder in your GitHub Pages branch. This may result in a lot of old folders to pile-up, so you may want to set up some way to clean them up periodically or after the pull request has been merged.</li><li>Due to the fact that GitHub Pages only allows static pages to be served, this process cannot be used with apps that require some kind of back-end or server-side logic.</li><li>If your project is already using GitHub Pages for something else (serve the project&#x27;s website or docs), that may conflict with this, preventing you from having this kind of preview envs.</li></ul>

Setting-up a preview environment for your client-side apps with GitHub Actions and GitHub Pages

I remember many years ago, when I released my first open source project, that every time I had a new release ready, I was never sure what should be the new version number.Versioning software is not as straightforward as it might look when you don&#x27;t have a lot of experience.In this article I&#x27;ll try to explain the <a target="_blank" rel="noopener noreferrer" href="https://semver.org/">SemVer</a> approach to version software, and some things you might want to take into account on top of that.<h3>Semantic Versioning</h3>The first thing you need is a solid set of rules that help you decide which should your next version be.I remember thinking &quot;is this version big enough as to jump from 1.0 to 2.0?&quot; or &quot;I have seen projects using three numbers for the version, X.Y.Z, should I do the same?&quot;Those questions are easier to answer if you stick to some standard that tells you what to do, and that will help others more easily understand your intention.My recommendation is to use <a target="_blank" rel="noopener noreferrer" href="https://semver.org/">Semantic Versioning</a>, as it defines a solid starting point, and it&#x27;s quite adopted by the community.Semantic Versioning states that you should use three numbers to identify versions, <code>MAJOR.MINOR.PATCH</code>, and follow these rules in order to decide which one to increase:<ul><li><code>PATCH</code>: the new release includes only bug fixes. People are encouraged to update to this release and no changes are needed in their code bases.</li><li><code>MINOR</code>: the new release includes new backwards-compatible features. People can update to this version without changing their code bases, and make use of the new features afterwards if they wish.</li><li><code>MAJOR</code>: the new release includes <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Backward_compatibility">backward compatibility</a> breaks. Changes in the code base will be needed when updating to this version.</li></ul><blockquote>These rules are easier to apply to libraries and frameworks than it is for apps and services. More about this later.</blockquote><h3>Try to keep backwards-compatibility</h3>Ok, we have some rules now. However, I have seen very frequently people mistaking what can be done with what should be done.Yes, if you introduce a breaking change, you can update the major version and that&#x27;s it. However, if you do it too frequently, people won&#x27;t be happy, and you will end up with a fragmented user base, that stop updating to newer versions.I remember using a library to deploy stuff that had a new major version every couple of months, changing things like &quot;The <code>host</code> function is now called <code>server</code>&quot;. Yes, ok, but why do I have to change my stuff so frequently.It&#x27;s usually better to try to implement things in a backwards-compatible way, and keep track of the things you want to change and do it all at a time.You can also deprecate things, and document the way you want those things to be done moving forward. That way you give people the chance to start changing their code and simplify a hypothetical upcoming major release.<h3>Provide clear upgrade paths</h3>As mentioned above, too frequent major version changes are not desirable, but sooner or later you will want to release a new major version for different reasons.<ul><li>Getting rid of that feature which is hard to maintain, introduces lots of bugs, and provides little value.</li><li>Supporting something new which is very hard to implement without breaking backwards compatibility.</li><li>Removing all those deprecated methods you have been dragging for months.</li><li>Fix design issues, where something was architected in the wrong way, and only spotted after some time.</li></ul>At the time this happens you will want your users to upgrade to the newer version, as you don&#x27;t want people to report bugs that only affect older versions, or to expect you to backport fixes to older versions because they haven&#x27;t updated to the new one.The best way to achieve this is to provide clear and simple upgrade paths:<ul><li>Prepare your releases for the things to come: If you want to introduce new ways of doing things, do it before the major release, and deprecate the older ones. For example, you can have a new method that gets called by an older one, while you mark the old one as deprecated.People will be more willing to update and change their code afterwards. By the time the major release is published, their code will be ready to upgrade.</li><li>Include a CHANGELOG file in your project, explaining the changes introduced in every version. A very good way to document a change log is the <a target="_blank" rel="noopener noreferrer" href="https://keepachangelog.com/">Keep a changelog</a> initiative.You can also use some other platform to document the change log, like GitHub releases.</li><li>Include documentation on how to upgrade to a major release: This is probably the most important one. Document all the steps that need to be followed and all the required changes to update from a release to the next major one.A good way to do this is by including an UPGRADE file in your project. You can see <a target="_blank" rel="noopener noreferrer" href="https://github.com/acmailer/acmailer/blob/main/UPGRADE.md">this example</a>.</li></ul><h3>Versioning libraries vs apps</h3>Semantic Versioning is a good standard to version software, but it plays much better with libraries and frameworks that are installed using some kind of package manager, than it does with apps and services that are not directly depended on.For example, how do you identify a backward compatibility break on a web user interface?With this kind of software there are more grey areas, and you will end up using your intuition.For example, not long ago I released a <a href="/2020/12/24/released-shlink-web-client-v3-0-0/">new major version</a> for a web app I maintain, and it was completely compatible with the previous one. However, it introduced a larger amount of features than usual, and big UI changes, so I decided it was worth the bump.Because of this there are projects that use different approaches to version apps. For example:<ul><li>Firefox and Chrome have 6-week cycles, and after each one of them they release a new major version no matter what.</li><li>Jetbrains publishes a few releases of their IDEs every year (I think 3) which always start with the year they were released on, like <code>2020.3.0</code>, and they increase the patch number for bugfixes.</li><li>Ubuntu releases 2 versions every year, one in April and one in October, and they are always identified by the year and month they were released on, like <code>19.04</code> or <code>20.10</code>.</li></ul><h3>Special versions</h3>There&#x27;s also a set of special versions that can be used to publish the so-called pre-release versions. These <a target="_blank" rel="noopener noreferrer" href="https://semver.org/#spec-item-9">are covered</a> by Semantic Versioning, but sometimes they are not so easy to understand.It is also very likely that you never have to use these, as only relatively big projects will need this level of granularity, but it&#x27;s still good to know what&#x27;s their purpose and what do they imply.<h4>0.x.y</h4>It is possible to release a version of your software where the major number is <code>0</code>. When this happens, it means your software is still in its early stages.It does not mean it&#x27;s necessarily unstable, but it means you are still introducing frequent changes on it, and therefore, it might be a bit more fragile than a version starting with a number greater than <code>0</code>.<h4>Alpha</h4>The intention of an alpha release is that a subset of people con test some new functionality, but you don&#x27;t want people to use it in productionAlpha versions are on their very early stages. Their public API is very likely to change, and they probably contain bugs.Semantic Versioning states that alpha versions are identified by this pattern: <code>MAJOR.MINOR.PATCH-alpha.NUMBER</code>, for example <code>2.0.0-alpha.1</code>.<h4>Beta</h4>Similar to alpha versions, beta versions are also prone to contain bugs, but their API will in theory not change. That means that you could potentially adapt your software to start using a beta version, and when the corresponding stable release is published, you shouldn&#x27;t need that many changes.Semantic Versioning defines a pattern similar to the one for alpha versions: <code>MAJOR.MINOR.PATCH-beta.NUMBER</code>, for example <code>2.0.0-beta.1</code>.<h4>Release candidate</h4>Release candidates (RC) are pre-release versions that you will want to publish for the general user-base to test an upcoming release. You want to publish a RC so that it&#x27;s battle tested by as many people as possible, in order to find possible bugs and edge cases.They should not contain many bugs, but some could be found. The public API should not change anymore.According to Semantic Versioning, the pattern to identify a RC is <code>MAJOR.MINOR.PATCH-rc.NUMBER</code>, for example <code>2.0.0-rc.1</code>.<h3>Conclusion</h3>We have seen some approaches and considerations to properly version your software.Versioning is not so straightforward when you don&#x27;t have a lot of experience, but as you have seen, you just need to know a small set of rules and use a bit your intuition.With those tools, you will be able to properly version your software.

What to take into account when versioning software

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.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.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.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>.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.It is open source and you can find it <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/website-expressive">here</a>.<h3>Why microframeworks</h3>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.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.There is where microframeworks have their power.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.<h3>Why Zend Expressive</h3>The first thing that I liked in Zend Expressive is that it doesn&#x27;t force you to use an implementaiton for common tasks. 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.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.<h3>Configuration driven apps</h3>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.For example, in Slim 3, you can do something like this to dispatch a request:<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>The same thing can be done like this with Silex:<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>And also, with Expressive, you do it like this:<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>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 main object, and fetch the <code>Application</code> in the front controller as a regular service. The best microframework to work like this is Expressive.For example, in my website, the front controller looks like this.<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>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.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.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.So, in Expressive, everything is middleware lazily fetched from a service container to dispatch HTTP requests.<h3>Router</h3>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.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.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.<blockquote>Update 2015-09-20: 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>.</blockquote>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.<h3>Template engine</h3>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>.I have used twig for my website, because I&#x27;ve been using it lately, and I really like it.The template engine will be injected in the Applicaiton by fetching the <code>Zend\Expressive\Template\TemplateInterface</code> service.<h3>Service container</h3>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).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.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.It&#x27;s one of my favourite PHP components and I use it whenever I can.<h3>Error management</h3>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>.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.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.<h3>Other considerations</h3>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.<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>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><h3>Conclusion</h3>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.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.

My first approach to Zend Expressive

About a year ago I wrote two articles discussing the best way to work with modules with sub-namespaces in Zend Framework 2.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>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.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>.<h3>The problems</h3><h4>Autoloading</h4>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.With the previously mentioned namespace, the module&#x27;s folder structure would be this.<pre><pre><code>modules
└── ZasDev
 └── AtomicReader
 └── Auth
 ├── config
 │ └── ...
 ├── view
 │ └── ...
 ├── src
 │   └── ZasDev
 │   └── AtomicReader
 │   └── Auth
 │   ├── Controller
 │   │   └── LoginController.php
 │   ├── Form
 │ │ └── ...
 │   └── Service
 │ └── ...
 └── Module.php
</code></pre></pre>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.<h4>View scripts resolution</h4>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.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.<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>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.The last example would produce this folder structure for view scripts.<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>It turns out that the solution to both problems is really easy.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.By having this module&#x27;s folder structure, which is much more usable.<pre><pre><code>modules
└── Auth
 ├── config
 │ └── ...
 ├── view
 │ └── ...
 └── src
    ├── Controller
     │   └── LoginController.php
    ├── Form
 │ └── ...
    ├── Service
 │ └── ...
 └── Module.php
</code></pre></pre>We just need to define this psr-4 autoloading strategy in our composer.json and all the classes will be properly loaded.<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>And then just refresh the autoloader by running <code>composer dumpautoload</code>.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.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.With this configuration, we will get controllers in the <code>ZasDev\AtomicReader\Auth</code> namespace to be resolved to the <code>auth</code> folder.<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>And our complete module&#x27;s folder structure will end like this.<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>Of course, even though I think this is the best solution, it is not the only one.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.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.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.Anyway, following this rules, you will be able to use sub-namespaces in modules in a very easy way.

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

Doctrine is currently the most used ORM in PHP. It makes it very easy to work with databases in an object oriented way.It comes with a set of built-in column types that map database types with PHP types. For example, the datetime 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.Type conversions work both ways, so column types take care of casting database to PHP types and vice versa.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.<h3>PHP enums</h3>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.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.Using this package, we can limit the values of properties in doctrine entities, but we need to tell doctrine how to persist those enumerations.<h3>Custom Doctrine type</h3>Let&#x27;s imagine we have this enum, and we want it to be a valid doctrine type.<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>We also have this entity with a column of type <code>Acelaya\Enum\Action</code>.<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>We have used the column type php_enum_action 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.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>.<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>This is what each method does:<ul><li><code>getName</code>: It just returns the name of the type that is used in the <code>Doctrine\ORM\Mapping\Column</code> annotation.</li><li><code>getSQLDeclaration</code>: 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><code>convertToPHPValue</code>: 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><code>convertToDatabaseValue</code>: 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>We now have to register this custom type so that doctrine is able to handle it.At your application&#x27;s bootstrap, make this call.<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>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.<h3>The Doctrine enum type package</h3>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>.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.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.For example, using this package, the <code>Acelaya\Type\ActionEnumType</code> would have been like this:<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>The rest of the process is the same.

Working with custom column types in Doctrine. Enums.

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.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.With this article I&#x27;m going to explain all the new features of the module.<h3>Installation</h3>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.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.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.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.Finally, enable the module in your application configuration file.<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>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.That was hard to achieve with earlier versions, because you had to update the configuration at runtime.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.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.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.The result was an structure like this.<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>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.Then, the next level defines each individual mail service. In this case there are two services defined, the &#x27;default&#x27; service and the &#x27;christmas&#x27; service.Each one of the services can contain any of the concrete configuration entries.There are 5 main configuration blocks.<ul><li>mail_adapter: 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>sendmail: To use a <code>Zend\Mail\Transport\Sendmail</code>.</li><li>smtp: To use a <code>Zend\Mail\Transport\Smtp</code>. </li><li>file: To use a <code>Zend\Mail\Transport\File</code>.</li><li>null or in_memory: 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>smtp_options: 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>file_options: 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>message_options: 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 &#x27;content&#x27; configuration, but it can be rendered from a template too using the &#x27;template&#x27; configuration, which is disabled by default, but will overwrite the &#x27;content&#x27; if enabled using the &#x27;use_template&#x27; configuration.<ul><li>template: 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 &#x27;default_layout&#x27; can be difined that will be used as the parent template for all the emails sent with this service.</li><li>attachments: Defines a list of files or a directory containing files that will be attached to the email at runtime.</li></ul></li><li>mail_listeners: 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>There is another new configuration block, the extends. 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.For example, in the example, the christmas service will have the same configuration as the default service.Any configuration that is redefined will overwrite the extended configuration.<h4>Migrate from old configurations</h4>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.You just have to have the old &#x27;mail_options&#x27; 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.Just run this command:<pre><pre><code class="language-bash">php public/index.php acmailer parse-config
</code></pre></pre>This will output the new configuration in phpArray format. To define another format, use the <code>format</code> value flag. like this.<pre><pre><code class="language-bash">php public/index.php acmailer parse-config --format=ini
</code></pre></pre>To directly dump the configuration into a config file, use the <code>outputFile</code> value flag.<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>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.Also, since this version supports multiple mail services, the old configuration will be wrapped into the &#x27;default&#x27; mail service.<h3>Fetch mail services</h3>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.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.For example, <code>acmailer.mailservice.default</code> or <code>acmailer.mailservice.christmas</code>.If you try to use a name that wasn&#x27;t defined in the configuration, the <code>ServiceManager</code> will throw an exception.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.<h3>Using mail services</h3>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.<h4>Send the email</h4>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.<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>It is very probable that the recipients of the message (for example) have to be dynamically set from the information of a form.Use the <code>getMessage()</code> method to get the wrapped <code>Zend\Mail\Message</code> instance and customize it.<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>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.In any case, the charset can be provided.Raw bodies:<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>Templates:<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>Complex templates:<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>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.<h4>Set attachments</h4>It is possible to add attachments or clean the attachments list before sending the message, by using the setter and adder methods.<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>This module comes with its own events layer.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.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.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.The mail listeners are attached and detached with two simple methods.<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>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.<h3>Others</h3>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.This is not the best module in the world, but it will help you send emails from Zend Framework 2 based applications.

Emails in Zend Framework 2 with ZF2-AcMailer version 5

<a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/">Composer</a> is The Tool in any modern PHP project. Nowadays I can&#x27;t imagine to work without it.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.I&#x27;m going to try to explain some of the best practices and mechanisms bundled with composer.<blockquote>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>.</blockquote><h3>Globally installing composer</h3>It is a good practice to have composer installed globally, instead of having a binary file per project.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.In UNIX systems, just make the file executable and move it to a folder that&#x27;s already in the path.<pre><pre><code class="language-bash">sudo chmod +x composer.phar
sudo mv composer.phar /usr/local/bin/composer
</code></pre></pre>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>.Now, go to any location and run <code>composer</code>. You should see composer&#x27;s help.<h3>Create the composer.json file</h3>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.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.<h3>Add dependencies to an existing composer.json file</h3>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.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.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.<h3>Production environments</h3>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.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 require and require-dev 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.That is ok for development, but in production we need something more efficient than that, and also, we don&#x27;t want require-dev dependencies to be installed.To get this done, in a deployment process, we should run this command instead.<pre><pre><code class="language-bash">composer install --no-dev --optimize-autoloader --prefer-dist --no-interaction
</code></pre></pre>This is what each flag makes:<ul><li><code>--no-dev</code>: prevents dependencies defined in the requre-dev block to be installed.</li><li><code>--optimize-autoloader</code>: generates a classmap autoloader, that will map each class with the file that contains it, preventing unnecessary directory iterations.</li><li><code>--prefer-dist</code>: installs distributable versions of the libraries, instead of source code, when possible.</li><li><code>--no-interaction</code>: 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>This is the command you should use when deploying a project, just after clonning a clean repository.<h3>Private repositories</h3>This is probably one of the most powerful features while working on many private projects that depend on each other.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.The composer.json file can include a repositories block, where we define other repositories (either public or private) where composer will try to find dependencies.There are several repository types supported by composer, from a VCS repository to a plain local directory containing zip files.<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>Composer will look for dependencies on each defined repository in order, and Packagist as a last resource.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>.<h3>CLI scripts</h3>Sometimes a library includes some command line interface scripts that the user can use to automate configuring some stuff.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 bin block.<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>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).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.This makes sense only in non-root projects (those that will be installed as dependencies of other projects and are not base applications).<h3>Events</h3>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.These event listeners are defined in the scripts block. They can be either CLI commands or static class methods.<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>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.<h3>Applications installation</h3>At this point we all know that we can use composer to install libraries at project level, but what happens with applications, known as root projects in composer&#x27;s terms.We can also use composer to distribute complete applications, allowing them to be easily installed by using this command.<pre><pre><code class="language-bash">composer create-project vendor-name/app-name
</code></pre></pre>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.<h3>Conclusion</h3>And that&#x27;s pretty much all.Use composer, it will improve your PHP projects.

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