[Nitro CLI] Add OpenAPI commands

src/Directory.Packages.props

@@ -30,6 +30,7 @@
     <PackageVersion Include="Microsoft.Azure.Functions.Worker.Extensions.Abstractions" Version="1.1.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.14.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.14.0" />
+    <PackageVersion Include="Microsoft.Extensions.FileSystemGlobbing" Version="10.0.0" />
     <PackageVersion Include="Microsoft.IO.RecyclableMemoryStream" Version="3.0.1" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
     <PackageVersion Include="Microsoft.OpenApi.Readers" Version="1.6.14" />
@@ -170,4 +171,4 @@
     <PackageVersion Include="Roslynator.CodeAnalysis.Analyzers" Version="4.15.0" />
     <PackageVersion Include="Roslynator.Formatting.Analyzers" Version="4.15.0" />
   </ItemGroup>
-</Project>
+</Project>

src/Nitro/CommandLine/src/CommandLine/Commands/Clients/ListClientCommand.cs

@@ -47,7 +47,7 @@ private static async Task<int> RenderInteractiveAsync(
         IApiClient client,
         CancellationToken ct)
     {
-        const string apiMessage = "For which client do you want to list the clients?";
+        const string apiMessage = "For which API do you want to list the clients?";
         var apiId = await context.GetOrSelectApiId(apiMessage);
 
         var container = PaginationContainer

src/Nitro/CommandLine/src/CommandLine/Commands/OpenApi/Component/OpenApiCollectionDetailPrompt.cs

@@ -0,0 +1,31 @@
+using ChilliCream.Nitro.CommandLine.Client;
+
+namespace ChilliCream.Nitro.CommandLine.Commands.OpenApi.Components;
+
+internal sealed class OpenApiCollectionDetailPrompt
+{
+    private readonly IOpenApiCollectionDetailPrompt_OpenApiCollection _data;
+
+    private OpenApiCollectionDetailPrompt(IOpenApiCollectionDetailPrompt_OpenApiCollection data)
+    {
+        _data = data;
+    }
+
+    public OpenApiCollectionDetailPromptResult ToObject(string[] formats)
+    {
+        return new OpenApiCollectionDetailPromptResult
+        {
+            Id = _data.Id,
+            Name = _data.Name
+        };
+    }
+
+    public static OpenApiCollectionDetailPrompt From(IOpenApiCollectionDetailPrompt_OpenApiCollection data) => new(data);
+
+    public class OpenApiCollectionDetailPromptResult
+    {
+        public required string Id { get; init; }
+
+        public required string Name { get; init; }
+    }
+}

src/Nitro/CommandLine/src/CommandLine/Commands/OpenApi/Component/OpenApiCollectionDetailPrompt.graphql

@@ -0,0 +1,4 @@
+fragment OpenApiCollectionDetailPrompt_OpenApiCollection on OpenApiCollection {
+  id
+  name
+}

src/Nitro/CommandLine/src/CommandLine/Commands/OpenApi/Component/SelectOpenApiCollectionPrompt.cs

@@ -0,0 +1,37 @@
+using ChilliCream.Nitro.CommandLine.Client;
+using ChilliCream.Nitro.CommandLine.Helpers;
+
+namespace ChilliCream.Nitro.CommandLine.Commands.OpenApi.Components;
+
+public sealed class SelectOpenApiCollectionPrompt(IApiClient client, string apiId)
+{
+    private string _title = "Select an OpenAPI collection from the list below.";
+
+    public SelectOpenApiCollectionPrompt Title(string title)
+    {
+        _title = title;
+        return this;
+    }
+
+    public async Task<ISelectOpenApiCollectionPrompt_OpenApiCollection?> RenderAsync(
+        IAnsiConsole console,
+        CancellationToken cancellationToken)
+    {
+        var paginationContainer = PaginationContainer.Create(
+            (after, first, ct)
+                => client.SelectOpenApiCollectionPromptQuery.ExecuteAsync(apiId, after, first, ct),
+            p => p.ApiById?.OpenApiCollections?.PageInfo,
+            p => p.ApiById?.OpenApiCollections?.Edges);
+
+        var selectedEdge = await PagedSelectionPrompt
+            .New(paginationContainer)
+            .Title(_title)
+            .UseConverter(x => x.Node.Name)
+            .RenderAsync(console, cancellationToken);
+
+        return selectedEdge?.Node;
+    }
+
+    public static SelectOpenApiCollectionPrompt New(IApiClient client, string apiId)
+        => new(client, apiId);
+}

src/Nitro/CommandLine/src/CommandLine/Commands/OpenApi/Component/SelectOpenApiCollectionPrompt.graphql

@@ -0,0 +1,25 @@
+query SelectOpenApiCollectionPromptQuery($apiId: ID!, $after: String, $first: Int) {
+  apiById(id: $apiId) {
+    openApiCollections(after: $after, first: $first) {
+      edges {
+        ...SelectOpenApiCollectionPrompt_OpenApiCollectionEdge
+      }
+      pageInfo {
+        ...PageInfo
+      }
+    }
+  }
+}
+
+fragment SelectOpenApiCollectionPrompt_OpenApiCollectionEdge on ApiOpenApiCollectionsEdge {
+  cursor
+  node {
+    ...SelectOpenApiCollectionPrompt_OpenApiCollection
+  }
+}
+
+fragment SelectOpenApiCollectionPrompt_OpenApiCollection on OpenApiCollection {
+  id
+  name
+  ...OpenApiCollectionDetailPrompt_OpenApiCollection
+}

src/Nitro/CommandLine/src/CommandLine/Commands/OpenApi/CreateOpenApiCollectionCommand.cs

@@ -0,0 +1,70 @@
+using System.CommandLine.Invocation;
+using ChilliCream.Nitro.CommandLine.Client;
+using ChilliCream.Nitro.CommandLine.Commands.Apis.Inputs;
+using ChilliCream.Nitro.CommandLine.Commands.OpenApi.Components;
+using ChilliCream.Nitro.CommandLine.Commands.OpenApi.Options;
+using ChilliCream.Nitro.CommandLine.Configuration;
+using ChilliCream.Nitro.CommandLine.Helpers;
+using ChilliCream.Nitro.CommandLine.Options;
+using ChilliCream.Nitro.CommandLine.Results;
+using static ChilliCream.Nitro.CommandLine.ThrowHelper;
+
+namespace ChilliCream.Nitro.CommandLine.Commands.OpenApi;
+
+internal sealed class CreateOpenApiCollectionCommand : Command
+{
+    public CreateOpenApiCollectionCommand() : base("create")
+    {
+        Description = "Creates a new OpenAPI collection";
+
+        AddOption(Opt<OptionalApiIdOption>.Instance);
+        AddOption(Opt<OpenApiCollectionNameOption>.Instance);
+
+        this.SetHandler(
+            ExecuteAsync,
+            Bind.FromServiceProvider<InvocationContext>(),
+            Bind.FromServiceProvider<IAnsiConsole>(),
+            Bind.FromServiceProvider<IApiClient>(),
+            Bind.FromServiceProvider<CancellationToken>());
+    }
+
+    private static async Task<int> ExecuteAsync(
+        InvocationContext context,
+        IAnsiConsole console,
+        IApiClient client,
+        CancellationToken cancellationToken)
+    {
+        console.WriteLine();
+        console.WriteLine("Creating an OpenAPI collection");
+        console.WriteLine();
+
+        const string apiMessage = "For which api do you want to create an OpenAPI collection?";
+        var apiId = await context.GetOrSelectApiId(apiMessage);
+
+        var name = await context
+            .OptionOrAskAsync("Name", Opt<OpenApiCollectionNameOption>.Instance, cancellationToken);
+
+        var input = new CreateOpenApiCollectionInput { Name = name, ApiId = apiId };
+        var result =
+            await client.CreateOpenApiCollectionCommandMutation.ExecuteAsync(input, cancellationToken);
+
+        console.EnsureNoErrors(result);
+        var data = console.EnsureData(result);
+        console.PrintErrorsAndExit(data.CreateOpenApiCollection.Errors);
+
+        var createdOpenApiCollection = data.CreateOpenApiCollection.OpenApiCollection;
+        if (createdOpenApiCollection is null)
+        {
+            throw Exit("Could not create OpenAPI collection.");
+        }
+
+        console.OkLine($"OpenAPI collection {createdOpenApiCollection.Name.AsHighlight()} created.");
+
+        if (createdOpenApiCollection is IOpenApiCollectionDetailPrompt_OpenApiCollection detail)
+        {
+            context.SetResult(OpenApiCollectionDetailPrompt.From(detail).ToObject([]));
+        }
+
+        return ExitCodes.Success;
+    }
+}

src/Nitro/CommandLine/src/CommandLine/Commands/OpenApi/CreateOpenApiCollectionCommand.graphql

@@ -0,0 +1,18 @@
+mutation CreateOpenApiCollectionCommandMutation($input: CreateOpenApiCollectionInput!) {
+  createOpenApiCollection(input: $input) {
+    openApiCollection {
+      ...CreateOpenApiCollectionCommandMutation_OpenApiCollection
+    }
+    errors {
+      ...Error
+      ...ApiNotFoundError
+      ...UnauthorizedOperation
+    }
+  }
+}
+
+fragment CreateOpenApiCollectionCommandMutation_OpenApiCollection on OpenApiCollection {
+  name
+  id
+  ...OpenApiCollectionDetailPrompt_OpenApiCollection
+}

src/Nitro/CommandLine/src/CommandLine/Commands/OpenApi/DeleteOpenApiCollectionCommand.cs

@@ -0,0 +1,112 @@
+using System.CommandLine.Invocation;
+using ChilliCream.Nitro.CommandLine.Arguments;
+using ChilliCream.Nitro.CommandLine.Client;
+using ChilliCream.Nitro.CommandLine.Commands.Apis.Components;
+using ChilliCream.Nitro.CommandLine.Commands.OpenApi.Components;
+using ChilliCream.Nitro.CommandLine.Configuration;
+using ChilliCream.Nitro.CommandLine.Helpers;
+using ChilliCream.Nitro.CommandLine.Options;
+using ChilliCream.Nitro.CommandLine.Results;
+using ChilliCream.Nitro.CommandLine.Services.Sessions;
+using static ChilliCream.Nitro.CommandLine.ThrowHelper;
+
+namespace ChilliCream.Nitro.CommandLine.Commands.OpenApi;
+
+internal sealed class DeleteOpenApiCollectionCommand : Command
+{
+   public DeleteOpenApiCollectionCommand() : base("delete")
+    {
+        Description = "Deletes an OpenAPI collection";
+
+        AddOption(Opt<ForceOption>.Instance);
+        AddArgument(Opt<OptionalIdArgument>.Instance);
+
+        this.SetHandler(
+            ExecuteAsync,
+            Bind.FromServiceProvider<InvocationContext>(),
+            Bind.FromServiceProvider<IAnsiConsole>(),
+            Bind.FromServiceProvider<IApiClient>(),
+            Opt<OptionalIdArgument>.Instance,
+            Bind.FromServiceProvider<CancellationToken>());
+    }
+
+    private static async Task<int> ExecuteAsync(
+        InvocationContext context,
+        IAnsiConsole console,
+        IApiClient client,
+        string? openApiCollectionId,
+        CancellationToken cancellationToken)
+    {
+        console.WriteLine();
+        console.WriteLine("Deleting an OpenAPI collection");
+        console.WriteLine();
+
+        const string apiMessage = "For which api do you want to delete an OpenAPI collection?";
+        const string openApiCollectionMessage = "Which OpenAPI collection do you want to delete?";
+
+        if (openApiCollectionId is null)
+        {
+            if (!console.IsHumanReadable())
+            {
+                throw Exit("The OpenAPI collection id is required in non-interactive mode.");
+            }
+
+            var workspaceId = context.RequireWorkspaceId();
+
+            var selectedApi = await SelectApiPrompt
+                .New(client, workspaceId)
+                .Title(apiMessage)
+                .RenderAsync(console, cancellationToken) ?? throw NoApiSelected();
+
+            var apiId = selectedApi.Id;
+
+            var selectedOpenApiCollection = await SelectOpenApiCollectionPrompt
+                .New(client, apiId)
+                .Title(openApiCollectionMessage)
+                .RenderAsync(console, cancellationToken) ?? throw NoOpenApiCollectionSelected();
+
+            console.WriteLine("Selected OpenAPI collection: " + selectedOpenApiCollection.Name);
+
+            openApiCollectionId = selectedOpenApiCollection.Id;
+            console.OkQuestion(openApiCollectionMessage, openApiCollectionId);
+        }
+        else
+        {
+            console.OkQuestion(openApiCollectionMessage, openApiCollectionId);
+        }
+
+        var shouldDelete = await context.ConfirmWhenNotForced(
+            $"Do you want to delete the OpenAPI collection with the id {openApiCollectionId}?"
+                .EscapeMarkup(),
+            cancellationToken);
+
+        if (!shouldDelete)
+        {
+            console.OkLine("Aborted.");
+            return ExitCodes.Success;
+        }
+
+        var input = new DeleteOpenApiCollectionByIdInput { OpenApiCollectionId = openApiCollectionId };
+        var result =
+            await client.DeleteOpenApiCollectionByIdCommandMutation.ExecuteAsync(input, cancellationToken);
+
+        console.EnsureNoErrors(result);
+        var data = console.EnsureData(result);
+        console.PrintErrorsAndExit(data.DeleteOpenApiCollectionById.Errors);
+
+        var deletedOpenApiCollection = data.DeleteOpenApiCollectionById.OpenApiCollection;
+        if (deletedOpenApiCollection is null)
+        {
+            throw Exit("Could not delete the OpenAPI collection.");
+        }
+
+        console.OkLine($"OpenAPI collection {deletedOpenApiCollection.Name.AsHighlight()} was deleted.");
+
+        if (deletedOpenApiCollection is IOpenApiCollectionDetailPrompt_OpenApiCollection detail)
+        {
+            context.SetResult(OpenApiCollectionDetailPrompt.From(detail).ToObject([]));
+        }
+
+        return ExitCodes.Success;
+    }
+}

src/Nitro/CommandLine/src/CommandLine/Commands/OpenApi/DeleteOpenApiCollectionCommand.graphql

@@ -0,0 +1,20 @@
+mutation DeleteOpenApiCollectionByIdCommandMutation(
+  $input: DeleteOpenApiCollectionByIdInput!
+) {
+  deleteOpenApiCollectionById(input: $input) {
+    openApiCollection {
+      ...DeleteOpenApiCollectionByIdCommandMutation_OpenApiCollection
+    }
+    errors {
+      ...Error
+      ...OpenApiCollectionNotFoundError
+      ...UnauthorizedOperation
+    }
+  }
+}
+
+fragment DeleteOpenApiCollectionByIdCommandMutation_OpenApiCollection on OpenApiCollection {
+  name
+  id
+  ...OpenApiCollectionDetailPrompt_OpenApiCollection
+}