@yosr-ai/template-dotnet 0.0.0-stage → 0.2.6

package/features/errors-result/files/src/App/Features/Notes/NotesService.cs

@@ -0,0 +1,56 @@
+using App.Shared;
+
+namespace App.Features.Notes;
+
+public sealed class NotesService(INoteStore store)
+{
+    public Task<IReadOnlyList<Note>> ListAsync(CancellationToken cancellationToken = default) =>
+        store.ListAsync(cancellationToken);
+
+    public async Task<Result<Note>> GetAsync(int id, CancellationToken cancellationToken = default)
+    {
+        var note = await store.GetAsync(id, cancellationToken);
+        if (note is null) return new Result<Note>.Err($"Note {id} was not found.");
+        return new Result<Note>.Ok(note);
+    }
+
+    public async Task<Result<Note>> CreateAsync(NoteCreate input, CancellationToken cancellationToken = default)
+    {
+        string title;
+        try
+        {
+            title = RequireTitle(input.Title);
+        }
+        catch (ArgumentException ex)
+        {
+            return new Result<Note>.Err(ex.Message);
+        }
+
+        var note = await store.AddAsync(title, input.Body, cancellationToken);
+        return new Result<Note>.Ok(note);
+    }
+
+    public async Task<Result<Note>> UpdateAsync(int id, NoteUpdate input, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            if (input.Title is not null) RequireTitle(input.Title);
+        }
+        catch (ArgumentException ex)
+        {
+            return new Result<Note>.Err(ex.Message);
+        }
+
+        var note = await store.UpdateAsync(id, input.Title, input.Body, cancellationToken);
+        if (note is null) return new Result<Note>.Err($"Note {id} was not found.");
+        return new Result<Note>.Ok(note);
+    }
+
+    private static string RequireTitle(string? title)
+    {
+        var trimmed = title?.Trim() ?? string.Empty;
+        if (trimmed.Length == 0)
+            throw new ArgumentException("Title must not be blank.", nameof(title));
+        return trimmed;
+    }
+}

package/features/errors-result/files/src/App/Shared/Result.cs

@@ -0,0 +1,8 @@
+namespace App.Shared;
+
+public abstract record Result<T>
+{
+    public sealed record Ok(T Value) : Result<T>;
+
+    public sealed record Err(string Message) : Result<T>;
+}

package/features/errors-result/files/tests/App.Tests/NotesServiceTests.cs

@@ -0,0 +1,37 @@
+using App.Features.Notes;
+using App.Shared;
+
+namespace App.Tests;
+
+public sealed class NotesServiceTests
+{
+    private static NotesService Service() => new(new MemoryNoteStore());
+
+    [Fact]
+    public async Task Create_then_get_returns_the_note()
+    {
+        var notes = Service();
+        var created = Assert.IsType<Result<Note>.Ok>(await notes.CreateAsync(new NoteCreate("Hello", "Body")));
+        var found = Assert.IsType<Result<Note>.Ok>(await notes.GetAsync(created.Value.Id));
+        Assert.Equal("Hello", found.Value.Title);
+        Assert.Equal("Body", found.Value.Body);
+    }
+
+    [Fact]
+    public async Task Get_missing_note_returns_err()
+    {
+        var notes = Service();
+        Assert.IsType<Result<Note>.Err>(await notes.GetAsync(99));
+    }
+
+    [Fact]
+    public async Task Update_changes_only_given_fields()
+    {
+        var notes = Service();
+        var created = Assert.IsType<Result<Note>.Ok>(await notes.CreateAsync(new NoteCreate("Hello", "Body")));
+        var updated = Assert.IsType<Result<Note>.Ok>(
+            await notes.UpdateAsync(created.Value.Id, new NoteUpdate("Hi", null)));
+        Assert.Equal("Hi", updated.Value.Title);
+        Assert.Equal("Body", updated.Value.Body);
+    }
+}

package/files/.env.example

@@ -0,0 +1,7 @@
+# Application display name
+APP_NAME=__seed_projectName__
+
+# Comma-separated browser origins allowed by CORS (Vite default included)
+CORS_ORIGINS=http://localhost:5173
+
+# @seed:anchor env-vars

package/files/App.sln

@@ -0,0 +1,24 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31903.59
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "App", "src\App\App.csproj", "{A1111111-1111-1111-1111-111111111111}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "App.Tests", "tests\App.Tests\App.Tests.csproj", "{B2222222-2222-2222-2222-222222222222}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{A1111111-1111-1111-1111-111111111111}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A1111111-1111-1111-1111-111111111111}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A1111111-1111-1111-1111-111111111111}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A1111111-1111-1111-1111-111111111111}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B2222222-2222-2222-2222-222222222222}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B2222222-2222-2222-2222-222222222222}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B2222222-2222-2222-2222-222222222222}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B2222222-2222-2222-2222-222222222222}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+EndGlobal

package/files/Directory.Build.props

@@ -0,0 +1,9 @@
+<Project>
+  <PropertyGroup>
+    <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <!-- Compile warnings fail via `dotnet build -warnaserror` in the gate; keep restore free of TreatWarningsAsErrors so NuGet audit advisories do not block locked restore. -->
+    <WarningsNotAsErrors>NU1901;NU1902;NU1903;NU1904</WarningsNotAsErrors>
+  </PropertyGroup>
+</Project>

package/files/README.md

@@ -0,0 +1,20 @@
+# __seed_projectName__
+
+Generated by [Yosr Seed](https://seed.yosr.ai) from the `__seed_templateName__@__seed_templateVersion__` template. API-only ASP.NET Core service on .NET 10: minimal API, xUnit, `dotnet format`. Data: __seed_storageLabel__.
+
+## Commands
+
+| Task | Command |
+| --- | --- |
+| Restore (locked) | `dotnet restore --locked-mode` |
+| Run | `dotnet run --project src/App` |
+| Format check | `dotnet format --verify-no-changes` |
+| Build | `dotnet build -warnaserror` |
+| Tests | `dotnet test` |
+
+## Layout
+
+- `src/App/` — app (Core, Features, Shared)
+- `tests/App.Tests/` — unit + in-process HTTP tests (`WebApplicationFactory`)
+
+<!-- @seed:anchor readme-sections -->

package/files/gitignore

@@ -0,0 +1,9 @@
+bin/
+obj/
+.vs/
+*.user
+*.suo
+.env
+.DS_Store
+TestResults/
+*.log

package/files/global.json

@@ -0,0 +1,6 @@
+{
+  "sdk": {
+    "version": "10.0.404",
+    "rollForward": "latestFeature"
+  }
+}

package/files/src/App/App.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <RootNamespace>App</RootNamespace>
+    <AssemblyName>App</AssemblyName>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="10.0.15" />
+  </ItemGroup>
+
+</Project>

package/files/src/App/Core/AppSettings.cs

@@ -0,0 +1,25 @@
+namespace App.Core;
+
+public sealed class AppSettings
+{
+    public required string AppName { get; init; }
+
+    public IReadOnlyList<string> CorsOrigins { get; init; } = ["http://localhost:5173"];
+
+    // @seed:anchor settings-fields
+
+    public static AppSettings FromConfiguration(IConfiguration configuration)
+    {
+        var cors = configuration["CORS_ORIGINS"]
+            ?? Environment.GetEnvironmentVariable("CORS_ORIGINS")
+            ?? "http://localhost:5173";
+        return new AppSettings
+        {
+            AppName = configuration["APP_NAME"]
+                ?? Environment.GetEnvironmentVariable("APP_NAME")
+                ?? "__seed_projectName__",
+            CorsOrigins = cors.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries),
+            // @seed:anchor settings-values
+        };
+    }
+}

package/files/src/App/Features/Notes/INoteStore.cs

@@ -0,0 +1,12 @@
+namespace App.Features.Notes;
+
+public interface INoteStore
+{
+    Task<IReadOnlyList<Note>> ListAsync(CancellationToken cancellationToken = default);
+
+    Task<Note?> GetAsync(int id, CancellationToken cancellationToken = default);
+
+    Task<Note> AddAsync(string title, string? body, CancellationToken cancellationToken = default);
+
+    Task<Note?> UpdateAsync(int id, string? title, string? body, CancellationToken cancellationToken = default);
+}

package/files/src/App/Features/Notes/MemoryNoteStore.cs

@@ -0,0 +1,54 @@
+namespace App.Features.Notes;
+
+public sealed class MemoryNoteStore : INoteStore
+{
+    private readonly object _gate = new();
+    private readonly List<Note> _notes = [];
+    private int _nextId = 1;
+
+    public Task<IReadOnlyList<Note>> ListAsync(CancellationToken cancellationToken = default)
+    {
+        lock (_gate)
+        {
+            return Task.FromResult<IReadOnlyList<Note>>(
+                _notes.OrderByDescending(note => note.Id).ToList());
+        }
+    }
+
+    public Task<Note?> GetAsync(int id, CancellationToken cancellationToken = default)
+    {
+        lock (_gate)
+        {
+            return Task.FromResult(_notes.FirstOrDefault(note => note.Id == id));
+        }
+    }
+
+    public Task<Note> AddAsync(string title, string? body, CancellationToken cancellationToken = default)
+    {
+        lock (_gate)
+        {
+            var note = new Note
+            {
+                Id = _nextId++,
+                Title = title,
+                Body = body,
+                CreatedAt = DateTimeOffset.UtcNow,
+            };
+            _notes.Add(note);
+            return Task.FromResult(note);
+        }
+    }
+
+    public Task<Note?> UpdateAsync(int id, string? title, string? body, CancellationToken cancellationToken = default)
+    {
+        lock (_gate)
+        {
+            var note = _notes.FirstOrDefault(item => item.Id == id);
+            if (note is null) return Task.FromResult<Note?>(null);
+            if (title is not null) note.Title = title;
+            if (body is not null) note.Body = body;
+            note.UpdatedAt = DateTimeOffset.UtcNow;
+            return Task.FromResult<Note?>(note);
+        }
+    }
+}

package/files/src/App/Features/Notes/Note.cs

@@ -0,0 +1,24 @@
+namespace App.Features.Notes;
+
+public sealed class Note
+{
+    public required int Id { get; init; }
+
+    public required string Title { get; set; }
+
+    public string? Body { get; set; }
+
+    public required DateTimeOffset CreatedAt { get; init; }
+
+    public DateTimeOffset? UpdatedAt { get; set; }
+}
+
+public sealed record NoteCreate(string Title, string? Body);
+
+public sealed record NoteUpdate(string? Title, string? Body);
+
+public sealed record NoteResponse(int Id, string Title, string? Body, DateTimeOffset CreatedAt, DateTimeOffset? UpdatedAt)
+{
+    public static NoteResponse From(Note note) =>
+        new(note.Id, note.Title, note.Body, note.CreatedAt, note.UpdatedAt);
+}

package/files/src/App/Features/Notes/NotesEndpoints.cs

@@ -0,0 +1,63 @@
+using App.Shared;
+
+namespace App.Features.Notes;
+
+public static class NotesEndpoints
+{
+    public static RouteGroupBuilder MapNotesEndpoints(this IEndpointRouteBuilder app)
+    {
+        var group = app.MapGroup("/notes");
+        // @seed:anchor notes-group
+
+        group.MapGet("/", async (NotesService notes, CancellationToken cancellationToken) =>
+        {
+            var items = await notes.ListAsync(cancellationToken);
+            return Results.Ok(items.Select(NoteResponse.From));
+        });
+
+        group.MapGet("/{id:int}", async (int id, NotesService notes, CancellationToken cancellationToken) =>
+        {
+            try
+            {
+                var note = await notes.GetAsync(id, cancellationToken);
+                return Results.Ok(NoteResponse.From(note));
+            }
+            catch (NotFoundException ex)
+            {
+                return Results.NotFound(new { detail = ex.Message });
+            }
+        });
+
+        group.MapPost("/", async (NoteCreate body, NotesService notes, CancellationToken cancellationToken) =>
+        {
+            try
+            {
+                var note = await notes.CreateAsync(body, cancellationToken);
+                return Results.Created($"/notes/{note.Id}", NoteResponse.From(note));
+            }
+            catch (ArgumentException ex)
+            {
+                return Results.BadRequest(new { detail = ex.Message });
+            }
+        });
+
+        group.MapPatch("/{id:int}", async (int id, NoteUpdate body, NotesService notes, CancellationToken cancellationToken) =>
+        {
+            try
+            {
+                var note = await notes.UpdateAsync(id, body, cancellationToken);
+                return Results.Ok(NoteResponse.From(note));
+            }
+            catch (ArgumentException ex)
+            {
+                return Results.BadRequest(new { detail = ex.Message });
+            }
+            catch (NotFoundException ex)
+            {
+                return Results.NotFound(new { detail = ex.Message });
+            }
+        });
+
+        return group;
+    }
+}

package/files/src/App/Features/Notes/NotesService.cs

@@ -0,0 +1,38 @@
+using App.Shared;
+
+namespace App.Features.Notes;
+
+public sealed class NotesService(INoteStore store)
+{
+    public Task<IReadOnlyList<Note>> ListAsync(CancellationToken cancellationToken = default) =>
+        store.ListAsync(cancellationToken);
+
+    public async Task<Note> GetAsync(int id, CancellationToken cancellationToken = default)
+    {
+        var note = await store.GetAsync(id, cancellationToken);
+        if (note is null) throw new NotFoundException($"Note {id} was not found.");
+        return note;
+    }
+
+    public Task<Note> CreateAsync(NoteCreate input, CancellationToken cancellationToken = default)
+    {
+        var title = RequireTitle(input.Title);
+        return store.AddAsync(title, input.Body, cancellationToken);
+    }
+
+    public async Task<Note> UpdateAsync(int id, NoteUpdate input, CancellationToken cancellationToken = default)
+    {
+        if (input.Title is not null) RequireTitle(input.Title);
+        var note = await store.UpdateAsync(id, input.Title, input.Body, cancellationToken);
+        if (note is null) throw new NotFoundException($"Note {id} was not found.");
+        return note;
+    }
+
+    private static string RequireTitle(string? title)
+    {
+        var trimmed = title?.Trim() ?? string.Empty;
+        if (trimmed.Length == 0)
+            throw new ArgumentException("Title must not be blank.", nameof(title));
+        return trimmed;
+    }
+}

package/files/src/App/Program.cs

@@ -0,0 +1,26 @@
+using App.Core;
+using App.Features.Notes;
+using App.Shared;
+// @seed:anchor program-usings
+
+var builder = WebApplication.CreateBuilder(args);
+
+var settings = AppSettings.FromConfiguration(builder.Configuration);
+builder.Services.AddSingleton(settings);
+// @seed:anchor service-registration
+builder.Services.AddSingleton<INoteStore, MemoryNoteStore>();
+builder.Services.AddSingleton<NotesService>();
+
+builder.Services.AddOpenApi();
+
+var app = builder.Build();
+
+// @seed:anchor middleware
+
+app.MapOpenApi();
+app.MapGet("/health", () => Results.Ok(new { status = "ok" }));
+app.MapNotesEndpoints();
+
+app.Run();
+
+public partial class Program;

package/files/src/App/Properties/launchSettings.json

@@ -0,0 +1,12 @@
+{
+  "profiles": {
+    "http": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "applicationUrl": "http://localhost:5080",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

package/files/src/App/Shared/NotFoundException.cs

@@ -0,0 +1,9 @@
+namespace App.Shared;
+
+public sealed class NotFoundException : Exception
+{
+    public NotFoundException(string message)
+        : base(message)
+    {
+    }
+}

package/files/src/App/appsettings.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}

package/files/src/App/packages.lock.json

@@ -0,0 +1,21 @@
+{
+  "version": 1,
+  "dependencies": {
+    "net10.0": {
+      "Microsoft.AspNetCore.OpenApi": {
+        "type": "Direct",
+        "requested": "[10.0.15, )",
+        "resolved": "10.0.15",
+        "contentHash": "pptFDPMWyPDDtt68s/HsvLYeHJ0WQtntjyve6ztp/5MrLOEzdZvafYIyWSeErtexIGaB8XGYCnnUK8T/Vn4MwQ==",
+        "dependencies": {
+          "Microsoft.OpenApi": "[2.13.0, 3.0.0)"
+        }
+      },
+      "Microsoft.OpenApi": {
+        "type": "Transitive",
+        "resolved": "2.13.0",
+        "contentHash": "wavlgBYnn7uU/ZGhFHNl0UlDOlwz+6KRduKkqdCCbfxxANaQ1rmBpETVGdwXanAM6twQOxsvI3CBEGF4OScbeQ=="
+      }
+    }
+  }
+}

package/files/tests/App.Tests/ApiFactory.cs

@@ -0,0 +1,14 @@
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Mvc.Testing;
+// @seed:anchor factory-usings
+
+namespace App.Tests;
+
+public sealed class ApiFactory : WebApplicationFactory<Program>
+{
+    protected override void ConfigureWebHost(IWebHostBuilder builder)
+    {
+        builder.UseEnvironment("Development");
+        // @seed:anchor factory-configure
+    }
+}

package/files/tests/App.Tests/App.Tests.csproj

@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <RootNamespace>App.Tests</RootNamespace>
+    <AssemblyName>App.Tests</AssemblyName>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.4">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="10.0.15" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.4">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\App\App.csproj" />
+  </ItemGroup>
+
+</Project>

package/files/tests/App.Tests/GlobalUsings.cs

@@ -0,0 +1 @@
+global using Xunit;

package/files/tests/App.Tests/NotesApiTests.cs

@@ -0,0 +1,62 @@
+using System.Net;
+using System.Net.Http.Json;
+
+namespace App.Tests;
+
+public sealed class NotesApiTests : IClassFixture<ApiFactory>
+{
+    private readonly HttpClient _client;
+
+    public NotesApiTests(ApiFactory factory)
+    {
+        _client = factory.CreateClient();
+        // @seed:anchor test-client-headers
+    }
+
+    [Fact]
+    public async Task Health_is_ok()
+    {
+        var response = await _client.GetAsync("/health");
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        var body = await response.Content.ReadFromJsonAsync<Dictionary<string, string>>();
+        Assert.Equal("ok", body?["status"]);
+    }
+
+    [Fact]
+    public async Task Create_list_get_and_update_a_note()
+    {
+        var created = await _client.PostAsJsonAsync("/notes", new { title = "Hello", body = "World" });
+        Assert.Equal(HttpStatusCode.Created, created.StatusCode);
+        var note = await created.Content.ReadFromJsonAsync<NoteDto>();
+        Assert.NotNull(note);
+        Assert.Equal("Hello", note.Title);
+
+        var list = await _client.GetFromJsonAsync<List<NoteDto>>("/notes");
+        Assert.Contains(list!, item => item.Id == note.Id);
+
+        var got = await _client.GetFromJsonAsync<NoteDto>($"/notes/{note.Id}");
+        Assert.Equal("Hello", got!.Title);
+
+        var patched = await _client.PatchAsJsonAsync($"/notes/{note.Id}", new { title = "Hi" });
+        Assert.Equal(HttpStatusCode.OK, patched.StatusCode);
+        var updated = await patched.Content.ReadFromJsonAsync<NoteDto>();
+        Assert.Equal("Hi", updated!.Title);
+        Assert.Equal("World", updated.Body);
+    }
+
+    [Fact]
+    public async Task Missing_note_is_404()
+    {
+        var response = await _client.GetAsync("/notes/999");
+        Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
+    }
+
+    [Fact]
+    public async Task Blank_title_is_rejected()
+    {
+        var response = await _client.PostAsJsonAsync("/notes", new { title = "  ", body = "x" });
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+    }
+
+    private sealed record NoteDto(int Id, string Title, string? Body);
+}

package/files/tests/App.Tests/NotesServiceTests.cs

@@ -0,0 +1,36 @@
+using App.Features.Notes;
+using App.Shared;
+
+namespace App.Tests;
+
+public sealed class NotesServiceTests
+{
+    private static NotesService Service() => new(new MemoryNoteStore());
+
+    [Fact]
+    public async Task Create_then_get_returns_the_note()
+    {
+        var notes = Service();
+        var created = await notes.CreateAsync(new NoteCreate("Hello", "Body"));
+        var found = await notes.GetAsync(created.Id);
+        Assert.Equal("Hello", found.Title);
+        Assert.Equal("Body", found.Body);
+    }
+
+    [Fact]
+    public async Task Get_missing_note_throws()
+    {
+        var notes = Service();
+        await Assert.ThrowsAsync<NotFoundException>(() => notes.GetAsync(99));
+    }
+
+    [Fact]
+    public async Task Update_changes_only_given_fields()
+    {
+        var notes = Service();
+        var created = await notes.CreateAsync(new NoteCreate("Hello", "Body"));
+        var updated = await notes.UpdateAsync(created.Id, new NoteUpdate("Hi", null));
+        Assert.Equal("Hi", updated.Title);
+        Assert.Equal("Body", updated.Body);
+    }
+}