Bump to net9.0

Makefile

@@ -16,14 +16,17 @@ watch:
 test-push:
 	isn push src/isn/bin/Debug/isn.*.nupkg
 
-clean-%: src/%
+clean-src-%: src/%
+	rm -rf $^/bin $^/obj
+
+clean-test-%: test/%
 	rm -rf $^/bin $^/obj
 
 packs: pack-isn pack-isnd pack-isn.abst
 
-clean: clean-isnd clean-isn clean-isn.abst
+clean: clean-src-isnd clean-src-isn clean-src-isn.abst clean-test-isnd.tests clean-test-isn.tests
 
-TARGETFRAMEWORK=net8.0
+TARGETFRAMEWORK=net9.0
 
 server-update:
 	dotnet build -c Release src/isnd

README.md

@@ -33,7 +33,7 @@ La livraison initiale, aujourd'hui :
 
 ````bash
 sudo mkdir -p /srv/www/isnd
-sudo cp -a src/isnd/bin/Release/net8.0/publish/* /srv/www/isnd
+sudo cp -a src/isnd/bin/Release/net9.0/publish/* /srv/www/isnd
 sudo cp contrib/isnd.service /etc/systemd/system
 chown -R isn:isn /srv/www/isnd/
 sudo systemctl daemon-reload
@@ -81,13 +81,13 @@ Dans le détail, la séquence serait du style :
 ````bash
 # compiler tout
 dotnet build -c Release
-dotnet publish -c Release -f net8.0 src/isnd
+dotnet publish -c Release -f net9.0 src/isnd
 # MAJ du serveur
 sudo systemctl stop isnd
-sudo cp -a src/isnd/bin/Release/net8.0/publish/* /srv/www/isnd
+sudo cp -a src/isnd/bin/Release/net9.0/publish/* /srv/www/isnd
 sudo systemctl start isnd
 # MAJ du client
-sudo cp -a src/isn/bin/Release/net8.0/* /usr/local/lib/isn
+sudo cp -a src/isn/bin/Release/net9.0/* /usr/local/lib/isn
 sudo chown -R root:root /usr/local/lib/isn
 ````
 

dotnet-tools.json

@@ -9,13 +9,6 @@
       ],
       "rollForward": false
     },
-    "gitversion.tool": {
-      "version": "6.3.0",
-      "commands": [
-        "dotnet-gitversion"
-      ],
-      "rollForward": false
-    },
     "gitreleasemanager.tool": {
       "version": "0.20.0",
       "commands": [
@@ -29,13 +22,6 @@
         "wyam2"
       ],
       "rollForward": false
-    },
-    "dotnet-ef": {
-      "version": "8.0.7",
-      "commands": [
-        "dotnet-ef"
-      ],
-      "rollForward": false
     }
   }
 }

src/.vscode/launch.json

@@ -10,7 +10,7 @@
             "request": "launch",
             "preLaunchTask": "build",
             // If you have changed target frameworks, make sure to update the program path.
-            "program": "${workspaceFolder}/isnd/bin/Debug/net8.0/isnd.dll",
+            "program": "${workspaceFolder}/isnd/bin/Debug/net9.0/isnd.dll",
             "args": [],
             "cwd": "${workspaceFolder}/isnd",
             "stopAtEntry": false,

src/isn.abst/isn.abst.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>net7.0;net8.0</TargetFrameworks>
+    <TargetFrameworks>net7.0;net8.0;net9.0</TargetFrameworks>
     </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />

src/isn/isn.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFrameworks>net8.0</TargetFrameworks>
+    <TargetFrameworks>net9.0</TargetFrameworks>
     <RootNamespace>nuget_cli</RootNamespace>
     <UserSecretsId>45b74c62-05bc-4603-95b4-3e80ae2fdf50</UserSecretsId>
     
@@ -12,11 +12,11 @@
     <InformationalVersion>1.0.7+Branch.main.Sha.3695c1742965d93eba0ad851656cfaa3e44ba327</InformationalVersion>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="System.Security.Cryptography.Pkcs" Version="8.0.1" />
+    <PackageReference Include="System.Security.Cryptography.Pkcs" Version="9.0.6" />
-    <PackageReference Include="Mono.Options" Version="5.3.0" />
+    <PackageReference Include="Mono.Options" Version="6.12.0.148" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-    <PackageReference Include="unleash.client" Version="4.1.13" />
+    <PackageReference Include="unleash.client" Version="5.2.1" />
-    <PackageReference Include="GitVersion.MsBuild" Version="6.0.3" />
+    <PackageReference Include="GitVersion.MsBuild" Version="6.3.0" />
     <ProjectReference Include="../isn.abst/isn.abst.csproj" />
   </ItemGroup>
 </Project>

src/isnd/Controllers/AccountController.cs

@@ -16,7 +16,6 @@ using System.Threading.Tasks;
 
 namespace isnd.Controllers
 {
-    [AllowAnonymous]
     public class AccountController : Controller
     {
         private readonly IAuthenticationSchemeProvider _schemeProvider;
@@ -40,7 +39,7 @@ namespace isnd.Controllers
         /// <summary>
         /// Entry point into the login workflow
         /// </summary>
-        [HttpGet]
+        [HttpGet,AllowAnonymous]
         public async Task<IActionResult> Login(string returnUrl)
         {
             // build a model so we know what to show on the login page
@@ -59,7 +58,7 @@ namespace isnd.Controllers
         /// Handle postback from username/password login
         /// </summary>
         [HttpPost]
-        [ValidateAntiForgeryToken]
+        [ValidateAntiForgeryToken, AllowAnonymous]
         public async Task<IActionResult> Login(LoginInputModel model, string button)
         {
 
@@ -167,7 +166,7 @@ namespace isnd.Controllers
             return View("LoggedOut", vm);
         }
 
-        [HttpGet]
+        [HttpGet,AllowAnonymous]
         public IActionResult AccessDenied()
         {
             return new BadRequestObjectResult(403);

src/isnd/Controllers/ApiKeysController.cs

@@ -81,7 +81,7 @@ namespace isnd.Controllers
         public async Task<ActionResult> Delete(string id)
         {
             string userid =  User.FindFirstValue(ClaimTypes.NameIdentifier);
-            ApiKey key = await dbContext.ApiKeys.FirstOrDefaultAsync(k => k.Id == id && k.UserId == userid);
+            ApiKey key = await dbContext.ApiKey.FirstOrDefaultAsync(k => k.Id == id && k.UserId == userid);
             return View(new DeleteModel { ApiKey = key });
         }
 
@@ -89,13 +89,13 @@ namespace isnd.Controllers
         public async Task<ActionResult> Delete(DeleteModel model)
         {
             string userid =  User.FindFirstValue(ClaimTypes.NameIdentifier);
-            ApiKey key = dbContext.ApiKeys.FirstOrDefault(k => k.Id == model.ApiKey.Id && k.UserId == userid);
+            ApiKey key = dbContext.ApiKey.FirstOrDefault(k => k.Id == model.ApiKey.Id && k.UserId == userid);
             if (key == null)
             {
                 ModelState.AddModelError(null, "Key not found");
                 return View();
             }
-            _ = dbContext.ApiKeys.Remove(key);
+            _ = dbContext.ApiKey.Remove(key);
             _ = await dbContext.SaveChangesAsync();
             return View("Index", new IndexModel { ApiKey = GetUserKeys().ToList() } );
         }
@@ -103,7 +103,7 @@ namespace isnd.Controllers
         public async Task<ActionResult> Details(string id)
         {
             string userid =  User.FindFirstValue(ClaimTypes.NameIdentifier);
-            ApiKey key = await dbContext.ApiKeys.FirstOrDefaultAsync(k => k.Id == id && k.UserId == userid);
+            ApiKey key = await dbContext.ApiKey.FirstOrDefaultAsync(k => k.Id == id && k.UserId == userid);
                     if (key == null)
                     {
                         ModelState.AddModelError("id", "Key not found");
@@ -133,7 +133,7 @@ namespace isnd.Controllers
         {
             string userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
             
-            var apiKey = await dbContext.ApiKeys.SingleOrDefaultAsync(k => k.UserId == userId && k.Id == model.ApiKey.Id);
+            var apiKey = await dbContext.ApiKey.SingleOrDefaultAsync(k => k.UserId == userId && k.Id == model.ApiKey.Id);
             apiKey.Name = model.ApiKey.Name;
             apiKey.ValidityPeriodInDays = model.ApiKey.ValidityPeriodInDays;
             await dbContext.SaveChangesAsync();
@@ -142,7 +142,7 @@ namespace isnd.Controllers
 
         public IQueryable<ApiKey> GetUserKeys()
         {
-            return dbContext.ApiKeys.Include(k => k.User).Where(k => k.User.UserName == User.Identity.Name);
+            return dbContext.ApiKey.Include(k => k.User).Where(k => k.User.UserName == User.Identity.Name);
         }
     }
 }

src/isnd/Controllers/HomeController.cs

@@ -36,7 +36,7 @@ namespace isnd.Controllers
         public IActionResult Index()
         {
             return View(new HomeIndexViewModel{
-                PkgCount = _dbContext.Packages
+                PkgCount = _dbContext.Package
                 .Where(p => p.Versions.Count > 0)
                 .Count(),
                 APIUrl = _isndSettings.ExternalUrl + Constants.ApiVersionPrefix + ApiConfig.Index});

src/isnd/Controllers/PackageVersionController.cs

@@ -27,7 +27,7 @@ namespace isnd
         // GET: PackageVersion
         public async Task<IActionResult> Index(PackageVersionIndexViewModel model)
         {
-            var applicationDbContext = _context.PackageVersions.Include(p => p.Package)
+            var applicationDbContext = _context.PackageVersion.Include(p => p.Package)
             .Include(p => p.Package.Owner)
             .Include(p => p.Package.Versions)
             .Where(
@@ -41,7 +41,7 @@ namespace isnd
         public async Task<IActionResult> Mines(PackageVersionIndexViewModel model)
         {
             var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
-            var applicationDbContext = _context.PackageVersions
+            var applicationDbContext = _context.PackageVersion
                 .Include(p => p.Package).Where(
                 p => (string.IsNullOrEmpty(model.PackageId) || p.PackageId.StartsWith(model.PackageId))
                 && p.Package.OwnerId == userId);

src/isnd/Controllers/Packages/PackagesController.Put.cs

@@ -27,7 +27,7 @@ namespace isnd.Controllers
                 ViewData["files"] = files;
 
                 var clearKey = protector.Unprotect(apiKey);
-                var dbApiKey = dbContext.ApiKeys.SingleOrDefault(k => k.Id == clearKey);
+                var dbApiKey = dbContext.ApiKey.SingleOrDefault(k => k.Id == clearKey);
                 if (dbApiKey == null)
                 {
                     logger.LogError("403 : no api-key");

src/isnd/Controllers/Packages/PackagesController.WebViews.cs

@@ -56,7 +56,7 @@ namespace isnd.Controllers
                 return NotFound();
             }
 
-            var packageVersion = dbContext.PackageVersions
+            var packageVersion = dbContext.PackageVersion
              .Include(p=>p.LatestCommit)
                 .Include(p => p.Package)
                 .Where(m => m.PackageId == model.pkgid)
@@ -84,7 +84,7 @@ namespace isnd.Controllers
                 return NotFound();
             }
 
-            var packageVersion = await dbContext.PackageVersions.Include(p => p.Package)
+            var packageVersion = await dbContext.PackageVersion.Include(p => p.Package)
              .FirstOrDefaultAsync(m => m.PackageId == pkgid && m.FullString == version 
              && (pkgtype!=null && m.Type == pkgtype || m.Type != "Delete" ));
             if (packageVersion == null) return NotFound();
@@ -99,7 +99,7 @@ namespace isnd.Controllers
         public async Task<IActionResult> DeleteConfirmed(string pkgid, string version,
          string type)
         {
-            var packageVersion = await dbContext.PackageVersions
+            var packageVersion = await dbContext.PackageVersion
              .Include(pv => pv.Package)
              .Where(m => m.PackageId == pkgid
              && m.FullString == version && (type==null || m.Type == type))

src/isnd/Data/ApplicationDbContext.cs

@@ -37,27 +37,27 @@ namespace isnd.Data
         /// User API keys
         /// </summary>
         /// <value></value>
-        public DbSet<ApiKey> ApiKeys { get; set; }
+        public DbSet<ApiKey> ApiKey { get; set; }
 
         /// <summary>
         /// Packages
         /// </summary>
         /// <value></value>
-        public DbSet<Package> Packages { get; set; }
+        public DbSet<Package> Package { get; set; }
 
         /// <summary>
         /// Package Versions
         /// </summary>
         /// <value></value>
-        public DbSet<PackageVersion> PackageVersions { get; set; }
+        public DbSet<PackageVersion> PackageVersion { get; set; }
 
         /// <summary>
         /// Commits
         /// </summary>
         /// <value></value>
         public DbSet<Commit> Commits { get; set; }
-        public DbSet<Dependency> Dependencies { get; set; }
+        public DbSet<Dependency> Dependency { get; set; }
 
-        public DbSet<PackageDependencyGroup> PackageDependencyGroups { get; set; }
+        public DbSet<PackageDependencyGroup> PackageDependencyGroup { get; set; }
     }
 }

src/isnd/Migrations/20250707142411_net9.Designer.cs

@@ -0,0 +1,545 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using isnd.Data;
+
+#nullable disable
+
+namespace isnd.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20250707142411_net9")]
+    partial class net9
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.6")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("isnd.Data.ApiKeys.ApiKey", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("CreationDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ValidityPeriodInDays")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("ApiKey");
+                });
+
+            modelBuilder.Entity("isnd.Data.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("FullName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("isnd.Data.Dependency", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DependencyGroupId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Exclude")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("PackageId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Version")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DependencyGroupId");
+
+                    b.ToTable("Dependency");
+                });
+
+            modelBuilder.Entity("isnd.Data.PackageDependencyGroup", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PackageId")
+                        .IsRequired()
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("PackageVersionFullString")
+                        .IsRequired()
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("TargetFramework")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PackageId", "PackageVersionFullString");
+
+                    b.ToTable("PackageDependencyGroup");
+                });
+
+            modelBuilder.Entity("isnd.Data.PackageVersion", b =>
+                {
+                    b.Property<string>("PackageId")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("FullString")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Authors")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<long>("CommitNId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<bool>("IsPrerelease")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("Major")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Minor")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Patch")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Revision")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Type")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("PackageId", "FullString");
+
+                    b.HasIndex("CommitNId");
+
+                    b.ToTable("PackageVersion");
+                });
+
+            modelBuilder.Entity("isnd.Data.Packages.Commit", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Action")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("TimeStamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Commits");
+                });
+
+            modelBuilder.Entity("isnd.Data.Packages.Package", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<long>("CommitNId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("OwnerId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Public")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CommitNId");
+
+                    b.HasIndex("OwnerId");
+
+                    b.ToTable("Package");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("isnd.Data.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("isnd.Data.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("isnd.Data.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("isnd.Data.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("isnd.Data.ApiKeys.ApiKey", b =>
+                {
+                    b.HasOne("isnd.Data.ApplicationUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("isnd.Data.Dependency", b =>
+                {
+                    b.HasOne("isnd.Data.PackageDependencyGroup", "Group")
+                        .WithMany("Dependencies")
+                        .HasForeignKey("DependencyGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("isnd.Data.PackageDependencyGroup", b =>
+                {
+                    b.HasOne("isnd.Data.PackageVersion", "PackageVersion")
+                        .WithMany("DependencyGroups")
+                        .HasForeignKey("PackageId", "PackageVersionFullString")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PackageVersion");
+                });
+
+            modelBuilder.Entity("isnd.Data.PackageVersion", b =>
+                {
+                    b.HasOne("isnd.Data.Packages.Commit", "LatestCommit")
+                        .WithMany("Versions")
+                        .HasForeignKey("CommitNId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("isnd.Data.Packages.Package", "Package")
+                        .WithMany("Versions")
+                        .HasForeignKey("PackageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("LatestCommit");
+
+                    b.Navigation("Package");
+                });
+
+            modelBuilder.Entity("isnd.Data.Packages.Package", b =>
+                {
+                    b.HasOne("isnd.Data.Packages.Commit", "LatestCommit")
+                        .WithMany()
+                        .HasForeignKey("CommitNId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("isnd.Data.ApplicationUser", "Owner")
+                        .WithMany()
+                        .HasForeignKey("OwnerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("LatestCommit");
+
+                    b.Navigation("Owner");
+                });
+
+            modelBuilder.Entity("isnd.Data.PackageDependencyGroup", b =>
+                {
+                    b.Navigation("Dependencies");
+                });
+
+            modelBuilder.Entity("isnd.Data.PackageVersion", b =>
+                {
+                    b.Navigation("DependencyGroups");
+                });
+
+            modelBuilder.Entity("isnd.Data.Packages.Commit", b =>
+                {
+                    b.Navigation("Versions");
+                });
+
+            modelBuilder.Entity("isnd.Data.Packages.Package", b =>
+                {
+                    b.Navigation("Versions");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/isnd/Migrations/20250707142411_net9.cs

@@ -0,0 +1,376 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace isnd.Migrations
+{
+    /// <inheritdoc />
+    public partial class net9 : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_ApiKeys_AspNetUsers_UserId",
+                table: "ApiKeys");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Dependencies_PackageDependencyGroups_DependencyGroupId",
+                table: "Dependencies");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_PackageDependencyGroups_PackageVersions_PackageId_PackageVe~",
+                table: "PackageDependencyGroups");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Packages_AspNetUsers_OwnerId",
+                table: "Packages");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Packages_Commits_CommitNId",
+                table: "Packages");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_PackageVersions_Commits_CommitNId",
+                table: "PackageVersions");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_PackageVersions_Packages_PackageId",
+                table: "PackageVersions");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_PackageVersions",
+                table: "PackageVersions");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_Packages",
+                table: "Packages");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_PackageDependencyGroups",
+                table: "PackageDependencyGroups");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_Dependencies",
+                table: "Dependencies");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_ApiKeys",
+                table: "ApiKeys");
+
+            migrationBuilder.RenameTable(
+                name: "PackageVersions",
+                newName: "PackageVersion");
+
+            migrationBuilder.RenameTable(
+                name: "Packages",
+                newName: "Package");
+
+            migrationBuilder.RenameTable(
+                name: "PackageDependencyGroups",
+                newName: "PackageDependencyGroup");
+
+            migrationBuilder.RenameTable(
+                name: "Dependencies",
+                newName: "Dependency");
+
+            migrationBuilder.RenameTable(
+                name: "ApiKeys",
+                newName: "ApiKey");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_PackageVersions_CommitNId",
+                table: "PackageVersion",
+                newName: "IX_PackageVersion_CommitNId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Packages_OwnerId",
+                table: "Package",
+                newName: "IX_Package_OwnerId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Packages_CommitNId",
+                table: "Package",
+                newName: "IX_Package_CommitNId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_PackageDependencyGroups_PackageId_PackageVersionFullString",
+                table: "PackageDependencyGroup",
+                newName: "IX_PackageDependencyGroup_PackageId_PackageVersionFullString");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Dependencies_DependencyGroupId",
+                table: "Dependency",
+                newName: "IX_Dependency_DependencyGroupId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_ApiKeys_UserId",
+                table: "ApiKey",
+                newName: "IX_ApiKey_UserId");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_PackageVersion",
+                table: "PackageVersion",
+                columns: new[] { "PackageId", "FullString" });
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_Package",
+                table: "Package",
+                column: "Id");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_PackageDependencyGroup",
+                table: "PackageDependencyGroup",
+                column: "Id");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_Dependency",
+                table: "Dependency",
+                column: "Id");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_ApiKey",
+                table: "ApiKey",
+                column: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ApiKey_AspNetUsers_UserId",
+                table: "ApiKey",
+                column: "UserId",
+                principalTable: "AspNetUsers",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Dependency_PackageDependencyGroup_DependencyGroupId",
+                table: "Dependency",
+                column: "DependencyGroupId",
+                principalTable: "PackageDependencyGroup",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Package_AspNetUsers_OwnerId",
+                table: "Package",
+                column: "OwnerId",
+                principalTable: "AspNetUsers",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Package_Commits_CommitNId",
+                table: "Package",
+                column: "CommitNId",
+                principalTable: "Commits",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_PackageDependencyGroup_PackageVersion_PackageId_PackageVers~",
+                table: "PackageDependencyGroup",
+                columns: new[] { "PackageId", "PackageVersionFullString" },
+                principalTable: "PackageVersion",
+                principalColumns: new[] { "PackageId", "FullString" },
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_PackageVersion_Commits_CommitNId",
+                table: "PackageVersion",
+                column: "CommitNId",
+                principalTable: "Commits",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_PackageVersion_Package_PackageId",
+                table: "PackageVersion",
+                column: "PackageId",
+                principalTable: "Package",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_ApiKey_AspNetUsers_UserId",
+                table: "ApiKey");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Dependency_PackageDependencyGroup_DependencyGroupId",
+                table: "Dependency");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Package_AspNetUsers_OwnerId",
+                table: "Package");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Package_Commits_CommitNId",
+                table: "Package");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_PackageDependencyGroup_PackageVersion_PackageId_PackageVers~",
+                table: "PackageDependencyGroup");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_PackageVersion_Commits_CommitNId",
+                table: "PackageVersion");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_PackageVersion_Package_PackageId",
+                table: "PackageVersion");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_PackageVersion",
+                table: "PackageVersion");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_PackageDependencyGroup",
+                table: "PackageDependencyGroup");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_Package",
+                table: "Package");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_Dependency",
+                table: "Dependency");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_ApiKey",
+                table: "ApiKey");
+
+            migrationBuilder.RenameTable(
+                name: "PackageVersion",
+                newName: "PackageVersions");
+
+            migrationBuilder.RenameTable(
+                name: "PackageDependencyGroup",
+                newName: "PackageDependencyGroups");
+
+            migrationBuilder.RenameTable(
+                name: "Package",
+                newName: "Packages");
+
+            migrationBuilder.RenameTable(
+                name: "Dependency",
+                newName: "Dependencies");
+
+            migrationBuilder.RenameTable(
+                name: "ApiKey",
+                newName: "ApiKeys");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_PackageVersion_CommitNId",
+                table: "PackageVersions",
+                newName: "IX_PackageVersions_CommitNId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_PackageDependencyGroup_PackageId_PackageVersionFullString",
+                table: "PackageDependencyGroups",
+                newName: "IX_PackageDependencyGroups_PackageId_PackageVersionFullString");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Package_OwnerId",
+                table: "Packages",
+                newName: "IX_Packages_OwnerId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Package_CommitNId",
+                table: "Packages",
+                newName: "IX_Packages_CommitNId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Dependency_DependencyGroupId",
+                table: "Dependencies",
+                newName: "IX_Dependencies_DependencyGroupId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_ApiKey_UserId",
+                table: "ApiKeys",
+                newName: "IX_ApiKeys_UserId");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_PackageVersions",
+                table: "PackageVersions",
+                columns: new[] { "PackageId", "FullString" });
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_PackageDependencyGroups",
+                table: "PackageDependencyGroups",
+                column: "Id");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_Packages",
+                table: "Packages",
+                column: "Id");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_Dependencies",
+                table: "Dependencies",
+                column: "Id");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_ApiKeys",
+                table: "ApiKeys",
+                column: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ApiKeys_AspNetUsers_UserId",
+                table: "ApiKeys",
+                column: "UserId",
+                principalTable: "AspNetUsers",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Dependencies_PackageDependencyGroups_DependencyGroupId",
+                table: "Dependencies",
+                column: "DependencyGroupId",
+                principalTable: "PackageDependencyGroups",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_PackageDependencyGroups_PackageVersions_PackageId_PackageVe~",
+                table: "PackageDependencyGroups",
+                columns: new[] { "PackageId", "PackageVersionFullString" },
+                principalTable: "PackageVersions",
+                principalColumns: new[] { "PackageId", "FullString" },
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Packages_AspNetUsers_OwnerId",
+                table: "Packages",
+                column: "OwnerId",
+                principalTable: "AspNetUsers",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Packages_Commits_CommitNId",
+                table: "Packages",
+                column: "CommitNId",
+                principalTable: "Commits",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_PackageVersions_Commits_CommitNId",
+                table: "PackageVersions",
+                column: "CommitNId",
+                principalTable: "Commits",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_PackageVersions_Packages_PackageId",
+                table: "PackageVersions",
+                column: "PackageId",
+                principalTable: "Packages",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}

src/isnd/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -17,7 +17,7 @@ namespace isnd.Migrations
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "8.0.10")
+                .HasAnnotation("ProductVersion", "9.0.6")
                 .HasAnnotation("Relational:MaxIdentifierLength", 63);
 
             NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
@@ -177,7 +177,7 @@ namespace isnd.Migrations
 
                     b.HasIndex("UserId");
 
-                    b.ToTable("ApiKeys", (string)null);
+                    b.ToTable("ApiKey");
                 });
 
             modelBuilder.Entity("isnd.Data.ApplicationUser", b =>
@@ -272,7 +272,7 @@ namespace isnd.Migrations
 
                     b.HasIndex("DependencyGroupId");
 
-                    b.ToTable("Dependencies", (string)null);
+                    b.ToTable("Dependency");
                 });
 
             modelBuilder.Entity("isnd.Data.PackageDependencyGroup", b =>
@@ -297,7 +297,7 @@ namespace isnd.Migrations
 
                     b.HasIndex("PackageId", "PackageVersionFullString");
 
-                    b.ToTable("PackageDependencyGroups", (string)null);
+                    b.ToTable("PackageDependencyGroup");
                 });
 
             modelBuilder.Entity("isnd.Data.PackageVersion", b =>
@@ -344,7 +344,7 @@ namespace isnd.Migrations
 
                     b.HasIndex("CommitNId");
 
-                    b.ToTable("PackageVersions", (string)null);
+                    b.ToTable("PackageVersion");
                 });
 
             modelBuilder.Entity("isnd.Data.Packages.Commit", b =>
@@ -363,7 +363,7 @@ namespace isnd.Migrations
 
                     b.HasKey("Id");
 
-                    b.ToTable("Commits", (string)null);
+                    b.ToTable("Commits");
                 });
 
             modelBuilder.Entity("isnd.Data.Packages.Package", b =>
@@ -392,7 +392,7 @@ namespace isnd.Migrations
 
                     b.HasIndex("OwnerId");
 
-                    b.ToTable("Packages", (string)null);
+                    b.ToTable("Package");
                 });
 
             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>

src/isnd/Services/ApiKeyProvider.cs

@@ -36,13 +36,13 @@ public class ApiKeyProvider : IApiKeyProvider
             ValidityPeriodInDays = model.ValidityPeriodInDays
         };
 
-        _ = dbContext.ApiKeys.Add(newKey);
+        _ = dbContext.ApiKey.Add(newKey);
         _ = await dbContext.SaveChangesAsync();
         return newKey;
     }
 
     public IQueryable<ApiKey> GetUserKeys(string identityName)
     {
-        return dbContext.ApiKeys.Include(k => k.User).Where(k => k.User.UserName == identityName);
+        return dbContext.ApiKey.Include(k => k.User).Where(k => k.User.UserName == identityName);
     }
 }

src/isnd/Services/PackageManager.cs

@@ -107,7 +107,7 @@ namespace isnd.Services
              int skip, int take, bool prerelease = false,
              string packageType = null)
         {
-            var scope = dbContext.PackageVersions.Where(
+            var scope = dbContext.PackageVersion.Where(
                          v => v.PackageId.StartsWith(id)
                             && (prerelease || !v.IsPrerelease)
                             && (packageType == null || v.Type == packageType)
@@ -139,13 +139,13 @@ namespace isnd.Services
                 IQueryable<PackageVersion> results =
                 (parsedVersion != null) ?
                 (packageType == null) ?
-                     dbContext.PackageVersions.Where(
+                     dbContext.PackageVersion.Where(
                                 v => v.PackageId.ToLower() == id
                                     && (prerelease || !v.IsPrerelease)
                                     && (parsedVersion.CompareTo(new SemanticVersion(v.Major, v.Minor, v.Patch)) < 0)
                             )
                             :
-                     dbContext.PackageVersions.Where(
+                     dbContext.PackageVersion.Where(
                                 v => v.PackageId.ToLower() == id
                                     && (prerelease || !v.IsPrerelease)
                                     && (v.Type == packageType)
@@ -154,12 +154,12 @@ namespace isnd.Services
 
                 :
                 (packageType == null) ?
-                dbContext.PackageVersions.Where(
+                dbContext.PackageVersion.Where(
                                  v => v.PackageId.ToLower() == id
                                     && (prerelease || !v.IsPrerelease)
                              )
                 :
-                     dbContext.PackageVersions.Where(
+                     dbContext.PackageVersion.Where(
                                  v => v.PackageId.ToLower() == id
                                     && (prerelease || !v.IsPrerelease)
                                     && (v.Type == packageType)
@@ -199,7 +199,7 @@ namespace isnd.Services
             i = isndSettings.CatalogPageLen;
             foreach (var commit in scope)
             {
-                var validPkgs = (await dbContext.Packages
+                var validPkgs = (await dbContext.Package
                 .Include(po => po.Owner)
                 .Include(pkg => pkg.Versions)
                 .Include(pkg => pkg.LatestCommit)
@@ -237,7 +237,7 @@ namespace isnd.Services
                 TimeStamp = DateTimeOffset.Now.ToUniversalTime()
             };
             dbContext.Commits.Add(commit);
-            var pkg = await dbContext.PackageVersions.SingleOrDefaultAsync(
+            var pkg = await dbContext.PackageVersion.SingleOrDefaultAsync(
                 v => v.PackageId == pkgId &&
                 v.FullString == version &&
                 v.Type == type
@@ -246,7 +246,7 @@ namespace isnd.Services
             {
                 return new PackageDeletionReport { Deleted = false };
             }
-            dbContext.PackageVersions.Remove(pkg);
+            dbContext.PackageVersion.Remove(pkg);
             await dbContext.SaveChangesAsync();
             await UpdateCatalogForAsync(commit);
             return new PackageDeletionReport { Deleted = true, DeletedVersion = pkg };
@@ -255,7 +255,7 @@ namespace isnd.Services
         public async Task<PackageDetails> GetPackageDetailsAsync
         (string pkgId, string version, string type)
         {
-            var pkg = await dbContext.PackageVersions
+            var pkg = await dbContext.PackageVersion
             .Include(v => v.Package)
             .Include(v => v.Package.Owner)
             .Include(v => v.LatestCommit)
@@ -268,7 +268,7 @@ namespace isnd.Services
             if (pkg == null) return null;
             foreach (var g in pkg.DependencyGroups)
             {
-                g.Dependencies = dbContext.Dependencies.Where(d => d.DependencyGroupId == g.Id).ToList();
+                g.Dependencies = dbContext.Dependency.Where(d => d.DependencyGroupId == g.Id).ToList();
             }
             return new PackageDetails(pkg, apiBase);
         }
@@ -276,7 +276,7 @@ namespace isnd.Services
         public async Task<Data.Catalog.RegistrationLeaf> GetCatalogEntryAsync
         (string pkgId, string semver, string pkgType = "Dependency")
         {
-            var version = await dbContext.PackageVersions
+            var version = await dbContext.PackageVersion
             .Include(v => v.Package)
             .Include(v => v.Package.LatestCommit)
             .Include(v => v.Package.Owner)
@@ -290,7 +290,7 @@ namespace isnd.Services
             if (version == null) return null;
             foreach (var g in version.DependencyGroups)
             {
-                g.Dependencies = dbContext.Dependencies.Where(d => d.DependencyGroupId == g.Id).ToList();
+                g.Dependencies = dbContext.Dependency.Where(d => d.DependencyGroupId == g.Id).ToList();
             }
             return version.ToPackage(apiBase);
         }
@@ -298,13 +298,13 @@ namespace isnd.Services
         public async Task<PackageDeletionReport> UserAskForPackageDeletionAsync
         (string uid, string id, string lower, string type)
         {
-            PackageVersion packageVersion = await dbContext.PackageVersions
+            PackageVersion packageVersion = await dbContext.PackageVersion
              .Include(pv => pv.Package)
              .FirstOrDefaultAsync(m => m.PackageId == id
              && m.FullString == lower && (type == null || m.Type == type));
             if (packageVersion == null) return null;
             if (packageVersion.Package.OwnerId != uid) return null;
-            dbContext.PackageVersions.Remove(packageVersion);
+            dbContext.PackageVersion.Remove(packageVersion);
             await dbContext.SaveChangesAsync();
             return new PackageDeletionReport { Deleted = true, DeletedVersion = packageVersion };
         }
@@ -314,7 +314,7 @@ namespace isnd.Services
         (string pkgId, string semver, string pkgType, bool preRelease)
         {
             // PackageDependency
-            return dbContext.PackageVersions
+            return dbContext.PackageVersion
             .Include(v => v.Package)
             .Include(v => v.Package.Owner)
             .Include(v => v.Package.LatestCommit)
@@ -329,7 +329,7 @@ namespace isnd.Services
         }
         public PackageVersion GetPackage(string pkgId, string semver, string pkgType)
         {
-            return dbContext.PackageVersions
+            return dbContext.PackageVersion
             .Include(v => v.Package)
             .Include(v => v.LatestCommit)
             .Include(v => v.DependencyGroups.Last().Dependencies)
@@ -342,7 +342,7 @@ namespace isnd.Services
         {
             if (string.IsNullOrWhiteSpace(query.Query)) return null;
             query.Query = query.Query.ToLower();
-            var scope = await dbContext.PackageVersions
+            var scope = await dbContext.PackageVersion
             .Include(p => p.Package)
             .Include(p => p.Package.Owner)
             .Include(p => p.LatestCommit)
@@ -352,7 +352,7 @@ namespace isnd.Services
             string bid = $"{apiBase}{ApiConfig.Registration}";
             foreach (var version in scope)
             {
-                version.DependencyGroups = dbContext.PackageDependencyGroups.Include(d => d.Dependencies)
+                version.DependencyGroups = dbContext.PackageDependencyGroup.Include(d => d.Dependencies)
                     .Where(d => d.PackageId == version.PackageId && d.PackageVersionFullString == version.FullString)
                     .ToList();
                 version.LatestCommit = dbContext.Commits.Single(c => c.Id == version.CommitNId);
@@ -371,7 +371,7 @@ namespace isnd.Services
                 return new PackageSearchResult(apiBase);
             }
 
-            var allPackages = dbContext.Packages
+            var allPackages = dbContext.Package
             .Include(g => g.Versions).OrderBy(v => v.CommitNId)
             .Where(d => d.Id.StartsWith(query.Query)
              && (query.Prerelease || d.Versions.Any(v => !v.IsPrerelease)))
@@ -386,7 +386,7 @@ namespace isnd.Services
             foreach (var package in packages)
                 foreach (var version in package.Versions)
                 {
-                    version.DependencyGroups = dbContext.PackageDependencyGroups.Include(d => d.Dependencies)
+                    version.DependencyGroups = dbContext.PackageDependencyGroup.Include(d => d.Dependencies)
                     .Where(d => d.PackageVersionFullString == version.FullString && d.PackageId == version.PackageId)
 
                     .ToList();
@@ -447,7 +447,7 @@ namespace isnd.Services
                     var authors = xMetaElements.FirstOrDefault(x => x.Name.LocalName == "authors")?.Value;
 
                     var packageIdPathInfo = new DirectoryInfo(packageIdPath);
-                    Data.Packages.Package pkg = dbContext.Packages.SingleOrDefault(p => p.Id == pkgId);
+                    Data.Packages.Package pkg = dbContext.Package.SingleOrDefault(p => p.Id == pkgId);
                     Commit commit = new Commit
                     {
                         Action = PackageAction.PublishPackage,
@@ -466,7 +466,7 @@ namespace isnd.Services
                             OwnerId = ownerId,
                             Public = true,
                         };
-                        dbContext.Packages.Add(pkg);
+                        dbContext.Package.Add(pkg);
                     }
                     pkg.LatestCommit = commit;
 
@@ -485,16 +485,16 @@ namespace isnd.Services
                     }
 
                     string fullStringVersion = nugetVersion.ToFullString();
-                    var pkgVersions = dbContext.PackageVersions.Where
+                    var pkgVersions = dbContext.PackageVersion.Where
                     (v => v.PackageId == pkg.Id && v.FullString == fullStringVersion);
                     if (pkgVersions.Count() > 0)
                     {
                         foreach (var v in pkgVersions.ToArray())
-                            dbContext.PackageVersions.Remove(v);
+                            dbContext.PackageVersion.Remove(v);
                     }
                     string versionFullString = nugetVersion.ToFullString();
 
-                    dbContext.PackageVersions.Add
+                    dbContext.PackageVersion.Add
                     (version = new PackageVersion
                     {
                         Package = pkg,
@@ -512,11 +512,11 @@ namespace isnd.Services
 
                     dbContext.Commits.Add(commit);
 
-                    foreach (var group in dbContext.PackageDependencyGroups.Include(g => g.PackageVersion)
+                    foreach (var group in dbContext.PackageDependencyGroup.Include(g => g.PackageVersion)
                     .Where(x => x.PackageId == pkgId && x.PackageVersionFullString == versionFullString)
                     .ToList())
                     {
-                        dbContext.PackageDependencyGroups.Remove(group);
+                        dbContext.PackageDependencyGroup.Remove(group);
                     }
                     version.DependencyGroups = new List<PackageDependencyGroup>();
                     foreach (var framework in frameWorks)
@@ -535,7 +535,7 @@ namespace isnd.Services
                         };
 
                         version.DependencyGroups.Add(group);
-                        dbContext.PackageDependencyGroups.Add(group);
+                        dbContext.PackageDependencyGroup.Add(group);
 
                     }
                     await dbContext.SaveChangesAsync();

src/isnd/Startup.cs

@@ -19,6 +19,7 @@ using System;
 using System.IO;
 using Microsoft.AspNetCore.HttpOverrides;
 using Microsoft.AspNetCore.DataProtection;
+using Microsoft.EntityFrameworkCore.Diagnostics;
 
 namespace isnd
 {
@@ -51,11 +52,11 @@ namespace isnd
             .Configure<AdminStartupList>(adminStartupListConf)
             .Configure<MigrationsEndPointOptions>(o => o.Path = "~/migrate")
             .AddDbContext<ApplicationDbContext>(options =>
-                options.UseNpgsql(
+                options.UseNpgsql(Configuration.GetConnectionString("DefaultConnection")))
-                    Configuration.GetConnectionString("DefaultConnection")))
             .AddIdentity<ApplicationUser, IdentityRole>()
             .AddRoles<IdentityRole>()
-            .AddEntityFrameworkStores<ApplicationDbContext>()
+            .AddEntityFrameworkStores<ApplicationDbContext>(
+             )
             .AddSignInManager()
             .AddDefaultUI()
             .AddDefaultTokenProviders();

src/isnd/isnd.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <UserSecretsId>85fd766d-5d23-4476-aed1-463b2942e86a</UserSecretsId>
     <IsPackable>true</IsPackable>
     <PackageLicenseExpression>WTFPL</PackageLicenseExpression>
@@ -13,33 +13,33 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="8.0.10" />
+    <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="9.0.6" />
-    <PackageReference Include="Microsoft.AspNetCore.Identity.UI" Version="8.0.10" />
+    <PackageReference Include="Microsoft.AspNetCore.Identity.UI" Version="9.0.6" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.10">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="9.0.6" />
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="9.0.0" />
-      <PrivateAssets>all</PrivateAssets>
-    </PackageReference>
-    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="8.0.10" />
-    <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="8.0.6" />
   </ItemGroup>
   
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore" Version="8.0.10" />
+    <PackageReference Include="Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore" Version="9.0.6" />
-    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="8.0.10" IncludeAssets="All" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="9.0.4" IncludeAssets="All" />
-    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="8.0.10" />
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="9.0.6" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="8.0.10">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="9.0.6">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-
+<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.6">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <Publish>true</Publish>
+    </PackageReference>
     <PackageReference Include="NuGet.Packaging.Core" Version="6.9.1" />
-    <PackageReference Include="MailKit" Version="4.8.0" />
+    <PackageReference Include="MailKit" Version="4.13.0" />
-    <PackageReference Include="GitVersion.MsBuild" Version="6.0.3">
+    <PackageReference Include="GitVersion.MsBuild" Version="6.3.0">
       <PrivateAssets>All</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="System.Security.Cryptography.Pkcs" Version="8.0.1" />
+    <PackageReference Include="System.Security.Cryptography.Pkcs" Version="9.0.6" />
-    <PackageReference Include="Microsoft.AspNetCore.Antiforgery" Version="2.2.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Antiforgery" Version="2.3.0" />
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="8.0.10" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="9.0.6" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="../isn.abst/isn.abst.csproj" />

test/data/test-isn/test-isn.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <RootNamespace>test_isn</RootNamespace>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>

test/isn.tests/isn.tests.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>net8.0</TargetFrameworks>
+    <TargetFrameworks>net9.0</TargetFrameworks>
     <IsPackable>false</IsPackable>
     <NoWarn>NETSDK1138</NoWarn>
     <AssemblyVersion>1.0.7.0</AssemblyVersion>
@@ -9,11 +9,11 @@
     <Version>1.0.7</Version>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
-    <PackageReference Include="xunit" Version="2.9.2" />
+    <PackageReference Include="xunit" Version="2.9.3" />
     <PackageReference Include="xunit.abstractions" Version="2.0.3" />
-    <PackageReference Include="xunit.runner.reporters" Version="2.9.2" />
+    <PackageReference Include="xunit.runner.reporters" Version="2.9.3" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.1" />
 
     <PackageToolReference Include="xunit.runner.console" Version="2.5.7" PrivateAssets="All" />
   </ItemGroup>

test/isnd.tests/WebServerFixture.cs

@@ -87,7 +87,7 @@ namespace isnd.tests
             TestingUserName = "Tester";
             TestingUser = dbContext.Users.FirstOrDefault(u => u.UserName == TestingUserName);
             EnsureUser(TestingUserName);
-            var testKey = dbContext.ApiKeys.FirstOrDefault(k => k.UserId == TestingUser.Id);
+            var testKey = dbContext.ApiKey.FirstOrDefault(k => k.UserId == TestingUser.Id);
             if (testKey == null)
             {
                 var keyProvider = scope.ServiceProvider.GetService<IApiKeyProvider>();