@aakash58/chatbot 1.1.19 → 1.1.21

package/projects/doohbot/src/lib/core/models/doohbot-config.model.ts

@@ -0,0 +1,109 @@
+import { InjectionToken } from '@angular/core';
+import { AuthMode } from '../types/auth-mode.type';
+import { TenantResolutionStrategy } from '../types/tenant-resolution-strategy.type';
+import { PromptMode } from '../types/prompt-mode.type';
+
+/**
+ * Advanced configuration for DoohBot package
+ * Supports both simple and complex use cases
+ */
+export interface DoohbotAdvancedConfig {
+  /**
+   * Authentication mode
+   * - 'manual': You provide platformTenant, subTenant, agent manually
+   * - 'auto': Package reads from your auth service via resolver
+   * @default 'manual'
+   */
+  authMode?: AuthMode;
+
+  /**
+   * Tenant resolution strategy
+   * - 'static': Use fixed values provided via inputs
+   * - 'dynamic': Automatically update when auth state changes
+   * - 'callback': Use custom resolver function
+   * @default 'static'
+   */
+  tenantResolution?: TenantResolutionStrategy;
+
+  /**
+   * Auto-configure from localStorage key
+   * If provided, package will read auth data from localStorage
+   * Example: 'auth_user' or 'saas_session'
+   */
+  autoConfigFromStorage?: string;
+
+  /**
+   * Enable multi-tenant mode
+   * Allows switching between different tenant contexts
+   * @default false
+   */
+  enableMultiTenant?: boolean;
+
+  /**
+   * Persist chat history per tenant
+   * @default true
+   */
+  persistChatPerTenant?: boolean;
+
+  /**
+   * Custom authentication header name
+   * @default 'Authorization'
+   */
+  authHeaderName?: string;
+
+  /**
+   * Custom authentication header format
+   * Use {token} as placeholder
+   * @default 'Bearer {token}'
+   */
+  authHeaderFormat?: string;
+
+  /**
+   * Enable role-based features
+   * Shows/hides features based on user permissions
+   * @default false
+   */
+  enableRoleBasedFeatures?: boolean;
+
+  /**
+   * User permissions (for role-based features)
+   */
+  userPermissions?: string[];
+
+  /**
+   * Callback when authentication fails
+   */
+  onAuthFailure?: (error: any) => void;
+
+  /**
+   * Enable debug mode (logs configuration and requests)
+   * @default false
+   */
+  debugMode?: boolean;
+
+  /**
+   * Prompt mode for chat responses
+   * @default 'markdown'
+   */
+  promptMode?: PromptMode;
+}
+
+/**
+ * Injection token for advanced configuration
+ */
+export const DOOHBOT_ADVANCED_CONFIG = new InjectionToken<DoohbotAdvancedConfig>(
+  'DOOHBOT_ADVANCED_CONFIG',
+  {
+    providedIn: 'root',
+    factory: () => ({
+      authMode: 'manual',
+      tenantResolution: 'static',
+      enableMultiTenant: false,
+      persistChatPerTenant: true,
+      authHeaderName: 'Authorization',
+      authHeaderFormat: 'Bearer {token}',
+      enableRoleBasedFeatures: false,
+      debugMode: false,
+    }),
+  },
+);

package/{lib/core/models/license.model.d.ts → projects/doohbot/src/lib/core/models/license.model.ts}

@@ -1,23 +1,27 @@
-export interface LicensingContext {
-    tenantId: string;
-    principalId: string;
-    roles?: string[];
-}
-export interface LicensePackage {
-    [packageId: string]: string;
-}
-export interface SubjectLicense {
-    subjectType: 'user' | 'role' | 'tenant';
-    subjectId: string;
-    packages: LicensePackage;
-}
-export interface LicenseFileContent {
-    accountId: string;
-    issuedBy: string;
-    issuedAt: string;
-    licenses: SubjectLicense[];
-}
-export interface LicenseRegistry {
-    accountId: string;
-    subjectLicenses: Map<string, LicensePackage>;
-}
+export interface LicensingContext {
+    tenantId: string;    // Unique company/org ID
+    principalId: string; // User / Merchant ID
+    roles?: string[];    // Optional roles/groups
+}
+
+export interface LicensePackage {
+    [packageId: string]: string; // packageId -> licenseKey
+}
+
+export interface SubjectLicense {
+    subjectType: 'user' | 'role' | 'tenant';
+    subjectId: string;
+    packages: LicensePackage;
+}
+
+export interface LicenseFileContent {
+    accountId: string;
+    issuedBy: string;
+    issuedAt: string;
+    licenses: SubjectLicense[];
+}
+
+export interface LicenseRegistry {
+    accountId: string;
+    subjectLicenses: Map<string, LicensePackage>;
+}

package/projects/doohbot/src/lib/core/models/message.ts

@@ -0,0 +1,18 @@
+import { MessageRole } from '../types/message-role.type';
+
+export interface Message {
+  id: string;
+  sender: MessageRole;
+  senderName?: string;
+  text: string; //! used for non-streaming
+  chunks?: string[]; //! used for streaming
+  timestamp?: Date;
+  showSuggestions?: boolean;
+  // Optional context fields for API integration
+  platformTenant?: string;
+  subTenant?: string;
+  agent?: string;
+  completed: boolean | true;
+  isHistory: boolean | true; //! Indicated the message is from history
+  copied?: boolean;
+}

package/projects/doohbot/src/lib/core/models/theme-config.model.ts

@@ -0,0 +1,48 @@
+// TODO
+export interface DoohbotThemeConfig {
+  // Font
+  fontFamily?: string;
+
+  // Primary & Secondary
+  primaryColor?: string;
+  secondaryColor?: string;
+
+  // Backgrounds
+  backgroundColor?: string;
+  chatInputColor?: string;
+
+  // Text Colors
+  textAltColor?: string;
+  textColor?: string;
+  secondaryTextColor?: string;
+  hintTextColor?: string;
+
+  // Button Colors
+  buttonColor?: string;
+
+  // Message Colors
+  userMessageColor?: string;
+  botMessageColor?: string;
+
+  // Message Text Colors
+  userTextColor?: string;
+  botTextColor?: string;
+
+  // Borders
+  borderColor?: string;
+  borderShadowColor?: string;
+  borderTopColor?: string;
+
+  // Indicators
+  typingIndicatorColor?: string;
+
+  // Utility Colors
+  white?: string;
+  black?: string;
+  grey?: string;
+  red?: string;
+  yellow?: string;
+  orange?: string;
+  green?: string;
+  blue?: string;
+}

package/projects/doohbot/src/lib/core/services/core-config.service.ts

@@ -0,0 +1,53 @@
+import { Injectable, signal, WritableSignal } from '@angular/core';
+import { DoohbotInput } from '../../doohbot-input';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class CoreConfigService {
+  private configSignal: WritableSignal<DoohbotInput> = signal(new DoohbotInput());
+  public config$ = this.configSignal.asReadonly();
+
+  /**
+   * Updates the global library configuration
+   */
+  updateConfig(config: DoohbotInput): void {
+    this.configSignal.set(config);
+  }
+
+  /**
+   * Dynamic getters for common config properties
+   */
+  get apiUrl(): string {
+    const config = this.configSignal();
+    return `${config.apiBaseUrl}${config.apiSegment}`;
+  }
+
+  get storageKey(): string {
+    return this.configSignal().storageKey || '';
+  }
+
+  get secretKey(): string {
+    return this.configSignal().secretKey || '';
+  }
+
+  get companyCode(): string {
+    return this.configSignal().companyCode || '';
+  }
+
+  get tenancyName(): string {
+    return this.configSignal().tenancyName || '';
+  }
+
+  get licenseKey(): string {
+    return this.configSignal().licenseKey || '';
+  }
+
+  get licenseFilePath(): string {
+    return this.configSignal().licenseFilePath || '';
+  }
+
+  get rememberMe(): boolean {
+    return this.configSignal().rememberMe !== undefined ? this.configSignal().rememberMe! : false;
+  }
+}

package/projects/doohbot/src/lib/core/services/doohbot-api.service.ts

@@ -0,0 +1,207 @@
+import { Injectable, inject } from '@angular/core';
+import { HttpClient, HttpHeaders, HttpErrorResponse } from '@angular/common/http';
+import { Observable, throwError, timer } from 'rxjs';
+import { catchError, retry, timeout, map } from 'rxjs/operators';
+import { DOOHBOT_API_CONFIG, DoohbotApiConfig } from '../models/api-config.model';
+import { ChatApiRequest, ChatApiResponse, ChatApiError } from '../models/api-request.model';
+import { Message } from '../models/message';
+import { ErrorHandlerUtil } from '../utils/error-handler.util';
+import logger from '../utils/logger.service';
+import { SnackbarUtils } from '../../shared/snackbar/snackbar.utils';
+import { StorageService } from './../auth/storage.service';
+import { LicenseService } from './license.service';
+import { AuthService } from '../auth/auth.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class ChatbotApiService {
+  private http = inject(HttpClient);
+  private config = inject(DOOHBOT_API_CONFIG);
+  private tokenStorage = inject(StorageService);
+  private licenseService = inject(LicenseService);
+  private authService = inject(AuthService);
+
+  /**
+   * Send a chat message to the API
+   * @param message User's message text
+   * @param history Optional message history for context
+   * @returns Observable of the API response
+   */
+  sendMessage(message: string, history?: Message[]): Observable<ChatApiResponse> {
+    if (!this.config.apiUrl) {
+      return throwError(
+        () =>
+          ({
+            message: 'API URL not configured',
+            code: 'CONFIG_ERROR',
+          }) as ChatApiError,
+      );
+    }
+
+    // Build request payload with tenant context
+    const request = this.buildRequest(message, history);
+
+    // Build headers
+    const headers = this.buildHeaders();
+
+    // Configure timeout
+    const timeoutMs = this.config.timeout || 30000;
+
+    // Make HTTP request
+    return this.http.post<ChatApiResponse>(this.config.apiUrl, request, { headers }).pipe(
+      timeout(timeoutMs),
+      this.applyRetryStrategy(),
+      map((response) => this.validateResponse(response)),
+      catchError((error) => this.handleError(error)),
+    );
+  }
+
+  /**
+   * Build request payload with current tenant context
+   */
+  private buildRequest(message: string, history?: Message[]): ChatApiRequest {
+    const request: ChatApiRequest = {
+      message,
+      timestamp: new Date().toISOString(),
+    };
+
+    // Include history if enabled and provided
+    if (this.config.includeHistory && history && history.length > 0) {
+      const maxMessages = this.config.maxHistoryMessages || 10;
+      request.history = history.slice(-maxMessages);
+    }
+
+    return request;
+  }
+
+  /**
+   * Build HTTP headers
+   */
+  private buildHeaders(): HttpHeaders {
+    let headers = new HttpHeaders({
+      'Content-Type': 'application/json',
+    });
+
+    // Add API key if provided
+    if (this.config.apiKey) {
+      headers = headers.set('Authorization', `Bearer ${this.config.apiKey}`);
+    }
+
+    // Headers (License and Auth) are now handled globally by AuthInterceptor
+    // Add custom headers if provided if any specific to this service
+    if (this.config.customHeaders) {
+      Object.entries(this.config.customHeaders).forEach(([key, value]) => {
+        headers = headers.set(key, value);
+      });
+    }
+
+    return headers;
+  }
+
+  /**
+   * Apply retry strategy based on configuration
+   */
+  private applyRetryStrategy() {
+    return (source: Observable<ChatApiResponse>) => {
+      if (!this.config.enableRetry) {
+        return source;
+      }
+
+      const retryAttempts = this.config.retryAttempts || 2;
+      const retryDelay = this.config.retryDelay || 1000;
+
+      return source.pipe(
+        retry({
+          count: retryAttempts,
+          delay: (error, retryCount) => {
+            // Only retry on network errors or 5xx server errors
+            if (this.shouldRetry(error)) {
+              logger.warn(`Retrying API request (attempt: ${retryCount}/${retryAttempts})...`);
+              return timer(retryDelay * retryCount);
+            }
+            // Don't retry on client errors (4xx)
+            return throwError(() => error);
+          },
+        }),
+      );
+    };
+  }
+
+  /**
+   * Determine if error should trigger a retry
+   */
+  private shouldRetry(error: any): boolean {
+    if (error instanceof HttpErrorResponse) {
+      // Retry on network errors or 5xx server errors
+      return error.status === 0 || error.status >= 500;
+    }
+    // Retry on timeout errors
+    if (error.name === 'TimeoutError') {
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Validate API response
+   */
+  private validateResponse(response: ChatApiResponse): ChatApiResponse {
+    if (!response || !response.reply) {
+      throw {
+        message: 'Invalid API response: missing reply field',
+        code: 'INVALID_RESPONSE',
+      } as ChatApiError;
+    }
+    return response;
+  }
+
+  /**
+   * Handle API errors
+   */
+  private handleError(error: any): Observable<never> {
+    let apiError: ChatApiError;
+
+    if (error instanceof HttpErrorResponse) {
+      // HTTP error
+      apiError = {
+        message: ErrorHandlerUtil.handleError(error),
+        code: error.error?.code || 'HTTP_ERROR',
+        statusCode: error.status,
+        details: error.error,
+      };
+    } else if (error.name === 'TimeoutError') {
+      // Timeout error
+      apiError = {
+        message: 'Request timeout - please try again',
+        code: 'TIMEOUT',
+        statusCode: 408,
+      };
+    } else {
+      // Other errors
+      apiError = {
+        message: error.message || 'Unknown error occurred',
+        code: error.code || 'UNKNOWN_ERROR',
+        details: error,
+      };
+    }
+
+    logger.error('Chatbot API Error:', apiError);
+    SnackbarUtils.error(apiError.message);
+    return throwError(() => apiError);
+  }
+
+  /**
+   * Check if API is enabled
+   */
+  isApiEnabled(): boolean {
+    return this.config.enableApi === true && !!this.config.apiUrl;
+  }
+
+  /**
+   * Get current API configuration
+   */
+  getConfig(): DoohbotApiConfig {
+    return { ...this.config };
+  }
+}

package/projects/doohbot/src/lib/core/services/license.service.ts

@@ -0,0 +1,171 @@
+import { inject, Injectable, signal } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { firstValueFrom } from 'rxjs';
+import {
+  LicenseFileContent,
+  LicenseRegistry,
+  LicensingContext,
+  LicensePackage,
+} from '../models/license.model';
+import logger from '../utils/logger.service';
+import { CoreConfigService } from './core-config.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class LicenseService {
+  private http = inject(HttpClient);
+  private coreConfig = inject(CoreConfigService);
+  private registry = signal<LicenseRegistry | null>(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?: string): Promise<void> {
+    try {
+      const finalPath = filePath || this.coreConfig.licenseFilePath;
+
+      const data = await firstValueFrom(this.http.get<any>(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);
+    }
+  }
+
+  private processHierarchicalLicense(data: LicenseFileContent): void {
+    const subjectMap = new Map<string, LicensePackage>();
+
+    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}`);
+  }
+
+  private processFlatMapLicense(data: Record<string, string>): void {
+    // Flat-map format: { "tenantName": "license_key" }
+    // Convert each entry to: tenant:tenantName -> { doohbot: license_key }
+
+    const subjectMap = new Map<string, LicensePackage>();
+
+    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: LicensingContext, packageId: string): string | null {
+    //   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;
+  }
+
+  private resolveFromRegistry(context: LicensingContext, packageId: string): string | null {
+    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?: string): string | null {
+    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(): boolean {
+    return this.registry() !== null;
+  }
+}