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

One of the first articles I wrote in this blog was an introduction to unit testing PHP applications. You can find it here in case you need to know the first steps and the theory. On this article I'm going to explain how to get a Zend Framework 2 module tested. It is indeed very similar to test any…

Unit testing Zend Framework 2 modules

Authentication is one of the most usual tasks we need to resolve in medium and large web applications.
There are many kinds of authentication. We could use database table authentication, HTTP authentication, LDAP authentication or any other kind of authentication we could imagine. Maybe we need to authenticate with a web service or by using OAuth.
The perfect solution would be to have a scalable component wich, today, let us authenticate over a MySQL database and store the session in the standard PHP session, but tomorrow can be easily changed to use HTTP authentication and store the session in a PostgreSQL database, without making big changes in our code.
Zend Framework 2 implements that in the <a target="_blank" rel="noopener noreferrer" href="http://framework.zend.com/manual/2.3/en/modules/zend.authentication.intro.html">Zend\Authentication component</a>
<h3>The Zend\Authentication component</h3>
This component has a main class, the <code>Zend\Authentication\AuthenticationService</code>, which encapsulates two adapters:
<ul>
<li>The authentication adapter, which is responsible of performing the authentication itself</li>
<li>The storage adapter, wich is responsible of storing the identity returned by the authentication adapter after a successful authentication. That identity could be any kind of data, from a simple array to a complex object.</li>
</ul>
Both of them have some predefined implementations, and we could even define our own by implementing <code>Zend\Authentication\Adapter\AdapterInterface</code> and <code>Zend\Authentication\Storage\StorageInterface</code>
As for this, we could say the Zend\Authentication component implements the <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Adapter_pattern">adapter pattern</a>, because the AuthetnicationService will never do the job, but delegate both tasks to its adapters. Changing one of the adapters should result in very little code modifications, because the rest of the application depends only in the AuthenticationService.
<h3>Installation</h3>
The easiest and recommended way to install this component is by using <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/">composer</a>
Just run <code>php composer.phar require zendframework/zend-authentication:2.3.*</code> to get the dependency installed.
It will suggest to install other Zend Framework 2 components that you will probably need if you want to use some of the built-in adapters and storages.
<blockquote>
For more information on how to use composer, read <a href="/2014/07/19/dependency-management-and-autoloading-in-php-projects-with-composer/">this</a>.
</blockquote>
<h3>Usage</h3>
Let&#x27;s imagine we want our users to use database authentication (the provided username and password will be checked in a table, for example), and store their data in a simple PHP session.
<h4>Create the service</h4>
This could be the creation of the AuthenticationService.
<pre class="language-php"><code class="language-php">// [...]

// We have passwords hashed with password_hash in the database,
// so we need some application level logic to compare hased and plain passwords
$credentialCallback = function ($passwordInDatabase, $passwordProvided) {
 return password_verify($passwordProvided, $passwordInDatabase);
};

// Create the authentication adapter
/** @var \Zend\Db\Adapter\Adapter $dbAdapter */
$adapter = new \Zend\Authentication\Adapter\DbTable\CallbackCheckAdapter(
 $dbAdapter,
 &#x27;users&#x27;, // Table name
 &#x27;username&#x27;, // Identity column
 &#x27;password&#x27;, // Credential column
 $credentialCallback // This adapter will run this function in order to check the password
);

// Create the storage adapter
$storage = new \Zend\Authentication\Storage\Session();

// Finally create the service
$authService = new \Zend\Authentication\AuthenticationService($storage, $adapter);
</code></pre>
And that would be all we need. That code could be located in some kind of factory or bootstrap script. We could also use a dependency injection container implementation to create the AuthenticationService object.
<h4>Using the service for authentication</h4>
Then, if we need to use the autentication service to perform an authentication, this would be the code. I have created a class that could act as a controller.
<pre class="language-php"><code class="language-php">class MyController
{
 /**
 * @var \Zend\Authentication\AuthenticationService
 */
 protected $authService;

 public function __construct(\Zend\Authentication\AuthenticationService $authService)
 {
 // We should get the previously created AuthenticationService injected
 $this-&gt;authService = $authService;
 }

 public function loginAction($username, $password)
 {
 /** @var \Zend\Authentication\Adapter\DbTable $adapter */
 $adapter = $this-&gt;authService-&gt;getAdapter();
 $adapter-&gt;setIdentity($username);
 $adapter-&gt;setCredential($password);

 $result = $this-&gt;authService-&gt;authenticate();
 return $result-&gt;isValid() ? &#x27;Login OK!&#x27; : &#x27;Wrong username or password&#x27;;
 }
}
</code></pre>
As you can see, we have to set the identity (usually a username) and the credential (the password) to the adapter wrapped by the AuthenticationService, and then call to the method authenticate.
That method will return a <code>Zend\Authentication\Result</code> object which can be used to know if authentication was OK (by calling the <code>isValid()</code> method) and get the identity data (by calling <code>getIdentity()</code>).
In any case, if authentication was valid, the AuthenticationService will automatically store the identity in the sotrage object.
The identity data contents will depend on the adapter implementation. In the case of the DbTable adapter, it is an array with information of the user&#x27;s table row.
<blockquote>
For this tutorial I have avoided the database connection configuration and how we get the username and password. If you want to know how to create a database adapter (<code>Zend\Db\Adapter\Adapter</code>) in Zend Framework 2, just read <a target="_blank" rel="noopener noreferrer" href="https://framework.zend.com/manual/2.3/en/modules/zend.db.adapter.html">this article</a>.
</blockquote>
<h4>Checking a stored identity</h4>
Now that we have performed the authentication, in next requests we need to check if the user is already logged in. The AuthenticationService is also capable of that.
Since we set a PHP session storage object, it can look at that storage for a previously persisted identity. If it exists we can assume a user is already logged in.
At some kind of pre-dispatch hook, after any operation that needs atuhentication is preformed, we could do something like this.
<pre class="language-php"><code class="language-php">// [...]

/** @var \Zend\Authentication\AuthenticationService $authService */
if (!$authService-&gt;hasIdentity()) {
 $response = new Response();
 $response-&gt;setCode(403);
 return $response;
}

// [...]
</code></pre>
The Response object is a fake object I made up just for this example, but it represents that if the user is not logged in we return a 403 error.
We could also redirect him to the login form, that just depends on the situation, but as you can see, the <code>hasIdentity()</code> method tells us if some user was logged in.
<h4>Deleting a stored identity</h4>
Finally any user could want to logout from the system. The AuthenticationService allows us to destroy the stored identity by calling <code>clearIdentity()</code>, which will make the method <code>hasIdentity()</code> to return false in subsequent calls.
Let&#x27;s extend the previous <code>MyController</code> class.
<pre class="language-php"><code class="language-php">class MyController
{
 /**
 * @var \Zend\Authentication\AuthenticationService
 */
 protected $authService;

 public function __construct(\Zend\Authentication\AuthenticationService $authService)
 {
 // We should get the previously created AuthenticationService injected
 $this-&gt;authService = $authService;
 }

 public function loginAction($username, $password)
 {
 // [...]
 }

 public function logoutAction()
 {
 $this-&gt;authService-&gt;clearIdentity();
 return &#x27;User logged out successfully&#x27;;
 }
}
</code></pre>
And that&#x27;s pretty much all you can (and probably need) to do with the AuthenticationService.

Authentication is one of the most usual tasks we need to resolve in medium and large web applications. There are many kinds of authentication. We could use database table authentication, HTTP authentication, LDAP authentication or any other kind of authentication we could imagine. Maybe we need to…

Managing authentication with Zend\Authentication in PHP projects

Some time ago, on January 2014, I decided to start writing a blog.
Seemed like a good idea. I might be able to show my skills and learn new ones at the same time.
I didn&#x27;t wanted to use a very complex tool for this purpose, or to create one of my own (why to reinvent the wheel?), so I decided that blogger or wordpress could be the right options.
After weighing the pros and cons of both options I opted for wordpress, because it seemed more customizable, and having a <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Virtual_private_server">VPS</a> could ease the self-hosting task.
At the begining it was a good solution, but finally proved to be hard to control. Not easy to customize the layout, very resource consuming, hard to optimize, etc.
I looked for alternatives and found an interesting one without all the previous problems, <a target="_blank" rel="noopener noreferrer" href="https://sculpin.io/">Sculpin</a>.
We discussed the tool in the <a target="_blank" rel="noopener noreferrer" href="https://twitter.com/symfony_zgz">Symfony Zaragoza</a> group, and I really loved it from the begining.
<h3>First approach to Sculpin</h3>
In the Github era, many static site generators have appeared, because Github allows us to host static sites for free. Those generators allows us to make a &quot;dynamic&quot; website which is compiled into a static site.
There are many alternatives. From <a target="_blank" rel="noopener noreferrer" href="https://jekyllrb.com/">Jekyll</a>, the Github official static site generator written in ruby, to <a target="_blank" rel="noopener noreferrer" href="http://blog.getpelican.com/">Pelican</a>, another python-powered alternative.
The problem is that I&#x27;m a PHP developer, and I&#x27;m not as confortable with those languages as I am with PHP, so I looked for a PHP alternative and Sculpin appeared.
Sculpin uses Symfony components, and is fully integrated with composer. I like both tools so I finally decided to use it.
For more information about how to use Sculpin, it has a very good <a target="_blank" rel="noopener noreferrer" href="https://sculpin.io/getstarted/">documentation</a>.
<h3>Migrating from Wordpress</h3>
There was a few features in wordpress that I didn&#x27;t wanted to loose and are not easy to implement in a static site, like comments, built-in search and RSS feed. I also didn&#x27;t wanted to loose the already indexed content, so I needed to keep the old URLs, at least those pointing to the articles.
Luckily for me, there is a <a target="_blank" rel="noopener noreferrer" href="https://github.com/sculpin/sculpin-blog-skeleton">Sculpin Blog Skeleton</a> in github with many of the work already done. It includes an atom feed that is refreshed every time you compile your site.
To get comments in my static blog, I have used <a target="_blank" rel="noopener noreferrer" href="https://disqus.com/">disqus</a>. It uses a very easy javascript api to host your comments which are associated to the article&#x27;s unique URL. Also, they allow to import comments from wordpress, so I could also keep the old comments.
There are other platforms like this, but they don&#x27;t look as good as disqus.
The built-in search was one of the hardest features to implement. I have used <a target="_blank" rel="noopener noreferrer" href="http://lunrjs.com/">lunr.js</a>, a javascript full text search engine, but I was not sure how to deal with it, so I finally found a Sculpin blog using it, and copy-pasted the needed code. Thanks to <a target="_blank" rel="noopener noreferrer" href="http://blog.andrewshell.com">Andrew Shell</a> for his code.
After this I just needed to get the articles from wordpress.
Sculpin uses <a target="_blank" rel="noopener noreferrer" href="http://twig.sensiolabs.org/">twig</a> templates and/or <a target="_blank" rel="noopener noreferrer" href="http://es.wikipedia.org/wiki/Markdown">markdown</a> to write articles, so it&#x27;s easy to copy-paste html documents on them. That&#x27;s what I did. A little customization and done.
Keeping the URLs was easy, because I was using the y/m/d/foobar form in wordpress, and the Sculpin skeleton uses that format by default.
Finally I was considering to host the blog in Github, but I decided to use my VPS, to use some htaccess tricks, like some rewrite rules in order to redirect old URLs to new ones and set a customized 404 page.
The result is the blog you are now seeing.
<h3>Conclusion</h3>
My conclusion is that a dynamically generate static site is a good solution for a personal blog. It loads superfast, is very SEO friendly and is easily customizable, but it has an important problem. Only advanced users can use it.
The lack of <a target="_blank" rel="noopener noreferrer" href="https://es.wikipedia.org/wiki/WYSIWYG">WYSIWYG</a> editor makes users with no experience on HTML/Markdown (at least) impossible to deal with this kind of sites.
Also, the site needs to be deployed every time a new article is written.
Apart from that, as I said, It&#x27;s a good solution, and Sculpin is a really good tool. If you are curious, you can see the pre-compiled version of this blog in github, <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/blog">here</a>.

Some time ago, on January 2014, I decided to start writing a blog. Seemed like a good idea. I might be able to show my skills and learn new ones at the same time.

I didn't wanted to use a very complex tool for this purpose, or to create one of my own (why to reinvent the wheel?), so I decided that…

Migrating from Wordpress to Sculpin

One of the common problems we have to confront when starting a new PHP project is how to handle the different dependencies we are going to have.
One could think the easier solution is to download all the libraries we are going to need, put them in a <code>lib</code> directory and add them to the version control of the project, but this could be problematic. Let&#x27;s see why.
The main problems of using this practice are this.
<ul>
<li>Dependencies of dependencies: Our dependencies may have their own dependencies that we will also need to download.</li>
<li>Updates: What happens if we need a new feature in the last version of one dependendency? We are going to have to update it manually, and that can be a hard task. Baybe even the new version has new dependencies of its own that we will need to download.</li>
<li>Autoloading: How do we deal with autoloading the classes in the dependencies? Some of them may have its own autoloading system, but anyway, we are going to need to <code>include</code> all the autoloaders of each dependency.</li>
</ul>
How do we solve all of this? The answer is <a target="_blank" rel="noopener noreferrer" href="http://getcomposer.org">Composer</a>.
<h3>Starting with composer</h3>
Composer has become the dependency manager in the main PHP projects. It uses its own library repository (<a target="_blank" rel="noopener noreferrer" href="https://packagist.org/">packagist</a>) to handle dependencies, but you can setup private repositories too.
It uses a small configuration file, the <code>composer.json</code>, to know which are our dependencies, and it will download their dependencies recursively without us having to do anything special.
We can define an autoloading strategy in that file too, and forget about that task for our project and our dependencies.
This are some examples of famous PHP project&#x27;s <code>composer.json</code> files:
<ul>
<li><a target="_blank" rel="noopener noreferrer" href="https://github.com/zendframework/zf2/blob/master/composer.json">Zend Framework</a></li>
<li><a target="_blank" rel="noopener noreferrer" href="https://github.com/symfony/symfony/blob/master/composer.json">Symfony</a></li>
<li><a target="_blank" rel="noopener noreferrer" href="https://github.com/doctrine/doctrine2/blob/master/composer.json">Doctrine</a></li>
<li><a target="_blank" rel="noopener noreferrer" href="https://github.com/aws/aws-sdk-php/blob/master/composer.json">AWS PHP SDK</a></li>
<li><a target="_blank" rel="noopener noreferrer" href="https://github.com/Seldaek/monolog/blob/master/composer.json">Monolog</a></li>
<li><a target="_blank" rel="noopener noreferrer" href="https://github.com/thephpleague/flysystem/blob/master/composer.json">Flysystem</a></li>
</ul>
Now lets see a simpler composer file:
<pre class="language-json"><code class="language-json">{
 &quot;name&quot; : &quot;acelaya/zf2-acmailer&quot;,
 &quot;description&quot; : &quot;Mail sending module for Zend Framework 2&quot;,
 &quot;type&quot; : &quot;library&quot;,
 &quot;authors&quot; : [
 {
 &quot;name&quot; : &quot;Alejandro Celaya Alastrué&quot;,
 &quot;email&quot; : &quot;alejandro@alejandrocelaya.com&quot;,
 &quot;homepage&quot; : &quot;http://www.alejandrocelaya.com&quot;,
 &quot;role&quot; : &quot;Developer&quot;
 }
 ],
 &quot;keywords&quot; : [
 &quot;mail&quot;,
 &quot;zend&quot;,
 &quot;php&quot;
 ],
 &quot;homepage&quot; : &quot;https://github.com/acelaya/ZF2-AcMailer&quot;,
 &quot;license&quot; : [
 &quot;BSD&quot;
 ],
 &quot;require&quot; : {
 &quot;php&quot; : &quot;&gt;=5.3.0&quot;,
 &quot;zendframework/zendframework&quot;: &quot;&gt;=2.2.2&quot;
 },
 &quot;require-dev&quot;: {
 &quot;phpunit/phpunit&quot;: &quot;&gt;=3.7&quot;,
 &quot;squizlabs/php_codesniffer&quot;: &quot;1.*&quot;,
 &quot;phploc/phploc&quot;: &quot;*&quot;,
 &quot;pdepend/pdepend&quot; : &quot;1.1.0&quot;,
 &quot;phpmd/phpmd&quot; : &quot;1.4.*&quot;,
 &quot;sebastian/phpcpd&quot;: &quot;*&quot;,
 &quot;theseer/phpdox&quot;: &quot;0.6.5&quot;
 },
 &quot;autoload&quot; : {
 &quot;psr-0&quot; : {
 &quot;AcMailer&quot; : &quot;src/&quot;
 },
 &quot;classmap&quot; : [
 &quot;./Module.php&quot;
 ]
 }
}
</code></pre>
This is the composer file of my Zend Framework 2 module <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/ZF2-AcMailer">AcMailer</a>. Let&#x27;s explain it.
The properties name, description, type, authors, keywords, homepage and license are just metadata to provide useful information to other users and ease finding the project in <a target="_blank" rel="noopener noreferrer" href="https://packagist.org/">packagist</a>.
The require property is the place where we define our dependencies and the version we want to install. We can define here the minimum required PHP version and even the php modules we need (like <code>php-pdo</code>, <code>php-intl</code> and such).
The require-dev property allows us to define other dependencies that won&#x27;t be necessery in a production environment, like testing or documentation tools.
Finally the autoload property is where we define how our own classes are loaded. It is very easy to define a <code>psr-0</code> or <code>psr-4</code> autoloading strategy, but we can even define a <code>classmap</code> with a list of paths to files.
<blockquote>
You don&#x27;t have to remember the <code>composer.json</code> schema. You can interactively create it by running <code>php composer.phar init</code>.
</blockquote>
<h3>Installing dependencies</h3>
Once this is defined we just need the composer binary file (usually in phar format), that can be found <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/download/">here</a>, and run <code>php composer.phar install</code>.
This will create a <code>vendor</code> folder in the root of our project, download our dependencies there, the dependencies of our dependencies, and set-up an autoloader that will be able to load all our dependencies and our own classes as well.
After this it&#x27;s enough with a single <code>include</code> statement to <code>vendor/autoload.php</code> to be able to access any class.
If later in the project we need to update an existing dependency, add new dependencies or change the autoloading, we just need to update the information in the <code>composer.json</code> file and run <code>php composer.phar update</code> to update dependencies and autoloader.
<blockquote>
It is recommended to include the composer binary in the PATH to be able to run <code>composer</code> instead of <code>php composer.phar</code>.
</blockquote>
<blockquote>
If you are using a VCS like <a target="_blank" rel="noopener noreferrer" href="https://git-scm.com/">git</a> in your project you will probably want to ignore your <code>vendor</code> folder.
</blockquote>
<h3>Advanced usages</h3>
This should be enough to start working with composer, but it is a much more powerful tool with more features. It is not a bad idea to take a quick read to its <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/doc/">documentation</a>, but let&#x27;s see the main advanced features.
<ul>
<li>Classmap autoloader: By running <code>composer dumpautoload --optimize</code> we can generate a much faster autoloader which defines a class =&gt; file map array with all the classes handled by composer. This is the more suitable autoloader for production environments.</li>
<li>Production dependencies: If we include de modifier <code>--no-dev</code> while installing or updating dependencies, it will ignore (or remove) the require-dev dependencies. For example <code>composer update --no-dev</code></li>
<li>Private repositories: If you want to install dependencies from repositories other than <a target="_blank" rel="noopener noreferrer" href="https://packagist.org/">packagist</a>, you can do it by using the repositories property. It supports many types of repositories, from VCS to PEAR repositories. Complete documentation <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/doc/05-repositories.md">here</a>.</li>
<li>Global packages: If you want to install dependencies globally, just add the <code>global</code> keyword before the <code>install</code> or <code>update</code>. That will install the dependencies in the <code>~/.composer/vendor</code> directory instead of installing them in the local <code>vendor</code> directory. For example <code>composer global update</code>.</li>
</ul>
And that&#x27;s all you need to know to start working with composer.
Update 2015-04-25: I&#x27;ve written an article addressing advanced concepts that is a good continuation to this one. <a href="/2015/04/25/composer-advanced-concepts/">Composer advanced concepts</a>.

One of the common problems we have to confront when starting a new PHP project is how to handle the different dependencies we are going to have. One could think the easier solution is to download all the libraries we are going to need, put them in a lib directory and add them to the version control…

Dependency management and autoloading in php projects with composer

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…

How to properly use the Zend framework 2 service manager as a dependency injection container

Some weeks ago, I explained how to create <a href="/2014/05/21/create-modules-with-sub-namespaces-in-zend-framework-2/">modules with sub-namespaces</a> in a Zend Framework 2 application.
On that article I created an example module that we could add in our <code>modules</code> directory, but what if we want to distribute that module through the <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/">composer</a> network to be installed as a vendor module.
There are a few considerations we have to take into account, since Zend Framework loads the Module class first in one way and then the classes of that module can be loaded by using the autoloader config provided by the Module class.
If the Module class is not in the include path, Zend Framework will try to autoload it, but modules in the vendor folder are not loaded the same way as modules in the modules folder.
By default, with no sub-namespaces, we will get a folder with the name of the vendor (acelaya, for example) and inside of it a folder for each module (zf2-acmailer, for example).
If our module does not follow this standard folder structure we will have to tell Zend Framework where the Module class is, for example in the application config file, in the module_paths part, like this.
If the Module class is not in the include path, Zend Framework will try to autoload it, but modules in the <code>vendor</code> folder are not loaded the same way as modules in the <code>modules</code> folder.
By default, with no sub-namespaces, we will get a folder with the name of the vendor (<a target="_blank" rel="noopener noreferrer" href="https://packagist.org/packages/acelaya/">acelaya</a>, for example) and inside of it a folder for each module (<a target="_blank" rel="noopener noreferrer" href="https://packagist.org/packages/acelaya/zf2-acmailer">zf2-acmailer</a>, for example).
If our module does not follow this standard folder structure we will have to tell Zend Framework where the Module class is, for example in the application config file, in the <code>module_paths</code> part, like this.
<pre class="language-php"><code class="language-php">&#x27;module_paths&#x27; =&gt; array(
 &#x27;./module&#x27;,
 &#x27;./vendor&#x27;,
 &#x27;HappyFactory\WebService\Module&#x27; =&gt; &#x27;./vendor/myname/happyfactory/WebService&#x27;
)
</code></pre>
But this is not the perfect solution, since we will need to update the config file for each sub-namespaced module we install, and paths can change in the future.
The best solution is to use the composer autoloading system to autoload the Module class, so we can use the folder structure we want for the module, and then the module autoloader config itself will take care to load the rest of the classes.
This way, our composer.json autoload for the module will look like this.
<pre class="language-json"><code class="language-json">{
 &quot;autoload&quot; : {
 &quot;psr-0&quot; : {
 &quot;HappyFactory\\WebService&quot; : &quot;src/&quot;
 },
 &quot;classmap&quot; : [
 &quot;./Module.php&quot;
 ]
 }
}
</code></pre>
The <code>psr-0</code> part tells composer how to load the classes in the src folder. The <code>classmap</code> part makes composer to be able to load the Module class in a specific file, so Zend Framework will be able to load it by using the composer autoloader just by including it in our modules list like this.
<pre class="language-php"><code class="language-php">&#x27;modules&#x27; =&gt; array(
 &#x27;Application&#x27;,
 &#x27;HappyFactory\WebService&#x27;,
 &#x27;AcMailer&#x27;,
),
</code></pre>
Even so, I would recommend to register the module at the same folder where the Module class is, that is to say, in our exampple, the WebService folder, instead of the HappyFactory folder.
Here is an example of a real module with subnamespaces you can install with composer <a target="_blank" rel="noopener noreferrer" href="https://github.com/zasDev/common">https://github.com/zasDev/common</a>. The module is in the namespace <code>ZasDev\Commons</code>. You can install it in your project by adding <code>&quot;zasdev/commons&quot; : &quot;0.*&quot;</code> to your composer.json file.
And that&#x27;s all. Nice and easy.

Some weeks ago, I explained how to create modules with sub-namespaces in a Zend Framework 2 application. On that article I created an example module that we could add in our modules directory, but what if we want to distribute that module through the composer network to be installed as a vendor…

Create modules with sub-namespaces in Zend Framework 2. Part II

The Zend Framework 2 module system is one of its greatest features. You can create re-usable modules very easily.
Each module has its own namespace, and each one of them should provide an autoloader implementation for the application to be able to load its classes.
<h3>The basics</h3>
Usually we give a name to each module and that is the namespace we are going to use for it.
For example, the default module use to be named Application. Its Module class belongs to the Application namespace, making its fully qualified name Application\Module.
Any other class in that module, for example a Service, will belong to the same namespace too. For example Application\Service\FooService.
The same will be applicable for any other module name. Authentication, Admin, WebService… Whatever you think is valid.
The module folder usually has the same name as the module, and the Module class is located in the root of that folder. Then we have an src folder inside of it where a new directory is created for each level in the namespace. In our Application example this would be the folder structure.
<pre><code>modules
 Application
 src
 Application
 Controller
 FooController.php
 Service
 FooService.php
 ...
 Module.php
 ...
</code></pre>
The module class has a method where we define how to load the classes in the module. This could be the Application\Module class
<pre class="language-php"><code class="language-php">&lt;?php
namespace Application;

use Zend\ModuleManager\Feature\AutoloaderProviderInterface;

class Module implements AutoloaderProviderInterface
{
 public function getAutoloaderConfig()
 {
 return array(
 &#x27;Zend\Loader\StandardAutoloader&#x27; =&gt; array(
 &#x27;namespaces&#x27; =&gt; array(
 __NAMESPACE__ =&gt; __DIR__ . &#x27;/src/&#x27; . __NAMESPACE__,
 ),
 ),
 );
 }
}
</code></pre>
A Zend\Loader\StandardAutoloader is created defining any class in the same namespace as the Module namespace should be located in the src folder.
<h3>Sub-namespaces in the module</h3>
But what happens if we want to use a sub-namespace in our module, lets say because we have to use a common namespace between all of our modules with the name of our company.
Let&#x27;s assume our company is called Happy Factory inc. We might want our Application module to use the HappyFactory\Application namespace, and our WebService module to use the HappyFactory\WebService namespace.
This can be easily done by making some changes to our folder structure and autoloader definition.
The module class will be changed to look like this.
<pre class="language-php"><code class="language-php">&lt;?php
namespace HappyFactory\Application;

use Zend\ModuleManager\Feature\AutoloaderProviderInterface;

class Module implements AutoloaderProviderInterface
{
 public function getAutoloaderConfig()
 {
 return array(
 &#x27;Zend\Loader\StandardAutoloader&#x27; =&gt; array(
 &#x27;namespaces&#x27; =&gt; array(
 __NAMESPACE__ =&gt; __DIR__ . &#x27;/src/&#x27; . str_replace(&quot;\\&quot;, &quot;/&quot;, __NAMESPACE__),
 ),
 ),
 );
 }
}
</code></pre>
We just updated the namespace and make sure to load classes within that namespace.
Now our folder structure. In the basic example the module folder was placed inside the modules folder (the folder used in Zend Framework 2 by default to load modules), but in this case we are going to have another folder in between, the HappyFactory folder.
<pre><code>modules
 HappyFactory
 Application
 src
 HappyFactory
 Application
 Controller
 FooController.php
 Service
 FooService.php
 ...
 Module.php
 WebService
 src
 HappyFactory
 WebService
 Controller
 UsersController.php
 Service
 AnotherService.php
 ...
 Module.php
 ...
 ...
</code></pre>
This method is much more verbose and has more empty directories, but it works, and can be combined with regular modules too, just place them outside of the HappyFactory folder.
To load this sub-namespaced modules just add the namespace of the Module class (HappyFactory\Application, HappyFactory\WebService…) in the list of modules in the application.config.php file like this.
<pre class="language-php"><code class="language-php">...

&#x27;modules&#x27; =&gt; array(
 &#x27;ZendDeveloperTools&#x27;,
 &#x27;HappyFactory\Application&#x27;,
 &#x27;HappyFactory\WebService&#x27;,
 &#x27;AcMailer&#x27;,
 &#x27;AcAssets&#x27;,
),

...
</code></pre>
They will be properly loaded with the rest of the company modules and third-party modules.
UPDATE 2014-06-21
You can continue reading <a href="/2014/06/21/create-modules-with-sub-namespaces-in-zend-framework-2-part-ii/">the second part</a> where I&#x27;m explaining how to create, install and enable vendor modules with sub-namespaces.
UPDATE 2014-06-23
<h3>Properly resolving view template paths</h3>
Resolving template paths is not immediate in sub-namespaced modules. It was first said <a href="/2014/06/21/create-modules-with-sub-namespaces-in-zend-framework-2-part-ii/#comment-391">here</a>.
By default, if you don&#x27;t set the template to a ViewModel, it is resolved to a path which is (top level controller namespace)/(controller name)/(action name), which is not what we want here.
In a standard module, let&#x27;s say Application, with an Application\Controller\IndexController and an indexAction, the path would be application/index/index.
In a sub-namespaced module like HappyFactory\WebService with a HappyFactory\WebService\Controller\IndexController, the resolved path would be happy-factory/index/index, the same as the one resolved if the module was HappyFactory\Application\Controller\IndexController. If we want them to be happy-factory/web-service/index/index, as we could expect, we have to use the <code>controller_map</code> configuration entry, which was introduced in ZF 2.3.
<pre class="language-php"><code class="language-php">&lt;?php
return array(
 &#x27;view_manager&#x27; =&gt; array(
 &#x27;template_map&#x27; =&gt; array(),
 &#x27;controller_map&#x27; =&gt; array(
 &#x27;HappyFactory\WebService&#x27; =&gt; true,
 &#x27;HappyFactory\Application&#x27; =&gt; true,
 ),
 &#x27;template_path_stack&#x27; =&gt; array(
 __DIR__ . &#x27;/../view&#x27;,
 ),
 // ...
 ),
 // ...
)
</code></pre>
Once we have set this for each of our modules (or once for the top level namespace), the template paths would be resolved as one could expect in a sub-namespaced module.

The Zend Framework 2 module system is one of its greatest features. You can create re-usable modules very easily. Each module has its own namespace, and each one of them should provide an autoloader implementation for the application to be able to load its classes.

The basics

Usually we give a name…

Create modules with sub-namespaces in Zend Framework 2

Last week I passed the <a target="_blank" rel="noopener noreferrer" href="http://www.zend.com/en/yellow-pages/ZEND021590">Zend Framework 2 Certified Architect</a> exam.
I will try to explain how did I prepare it.
<h3>Studying</h3>
In late March I recived an email that my exam was going to be on May the seventh, so I saw that I was going to have 4-6 weeks to prepare it. I could have started earlier, but maybe I&#x27;m a little lazy.
Since this was one of the first times the Zend Framework certification exam was based on version 2 (2.2), there was no documentation or examples in the internet, so I decided to just read the whole <a target="_blank" rel="noopener noreferrer" href="https://framework.zend.com/manual/2.2/en/user-guide/overview.html">documentation</a>. I was working with Zend Framework 2 in my job, so I could apply the theory in real projects.
My main problem was that I needed to compatibilize the study with my work, so I started studying about an hour a day. Some days I didn&#x27;t studied, but some weekends I could spend more time on it.
About two weeks after I started I saw I wasn&#x27;t going to be able to read all the documentation, so I started to read the components documentation in order of importance. This finally was proved to be a good system. I got no questions in my exam about <code>Zend\Barcode</code>, <code>Zend\Debug</code>, <code>Zend\Navigation</code> and such trivial components, but plenty of questions about <code>EventManager</code>, <code>ServiceManager</code>, <code>ModuleManager</code>, <code>Mvc</code> and <code>Forms</code>.
I neither had any questions of ZendService components.
<h3>Questions</h3>
The <code>ServiceManager</code> was present in many questions, as well as any kind of plugin manager (<code>ControllerManager</code>, <code>ViewHelperManager</code>…)
In those questions a piece of code was present where many services were registered in different ways, from a plain PHP array, from a <code>Zend\ServiceManager\Config</code> object or directly by calling methods from a <code>ServiceManager</code> instance.
Then the <code>ServiceManager</code> instance was used to retrive services, and you were supposed to know which ones were the same instance, what type of object do they return or even which services return the same instance.
The <code>EventManager</code> was also present in many forms. In some questions you were supposed to know the difference between the <code>EventManager</code> and the <code>SharedEventManager</code>, how to attach listeners or how to use <code>ListenerAggregates</code>.
The <code>MvcEvent</code> appeared in many questions too, where you need to know about the <code>EventManager</code> and the <code>MVC</code> layer.
A good bunch of questions was related with Forms, Validators and Filters.
In those questions you may be asked about the <code>FormElementManager</code>, get an element where some filters were attached and know which would be the final output from a specific input, or get a form with many elements with validators and know if an input was going to make the form valid or not.
These was the most important parts, but I also had questions about <code>Hydrators</code>, <code>Zend\Db</code>, the <code>ModuleManager</code> and how Modules are loaded, <code>Zend\View</code> with its events layer and the <code>PhpRenderer</code>, <code>Zend\I18n</code>, <code>Zend\Cache</code> or <code>Zend\Config</code>.
<h3>Conclusions</h3>
I made the exam with two other people I knew. The three of us thought that it wasn&#x27;t a very complicated exam, with no tricky questions (like <code>$foo = &quot;Bar&quot;; echo $fo;</code>), but you have to know the theory very well, how the framework works and how it is supposed to be used.
It is important to know about factories, dependency injection and good practices.
It would be good to work with Zend Framework 2 as long as you study, because that shows you how it behaves in real environments. Sometimes the Albums tutorial is not enough.
I hope this article helps to anyone preparing the exam. I wish you luck.

Last week I passed the Zend Framework 2 Certified Architect exam. I will try to explain how did I prepare it.

Studying

In late March I recived an email that my exam was going to be on May the seventh, so I saw that I was going to have 4-6 weeks to prepare it. I could have started earlier, but maybe…

How to prepare the Zend Framework 2 Certified Architect exam

There are many situations where you need multiple database connections in your application.
In this post I am going to explain how to configure a connection to 2 databases to be used by Doctrine in Zend Framework 2 and how to configure a master-slave connection. Both examples will be using MySQL.
Lets asume we have a <code>doctrine_connection.global.php</code> configuration file, where we are going to define the doctrine database connection configuration. Any other doctrine configuration should be defined in other configuration files.
For further information on how Zend Framework 2 configuration works take a look at its <a target="_blank" rel="noopener noreferrer" href="https://framework.zend.com/manual/2.2/en/tutorials/config.advanced.html">documentation</a>.
<h3>Two connections. Two entity managers.</h3>
Sometimes we could need to connect to two different databases and handle their connections separately, maybe because we need to work with our application database and a third party application database that can&#x27;t be integrated in our system.
For this purpose, Doctrine allows us to define multiple connections and different EntityManagers to handle them. This could be our configuration file.
<pre class="language-php"><code class="language-php">&lt;?php
return array(

 &#x27;doctrine&#x27; =&gt; array(

 // Connections
 &#x27;connection&#x27; =&gt; array(
 &#x27;orm_default&#x27; =&gt; array(
 &#x27;driverClass&#x27; =&gt;&#x27;Doctrine\DBAL\Driver\PDOMySql\Driver&#x27;,
 &#x27;params&#x27; =&gt; array(
 &#x27;host&#x27; =&gt; &#x27;localhost&#x27;,
 &#x27;port&#x27; =&gt; &#x27;3306&#x27;,
 &#x27;user&#x27; =&gt; &#x27;root&#x27;,
 &#x27;password&#x27; =&gt; &#x27;foobar&#x27;,
 &#x27;dbname&#x27; =&gt; &#x27;main_database&#x27;,
 &#x27;driverOptions&#x27; =&gt; array(
 PDO::MYSQL_ATTR_INIT_COMMAND =&gt; &#x27;SET NAMES utf8&#x27;
 ),
 )
 ),
 &#x27;orm_another&#x27; =&gt; array(
 &#x27;driverClass&#x27; =&gt;&#x27;Doctrine\DBAL\Driver\PDOMySql\Driver&#x27;,
 &#x27;params&#x27; =&gt; array(
 &#x27;host&#x27; =&gt; &#x27;localhost&#x27;,
 &#x27;port&#x27; =&gt; &#x27;3306&#x27;,
 &#x27;user&#x27; =&gt; &#x27;root&#x27;,
 &#x27;password&#x27; =&gt; &#x27;foobar&#x27;,
 &#x27;dbname&#x27; =&gt; &#x27;another_database&#x27;,
 &#x27;driverOptions&#x27; =&gt; array(
 PDO::MYSQL_ATTR_INIT_COMMAND =&gt; &#x27;SET NAMES utf8&#x27;
 ),
 )
 ),
 ),

 // Entity managers
 &#x27;entitymanager&#x27; =&gt; array(
 &#x27;orm_another&#x27; =&gt; array(
 &#x27;connection&#x27; =&gt; &#x27;orm_another&#x27;,
 )
 ),

 )
);
</code></pre>
As you can see, two connections have been defined, the standard <code>orm_default</code> and a new <code>orm_another</code> connection.
To access the standard connection we can use the already existing <code>Doctrine\ORM\EntityManager</code> service or even the <code>doctrine.entitymanager.orm_default</code> service.
To access any other connection we should use, for example, the <code>doctrine.entitymanager.orm_another</code> service, where the last part of the service name is the connection name. This will return a new EntityManager instance that can be used to handle the other database
Then we only need to inject the desired EntityManager on each service that will need to make use of them.
<h3>Master-slave connection. One entity manager.</h3>
The master-slave connection is very important in a high performance environment.
We can have a good cache system or server replication with load balancer, but finally if we only have one database, that will slow down the whole application. The master-slave system allows us to define &quot;multiple&quot; database connections that MySQL will internally synchronize.
It defines a unique database entry point, that is used for write operations (INSERT, UPDATE, DELETE) and multiple databases for reading operations (SELECT).
To set up this kind of connection in our <code>doctrine_connection.global.php</code> configuration file we could use something like this.
<pre class="language-php"><code class="language-php">&lt;?php
return array(

 &#x27;doctrine&#x27; =&gt; array(
 &#x27;connection&#x27; =&gt; array(
 &#x27;orm_default&#x27; =&gt; array(
 &#x27;wrapperClass&#x27; =&gt; &#x27;Doctrine\DBAL\Connections\MasterSlaveConnection&#x27;,
 &#x27;params&#x27; =&gt; array(
 &#x27;driver&#x27; =&gt; &#x27;pdo_mysql&#x27;,
 &#x27;master&#x27; =&gt; array(
 &#x27;host&#x27; =&gt; &#x27;localhost&#x27;,
 &#x27;port&#x27; =&gt; &#x27;3306&#x27;,
 &#x27;user&#x27; =&gt; &#x27;root&#x27;,
 &#x27;password&#x27; =&gt; &#x27;foobar&#x27;,
 &#x27;dbname&#x27; =&gt; &#x27;mydatabase&#x27;,
 ),
 &#x27;slaves&#x27; =&gt; array(
 array(
 &#x27;host&#x27; =&gt; &#x27;localhost&#x27;,
 &#x27;port&#x27; =&gt; &#x27;3306&#x27;,
 &#x27;user&#x27; =&gt; &#x27;root&#x27;,
 &#x27;password&#x27; =&gt; &#x27;foobar&#x27;,
 &#x27;dbname&#x27; =&gt; &#x27;mydatabase2&#x27;,
 ),
 array(
 &#x27;host&#x27; =&gt; &#x27;localhost&#x27;,
 &#x27;port&#x27; =&gt; &#x27;3306&#x27;,
 &#x27;user&#x27; =&gt; &#x27;root&#x27;,
 &#x27;password&#x27; =&gt; &#x27;foobar&#x27;,
 &#x27;dbname&#x27; =&gt; &#x27;mydatabase3&#x27;,
 ),
 ),
 ),
 )
 )
 ),

);
</code></pre>
In this example we have defined a master connection and two slave connections. Doctrine will be aware of handling connections internally, it is transparent for us, we only need to use one EntityManager by getting the <code>Doctrine\ORM\EntityManager</code> service and we won&#x27;t need to change anything in the code.

There are many situations where you need multiple database connections in your application. In this post I am going to explain how to configure a connection to 2 databases to be used by Doctrine in Zend Framework 2 and how to configure a master-slave connection. Both examples will be using MySQL.

L…

Configure multiple database connections in Doctrine with Zend Framework 2

Some time ago I created a Zend Framework 2 module designed to wrap Zend\Mail and ease sending emails in a Zend Framework 2 application. I was copy-pasting the code of that module in many applications so I decided it was a good candidate to become an independent module. After creating it I pushed it…

Alejandro Celaya | Blog

Software development, agile methodologies and open source software.

category Archive — "php"

— 2014 —