Your Web News in One Place

Help Webnuz

Referal links:

Sign up for GreenGeeks web hosting
December 23, 2021 01:35 pm GMT

TypeScript Monorepos with Yarn

In a past article in this monorepo series, weve discussed setting up CI/CD for JavaScript packages using Yarn Workspaces. This time, we will figure out the same for TypeScript. Well learn how to build and test TypeScript projects at scale with Yarn and Semaphore.

At the end of the tutorial, were going to have a continuous integration pipeline that builds only the code that changes.

Image description

Uniting Yarn and TypeScript

TypeScript extends JavaScript by adding everything it was missing: types, stricter checks, and a deeper IDE integration. TypeScript code is easier to read and debug, helping us write more robust code.

Compared to JavaScript, however, TypeScript saddles us with one more layer of complexity: code must be compiled first before it can be executed or used as a dependency. For instance, say we have two packages, child and parent. The child is easy to compile since it has no other dependencies:

$ npm install -g typescript$ cd child$ tsc

Yet, when we try to do the same with the parent that depends on it, we get an error since the local dependency is not found.

$ cd parent$ tscsrc/index.ts:1:20 - error TS2307: Cannot find module 'child' or its corresponding type declarations.1 import { moduleName } from 'child';Found 1 error.

Without specialized tooling, we have to build and link packages by hand while preserving the correct build order. Yarn Workspaces already solves problems like these in JavaScript. Fortunately, with a bit of tweaking, we can extend it to TypeScript.

Setting up Workspaces in Yarn

Fork and clone the following GitHub repository, which has a couple of packages to experiment with.

GitHub logo TomFern / semaphore-demo-monorepo-typescript

Yarn Workspaces + TypeScript monorepo

Monorepo TypeScript Demo

Build Status

A hello world type monorepo demo for TypeScript and Yarn Workspaces.

Before Yarn Workspaces

Withouth workspaces, you have to build and link each project separately. For instance:

$ npm install -g typescript$ cd shared$ tsc

This builds the shared package. But when we try to do the same with sayhi, we get an error since the local dependency is not found:

$ cd ..$ cd sayhi$ tscsrc/sayhi.ts:1:20 - error TS2307: Cannot find module 'shared' or its corresponding type declarations.1 import { hi } from 'shared';                     ~~~~~~~~Found 1 error.

Yarn workspaces help us link projects while keeping each in its own separate folder.

Configure Yarn Workspaces and TypeScript

To configure workspaces, first install the latest Yarn version:

$ yarn set version berry

This creates .yarn and .yarnrc.yml

Initialize workspaces, this creates the packages folder

Were going to build a TypeScript monorepo made of two small packages:

  • shared: contains a few utility functions.
  • sayhi: the main package provides a hello, world program.

Lets get going. To configure workspaces, switch to the latest Yarn version:

$ yarn set version berry

Yarn installs on .yarn/releases and can be safely checked in the repo.

Then, initialize workspaces. This creates the packages folder, a .gitignore, and the package.json and yarn.lock.

$ yarn init -w

You can add root-level dependencies to build all projects at once with:

$ yarn add -D typescript

Optionally, you may want to install the TypeScript plugin, which handles types for you. The foreach plugin is also convenient for running commands in many packages at the same time.

Next, move the code into packages.

$ git mv sayhi shared packages/

To confirm that workspaces have been detected, run:

$ yarn workspaces list --json{"location":".","name":"semaphore-demo-monorepo-typescript"}{"location":"packages/sayhi","name":"sayhi"}{"location":"packages/shared","name":"shared"}

If this were a JavaScript monorepo, we would be finished. The following section introduces TypeScript builds into the mix.

TypeScript Workspaces

Our demo packages already come with a working tsconfig.json, albeit a straightforward one. Yet, we havent done anything to link them up thus far, they have been completely isolated and dont reference each other.

We can link TypeScript packages using project references. This feature, which was introduced on TypeScript 3.0, allows us to break an application into small pieces and build them piecemeal.

First, we need a root-level tsconfig.json with the following contents:

{  "exclude": [    "packages/**/tests/**",    "packages/**/dist/**"  ],  "references": [    {      "path": "./packages/shared"    },    {      "path": "./packages/sayhi"    }  ]}

As you can see, we have one path item per package in the repo. The paths must point to folders containing package-specific tsconfig.json.

The referenced packages also need to have the composite option enabled. Add this line into packages/shared/tsconfig.json and packages/sayhi/tsconfig.json.

{  "compilerOptions": {     "composite": true     . . .  }}

Packages that depend on other ones within the monorepo will need an extra reference. Add a references instruction in packages/sayhi/tsconfig.json (the parent package). The lines go at the top level of the file, outside compilerOptions.

{  "references": [    {      "path": "../shared"    }  ]  . . .}

Install and build the combined dependencies with yarn install. Since were using the latest release of Yarn, it will generate a zero install file that can be checked into the repository.

Now that the configuration is ready, we need to run tsc to build everything for the first time.

$ yarn tsc --build --force

You also can build each project separately with:

$ yarn workspace shared build$ yarn workspace sayhi build

And you can try running the main program.

$ yarn workspace sayhi node dist/src/sayhi.jsHi, World

At the end of this section, the monorepo structure should look like this:

 package.json packages    sayhi       dist/       src/       package.json       tsconfig.json    shared        dist/        src/        package.json        tsconfig.json tsconfig.json yarn.lock

Thats it, Yarn and TypeScript work together. Commit everything into the repository, so were ready to begin the next phase: automating testing with CI/CD.

$ git add -A$ git commit -m "Set up TS and Yarn"$ git push origin master

Building and testing with Semaphore

The demo includes a ready-to-work, change-based pipeline in the final branch. But well learn faster by creating it from zero.

Image description

If youve never used Semaphore before, check out the getting started guide. Once you have added the forked demo repository into Semaphore, come back, and well finish the setup.

Well start from scratch and use the starter single job template. Select Single Job and click on Customize.

Image description

The Workflow Builder opens to let you configure the pipeline.

Image description

Build Stage

Well set up a TypeScript build stage. The build stage compiles the code into JavaScript and runs tests such as linting and unit testing.

The first block will build the shared package. Add the following commands to the job.

sem-version node 14.17.3checkoutyarn workspace shared build

Image description

The details are covered in-depth in the starter guide. But in a few words, sem-version switches the active version of Node (so we have version consistency), while checkout clones the repository into the CI machine.

Scroll down the right pane until you find Skip/Run conditions. Select Run this block when conditions are met. In the When? field type:

change_in('/packages/shared/')

The change_in function is an integral part of monorepo workflows. It scans the Git history to find which files have recently changed. In this case, were essentially asking Semaphore to skip the block if no files in the /packages/shared folders have changed.

Image description

Create a new block for testing. Well use it to run ESLint and unit tests with Jest.

In the prologue, type:

sem-version node 14.17.3checkout

Create two jobs in the block:

  • Lint with the command: yarn workspace shared lint
  • Unit testing: yarn workspace shared test

Again, set the Skip/Run conditions and put the same condition as before.

Image description

Managing dependencies

Well repeat the steps for the sayhi package. Here, we only need to replace any instance of yarn workspace shared <command> with yarn workspace sayhi <command>.

Now, create a building block and uncheck the Dependencies section. Removing block dependencies in the pipeline makes blocks run in parallel.

Image description

Next, set the Skip/Run Condition on the new block to: change_in('/packages/sayhi/').

To finish, add a test block with a lint job and a unit test job. Since this package depends on shared, we can add a block-level dependency at this point. When done, you should have a total of four blocks.

Image description

The Skip/Run Condition, in this case, is different because the test block should run if either sayhi or shared change. Thus, we must supply an array instead of a single path in order to let change_in handle all cases correctly:

change_in(['/packages/sayhi', '/packages/shared'])

Running the Workflow

Click on Run the Workflow and then Start.

Image description

The first time the pipeline runs, all blocks will be executed.

Image description

On successive runs, only relevant blocks will start; the rest will be skipped, speeding up the pipeline considerably, especially if were dealing with tens or hundreds of packages in the repo.

Image description

Read Next

Adding TypeScript into the mix doesnt complicate things too much. Its a small effort that returns gains manifold with higher code readability and fewer errors.

Want to keep learning about monorepos? Check these excellent posts and tutorials:


Original Link: https://dev.to/semaphore/typescript-monorepos-with-yarn-30m9

Share this article:    Share on Facebook
View Full Article

Dev To

An online community for sharing and discovering great ideas, having debates, and making friends

More About this Source Visit Dev To