Kitsu

https://github.com/wopian/kitsu
Admin
Kitsu is a simple, lightweight & framework agnostic JSON:API client for kitsu.app & other APIs.
Tokens:24,961
Snippets:225
Trust Score:9.4
License:MIT
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install kitsu-core with Yarn or NPM

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu-core/README.md

Install the kitsu-core package using your preferred package manager.

```bash
yarn add kitsu-core
npm install kitsu-core
```

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

### Install Dependencies

Source: https://github.com/wopian/kitsu/blob/master/CONTRIBUTING.md

Install project dependencies using either Yarn or npm. Ensure you have Node.js and a package manager installed.

```bash
yarn
# or
npm install
```

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

### Install Kitsu using Yarn or NPM

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Install the kitsu package using either Yarn or NPM. This is the first step to using the library in your project.

```bash
yarn add kitsu
npm install kitsu
```

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

### Nested Query Parameters Example

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/MIGRATING.md

Demonstrates how to construct nested query parameters for filtering resources.

```javascript
api.get('resource', {
  filter: {
    myFilter: {
      content: {
        name: 'filter_name'
      }
    }
  }
})
```

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

### Kitsu Client Response Example

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

An example of a response object processed by the Kitsu client, where related data is often flattened into the main object.

```json5
{
  data: {
    id: '1'
    type: 'articles'
    title: 'JSON API paints my bikeshed'
    author: {
      data: {
        id: '42'
        type: 'people'
        name: 'John'
      }
    }
  }
}
```

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

### JSON:API Server Response Example

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

An example of a standard JSON:API response object from a server, including 'data' and 'included' sections.

```json5
{
  data: {
    id: '1'
    type: 'articles'
    attributes: {
      title: 'JSON API paints my bikeshed'
    }
    relationships: {
      author: {
        data: {
          id: '42'
          type: 'people'
        }
      }
    }
  }
  included: [
    {
      id: '42'
      type: 'people'
      attributes: {
        name: 'John'
      }
    }
  ]
}
```

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

### get

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Fetches a resource or a collection of resources.

```APIDOC
## GET /:type

Fetches a resource or a collection of resources.

### Method

GET

### Endpoint

`/:type`

### Parameters

#### Path Parameters

* **type** (string) - Required - The type of resource to fetch.

#### Query Parameters

* **filter** (object) - Optional - Filters to apply to the request.
* **sort** (string) - Optional - Fields to sort the results by.
* **page[limit]** (number) - Optional - The maximum number of resources to return.
* **page[offset]** (number) - Optional - The offset for pagination.
* **include** (string) - Optional - Comma-separated list of related resources to include.

### Request Example

```javascript
// Fetch a single user by ID
api.get('users', { filter: { id: '1' } });

// Fetch a collection of posts with included author and comments
api.get('posts', {
  include: 'author,comments',
  'page[limit]': 10,
  'page[offset]': 0
});
```

### Response

#### Success Response (200)

Returns a JSON:API compliant response containing the requested resources.

* **data** (array) - The array of resources.
* **included** (array) - Any included related resources.
* **links** (object) - Links for pagination and related resources.
* **meta** (object) - Metadata about the response.

#### Response Example

```json
{
  "data": [
    {
      "type": "users",
      "id": "1",
      "attributes": {
        "name": "John Doe"
      }
    }
  ],
  "links": {
    "self": "https://kitsu.app/api/edge/users?page[limit]=10&page[offset]=0"
  }
}
```
```

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

### Clone Repository

Source: https://github.com/wopian/kitsu/blob/master/CONTRIBUTING.md

Clone your forked repository to your local machine and navigate into the project directory. Ensure you have Git installed.

```bash
git clone https://github.com/your-username/kitsu.git
cd kitsu
```

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

### get

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Fetch resources from the API. This method is an alias for the `fetch` functionality.

```APIDOC
## get

### Description
Fetches resources from the Kitsu API. This method serves as an alias for the underlying fetch operation.

### Usage
`api.get(resourcePath, [config])`

### Parameters
- **resourcePath** (string) - Required - The path to the resource to fetch (e.g., 'users', 'anime').
- **config** (Object) - Optional - Configuration object for the request (e.g., for query parameters, headers not set globally).
```

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

### Getting a resource with JSON:API parameters

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Demonstrates how to fetch a specific resource using JSON:API compliant parameters for filtering and field selection.

```APIDOC
## GET /users

### Description
Retrieves a user resource with specified fields and filters.

### Method
GET

### Endpoint
`/users`

### Parameters
#### Query Parameters
- **fields** (object) - Optional - Specifies which fields to include for the users resource.
- **filter** (object) - Optional - Filters the results based on user properties.

### Request Example
```javascript
api.get('users', {
  params: {
    fields: {
      users: 'name,birthday'
    },
    filter: {
      name: 'wopian'
    }
  }
})
```
```

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

### Utilize JSON:API Parameters

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Demonstrates how to use common JSON:API query parameters such as include, fields, filter, sort, and pagination with the `get` method.

```javascript
// JSON:API parameters
api.get('users', {
  params: {
    include: 'followers,waifu.character',
    fields: {
      users: 'slug,followers,waifu'
    },
    filter: {
      slug: 'wopian'
    },
    sort: '-id',
    page: {
      limit: 5,
      offset: 0
    }
  }
})
```

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

### Getting a collection of resources with their relationships

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Shows how to retrieve a collection of resources and include related data, such as categories for anime.

```APIDOC
## GET /anime

### Description
Retrieves a collection of anime resources and includes their associated categories.

### Method
GET

### Endpoint
`/anime`

### Parameters
#### Query Parameters
- **include** (string) - Optional - Specifies related resources to include in the response, e.g., 'categories'.

### Request Example
```javascript
api.get('anime', {
  params: {
    include: 'categories'
  }
})
```
```

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

### Legacy Deserialization Output

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu-core/MIGRATING.md

Example output structure after applying legacy deserialization.

```javascript
data: {
  id: '1',
  type: 'libraryEntries',
  ratingTwenty: 10,
  user: {
    id: '2',
    type: 'users',
    name: 'Example'
  }
}
```

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

### New Deserialization Output

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu-core/MIGRATING.md

Example output structure after applying new deserialization behavior with the same input as legacy.

```javascript
data: {
  id: '1',
  type: 'libraryEntries',
  links: {
    self: 'library-entries/1'
  },
  ratingTwenty: 10,
  user: {
    links: {
      self: 'library-entries/1/relationships/user',
      related: 'library-entries/1/user'
    },
    data: {
      id: '2',
      type: 'users',
      links: {
        self: 'users/2'
      },
      name: 'Example'
    }
  }
}
```

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

### Kitsu Core `serialise` New Output Structure

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu-core/MIGRATING.md

Example of the output structure from the `serialise` function with new input. Relationships are correctly formatted with `links` and `data` keys.

```json
data: {
  id: '1',
  type: 'libraryEntries',
  links: { self: 'library-entries/1' },
  relationships: {
    user: {
      links: {
        self: 'library-entries/1/relationships/user'
        related: 'libary-entries/1/user'
      },
      data: {
        id: '2',
        type: 'users',
        links: { self: 'users/2' },
        attributes: {
          name: 'Example'
        }
      }
    },
    unit: {
      links: {
        self: 'library-entries/1/relationships/unit',
        related: 'library-entries/1/unit'
      },
      data: [
        {
          id: '3',
          type: 'episodes',
          links: { self: 'episodes/3' },
          attributes: {
            number: 12
          }
        }
      ]
    }
  }
}
```

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

### Legacy Deserialization Input

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu-core/MIGRATING.md

Example input data structure for the legacy deserialization behavior.

```javascript
data: {
  id: '1',
  type: 'libraryEntries'
  links: {
    self: 'library-entries/1'
  },
  attributes: {
    ratingTwenty: 10
  },
  relationships: {
    user: {
      links: {
        self: 'library-entries/1/relationships/user',
        related: 'library-entries/1/user'
      },
      data: {
        id: '2',
        type: 'users'
      }
    }
  }
},
included: [
  {
    id: '2',
    type: 'users',
    links: {
      self: 'users/2'
    },
    attributes: {
      name: 'Example'
    }
  }
]
```

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

### Get Collection with Relationships

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Retrieve a collection of resources and include their related data.

```javascript
api.get('anime', {
  params: {
    include: 'categories'
  }
})
```

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

### Send Raw GET Request with Kitsu

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Use this method to perform a raw GET request to a specific API endpoint. Configure the URL, resource type, and any necessary query parameters.

```javascript
api.request({
  url: 'anime/1/mappings',
  type: 'mappings',
  params: { filter: { externalSite: 'aozora' } }
})
```

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

### Get Resource with JSON:API Parameters

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Fetch a specific resource using JSON:API parameters for filtering and field selection.

```javascript
api.get('users', {
  params: {
    fields: {
      users: 'name,birthday'
    },
    filter: {
      name: 'wopian'
    }
  }
})
```

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

### Kitsu Core `serialise` New Input Structure

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu-core/MIGRATING.md

Example of the input structure for the `serialise` function in newer versions. Relationships must be objects containing `data` and optional `links` or `meta`.

```json
{
  id: '1',
  type: 'libraryEntries',
  links: { self: 'library-entries/1' }
  user: { // one-to-one relationship
    links: {
      self: 'library-entries/1/relationships/user'
      related: 'libary-entries/1/user'
    },
    data: {
      id: '2',
      type: 'users',
      links: { self: 'users/2' }
      name: 'Example'
    }
  },
  unit: { // one-to-many relationship
    links: {
      self: 'library-entries/1/relationships/unit',
      related: 'library-entries/1/unit'
    },
    data: [
      {
        id: '3',
        type: 'episodes',
        links: { self: 'episodes/3' },
        number: 12
      }
    ]
  }
}
```

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

### Fetch Data using Async/Await

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Retrieve data from the API using the `get` method with async/await syntax for cleaner asynchronous operations.

```javascript
// Using with async/await
const res = await api.get('anime')
```

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

### Getting a single resource by ID (method one)

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Fetches a single anime resource by its ID and includes its related categories.

```APIDOC
## GET /anime/:id

### Description
Retrieves a specific anime resource by its ID, including its categories.

### Method
GET

### Endpoint
`/anime/:id`

### Parameters
#### Path Parameters
- **id** (string) - Required - The unique identifier of the anime resource.
#### Query Parameters
- **include** (string) - Optional - Specifies related resources to include in the response, e.g., 'categories'.

### Request Example
```javascript
api.get('anime/2', {
  params: {
    include: 'categories'
  }
})
```
```

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

### Kitsu Core `serialise` Legacy Output Structure

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu-core/MIGRATING.md

Example of the output structure from the `serialise` function with legacy input. Relationships were placed under `relationships` and nested data was under `attributes`.

```json
data: {
  id: '1',
  type: 'libraryEntries',
  attributes: {
    links: { self: 'library-entries/1' }
  },
  relationships: {
    user: {
      data: {
        id: '2',
        type: 'users',
        attributes: {
          links: { self: 'users/2' }
          name: 'Example'
        }
      }
    },
    unit: {
      data: [
        {
          id: '3',
          type: 'episodes',
          attributes: {
            links: { self: 'episodes/3' }
            number: 12
          }
        }
      ]
    }
  }
}
```

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

### Get Single Resource by ID

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Fetch a single resource by its ID, with an option to include relationships.

```javascript
api.get('anime/2', {
  params: {
    include: 'categories'
  }
})
```

```javascript
api.get('anime', {
  params: {
    include: 'categories',
    filter: { id: '2' }
 }
})
```

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

### Get Resource Relationship Data Only

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Retrieve only the relationship data for a specific resource.

```javascript
api.get('anime/2/categories')
```

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

### Kitsu Core `serialise` Legacy Input Structure

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu-core/MIGRATING.md

Example of the input structure for the `serialise` function in previous versions. Relationships were directly embedded without a `data` key.

```json
{
  id: '1',
  type: 'libraryEntries',
  links: { self: 'library-entries/1' }
  user: { // one-to-one relationship
    id: '2',
    type: 'users',
    links: { self: 'users/2' }
    name: 'Example'
  },
  unit: [ // one-to-many relationship
    {
      id: '3',
      type: 'episodes',
      links: { self: 'episodes/3' }
      number: 12
    }
  ]
}
```

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

### Getting a single resource by ID (method two)

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

An alternative method to fetch a single anime resource by ID using a filter parameter.

```APIDOC
## GET /anime

### Description
Retrieves a specific anime resource by its ID using a filter parameter and includes its categories.

### Method
GET

### Endpoint
`/anime`

### Parameters
#### Query Parameters
- **include** (string) - Optional - Specifies related resources to include in the response, e.g., 'categories'.
- **filter** (object) - Optional - Filters the results. Use `id` to specify the resource ID.

### Request Example
```javascript
api.get('anime', {
  params: {
    include: 'categories',
    filter: { id: '2' }
  }
})
```
```

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

### Get Resource with Nested Filters

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Demonstrates how to structure nested filters for resource retrieval. Note: This specific nested filter structure may not be supported by all APIs.

```javascript
// resource?filter[x][y]=value
api.get('resource', {
  params: {
    filter: {
      x: {
        y: 'value'
      }
    }
  }
})
```

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

### Fetch Data using Promises

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Retrieve data from the API using the `get` method with Promise-based syntax, handling responses and errors with `.then()` and `.catch()`.

```javascript
// Using with Promises
api.get('anime')
  .then(res => { ... })
  .catch(err => { ... })
```

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

### Consolidated Config Parameter for Requests

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/MIGRATING.md

For `GET`, `PATCH`, `POST`, `DELETE`, `SELF`, and `REQUEST` methods, the `params` and `headers` arguments have been merged into a single `config` object. This simplifies the API signature.

```javascript
Kitsu.get(model, config? { params?, headers? })
```

```javascript
Kitsu.patch(model, body, config? { params?, headers? })
```

```javascript
Kitsu.delete(model, id, config? { params?, headers? })
```

```javascript
Kitsu.self(config? { params?, headers? })
```

```javascript
Kitsu.request(config? { headers? })
```

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

### Get Authenticated User Data with Parameters

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Fetch the authenticated user's data while applying specific JSON:API query parameters, such as filtering fields.

```javascript
api.self({
  params: {
    fields: {
      users: 'name,birthday'
    }
  }
})
```

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

### Serialise with Custom Options

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu-core/README.md

Use this snippet to serialize an object into JSON-API format with custom options for camel casing and pluralization. This is useful when you need to control the output format precisely, for example, by using the default options provided by the kitsu package.

```javascript
import { serialise, camel } from 'kitsu-core'
import pluralize from 'pluralize'

const model = 'anime'
const obj = { id: '1', slug: 'shirobako' }

// { data: { id: '1', type: 'anime', attributes: { slug: 'shirobako' } } }
const output = serialise(model, obj, 'PATCH', { camelCaseTypes: camel, pluralTypes: pluralize })
```

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

### Accessing Relationship Resources with Kitsu API

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/MIGRATING.md

Shows the updated methods for accessing relationship resources in Kitsu 9.0.0. Use these methods for GET, PATCH, POST, and DELETE operations on related resources.

```javascript
import Kitsu from 'kitsu'

const api = new Kitsu()

api.get('posts/1/comments')
api.patch('post/1/comments', { id: '1', body: 'An updated comment'})
api.post('post/1/comments', { body: 'A new comment'})
api.delete('post/1/comments', 1)
```

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

### Fetch Resources

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Demonstrates various ways to fetch resources, including by endpoint, with query parameters, and by specific resource IDs or relationships.

```javascript
// Fetching resources (get/fetch)
api.fetch('anime')
api.fetch('anime', { params: { filter: { id: 1 } } })
api.fetch('anime/1/episodes')
api.fetch('anime/1/relationships/episodes')
```

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

### Initialize Kitsu API Client

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Instantiate the Kitsu client. Use the default constructor for kitsu.app's API or provide a custom baseURL for other JSON:API servers.

```javascript
// kitsu.app's API
const api = new Kitsu()

// Other JSON:API servers
const api = new Kitsu({ 
  baseURL: 'https://api.example/2'
})
```

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

### Initialize Kitsu API Client

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Instantiate the Kitsu client to interact with the default kitsu.app API.

```javascript
const api = new Kitsu()
```

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

### Kitsu Constructor

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Initialize the Kitsu API client. You can specify a custom API server URL, set default headers, or configure flatter responses.

```APIDOC
## Kitsu Constructor

### Description
Initializes a new Kitsu API client instance. Allows configuration of the base URL for the API server, default headers to be sent with every request, and an option to hoist data directly without a `data` property in responses.

### Parameters
#### Constructor Options
- **baseURL** (string) - Optional - The base URL for the API server. Defaults to kitsu.app's API.
- **headers** (Object) - Optional - An object containing headers to be sent with every request.
- **hoistData** (boolean) - Optional - If true, response data will not be wrapped in a `data` property.
```

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

### Kitsu Constructor

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Initializes a new Kitsu API client instance. You can configure various options such as the base URL, headers, query serialization, casing, pluralization, and request timeout.

```APIDOC
## Kitsu Constructor

Creates a new `kitsu` instance.

### Parameters

* `options` **[Object]?** Options (optional, default `{}`)

    * `options.baseURL` **[string]** Set the API endpoint (optional, default `'https://kitsu.app/api/edge'`)
    * `options.headers` **[Object]?** Additional headers to send with the requests
    * `options.query` **(`"traditional"` | `"modern"` | [Function])** Query serializer function to use. This will impact the way keys are serialized when passing arrays as query parameters. 'modern' is recommended for new projects. (optional, default `traditional`)
    * `options.camelCaseTypes` **[boolean]** If enabled, `type` will be converted to camelCase from kebab-casae or snake_case (optional, default `true`)
    * `options.resourceCase` **(`"kebab"` | `"snake"` | `"none"`)** Case to convert camelCase to. `kebab` - `/library-entries`; `snake` - /library_entries`; `none`-`/libraryEntries\` (optional, default `kebab`)
    * `options.pluralize` **[boolean]** If enabled, `/user` will become `/users` in the URL request and `type` will be pluralized in POST, PATCH and DELETE requests (optional, default `true`)
    * `options.timeout` **[number]** Set the request timeout in milliseconds (optional, default `30000`)
    * `options.axiosOptions` **[Object]?** Additional options for the axios instance (see [axios/axios#request-config](https://github.com/axios/axios#request-config) for details)
    * `options.hoistData` **[boolean]** If enabled, the contents of the `data` property will be hoisted to the parent. This provides a flatter response object, see examples below for transformation examples. Links and Meta properties will be merged into the parent object if they exist. If attributes named `links` or `meta` exist, they will overwrite the JSON:API `links` and `meta` properties. (optional, default `false`)

### Examples

```javascript
import Kitsu from '@kitsu/kitsu';

const api = new Kitsu({
  baseURL: 'https://kitsu.app/api/edge',
  headers: {
    'Accept': 'application/vnd.api+json',
    'Content-Type': 'application/vnd.api+json'
  }
});
```
```

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

### Importing Kitsu Legacy

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/MIGRATING.md

Update import paths when migrating from older versions that used `/lib/`.

```diff
import Kitsu from 'kitsu/lib/legacy'
+ import Kitsu from 'kitsu/legacy'
```

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

### Initialize Kitsu API Client with Custom Base URL

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Configure the Kitsu client to use a different API server by specifying a baseURL.

```javascript
const api = new Kitsu({
  baseURL: 'https://api.example.org/2'
})
```

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

### Include kitsu-core via CDN

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu-core/README.md

Include kitsu-core in your HTML using CDNs like jsDelivr or unpkg.

```html
<!-- jsDelivr -->
<script src="https://cdn.jsdelivr.net/npm/kitsu-core"></script>

<!-- unpkg -->
<script src="https://unpkg.com/kitsu-core"></script>
```

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

### Getting a resource's relationship data only

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Retrieves only the relationship data for a specific resource, such as the categories associated with an anime.

```APIDOC
## GET /anime/:id/categories

### Description
Retrieves the relationship data for the categories of a specific anime resource.

### Method
GET

### Endpoint
`/anime/:id/categories`

### Parameters
#### Path Parameters
- **id** (string) - Required - The unique identifier of the anime resource.

### Request Example
```javascript
api.get('anime/2/categories')
```
```

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

### Access a Single Header Value

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Get the value of a specific header by its key from the Kitsu API client instance.

```javascript
api.headers['User-Agent']
```

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

### Create Resources

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Use the `create` method to send POST requests for creating new resources on the API.

```javascript
// Creating resources (post/create)
api.create('post', {
  content: 'some content'
})
```

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

### post

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Creates a new resource.

```APIDOC
## POST /:type

Creates a new resource.

### Method

POST

### Endpoint

`/:type`

### Parameters

#### Path Parameters

* **type** (string) - Required - The type of resource to create.

#### Request Body

* **data** (object) - Required - The resource data to create, conforming to JSON:API structure.
    * **type** (string) - Required - The type of the resource.
    * **attributes** (object) - Required - The attributes of the resource.
    * **relationships** (object) - Optional - The relationships to other resources.

### Request Example

```javascript
api.post('posts', {
  data: {
    type: 'posts',
    attributes: {
      title: 'My First Post',
      content: 'This is the content of my first post.'
    },
    relationships: {
      author: {
        data: { type: 'users', id: '1' }
      }
    }
  }
});
```

### Response

#### Success Response (201)

Returns the newly created resource.

* **data** (object) - The created resource.
* **links** (object) - Links related to the resource.

#### Response Example

```json
{
  "data": {
    "type": "posts",
    "id": "123",
    "attributes": {
      "title": "My First Post",
      "content": "This is the content of my first post."
    },
    "relationships": {
      "author": {
        "links": {
          "self": "https://kitsu.app/api/edge/posts/123/relationships/author",
          "related": "https://kitsu.app/api/edge/posts/123/author"
        }
      }
    }
  },
  "links": {
    "self": "https://kitsu.app/api/edge/posts/123"
  }
}
```
```

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

### Initialize Kitsu API Client with Custom Headers

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Set custom headers, such as User-Agent and Authorization, during Kitsu client initialization.

```javascript
const api = new Kitsu({
  headers: {
    'User-Agent': 'MyApp/1.0.0 (github.com/username/repo)',
    Authorization: 'Bearer 1234567890'
  }
})
```

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

### headers

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Access and modify the headers used for API requests. You can get all headers, retrieve a specific header's value, or add/update headers.

```APIDOC
## headers

### Description
Allows access and modification of the HTTP headers sent with API requests. This property is an object that holds all current headers.

### Usage
- **Get all headers**: `api.headers`
- **Get a specific header**: `api.headers['Header-Name']`
- **Add or update a header**: `api.headers['Header-Name'] = 'new-value'`

### Returns
**Object**: All the current headers.
```

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

### Use kitsu-core globally from CDN

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu-core/README.md

Access kitsu-core functions globally after including it via a CDN.

```javascript
kitsuCore.camel(...)
```

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

### Nested Query Parameters in Kitsu Core

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu-core/MIGRATING.md

Demonstrates how to construct nested query parameters using the kitsuCore.query method. This is useful for complex filtering and data retrieval scenarios.

```javascript
kitsuCore.query({
  filter: {
    myFilter: {
      content: {
        name: 'filter_name'
    }
  }
})
```

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

### Get Authenticated User Data

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Retrieve the data for the currently authenticated user. This requires the JSON:API server to support the `filter[self]=true` filter.

```javascript
api.self()
```

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

### Setting Headers in Kitsu 2.0.0+

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/MIGRATING.md

The `kitsu.header('key', 'value')` method has been removed in Kitsu 2.0.0. Use the `kitsu.headers` object to set headers directly.

```javascript
// kitsu.header('key', 'value') has been removed
// Use the existing kitsu.headers['key'] = 'value'
```

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

### Handling errors (async/await)

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Demonstrates how to handle errors when making API requests using async/await syntax.

```APIDOC
## Error Handling with async/await

### Description
This example shows how to catch and process errors that occur during asynchronous API calls.

### Code Example
```javascript
try {
  const { data } = await api.get('anime')
} catch (err) {
  // Array of JSON:API errors: http://jsonapi.org/format/#error-objects
  if (err.errors) err.errors.forEach(error => { ... })
  // Error type (Error, TypeError etc.)
  err.name
  // Error message
  err.message
  // Axios request parameters
  err.config
  // Axios response parameters
  err.response
}
```
```

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

### create

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Creates a new resource. This method can be used to create single or multiple resources, depending on the API's support for the Bulk Extension.

```APIDOC
## POST /:resource

### Description
Creates a new resource. This method can be used to create single or multiple resources, depending on the API's support for the Bulk Extension.

### Method
POST

### Endpoint
/:resource

### Parameters
#### Path Parameters
- **model** (string) - Required - Resource to create. Expected formats are [:resource](https://jsonapi.org/format/#document-resource-objects), [:resource/:id](https://jsonapi.org/format/#document-resource-objects), [:resource/:id/:relationship](https://jsonapi.org/format/#document-resource-object-relationships) or [:resource/:id/relationships/:relationship](https://jsonapi.org/format/#document-resource-object-linkage)

#### Request Body
- **body** (Object | Array<Object>) - Required - Data to send in the request

#### Request Body
- **config** (Object) - Optional - Additional configuration
  - **config.params** (Object) - Optional - JSON:API request queries.
  - **config.headers** (Object) - Optional - Additional headers to send with the request
  - **config.axiosOptions** (Object) - Optional - Additional options for the axios instance

### Request Example
```javascript
api.create('posts', {
  content: 'Hello World',
  targetUser: {
    data: {
      id: '42603',
      type: 'users'
    }
  },
  user: {
    data: {
      id: '42603',
      type: 'users'
    }
  }
})

api.create('posts', [
  { content: 'Hello World' },
  { content: 'Another post' }
])
```

### Response
#### Success Response
Returns a Promise that resolves with the JSON-parsed response, which can be an Object or an Array of Objects.
```

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

### Create Multiple Resources with Kitsu API

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

This snippet demonstrates how to create multiple resources in a single request. This functionality requires the API to support the Bulk Extension. Pass an array of resource objects as the second argument.

```javascript
api.create('posts', [
  { content: 'Hello World' },
  { content: 'Another post' }
])
```

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

### Project File Structure

Source: https://github.com/wopian/kitsu/blob/master/specification/README.md

Displays the directory structure for the JSON:API test cases project. Specifies the location for JSON:API structured data and kitsu-consumed data.

```plaintext
. 
|-- caseName 
|   |-- index.js 
|   |-- jsonapi.js 
|   `-- kitsu.js 
`-- index.js
```

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

### New Serialization Syntax

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu-core/MIGRATING.md

Demonstrates the new syntax for the `serialise` function, passing options as arguments for camel casing and pluralization.

```javascript
import { serialise, camel } from 'kitsu-core'
import plural from 'pluralize'

serialise(model, obj, 'PATCH', {
  camelCaseTypes: camel,
  pluralTypes: plural
})
```

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

### Test Changes

Source: https://github.com/wopian/kitsu/blob/master/CONTRIBUTING.md

Run the project tests to ensure your changes do not introduce regressions. Use either Yarn or npm for running tests.

```bash
yarn test
# or
npm test
```

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

### Legacy Serialization Syntax

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu-core/MIGRATING.md

Demonstrates the legacy syntax for the `serialise` function, including options for camel casing and pluralization.

```javascript
import { serialise, camel, kebab } from 'kitsu-core'
import plural from 'pluralize'

serialise.apply({ camel, resCase: kebab, plural }, [ model, obj, 'PATCH' ])
```

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

### Initialize Kitsu API Client with Hoisted Data

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Enable `hoistData` to receive flatter responses without nested 'data' properties. This simplifies data access.

```javascript
const api = new Kitsu({ hoistData: true })
const { data } = await api.get('library-entries')
// instead of: { data: { id: '1', type: 'people', coworkers: data: [ { id: '2', type: 'people' } ] } }
// you get: { id: '1', type: 'people', coworkers: [ { id: '2', type: 'people' } ] }
```

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

### Access All Headers

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Retrieve all currently set headers from the Kitsu API client instance.

```javascript
api.headers
```

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

### Import Kitsu in JavaScript

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Import the Kitsu library depending on your module system. Use ES Modules and Babel for modern JavaScript, or CommonJS for older environments and Browserify.

```javascript
import Kitsu from "kitsu"; // ES Modules & Babel
const Kitsu = require("kitsu"); // CommonJS & Browserify
```

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

### Create Single Resource with Kitsu API

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Use this snippet to create a single resource, such as a post on a user's profile feed. Ensure the `targetUser` and `user` objects are correctly formatted with `data`, `id`, and `type`.

```javascript
api.create('posts', {
  content: 'Hello World',
  targetUser: {
    data: {
      id: '42603',
      type: 'users'
    }
  },
  user: {
    data: {
      id: '42603',
      type: 'users'
    }
  }
})
```

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

### Handling errors (Promises)

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Illustrates how to handle errors when making API requests using Promise-based syntax.

```APIDOC
## Error Handling with Promises

### Description
This example demonstrates how to handle errors using the .catch() method for Promise-based API calls.

### Code Example
```javascript
api.get('anime')
  .then(({ data }) => { ... })
  .catch(err => {
    // Array of JSON:API errors: http://jsonapi.org/format/#error-objects
    if (err.errors) err.errors.forEach(error => { ... })
    // Error type (Error, TypeError etc.)
    err.name
    // Error message
    err.message
    // Axios request parameters
    err.config
    // Axios response parameters
    err.response
  })
```
```

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

### Accessing Relationships in Kitsu 2.0.0+

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/MIGRATING.md

Kitsu 2.0.0 changed how relationships are accessed. Use the relationship name directly instead of a nested structure.

```javascript
// In 1.x the waifu relationship erroneously became characters: { type: 'characters' }
// In 2.x the waifu relationship is waifu: { type: 'characters' }
```

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

### Split Model Name with Kebab Case Resource

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu-core/README.md

Splits the model name from the URL and converts the resource URL to kebab-case using the kebab function from kitsu-core.

```javascript
import { kebab, snake } from 'kitsu-core'
splitModel('libraryEntries', { resourceCase: kebab })
// [ 'libraryEntries', 'library-entries' ]
```

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

### request

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Makes a generic request to the API.

```APIDOC
## request(method, type, id, options)

Makes a generic request to the API.

### Parameters

* `method` **[string]** The HTTP method to use (e.g., 'GET', 'POST', 'PATCH', 'DELETE').
* `type` **[string]** The type of resource.
* `id` **[string]?** The ID of the resource (optional).
* `options` **[Object]?** Additional request options.

### Examples

```javascript
// Make a GET request to /users
api.request('GET', 'users');

// Make a POST request to /posts with data
api.request('POST', 'posts', null, {
  data: {
    type: 'posts',
    attributes: { title: 'New Post' }
  }
});

// Make a PATCH request to update a post
api.request('PATCH', 'posts', '123', {
  data: {
    type: 'posts',
    id: '123',
    attributes: { content: 'Updated content' }
  }
});
```
```

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

### New JSON:API Response and Output Structure

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/MIGRATING.md

Demonstrates the updated behavior in Kitsu 9.0.0, where link objects are preserved at the root and relationship data is accessed differently. This output reflects the new structure with the same input JSON:API response data.

```js
data: {
  id: '1',
  type: 'libraryEntries',
  links: {
    self: 'https://kitsu.app/api/edge/library-entries/1'
  },
  ratingTwenty: 10,
  user: {
    links: {
      self: 'https://kitsu.app/api/edge/library-entries/1/relationships/user',
      related: 'https://kitsu.app/api/edge/library-entries/1/user'
    }
    data: {
      id: '2',
      type: 'users',
      links: {
        self: 'https://kitsu.app/api/edge/users/2'
      },
      name: 'Example'
    }
  }
}
```

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

### query

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu-core/README.md

Constructs a URL query string for JSON:API parameters. This function helps in building compliant API request URLs by serializing parameters.

```APIDOC
## query

### Description
Constructs a URL query string for JSON:API parameters.

### Parameters
#### Path Parameters
* `params` (Object) - Optional - Parameters to parse.
* `prefix` (string) - Optional - Prefix for nested parameters - used internally (default `undefined`).
* `traditional` (boolean) - Optional - Use the traditional (default) or modern param serializer. Set to false if your server is running Ruby on Rails or other modern web frameworks (default `true`).

### Response
#### Success Response (200)
* `string` - URL query string.

### Request Example
```javascript
query({
  filter: {
    slug: 'cowboy-bebop',
    title: {
      value: 'foo'
    }
  },
  sort: '-id'
})
// filter%5Bslug%5D=cowboy-bebop&filter%5Btitle%5D%5Bvalue%5D=foo&sort=-id
```
```

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

### Update Multiple Resources (Bulk)

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Update multiple resources simultaneously. This requires the API to support the Bulk Extension.

```javascript
api.update('posts', [
  { id: '1', content: 'Hello World' },
  { id: '2', content: 'Another post' }
])
```

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

### Send Bulk PATCH/POST/DELETE Requests with Kitsu

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

This method supports bulk operations for PATCH, POST, and DELETE requests by passing an array of resource objects in the body. Each object in the array should contain the necessary fields for the operation.

```javascript
api.request({
  method: 'PATCH',
  url: 'anime',
  type: 'anime',
  body: [
    { id: '1', subtype: 'tv' }
    { id: '2', subtype: 'ona' }
  ]
})
```

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

### Fetch Resource

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

This method allows fetching data for a specified resource. You can fetch a single resource by ID, a resource's relationship, or related data. It supports various JSON:API query parameters for filtering, sorting, sparse fieldsets, includes, and pagination.

```APIDOC
## GET /api/{model}

### Description
Fetches data for a specified resource. Supports fetching by ID, relationships, and related data with advanced JSON:API query parameters.

### Method
GET

### Endpoint
`/api/{model}`

### Parameters
#### Path Parameters
- **model** (string) - Required - Resource to fetch data from. Expected formats are [`:resource`], [`:resource/:id`], [`:resource/:id/:relationship`] or [`:resource/:id/relationships/:relationship`]

#### Query Parameters
- **config.params.fields** (Object) - Optional - Return a sparse fieldset with only the included attributes/relationships.
- **config.params.filter** (Object) - Optional - Filter dataset by attribute values.
- **config.params.include** (string) - Optional - Include relationship data.
- **config.params.sort** (string) - Optional - Sort dataset by one or more comma separated attributes (prepend `-` for descending order).
- **config.params.page** (Object) - Optional - JSON:API Pagination.
  - **config.params.page.limit** (number) - Optional - Number of resources to return in request (Offset-based). Max is `20` (or `500` for `libraryEntries`).
  - **config.params.page.offset** (number) - Optional - Number of resources to offset the dataset by (Offset-based).
  - **config.params.page.number** (number) - Optional - Page of resources to return in request (Page-based). Not supported on kitsu.app.
  - **config.params.page.size** (number) - Optional - Number of resources to return in request (Page-based and cursor-based). Not supported on kitsu.app.
  - **config.params.page.before** (string) - Optional - Get the previous page of resources (Cursor-based). Not Supported on kitsu.app.
  - **config.params.page.after** (string) - Optional - Get the next page of resources (Cursor-based). Not Supported on kitsu.app.

#### Request Body
None

### Request Example
```json
{
  "example": "request body"
}
```

### Response
#### Success Response (200)
- **data** (Array) - The fetched resources.
- **meta** (Object) - Metadata about the response.
- **links** (Object) - Links for pagination.

#### Response Example
```json
{
  "data": [
    {
      "type": "anime",
      "id": "1",
      "attributes": {
        "canonicalTitle": "Cowboy Bebop"
      }
    }
  ],
  "meta": {
    "count": 1
  },
  "links": {
    "self": "https://kitsu.io/api/edge/anime?page[limit]=1"
  }
}
```
```

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

### Create Feature Branch

Source: https://github.com/wopian/kitsu/blob/master/CONTRIBUTING.md

Create a new branch for your feature or bug fix to keep changes isolated. Use a descriptive name for your branch.

```bash
git checkout -b your-feature-name
```

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

### Send Raw POST Request with Kitsu

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Use this method to perform a raw POST request. This is typically used for creating or updating resources where the ID might be implicitly handled or provided.

```javascript
api.request({
  method: 'PATCH',
  url: 'anime',
  type: 'anime',
  body: { subtype: 'tv' }
})
```

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

### Arbitrary Request

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu/README.md

Allows sending arbitrary requests to the Kitsu API with custom configurations for method, URL, parameters, and body. This method is flexible but may be redundant in future releases.

```APIDOC
## request

### Description
Send arbitrary requests to the Kitsu API.

### Method
`GET`, `PATCH`, `POST`, `DELETE` (case-insensitive, defaults to `GET`)

### Endpoint
`config.url`

### Parameters
#### Path Parameters
None

#### Query Parameters
* **params** (Object) - Optional - JSON:API request queries. See [#get](#get) for documentation

#### Request Body
* **body** (Object | Array<Object>) - Optional - Data to send in the request
* **method** (string) - Optional - Request method (`GET`, `PATCH`, `POST` or `DELETE`)
* **type** (string) - Required - The resource type
* **url** (string) - Required - The URL path of the resource
* **headers** (Object) - Optional - Additional headers to send with the request
* **axiosOptions** (Object) - Optional - Additional options for the axios instance

### Request Example
```javascript
// Raw GET request
api.request({
  url: 'anime/1/mappings',
  type: 'mappings',
  params: { filter: { externalSite: 'aozora' } }
})

// Raw PATCH request
api.request({
  method: 'PATCH',
  url: 'anime',
  type: 'anime',
  body: { id: '1', subtype: 'tv' }
})

// Raw POST request
api.request({
  method: 'POST',
  url: 'anime',
  type: 'anime',
  body: { subtype: 'tv' }
})

// Raw DELETE request
api.request({
  method: 'DELETE',
  url: 'anime/1',
  type: 'anime',
  body: { id: '1' }
})

// Bulk Extension support (PATCH, POST & DELETE)
api.request({
  method: 'PATCH',
  url: 'anime',
  type: 'anime',
  body: [
    { id: '1', subtype: 'tv' },
    { id: '2', subtype: 'ona' }
  ]
})
```

### Response
#### Success Response (200)
Returns a Promise that resolves to the JSON-parsed response.

#### Response Example
(Response structure depends on the specific request made)
```

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

### Basic Serialisation

Source: https://github.com/wopian/kitsu/blob/master/packages/kitsu-core/README.md

Use this snippet for basic serialization of an object into JSON-API format without any case conversion or pluralization. This is the simplest way to format your data when no special transformations are needed.

```javascript
import { serialise } from 'kitsu-core'

const model = 'anime'
const obj = { id: '1', slug: 'shirobako' }

// { data: { id: '1', type: 'anime', attributes: { slug: 'shirobako' } } }
const output = serialise(model, obj, 'PATCH')
```
Tokens:
Raw