@obsidiane/meridiane 2.0.10 → 2.0.12

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

@@ -1,31 +0,0 @@
-import {
-  Collection,
-  HttpRequestConfig,
-  Iri,
-  IriRequired,
-  Item,
-  HttpCallOptions,
-  AnyQuery,
-} from '../ports/resource-repository.port';
-import {Observable} from 'rxjs';
-import {WatchConnectionOptions} from '../bridge.types';
-
-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[], options?: WatchConnectionOptions): Observable<T>;
-
-  unwatch(iri: Iri | Iri[]): void;
-}

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

@@ -1,53 +0,0 @@
-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,49 +0,0 @@
-import {HttpInterceptorFn} from '@angular/common/http';
-
-export interface ApiMediaTypes {
-  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',
-};
-
-export const contentTypeInterceptor: HttpInterceptorFn = (req, next) => {
-  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;
-    }
-
-    headers = headers.set('Content-Type', contentType);
-  }
-
-  return next(req.clone({headers}));
-};

package/templates/_lib_template/src/lib/interceptors/singleflight.interceptor.ts

@@ -1,55 +0,0 @@
-import {HttpEvent, HttpInterceptorFn, HttpRequest} from '@angular/common/http';
-import {finalize, Observable, shareReplay} from 'rxjs';
-
-export type SingleFlightMode = 'off' | 'safe';
-
-const DEFAULT_MODE: SingleFlightMode = 'safe';
-const SAFE_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);
-
-export function createSingleFlightInterceptor(mode: SingleFlightMode = DEFAULT_MODE): HttpInterceptorFn {
-  const inflight = new Map<string, Observable<HttpEvent<unknown>>>();
-
-  return (req, next) => {
-    if (mode === 'off') {
-      return next(req);
-    }
-
-    const method = req.method.toUpperCase();
-    if (!SAFE_METHODS.has(method)) {
-      return next(req);
-    }
-    if (req.reportProgress === true) {
-      return next(req);
-    }
-
-    const key = computeKey(req);
-    const existing = inflight.get(key);
-    if (existing) {
-      return existing;
-    }
-
-    const shared$ = next(req).pipe(
-      finalize(() => inflight.delete(key)),
-      shareReplay({bufferSize: 1, refCount: true})
-    );
-
-    inflight.set(key, shared$);
-    return shared$;
-  };
-}
-
-function computeKey(req: HttpRequest<unknown>): string {
-  const auth = req.headers.get('Authorization') ?? '';
-  const accept = req.headers.get('Accept') ?? '';
-  const contentType = req.headers.get('Content-Type') ?? '';
-  const creds = req.withCredentials ? '1' : '0';
-  return [
-    req.method.toUpperCase(),
-    req.urlWithParams,
-    `rt=${req.responseType}`,
-    `wc=${creds}`,
-    `a=${auth}`,
-    `acc=${accept}`,
-    `ct=${contentType}`,
-  ].join('::');
-}

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

@@ -1,186 +0,0 @@
-import {EnvironmentProviders, makeEnvironmentProviders} from '@angular/core';
-import {HttpInterceptorFn, provideHttpClient, withFetch, withInterceptors} from '@angular/common/http';
-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';
-import {BridgeDefaults, BridgeLogger, MercureConnectionMode, 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';
-import {createSingleFlightInterceptor} from './interceptors/singleflight.interceptor';
-
-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;
-  /**
-   * Connection strategy for SSE subscriptions.
-   * - `single`: one SSE connection per watch subscription
-   * - `auto` (default): shared connections with automatic URL-length sharding
-   */
-  connectionMode?: MercureConnectionMode;
-  /**
-   * Maximum Mercure URL length before auto-sharding topics into multiple connections.
-   * Used only when `connectionMode: 'auto'`. Default: `1900`.
-   */
-  maxUrlLength?: number;
-}
-
-export interface BridgeHttpOptions {
-  /**
-   * Enables cookies / credentials on HTTP requests by default.
-   *
-   * When omitted, the bridge preserves the historical behavior and derives the
-   * HTTP value from `mercure.init.credentials`.
-   */
-  withCredentials?: boolean;
-}
-
-export interface BridgeOptions {
-  /** Base URL of the API (e.g. `http://localhost:8000`). */
-  baseUrl: string;
-  /** Auth strategy used to attach an Authorization header. */
-  auth?: BridgeAuth;
-  /** Default HTTP transport options. */
-  http?: BridgeHttpOptions;
-  /**
-   * Use `topicMode` to control the `topic=` values sent to the hub.
-   */
-  mercure?: BridgeMercureOptions;
-  /** Default HTTP behaviour (headers, timeout, retries). */
-  defaults?: BridgeDefaults;
-  /**
-   * De-duplicates in-flight HTTP requests.
-   *
-   * - `true` (default): single-flight for safe methods (`GET/HEAD/OPTIONS`)
-   * - `false`: disabled (each call triggers a new request)
-   */
-  singleFlight?: boolean;
-  /** 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 {
-    baseUrl,
-    auth,
-    http,
-    mercure,
-    defaults,
-    singleFlight = true,
-    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 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 interceptors: HttpInterceptorFn[] = [
-    contentTypeInterceptor,
-    bridgeDefaultsInterceptor,
-    ...createAuthInterceptors(auth),
-    ...(singleFlight ? [createSingleFlightInterceptor('safe')] : [createSingleFlightInterceptor('off')]),
-    ...(debug ? [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;
-}
-
-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/tools/build.js

@@ -1 +0,0 @@
-export { runBuild } from './app/run-build.js';

package/tools/dev.js

@@ -1 +0,0 @@
-export { runDev } from './app/run-dev.js';

package/tools/domain/paths.js

@@ -1,10 +0,0 @@
-export function splitListArgs(values) {
-  const out = [];
-  for (const v of Array.isArray(values) ? values : []) {
-    for (const part of String(v).split(',')) {
-      const s = part.trim();
-      if (s) out.push(s);
-    }
-  }
-  return out;
-}

package/tools/generate.js

@@ -1 +0,0 @@
-export { runGenerate } from './app/run-generate.js';

package/tools/generator/models/oas-contract.js

@@ -1,159 +0,0 @@
-import { schemaNameFromRef } from './schema-utils.js';
-
-function resolveRefPointer(spec, ref) {
-  const s = String(ref || '');
-  if (!s.startsWith('#/')) return undefined;
-  const parts = s.slice(2).split('/').filter(Boolean);
-  let cur = spec;
-  for (const p of parts) {
-    if (!cur || typeof cur !== 'object') return undefined;
-    cur = cur[p];
-  }
-  return cur;
-}
-
-function deref(spec, maybeRef) {
-  if (!maybeRef || typeof maybeRef !== 'object') return maybeRef;
-  if (typeof maybeRef.$ref === 'string') return resolveRefPointer(spec, maybeRef.$ref) || maybeRef;
-  return maybeRef;
-}
-
-export function canonicalizeMediaType(mediaType) {
-  return String(mediaType || '').split(';')[0].trim().toLowerCase();
-}
-
-function getContentSchema(content, wantedLower) {
-  if (!content || typeof content !== 'object') return undefined;
-  for (const [k, v] of Object.entries(content)) {
-    const canon = canonicalizeMediaType(k);
-    if (canon === wantedLower) return v?.schema;
-  }
-  return undefined;
-}
-
-function is2xxStatus(code) {
-  const s = String(code || '');
-  if (/^[0-9]{3}$/.test(s)) return s.startsWith('2');
-  return /^2xx$/i.test(s);
-}
-
-/**
- * Collects only component schema refs (`#/components/schemas/*`) found in a JSON schema.
- * @param {any} schema
- * @param {Set<string>} out
- */
-function collectComponentSchemaRefs(schema, out) {
-  const seen = new Set();
-
-  function walk(node) {
-    if (!node || typeof node !== 'object') return;
-    if (seen.has(node)) return;
-    seen.add(node);
-
-    if (node.$ref && typeof node.$ref === 'string') {
-      const name = schemaNameFromRef(node.$ref);
-      if (name) out.add(name);
-      return;
-    }
-
-    if (Array.isArray(node)) {
-      for (const it of node) walk(it);
-      return;
-    }
-
-    if (node.allOf) walk(node.allOf);
-    if (node.oneOf) walk(node.oneOf);
-    if (node.anyOf) walk(node.anyOf);
-    if (node.items) walk(node.items);
-    if (node.properties) walk(node.properties);
-    if (node.additionalProperties) walk(node.additionalProperties);
-
-    for (const v of Object.values(node)) walk(v);
-  }
-
-  walk(schema);
-}
-
-/**
- * Extracts root schemas from endpoints for one media type.
- * - requestBody is ignored for PATCH (merge-patch typed as Partial<> elsewhere)
- * - responses keep only 2xx and default
- */
-function listRootsFromPaths(spec, { mediaType } = {}) {
-  const wantedLower = canonicalizeMediaType(mediaType);
-  const roots = [];
-
-  const paths = spec?.paths;
-  if (!paths || typeof paths !== 'object') return roots;
-
-  for (const pathItem of Object.values(paths)) {
-    if (!pathItem || typeof pathItem !== 'object') continue;
-    for (const [method, op0] of Object.entries(pathItem)) {
-      const op = deref(spec, op0);
-      if (!op || typeof op !== 'object') continue;
-
-      const isPatch = String(method || '').toLowerCase() === 'patch';
-
-      if (!isPatch) {
-        const rb = deref(spec, op.requestBody);
-        const rbSchema = getContentSchema(rb?.content, wantedLower);
-        if (rbSchema) roots.push(rbSchema);
-      }
-
-      const responses = op.responses;
-      if (!responses || typeof responses !== 'object') continue;
-      for (const [code, resp] of Object.entries(responses)) {
-        if (!is2xxStatus(code) && String(code).toLowerCase() !== 'default') continue;
-        const resolved = deref(spec, resp);
-        const schema = getContentSchema(resolved?.content, wantedLower);
-        if (schema) roots.push(schema);
-      }
-    }
-  }
-
-  return roots;
-}
-
-/**
- * Returns the transitive closure of schema dependencies (following component-schema $ref).
- * @param {Iterable<string>} start
- * @param {Record<string, any>} schemas
- */
-export function expandWithSchemaDependencies(start, schemas) {
-  const out = new Set();
-  const queue = [];
-
-  for (const n of start) {
-    if (!n || out.has(n)) continue;
-    out.add(n);
-    queue.push(n);
-  }
-
-  while (queue.length) {
-    const name = queue.pop();
-    const schema = schemas[name];
-    if (!schema) continue;
-    const refs = new Set();
-    collectComponentSchemaRefs(schema, refs);
-    for (const ref of refs) {
-      if (!ref || out.has(ref)) continue;
-      out.add(ref);
-      queue.push(ref);
-    }
-  }
-
-  return out;
-}
-
-/**
- * Collects all component schemas used by endpoints for one media type.
- * @param {any} spec
- * @param {{ mediaType: string }} cfg
- */
-export function collectUsedSchemasForMediaType(spec, cfg) {
-  const schemas = spec?.components?.schemas || {};
-  const roots = listRootsFromPaths(spec, cfg);
-  const initialRefs = new Set();
-  for (const r of roots) collectComponentSchemaRefs(r, initialRefs);
-  return expandWithSchemaDependencies(initialRefs, schemas);
-}