lerna VS husky

On Netlify's enterprise tier, approximately 46% of builds are monorepos, with the majority leveraging Nx and Lerna. Recognizing this trend, Netlify has focused on enhancing the setup and deployment experiences for monorepo projects. In particular they worked on an "automatic monorepo detection" feature. When you connect your project to GitHub, Netlify automatically detects if it's part of a monorepo, reads the relevant settings, and pre-configures your project. This eliminates the need for manual setup. This feature also extends to local development via the Netlify CLI.

This is the exact problem monorepos were born to solve. Not only will a monorepo let you share UI components, you'll be able to gradually add shared application logic as well (for instance, do all of your apps have their own logic for connecting to a database? you could roll that into a shared library with a monorepo). There are a lot of tools for accomplishing this in JS, but probably the most popular is lerna, which is built on top of NX (though lots of teams roll their own monorepo in nx without lerna, which IMO is a totally valid option).

To begin, you need to prepare your environment. A few ways to build a React package include tools like Bit, Storybook, Lerna, and TSDX. However, for this tutorial, you will use a zero-configuration bundler for tiny modules called Microbundle.

If so, are you using a monorepo tool like Nx or Lerna? If not, start there and see if it solves your problem.

I mean I don't know what your monorepo looks like, but for example infernojs (actually written with typescript) uses lerna, and lerna seems simpler than typescript references

Tools for publishing, such as Lerna (when using the --conventional-commit flag), follow this convention when incrementing package versions and generating changelog files.

We could improve part of this by using something like Lerna. With the right configuration, Lerna can be really helpful.

It feels dirty to be adding express as a dependency to a react project, but I'm pretty sure TRPC requires all of client and server code to be in the same node.js project, since types are shared. I've read that you can use a tool like Lerna to share types between node projects, but it requires a build step, which would diminish the benefits of TRPC.

For more information, check out the PR

In addition to these aspects, the repository makes use of Husky to automate certain tasks when making commits and pushing to the repository.

To make your life easier, you can also use resources like Husky that leverage pre-commit hooks*

Husky is a tool which allows you to easily add git hooks to your project. It's very easy to set up and it will make sure that everyone who clones your repo will have the hooks installed as well, as they are part of the project and get installed with the dependencies, right after running npm install. No need to rely on people remembering to install them!

To automate that we need some kind of pre-commit hook validation. That's where husky and lint-staged plugins come in handy let's install and set them up.

You can learn more about husky in the official docs and you should definitely leave a star to the GitHub repository.

It is not wild at all. Check out husky, the most popular tool for git hooks. The recommended way to use it is by running npx husky-init, which registers a pre-commit hook that by default runs npm test whenever you commit.

Husky is the typical choice in Node.js packages for registering commands to run in Git hooks.

Depending on the project, you may prefer to run these scripts locally or in a server, perhaps as a part of your CI pipeline. To round out the example, we’ll describe how to run them as a Git Hook using husky:

To answer your next question: I lint and format on save, and I use Git hooks installed by Husky and executed through Lint-Staged (this tool helps ensure your Git hooks only run on modified files, etc) to ensure there are no lint or formatting errors whenever making a commit or pushing code. This is helpful for teams, as some developers tend to forget to run lint tasks, or don't have the Prettier extension installed in their IDE. If there are lint errors, the commit is rejected until fixed. YMMV - you'll need to fine-tune the strictness of this based on the team's needs.

Now you have a mechanism to generate frontend types from OpenAPI spec, so backend becomes a single source of truth and you don't need to repeat a lot of code by hands. But there's still no answer on how to keep types in sync. One of the possible approaches is to use pre-commit hooks, like pre-commit or Husky.