MaBibli 1.0.0

Gestion de bibliothèque personnelle auto-hébergée : catalogue, prêts,
scan de code-barres, consultation hors-ligne.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

MaBibli.Api/Program.cs

@@ -0,0 +1,152 @@
+using MaBibli.Api.Data;
+using MaBibli.Api.Endpoints;
+using MaBibli.Api.Services.Catalogue;
+using MaBibli.Api.Services.Couvertures;
+using MaBibli.Api.Services.Identite;
+using MaBibli.Api.Services.Isbn;
+using MaBibli.Api.Services.Prets;
+using MaBibli.Api.Services.Revues;
+using MaBibli.Api.Services.Series;
+using MaBibli.Api.Services.Souhaits;
+using Microsoft.EntityFrameworkCore;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.AddOpenApi();
+
+builder.Services.AddDbContext<MaBibliDbContext>(options =>
+    options.UseSqlite(builder.Configuration.GetConnectionString("MaBibli")));
+
+builder.Services.AddScoped<IServiceAuteurs, ServiceAuteurs>();
+builder.Services.AddScoped<IServiceCatalogue, ServiceCatalogue>();
+builder.Services.AddScoped<IServicePrets, ServicePrets>();
+builder.Services.AddScoped<IServiceSouhaits, ServiceSouhaits>();
+builder.Services.AddScoped<IServiceRevuesSouhaitees, ServiceRevuesSouhaitees>();
+builder.Services.AddScoped<IServiceBibliographie, ServiceBibliographie>();
+builder.Services.AddScoped<IServiceSeries, ServiceSeries>();
+builder.Services.AddScoped<IServiceRevues, ServiceRevues>();
+
+// Identité : lue dans les en-têtes injectés par SSOwat, avec repli sur un utilisateur simulé
+// configuré en développement (il n'y a pas de portail YunoHost en local).
+builder.Services.AddHttpContextAccessor();
+builder.Services.Configure<OptionsIdentite>(builder.Configuration.GetSection(OptionsIdentite.Section));
+builder.Services.AddScoped<IFournisseurUtilisateur, FournisseurUtilisateurSsowat>();
+
+// Lookup ISBN : clients typés via IHttpClientFactory (pas de HttpClient instancié à la main).
+// Timeout court : une source lente ne doit pas bloquer la cascade, l'appelant bascule sur la suivante.
+var timeoutSources = TimeSpan.FromSeconds(10);
+
+// ⚠️ Le relais de couvertures a son PROPRE délai, et bien plus long. Ce n'est pas une largesse :
+// les deux appels n'ont pas le même témoin. Un lookup ISBN fait patienter quelqu'un devant un
+// formulaire — d'où les 10 s ci-dessus, et la bascule sur la source suivante. Le relais, lui,
+// remplit un cache en tâche de fond : personne n'attend derrière, et abandonner ne fait pas
+// gagner du temps, cela perd la couverture.
+//
+// Mesuré le 2026-08-21 : les couvertures OpenLibrary aboutissent sur `archive.org`, qui les
+// EXTRAIT D'UNE ARCHIVE ZIP à la volée et met 5 à 15 s. À 10 s, le relais répondait 404 une fois
+// sur trois — indistinguable, pour l'appelant, d'une URL inconnue. L'image n'était alors jamais
+// mise en cache, et le client rejouait CORS puis relais à CHAQUE affichage : exactement le
+// défaut que ce relais existe pour corriger.
+var timeoutRelaisCouvertures = TimeSpan.FromSeconds(30);
+
+builder.Services.AddHttpClient<IBnfClient, BnfClient>(http =>
+{
+    http.BaseAddress = new Uri(BnfClient.UrlBase);
+    http.Timeout = timeoutSources;
+    http.DefaultRequestHeaders.UserAgent.ParseAdd("MaBibli/0.1 (bibliotheque personnelle auto-hebergee)");
+});
+
+builder.Services.AddHttpClient<IOpenLibraryClient, OpenLibraryClient>(http =>
+{
+    http.BaseAddress = new Uri(OpenLibraryClient.UrlBase);
+    http.Timeout = timeoutSources;
+    http.DefaultRequestHeaders.UserAgent.ParseAdd("MaBibli/0.1 (bibliotheque personnelle auto-hebergee)");
+});
+
+builder.Services.AddScoped<IIsbnLookupService, IsbnLookupService>();
+
+// Relais de couvertures : rend une image de MÊME ORIGINE, seule façon de la mettre en cache
+// hors-ligne quand son hébergeur n'envoie pas d'en-tête CORS (le formulaire livre accepte
+// n'importe quelle URL de couverture).
+//
+// ⚠️ Les deux réglages du handler ne sont PAS des détails de confort :
+//   - ConnectCallback n'ouvre la socket que vers une adresse publiquement routable, ce qui
+//     ferme le SSRF y compris par DNS rebinding (voir GardeAdresses) ;
+//   - les redirections sont SUIVIES, mais bornées à 3. Elles avaient d'abord été coupées, à
+//     tort : `covers.openlibrary.org` répond 302 (mesuré), et beaucoup de CDN font de même —
+//     les couper refusait donc les couvertures les plus courantes. Les suivre reste sûr parce
+//     que le garde agit à la CONNEXION : il s'applique à chaque saut, cible de redirection
+//     comprise. C'est la position du garde, et non l'interdiction des redirections, qui ferme
+//     le SSRF.
+builder.Services.AddHttpClient<IServiceCouvertures, ServiceCouvertures>(http =>
+{
+    http.Timeout = timeoutRelaisCouvertures;
+    http.DefaultRequestHeaders.UserAgent.ParseAdd("MaBibli/0.1 (bibliotheque personnelle auto-hebergee)");
+})
+.ConfigurePrimaryHttpMessageHandler(() => new SocketsHttpHandler
+{
+    AllowAutoRedirect = true,
+    MaxAutomaticRedirections = 3,
+    ConnectCallback = GardeAdresses.ConnecterAsync,
+});
+
+var app = builder.Build();
+
+// Une seule base SQLite, migrée au démarrage : pas d'étape manuelle à l'installation YunoHost.
+using (var portee = app.Services.CreateScope())
+{
+    var db = portee.ServiceProvider.GetRequiredService<MaBibliDbContext>();
+    db.Database.Migrate();
+
+    // Les colonnes normalisées (sans accents) ne peuvent pas être calculées en SQL : la
+    // migration ne les remplit qu'approximativement, ce passage les remet d'aplomb et réunit
+    // les auteurs que la normalisation révèle identiques. Idempotent, donc sans coût ensuite.
+    await new ServiceRenormalisation(
+            db, portee.ServiceProvider.GetRequiredService<ILogger<ServiceRenormalisation>>())
+        .ExecuterAsync();
+}
+
+if (app.Environment.IsDevelopment())
+{
+    app.MapOpenApi();
+}
+
+// Le client Blazor WebAssembly est servi comme fichiers statiques par cette API :
+// un seul processus tourne sur le serveur.
+//
+// ⚠️ Les empreintes WASM sont désactivées (voir CLAUDE.md) : tous ces fichiers portent des noms
+// stables. Sans en-tête Cache-Control, un navigateur peut garder une version périmée en cache
+// heuristique (par exemple MaBibli.Client.styles.css) même si le service worker, lui, revalide
+// déjà à l'installation — mais seulement quand il parvient à s'activer. `no-cache` force une
+// revalidation conditionnelle (ETag/Last-Modified, déjà posés par défaut) à chaque requête :
+// pas de re-téléchargement si le fichier n'a pas changé, mais jamais de contenu périmé servi
+// sans repasser par le serveur.
+var optionsFichiersStatiques = new StaticFileOptions
+{
+    OnPrepareResponse = ctx =>
+        ctx.Context.Response.Headers.CacheControl = "no-cache, must-revalidate",
+};
+app.UseBlazorFrameworkFiles();
+app.UseStaticFiles(optionsFichiersStatiques);
+
+app.MapIsbnEndpoints();
+app.MapLivresEndpoints();
+app.MapAuteursEndpoints();
+app.MapPretsEndpoints();
+app.MapSouhaitsEndpoints();
+app.MapSeriesEndpoints();
+app.MapRevuesEndpoints();
+app.MapBibliographieEndpoints();
+app.MapIdentiteEndpoints();
+app.MapCouverturesEndpoints();
+app.MapVersionEndpoints();
+
+// ⚠️ Le fallback a son propre pipeline : il NE passe PAS par les StaticFileOptions posées
+// ci-dessus. Sans lui repasser les mêmes options, « / » — c'est-à-dire le start_url de la PWA,
+// la seule URL qu'ouvre l'application installée — repartait sans aucun Cache-Control, donc en
+// cache heuristique du navigateur. Mesuré : /index.html portait bien l'en-tête, « / » non.
+// C'est la coquille HTML qui décide de tout le reste : la servir périmée suffit à mélanger deux
+// versions sur l'appareil.
+app.MapFallbackToFile("index.html", optionsFichiersStatiques);
+
+app.Run();