octokit.js
v4.0.2
Die All-Batteries included Github SDK für Browser, Node.js und Deno.
Das octokit -Paket integriert die drei Haupt -Octokit -Bibliotheken
Octokit -API -Clientoctokit.rest -Endpunktmethodenoctokit.request()| Browser | Laden Sie octokit direkt von Esm.sh < script type =" module " >
import { Octokit , App } from "https://esm.sh/octokit" ;
</ script > |
|---|---|
| Deno | Laden Sie octokit direkt von Esm.sh import { Octokit , App } from "https://esm.sh/octokit?dts" ; |
| Knoten | Installieren Sie mit import { Octokit , App } from "octokit" ; |
Wichtig
Wenn wir bedingte Exporte verwenden, müssen Sie Ihre tsconfig.json anpassen, indem "moduleResolution": "node16", "module": "node16" einstellen.
Siehe die Typscript -Dokumente auf Package.json "Exporte".
Sehen Sie sich diese hilfreiche Anleitung zum Übergang zu ESM von @Sindresorhus an
Octokit -API -Client Standalone Minimal Octokit : @octokit/core .
Der Octokit -Client kann verwendet werden, um Anfragen an die REST -API von Github und Abfragen an die Github -GraphQL -API zu senden.
Beispiel : Holen Sie sich den Benutzernamen für den authentifizierten Benutzer.
// Create a personal access token at https://github.com/settings/tokens/new?scopes=repo
const octokit = new Octokit ( { auth : `personal-access-token123` } ) ;
// Compare: https://docs.github.com/en/rest/reference/users#get-the-authenticated-user
const {
data : { login } ,
} = await octokit . rest . users . getAuthenticated ( ) ;
console . log ( "Hello, %s" , login ) ;Die am häufigsten verwendeten Optionen sind
| Name | Typ | Beschreibung |
|---|---|---|
userAgent | String | Das Einstellen eines Benutzeragenten ist für alle Anfragen erforderlich, die an die Github -Plattform -APIs gesendet werden. Der Benutzeragent stellt so etwas auf: const octokit = new Octokit ( {
userAgent : "my-app/v1.2.3" ,
} ) ; |
authStrategy | Function | Standardeinstellungen zu Siehe Authentifizierung unten. |
auth | String oder Object | Setzen Sie sich auf ein persönliches Zugriffstoken ein, es sei denn, Sie haben die Option Siehe Authentifizierung unten. |
baseUrl | String | Wenn Sie mit GitHub Enterprise Server verwendet werden, setzen Sie const octokit = new Octokit ( {
baseUrl : "https://github.acme-inc.com/api/v3" ,
} ) ; |
Erweiterte Optionen
| Name | Typ | Beschreibung |
|---|---|---|
request | Object |
Nur Knoten
Die |
timeZone | String | Legt den const octokit = new Octokit ( {
timeZone : "America/Los_Angeles" ,
} ) ;Der Zeitzonen -Header bestimmt die Zeitzone, die zum Erstellen des Zeitstempels beim Erstellen von Commits verwendet wird. Siehe Dokumentation von Githubs Timezones. |
throttle | Object | Standardmäßig werden Anfragen einmal getrocknet und Warnungen protokolliert, wenn sie auf einen Raten- oder Sekundärrücklaufgrenze eintreten. {
onRateLimit : ( retryAfter , options , octokit ) => {
octokit . log . warn (
`Request quota exhausted for request ${ options . method } ${ options . url } `
) ;
if ( options . request . retryCount === 0 ) {
// only retries once
octokit . log . info ( `Retrying after ${ retryAfter } seconds!` ) ;
return true ;
}
} ,
onSecondaryRateLimit : ( retryAfter , options , octokit ) => {
octokit . log . warn (
`SecondaryRateLimit detected for request ${ options . method } ${ options . url } `
) ;
if ( options . request . retryCount === 0 ) {
// only retries once
octokit . log . info ( `Retrying after ${ retryAfter } seconds!` ) ;
return true ;
}
} ,
} ;Um diese Funktion abzumelden: new Octokit ( { throttle : { enabled : false } } ) ; Das Droseln in einem Cluster wird mit einem Redis -Backend unterstützt. Siehe |
retry | Object | Um diese Funktion abzumelden: new Octokit ( { retry : { enabled : false } } ) ; |
Standardmäßig unterstützt der Octokit -API -Client die Authentifizierung mit einem statischen Token.
Es gibt verschiedene Authentifizierungsmittel, die von GitHub unterstützt werden, die bei Octokit/Authentifizierungsstrategien ausführlich beschrieben werden. Sie können jeden von ihnen als authStrategy -Konstruktoroption festlegen und die Strategieoptionen als Option für auth Constructor übergeben.
Zum Beispiel, um sich als GitHub -App -Installation zu authentifizieren:
import { createAppAuth } from "@octokit/auth-app" ;
const octokit = new Octokit ( {
authStrategy : createAppAuth ,
auth : {
appId : 1 ,
privateKey : "-----BEGIN PRIVATE KEY-----n..." ,
installationId : 123 ,
} ,
} ) ;
// authenticates as app based on request URLs
const {
data : { slug } ,
} = await octokit . rest . apps . getAuthenticated ( ) ;
// creates an installation access token as needed
// assumes that installationId 123 belongs to @octocat, otherwise the request will fail
await octokit . rest . issues . create ( {
owner : "octocat" ,
repo : "hello-world" ,
title : "Hello world from " + slug ,
} ) ; Sie können die App oder OAuthApp -SDKs verwenden, die APIs und interne Verkabelungen bereitstellen, um die meisten Anwendungsfälle abzudecken.
Zum Beispiel um die obige mit App implementieren zu implementieren
const app = new App ( { appId , privateKey } ) ;
const { data : slug } = await app . octokit . rest . apps . getAuthenticated ( ) ;
const octokit = await app . getInstallationOctokit ( 123 ) ;
await octokit . rest . issues . create ( {
owner : "octocat" ,
repo : "hello-world" ,
title : "Hello world from " + slug ,
} ) ;Erfahren Sie mehr darüber, wie Authentifizierungsstrategien funktionieren oder wie Sie Ihre eigenen erstellen.
Standardmäßig nutzt der Octokit -API -Client die Standardvariablen für die Standard -Proxy -Server -Umgebungsvariablen nicht. Um Unterstützung für Proxy -Server hinzuzufügen, müssen Sie einen HTTPS -Client bereitstellen, der diese wie undici.ProxyAgent() unterstützt.
Dies würde beispielsweise einen ProxyAgent verwenden, um Anforderungen über einen Proxy -Server zu stellen:
import { fetch as undiciFetch , ProxyAgent } from 'undici' ;
const myFetch = ( url , options ) => {
return undiciFetch ( url , {
... options ,
dispatcher : new ProxyAgent ( < your_proxy_url > )
} )
}
const octokit = new Octokit ( {
request : {
fetch : myFetch
} ,
} ) ; Wenn Sie ein Modul schreiben, das Octokit verwendet und von anderen Personen verwendet werden soll, sollten Sie sicherstellen, dass Verbraucher einen alternativen Agenten für Ihr Octokit oder als Parameter für bestimmte Anrufe bereitstellen können, wie z. B.:
import { fetch as undiciFetch , ProxyAgent } from 'undici' ;
const myFetch = ( url , options ) => {
return undiciFetch ( url , {
... options ,
dispatcher : new ProxyAgent ( < your_proxy_url > )
} )
}
octokit . rest . repos . get ( {
owner ,
repo ,
request : {
fetch : myFetch
} ,
} ) ; Wenn Sie den folgenden Fehler erhalten:
Fetch ist nicht eingestellt. Bitte übergeben Sie eine Fetch -Implementierung als neues Octokit ({Anfrage: {Fetch}}).
Es bedeutet wahrscheinlich, dass Sie versuchen, Octokit mit einer nicht unterstützten Version von NodeJs auszuführen. Octokit erfordert einen Knoten 18 oder höher, der eine native Fetch -API enthält.
Um dieses Problem zu umgehen, können Sie eine eigene fetch Implementierung (oder eine integrierte Version wie node-fetch ) wie folgt bereitstellen:
import fetch from "node-fetch" ;
const octokit = new Octokit ( {
request : {
fetch : fetch ,
} ,
} ) ; Es gibt zwei Möglichkeiten, die Github -REST -API zu verwenden, die octokit.rest.* Endpoint -Methoden und octokit.request . Beide handeln genauso, die octokit.request octokit.rest.* Methoden werden nur für die Bequemlichkeit hinzugefügt.
Zum Beispiel
await octokit . rest . issues . create ( {
owner : "octocat" ,
repo : "hello-world" ,
title : "Hello, world!" ,
body : "I created this issue using Octokit!" ,
} ) ;Ist dasselbe wie
await octokit . request ( "POST /repos/{owner}/{repo}/issues" , {
owner : "octocat" ,
repo : "hello-world" ,
title : "Hello, world!" ,
body : "I created this issue using Octokit!" ,
} ) ; In beiden Fällen wird eine bestimmte Anfrage durch die octokit -Instanz authentifiziert, wiedergegeben und drosselt, die auch die accept und user-agent Header bei Bedarf verwaltet.
octokit.request kann verwendet werden, um Anfragen an andere Domänen zu senden, indem eine vollständige URL übergeben und Anfragen an Endpunkte gesendet werden, die in Githubs REST -API -Dokumentation nicht (noch) dokumentiert sind.
octokit.rest -Endpunktmethoden Jeder GitHub -REST -API -Endpunkt hat eine zugehörige octokit.rest -Endpunktmethode für eine bessere Code -Lesbarkeit und Entwicklerkomfort. Weitere Informationen finden Sie unter @octokit/plugin-rest-endpoint-methods .
Beispiel: Erstellen Sie ein Problem
await octokit . rest . issues . create ( {
owner : "octocat" ,
repo : "hello-world" ,
title : "Hello, world!" ,
body : "I created this issue using Octokit!" ,
} ) ; Die octokit.rest -Endpunktmethoden werden automatisch aus der OpenAPI -Spezifikation von Github generiert. Wir verfolgen Änderungen der Betriebs -ID und den Parameternamen, um Abschreibungswarnungen zu implementieren und die Häufigkeit von Veränderungen zu verringern.
Unter den Covers ist jede Endpunktmethode nur octokit.request mit Standardeinstellungen, sodass sie dieselben Parameter sowie die api .endpoint() unterstützt.
octokit.request() Sie können die Github -REST -API direkt mit octokit.request aufrufen. Die request -API entspricht der REST -API -Dokumentation von Github 1: 1. Alles, was Sie dort sehen, können Sie mit request anrufen. Weitere Informationen finden Sie unter @octokit/request .
Beispiel: Erstellen Sie ein Problem
Der API -Aufruf octokit.request , der dieser Ausgabe -Erstellungsdokumentation entspricht, sieht Folgendes aus:
// https://docs.github.com/en/rest/reference/issues#create-an-issue
await octokit . request ( "POST /repos/{owner}/{repo}/issues" , {
owner : "octocat" ,
repo : "hello-world" ,
title : "Hello, world!" ,
body : "I created this issue using Octokit!" ,
} ) ;Das erste Argument ist die REST -API -Route, die in Githubs API -Dokumentation aufgeführt ist. Das 2. Argument ist ein Objekt mit allen Parametern, unabhängig davon, ob sie im Pfad, in der Abfrage oder im Körper verwendet werden.
Alle REST -API -Endpunkte, die paginieren, geben die ersten 30 Elemente standardmäßig zurück. Wenn Sie alle Elemente abrufen möchten, können Sie die Pagination -API verwenden. Die Pagination -API erwartet die Rest -API -Route als erstes Argument, aber Sie können auch jeden der octokit.rest.*.list*
Beispiel: Durch alle Probleme in einem Repository iterieren
const iterator = octokit . paginate . iterator ( octokit . rest . issues . listForRepo , {
owner : "octocat" ,
repo : "hello-world" ,
per_page : 100 ,
} ) ;
// iterate through each response
for await ( const { data : issues } of iterator ) {
for ( const issue of issues ) {
console . log ( "Issue #%d: %s" , issue . number , issue . title ) ;
}
}Die Verwendung des asynchronisierten Iterators ist die maßstabendigste Möglichkeit, alle Elemente durchzusetzen. Sie können aber auch alle Elemente in einem einzigen Anruf abrufen
const issues = await octokit . paginate ( octokit . rest . issues . listForRepo , {
owner : "octocat" ,
repo : "hello-world" ,
per_page : 100 ,
} ) ; Medientypformate können auf jeder Anfrage mit mediaType: { format } festgelegt werden.
Beispiel: Rufen Sie den Rohinhalt einer package.json -Datei ab
const { data } = await octokit . rest . repos . getContent ( {
mediaType : {
format : "raw" ,
} ,
owner : "octocat" ,
repo : "hello-world" ,
path : "package.json" ,
} ) ;
console . log ( "package name: %s" , JSON . parse ( data ) . name ) ;Erfahren Sie mehr über Medientypformate.
Eigenständiges Modul: @octokit/request-error
Für Anforderungsfehlerbehandlung importieren Sie RequestError und verwenden Sie die Anweisung try...catch .
import { RequestError } from "octokit" ; try {
// your code here that sends at least one Octokit request
await octokit . request ( "GET /" ) ;
} catch ( error ) {
// Octokit errors are instances of RequestError, so they always have an `error.status` property containing the HTTP response code.
if ( error instanceof RequestError ) {
// handle Octokit error
// error.message; // Oops
// error.status; // 500
// error.request; // { method, url, headers, body }
// error.response; // { url, status, headers, data }
} else {
// handle all other errors
throw error ;
}
} Octokit unterstützt auch die Github -GraphQL -API direkt - Sie können dieselben Abfragen verwenden, die in der Dokumentation angezeigt und im GraphQL Explorer in Ihren Aufrufen mit octokit.graphql verfügbar sind.
Beispiel: Holen Sie sich die Anmeldung des authentifizierten Benutzer
const {
viewer : { login } ,
} = await octokit . graphql ( `{
viewer {
login
}
}` ) ;Variablen können als 2. Argument übergeben werden
const { lastIssues } = await octokit . graphql (
`
query lastIssues($owner: String!, $repo: String!, $num: Int = 3) {
repository(owner: $owner, name: $repo) {
issues(last: $num) {
edges {
node {
title
}
}
}
}
}
` ,
{
owner : "octokit" ,
repo : "graphql.js" ,
} ,
) ; Githubs GraphQL API gibt maximal 100 Elemente zurück. Wenn Sie alle Elemente abrufen möchten, können Sie die Pagination -API verwenden.
Beispiel: Holen Sie sich alle Probleme
const { allIssues } = await octokit . graphql . paginate (
`
query allIssues($owner: String!, $repo: String!, $num: Int = 10, $cursor: String) {
repository(owner: $owner, name: $repo) {
issues(first: $num, after: $cursor) {
edges {
node {
title
}
}
pageInfo {
hasNextPage
endCursor
}
}
}
}
` ,
{
owner : "octokit" ,
repo : "graphql.js" ,
} ,
) ;Erfahren Sie mehr über die Verwendung von Githubs GraphQL -Pagination.
Vorschau können mit der Option {mediaType: previews: [] } aktiviert werden.
Beispiel: Erstellen Sie ein Etikett
await octokit . graphql (
`mutation createLabel($repositoryId:ID!,name:String!,color:String!) {
createLabel(input:{repositoryId:$repositoryId,name:$name}) {
label: {
id
}
}
}` ,
{
repositoryId : 1 ,
name : "important" ,
color : "cc0000" ,
mediaType : {
previews : [ "bane" ] ,
} ,
} ,
) ;Erfahren Sie mehr über Githubs GraphQL -Schema -Vorschau
Der App -Client kombiniert Funktionen für Github -Apps, Webhooks und OAuth
Eigenständiges Modul : @octokit/app
Für Integratoren sind GitHub -Apps ein Mittel zur Authentifizierung und Autorisierung. Eine GitHub -App kann auf einem GitHub -Benutzer- oder Organisationskonto registriert werden. Eine GitHub -App -Registrierung definiert eine Reihe von Berechtigungen und Webhooks -Ereignissen, die sie empfangen möchten, und bietet eine Reihe von Anmeldeinformationen als Gegenleistung. Benutzer können Zugriff auf Repositorys erteilen, indem sie diese installiert.
Einige API -Endpunkte erfordern, dass die GitHub -App mit einem JSON -Web -Token (JWT) als sich selbst authentifiziert wird. Für Anfragen, die eine Installation betreffen, muss ein Installationszugriffs -Token mit den Anmeldeinformationen der App und der Installations -ID erstellt werden.
Der App -Client kümmert sich um all das für Sie.
Beispiel: Entsenden Sie ein Repository -Ereignis in jedem Repository, auf dem die App installiert ist
import { App } from "octokit" ;
const app = new App ( { appId , privateKey } ) ;
for await ( const { octokit , repository } of app . eachRepository . iterator ( ) ) {
// https://docs.github.com/en/rest/reference/repos#create-a-repository-dispatch-event
await octokit . rest . repos . createDispatchEvent ( {
owner : repository . owner . login ,
repo : repository . name ,
event_type : "my_event" ,
client_payload : {
foo : "bar" ,
} ,
} ) ;
console . log ( "Event dispatched for %s" , repository . full_name ) ;
} Beispiel: Holen Sie sich eine octokit -Instanz, die als Installation authentifiziert wurde
const octokit = await app . getInstallationOctokit ( 123 ) ;Erfahren Sie mehr über Apps.
Eigenständiges Modul : @octokit/webhooks
Bei der Installation einer App werden Ereignisse, bei denen die App -Registrierungsanfragen als Anfragen an die in der Registrierung der App festgelegte Webhook -URL gesendet werden.
Webhook -Ereignisanfragen werden mit dem Webhook -Geheimnis unterzeichnet, das auch Teil der Registrierung der App ist. Sie müssen dieses Geheimnis überprüfen, bevor Sie die Nutzlast der Anfrage bearbeiten.
Die app.webhooks.* APIs bieten Methoden zum Empfang, Überprüfen und Umgang mit Webhook -Veranstaltungen.
Beispiel: Erstellen Sie einen Kommentar zu neuen Themen
import { createServer } from "node:http" ;
import { App , createNodeMiddleware } from "octokit" ;
const app = new App ( {
appId ,
privateKey ,
webhooks : { secret } ,
} ) ;
app . webhooks . on ( "issues.opened" , ( { octokit , payload } ) => {
return octokit . rest . issues . createComment ( {
owner : payload . repository . owner . login ,
repo : payload . repository . name ,
issue_number : payload . issue . number ,
body : "Hello, World!" ,
} ) ;
} ) ;
// Your app can now receive webhook events at `/api/github/webhooks`
createServer ( createNodeMiddleware ( app ) ) . listen ( 3000 ) ;Für serverlose Umgebungen können Sie ein Ereignis explizit überprüfen und empfangen
await app . webhooks . verifyAndReceive ( {
id : request . headers [ "x-github-delivery" ] ,
name : request . headers [ "x-github-event" ] ,
signature : request . headers [ "x-hub-signature-256" ] ,
payload : request . body ,
} ) ;Erfahren Sie mehr über Github Webhooks.
Eigenständiges Modul: @octokit/oauth-app
Sowohl OAuth -Apps als auch GitHub -Apps unterstützen die Authentifizierung von Github -Benutzern mit OAuth. Siehe Autorisierung von OAuth -Apps und das Identifizieren und Autorisieren von Benutzern für GitHub -Apps.
Es gibt einige Unterschiede:
App ist für GitHub -Apps. Wenn Sie OAuth-App-spezifische Funktionen benötigen, verwenden Sie stattdessen OAuthApp .
Beispiel: Sehen Sie sich ein Repository an, wenn sich ein Benutzer mithilfe des OAuth Web Flows anmeldet
import { createServer } from "node:http" ;
import { App , createNodeMiddleware } from "octokit" ;
const app = new App ( {
oauth : { clientId , clientSecret } ,
} ) ;
app . oauth . on ( "token.created" , async ( { token , octokit } ) => {
await octokit . rest . activity . setRepoSubscription ( {
owner : "octocat" ,
repo : "hello-world" ,
subscribed : true ,
} ) ;
} ) ;
// Your app can receive the OAuth redirect at /api/github/oauth/callback
// Users can initiate the OAuth web flow by opening /api/github/oauth/login
createServer ( createNodeMiddleware ( app ) ) . listen ( 3000 ) ; Für serverlose Umgebungen können Sie den code explizit aus der OAuth -Web -Flow -Umleitung gegen einen Zugriffstoken austauschen. app.oauth.createToken() gibt ein Authentifizierungsobjekt zurück und emittiert das Ereignis "token.created".
const { token } = await app . oauth . createToken ( {
code : request . query . code ,
} ) ;Beispiel: Erstellen Sie ein Token mit dem Gerätefluss.
const { token } = await app . oauth . createToken ( {
async onVerification ( verification ) {
await sendMessageToUser (
request . body . phoneNumber ,
`Your code is ${ verification . user_code } . Enter it at ${ verification . verification_uri } ` ,
) ;
} ,
} ) ;Beispiel: Erstellen Sie einen OAuth -App -Server mit Standardzielen
import { createServer } from "node:http" ;
import { OAuthApp , createNodeMiddleware } from "octokit" ;
const app = new OAuthApp ( {
clientId ,
clientSecret ,
defaultScopes : [ "repo" , "gist" ] ,
} ) ;
app . oauth . on ( "token" , async ( { token , octokit } ) => {
await octokit . rest . gists . create ( {
description : "I created this gist using Octokit!" ,
public : true ,
files : {
"example.js" : `/* some code here */` ,
} ,
} ) ;
} ) ;
// Your app can receive the OAuth redirect at /api/github/oauth/callback
// Users can initiate the OAuth web flow by opening /api/oauth/login
createServer ( createNodeMiddleware ( app ) ) . listen ( 3000 ) ;Nach der Registrierung Ihrer GitHub -App müssen Sie einen Server erstellen und bereitstellen, mit dem die Webhook -Ereignisanforderungen von GitHub abgerufen werden und Ausführungen aus dem OAuth -Benutzer -Web -Flow akzeptiert werden können.
Der einfachste Weg, um einen solchen Server zu erstellen, besteht darin createNodeMiddleware() zu verwenden. Es funktioniert mit beiden, sowohl die http.createServer() -Methode von Node als auch eine Express Middleware.
Die Standardrouten, die die Middleware aussetzt
| Route | Routenbeschreibung |
|---|---|
POST /api/github/webhooks | Endpunkt zum Empfangen von Github Webhook -Ereignisanfragen |
GET /api/github/oauth/login | Leitet zu Githubs Autorisierungsendpunkt weiter. Akzeptiert optional ?state und ?scopes . ?scopes ist eine von Kommas getrennte Liste unterstützter OAuth-Scope-Namen |
GET /api/github/oauth/callback | Der Umleitungsendpunkt des Kunden. Hier wird das token -Ereignis ausgelöst |
POST /api/github/oauth/token | Tauschen Sie einen Autorisierungscode für ein OAuth -Zugangs -Token aus. Wenn er erfolgreich ist, wird das token -Ereignis ausgelöst. |
GET /api/github/oauth/token | Überprüfen Sie, ob Token gültig ist. Muss sich mit Token im Authorization authentifizieren. Verwendet Githubs POST /applications/{client_id}/token -Endpunkt |
PATCH /api/github/oauth/token | Setzt ein Token zurück (ungültig, gibt das neue Token zurück). Muss sich mit Token im Authorization authentifizieren. Verwendet Githubs PATCH /applications/{client_id}/token -Endpunkt. |
PATCH /api/github/oauth/refresh-token | Aktualisieren Sie ein ablaufendes Token (ungültig, gibt das neue Zugangs -Token und Aktualisierungstoken zurück). Muss sich mit Token im Authorization authentifizieren. Verwendet Githubs POST https://github.com/login/oauth/access_token oAuth Endpoint. |
POST /api/github/oauth/token/scoped | Erstellt ein Scoped -Token (macht die aktuelle nicht ungültig). Muss sich mit Token im Authorization authentifizieren. Verwendet GitHubs POST /applications/{client_id}/token/scoped Endpoint. |
DELETE /api/github/oauth/token | Ungültiges aktuelles Token, im Grunde das Äquivalent eines Abmeldes. Muss sich mit Token im Authorization authentifizieren. |
DELETE /api/github/oauth/grant | Widerrufen den Zuschuss des Benutzers, im Grunde genommen das Äquivalent einer Deinstallation. Muss sich mit Token im Authorization authentifizieren. |
Beispiel: Erstellen Sie einen Github -Server mit Express
import express from "express" ;
import { App , createNodeMiddleware } from "octokit" ;
const expressApp = express ( ) ;
const octokitApp = new App ( {
appId ,
privateKey ,
webhooks : { secret } ,
oauth : { clientId , clientSecret } ,
} ) ;
expressApp . use ( createNodeMiddleware ( app ) ) ;
expressApp . listen ( 3000 , ( ) => {
console . log ( `Example app listening at http://localhost:3000` ) ;
} ) ; Sie dürfen das Client -Geheimnis Ihrer App dem Benutzer nicht aussetzen, sodass Sie den App -Konstruktor nicht verwenden können. Stattdessen müssen Sie einen Server mit dem App -Konstruktor erstellen, der die Routen /api/github/oauth/* enthüllt, über die Sie sicher eine OAuth -Anmeldung für Apps implementieren können, die in einem Webbrowser ausgeführt werden.
Wenn Sie (User) Authorization callback URL auf Ihre eigene App festlegen, müssen Sie die Parameter von ?code=...&state=... Abfrage -Parameter vorlesen, vergleichen Sie den state -Parameter mit dem von app.oauthLoginUrl() vorgegebenen Wert, um vor Fälschungsangriffen zu schützen, und tauschen Sie dann den code gegen einen OATH -Autorisierungs -Token aus.
Wenn Sie wie oben beschrieben einen App -Server ausführen, finden Sie die Standardroute, um dies zu tun, POST /api/github/oauth/token .
Sobald Sie das Token erfolgreich abgerufen haben, wird auch empfohlen, den ?code=...&state=... Abfrageparameter aus der URL des Browsers zu entfernen
const code = new URL ( location . href ) . searchParams . get ( "code" ) ;
if ( code ) {
// remove ?code=... from URL
const path =
location . pathname +
location . search . replace ( / b(code|state)=w+ / g , "" ) . replace ( / [?&]+$ / , "" ) ;
history . replaceState ( { } , "" , path ) ;
// exchange the code for a token with your backend.
// If you use https://github.com/octokit/oauth-app.js
// the exchange would look something like this
const response = await fetch ( "/api/github/oauth/token" , {
method : "POST" ,
headers : {
"content-type" : "application/json" ,
} ,
body : JSON . stringify ( { code } ) ,
} ) ;
const { token } = await response . json ( ) ;
// `token` is the OAuth Access Token that can be use
const { Octokit } = await import ( "https://esm.sh/@octokit/core" ) ;
const octokit = new Octokit ( { auth : token } ) ;
const {
data : { login } ,
} = await octokit . request ( "GET /user" ) ;
alert ( "Hi there, " + login ) ;
} ? Wir arbeiten an @octokit/auth-oauth-user-client um eine einfache API für alle Methoden im Zusammenhang mit OAuth-Benutzer-Token bereitzustellen.
Der Plan besteht darin, eine neue GET /api/github/oauth/octokit.js -Route zur Node Middleware hinzuzufügen, die eine JavaScript -Datei zurückgibt, die in eine HTML -Datei importiert werden kann. Es wird eine vorauthentierte octokit Instanz zur Verfügung stellen.
eigenständiges Modul: @octokit/action
? Ein vollwertiger Action -Client steht anhängig. Sie können vorerst @actions/github verwenden
MIT
