Client Delphi pour l'API REST GitHub via sgcOpenAPI

GitHub maintient la plus grande description OpenAPI publiquement disponible — plus de 1 000 endpoints à travers dépôts, issues, pull requests, actions, checks, packages et la passerelle GraphQL. Injectez-la dans sgcOpenAPI et émettez une unité Delphi typée que votre application peut utiliser pour piloter tout workflow GitHub que l'API REST expose.

GitHub + sgcOpenAPI

GitHub livre une description OpenAPI 3 entièrement maintenue sous licence MIT. sgcOpenAPI la parse et émet une seule unité Pascal qui compile de Delphi 7 à RAD Studio 13.

Auth

Personal access token, JWT GitHub App, OAuth

Unité générée

sgcOpenAPI_GitHub

Plateformes

Windows, macOS, Linux, iOS, Android

Générer le client

GitHub publie deux saveurs de la spec — api.github.com.json pour le service public hébergé et ghes-3.x.json pour GitHub Enterprise Server. Pointez le parseur sur celle que vous ciblez.

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;

Le générateur émet une classe par tag GitHub — TsgcGitHub_Repos, TsgcGitHub_Issues, TsgcGitHub_Pulls, TsgcGitHub_Actions, TsgcGitHub_Checks, TsgcGitHub_Packages, TsgcGitHub_OrgsAdmin et ainsi de suite — toutes possédées par une façade top-level TsgcGitHub.

Lister les dépôts

Authentifiez-vous avec un personal access token, puis énumérez les dépôts de l'utilisateur courant. La pagination est gérée par le wrapper enumerable généré — faites simplement for...in sur le résultat et le client récupère des pages supplémentaires à la demande.

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;

Créer une issue et revoir une pull request

Deux appels courts — un mutant, un en lecture. Les deux routes retournent les mêmes objets fortement typés que la spec décrit.

// 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;

Ce que l'unité générée vous donne

Chaque tag dans la description OpenAPI officielle devient une classe typée. Chaque paramètre documenté devient un argument typé.

Dépôts et contenu

Repos, Git, Contents, Branches, Tags, Releases, Forks. Lisez, écrivez et supprimez des fichiers. Créez des branches, gérez les règles de protection, brouillonnez et publiez des releases.

Issues et pull requests

Issues, Pulls, Reviews, Comments, Reactions, Labels, Milestones, Assignees. La surface complète de collaboration.

Actions et checks

Actions, WorkflowRuns, WorkflowJobs, Artifacts, Secrets, Variables, Checks, CheckRuns, CheckSuites — construisez des tableaux de bord ou faites tourner de l'automatisation sur les données GitHub Actions.

Packages et registre de conteneurs

Packages, PackageVersions — gérez les paquets npm, NuGet, Maven, RubyGems et conteneurs depuis Delphi.

Organisations et équipes

Orgs, Teams, Members, Memberships, OrgsAdmin pour les opérations propriétaire uniquement comme le provisionnement SCIM.

GitHub Apps

Apps, Installations, AppManifests — installez des GitHub Apps programmatiquement et frappez des tokens d'installation à durée de vie courte.

Trois choses à surveiller

Limites de débit et requêtes conditionnelles

GitHub impose une limite de débit horaire (5 000 requêtes/heure avec un token, 60 sans authentification). Le client généré stocke le dernier ETag pour chaque réponse GET — réutilisez-les en définissant IfNoneMatch sur l'appel suivant pour obtenir une réponse 304 gratuite.

Les GitHub Apps ont besoin de tokens à courte durée de vie

Pour les installations GitHub App, vous échangez un JWT (signé avec la clé privée de votre app) contre un token d'installation d'1 heure. Utilisez la méthode Apps.CreateInstallationAccessToken et rafraîchissez le token avant qu'il n'expire.

Événements de timeline polymorphiques

L'endpoint Issues.ListEventsForTimeline retourne une union discriminée de douzaines de types d'événements. L'unité générée émet une classe de base et un descendant par variante — downcast en fonction de la propriété Event.

Depuis le blog

Parseur OpenAPI Delphi

Comment le parseur sous-jacent gère les spécifications OpenAPI 3.x du monde réel.

Lire le billet →

Client OpenAPI + parseur

Le billet de blog compagnon qui présente à la fois le wrapper client et les internes du parseur.

Lire le billet →

sgcOpenAPI 2026.6

Dernières notes de release — nouvelles options de générateur et corrections du parseur.

Lire le billet →

Construisez votre automatisation GitHub aujourd'hui

sgcOpenAPI livre le parseur, le générateur de code, le serveur OpenAPI et les bundles SDK Amazon, Google, Microsoft et Azure — un produit, trois niveaux.