This a tale of things that are and things that aren't. It's a tale of semantic versioning, the lack thereof and heartbreak. It's a story of terror and failing builds. But it has a bittersweet ending wherein our heroes learn a lesson and understand the need for compromise. We all come out better and wiser people. Hopefully there's something for everybody; let's start with an exciting opener and see where it goes...
This is often the experience people have of using type definitions from Definitely Typed:
Specifically, people are used to the idea of semantic versioning and expect it from types published to npm by Definitely Typed. They wait in vain. I've written before about the Definitely Typed / @types semantic version compromise. And I wanted to talk about it a little further as (watching the issues raised on DT) I don't think the message has quite got out there. To summarise:
npm is built on top of semantic versioning and they take it seriously. When a package is published it should be categorised as a major release (breaking changes), a minor release (extra functionality which is backwards compatible) or a patch release (backwards compatible bug fixes).
Definitely Typed publishes type definitions to npm under the
To make consumption of type definitions easier, the versioning of a type definition package will seek to emulate the versioning of the npm package it supports. For example, right now
<a href="https://www.npmjs.com/package/react-router">react-router</a>'s latest version is
4.3.1. The corresponding type definition
<a href="https://www.npmjs.com/package/@types/react-router">@types/react-router</a>'s latest version is
4.0.31. (It's fairly common for type definition versions to lag behind the package they type.)
If there's a breaking change to the
react-routertype definition then the new version published will have a version number that begins
"4.0.". If you are relying on semantic versioning this will break you.
If you're reading this and can't quite believe that @types would be so inconsiderate as to break the conventions of the ecosystem it lives in, I understand. But hopefully you can see there are reasons for this. In the end, being able to use npm as a delivery mechanism for versioned type definitions associated with another package has a cost; that cost is semantic versioning for the type definitions themselves. It wasn't a choice taken lightly; it's a pragmatic compromise.
"But what about my failing builds? Fine, people are going to change type definitions, but why should I burn because of their choices?"
Excellent question. Truly. Well here's my advice: don't expect semantic versioning where there is none. Use specific package versions. You can do that directly with your
package.json. For example replace something like this:
"@types/react-router": "^4.0.0" with a specific version number:
"@types/react-router": "4.0.31". With this approach it's a specific activity to upgrade your type definitions. A chore if you will; but a chore that guarantees builds will not fail unexpectedly due to changing type defs.
My own personal preference is yarn. Mother, I'm in love with a
yarn.lock file. It is the alternative npm client that came out of Facebook. It pins the exact versions of all packages used in your
yarn.lock file and guarantees to install the same versions each time. Problem solved; and it even allows me to keep the semantic versioning in my
package.json as is.
This has some value in that when I upgrade I probably want to upgrade to a newer version following the semantic versioning convention. I should just expect that I'll need to check valid compilation when I do so. yarn even has it's own built in utility that tells you when things are out of date:
Before I finish I wanted to draw out one reason why breaking changes can be a reason for happiness. Because sometimes your code is wrong. An update to a type definition may highlight that. This is analogous to when the TypeScript compiler ships a new version. When I upgrade to a newer version of TypeScript it lights up errors in my codebase that I hadn't spotted. Yay compiler!
An example of this is a PR I submitted to DefinitelyTyped earlier this week. This PR changed how
react-router models the parameters of a
Match. Until now, an object was expected; the user could define any object they liked. However,
react-router will only produce
string values for a parameter. If you look at the underlying code it's nothing more than an
exec on a regular expression.
My PR enforces this at type level by changing this:
So any object definition supplied must have
string values (and you don't actually need to supply an object definition; that's optional now).
I expected this PR to break people and it did. But this is a useful break. If they were relying upon their parameters to be types other than strings they would be experiencing some unexpected behaviour. In fact, it's exactly this that prompted my PR in the first place. A colleague had defined his parameters as
numbers and couldn't understand why they weren't behaving like
numbers. Because they weren't
numbers! And wonderfully, this will now be caught at compile time; not runtime. Yay!