@en-solutions/tgm-client-sdk 1.6.21

package/esm2022/lib/core/auth-interceptor.mjs

@@ -0,0 +1,33 @@
+import { Injectable, Inject } from '@angular/core';
+import { TGM_SDK_CONFIG, InMemoryTokenStorage } from '../tgm-sdk.config';
+import * as i0 from "@angular/core";
+export class AuthInterceptor {
+    config;
+    tokenStorage;
+    constructor(config) {
+        this.config = config;
+        this.tokenStorage = config.tokenStorage ?? new InMemoryTokenStorage();
+    }
+    intercept(req, next) {
+        const token = this.tokenStorage.getToken();
+        if (token && this.shouldAddToken(req)) {
+            req = req.clone({
+                setHeaders: { Authorization: `Bearer ${token}` },
+            });
+        }
+        return next.handle(req);
+    }
+    shouldAddToken(req) {
+        const baseUrl = this.config.baseUrl.replace(/\/+$/, '');
+        return req.url.startsWith(baseUrl);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthInterceptor, deps: [{ token: TGM_SDK_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthInterceptor });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TGM_SDK_CONFIG]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC1pbnRlcmNlcHRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvY29yZS9hdXRoLWludGVyY2VwdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBR25ELE9BQU8sRUFBRSxjQUFjLEVBQWdCLG9CQUFvQixFQUF3QixNQUFNLG1CQUFtQixDQUFDOztBQUc3RyxNQUFNLE9BQU8sZUFBZTtJQUdrQjtJQUZwQyxZQUFZLENBQXVCO0lBRTNDLFlBQTRDLE1BQW9CO1FBQXBCLFdBQU0sR0FBTixNQUFNLENBQWM7UUFDOUQsSUFBSSxDQUFDLFlBQVksR0FBRyxNQUFNLENBQUMsWUFBWSxJQUFJLElBQUksb0JBQW9CLEVBQUUsQ0FBQztJQUN4RSxDQUFDO0lBRUQsU0FBUyxDQUFDLEdBQXFCLEVBQUUsSUFBaUI7UUFDaEQsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUMzQyxJQUFJLEtBQUssSUFBSSxJQUFJLENBQUMsY0FBYyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDdEMsR0FBRyxHQUFHLEdBQUcsQ0FBQyxLQUFLLENBQUM7Z0JBQ2QsVUFBVSxFQUFFLEVBQUUsYUFBYSxFQUFFLFVBQVUsS0FBSyxFQUFFLEVBQUU7YUFDakQsQ0FBQyxDQUFDO1FBQ0wsQ0FBQztRQUNELE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUMxQixDQUFDO0lBRU8sY0FBYyxDQUFDLEdBQXFCO1FBQzFDLE1BQU0sT0FBTyxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFDeEQsT0FBTyxHQUFHLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNyQyxDQUFDO3dHQXBCVSxlQUFlLGtCQUdOLGNBQWM7NEdBSHZCLGVBQWU7OzRGQUFmLGVBQWU7a0JBRDNCLFVBQVU7OzBCQUlJLE1BQU07MkJBQUMsY0FBYyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUsIEluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgSHR0cEludGVyY2VwdG9yLCBIdHRwUmVxdWVzdCwgSHR0cEhhbmRsZXIsIEh0dHBFdmVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcbmltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IFRHTV9TREtfQ09ORklHLCBUZ21TZGtDb25maWcsIEluTWVtb3J5VG9rZW5TdG9yYWdlLCBUb2tlblN0b3JhZ2VTdHJhdGVneSB9IGZyb20gJy4uL3RnbS1zZGsuY29uZmlnJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIEF1dGhJbnRlcmNlcHRvciBpbXBsZW1lbnRzIEh0dHBJbnRlcmNlcHRvciB7XG4gIHByaXZhdGUgdG9rZW5TdG9yYWdlOiBUb2tlblN0b3JhZ2VTdHJhdGVneTtcblxuICBjb25zdHJ1Y3RvcihASW5qZWN0KFRHTV9TREtfQ09ORklHKSBwcml2YXRlIGNvbmZpZzogVGdtU2RrQ29uZmlnKSB7XG4gICAgdGhpcy50b2tlblN0b3JhZ2UgPSBjb25maWcudG9rZW5TdG9yYWdlID8/IG5ldyBJbk1lbW9yeVRva2VuU3RvcmFnZSgpO1xuICB9XG5cbiAgaW50ZXJjZXB0KHJlcTogSHR0cFJlcXVlc3Q8YW55PiwgbmV4dDogSHR0cEhhbmRsZXIpOiBPYnNlcnZhYmxlPEh0dHBFdmVudDxhbnk+PiB7XG4gICAgY29uc3QgdG9rZW4gPSB0aGlzLnRva2VuU3RvcmFnZS5nZXRUb2tlbigpO1xuICAgIGlmICh0b2tlbiAmJiB0aGlzLnNob3VsZEFkZFRva2VuKHJlcSkpIHtcbiAgICAgIHJlcSA9IHJlcS5jbG9uZSh7XG4gICAgICAgIHNldEhlYWRlcnM6IHsgQXV0aG9yaXphdGlvbjogYEJlYXJlciAke3Rva2VufWAgfSxcbiAgICAgIH0pO1xuICAgIH1cbiAgICByZXR1cm4gbmV4dC5oYW5kbGUocmVxKTtcbiAgfVxuXG4gIHByaXZhdGUgc2hvdWxkQWRkVG9rZW4ocmVxOiBIdHRwUmVxdWVzdDxhbnk+KTogYm9vbGVhbiB7XG4gICAgY29uc3QgYmFzZVVybCA9IHRoaXMuY29uZmlnLmJhc2VVcmwucmVwbGFjZSgvXFwvKyQvLCAnJyk7XG4gICAgcmV0dXJuIHJlcS51cmwuc3RhcnRzV2l0aChiYXNlVXJsKTtcbiAgfVxufVxuIl19

package/esm2022/lib/core/client-interceptor.mjs

@@ -0,0 +1,34 @@
+import { Injectable, Inject } from '@angular/core';
+import { TGM_SDK_CONFIG } from '../tgm-sdk.config';
+import * as i0 from "@angular/core";
+import * as i1 from "./http-client.service";
+export class ClientInterceptor {
+    config;
+    httpClient;
+    constructor(config, httpClient) {
+        this.config = config;
+        this.httpClient = httpClient;
+    }
+    intercept(req, next) {
+        const clientId = this.httpClient.getClientId();
+        if (clientId && this.shouldAddClientId(req)) {
+            req = req.clone({
+                setHeaders: { 'X-Client-ID': clientId },
+            });
+        }
+        return next.handle(req);
+    }
+    shouldAddClientId(req) {
+        const baseUrl = this.config.baseUrl.replace(/\/+$/, '');
+        return req.url.startsWith(baseUrl);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ClientInterceptor, deps: [{ token: TGM_SDK_CONFIG }, { token: i1.TgmHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ClientInterceptor });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ClientInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TGM_SDK_CONFIG]
+                }] }, { type: i1.TgmHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/error-handler.mjs

@@ -0,0 +1,32 @@
+export class TgmApiError extends Error {
+    status;
+    error;
+    originalError;
+    constructor(status, message, error, originalError) {
+        super(message);
+        this.status = status;
+        this.error = error;
+        this.originalError = originalError;
+        this.name = 'TgmApiError';
+    }
+    get isUnauthorized() {
+        return this.status === 401;
+    }
+    get isForbidden() {
+        return this.status === 403;
+    }
+    get isNotFound() {
+        return this.status === 404;
+    }
+    get isValidationError() {
+        return this.status === 400 || this.status === 422;
+    }
+    get isServerError() {
+        return this.status >= 500;
+    }
+}
+export function mapHttpError(error) {
+    const message = error.error?.message ?? error.message ?? 'An unknown error occurred';
+    return new TgmApiError(error.status, message, error.error, error);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/http-client.service.mjs

@@ -0,0 +1,254 @@
+import { Injectable } from '@angular/core';
+import { throwError, BehaviorSubject, Subject, take, switchMap, catchError } from 'rxjs';
+import { InMemoryTokenStorage } from '../tgm-sdk.config';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * Core HTTP client for the TGM SDK.
+ * NOT providedIn root — must be provided by the consuming application
+ * via useFactory to avoid cross-bundle token mismatch in production builds.
+ */
+export class TgmHttpClient {
+    http;
+    baseUrl = '';
+    tokenStorage = new InMemoryTokenStorage();
+    clientId$ = new BehaviorSubject(undefined);
+    isRefreshing = false;
+    refreshTokenSubject = new Subject();
+    config;
+    constructor(http, config) {
+        this.http = http;
+        this.config = config ?? { baseUrl: '', tokenStorage: new InMemoryTokenStorage(), autoRefresh: false };
+        if (config) {
+            this.baseUrl = (config.baseUrl || '').replace(/\/+$/, '');
+            this.tokenStorage = config.tokenStorage ?? new InMemoryTokenStorage();
+            if (config.clientId) {
+                this.clientId$.next(config.clientId);
+            }
+        }
+    }
+    // --- Token management ---
+    getToken() {
+        return this.tokenStorage.getToken();
+    }
+    setToken(token) {
+        this.tokenStorage.setToken(token);
+    }
+    removeToken() {
+        this.tokenStorage.removeToken();
+    }
+    getRefreshToken() {
+        return this.tokenStorage.getRefreshToken();
+    }
+    setRefreshToken(token) {
+        this.tokenStorage.setRefreshToken(token);
+    }
+    removeRefreshToken() {
+        this.tokenStorage.removeRefreshToken();
+    }
+    clearTokens() {
+        this.tokenStorage.removeToken();
+        this.tokenStorage.removeRefreshToken();
+    }
+    // --- Client ID management ---
+    setClientId(clientId) {
+        this.clientId$.next(clientId);
+    }
+    getClientId() {
+        return this.clientId$.value;
+    }
+    // --- HTTP Methods ---
+    get(path, options) {
+        return this.request('GET', path, undefined, options);
+    }
+    post(path, body, options) {
+        return this.request('POST', path, body, options);
+    }
+    put(path, body, options) {
+        return this.request('PUT', path, body, options);
+    }
+    patch(path, body, options) {
+        return this.request('PATCH', path, body, options);
+    }
+    delete(path, options) {
+        return this.request('DELETE', path, undefined, options);
+    }
+    upload(path, formData, options) {
+        return this.request('POST', path, formData, { ...options, headers: { ...(options?.headers || {}) } });
+    }
+    download(path, options) {
+        return this.request('GET', path, undefined, { ...options, responseType: 'blob' });
+    }
+    // --- Internal ---
+    request(method, path, body, options) {
+        const url = `${this.baseUrl}${path}`;
+        // Use plain objects for headers and params to avoid cross-bundle class mismatch
+        // (SDK's HttpHeaders/HttpParams class !== app's HttpHeaders/HttpParams class in prod builds)
+        const headerMap = {};
+        // Auth header
+        if (!options?.skipAuth) {
+            const token = this.tokenStorage.getToken();
+            if (token) {
+                headerMap['Authorization'] = `Bearer ${token}`;
+            }
+        }
+        // Client ID header
+        if (!options?.skipClientId) {
+            const clientId = this.clientId$.value;
+            if (clientId) {
+                headerMap['X-Client-ID'] = clientId;
+            }
+        }
+        // Custom headers
+        if (options?.headers) {
+            for (const [key, value] of Object.entries(options.headers)) {
+                headerMap[key] = value;
+            }
+        }
+        // Query params — flatten nested objects/arrays for backend compatibility
+        const paramMap = {};
+        if (options?.params) {
+            const flatParams = this.flattenParams(options.params);
+            for (const [key, value] of Object.entries(flatParams)) {
+                if (value !== undefined && value !== null) {
+                    paramMap[key] = String(value);
+                }
+            }
+        }
+        const responseType = (options?.responseType ?? 'json');
+        const httpOptions = { headers: headerMap, params: paramMap, body, responseType };
+        return this.http.request(method, url, httpOptions).pipe(catchError((error) => {
+            if (error.status === 401 && !options?.skipAuth && this.config.autoRefresh !== false) {
+                return this.handle401(method, path, body, options);
+            }
+            return throwError(() => this.mapError(error));
+        }));
+    }
+    handle401(method, path, body, options) {
+        if (this.isRefreshing) {
+            return this.refreshTokenSubject.pipe(take(1), switchMap(() => this.request(method, path, body, { ...options, skipAuth: false })));
+        }
+        this.isRefreshing = true;
+        const refreshToken = this.tokenStorage.getRefreshToken();
+        if (!refreshToken) {
+            this.isRefreshing = false;
+            return throwError(() => ({ status: 401, message: 'No refresh token available' }));
+        }
+        return this.http.post(`${this.baseUrl}/auth/refresh-token`, null, {
+            params: { refreshToken }
+        }).pipe(switchMap((response) => {
+            this.isRefreshing = false;
+            const tokenKey = this.config.tokenKey ?? 'jwt';
+            const refreshKey = this.config.refreshTokenKey ?? 'refreshToken';
+            const newToken = response[tokenKey] ?? response.data?.[tokenKey];
+            const newRefresh = response[refreshKey] ?? response.data?.[refreshKey];
+            if (newToken) {
+                this.tokenStorage.setToken(newToken);
+            }
+            if (newRefresh) {
+                this.tokenStorage.setRefreshToken(newRefresh);
+            }
+            this.refreshTokenSubject.next(newToken);
+            return this.request(method, path, body, options);
+        }), catchError((err) => {
+            this.isRefreshing = false;
+            this.clearTokens();
+            return throwError(() => this.mapError(err));
+        }));
+    }
+    /**
+     * Flattens nested param objects into flat key-value pairs.
+     * - `{ filters: { status: 'active' } }` → `{ status: 'active' }`
+     * - `{ populate: ['a', 'b'] }` → `{ populate: 'a,b' }`
+     * - `{ pagination: { page: 1, pageSize: 25 } }` → `{ page: 1, pageSize: 25 }`
+     */
+    flattenParams(params) {
+        // Map Strapi pagination params to backend params
+        // Note: 'start' (offset) is converted to page number using limit as page size
+        const paramKeyMap = {
+            'limit': 'pageSize',
+            'page': 'page', 'pageSize': 'pageSize',
+        };
+        const result = {};
+        for (const [key, value] of Object.entries(params)) {
+            if (value === undefined || value === null)
+                continue;
+            if (Array.isArray(value)) {
+                result[key] = value.join(',');
+            }
+            else if (typeof value === 'object' && !(value instanceof Date)) {
+                // Flatten nested objects: merge their keys directly
+                for (const [nestedKey, nestedValue] of Object.entries(value)) {
+                    if (nestedValue !== undefined && nestedValue !== null) {
+                        if (typeof nestedValue === 'object' && !Array.isArray(nestedValue)) {
+                            // Two levels deep: map Strapi operators to backend suffix operators
+                            // e.g., { unit: { $eq: 5 } } → unit=5, { unit: { $notNull: true } } → unit_isnull=false
+                            const strapiToBackend = {
+                                '$eq': '', '$ne': '_ne', '$contains': '_contains',
+                                '$startsWith': '_startsWith', '$endsWith': '_endsWith',
+                                '$gt': '_gt', '$gte': '_gte', '$lt': '_lt', '$lte': '_lte',
+                                '$in': '_in', '$notIn': '_notIn', '$null': '_isnull',
+                                '$notNull': '_isnull', '$eqOrNull': '_eqOrNull',
+                            };
+                            for (const [deepKey, deepValue] of Object.entries(nestedValue)) {
+                                if (deepValue !== undefined && deepValue !== null) {
+                                    if (deepKey.startsWith('$')) {
+                                        // Strapi operator: { $eq: 5 } → field=5, { $contains: 'x' } → field_contains=x
+                                        const suffix = strapiToBackend[deepKey] ?? '_' + deepKey.slice(1);
+                                        const finalValue = deepKey === '$notNull' ? !deepValue : deepValue;
+                                        result[`${nestedKey}${suffix}`] = finalValue;
+                                    }
+                                    else {
+                                        // Relation field: { id: 5 } → field.id=5
+                                        result[`${nestedKey}.${deepKey}`] = deepValue;
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            const mappedKey = paramKeyMap[nestedKey] || nestedKey;
+                            result[mappedKey] = Array.isArray(nestedValue) ? nestedValue.join(',') : nestedValue;
+                        }
+                    }
+                }
+            }
+            else {
+                const mappedKey = paramKeyMap[key] || key;
+                result[mappedKey] = value;
+            }
+        }
+        // Convert Strapi offset-based 'start' to page number
+        // Only convert if 'start' is a pure number (Strapi offset), NOT an ISO date string
+        if ('start' in result) {
+            const startVal = result['start'];
+            const isNumericOffset = typeof startVal === 'number' || /^\d+$/.test(String(startVal));
+            if (isNumericOffset) {
+                const start = Number(startVal) || 0;
+                if ('pageSize' in result) {
+                    const pageSize = Number(result['pageSize']) || 25;
+                    result['page'] = Math.floor(start / pageSize);
+                }
+                else {
+                    result['page'] = start;
+                }
+                delete result['start'];
+            }
+            // If start is an ISO date string (e.g. "2026-01-01T00:00:00"), preserve it as-is
+        }
+        return result;
+    }
+    mapError(error) {
+        return {
+            status: error.status,
+            message: error.error?.message ?? error.message ?? 'Unknown error',
+            error: error.error,
+            originalError: error,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TgmHttpClient, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TgmHttpClient });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TgmHttpClient, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-client.service.js","sourceRoot":"","sources":["../../../../src/lib/core/http-client.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient, HttpErrorResponse } from '@angular/common/http';\nimport { Observable, throwError, BehaviorSubject, Subject, filter, take, switchMap, catchError } from 'rxjs';\nimport { TgmSdkConfig, InMemoryTokenStorage, TokenStorageStrategy } from '../tgm-sdk.config';\n\nexport interface RequestOptions {\n  headers?: Record<string, string>;\n  params?: Record<string, string | number | boolean | undefined>;\n  responseType?: 'json' | 'blob' | 'text' | 'arraybuffer';\n  reportProgress?: boolean;\n  skipAuth?: boolean;\n  skipClientId?: boolean;\n}\n\n/**\n * Core HTTP client for the TGM SDK.\n * NOT providedIn root — must be provided by the consuming application\n * via useFactory to avoid cross-bundle token mismatch in production builds.\n */\n@Injectable()\nexport class TgmHttpClient {\n  private baseUrl = '';\n  private tokenStorage: TokenStorageStrategy = new InMemoryTokenStorage();\n  private clientId$ = new BehaviorSubject<string | undefined>(undefined);\n  private isRefreshing = false;\n  private refreshTokenSubject = new Subject<string>();\n  private config: TgmSdkConfig;\n\n  constructor(private http: HttpClient, config?: TgmSdkConfig | null) {\n    this.config = config ?? { baseUrl: '', tokenStorage: new InMemoryTokenStorage(), autoRefresh: false };\n    if (config) {\n      this.baseUrl = (config.baseUrl || '').replace(/\\/+$/, '');\n      this.tokenStorage = config.tokenStorage ?? new InMemoryTokenStorage();\n      if (config.clientId) {\n        this.clientId$.next(config.clientId);\n      }\n    }\n  }\n\n  // --- Token management ---\n\n  getToken(): string | null {\n    return this.tokenStorage.getToken();\n  }\n\n  setToken(token: string): void {\n    this.tokenStorage.setToken(token);\n  }\n\n  removeToken(): void {\n    this.tokenStorage.removeToken();\n  }\n\n  getRefreshToken(): string | null {\n    return this.tokenStorage.getRefreshToken();\n  }\n\n  setRefreshToken(token: string): void {\n    this.tokenStorage.setRefreshToken(token);\n  }\n\n  removeRefreshToken(): void {\n    this.tokenStorage.removeRefreshToken();\n  }\n\n  clearTokens(): void {\n    this.tokenStorage.removeToken();\n    this.tokenStorage.removeRefreshToken();\n  }\n\n  // --- Client ID management ---\n\n  setClientId(clientId: string): void {\n    this.clientId$.next(clientId);\n  }\n\n  getClientId(): string | undefined {\n    return this.clientId$.value;\n  }\n\n  // --- HTTP Methods ---\n\n  get<T>(path: string, options?: RequestOptions): Observable<T> {\n    return this.request<T>('GET', path, undefined, options);\n  }\n\n  post<T>(path: string, body?: unknown, options?: RequestOptions): Observable<T> {\n    return this.request<T>('POST', path, body, options);\n  }\n\n  put<T>(path: string, body?: unknown, options?: RequestOptions): Observable<T> {\n    return this.request<T>('PUT', path, body, options);\n  }\n\n  patch<T>(path: string, body?: unknown, options?: RequestOptions): Observable<T> {\n    return this.request<T>('PATCH', path, body, options);\n  }\n\n  delete<T>(path: string, options?: RequestOptions): Observable<T> {\n    return this.request<T>('DELETE', path, undefined, options);\n  }\n\n  upload<T>(path: string, formData: FormData, options?: RequestOptions): Observable<T> {\n    return this.request<T>('POST', path, formData, { ...options, headers: { ...(options?.headers || {}) } });\n  }\n\n  download(path: string, options?: RequestOptions): Observable<Blob> {\n    return this.request<Blob>('GET', path, undefined, { ...options, responseType: 'blob' });\n  }\n\n  // --- Internal ---\n\n  private request<T>(method: string, path: string, body?: unknown, options?: RequestOptions): Observable<T> {\n    const url = `${this.baseUrl}${path}`;\n\n    // Use plain objects for headers and params to avoid cross-bundle class mismatch\n    // (SDK's HttpHeaders/HttpParams class !== app's HttpHeaders/HttpParams class in prod builds)\n    const headerMap: Record<string, string> = {};\n\n    // Auth header\n    if (!options?.skipAuth) {\n      const token = this.tokenStorage.getToken();\n      if (token) {\n        headerMap['Authorization'] = `Bearer ${token}`;\n      }\n    }\n\n    // Client ID header\n    if (!options?.skipClientId) {\n      const clientId = this.clientId$.value;\n      if (clientId) {\n        headerMap['X-Client-ID'] = clientId;\n      }\n    }\n\n    // Custom headers\n    if (options?.headers) {\n      for (const [key, value] of Object.entries(options.headers)) {\n        headerMap[key] = value;\n      }\n    }\n\n    // Query params — flatten nested objects/arrays for backend compatibility\n    const paramMap: Record<string, string> = {};\n    if (options?.params) {\n      const flatParams = this.flattenParams(options.params);\n      for (const [key, value] of Object.entries(flatParams)) {\n        if (value !== undefined && value !== null) {\n          paramMap[key] = String(value);\n        }\n      }\n    }\n\n    const responseType = (options?.responseType ?? 'json') as 'json';\n\n    const httpOptions: Record<string, unknown> = { headers: headerMap, params: paramMap, body, responseType };\n\n    return (this.http.request(method, url, httpOptions) as Observable<T>).pipe(\n      catchError((error: HttpErrorResponse) => {\n        if (error.status === 401 && !options?.skipAuth && this.config.autoRefresh !== false) {\n          return this.handle401<T>(method, path, body, options);\n        }\n        return throwError(() => this.mapError(error));\n      })\n    );\n  }\n\n  private handle401<T>(method: string, path: string, body?: unknown, options?: RequestOptions): Observable<T> {\n    if (this.isRefreshing) {\n      return this.refreshTokenSubject.pipe(\n        take(1),\n        switchMap(() => this.request<T>(method, path, body, { ...options, skipAuth: false }))\n      );\n    }\n\n    this.isRefreshing = true;\n    const refreshToken = this.tokenStorage.getRefreshToken();\n\n    if (!refreshToken) {\n      this.isRefreshing = false;\n      return throwError(() => ({ status: 401, message: 'No refresh token available' }));\n    }\n\n    return this.http.post<any>(`${this.baseUrl}/auth/refresh-token`, null, {\n      params: { refreshToken }\n    }).pipe(\n      switchMap((response: any) => {\n        this.isRefreshing = false;\n        const tokenKey = this.config.tokenKey ?? 'jwt';\n        const refreshKey = this.config.refreshTokenKey ?? 'refreshToken';\n        const newToken = response[tokenKey] ?? response.data?.[tokenKey];\n        const newRefresh = response[refreshKey] ?? response.data?.[refreshKey];\n\n        if (newToken) {\n          this.tokenStorage.setToken(newToken);\n        }\n        if (newRefresh) {\n          this.tokenStorage.setRefreshToken(newRefresh);\n        }\n\n        this.refreshTokenSubject.next(newToken);\n        return this.request<T>(method, path, body, options);\n      }),\n      catchError((err) => {\n        this.isRefreshing = false;\n        this.clearTokens();\n        return throwError(() => this.mapError(err));\n      })\n    );\n  }\n\n  /**\n   * Flattens nested param objects into flat key-value pairs.\n   * - `{ filters: { status: 'active' } }` → `{ status: 'active' }`\n   * - `{ populate: ['a', 'b'] }` → `{ populate: 'a,b' }`\n   * - `{ pagination: { page: 1, pageSize: 25 } }` → `{ page: 1, pageSize: 25 }`\n   */\n  private flattenParams(params: Record<string, any>): Record<string, string | number | boolean> {\n    // Map Strapi pagination params to backend params\n    // Note: 'start' (offset) is converted to page number using limit as page size\n    const paramKeyMap: Record<string, string> = {\n      'limit': 'pageSize',\n      'page': 'page', 'pageSize': 'pageSize',\n    };\n    const result: Record<string, any> = {};\n    for (const [key, value] of Object.entries(params)) {\n      if (value === undefined || value === null) continue;\n      if (Array.isArray(value)) {\n        result[key] = value.join(',');\n      } else if (typeof value === 'object' && !(value instanceof Date)) {\n        // Flatten nested objects: merge their keys directly\n        for (const [nestedKey, nestedValue] of Object.entries(value)) {\n          if (nestedValue !== undefined && nestedValue !== null) {\n            if (typeof nestedValue === 'object' && !Array.isArray(nestedValue)) {\n              // Two levels deep: map Strapi operators to backend suffix operators\n              // e.g., { unit: { $eq: 5 } } → unit=5, { unit: { $notNull: true } } → unit_isnull=false\n              const strapiToBackend: Record<string, string> = {\n                '$eq': '', '$ne': '_ne', '$contains': '_contains',\n                '$startsWith': '_startsWith', '$endsWith': '_endsWith',\n                '$gt': '_gt', '$gte': '_gte', '$lt': '_lt', '$lte': '_lte',\n                '$in': '_in', '$notIn': '_notIn', '$null': '_isnull',\n                '$notNull': '_isnull', '$eqOrNull': '_eqOrNull',\n              };\n              for (const [deepKey, deepValue] of Object.entries(nestedValue as any)) {\n                if (deepValue !== undefined && deepValue !== null) {\n                  if (deepKey.startsWith('$')) {\n                    // Strapi operator: { $eq: 5 } → field=5, { $contains: 'x' } → field_contains=x\n                    const suffix = strapiToBackend[deepKey] ?? '_' + deepKey.slice(1);\n                    const finalValue = deepKey === '$notNull' ? !deepValue : deepValue;\n                    result[`${nestedKey}${suffix}`] = finalValue;\n                  } else {\n                    // Relation field: { id: 5 } → field.id=5\n                    result[`${nestedKey}.${deepKey}`] = deepValue;\n                  }\n                }\n              }\n            } else {\n              const mappedKey = paramKeyMap[nestedKey] || nestedKey;\n              result[mappedKey] = Array.isArray(nestedValue) ? nestedValue.join(',') : nestedValue;\n            }\n          }\n        }\n      } else {\n        const mappedKey = paramKeyMap[key] || key;\n        result[mappedKey] = value;\n      }\n    }\n    // Convert Strapi offset-based 'start' to page number\n    // Only convert if 'start' is a pure number (Strapi offset), NOT an ISO date string\n    if ('start' in result) {\n      const startVal = result['start'];\n      const isNumericOffset = typeof startVal === 'number' || /^\\d+$/.test(String(startVal));\n      if (isNumericOffset) {\n        const start = Number(startVal) || 0;\n        if ('pageSize' in result) {\n          const pageSize = Number(result['pageSize']) || 25;\n          result['page'] = Math.floor(start / pageSize);\n        } else {\n          result['page'] = start;\n        }\n        delete result['start'];\n      }\n      // If start is an ISO date string (e.g. \"2026-01-01T00:00:00\"), preserve it as-is\n    }\n    return result;\n  }\n\n  private mapError(error: HttpErrorResponse): TgmSdkError {\n    return {\n      status: error.status,\n      message: error.error?.message ?? error.message ?? 'Unknown error',\n      error: error.error,\n      originalError: error,\n    };\n  }\n}\n\nexport interface TgmSdkError {\n  status: number;\n  message: string;\n  error?: any;\n  originalError?: HttpErrorResponse;\n}\n"]}

package/esm2022/lib/core/websocket.service.mjs

@@ -0,0 +1,185 @@
+import { Injectable, Inject } from '@angular/core';
+import { Subject, BehaviorSubject, share, takeUntil } from 'rxjs';
+import { Client } from '@stomp/stompjs';
+import * as SockJSModule from 'sockjs-client';
+import { TGM_SDK_CONFIG } from '../tgm-sdk.config';
+import * as i0 from "@angular/core";
+import * as i1 from "./http-client.service";
+const SockJS = SockJSModule.default || SockJSModule;
+export class WebSocketService {
+    config;
+    httpClient;
+    client = null;
+    subscriptions = new Map();
+    messageSubjects = new Map();
+    destroy$ = new Subject();
+    reconnectAttempts = 0;
+    maxReconnectAttempts = 10;
+    baseReconnectDelay = 1000;
+    connectionState$ = new BehaviorSubject('DISCONNECTED');
+    constructor(config, httpClient) {
+        this.config = config;
+        this.httpClient = httpClient;
+    }
+    connect(endpoint) {
+        if (this.client?.connected)
+            return;
+        const wsEndpoint = endpoint ?? this.config.wsEndpoint ?? '/ws';
+        const baseUrl = this.config.baseUrl.replace(/\/+$/, '');
+        const url = `${baseUrl}${wsEndpoint}`;
+        this.connectionState$.next('CONNECTING');
+        this.client = new Client({
+            webSocketFactory: () => new SockJS(url),
+            connectHeaders: this.getConnectHeaders(),
+            reconnectDelay: 0, // We handle reconnect manually
+            heartbeatIncoming: 10000,
+            heartbeatOutgoing: 10000,
+            onConnect: () => {
+                this.connectionState$.next('CONNECTED');
+                this.reconnectAttempts = 0;
+                this.resubscribeAll();
+            },
+            onStompError: (frame) => {
+                this.connectionState$.next('ERROR');
+                console.error('STOMP error:', frame.headers['message']);
+                this.scheduleReconnect(endpoint);
+            },
+            onWebSocketClose: () => {
+                if (this.connectionState$.value !== 'DISCONNECTED') {
+                    this.connectionState$.next('ERROR');
+                    this.scheduleReconnect(endpoint);
+                }
+            },
+        });
+        this.client.activate();
+    }
+    disconnect() {
+        this.connectionState$.next('DISCONNECTED');
+        this.subscriptions.forEach((sub) => {
+            try {
+                sub.unsubscribe();
+            }
+            catch (_) { }
+        });
+        this.subscriptions.clear();
+        if (this.client) {
+            this.client.deactivate();
+            this.client = null;
+        }
+    }
+    subscribe(destination) {
+        const prefixed = this.getTenantPrefixedDestination(destination);
+        if (!this.messageSubjects.has(prefixed)) {
+            this.messageSubjects.set(prefixed, new Subject());
+        }
+        // Subscribe when connected
+        if (this.client?.connected && !this.subscriptions.has(prefixed)) {
+            this.doSubscribe(prefixed);
+        }
+        return this.messageSubjects.get(prefixed).asObservable().pipe(takeUntil(this.destroy$), share());
+    }
+    unsubscribe(destination) {
+        const prefixed = this.getTenantPrefixedDestination(destination);
+        const sub = this.subscriptions.get(prefixed);
+        if (sub) {
+            try {
+                sub.unsubscribe();
+            }
+            catch (_) { }
+            this.subscriptions.delete(prefixed);
+        }
+        this.messageSubjects.get(prefixed)?.complete();
+        this.messageSubjects.delete(prefixed);
+    }
+    send(destination, body, headers) {
+        if (!this.client?.connected) {
+            console.warn('WebSocket not connected, cannot send to', destination);
+            return;
+        }
+        this.client.publish({
+            destination,
+            body: typeof body === 'string' ? body : JSON.stringify(body),
+            headers,
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.disconnect();
+    }
+    /**
+     * Prefix /topic/ destinations with the client ID for tenant isolation.
+     * Matches server-side WebSocketService.getTenantPrefixedDestination().
+     * /user/queue/ destinations are user-scoped and not prefixed.
+     */
+    getTenantPrefixedDestination(destination) {
+        const clientId = this.httpClient.getClientId();
+        if (clientId) {
+            if (destination.startsWith('/topic/')) {
+                return `/topic/${clientId}${destination.substring(6)}`;
+            }
+        }
+        return destination;
+    }
+    getConnectHeaders() {
+        const headers = {};
+        const token = this.httpClient.getToken();
+        if (token) {
+            headers['Authorization'] = `Bearer ${token}`;
+            headers['token'] = token;
+        }
+        const clientId = this.httpClient.getClientId();
+        if (clientId) {
+            headers['X-Client-ID'] = clientId;
+        }
+        return headers;
+    }
+    doSubscribe(destination) {
+        if (!this.client?.connected)
+            return;
+        const sub = this.client.subscribe(destination, (message) => {
+            const subject = this.messageSubjects.get(destination);
+            if (subject) {
+                try {
+                    subject.next(JSON.parse(message.body));
+                }
+                catch {
+                    subject.next(message.body);
+                }
+            }
+        });
+        this.subscriptions.set(destination, sub);
+    }
+    resubscribeAll() {
+        const destinations = Array.from(this.messageSubjects.keys());
+        this.subscriptions.clear();
+        for (const dest of destinations) {
+            this.doSubscribe(dest);
+        }
+    }
+    scheduleReconnect(endpoint) {
+        if (this.connectionState$.value === 'DISCONNECTED')
+            return;
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            console.error('Max WebSocket reconnect attempts reached');
+            return;
+        }
+        const delay = Math.min(this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts), 30000);
+        this.reconnectAttempts++;
+        setTimeout(() => {
+            if (this.connectionState$.value !== 'DISCONNECTED') {
+                this.connect(endpoint);
+            }
+        }, delay);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WebSocketService, deps: [{ token: TGM_SDK_CONFIG }, { token: i1.TgmHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WebSocketService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WebSocketService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TGM_SDK_CONFIG]
+                }] }, { type: i1.TgmHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket.service.js","sourceRoot":"","sources":["../../../../src/lib/core/websocket.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject, OnDestroy } from '@angular/core';\nimport { Observable, Subject, BehaviorSubject, share, filter, takeUntil } from 'rxjs';\nimport { Client, IMessage, StompSubscription } from '@stomp/stompjs';\nimport * as SockJSModule from 'sockjs-client';\nconst SockJS = (SockJSModule as any).default || SockJSModule;\nimport { TGM_SDK_CONFIG, TgmSdkConfig } from '../tgm-sdk.config';\nimport { TgmHttpClient } from './http-client.service';\n\nexport type ConnectionState = 'DISCONNECTED' | 'CONNECTING' | 'CONNECTED' | 'ERROR';\n\n@Injectable({ providedIn: 'root' })\nexport class WebSocketService implements OnDestroy {\n  private client: Client | null = null;\n  private subscriptions = new Map<string, StompSubscription>();\n  private messageSubjects = new Map<string, Subject<any>>();\n  private destroy$ = new Subject<void>();\n  private reconnectAttempts = 0;\n  private maxReconnectAttempts = 10;\n  private baseReconnectDelay = 1000;\n\n  connectionState$ = new BehaviorSubject<ConnectionState>('DISCONNECTED');\n\n  constructor(\n    @Inject(TGM_SDK_CONFIG) private config: TgmSdkConfig,\n    private httpClient: TgmHttpClient\n  ) {}\n\n  connect(endpoint?: string): void {\n    if (this.client?.connected) return;\n\n    const wsEndpoint = endpoint ?? this.config.wsEndpoint ?? '/ws';\n    const baseUrl = this.config.baseUrl.replace(/\\/+$/, '');\n    const url = `${baseUrl}${wsEndpoint}`;\n\n    this.connectionState$.next('CONNECTING');\n\n    this.client = new Client({\n      webSocketFactory: () => new SockJS(url) as any,\n      connectHeaders: this.getConnectHeaders(),\n      reconnectDelay: 0, // We handle reconnect manually\n      heartbeatIncoming: 10000,\n      heartbeatOutgoing: 10000,\n      onConnect: () => {\n        this.connectionState$.next('CONNECTED');\n        this.reconnectAttempts = 0;\n        this.resubscribeAll();\n      },\n      onStompError: (frame) => {\n        this.connectionState$.next('ERROR');\n        console.error('STOMP error:', frame.headers['message']);\n        this.scheduleReconnect(endpoint);\n      },\n      onWebSocketClose: () => {\n        if (this.connectionState$.value !== 'DISCONNECTED') {\n          this.connectionState$.next('ERROR');\n          this.scheduleReconnect(endpoint);\n        }\n      },\n    });\n\n    this.client.activate();\n  }\n\n  disconnect(): void {\n    this.connectionState$.next('DISCONNECTED');\n    this.subscriptions.forEach((sub) => {\n      try { sub.unsubscribe(); } catch (_) {}\n    });\n    this.subscriptions.clear();\n    if (this.client) {\n      this.client.deactivate();\n      this.client = null;\n    }\n  }\n\n  subscribe<T = any>(destination: string): Observable<T> {\n    const prefixed = this.getTenantPrefixedDestination(destination);\n    if (!this.messageSubjects.has(prefixed)) {\n      this.messageSubjects.set(prefixed, new Subject<T>());\n    }\n\n    // Subscribe when connected\n    if (this.client?.connected && !this.subscriptions.has(prefixed)) {\n      this.doSubscribe(prefixed);\n    }\n\n    return this.messageSubjects.get(prefixed)!.asObservable().pipe(\n      takeUntil(this.destroy$),\n      share()\n    );\n  }\n\n  unsubscribe(destination: string): void {\n    const prefixed = this.getTenantPrefixedDestination(destination);\n    const sub = this.subscriptions.get(prefixed);\n    if (sub) {\n      try { sub.unsubscribe(); } catch (_) {}\n      this.subscriptions.delete(prefixed);\n    }\n    this.messageSubjects.get(prefixed)?.complete();\n    this.messageSubjects.delete(prefixed);\n  }\n\n  send(destination: string, body: any, headers?: Record<string, string>): void {\n    if (!this.client?.connected) {\n      console.warn('WebSocket not connected, cannot send to', destination);\n      return;\n    }\n    this.client.publish({\n      destination,\n      body: typeof body === 'string' ? body : JSON.stringify(body),\n      headers,\n    });\n  }\n\n  ngOnDestroy(): void {\n    this.destroy$.next();\n    this.destroy$.complete();\n    this.disconnect();\n  }\n\n  /**\n   * Prefix /topic/ destinations with the client ID for tenant isolation.\n   * Matches server-side WebSocketService.getTenantPrefixedDestination().\n   * /user/queue/ destinations are user-scoped and not prefixed.\n   */\n  private getTenantPrefixedDestination(destination: string): string {\n    const clientId = this.httpClient.getClientId();\n    if (clientId) {\n      if (destination.startsWith('/topic/')) {\n        return `/topic/${clientId}${destination.substring(6)}`;\n      }\n    }\n    return destination;\n  }\n\n  private getConnectHeaders(): Record<string, string> {\n    const headers: Record<string, string> = {};\n    const token = this.httpClient.getToken();\n    if (token) {\n      headers['Authorization'] = `Bearer ${token}`;\n      headers['token'] = token;\n    }\n    const clientId = this.httpClient.getClientId();\n    if (clientId) {\n      headers['X-Client-ID'] = clientId;\n    }\n    return headers;\n  }\n\n  private doSubscribe(destination: string): void {\n    if (!this.client?.connected) return;\n    const sub = this.client.subscribe(destination, (message: IMessage) => {\n      const subject = this.messageSubjects.get(destination);\n      if (subject) {\n        try {\n          subject.next(JSON.parse(message.body));\n        } catch {\n          subject.next(message.body as any);\n        }\n      }\n    });\n    this.subscriptions.set(destination, sub);\n  }\n\n  private resubscribeAll(): void {\n    const destinations = Array.from(this.messageSubjects.keys());\n    this.subscriptions.clear();\n    for (const dest of destinations) {\n      this.doSubscribe(dest);\n    }\n  }\n\n  private scheduleReconnect(endpoint?: string): void {\n    if (this.connectionState$.value === 'DISCONNECTED') return;\n    if (this.reconnectAttempts >= this.maxReconnectAttempts) {\n      console.error('Max WebSocket reconnect attempts reached');\n      return;\n    }\n    const delay = Math.min(\n      this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts),\n      30000\n    );\n    this.reconnectAttempts++;\n    setTimeout(() => {\n      if (this.connectionState$.value !== 'DISCONNECTED') {\n        this.connect(endpoint);\n      }\n    }, delay);\n  }\n}\n"]}

package/esm2022/lib/models/admin/audit.models.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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