TypeScript monorepo for React project
Tags: typescript, react, help, discuss
Published: 2019-05-25 14:55:06

---
title: TypeScript monorepo for React project
published: true
description: What problems to expect from TypeScript monorepo for React project?
tags: [typescript, react, help, discuss]
cover_image: https://thepracticaldev.s3.amazonaws.com/i/voui7jxi2nae8ypxqyod.jpg
---

**UPD**: with the help from the community some of the problems were resolved. Not all steps in `What I did` section are updated, but [github repo contains all recent changes](https://github.com/stereobooster/typescript-monorepo).

I want to create TypeScript monorepo for React project. I tried and I'm not happy with my result. This post describes what I did. **Any advice on how to improve setup?** As well there is a small rant in the end. Source code is [here](https://github.com/stereobooster/typescript-monorepo).

## What I want to achieve

- [Monorepo](https://www.atlassian.com/git/tutorials/monorepos) project, to be able comfortably develop several packages, which can be used separately but as well together
- with TypeScript
- for React project
- with a testing library, I want to start with Jest, but as well we can choose something else
- with Storybook (or similar tool) for React components development and showcasing
- (nice to have, but optional) ESlint with [eslint-config-react-app](https://www.npmjs.com/package/eslint-config-react-app)
- (nice to have, but optional) Rollup to bundle and minify
- (nice to have, but optional) pre-commit hooks with prettier

### Packages structure

- `a` - utility library
- `b` - React components library, which depends on `a`
- `c` - another React components library, which depends on `a`
- `stories` - showcase of `b` and `c` package's components as well used for development (initial plan, can change later)

## What I did

### yarn

`yarn` instead of `npm`, because it supports `workspaces` to link cross-dependencies.

Create `package.json` in the root without version because we not going to publish it and with `workspaces`:

```json
"workspaces": [
  "packages/*"
]
```

### lerna

We will use `lerna` to run commands across all packages and "elevate" common dependencies.

Create `lerna.json`:

```json
{
  "packages": ["packages/*"],
  "npmClient": "yarn",
  "useWorkspaces": true,
  "version": "0.0.1"
}
```

### TypeScript

We will use `typescript` to check types and compile TS down to desired JS files (ES5 or ES2015, CommonJS or ES modules).

Create `tsconfig.base.json`. This is what you need to add to enable monorepo:

```json
{
  "include": ["packages/*/src"],
  "compilerOptions": {
    "declaration": true,
    "declarationMap": true,
    "baseUrl": ".",
    "paths": {
      "@stereobooster/*": ["packages/*/src"]
    }
  }
}
```

Create `packages/a/`, `packages/b/`, `packages/c/`, `packages/stories/`. Add `tsconfig.json` to each one:

```json
{
  "include": ["src"],
  "extends": "../../tsconfig.base.json",
  "compilerOptions": {
    // to override config from tsconfig.base.json
    "outDir": "lib",
    "rootDir": "src",
    // for references
    "baseUrl": "src"
  },
  // references required for monorepo to work
  "references": [{ "path": "../a" }]
}
```

In `package.json` for packages `b` and `c` add:

```json
"peerDependencies": {
  "@stereobooster/a": "0.0.1"
},
"devDependencies": {
  "@stereobooster/a": "*"
}
```

We need `peerDependencies` to make sure that when packages (`a`, `b`, `c`) installed by the end user they will use the same instance of package `a`, otherwise, TypeScript can complain about incompatible types (especially if use inheritance and private fields). In `peerDependencies` we specify a version, but in `devDependencies` we don't need to, because we need simply to instruct `yarn` to use whatever version of package we have locally.

Now we can build projects. Add to root `package.json`:

```json
"scripts": {
  "build": "lerna run build --stream --scope=@stereobooster/{a,b,c}"
}
```

and to `package.json` for `a`, `b`, `c`

```json
"scripts": {
  "build": "tsc"
}
```

**Problem 1**: because of sub-dependencies (packages `b` and `c` depend on `a`, `stories` depends on `a`, `b`, `c`) we need to build packages accordingly, e.g. first `a`, second `b` and `c`, third `stories`. That is why we can't use `--parallel` flag for `lerna` for build command.

### React

Install `@types/react`, `@types/react-dom`, `react`, `react-dom`.

Add to `tsconfig.base.json`:

```json
"compilerOptions": {
  "lib": ["dom", "esnext"],
  "jsx": "react",
}
```

Add to subpackage's `package.json`:

```json
"peerDependencies": {
  "react": "^16.8.0",
  "react-dom": "^16.8.0"
}
```

### Jest

We will use `jest` to run tests. Install `@types/jest`, `@types/react-test-renderer`, `jest`, `react-test-renderer`. Add `jest.json`. To eanbale TypeScript:

```json
{
  "moduleFileExtensions": ["ts", "tsx", "js"],
  "transform": {
    "\\.tsx?$": "ts-jest"
  },
  "testMatch": ["**/__tests__/**/*.test.*"],
  "globals": {
    "ts-jest": {
      "tsConfig": "tsconfig.base.json"
    }
  }
}
```

to enable monorepo:

```json
"moduleNameMapper": {
  "@stereobooster/(.*)$": "<rootDir>/packages/$1"
}
```

As well we will need to change `tsconfig.base.json`, because [Jest doesn't support ES modules](https://github.com/facebook/jest/issues/4842):

```json
"compilerOptions": {
  "target": "es5",
  "module": "commonjs",
}
```

Add command to `package.json`

```json
"scripts": {
  "pretest": "yarn build",
  "test": "jest --config=jest.json"
}
```

**Problem 2**: we will publish modules as ES5 + CommonJS, which makes no sense for React package, which would require some kind of bundler to consume packages, like Parcel or Webpack.

**Problem 3**: there are sub-dependencies, so we need to build all packages first and only after we can run tests. That is why we need `pretest` script.

### Storybook

Install storybook according to [official instruction](https://storybook.js.org/docs/configurations/typescript-config/).

We will need the following things in `package.json`:

```json
"scripts": {
  "start": "start-storybook -p 8080",
  "build": "build-storybook -o dist"
},
"dependencies": {
  "@stereobooster/a": "*",
  "@stereobooster/b": "*",
  "@stereobooster/c": "*"
},
"devDependencies": {
  "@babel/core": "7.4.3",
  "@storybook/addon-info": "^5.0.11",
  "@storybook/addons": "5.0.6",
  "@storybook/core": "5.0.6",
  "@storybook/react": "5.0.6",
  "@types/storybook__addon-info": "^4.1.1",
  "@types/storybook__react": "4.0.1",
  "awesome-typescript-loader": "^5.2.1",
  "babel-loader": "8.0.5",
  "react-docgen-typescript-loader": "^3.1.0"
}
```

Create configurations in `.storybook` (again, based on official instruction). Now we can create stories in `/src/b` for `b` packages, in `/src/c` for `c` package.

Storybook will watch for changes in `stories/src`, but not for changes in `a/src`, `b/src`, `c/src`. We will need to use TypeScript to watch for changes in other packages.

Add to `package.json` of `a`, `b` and `c` packages:

```json
"scripts": {
  "start": "tsc -w"
}
```

and to the root `package.json`:

```json
"scripts": {
  "prestart": "yarn build",
  "start": "lerna run start --stream --parallel"
}
```

Now a developer can run `yarn start` (in one terminal) and `yarn test --watch` (in another terminal) to get development environment - scripts will watch for changes and reload.

**Problem 3**: there are sub-dependencies, so we need to build all packages first and only after we can run the start script. That is why we need `prestart` script.

**Problem 4**: If there is type error in stories it will show up in the browser, but if there is type error in `a`, `b` or `c` packages it will only show up in terminal, which spoils all DX, because instead of switching between editor and browser you will need to switch to terminal as well to check if there is an error or not.

## Rant

So I spent quite some time (half of a day?) to figure out all the details and the result is disappointing. Especially I disappointed by **problem 2** and **problem 4**. Even more, I didn't write a line of actual code. It is so frustrating that the JS ecosystem doesn't appreciate convention over configuration principle more. We need more create-react-apps and Parcels in the ecosystem. Tools should be built with cross-integration in mind. 

There is probably the solution to the problem, maybe I need to try `ava` and `esm` to fix **problem 2**, but I'm so disappointed that I spent all that time to fight with incidental complexity. Instead, I decided to pause and write the post.

> Photo by Ruby Schmank on Unsplash