I have always struggled with how packages are versioned and published to the npm registry.
My main concern is that you probably want to also add a git tag to your source code when you are releasing a new version, but npm packages have their own versioning system, and include a &quot;version&quot; field in the package.json
Because of this, most of the workflows I have seen, usually involve:
<ol>
<li>Running <code>npm version ...</code>. This will update the &quot;version&quot; field in the package.json file.</li>
<li>Publishing the package to the npm registry, using the version set in previous step.</li>
<li>Committing to git, so that we track the change in package.json file.</li>
<li>Adding a git tag.</li>
<li>Pushing to git remote to track new commit and new tag.</li>
</ol>
<blockquote>
Steps 3 and 4 are frequently done automatically as part of <code>npm version</code>.
</blockquote>
For me this flow has two main problems:
<ul>
<li>
My personal preference is that everything is driven by git tags, making them the single source of truth.
This would allow to just have one manual step -&gt; <code>git tag -a v1.0.0 -m &quot;...&quot; &amp;&amp; git push origin --tags</code>. Then, this would trigger a number of potential automations, including publishing to the npm registry, but also others like creating a release with the appropriate release notes, building release artifacts, etc.
</li>
<li>
The &quot;version&quot; field in the package.json file can very easily become outdated, if you git-tag by mistake before publishing the package, or if pushing the changes fails after <code>npm version ...</code> has been run.
I&#x27;ve seen this happening more often than it seems.
</li>
</ul>
Because of this, my current take when publishing npm packages for my personal projects is:
<ol>
<li>
Get rid of the &quot;version&quot; field from the package.json file. It&#x27;s misleading in source code, as it can very easily be out of date.
The only case where it&#x27;s useful is when the package has been installed and is inside node_modules, as other packages will assume this field to exist and have the right value on it.
In this case it&#x27;s always going to be correct due to the<code>npm version ...</code> + <code>npm publish</code> tandem (see next point).
</li>
<li>
Creating the git tag is the only &quot;manual step&quot;. This triggers an automation running <code>npm version ${GIT_TAG} --git-tag-version=false &amp;&amp; npm publish</code> (this is simplified. You probably also need to build your project and other potential extra steps).
The version to publish is inferred from the git tag (<code>${GIT_TAG}</code> is just a placeholder), and only at this stage we will set the &quot;version&quot; inside package.json, just before the package is published.
</li>
<li>
Other automations that need to happen during releases, can be also triggered now, like publishing release notes, building artifacts, etc.
</li>
</ol>
<blockquote>
As an example, you can see <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/github-actions/blob/24de7a2b89a9eb11b0acfd184de7187698b051b6/.github/workflows/js-lib-publish.yml">this GitHub actions workflow</a>, which follows this approach.
</blockquote>

I have always struggled with how packages are versioned and published to the npm registry. My main concern is that you probably want to also add a git tag to your source code when you are releasing a new version, but npm packages have their own versioning system, and include a "version" field in…

My current take when publishing packages to the npm registry

A couple of weeks ago I migrated a React project using redux to <a target="_blank" rel="noopener noreferrer" href="https://redux-toolkit.js.org/">Redux Toolkit</a>.
Redux has always been my preferred state management tool for React (which doesn&#x27;t mean I &quot;love&quot; it), but one of its main problems is the amount of boilerplate code it requires.
Because of that I had a couple of helper functions, but there was still some things not properly handled, like proper type inference on reducers and actions (I use TypeScript).
A bit by accident (I think it was on Twitter), I found out about Redux Toolkit (RTK from now on), an official library from the redux team, which provides some opinionated helpers to reduce the amount of boilerplate, and I decided to give it a chance.
These are my impressions.
<h3>TL;DR</h3>
I first started to use it in a proof of concept, and I quickly loved it.
RTK does not &quot;replace&quot; any of the redux principles, so you can progressively adopt it, by replacing small bits of code. My plan was to use it just for some reducers, but I liked it so much that I ended up migrating the whole project in a series of consecutive pull requests.
<h3>A bit of context</h3>
Before the migration, I used to follow the <a target="_blank" rel="noopener noreferrer" href="https://github.com/erikras/ducks-modular-redux">ducks modular pattern</a>, which promotes putting all your action types, action creators and the reducer handling those actions on the same module.
This fits pretty well with RTK, as in most of the cases you will use <a target="_blank" rel="noopener noreferrer" href="https://redux-toolkit.js.org/api/createSlice">slices</a>, and end up exporting the reducer and action creators returned by it, from the same module.
If you use <a target="_blank" rel="noopener noreferrer" href="https://redux-toolkit.js.org/api/createAsyncThunk">async thunks</a>, they usually need to be used by that same slice, so it&#x27;s not a bad idea to export them also from there.
<h3>Why I love it</h3>
There are a couple of reasons for which I loved RTK right away. The main one is that they make an impressive work on making type inference in TypeScript work properly.
<ul>
<li>Slices detect the type of the initial state in order to know what is expected to be passed as <code>state</code> to reducers.</li>
<li>You can infer the type of your store from what is generated by <code>configureStore</code> or <code>combineReducers</code> functions, allowing you to also properly type the <code>dispatch</code> function.</li>
<li>Action creators are generated with the proper param types based on the reducers provided to <code>createSlice</code> or the callback provided to <code>createAsyncThunk</code>.</li>
<li><code>createSlice</code> can consume all the action creators generated by <code>createAsyncThunk</code>, and infer the proper payload for each one of them.</li>
</ul>
Thanks to this, the code is super predictable and potential bugs can be caught sooner.
<blockquote>
More details on how to use RTK with typescript https://redux-toolkit.js.org/usage/usage-with-typescript
</blockquote>
But this is not the only benefit. Other reasons that make it very nice to work with are:
<ul>
<li>It keeps the same concepts from Redux, but removing the boilerplate or your own helper functions if you have them (yes, I didn&#x27;t want to keep all those <code>switch</code> statements everywhere).</li>
<li>It is mostly transparent for the components dispatching the actions or consuming the state.</li>
<li>All the tests covering your reducers/actions/components should keep passing, as the outcome from RTK is the same as if you built everything manually.</li>
<li>It introduces a couple of extra helpers, like <a target="_blank" rel="noopener noreferrer" href="https://redux-toolkit.js.org/rtk-query/overview">RTK query</a> or the <a target="_blank" rel="noopener noreferrer" href="https://redux-toolkit.js.org/api/createListenerMiddleware">listener middleware</a>, which is very useful to dispatch actions as a result of other actions being dispatched.</li>
</ul>
<h3>Challenges I found</h3>
Of course, adopting a new tool always comes with some challenges.
The main &quot;problem&quot; I found is that RTK is a bit opinionated, but that&#x27;s precisely how they manage to reduce boilerplate code, and it&#x27;s also &quot;advertised&quot; in their website, so not a big surprise.
I usually prefer to be in control of everything (configuration over convention), but that&#x27;s just a personal preference, and sometimes it&#x27;s ok to accept a bit of magic for the sake of simplicity.
This caused the next challenges for my particular case:
<ul>
<li>
RTK assumes your project follows a strict <a target="_blank" rel="noopener noreferrer" href="https://redux.js.org/tutorials/fundamentals/part-7-standard-patterns#flux-standard-actions">Flux pattern</a>, meaning your actions always have the properties <code>type</code>, <code>payload</code> and optionally <code>meta</code> and <code>error</code>.
I was not following this pattern (my actions had the payload &quot;mixed&quot; on the first object level), so I had to adapt all my actions first, fix the tests, then migrate the reducer to RTK and make sure the tests kept passing.
<div></div>
</li>
<li>
Immutability is no longer promoted in reducers. Instead, the library requires <a target="_blank" rel="noopener noreferrer" href="https://immerjs.github.io/immer/">immer</a> internally, and using proxies they automatically ensure immutability, even if you &quot;mutate&quot; the state.
This feels a bit counterintuitive at first, because redux always promoted an immutable approach, and the use of immer is not obvious.
However, they have <a target="_blank" rel="noopener noreferrer" href="https://redux-toolkit.js.org/usage/immer-reducers#why-immer-is-built-in">good reasons</a> to do it, and if your reducers return a state object, you can still use the immutable approach. It&#x27;s up to you.
<div></div>
</li>
<li>
Action creators resulting of <code>createAsyncThunk</code> can only have one argument.
This is because the async thunk callback receives a second argument containing the <code>dispatch</code> and <code>getState</code> functions, as well as a couple of other goodies, enforcing this convention to avoid human errors.
<div></div>
</li>
<li>
You cannot dispatch other actions after the callback passed to <code>createAsyncThunk</code>, because it has to return the payload and RTK dispatches the action for you.
However, this is probably something you usually should not be doing, and in my case, I resolved it with the <a target="_blank" rel="noopener noreferrer" href="https://redux-toolkit.js.org/api/createListenerMiddleware">listener middleware</a>, listening for the second action in order to dispatch the second one.
</li>
</ul>
<h3>Conclusion</h3>
My conclusion is that RTK is definitely worth it if you use redux.
It makes code simpler, more predictable and better typed. However, it still requires knowing how redux works internally and what are its patterns, in order to understand why the library exposes the helpers it exposes and why.
For existing redux projects, you can migrate progressively, addressing the challenges bit by bit and not all at once, which simplifies its adoption.
For new projects in which you want to use redux, I would recommend starting right away with RTK.

A couple of weeks ago I migrated a React project using redux to Redux Toolkit. Redux has always been my preferred state management tool for React (which doesn't mean I "love" it), but one of its main problems is the amount of boilerplate code it requires.

Because of that I had a couple of helper…

My experience migrating to Redux Toolkit (RTK)

In 2019, GitHub published their own solution to run automated workflows called GitHub Actions, which allowed those hosting their code in GitHub, to be able to define and run their CI/CD pipelines in the same platform. When it was released, one of the main pain points to use it was that defining…

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 class="language-tsx"><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>
</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 class="language-tsx"><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>
</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.

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 shlink-web-client, so I naturally created a new branch and started the process.

The…

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…

Capturing remote code coverage in API tests with PHPUnit

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>.
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.
<h3>How does swoole work?</h3>
Swoole is an asynchronous non-blocking I/O framework which works in a similar way as node.js, but for PHP apps.
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.
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>).
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.
<h3>How does this affect the EntityManager?</h3>
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>.
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:
<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>
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.
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.
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).
That&#x27;s how I came up with the <code>ReopeningEntityManager</code> Shlink is currently using (as of v1.20.0):
<pre class="language-php"><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>
<blockquote>
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>.
</blockquote>
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.
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:
<pre class="language-php"><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>
<blockquote>
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>
</blockquote>
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).
<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>
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.
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.
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.
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.
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>:
<pre class="language-php"><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>
<blockquote>
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>.
</blockquote>
<h3>Conclusion</h3>
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.
I hope that, if you ended up here, this article served you well.

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 Shlink. Shlink is built using expressive as the base framework for the HTTP-dispatching task. A while ago, an expressive module was released to…

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

Sometimes the nature of an application requires you to change the default framework&#x27;s way to structure error responses (like 404 and 405).
On this article I&#x27;m going to explain how to customize those responses when working with Zend Expressive 2.
<h3>Expressive 1. Error handler.</h3>
In Expressive 1, error handling was different.
There used to be an element called error handler, which was responsible of handling uncaught exceptions, but also, other errors, like the ones above (404 and 405).
When using the error handler it was easier to have an standard way to generate error responses for any kind of situation, like unmatched routes (404), routes requested with an incorrect HTTP verb (405) or uncaught exceptions (500), as well as other errors.
<h3>Expressive 2 behavior.</h3>
In expressive 2, the error handler is gone, replaced by a middleware which catches exceptions and lets you generate error responses. However, this middleware does not deal with 404 and 405 errors anymore. Now, those errors are handled by two new elements.
<ul>
<li>405: The routing middleware (which is now a separated middleware class) returns a 405 response when it detects that a request has been performed to an existing path but using an unsupported method. It adds an Allow header too, including the allowed HTTP verbs for that path.</li>
<li>404: The last middleware in the stack now receives the so called &quot;default delegate&quot;, which is responsible of generating a response when the stack is exhausted. The default implementation is the <code>NotFoundDelegate</code>, which as its name suggests, returns a response with status 404.</li>
</ul>
The problem with this two elements is the response body.
The first one returns an empty body by default, and the second one returns an error template (if a renderer service was registered) or a plain text response otherwise.
If your API is returning JSON responses (for example), this behavior is inconsistent and should be fixed.
<h3>Customize the response prototype</h3>
Both the <code>RouteMiddleware</code> and the <code>NotFoundDelegate</code> allow a PSR-7 response to be injected on them, to be used as the response prototype.
This way, we can define a consistent response that has the same structure regardless the error.
<h4>- 404 -</h4>
For the &quot;not found&quot; error, we have to define and register our own factory for the default delegate, which gets injected our customized response prototype:
<pre class="language-php"><code class="language-php">&lt;?php
namespace App\Delegate;

use Psr\Container\ContainerInterface;
use Zend\Diactoros\Response\JsonResponse;
use Zend\Expressive\Delegate\NotFoundDelegate;

class DefaultDelegateFactory
{
 public function __invoke(ContainerInterface $container)
 {
 $myResponsePrototype = new JsonResponse([
 &#x27;foo&#x27; =&gt; &#x27;bar&#x27;,
 &#x27;message&#x27; =&gt; &#x27;Not found&#x27;,
 ], 404); // We don&#x27;t really need to set the status, since the NotFoundDelegate will set it for us

 return new NotFoundDelegate($myResponsePrototype);
 }
}
</code></pre>
Now register it on the <code>config/autoload/dependencies.global.php</code> file:
<pre class="language-php"><code class="language-php">&lt;?php

use App\Delegate\DefaultDelegateFactory;

return [

 &#x27;factories&#x27; =&gt; [
 &#x27;Zend\Expressive\Delegate\DefaultDelegate&#x27; =&gt; DefaultDelegateFactory::class,
 ],

 // [...]
 
];
</code></pre>
And that should be it.
Of course, in this case that we always want to return the same response, we could just define another delegate which returns it, instead of using the built in implementation.
<h4>- 405 -</h4>
The &quot;method not allowed&quot; case is very similar, but with the <code>RouteMiddleware</code> instead of the <code>NotFoundDelegate</code>. However, there is one thing to take into account that we&#x27;ll see later.
First, let&#x27;s create our own factory:
<pre class="language-php"><code class="language-php">&lt;?php
namespace App\Middleware;

use Psr\Container\ContainerInterface;
use Zend\Diactoros\Response\JsonResponse;
use Zend\Expressive\Middleware\RouteMiddleware;
use Zend\Expressive\Router\RouterInterface;

class RouteMiddlewareFactory
{
 public function __invoke(ContainerInterface $container)
 {
 $myResponsePrototype = new JsonResponse([
 &#x27;bar&#x27; =&gt; &#x27;foo&#x27;,
 &#x27;message&#x27; =&gt; &#x27;Method not allowed&#x27;,
 ], 405); // Again, we don&#x27;t need to set the status because the RouteMiddleware will set it

 return new RouteMiddleware($container-&gt;get(RouterInterface::class), $myResponsePrototype);
 }
}
</code></pre>
Now we should register the middleware service and pipe it, but here&#x27;s the &quot;problem&quot;.
When doing this, my first approach was trying to override the <code>Application::ROUTING_MIDDLEWARE</code> name, but it didn&#x27;t work.
Internally, when expressive detects that middleware name, it instantiates a <code>RouteMiddleware</code> instance of its own, without the custom response prototype.
I have already created a question in ZF&#x27;s forum, because I&#x27;m not sure if that&#x27;s the intended behavior: <a target="_blank" rel="noopener noreferrer" href="https://discourse.zendframework.com/t/customize-response-prototype-on-routemiddleware/129">https://discourse.zendframework.com/t/customize-response-prototype-on-routemiddleware/129</a>
In the meantime, we are going to use a different middleware/service name, so let&#x27;s register it.
<pre class="language-php"><code class="language-php">&lt;?php

use App\Middleware\RouteMiddlewareFactory;

return [

 &#x27;factories&#x27; =&gt; [
 &#x27;my_routing_middleware&#x27; =&gt; RouteMiddlewareFactory::class, 
 ],

];
</code></pre>
Now, we have to pipe our middleware instead of the built in <code>Application::ROUTING_MIDDLEWARE</code>. Do it on <code>config\pipeline.php</code>;
<pre class="language-php"><code class="language-php">&lt;?php
// [..]

// Remove this, which pipes the Application::ROUTING_MIDDLEWARE
//$app-&gt;pipeRoutingMiddleware();

// Add this instead so that our custom RouteMiddleware is used
$app-&gt;pipe(&#x27;my_routing_middleware&#x27;);

// [...]
</code></pre>
And that&#x27;s all.
If in the end, the &quot;problem&quot; described above is fixed somehow, I&#x27;ll update this article.
<h3>Conclusion</h3>
This demonstrates how flexible expressive is.
We have many possible approaches. Overwrite built-in components, customize its behavior... We are always in control of the application, and there&#x27;s no black magic involved.

Sometimes the nature of an application requires you to change the default framework's way to structure error responses (like 404 and 405). On this article I'm going to explain how to customize those responses when working with Zend Expressive 2.

Expressive 1. Error handler.

In Expressive 1, error…

How to customize 'not found' and 'method not allowed' response prototypes in Zend expressive 2

The day Zend Expressive 2 was released I was super excited. I have been using it a lot for both professional and personal projects, so I&#x27;m quite used to it.
Since I&#x27;ve been using it in many projects, being able to update all of them to version 2 was a challenge, but I can say, I have succeed :-)
<h3>The projects</h3>
I have used expressive for two small websites, <a target="_blank" rel="noopener noreferrer" href="https://www.alejandrocelaya.com">https://www.alejandrocelaya.com</a> and <a target="_blank" rel="noopener noreferrer" href="https://shlink.io">https://shlink.io</a>.
The code can be found <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/alejandrocelaya.com">here</a> and <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink.io">here</a>.
When I migrated my website to expressive, I had to create a custom router for backward compatibility reasons, because none of the provided implementations supports optional params at the beginning of the path, and I was using them.
That&#x27;s why I created <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/expressive-slim-router">this</a> implementation based on Slim framework router (Slim 2, not 3). Since expressive 2 depends on the expressive router 2, I had to release a new version of this component too.
The next project to migrate was <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink">Shlink</a>, a little OSS project of my own. Like its website, it is based on expressive too.
This is a little bit bigger application, but not too big anyway.
Shlink is mainly a REST API, but has two or three endpoints that are meant to be consumed by humans in a web browser. For this reason I created a component that was responsible of handling errors in a different way, depending on the request&#x27;s <code>Accept</code> header.
Since the concept of error handling has completely changed in expressive 2, that library needed to be updated too: <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/ze-content-based-error-handler">https://github.com/acelaya/ze-content-based-error-handler</a>
And I left the two most important projects for the end.
First, my company&#x27;s website. Another small project, not too hard to migrate.
Finally, my company&#x27;s main product. A big and modular REST API, with about 100 actions/middlewares I wanted to migrate to <a target="_blank" rel="noopener noreferrer" href="https://github.com/http-interop/http-middleware">http-interop middleware</a>. It wasn&#x27;t difficult, but it took me a while to fix all tests xD.
In the end I migrated 5 projects and 2 libraries, and I am quite proud of the result.
<h3>The process</h3>
When I decided to migrate the first project, I started by following this article from the official documentation: <a target="_blank" rel="noopener noreferrer" href="https://docs.zendframework.com/zend-expressive/reference/migration/to-v2/">https://docs.zendframework.com/zend-expressive/reference/migration/to-v2/</a>.
It has a very detailed explanation with everything you need to know. Indeed, the best achievement of the Zend Framework team has been the number of articles, tools and documentation they provide to make this migration easier.
They have also spent a lot of time on making as many features as possible, backward compatible, to the point that almost everything keeps working after updating the components.
My conclusion after reading the article was that the only two things I needed to fix was the error handler and the middlewares signature, to use the single-pass approach instead of the old double-pass. However, the second one is not really necessary, since double-pass middleware keeps working with expressive 2, but I wanted to change it.
<h3>Error handler</h3>
At first, when one reads the docs, it seems that changing the error handler is going to be hard.
They explain the idea behind the new approach, why they have changed it, and how you should implement it.
The fact is that after reading this you realize expressive 2 and stratigility 2 come with a basic implementation that makes migrating from the old error handler to the new approach as easy as registering two services and one middleware. Done.
Now, instead of having a component that gets called when the middleware stack gets exhausted or an exception is thrown, like in expressive 1, the recommendation is to register a middleware at the outermost layer of the stack, that is responsible of catching any exception thrown by any inner middleware. Basically, what you do is invoke the next middleware inside a try/catch, and return an error response if the catch block is reached.
Stratigility 2 comes with a <code>Zend\Stratigility\Middleware\ErrorHandler</code> middleware that already does this. Just pipe it at the beginning of the stack and register the service using the provided <code>Zend\Expressive\Middleware\ErrorHandlerFactory</code> factory.
In expressive 1, the error handler was responsible of returning a response object. Now, this new ErrorHandler middleware delegates this responsibility into a service called ErrorResponseGenerator. Stratigility comes with an implementation, the <code>Zend\Stratigility\Middleware\ErrorResponseGenerator</code> that returns plain text errors, like the old stratigility ErrorHandler used to do.
On the other hand, expressive comes with two implementations, the <code>Zend\Expressive\Middleware\ErrorResponseGenerator</code>, which gets a template renderer injected, and acts like the old <code>TemplatedErrorHandler</code>, and also, a <code>Zend\Expressive\Middleware\WhoopsErrorResponseGenerator</code>, which is meant to be used in development, and acts like the old <code>WhoopsErrorHandler</code>.
In other words, in order to migrate the error handler, you just need to do three things:
<ul>
<li>Remove the old <code>Zend\Expressive\ErrorHandler</code> service</li>
<li>Register both <code>Zend\Stratigility\Middleware\ErrorHandler</code> and <code>Zend\Expressive\Middleware\ErrorResponseGenerator</code>, with whichever implementation you want.</li>
<li>Pipe the <code>Zend\Stratigility\Middleware\ErrorHandler</code> middleware as the outermost middleware of your stack.</li>
</ul>
After doing this, everything should work.
<h3>Error middleware</h3>
Expressive 1 had a feature called error middleware.
These middlewares were not exactly the same as regular middleware. Instead, they received a fourth <code>error</code> param, and were piped at the end of the stack, so they were invoked only if the latest regular middleware called the next one, or any other middleware called next with an <code>error</code> parameter, which had the effect of bypassing any other regular middleware and jumping directly to the first error middleware.
I never liked this feature, because it wasn&#x27;t clear.
<ul>
<li>What if I pipe error middleware between regular middleware, with a higher priority? Does it get invoked?</li>
<li>Why error middleware doesn&#x27;t get invoked in case of status 404 or 405? Isn&#x27;t that an error? Apparently not.</li>
<li>What is an &quot;error&quot; in the scope of middleware then? An exception only?</li>
</ul>
Because I was never sure how to use error middleware, I decided to reduce it to the point that only one of the projects had one error middleware that was responsible of logging exceptions in a file.
Gladly, the new error handling approach, the <code>Zend\Stratigility\Middleware\ErrorHandler</code>, allows &quot;error&quot; listeners to be attached, so that when an exception is caught, the error can be processed by any number of listeners.
The signature of the listeners is the same as the error middlewares used to have. Invokable objects with three parameters, an error, a request and a response.
This allowed me to register that error middleware as a listener, and just remove the return statement, which is no longer used.
<h3>Single-pass middleware</h3>
One of the most important new features in expressive 2, and the one I most wanted to use, is the support for interop middleware. It is what has been proposed to end up as the <a target="_blank" rel="noopener noreferrer" href="https://github.com/php-fig/fig-standards/blob/master/proposed/http-middleware/middleware.md">psr-15</a> standard for server middleware.
The main difference with middleware in expressive 1 is that middlewares no longer get the response object (which is less error prone), and that the last argument is no longer a <code>callable</code>, but an object (the delegate) which invokes the next middleware and returns the response generated by it.
Migrating middlewares to this approach is very easy. Remove the second argument and replace <code>$out($request, $response)</code> by <code>$delegate-&gt;process($request)</code>. Done.
The hardest part here is migrating tests.
Since expressive 1 middlewares are <code>callables</code>, I used to use <code>Closures</code> in tests. Now, the last argument is type hinted to <code>DelegateInterface</code>, so you have to explicitly mock it.
I have used <a target="_blank" rel="noopener noreferrer" href="https://github.com/phpspec/prophecy">prophecy</a>, which comes with PHPUnit, and it works like a charm. It&#x27;s not very difficult, but it could take a while if the application is big.
Of course, If you don&#x27;t test your code, you won&#x27;t have this problem, but I hope it is not your case ;-)
Tests allowed me to be sure all middlewares and actions were still working, before testing the apps manually.
<h3>Router</h3>
Changes in the router shouldn&#x27;t affect you, unless you have implemented your own router, like me.
However, the change is very small. This is what I had to change: <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/expressive-slim-router/commit/46bb000cb4389a6be6bff1335f875d7c6d8f5ca9">feature/v3</a>
You could also be affected by this if you rely on the <code>RouteResult</code> in any of your middlewares and used to call <code>RouteResult::fromRouteMatch()</code> in tests. Just replace it by <code>RouteResult::fromRoute()</code> and that&#x27;s it.
<h3>Programmatic approach</h3>
Another of the changes in expressive 2 is that now they promote the programmatic approach to configure routes and pipe middlewares, because newcomers find it easier to understand.
However, the config-driven approach still works, and you can still use it if you want.
That&#x27;s my case indeed. I like having my modules provide different routes, instead of defining all of them in a single config file. It better fits my workflow and my way of thinking.
Something similar happens with middleware, I prefer defining it in a config file with array notation. However, I have to confess I have moved all the middleware config to a single file in all projects.
I have found that, as the project grows, since middleware needs to be piped in a specific order, defining it in different files makes it harder to maintain and much more error prone. This is probably one of the reasons of promoting the programmatic approach.
<h3>Conclusion</h3>
My conclusion after migrating all these projects is that expressive is a great framework, and the Zend Framework team is expending a lot of time to make it scalable, maintainable an usable.
The more I use it, the more I see it is the best option for projects of any size. A framework where everything is perfectly explained, with a really good documentation, very loosely coupled with any other component, and a framework where you always have the last word.
No black magic or obscure conventions. But at the same time, you can quickly prototype any application without writing a lot of boilerplate code.
Thanks to all of this, the migration between major versions has been a breeze.

The day Zend Expressive 2 was released I was super excited. I have been using it a lot for both professional and personal projects, so I'm quite used to it. Since I've been using it in many projects, being able to update all of them to version 2 was a challenge, but I can say, I have succeed :-)

Th…

My thoughts after migrating some projects to Zend Expressive 2

It has been a long time since I first realized that handling file uploads in non-POST requests (like PUT) wasn't an easy task. One could assume the $_FILES array should be populated regardless the HTTP verb, but actually, PHP doesn't do it on its own.

After a long time wanting to find a solution to…

Managing PUT requests with file uploads in psr-7 and middleware PHP applications

The other day I was working on a Zend Expressive application I'm currently building. The application includes a REST API among other things, but it also has some endpoints which render HTML. In one of my tests of the REST API I saw that when an error occurs (404, 405 or 500), I was getting an HTML…

Creating a content-based Error Handler for Zend Expressive

I've been working with some different frameworks lately. One of them is Zend Expressive, and I've come to the conclusion that I don't need to choose between different frameworks; depending on the project, Expressive always fits my needs and…

Project Scalability with Zend Expressive

I was digging into Zend Expressive and how to use controllers that allow me to share dependencies between different routes, instead of having to use different middlewares every time. Abdul wrote a great article on this subject that you can find here, which also became part of Expressive's cookbook…

Dispatch REST-like requests with a single controller class in Zend Expressive

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 class="language-php"><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>
The same thing can be done like this with Silex:
<pre class="language-php"><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>
And also, with Expressive, you do it like this:
<pre class="language-php"><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>
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 class="language-php"><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>
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.

One of the trending topics in the PHP world nowadays is the one about microframeworks. It started some years ago with Slim and Silex, but recently it has been an explossion of new microframeworks. First, Slim's team announced the third version of its own framework, which implemented the psr-7 HTTP…

Alejandro Celaya | Blog

Software development, agile methodologies and open source software.

tag Archive — "zend-expressive"

— 2019 —

— 2017 —

— 2016 —

— 2015 —