request.js

> Send parameterized requests to GitHub’s APIs with sensible defaults in browsers and Node


@octokit-next/request is a request library for modern JavaScript runtime environments (e.g. Browsers, Node, or Deno) that makes it easier
to interact with GitHub’s REST API and
GitHub’s GraphQL API.

It uses @octokit/endpoint to parse
the passed options and sends the request using fetch
(node-fetch when the runtime has no native fetch API).

Features

🤩 1:1 mapping of REST API endpoint documentation, e.g. Add labels to an issue becomes

``js
request("POST /repos/{owner}/{repo}/issues/{number}/labels", {
owner: "octokit",
repo: "request.js",
number: 1,
labels: ["🐛 bug"],
});
`

👶 Small bundle size (\<4kb minified + gzipped)

😎 Authenticate with any of GitHubs Authentication Strategies.

👍 Sensible defaults

- baseUrl: https://api.github.com
- headers.accept: application/vnd.github.v3+json
- headers.agent: octokit-request.js/ , e.g. octokit-request.js/1.2.3 Node.js/10.15.0 (macOS Mojave; x64)

👌 Simple to test: mock requests by passing a custom fetch method.

🧐 Simple to debug: Sets error.request to request options causing the error (with redacted credentials).

Usage

$3

`js
// Following GitHub docs formatting:
// https://docs.github.com/en/rest/repos/repos#list-organization-repositories
const result = await request("GET /orgs/{org}/repos", {
headers: {
authorization: "token 0000000000000000000000000000000000000001",
},
org: "octokit",
type: "private",
});

console.log(${result.data.length} repos found.);
`

$3

For GraphQL request we recommend using @octokit/graphql. But in the end a GraphQL query is just a POST /graphql request:

`js
const result = await request("POST /graphql", {
headers: {
authorization: "token 0000000000000000000000000000000000000001",
},
query: query ($login: String!) {
organization(login: $login) {
repositories(privacy: PRIVATE) {
totalCount
}
}
},
variables: {
login: "octokit",
},
});
`

$3

Alternatively, pass in a method and a url

`js
const result = await request({
method: "GET",
url: "/orgs/{org}/repos",
headers: {
authorization: "token 0000000000000000000000000000000000000001",
},
org: "octokit",
type: "private",
});
`

Authentication

The simplest way to authenticate a request is to set the Authorization header directly, e.g. to a personal access token.

`js
const requestWithAuth = request.defaults({
headers: {
authorization: "token 0000000000000000000000000000000000000001",
},
});
const result = await requestWithAuth("GET /user");
`

For more complex authentication strategies such as GitHub Apps, we recommend an authentication strategy plugin.

`js
// expects APP_ID and PRIVATE_KEY to be set.
import { createAppAuth } from "@octokit/auth-app";
const auth = createAppAuth({
appId: APP_ID,
privateKey: PRIVATE_KEY,
installationId: 123,
});
const requestWithAuth = request.defaults({
request: {
hook: auth.hook,
},
});

const { data: app } = await requestWithAuth("GET /app");
const { data: app } = await requestWithAuth(
"POST /repos/{owner}/{repo}/issues",
{
owner: "octocat",
repo: "hello-world",
title: "Hello from the engine room",
}
);
`

request()

request(route, options) or request(options).

Options

All other options except options.request.* will be passed depending on the method and url options.

1. If the option key is a placeholder in the url, it will be used as replacement. For example, if the passed options are {url: '/orgs/{org}/repos', org: 'foo'} the returned options.url is https://api.github.com/orgs/foo/repos
2. If the method is GET or HEAD, the option is passed as query parameter
3. Otherwise the parameter is passed in the request body as JSON key.

Result

request returns a promise. If the request was successful, the promise resolves with an object containing 4 keys:

If an error occurs, the promise is rejected with an error object containing 3 keys to help with debugging:

- error.status The http response status code
- error.request The request options such as method, url and data
- error.response The http response object with url, headers, and data

If the error is due to an AbortSignal being used, the resulting AbortError is bubbled up to the caller.

request.defaults()

Override or set default options. Example:

`js
import { request } from "@octokit-next/request";
const myrequest = request.defaults({
baseUrl: "https://github-enterprise.acme-inc.com/api/v3",
headers: {
"user-agent": "myApp/1.2.3",
authorization: token 0000000000000000000000000000000000000001,
},
org: "my-project",
per_page: 100,
});

myrequest(GET /orgs/{org}/repos);
`

You can call .defaults() again on the returned method, the defaults will cascade.

`js
const myProjectRequest = request.defaults({
baseUrl: "https://github-enterprise.acme-inc.com/api/v3",
headers: {
"user-agent": "myApp/1.2.3",
},
org: "my-project",
});
const myProjectRequestWithAuth = myProjectRequest.defaults({
headers: {
authorization: token 0000000000000000000000000000000000000001,
},
});
`

myProjectRequest now defaults the baseUrl, headers['user-agent'],
org and headers['authorization'] on top of headers['accept'] that is set
by the global default.

request.endpoint

See https://github.com/octokit/endpoint.js. Example

`js
const options = request.endpoint("GET /orgs/{org}/repos", {
org: "my-project",
type: "private",
});

// {
// method: 'GET',
// url: 'https://api.github.com/orgs/my-project/repos?type=private',
// headers: {
// accept: 'application/vnd.github.v3+json',
// authorization: 'token 0000000000000000000000000000000000000001',
// 'user-agent': 'octokit/endpoint.js v1.2.3'
// }
// }
`

All of the @octokit/endpoint API can be used:

- octokitRequest.endpoint()
- octokitRequest.endpoint.defaults()
- octokitRequest.endpoint.merge()
- octokitRequest.endpoint.parse()

Special cases

$3

Some endpoints such as Render a Markdown document in raw mode don’t have parameters that are sent as request body keys, instead the request body needs to be set directly. In these cases, set the data parameter.

`js
const response = await request("POST /markdown/raw", {
data: "Hello world github/linguist#1 cool, and #1!",
headers: {
accept: "text/html;charset=utf-8",
"content-type": "text/plain",
},
});

// Request is sent as
//
// {
// method: 'post',
// url: 'https://api.github.com/markdown/raw',
// headers: {
// accept: 'text/html;charset=utf-8',
// 'content-type': 'text/plain',
// 'user-agent': userAgent
// },
// body: 'Hello world github/linguist#1 cool, and #1!'
// }
//
// not as
//
// {
// ...
// body: '{"data": "Hello world github/linguist#1 cool, and #1!"}'
// }
`

$3

There are API endpoints that accept both query parameters as well as a body. In that case you need to add the query parameters as templates to options.url, as defined in the RFC 6570 URI Template specification.

Example

`js
request(
"POST https://uploads.github.com/repos/octocat/Hello-World/releases/1/assets{?name,label}",
{
name: "example.zip",
label: "short description",
headers: {
"content-type": "text/plain",
"content-length": 14,
authorization: token 0000000000000000000000000000000000000001,
},
data: "Hello, world!",
}
);
``

LICENSE

MIT