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

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# @yosr-ai/template-dotnet
+
+## 0.2.6
+
+### Patch Changes
+
+- 2373b62: Fix Spring create success next-steps (`mvn spring-boot:run` instead of `pnpm dev`) and add download links when the JDK or Maven is missing (same clarity as .NET’s https://dot.net/download).
+
+## 0.2.5
+
+### Patch Changes
+
+- 63badc9: Add the ASP.NET Core API template (`--template dotnet`, ADR 0026): .NET 10 LTS, minimal API, xUnit + WebApplicationFactory, locked NuGet restore with committed `packages.lock.json` and `global.json`, notes API, database none/Postgres (EF Core + Npgsql), API-key auth, multi-stage non-root Docker. Engine gains `engines.dotnet` / package manager `dotnet` (and the same shape for later `engines.java` / `maven`). Joins the Yosr Seed fixed group.
+- 11f252b: Add Spring Boot template-spring (ADR 0027): Java 25, Maven locked resolve, optional JPA Postgres.
+
+## 0.2.4
+
+### Minor Changes
+
+- First npm release of the ASP.NET Core API template (`--template dotnet`, ADR 0026): .NET 10 LTS, minimal API, xUnit + WebApplicationFactory, locked NuGet restore, `global.json`, notes API, database none/Postgres (EF Core + Npgsql), API-key auth, Docker (multi-stage non-root). Joins the Yosr Seed fixed group.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wael Zohny / Yosr AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,15 @@
-# Temporary Holding Version
+# @yosr-ai/template-dotnet
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Yosr Seed template for an API-only ASP.NET Core service on .NET 10 (ADR 0026). Create with:
+
+```bash
+npx create-yosr-seed@latest my-api --template dotnet
+```
+
+Published MIT. Exact-pinned by the `yosr-seed` CLI.
+
+## Bugs and feedback
+
+Email **wzohny@gmail.com**. The source repository is private, so there is no public issue tracker.
+
+Site: [seed.yosr.ai](https://seed.yosr.ai)

package/features/auth-api-key/files/src/App/Core/ApiKeyMiddleware.cs

@@ -0,0 +1,33 @@
+namespace App.Core;
+
+public sealed class ApiKeyMiddleware(RequestDelegate next)
+{
+    public const string HeaderName = "X-API-Key";
+
+    public async Task InvokeAsync(HttpContext context, AppSettings settings)
+    {
+        if (context.Request.Path.StartsWithSegments("/health") ||
+            context.Request.Path.StartsWithSegments("/openapi"))
+        {
+            await next(context);
+            return;
+        }
+
+        if (string.IsNullOrEmpty(settings.ApiKey))
+        {
+            context.Response.StatusCode = StatusCodes.Status500InternalServerError;
+            await context.Response.WriteAsJsonAsync(new { detail = "API_KEY is not configured." });
+            return;
+        }
+
+        if (!context.Request.Headers.TryGetValue(HeaderName, out var provided) ||
+            !string.Equals(provided.ToString(), settings.ApiKey, StringComparison.Ordinal))
+        {
+            context.Response.StatusCode = StatusCodes.Status401Unauthorized;
+            await context.Response.WriteAsJsonAsync(new { detail = "Invalid or missing API key." });
+            return;
+        }
+
+        await next(context);
+    }
+}

package/features/auth-api-key/files/tests/App.Tests/ApiKeyTests.cs

@@ -0,0 +1,27 @@
+using System.Net;
+
+namespace App.Tests;
+
+public sealed class ApiKeyTests : IClassFixture<ApiFactory>
+{
+    private readonly HttpClient _client;
+
+    public ApiKeyTests(ApiFactory factory)
+    {
+        _client = factory.CreateClient();
+    }
+
+    [Fact]
+    public async Task Missing_api_key_is_unauthorized()
+    {
+        var response = await _client.GetAsync("/notes");
+        Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
+    }
+
+    [Fact]
+    public async Task Health_stays_open()
+    {
+        var response = await _client.GetAsync("/health");
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+    }
+}

package/features/data-efcore/files/src/App/App.csproj

@@ -0,0 +1,16 @@
+<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" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="10.0.5" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="10.0.5" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="10.0.0" />
+  </ItemGroup>
+
+</Project>

package/features/data-efcore/files/src/App/Core/AppDbContext.cs

@@ -0,0 +1,22 @@
+using App.Features.Notes;
+using Microsoft.EntityFrameworkCore;
+
+namespace App.Core;
+
+public sealed class AppDbContext(DbContextOptions<AppDbContext> options) : DbContext(options)
+{
+    public DbSet<NoteEntity> Notes => Set<NoteEntity>();
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        modelBuilder.Entity<NoteEntity>(entity =>
+        {
+            entity.ToTable("notes");
+            entity.HasKey(note => note.Id);
+            entity.Property(note => note.Title).HasMaxLength(200).IsRequired();
+            entity.Property(note => note.Body);
+            entity.Property(note => note.CreatedAt).IsRequired();
+            entity.Property(note => note.UpdatedAt);
+        });
+    }
+}

package/features/data-efcore/files/src/App/Core/AppSettings.cs

@@ -0,0 +1,30 @@
+namespace App.Core;
+
+public sealed class AppSettings
+{
+    public required string AppName { get; init; }
+
+    public IReadOnlyList<string> CorsOrigins { get; init; } = ["http://localhost:5173"];
+
+    public required string DatabaseUrl { get; init; }
+
+    // @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),
+            DatabaseUrl = configuration["DATABASE_URL"]
+                ?? Environment.GetEnvironmentVariable("DATABASE_URL")
+                ?? "__seed_databaseUrl__",
+            // @seed:anchor settings-values
+        };
+    }
+}

package/features/data-efcore/files/src/App/Features/Notes/EfNoteStore.cs

@@ -0,0 +1,46 @@
+using App.Core;
+using Microsoft.EntityFrameworkCore;
+
+namespace App.Features.Notes;
+
+public sealed class EfNoteStore(AppDbContext db) : INoteStore
+{
+    public async Task<IReadOnlyList<Note>> ListAsync(CancellationToken cancellationToken = default)
+    {
+        var rows = await db.Notes.AsNoTracking()
+            .OrderByDescending(note => note.Id)
+            .ToListAsync(cancellationToken);
+        return rows.Select(row => row.ToNote()).ToList();
+    }
+
+    public async Task<Note?> GetAsync(int id, CancellationToken cancellationToken = default)
+    {
+        var row = await db.Notes.AsNoTracking()
+            .FirstOrDefaultAsync(note => note.Id == id, cancellationToken);
+        return row?.ToNote();
+    }
+
+    public async Task<Note> AddAsync(string title, string? body, CancellationToken cancellationToken = default)
+    {
+        var row = new NoteEntity
+        {
+            Title = title,
+            Body = body,
+            CreatedAt = DateTimeOffset.UtcNow,
+        };
+        db.Notes.Add(row);
+        await db.SaveChangesAsync(cancellationToken);
+        return row.ToNote();
+    }
+
+    public async Task<Note?> UpdateAsync(int id, string? title, string? body, CancellationToken cancellationToken = default)
+    {
+        var row = await db.Notes.FirstOrDefaultAsync(note => note.Id == id, cancellationToken);
+        if (row is null) return null;
+        if (title is not null) row.Title = title;
+        if (body is not null) row.Body = body;
+        row.UpdatedAt = DateTimeOffset.UtcNow;
+        await db.SaveChangesAsync(cancellationToken);
+        return row.ToNote();
+    }
+}

package/features/data-efcore/files/src/App/Features/Notes/NoteEntity.cs

@@ -0,0 +1,24 @@
+namespace App.Features.Notes;
+
+public sealed class NoteEntity
+{
+    public int Id { get; set; }
+
+    public required string Title { get; set; }
+
+    public string? Body { get; set; }
+
+    public DateTimeOffset CreatedAt { get; set; }
+
+    public DateTimeOffset? UpdatedAt { get; set; }
+
+    public Note ToNote() =>
+        new()
+        {
+            Id = Id,
+            Title = Title,
+            Body = Body,
+            CreatedAt = CreatedAt,
+            UpdatedAt = UpdatedAt,
+        };
+}

package/features/data-efcore/files/src/App/Program.cs

@@ -0,0 +1,46 @@
+using App.Core;
+using App.Features.Notes;
+using App.Shared;
+using Microsoft.EntityFrameworkCore;
+// @seed:anchor program-usings
+
+var builder = WebApplication.CreateBuilder(args);
+
+var settings = AppSettings.FromConfiguration(builder.Configuration);
+builder.Services.AddSingleton(settings);
+builder.Services.AddDbContext<AppDbContext>(options =>
+    options.UseNpgsql(ToNpgsql(settings.DatabaseUrl)));
+builder.Services.AddScoped<INoteStore, EfNoteStore>();
+builder.Services.AddScoped<NotesService>();
+// @seed:anchor service-registration
+
+builder.Services.AddOpenApi();
+
+var app = builder.Build();
+
+// @seed:anchor middleware
+
+app.MapOpenApi();
+app.MapGet("/health", () => Results.Ok(new { status = "ok" }));
+app.MapNotesEndpoints();
+
+app.Run();
+
+static string ToNpgsql(string url)
+{
+    if (url.StartsWith("postgresql://", StringComparison.OrdinalIgnoreCase) ||
+        url.StartsWith("postgres://", StringComparison.OrdinalIgnoreCase))
+    {
+        var uri = new Uri(url);
+        var user = Uri.UnescapeDataString(uri.UserInfo.Split(':')[0]);
+        var pass = uri.UserInfo.Contains(':')
+            ? Uri.UnescapeDataString(uri.UserInfo.Split(':')[1])
+            : string.Empty;
+        var db = uri.AbsolutePath.Trim('/');
+        return $"Host={uri.Host};Port={(uri.Port > 0 ? uri.Port : 5432)};Database={db};Username={user};Password={pass}";
+    }
+
+    return url;
+}
+
+public partial class Program;

package/features/data-efcore/files/src/App/packages.lock.json

@@ -0,0 +1,74 @@
+{
+  "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.EntityFrameworkCore": {
+        "type": "Direct",
+        "requested": "[10.0.5, )",
+        "resolved": "10.0.5",
+        "contentHash": "9tNBmK3EpYVGRQLiqP+bqK2m+TD0Gv//4vCzR7ZOgl4FWzCFyOpYdIVka13M4kcBdPdSJcs3wbHr3rmzOqbIMA==",
+        "dependencies": {
+          "Microsoft.EntityFrameworkCore.Abstractions": "10.0.5",
+          "Microsoft.EntityFrameworkCore.Analyzers": "10.0.5"
+        }
+      },
+      "Microsoft.EntityFrameworkCore.InMemory": {
+        "type": "Direct",
+        "requested": "[10.0.5, )",
+        "resolved": "10.0.5",
+        "contentHash": "zz4THzlDOrJ7fKU2YUOzQFs2LJ9DgOSr5xFXcDdoD59el73MTQLtQQOAJxQ94F4XDegyL9+2sePSQGdcU25ZxQ==",
+        "dependencies": {
+          "Microsoft.EntityFrameworkCore": "10.0.5"
+        }
+      },
+      "Npgsql.EntityFrameworkCore.PostgreSQL": {
+        "type": "Direct",
+        "requested": "[10.0.0, )",
+        "resolved": "10.0.0",
+        "contentHash": "E2+uSWxSB8LdsUVwPaqRWOcGOP92biry2JEwc0KJMdLJF+aZdczeIdEXVwEyv4nSVMQJH0o8tLhyAMiR6VF0lw==",
+        "dependencies": {
+          "Microsoft.EntityFrameworkCore": "[10.0.0, 11.0.0)",
+          "Microsoft.EntityFrameworkCore.Relational": "[10.0.0, 11.0.0)",
+          "Npgsql": "10.0.0"
+        }
+      },
+      "Microsoft.EntityFrameworkCore.Abstractions": {
+        "type": "Transitive",
+        "resolved": "10.0.5",
+        "contentHash": "32c58Rnm47Qvhimawf67KO9PytgPz3QoWye7Abapt0Yocw/JnzMiSNj/pRoIKyn8Jxypkv86zxKD4Q/zNTc0Ag=="
+      },
+      "Microsoft.EntityFrameworkCore.Analyzers": {
+        "type": "Transitive",
+        "resolved": "10.0.5",
+        "contentHash": "ipC4u1VojgEfoIZhtbS2Sx5IluJTP/Jf1hz3yGsxGBgSukYY/CquI6rAjxn5H58CZgVn36qcuPPtNMwZ0AUzMg=="
+      },
+      "Microsoft.EntityFrameworkCore.Relational": {
+        "type": "Transitive",
+        "resolved": "10.0.0",
+        "contentHash": "A3MX1ee7RDxWCUdx/KqP+74fbksz0UIhkVZh56YHvbPkEKsffCXgHU3LGkRDwqR/MrBNWLCWC/IVX79tzM30ZA==",
+        "dependencies": {
+          "Microsoft.EntityFrameworkCore": "10.0.0"
+        }
+      },
+      "Microsoft.OpenApi": {
+        "type": "Transitive",
+        "resolved": "2.13.0",
+        "contentHash": "wavlgBYnn7uU/ZGhFHNl0UlDOlwz+6KRduKkqdCCbfxxANaQ1rmBpETVGdwXanAM6twQOxsvI3CBEGF4OScbeQ=="
+      },
+      "Npgsql": {
+        "type": "Transitive",
+        "resolved": "10.0.0",
+        "contentHash": "xZAYhPOU2rUIFpV48xsqhCx9vXs6Y+0jX2LCoSEfDFYMw9jtAOUk3iQsCnDLrFIv9NT3JGMihn7nnuZsPKqJmA=="
+      }
+    }
+  }
+}

package/features/data-efcore/files/tests/App.Tests/ApiFactory.cs

@@ -0,0 +1,70 @@
+using App.Core;
+using App.Features.Notes;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+// @seed:anchor factory-usings
+
+namespace App.Tests;
+
+/// <summary>
+/// In-process HTTP tests. Uses EnsureCreated against DATABASE_URL when set
+/// (gate throwaway Postgres); otherwise an in-memory EF provider. Gate never
+/// runs <c>dotnet ef database update</c>.
+/// </summary>
+public sealed class ApiFactory : WebApplicationFactory<Program>
+{
+    protected override void ConfigureWebHost(IWebHostBuilder builder)
+    {
+        builder.UseEnvironment("Development");
+        builder.ConfigureServices(services =>
+        {
+            services.RemoveAll(typeof(DbContextOptions<AppDbContext>));
+            services.RemoveAll(typeof(AppDbContext));
+            services.RemoveAll(typeof(INoteStore));
+
+            var databaseUrl = Environment.GetEnvironmentVariable("DATABASE_URL");
+            if (!string.IsNullOrWhiteSpace(databaseUrl))
+            {
+                services.AddDbContext<AppDbContext>(options =>
+                    options.UseNpgsql(ToNpgsql(databaseUrl)));
+            }
+            else
+            {
+                var name = $"yosr-tests-{Guid.NewGuid():N}";
+                services.AddDbContext<AppDbContext>(options =>
+                    options.UseInMemoryDatabase(name));
+            }
+
+            services.AddScoped<INoteStore, EfNoteStore>();
+        });
+        // @seed:anchor factory-configure
+    }
+
+    protected override void ConfigureClient(HttpClient client)
+    {
+        using var scope = Services.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
+        db.Database.EnsureCreated();
+        base.ConfigureClient(client);
+    }
+
+    private static string ToNpgsql(string url)
+    {
+        if (url.StartsWith("postgresql://", StringComparison.OrdinalIgnoreCase) ||
+            url.StartsWith("postgres://", StringComparison.OrdinalIgnoreCase))
+        {
+            var uri = new Uri(url);
+            var user = Uri.UnescapeDataString(uri.UserInfo.Split(':')[0]);
+            var pass = uri.UserInfo.Contains(':')
+                ? Uri.UnescapeDataString(uri.UserInfo.Split(':')[1])
+                : string.Empty;
+            var db = uri.AbsolutePath.Trim('/');
+            return $"Host={uri.Host};Port={(uri.Port > 0 ? uri.Port : 5432)};Database={db};Username={user};Password={pass}";
+        }
+
+        return url;
+    }
+}