Descarga hexarc pact - Descargar el código fuente hexarc pact

hexarc pact

Otras categorias

1.0.0

Descargar

Pacto hexarc

HEXARC PACT proporciona una cadena de herramientas para exponer y consumir API web para proyectos basados en .NET/TypeScript.

Desarrolle su proyecto de API web .NET con PACT para mantener una sola fuente de verdad para los metadatos de API y consumirlo en el ecosistema .NET (microservicios, escritorio y aplicaciones móviles) o en la web a través de TypeScript.

Paquete	Plataforma	Versión	Descargas
`Hexarch.Pact.Protocol`	.NET 7.0+
`Hexarch.Pact.AspNetCore`	.NET 7.0+
`Hexarch.Pact.Client`	.NET 7.0+
`Hexarch.Pact.Tool`	.NET 7.0+
`@hexarc/pact-tool`	Mecanografiado

¿Qué hay en pacto?

Características
Sistema tipo
Reglas de anotación de API
- Atributos adicionales
API de demostración
Cómo usar
- Exponer el esquema de la API PACT (servicio de API web .NET)
- Consumir el esquema de la API PACT (aplicación del cliente .NET)
Expresiones de gratitud
Licencia

Características

Integraciones de API sin problemas en segundos.
No se pierde información de tipo. Consume la API exacta tal como está diseñada.
Código primero. No es necesario describir su protocolo API en IDL/DSL externo.
Cargado de tipos avanzados. No solo los DTO simples sino enumeros, genéricos, sindicatos etiquetados, etc.

Sistema tipo

El sistema de tipo PACT se basa en los tipos de CLR .NET con algunos a medida para la mejor experiencia de desarrollo.

¿Qué hay dentro del sistema de tipo de pacto?

Tipos primitivos (incluidos Guid y DateTime )
Valor/Tipo de referencia Semántica
Colecciones y genéricos (no solo matrices y diccionarios simples)
Soporte completo para anotaciones de tipo de referencia anulables (NRT)
Enums (basados en cadenas y basados en numeros
Uniones etiquetadas (a través de hexarc.serialization.union)
Tuples (a través de hexarc.serialization.tuple)

Reglas de anotación de API

El esquema PACT API está diseñado para tener una semántica similar a RPC. Al hacerlo, una API expuesta debe seguir estas reglas:

Los controladores API deben estar marcados con atributos estándar ApiController y Route .
El atributo de ruta debe tener solo una ruta de cadena constante sin plantilla (por ejemplo, [Route("Entities")] ).
Los métodos API deben estar marcados con uno de los verbos HTTP compatibles ( HttpGet o HttpPost ). Los atributos verbales pueden contener una ruta de punto final. Otros no son apoyados en este momento.
- Los métodos HttpGet pueden tener parámetros de consulta que deben estar enlaces a través del atributo FromQuery .
- Los métodos HttpPost deben tener solo un parámetro que es el cuerpo de solicitud.
La ruta del método API se puede especificar en el atributo verbal HTTP o el atributo Route . Si la ruta del método no se especifica en el atributo verbal HTTP, se tomará de la Route uno o se planteará una excepción.

Atributos adicionales

PACT proporciona algunos atributos útiles para la anotación de API:

PactIgnoreAttribute se puede aplicar a los controladores o métodos API que se excluirán de un esquema API.
PactScopeAttribute se puede aplicar a los controladores API para aislarse en un alcance específico en un esquema API.

Servidor API de demostración

El servidor API de demostración se puede encontrar en https://hexarc-demo-api.herokuapp.com/.

El esquema de la API PACT está expuesto a https://hexarc-demo-api.herokuapp.com/pact/schema.

Para generar un cliente API, use la instrucción a continuación.

Cómo usar

Descubra cómo usar PACT para exponer y consumir una API web típica.

Exponer el esquema API del PACT

Instale el paquete Hexarc.Pact.AspNetCore en un proyecto de API web .NET:

dotnet add package Hexarc.Pact.AspNetCore

Agregue la generación del esquema del pacto en el método Startup.ConfigureServices :

 public void ConfigureServices ( IServiceCollection services )
{
    services . AddControllers ( ) ;

    // Register the Pact schema generation.
    services . AddPactGeneration ( ) ;
}

Habilite el middleware del pacto en el método Startup.Configure :

 public void Configure ( IApplicationBuilder app )
{
    // Enable the Pact middleware to expose the generated API schema.
    app . UsePact ( ) ;

    app . UseRouting ( ) ;
    app . UseEndpoints ( endpoints => endpoints . MapControllers ( ) ) ;
}

Implementar un controlador API de acuerdo con las reglas de anotación del pacto:

 [ ApiController , Route ( "Misc" ) ]
public sealed class MiscController : ControllerBase
{
    [ HttpGet ( nameof ( Ping ) ) ]
    public String Ping ( [ FromQuery ] String message ) => $ "Hello, { message } " ;
}

Inicie la aplicación y abra la dirección YOUR_API_HOST/pact/schema para garantizar que se genere el esquema de la API PACT.

Consumir el esquema de la API de PACT

Instale el paquete Hexarc.Pact.Client en un proyecto .NET:

dotnet add package Hexarc.Pact.Client

Instale la herramienta Hexarc.Pact.Tool en el proyecto:

dotnet tool install Hexarc.Pact.Tool

Es posible que deba configurar un manifiesto de .NET Tools antes de instalar la herramienta Hexarc.Pact.Tool :

dotnet new tool-manifest

Agregue una configuración pact.json en el proyecto con una configuración de generación de clientes API deseada:

{
   "schemaUri" : " YOUR_API_HOST/pact/schema " ,
   "clientClassName" : " DemoClient " ,
   "clientClassNamespace" : " DemoNamespace " ,
   "outputDirectory" : " Generated "
}

dónde

schemaUri - Enlace a un esquema de PACT API
clientClassName : nombre para una clase de cliente API generada
clientClassNamespace : espacio de nombres dónde colocar la clase de cliente API generada
outputDirectory - Directorio de salida para las fuentes generadas

Genere el cliente API a través de la herramienta PACT CLI:

dotnet pact

Este comando debe realizarse en la misma carpeta con la configuración pact.json .

El cliente API generado estará disponible para acceder al servidor API:

 var client = new DemoClient ( new HttpClient { BaseAddress = new Uri ( "YOUR_API_HOST" ) } ) ;
var pong = await client . Misc . Ping ( "World" ) ;
Console . WriteLine ( pong ) ; // Prints "Hello, World" to the output.