@obsidiane/meridiane 0.0.6 → 0.0.7

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

@@ -1,15 +1,18 @@
 import {Signal} from '@angular/core';
 import {
   ResourceRepository,
-  Query,
-  CreateCommand,
-  UpdateCommand,
-  Collection, Iri, Item, HttpRequestConfig
+  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 {map, shareReplay, filter, Observable} from 'rxjs';
-import {Facade, RestRequest} from './facade.interface';
+import {filter, map, Observable, share} from 'rxjs';
+import {Facade} from './facade.interface';
 
 export class ResourceFacade<T extends Item> implements Facade<T> {
 
@@ -17,99 +20,82 @@ export class ResourceFacade<T extends Item> implements Facade<T> {
 
   constructor(
     protected readonly repo: ResourceRepository<T>,
-    protected readonly realtime: RealtimePort,
-    protected readonly resourcePath: string
+    protected readonly realtime: RealtimePort
   ) {
-    this.resourcePath = resourcePath;
     this.connectionStatus = toSignal(
       this.realtime.status$(),
-      {initialValue: 'offline' as RealtimeStatus}
+      {initialValue: 'closed'}
     );
   }
 
-  list$(query?: Query): Observable<Collection<T>> {
-    return this.repo.list$(query)
+  getCollection$(query?: AnyQuery, opts?: HttpCallOptions): Observable<Collection<T>> {
+    return this.repo.getCollection$(query, opts);
   }
 
-  get$(iri: Iri): Observable<T> {
-    return this.repo.get$(iri).pipe(
-      shareReplay({bufferSize: 1, refCount: true})
-    );
-  }
-
-  create$(cmd: CreateCommand<T>) {
-    return this.repo.create$(cmd).pipe(
-      shareReplay({bufferSize: 1, refCount: true})
-    );
-  }
-
-  update$(cmd: UpdateCommand<T>) {
-    return this.repo.update$(cmd).pipe(
-      shareReplay({bufferSize: 1, refCount: true})
-    );
+  get$(iri: IriRequired, opts?: HttpCallOptions): Observable<T> {
+    return this.repo.get$(iri, opts);
   }
 
-  delete$(iri: Iri): Observable<void> {
-    return this.repo.delete$(iri).pipe(
-      shareReplay({bufferSize: 1, refCount: true})
-    );
+  patch$(iri: IriRequired, changes: Partial<T>, opts?: HttpCallOptions): Observable<T> {
+    return this.repo.patch$(iri, changes, opts);
   }
 
-  request$<R = unknown, B = unknown>(req: HttpRequestConfig<B>): Observable<R> {
-    return this.repo.request$<R, B>(req).pipe(
-      shareReplay({bufferSize: 1, refCount: true})
-    );
+  post$(payload: Partial<T>, opts?: HttpCallOptions): Observable<T> {
+    return this.repo.post$(payload, opts);
   }
 
-  post$<R = unknown, B = unknown>(req: RestRequest<B> = {}): Observable<R> {
-    return this.request$<R, B>({...req, method: 'POST'});
+  put$(iri: IriRequired, payload: Partial<T>, opts?: HttpCallOptions): Observable<T> {
+    return this.repo.put$(iri, payload, opts);
   }
 
-  put$<R = unknown, B = unknown>(req: RestRequest<B> = {}): Observable<R> {
-    return this.request$<R, B>({...req, method: 'PUT'});
+  delete$(iri: IriRequired, opts?: HttpCallOptions): Observable<void> {
+    return this.repo.delete$(iri, opts);
   }
 
-  patch$<R = unknown, B = unknown>(req: RestRequest<B> = {}): Observable<R> {
-    return this.request$<R, B>({...req, method: 'PATCH'});
+  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> {
-    if (Array.isArray(iri)) {
-      return this.subscribeAndSync(iri);
-    }
-    return this.subscribeAndSync([iri]);
+    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 {
-    if (Array.isArray(iri)) {
-      this.realtime.unsubscribe(iri);
-      return;
-    }
-    this.realtime.unsubscribe([iri]);
+    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];
+    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),
-        shareReplay({bufferSize: 1, refCount: true})
+        share()
       );
   }
 
-  protected subscribeAndSync(iris: Iri[]): Observable<T> {
+  protected subscribeAndSync(iris: string[]): Observable<T> {
     return this.realtime
       .subscribe$<T>(iris)
       .pipe(
         map(event => event.data),
         filter((data): data is T => data !== undefined),
-        shareReplay({bufferSize: 1, refCount: true})
-      )
+        share()
+      );
   }
 }

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

@@ -0,0 +1,32 @@
+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});
+    })
+  );
+};

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

@@ -0,0 +1,53 @@
+import {HttpInterceptorFn} from '@angular/common/http';
+import {inject} from '@angular/core';
+import {BRIDGE_DEFAULTS, BRIDGE_LOGGER} from '../tokens';
+import {retry, timeout, timer} from 'rxjs';
+
+const DEFAULT_RETRY_METHODS = ['GET', 'HEAD', 'OPTIONS'];
+
+/**
+ * Applies default headers, timeout and retry policy configured via `provideBridge({defaults: ...})`.
+ */
+export const bridgeDefaultsInterceptor: HttpInterceptorFn = (req, next) => {
+  const defaults = inject(BRIDGE_DEFAULTS, {optional: true}) ?? {};
+  const logger = inject(BRIDGE_LOGGER, {optional: true});
+
+  let nextReq = req;
+
+  if (defaults.headers) {
+    for (const [k, v] of Object.entries(defaults.headers)) {
+      if (!nextReq.headers.has(k)) {
+        nextReq = nextReq.clone({headers: nextReq.headers.set(k, v)});
+      }
+    }
+  }
+
+  let out$ = next(nextReq);
+
+  const timeoutMs = typeof defaults.timeoutMs === 'number' ? defaults.timeoutMs : undefined;
+  if (timeoutMs && timeoutMs > 0) {
+    out$ = out$.pipe(timeout({first: timeoutMs}));
+  }
+
+  const retryCfg = defaults.retries;
+  const retryCount = typeof retryCfg === 'number' ? retryCfg : retryCfg?.count;
+  if (retryCount && retryCount > 0) {
+    const methods = (typeof retryCfg === 'object' && retryCfg.methods) ? retryCfg.methods : DEFAULT_RETRY_METHODS;
+    const normalizedMethod = req.method.toUpperCase();
+    const methodAllowList = new Set(methods.map((m) => m.toUpperCase()));
+    if (methodAllowList.has(normalizedMethod)) {
+      const delayMs = typeof retryCfg === 'object' ? (retryCfg.delayMs ?? 250) : 250;
+      out$ = out$.pipe(
+        retry({
+          count: retryCount,
+          delay: (_err, retryIndex) => {
+            logger?.debug?.('[Bridge] retry', {url: req.urlWithParams, method: req.method, retryIndex});
+            return timer(delayMs);
+          },
+        })
+      );
+    }
+  }
+
+  return out$;
+};

package/templates/_lib_template/src/lib/interceptors/content-type.interceptor.ts

@@ -1,50 +1,49 @@
 import {HttpInterceptorFn} from '@angular/common/http';
 
 export interface ApiMediaTypes {
-    accept: string;
-    post: string;
-    put: string;
-    patch: string;
+  accept: string;
+  post: string;
+  put: string;
+  patch: string;
 }
 
 export const DEFAULT_MEDIA_TYPES: ApiMediaTypes = {
-    accept: 'application/ld+json',
-    post: 'application/ld+json',
-    put: 'application/ld+json',
-    patch: 'application/merge-patch+json'
+  accept: 'application/ld+json',
+  post: 'application/ld+json',
+  put: 'application/ld+json',
+  patch: 'application/merge-patch+json',
 };
 
 export const contentTypeInterceptor: HttpInterceptorFn = (req, next) => {
-    const mediaTypes = DEFAULT_MEDIA_TYPES;
-    let headers = req.headers;
-
-    // Toujours définir Accept si absent
-    if (!headers.has('Accept')) {
-        headers = headers.set('Accept', mediaTypes.accept);
+  const mediaTypes = DEFAULT_MEDIA_TYPES;
+  let headers = req.headers;
+
+  // Set Accept if missing.
+  if (!headers.has('Accept')) {
+    headers = headers.set('Accept', mediaTypes.accept);
+  }
+
+  // Only methods with a body.
+  const isBodyMethod = ['POST', 'PUT', 'PATCH'].includes(req.method);
+  // Ignore FormData (browser sets multipart boundary).
+  const isFormData = typeof FormData !== 'undefined' && req.body instanceof FormData;
+
+  if (isBodyMethod && !isFormData && !headers.has('Content-Type')) {
+    let contentType: string;
+
+    switch (req.method) {
+      case 'PATCH':
+        contentType = mediaTypes.patch;
+        break;
+      case 'PUT':
+        contentType = mediaTypes.put;
+        break;
+      default:
+        contentType = mediaTypes.post;
     }
 
-    // Vérifie si la méthode peut avoir un body
-    const isBodyMethod = ['POST', 'PUT', 'PATCH'].includes(req.method);
-    // Ignore FormData (Content-Type sera défini par le navigateur)
-    const isFormData = typeof FormData !== 'undefined' && req.body instanceof FormData;
-
-    if (isBodyMethod && !isFormData && !headers.has('Content-Type')) {
-        let contentType: string;
-
-        switch (req.method) {
-            case 'PATCH':
-                contentType = mediaTypes.patch;
-                break;
-            case 'PUT':
-                contentType = mediaTypes.put;
-                break;
-            default:
-                contentType = mediaTypes.post;
-        }
-
-        headers = headers.set('Content-Type', contentType);
-    }
+    headers = headers.set('Content-Type', contentType);
+  }
 
-    // Cloner la requête avec les nouveaux headers
-    return next(req.clone({headers}));
+  return next(req.clone({headers}));
 };

package/templates/_lib_template/src/lib/ports/realtime.port.ts

@@ -11,10 +11,8 @@ export interface SseEvent {
 
 export interface SseOptions {
   withCredentials?: boolean;
-  listen?: string[];
 }
 
-
 export interface RealtimeEvent<T> {
   iri: string;
   data?: T;
@@ -24,8 +22,12 @@ export type SubscribeFilter = {
   field: string;
 };
 
-
 export interface RealtimePort {
+  /**
+   * Subscribes to Mercure events for the given topics.
+   *
+   * Note: topics must be stable strings. Undefined values are ignored by the adapter.
+   */
   subscribe$<T>(iris: Iri[], filter?: SubscribeFilter): Observable<RealtimeEvent<T>>;
 
   unsubscribe(iris: Iri[]): void;

package/templates/_lib_template/src/lib/ports/resource-repository.port.ts

@@ -2,6 +2,7 @@ import {HttpHeaders, HttpParams} from '@angular/common/http';
 import {Observable} from 'rxjs';
 
 export type Iri = string | undefined;
+export type IriRequired = string;
 
 type BaseHttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
 export type HttpMethod = BaseHttpMethod | Lowercase<BaseHttpMethod>;
@@ -11,11 +12,11 @@ export type AnyQuery = Query | Record<string, QueryParamValue> | HttpParams;
 
 export interface Item {
   '@id'?: Iri;
-  '@context'?: string,
-  '@type'?: string
+  '@context'?: string;
+  '@type'?: string;
 }
 
-export interface View extends Item{
+export interface View extends Item {
   first?: Iri;
   last?: Iri;
   next?: Iri;
@@ -44,25 +45,23 @@ export interface Query {
   filters?: Record<string, QueryParamValue>;
 }
 
-export interface CreateCommand<T> {
-  payload: T;
-}
-
-export interface UpdateCommand<T> {
-  iri?: Iri;
-  changes: Partial<T>;
+export interface HttpCallOptions {
+  headers?: HttpHeaders | Record<string, string>;
+  withCredentials?: boolean;
 }
 
 export interface ResourceRepository<T> {
-  list$(query?: Query): Observable<Collection<T>>;
+  getCollection$(query?: AnyQuery, opts?: HttpCallOptions): Observable<Collection<T>>;
+
+  get$(iri: IriRequired, opts?: HttpCallOptions): Observable<T>;
 
-  get$(iri: Iri): Observable<T>;
+  post$(payload: Partial<T>, opts?: HttpCallOptions): Observable<T>;
 
-  create$(cmd: CreateCommand<T>): Observable<T>;
+  patch$(iri: IriRequired, changes: Partial<T>, opts?: HttpCallOptions): Observable<T>;
 
-  update$(cmd: UpdateCommand<T>): Observable<T>;
+  put$(iri: IriRequired, payload: Partial<T>, opts?: HttpCallOptions): Observable<T>;
 
-  delete$(iri: Iri): Observable<void>;
+  delete$(iri: IriRequired, opts?: HttpCallOptions): Observable<void>;
 
   request$<R = unknown, B = unknown>(req: HttpRequestConfig<B>): Observable<R>;
 }

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

@@ -1,35 +1,138 @@
-import {EnvironmentProviders, Provider, makeEnvironmentProviders} from '@angular/core';
-import {provideHttpClient, withFetch, withInterceptors} from '@angular/common/http';
-import {API_BASE_URL, MERCURE_CONFIG, MERCURE_HUB_URL} from './tokens';
+import {EnvironmentProviders, makeEnvironmentProviders} from '@angular/core';
+import {HttpInterceptorFn, provideHttpClient, withFetch, withInterceptors} from '@angular/common/http';
+import {
+  API_BASE_URL,
+  BRIDGE_DEFAULTS,
+  BRIDGE_LOGGER,
+  BRIDGE_WITH_CREDENTIALS,
+  MERCURE_HUB_URL,
+  MERCURE_TOPIC_MODE,
+} from './tokens';
+import {BridgeDefaults, BridgeLogger, MercureTopicMode} from './bridge.types';
 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';
+
+export type BridgeAuth =
+  | string
+  | {type: 'bearer'; token: string}
+  | {type: 'bearer'; getToken: () => string | undefined | Promise<string | undefined>}
+  | HttpInterceptorFn;
+
+export interface BridgeMercureOptions {
+  hubUrl?: string;
+  init?: RequestInit;
+  topicMode?: MercureTopicMode;
+}
 
 export interface BridgeOptions {
-  apiBaseUrl: string;
-  mercure?: RequestInit;
-  mercureHubUrl?: string;
-  extraInterceptors?: any[];
+  /** Base URL of the API (e.g. `http://localhost:8000`). */
+  baseUrl: string;
+  /** Auth strategy used to attach an Authorization header. */
+  auth?: BridgeAuth;
+  /**
+   * Use `topicMode` to control the `topic=` values sent to the hub.
+   */
+  mercure?: BridgeMercureOptions;
+  /** Default HTTP behaviour (headers, timeout, retries). */
+  defaults?: BridgeDefaults;
+  /** Enables debug logging via the debug interceptor and console logger. */
+  debug?: boolean;
+  /** Extra `HttpInterceptorFn` applied after bridge interceptors. */
+  extraInterceptors?: HttpInterceptorFn[];
 }
 
+/** Registers the bridge HTTP client, interceptors, Mercure realtime adapter and configuration tokens. */
 export function provideBridge(opts: BridgeOptions): EnvironmentProviders {
   const {
-    apiBaseUrl,
-    mercure = {credentials: 'include' as RequestCredentials},
-    mercureHubUrl,
+    baseUrl,
+    auth,
+    mercure,
+    defaults,
+    debug = false,
     extraInterceptors = [],
-
   } = opts;
 
+  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 withCredentials = resolveWithCredentials(resolvedMercureInit);
+
+  const loggerProvider: BridgeLogger = createBridgeLogger(debug);
+
+  const interceptors: HttpInterceptorFn[] = [
+    contentTypeInterceptor,
+    bridgeDefaultsInterceptor,
+    ...createAuthInterceptors(auth),
+    ...(debug ? [bridgeDebugInterceptor] : []),
+    ...extraInterceptors,
+  ];
+
   return makeEnvironmentProviders([
     provideHttpClient(
       withFetch(),
-      withInterceptors([
-        contentTypeInterceptor,
-        ...extraInterceptors
-
-      ])
+      withInterceptors(interceptors)
     ),
-    {provide: API_BASE_URL, useValue: apiBaseUrl},
-    {provide: MERCURE_CONFIG, useValue: mercure},
-    ...(mercureHubUrl ? [{provide: MERCURE_HUB_URL, useValue: mercureHubUrl}] : []),
+    {provide: API_BASE_URL, useValue: baseUrl},
+    {provide: BRIDGE_WITH_CREDENTIALS, useValue: withCredentials},
+    ...(resolvedMercureHubUrl ? [{provide: MERCURE_HUB_URL, useValue: resolvedMercureHubUrl}] : []),
+    {provide: MERCURE_TOPIC_MODE, useValue: resolvedMercureTopicMode},
+    {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 createAuthInterceptors(auth?: BridgeAuth): HttpInterceptorFn[] {
+  if (!auth) return [];
+
+  if (typeof auth === 'function') {
+    return [auth as HttpInterceptorFn];
+  }
+
+  const bearer =
+    typeof auth === 'string'
+      ? {type: 'bearer' as const, token: auth}
+      : (auth as Exclude<BridgeAuth, string | HttpInterceptorFn>);
+
+  if (bearer.type !== 'bearer') return [];
+
+  if ('token' in bearer) {
+    const token = bearer.token;
+    return [createBearerAuthInterceptor(() => token)];
+  }
+
+  return [createBearerAuthInterceptor(bearer.getToken)];
+}
+
+function createBearerAuthInterceptor(getToken: () => string | undefined | Promise<string | undefined>): HttpInterceptorFn {
+  return (req, next) => {
+    if (req.headers.has('Authorization')) return next(req);
+    return from(Promise.resolve(getToken())).pipe(
+      switchMap((token) => {
+        if (!token) return next(req);
+        return next(req.clone({headers: req.headers.set('Authorization', `Bearer ${token}`)}));
+      })
+    );
+  };
+}

package/templates/_lib_template/src/lib/tokens.ts

@@ -1,7 +1,20 @@
 import {InjectionToken} from '@angular/core';
+import {BridgeDefaults, BridgeLogger, MercureTopicMode} from './bridge.types';
 
+/** Base URL of the API (e.g. `http://localhost:8000`). */
 export const API_BASE_URL = new InjectionToken<string>('API_BASE_URL');
 
+/** Mercure hub URL (e.g. `http://localhost:8000/.well-known/mercure`). */
 export const MERCURE_HUB_URL = new InjectionToken<string>('MERCURE_HUB_URL');
 
-export const MERCURE_CONFIG = new InjectionToken<RequestInit>('MERCURE_CONFIG');
+/**
+ * Default credential policy for HTTP requests and Mercure EventSource.
+ * When `true`, the bridge sets `withCredentials: true` on HTTP calls and uses cookies for SSE.
+ */
+export const BRIDGE_WITH_CREDENTIALS = new InjectionToken<boolean>('BRIDGE_WITH_CREDENTIALS');
+
+export const MERCURE_TOPIC_MODE = new InjectionToken<MercureTopicMode>('MERCURE_TOPIC_MODE');
+
+export const BRIDGE_LOGGER = new InjectionToken<BridgeLogger>('BRIDGE_LOGGER');
+
+export const BRIDGE_DEFAULTS = new InjectionToken<BridgeDefaults>('BRIDGE_DEFAULTS');

package/templates/_lib_template/src/lib/utils/url.ts

@@ -0,0 +1,15 @@
+export function joinUrl(base: string, path: string): string {
+  const normalizedBase = base.endsWith('/') ? base.slice(0, -1) : base;
+  const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+  return `${normalizedBase}${normalizedPath}`;
+}
+
+/**
+ * Resolves an API IRI (e.g. `/api/books/1`) to a full URL using the API base.
+ * If `path` is already absolute (http/https), it is returned as-is.
+ */
+export function resolveUrl(base: string, path: string): string {
+  if (/^https?:\/\//i.test(path)) return path;
+  if (path.startsWith('//')) return path;
+  return joinUrl(base, path);
+}

package/templates/_lib_template/src/public-api.ts

@@ -1,8 +1,9 @@
 export * from './lib/provide-bridge';
-export * from './lib/tokens';
+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/ports/resource-repository.port';
-export * from './lib/utils/utils'
+export * from './lib/utils/url';
 
 export * from './models';