CogentJS

https://www.npmjs.com/package/cogent-js
Admin
CogentJS is a fluent syntax library for building REST API URLs with support for filtering, sorting,...
Tokens:19,580
Snippets:241
Trust Score:9.6
Update:10 months ago
Show doc for...
Tokens:
Raw
### Installation of cogent-js via npm and Yarn

Source: https://www.npmjs.com/package/cogent-js/v/2.0_activeTab=readme

Provides the commands for installing the cogent-js package using either npm or Yarn package managers. These are the standard methods for adding the library to a project.

```bash
npm i cogent-js
```

```bash
yarn add cogent-js
```

--------------------------------

### Installing cogent-js

Source: https://www.npmjs.com/package/cogent-js/v/2.0

Provides instructions for installing the cogent-js package using npm or yarn package managers. This is a prerequisite for using the library in a project.

```bash
npm install cogent-js
```

```bash
yarn add cogent-js
```

--------------------------------

### Install cogent-js using npm

Source: https://www.npmjs.com/package/cogent-js/v/2.0_activeTab=dependents

Installs the cogent-js package using npm. This is the primary method for adding the library to your project.

```bash
npm install cogent-js
```

--------------------------------

### Install cogent-js using Yarn

Source: https://www.npmjs.com/package/cogent-js/v/2.0_activeTab=dependents

Installs the cogent-js package using Yarn. This is an alternative package manager for adding the library to your project.

```bash
yarn add cogent-js
```

--------------------------------

### Basic URL construction with cogent-js

Source: https://www.npmjs.com/package/cogent-js/v/2.0_activeTab=dependents

Demonstrates the basic usage of the cogent-js Query class to construct a URL. It shows how to chain methods like `for`, `where`, `includes`, and `orderBy` to build a query string.

```javascript
const { Query } = require("cogent-js");

const query = new Query();

const url = query
  .for('posts') // the model you're selecting
  .where('name', 'Bob') // where the models `name` is 'Bob'
  .includes('posts', 'comments') // include the models related relationships: posts and comments
  .orderBy('-created_at') // order by -created_at desc
  .get(); // generate the url and pass it into fetch!
```

--------------------------------

### Using the include() Method in cogent-js

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=dependents

Demonstrates the `include()` method for specifying related resources to be included in the API response with cogent-js.

```javascript
// /pouserssts?include=posts
const url = query.for('users').include('posts').url(); // or .get();
```

--------------------------------

### Basic Usage

Source: https://www.npmjs.com/package/cogent-js/v/1.0

Demonstrates the fundamental usage of the Query class to construct a URL with basic filters and includes.

```APIDOC
## Basic Usage

### Description
This example shows how to import the Query class and use its methods to build a URL for fetching posts with specific filters and inclusions.

### Method
Instantiation and Chaining

### Endpoint
Dynamic URL construction based on chained methods.

### Parameters
None directly for this basic example, methods take parameters.

### Request Example
```javascript
// Import
const { Query } = require("cogent-js");

// Instantiate Query
const query = new Query();

// Build URL
const url = query
  .for('posts')
  .where('name', 'Bob')
  .include('posts', 'comments')
  .orderBy('-created_at')
  .get();

// Expected URL structure: /posts?filter[name]=Bob&include=posts,comments&orderBy=-created_at
```

### Response

#### Success Response (200)
N/A - This is a client-side URL builder.

#### Response Example
N/A
```

--------------------------------

### Basic URL construction with cogent-js

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=dependencies

Demonstrates the basic usage of the CogentJS Query class to construct a URL. It shows how to chain methods like `for`, `where`, `include`, and `orderBy` to build a complete API endpoint URL.

```javascript
// Import
const { Query } = require("cogent-js");

// If custom configuration is required, see Additional Configuration
const query = new Query();

// /posts?filter[name]=Bob&include=posts,comments&orderBy=-created_at
const url = query
  .for('posts')
  .where('name', 'Bob')
  .include('posts', 'comments')
  .orderBy('-created_at')
  .get();
```

--------------------------------

### Pagination with limit() and page() in cogent-js

Source: https://www.npmjs.com/package/cogent-js/v/2.0

Demonstrates how to implement pagination using both `limit()` to set the page size and `page()` to specify the desired page number. This is a standard approach for handling large datasets.

```javascript
const url = query.for('users').limit(5).page(2).url();
```

--------------------------------

### Basic URL Construction with CogentJS

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=versions

Demonstrates the fundamental usage of the CogentJS library to build a URL for fetching 'posts'. It shows how to chain methods like `for`, `where`, `include`, and `orderBy` to construct a complex query string.

```javascript
const { Query } = require("cogent-js");

const query = new Query();

// /posts?filter[name]=Bob&include=posts,comments&orderBy=-created_at
const url = query
  .for('posts')
  .where('name', 'Bob')
  .include('posts', 'comments')
  .orderBy('-created_at')
  .get();
```

--------------------------------

### Setting Base URL with cogent-js

Source: https://www.npmjs.com/package/cogent-js/v/2.0

Shows how to configure a base URL when instantiating the Query class, which will be prepended to all generated URLs. Useful for API endpoints hosted on a specific domain.

```javascript
const { Query } = require('cogent-js');

const query = new Query({
  base_url: 'http://api.example.com'
});

const url = query.for('users').where('name', 'Bob').url();
```

--------------------------------

### Additional Configuration - Base URL

Source: https://www.npmjs.com/package/cogent-js/v/1.0

Illustrates how to set a base URL when instantiating the Query class, which will be prepended to all generated URLs.

```APIDOC
## Additional Configuration - Base URL

### Description
This example shows how to configure a base URL that will be automatically added to the beginning of all generated URLs.

### Method
Instantiation with Configuration Object

### Endpoint
Dynamic URL construction with a prepended base URL.

### Parameters
- **base_url** (string) - Optional - The base URL to prepend to all generated URLs.

### Request Example
```javascript
const { Query } = require('cogent-js');

// Instantiate Query with a base URL
const query = new Query({
  base_url: 'http://api.example.com'
});

// Build URL for users
const url = query.for('users').where('name', 'Bob').url(); // or .get();

// Expected URL: http://api.example.com/users?filter[name]=Bob
```

### Response

#### Success Response (200)
N/A - This is a client-side URL builder.

#### Response Example
N/A
```

--------------------------------

### Using limit() and page() for pagination

Source: https://www.npmjs.com/package/cogent-js/v/2.0_activeTab=dependents

Combines `limit()` and `page()` methods to implement pagination, specifying both the number of items per page and the current page number.

```javascript
// /users?page=2&limit=5
const url = query.for('users').limit(5).page(2).url(); // or .get();
```

--------------------------------

### Pagination with limit() and page() in CogentJS

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=versions

Explains how to implement pagination using both `limit()` and `page()` methods. This combination allows you to fetch results in distinct chunks, essential for large datasets.

```javascript
// /users?page=2&limit=5
const url = query.for('users').limit(5).page(2).url()); // or .get();
```

--------------------------------

### Setting a Base URL in CogentJS

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=code

Shows how to configure a base URL when instantiating the `Query` class. This ensures that all generated URLs will be prepended with the specified base URL, simplifying configuration for APIs hosted at a specific domain.

```javascript
const { Query } = require('cogent-js');

const query = new Query({
  base_url: 'http://api.example.com'
});

// http://api.example.com/users?filter[name]=Bob
const url = query.for('users').where('name', 'Bob').url(); // or .get();

console.log(url);
```

--------------------------------

### Customizing Query Parameters

Source: https://www.npmjs.com/package/cogent-js/v/1.0

Explains how to customize the names of the default query parameters used by the library through a configuration object during instantiation.

```APIDOC
## Customizing Query Parameters

### Description
This example demonstrates how to override the default query parameter names (e.g., `filter`, `include`, `sort`) with custom names by providing a configuration object during the `Query` class instantiation.

### Method
Instantiation with Configuration Object

### Endpoint
Dynamic URL construction with customized query parameter names.

### Parameters
- **queryParameters** (object) - Optional - An object where keys are the default parameter names and values are the desired custom names.
  - `include`: Custom name for the include parameter.
  - `filter`: Custom name for the filter parameter.
  - `sort`: Custom name for the sort parameter.
  - `fields`: Custom name for the fields parameter.
  - `append`: Custom name for the append parameter.
  - `page`: Custom name for the page parameter.
  - `limit`: Custom name for the limit parameter.

### Request Example
```javascript
const { Query } = require("cogent-js");

const query = new Query({
  queryParameters: {
    include: "include_custom",
    filter: "filter_custom",
    sort: "sort_custom",
    fields: "fields_custom",
    append: "append_custom",
    page: "page_custom",
    limit: "limit_custom"
  }
});

// Example of building a URL with custom parameter names
// If you were to use .include('details') and .filter('status', 'active') on this query instance,
// the resulting URL would use 'include_custom' and 'filter_custom' respectively.
```

### Response

#### Success Response (200)
N/A - This is a client-side URL builder.

#### Response Example
N/A
```

--------------------------------

### Basic URL Construction with cogent-js

Source: https://www.npmjs.com/package/cogent-js/v/2.0

Demonstrates the fundamental usage of the Query class to build a URL with filters, includes, and sorting. This is the primary method for generating API request URLs.

```javascript
const { Query } = require("cogent-js");

const query = new Query();

const url = query
  .for('posts')
  .where('name', 'Bob')
  .includes('posts', 'comments')
  .orderBy('-created_at')
  .get();
```

--------------------------------

### Available Methods

Source: https://www.npmjs.com/package/cogent-js/v/1.0

Details the various methods available on the Query class for constructing complex API URLs, including filtering, selection, sorting, and pagination.

```APIDOC
## Available Methods

### Description
This section details the various fluent methods provided by the `Query` class to customize and build API request URLs.

### Methods Overview

- **`where(field, value)`**: Adds a filter condition.
  - Example: `/users?filter[name]=Bob`
  - Code: `query.for('users').where('name', 'Bob').url()`

- **`whereIn(field, values)`**: Adds a filter condition for multiple values.
  - Example: `/users?filter[name]=bob,jerry`
  - Code: `query.for('users').whereIn('name', ['bob', 'jerry']).url()`

- **`select(...fields)`**: Specifies which fields to include in the response.
  - Example: `/users?fields=name,age,date_of_birth`
  - Code: `query.for('users').select('name', 'age', 'date_of_birth').url()`

- **`include(...relations)`**: Specifies related resources to include.
  - Example: `/users?include=posts`
  - Code: `query.for('users').include('posts').url()`

- **`append(...fields)`**: Appends additional fields to the request.
  - Example: `/users?append=full_name,age`
  - Code: `query.for('users').append('full_name', 'age').url()`

- **`limit(count)`**: Sets the number of items to return.
  - Example: `/users?limit=5`
  - Code: `query.for('users').limit(5).url()`

- **`page(pageNumber)`**: Sets the current page number for pagination.
  - Example: `/users?page=2&limit=5`
  - Code: `query.for('users').limit(5).page(2).url()`

- **`sort(...fields)`**: Specifies the fields to sort by.
  - Example: `/users?sort=-name,age`
  - Code: `query.for('users').sort('-name', 'age').url()`

- **`params(options)`**: Appends custom query parameters.
  - Example: `/users?format=admin`
  - Code: `query.for('users').params({ format: 'admin' }).url()`

### Response

#### Success Response (200)
N/A - This is a client-side URL builder.

#### Response Example
N/A
```

--------------------------------

### Basic URL Construction with cogent-js

Source: https://www.npmjs.com/package/cogent-js/v/2.0_activeTab=readme

Demonstrates the fundamental usage of the cogent-js Query class to build a URL with filters, includes, and ordering. This is the primary method for generating API endpoints.

```javascript
const { Query } = require("cogent-js");

const query = new Query();

// /posts?filter[name]=Bob&include=posts,comments&orderBy=-created_at
const url = query
  .for('posts') // the model you're selecting
  .where('name', 'Bob') // where the models `name` is 'Bob'
  .includes('posts', 'comments') // include the models related relationships: posts and comments
  .orderBy('-created_at') // order by -created_at desc
  .get(); // generate the url and pass it into fetch!
```

--------------------------------

### Basic URL Construction with CogentJS

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=code

Demonstrates the fundamental usage of the CogentJS `Query` class to build a URL with common query parameters like `for`, `where`, `include`, and `orderBy`. This is the most straightforward way to create API request URLs.

```javascript
const { Query } = require("cogent-js");

const query = new Query();

// /posts?filter[name]=Bob&include=posts,comments&orderBy=-created_at
const url = query
  .for('posts')
  .where('name', 'Bob')
  .include('posts', 'comments')
  .orderBy('-created_at')
  .get();

console.log(url);
```

--------------------------------

### Setting a Base URL with CogentJS

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=versions

Illustrates how to configure CogentJS with a base URL. When a base URL is set, it will be automatically prepended to all generated URLs, simplifying requests to a specific API endpoint.

```javascript
const { Query } = require('cogent-js');

const query = new Query({
  base_url: 'http://api.example.com'
});

// http://api.example.com/users?filter[name]=Bob
const url = query.for('users').where('name', 'Bob').url()); // or .get();
```

--------------------------------

### Including Related Resources with include() in CogentJS

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=versions

Shows how to use the `include()` method to request related resources along with the primary resource. This is common in APIs to avoid multiple round trips for linked data.

```javascript
// /pouserssts?include=posts
const url = query.for('users').include('posts').url()); // or .get();
```

--------------------------------

### Setting a base URL for API requests

Source: https://www.npmjs.com/package/cogent-js/v/2.0_activeTab=dependents

Configures the Query class with a base URL. This prepends the specified base URL to all generated API endpoints, simplifying relative path management.

```javascript
const { Query } = require('cogent-js');

const query = new Query({
  base_url: 'http://api.example.com'
});

// http://api.example.com/users?filter[name]=Bob
const url = query.for('users').where('name', 'Bob').url(); // or .get();
```

--------------------------------

### Using `limit()` and `page()` for Pagination in CogentJS

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=code

Combines the `limit()` and `page()` methods to specify both the number of items per page and the current page number for paginated API requests. This is essential for navigating through large datasets.

```javascript
const { Query } = require('cogent-js');
const query = new Query();

// /users?page=2&limit=5
const url = query.for('users').limit(5).page(2).url(); // or .get();

console.log(url);
```

--------------------------------

### Using `include()` Method in CogentJS

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=code

Shows how to use the `include()` method to specify related resources that should be included in the API response. This is common for fetching nested or associated data.

```javascript
const { Query } = require('cogent-js');
const query = new Query();

// /users?include=posts
const url = query.for('users').include('posts').url(); // or .get();

console.log(url);
```

--------------------------------

### CogentJS URL Builder API

Source: https://www.npmjs.com/package/cogent-js/index_activeTab=readme

This section details the core functionality of the CogentJS library for building API URLs. It covers instantiation, common methods for adding query parameters, and generating the final URL.

```APIDOC
## CogentJS URL Builder API

### Description

The CogentJS library allows developers to construct REST API URLs in a programmatic and readable manner using a fluent syntax. This documentation covers the primary methods available for building these URLs.

### Class: Query

#### Constructor

`new Query(config?: object)`

Initializes a new Query instance. An optional configuration object can be provided for setting a base URL or customizing query parameter names.

**Configuration Object Properties:**

- **`base_url`** (string) - Optional. The base URL to prepend to all generated URLs.
- **`queryParameters`** (object) - Optional. An object to customize the names of query parameters (e.g., `include`, `filters`, `sort`).

### Methods

#### `for(model: string): Query`

Specifies the primary resource or model for the API request.

**Example:**
```javascript
query.for('posts')
```

#### `where(field: string, value: any): Query`

Adds a filter condition to the query.

**Example:**
```javascript
query.where('name', 'Bob')
```

#### `whereIn(field: string, values: any[]): Query`

Adds a filter condition to include values within a specified array.

**Example:**
```javascript
query.whereIn('name', ['bob', 'jerry'])
```

#### `select(...fields: string[]): Query`

Specifies which fields to include in the response.

**Example:**
```javascript
query.select('name', 'age', 'date_of_birth')
```

#### `includes(...relations: string[]): Query`

Requests the inclusion of related resources.

**Example:**
```javascript
query.includes('posts', 'comments')
```

#### `appends(...params: string[]): Query`

Appends additional parameters to the query.

**Example:**
```javascript
query.appends('full_name', 'age')
```

#### `limit(count: number): Query`

Sets the maximum number of results to return.

**Example:**
```javascript
query.limit(5)
```

#### `page(pageNumber: number): Query`

Specifies the page number for pagination.

**Example:**
```javascript
query.page(2)
```

#### `sort(...fields: string[]): Query`

Defines the sorting order for the results. Prefixing a field with `-` indicates descending order.

**Example:**
```javascript
query.sort('-created_at')
```

#### `params(parameters: object): Query`

Adds custom key-value pairs as query parameters.

**Example:**
```javascript
query.params({ format: 'admin' })
```

#### `get(): string`

Generates and returns the complete API URL.

**Example:**
```javascript
const url = query.for('posts').where('name', 'Bob').get();
// url will be '/posts?filter[name]=Bob'
```

#### `url(): string`

Alias for `get()`, also generates and returns the complete API URL.

**Example:**
```javascript
const url = query.for('users').where('name', 'Bob').url();
// url will be '/users?filter[name]=Bob'
```

### Example Usage

```javascript
const { Query } = require("cogent-js");

// Basic usage
const query = new Query();
const url = query
  .for('posts')
  .where('name', 'Bob')
  .includes('posts', 'comments')
  .orderBy('-created_at')
  .get();
// url: "/posts?filter[name]=Bob&include=posts,comments&orderBy=-created_at"

// With base URL
const queryWithBase = new Query({ base_url: 'http://api.example.com' });
const urlWithBase = queryWithBase.for('users').where('name', 'Bob').url();
// urlWithBase: "http://api.example.com/users?filter[name]=Bob"
```
```

--------------------------------

### Limiting Results with limit() and Pagination with page() in cogent-js

Source: https://www.npmjs.com/package/cogent-js/v/2.0_activeTab=readme

Details the usage of `limit()` to control the maximum number of results returned and `page()` to implement pagination. These are standard features for managing large datasets.

```javascript
// /users?limit=5
const url = query.for('users').limit(5).url(); // or .get();
```

```javascript
// /users?page=2&limit=5
const url = query.for('users').limit(5).page(2).url(); // or .get();
```

--------------------------------

### Using select() method for specific fields

Source: https://www.npmjs.com/package/cogent-js/v/2.0_activeTab=dependents

Specifies which fields to include in the API response. This helps in optimizing data transfer by fetching only necessary information.

```javascript
// /users?fields=name,age,date_of_birth
const url = query.for('users').select('name', 'age', 'date_of_birth').url(); // or .get();
```

--------------------------------

### Selecting Specific Fields with select() in cogent-js

Source: https://www.npmjs.com/package/cogent-js/v/2.0

Explains how to use the `select()` method to specify which fields should be returned in the API response. This helps in reducing payload size by fetching only necessary data.

```javascript
const url = query.for('users').select('name', 'age', 'date_of_birth').url();
```

--------------------------------

### Adding Custom Parameters with params() in cogent-js

Source: https://www.npmjs.com/package/cogent-js/v/2.0

Shows how to append arbitrary custom parameters to the URL using the `params()` method. This provides flexibility for non-standard API requirements.

```javascript
const url = query.for('users').params({ format: 'admin' }).url();
```

--------------------------------

### Using `sort()` Method in CogentJS

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=code

Demonstrates the `sort()` method for defining the order in which resources are returned. It supports both ascending and descending order using a prefix.

```javascript
const { Query } = require('cogent-js');
const query = new Query();

// /users?sort=-name,age
const url = query.for('users').sort('-name', 'age').url(); // or .get();

console.log(url);
```

--------------------------------

### Using `limit()` Method for Pagination in CogentJS

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=code

Illustrates the `limit()` method for controlling the number of items returned in a paginated response. This is a standard way to manage the size of API result sets.

```javascript
const { Query } = require('cogent-js');
const query = new Query();

// /users?limit=5
const url = query.for('users').limit(5).url(); // or .get();

console.log(url);
```

--------------------------------

### Adding Custom Parameters with params() in CogentJS

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=versions

Shows how to add arbitrary custom query parameters to the URL using the `params()` method. This provides flexibility for non-standard API requirements.

```javascript
// /users?format=admin
const url = query.for('users').params({ format: 'admin' }).url()); // or .get();
```

--------------------------------

### Limiting Results with limit() in cogent-js

Source: https://www.npmjs.com/package/cogent-js/v/2.0

Illustrates the `limit()` method for controlling the maximum number of records returned in a query. This is crucial for pagination and performance optimization.

```javascript
const url = query.for('users').limit(5).url();
```

--------------------------------

### Using the append() Method in cogent-js

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=dependents

Illustrates the `append()` method for adding extra attributes or calculated fields to the API response using cogent-js.

```javascript
// /users?append=full_name,age
const url = query.for('users').append('full_name', 'age').url(); // or .get();
```

--------------------------------

### Using `select()` Method in CogentJS

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=code

Explains the `select()` method, which allows you to specify which fields to include in the API response. This is useful for optimizing data retrieval by only fetching necessary information.

```javascript
const { Query } = require('cogent-js');
const query = new Query();

// /users?fields=name,age,date_of_birth
const url = query.for('users').select('name', 'age', 'date_of_birth').url(); // or .get();

console.log(url);
```

--------------------------------

### Limiting Results with limit() in CogentJS

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=versions

Illustrates the `limit()` method for controlling the maximum number of results returned by the API. This is crucial for performance and managing data sets.

```javascript
// /users?limit=5
const url = query.for('users').limit(5).url()); // or .get();
```

--------------------------------

### Selecting Specific Fields with select() in CogentJS

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=versions

Explains the `select()` method, which allows you to specify which fields you want to retrieve from the API. This is useful for reducing payload size and fetching only necessary data.

```javascript
// /users?fields=name,age,date_of_birth
const url = query.for('users').select('name', 'age', 'date_of_birth').url()); // or .get();
```

--------------------------------

### Filtering Records with where() and whereIn() in cogent-js

Source: https://www.npmjs.com/package/cogent-js/v/2.0_activeTab=readme

Shows how to apply filters to URL generation using the `where()` method for single values and `whereIn()` for multiple values. These methods are essential for selecting specific records.

```javascript
// /users?filter[name]=Bob
const url = query.for('users').where('name', 'Bob').url(); // or .get();
```

```javascript
// /users?filter[name]=bob,jerry
const url = query.for('users').whereIn('name', ['bob', 'jerry']).url(); // or .get();
```

--------------------------------

### Customizing Query Parameter Names in CogentJS

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=code

Explains how to customize the names of default query parameters (like `include`, `filter`, `sort`) by passing a configuration object during `Query` instantiation. This is useful for aligning with API conventions or avoiding conflicts.

```javascript
const { Query } = require("cogent-js");

const query = new Query({
  queryParameters: {
    include: "include_custom",
    filter: "filter_custom",
    sort: "sort_custom",
    fields: "fields_custom",
    append: "append_custom",
    page: "page_custom",
    limit: "limit_custom"
  }
});

// Example of how a custom parameter might be used (actual URL depends on other methods called)
console.log(query.for('items').include('details').url()); // Might generate something like /items?include_custom=details
```

--------------------------------

### Customizing Query Parameter Names in CogentJS

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=versions

Explains how to override the default query parameter names (e.g., 'include', 'filter') by providing a custom configuration object during `Query` instantiation. This allows for compatibility with APIs that use different parameter naming conventions.

```javascript
const { Query } = require("cogent-js");

const query = new Query({
  queryParameters: {
    include: "include_custom",
    filter: "filter_custom",
    sort: "sort_custom",
    fields: "fields_custom",
    append: "append_custom",
    page: "page_custom",
    limit: "limit_custom"
  }
});
```

--------------------------------

### Using where() method for filtering

Source: https://www.npmjs.com/package/cogent-js/v/2.0_activeTab=dependents

Applies a simple key-value filter to the URL. This method is used to specify conditions for retrieving data.

```javascript
// /users?filter[name]=Bob
const url = query.for('users').where('name', 'Bob').url(); // or .get();
```

--------------------------------

### Appending Custom Parameters with `params()` in CogentJS

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=code

Shows how to append custom, non-standard query parameters to the URL using the `params()` method. This provides flexibility for interacting with APIs that require unique parameters.

```javascript
const { Query } = require('cogent-js');
const query = new Query();

// /users?format=admin
const url = query.for('users').params({ format: 'admin' }).url(); // or .get();

console.log(url);
```

--------------------------------

### Using sort() method for ordering results

Source: https://www.npmjs.com/package/cogent-js/v/2.0_activeTab=dependents

Specifies the order in which results should be returned. It accepts field names and can be prefixed with '-' for descending order.

```javascript
// /users?sort=-name,age
const url = query.for('users').sort('-name', 'age').url(); // or .get();
```

--------------------------------

### Adding custom parameters to the URL

Source: https://www.npmjs.com/package/cogent-js/v/2.0_activeTab=dependents

Allows for the addition of arbitrary custom query parameters to the URL by passing an object to the `params()` method.

```javascript
// /users?format=admin
const url = query.for('users').params({ format: 'admin' }).url(); // or .get();
```

--------------------------------

### Using includes() method for relationships

Source: https://www.npmjs.com/package/cogent-js/v/2.0_activeTab=dependents

Requests related data (relationships) to be included in the API response. This is commonly used for eager loading in APIs.

```javascript
// /users?include=posts
const url = query.for('users').includes('posts').url(); // or .get();
```

--------------------------------

### Using limit() method for result count

Source: https://www.npmjs.com/package/cogent-js/v/2.0_activeTab=dependents

Limits the number of results returned by the API. This is essential for pagination and controlling response size.

```javascript
// /users?limit=5
const url = query.for('users').limit(5).url(); // or .get();
```

--------------------------------

### Using `whereIn()` Method in CogentJS

Source: https://www.npmjs.com/package/cogent-js/v/1.0_activeTab=code

Demonstrates how to use the `whereIn()` method to filter resources based on a list of possible values for a given field. This is useful for queries where a field can match any value in a provided array.

```javascript
const { Query } = require('cogent-js');
const query = new Query();

// /users?filter[name]=bob,jerry
const url = query.for('users').whereIn('name', ['bob', 'jerry']).url(); // or .get();

console.log(url);
```
Tokens:
Raw