đź’ˇ Currently in early alpha!
lazyrepo
is a zero-config caching task runner for npm
/pnpm
/yarn
monorepos.
It fits right into the niche that turborepo
carved out: making package.json "scripts"
scale without adopting a big industrial-strength build system like nx
, bazel
, rush
, or buck
.
lazyrepo
is scary fast. It's a lot faster than turborepo
despite being written in TypeScript rather than some young handsome clever funny systems language.
Aside from perf, lazyrepo
comes with some big quality-of-life improvements:
- A human-friendly config format.
- Palpably sensible defaults.
- Concise and timely feedback to help you tweak and debug your build pipelines.
- You don't need to learn Rust to contribute.
Trust me, the whole situation is so delightful it will make you reach for the :chefs-kiss:
emoji. And then you'll realize that there is no such emoji, but you'll want it so badly that you'll draft a proposal to the Unicode Consortium to lobby for its introduction.
Install lazyrepo
globally
npm install lazyrepo --global
And also as a dev dependency in the root of your repo
npm install lazyrepo --save-dev
And finally add .lazy
to your .gitignore
echo "\n\n#lazyrepo\n.lazy" >> .gitignore
Run tasks defined in "scripts"
entries using:
lazy <script-name>
Anything that comes after the script name will be forwarded to the script itself, so you can do stuff like:
lazy test --runInBand
The default behavior is optimized for "test"
scripts, where the order of execution matters if your packages depend on each other.
Let's say you have three packages: core
, utils
, and primitives
. The core
package depends on both utils
and primitives
, and they all have "test"
scripts in their package.json files.
graph TD
A[packages/core] -->|depends on| B[packages/utils]
A -->|depends on| C[packages/primitives]
With no config, when you run lazy test
in the project root:
- The tests for
utils
andprimitives
will begin concurrently. The tests forcore
will only be started if bothutils
andprimitives
finish successfully. - If you change a source file in
core
and runlazy test
again, onlycore
's tests will be executed. - If you change a source file in
utils
and runlazy test
again, bothutils
andcore
's tests will be executed, in that order.
These are prefixed with a colon (:
) to help avoid conflicts with your script names.
-
lazy :init
Creates a config file.
-
lazy :clean
Deletes all local cache data.
-
lazy :inherit
In larger projects, you often end up with the same
"script"
entries duplicated in lots of package.json files. Keeping them in sync can be troublesome.lazyrepo
lets you specify the command just once.Replace the scripts entries with
lazy :inherit
:"scripts": { - "test": "jest --runInBand --noCache --coverage", + "test": "lazy :inherit" }
Then add this in your lazy config file:
"tasks": { "test": { + "defaultCommand": "jest --runInBand --noCache --coverage" } }
Now when you run
npm test
, or whatever, in one of your package directories, it will look up the actual command to run from your lazy config file and run that. -
lazy :run <task> [...<filter-paths>] [-- <forward-args>]
Runs the given task in all packages specified by
<paths>
e.g. to test only packages that end in
-utils
lazy :run test packages/*-utils
To forward args to the script in
:run
mode, append the args after--
, e.g.lazy :run test packages/core -- --runInBand
You can add more
:run
invocations at the end.lazy :run test :run packages/core -- --watch
Create a file called lazy.config.js
or lazy.config.json
To create a .js
config file, in your project root run:
lazy :init
export default {
tasks: {
test: {
cache: {
// by default we consider all files in the package directory
inputs: ['**/*'],
// there are no outputs
outputs: [],
// a test invocation depends on the input files of any upstream packages
inheritsInputFromDependencies: true,
},
},
},
}
TODO