Monorepa: Effective code management in modern development

###What is a monorepo? A monorepository, or monorepo for short, is a way of organizing code where all of an organization's projects and libraries are stored in a single repository. Try to think of it as a large library where all the books (projects) are carefully organized under one roof, instead of being scattered in different buildings. Today we find their use almost everywhere. Examples are babel monorepo, react, remix or our own React UI library Utima UI. You may notice that besides individual libraries we often find eslint plugins, bundler tools, and more. Benefits of monorepa There are several advantages of monoreps and everyone will find their own over time. The main advantages include:

###Efficient code sharing One of the biggest advantages of monorepo is the ease of sharing code between projects. For example, you develop new functionality for one project and realize that it could be useful elsewhere. In monorepo, just move the code to a shared library and it's immediately available to all projects.

###Atomic commits across projects Monorepo allows you to make changes across multiple projects within a single commit. This is especially useful when introducing new functionality that requires modifications across multiple applications, or when introducing breaking changes that affect multiple projects at once. It is also one of the main benefits that greatly increases developer efficiency in large, tightly coupled projects.

###Simplified dependency management It removes the need to deal with complex dependencies between different versions of your internal libraries. All projects always use the latest version of the shared components.

###Challenges associated with monoreps For all its advantages, the monorepa journey is not always a cake walk.

###Performance aspects

As the amount of code grows, common operations like git clone or npm install can take longer. This can be frustrating, especially in CI/CD environments where the time it takes to complete each pipeline increases significantly.

Another issue, typically with TypeScript projects, is longer indexing times and slower LSP performance. It is important to be prepared for these aspects and implement optimizations where necessary.

###More comprehensive CI/CD pipeline

Configuring CI/CD for monorepo can be more challenging. It is necessary to ensure that the different parts of the application, which often run in different environments, are built and deployed correctly. Fortunately, there are tools to help with this task.

###Monorepa management tools Thankfully, there are several tools that help with these challenges and try to address them.

• Lerna: A pioneer in monorepo management for JavaScript projects. Although it's older now, it still offers useful features, especially in the area of library management and publishing.
• Turborepo: New from Vercel, focused on speed and efficiency. It offers advanced caching and parallelization capabilities for npm run scripts.
• Nx: A comprehensive tool with a wide range of features. Provides advanced options for code management, analysis, and generation. It also offers code gene functionality and a very sophisticated CLI. Teams that learn to use Nx effectively are able to quickly generate packages and projects in many popular frameworks using the available tools.

###Is monorepo the right choice for your team? The choice of monorepo depends on many factors - the size of the team, the nature of the project, and your long-term goals. For smaller, isolated projects, a monorepo can be unnecessarily complex, but for larger, interconnected projects it can bring significant benefits in efficiency and consistency.

In our experience, we use monorepo on most projects with longer-term collaborations, where the simplicity of sharing code within full stack JS development pays off.

###Monorepo for beginners: npm Workspaces If you want to get started with monorepo, pure npm workspaces are a great starting point. If you were to start reading the Nx documentation now, you might be overwhelmed by the large amount of new information.

One of the first problems monorepo tries to address is linking dependencies between packages and managing them in a unified way. This is achieved by using npm workspaces.

If you don't use npm, the workspaces protocol is now supported by almost all modern package managers - yarn, pnpm.

Create the following directory structure:

monorepo-root
|_ package.json
|_ packages
   |_ shared
   |  |_ package.json
   |  |_ src
   |     |_ index.js
   |
   |_ web-app
   |  |_ package.json
   |  |_ src
   |     |_ index.js
   |
   |_ api
      |_ package.json
      |_ src
         |_ index.js

Each package in /packagess has its package.json, which allows independent dependency and script management.

Activate the workspaces protocol in the root package.json:

{
  "name": "my-monorepo",
  "private": true,
  "workspaces": [
    "packages/*"
  ]
}

The root package.json can also contain any shared dependencies (often most devDependencies) that you can maintain in one place. Workspaces also ensure that they are only installed once, which increases the speed of installing dependencies and saves your disk.

###Dependencies between projects

In our example, we can see that we have created a shared package containing shared code between the API and the web application. We can use the shared package in the API and web app by modifying the dependency definitions in their package.json files:

{
  "dependencies": {
    "@my-monorepo/shared": "*"
  }
}

###The basis for other instruments

Workspaces form the foundation on which more advanced monorepo management tools like Nx, Lerna, or Turborepo build. These tools extend the functionality with advanced building, testing, and publishing capabilities, but all build on the concept of workspaces.

Understanding and implementing workspaces is therefore a crucial first step when working with monoreps. Whether you decide to stick with pure workspaces or later move to more sophisticated solutions, the knowledge gained from using them will provide a solid foundation for further developing your monorepo.

###Conclusion

Monorepo is not a one-size-fits-all solution, but for the right teams and projects, it can be a transformative tool. As with any technology, careful consideration of your specific needs and limitations is key. With the right tools and practices, monorepo can open up new possibilities for your team and projects.

We'll return to monorepos in the future and take a closer look at the various tools for managing them.

Remember that in monorepo, as in software development in general, the key to success is a good organization and regular maintenance.