hexarc pact Download - hexarc pact Quellcode Download

hexarc pact

Andere Kategorien

1.0.0

Herunterladen

Hexarc -Pakt

Hexarc Pact bietet eine ToolChain für die Freigabe und Konsum von Web-API für .NET/TypeScript-basierte Projekte.

Entwickeln Sie Ihr .NET -Web -API -Projekt mit PACT, um eine einzelne Wahrheitsquelle für die API -Metadaten beizubehalten, und konsumieren Sie sie über das .NET -Ökosystem (Microservices, Desktop- und Mobile -Anwendungen) oder im Web über Typscript.

Paket	Plattform	Version	Downloads
`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`	Typoskript

Was ist in Pakt?

Merkmale
Typ System
API -Annotationsregeln
- Zusätzliche Attribute
Demo -API
Wie man benutzt
- Das PACT -API -Schema (.NET Web API -Dienst) freilegen
- Konsumieren Sie das PACT -API -Schema (.NET -Client -Anwendung)
Anerkennung
Lizenz

Merkmale

Problemlose API-Integrationen in Sekunden.
Keine Typinformationen verlieren. Kongen Sie sich so, wie es entworfen wurde.
Zuerst Code. Sie müssen Ihr API -Protokoll in externen IDL/DSL nicht beschreiben.
Mit fortgeschrittenen Typen aufgeladen. Nicht nur einfache DTOs, sondern auch Enums, Generika, markierte Gewerkschaften usw.

Typ System

Das PACT -System basiert auf den .NET -CLR -Typen mit einigen maßgeschneiderten, für die beste Entwicklungserfahrung.

Was ist innerhalb des Paktsystems:

Primitive Typen (einschließlich Guid und DateTime )
Wert-/Referenztyp -Semantik
Sammlungen und Generika (nicht nur einfache Arrays und Wörterbücher)
Vollständige Unterstützung für nullable Referenztypanmerkungen (NRT)
Enums (String-basierte und nummernbasierte)
Tagged Gewerkschaften (über hexarc.serialisation.union)
Tupel (über Hexarc.Serialization.tuple)

API -Annotationsregeln

Das PACT-API-Schema ist für eine RPC-ähnliche Semantik ausgelegt. Dabei muss eine exponierte API folgende Regeln befolgen:

API -Controller müssen mit Standard ApiController und Route markiert sein.
Das Routenattribut muss nur einen konstanten String -Pfad ohne Vorlagen haben (z. B. [Route("Entities")] ).
API -Methoden müssen mit einem der unterstützten HTTP -Verben ( HttpGet oder HttpPost ) markiert werden. Verbattribute können einen Endpunktpfad enthalten. Andere werden momentan nicht unterstützt.
- HttpGet -Methoden können Abfrageparameter haben, die über das Attribut FromQuery gebunden werden müssen.
- HttpPost -Methoden müssen nur einen Parameter haben, der die Anforderungskörper ist.
Der API -Methodenpfad kann im HTTP -Verb -Attribut oder im Route angegeben werden. Wenn der Methodenpfad im HTTP -Verb -Attribut nicht angegeben ist, wird er aus der Route ausgenommen oder eine Ausnahme wird angehoben.

Zusätzliche Attribute

PACT bietet einige nützliche Attribute für die API -Annotation:

PactIgnoreAttribute kann auf API -Controller oder -Methoden angewendet werden, die von einem API -Schema ausgeschlossen werden sollen.
PactScopeAttribute kann auf API -Controller angewendet werden, um in einem API -Schema in einen spezifischen Bereich zu isolieren.

Demo -API -Server

Der Demo-API-Server finden Sie unter https://hexarc-demo-api.herokuapp.com/.

Das PACT-API-Schema ist unter https://hexarc-demo-api.herokuapp.com/pact/schema freigelegt.

Um einen API -Client zu generieren, verwenden Sie die folgende Anweisung.

Wie man benutzt

Finden Sie heraus, wie Sie PACT verwenden, um eine typische Web -API zu enthüllen und zu konsumieren.

Pakt -API -Schema freilegen

Installieren Sie das Paket Hexarc.Pact.AspNetCore in einem .NET -Web -API -Projekt:

dotnet add package Hexarc.Pact.AspNetCore

Fügen Sie die PACT -Schema -Erzeugung in die Startup.ConfigureServices -Methode hinzu:

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

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

Aktivieren Sie die PACT Middleware in der Startup.Configure -Methode:

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

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

Implementieren Sie einen API -Controller gemäß den PACT -Annotationsregeln:

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

Starten Sie die App und öffnen Sie die Adresse YOUR_API_HOST/pact/schema um sicherzustellen, dass das PACT -API -Schema generiert wird.

Pakt -API -Schema konsumieren

Installieren Sie das Paket Hexarc.Pact.Client in einem .NET -Projekt:

dotnet add package Hexarc.Pact.Client

Installieren Sie das Tool Hexarc.Pact.Tool im Projekt:

dotnet tool install Hexarc.Pact.Tool

Möglicherweise müssen Sie ein .NET -Tools -Manifest einrichten, bevor Sie das Werkzeug von Hexarc.Pact.Tool installieren:

dotnet new tool-manifest

Fügen Sie eine pact.json -Konfiguration im Projekt mit den gewünschten API -Client -Generierungseinstellungen hinzu:

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

Wo

schemaUri - Link zu einem Pakt -API -Schema
clientClassName - Name für eine generierte API -Client -Klasse
clientClassNamespace - Namespace, in dem in die generierte API -Client -Klasse eingebracht werden soll
outputDirectory - Ausgabeverzeichnis für die generierten Quellen

Generieren Sie den API -Client über das PACT CLI -Tool:

dotnet pact

Dieser Befehl muss im selben Ordner mit der pact.json -Konfiguration durchgeführt werden.

Der generierte API -Client steht für den Zugriff auf den API -Server zur Verfügung:

 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.