eSeGeCe — Enterprise-Kommunikationskomponenten für Delphi & .NET
IM FOKUS · sgcOpenAPI

Schluss mit handgeschriebenen REST-Clients

Richte sgcOpenAPI auf ein OpenAPI-3.x-Dokument. Der Parser liest es ein, der Generator erzeugt ein natives Object Pascal-SDK, und die OpenAPI-Server-Komponente veröffentlicht deine eigenen Endpunkte wieder als live erzeugte Spezifikation. Oder lass den Generator ganz weg, denn 1.195+ SDKs für AWS, Azure, Google Cloud und Microsoft Graph sind bereits fertig gebaut und mitgeliefert.

  • OpenAPI 3.0 und 3.1
  • JSON und YAML
  • Swagger 2.0 automatisch konvertiert
  • Delphi 7 bis RAD Studio 13

Das SDK, das du brauchst, gibt es wahrscheinlich schon

Jede sgcOpenAPI-Stufe, Single, Team und Site, enthält den Parser, den Code-Generator, die OpenAPI-Server-Komponente und die komplette Bibliothek vorgefertigter SDKs. Nichts wird separat verkauft.

1,195+ Vorgefertigte Cloud-SDKs Aus den offiziellen OpenAPI-Spezifikationen generiert und regelmäßig aktualisiert.
280+ Amazon AWS-Dienste REST-Dienst-SDKs für S3, EC2, Lambda, DynamoDB, SQS, SNS, CloudFormation und mehr.
650+ Microsoft Azure-Dienste Azure VMs, Blob Storage, Functions, Cosmos DB, Key Vault und mehr.
250+ Google Cloud-Dienste Compute Engine, Cloud Storage, BigQuery, Pub/Sub, Cloud Functions und mehr.
15+ Microsoft Graph-SDKs Office 365, Microsoft Teams, OneDrive, Outlook und Active Directory.
sgcOpenAPI

Ein gebündeltes Produkt für Delphi und C++ Builder: ein OpenAPI-3.x-Parser, ein nativer Pascal-SDK-Generator, eine OpenAPI-Server-Komponente und 1.195+ vorgefertigte Cloud-SDKs. Vollständiger Quellcode, royaltyfreie Bereitstellung.

Vier Clouds, schon in Pascal

Du musst nichts generieren, um loszulegen. Die vier größten Cloud-Plattformen liegen sgcOpenAPI als einsatzbereite Pascal-SDKs bei, aus den offiziellen Spezifikationen generiert und laufend aktuell gehalten.

280+ Dienste

Amazon AWS

REST-Dienst-SDKs für S3, EC2, Lambda, DynamoDB, SQS, SNS, CloudFormation und mehr. Nimm die Unit ins Projekt auf und rufe den Dienst mit typisierten Request- und Response-Klassen auf.

AWS-SDKs ansehen →
650+ Dienste

Microsoft Azure

Die größte Sammlung der Bibliothek. Azure VMs, Blob Storage, Functions, Cosmos DB, Key Vault und der Rest der Azure Control Plane, jeweils als generierter Pascal-Client.

Azure-SDKs ansehen →
250+ Dienste

Google Cloud

Compute Engine, Cloud Storage, BigQuery, Pub/Sub, Cloud Functions und mehr.

Google-SDKs ansehen →
15+ SDKs

Microsoft Graph

Office 365, Microsoft Teams, OneDrive, Outlook und Active Directory, über die Graph API.

Microsoft-SDKs ansehen →
Alles andere

Jede andere Spezifikation

Wenn die API ein OpenAPI- oder Swagger-Dokument veröffentlicht, macht der Generator daraus dieselbe Art typisierter Pascal-Unit. Es gibt keine Positivliste.

Generator-Funktionen →

Ausgearbeitete Anleitungen, von der öffentlichen Spezifikation bis zum kompilierenden Delphi-Client:

Spezifikation rein, kompilierender Code raus

Fünf Schritte, alle in der IDE. Kein Node.js, kein Java-Code-Generator, keine Template-Engine, die du lernen musst.

  1. 1 Richte es auf eine Spezifikation

    Lade ein OpenAPI-3.x-Dokument aus einer Datei, einer URL oder einem String, als JSON oder YAML. Swagger-1.x- und -2.x-Dateien werden erkannt und für dich ins OpenAPI-3.x-Modell konvertiert.

  2. 2 Parsen

    TsgcOpenAPIParser löst $ref-Verweise auf, auch auf externe Dateien und Zirkelbezüge, flacht allOf, oneOf und anyOf ab und meldet Strukturfehler zeilengenau.

  3. 3 Generieren

    TsgcOpenAPIGenerator erzeugt streng typisierte Pascal-Klassen, -Records und -Enumerationen, gruppiert als eine Klasse pro Tag, dazu PDF- und CHM-Dokumentation neben dem Code.

  4. 4 Kompilieren

    Nimm die generierten Units ins Projekt auf. Außer der sgcOpenAPI-Laufzeit gibt es keine externen Abhängigkeiten, von Delphi 7 bis RAD Studio 13 und C++ Builder 2007 bis 13.

  5. 5 Aufrufen

    Setze BaseURL, setze die Zugangsdaten und rufe die Operation auf. Typsichere Methoden, typisierte Ergebnisse, volle IntelliSense-Unterstützung in der IDE.

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;
uses
  sgcOpenAPI_PetStore;  // Generated from petstore.yaml

procedure TForm1.btnGetPetClick(Sender: TObject);
var
  Client: TsgcOpenAPI_PetStoreClient;
  Pet: TsgcOpenAPI_Pet;
begin
  Client := TsgcOpenAPI_PetStoreClient.Create(nil);
  try
    Client.BaseURL := 'https://petstore.swagger.io/v2';
    Client.ApiKey  := 'your-api-key';

    // Type-safe API call with IntelliSense
    Pet := Client.GetPetById(42);
    try
      Memo1.Lines.Add('Name: '     + Pet.Name);
      Memo1.Lines.Add('Status: '   + Pet.Status);
      Memo1.Lines.Add('Category: ' + Pet.Category.Name);
    finally
      Pet.Free;
    end;
  finally
    Client.Free;
  end;
end;

Parser und Generator sind getrennte Komponenten, du kannst das geparste Modell also auch selbst durchlaufen und eigenes Tooling darauf aufbauen. Die Parser-Komponente →

Die Spezifikation ausliefern, nicht nur konsumieren

TsgcOpenAPIServer veröffentlicht ein live erzeugtes OpenAPI-3.x-Dokument, routet eingehende Requests anhand der Spezifikation, validiert Payloads in beide Richtungen und bringt Swagger UI und Redoc eingebettet mit, alles aus einer einzigen Delphi-Komponente auf dem HTTP/2-Server von sgcWebSockets.

OpenAPIServer.pas
uses
  sgcOpenAPI_Server, sgcOpenAPI_Types, sgcHTTP_Server;

procedure TForm1.FormCreate(Sender: TObject);
begin
  FServer := TsgcOpenAPIServer.Create(nil);
  FServer.HTTPServer := sgcHTTPServer1;
  FServer.Spec.LoadFromFile('petstore.yaml');
  FServer.PublishSpecPath := '/openapi.json';
  FServer.SwaggerUIPath   := '/docs';
  FServer.RedocPath       := '/redoc';

  // Bind an operation declared in the spec
  FServer.OnOperation_getPetById :=
    procedure(const Ctx: TsgcOpenAPIContext)
    var
      oPet: TJSONObject;
    begin
      oPet := TJSONObject.Create;
      oPet.AddPair('id',     Ctx.PathParams['petId']);
      oPet.AddPair('name',   'Rex');
      oPet.AddPair('status', 'available');
      Ctx.RespondJSON(200, oPet);
    end;

  sgcHTTPServer1.Port   := 8080;
  sgcHTTPServer1.Active := True;
end;

Was dir das bringt

GET /pets/{petId} ruft den Handler oben auf. GET /openapi.json liefert das live erzeugte Dokument. GET /docs öffnet Swagger UI, GET /redoc öffnet Redoc. HTTP/2 und TLS sind bereits aktiv, wenn der HTTP-Server sie konfiguriert hat.

Spec-first oder Code-first

Lade einen YAML- oder JSON-Vertrag und binde Handler an die Operation-IDs, oder registriere Handler in Pascal und lass die Komponente das OpenAPI-Dokument zur Laufzeit bauen.

Validierung in beide Richtungen

Pflichtfelder, Typumwandlung, Enum-Zugehörigkeit, Format-Validatoren, Längen- und Bereichsgrenzen, Muster und Schema-Komposition werden alle erzwungen, bevor der Handler läuft. Fehler kommen als RFC 7807 Problem Details mit feldgenauer Diagnose zurück.

Auth direkt aus der Spezifikation verdrahtet

Jedes securityScheme im Dokument wird automatisch durchgesetzt. Du schreibst die Prüfung der Zugangsdaten, die Komponente übernimmt das Parsen, die Challenge-Header und die 401- und 403-Antworten.

API Key HTTP Basic Bearer JWT OAuth2 OpenID Connect mTLS Swagger UI + Redoc

Die OpenAPI-Server-Komponente →

Der Server läuft auf demselben sgcWebSockets-HTTP-Server, der deine WebSocket-Endpunkte und statischen Dateien hostet. Ein Port, ein TLS-Zertifikat, ein Log-Stream.

Sechs Bibliotheken, ein Werkzeugkasten

sgcOpenAPI ist eine von sechs eSeGeCe-Komponentenbibliotheken für Delphi, C++ Builder und .NET. Sie teilen dieselben Konventionen, werden mit vollständigem Quellcode ausgeliefert und lassen sich royaltyfrei verteilen.

sgcOpenAPI

OpenAPI-3.x-Parser, nativer Pascal-SDK-Generator, OpenAPI-Server-Komponente und 1.195+ vorgefertigte SDKs für AWS, Azure, Google Cloud und Microsoft Graph.

Mehr erfahren →

sgcWebSockets

WebSocket, HTTP/2, HTTP/3, MQTT, AMQP, WebRTC, KI und 30+ API-Integrationen. Der HTTP-Server, auf dem die OpenAPI-Server-Komponente läuft.

Mehr erfahren →

sgcHTML

Serverseitige HTML- und UI-Komponenten auf Bootstrap 5 und htmx. Baue die Admin- oder Dashboard-UI für die REST-Clients, die du generierst, ganz ohne JavaScript-Frontend.

Mehr erfahren →

sgcSign

XAdES, PAdES, CAdES und ASiC für Dokumente, Authenticode, ClickOnce, NuGet und VSIX für Code. Signiere die Request- und Response-Bodies, die deine API austauscht.

Mehr erfahren →

sgcBiometrics

Windows Hello, Fingerabdrucksensoren und das Windows Biometric Framework für Delphi und C++ Builder. Sichere den API-Zugriff hinter einem Fingerabdruck ab.

Mehr erfahren →

sgcIndy

Aktualisierte Indy TCP/IP-Komponenten mit moderner TLS-, IPv6- und HTTP/2-Unterstützung, für Delphi 7 bis 13. Die Transportschicht unter den generierten Clients.

Mehr erfahren →

Preise und Editionen ansehen Kostenlose Testversion herunterladen

Was Entwickler sagen

Vertrauen von Delphi-, C++ Builder-, Lazarus- und .NET-Entwicklern weltweit.

Eure sgcWebSockets-Bibliothek ist sehr nützlich und einfach einzurichten. Macht weiter so!

Simone Moretti Delphi-Entwickler

sgcWebSockets ist großartig und euer Support ist der beste!

Christian Meyer Gründer & CTO

Vielen Dank für eure Hilfe und Unterstützung, ich liebe eure Komponenten.

Mark Steinfeld CTO

Du siehst gerade die Ansicht OpenAPI von eSeGeCe.

Zeig mir eine andere Perspektive →
30 Tage Geld-zurück-GarantieNicht zufrieden? Fordern Sie innerhalb von 30 Tagen nach dem Kauf eine vollständige Rückerstattung an. Rückerstattungsrichtlinie ansehen

Generiere noch heute dein erstes Pascal-SDK

Parser, Code-Generator, OpenAPI-Server-Komponente und alle 1.195+ vorgefertigten Cloud-SDKs, in einer Lizenz. Vollständiger Quellcode, royaltyfreie Bereitstellung, Delphi 7 bis RAD Studio 13.