@obsidiane/meridiane 2.0.7 → 2.0.11

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

@@ -0,0 +1,98 @@
+import {EnvironmentProviders, makeEnvironmentProviders} from '@angular/core';
+import {HttpInterceptorFn, provideHttpClient, withFetch, withInterceptors} from '@angular/common/http';
+import {BridgeOptions} from './bridge-options';
+import {BridgeLogger, MercureConnectionMode, MercureTopicMode} from './bridge.types';
+import {createAuthInterceptors} from './interceptors/bearer-auth.interceptor';
+import {bridgeDebugInterceptor} from './interceptors/bridge-debug.interceptor';
+import {bridgeDefaultsInterceptor} from './interceptors/bridge-defaults.interceptor';
+import {contentTypeInterceptor} from './interceptors/content-type.interceptor';
+import {scopeInterceptor} from './interceptors/scoped.interceptor';
+import {createSingleFlightInterceptor} from './interceptors/singleflight.interceptor';
+import {
+  API_BASE_URL,
+  BRIDGE_DEFAULTS,
+  BRIDGE_HTTP_WITH_CREDENTIALS,
+  BRIDGE_LOGGER,
+  BRIDGE_MERCURE_WITH_CREDENTIALS,
+  MERCURE_CONNECTION_MODE,
+  MERCURE_HUB_URL,
+  MERCURE_MAX_URL_LENGTH,
+  MERCURE_TOPIC_MODE,
+} from './tokens';
+
+export type {BridgeAuth, BridgeHttpOptions, BridgeMercureOptions, BridgeOptions} from './bridge-options';
+
+/** Registers the bridge HTTP client, interceptors, Mercure realtime adapter and configuration tokens. */
+export function provideBridge(options: BridgeOptions): EnvironmentProviders {
+  const {
+    baseUrl,
+    auth,
+    http,
+    mercure,
+    defaults,
+    singleFlight = true,
+    debug = false,
+    extraInterceptors = [],
+  } = options;
+
+  if (!baseUrl) {
+    throw new Error("provideBridge(): missing 'baseUrl'");
+  }
+
+  const resolvedMercureInit: RequestInit = mercure?.init ?? {credentials: 'include' as RequestCredentials};
+  const resolvedMercureHubUrl = mercure?.hubUrl;
+  const resolvedMercureTopicMode: MercureTopicMode = mercure?.topicMode ?? 'url';
+  const resolvedMercureConnectionMode: MercureConnectionMode = mercure?.connectionMode ?? 'auto';
+  const resolvedMercureMaxUrlLength = normalizeMercureMaxUrlLength(mercure?.maxUrlLength, 1900);
+  const mercureWithCredentials = resolveWithCredentials(resolvedMercureInit);
+  const httpWithCredentials = http?.withCredentials ?? mercureWithCredentials;
+
+  const loggerProvider: BridgeLogger = createBridgeLogger(debug);
+  const scopeToBridge = (interceptor: HttpInterceptorFn) => scopeInterceptor(baseUrl, interceptor);
+
+  const interceptors: HttpInterceptorFn[] = [
+    scopeToBridge(contentTypeInterceptor),
+    scopeToBridge(bridgeDefaultsInterceptor),
+    ...createAuthInterceptors(auth, baseUrl),
+    ...(singleFlight ? [scopeToBridge(createSingleFlightInterceptor())] : []),
+    ...(debug ? [scopeToBridge(bridgeDebugInterceptor)] : []),
+    ...extraInterceptors,
+  ];
+
+  return makeEnvironmentProviders([
+    provideHttpClient(
+      withFetch(),
+      withInterceptors(interceptors)
+    ),
+    {provide: API_BASE_URL, useValue: baseUrl},
+    {provide: BRIDGE_HTTP_WITH_CREDENTIALS, useValue: httpWithCredentials},
+    {provide: BRIDGE_MERCURE_WITH_CREDENTIALS, useValue: mercureWithCredentials},
+    ...(resolvedMercureHubUrl ? [{provide: MERCURE_HUB_URL, useValue: resolvedMercureHubUrl}] : []),
+    {provide: MERCURE_TOPIC_MODE, useValue: resolvedMercureTopicMode},
+    {provide: MERCURE_CONNECTION_MODE, useValue: resolvedMercureConnectionMode},
+    {provide: MERCURE_MAX_URL_LENGTH, useValue: resolvedMercureMaxUrlLength},
+    {provide: BRIDGE_DEFAULTS, useValue: defaults ?? {}},
+    {provide: BRIDGE_LOGGER, useValue: loggerProvider},
+  ]);
+}
+
+function createBridgeLogger(debug: boolean): BridgeLogger {
+  const noop = () => undefined;
+  return {
+    debug: debug ? console.debug.bind(console) : noop,
+    info: debug ? console.info.bind(console) : noop,
+    warn: debug ? console.warn.bind(console) : noop,
+    error: console.error.bind(console),
+  };
+}
+
+function resolveWithCredentials(init: RequestInit | undefined): boolean {
+  if (!init) return false;
+  const anyInit = init as RequestInit & {withCredentials?: boolean};
+  return anyInit.withCredentials === true || init.credentials === 'include';
+}
+
+function normalizeMercureMaxUrlLength(input: unknown, fallback: number): number {
+  const value = typeof input === 'number' ? Math.floor(input) : fallback;
+  return Number.isFinite(value) && value >= 256 ? value : fallback;
+}

package/templates/{_lib_template → angular-bridge}/src/lib/tokens.ts

@@ -8,10 +8,16 @@ export const API_BASE_URL = new InjectionToken<string>('API_BASE_URL');
 export const MERCURE_HUB_URL = new InjectionToken<string>('MERCURE_HUB_URL');
 
 /**
- * Default credential policy for HTTP requests and Mercure EventSource.
- * When `true`, the bridge sets `withCredentials: true` on HTTP calls and uses cookies for SSE.
+ * Default credential policy for HTTP requests.
+ * When `true`, the bridge sets `withCredentials: true` on HTTP calls.
  */
-export const BRIDGE_WITH_CREDENTIALS = new InjectionToken<boolean>('BRIDGE_WITH_CREDENTIALS');
+export const BRIDGE_HTTP_WITH_CREDENTIALS = new InjectionToken<boolean>('BRIDGE_HTTP_WITH_CREDENTIALS');
+
+/**
+ * Default credential policy for Mercure EventSource.
+ * When `true`, the bridge opens SSE connections with cookies enabled.
+ */
+export const BRIDGE_MERCURE_WITH_CREDENTIALS = new InjectionToken<boolean>('BRIDGE_MERCURE_WITH_CREDENTIALS');
 
 export const MERCURE_TOPIC_MODE = new InjectionToken<MercureTopicMode>('MERCURE_TOPIC_MODE');
 

package/templates/angular-bridge/src/lib/utils/iri.ts

@@ -0,0 +1,6 @@
+import {Iri} from '../ports/resource-repository.port';
+
+export function toIriList(input: Iri | Iri[]): string[] {
+  const values = Array.isArray(input) ? input : [input];
+  return values.filter((value): value is string => typeof value === 'string' && value.length > 0);
+}

package/templates/angular-bridge/src/lib/utils/request-url.ts

@@ -0,0 +1,31 @@
+type UrlKind = 'absolute' | 'protocol-relative' | 'relative';
+
+/** Returns whether a request belongs to the configured API origin and path. */
+export function isRequestWithinBaseUrl(requestUrl: string, baseUrl: string): boolean {
+  try {
+    const kind = classifyUrl(baseUrl);
+    if (kind !== classifyUrl(requestUrl)) return false;
+
+    const protocol = kind === 'absolute' && baseUrl.toLowerCase().startsWith('http://') ? 'http:' : 'https:';
+    const comparisonOrigin = `${protocol}//bridge.invalid`;
+    const base = new URL(baseUrl, `${comparisonOrigin}/`);
+    const request = new URL(requestUrl, `${comparisonOrigin}/`);
+
+    if (base.origin !== request.origin) return false;
+
+    const basePath = trimTrailingSlash(base.pathname);
+    return basePath === '/' || request.pathname === basePath || request.pathname.startsWith(`${basePath}/`);
+  } catch {
+    return false;
+  }
+}
+
+function classifyUrl(url: string): UrlKind {
+  if (/^https?:\/\//i.test(url)) return 'absolute';
+  if (url.startsWith('//')) return 'protocol-relative';
+  return 'relative';
+}
+
+function trimTrailingSlash(pathname: string): string {
+  return pathname === '/' ? pathname : pathname.replace(/\/+$/, '') || '/';
+}

package/templates/{_lib_template → angular-bridge}/src/public-api.ts

@@ -3,6 +3,8 @@ export * from './lib/bridge.types';
 export * from './lib/facades/facade.factory';
 export * from './lib/facades/bridge.facade';
 export * from './lib/facades/resource.facade';
+export * from './lib/facades/facade.interface';
+export * from './lib/ports/realtime.port';
 export * from './lib/ports/resource-repository.port';
 export * from './lib/utils/url';
 

package/templates/_lib_template/src/lib/bridge/rest/api-platform.adapter.ts

@@ -1,84 +0,0 @@
-import {HttpClient} from '@angular/common/http';
-import {Observable} from 'rxjs';
-import {toHttpParams} from './query-builder';
-import {buildHttpRequestOptions} from './http-request.options';
-import {
-  Collection,
-  HttpCallOptions,
-  HttpRequestConfig,
-  Iri,
-  IriRequired,
-  Item,
-  AnyQuery,
-  ResourceRepository,
-} from '../../ports/resource-repository.port';
-import {resolveUrl} from '../../utils/url';
-
-export class ApiPlatformRestRepository<T extends Item> implements ResourceRepository<T> {
-  constructor(
-    private readonly http: HttpClient,
-    private readonly apiBase: string,
-    private readonly resourcePath: Iri,
-    private readonly withCredentialsDefault: boolean,
-  ) {
-  }
-
-  getCollection$(query?: AnyQuery, opts?: HttpCallOptions): Observable<Collection<T>> {
-    const params = toHttpParams(query);
-    return this.http.get<Collection<T>>(this.resolveUrl(this.resourcePath), {
-      params,
-      headers: opts?.headers,
-      withCredentials: opts?.withCredentials ?? this.withCredentialsDefault,
-    });
-  }
-
-  get$(iri: IriRequired, opts?: HttpCallOptions): Observable<T> {
-    return this.http.get<T>(this.resolveUrl(iri), {
-      headers: opts?.headers,
-      withCredentials: opts?.withCredentials ?? this.withCredentialsDefault,
-    });
-  }
-
-  post$(payload: Partial<T>, opts?: HttpCallOptions): Observable<T> {
-    return this.http.post<T>(this.resolveUrl(this.resourcePath), payload, {
-      headers: opts?.headers,
-      withCredentials: opts?.withCredentials ?? this.withCredentialsDefault,
-    });
-  }
-
-  patch$(iri: IriRequired, changes: Partial<T>, opts?: HttpCallOptions): Observable<T> {
-    return this.http.patch<T>(this.resolveUrl(iri), changes, {
-      headers: opts?.headers,
-      withCredentials: opts?.withCredentials ?? this.withCredentialsDefault,
-    });
-  }
-
-  put$(iri: IriRequired, payload: Partial<T>, opts?: HttpCallOptions): Observable<T> {
-    return this.http.put<T>(this.resolveUrl(iri), payload, {
-      headers: opts?.headers,
-      withCredentials: opts?.withCredentials ?? this.withCredentialsDefault,
-    });
-  }
-
-  delete$(iri: IriRequired, opts?: HttpCallOptions): Observable<void> {
-    return this.http.delete<void>(this.resolveUrl(iri), {
-      headers: opts?.headers,
-      withCredentials: opts?.withCredentials ?? this.withCredentialsDefault,
-    });
-  }
-
-  request$<R = unknown, B = unknown>(req: HttpRequestConfig<B>): Observable<R> {
-    // Low-level escape hatch for non-standard endpoints (custom controllers, uploads, etc.).
-    const {method, url} = req;
-
-    const targetUrl = this.resolveUrl(url ?? this.resourcePath);
-    const mergedOptions = buildHttpRequestOptions(req, {withCredentialsDefault: this.withCredentialsDefault});
-    return this.http.request<R>(method, targetUrl, mergedOptions as {observe: 'body'});
-  }
-
-  private resolveUrl(path?: Iri): string {
-    const effectivePath = path ?? this.resourcePath;
-    if (!effectivePath) throw new Error('ApiPlatformRestRepository: missing url and resourcePath');
-    return resolveUrl(this.apiBase, effectivePath);
-  }
-}

package/templates/_lib_template/src/lib/bridge/rest/http-request.options.ts

@@ -1,21 +0,0 @@
-import {HttpRequestConfig} from '../../ports/resource-repository.port';
-import {toHttpParams} from './query-builder';
-
-export function buildHttpRequestOptions(
-  req: HttpRequestConfig,
-  {withCredentialsDefault}: {withCredentialsDefault: boolean}
-): Record<string, unknown> {
-  const {query, body, headers, responseType, withCredentials, options = {}} = req;
-  const mergedOptions: Record<string, unknown> = {...options};
-
-  if (headers) mergedOptions['headers'] = headers;
-  if (query) mergedOptions['params'] = toHttpParams(query);
-  if (body !== undefined) mergedOptions['body'] = body;
-
-  mergedOptions['responseType'] = (responseType ?? (mergedOptions['responseType'] as any) ?? 'json') as any;
-  mergedOptions['withCredentials'] =
-    withCredentials ?? (mergedOptions['withCredentials'] as any) ?? withCredentialsDefault;
-  mergedOptions['observe'] = 'body';
-
-  return mergedOptions;
-}

package/templates/_lib_template/src/lib/bridge/sse/mercure-url.builder.ts

@@ -1,17 +0,0 @@
-export class MercureUrlBuilder {
-  /**
-   * Builds the Mercure hub URL with one `topic=` parameter per topic.
-   * The adapter is responsible for canonicalising topics beforehand.
-   */
-  build(hubUrl: string, topics: ReadonlySet<string>, lastEventId?: string): string {
-    const url = new URL(hubUrl);
-    if (lastEventId) {
-      url.searchParams.set('lastEventID', lastEventId);
-    }
-    url.searchParams.delete('topic');
-    for (const topic of topics) {
-      url.searchParams.append('topic', topic);
-    }
-    return url.toString();
-  }
-}