@aakash58/chatbot 1.1.15 → 1.1.17

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

@@ -0,0 +1,103 @@
+import { Injectable } from '@angular/core';
+import { delay, retry, map, catchError, of } from 'rxjs';
+import logger from '../utils/logger.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../auth/storage.service";
+import * as i3 from "../services/core-config.service";
+export class HttpService {
+    //   @BlockUI() blockUI!: NgBlockUI;
+    get apiUrl() {
+        return this.coreConfig.apiUrl;
+    }
+    constructor(http, tokenStorage, coreConfig) {
+        this.http = http;
+        this.tokenStorage = tokenStorage;
+        this.coreConfig = coreConfig;
+        logger.log('HttpService: Initialized');
+    }
+    get(url, param, nestedParam = false, showLoader = false, refresh = true, headers) {
+        // if (showLoader && !this.blockUI.isActive) {
+        //   this.blockUI.start();
+        // }
+        let params = {};
+        if (nestedParam) {
+            this.buildHttpParams(params, param, '');
+        }
+        else {
+            params = param;
+        }
+        return this.http
+            .get(`${this.apiUrl}${url}`, {
+            params: params,
+            // withCredentials: true,
+            headers,
+        })
+            .pipe(delay(100), retry(0), map((response) => this.returnResponse(response, showLoader)), catchError((error) => {
+            // if (this.blockUI.isActive) {
+            //   this.blockUI.stop();
+            // }
+            return of(error);
+        }));
+    }
+    buildHttpParams(params, data, currentPath) {
+        Object.keys(data).forEach((key) => {
+            if (data[key] instanceof Object && !(data[key] instanceof Array)) {
+                this.buildHttpParams(params, data[key], `${currentPath}${key}.`);
+            }
+            else {
+                params[`${currentPath}${key}`] = data[key];
+            }
+        });
+    }
+    post(url, param, showLoader = false, headers) {
+        // if (showLoader && !this.blockUI.isActive) {
+        //   this.blockUI.start();
+        // }
+        return this.http.post(`${this.apiUrl}${url}`, param, { headers }).pipe(delay(100), retry(0), map((response) => this.returnResponse(response, showLoader)), catchError((error) => {
+            // if (this.blockUI.isActive) {
+            //   this.blockUI.stop();
+            // }
+            return of(error);
+        }));
+    }
+    patch(url, param, showLoader = false, headers) {
+        // if (showLoader && !this.blockUI.isActive) {
+        //   this.blockUI.start();
+        // }
+        return this.http.patch(`${this.apiUrl}${url}`, param, { headers }).pipe(delay(100), retry(0), map((response) => this.returnResponse(response, showLoader)), catchError((error) => {
+            // if (this.blockUI.isActive) {
+            //   this.blockUI.stop();
+            // }
+            return of(error);
+        }));
+    }
+    delete(url, param, showLoader = false, headers) {
+        // if (showLoader && !this.blockUI.isActive) {
+        //   this.blockUI.start();
+        // }
+        let params = {};
+        params = param;
+        return this.http.delete(`${this.apiUrl}${url}`, { body: param, headers }).pipe(delay(100), retry(0), map((response) => this.returnResponse(response, showLoader)), catchError((error) => {
+            // if (this.blockUI.isActive) {
+            //   this.blockUI.stop();
+            // }
+            return of(error);
+        }));
+    }
+    returnResponse(value, showLoader = true) {
+        // if (showLoader && this.blockUI.isActive) {
+        //   this.blockUI.reset();
+        // }
+        return value;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HttpService, deps: [{ token: i1.HttpClient }, { token: i2.StorageService }, { token: i3.CoreConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HttpService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HttpService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.StorageService }, { type: i3.CoreConfigService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.service.js","sourceRoot":"","sources":["../../../../../../projects/doohbot/src/lib/core/http/http.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAc,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,MAAM,CAAC;AAGrE,OAAO,MAAM,MAAM,yBAAyB,CAAC;;;;;AAK7C,MAAM,OAAO,WAAW;IACtB,oCAAoC;IAEpC,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC;IAChC,CAAC;IAED,YACU,IAAgB,EAChB,YAA4B,EAC5B,UAA6B;QAF7B,SAAI,GAAJ,IAAI,CAAY;QAChB,iBAAY,GAAZ,YAAY,CAAgB;QAC5B,eAAU,GAAV,UAAU,CAAmB;QAErC,MAAM,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC;IACzC,CAAC;IAED,GAAG,CACD,GAAW,EACX,KAAc,EACd,WAAW,GAAG,KAAK,EACnB,UAAU,GAAG,KAAK,EAClB,OAAO,GAAG,IAAI,EACd,OAAqB;QAErB,8CAA8C;QAE9C,0BAA0B;QAE1B,IAAI;QAEJ,IAAI,MAAM,GAAG,EAAE,CAAC;QAEhB,IAAI,WAAW,EAAE;YACf,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;SACzC;aAAM;YACL,MAAM,GAAG,KAAmB,CAAC;SAC9B;QAED,OAAO,IAAI,CAAC,IAAI;aACb,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,GAAG,EAAE,EAAE;YAC3B,MAAM,EAAE,MAAM;YACd,yBAAyB;YACzB,OAAO;SACR,CAAC;aACD,IAAI,CACH,KAAK,CAAC,GAAG,CAAC,EAEV,KAAK,CAAC,CAAC,CAAC,EAER,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC,EAE5D,UAAU,CAAC,CAAC,KAAK,EAAE,EAAE;YACnB,+BAA+B;YAE/B,yBAAyB;YAEzB,IAAI;YAEJ,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;QACnB,CAAC,CAAC,CACH,CAAC;IACN,CAAC;IAEO,eAAe,CAAC,MAAW,EAAE,IAAS,EAAE,WAAmB;QACjE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;YAChC,IAAI,IAAI,CAAC,GAAG,CAAC,YAAY,MAAM,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,KAAK,CAAC,EAAE;gBAChE,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,WAAW,GAAG,GAAG,GAAG,CAAC,CAAC;aAClE;iBAAM;gBACL,MAAM,CAAC,GAAG,WAAW,GAAG,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;aAC5C;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,IAAI,CAAC,GAAW,EAAE,KAAc,EAAE,UAAU,GAAG,KAAK,EAAE,OAAqB;QACzE,8CAA8C;QAC9C,0BAA0B;QAC1B,IAAI;QAEJ,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,GAAG,EAAE,EAAE,KAAmB,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC,IAAI,CAClF,KAAK,CAAC,GAAG,CAAC,EACV,KAAK,CAAC,CAAC,CAAC,EACR,GAAG,CAAC,CAAC,QAAa,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC,EACjE,UAAU,CAAC,CAAC,KAAK,EAAE,EAAE;YACnB,+BAA+B;YAC/B,yBAAyB;YACzB,IAAI;YAEJ,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;QACnB,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,GAAW,EAAE,KAAc,EAAE,UAAU,GAAG,KAAK,EAAE,OAAqB;QAC1E,8CAA8C;QAC9C,0BAA0B;QAC1B,IAAI;QAEJ,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,GAAG,EAAE,EAAE,KAAmB,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC,IAAI,CACnF,KAAK,CAAC,GAAG,CAAC,EACV,KAAK,CAAC,CAAC,CAAC,EACR,GAAG,CAAC,CAAC,QAAa,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC,EACjE,UAAU,CAAC,CAAC,KAAK,EAAE,EAAE;YACnB,+BAA+B;YAC/B,yBAAyB;YACzB,IAAI;YAEJ,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;QACnB,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,GAAW,EAAE,KAAc,EAAE,UAAU,GAAG,KAAK,EAAE,OAAqB;QAC3E,8CAA8C;QAC9C,0BAA0B;QAC1B,IAAI;QACJ,IAAI,MAAM,GAAG,EAAE,CAAC;QAChB,MAAM,GAAG,KAAmB,CAAC;QAE7B,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,IAAI,CAC5E,KAAK,CAAC,GAAG,CAAC,EACV,KAAK,CAAC,CAAC,CAAC,EACR,GAAG,CAAC,CAAC,QAAa,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC,EACjE,UAAU,CAAC,CAAC,KAAK,EAAE,EAAE;YACnB,+BAA+B;YAC/B,yBAAyB;YACzB,IAAI;YAEJ,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;QACnB,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAEO,cAAc,CAAC,KAAU,EAAE,aAAsB,IAAI;QAC3D,6CAA6C;QAC7C,0BAA0B;QAC1B,IAAI;QACJ,OAAO,KAAK,CAAC;IACf,CAAC;+GAxIU,WAAW;mHAAX,WAAW,cAFV,MAAM;;4FAEP,WAAW;kBAHvB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { Observable, delay, retry, map, catchError, of } from 'rxjs';\r\nimport { CoreConfigService } from '../services/core-config.service';\r\nimport { StorageService } from '../auth/storage.service';\r\nimport logger from '../utils/logger.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class HttpService {\r\n  //   @BlockUI() blockUI!: NgBlockUI;\r\n\r\n  get apiUrl(): string {\r\n    return this.coreConfig.apiUrl;\r\n  }\r\n\r\n  constructor(\r\n    private http: HttpClient,\r\n    private tokenStorage: StorageService,\r\n    private coreConfig: CoreConfigService,\r\n  ) {\r\n    logger.log('HttpService: Initialized');\r\n  }\r\n\r\n  get(\r\n    url: string,\r\n    param?: object,\r\n    nestedParam = false,\r\n    showLoader = false,\r\n    refresh = true,\r\n    headers?: HttpHeaders,\r\n  ): Observable<any> {\r\n    // if (showLoader && !this.blockUI.isActive) {\r\n\r\n    //   this.blockUI.start();\r\n\r\n    // }\r\n\r\n    let params = {};\r\n\r\n    if (nestedParam) {\r\n      this.buildHttpParams(params, param, '');\r\n    } else {\r\n      params = param as HttpParams;\r\n    }\r\n\r\n    return this.http\r\n      .get(`${this.apiUrl}${url}`, {\r\n        params: params,\r\n        // withCredentials: true,\r\n        headers,\r\n      })\r\n      .pipe(\r\n        delay(100),\r\n\r\n        retry(0),\r\n\r\n        map((response) => this.returnResponse(response, showLoader)),\r\n\r\n        catchError((error) => {\r\n          // if (this.blockUI.isActive) {\r\n\r\n          //   this.blockUI.stop();\r\n\r\n          // }\r\n\r\n          return of(error);\r\n        }),\r\n      );\r\n  }\r\n\r\n  private buildHttpParams(params: any, data: any, currentPath: string) {\r\n    Object.keys(data).forEach((key) => {\r\n      if (data[key] instanceof Object && !(data[key] instanceof Array)) {\r\n        this.buildHttpParams(params, data[key], `${currentPath}${key}.`);\r\n      } else {\r\n        params[`${currentPath}${key}`] = data[key];\r\n      }\r\n    });\r\n  }\r\n\r\n  post(url: string, param?: object, showLoader = false, headers?: HttpHeaders): Observable<any> {\r\n    // if (showLoader && !this.blockUI.isActive) {\r\n    //   this.blockUI.start();\r\n    // }\r\n\r\n    return this.http.post(`${this.apiUrl}${url}`, param as HttpParams, { headers }).pipe(\r\n      delay(100),\r\n      retry(0),\r\n      map((response: any) => this.returnResponse(response, showLoader)),\r\n      catchError((error) => {\r\n        // if (this.blockUI.isActive) {\r\n        //   this.blockUI.stop();\r\n        // }\r\n\r\n        return of(error);\r\n      }),\r\n    );\r\n  }\r\n\r\n  patch(url: string, param?: object, showLoader = false, headers?: HttpHeaders): Observable<any> {\r\n    // if (showLoader && !this.blockUI.isActive) {\r\n    //   this.blockUI.start();\r\n    // }\r\n\r\n    return this.http.patch(`${this.apiUrl}${url}`, param as HttpParams, { headers }).pipe(\r\n      delay(100),\r\n      retry(0),\r\n      map((response: any) => this.returnResponse(response, showLoader)),\r\n      catchError((error) => {\r\n        // if (this.blockUI.isActive) {\r\n        //   this.blockUI.stop();\r\n        // }\r\n\r\n        return of(error);\r\n      }),\r\n    );\r\n  }\r\n\r\n  delete(url: string, param?: object, showLoader = false, headers?: HttpHeaders): Observable<any> {\r\n    // if (showLoader && !this.blockUI.isActive) {\r\n    //   this.blockUI.start();\r\n    // }\r\n    let params = {};\r\n    params = param as HttpParams;\r\n\r\n    return this.http.delete(`${this.apiUrl}${url}`, { body: param, headers }).pipe(\r\n      delay(100),\r\n      retry(0),\r\n      map((response: any) => this.returnResponse(response, showLoader)),\r\n      catchError((error) => {\r\n        // if (this.blockUI.isActive) {\r\n        //   this.blockUI.stop();\r\n        // }\r\n\r\n        return of(error);\r\n      }),\r\n    );\r\n  }\r\n\r\n  private returnResponse(value: any, showLoader: boolean = true): any {\r\n    // if (showLoader && this.blockUI.isActive) {\r\n    //   this.blockUI.reset();\r\n    // }\r\n    return value;\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,96 @@
+import { HttpErrorResponse, } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, catchError, filter, switchMap, take, throwError } from 'rxjs';
+import { AuthService } from '../auth/auth.service';
+import logger from '../utils/logger.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../auth/storage.service";
+export class AuthInterceptor {
+    constructor(tokenStorage, injector) {
+        this.tokenStorage = tokenStorage;
+        this.injector = injector;
+        this.isRefreshing = false;
+        this.clearingAuth = false; // Prevent multiple clearAuth calls
+        this.refreshTokenSubject = new BehaviorSubject(null);
+    }
+    intercept(req, next) {
+        const authReq = this.getRequestWithHeaders(req);
+        return next.handle(authReq).pipe(catchError((error) => {
+            // Handle 401 Unauthorized errors
+            if (error instanceof HttpErrorResponse &&
+                error.status === 401 &&
+                !authReq.url.includes('auth/login') && // Don't retry login
+                !authReq.url.includes('auth/federated/login') && // Don't retry federated login
+                !authReq.url.includes('auth/logout') && // Don't retry logout
+                !authReq.url.includes('auth/refresh') // Don't retry refresh itself
+            ) {
+                logger.error('[AuthInterceptor] 401 Unauthorized:', {
+                    url: authReq.url,
+                    userId: this.tokenStorage.get('user_id'),
+                });
+                return this.handle401Error(authReq, next);
+            }
+            return throwError(() => error);
+        }));
+    }
+    handle401Error(request, next) {
+        // If already clearing, don't retry
+        if (this.clearingAuth) {
+            logger.log('[AuthInterceptor] Already clearing auth, rejecting request');
+            return throwError(() => new Error('Authentication cleared'));
+        }
+        if (!this.isRefreshing) {
+            this.isRefreshing = true;
+            this.refreshTokenSubject.next(null);
+            const authService = this.injector.get(AuthService);
+            return authService.refreshToken().pipe(switchMap((token) => {
+                this.isRefreshing = false;
+                this.refreshTokenSubject.next(token.access_token);
+                // Retry the original request with the new token
+                return next.handle(this.getRequestWithHeaders(request));
+            }), catchError((err) => {
+                this.isRefreshing = false;
+                // Refresh failed - logout user (only once)
+                if (!this.clearingAuth) {
+                    this.clearingAuth = true;
+                    const authService = this.injector.get(AuthService);
+                    authService.clearAuth();
+                    this.clearingAuth = false;
+                }
+                return throwError(() => err);
+            }));
+        }
+        else {
+            // Wait while getting new token
+            return this.refreshTokenSubject.pipe(filter((token) => token != null), take(1), switchMap((jwt) => {
+                // Rewrite with new token and retry
+                return next.handle(this.getRequestWithHeaders(request));
+            }));
+        }
+    }
+    getRequestWithHeaders(req) {
+        // Skip adding token for login/refresh/logout endpoints
+        if (req.url.includes('auth/login') ||
+            req.url.includes('auth/federated/login') ||
+            req.url.includes('auth/refresh') ||
+            req.url.includes('auth/logout')) {
+            return req;
+        }
+        let headers = req.headers;
+        // Get fresh token from new storage service
+        const token = this.tokenStorage.get('access_token') ?? '';
+        if (token != '') {
+            headers = headers.set('authorization', `Bearer ${token}`);
+        }
+        return req.clone({ headers });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthInterceptor, deps: [{ token: i1.StorageService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthInterceptor, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.StorageService }, { type: i0.Injector }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.interceptor.js","sourceRoot":"","sources":["../../../../../../projects/doohbot/src/lib/core/interceptors/auth.interceptor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,GAKlB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,EAAc,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AACpG,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAGnD,OAAO,MAAM,MAAM,yBAAyB,CAAC;;;AAK7C,MAAM,OAAO,eAAe;IAK1B,YACU,YAA4B,EAC5B,QAAkB;QADlB,iBAAY,GAAZ,YAAY,CAAgB;QAC5B,aAAQ,GAAR,QAAQ,CAAU;QANpB,iBAAY,GAAG,KAAK,CAAC;QACrB,iBAAY,GAAG,KAAK,CAAC,CAAC,mCAAmC;QACzD,wBAAmB,GAAyB,IAAI,eAAe,CAAM,IAAI,CAAC,CAAC;IAKhF,CAAC;IAEJ,SAAS,CAAC,GAAqB,EAAE,IAAiB;QAChD,MAAM,OAAO,GAAG,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,CAAC;QAEhD,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAC9B,UAAU,CAAC,CAAC,KAAK,EAAE,EAAE;YACnB,iCAAiC;YACjC,IACE,KAAK,YAAY,iBAAiB;gBAClC,KAAK,CAAC,MAAM,KAAK,GAAG;gBACpB,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,oBAAoB;gBAC3D,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,sBAAsB,CAAC,IAAI,8BAA8B;gBAC/E,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,aAAa,CAAC,IAAI,qBAAqB;gBAC7D,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,6BAA6B;cACnE;gBACA,MAAM,CAAC,KAAK,CAAC,qCAAqC,EAAE;oBAClD,GAAG,EAAE,OAAO,CAAC,GAAG;oBAChB,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC;iBACzC,CAAC,CAAC;gBACH,OAAO,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;aAC3C;YACD,OAAO,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAEO,cAAc,CAAC,OAAyB,EAAE,IAAiB;QACjE,mCAAmC;QACnC,IAAI,IAAI,CAAC,YAAY,EAAE;YACrB,MAAM,CAAC,GAAG,CAAC,4DAA4D,CAAC,CAAC;YACzE,OAAO,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC,CAAC;SAC9D;QAED,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YACtB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;YACzB,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAEpC,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;YACnD,OAAO,WAAW,CAAC,YAAY,EAAE,CAAC,IAAI,CACpC,SAAS,CAAC,CAAC,KAAU,EAAE,EAAE;gBACvB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;gBAC1B,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;gBAClD,gDAAgD;gBAChD,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC,CAAC;YAC1D,CAAC,CAAC,EACF,UAAU,CAAC,CAAC,GAAG,EAAE,EAAE;gBACjB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;gBAC1B,2CAA2C;gBAC3C,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;oBACtB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;oBACzB,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;oBACnD,WAAW,CAAC,SAAS,EAAE,CAAC;oBACxB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;iBAC3B;gBACD,OAAO,UAAU,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;YAC/B,CAAC,CAAC,CACH,CAAC;SACH;aAAM;YACL,+BAA+B;YAC/B,OAAO,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAClC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,IAAI,IAAI,CAAC,EAChC,IAAI,CAAC,CAAC,CAAC,EACP,SAAS,CAAC,CAAC,GAAG,EAAE,EAAE;gBAChB,mCAAmC;gBACnC,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC,CAAC;YAC1D,CAAC,CAAC,CACH,CAAC;SACH;IACH,CAAC;IAED,qBAAqB,CAAC,GAAqB;QACzC,uDAAuD;QACvD,IACE,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,YAAY,CAAC;YAC9B,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,sBAAsB,CAAC;YACxC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,cAAc,CAAC;YAChC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,aAAa,CAAC,EAC/B;YACA,OAAO,GAAG,CAAC;SACZ;QAED,IAAI,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC;QAC1B,2CAA2C;QAC3C,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC;QAE1D,IAAI,KAAK,IAAI,EAAE,EAAE;YACf,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,UAAU,KAAK,EAAE,CAAC,CAAC;SAC3D;QAED,OAAO,GAAG,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;IAChC,CAAC;+GAnGU,eAAe;mHAAf,eAAe,cAFd,MAAM;;4FAEP,eAAe;kBAH3B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import {\r\n  HttpErrorResponse,\r\n  HttpEvent,\r\n  HttpHandler,\r\n  HttpInterceptor,\r\n  HttpRequest,\r\n} from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { BehaviorSubject, catchError, filter, Observable, switchMap, take, throwError } from 'rxjs';\r\nimport { AuthService } from '../auth/auth.service';\r\nimport { StorageService } from '../auth/storage.service';\r\nimport { Injector } from '@angular/core';\r\nimport logger from '../utils/logger.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class AuthInterceptor implements HttpInterceptor {\r\n  private isRefreshing = false;\r\n  private clearingAuth = false; // Prevent multiple clearAuth calls\r\n  private refreshTokenSubject: BehaviorSubject<any> = new BehaviorSubject<any>(null);\r\n\r\n  constructor(\r\n    private tokenStorage: StorageService,\r\n    private injector: Injector,\r\n  ) {}\r\n\r\n  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\r\n    const authReq = this.getRequestWithHeaders(req);\r\n\r\n    return next.handle(authReq).pipe(\r\n      catchError((error) => {\r\n        // Handle 401 Unauthorized errors\r\n        if (\r\n          error instanceof HttpErrorResponse &&\r\n          error.status === 401 &&\r\n          !authReq.url.includes('auth/login') && // Don't retry login\r\n          !authReq.url.includes('auth/federated/login') && // Don't retry federated login\r\n          !authReq.url.includes('auth/logout') && // Don't retry logout\r\n          !authReq.url.includes('auth/refresh') // Don't retry refresh itself\r\n        ) {\r\n          logger.error('[AuthInterceptor] 401 Unauthorized:', {\r\n            url: authReq.url,\r\n            userId: this.tokenStorage.get('user_id'),\r\n          });\r\n          return this.handle401Error(authReq, next);\r\n        }\r\n        return throwError(() => error);\r\n      }),\r\n    );\r\n  }\r\n\r\n  private handle401Error(request: HttpRequest<any>, next: HttpHandler) {\r\n    // If already clearing, don't retry\r\n    if (this.clearingAuth) {\r\n      logger.log('[AuthInterceptor] Already clearing auth, rejecting request');\r\n      return throwError(() => new Error('Authentication cleared'));\r\n    }\r\n\r\n    if (!this.isRefreshing) {\r\n      this.isRefreshing = true;\r\n      this.refreshTokenSubject.next(null);\r\n\r\n      const authService = this.injector.get(AuthService);\r\n      return authService.refreshToken().pipe(\r\n        switchMap((token: any) => {\r\n          this.isRefreshing = false;\r\n          this.refreshTokenSubject.next(token.access_token);\r\n          // Retry the original request with the new token\r\n          return next.handle(this.getRequestWithHeaders(request));\r\n        }),\r\n        catchError((err) => {\r\n          this.isRefreshing = false;\r\n          // Refresh failed - logout user (only once)\r\n          if (!this.clearingAuth) {\r\n            this.clearingAuth = true;\r\n            const authService = this.injector.get(AuthService);\r\n            authService.clearAuth();\r\n            this.clearingAuth = false;\r\n          }\r\n          return throwError(() => err);\r\n        }),\r\n      );\r\n    } else {\r\n      // Wait while getting new token\r\n      return this.refreshTokenSubject.pipe(\r\n        filter((token) => token != null),\r\n        take(1),\r\n        switchMap((jwt) => {\r\n          // Rewrite with new token and retry\r\n          return next.handle(this.getRequestWithHeaders(request));\r\n        }),\r\n      );\r\n    }\r\n  }\r\n\r\n  getRequestWithHeaders(req: HttpRequest<any>): HttpRequest<any> {\r\n    // Skip adding token for login/refresh/logout endpoints\r\n    if (\r\n      req.url.includes('auth/login') ||\r\n      req.url.includes('auth/federated/login') ||\r\n      req.url.includes('auth/refresh') ||\r\n      req.url.includes('auth/logout')\r\n    ) {\r\n      return req;\r\n    }\r\n\r\n    let headers = req.headers;\r\n    // Get fresh token from new storage service\r\n    const token = this.tokenStorage.get('access_token') ?? '';\r\n\r\n    if (token != '') {\r\n      headers = headers.set('authorization', `Bearer ${token}`);\r\n    }\r\n\r\n    return req.clone({ headers });\r\n  }\r\n}\r\n"]}

package/esm2022/lib/core/interceptors/license.interceptor.mjs

@@ -0,0 +1,44 @@
+import { Injectable } from '@angular/core';
+import { AuthService } from '../auth/auth.service';
+import { LicenseService } from '../services/license.service';
+import * as i0 from "@angular/core";
+export class LicenseInterceptor {
+    constructor(injector) {
+        this.injector = injector;
+    }
+    intercept(req, next) {
+        const authService = this.injector.get(AuthService);
+        const licenseService = this.injector.get(LicenseService);
+        // Skip if this is a login/auth request (AccountService handles it explicitly)
+        if (req.url.includes('auth/login') ||
+            req.url.includes('auth/federated/login') ||
+            req.url.includes('auth/refresh') ||
+            req.url.includes('auth/logout')) {
+            return next.handle(req);
+        }
+        // Determine if this is an internal API request
+        const apiUrl = authService.apiUrl;
+        const isInternalApi = (apiUrl && req.url.startsWith(apiUrl)) ||
+            (!req.url.startsWith('http') && !req.url.startsWith('assets/'));
+        if (!isInternalApi) {
+            return next.handle(req);
+        }
+        // Resolve License Key for Authenticated Request
+        const context = authService.getLicensingContext();
+        // Post-login, context.tenantId should be company_id
+        const licenseKey = licenseService.resolveLicenseKey(context, '');
+        if (licenseKey) {
+            const clonedReq = req.clone({
+                headers: req.headers.set('x-license-key', licenseKey),
+            });
+            return next.handle(clonedReq);
+        }
+        return next.handle(req);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LicenseInterceptor, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LicenseInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LicenseInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/models/api-config.model.mjs

@@ -0,0 +1,18 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Injection token for providing Doohbot API configuration
+ */
+export const DOOHBOT_API_CONFIG = new InjectionToken('DOOHBOT_API_CONFIG', {
+    providedIn: 'root',
+    factory: () => ({
+        apiUrl: '',
+        timeout: 30000,
+        enableApi: false,
+        includeHistory: false,
+        maxHistoryMessages: 10,
+        enableRetry: true,
+        retryAttempts: 2,
+        retryDelay: 1000,
+    }),
+});
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/models/api-request.model.mjs

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

package/esm2022/lib/core/models/api-response.model.mjs

@@ -0,0 +1,8 @@
+export class ApiResponse {
+    constructor(success, message, data) {
+        this.success = success;
+        this.message = message;
+        this.data = data;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLXJlc3BvbnNlLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZG9vaGJvdC9zcmMvbGliL2NvcmUvbW9kZWxzL2FwaS1yZXNwb25zZS5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sV0FBVztJQU90QixZQUFZLE9BQWdCLEVBQUUsT0FBZSxFQUFFLElBQVE7UUFDckQsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7UUFDdkIsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7UUFDdkIsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUM7SUFDbkIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIEFwaVJlc3BvbnNlPFQ+IHtcclxuICBzdWNjZXNzITogYm9vbGVhbjtcclxuXHJcbiAgbWVzc2FnZSE6IHN0cmluZztcclxuXHJcbiAgZGF0YT86IFQ7XHJcblxyXG4gIGNvbnN0cnVjdG9yKHN1Y2Nlc3M6IGJvb2xlYW4sIG1lc3NhZ2U6IHN0cmluZywgZGF0YT86IFQpIHtcclxuICAgIHRoaXMuc3VjY2VzcyA9IHN1Y2Nlc3M7XHJcbiAgICB0aGlzLm1lc3NhZ2UgPSBtZXNzYWdlO1xyXG4gICAgdGhpcy5kYXRhID0gZGF0YTtcclxuICB9XHJcbn1cclxuIl19

package/esm2022/lib/core/models/doohbot-config.model.mjs

@@ -0,0 +1,18 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Injection token for advanced configuration
+ */
+export const DOOHBOT_ADVANCED_CONFIG = new InjectionToken('DOOHBOT_ADVANCED_CONFIG', {
+    providedIn: 'root',
+    factory: () => ({
+        authMode: 'manual',
+        tenantResolution: 'static',
+        enableMultiTenant: false,
+        persistChatPerTenant: true,
+        authHeaderName: 'Authorization',
+        authHeaderFormat: 'Bearer {token}',
+        enableRoleBasedFeatures: false,
+        debugMode: false,
+    }),
+});
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/models/license.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGljZW5zZS5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Rvb2hib3Qvc3JjL2xpYi9jb3JlL21vZGVscy9saWNlbnNlLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIExpY2Vuc2luZ0NvbnRleHQge1xyXG4gICAgdGVuYW50SWQ6IHN0cmluZzsgICAgLy8gVW5pcXVlIGNvbXBhbnkvb3JnIElEXHJcbiAgICBwcmluY2lwYWxJZDogc3RyaW5nOyAvLyBVc2VyIC8gTWVyY2hhbnQgSURcclxuICAgIHJvbGVzPzogc3RyaW5nW107ICAgIC8vIE9wdGlvbmFsIHJvbGVzL2dyb3Vwc1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIExpY2Vuc2VQYWNrYWdlIHtcclxuICAgIFtwYWNrYWdlSWQ6IHN0cmluZ106IHN0cmluZzsgLy8gcGFja2FnZUlkIC0+IGxpY2Vuc2VLZXlcclxufVxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBTdWJqZWN0TGljZW5zZSB7XHJcbiAgICBzdWJqZWN0VHlwZTogJ3VzZXInIHwgJ3JvbGUnIHwgJ3RlbmFudCc7XHJcbiAgICBzdWJqZWN0SWQ6IHN0cmluZztcclxuICAgIHBhY2thZ2VzOiBMaWNlbnNlUGFja2FnZTtcclxufVxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBMaWNlbnNlRmlsZUNvbnRlbnQge1xyXG4gICAgYWNjb3VudElkOiBzdHJpbmc7XHJcbiAgICBpc3N1ZWRCeTogc3RyaW5nO1xyXG4gICAgaXNzdWVkQXQ6IHN0cmluZztcclxuICAgIGxpY2Vuc2VzOiBTdWJqZWN0TGljZW5zZVtdO1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIExpY2Vuc2VSZWdpc3RyeSB7XHJcbiAgICBhY2NvdW50SWQ6IHN0cmluZztcclxuICAgIHN1YmplY3RMaWNlbnNlczogTWFwPHN0cmluZywgTGljZW5zZVBhY2thZ2U+O1xyXG59XHJcbiJdfQ==

package/esm2022/lib/core/models/message.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Rvb2hib3Qvc3JjL2xpYi9jb3JlL21vZGVscy9tZXNzYWdlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBNZXNzYWdlUm9sZSB9IGZyb20gJy4uL3R5cGVzL21lc3NhZ2Utcm9sZS50eXBlJztcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgTWVzc2FnZSB7XHJcbiAgaWQ6IHN0cmluZztcclxuICBzZW5kZXI6IE1lc3NhZ2VSb2xlO1xyXG4gIHNlbmRlck5hbWU/OiBzdHJpbmc7XHJcbiAgdGV4dDogc3RyaW5nOyAvLyEgdXNlZCBmb3Igbm9uLXN0cmVhbWluZ1xyXG4gIGNodW5rcz86IHN0cmluZ1tdOyAvLyEgdXNlZCBmb3Igc3RyZWFtaW5nXHJcbiAgdGltZXN0YW1wPzogRGF0ZTtcclxuICBzaG93U3VnZ2VzdGlvbnM/OiBib29sZWFuO1xyXG4gIC8vIE9wdGlvbmFsIGNvbnRleHQgZmllbGRzIGZvciBBUEkgaW50ZWdyYXRpb25cclxuICBwbGF0Zm9ybVRlbmFudD86IHN0cmluZztcclxuICBzdWJUZW5hbnQ/OiBzdHJpbmc7XHJcbiAgYWdlbnQ/OiBzdHJpbmc7XHJcbiAgY29tcGxldGVkOiBib29sZWFuIHwgdHJ1ZTtcclxuICBpc0hpc3Rvcnk6IGJvb2xlYW4gfCB0cnVlOyAvLyEgSW5kaWNhdGVkIHRoZSBtZXNzYWdlIGlzIGZyb20gaGlzdG9yeVxyXG4gIGNvcGllZD86IGJvb2xlYW47XHJcbn1cclxuIl19

package/esm2022/lib/core/models/theme-config.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhlbWUtY29uZmlnLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZG9vaGJvdC9zcmMvbGliL2NvcmUvbW9kZWxzL3RoZW1lLWNvbmZpZy5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLy8gVE9ET1xyXG5leHBvcnQgaW50ZXJmYWNlIERvb2hib3RUaGVtZUNvbmZpZyB7XHJcbiAgLy8gRm9udFxyXG4gIGZvbnRGYW1pbHk/OiBzdHJpbmc7XHJcblxyXG4gIC8vIFByaW1hcnkgJiBTZWNvbmRhcnlcclxuICBwcmltYXJ5Q29sb3I/OiBzdHJpbmc7XHJcbiAgc2Vjb25kYXJ5Q29sb3I/OiBzdHJpbmc7XHJcblxyXG4gIC8vIEJhY2tncm91bmRzXHJcbiAgYmFja2dyb3VuZENvbG9yPzogc3RyaW5nO1xyXG4gIGNoYXRJbnB1dENvbG9yPzogc3RyaW5nO1xyXG5cclxuICAvLyBUZXh0IENvbG9yc1xyXG4gIHRleHRBbHRDb2xvcj86IHN0cmluZztcclxuICB0ZXh0Q29sb3I/OiBzdHJpbmc7XHJcbiAgc2Vjb25kYXJ5VGV4dENvbG9yPzogc3RyaW5nO1xyXG4gIGhpbnRUZXh0Q29sb3I/OiBzdHJpbmc7XHJcblxyXG4gIC8vIEJ1dHRvbiBDb2xvcnNcclxuICBidXR0b25Db2xvcj86IHN0cmluZztcclxuXHJcbiAgLy8gTWVzc2FnZSBDb2xvcnNcclxuICB1c2VyTWVzc2FnZUNvbG9yPzogc3RyaW5nO1xyXG4gIGJvdE1lc3NhZ2VDb2xvcj86IHN0cmluZztcclxuXHJcbiAgLy8gTWVzc2FnZSBUZXh0IENvbG9yc1xyXG4gIHVzZXJUZXh0Q29sb3I/OiBzdHJpbmc7XHJcbiAgYm90VGV4dENvbG9yPzogc3RyaW5nO1xyXG5cclxuICAvLyBCb3JkZXJzXHJcbiAgYm9yZGVyQ29sb3I/OiBzdHJpbmc7XHJcbiAgYm9yZGVyU2hhZG93Q29sb3I/OiBzdHJpbmc7XHJcbiAgYm9yZGVyVG9wQ29sb3I/OiBzdHJpbmc7XHJcblxyXG4gIC8vIEluZGljYXRvcnNcclxuICB0eXBpbmdJbmRpY2F0b3JDb2xvcj86IHN0cmluZztcclxuXHJcbiAgLy8gVXRpbGl0eSBDb2xvcnNcclxuICB3aGl0ZT86IHN0cmluZztcclxuICBibGFjaz86IHN0cmluZztcclxuICBncmV5Pzogc3RyaW5nO1xyXG4gIHJlZD86IHN0cmluZztcclxuICB5ZWxsb3c/OiBzdHJpbmc7XHJcbiAgb3JhbmdlPzogc3RyaW5nO1xyXG4gIGdyZWVuPzogc3RyaW5nO1xyXG4gIGJsdWU/OiBzdHJpbmc7XHJcbn1cclxuIl19

package/esm2022/lib/core/services/core-config.service.mjs

@@ -0,0 +1,52 @@
+import { Injectable, signal } from '@angular/core';
+import { DoohbotInput } from '../../doohbot-input';
+import * as i0 from "@angular/core";
+export class CoreConfigService {
+    constructor() {
+        this.configSignal = signal(new DoohbotInput());
+        this.config$ = this.configSignal.asReadonly();
+    }
+    /**
+     * Updates the global library configuration
+     */
+    updateConfig(config) {
+        this.configSignal.set(config);
+    }
+    /**
+     * Dynamic getters for common config properties
+     */
+    get apiUrl() {
+        const config = this.configSignal();
+        return `${config.apiBaseUrl}${config.apiSegment}`;
+    }
+    get storageKey() {
+        return this.configSignal().storageKey || '';
+    }
+    get secretKey() {
+        return this.configSignal().secretKey || '';
+    }
+    get companyCode() {
+        return this.configSignal().companyCode || '';
+    }
+    get tenancyName() {
+        return this.configSignal().tenancyName || '';
+    }
+    get licenseKey() {
+        return this.configSignal().licenseKey || '';
+    }
+    get licenseFilePath() {
+        return this.configSignal().licenseFilePath || '';
+    }
+    get rememberMe() {
+        return this.configSignal().rememberMe !== undefined ? this.configSignal().rememberMe : false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CoreConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CoreConfigService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CoreConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29yZS1jb25maWcuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Rvb2hib3Qvc3JjL2xpYi9jb3JlL3NlcnZpY2VzL2NvcmUtY29uZmlnLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQWtCLE1BQU0sZUFBZSxDQUFDO0FBQ25FLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQzs7QUFLbkQsTUFBTSxPQUFPLGlCQUFpQjtJQUg5QjtRQUlVLGlCQUFZLEdBQWlDLE1BQU0sQ0FBQyxJQUFJLFlBQVksRUFBRSxDQUFDLENBQUM7UUFDekUsWUFBTyxHQUFHLElBQUksQ0FBQyxZQUFZLENBQUMsVUFBVSxFQUFFLENBQUM7S0E0Q2pEO0lBMUNDOztPQUVHO0lBQ0gsWUFBWSxDQUFDLE1BQW9CO1FBQy9CLElBQUksQ0FBQyxZQUFZLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ2hDLENBQUM7SUFFRDs7T0FFRztJQUNILElBQUksTUFBTTtRQUNSLE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztRQUNuQyxPQUFPLEdBQUcsTUFBTSxDQUFDLFVBQVUsR0FBRyxNQUFNLENBQUMsVUFBVSxFQUFFLENBQUM7SUFDcEQsQ0FBQztJQUVELElBQUksVUFBVTtRQUNaLE9BQU8sSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDLFVBQVUsSUFBSSxFQUFFLENBQUM7SUFDOUMsQ0FBQztJQUVELElBQUksU0FBUztRQUNYLE9BQU8sSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDLFNBQVMsSUFBSSxFQUFFLENBQUM7SUFDN0MsQ0FBQztJQUVELElBQUksV0FBVztRQUNiLE9BQU8sSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDLFdBQVcsSUFBSSxFQUFFLENBQUM7SUFDL0MsQ0FBQztJQUVELElBQUksV0FBVztRQUNiLE9BQU8sSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDLFdBQVcsSUFBSSxFQUFFLENBQUM7SUFDL0MsQ0FBQztJQUVELElBQUksVUFBVTtRQUNaLE9BQU8sSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDLFVBQVUsSUFBSSxFQUFFLENBQUM7SUFDOUMsQ0FBQztJQUVELElBQUksZUFBZTtRQUNqQixPQUFPLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQyxlQUFlLElBQUksRUFBRSxDQUFDO0lBQ25ELENBQUM7SUFFRCxJQUFJLFVBQVU7UUFDWixPQUFPLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQyxVQUFVLEtBQUssU0FBUyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUMsVUFBVyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUM7SUFDaEcsQ0FBQzsrR0E3Q1UsaUJBQWlCO21IQUFqQixpQkFBaUIsY0FGaEIsTUFBTTs7NEZBRVAsaUJBQWlCO2tCQUg3QixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUsIHNpZ25hbCwgV3JpdGFibGVTaWduYWwgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgRG9vaGJvdElucHV0IH0gZnJvbSAnLi4vLi4vZG9vaGJvdC1pbnB1dCc7XHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxyXG59KVxyXG5leHBvcnQgY2xhc3MgQ29yZUNvbmZpZ1NlcnZpY2Uge1xyXG4gIHByaXZhdGUgY29uZmlnU2lnbmFsOiBXcml0YWJsZVNpZ25hbDxEb29oYm90SW5wdXQ+ID0gc2lnbmFsKG5ldyBEb29oYm90SW5wdXQoKSk7XHJcbiAgcHVibGljIGNvbmZpZyQgPSB0aGlzLmNvbmZpZ1NpZ25hbC5hc1JlYWRvbmx5KCk7XHJcblxyXG4gIC8qKlxyXG4gICAqIFVwZGF0ZXMgdGhlIGdsb2JhbCBsaWJyYXJ5IGNvbmZpZ3VyYXRpb25cclxuICAgKi9cclxuICB1cGRhdGVDb25maWcoY29uZmlnOiBEb29oYm90SW5wdXQpOiB2b2lkIHtcclxuICAgIHRoaXMuY29uZmlnU2lnbmFsLnNldChjb25maWcpO1xyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogRHluYW1pYyBnZXR0ZXJzIGZvciBjb21tb24gY29uZmlnIHByb3BlcnRpZXNcclxuICAgKi9cclxuICBnZXQgYXBpVXJsKCk6IHN0cmluZyB7XHJcbiAgICBjb25zdCBjb25maWcgPSB0aGlzLmNvbmZpZ1NpZ25hbCgpO1xyXG4gICAgcmV0dXJuIGAke2NvbmZpZy5hcGlCYXNlVXJsfSR7Y29uZmlnLmFwaVNlZ21lbnR9YDtcclxuICB9XHJcblxyXG4gIGdldCBzdG9yYWdlS2V5KCk6IHN0cmluZyB7XHJcbiAgICByZXR1cm4gdGhpcy5jb25maWdTaWduYWwoKS5zdG9yYWdlS2V5IHx8ICcnO1xyXG4gIH1cclxuXHJcbiAgZ2V0IHNlY3JldEtleSgpOiBzdHJpbmcge1xyXG4gICAgcmV0dXJuIHRoaXMuY29uZmlnU2lnbmFsKCkuc2VjcmV0S2V5IHx8ICcnO1xyXG4gIH1cclxuXHJcbiAgZ2V0IGNvbXBhbnlDb2RlKCk6IHN0cmluZyB7XHJcbiAgICByZXR1cm4gdGhpcy5jb25maWdTaWduYWwoKS5jb21wYW55Q29kZSB8fCAnJztcclxuICB9XHJcblxyXG4gIGdldCB0ZW5hbmN5TmFtZSgpOiBzdHJpbmcge1xyXG4gICAgcmV0dXJuIHRoaXMuY29uZmlnU2lnbmFsKCkudGVuYW5jeU5hbWUgfHwgJyc7XHJcbiAgfVxyXG5cclxuICBnZXQgbGljZW5zZUtleSgpOiBzdHJpbmcge1xyXG4gICAgcmV0dXJuIHRoaXMuY29uZmlnU2lnbmFsKCkubGljZW5zZUtleSB8fCAnJztcclxuICB9XHJcblxyXG4gIGdldCBsaWNlbnNlRmlsZVBhdGgoKTogc3RyaW5nIHtcclxuICAgIHJldHVybiB0aGlzLmNvbmZpZ1NpZ25hbCgpLmxpY2Vuc2VGaWxlUGF0aCB8fCAnJztcclxuICB9XHJcblxyXG4gIGdldCByZW1lbWJlck1lKCk6IGJvb2xlYW4ge1xyXG4gICAgcmV0dXJuIHRoaXMuY29uZmlnU2lnbmFsKCkucmVtZW1iZXJNZSAhPT0gdW5kZWZpbmVkID8gdGhpcy5jb25maWdTaWduYWwoKS5yZW1lbWJlck1lISA6IGZhbHNlO1xyXG4gIH1cclxufVxyXG4iXX0=

package/esm2022/lib/core/services/license.service.mjs

@@ -0,0 +1,145 @@
+import { inject, Injectable, signal } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { firstValueFrom } from 'rxjs';
+import logger from '../utils/logger.service';
+import { CoreConfigService } from './core-config.service';
+import * as i0 from "@angular/core";
+export class LicenseService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.coreConfig = inject(CoreConfigService);
+        this.registry = signal(null);
+    }
+    /**
+     * Load the license configuration from a JSON file.
+     * Supports both Hierarchical (entitlements) and Flat-map (package:key) formats.
+     * @param filePath Path to the license JSON file
+     */
+    async loadLicenseFile(filePath) {
+        try {
+            const finalPath = filePath || this.coreConfig.licenseFilePath;
+            const data = await firstValueFrom(this.http.get(finalPath));
+            if (!data) {
+                throw new Error('Empty license file');
+            }
+            // Detection: Hierarchical Format (subjectId/licenses array)
+            if (data.licenses && Array.isArray(data.licenses)) {
+                this.processHierarchicalLicense(data);
+            }
+            // Detection: Flat Map Format (packageId: key)
+            else {
+                this.processFlatMapLicense(data);
+            }
+        }
+        catch (error) {
+            // Industry pattern: Silent loading for optional registry files
+            logger.log('[LicenseService] No external license file found or failed to load. Falling back to AppConst.');
+            this.registry.set(null);
+        }
+    }
+    processHierarchicalLicense(data) {
+        const subjectMap = new Map();
+        data.licenses.forEach((license) => {
+            const key = `${license.subjectType}:${license.subjectId}`;
+            subjectMap.set(key, license.packages);
+        });
+        this.registry.set({
+            accountId: data.accountId,
+            subjectLicenses: subjectMap,
+        });
+        logger.log(`[LicenseService] Hierarchical Registry loaded for account: ${data.accountId}`);
+    }
+    processFlatMapLicense(data) {
+        // Flat-map format: { "tenantName": "license_key" }
+        // Convert each entry to: tenant:tenantName -> { doohbot: license_key }
+        const subjectMap = new Map();
+        Object.entries(data).forEach(([tenantName, licenseKey]) => {
+            const tenantKey = `tenant:${tenantName}`;
+            subjectMap.set(tenantKey, {
+                doohbot: licenseKey,
+            });
+        });
+        this.registry.set({
+            accountId: 'FLAT_MAP_REGISTRY',
+            subjectLicenses: subjectMap,
+        });
+        logger.log(`[LicenseService] Flat-map registry loaded with ${subjectMap.size} tenant(s)`);
+    }
+    /**
+     * Resolve the correct license key based on context and requested package
+     * @param context The current licensing context (tenant, user, roles)
+     * @param packageId The ID of the package requesting a license
+     * @returns The resolved license key, or null if unauthorized
+     */
+    resolveLicenseKey(context, packageId) {
+        //   Hierarchical Registry (Most Specific)
+        const keyFromRegistry = this.resolveFromRegistry(context, packageId);
+        if (keyFromRegistry)
+            return keyFromRegistry;
+        logger.warn(`[LicenseService] No license found for package: ${packageId} and user: ${context.principalId}`);
+        return null;
+    }
+    resolveFromRegistry(context, packageId) {
+        const reg = this.registry();
+        if (!reg)
+            return null;
+        // Strict Account Check
+        if (reg.accountId !== 'EXTERNAL_OVERRIDE' && reg.accountId !== context.tenantId) {
+            logger.error(`[LicenseService] Account mismatch! Registry: ${reg.accountId}, Context: ${context.tenantId}`);
+            return null;
+        }
+        const subjectsToSearch = [
+            `user:${context.principalId}`,
+            ...(context.roles?.map((r) => `role:${r}`) || []),
+            `tenant:${context.tenantId}`,
+            'tenant:default', // Fallback for flat-map external files
+        ];
+        for (const subjectKey of subjectsToSearch) {
+            const packages = reg.subjectLicenses.get(subjectKey);
+            if (packages && packages[packageId]) {
+                logger.debug(`[LicenseService] Resolved key for ${packageId} via Registry (${subjectKey})`);
+                return packages[packageId];
+            }
+        }
+        return null;
+    }
+    /**
+     * Resolves the license key for the current tenant.
+     */
+    resolveTenantLicenseKey(tenancyName) {
+        const activeTenancy = tenancyName || this.coreConfig.tenancyName;
+        if (!activeTenancy) {
+            logger.warn('[LicenseService] No tenancy name found.');
+            return null;
+        }
+        const reg = this.registry();
+        if (!reg) {
+            logger.error('[LicenseService] License registry not loaded.');
+            return null;
+        }
+        const tenantLicenses = reg.subjectLicenses.get(`tenant:${activeTenancy}`);
+        const licenseKey = tenantLicenses?.['doohbot'] || null;
+        if (licenseKey) {
+            logger.info(`[LicenseService] Resolved Doohbot license for: ${activeTenancy}`);
+        }
+        else {
+            logger.warn(`[LicenseService] No license key found for tenant: ${activeTenancy}`);
+        }
+        return licenseKey;
+    }
+    /**
+     * Check if a registry is currently loaded
+     */
+    isRegistryLoaded() {
+        return this.registry() !== null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LicenseService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LicenseService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LicenseService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"license.service.js","sourceRoot":"","sources":["../../../../../../projects/doohbot/src/lib/core/services/license.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable, signal } from '@angular/core';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { firstValueFrom } from 'rxjs';\r\nimport {\r\n  LicenseFileContent,\r\n  LicenseRegistry,\r\n  LicensingContext,\r\n  LicensePackage,\r\n} from '../models/license.model';\r\nimport logger from '../utils/logger.service';\r\nimport { CoreConfigService } from './core-config.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class LicenseService {\r\n  private http = inject(HttpClient);\r\n  private coreConfig = inject(CoreConfigService);\r\n  private registry = signal<LicenseRegistry | null>(null);\r\n\r\n  /**\r\n   * Load the license configuration from a JSON file.\r\n   * Supports both Hierarchical (entitlements) and Flat-map (package:key) formats.\r\n   * @param filePath Path to the license JSON file\r\n   */\r\n  async loadLicenseFile(filePath?: string): Promise<void> {\r\n    try {\r\n      const finalPath = filePath || this.coreConfig.licenseFilePath;\r\n\r\n      const data = await firstValueFrom(this.http.get<any>(finalPath));\r\n\r\n      if (!data) {\r\n        throw new Error('Empty license file');\r\n      }\r\n\r\n      // Detection: Hierarchical Format (subjectId/licenses array)\r\n      if (data.licenses && Array.isArray(data.licenses)) {\r\n        this.processHierarchicalLicense(data);\r\n      }\r\n      // Detection: Flat Map Format (packageId: key)\r\n      else {\r\n        this.processFlatMapLicense(data);\r\n      }\r\n    } catch (error) {\r\n      // Industry pattern: Silent loading for optional registry files\r\n      logger.log(\r\n        '[LicenseService] No external license file found or failed to load. Falling back to AppConst.',\r\n      );\r\n      this.registry.set(null);\r\n    }\r\n  }\r\n\r\n  private processHierarchicalLicense(data: LicenseFileContent): void {\r\n    const subjectMap = new Map<string, LicensePackage>();\r\n\r\n    data.licenses.forEach((license) => {\r\n      const key = `${license.subjectType}:${license.subjectId}`;\r\n      subjectMap.set(key, license.packages);\r\n    });\r\n\r\n    this.registry.set({\r\n      accountId: data.accountId,\r\n      subjectLicenses: subjectMap,\r\n    });\r\n\r\n    logger.log(`[LicenseService] Hierarchical Registry loaded for account: ${data.accountId}`);\r\n  }\r\n\r\n  private processFlatMapLicense(data: Record<string, string>): void {\r\n    // Flat-map format: { \"tenantName\": \"license_key\" }\r\n    // Convert each entry to: tenant:tenantName -> { doohbot: license_key }\r\n\r\n    const subjectMap = new Map<string, LicensePackage>();\r\n\r\n    Object.entries(data).forEach(([tenantName, licenseKey]) => {\r\n      const tenantKey = `tenant:${tenantName}`;\r\n      subjectMap.set(tenantKey, {\r\n        doohbot: licenseKey,\r\n      });\r\n    });\r\n\r\n    this.registry.set({\r\n      accountId: 'FLAT_MAP_REGISTRY',\r\n      subjectLicenses: subjectMap,\r\n    });\r\n\r\n    logger.log(`[LicenseService] Flat-map registry loaded with ${subjectMap.size} tenant(s)`);\r\n  }\r\n\r\n  /**\r\n   * Resolve the correct license key based on context and requested package\r\n   * @param context The current licensing context (tenant, user, roles)\r\n   * @param packageId The ID of the package requesting a license\r\n   * @returns The resolved license key, or null if unauthorized\r\n   */\r\n  resolveLicenseKey(context: LicensingContext, packageId: string): string | null {\r\n    //   Hierarchical Registry (Most Specific)\r\n    const keyFromRegistry = this.resolveFromRegistry(context, packageId);\r\n    if (keyFromRegistry) return keyFromRegistry;\r\n\r\n    logger.warn(\r\n      `[LicenseService] No license found for package: ${packageId} and user: ${context.principalId}`,\r\n    );\r\n    return null;\r\n  }\r\n\r\n  private resolveFromRegistry(context: LicensingContext, packageId: string): string | null {\r\n    const reg = this.registry();\r\n    if (!reg) return null;\r\n\r\n    // Strict Account Check\r\n    if (reg.accountId !== 'EXTERNAL_OVERRIDE' && reg.accountId !== context.tenantId) {\r\n      logger.error(\r\n        `[LicenseService] Account mismatch! Registry: ${reg.accountId}, Context: ${context.tenantId}`,\r\n      );\r\n      return null;\r\n    }\r\n\r\n    const subjectsToSearch = [\r\n      `user:${context.principalId}`,\r\n      ...(context.roles?.map((r) => `role:${r}`) || []),\r\n      `tenant:${context.tenantId}`,\r\n      'tenant:default', // Fallback for flat-map external files\r\n    ];\r\n\r\n    for (const subjectKey of subjectsToSearch) {\r\n      const packages = reg.subjectLicenses.get(subjectKey);\r\n      if (packages && packages[packageId]) {\r\n        logger.debug(`[LicenseService] Resolved key for ${packageId} via Registry (${subjectKey})`);\r\n        return packages[packageId];\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Resolves the license key for the current tenant.\r\n   */\r\n  resolveTenantLicenseKey(tenancyName?: string): string | null {\r\n    const activeTenancy = tenancyName || this.coreConfig.tenancyName;\r\n\r\n    if (!activeTenancy) {\r\n      logger.warn('[LicenseService] No tenancy name found.');\r\n      return null;\r\n    }\r\n\r\n    const reg = this.registry();\r\n    if (!reg) {\r\n      logger.error('[LicenseService] License registry not loaded.');\r\n      return null;\r\n    }\r\n\r\n    const tenantLicenses = reg.subjectLicenses.get(`tenant:${activeTenancy}`);\r\n    const licenseKey = tenantLicenses?.['doohbot'] || null;\r\n\r\n    if (licenseKey) {\r\n      logger.info(`[LicenseService] Resolved Doohbot license for: ${activeTenancy}`);\r\n    } else {\r\n      logger.warn(`[LicenseService] No license key found for tenant: ${activeTenancy}`);\r\n    }\r\n\r\n    return licenseKey;\r\n  }\r\n\r\n  /**\r\n   * Check if a registry is currently loaded\r\n   */\r\n  isRegistryLoaded(): boolean {\r\n    return this.registry() !== null;\r\n  }\r\n}\r\n"]}