eSeGeCe — Componentes de Comunicación Empresarial para Delphi y .NET
DESTACADO · sgcOpenAPI

Deja de escribir a mano clientes REST

Apunta sgcOpenAPI a un documento OpenAPI 3.x. El parser lo lee, el generador emite un SDK nativo en Object Pascal y el componente servidor OpenAPI publica tus propios endpoints como una especificación viva. O sáltate el generador por completo, porque ya hay más de 1.195 SDK para AWS, Azure, Google Cloud y Microsoft Graph construidos e incluidos.

  • OpenAPI 3.0 y 3.1
  • JSON y YAML
  • Swagger 2.0 con conversión automática
  • De Delphi 7 a RAD Studio 13

El SDK que necesitas probablemente ya está escrito

Todos los niveles de sgcOpenAPI, Single, Team y Site, incluyen el parser, el generador de código, el componente servidor OpenAPI y toda la librería de SDK preconstruidos. Nada se vende por separado.

1.195+ SDK de nube preconstruidos Generados a partir de las especificaciones oficiales de OpenAPI y actualizados con regularidad.
280+ Servicios de Amazon AWS SDK de servicios REST que cubren S3, EC2, Lambda, DynamoDB, SQS, SNS, CloudFormation y más.
650+ Servicios de Microsoft Azure Azure VMs, Blob Storage, Functions, Cosmos DB, Key Vault y más.
250+ Servicios de Google Cloud Compute Engine, Cloud Storage, BigQuery, Pub/Sub, Cloud Functions y más.
15+ SDK de Microsoft Graph Office 365, Microsoft Teams, OneDrive, Outlook y Active Directory.
sgcOpenAPI

Un producto integrado para Delphi y C++ Builder: un parser de OpenAPI 3.x, un generador nativo de SDK Pascal, un componente servidor OpenAPI y más de 1.195 SDK de nube preconstruidos. Código fuente completo, despliegue libre de royalties.

Cuatro nubes, ya en Pascal

No tienes que generar nada para empezar. Las cuatro mayores plataformas de nube vienen como SDK Pascal listos para usar dentro de sgcOpenAPI, generados a partir de las especificaciones oficiales y mantenidos al día.

Más de 280 servicios

Amazon AWS

SDK de servicios REST que cubren S3, EC2, Lambda, DynamoDB, SQS, SNS, CloudFormation y más. Añade la unit al proyecto y llama al servicio con clases tipadas de petición y respuesta.

Ver los SDK de AWS →
Más de 650 servicios

Microsoft Azure

El conjunto más grande de la librería. Azure VMs, Blob Storage, Functions, Cosmos DB, Key Vault y el resto del plano de control de Azure, cada uno un cliente Pascal generado.

Ver los SDK de Azure →
Más de 250 servicios

Google Cloud

Compute Engine, Cloud Storage, BigQuery, Pub/Sub, Cloud Functions y más.

Ver los SDK de Google →
Más de 15 SDK

Microsoft Graph

Office 365, Microsoft Teams, OneDrive, Outlook y Active Directory, a través de la API de Graph.

Ver los SDK de Microsoft →
Todo lo demás

Cualquier otra spec

Si la API publica un documento OpenAPI o Swagger, el generador lo convierte en el mismo tipo de unit Pascal tipada. No hay lista de permitidos.

Características del generador →

Guías paso a paso, desde una especificación pública hasta un cliente Delphi que compila:

Entra la spec, sale código que compila

Cinco pasos, todos dentro del IDE. Sin Node.js, sin generador de código en Java, sin motor de plantillas que aprender.

  1. 1 Apúntalo a una spec

    Carga un documento OpenAPI 3.x desde un fichero, una URL o una cadena, en JSON o YAML. Los ficheros Swagger 1.x y 2.x se detectan y se convierten al modelo OpenAPI 3.x automáticamente.

  2. 2 Parsea

    TsgcOpenAPIParser resuelve los punteros $ref, incluidos ficheros externos y referencias circulares, aplana allOf, oneOf y anyOf, e informa de los errores estructurales con detalle a nivel de línea.

  3. 3 Genera

    TsgcOpenAPIGenerator emite clases, records y enumerados Pascal fuertemente tipados, agrupados en una clase por tag, además de documentación en PDF y CHM junto al código.

  4. 4 Compila

    Añade las units generadas al proyecto. No hay dependencias externas más allá del runtime de sgcOpenAPI, de Delphi 7 a RAD Studio 13 y de C++ Builder 2007 a 13.

  5. 5 Llama

    Fija BaseURL, fija las credenciales y llama a la operación. Métodos con tipos seguros, resultados tipados e IntelliSense completo en el 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;

El parser y el generador son componentes separados, así que también puedes recorrer el modelo parseado por tu cuenta y construir tus propias herramientas encima. El componente parser →

Sirve la spec, no solo la consumas

TsgcOpenAPIServer publica un documento OpenAPI 3.x en vivo, enruta las peticiones entrantes según la especificación, valida payloads en ambas direcciones y ofrece Swagger UI y Redoc embebidos, todo desde un único componente Delphi sobre el servidor HTTP/2 de 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;

Qué te da eso

GET /pets/{petId} ejecuta el manejador de arriba. GET /openapi.json devuelve el documento en vivo. GET /docs abre Swagger UI y GET /redoc abre Redoc. HTTP/2 y TLS ya están activos si el servidor HTTP los tiene configurados.

Primero la spec o primero el código

Carga un contrato YAML o JSON y enlaza los manejadores a los identificadores de operación, o registra los manejadores en Pascal y deja que el componente construya el documento OpenAPI en tiempo de ejecución.

Validación en ambas direcciones

Campos obligatorios, coerción de tipos, pertenencia a enumerados, validadores de formato, límites de longitud y de rango, patrones y composición de esquemas se aplican antes de que se ejecute el manejador. Los fallos vuelven como problem details de RFC 7807 con diagnóstico a nivel de campo.

Autenticación cableada desde la spec

Cada securityScheme del documento se aplica automáticamente. Tú escribes la búsqueda de credenciales, el componente se encarga del parseo, de las cabeceras de desafío y de las respuestas 401 y 403.

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

El componente servidor OpenAPI →

El servidor corre sobre el mismo servidor HTTP de sgcWebSockets que aloja tus endpoints WebSocket y tus ficheros estáticos. Un puerto, un certificado TLS, un único flujo de log.

Seis librerías, una sola caja de herramientas

sgcOpenAPI es una de las seis librerías de componentes de eSeGeCe para Delphi, C++ Builder y .NET. Comparten convenciones, incluyen el código fuente completo y se despliegan libres de royalties.

sgcOpenAPI

Parser de OpenAPI 3.x, generador nativo de SDK Pascal, componente servidor OpenAPI y más de 1.195 SDK preconstruidos para AWS, Azure, Google Cloud y Microsoft Graph.

Más información →

sgcWebSockets

WebSocket, HTTP/2, HTTP/3, MQTT, AMQP, WebRTC, IA y más de 30 integraciones de APIs. El servidor HTTP sobre el que corre el componente servidor OpenAPI.

Más información →

sgcHTML

Componentes HTML y de UI en servidor sobre Bootstrap 5 y htmx. Construye la interfaz de administración o el cuadro de mando para los clientes REST que generes, sin front-end JavaScript.

Más información →

sgcSign

XAdES, PAdES, CAdES y ASiC para documentos, Authenticode, ClickOnce, NuGet y VSIX para código. Firma los cuerpos de petición y respuesta que intercambia tu API.

Más información →

sgcBiometrics

Windows Hello, sensores de huella dactilar y el Windows Biometric Framework para Delphi y C++ Builder. Protege el acceso a tu API tras una huella dactilar.

Más información →

sgcIndy

Componentes Indy TCP/IP actualizados con TLS moderno, IPv6 y HTTP/2, de Delphi 7 a 13. La capa de transporte bajo los clientes generados.

Más información →

Ver precios y ediciones Descargar la prueba gratuita

Qué dicen los desarrolladores

La confianza de desarrolladores de Delphi, C++ Builder, Lazarus y .NET en todo el mundo.

Vuestra librería sgcWebSockets es muy útil y fácil de configurar. ¡Seguid así!

Simone Moretti Desarrollador Delphi

sgcWebSockets es increíble y vuestro soporte es el mejor.

Christian Meyer Fundador y CTO

Muchas gracias por vuestra ayuda y soporte, me encantan vuestros componentes.

Mark Steinfeld CTO

Estás viendo la vista OpenAPI de eSeGeCe.

Muéstrame otro enfoque →
Garantía de devolución de 30 días¿No estás satisfecho? Solicita un reembolso completo en los 30 días posteriores a la compra. Ver política de reembolso

Genera hoy tu primer SDK en Pascal

Parser, generador de código, componente servidor OpenAPI y los más de 1.195 SDK de nube preconstruidos, con una sola licencia. Código fuente completo, despliegue libre de royalties, de Delphi 7 a RAD Studio 13.