@obsidiane/meridiane 2.0.13 → 3.0.1

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

@@ -1,82 +0,0 @@
-import {HttpClient} from '@angular/common/http';
-import {Observable} from 'rxjs';
-import {toHttpParams} from './query-builder';
-import {buildHttpRequestOptions, resolveHttpCallOptions} 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 httpWithCredentialsDefault: boolean,
-  ) {
-  }
-
-  getCollection$(query?: AnyQuery, options?: HttpCallOptions): Observable<Collection<T>> {
-    return this.http.get<Collection<T>>(this.resolveUrl(this.resourcePath), {
-      ...resolveHttpCallOptions(options, this.httpWithCredentialsDefault),
-      params: toHttpParams(query),
-    });
-  }
-
-  get$(iri: IriRequired, options?: HttpCallOptions): Observable<T> {
-    return this.http.get<T>(this.resolveUrl(iri), resolveHttpCallOptions(options, this.httpWithCredentialsDefault));
-  }
-
-  post$(payload: Partial<T>, options?: HttpCallOptions): Observable<T> {
-    return this.http.post<T>(
-      this.resolveUrl(this.resourcePath),
-      payload,
-      resolveHttpCallOptions(options, this.httpWithCredentialsDefault)
-    );
-  }
-
-  patch$(iri: IriRequired, changes: Partial<T>, options?: HttpCallOptions): Observable<T> {
-    return this.http.patch<T>(
-      this.resolveUrl(iri),
-      changes,
-      resolveHttpCallOptions(options, this.httpWithCredentialsDefault)
-    );
-  }
-
-  put$(iri: IriRequired, payload: Partial<T>, options?: HttpCallOptions): Observable<T> {
-    return this.http.put<T>(
-      this.resolveUrl(iri),
-      payload,
-      resolveHttpCallOptions(options, this.httpWithCredentialsDefault)
-    );
-  }
-
-  delete$(iri: IriRequired, options?: HttpCallOptions): Observable<void> {
-    return this.http.delete<void>(
-      this.resolveUrl(iri),
-      resolveHttpCallOptions(options, this.httpWithCredentialsDefault)
-    );
-  }
-
-  request$<R = unknown, B = unknown>(request: HttpRequestConfig<B>): Observable<R> {
-    // Low-level escape hatch for non-standard endpoints (custom controllers, uploads, etc.).
-    const {method, url} = request;
-
-    const targetUrl = this.resolveUrl(url ?? this.resourcePath);
-    const mergedOptions = buildHttpRequestOptions(request, {withCredentialsDefault: this.httpWithCredentialsDefault});
-    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/angular-bridge/src/lib/bridge/sse/eventsource-wrapper.ts

@@ -1,70 +0,0 @@
-import {ReplaySubject, Subject} from 'rxjs';
-import {SseEvent, SseOptions, RealtimeStatus} from '../../ports/realtime.port';
-import {BridgeLogger} from '../../bridge.types';
-
-export class EventSourceWrapper {
-  private es?: EventSource;
-
-  private readonly statusSub = new ReplaySubject<RealtimeStatus>(1);
-  private readonly eventSub = new Subject<SseEvent>();
-
-  readonly status$ = this.statusSub.asObservable();
-  readonly events$ = this.eventSub.asObservable();
-
-  constructor(
-    private readonly url: string,
-    private readonly opts: SseOptions = {},
-    private readonly logger?: BridgeLogger,
-  ) {
-    this.setState('closed');
-    this.log('[SSE] init', {url, withCredentials: !!opts.withCredentials});
-  }
-
-  open(): void {
-    if (this.es) {
-      this.log('[SSE] open() ignored: already open');
-      return;
-    }
-
-    this.setState('connecting');
-    this.log('[SSE] open', {url: this.url});
-
-    const es = new EventSource(this.url, {
-      withCredentials: !!this.opts.withCredentials,
-    });
-    this.es = es;
-
-    es.onopen = () => {
-      this.setState('connected');
-    };
-
-    es.onmessage = (ev) => {
-      this.eventSub.next({type: 'message', data: ev.data, lastEventId: ev.lastEventId || undefined});
-    };
-
-    es.onerror = () => {
-      // The browser will retry automatically. We stay in "connecting".
-      this.log('[SSE] error');
-      this.setState('connecting');
-    };
-  }
-
-  close(): void {
-    if (this.es) {
-      this.es.close();
-      this.es = undefined;
-      this.log('[SSE] closed');
-    }
-    this.setState('closed');
-  }
-
-  // ──────────────── internals ────────────────
-
-  private setState(state: RealtimeStatus): void {
-    this.statusSub.next(state);
-  }
-
-  private log(...args: unknown[]): void {
-    this.logger?.debug?.(...args);
-  }
-}

package/templates/angular-bridge/src/lib/bridge/sse/mercure-connections.ts

@@ -1,255 +0,0 @@
-import {BehaviorSubject, Observable, Subject} from 'rxjs';
-import {takeUntil} from 'rxjs/operators';
-import {
-  BridgeLogger,
-  MercureConnectionMode,
-  RealtimeDiagnostics,
-} from '../../bridge.types';
-import {RealtimeStatus} from '../../ports/realtime.port';
-import {EventSourceWrapper} from './eventsource-wrapper';
-import {MercureUrlBuilder} from './mercure-url.builder';
-
-export type IncomingMessage = {type: string; data: string; lastEventId?: string};
-
-type ConnectionScope = 'shared' | 'dedicated';
-
-type ManagedConnection = {
-  id: string;
-  key: string;
-  scope: ConnectionScope;
-  groupId?: string;
-  topics: ReadonlySet<string>;
-  urlLength: number;
-  wrapper: EventSourceWrapper;
-  stop$: Subject<void>;
-  status: RealtimeStatus;
-};
-
-type ConnectionTarget = Subject<IncomingMessage>;
-
-type ConnectionManagerOptions = {
-  hubUrl?: string;
-  withCredentials: boolean;
-  mode: MercureConnectionMode;
-  maxUrlLength: number;
-  logger?: BridgeLogger;
-  destroy$: Observable<void>;
-  nextId: (prefix: string) => string;
-};
-
-export class MercureConnectionManager {
-  private readonly urlBuilder = new MercureUrlBuilder();
-  private readonly connections = new Map<string, ManagedConnection>();
-  private readonly sharedConnections = new Map<string, ManagedConnection>();
-  private readonly dedicatedGroups = new Map<string, Set<string>>();
-  private readonly lastEventIdByKey = new Map<string, string>();
-
-  private readonly statusSubject = new BehaviorSubject<RealtimeStatus>('closed');
-  private readonly diagnosticsSubject: BehaviorSubject<RealtimeDiagnostics>;
-
-  readonly status$ = this.statusSubject.asObservable();
-  readonly diagnostics$: Observable<RealtimeDiagnostics>;
-
-  constructor(private readonly options: ConnectionManagerOptions) {
-    this.diagnosticsSubject = new BehaviorSubject<RealtimeDiagnostics>(this.createDiagnostics());
-    this.diagnostics$ = this.diagnosticsSubject.asObservable();
-  }
-
-  reconcileShared(topics: Iterable<string>, target: ConnectionTarget): void {
-    if (!this.options.hubUrl) {
-      this.closeShared();
-      return;
-    }
-
-    const desiredConnections = new Map<string, ReadonlySet<string>>();
-    for (const partition of this.partitionTopics(topics)) {
-      const partitionTopics = new Set(partition);
-      desiredConnections.set(this.connectionKey(partitionTopics, 'shared'), partitionTopics);
-    }
-
-    for (const [key, connection] of [...this.sharedConnections.entries()]) {
-      if (!desiredConnections.has(key)) this.close(connection.id);
-    }
-
-    for (const [key, partitionTopics] of desiredConnections) {
-      if (this.sharedConnections.has(key)) continue;
-      const connection = this.open({key, scope: 'shared', topics: partitionTopics, target});
-      this.sharedConnections.set(key, connection);
-    }
-  }
-
-  openDedicated(groupId: string, topics: Iterable<string>, target: ConnectionTarget): void {
-    this.dedicatedGroups.set(groupId, new Set());
-
-    for (const partition of this.partitionTopics(topics)) {
-      const partitionTopics = new Set(partition);
-      const key = this.connectionKey(partitionTopics, 'dedicated', groupId);
-      const connection = this.open({key, scope: 'dedicated', groupId, topics: partitionTopics, target});
-      this.dedicatedGroups.get(groupId)?.add(connection.id);
-    }
-  }
-
-  closeShared(): void {
-    for (const connection of [...this.sharedConnections.values()]) this.close(connection.id);
-  }
-
-  closeDedicated(groupId: string): void {
-    const connectionIds = this.dedicatedGroups.get(groupId);
-    if (!connectionIds) return;
-
-    for (const connectionId of [...connectionIds]) this.close(connectionId);
-    this.dedicatedGroups.delete(groupId);
-  }
-
-  closeAll(): void {
-    for (const connection of [...this.connections.values()]) this.close(connection.id);
-    this.sharedConnections.clear();
-    this.dedicatedGroups.clear();
-    this.updateStatus();
-  }
-
-  complete(): void {
-    this.statusSubject.complete();
-    this.diagnosticsSubject.complete();
-  }
-
-  private partitionTopics(topics: Iterable<string>): string[][] {
-    if (!this.options.hubUrl) return [];
-    return this.urlBuilder.partitionTopics(
-      this.options.hubUrl,
-      topics,
-      this.options.maxUrlLength,
-      this.options.mode === 'auto'
-    );
-  }
-
-  private open(params: {
-    key: string;
-    scope: ConnectionScope;
-    topics: ReadonlySet<string>;
-    target: ConnectionTarget;
-    groupId?: string;
-  }): ManagedConnection {
-    const {hubUrl, withCredentials, logger, destroy$, nextId} = this.options;
-    if (!hubUrl) throw new Error('Mercure hub URL is required to open a realtime connection.');
-
-    const lastEventId = this.lastEventIdByKey.get(params.key);
-    const url = this.urlBuilder.build(hubUrl, params.topics, lastEventId);
-
-    logger?.debug?.('[Mercure] connect', {
-      mode: this.options.mode,
-      scope: params.scope,
-      key: params.key,
-      urlLength: url.length,
-      topics: [...params.topics],
-      lastEventId,
-    });
-
-    const wrapper = new EventSourceWrapper(url, {withCredentials}, logger);
-    const stop$ = new Subject<void>();
-    const connection: ManagedConnection = {
-      id: nextId('conn'),
-      key: params.key,
-      scope: params.scope,
-      groupId: params.groupId,
-      topics: params.topics,
-      urlLength: url.length,
-      wrapper,
-      stop$,
-      status: 'connecting',
-    };
-
-    this.connections.set(connection.id, connection);
-
-    wrapper.status$
-      .pipe(takeUntil(stop$), takeUntil(destroy$))
-      .subscribe((status) => {
-        connection.status = status;
-        this.updateStatus();
-      });
-
-    wrapper.events$
-      .pipe(takeUntil(stop$), takeUntil(destroy$))
-      .subscribe((event) => {
-        if (event.lastEventId) this.lastEventIdByKey.set(params.key, event.lastEventId);
-        params.target.next({type: event.type, data: event.data, lastEventId: event.lastEventId});
-      });
-
-    try {
-      wrapper.open();
-      this.updateStatus();
-      return connection;
-    } catch (error) {
-      this.close(connection.id);
-      throw error;
-    }
-  }
-
-  private close(connectionId: string): void {
-    const connection = this.connections.get(connectionId);
-    if (!connection) return;
-
-    connection.status = 'closed';
-    connection.wrapper.close();
-    connection.stop$.next();
-    connection.stop$.complete();
-    this.connections.delete(connectionId);
-
-    if (connection.scope === 'shared') this.sharedConnections.delete(connection.key);
-    if (connection.scope === 'dedicated' && connection.groupId) {
-      const group = this.dedicatedGroups.get(connection.groupId);
-      group?.delete(connection.id);
-      if (group?.size === 0) this.dedicatedGroups.delete(connection.groupId);
-      this.lastEventIdByKey.delete(connection.key);
-    }
-
-    this.updateStatus();
-  }
-
-  private connectionKey(topics: ReadonlySet<string>, scope: ConnectionScope, groupId = ''): string {
-    const {hubUrl = '', withCredentials, mode} = this.options;
-    return [
-      scope,
-      groupId,
-      hubUrl,
-      withCredentials ? '1' : '0',
-      mode,
-      [...topics].sort().join('|'),
-    ].join('::');
-  }
-
-  private updateStatus(): void {
-    const statuses = [...this.connections.values()].map((connection) => connection.status);
-    this.statusSubject.next(aggregateStatus(statuses));
-    this.diagnosticsSubject.next(this.createDiagnostics());
-  }
-
-  private createDiagnostics(): RealtimeDiagnostics {
-    const connections = [...this.connections.values()]
-      .map((connection) => ({
-        id: connection.id,
-        scope: connection.scope,
-        status: connection.status,
-        topicCount: connection.topics.size,
-        topics: [...connection.topics].sort(),
-        urlLength: connection.urlLength,
-      }))
-      .sort((left, right) => left.scope.localeCompare(right.scope) || left.id.localeCompare(right.id));
-    const sharedConnections = connections.filter((connection) => connection.scope === 'shared').length;
-
-    return {
-      mode: this.options.mode,
-      maxUrlLength: this.options.maxUrlLength,
-      totalConnections: connections.length,
-      sharedConnections,
-      dedicatedConnections: connections.length - sharedConnections,
-      connections,
-    };
-  }
-}
-
-function aggregateStatus(statuses: RealtimeStatus[]): RealtimeStatus {
-  if (statuses.includes('connected')) return 'connected';
-  if (statuses.includes('connecting')) return 'connecting';
-  return 'closed';
-}

package/templates/angular-bridge/src/lib/bridge/sse/mercure-payload.ts

@@ -1,82 +0,0 @@
-import {BridgeLogger} from '../../bridge.types';
-import {SubscribeFilter} from '../../ports/realtime.port';
-import {Item} from '../../ports/resource-repository.port';
-import {MercureTopicMapper} from './mercure-topic.mapper';
-
-export function parseMercurePayload(raw: string, logger?: BridgeLogger): Item | undefined {
-  try {
-    const value: unknown = JSON.parse(raw);
-    return isRecord(value) ? value as Item : undefined;
-  } catch {
-    logger?.debug?.('[Mercure] invalid JSON payload ignored', {raw});
-    return undefined;
-  }
-}
-
-export function createPayloadTopicMatcher(
-  iris: string[],
-  filter: SubscribeFilter | undefined,
-  topicMapper: MercureTopicMapper
-): (payload: Item) => string | undefined {
-  const subscribedTopics = iris.map((iri) => normalizeIri(topicMapper.toPayloadIri(iri)));
-  const fieldPaths = [
-    ...(filter?.fields?.filter((field): field is string => typeof field === 'string' && field.length > 0) ?? []),
-    ...(typeof filter?.field === 'string' && filter.field.length > 0 ? [filter.field] : []),
-  ];
-  const includeSelf = filter?.includeSelf ?? fieldPaths.length === 0;
-
-  return (payload) => {
-    for (const fieldPath of fieldPaths) {
-      const relationIris = readRelationIris(payload, fieldPath)
-        .map((iri) => normalizeIri(topicMapper.toPayloadIri(iri)));
-      for (const relationIri of relationIris) {
-        const match = findClosestTopic(relationIri, subscribedTopics);
-        if (match) return match;
-      }
-    }
-
-    if (!includeSelf) return undefined;
-
-    const payloadIri = payload['@id'];
-    if (typeof payloadIri !== 'string') return undefined;
-    return findClosestTopic(normalizeIri(topicMapper.toPayloadIri(payloadIri)), subscribedTopics);
-  };
-}
-
-function readRelationIris(payload: Item, path: string): string[] {
-  const value = path
-    .split('.')
-    .filter(Boolean)
-    .reduce<unknown>((current, key) => isIndexable(current) ? current[key] : undefined, payload);
-
-  return extractIris(value);
-}
-
-function extractIris(value: unknown): string[] {
-  if (!value) return [];
-  if (typeof value === 'string') return value.length > 0 ? [value] : [];
-  if (isIndexable(value) && typeof value['@id'] === 'string') return [value['@id']];
-  if (Array.isArray(value)) return value.flatMap(extractIris);
-  return [];
-}
-
-function findClosestTopic(candidate: string, subscribedTopics: string[]): string | undefined {
-  let closest: string | undefined;
-  for (const topic of subscribedTopics) {
-    if (candidate !== topic && !candidate.startsWith(`${topic}/`)) continue;
-    if (!closest || topic.length > closest.length) closest = topic;
-  }
-  return closest;
-}
-
-function normalizeIri(iri: string): string {
-  return iri.endsWith('/') ? iri.slice(0, -1) : iri;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === 'object' && !Array.isArray(value);
-}
-
-function isIndexable(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === 'object';
-}

package/templates/angular-bridge/src/lib/bridge/sse/mercure-topic.mapper.ts

@@ -1,48 +0,0 @@
-import {MercureTopicMode} from '../../bridge.types';
-
-export class MercureTopicMapper {
-  private readonly apiBaseUrl: URL;
-
-  constructor(
-    apiBase: string,
-    private readonly mode: MercureTopicMode,
-  ) {
-    this.apiBaseUrl = new URL(apiBase);
-  }
-
-  /**
-   * Canonical value used for ref-counting and as the "topic" query param value.
-   * - mode "url": always absolute, same-origin resolved
-   * - mode "iri": same-origin path+query+hash ("/api/..."), otherwise keep as-is
-   */
-  toTopic(input: string): string {
-    if (this.mode === 'url') return this.toAbsoluteUrl(input);
-    return this.toRelativeIriIfSameOrigin(input);
-  }
-
-  /**
-   * Canonical value used to compare incoming payload IRIs with subscribed IRIs.
-   * We keep payload matching stable by using same-origin relative IRIs ("/api/...").
-   */
-  toPayloadIri(input: string): string {
-    return this.toRelativeIriIfSameOrigin(input);
-  }
-
-  private toAbsoluteUrl(input: string): string {
-    try {
-      return new URL(input, this.apiBaseUrl).toString();
-    } catch {
-      return input;
-    }
-  }
-
-  private toRelativeIriIfSameOrigin(input: string): string {
-    try {
-      const url = new URL(input, this.apiBaseUrl);
-      if (url.origin !== this.apiBaseUrl.origin) return input;
-      return `${url.pathname}${url.search}${url.hash}`;
-    } catch {
-      return input;
-    }
-  }
-}

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

@@ -1,39 +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();
-  }
-
-  partitionTopics(hubUrl: string, topics: Iterable<string>, maxUrlLength: number, allowSplit: boolean): string[][] {
-    const sortedTopics = [...new Set(topics)].sort();
-    if (sortedTopics.length === 0) return [];
-    if (!allowSplit) return [sortedTopics];
-
-    const partitions: string[][] = [];
-    let current: string[] = [];
-
-    for (const topic of sortedTopics) {
-      const candidate = [...current, topic];
-      if (current.length > 0 && this.build(hubUrl, new Set(candidate)).length > maxUrlLength) {
-        partitions.push(current);
-        current = [topic];
-      } else {
-        current = candidate;
-      }
-    }
-
-    if (current.length > 0) partitions.push(current);
-    return partitions;
-  }
-}