# good-filter

> Good filter.

Latest version **1.1.0** (published 2018-12-21) · MIT license · 0 weekly downloads

## Install

```sh
npm install good-filter
pnpm add good-filter
yarn add good-filter
bun add good-filter
```

## Health

**Score 15/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 1.1.0 |
| Published | 2018-12-21 |
| First published | 2018-12-17 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | none |
| Module format | CommonJS |
| Dependencies | 2 |
| Unpacked size | 13.7 KB |
| Known vulnerabilities | 0 (+1 in 1 direct dependencies) |
| Install scripts | no |
| GitHub stars | 0 |
| Author | Yehor Manzhula |
| Maintainers | yehor.manzhula |
| Keywords | good, hapijs, filter, good-reporter, transform-stream, filtering, stream |

## Links

- npm: https://www.npmjs.com/package/good-filter
- Repository: https://github.com/yehor-manzhula/good-filter
- Homepage: https://github.com/yehor-manzhula/good-filter#readme
- Issues: https://github.com/yehor-manzhula/good-filter/issues
- npm.io page: https://npm.io/package/good-filter

## Dependencies (2)

- [hoek](https://npm.io/package/hoek.md) ^6.1.2
- [lodash](https://npm.io/package/lodash.md) ^4.17.11

## Alternatives

- [byte-size](https://npm.io/package/byte-size.md) — 2.1M weekly downloads
- [speed-limiter](https://npm.io/package/speed-limiter.md) — 16.0K weekly downloads
- [@powersync/node](https://npm.io/package/@powersync/node.md) — 10.9K weekly downloads
- [@ledgerhq/coin-cardano](https://npm.io/package/@ledgerhq/coin-cardano.md) — 1.0K weekly downloads
- [@jayesol/jayeson.lib.streamfinder](https://npm.io/package/@jayesol/jayeson.lib.streamfinder.md) — 1.0K weekly downloads

## Recent versions

- 1.1.0 (latest) — 2018-12-21
- 1.0.3 — 2018-12-21
- 1.0.2 — 2018-12-20
- 1.0.1 — 2018-12-18
- 1.0.0 — 2018-12-17

## README

# good-filter

`good-filter` is a transform stream useful for filtering [good](https://github.com/hapijs/good) server events based on given conditions.
[![Current Version](https://img.shields.io/npm/v/good-filter.svg)](https://www.npmjs.com/package/good-filter)

Maintainer: [Yehor Manzhula][author-github]

## Usage

## `new GoodFilter([config])`
Creates a new GoodFilter object with the following arguments:

    - `[config]` - optional configuration object with the following keys
    - `response` - filter for response event 
    - `error` - filter for error event
    - `log` - filter for log event
    - `opts` - filter for opts event

**Notice: By default good filter filters out all the events to allow event * sign should be used**

In manifest.js

```javascript
    const GoodFilter = require('good-filter');
    
    // Another one awesome plugin you definitely need to try
    const GoodFormat = require('good-format');

    module.exports = {
        // ...
        register: {
            plugins: {
                // ...
                plugin: 'good',
                options: {
                    reporters: {
                        consoleReporter: [
                            new GoodFilter({
                                    log: '*',   // Allow all log events
                                    error: '*', // Allow all error events
                                    response: {
                                        include: '*', 
                                        exclude: {
                                            route: /\/swaggerui\/.*/ // Route property should match regexp
                                        }
                                    }
                                }),
                            new GoodFormat(),
                            'stdout']
                    } 
                }
                // ...
            }
        }
    };
```

## Customization

#### Matchers
good-filter supports few types of matcher values

    - String - Property value should be equal to matcher value, * sign is used to match any value
    - RegExp - Property value should match given RegExp using .match method
    - Function - Function to be invoked with property value
    - Array - Each array value is a separate matcher, under the hood OR logical operator is used, that mean that all of matchers should pass to pass the filter 

#### String

```javascript
    const GoodFilter = require('good-filter');
    
    // Another one awesome plugin you definitely need to try
    const GoodFormat = require('good-format');

    module.exports = {
        // ...
        register: {
            plugins: {
                // ...
                plugin: 'good',
                options: {
                    reporters: {
                        consoleReporter: [
                            new GoodFilter({
                                log: '*', // Allow all log events
                                error: '*', // Allow all error events
                                response: {
                                    include: '*', // Include all responses
                                    exclude: {
                                        method: 'OPTIONS' // Exclude responses for OPTIONS method
                                    }
                                }
                            }),
                            new GoodFormat(),
                            'stdout']
                    }
                }
                // ...
            }
        }
    };
```

### RegExp

```javascript
    const GoodFilter = require('good-filter');

    // Another one awesome plugin you definitely need to try
    const GoodFormat = require('good-format'); 

    module.exports = {
        // ...
        register: {
            plugins: {
                // ...
                plugin: 'good',
                options: {
                    reporters: {
                        consoleReporter: [
                            new GoodFilter({
                                log: '*',
                                error: '*',
                                response: {
                                    include: '*',
                                    exclude: {
                                        route: /\/swaggerui\/.*/ // Exclude swaggerui routes
                                    }
                                }
                            }),
                            new GoodFormat(),
                            'stdout']
                    }
                }
                // ...
            }
        }
    };
```

### Function

```javascript
    const GoodFilter = require('good-filter');

    // Another one awesome plugin you definitely need to try
    const GoodFormat = require('good-format'); 

    module.exports = {
        // ...
        register: {
            plugins: {
                // ...
                plugin: 'good',
                options: {
                    reporters: {
                        consoleReporter: [
                            new GoodFilter({
                                log: '*',
                                error: '*',
                                response: {
                                    include: '*',
                                    exclude: {
                                        method: method => ['OPTIONS', 'DELETE'].includes(method); // Exclude OPTIONS and DELETE method
                                    }
                                }
                            }),
                            new GoodFormat(),
                            'stdout']
                    }
                }
                // ...
            }
        }
    };
```

### Array values
```javascript
    const GoodFilter = require('good-filter');

    // Another one awesome plugin you definitely need to try
    const GoodFormat = require('good-format'); 

    module.exports = {
        // ...
        register: {
            plugins: {
                // ...
                plugin: 'good',
                options: {
                    reporters: {
                        consoleReporter: [
                            new GoodFilter({
                                log: '*',
                                error: '*',
                                response: {
                                    include: '*',
                                    exclude: {
                                        method: ['OPTIONS', 'DELETE']
                                    }
                                }
                            }),
                            new GoodFormat(),
                            'stdout']
                    }
                }
                // ...
            }
        }
    };
```

### Array of matchers
```javascript
    const GoodFilter = require('good-filter');

    // Another one awesome plugin you definitely need to try
    const GoodFormat = require('good-format'); 

    module.exports = {
        // ...
        register: {
            plugins: {
                // ...
                plugin: 'good',
                options: {
                    reporters: {
                        consoleReporter: [
                            new GoodFilter({
                                log: '*',
                                error: '*',
                                response: {
                                    include: '*',
                                    exclude: [{
                                        method: method => ['OPTIONS', 'DELETE'].includes(method); // Exclude OPTIONS and DELETE method

                                        // Works as AND logical operator
                                        route: '/health'    
                                    }, 
                                    // Works as OR operator
                                    {
                                        route: '/test'
                                    }]
                                }
                            }),
                            new GoodFormat(),
                            'stdout']
                    }
                }
                // ...
            }
        }
    };
```

[author-github]: <https://github.com/yehor-manzhula>

---
_Source: https://npm.io/package/good-filter · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._