auth-oauth-app.js

> GitHub OAuth App authentication for JavaScript


@octokit/auth-oauth-app is implementing one of GitHub’s authentication strategies.

It implements authentication using an OAuth app’s client ID and secret as well as creating user access tokens GitHub's OAuth web application flow and device flow.

- Standalone Usage
- Authenticate as app
- Authenticate user using OAuth Web Flow
- Authenticate user using OAuth Device flow
- Usage with Octokit
- createOAuthAppAuth(options) or new Octokit({ auth })
- auth(options) or octokit.auth(options)
- Client ID/Client Secret Basic authentication
- OAuth web flow
- OAuth device flow
- Authentication object
- OAuth App authentication
- OAuth user access token authentication
- GitHub APP user authentication token with expiring disabled
- GitHub APP user authentication token with expiring enabled
- auth.hook(request, route, parameters) or auth.hook(request, options)
- Types
- Implementation details
- License

Standalone Usage

> [!IMPORTANT]
> As we use conditional exports, you will need to adapt your tsconfig.json by setting "moduleResolution": "node16", "module": "node16".
>
> See the TypeScript docs on package.json "exports".

> See this helpful guide on transitioning to ESM from @sindresorhus

$3

`js
const auth = createOAuthAppAuth({
clientType: "oauth-app",
clientId: "1234567890abcdef1234",
clientSecret: "1234567890abcdef1234567890abcdef12345678",
});

const appAuthentication = await auth({
type: "oauth-app",
});
`

resolves with

`json
{
"type": "oauth-app",
"clientId": "1234567890abcdef1234",
"clientSecret": "1234567890abcdef1234567890abcdef12345678",
"headers": {
"authorization": "basic MTIzNDU2Nzg5MGFiY2RlZjEyMzQ6MTIzNDU2Nzg5MGFiY2RlZjEyMzQ1Njc4OTBhYmNkZWYxMjM0NTY3OA=="
}
}
`

$3

Exchange code from GitHub's OAuth web flow, see https://docs.github.com/en/developers/apps/authorizing-oauth-apps#2-users-are-redirected-back-to-your-site-by-github

`js
const auth = createOAuthAppAuth({
clientType: "oauth-app",
clientId: "1234567890abcdef1234",
clientSecret: "1234567890abcdef1234567890abcdef12345678",
});

const userAuthenticationFromWebFlow = await auth({
type: "oauth-user",
code: "random123",
state: "mystate123",
});
`

resolves with

`json
{
"clientType": "oauth-app",
"clientId": "1234567890abcdef1234",
"clientSecret": "1234567890abcdef1234567890abcdef12345678",
"type": "token",
"tokenType": "oauth",
"token": "useraccesstoken123",
"scopes": []
}
`

$3

Pass an asynchronous onVerification() method which will be called with the response from step 1 of the device flow. In that function you have to prompt the user to enter the user code at the provided verification URL.

auth() will not resolve until the user entered the code and granted access to the app.

See https://docs.github.com/en/developers/apps/authorizing-oauth-apps#2-users-are-redirected-back-to-your-site-by-github

`js
const auth = createOAuthAppAuth({
clientType: "oauth-app",
clientId: "1234567890abcdef1234",
clientSecret: "1234567890abcdef1234567890abcdef12345678",
});

const userAuthenticationFromDeviceFlow = await auth({
async onVerification(verification) {
// verification example
// {
// device_code: "3584d83530557fdd1f46af8289938c8ef79f9dc5",
// user_code: "WDJB-MJHT",
// verification_uri: "https://github.com/login/device",
// expires_in: 900,
// interval: 5,
// };

console.log("Open %s", verification.verification_uri);
console.log("Enter code: %s", verification.user_code);
},
});
`

resolves with

`json
{
"clientType": "oauth-app",
"clientId": "1234567890abcdef1234",
"clientSecret": "1234567890abcdef1234567890abcdef12345678",
"type": "token",
"tokenType": "oauth",
"token": "useraccesstoken123",
"scopes": []
}
`

Usage with Octokit

`js
const appOctokit = new Octokit({
authStrategy: createOAuthAppAuth,
auth: {
clientId: "1234567890abcdef1234",
clientSecret: "1234567890abcdef1234567890abcdef12345678",
},
});

// Send requests as app
await appOctokit.request("POST /application/{client_id}/token", {
client_id: "1234567890abcdef1234",
access_token: "existingtoken123",
});
console.log("token is valid");

// create a new octokit instance that is authenticated as the user
const userOctokit = await appOctokit.auth({
type: "oauth-user",
code: "code123",
factory: (options) => {
return new Octokit({
authStrategy: createOAuthUserAuth,
auth: options,
});
},
});

// Exchanges the code for the user access token authentication on first request
// and caches the authentication for successive requests
const {
data: { login },
} = await userOctokit.request("GET /user");
console.log("Hello, %s!", login);
`

createOAuthAppAuth(options) or new Octokit({ auth })

The createOAuthAppAuth method accepts a single options object as argument. The same set of options can be passed as auth to the Octokit constructor when setting authStrategy: createOAuthAppAuth

auth(options) or octokit.auth(options)

The async auth() method returned by createOAuthAppAuth(options) accepts different options depending on your use case

$3

All REST API routes starting with /applications/{client_id} need to be authenticated using the OAuth/GitHub App's Client ID and a client secret.

$3

Exchange code for a user access token. See Web application flow.

$3

Create a user access token without an http redirect. See Device flow.

The device flow does not require a client secret, but it is required as strategy option for @octokit/auth-oauth-app, even for the device flow. If you want to implement the device flow without requiring a client secret, use @octokit/auth-oauth-device.

Authentication object

The async auth(options) method to one of four possible authentication objects

1. OAuth App authentication for auth({ type: "oauth-app" })
2. OAuth user access token authentication for auth({ type: "oauth-app" }) and App is an OAuth App (OAuth user access token)
3. GitHub APP user authentication token with expiring disabled for auth({ type: "oauth-app" }) and App is a GitHub App (user-to-server token)
4. GitHub APP user authentication token with expiring enabled for auth({ type: "oauth-app" }) and App is a GitHub App (user-to-server token)

$3

$3

$3

$3

auth.hook(request, route, parameters) or auth.hook(request, options)

auth.hook() hooks directly into the request life cycle. It amends the request to authenticate correctly using clientId and clientSecret as basic auth for the API endpoints that support it. It throws an error in other cases.

The request option is an instance of @octokit/request. The route/options parameters are the same as for the request() method.

auth.hook() can be called directly to send an authenticated request

`js
const { data: user } = await auth.hook(
request,
"POST /applications/{client_id}/token",
{
client_id: "1234567890abcdef1234",
access_token: "token123",
},
);
`

Or it can be passed as option to request().

`js
const requestWithAuth = request.defaults({
request: {
hook: auth.hook,
},
});

const { data: user } = await requestWithAuth(
"POST /applications/{client_id}/token",
{
client_id: "1234567890abcdef1234",
access_token: "token123",
},
);
`

Types

`ts
import {
// strategy options
OAuthAppStrategyOptions,
GitHubAppStrategyOptions,
// auth options
AppAuthOptions,
WebFlowAuthOptions,
OAuthAppDeviceFlowAuthOptions,
GitHubAppDeviceFlowAuthOptions,
// auth interfaces
OAuthAppAuthInterface,
GitHubAuthInterface,
// authentication object
AppAuthentication,
OAuthAppUserAuthentication,
GitHubAppUserAuthentication,
GitHubAppUserAuthenticationWithExpiration,
} from "@octokit/auth-oauth-app";
`

Implementation details

Client ID and secret can be passed as Basic auth in the Authorization header in order to get a higher rate limit compared to unauthenticated requests. This is meant for the use on servers only: never expose an OAuth client secret on a client such as a web application!

auth.hook will set the correct authentication header automatically based on the request URL. For all OAuth Application endpoints, the Authorization header is set to basic auth. For all other endpoints and token is retrieved and used in the Authorization header. The token is cached and used for succeeding requests.

To reset the cached access token, you can do this

`js
const { token } = await auth({ type: "oauth-user" });
await auth.hook(request, "POST /applications/{client_id}/token", {
client_id: "1234567890abcdef1234",
access_token: token,
});
`

The internally cached token will be replaced and used for succeeding requests. See also "the REST API documentation".

See also: octokit/oauth-authorization-url.js.

License

MIT

`

``