@obsidiane/meridiane 0.0.6

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

@@ -0,0 +1,36 @@
+import {Injectable, Inject, runInInjectionContext, inject, EnvironmentInjector} 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, MERCURE_CONFIG} 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 env = inject(EnvironmentInjector);
+
+  constructor(
+    private readonly http: HttpClient,
+    @Inject(API_BASE_URL) private readonly baseUrl: string,
+    @Inject(MERCURE_CONFIG) private readonly init: string,
+    private readonly mercureAny: MercureRealtimeAdapter
+  ) {
+  }
+
+  create<T extends Item>(config: FacadeConfig<T>): ResourceFacade<T> {
+    const path = config.url;
+    const repo = new ApiPlatformRestRepository<T>(this.http, this.baseUrl, path , this.init);
+    const realtime = this.mercureAny as MercureRealtimeAdapter;
+    return runInInjectionContext(this.env, () => new ResourceFacade<T>(repo, realtime, path));
+  }
+}

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

@@ -0,0 +1,35 @@
+import {
+  Collection,
+  CreateCommand,
+  HttpRequestConfig,
+  Iri,
+  Item,
+  Query,
+  UpdateCommand
+} from "../ports/resource-repository.port";
+import {Observable} from "rxjs";
+
+export interface Facade<T extends Item> {
+
+  list$(query?: Query): Observable<Collection<T>>;
+
+  get$(iri: Iri): Observable<T>;
+
+  create$(cmd: CreateCommand<T>): Observable<T>;
+
+  update$(cmd: UpdateCommand<T>): Observable<T>;
+
+  delete$(iri: Iri): Observable<void>;
+
+  post$<R = unknown, B = unknown>(req: RestRequest<B>): Observable<R>;
+  put$<R = unknown, B = unknown>(req: RestRequest<B>): Observable<R>;
+  patch$<R = unknown, B = unknown>(req: RestRequest<B>): Observable<R>;
+
+  request$<R = unknown, B = unknown>(req: HttpRequestConfig<B>): Observable<R>;
+
+  watch$(iri: Iri|Iri[]): Observable<T>;
+
+  unwatch(iri: Iri|Iri[]): void;
+}
+
+export type RestRequest<B> = Omit<HttpRequestConfig<B>, 'method'>;

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

@@ -0,0 +1,115 @@
+import {Signal} from '@angular/core';
+import {
+  ResourceRepository,
+  Query,
+  CreateCommand,
+  UpdateCommand,
+  Collection, Iri, 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';
+
+export class ResourceFacade<T extends Item> implements Facade<T> {
+
+  readonly connectionStatus: Signal<RealtimeStatus>;
+
+  constructor(
+    protected readonly repo: ResourceRepository<T>,
+    protected readonly realtime: RealtimePort,
+    protected readonly resourcePath: string
+  ) {
+    this.resourcePath = resourcePath;
+    this.connectionStatus = toSignal(
+      this.realtime.status$(),
+      {initialValue: 'offline' as RealtimeStatus}
+    );
+  }
+
+  list$(query?: Query): Observable<Collection<T>> {
+    return this.repo.list$(query)
+  }
+
+  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})
+    );
+  }
+
+  delete$(iri: Iri): Observable<void> {
+    return this.repo.delete$(iri).pipe(
+      shareReplay({bufferSize: 1, refCount: true})
+    );
+  }
+
+  request$<R = unknown, B = unknown>(req: HttpRequestConfig<B>): Observable<R> {
+    return this.repo.request$<R, B>(req).pipe(
+      shareReplay({bufferSize: 1, refCount: true})
+    );
+  }
+
+  post$<R = unknown, B = unknown>(req: RestRequest<B> = {}): Observable<R> {
+    return this.request$<R, B>({...req, method: 'POST'});
+  }
+
+  put$<R = unknown, B = unknown>(req: RestRequest<B> = {}): Observable<R> {
+    return this.request$<R, B>({...req, method: 'PUT'});
+  }
+
+  patch$<R = unknown, B = unknown>(req: RestRequest<B> = {}): Observable<R> {
+    return this.request$<R, B>({...req, method: 'PATCH'});
+  }
+
+  watch$(iri: Iri | Iri[]): Observable<T> {
+    if (Array.isArray(iri)) {
+      return this.subscribeAndSync(iri);
+    }
+    return this.subscribeAndSync([iri]);
+  }
+
+
+  unwatch(iri: Iri | Iri[]): void {
+    if (Array.isArray(iri)) {
+      this.realtime.unsubscribe(iri);
+      return;
+    }
+    this.realtime.unsubscribe([iri]);
+  }
+
+  watchSubResource$<R>(
+    iri: Iri | Iri[],
+    field: string
+  ): Observable<R> {
+    const iris = Array.isArray(iri) ? iri : [iri];
+    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})
+      );
+  }
+
+  protected subscribeAndSync(iris: Iri[]): 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})
+      )
+  }
+}

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

@@ -0,0 +1,50 @@
+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;
+
+    // Toujours définir Accept si absent
+    if (!headers.has('Accept')) {
+        headers = headers.set('Accept', mediaTypes.accept);
+    }
+
+    // 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);
+    }
+
+    // Cloner la requête avec les nouveaux headers
+    return next(req.clone({headers}));
+};

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

@@ -0,0 +1,34 @@
+import {Observable} from 'rxjs';
+import {Iri} from './resource-repository.port';
+
+export type RealtimeStatus = 'connecting' | 'connected' | 'closed';
+
+export interface SseEvent {
+  type: string;
+  data: string;
+  lastEventId?: string;
+}
+
+export interface SseOptions {
+  withCredentials?: boolean;
+  listen?: string[];
+}
+
+
+export interface RealtimeEvent<T> {
+  iri: string;
+  data?: T;
+}
+
+export type SubscribeFilter = {
+  field: string;
+};
+
+
+export interface RealtimePort {
+  subscribe$<T>(iris: Iri[], filter?: SubscribeFilter): Observable<RealtimeEvent<T>>;
+
+  unsubscribe(iris: Iri[]): void;
+
+  status$(): Observable<RealtimeStatus>;
+}

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

@@ -0,0 +1,79 @@
+import {HttpHeaders, HttpParams} from '@angular/common/http';
+import {Observable} from 'rxjs';
+
+export type Iri = string | undefined;
+
+type BaseHttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
+export type HttpMethod = BaseHttpMethod | Lowercase<BaseHttpMethod>;
+
+export type QueryParamValue = string | number | boolean | Array<string | number | boolean>;
+export type AnyQuery = Query | Record<string, QueryParamValue> | HttpParams;
+
+export interface Item {
+  '@id'?: Iri;
+  '@context'?: string,
+  '@type'?: string
+}
+
+export interface View extends Item{
+  first?: Iri;
+  last?: Iri;
+  next?: Iri;
+  previous?: Iri;
+}
+export interface IriTemplateMapping extends Item {
+  variable: string;
+  property?: string;
+  required?: boolean;
+}
+export interface IriTemplate extends Item {
+  template: string;
+  variableRepresentation?: string;
+  mapping: IriTemplateMapping[];
+}
+export interface Collection<T> extends Item {
+  member: T[];
+  totalItems?: number;
+  search?: IriTemplate;
+  view?: View;
+}
+
+export interface Query {
+  itemsPerPage?: number;
+  page?: number;
+  filters?: Record<string, QueryParamValue>;
+}
+
+export interface CreateCommand<T> {
+  payload: T;
+}
+
+export interface UpdateCommand<T> {
+  iri?: Iri;
+  changes: Partial<T>;
+}
+
+export interface ResourceRepository<T> {
+  list$(query?: Query): Observable<Collection<T>>;
+
+  get$(iri: Iri): Observable<T>;
+
+  create$(cmd: CreateCommand<T>): Observable<T>;
+
+  update$(cmd: UpdateCommand<T>): Observable<T>;
+
+  delete$(iri: Iri): Observable<void>;
+
+  request$<R = unknown, B = unknown>(req: HttpRequestConfig<B>): Observable<R>;
+}
+
+export interface HttpRequestConfig<TBody = unknown> {
+  method: HttpMethod;
+  url?: Iri;
+  query?: AnyQuery;
+  body?: TBody;
+  headers?: HttpHeaders | Record<string, string>;
+  responseType?: 'json' | 'text' | 'blob';
+  withCredentials?: boolean;
+  options?: Record<string, unknown>;
+}

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

@@ -0,0 +1,35 @@
+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 {contentTypeInterceptor} from './interceptors/content-type.interceptor';
+
+export interface BridgeOptions {
+  apiBaseUrl: string;
+  mercure?: RequestInit;
+  mercureHubUrl?: string;
+  extraInterceptors?: any[];
+}
+
+export function provideBridge(opts: BridgeOptions): EnvironmentProviders {
+  const {
+    apiBaseUrl,
+    mercure = {credentials: 'include' as RequestCredentials},
+    mercureHubUrl,
+    extraInterceptors = [],
+
+  } = opts;
+
+  return makeEnvironmentProviders([
+    provideHttpClient(
+      withFetch(),
+      withInterceptors([
+        contentTypeInterceptor,
+        ...extraInterceptors
+
+      ])
+    ),
+    {provide: API_BASE_URL, useValue: apiBaseUrl},
+    {provide: MERCURE_CONFIG, useValue: mercure},
+    ...(mercureHubUrl ? [{provide: MERCURE_HUB_URL, useValue: mercureHubUrl}] : []),
+  ]);
+}

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

@@ -0,0 +1,7 @@
+import {InjectionToken} from '@angular/core';
+
+export const API_BASE_URL = new InjectionToken<string>('API_BASE_URL');
+
+export const MERCURE_HUB_URL = new InjectionToken<string>('MERCURE_HUB_URL');
+
+export const MERCURE_CONFIG = new InjectionToken<RequestInit>('MERCURE_CONFIG');

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

@@ -0,0 +1,21 @@
+import {WritableSignal} from '@angular/core';
+import {Item} from '../ports/resource-repository.port';
+
+export function upsertInSignal(
+  signal: WritableSignal<readonly Item[]>,
+  item: Item,
+): void {
+  signal.update(items => {
+
+    const id = item['@id'];
+    const existingIndex = items.findIndex(it => it['@id'] === id);
+
+    if (existingIndex === -1) {
+      return [item, ...items];
+    }
+
+    const next = items.slice() as Item[];
+    next[existingIndex] = item;
+    return next;
+  });
+}

package/templates/_lib_template/src/models/index.ts

@@ -0,0 +1,2 @@
+export {};
+

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

@@ -0,0 +1,8 @@
+export * from './lib/provide-bridge';
+export * from './lib/tokens';
+export * from './lib/facades/facade.factory';
+export * from './lib/facades/resource.facade';
+export * from './lib/ports/resource-repository.port';
+export * from './lib/utils/utils'
+
+export * from './models';

package/templates/_lib_template/tsconfig.lib.json

@@ -0,0 +1,18 @@
+/* To learn more about Typescript configuration file: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html. */
+/* To learn more about Angular compiler options: https://angular.dev/reference/configs/angular-compiler-options. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/lib",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "types": []
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "**/*.spec.ts"
+  ]
+}

package/templates/_lib_template/tsconfig.lib.prod.json

@@ -0,0 +1,11 @@
+/* To learn more about Typescript configuration file: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html. */
+/* To learn more about Angular compiler options: https://angular.dev/reference/configs/angular-compiler-options. */
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}

package/templates/_lib_template/tsconfig.spec.json

@@ -0,0 +1,14 @@
+/* To learn more about Typescript configuration file: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html. */
+/* To learn more about Angular compiler options: https://angular.dev/reference/configs/angular-compiler-options. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/spec",
+    "types": [
+      "jasmine"
+    ]
+  },
+  "include": [
+    "src/**/*.ts"
+  ]
+}

package/tools/generate-lib.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+import fs from "fs-extra"
+import path from "path"
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname  = path.dirname(__filename);
+/**
+ * Recursively replace all placeholders in files under a directory
+ * @param {string} srcDir - source directory path
+ * @param {Object.<string,string>} placeholders - map of placeholder -> value
+ */
+async function replacePlaceholdersInDir(srcDir, placeholders) {
+  const entries = await fs.readdir(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(srcDir, entry.name);
+    if (entry.isDirectory()) {
+      await replacePlaceholdersInDir(fullPath, placeholders);
+    } else if (entry.isFile()) {
+      let content = await fs.readFile(fullPath, 'utf8');
+      for (const [key, value] of Object.entries(placeholders)) {
+        const regex = new RegExp(key, 'g');
+        content = content.replace(regex, value);
+      }
+      await fs.writeFile(fullPath, content);
+    }
+  }
+}
+
+/**
+ * Generate a new Angular library from template
+ * @param {string} libName - folder and project name
+ * @param {string} packageName - NPM package name (e.g. @org/lib)
+ * @param {string} version - initial version for the package
+ * @param {string} urlRegistry  - NPM registry url
+ */
+async function generate(libName, packageName, version, urlRegistry) {
+  const tplDir = path.resolve(__dirname, '../templates/_lib_template');
+  const workspaceRoot = process.cwd();
+  const targetDir = path.resolve(workspaceRoot, 'projects', libName);
+
+  // 1) Copy the template directory
+  await fs.copy(tplDir, targetDir);
+
+  // 2) Replace placeholders __LIB_NAME__, __PACKAGE_NAME__, __VERSION__
+  const placeholders = {
+    '__LIB_NAME__': libName,
+    '__PACKAGE_NAME__': packageName,
+    '__VERSION__': version
+  };
+  await replacePlaceholdersInDir(targetDir, placeholders);
+
+  // 3) Update the library's package.json
+  const libPackageJsonPath = path.join(targetDir, 'package.json');
+  if (await fs.pathExists(libPackageJsonPath)) {
+    const libPkg = await fs.readJson(libPackageJsonPath);
+    libPkg.name = packageName;
+    libPkg.version = version;
+    if (urlRegistry) {
+      libPkg.publishConfig = {...(libPkg.publishConfig || {}), registry: urlRegistry};
+    } else if (libPkg.publishConfig?.registry) {
+      delete libPkg.publishConfig.registry;
+      if (Object.keys(libPkg.publishConfig).length === 0) delete libPkg.publishConfig;
+    }
+    await fs.writeJson(libPackageJsonPath, libPkg, { spaces: 2 });
+  }
+
+  // 4) Update angular.json
+  const angularJsonPath = path.resolve(workspaceRoot, 'angular.json');
+  const ng = await fs.readJson(angularJsonPath);
+
+  ng.projects[libName] = {
+    root: `projects/${libName}`,
+    sourceRoot: `projects/${libName}/src`,
+    projectType: 'library',
+    "architect": {
+      "build": {
+        "builder": "@angular/build:ng-packagr",
+        "configurations": {
+          "production": {
+            "tsConfig": `projects/${libName}/tsconfig.lib.prod.json`
+          },
+          "development": {
+            "tsConfig": `projects/${libName}/tsconfig.lib.json`
+          }
+        },
+        "defaultConfiguration": "production"
+      },
+      "test": {
+        "builder": "@angular/build:karma",
+        "options": {
+          "tsConfig": `projects/${libName}/tsconfig.spec.json`
+        }
+      }
+    }
+  };
+  await fs.writeJson(angularJsonPath, ng, { spaces: 2 });
+
+  console.log(`✅ Library '${libName}' generated at projects/${libName}` +
+    ` with package '${packageName}@${version}'`);
+
+  const ngPackagrPkg = findUpNodeModulePackageJson(workspaceRoot, 'ng-packagr');
+  if (!ngPackagrPkg) {
+    console.warn(
+      [
+        "⚠️  'ng-packagr' n'est pas installé dans ce workspace.",
+        "   Pour builder une librairie (ng-packagr), installez-le dans votre projet Angular :",
+        "   npm i -D ng-packagr",
+      ].join('\n')
+    );
+  }
+}
+
+function findUpNodeModulePackageJson(startDir, packageName) {
+  let dir = startDir;
+  while (true) {
+    const candidate = path.join(dir, 'node_modules', packageName, 'package.json');
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+}
+
+// CLI args: node generate-lib.js <lib-name> <package-name> [version] <url-registry>
+// CLI args: node generate-lib.js <lib-name> <package-name> [version] [url-registry]
+const [,, libName, packageName, version = '0.0.1', urlRegistry] = process.argv;
+if (!libName || !packageName) {
+  console.error('Usage: generate-lib.js <lib-name> <package-name> [version] [url-registry]');
+  process.exit(1);
+}
+
+generate(libName, packageName, version, urlRegistry).catch(err => {
+  console.error(err);
+  process.exit(1);
+});