@obsidiane/meridiane 2.0.13 → 3.0.1

package/templates/angular-bridge/src/lib/bridge.types.ts

@@ -25,46 +25,35 @@ export interface BridgeDefaults {
 }
 
 /**
- * Controls how Mercure topics are sent in the hub URL.
- * - `url`: topics are absolute URLs (recommended default)
- * - `iri`: topics are same-origin relative IRIs (e.g. `/api/...`)
+ * State of the Mercure connections.
+ * - `closed`: no active subscription (or realtime disabled)
+ * - `connecting`: at least one connection is opening, reconnecting, or waiting before a retry
+ * - `connected`: the hub accepted every connection and the streams are open
  */
-export type MercureTopicMode = 'url' | 'iri';
+export type RealtimeStatus = 'closed' | 'connecting' | 'connected';
 
-/**
- * Controls how SSE connections are managed.
- * - `single`: each watch subscription opens its own SSE connection
- * - `auto`: subscriptions are shared and split into multiple connections only when URL length is too large
- */
-export type MercureConnectionMode = 'single' | 'auto';
-
-/**
- * Per-subscription realtime override.
- * - `true`: force an isolated SSE connection for this watch call
- * - `false`/`undefined`: use adapter strategy (`single` or `auto`)
- */
-export interface WatchConnectionOptions {
-  newConnection?: boolean;
+export interface RealtimeSubscriptionDiagnostics {
+  match: string;
+  type: 'exact' | 'urlpattern';
+  /** Number of active `watch$()` streams sharing this subscription. */
+  consumers: number;
 }
 
-export type RealtimeConnectionScope = 'shared' | 'dedicated';
-
-export type RealtimeConnectionStatus = 'connecting' | 'connected' | 'closed';
-
 export interface RealtimeConnectionDiagnostics {
-  id: string;
-  scope: RealtimeConnectionScope;
-  status: RealtimeConnectionStatus;
-  topicCount: number;
-  topics: string[];
-  urlLength: number;
+  /** `shared`, `dedicated`, or the name given with `watch$(..., {connection})`. */
+  connection: string;
+  status: RealtimeStatus;
+  /** Subscribe URL (without `last_event_id`). */
+  url?: string;
+  subscriptions: RealtimeSubscriptionDiagnostics[];
+  /** Last update ID received on this connection, used to request replay after a reconnection. */
+  lastEventId?: string;
+  /** Consecutive connections refused by the hub (authentication, authorization, limits). */
+  failures: number;
 }
 
 export interface RealtimeDiagnostics {
-  mode: MercureConnectionMode;
-  maxUrlLength: number;
-  totalConnections: number;
-  sharedConnections: number;
-  dedicatedConnections: number;
+  status: RealtimeStatus;
+  /** One entry per `EventSource`: subscriptions are split when a subscribe URL would exceed the limits. */
   connections: RealtimeConnectionDiagnostics[];
 }

package/templates/angular-bridge/src/lib/facades/bridge.facade.ts

@@ -1,165 +1,100 @@
-import {Inject, Injectable} from '@angular/core';
+import {inject, Injectable} from '@angular/core';
+import {DOCUMENT} from '@angular/common';
 import {HttpClient} from '@angular/common/http';
-import {Observable} from 'rxjs';
-import {filter, map, share} from 'rxjs/operators';
+import {map, Observable} from 'rxjs';
 import {toHttpParams} from '../bridge/rest/query-builder';
 import {buildHttpRequestOptions, resolveHttpCallOptions} from '../bridge/rest/http-request.options';
-import {MercureRealtimeAdapter} from '../bridge/sse/mercure.adapter';
+import {MercureHub} from '../bridge/sse/mercure-hub';
 import {API_BASE_URL, BRIDGE_HTTP_WITH_CREDENTIALS} from '../tokens';
-import {AnyQuery, Collection, HttpCallOptions, HttpRequestConfig, Iri, IriRequired, Item} from '../ports/resource-repository.port';
-import {RealtimeDiagnosticsPort, SubscribeFilter} from '../ports/realtime.port';
-import {resolveUrl} from '../utils/url';
-import {toIriList} from '../utils/iri';
-import {RealtimeDiagnostics, WatchConnectionOptions} from '../bridge.types';
-
-export type TypedEvent<TType extends string = string, TPayload = unknown> = {
-  resourceType: TType;
-  payload: TPayload;
-};
-
-export type WatchTypesResult<R extends Record<string, any>> =
-  { [K in keyof R]: TypedEvent<K & string, R[K]> }[keyof R];
-
-export type WatchTypesConfig = {
-  /** Field name used as discriminator. Default: `@type` (JSON-LD). */
-  discriminator?: string;
-};
-
-export type WatchSubscriptionOptions = WatchConnectionOptions;
+import {AnyQuery, Collection, HttpCallOptions, HttpRequestConfig, Iri, Item} from '../ports/resource-repository.port';
+import {MercureSubscription, RealtimePort, RealtimeSubscribeOptions} from '../ports/realtime.port';
+import {resolveUrl, toAbsoluteUrl} from '../utils/url';
+import {RealtimeDiagnostics, RealtimeStatus} from '../bridge.types';
+
+/** Mercure selector of `BridgeFacade.watch$()`: an IRI / URL, or a URL Pattern. Relative values use `baseUrl`. */
+export interface RealtimeSelector {
+  match: string;
+  /** Default: `exact`. */
+  type?: MercureSubscription['type'];
+}
 
 /**
- * High-level facade for ad-hoc HTTP calls and Mercure subscriptions.
+ * HTTP client of the bridge (every call resolves its IRI against `baseUrl`), and access to the Mercure connections.
  *
  * Prefer `FacadeFactory` + `ResourceFacade<T>` when you want a resource-oriented API.
  */
 @Injectable({providedIn: 'root'})
 export class BridgeFacade {
-  constructor(
-    private readonly http: HttpClient,
-    @Inject(MercureRealtimeAdapter) private readonly realtime: RealtimeDiagnosticsPort,
-    @Inject(API_BASE_URL) private readonly apiBase: string,
-    @Inject(BRIDGE_HTTP_WITH_CREDENTIALS) private readonly httpWithCredentialsDefault: boolean,
-  ) {
+  private readonly http = inject(HttpClient);
+  private readonly realtime: RealtimePort = inject(MercureHub);
+  private readonly apiBase = inject(API_BASE_URL);
+  private readonly httpWithCredentialsDefault = inject(BRIDGE_HTTP_WITH_CREDENTIALS);
+  /** Mercure topics are absolute URLs: a relative `baseUrl` is resolved against the document base. */
+  private readonly topicBaseUrl = toAbsoluteUrl(this.apiBase, inject(DOCUMENT).baseURI);
+
+  get$<R = unknown>(url: Iri, options?: HttpCallOptions): Observable<R> {
+    return this.http.get<R>(this.resolveUrl(url), resolveHttpCallOptions(options, this.httpWithCredentialsDefault));
   }
 
-  get$<R = unknown>(url: IriRequired, options?: HttpCallOptions): Observable<R> {
-    return this.http.get<R>(
-      this.resolveUrl(url),
-      resolveHttpCallOptions(options, this.httpWithCredentialsDefault)
-    );
-  }
-
-  getCollection$<T extends Item = Item>(
-    url: IriRequired,
-    query?: AnyQuery,
-    options?: HttpCallOptions
-  ): Observable<Collection<T>> {
+  getCollection$<T extends Item = Item>(url: Iri, query?: AnyQuery, options?: HttpCallOptions): Observable<Collection<T>> {
     return this.http.get<Collection<T>>(this.resolveUrl(url), {
       ...resolveHttpCallOptions(options, this.httpWithCredentialsDefault),
       params: toHttpParams(query),
     });
   }
 
-  post$<R = unknown, B = unknown>(url: IriRequired, payload: B, options?: HttpCallOptions): Observable<R> {
-    return this.http.post<R>(
-      this.resolveUrl(url),
-      payload,
-      resolveHttpCallOptions(options, this.httpWithCredentialsDefault)
-    );
+  post$<R = unknown, B = unknown>(url: Iri, payload: B, options?: HttpCallOptions): Observable<R> {
+    return this.http.post<R>(this.resolveUrl(url), payload, resolveHttpCallOptions(options, this.httpWithCredentialsDefault));
   }
 
-  patch$<R = unknown, B = unknown>(url: IriRequired, changes: B, options?: HttpCallOptions): Observable<R> {
-    return this.http.patch<R>(
-      this.resolveUrl(url),
-      changes,
-      resolveHttpCallOptions(options, this.httpWithCredentialsDefault)
-    );
+  patch$<R = unknown, B = unknown>(url: Iri, changes: B, options?: HttpCallOptions): Observable<R> {
+    return this.http.patch<R>(this.resolveUrl(url), changes, resolveHttpCallOptions(options, this.httpWithCredentialsDefault));
   }
 
-  put$<R = unknown, B = unknown>(url: IriRequired, payload: B, options?: HttpCallOptions): Observable<R> {
-    return this.http.put<R>(
-      this.resolveUrl(url),
-      payload,
-      resolveHttpCallOptions(options, this.httpWithCredentialsDefault)
-    );
+  put$<R = unknown, B = unknown>(url: Iri, payload: B, options?: HttpCallOptions): Observable<R> {
+    return this.http.put<R>(this.resolveUrl(url), payload, resolveHttpCallOptions(options, this.httpWithCredentialsDefault));
   }
 
-  delete$(url: IriRequired, options?: HttpCallOptions): Observable<void> {
-    return this.http.delete<void>(
-      this.resolveUrl(url),
-      resolveHttpCallOptions(options, this.httpWithCredentialsDefault)
-    );
+  delete$(url: Iri, options?: HttpCallOptions): Observable<void> {
+    return this.http.delete<void>(this.resolveUrl(url), resolveHttpCallOptions(options, this.httpWithCredentialsDefault));
   }
 
+  /** Low-level escape hatch for non-standard endpoints (custom controllers, uploads, other formats...). */
   request$<R = unknown, B = unknown>(request: HttpRequestConfig<B>): Observable<R> {
-    const {method, url} = request;
-    const targetUrl = this.resolveUrl(url);
-
-    const mergedOptions = buildHttpRequestOptions(request, {withCredentialsDefault: this.httpWithCredentialsDefault});
-    return this.http.request<R>(method, targetUrl, mergedOptions as {observe: 'body'});
-  }
-
-  watch$<T = Item>(
-    iri: Iri | Iri[],
-    subscribeFilter?: SubscribeFilter,
-    options?: WatchSubscriptionOptions
-  ): Observable<T> {
-    const iris = toIriList(iri);
-    return this.realtime
-      .subscribe$<T>(iris, subscribeFilter, options)
-      .pipe(
-        map((event) => event.data),
-        filter((data): data is T => data !== undefined),
-        share()
-      );
+    return this.http.request<R>(
+      request.method,
+      this.resolveUrl(request.url),
+      buildHttpRequestOptions(request, this.httpWithCredentialsDefault)
+    );
   }
 
   /**
-   * Watches a "multi-entity" topic and emits only payloads whose discriminator matches `resourceTypes`.
-   *
-   * Important:
-   * - filtering is done on payload content (e.g. `@type`), not on network topic provenance.
-   * - in shared mode (`connectionMode: 'auto'` without `newConnection`), events from another shared topic
-   *   can be emitted if they carry an allowed discriminator.
+   * Streams the JSON payloads of a custom Mercure subscription, without filtering them.
    *
-   * For strict single-topic isolation, use a dedicated connection:
-   * `watchTypes$(..., ..., ..., { newConnection: true })`
-   * (or `connectionMode: 'single'` globally).
+   * The default connection is `dedicated`: every update received on it belongs to this subscription. On a
+   * shared or named connection, the stream also carries the updates of the other subscriptions of that connection.
    */
-  watchTypes$<R extends Record<string, any>>(
-    iri: Iri | Iri[],
-    resourceTypes: (keyof R & string)[],
-    config?: WatchTypesConfig,
-    options?: WatchSubscriptionOptions
-  ): Observable<WatchTypesResult<R>> {
-    const iris = toIriList(iri);
-    const discriminator = config?.discriminator ?? '@type';
-    const allowedTypes = new Set(
-      resourceTypes.filter((type): type is string => typeof type === 'string' && type.length > 0)
-    );
-
+  watch$<T = unknown>(selector: RealtimeSelector, options?: RealtimeSubscribeOptions): Observable<T> {
+    const subscription: MercureSubscription = {
+      match: resolveUrl(this.topicBaseUrl, selector.match),
+      type: selector.type ?? 'exact',
+    };
     return this.realtime
-      .subscribeAll$<unknown>(iris, options)
-      .pipe(
-        map((event): WatchTypesResult<R> | undefined => {
-          const raw = event.data;
-
-          const resolvedType = readDiscriminator(raw, discriminator);
-          if (typeof resolvedType !== 'string') return undefined;
-          if (!allowedTypes.has(resolvedType)) return undefined;
+      .subscribe$(subscription, {connection: options?.connection ?? 'dedicated'})
+      .pipe(map((update) => update.data as T));
+  }
 
-          const key = resolvedType as keyof R & string;
-          return {resourceType: key, payload: raw as R[keyof R]} as WatchTypesResult<R>;
-        }),
-        filter((event): event is WatchTypesResult<R> => !!event),
-        share()
-      );
+  /** Renews the Mercure authorization and reopens every connection, e.g. after login or logout. */
+  reconnectRealtime(): void {
+    this.realtime.reconnect();
   }
 
-  unwatch(iri: Iri | Iri[]): void {
-    this.realtime.unsubscribe(toIriList(iri));
+  /** State of the Mercure connections. */
+  realtimeStatus$(): Observable<RealtimeStatus> {
+    return this.realtime.status$();
   }
 
+  /** Mercure connections, their subscriptions and resume positions. */
   realtimeDiagnostics$(): Observable<RealtimeDiagnostics> {
     return this.realtime.diagnostics$();
   }
@@ -169,14 +104,3 @@ export class BridgeFacade {
     return resolveUrl(this.apiBase, path);
   }
 }
-
-function readDiscriminator(payload: unknown, discriminator: string): string | undefined {
-  if (!payload || typeof payload !== 'object') return undefined;
-  const value = (payload as Record<string, unknown>)[discriminator];
-  if (typeof value === 'string') return value;
-  if (Array.isArray(value)) {
-    const first = value.find((v) => typeof v === 'string');
-    return typeof first === 'string' ? first : undefined;
-  }
-  return undefined;
-}

package/templates/angular-bridge/src/lib/facades/facade.factory.ts

@@ -1,37 +1,37 @@
-import {EnvironmentInjector, inject, Injectable, runInInjectionContext} from '@angular/core';
-import {HttpClient} from '@angular/common/http';
+import {inject, Injectable} from '@angular/core';
+import {DOCUMENT} from '@angular/common';
 import {RealtimePort} from '../ports/realtime.port';
-import {Item, ResourceRepository} from '../ports/resource-repository.port';
-import {API_BASE_URL, BRIDGE_HTTP_WITH_CREDENTIALS} from '../tokens';
-import {MercureRealtimeAdapter} from '../bridge/sse/mercure.adapter';
-import {ApiPlatformRestRepository} from '../bridge/rest/api-platform.adapter';
+import {Item} from '../ports/resource-repository.port';
+import {API_BASE_URL} from '../tokens';
+import {MercureHub} from '../bridge/sse/mercure-hub';
+import {ResourceTopic} from '../bridge/sse/resource-topic';
+import {resolveUrl, toAbsoluteUrl, trimTrailingSlash} from '../utils/url';
+import {BridgeFacade} from './bridge.facade';
 import {ResourceFacade} from './resource.facade';
 
-export type FacadeConfig<T> = {
+export type FacadeConfig = {
+  /** Collection path of the resource (e.g. `/api/books`). */
   url: string;
-  repo?: ResourceRepository<T>;
+  /**
+   * URL Pattern of the resource item IRIs, i.e. the Mercure topics API Platform publishes on.
+   * Default: `{url}/:id`. Relative patterns are resolved against `baseUrl`.
+   */
+  topic?: string;
   realtime?: RealtimePort;
 };
 
 @Injectable({providedIn: 'root'})
 export class FacadeFactory {
-  private readonly env = inject(EnvironmentInjector);
-  private readonly http = inject(HttpClient);
-  private readonly baseUrl = inject(API_BASE_URL);
-  private readonly httpWithCredentials = inject(BRIDGE_HTTP_WITH_CREDENTIALS);
-  private readonly mercure = inject(MercureRealtimeAdapter);
-
-  /**
-   * Creates a `ResourceFacade<T>`.
-   *
-   * Important: `ResourceFacade` uses `toSignal()`, which requires an injection context.
-   * This factory ensures that by using `runInInjectionContext`.
-   */
-  create<T extends Item>(config: FacadeConfig<T>): ResourceFacade<T> {
-    const url = config.url;
-    const repo = config.repo ?? new ApiPlatformRestRepository<T>(this.http, this.baseUrl, url, this.httpWithCredentials);
-    const realtime = config.realtime ?? this.mercure;
+  private readonly bridge = inject(BridgeFacade);
+  private readonly mercure = inject(MercureHub);
+  /** Mercure topics are absolute URLs: a relative `baseUrl` is resolved against the document base. */
+  private readonly topicBaseUrl = toAbsoluteUrl(inject(API_BASE_URL), inject(DOCUMENT).baseURI);
 
-    return runInInjectionContext(this.env, () => new ResourceFacade<T>(repo, realtime));
+  create<T extends Item>(config: FacadeConfig): ResourceFacade<T> {
+    const topic = new ResourceTopic(
+      resolveUrl(this.topicBaseUrl, config.topic ?? `${trimTrailingSlash(config.url)}/:id`),
+      this.topicBaseUrl
+    );
+    return new ResourceFacade<T>(this.bridge, config.url, config.realtime ?? this.mercure, topic);
   }
 }

package/templates/angular-bridge/src/lib/facades/facade.interface.ts

@@ -1,13 +1,8 @@
-import {
-  Iri,
-  Item,
-  ResourceRepository,
-} from '../ports/resource-repository.port';
+import {Iri, Item, ResourceRepository} from '../ports/resource-repository.port';
 import {Observable} from 'rxjs';
-import {WatchConnectionOptions} from '../bridge.types';
+import {ResourceDeletion} from '../bridge/sse/resource-topic';
+import {RealtimeSubscribeOptions} from '../ports/realtime.port';
 
 export interface Facade<T extends Item> extends ResourceRepository<T> {
-  watch$(iri: Iri | Iri[], options?: WatchConnectionOptions): Observable<T>;
-
-  unwatch(iri: Iri | Iri[]): void;
+  watch$(iri?: Iri, options?: RealtimeSubscribeOptions): Observable<T | ResourceDeletion>;
 }

package/templates/angular-bridge/src/lib/facades/resource.facade.ts

@@ -1,95 +1,72 @@
 import {Signal} from '@angular/core';
-import {
-  ResourceRepository,
-  AnyQuery,
-  HttpCallOptions,
-  Iri,
-  IriRequired,
-  Collection,
-  Item,
-  HttpRequestConfig,
-} from '../ports/resource-repository.port';
-import {RealtimePort, RealtimeStatus} from '../ports/realtime.port';
-import {toSignal} from '@angular/core/rxjs-interop';
 import {filter, map, Observable, share} from 'rxjs';
+import {AnyQuery, Collection, HttpCallOptions, HttpRequestConfig, Iri, Item} from '../ports/resource-repository.port';
+import {RealtimePort, RealtimeSubscribeOptions} from '../ports/realtime.port';
+import {RealtimeStatus} from '../bridge.types';
+import {ResourceDeletion, ResourceTopic} from '../bridge/sse/resource-topic';
+import {BridgeFacade} from './bridge.facade';
 import {Facade} from './facade.interface';
-import {WatchConnectionOptions} from '../bridge.types';
-import {toIriList} from '../utils/iri';
 
+export {isResourceDeletion} from '../bridge/sse/resource-topic';
+export type {ResourceDeletion} from '../bridge/sse/resource-topic';
+
+/** API of one API Platform resource: its collection path for HTTP, its URL Pattern for Mercure. */
 export class ResourceFacade<T extends Item> implements Facade<T> {
   readonly connectionStatus: Signal<RealtimeStatus>;
 
   constructor(
-    protected readonly repo: ResourceRepository<T>,
-    protected readonly realtime: RealtimePort
+    protected readonly bridge: BridgeFacade,
+    protected readonly url: Iri,
+    protected readonly realtime: RealtimePort,
+    protected readonly topic: ResourceTopic,
   ) {
-    this.connectionStatus = toSignal(this.realtime.status$(), {initialValue: 'closed'});
+    this.connectionStatus = realtime.status;
   }
 
   getCollection$(query?: AnyQuery, options?: HttpCallOptions): Observable<Collection<T>> {
-    return this.repo.getCollection$(query, options);
-  }
-
-  get$(iri: IriRequired, options?: HttpCallOptions): Observable<T> {
-    return this.repo.get$(iri, options);
+    return this.bridge.getCollection$<T>(this.url, query, options);
   }
 
-  patch$(iri: IriRequired, changes: Partial<T>, options?: HttpCallOptions): Observable<T> {
-    return this.repo.patch$(iri, changes, options);
+  get$(iri: Iri, options?: HttpCallOptions): Observable<T> {
+    return this.bridge.get$<T>(iri, options);
   }
 
   post$(payload: Partial<T>, options?: HttpCallOptions): Observable<T> {
-    return this.repo.post$(payload, options);
+    return this.bridge.post$<T, Partial<T>>(this.url, payload, options);
   }
 
-  put$(iri: IriRequired, payload: Partial<T>, options?: HttpCallOptions): Observable<T> {
-    return this.repo.put$(iri, payload, options);
+  patch$(iri: Iri, changes: Partial<T>, options?: HttpCallOptions): Observable<T> {
+    return this.bridge.patch$<T, Partial<T>>(iri, changes, options);
   }
 
-  delete$(iri: IriRequired, options?: HttpCallOptions): Observable<void> {
-    return this.repo.delete$(iri, options);
+  put$(iri: Iri, payload: Partial<T>, options?: HttpCallOptions): Observable<T> {
+    return this.bridge.put$<T, Partial<T>>(iri, payload, options);
   }
 
-  request$<R = unknown, B = unknown>(request: HttpRequestConfig<B>): Observable<R> {
-    return this.repo.request$<R, B>(request);
+  delete$(iri: Iri, options?: HttpCallOptions): Observable<void> {
+    return this.bridge.delete$(iri, options);
   }
 
-  /**
-   * Subscribes to real-time updates for one or many IRIs.
-   * Undefined/empty values are ignored.
-   */
-  watch$(iri: Iri | Iri[], options?: WatchConnectionOptions): Observable<T> {
-    return this.subscribeAndSync(toIriList(iri), options);
-  }
-  unwatch(iri: Iri | Iri[]): void {
-    this.realtime.unsubscribe(toIriList(iri));
+  /** Low-level escape hatch; `url` defaults to the collection path of the resource. */
+  request$<R = unknown, B = unknown>(request: HttpRequestConfig<B>): Observable<R> {
+    return this.bridge.request$<R, B>({...request, url: request.url ?? this.url});
   }
 
   /**
-   * Subscribes to updates of a related sub-resource published on the parent topic.
-   * Example: subscribe to Message events on a Conversation topic, filtering by `message.conversation`.
+   * Streams changes of one item when an IRI is supplied, or of the resource's items otherwise.
+   * Payloads are forwarded unchanged, including API Platform deletion payloads.
+   *
+   * Item subscriptions use `match`; resource subscriptions use `match_urlpattern`. Updates are kept by `@id`,
+   * so `connection` (default `shared`) only chooses the SSE connection carrying the subscription.
+   * Unsubscribing releases this consumer; other consumers keep sharing the subscription.
    */
-  watchSubResource$<R>(
-    iri: Iri | Iri[],
-    field: string,
-    options?: WatchConnectionOptions
-  ): Observable<R> {
-    const iris = toIriList(iri);
-    return this.realtime
-      .subscribe$<R>(iris, {field}, options)
-      .pipe(
-        map((event) => event.data),
-        filter((data): data is R => data !== undefined),
-        share()
-      );
-  }
-
-  protected subscribeAndSync(iris: string[], options?: WatchConnectionOptions): Observable<T> {
+  watch$(iri?: Iri, options?: RealtimeSubscribeOptions): Observable<T | ResourceDeletion> {
+    const topic = iri === undefined ? this.topic : this.topic.forIri(iri);
     return this.realtime
-      .subscribe$<T>(iris, undefined, options)
+      .subscribe$({match: topic.match, type: topic.type}, options)
       .pipe(
-        map((event) => event.data),
-        filter((data): data is T => data !== undefined),
+        map((update) => topic.toResource<T>(update.data)),
+        filter((resource): resource is T | ResourceDeletion => resource !== undefined),
         share()
       );
   }

package/templates/angular-bridge/src/lib/interceptors/bearer-auth.interceptor.ts

@@ -1,26 +1,22 @@
 import {HttpInterceptorFn} from '@angular/common/http';
 import {from, switchMap} from 'rxjs';
 import {BridgeAuth} from '../bridge-options';
-import {isRequestWithinBaseUrl} from '../utils/request-url';
 
 type TokenProvider = () => string | undefined | Promise<string | undefined>;
 
-export function createAuthInterceptors(auth: BridgeAuth | undefined, baseUrl: string): HttpInterceptorFn[] {
-  if (!auth) return [];
-  if (typeof auth === 'function') return [auth];
-
-  const bearer = typeof auth === 'string' ? {type: 'bearer' as const, token: auth} : auth;
-  if (bearer.type !== 'bearer') return [];
+/** Builds the auth interceptor; `provideBridge` limits it to requests targeting the API. */
+export function createAuthInterceptor(auth: BridgeAuth | undefined): HttpInterceptorFn | undefined {
+  if (!auth) return undefined;
+  if (typeof auth === 'function') return auth;
 
+  const bearer = typeof auth === 'string' ? {token: auth} : auth;
   const getToken: TokenProvider = 'token' in bearer ? () => bearer.token : bearer.getToken;
-  return [createBearerAuthInterceptor(baseUrl, getToken)];
+  return createBearerAuthInterceptor(getToken);
 }
 
-function createBearerAuthInterceptor(baseUrl: string, getToken: TokenProvider): HttpInterceptorFn {
+function createBearerAuthInterceptor(getToken: TokenProvider): HttpInterceptorFn {
   return (request, next) => {
-    if (!isRequestWithinBaseUrl(request.url, baseUrl) || request.headers.has('Authorization')) {
-      return next(request);
-    }
+    if (request.headers.has('Authorization')) return next(request);
 
     return from(Promise.resolve(getToken())).pipe(
       switchMap((token) => {

package/templates/angular-bridge/src/lib/interceptors/bridge-defaults.interceptor.ts

@@ -1,6 +1,6 @@
-import {HttpInterceptorFn, HttpRequest} from '@angular/common/http';
+import {HttpErrorResponse, HttpInterceptorFn, HttpRequest} from '@angular/common/http';
 import {inject} from '@angular/core';
-import {retry, timeout, timer} from 'rxjs';
+import {retry, throwError, timer} from 'rxjs';
 import {BridgeDefaults} from '../bridge.types';
 import {BRIDGE_DEFAULTS, BRIDGE_LOGGER} from '../tokens';
 
@@ -18,22 +18,18 @@ type RetryPolicy = {
 export const bridgeDefaultsInterceptor: HttpInterceptorFn = (req, next) => {
   const defaults = inject(BRIDGE_DEFAULTS, {optional: true}) ?? {};
   const logger = inject(BRIDGE_LOGGER, {optional: true});
-  const request = applyDefaultHeaders(req, defaults.headers);
-
-  let response$ = next(request);
-  if (typeof defaults.timeoutMs === 'number' && defaults.timeoutMs > 0) {
-    response$ = response$.pipe(timeout({first: defaults.timeoutMs}));
-  }
+  const request = applyTimeout(applyDefaultHeaders(req, defaults.headers), defaults.timeoutMs);
 
   const retryPolicy = resolveRetryPolicy(defaults.retries);
   if (!retryPolicy || !retryPolicy.methods.has(req.method.toUpperCase())) {
-    return response$;
+    return next(request);
   }
 
-  return response$.pipe(
+  return next(request).pipe(
     retry({
       count: retryPolicy.count,
-      delay: (_error, retryIndex) => {
+      delay: (error, retryIndex) => {
+        if (!isRetryable(error)) return throwError(() => error);
         logger?.debug?.('[Bridge] retry', {url: req.urlWithParams, method: req.method, retryIndex});
         return timer(retryPolicy.delayMs);
       },
@@ -52,6 +48,18 @@ function applyDefaultHeaders(request: HttpRequest<unknown>, defaults?: Record<st
   return headers === request.headers ? request : request.clone({headers});
 }
 
+/** Uses the native request timeout, which aborts the request; an explicit per-request timeout wins. */
+function applyTimeout(request: HttpRequest<unknown>, timeoutMs?: number): HttpRequest<unknown> {
+  if (typeof timeoutMs !== 'number' || timeoutMs <= 0 || request.timeout !== undefined) return request;
+  return request.clone({timeout: timeoutMs});
+}
+
+/** Network errors (status 0), rate limiting and server errors are transient; other responses are final. */
+function isRetryable(error: unknown): boolean {
+  if (!(error instanceof HttpErrorResponse)) return false;
+  return error.status === 0 || error.status === 429 || error.status >= 500;
+}
+
 function resolveRetryPolicy(retries: BridgeDefaults['retries']): RetryPolicy | undefined {
   const count = typeof retries === 'number' ? retries : retries?.count;
   if (!count || count <= 0) return undefined;