@aakash58/chatbot 1.1.21 → 1.1.24

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

@@ -1,109 +0,0 @@
-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/projects/doohbot/src/lib/core/models/message.ts

@@ -1,18 +0,0 @@
-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

@@ -1,48 +0,0 @@
-// 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

@@ -1,53 +0,0 @@
-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

@@ -1,207 +0,0 @@
-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

@@ -1,171 +0,0 @@
-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;
-  }
-}

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

@@ -1,73 +0,0 @@
-import { Injectable } from '@angular/core';
-
-@Injectable({
-  providedIn: 'root',
-})
-export class MarkdownService {
-  constructor() {}
-
-  convert(markdown: string): string {
-    if (!markdown) return '';
-
-    // 1. Escape HTML first to prevent XSS
-    let html = this.escapeHtml(markdown);
-
-    // 2. Process Heads (h1-h3)
-    // # Header -> <h1>Header</h1>
-    html = html.replace(/^### (.*$)/gim, '<h3>$1</h3>');
-    html = html.replace(/^## (.*$)/gim, '<h2>$1</h2>');
-    html = html.replace(/^# (.*$)/gim, '<h1>$1</h1>');
-
-    // 3. Bold (** or __)
-    html = html.replace(/\*\*(.*?)\*\*/gim, '<strong>$1</strong>');
-    html = html.replace(/__(.*?)__/gim, '<strong>$1</strong>');
-
-    // 4. Italic (* or _)
-    html = html.replace(/\*(.*?)\*/gim, '<em>$1</em>');
-    html = html.replace(/_(.*?)_/gim, '<em>$1</em>');
-
-    // 5. Lists (unordered)
-    // Note: This is a simple regex that wraps each list item in <li>.
-    // Full list wrapping <ul> needs state awareness, but for simple chat line-by-line:
-    html = html.replace(/^\s*-\s+(.*$)/gim, '<li>$1</li>');
-    html = html.replace(/^\s*\*\s+(.*$)/gim, '<li>$1</li>');
-
-    // 6. Lists (ordered)
-    html = html.replace(/^\s*\d+\.\s+(.*$)/gim, '<li>$1</li>');
-
-    // 7. Paragraphs
-    // Split by double newline to form paragraphs, but avoid wrapping existing tags
-    // This is a naive implementation; for robust parsing, we'd need a token,
-    // but for simple chat, we can just replace \n with <br> inside paragraphs.
-
-    // Simple line break handling
-    html = html.replace(/\n/gim, '<br>');
-
-    // Optional: Wrap loose text in paragraphs if completely robust is needed,
-    // but <br> is usually sufficient for chat bubbles.
-
-    // Wrap adjacent <li>s in <ul> or <ol> is tricky with pure regex on the whole string.
-    // Improvement: We can wrap the whole block.
-
-    // Basic List Wrapping (very simple heuristic)
-    // Replace sequences of <li>...</li> with <ul>...</ul> is hard without multiple passes.
-    // For now, we will style straight <li>s if they appear, or just accept that they might lack a parent <ul>
-    // which browsers often handle okay visually, OR we try to group them.
-
-    // Let's try to group <li>s
-    html = html.replace(/(<li>.*<\/li>(\s*<br>\s*)*)+/gim, '<ul>$&</ul>');
-
-    // Clean up <br> inside <ul>
-    html = html.replace(/<\/li>\s*<br>\s*<li>/gim, '</li><li>');
-    html = html.replace(/<ul>\s*<br>/gim, '<ul>');
-    html = html.replace(/<br>\s*<\/ul>/gim, '</ul>');
-
-    return html;
-  }
-
-  private escapeHtml(text: string): string {
-    const div = document.createElement('div');
-    div.textContent = text;
-    return div.innerHTML;
-  }
-}