@obsidiane/auth-client-js 1.0.3 → 1.0.5

package/src/lib/bridge/sse/mercure.adapter.ts

@@ -1,261 +0,0 @@
-import {Inject, Injectable, OnDestroy, Optional, PLATFORM_ID} from '@angular/core';
-import {BehaviorSubject, defer, EMPTY, fromEvent, Observable, of, Subject} from 'rxjs';
-import {auditTime, concatMap, filter, finalize, map, share, takeUntil} from 'rxjs/operators';
-import {API_BASE_URL, BRIDGE_LOGGER, BRIDGE_WITH_CREDENTIALS, MERCURE_HUB_URL, MERCURE_TOPIC_MODE} from '../../tokens';
-import {BridgeLogger, MercureTopicMode} from '../../bridge.types';
-import {RealtimeEvent, RealtimePort, RealtimeStatus} from '../../ports/realtime.port';
-import {EventSourceWrapper} from './eventsource-wrapper';
-import {Item} from '../../ports/resource-repository.port';
-import {isPlatformBrowser} from '@angular/common';
-import {MercureUrlBuilder} from './mercure-url.builder';
-import {RefCountTopicRegistry} from './ref-count-topic.registry';
-import {MercureTopicMapper} from './mercure-topic.mapper';
-
-
-@Injectable({providedIn: 'root'})
-export class MercureRealtimeAdapter implements RealtimePort, OnDestroy {
-  private lastEventId?: string;
-  private es?: EventSourceWrapper;
-  private currentKey?: string;
-
-  private readonly topicsRegistry = new RefCountTopicRegistry();
-  private readonly urlBuilder: MercureUrlBuilder;
-  private readonly topicMapper: MercureTopicMapper;
-
-  private readonly destroy$ = new Subject<void>();
-  private connectionStop$ = new Subject<void>();
-  private readonly rebuild$ = new Subject<void>();
-  private shuttingDown = false;
-
-  private readonly _status$ = new BehaviorSubject<RealtimeStatus>('closed');
-  private readonly incoming$ = new Subject<{ type: string; data: string }>();
-
-  constructor(
-    @Inject(API_BASE_URL) private readonly apiBase: string,
-    @Inject(BRIDGE_WITH_CREDENTIALS) private readonly withCredentialsDefault: boolean,
-    @Inject(PLATFORM_ID) private readonly platformId: object,
-    @Optional() @Inject(MERCURE_HUB_URL) private readonly hubUrl?: string,
-    @Optional() @Inject(MERCURE_TOPIC_MODE) topicMode?: MercureTopicMode,
-    @Optional() @Inject(BRIDGE_LOGGER) private readonly logger?: BridgeLogger,
-  ) {
-    this.urlBuilder = new MercureUrlBuilder();
-    // `topicMode` affects only the `topic=` query param sent to the hub.
-    // Payload IRIs are always matched using same-origin relative IRIs (`/api/...`) when possible.
-    this.topicMapper = new MercureTopicMapper(apiBase, topicMode ?? 'url');
-
-    this.rebuild$
-      .pipe(
-        auditTime(10),
-        concatMap(() => this.rebuildOnce$()),
-      )
-      .subscribe();
-
-    if (isPlatformBrowser(this.platformId)) {
-      fromEvent<PageTransitionEvent>(window, 'pagehide')
-        .pipe(takeUntil(this.destroy$))
-        .subscribe(() => this.shutdownBeforeExit());
-
-      fromEvent<BeforeUnloadEvent>(window, 'beforeunload')
-        .pipe(takeUntil(this.destroy$))
-        .subscribe(() => this.shutdownBeforeExit());
-    }
-  }
-
-  // ──────────────── API publique ────────────────
-
-  status$(): Observable<RealtimeStatus> {
-    return this._status$.asObservable();
-  }
-
-
-  subscribe$<T>(iris: string[], _filter?: { field?: string }): Observable<RealtimeEvent<T>> {
-    return defer(() => {
-      const inputIris = iris.filter((v): v is string => typeof v === 'string' && v.length > 0);
-      if (inputIris.length === 0) return EMPTY;
-
-      if (!this.hubUrl) {
-        this.logger?.debug?.('[Mercure] hubUrl not configured → realtime disabled');
-        return EMPTY;
-      }
-
-      // Canonicalise topics (ref-count + URL) to avoid duplicates like:
-      // - "/api/conversations/1" and "http://localhost:8000/api/conversations/1"
-      const registeredTopics = Array.from(new Set(inputIris.map((i) => this.topicMapper.toTopic(i))));
-
-      this.topicsRegistry.addAll(registeredTopics);
-      this.scheduleRebuild();
-
-      // Matching is done against the payload IRIs (typically "/api/...").
-      const subscribed = inputIris.map((i) => normalizeIri(this.topicMapper.toPayloadIri(i)));
-      const fieldPath = _filter?.field;
-
-      return this.incoming$.pipe(
-        map((evt) => this.safeParse(evt.data)),
-        filter((raw): raw is Item => !!raw),
-
-        filter((raw: any) => {
-          if (fieldPath) {
-            const relIris = this.extractRelationIris(raw, fieldPath).map((i) => normalizeIri(this.topicMapper.toPayloadIri(i)));
-            return relIris.some((relIri) => matchesAnySubscribed(relIri, subscribed));
-          }
-          const rawId = raw?.['@id'];
-          const id = typeof rawId === 'string' ? normalizeIri(this.topicMapper.toPayloadIri(rawId)) : undefined;
-          return typeof id === 'string' && matchesAnySubscribed(id, subscribed);
-        }),
-        map((payload) => ({iri: payload['@id'] as string, data: payload as T})),
-        finalize(() => {
-          this.topicsRegistry.removeAll(registeredTopics);
-          this.scheduleRebuild();
-        }),
-        share()
-      );
-    });
-  }
-
-  unsubscribe(iris: string[]): void {
-    const inputIris = iris.filter((v): v is string => typeof v === 'string' && v.length > 0);
-    if (inputIris.length === 0) return;
-    const topics = Array.from(new Set(inputIris.map((i) => this.topicMapper.toTopic(i))));
-    this.topicsRegistry.removeAll(topics);
-    this.scheduleRebuild();
-  }
-
-  public shutdownBeforeExit(): void {
-    if (this.shuttingDown) return;
-    this.shuttingDown = true;
-    this.teardownConnection();
-  }
-
-  ngOnDestroy(): void {
-    this.teardownConnection();
-    this._status$.complete();
-    this.incoming$.complete();
-    this.destroy$.next();
-    this.destroy$.complete();
-    this.rebuild$.complete();
-  }
-
-  // ───────────────── PRIVATE ─────────────────
-
-  private scheduleRebuild(): void {
-    if (this.shuttingDown) return;
-    this.rebuild$.next();
-  }
-
-  private rebuildOnce$() {
-    return defer(() => {
-      if (this.shuttingDown) return of(void 0);
-
-      try {
-        if (!this.hubUrl) {
-          this.currentKey = undefined;
-          this._status$.next('closed');
-          return of(void 0);
-        }
-
-        const hasTopics = this.topicsRegistry.hasAny();
-        const key = hasTopics ? this.topicsRegistry.computeKey(this.hubUrl, this.withCredentialsDefault) : undefined;
-
-        if (!hasTopics) {
-          if (this.es) this.teardownConnection();
-          this.currentKey = undefined;
-          this._status$.next('closed');
-          return of(void 0);
-        }
-
-        if (key && key === this.currentKey) {
-          return of(void 0);
-        }
-
-        this.teardownConnection();
-
-        const url = this.urlBuilder.build(this.hubUrl, this.topicsRegistry.snapshot(), this.lastEventId);
-        this.logger?.debug?.('[Mercure] connect', {hubUrl: this.hubUrl, topics: this.topicsRegistry.snapshot(), lastEventId: this.lastEventId});
-        this.es = new EventSourceWrapper(url, {withCredentials: this.withCredentialsDefault}, this.logger);
-
-        this.connectionStop$ = new Subject<void>();
-
-        this.es.status$
-          .pipe(takeUntil(this.connectionStop$), takeUntil(this.destroy$))
-          .subscribe((st) => this.updateGlobalStatus(st));
-
-        this.es.events$
-          .pipe(takeUntil(this.connectionStop$), takeUntil(this.destroy$))
-          .subscribe((e) => {
-            this.lastEventId = e.lastEventId ?? this.lastEventId;
-            this.incoming$.next(e);
-          });
-
-        this._status$.next('connecting');
-        this.es.open();
-        this.currentKey = key;
-      } catch (err) {
-        this.logger?.error?.('[Mercure] rebuild failed:', err);
-        this.currentKey = undefined;
-        this._status$.next(this.topicsRegistry.hasAny() ? 'connecting' : 'closed');
-      }
-
-      return of(void 0);
-    });
-  }
-
-  private teardownConnection(): void {
-    this.es?.close();
-    this.es = undefined;
-    this.connectionStop$.next();
-    this.connectionStop$.complete();
-  }
-
-  private updateGlobalStatus(sse: RealtimeStatus): void {
-    if (sse === 'connected') {
-      this._status$.next('connected');
-      return;
-    }
-    if (sse === 'connecting') {
-      this._status$.next('connecting');
-      return;
-    }
-    this._status$.next(this.topicsRegistry.hasAny() ? 'connecting' : 'closed');
-  }
-
-  private safeParse(raw: string): Item | undefined {
-    try {
-      return JSON.parse(raw) as Item;
-    } catch (err) {
-      this.logger?.debug?.('[Mercure] invalid JSON payload ignored', {raw});
-      return undefined;
-    }
-  }
-
-  private extractRelationIris(raw: any, path: string): string[] {
-    const readPath = (obj: any, dotPath: string): any => {
-      return dotPath
-        .split('.')
-        .filter(Boolean)
-        .reduce((acc, key) => acc?.[key], obj);
-    };
-
-    const normalize = (value: any): string[] => {
-      if (!value) return [];
-      if (typeof value === 'string') return value.length > 0 ? [value] : [];
-      if (typeof value === 'object' && typeof value['@id'] === 'string') return [value['@id']];
-      if (Array.isArray(value)) return value.flatMap(normalize);
-      return [];
-    };
-
-    return normalize(readPath(raw, path));
-  }
-
-}
-
-function normalizeIri(iri: string): string {
-  return iri.endsWith('/') ? iri.slice(0, -1) : iri;
-}
-
-function matchesAnySubscribed(candidate: string, subscribed: string[]): boolean {
-  for (const iri of subscribed) {
-    if (candidate === iri) return true;
-    if (candidate.startsWith(`${iri}/`)) return true;
-  }
-  return false;
-}

package/src/lib/bridge/sse/ref-count-topic.registry.ts

@@ -1,45 +0,0 @@
-export class RefCountTopicRegistry {
-  private readonly topics = new Set<string>();
-  private readonly refCounts = new Map<string, number>();
-
-  /**
-   * Increments ref-count for each topic.
-   * Callers should pass unique topic strings (deduped).
-   */
-  addAll(topics: Iterable<string>): void {
-    for (const topic of topics) {
-      const next = (this.refCounts.get(topic) ?? 0) + 1;
-      this.refCounts.set(topic, next);
-      this.topics.add(topic);
-    }
-  }
-
-  /**
-   * Decrements ref-count for each topic.
-   * Callers should pass unique topic strings (deduped).
-   */
-  removeAll(topics: Iterable<string>): void {
-    for (const topic of topics) {
-      const next = (this.refCounts.get(topic) ?? 0) - 1;
-      if (next <= 0) {
-        this.refCounts.delete(topic);
-        this.topics.delete(topic);
-      } else {
-        this.refCounts.set(topic, next);
-      }
-    }
-  }
-
-  hasAny(): boolean {
-    return this.topics.size > 0;
-  }
-
-  snapshot(): ReadonlySet<string> {
-    return new Set(this.topics);
-  }
-
-  computeKey(hubUrl: string, credentialsOn: boolean): string {
-    const topicsSorted = Array.from(this.topics).sort().join('|');
-    return `${hubUrl}::${credentialsOn ? '1' : '0'}::${topicsSorted}`;
-  }
-}

package/src/lib/bridge.types.ts

@@ -1,33 +0,0 @@
-/**
- * Public configuration types for the bridge.
- *
- * Keep this file dependency-free (no Angular imports) so it can be used from both
- * runtime code and type-only contexts.
- */
-
-export interface BridgeLogger {
-  debug: (...args: unknown[]) => void;
-  info: (...args: unknown[]) => void;
-  warn: (...args: unknown[]) => void;
-  error: (...args: unknown[]) => void;
-}
-
-export interface BridgeDefaults {
-  headers?: Record<string, string>;
-  timeoutMs?: number;
-  retries?:
-    | number
-    | {
-        count: number;
-        delayMs?: number;
-        methods?: string[];
-      };
-}
-
-/**
- * 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/...`)
- */
-export type MercureTopicMode = 'url' | 'iri';
-

package/src/lib/facades/bridge.facade.ts

@@ -1,108 +0,0 @@
-import {Inject, Injectable} from '@angular/core';
-import {HttpClient} from '@angular/common/http';
-import {Observable} from 'rxjs';
-import {filter, map, share} from 'rxjs/operators';
-import {toHttpParams} from '../bridge/rest/query-builder';
-import {buildHttpRequestOptions} from '../bridge/rest/http-request.options';
-import {MercureRealtimeAdapter} from '../bridge/sse/mercure.adapter';
-import {API_BASE_URL, BRIDGE_WITH_CREDENTIALS} from '../tokens';
-import {AnyQuery, Collection, HttpCallOptions, HttpRequestConfig, Iri, IriRequired, Item} from '../ports/resource-repository.port';
-import {SubscribeFilter} from '../ports/realtime.port';
-import {resolveUrl} from '../utils/url';
-
-/**
- * High-level facade for ad-hoc HTTP calls and Mercure subscriptions.
- *
- * Prefer `FacadeFactory` + `ResourceFacade<T>` when you want a resource-oriented API.
- */
-@Injectable({providedIn: 'root'})
-export class BridgeFacade {
-  constructor(
-    private readonly http: HttpClient,
-    private readonly realtime: MercureRealtimeAdapter,
-    @Inject(API_BASE_URL) private readonly apiBase: string,
-    @Inject(BRIDGE_WITH_CREDENTIALS) private readonly withCredentialsDefault: boolean,
-  ) {
-  }
-
-  // ──────────────── HTTP ────────────────
-
-  get$<R = unknown>(url: IriRequired, opts?: HttpCallOptions): Observable<R> {
-    return this.http.get<R>(this.resolveUrl(url), {
-      headers: opts?.headers,
-      withCredentials: opts?.withCredentials ?? this.withCredentialsDefault,
-    });
-  }
-
-  getCollection$<T extends Item = Item>(
-    url: IriRequired,
-    query?: AnyQuery,
-    opts?: HttpCallOptions
-  ): Observable<Collection<T>> {
-    const params = toHttpParams(query);
-    return this.http.get<Collection<T>>(this.resolveUrl(url), {
-      params,
-      headers: opts?.headers,
-      withCredentials: opts?.withCredentials ?? this.withCredentialsDefault,
-    });
-  }
-
-  post$<R = unknown, B = unknown>(url: IriRequired, payload: B, opts?: HttpCallOptions): Observable<R> {
-    return this.http.post<R>(this.resolveUrl(url), payload, {
-      headers: opts?.headers,
-      withCredentials: opts?.withCredentials ?? this.withCredentialsDefault,
-    });
-  }
-
-  patch$<R = unknown, B = unknown>(url: IriRequired, changes: B, opts?: HttpCallOptions): Observable<R> {
-    return this.http.patch<R>(this.resolveUrl(url), changes, {
-      headers: opts?.headers,
-      withCredentials: opts?.withCredentials ?? this.withCredentialsDefault,
-    });
-  }
-
-  put$<R = unknown, B = unknown>(url: IriRequired, payload: B, opts?: HttpCallOptions): Observable<R> {
-    return this.http.put<R>(this.resolveUrl(url), payload, {
-      headers: opts?.headers,
-      withCredentials: opts?.withCredentials ?? this.withCredentialsDefault,
-    });
-  }
-
-  delete$(url: IriRequired, opts?: HttpCallOptions): Observable<void> {
-    return this.http.delete<void>(this.resolveUrl(url), {
-      headers: opts?.headers,
-      withCredentials: opts?.withCredentials ?? this.withCredentialsDefault,
-    });
-  }
-
-  request$<R = unknown, B = unknown>(req: HttpRequestConfig<B>): Observable<R> {
-    const {method, url} = req;
-    const targetUrl = this.resolveUrl(url);
-
-    const mergedOptions = buildHttpRequestOptions(req, {withCredentialsDefault: this.withCredentialsDefault});
-    return this.http.request<R>(method, targetUrl, mergedOptions as {observe: 'body'});
-  }
-
-  // ──────────────── SSE / Mercure ────────────────
-
-  watch$<T = Item>(iri: Iri | Iri[], subscribeFilter?: SubscribeFilter): Observable<T> {
-    const iris = (Array.isArray(iri) ? iri : [iri]).filter((v): v is string => typeof v === 'string' && v.length > 0);
-    return this.realtime
-      .subscribe$<T>(iris, subscribeFilter)
-      .pipe(
-        map((event) => event.data),
-        filter((data): data is T => data !== undefined),
-        share()
-      );
-  }
-
-  unwatch(iri: Iri | Iri[]): void {
-    const iris = (Array.isArray(iri) ? iri : [iri]).filter((v): v is string => typeof v === 'string' && v.length > 0);
-    this.realtime.unsubscribe(iris);
-  }
-
-  private resolveUrl(path?: Iri): string {
-    if (!path) throw new Error('BridgeFacade: missing url');
-    return resolveUrl(this.apiBase, path);
-  }
-}

package/src/lib/facades/facade.factory.ts

@@ -1,38 +0,0 @@
-import {EnvironmentInjector, inject, Injectable, runInInjectionContext} from '@angular/core';
-import {HttpClient} from '@angular/common/http';
-import {RealtimePort} from '../ports/realtime.port';
-import {Item, ResourceRepository} from '../ports/resource-repository.port';
-import {API_BASE_URL, BRIDGE_WITH_CREDENTIALS} from '../tokens';
-import {MercureRealtimeAdapter} from '../bridge/sse/mercure.adapter';
-import {ApiPlatformRestRepository} from '../bridge/rest/api-platform.adapter';
-import {ResourceFacade} from './resource.facade';
-
-export type FacadeConfig<T> = {
-  url: string;
-  repo?: ResourceRepository<T>;
-  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 withCredentials = inject(BRIDGE_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.withCredentials);
-    const realtime = config.realtime ?? this.mercure;
-
-    return runInInjectionContext(this.env, () => new ResourceFacade<T>(repo, realtime));
-  }
-}

package/src/lib/facades/facade.interface.ts

@@ -1,30 +0,0 @@
-import {
-  Collection,
-  HttpRequestConfig,
-  Iri,
-  IriRequired,
-  Item,
-  HttpCallOptions,
-  AnyQuery,
-} from '../ports/resource-repository.port';
-import {Observable} from 'rxjs';
-
-export interface Facade<T extends Item> {
-  getCollection$(query?: AnyQuery, opts?: HttpCallOptions): Observable<Collection<T>>;
-
-  get$(iri: IriRequired, opts?: HttpCallOptions): Observable<T>;
-
-  post$(payload: Partial<T>, opts?: HttpCallOptions): Observable<T>;
-
-  patch$(iri: IriRequired, changes: Partial<T>, opts?: HttpCallOptions): Observable<T>;
-
-  put$(iri: IriRequired, payload: Partial<T>, opts?: HttpCallOptions): Observable<T>;
-
-  delete$(iri: IriRequired, opts?: HttpCallOptions): Observable<void>;
-
-  request$<R = unknown, B = unknown>(req: HttpRequestConfig<B>): Observable<R>;
-
-  watch$(iri: Iri | Iri[]): Observable<T>;
-
-  unwatch(iri: Iri | Iri[]): void;
-}

package/src/lib/facades/resource.facade.ts

@@ -1,101 +0,0 @@
-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 {Facade} from './facade.interface';
-
-export class ResourceFacade<T extends Item> implements Facade<T> {
-
-  readonly connectionStatus: Signal<RealtimeStatus>;
-
-  constructor(
-    protected readonly repo: ResourceRepository<T>,
-    protected readonly realtime: RealtimePort
-  ) {
-    this.connectionStatus = toSignal(
-      this.realtime.status$(),
-      {initialValue: 'closed'}
-    );
-  }
-
-  getCollection$(query?: AnyQuery, opts?: HttpCallOptions): Observable<Collection<T>> {
-    return this.repo.getCollection$(query, opts);
-  }
-
-  get$(iri: IriRequired, opts?: HttpCallOptions): Observable<T> {
-    return this.repo.get$(iri, opts);
-  }
-
-  patch$(iri: IriRequired, changes: Partial<T>, opts?: HttpCallOptions): Observable<T> {
-    return this.repo.patch$(iri, changes, opts);
-  }
-
-  post$(payload: Partial<T>, opts?: HttpCallOptions): Observable<T> {
-    return this.repo.post$(payload, opts);
-  }
-
-  put$(iri: IriRequired, payload: Partial<T>, opts?: HttpCallOptions): Observable<T> {
-    return this.repo.put$(iri, payload, opts);
-  }
-
-  delete$(iri: IriRequired, opts?: HttpCallOptions): Observable<void> {
-    return this.repo.delete$(iri, opts);
-  }
-
-  request$<R = unknown, B = unknown>(req: HttpRequestConfig<B>): Observable<R> {
-    return this.repo.request$<R, B>(req);
-  }
-
-  /**
-   * Subscribes to real-time updates for one or many IRIs.
-   * Undefined/empty values are ignored.
-   */
-  watch$(iri: Iri | Iri[]): Observable<T> {
-    const iris = (Array.isArray(iri) ? iri : [iri]).filter((v): v is string => typeof v === 'string' && v.length > 0);
-    return this.subscribeAndSync(iris);
-  }
-
-
-  unwatch(iri: Iri | Iri[]): void {
-    const iris = (Array.isArray(iri) ? iri : [iri]).filter((v): v is string => typeof v === 'string' && v.length > 0);
-    this.realtime.unsubscribe(iris);
-  }
-
-  /**
-   * 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`.
-   */
-  watchSubResource$<R>(
-    iri: Iri | Iri[],
-    field: string
-  ): Observable<R> {
-    const iris = (Array.isArray(iri) ? iri : [iri]).filter((v): v is string => typeof v === 'string' && v.length > 0);
-    return this.realtime
-      .subscribe$<R>(iris, {field: field})
-      .pipe(
-        map(e => e.data),
-        filter((d): d is R => d !== undefined),
-        share()
-      );
-  }
-
-  protected subscribeAndSync(iris: string[]): Observable<T> {
-    return this.realtime
-      .subscribe$<T>(iris)
-      .pipe(
-        map(event => event.data),
-        filter((data): data is T => data !== undefined),
-        share()
-      );
-  }
-}

package/src/lib/interceptors/bridge-debug.interceptor.ts

@@ -1,32 +0,0 @@
-import {HttpInterceptorFn, HttpResponse} from '@angular/common/http';
-import {inject} from '@angular/core';
-import {BRIDGE_LOGGER} from '../tokens';
-import {catchError, finalize, tap, throwError} from 'rxjs';
-
-/**
- * Lightweight request/response logging controlled by `provideBridge({debug: true})`.
- * Logs are delegated to the injected `BRIDGE_LOGGER`.
- */
-export const bridgeDebugInterceptor: HttpInterceptorFn = (req, next) => {
-  const logger = inject(BRIDGE_LOGGER, {optional: true});
-  if (!logger) return next(req);
-
-  const startedAt = Date.now();
-  logger.debug('[Bridge] request', {method: req.method, url: req.urlWithParams});
-
-  return next(req).pipe(
-    tap((evt) => {
-      if (evt instanceof HttpResponse) {
-        logger.debug('[Bridge] response', {method: req.method, url: req.urlWithParams, status: evt.status});
-      }
-    }),
-    catchError((err) => {
-      logger.error('[Bridge] error', {method: req.method, url: req.urlWithParams, err});
-      return throwError(() => err);
-    }),
-    finalize(() => {
-      const durationMs = Date.now() - startedAt;
-      logger.debug('[Bridge] done', {method: req.method, url: req.urlWithParams, durationMs});
-    })
-  );
-};