GitHub-REST-API-Delphi-Client mit sgcOpenAPI

GitHub pflegt die größte öffentlich verfügbare OpenAPI-Beschreibung — über 1.000 Endpunkte für Repositories, Issues, Pull Requests, Actions, Checks, Packages und das GraphQL-Gateway. Füttere sie in sgcOpenAPI und erzeuge eine typisierte Delphi-Unit, mit der deine Anwendung jeden GitHub-Workflow ansteuern kann, den die REST-API freigibt.

GitHub + sgcOpenAPI

GitHub liefert eine vollständig gepflegte OpenAPI-3-Beschreibung unter der MIT-Lizenz aus. sgcOpenAPI parst sie und erzeugt eine einzige Pascal-Unit, die von Delphi 7 bis RAD Studio 13 kompiliert.

Quell-Spezifikation

github/rest-api-description

Auth

Personal Access Token, GitHub-App-JWT, OAuth

Generierte Unit

sgcOpenAPI_GitHub

Plattformen

Windows, macOS, Linux, iOS, Android

Den Client erzeugen

GitHub veröffentlicht zwei Varianten der Spezifikation — api.github.com.json für den öffentlichen Hosted-Dienst und ghes-3.x.json für GitHub Enterprise Server. Zeige den Parser auf die, die du ansprichst.

uses
  sgcOpenAPI_Parser, sgcOpenAPI_Generator;

var
  vParser: TsgcOpenAPIParser;
  vGen: TsgcOpenAPIGenerator;
begin
  vParser := TsgcOpenAPIParser.Create(nil);
  try
    vParser.LoadFromFile('C:\specs\github\api.github.com.json');
    Memo1.Lines.Add(Format('GitHub spec: %d paths, %d schemas',
      [vParser.Paths.Count, vParser.Schemas.Count]));

    vGen := TsgcOpenAPIGenerator.Create(nil);
    try
      vGen.Parser := vParser;
      vGen.OutputUnit := 'sgcOpenAPI_GitHub';
      vGen.OutputFolder := 'C:\Generated\GitHub';
      vGen.GroupBy := gbTag;        // one class per tag
      vGen.Generate;
    finally
      vGen.Free;
    end;
  finally
    vParser.Free;
  end;
end;

Der Generator emittiert eine Klasse pro GitHub-Tag — TsgcGitHub_Repos, TsgcGitHub_Issues, TsgcGitHub_Pulls, TsgcGitHub_Actions, TsgcGitHub_Checks, TsgcGitHub_Packages, TsgcGitHub_OrgsAdmin usw. — alle besessen von einer übergeordneten TsgcGitHub-Fassade.

Repositories auflisten

Authentifiziere dich mit einem Personal Access Token und enumeriere die Repositories des aktuellen Benutzers. Die Paginierung übernimmt der generierte Enumerable-Wrapper — einfach mit for...in über das Ergebnis iterieren, und der Client lädt weitere Seiten bei Bedarf nach.

uses sgcOpenAPI_GitHub;

var
  vGH: TsgcGitHub;
  vRepo: TsgcGitHubRepository;
begin
  vGH := TsgcGitHub.Create(nil);
  try
    vGH.Token := 'ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxx';
    vGH.UserAgent := 'sgcDelphi/1.0';

    for vRepo in vGH.Repos.ListForAuthenticatedUser(
      Visibility := 'private', PerPage := 100) do
    begin
      Memo1.Lines.Add(Format('%s — %s',
        [vRepo.FullName, vRepo.Description]));
    end;
  finally
    vGH.Free;
  end;
end;

Ein Issue erstellen und einen Pull Request einsehen

Zwei kurze Aufrufe — einer mutierend, einer lesend. Beide Routen liefern dieselben streng typisierten Objekte zurück, die die Spezifikation beschreibt.

// Create an issue in repo "octocat/Hello-World"
var
  vIssue: TsgcGitHubIssue;
begin
  vIssue := vGH.Issues.Create(
    Owner := 'octocat',
    Repo  := 'Hello-World',
    Title := 'Memory leak in HTTP/2 reader',
    Body  := 'Repro steps: ...',
    Labels := ['bug', 'http2']);
  ShowMessage('Filed issue #' + IntToStr(vIssue.Number));

  // List open PRs and inspect the head ref
  for vPR in vGH.Pulls.List(
    Owner := 'octocat', Repo := 'Hello-World',
    State := 'open', Sort := 'updated') do
  begin
    Memo1.Lines.Add(Format('PR #%d %s — %s',
      [vPR.Number, vPR.Title, vPR.Head.Ref]));
  end;
end;

Was die generierte Unit dir liefert

Jeder Tag in der offiziellen OpenAPI-Beschreibung wird zu einer typisierten Klasse. Jeder dokumentierte Parameter wird zu einem typisierten Argument.

Repositories & Inhalte

Repos, Git, Contents, Branches, Tags, Releases, Forks. Lies, schreibe und lösche Dateien. Erstelle Branches, verwalte Schutzregeln, entwirf und veröffentliche Releases.

Issues & Pull Requests

Issues, Pulls, Reviews, Comments, Reactions, Labels, Milestones, Assignees. Die komplette Kollaborationsoberfläche.

Actions & Checks

Actions, WorkflowRuns, WorkflowJobs, Artifacts, Secrets, Variables, Checks, CheckRuns, CheckSuites — baue Dashboards oder fahre Automatisierung mit GitHub-Actions-Daten.

Packages & Container-Registry

Packages, PackageVersions — verwalte npm-, NuGet-, Maven-, RubyGems- und Container-Pakete aus Delphi.

Organisationen & Teams

Orgs, Teams, Members, Memberships, OrgsAdmin für reine Owner-Operationen wie SCIM-Provisionierung.

GitHub Apps

Apps, Installations, AppManifests — installiere GitHub Apps programmatisch und erzeuge kurzlebige Installations-Tokens.

Drei Dinge, auf die du achten solltest

Rate Limits und Conditional Requests

GitHub erzwingt ein stündliches Rate Limit (5.000 Requests/Stunde mit Token, 60 unauthentifiziert). Der generierte Client speichert den letzten ETag jeder GET-Antwort — verwende ihn beim nächsten Aufruf über IfNoneMatch, um eine kostenlose 304-Antwort zu erhalten.

GitHub Apps brauchen kurzlebige Tokens

Bei GitHub-App-Installationen tauschst du ein JWT (signiert mit dem privaten Schlüssel deiner App) gegen einen 1-Stunden-Installations-Token. Verwende die Methode Apps.CreateInstallationAccessToken und erneuere den Token, bevor er abläuft.

Polymorphe Timeline-Events

Der Endpunkt Issues.ListEventsForTimeline liefert eine diskriminierte Union aus Dutzenden Event-Typen zurück. Die generierte Unit liefert eine Basisklasse und einen Nachfahren pro Variante — cast je nach Eigenschaft Event herunter.

Aus dem Blog

OpenAPI-Delphi-Parser

Wie der zugrunde liegende Parser reale OpenAPI-3.x-Spezifikationen handhabt.

Beitrag lesen →

OpenAPI-Client + Parser

Der Begleitbeitrag, der sowohl den Client-Wrapper als auch die Parser-Internals einführt.

Beitrag lesen →

sgcOpenAPI 2026.6

Aktuelle Release Notes — neue Generator-Optionen und Parser-Fixes.

Beitrag lesen →

Baue deine GitHub-Automatisierung noch heute

sgcOpenAPI liefert Parser, Codegenerator, OpenAPI-Server sowie die Amazon-, Google-, Microsoft- und Azure-SDK-Bundles mit — ein Produkt, drei Stufen.