@blackcube/aurelia2-bleet 1.0.0

package/src/services/api-service.ts

@@ -0,0 +1,387 @@
+import {DI, ILogger, resolve} from 'aurelia';
+import {
+    IBuiltRequest,
+    ICacheConfig,
+    ICacheEntry,
+    ICodec,
+    IHttpRequest,
+    IHttpResponse,
+    IPaginationConfig,
+    ITransport
+} from '../interfaces/api';
+import {IBleetConfiguration} from '../configure';
+import {CsrfCodec} from '../codecs/csrf-codec';
+
+export interface IApiService extends ApiService {}
+export const IApiService = /*@__PURE__*/DI.createInterface<IApiService>(
+    'IApiService',
+    (x) => x.singleton(ApiService)
+);
+
+export class ApiService {
+    private static readonly PARAM_PATTERN = /:[a-zA-Z_][a-zA-Z0-9_-]*/g;
+    private memoryCache = new Map<string, ICacheEntry>();
+
+    public constructor(
+        private readonly logger: ILogger = resolve(ILogger).scopeTo('ApiService'),
+        private readonly config: IBleetConfiguration = resolve(IBleetConfiguration),
+    ) {
+        this.logger.trace('constructor');
+    }
+
+    public url(path: string, params?: Record<string, any>): ApiRequestBuilder {
+        return new ApiRequestBuilder(this, path, params);
+    }
+
+    /**
+     * Simple HTML fetch for AJAX dialogs (modal/drawer)
+     * Returns full response for status code checking
+     */
+    public async fetchHtml(url: string): Promise<IHttpResponse<string>> {
+        this.logger.trace('fetchHtml', url);
+        return this.url(url).toText().get<string>();
+    }
+
+    public execute<T>(request: IBuiltRequest): Promise<IHttpResponse<T>> {
+        this.logger.trace('execute', request.method, request.url);
+
+        // 1. Validate path params are present in pathParams or data
+        this.validateParams(request.url, request.pathParams, request.data);
+
+        // 2. Build request context
+        const initialCtx: IHttpRequest = {
+            url: request.url,
+            method: request.method,
+            headers: request.headers,
+            data: request.data,
+            pathParams: request.pathParams
+        };
+
+        // 3. Build codec chain : CSRF auto + user codecs
+        const csrfConfig = this.config.getCsrfConfig();
+        const allInputCodecs: ICodec[] = [];
+        if (csrfConfig.enabled) {
+            allInputCodecs.push(CsrfCodec.fromConfig(csrfConfig));
+        }
+        allInputCodecs.push(...request.inputCodecs);
+
+        // 4. Apply input codecs (encode) — chaîne de promesses
+        const ctxPromise = allInputCodecs.reduce(
+            (promise, codec) => codec.encode ? promise.then((ctx) => codec.encode!(ctx)) : promise,
+            Promise.resolve(initialCtx)
+        );
+
+        return ctxPromise.then((ctx) => {
+            // 4. Check cache
+            if (request.cache) {
+                const cached = this.getFromCache<T>(request, ctx);
+                if (cached) {
+                    this.logger.trace('execute:cache-hit');
+                    return Promise.resolve(cached);
+                }
+            }
+
+            // 5. Execute via transport avec fallback
+            return this.executeWithFallback<T>(ctx, request.responseType)
+                .then((response) => {
+                    // 6. Apply output codecs (decode)
+                    return request.outputCodecs.reduce(
+                        (promise, codec) => codec.decode ? promise.then((r) => codec.decode!(r)) : promise,
+                        Promise.resolve(response)
+                    );
+                })
+                .then((response) => {
+                    // 7. Store in cache
+                    if (request.cache) {
+                        this.storeInCache(request, ctx, response);
+                    }
+                    return response;
+                });
+        });
+    }
+
+    private executeWithFallback<T>(
+        ctx: IHttpRequest,
+        responseType: 'json' | 'text' | 'blob' | 'arraybuffer' | 'auto'
+    ): Promise<IHttpResponse<T>> {
+        const transports = this.config.getAvailableTransports();
+
+        if (transports.length === 0) {
+            return Promise.reject(new Error('No transport available'));
+        }
+
+        const tryTransport = (index: number, lastError: Error | null): Promise<IHttpResponse<T>> => {
+            if (index >= transports.length) {
+                return Promise.reject(lastError ?? new Error('All transports failed'));
+            }
+
+            const transport: ITransport = transports[index];
+
+            if (!transport.isAvailable()) {
+                this.logger.trace('execute:transport-unavailable', transport.type);
+                return tryTransport(index + 1, lastError);
+            }
+
+            this.logger.trace('execute:trying', transport.type);
+
+            const preparedCtx = transport.prepareRequest(ctx);
+
+            return transport.execute<T>(preparedCtx, responseType)
+                .catch((error: Error) => {
+                    this.logger.warn('execute:transport-failed', transport.type, error);
+                    return tryTransport(index + 1, error);
+                });
+        };
+
+        return tryTransport(0, null);
+    }
+
+    private validateParams(url: string, pathParams?: Record<string, any>, data?: Record<string, any>): void {
+        const matches = url.match(ApiService.PARAM_PATTERN) ?? [];
+        for (const match of matches) {
+            const paramName = match.slice(1);
+            const inPathParams = pathParams !== undefined && paramName in pathParams;
+            const inData = data !== undefined && paramName in data;
+            if (!inPathParams && !inData) {
+                throw new Error(`Missing path param '${match}'`);
+            }
+        }
+    }
+
+    private genCacheKey(request: IBuiltRequest, ctx: IHttpRequest): string {
+        const parts = [
+            request.method,
+            ctx.url,
+            JSON.stringify(ctx.data ?? {}),
+            request.pagination?.page ?? 0
+        ];
+        return 'api-cache:' + btoa(parts.join('|')).slice(0, 24);
+    }
+
+    private getFromCache<T>(request: IBuiltRequest, ctx: IHttpRequest): IHttpResponse<T> | null {
+        const key = this.genCacheKey(request, ctx);
+        const storage = request.cache?.storage ?? 'session';
+
+        let entry: ICacheEntry | null = null;
+
+        if (storage === 'session') {
+            const raw = sessionStorage.getItem(key);
+            entry = raw ? JSON.parse(raw) : null;
+        } else {
+            entry = this.memoryCache.get(key) ?? null;
+        }
+
+        if (!entry) {
+            return null;
+        }
+
+        // Check TTL
+        if (entry.expires && Date.now() > entry.expires) {
+            if (storage === 'session') {
+                sessionStorage.removeItem(key);
+            } else {
+                this.memoryCache.delete(key);
+            }
+            return null;
+        }
+
+        return entry.data;
+    }
+
+    private storeInCache(request: IBuiltRequest, ctx: IHttpRequest, response: IHttpResponse): void {
+        const key = this.genCacheKey(request, ctx);
+        const storage = request.cache?.storage ?? 'session';
+        const ttl = request.cache?.ttl;
+
+        const entry: ICacheEntry = {
+            data: response,
+            expires: ttl ? Date.now() + (ttl * 1000) : null,
+            created: Date.now()
+        };
+
+        if (storage === 'session') {
+            sessionStorage.setItem(key, JSON.stringify(entry));
+        } else {
+            this.memoryCache.set(key, entry);
+        }
+    }
+}
+
+export class ApiRequestBuilder {
+    private _url: string;
+    private _method: string = 'GET';
+    private _data: any;
+    private _pathParams: Record<string, any> | undefined;
+    private _queryString: Record<string, any> = {};
+    private _headers: Record<string, string> = {};
+    private _inputCodecs: ICodec[] = [];
+    private _outputCodecs: ICodec[] = [];
+    private _pagination: IPaginationConfig | null = null;
+    private _cache: ICacheConfig | null = null;
+    private _contentType: string = 'application/json';
+    private _accept: string = 'application/json';
+    private _responseType: 'json' | 'text' | 'blob' | 'arraybuffer' | 'auto' = 'auto';
+
+    constructor(
+        private api: ApiService,
+        path: string,
+        pathParams?: Record<string, any>
+    ) {
+        this._url = path;
+        this._pathParams = pathParams;
+    }
+
+    // Query string
+    public queryString(params: Record<string, any>): this {
+        this._queryString = {...this._queryString, ...params};
+        return this;
+    }
+
+    // Format entrée
+    public fromJson<T>(data?: T): this {
+        this._contentType = 'application/json';
+        if (data !== undefined) {
+            this._data = data;
+        }
+        return this;
+    }
+
+    public fromForm<T>(data?: T): this {
+        this._contentType = 'application/x-www-form-urlencoded';
+        if (data !== undefined) {
+            this._data = data;
+        }
+        return this;
+    }
+
+    public fromMultipart(data?: FormData): this {
+        this._contentType = 'multipart/form-data';
+        if (data !== undefined) {
+            this._data = data;
+        }
+        return this;
+    }
+
+    // Format sortie
+    public toJson(): this {
+        this._accept = 'application/json';
+        this._responseType = 'json';
+        return this;
+    }
+
+    public toXls(): this {
+        this._accept = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+        this._responseType = 'blob';
+        return this;
+    }
+
+    public toBlob(): this {
+        this._accept = 'application/octet-stream';
+        this._responseType = 'blob';
+        return this;
+    }
+
+    public toText(): this {
+        this._accept = 'text/plain';
+        this._responseType = 'text';
+        return this;
+    }
+
+    public toArrayBuffer(): this {
+        this._accept = 'application/octet-stream';
+        this._responseType = 'arraybuffer';
+        return this;
+    }
+
+    // Codecs
+    public withInputCodec(codec: ICodec): this {
+        this._inputCodecs.push(codec);
+        return this;
+    }
+
+    public withOutputCodec(codec: ICodec): this {
+        this._outputCodecs.push(codec);
+        return this;
+    }
+
+    // Pagination & Cache
+    public withPagination(config?: IPaginationConfig): this {
+        this._pagination = {pageSize: 20, ...config};
+        return this;
+    }
+
+    public withCache(config?: ICacheConfig): this {
+        this._cache = {storage: 'session', ...config};
+        return this;
+    }
+
+    // Execution
+    public get<T>(): Promise<IHttpResponse<T>> {
+        this._method = 'GET';
+        return this.api.execute<T>(this.build());
+    }
+
+    public post<T>(): Promise<IHttpResponse<T>> {
+        this._method = 'POST';
+        return this.api.execute<T>(this.build());
+    }
+
+    public put<T>(): Promise<IHttpResponse<T>> {
+        this._method = 'PUT';
+        return this.api.execute<T>(this.build());
+    }
+
+    public patch<T>(): Promise<IHttpResponse<T>> {
+        this._method = 'PATCH';
+        return this.api.execute<T>(this.build());
+    }
+
+    public delete<T>(): Promise<IHttpResponse<T>> {
+        this._method = 'DELETE';
+        return this.api.execute<T>(this.build());
+    }
+
+    public request<T>(verb: string): Promise<IHttpResponse<T>> {
+        this._method = verb.toUpperCase();
+        return this.api.execute<T>(this.build());
+    }
+
+    private build(): IBuiltRequest {
+        return {
+            url: this.appendQueryString(this._url),
+            method: this._method,
+            headers: {
+                'Content-Type': this._contentType,
+                'Accept': this._accept,
+                ...this._headers
+            },
+            data: this._data,
+            pathParams: this._pathParams,
+            responseType: this._responseType,
+            inputCodecs: this._inputCodecs,
+            outputCodecs: this._outputCodecs,
+            pagination: this._pagination,
+            cache: this._cache
+        };
+    }
+
+    private appendQueryString(url: string): string {
+        if (Object.keys(this._queryString).length === 0) {
+            return url;
+        }
+
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(this._queryString)) {
+            if (value !== undefined && value !== null) {
+                params.append(key, String(value));
+            }
+        }
+
+        const qs = params.toString();
+        if (!qs) {
+            return url;
+        }
+
+        return url.includes('?') ? `${url}&${qs}` : `${url}?${qs}`;
+    }
+}

package/src/services/http-service.ts

@@ -0,0 +1,166 @@
+import {DI, ILogger, resolve} from 'aurelia';
+import {HttpClientConfiguration, IHttpClient} from '@aurelia/fetch-client';
+import {IHttpRequest, IHttpResponse, ITransport} from '../interfaces/api';
+import {Transport} from '../enums/api';
+import {IBleetConfiguration} from '../configure';
+
+export interface IHttpService extends HttpService {}
+export const IHttpService = DI.createInterface<IHttpService>(
+    'IHttpService',
+    (x) => x.singleton(HttpService)
+);
+
+export class HttpService implements ITransport {
+    public readonly type = Transport.Http;
+    public constructor(
+        private readonly logger: ILogger = resolve(ILogger).scopeTo('HttpService'),
+        private readonly httpClient: IHttpClient = resolve(IHttpClient),
+        private readonly config: IBleetConfiguration = resolve(IBleetConfiguration),
+    ) {
+        this.logger.trace('constructor');
+        this.httpClient.configure((config: HttpClientConfiguration) => {
+            config.withDefaults({
+                headers: {
+                    'X-Requested-With': 'XMLHttpRequest',
+                },
+                credentials: 'include'
+            });
+            return config;
+        });
+    }
+
+    public isAvailable(): boolean {
+        return true;
+    }
+
+    public prepareRequest(ctx: IHttpRequest): IHttpRequest {
+        const baseUrl = this.config.getBaseUrl(Transport.Http);
+        let url = baseUrl + ctx.url;
+        const pathParams = ctx.pathParams ?? {};
+
+        // FormData: don't try to extract path params from it, keep as-is
+        if (ctx.data instanceof FormData) {
+            // Substitute :params in URL from pathParams only
+            const paramPattern = /:[a-zA-Z_][a-zA-Z0-9_-]*/g;
+            const matches = ctx.url.match(paramPattern) ?? [];
+
+            for (const match of matches) {
+                const paramName = match.slice(1);
+                if (paramName in pathParams) {
+                    url = url.replace(match, encodeURIComponent(String(pathParams[paramName])));
+                }
+            }
+
+            return {
+                url,
+                method: ctx.method,
+                headers: ctx.headers,
+                data: ctx.data
+            };
+        }
+
+        const remainingData = {...ctx.data};
+
+        // Substitute :params in URL (explicit > implicit) and remove from payload
+        const paramPattern = /:[a-zA-Z_][a-zA-Z0-9_-]*/g;
+        const matches = ctx.url.match(paramPattern) ?? [];
+
+        for (const match of matches) {
+            const paramName = match.slice(1);
+            const value = paramName in pathParams ? pathParams[paramName] : remainingData[paramName];
+            url = url.replace(match, encodeURIComponent(String(value)));
+            delete remainingData[paramName];
+        }
+
+        return {
+            url,
+            method: ctx.method,
+            headers: ctx.headers,
+            data: remainingData
+        };
+    }
+
+    public execute<T>(
+        ctx: IHttpRequest,
+        responseType: 'json' | 'text' | 'blob' | 'arraybuffer' | 'auto' = 'json'
+    ): Promise<IHttpResponse<T>> {
+        this.logger.trace('execute', ctx.method, ctx.url);
+
+        const hasBody = ['POST', 'PATCH', 'PUT', 'DELETE'].includes(ctx.method.toUpperCase());
+        const headers = { ...ctx.headers };
+
+        const init: RequestInit = {
+            method: ctx.method.toUpperCase(),
+        };
+
+        if (hasBody && ctx.data) {
+            if (ctx.data instanceof FormData) {
+                // FormData: don't set Content-Type, browser will set it with boundary
+                delete headers['Content-Type'];
+                init.body = ctx.data;
+            } else if (Object.keys(ctx.data).length > 0) {
+                init.body = JSON.stringify(ctx.data);
+            }
+        }
+
+        init.headers = headers;
+
+        return this.httpClient.fetch(ctx.url, init)
+            .then((response) => this.parseResponse<T>(response, responseType));
+    }
+
+    private parseResponse<T>(response: Response, responseType: string): Promise<IHttpResponse<T>> {
+        const headers: Record<string, string> = {};
+        response.headers.forEach((value, key) => {
+            headers[key] = value;
+        });
+
+        const effectiveType = responseType === 'auto'
+            ? this.detectResponseType(response.headers.get('Content-Type'))
+            : responseType;
+
+        return this.parseBody<T>(response, effectiveType)
+            .then((body) => ({
+                statusCode: response.status,
+                headers,
+                body
+            }));
+    }
+
+    private detectResponseType(contentType: string | null): 'json' | 'text' | 'blob' {
+        if (!contentType) {
+            return 'text';
+        }
+
+        const ct = contentType.toLowerCase();
+
+        if (ct.includes('application/json')) {
+            return 'json';
+        }
+
+        if (ct.startsWith('text/')) {
+            return 'text';
+        }
+
+        if (ct.includes('application/')) {
+            return 'blob';
+        }
+
+        return 'text';
+    }
+
+    private parseBody<T>(response: Response, responseType: string): Promise<T> {
+        switch (responseType) {
+            case 'json':
+                return response.json();
+            case 'text':
+                return response.text() as Promise<T>;
+            case 'blob':
+                return response.blob() as Promise<T>;
+            case 'arraybuffer':
+                return response.arrayBuffer() as Promise<T>;
+            default:
+                return response.json();
+        }
+    }
+}

package/src/services/socketio-service.ts

@@ -0,0 +1,138 @@
+import {DI, ILogger, resolve} from 'aurelia';
+import type {Socket} from 'socket.io-client';
+import {IHttpRequest, IHttpResponse, ITransport} from '../interfaces/api';
+import {Transport} from '../enums/api';
+import {IBleetConfiguration} from '../configure';
+
+// io sera chargé à la demande via require()
+let io: typeof import('socket.io-client').io | null = null;
+
+function getSocketIo(): typeof import('socket.io-client').io {
+    if (!io) {
+        try {
+            io = require('socket.io-client').io;
+        } catch {
+            throw new Error(
+                'socket.io-client non installé. ' +
+                'Installez-le avec : npm install socket.io-client'
+            );
+        }
+    }
+    return io;
+}
+
+export interface ISocketioService extends SocketioService {}
+export const ISocketioService = DI.createInterface<ISocketioService>(
+    'ISocketioService',
+    (x) => x.singleton(SocketioService)
+);
+
+export class SocketioService implements ITransport {
+    public readonly type = Transport.Socketio;
+    private readonly timeout = 5000;
+    private socket: Socket | null = null;
+    private connected: boolean = false;
+
+    public constructor(
+        private readonly logger: ILogger = resolve(ILogger).scopeTo('SocketioService'),
+        private readonly config: IBleetConfiguration = resolve(IBleetConfiguration),
+    ) {
+        this.logger.trace('constructor');
+    }
+
+    public isConnected(): boolean {
+        return this.connected && this.socket !== null;
+    }
+
+    public isAvailable(): boolean {
+        return this.isConnected();
+    }
+
+    public prepareRequest(ctx: IHttpRequest): IHttpRequest {
+        return {
+            ...ctx,
+            data: {...ctx.data, ...ctx.pathParams}
+        };
+    }
+
+    public connect(namespace: string = '/', options?: Record<string, any>): Promise<void> {
+        const baseUrl = this.config.getBaseUrl(Transport.Socketio);
+        const url = baseUrl + namespace;
+        this.logger.trace('connect', url);
+
+        if (this.socket !== null) {
+            this.logger.warn('connect:already-connected');
+            return Promise.resolve();
+        }
+
+        return new Promise((resolve, reject) => {
+            const socketIo = getSocketIo();
+            this.socket = socketIo(url, {
+                transports: ['websocket'],
+                ...options
+            });
+
+            this.socket.on('connect', () => {
+                this.logger.trace('connect:success');
+                this.connected = true;
+                resolve();
+            });
+
+            this.socket.on('connect_error', (error: Error) => {
+                this.logger.error('connect:error', error);
+                this.connected = false;
+                reject(error);
+            });
+
+            this.socket.on('disconnect', (reason: string) => {
+                this.logger.trace('disconnect', reason);
+                this.connected = false;
+            });
+        });
+    }
+
+    public disconnect(): void {
+        this.logger.trace('disconnect');
+
+        if (this.socket !== null) {
+            this.socket.disconnect();
+            this.socket = null;
+            this.connected = false;
+        }
+    }
+
+    public execute<T>(ctx: IHttpRequest, responseType?: string): Promise<IHttpResponse<T>> {
+        this.logger.trace('execute', ctx.method, ctx.url);
+
+        if (!this.isConnected() || this.socket === null) {
+            return Promise.reject(new Error('Socket not connected'));
+        }
+
+        const channel = `${ctx.method.toLowerCase()}:${ctx.url}`;
+        let data = ctx.data ?? {};
+
+        // Convert FormData to plain object (Socket.io can't send FormData)
+        if (data instanceof FormData) {
+            const obj: Record<string, any> = {};
+            data.forEach((value, key) => {
+                // Skip File objects - can't be serialized for Socket.io
+                if (!(value instanceof File)) {
+                    obj[key] = value;
+                }
+            });
+            data = obj;
+        }
+
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                reject(new Error('Socket timeout'));
+            }, this.timeout);
+
+            this.socket!.emit(channel, data, (response: IHttpResponse<T>) => {
+                clearTimeout(timeoutId);
+                this.logger.trace('execute:response', channel, response);
+                resolve(response);
+            });
+        });
+    }
+}