Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/ds300/lazyrepo
Caching task runner for npm/pnpm/yarn monorepos.
https://github.com/ds300/lazyrepo
Last synced: 2 days ago
JSON representation
Caching task runner for npm/pnpm/yarn monorepos.
- Host: GitHub
- URL: https://github.com/ds300/lazyrepo
- Owner: ds300
- License: mit
- Created: 2023-04-07T09:23:46.000Z (over 1 year ago)
- Default Branch: main
- Last Pushed: 2023-11-18T17:54:18.000Z (12 months ago)
- Last Synced: 2024-10-19T03:56:31.219Z (16 days ago)
- Language: TypeScript
- Size: 1.11 MB
- Stars: 528
- Watchers: 8
- Forks: 13
- Open Issues: 22
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- Contributing: CONTRIBUTING.md
- Funding: .github/FUNDING.yml
- License: LICENSE
- Code of conduct: CODE_OF_CONDUCT.md
Awesome Lists containing this project
README
> **Warning** Currently in the prototyping stage, expect breaking changes! Get help or join in development on [discord](https://discord.gg/XWb3NGHkfD).
`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, 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.
- Concise and timely feedback to help you tweak and debug your build pipelines.
- Palpably sensible defaults.
- 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.
## Installation
Install `lazyrepo` globally
npm install lazyrepo@alpha --global
And also as a dev dependency in the root of your repo
npm install lazyrepo@alpha --save-dev
And finally add `.lazy` to your .gitignore
echo "\n\n#lazyrepo\n.lazy" >> .gitignore
## Basic Usage
### Running Tasks
Run scripts defined in `"scripts"` entries using:
lazy run
You can pass arguments to the task script after a `--`
lazy run 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.
```mermaid
graph TD
A[packages/core] -->|depends on| B[packages/utils]
A -->|depends on| C[packages/primitives]
```
With no config, when you run `lazy run test` in the project root:
- The tests for `utils` and `primitives` will begin concurrently. The tests for `core` will only be started if both `utils` and `primitives` finish successfully.
- If you change a source file in `core` and run `lazy run test` again, only `core`'s tests will be executed.
- If you change a source file in `utils` and run `lazy run test` again, both `utils` and `core`'s tests will be executed, in that order.
### Other commands
- `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`:
```diff
"scripts": {
- "test": "jest --runInBand --noCache --coverage",
+ "test": "lazy inherit"
}
```
Then add this in your lazy config file:
```diff
"scripts": {
"test": {
+ "baseCommand": "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 [-- <forward-args>]`
Runs the given script, forwarding any args passed after the `--`
You may filter the packages that a script should run in using the `--filter` option, which supports glob patterns.
e.g. to test only packages that end in `-utils`
lazy run test --filter="packages/*-utils"
You may force all tasks to execute by passing the `--force` option.
lazy run test --force
## Configuration
Create a file called `lazy.config.js` or `lazy.config.json`
To create a `.js` config file, in your project root run:
lazy init
```ts
export default {
scripts: {
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,
},
},
},
}
```