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

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 class="language-yml"><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>
<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 class="language-diff"><code class="language-diff">on:
- pull_request: null
+ pull_request_target: null
</code></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 class="language-diff"><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>
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>

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…

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

I think it is doubtless that modern PHP embraces SOLID principles, and therefore, dependency injection. That's why every modern PHP application needs a dependency injection container to deal with it.

There are several options out there, depending on the way you like to work. Every container has a…

Reusing factories in Zend ServiceManager

Performance is an important subject when a project grows.
There are some good practices that make projects more maintainable, like <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Dependency_injection">dependency injection</a>, however, creating all the objects at the beginning of the request could reduce the application performance.
If some of the created objects are not finally used, we have wasted CPU time and memory for no reason.
<h3>DI pattern basics</h3>
The dependency injection pattern is &quot;simple&quot;. It is one way to implement the <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Dependency_inversion_principle">Dependency Inversion Principle</a>, and it says that all the objects that certain subject depends on should be injected on it when the subject is created, rather than letting the subject internally create them at runtime.
This decouples every part of the application and eases testing each subject.
However, what happens if some of those objects are not finally used?
<h3>The proxy pattern to the rescue</h3>
A proxy is a lightweight wrapper for an expensive object. It implements the same type of the wrapped object, but delays the object creation until it is going to be really used, for example by overriding all the public methods and initializing the wrapped object the first time one of them is called.
If we used proxies for every expensive dependency, the previous problem would be solved. We can still inject the dependency, but it will be wrapped by the proxy, which will create the object itself once we need it, or never, if it is not finally used.
This is the principle behind lazy services. The ServiceManager makes use of the <a target="_blank" rel="noopener noreferrer" href="https://github.com/Ocramius/ProxyManager">ocramius/proxy-manager</a> package to create proxies on the fly for all the services configured as lazy.
<h3>Lazy services config</h3>
The <code>lazy_services</code> config block used to be an independent block on v2 of the ServiceManager. On v3 it has been integrated on the ServiceManager configuration itself, along with <code>factories</code>, <code>invokables</code> and such.
This is an example of <code>lazy_services</code> usage:
<pre class="language-php"><code class="language-php">use Acelaya\Database\DbConnFactory;
use Acelaya\Service\MyExpensiveService;
use Acelaya\Service\MyExpensiveServiceFactory;
use Zend\ServiceManager\Proxy\LazyServiceFactory;
use Zend\ServiceManager\ServiceManager;

$sm = new ServiceManager([
 &#x27;factories&#x27; =&gt; [
 &#x27;db_connection&#x27; =&gt; DbConnFactory::class,
 MyExpensiveService::class =&gt; MyExpensiveServiceFactory::class,
 ],

 &#x27;lazy_services&#x27; =&gt; [
 &#x27;class_map&#x27; =&gt; [
 &#x27;db_connection&#x27; =&gt; \PDO::class,
 MyExpensiveService::class =&gt; MyExpensiveService::class,
 ],
 &#x27;proxies_target_dir&#x27; =&gt; &#x27;data/proxies&#x27;,
 &#x27;proxies_namespace&#x27; =&gt; &#x27;AcelayaProxy&#x27;,
 &#x27;write_proxy_files&#x27; =&gt; getenv(&#x27;APPLICATION_ENV&#x27;) === &#x27;prod&#x27;,
 ],

 &#x27;delegators&#x27; =&gt; [
 &#x27;db_connection&#x27; =&gt; [
 LazyServiceFactory::class,
 ],
 MyExpensiveService::class =&gt; [
 LazyServiceFactory::class,
 ],
 ],
]);
</code></pre>
But how does this work?
The first thing we have to do is register our services the regular way. In this case I have registered 2 services in the <code>factories</code> block, the <code>db_connection</code>and the <code>MyExpensiveService</code>. I can fetch those services in a normal way, and their factories will be hit in order to create them.
But we don&#x27;t want that. We want a proxy to be returned, wrapping the factory that will be hit only when the object is going to be used.
The next block, <code>lazy_services</code>, wraps some config params, like the <code>class_map</code>, which determines the class that needs to be proxied for each service (sometimes the service name is the class itself, but we still have to map it).
Finally, by making use of the <code>delegators</code> block, we have to add a built-in delegator to each lazy service, the <code>Zend\ServiceManager\Proxy\LazyServiceFactory</code>.
Important!: If your service needs more delegators, this one should be the last one of the list, so that it is the first one hit.
This delegator is the one which makes the magic. Instead of calling the next delegator until the factory is hit, it returns the generated proxy, and makes it wrap the next factory, so that the delegators chain which ends on the main factory, is only hit the first time the object is going to be used.
The rest of the <code>lazy_services</code> properties are only used for convenience.
<ul>
<li>The <code>proxies_target_dir</code> tells where proxies should be created. If you don&#x27;t define it, the system temp dir will be used.</li>
<li>The <code>proxies_namespace</code> tells the namespace to be used for proxy classes.</li>
<li>The <code>write_proxy_files</code> property is a boolean which tells whether to persist generated proxies or generate them every time. It is a good idea that you set it to false on development, so that proxies are regenerated every time, in case the proxied classes have changed, and true on production to improve performance, so that once a proxy has been created, the same file is used every time.</li>
</ul>
<h3>How to fetch lazy services</h3>
The good thing is that the whole process is transparent. You don&#x27;t need to change your code.
If you were already fetching services and you want to make them lazy, you just need to map them and add the <code>LazyServiceFactory</code> delegator in the ServiceManager config. Everything else remains the same.

Performance is an important subject when a project grows. There are some good practices that make projects more maintainable, like dependency injection, however, creating all the objects at the beginning of the request could reduce the application performance.

If some of the created objects are not…

Using ServiceManager 3 lazy services to improve your PHP application performance

Everyone who regularly visits my blog knows that I&#x27;m an absolute fan of the <a target="_blank" rel="noopener noreferrer" href="https://zendframework.github.io/zend-servicemanager/">Zend\ServiceManager</a> component.
It is always my choice to deal with dependency injection in any kind of project, more now that v3 has been released, which is faster and has a better public API.
The workflow while working with the <code>ServiceManager</code> is usually the same. You create a factory or abstract factory that creates a service and then you register that service into the <code>ServiceManager</code> itself.
Of course you have to optimize your code, and you should try to reuse the same factories whenever possible, and try not to abuse of abstract factories and initializers.
<h3>Detecting a problem</h3>
The thing is that if your project grows, you will end with lots of services, and probably lots of factories too.
There are services that are complicated to create, like the <code>Application</code> object in many frameworks, or services like doctrine&#x27;s <code>EntityManager</code>. They need to check a lot of configuration elements, and not only get some dependencies injected.
The factory pattern is perfect for these kind of services, but there are a lot of services too where you end up creating a factory just to fetch a couple services from the <code>ServiceManager</code> and injecting them in the new service constructor.
This could be an example:
<pre class="language-php"><code class="language-php">namespace Acelaya\Factory;

use Acelaya\Foo;
use Acelaya\MyService;
use Interop\Container\ContainerInterface;
use Zend\ServiceManager\Factory\FactoryInterface;

class MyFactory
{
 public function __invoke(ContainerInterface $container, $requestedName, array $options = null)
 {
 $foo = $container-&gt;get(Foo::class);
 $bar = $container-&gt;get(&#x27;bar&#x27;);
 
 return new MyService($foo, $bar);
 }
}
</code></pre>
In my applications, these kind of services are very usually more than a half of the total registered services, and at the end it is boring and repetitive, and you have to maintain a lot of classes that don&#x27;t really do much.
<h3>Proposing a solution</h3>
So I decided to find a solution that would allow me not to repeat the same task over and over.
After some research and trying some different solutions I ended up creating the <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/zsm-annotated-services">acelaya/zsm-annotated-services</a> package, which allows you to annotate your service constructors and use a common factory which is already provided. It supports both v2 and v3 of the ServiceManager.
By making use of the <code>$requestedName</code> argument that all ServiceManager factories receive (even in v2, although it is not in the FactoryInterface), and assuming that the service name is the fully qualified class name, that factory reads a special <code>@Inject</code> annotation in the service constructor, which contains the name of the services that need to be injected.
This way, the service in the previos example could be defined like this:
<pre class="language-php"><code class="language-php">namespace Acelaya;

use Acelaya\ZsmAnnotatedServices\Annotation\Inject;

class MyService
{
 /**
 * @Inject({Foo::class, &quot;bar&quot;})
 */
 public function __construct(Foo $foo, $bar)
 {
 // [...]
 }
}
</code></pre>
The <code>@Inject</code> annotation receives an array of service names in the same order that they need to be injected in the constructor. Then the provided <code>AnnotatedFactory</code> reads that list and fetches them from the <code>ServiceManager</code>, and finally creates the service and injects the dependencies in the same order. You just need to register the service like this:
<pre class="language-php"><code class="language-php">use Acelaya\MyService;
use Acelaya\ZsmAnnotatedServices\Factory\V3\AnnotatedFactory;
use Zend\ServiceManager\ServiceManager;

return new ServiceManager([
 &#x27;factories&#x27; =&gt; [
 MyService::class =&gt; AnnotatedFactory::class,
 ],
]);
</code></pre>
This is perfect, because we don&#x27;t need to create a new factory for every service. We can always use the provided factory to register many services.
That allows us not to have to maintain so many classes, so many tests and also it means that a lot less includes are going to be done by the autoloader.
Also, using factories instead of abstract factories is faster at runtime.
<h3>Considerations</h3>
There are, however, a couple of things to have in mind while using this package.
Processing the annotations on every request is very slow. That&#x27;s why this package allows you to provide a <a target="_blank" rel="noopener noreferrer" href="https://github.com/doctrine/cache">doctrine/cache</a> adapter where the result of processing the annotations is saved. If you use an in-memory cache adapter (like <code>ApcuAdapter</code>), this package has almost no performance penalty.
In order to register a cache adapter, you just need to register a service with the Acelaya\ZsmAnnotatedServices\Cache key that returns a <code>Doctrine\Common\Cache\Cache</code> instance. The key is provided as a <code>CACHE_SERVICE</code> constant in the <code>AnnotatedFactory</code> class, so the previos example could be improved like this:
<pre class="language-php"><code class="language-php">use Acelaya\MyService;
use Acelaya\ZsmAnnotatedServices\Factory\V3\AnnotatedFactory;
use Doctrine\Common\Cache\ApcuCache;
use Doctrine\Common\Cache\ArrayCache;
use Zend\ServiceManager\ServiceManager;

return new ServiceManager([
 &#x27;factories&#x27; =&gt; [
 MyService::class =&gt; AnnotatedFactory::class,
 AnnotatedFactory::CACHE_SERVICE =&gt; function () {
 return getenv(&#x27;APP_ENV&#x27;) === &#x27;production&#x27; ? new ApcuCache() : new ArrayCache();
 }
 ],
]);
</code></pre>
It is a good idea to provide a non-persistent cache for development environments.
Also, the package has currently some limitations. Some of them will probably get fixed in the future, as new versions are released.
<ul>
<li>It is not possible to perform setter or property injection, just constructor injection. Since setter injection is not a good practice, I&#x27;m not sure if this is going to change.</li>
<li>It is not possible to inject something that is not registered in the container. All the dependencies need to be services themselves.</li>
<li><del>If a service returns an array, you cannot pick just a key from it, but I will probably support this in future versions.</del> Update 2016-04-10. As of v0.2, it is already possible to fetch just one part of an array by using dot notation. For example, config.mail.smtp</li>
<li>The <code>AnnotatedFactory</code> cannot create services that are not identified by their fully qualified class names.</li>
</ul>
Anyway, if there is a service complex enough that you can&#x27;t create with annotations, you can always use regular factories.
<h3>Performance improvements</h3>
Update 2016-05-15
Since I published this article, we have started to use this library in one of my company&#x27;s biggest projects, and this is the result.
At the beginning, I started benchmarking the library by checking how much time was used to create thousands of services with or without it, and the result was that it was a very little bit slower with the <code>AnnotatedFactory</code>.
However, when a project grows, maintainability is also important, not only performance. Also, my benchmarks were made against a non-shared service, but always the same one, which was being created by the same factory.
My surprise was that after performing an important refactoring which allowed us to replace more than 150 factories by the same <code>AnnotatedFactory</code>, performance was improved by about a 20% (while using cache, of course).
I suppose this is due to the fact that the same factory instance is used to create many objects, which reduces the number of autoloader hits, the number of factories instantiated and the number of files included per request.

Everyone who regularly visits my blog knows that I'm an absolute fan of the Zend\ServiceManager component. It is always my choice to deal with dependency injection in any kind of project, more now that v3 has been released, which is faster and has a better public API.

The workflow while working…

Improving Zend\ServiceManager workflow with annotations

I have spoken many times at this blog about dependency injection, and how the ZF2 ServiceManager is one of the best tools to solve it. You can read these related articles to know more: How to properly use the Zend framework 2 service manager as a dependency injection containerAdvanced usage of…

Improve dependency injection in PHP apps with Zend Framework plugin managers

Some time ago I wrote the most successful article of this blog, Advanced usage of ServiceManager in Zend Framework 2, explaining all the ways a service can be created by making use of Zend\ServiceManager, the service container component in Zend Framework 2. On this article I'm going to show a real…

Managing objects creation and dependency injection with Zend\ServiceManager

After a time working with Zend Framework 2 one is used to use the ServiceManager, which is one of the most powerful components in the framework. It eases the creation of objects and performing dependency injection, allowing us to define how objects are created just in one place and letting the Serv…

Advanced usage of ServiceManager in Zend Framework 2

The service manager is one of the most important components in Zend Framework 2.
It easily allows us to handle object instances, construct them and share them between other objects.
By using a simple configuration file, we define how our objects have to be constructed, by a simple <code>new</code>, by using a <code>factory</code>, etc.
<pre class="language-php"><code class="language-php">return array(
 // ...

 &#x27;service_manager&#x27; =&gt; array(
 &#x27;invokables&#x27; =&gt; array(
 &#x27;SimpleService&#x27; =&gt; &#x27;Application\Service\SimpleService&#x27;
 ),
 &#x27;factories&#x27; =&gt; array(
 &#x27;ComplexService&#x27; =&gt; &#x27;Application\Service\Factory\ComplexService&#x27;
 ),
 &#x27;abstract_factories&#x27; =&gt; array(
 &#x27;Zend\Cache\Service\StorageCacheAbstractServiceFactory&#x27;,
 &#x27;Zend\Log\LoggerAbstractServiceFactory&#x27;,
 ),
 &#x27;aliases&#x27; =&gt; array(
 &#x27;translator&#x27; =&gt; &#x27;MvcTranslator&#x27;,
 ),
 ),

 // ...
)
</code></pre>
For more information about the service manager configuration read <a target="_blank" rel="noopener noreferrer" href="https://framework.zend.com/manual/2.3/en/modules/zend.service-manager.quick-start.html">this</a>.
<h3>ServiceLocatorAwareInterface</h3>
The ServiceLocatorAwareInterface was created to make the service manager to be automatically injected on any object implementing it.
A service initializer is used to accomplish this task. It is automatically registered by Zend Framework.
The problem is that this makes it very easy to use bad practices, because one tends to get services from the service manager instance without making dependency injection. As a consequence we get a very tight coupled code, very hard to test which is not what we want.
The <code>Zend\Mvc\Controller\AbstractController</code> class currently implements that interface, and there is an <a target="_blank" rel="noopener noreferrer" href="https://github.com/zendframework/zf2/issues/5168">opened debate</a> to remove it in the future.
<h3>Dependency Injection</h3>
The best way to work with the Service Manager is to use it as a dependency injection container.
By using service <a target="_blank" rel="noopener noreferrer" href="https://github.com/zendframework/zf2/blob/master/library/Zend/ServiceManager/FactoryInterface.php">factories</a>, <a target="_blank" rel="noopener noreferrer" href="https://github.com/zendframework/zf2/blob/master/library/Zend/ServiceManager/AbstractFactoryInterface.php">abstract factories</a> or <a target="_blank" rel="noopener noreferrer" href="https://github.com/zendframework/zf2/blob/master/library/Zend/ServiceManager/DelegatorFactoryInterface.php">delegator factories</a>, we can get the service manager just at the moment we create an object to fetch its dependencies, inject them in the object and return that object, without injecting the service manager itself.
This is a better practice, which allows us to easily test our code and decouples the components of our application.
<pre class="language-php"><code class="language-php">&lt;?php
namespace Application\Service\Factory;

use Zend\ServiceManager\FactoryInterface;
use Zend\ServiceManager\ServiceLocatorInterface;
use Application\Service\MyService;

class MyServiceFactory implements FactoryInterface
{
 public function createService(ServiceLocatorInterface $sm)
 {
 $oneDependency = $sm-&gt;get(&#x27;ModuleOne\Service\OneService&#x27;);
 $anotherDependency = $sm-&gt;get(&#x27;ModuleTwo\Service\AnotherService&#x27;);

 return new MyService($oneDependency, $anotherDependency);
 }
}
</code></pre>
As you can see in this factory, we have used the service manager just to locate the dependencies of the object we are creating, but then that object is not &quot;aware&quot; of the service manager any more, to avoid bad practices while using it.
With this implementation we can easily test the <code>MyService</code> class by injecting mocks.

The service manager is one of the most important components in Zend Framework 2. It easily allows us to handle object instances, construct them and share them between other objects.

By using a simple configuration file, we define how our objects have to be constructed, by a simple new, by using a…

Alejandro Celaya | Blog

Software development, agile methodologies and open source software.

tag Archive — "service-manager"

— 2017 —

— 2016 —

— 2015 —

— 2014 —