https://github.com/csvenke/compose-rules
Dead simple helpers for writing composable rules
https://github.com/csvenke/compose-rules
compose composition helpers javascript library npm-package typescript
Last synced: over 1 year ago
JSON representation
Dead simple helpers for writing composable rules
- Host: GitHub
- URL: https://github.com/csvenke/compose-rules
- Owner: csvenke
- License: mit
- Created: 2020-04-09T12:26:42.000Z (about 6 years ago)
- Default Branch: master
- Last Pushed: 2024-05-14T08:04:08.000Z (about 2 years ago)
- Last Synced: 2024-05-14T09:27:30.576Z (about 2 years ago)
- Topics: compose, composition, helpers, javascript, library, npm-package, typescript
- Language: TypeScript
- Homepage: https://www.npmjs.com/package/@csvenke/compose-rules
- Size: 1.51 MB
- Stars: 6
- Watchers: 1
- Forks: 0
- Open Issues: 17
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
@csvenke/compose-rules
Dead simple helpers for writing composable rules
Overview •
Install •
Usage •
Documentation •
Why •
Development •
Contributing •
License
**@csvenke/compose-rules** provides dead simple helpers for writing composable rules.
Attack complex problems by dividing them into smaller easier problems.
> "Nothing is particularly hard if you divide it into small jobs" - [Henry Ford](https://no.wikipedia.org/wiki/Henry_Ford)
## Overview
- Compose your rules with a dead simple API!
```js
import { and, or, not } from "@csvenke/compose-rules";
const myRule = and(myRule1, or(myRule2, myRule3), not(myRule4));
```
- Rich typescript support!
```ts
import { and, Rule } from "@csvenke/compose-rules";
type MyRule = Rule<[string, string]>;
const myRule1: MyRule = (firstName, lastName) => true;
const myRule2: MyRule = (firstName, lastName) => true;
// type inference from first rule!
const myRule = and(myRule1, myRule2);
myRule("John", "Doe"); // Ok!
myRule("John"); // Error!
```
- No dependencies!
- Tiny bundle size!
- Tree shakeable and side effect free!
- 100% test coverage!
## Install
Using npm
```
npm install --save @csvenke/compose-rules
```
Using yarn
```
yarn add @csvenke/compose-rules
```
## Usage
[Try it out online with repl.it!](https://repl.it/@csvenke/PunyCalculatingServers)
```js
import { and } from "@csvenke/compose-rules";
const isLargerThanOne = n => n > 1;
const isLessThanTen = n => n < 10;
const isValidValue = and(isLargerThanOne, isLessThanTen);
console.log(isValidValue(4)); // true
console.log(isValidValue(14)); // false
```
## Documentation
The documentation can be found [here](https://csvenke.github.io/compose-rules)
## Why
Let's say you need to verify that some value complies with a series of requirements.
- It must be a number
- It must be larger than 1
- It must be less than 10
- It must be an odd number
- It must be a prime number
You could just write a function that verifies all those requirements, but requirements tend to change and changes tend to cause regression in your code.
You should instead write separate functions that verify each requirement and then compose all those functions into a single function that verifies all the requirements.
The main benefit of this approach is when requirements change you simply add/remove/edit specific functions from the composer without affecting the other functions.
See the example below for what that might look like.
### Example
[Try it out online with repl.it!](https://repl.it/@csvenke/WorseMiserlyScale)
```js
import { and, not } from "@csvenke/compose-rules";
/**
* Returns true if n is number
*/
const isNumber = n => typeof n === "number";
/**
* Returns true if n is larger than one
*/
const isNumberLargerThanOne = n => n > 1;
/**
* Returns true if n is less than ten
*/
const isNumberLessThanTen = n => n < 10;
/**
* Returns true if n is even
*/
const isNumberEven = n => n % 2 === 0;
/**
* Returns true if n is odd
*/
const isNumberOdd = not(isNumberEven);
/**
* Returns true if n is prime
*/
const isNumberPrime = n => {
for (let i = 2, s = Math.sqrt(n); i <= s; i++) if (n % i === 0) return false;
return n > 1;
};
/**
* Returns true if all rules returns true
*/
const isValidValue = and(
isNumber,
isNumberLargerThanOne,
isNumberLessThanTen,
isNumberOdd,
isNumberPrime
);
console.log(isValidValue(5)); // true
console.log(isValidValue(8)); // false
console.log(isValidValue("Hello")); // false
console.log(isValidValue(undefined)); // false
```
## Development
Installing dependencies
```
yarn install
```
Running tests
```
yarn test
```
## Contributing
In lieu of a formal styleguide, take care to maintain the existing coding style.
## License
[MIT](https://github.com/csvenke/compose-rules/blob/master/LICENSE)