@obsidiane/meridiane 2.0.1 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@obsidiane/meridiane",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "Générateur de librairie Angular et modèles TypeScript (OpenAPI) pour un bridge Symfony/API Platform + Mercure.",
   "repository": {
     "type": "git",

package/templates/_lib_template/README.md

@@ -2,7 +2,7 @@
 
 Bridge Angular (runtime + models TypeScript) pour une API Platform (Hydra/JSON-LD), avec support Mercure/SSE optionnel.
 
-Le package expose une API Angular minimaliste :
+Le package expose une API Angular volontairement minimaliste :
 - `provideBridge()` pour configurer le bridge (HTTP + tokens + Mercure) ;
 - `FacadeFactory` / `ResourceFacade<T>` pour une API orientée ressource ;
 - `BridgeFacade` pour des appels ad-hoc.
@@ -22,7 +22,7 @@ Le bridge est conçu pour être installé dans une application Angular. Les dép
 
 ## Démarrage rapide
 
-Configurez le bridge au démarrage de l’application avec `provideBridge()`.
+Configurez le bridge au démarrage de l’application avec `provideBridge()` (requis).
 
 ### Application standalone (recommandé)
 
@@ -57,6 +57,15 @@ export class AppModule {}
 
 ## Configuration
 
+`provideBridge({ ... })` accepte notamment :
+- `baseUrl` (requis) ;
+- `auth` (Bearer ou interceptor custom) ;
+- `mercure` (hubUrl + options SSE) ;
+- `defaults` (headers/timeout/retries) ;
+- `singleFlight` (déduplication “in-flight” des requêtes HTTP identiques `GET/HEAD/OPTIONS`) ;
+- `debug` (logs runtime) ;
+- `extraInterceptors` (interceptors Angular additionnels).
+
 ### Cookies / `withCredentials`
 
 Le bridge peut envoyer des cookies (sessions) côté HTTP et SSE.
@@ -175,6 +184,24 @@ provideBridge({
 });
 ```
 
+### Concurrence
+
+Le bridge maintient une seule connexion SSE (une seule `EventSource`) et mutualise les topics :
+- regarder plusieurs fois la même ressource ne crée pas plusieurs connexions ;
+- un même topic est dédoublonné et géré par ref-count (unsubscribe effectif quand plus personne n’écoute).
+
+Côté HTTP, le bridge déduplique les requêtes identiques tant qu’elles sont en cours (single-flight, activé par défaut) :
+- `GET` / `HEAD` / `OPTIONS` : deux appels identiques partagent le même appel réseau et reçoivent la même réponse ;
+- les méthodes avec body (`POST`/`PUT`/`PATCH`/`DELETE`) ne sont pas dédupliquées.
+
+Ce n’est pas un cache : une fois la requête terminée, un nouvel appel identique relance un nouvel appel réseau.
+
+Pour désactiver :
+
+```ts
+provideBridge({baseUrl: 'https://api.example.com', singleFlight: false});
+```
+
 API :
 - `ResourceFacade<T>.watch$(iri | iri[])` / `unwatch(iri | iri[])`
 - `ResourceFacade<T>.watchSubResource$(iri | iri[], 'field.path')`

package/templates/_lib_template/src/lib/interceptors/singleflight.interceptor.ts

@@ -0,0 +1,55 @@
+import {HttpEvent, HttpInterceptorFn, HttpRequest} from '@angular/common/http';
+import {finalize, Observable, shareReplay} from 'rxjs';
+
+export type SingleFlightMode = 'off' | 'safe';
+
+const DEFAULT_MODE: SingleFlightMode = 'safe';
+const SAFE_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);
+
+export function createSingleFlightInterceptor(mode: SingleFlightMode = DEFAULT_MODE): HttpInterceptorFn {
+  const inflight = new Map<string, Observable<HttpEvent<unknown>>>();
+
+  return (req, next) => {
+    if (mode === 'off') {
+      return next(req);
+    }
+
+    const method = req.method.toUpperCase();
+    if (!SAFE_METHODS.has(method)) {
+      return next(req);
+    }
+    if (req.reportProgress === true) {
+      return next(req);
+    }
+
+    const key = computeKey(req);
+    const existing = inflight.get(key);
+    if (existing) {
+      return existing;
+    }
+
+    const shared$ = next(req).pipe(
+      finalize(() => inflight.delete(key)),
+      shareReplay({bufferSize: 1, refCount: true})
+    );
+
+    inflight.set(key, shared$);
+    return shared$;
+  };
+}
+
+function computeKey(req: HttpRequest<unknown>): string {
+  const auth = req.headers.get('Authorization') ?? '';
+  const accept = req.headers.get('Accept') ?? '';
+  const contentType = req.headers.get('Content-Type') ?? '';
+  const creds = req.withCredentials ? '1' : '0';
+  return [
+    req.method.toUpperCase(),
+    req.urlWithParams,
+    `rt=${req.responseType}`,
+    `wc=${creds}`,
+    `a=${auth}`,
+    `acc=${accept}`,
+    `ct=${contentType}`,
+  ].join('::');
+}

package/templates/_lib_template/src/lib/provide-bridge.ts

@@ -13,6 +13,7 @@ import {contentTypeInterceptor} from './interceptors/content-type.interceptor';
 import {bridgeDefaultsInterceptor} from './interceptors/bridge-defaults.interceptor';
 import {bridgeDebugInterceptor} from './interceptors/bridge-debug.interceptor';
 import {from, switchMap} from 'rxjs';
+import {createSingleFlightInterceptor} from './interceptors/singleflight.interceptor';
 
 export type BridgeAuth =
   | string
@@ -37,6 +38,13 @@ export interface BridgeOptions {
   mercure?: BridgeMercureOptions;
   /** Default HTTP behaviour (headers, timeout, retries). */
   defaults?: BridgeDefaults;
+  /**
+   * De-duplicates in-flight HTTP requests.
+   *
+   * - `true` (default): single-flight for safe methods (`GET/HEAD/OPTIONS`)
+   * - `false`: disabled (each call triggers a new request)
+   */
+  singleFlight?: boolean;
   /** Enables debug logging via the debug interceptor and console logger. */
   debug?: boolean;
   /** Extra `HttpInterceptorFn` applied after bridge interceptors. */
@@ -50,6 +58,7 @@ export function provideBridge(opts: BridgeOptions): EnvironmentProviders {
     auth,
     mercure,
     defaults,
+    singleFlight = true,
     debug = false,
     extraInterceptors = [],
   } = opts;
@@ -69,6 +78,7 @@ export function provideBridge(opts: BridgeOptions): EnvironmentProviders {
     contentTypeInterceptor,
     bridgeDefaultsInterceptor,
     ...createAuthInterceptors(auth),
+    ...(singleFlight ? [createSingleFlightInterceptor('safe')] : [createSingleFlightInterceptor('off')]),
     ...(debug ? [bridgeDebugInterceptor] : []),
     ...extraInterceptors,
   ];