json-rest-api 1.0.20 → 1.0.22

package/audit/evidence/external/readme-jsonapi-serializer-signals.txt

@@ -0,0 +1,63 @@
+4:# JSON API Serializer
+7:  <img src="https://github.com/SeyZ/jsonapi-serializer/blob/master/logo.jpg?raw=true" alt="JSONAPI Serializer Logo">
+10:[![Build Status](https://travis-ci.org/SeyZ/jsonapi-serializer.svg?branch=master)](https://travis-ci.org/SeyZ/jsonapi-serializer)
+11:[![npm version](https://img.shields.io/npm/v/jsonapi-serializer.svg)](https://yarnpkg.com/en/package/jsonapi-serializer)
+12:[![download](https://img.shields.io/npm/dm/jsonapi-serializer.svg)](https://yarnpkg.com/en/package/jsonapi-serializer)
+14:A Node.js framework agnostic library for (de)serializing your data to [JSON
+17:psst: If you need an off-the-shelf admin panel for your app, check out what I build in my day job at [forestadmin.com](https://www.forestadmin.com) - it uses jsonapi-serializer to de/serialize data data coming from/to the APIs.
+19:- [Migrate from 2.0 to 3.0](https://github.com/SeyZ/jsonapi-serializer/wiki/Migrate-from-2.0-to-3.0)
+20:- [Migrate from 1.x to 2.0](https://github.com/SeyZ/jsonapi-serializer/wiki/Migrate-from-1.x-to-2.0)
+23:`$ npm install jsonapi-serializer`
+29:    var JSONAPISerializer = require('jsonapi-serializer').Serializer;
+30:    new JSONAPISerializer(type, opts).serialize(data);
+37:Calling the `serialize` method on the returned object will serialize your `data` (object or array) to a compliant JSONAPI document.
+42:- **attributes**: An array of attributes to show. You can define an attribute as an option if you want to define some relationships (included or not).
+43:    - **ref**: If present, it's considered as a relationships.
+44:    - **included**: Consider the relationships as [compound document](http://jsonapi.org/format/#document-compound-documents). Default: true.
+50:    - **relationshipLinks**: An object that describes the links inside relationships. Values can be *string* or a *function*
+51:    - **relationshipMeta**: An object that describes the meta inside relationships. Values can be a plain value or a *function*
+52:    - **ignoreRelationshipData**: Do not include the `data` key inside the relationship. Default: false.
+62:- [Express example](https://github.com/SeyZ/jsonapi-serializer/tree/master/examples/express)
+63:- [Simple usage](#simple-usage-serializer)
+64:- [More examples in tests](https://github.com/SeyZ/jsonapi-serializer/blob/master/test/serializer.js)
+66:<a name="simple-usage-serializer"></a>
+77:var JSONAPISerializer = require('jsonapi-serializer').Serializer;
+83:var users = UserSerializer.serialize(data);
+85:// `users` here are JSON API compliant.
+112:    var JSONAPIDeserializer = require('jsonapi-serializer').Deserializer;
+113:    new JSONAPIDeserializer(opts).deserialize(data);
+115:The function `JSONAPIDeserializer` takes one argument:
+117:- `opts`: The deserializer options.
+119:Calling the `deserialize` method on the returned object will deserialize your `data` (JSONAPI document) to a plain javascript object.
+124:- **AN\_ATTRIBUTE\_TYPE**: this option name corresponds to the type of a relationship from your JSONAPI document.
+125:	- **valueForRelationship**: A function that returns whatever you want for a relationship (see examples below) ***can return a Promise (see tests)***
+130:- [Simple usage](#simple-usage-deserializer)
+131:- [Relationship](#relationship-deserializer)
+132:- [More examples in tests](https://github.com/SeyZ/jsonapi-serializer/blob/master/test/deserializer.js)
+134:<a name="simple-usage-deserializer"></a>
+158:var JSONAPIDeserializer = require('jsonapi-serializer').Deserializer;
+160:new JSONAPIDeserializer().deserialize(jsonapi, function (err, users) {
+171:<a name="relationship-deserializer"></a>
+183:    relationships: {
+195:    relationships: {
+205:var JSONAPIDeserializer = require('jsonapi-serializer').Deserializer;
+207:new JSONAPIDeserializer({
+209:    valueForRelationship: function (relationship) {
+211:        id: relationship.id,
+218:}).deserialize(jsonapi, function (err, users) {
+256:    var JSONAPIError = require('jsonapi-serializer').Error;
+257:    var error = new JSONAPIError(opts);
+261:- `opts`: The error options. All options are optional.
+263:#### Available error option (`opts` argument)
+267:- **code**: an application-specific error code, expressed as a string value.
+270:- **source**: an object containing references to the source of the error, optionally including any of the following members:
+272:  - **parameter**: a string indicating which URI query parameter caused the error.
+275:- **meta**: a meta object containing non-standard meta-information about the error.
+279:- [Simple usage](#simple-usage-error)
+280:- [More example](https://github.com/SeyZ/jsonapi-serializer/blob/master/test/error.js)
+282:<a name="simple-usage-error"></a>
+286:var JSONAPIError = require('jsonapi-serializer').Error;
+288:var errors = new JSONAPIError({
+295:// `errors` here are JSON API compliant.
+302:  "errors": [
+315:[MIT](https://github.com/SeyZ/jsonapi-serializer/blob/master/LICENSE)

package/audit/evidence/external/readme-jsonapi-serializer.md

@@ -0,0 +1,315 @@
+# I am looking for new maintainers
+If you are interested, send me an email: sandro@munda.me
+
+# JSON API Serializer
+
+<p align="center">
+  <img src="https://github.com/SeyZ/jsonapi-serializer/blob/master/logo.jpg?raw=true" alt="JSONAPI Serializer Logo">
+</p>
+
+[![Build Status](https://travis-ci.org/SeyZ/jsonapi-serializer.svg?branch=master)](https://travis-ci.org/SeyZ/jsonapi-serializer)
+[![npm version](https://img.shields.io/npm/v/jsonapi-serializer.svg)](https://yarnpkg.com/en/package/jsonapi-serializer)
+[![download](https://img.shields.io/npm/dm/jsonapi-serializer.svg)](https://yarnpkg.com/en/package/jsonapi-serializer)
+
+A Node.js framework agnostic library for (de)serializing your data to [JSON
+API](http://jsonapi.org) (1.0 compliant).
+
+psst: If you need an off-the-shelf admin panel for your app, check out what I build in my day job at [forestadmin.com](https://www.forestadmin.com) - it uses jsonapi-serializer to de/serialize data data coming from/to the APIs.
+
+- [Migrate from 2.0 to 3.0](https://github.com/SeyZ/jsonapi-serializer/wiki/Migrate-from-2.0-to-3.0)
+- [Migrate from 1.x to 2.0](https://github.com/SeyZ/jsonapi-serializer/wiki/Migrate-from-1.x-to-2.0)
+
+## Installation
+`$ npm install jsonapi-serializer`
+
+## Documentation
+
+### Serialization
+
+    var JSONAPISerializer = require('jsonapi-serializer').Serializer;
+    new JSONAPISerializer(type, opts).serialize(data);
+
+The function `JSONAPISerializer` takes two arguments:
+
+- `type`: The resource type.
+- `opts`: The serialization options.
+
+Calling the `serialize` method on the returned object will serialize your `data` (object or array) to a compliant JSONAPI document.
+
+
+#### Available serialization option (`opts` argument)
+
+- **attributes**: An array of attributes to show. You can define an attribute as an option if you want to define some relationships (included or not).
+    - **ref**: If present, it's considered as a relationships.
+    - **included**: Consider the relationships as [compound document](http://jsonapi.org/format/#document-compound-documents). Default: true.
+    - **id**: Configurable identifier field for the resource. Default: `id`.
+    - **attributes**: An array of attributes to show.
+    - **topLevelLinks**: An object that describes the top-level links. Values can be *string* or a *function*
+    - **dataLinks**: An object that describes the links inside data. Values can be *string* or a *function* (see examples below)
+    - **dataMeta**: An object that describes the meta inside data. Values can be a plain value or a *function* (see examples below)
+    - **relationshipLinks**: An object that describes the links inside relationships. Values can be *string* or a *function*
+    - **relationshipMeta**: An object that describes the meta inside relationships. Values can be a plain value or a *function*
+    - **ignoreRelationshipData**: Do not include the `data` key inside the relationship. Default: false.
+    - **keyForAttribute**: A function or string to customize attributes. Functions are passed the attribute as a single argument and expect a string to be returned. Strings are aliases for inbuilt functions for common case conversions. Options include: `dash-case` (default), `lisp-case`, `spinal-case`, `kebab-case`, `underscore_case`, `snake_case`, `camelCase`, `CamelCase`.
+    - **nullIfMissing**: Set the attribute to null if missing from your data input. Default: false.
+    - **pluralizeType**: A boolean to indicate if the type must be pluralized or not. Default: true.
+    - **typeForAttribute**: A function that maps the attribute (passed as an argument) to the type you want to override. If it returns `undefined`, ignores the flag for that attribute. Option *pluralizeType* ignored if set.
+    - **meta**: An object to include non-standard meta-information. Values can be a plain value or a *function*
+    - **transform**: A function to transform each record before the serialization.
+
+**Examples**
+
+- [Express example](https://github.com/SeyZ/jsonapi-serializer/tree/master/examples/express)
+- [Simple usage](#simple-usage-serializer)
+- [More examples in tests](https://github.com/SeyZ/jsonapi-serializer/blob/master/test/serializer.js)
+
+<a name="simple-usage-serializer"></a>
+Simple usage:
+
+```javascript
+var data = [
+  { id: 1, firstName: 'Sandro', lastName: 'Munda' },
+  { id: 2, firstName: 'John', lastName: 'Doe' }
+];
+```
+
+```javascript
+var JSONAPISerializer = require('jsonapi-serializer').Serializer;
+
+var UserSerializer = new JSONAPISerializer('users', {
+  attributes: ['firstName', 'lastName']
+});
+
+var users = UserSerializer.serialize(data);
+
+// `users` here are JSON API compliant.
+```
+
+The result will be something like:
+
+```javascript
+{
+  "data": [{
+    "type": "users",
+    "id": "1",
+    "attributes": {
+      "first-name": "Sandro",
+      "last-name": "Munda"
+    }
+  }, {
+    "type": "users",
+    "id": "2",
+    "attributes": {
+      "first-name": "John",
+      "last-name": "Doe"
+    }
+  }]
+}
+```
+
+### Deserialization
+
+    var JSONAPIDeserializer = require('jsonapi-serializer').Deserializer;
+    new JSONAPIDeserializer(opts).deserialize(data);
+
+The function `JSONAPIDeserializer` takes one argument:
+
+- `opts`: The deserializer options.
+
+Calling the `deserialize` method on the returned object will deserialize your `data` (JSONAPI document) to a plain javascript object.
+
+#### Available deserialization option (`opts` argument)
+
+- **keyForAttribute**: A function or string to customize attributes. Functions are passed the attribute as a single argument and expect a string to be returned. Strings are aliases for inbuilt functions for common case conversions. Options include: `dash-case` (default), `lisp-case`, `spinal-case`, `kebab-case`, `underscore_case`, `snake_case`, `camelCase`, `CamelCase`.
+- **AN\_ATTRIBUTE\_TYPE**: this option name corresponds to the type of a relationship from your JSONAPI document.
+	- **valueForRelationship**: A function that returns whatever you want for a relationship (see examples below) ***can return a Promise (see tests)***
+   - **transform**: A function to transform each record after the deserialization.
+
+**Examples**
+
+- [Simple usage](#simple-usage-deserializer)
+- [Relationship](#relationship-deserializer)
+- [More examples in tests](https://github.com/SeyZ/jsonapi-serializer/blob/master/test/deserializer.js)
+
+<a name="simple-usage-deserializer"></a>
+Simple usage:
+
+```
+{
+  data: [{
+    type: 'users',
+    id: '1',
+    attributes: {
+      'first-name': Sandro,
+      'last-name': Munda
+    }
+  }, {
+    type: 'users',
+    id: '2',
+    attributes: {
+      'first-name': 'John',
+      'last-name': 'Doe'
+    }
+  }]
+}
+```
+
+```javascript
+var JSONAPIDeserializer = require('jsonapi-serializer').Deserializer;
+
+new JSONAPIDeserializer().deserialize(jsonapi, function (err, users) {
+  // `users` is...
+});
+```
+
+```javascript
+[
+  { id: 1, firstName: 'Sandro', lastName: 'Munda' },
+  { id: 2, firstName: 'John', lastName: 'Doe' }
+];
+```
+<a name="relationship-deserializer"></a>
+Relationship:
+
+```
+{
+  data: [{
+    type: 'users',
+    id: '54735750e16638ba1eee59cb',
+    attributes: {
+      'first-name': 'Sandro',
+      'last-name': 'Munda'
+    },
+    relationships: {
+      address: {
+        data: { type: 'addresses', id: '54735722e16620ba1eee36af' }
+      }
+    }
+  }, {
+    type: 'users',
+    id: '5490143e69e49d0c8f9fc6bc',
+    attributes: {
+      'first-name': 'Lawrence',
+      'last-name': 'Bennett'
+    },
+    relationships: {
+      address: {
+        data: { type: 'addresses', id: '54735697e16624ba1eee36bf' }
+      }
+    }
+  }]
+}
+```
+
+```javascript
+var JSONAPIDeserializer = require('jsonapi-serializer').Deserializer;
+
+new JSONAPIDeserializer({
+  addresses: {
+    valueForRelationship: function (relationship) {
+      return {
+        id: relationship.id,
+        'address-line1': '406 Madison Court',
+        'zip-code': '49426',
+        country: 'USA'
+      };
+    }
+  }
+}).deserialize(jsonapi, function (err, users) {
+  // `users` is...
+});
+```
+
+```
+[{
+  id: '54735750e16638ba1eee59cb',
+  'first-name': 'Sandro',
+  'last-name': 'Munda',
+  address: {
+    id: '54735722e16620ba1eee36af',
+    'address-line1': '406 Madison Court',
+    'zip-code': '49426',
+    country: 'USA'
+  }
+}, {
+  id: '5490143e69e49d0c8f9fc6bc',
+  'first-name': 'Lawrence',
+  'last-name': 'Bennett',
+  address: {
+    id: '54735697e16624ba1eee36bf',
+    'address-line1': '406 Madison Court',
+    'zip-code': '49426',
+    country: 'USA'
+  }
+}]
+```
+
+#### Notes on Promises
+The deserialization option `valueForRelationship` supports returning a `Promise` and so this library uses `Promises` under the hood. `bluebird` was previously used as a dependency, but due to bundle size concerns on both node and the web it was replaced with native promises.
+
+`bluebird` is definitely [more performant](http://bluebirdjs.com/docs/benchmarks.html) than native Promises. If performance is a major concern `Promise` can be globally polyfilled
+- node - via `global.Promise = require('bluebird')`
+- web - global `Promise` automatically gets assigned when using the [script tag](http://bluebirdjs.com/docs/getting-started.html) to load `bluebird`
+
+## Error serialization
+
+    var JSONAPIError = require('jsonapi-serializer').Error;
+    var error = new JSONAPIError(opts);
+
+The function JSONAPIError takes one argument:
+
+- `opts`: The error options. All options are optional.
+
+#### Available error option (`opts` argument)
+
+- **id**: a unique identifier for this particular occurrence of the problem.
+- **status**: the HTTP status code applicable to this problem, expressed as a string value.
+- **code**: an application-specific error code, expressed as a string value.
+- **title**: a short, human-readable summary of the problem that SHOULD NOT change from occurrence to occurrence of the problem, except for purposes of localization.
+- **detail**: a human-readable explanation specific to this occurrence of the problem. Like title, this field’s value can be localized.
+- **source**: an object containing references to the source of the error, optionally including any of the following members:
+  - **pointer**: a JSON Pointer [RFC6901] to the associated entity in the request document [e.g. "/data" for a primary data object, or "/data/attributes/title" for a specific attribute].
+  - **parameter**: a string indicating which URI query parameter caused the error.
+- **links**: a links object containing the following members:
+  - **about**: a link that leads to further details about this particular occurrence of the problem.
+- **meta**: a meta object containing non-standard meta-information about the error.
+
+**Examples**
+
+- [Simple usage](#simple-usage-error)
+- [More example](https://github.com/SeyZ/jsonapi-serializer/blob/master/test/error.js)
+
+<a name="simple-usage-error"></a>
+Simple usage:
+
+```javascript
+var JSONAPIError = require('jsonapi-serializer').Error;
+
+var errors = new JSONAPIError({
+  code: '123',
+  source: { 'pointer': '/data/attributes/first-name' },
+  title: 'Value is too short',
+  detail: 'First name must contain at least three characters.'
+});
+
+// `errors` here are JSON API compliant.
+```
+
+The result will be something like:
+
+```javascript
+{
+  "errors": [
+    {
+      "code":   "123",
+      "source": { "pointer": "/data/attributes/first-name" },
+      "title":  "Value is too short",
+      "detail": "First name must contain at least three characters."
+    }
+  ]
+}
+```
+
+# License
+
+[MIT](https://github.com/SeyZ/jsonapi-serializer/blob/master/LICENSE)

package/audit/evidence/external/readme-jsonapi-server-signals.txt

@@ -0,0 +1,19 @@
+10:A config driven NodeJS framework implementing [`json:api`](http://jsonapi.org/) and [`GraphQL`](http://graphql.org/). You define the resources, it provides the api.
+16:A config driven approach to building an API enables:
+24: * Automatic handling of relationships
+27: * What are my resources called
+28: * What properties do my resources have
+29: * For each resource, implement a `handler` for:
+30:   * `create`ing a resource
+31:   * `delete`ing a resource
+32:   * `search`ing for many resources
+33:   * `find`ing a specific resource
+34:   * `update`ing a specific resource
+36:We've created `handler`s to automatically map our config over to database solutions help people get off the ground:
+51:- [Configuring jsonapi-server](documentation/configuring.md)
+53:- [Defining Resources](documentation/resources.md)
+59:- [Migrating from an existing express server](documentation/api-migration.md)
+64:You can have a complete json:api server providing a `photos` resource with just this:
+74:  resource: "photos",
+86:Your new API will be alive at `http://localhost:16006/` and your `photos` resources will be at `http://localhost:16006/photos`. The GraphiQL interface will be available at `http://localhost:16006/`.
+90:Fire up an example `json:api` server using the resources mentioned in the official spec via:

package/audit/evidence/external/readme-jsonapi-server.md

@@ -0,0 +1,104 @@
+[![Build Status](https://travis-ci.org/holidayextras/jsonapi-server.svg?branch=master)](https://travis-ci.org/holidayextras/jsonapi-server)
+[![Coverage Status](https://coveralls.io/repos/github/holidayextras/jsonapi-server/badge.svg?branch=master)](https://coveralls.io/github/holidayextras/jsonapi-server?branch=master)
+[![npm version](https://badge.fury.io/js/jsonapi-server.svg)](http://badge.fury.io/js/jsonapi-server)
+[![Dependencies Status](https://david-dm.org/holidayextras/jsonapi-server.svg)](https://david-dm.org/holidayextras/jsonapi-server)
+
+# jsonapi-server
+
+[![Greenkeeper badge](https://badges.greenkeeper.io/holidayextras/jsonapi-server.svg)](https://greenkeeper.io/)
+
+A config driven NodeJS framework implementing [`json:api`](http://jsonapi.org/) and [`GraphQL`](http://graphql.org/). You define the resources, it provides the api.
+
+### Motivation / Justification / Rationale
+
+This framework solves the challenges of json:api and GraphQL without coupling us to any one ORM solution. Every other module out there is either tightly coupled to a database implementation, tracking an old version of the json:api spec, or is merely a helper library for a small feature. If you're building an API and your use case only involves reading and writing to a data store... well count yourself lucky. For everyone else, this framework provides the flexibility to provide a complex API without being confined to any one technology.
+
+A config driven approach to building an API enables:
+ * Enforced json:api responses
+ * Automatic GraphQL schema generation
+ * Request validation
+ * Payload validation
+ * Automatic documentation generation
+ * Automatic inclusions
+ * Automatic routing
+ * Automatic handling of relationships
+
+Ultimately, the only things you as a user of this framework need to care about are:
+ * What are my resources called
+ * What properties do my resources have
+ * For each resource, implement a `handler` for:
+   * `create`ing a resource
+   * `delete`ing a resource
+   * `search`ing for many resources
+   * `find`ing a specific resource
+   * `update`ing a specific resource
+
+We've created `handler`s to automatically map our config over to database solutions help people get off the ground:
+ * [jsonapi-store-memoryhandler](https://github.com/holidayextras/jsonapi-server/blob/master/lib/MemoryHandler.js) - an in-memory data store to enable rapid prototyping. This ships as a part of `jsonapi-server` and powers the core test suite.
+ * [jsonapi-handler-chain](https://github.com/holidayextras/jsonapi-server/blob/master/lib/ChainHandler.js) - a handler to chain custom behaviour around an existing handler. This ships as a part of `jsonapi-server`. More info can be found [here](https://github.com/holidayextras/jsonapi-server/blob/master/documentation/chain-handler.md)
+ * [jsonapi-store-relationaldb](https://github.com/holidayextras/jsonapi-store-relationaldb) - using `sequelize` to support PostgreSQL, MySQL, MSSQL, MariaDB and SQLite.
+ * [jsonapi-store-mongodb](https://github.com/holidayextras/jsonapi-store-mongodb) - for MongoDB.
+ * [jsonapi-store-elasticsearch](https://github.com/holidayextras/jsonapi-store-elasticsearch) - for Elasticsearch.
+ * [jsonapi-store-dynamodb](https://github.com/holidayextras/jsonapi-server/compare/dynamodb?expand=1) - *!SIGNIFICANT WIP!* for AWS DynamoDB.
+
+We've also written a library to ease the consumption of a json:api compliant service, if GraphQL isn't your thing:
+ * [jsonapi-client](https://github.com/holidayextras/jsonapi-client) - for NodeJS and Browsers
+
+
+### Full documentation
+
+- [Suggested Project Structure](documentation/suggested-project-structure.md)
+- [Configuring jsonapi-server](documentation/configuring.md)
+- [Automatic Swagger Generation](documentation/swagger.md)
+- [Defining Resources](documentation/resources.md)
+- [Debugging](documentation/debugging.md)
+- [Foreign Key Relations](documentation/foreign-relations.md)
+- [Chaining handlers together](documentation/chain-handler.md)
+- [Custom Handlers](documentation/handlers.md)
+- [Post Processing Examples](documentation/post-processing.md)
+- [Migrating from an existing express server](documentation/api-migration.md)
+- [Application metrics](documentation/metrics.md)
+
+### The tl;dr
+
+You can have a complete json:api server providing a `photos` resource with just this:
+```javascript
+var jsonApi = require("jsonapi-server");
+
+jsonApi.setConfig({
+  port: 16006,
+  graphiql: true
+});
+
+jsonApi.define({
+  resource: "photos",
+  handlers: new jsonApi.MemoryHandler(),
+  attributes: {
+    title: jsonApi.Joi.string(),
+    url: jsonApi.Joi.string().uri(),
+    height: jsonApi.Joi.number().min(1).max(10000).precision(0),
+    width: jsonApi.Joi.number().min(1).max(10000).precision(0)
+  }
+});
+
+jsonApi.start();
+```
+Your new API will be alive at `http://localhost:16006/` and your `photos` resources will be at `http://localhost:16006/photos`. The GraphiQL interface will be available at `http://localhost:16006/`.
+
+### Show me a full example!
+
+Fire up an example `json:api` server using the resources mentioned in the official spec via:
+```
+$ git clone https://github.com/holidayextras/jsonapi-server.git
+$ npm install
+$ npm start
+```
+then browse to the JSON:API endpoints:
+```
+http://localhost:16006/rest/photos
+```
+or, for GraphQL:
+```
+http://localhost:16006/rest/
+```
+the example implementation can be found [here](example)

package/audit/evidence/external/readme-nestjs-json-api-signals.txt

@@ -0,0 +1,4 @@
+10:npm install nestjs-json-api
+15:yarn add nestjs-json-api
+40:Example with a user controller:
+81:If you want to quickly get it working, you can use the `JsonApiController` decorator on your controller. The downside is that you won't have control over the endpoints.

package/audit/evidence/external/readme-nestjs-json-api.md

@@ -0,0 +1,94 @@
+# NESTJS JSON API
+
+A library to easily implement a JSON API in your NestJs application.
+
+This library contains a set of decorators and a service to make everything easier.
+
+## Installation
+
+```
+npm install nestjs-json-api
+```
+
+Or
+```
+yarn add nestjs-json-api
+```
+
+## Usage
+
+First, import the `JsonApiModule` in your root module. You'll have to setup the database connection independently.
+
+Example with Mongoose:
+
+```
+@Module({
+  ...
+  imports: [
+    MongooseModule.forRoot('mongodb://localhost:27017/dbname'),
+    JsonApiModule.forRoot({
+      adapter: JsonApiMongooseAdapter,
+    }),
+  ],
+  ...
+})
+export class AppModule {}
+```
+
+Now you can use the decorators. The recommended way is to use the method decorators
+
+Example with a user controller:
+
+```
+@Controller('user')
+class UserController {
+  @Get(':id')
+  @JsonApiFindById('UserModel')
+  findById(@JsonApiDoc doc: JsonApiTopLevelObject<User>) {
+    // Do stuff with the doc
+    return doc;
+  }
+
+  @Get()
+  @JsonApiFind('UserModel')
+  find(@JsonApiDoc doc: JsonApiTopLevelObject<User[]>) {
+    // Do stuff with the doc
+    return doc;
+  }
+
+  @Post()
+  @JsonApiCreate('UserModel')
+  create(@JsonApiDoc doc: JsonApiTopLevelObject<User>) {
+    // Do stuff with the doc
+    return doc;
+  }
+
+  @Patch(':id')
+  @JsonApiUpdate('UserModel')
+  update(@JsonApiDoc doc: JsonApiTopLevelObject<User>) {
+    // Do stuff with the doc
+    return doc;
+  }
+  
+  @Delete(idParamKey)
+  @JsonApiDelete('UserModel')
+  delete() {
+    return;
+  }
+}
+```
+
+If you want to quickly get it working, you can use the `JsonApiController` decorator on your controller. The downside is that you won't have control over the endpoints.
+
+Example:
+
+```
+@Controller('categories')
+@JsonApiController('CategoryModel')
+export class CategoriesController {}
+```
+
+
+## TODO
+
+* Improve docs

package/audit/evidence/external/readme-yaser-json-api-nestjs-signals.txt

@@ -0,0 +1,47 @@
+2:  <a href="https://www.npmjs.com/package/json-api-nestjs" target="_blank"><img src="https://img.shields.io/npm/v/json-api-nestjs.svg" alt="NPM Version" /></a>
+3:  <a href="https://www.npmjs.com/package/json-api-nestjs" target="_blank"><img src="https://img.shields.io/npm/l/json-api-nestjs.svg" alt="Package License" /></a>
+4:  <a href="https://www.npmjs.com/package/json-api-nestjs" target="_blank"><img src="https://img.shields.io/npm/dm/json-api-nestjs.svg" alt="NPM Downloads" /></a>
+6:  <img src="https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/klerick/02a4c98cf7008fea2af70dc2d50f4cb7/raw/json-api-nestjs.json" alt="Coverage Badge" />
+9:# json-api-nestjs
+11:This plugin works upon **TypeOrm** or **MicroOrm** library, which is used as the main database abstraction layer tool. The module
+13:supports features such as requests validation based on database fields types, request filtering, endpoints extending,
+14:data relations control and much more. Our module significantly reduces the development time of REST services by removing
+21:$ npm install @yaser2us/json-api-nestjs
+29:import {Module} from '@nestjs/common';
+30:import {JsonApiModule} from '@yaser2us/json-api-nestjs';
+31:import {TypeOrmJsonApiModule} from '@yaser2us/json-api-nestjs-typeorm';
+47:import {Module} from '@nestjs/common';
+48:import {JsonApiModule} from '@yaser2us/json-api-nestjs';
+49:import {MicroOrmJsonApiModule} from '@yaser2us/json-api-nestjs-microorm';
+70:- GET /users/{id}/relationships/{relName}
+71:- POST /users/{id}/relationships/{relName}
+72:- PATCH /users/{id}/relationships/{relName}
+73:- DELETE /users/{id}/relationships/{relName}
+85:  imports?: NestImport[]; // List of addition module for useing in custom controller
+88:    debug?: boolean; // Debug info in result object, like error message
+90:    operationUrl?: string // Url for atomic operation https://jsonapi.org/ext/atomic/
+99:import {Get, Param, Inject, BadRequestException} from '@nestjs/common';
+109:} from '@yaser2us/json-api-nestjs';
+112:} from '@yaser2us/json-api-nestjs-shared';
+146:You can overwrite the default config for the current controller using options in the decorator **JsonAPi**.
+153:import { Query } from '@nestjs/common';
+161:} from 'json-api-nestjs';
+181:import { ArgumentMetadata, PipeTransform } from '@nestjs/common';
+183:import { Query } from 'json-api-nestjs';
+195:For using swagger, you should only add [@nestjs/swagger](https://docs.nestjs.com/openapi/introduction) and configure it
+227:- **include** - you can extend result with relations (aka join)
+229:   GET /users?include=roles
+242:- **sort** - you can sort result of the request
+245:   GET /users?sort=target.name,-roles.key
+249:  So, result of the request will be sorted by field *name* of **Users** by *ASC* and field *key* of **Roles** entity
+251:- **page** - pagination for you request
+256:- **filter** - filter for query
+259:  GET /users?filter[name][eq]=1&filter[roles.name][ne]=test&filter[roles.status][eq]=true
+263:  The "eq", "ne" is *[Filter operand](#filter-operand)*
+293:- **include** - you can extend result with relations (aka join)
+295:   GET /users?include=roles
+329:    "relationships": {
+359:    "relationships": {
+375:You can more information find [here](https://jsonapi.org/ext/atomic/)
+382:but [Atomic operation](https://jsonapi.org/ext/atomic/) allow for one request.
+411:            "relationships":{