Client Delphi per la REST API di GitHub via sgcOpenAPI

GitHub mantiene la più grande descrizione OpenAPI pubblicamente disponibile — oltre 1.000 endpoint tra repository, issue, pull request, actions, check, package e il gateway GraphQL. Dalla in pasto a sgcOpenAPI ed emetti una unit Delphi tipizzata che la tua applicazione può usare per pilotare qualunque workflow GitHub esposto dalla REST API.

GitHub + sgcOpenAPI

GitHub distribuisce una descrizione OpenAPI 3 completamente mantenuta sotto licenza MIT. sgcOpenAPI la fa il parsing ed emette una singola unit Pascal che compila da Delphi 7 a RAD Studio 13.

Specifica sorgente

github/rest-api-description

Autenticazione

Personal access token, JWT GitHub App, OAuth

Unit generata

sgcOpenAPI_GitHub

Piattaforme

Windows, macOS, Linux, iOS, Android

Genera il client

GitHub pubblica due varianti della specifica — api.github.com.json per il servizio hosted pubblico e ghes-3.x.json per GitHub Enterprise Server. Punta il parser a quella che ti serve.

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;

Il generator emette una classe per ogni tag GitHub — TsgcGitHub_Repos, TsgcGitHub_Issues, TsgcGitHub_Pulls, TsgcGitHub_Actions, TsgcGitHub_Checks, TsgcGitHub_Packages, TsgcGitHub_OrgsAdmin e così via — tutte di proprietà di una facade di livello superiore TsgcGitHub.

Elenca i repository

Autenticati con un personal access token, poi enumera i repository dell'utente corrente. La paginazione è gestita dal wrapper enumerable generato — basta un for...in sul risultato e il client recupera le pagine aggiuntive on demand.

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;

Crea una issue e ispeziona una pull request

Due chiamate brevi — una di mutazione, una di lettura. Entrambe le route restituiscono gli stessi oggetti fortemente tipizzati descritti dalla specifica.

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

Cosa ti dà la unit generata

Ogni tag della descrizione OpenAPI ufficiale diventa una classe tipizzata. Ogni parametro documentato diventa un argomento tipizzato.

Repository e contenuti

Repos, Git, Contents, Branches, Tags, Releases, Forks. Leggi, scrivi ed elimina file. Crea branch, gestisci le regole di protezione, fai il draft e pubblica le release.

Issue e pull request

Issues, Pulls, Reviews, Comments, Reactions, Labels, Milestones, Assignees. L'intera superficie di collaborazione.

Actions e checks

Actions, WorkflowRuns, WorkflowJobs, Artifacts, Secrets, Variables, Checks, CheckRuns, CheckSuites — costruisci dashboard o automazioni a partire dai dati di GitHub Actions.

Package e container registry

Packages, PackageVersions — gestisci pacchetti npm, NuGet, Maven, RubyGems e container da Delphi.

Organizzazioni e team

Orgs, Teams, Members, Memberships, OrgsAdmin per operazioni riservate ai proprietari come il provisioning SCIM.

GitHub Apps

Apps, Installations, AppManifests — installa GitHub Apps in modo programmatico e genera installation token di breve durata.

Tre cose a cui fare attenzione

Rate limit e richieste condizionali

GitHub impone un rate limit orario (5.000 richieste/ora con un token, 60 non autenticate). Il client generato memorizza l'ultimo ETag per ogni response GET — riusalo impostando IfNoneMatch sulla chiamata successiva per ottenere una response 304 gratuita.

Le GitHub App richiedono token di breve durata

Per le installazioni di GitHub App scambi un JWT (firmato con la chiave privata della tua app) per un installation token valido un'ora. Usa il metodo Apps.CreateInstallationAccessToken e rinnova il token prima della scadenza.

Eventi timeline polimorfici

L'endpoint Issues.ListEventsForTimeline restituisce un'unione discriminata di decine di tipi di evento. La unit generata emette una classe base e un discendente per ogni variante — fai il downcast in base alla proprietà Event.

Dal blog

Parser OpenAPI Delphi

Come il parser sottostante gestisce specifiche OpenAPI 3.x reali.

Leggi il post →

Client + parser OpenAPI

Il post di accompagnamento che introduce sia il wrapper client sia i meccanismi interni del parser.

Leggi il post →

sgcOpenAPI 2026.6

Note dell'ultimo rilascio — nuove opzioni del generator e fix del parser.

Leggi il post →

Costruisci oggi la tua automazione GitHub

sgcOpenAPI include il parser, il code generator, il server OpenAPI e i bundle SDK di Amazon, Google, Microsoft e Azure — un prodotto, tre tier.