@opensourcekd/ng-common-libs 2.0.5 → 2.0.7

package/dist/index.d.ts

@@ -8,6 +8,12 @@ interface EventPayload<T = unknown> {
     data: T;
     timestamp?: number;
 }
+/**
+ * EventBus options interface
+ */
+interface EventBusOptions {
+    id?: string;
+}
 /**
  * EventBus - A centralized event bus for application-wide communication
  * Framework-agnostic implementation using only RxJS
@@ -17,6 +23,9 @@ interface EventPayload<T = unknown> {
  * // Create an instance
  * const eventBus = new EventBus();
  *
+ * // Create an instance with an identifier
+ * const eventBus = new EventBus({ id: 'MFE' });
+ *
  * // Emit an event
  * eventBus.emit('user:login', { userId: '123', username: 'john' });
  *
@@ -24,10 +33,24 @@ interface EventPayload<T = unknown> {
  * eventBus.on('user:login').subscribe(data => {
  *   console.log('User logged in:', data);
  * });
+ *
+ * // Get the identifier
+ * const id = eventBus.getId(); // 'MFE' or undefined
  * ```
  */
 declare class EventBus {
     private eventSubject;
+    private id?;
+    /**
+     * Create a new EventBus instance
+     * @param options - Optional configuration with an id to identify the instance
+     */
+    constructor(options?: EventBusOptions);
+    /**
+     * Get the identifier of this EventBus instance
+     * @returns The id if provided during initialization, undefined otherwise
+     */
+    getId(): string | undefined;
     /**
      * Emit an event with optional data
      * @param eventType - The type/name of the event
@@ -243,6 +266,12 @@ interface Auth0Config {
     scope: string;
     connection?: string;
 }
+/**
+ * AuthService options interface
+ */
+interface AuthServiceOptions {
+    id?: string;
+}
 /**
  * Storage configuration
  */
@@ -280,10 +309,16 @@ interface StorageKeys {
  * };
  * const authService = new AuthService(authConfig, eventBus);
  *
+ * // Or create with an identifier
+ * const authService = new AuthService(authConfig, eventBus, undefined, undefined, { id: 'MFE' });
+ *
  * // Use the service
  * await authService.login();
  * const user = authService.getUser();
  * const token = await authService.getToken();
+ *
+ * // Get the identifier
+ * const id = authService.getId(); // 'MFE' or undefined
  * ```
  */
 declare class AuthService {
@@ -296,14 +331,21 @@ declare class AuthService {
     private storageConfig;
     private storageKeys;
     private eventBus;
+    private id?;
     /**
      * Create a new AuthService instance
      * @param config - Auth0 configuration
      * @param eventBus - EventBus instance for emitting auth events
      * @param storageConfig - Storage configuration (optional, defaults to sessionStorage)
      * @param storageKeys - Storage keys (optional, defaults to standard keys)
+     * @param options - Optional configuration with an id to identify the instance
      */
-    constructor(config: Auth0Config, eventBus: EventBus, storageConfig?: StorageConfig, storageKeys?: StorageKeys);
+    constructor(config: Auth0Config, eventBus: EventBus, storageConfig?: StorageConfig, storageKeys?: StorageKeys, options?: AuthServiceOptions);
+    /**
+     * Get the identifier of this AuthService instance
+     * @returns The id if provided during initialization, undefined otherwise
+     */
+    getId(): string | undefined;
     /**
      * Initialize Auth0 client
      */
@@ -377,6 +419,11 @@ declare class AuthService {
      * Emit authentication event for cross-application communication
      */
     private emitAuthEvent;
+    /**
+     * Clean up OAuth callback parameters from URL after successful authentication
+     * Removes 'code' and 'state' parameters while preserving other query parameters
+     */
+    private cleanupCallbackUrl;
 }
 /**
  * Create AuthService instance using AUTH0_CONFIG
@@ -405,5 +452,204 @@ declare class AuthService {
  */
 declare function createAuthService(eventBus: EventBus): AuthService;
 
-export { APP_CONFIG, AUTH0_CONFIG, AuthService, EventBus, STORAGE_CONFIG, STORAGE_KEYS, configureAuth0, createAuthService, getStorageItem, removeStorageItem, resetAuth0Config, setStorageItem };
-export type { AppState, Auth0Config, Auth0ConfigOptions, AuthorizationParams, CallbackResult, EventPayload, StorageConfig, StorageKeys, UserData, UserInfo };
+/**
+ * OpenTelemetry severity levels
+ * Based on OpenTelemetry log data model
+ * @see https://opentelemetry.io/docs/specs/otel/logs/data-model/
+ */
+declare enum LogSeverity {
+    TRACE = 1,
+    DEBUG = 5,
+    INFO = 9,
+    WARN = 13,
+    ERROR = 17,
+    FATAL = 21
+}
+/**
+ * OpenTelemetry log record attributes
+ * Structured key-value pairs for additional context
+ */
+interface LogAttributes {
+    [key: string]: string | number | boolean | undefined | null;
+}
+/**
+ * OpenTelemetry log record
+ * Conforms to OTel log data model specification
+ */
+interface LogRecord {
+    /** Timestamp in milliseconds since Unix epoch */
+    timestamp: number;
+    /** Severity level number */
+    severityNumber: LogSeverity;
+    /** Severity level text */
+    severityText: string;
+    /** Log message body */
+    body: string;
+    /** Structured attributes for additional context */
+    attributes?: LogAttributes;
+    /** Trace ID if available (for correlation) */
+    traceId?: string;
+    /** Span ID if available (for correlation) */
+    spanId?: string;
+    /** Resource attributes (e.g., service.name, deployment.environment) */
+    resource?: LogAttributes;
+}
+/**
+ * Logger options interface
+ */
+interface LoggerOptions {
+    /** Logger identifier (e.g., service name, component name) */
+    name?: string;
+    /** Minimum severity level to log (logs below this level are ignored) */
+    minSeverity?: LogSeverity;
+    /** Resource attributes applied to all logs from this logger */
+    resource?: LogAttributes;
+    /** Whether to output logs to console (default: true) */
+    consoleOutput?: boolean;
+}
+/**
+ * Logger - OpenTelemetry-compliant structured logging
+ * Framework-agnostic implementation using RxJS for observability
+ *
+ * Conforms to OpenTelemetry log data model:
+ * - Structured logging with severity levels
+ * - Timestamp in milliseconds
+ * - Support for attributes and resource context
+ * - Observable log stream for integration with OTel exporters
+ *
+ * @example
+ * ```typescript
+ * // Create a logger instance
+ * const logger = new Logger({
+ *   name: 'MyService',
+ *   minSeverity: LogSeverity.INFO,
+ *   resource: {
+ *     'service.name': 'my-app',
+ *     'deployment.environment': 'production'
+ *   }
+ * });
+ *
+ * // Simple logging
+ * logger.info('User logged in');
+ * logger.error('Failed to fetch data');
+ *
+ * // Structured logging with attributes
+ * logger.info('User action', {
+ *   userId: '123',
+ *   action: 'purchase',
+ *   amount: 99.99
+ * });
+ *
+ * // Subscribe to log stream (e.g., for sending to OTel collector)
+ * logger.getLogStream().subscribe(logRecord => {
+ *   // Send to OTel exporter, custom backend, etc.
+ *   console.log(JSON.stringify(logRecord));
+ * });
+ *
+ * // Log with trace correlation
+ * logger.info('Processing request',
+ *   { requestId: 'abc-123' },
+ *   { traceId: '1234...', spanId: '5678...' }
+ * );
+ * ```
+ */
+declare class Logger {
+    private logSubject;
+    private name?;
+    private minSeverity;
+    private resource?;
+    private consoleOutput;
+    /**
+     * Create a new Logger instance
+     * @param options - Optional configuration for the logger
+     */
+    constructor(options?: LoggerOptions);
+    /**
+     * Get the logger name
+     * @returns The logger name if provided during initialization
+     */
+    getName(): string | undefined;
+    /**
+     * Get the observable log stream
+     * Subscribe to this to receive all log records emitted by this logger
+     * @returns Observable that emits LogRecord objects
+     */
+    getLogStream(): Observable<LogRecord>;
+    /**
+     * Emit a log record
+     * @param severity - Severity level
+     * @param severityText - Severity level text
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context (traceId, spanId)
+     */
+    private log;
+    /**
+     * Output log to console
+     * @param logRecord - The log record to output
+     */
+    private outputToConsole;
+    /**
+     * Log a TRACE level message
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context
+     */
+    trace(body: string, attributes?: LogAttributes, context?: {
+        traceId?: string;
+        spanId?: string;
+    }): void;
+    /**
+     * Log a DEBUG level message
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context
+     */
+    debug(body: string, attributes?: LogAttributes, context?: {
+        traceId?: string;
+        spanId?: string;
+    }): void;
+    /**
+     * Log an INFO level message
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context
+     */
+    info(body: string, attributes?: LogAttributes, context?: {
+        traceId?: string;
+        spanId?: string;
+    }): void;
+    /**
+     * Log a WARN level message
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context
+     */
+    warn(body: string, attributes?: LogAttributes, context?: {
+        traceId?: string;
+        spanId?: string;
+    }): void;
+    /**
+     * Log an ERROR level message
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context
+     */
+    error(body: string, attributes?: LogAttributes, context?: {
+        traceId?: string;
+        spanId?: string;
+    }): void;
+    /**
+     * Log a FATAL level message
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context
+     */
+    fatal(body: string, attributes?: LogAttributes, context?: {
+        traceId?: string;
+        spanId?: string;
+    }): void;
+}
+
+export { APP_CONFIG, AUTH0_CONFIG, AuthService, EventBus, LogSeverity, Logger, STORAGE_CONFIG, STORAGE_KEYS, configureAuth0, createAuthService, getStorageItem, removeStorageItem, resetAuth0Config, setStorageItem };
+export type { AppState, Auth0Config, Auth0ConfigOptions, AuthServiceOptions, AuthorizationParams, CallbackResult, EventBusOptions, EventPayload, LogAttributes, LogRecord, LoggerOptions, StorageConfig, StorageKeys, UserData, UserInfo };

package/dist/index.mjs

@@ -10,6 +10,9 @@ import { filter, map } from 'rxjs/operators';
  * // Create an instance
  * const eventBus = new EventBus();
  *
+ * // Create an instance with an identifier
+ * const eventBus = new EventBus({ id: 'MFE' });
+ *
  * // Emit an event
  * eventBus.emit('user:login', { userId: '123', username: 'john' });
  *
@@ -17,10 +20,28 @@ import { filter, map } from 'rxjs/operators';
  * eventBus.on('user:login').subscribe(data => {
  *   console.log('User logged in:', data);
  * });
+ *
+ * // Get the identifier
+ * const id = eventBus.getId(); // 'MFE' or undefined
  * ```
  */
 class EventBus {
     eventSubject = new Subject();
+    id;
+    /**
+     * Create a new EventBus instance
+     * @param options - Optional configuration with an id to identify the instance
+     */
+    constructor(options) {
+        this.id = options?.id;
+    }
+    /**
+     * Get the identifier of this EventBus instance
+     * @returns The id if provided during initialization, undefined otherwise
+     */
+    getId() {
+        return this.id;
+    }
     /**
      * Emit an event with optional data
      * @param eventType - The type/name of the event
@@ -243,10 +264,16 @@ function removeStorageItem(key, storageType = 'sessionStorage') {
  * };
  * const authService = new AuthService(authConfig, eventBus);
  *
+ * // Or create with an identifier
+ * const authService = new AuthService(authConfig, eventBus, undefined, undefined, { id: 'MFE' });
+ *
  * // Use the service
  * await authService.login();
  * const user = authService.getUser();
  * const token = await authService.getToken();
+ *
+ * // Get the identifier
+ * const id = authService.getId(); // 'MFE' or undefined
  * ```
  */
 class AuthService {
@@ -265,12 +292,14 @@ class AuthService {
     storageConfig;
     storageKeys;
     eventBus;
+    id;
     /**
      * Create a new AuthService instance
      * @param config - Auth0 configuration
      * @param eventBus - EventBus instance for emitting auth events
      * @param storageConfig - Storage configuration (optional, defaults to sessionStorage)
      * @param storageKeys - Storage keys (optional, defaults to standard keys)
+     * @param options - Optional configuration with an id to identify the instance
      */
     constructor(config, eventBus, storageConfig = {
         TOKEN_STORAGE: 'sessionStorage',
@@ -278,16 +307,24 @@ class AuthService {
     }, storageKeys = {
         ACCESS_TOKEN: 'auth0_access_token',
         USER_INFO: 'auth0_user_info'
-    }) {
+    }, options) {
         this.config = config;
         this.eventBus = eventBus;
         this.storageConfig = storageConfig;
         this.storageKeys = storageKeys;
+        this.id = options?.id;
         this.userSubject = new BehaviorSubject(this.getUserInfoFromStorage());
         this.user$ = this.userSubject.asObservable();
         console.log("[AuthService] AuthService instance created (Auth0 client will be initialized on first use)");
         // Lazy initialization - Auth0 client will be initialized in ensureInitialized() on first use
     }
+    /**
+     * Get the identifier of this AuthService instance
+     * @returns The id if provided during initialization, undefined otherwise
+     */
+    getId() {
+        return this.id;
+    }
     /**
      * Initialize Auth0 client
      */
@@ -404,6 +441,8 @@ class AuthService {
             }
             const token = await this.auth0Client.getTokenSilently();
             this.setToken(token);
+            // Clean up OAuth callback parameters from URL
+            this.cleanupCallbackUrl();
             console.log("[AuthService] Authentication successful");
             this.emitAuthEvent('login_success', { user, appState: result.appState });
             return { success: true, appState: result.appState };
@@ -626,6 +665,34 @@ class AuthService {
         this.eventBus.emit(event.type, event);
         console.log('[AuthService] Auth event emitted:', event.type);
     }
+    /**
+     * Clean up OAuth callback parameters from URL after successful authentication
+     * Removes 'code' and 'state' parameters while preserving other query parameters
+     */
+    cleanupCallbackUrl() {
+        try {
+            const url = new URL(window.location.href);
+            const params = new URLSearchParams(url.search);
+            // Check if OAuth params exist
+            const hasCode = params.has('code');
+            const hasState = params.has('state');
+            if (hasCode || hasState) {
+                // Remove OAuth callback parameters
+                params.delete('code');
+                params.delete('state');
+                // Construct new URL without OAuth params
+                const newSearch = params.toString();
+                const newUrl = `${url.pathname}${newSearch ? '?' + newSearch : ''}${url.hash}`;
+                // Replace URL without adding to browser history
+                window.history.replaceState({}, '', newUrl);
+                console.log('[AuthService] OAuth callback parameters cleaned from URL');
+            }
+        }
+        catch (error) {
+            console.warn('[AuthService] Failed to clean up callback URL:', error);
+            // Don't throw - URL cleanup is not critical for auth functionality
+        }
+    }
 }
 /**
  * Create AuthService instance using AUTH0_CONFIG
@@ -665,5 +732,209 @@ function createAuthService(eventBus) {
     return new AuthService(auth0Config, eventBus, STORAGE_CONFIG, STORAGE_KEYS);
 }
 
-export { APP_CONFIG, AUTH0_CONFIG, AuthService, EventBus, STORAGE_CONFIG, STORAGE_KEYS, configureAuth0, createAuthService, getStorageItem$1 as getStorageItem, removeStorageItem$1 as removeStorageItem, resetAuth0Config, setStorageItem$1 as setStorageItem };
+/**
+ * OpenTelemetry severity levels
+ * Based on OpenTelemetry log data model
+ * @see https://opentelemetry.io/docs/specs/otel/logs/data-model/
+ */
+var LogSeverity;
+(function (LogSeverity) {
+    LogSeverity[LogSeverity["TRACE"] = 1] = "TRACE";
+    LogSeverity[LogSeverity["DEBUG"] = 5] = "DEBUG";
+    LogSeverity[LogSeverity["INFO"] = 9] = "INFO";
+    LogSeverity[LogSeverity["WARN"] = 13] = "WARN";
+    LogSeverity[LogSeverity["ERROR"] = 17] = "ERROR";
+    LogSeverity[LogSeverity["FATAL"] = 21] = "FATAL";
+})(LogSeverity || (LogSeverity = {}));
+/**
+ * Logger - OpenTelemetry-compliant structured logging
+ * Framework-agnostic implementation using RxJS for observability
+ *
+ * Conforms to OpenTelemetry log data model:
+ * - Structured logging with severity levels
+ * - Timestamp in milliseconds
+ * - Support for attributes and resource context
+ * - Observable log stream for integration with OTel exporters
+ *
+ * @example
+ * ```typescript
+ * // Create a logger instance
+ * const logger = new Logger({
+ *   name: 'MyService',
+ *   minSeverity: LogSeverity.INFO,
+ *   resource: {
+ *     'service.name': 'my-app',
+ *     'deployment.environment': 'production'
+ *   }
+ * });
+ *
+ * // Simple logging
+ * logger.info('User logged in');
+ * logger.error('Failed to fetch data');
+ *
+ * // Structured logging with attributes
+ * logger.info('User action', {
+ *   userId: '123',
+ *   action: 'purchase',
+ *   amount: 99.99
+ * });
+ *
+ * // Subscribe to log stream (e.g., for sending to OTel collector)
+ * logger.getLogStream().subscribe(logRecord => {
+ *   // Send to OTel exporter, custom backend, etc.
+ *   console.log(JSON.stringify(logRecord));
+ * });
+ *
+ * // Log with trace correlation
+ * logger.info('Processing request',
+ *   { requestId: 'abc-123' },
+ *   { traceId: '1234...', spanId: '5678...' }
+ * );
+ * ```
+ */
+class Logger {
+    logSubject = new Subject();
+    name;
+    minSeverity;
+    resource;
+    consoleOutput;
+    /**
+     * Create a new Logger instance
+     * @param options - Optional configuration for the logger
+     */
+    constructor(options) {
+        this.name = options?.name;
+        this.minSeverity = options?.minSeverity ?? LogSeverity.TRACE;
+        this.resource = options?.resource;
+        this.consoleOutput = options?.consoleOutput ?? true;
+    }
+    /**
+     * Get the logger name
+     * @returns The logger name if provided during initialization
+     */
+    getName() {
+        return this.name;
+    }
+    /**
+     * Get the observable log stream
+     * Subscribe to this to receive all log records emitted by this logger
+     * @returns Observable that emits LogRecord objects
+     */
+    getLogStream() {
+        return this.logSubject.asObservable();
+    }
+    /**
+     * Emit a log record
+     * @param severity - Severity level
+     * @param severityText - Severity level text
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context (traceId, spanId)
+     */
+    log(severity, severityText, body, attributes, context) {
+        // Check if we should log based on minimum severity
+        if (severity < this.minSeverity) {
+            return;
+        }
+        const logRecord = {
+            timestamp: Date.now(),
+            severityNumber: severity,
+            severityText,
+            body,
+            attributes,
+            traceId: context?.traceId,
+            spanId: context?.spanId,
+            resource: this.resource
+        };
+        // Emit to observable stream
+        this.logSubject.next(logRecord);
+        // Console output if enabled
+        if (this.consoleOutput) {
+            this.outputToConsole(logRecord);
+        }
+    }
+    /**
+     * Output log to console
+     * @param logRecord - The log record to output
+     */
+    outputToConsole(logRecord) {
+        const prefix = this.name ? `[${this.name}]` : '';
+        const message = `${prefix} ${logRecord.body}`;
+        const meta = logRecord.attributes;
+        switch (logRecord.severityNumber) {
+            case LogSeverity.TRACE:
+            case LogSeverity.DEBUG:
+                console.debug(message, meta);
+                break;
+            case LogSeverity.INFO:
+                console.info(message, meta);
+                break;
+            case LogSeverity.WARN:
+                console.warn(message, meta);
+                break;
+            case LogSeverity.ERROR:
+            case LogSeverity.FATAL:
+                console.error(message, meta);
+                break;
+            default:
+                console.log(message, meta);
+        }
+    }
+    /**
+     * Log a TRACE level message
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context
+     */
+    trace(body, attributes, context) {
+        this.log(LogSeverity.TRACE, 'TRACE', body, attributes, context);
+    }
+    /**
+     * Log a DEBUG level message
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context
+     */
+    debug(body, attributes, context) {
+        this.log(LogSeverity.DEBUG, 'DEBUG', body, attributes, context);
+    }
+    /**
+     * Log an INFO level message
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context
+     */
+    info(body, attributes, context) {
+        this.log(LogSeverity.INFO, 'INFO', body, attributes, context);
+    }
+    /**
+     * Log a WARN level message
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context
+     */
+    warn(body, attributes, context) {
+        this.log(LogSeverity.WARN, 'WARN', body, attributes, context);
+    }
+    /**
+     * Log an ERROR level message
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context
+     */
+    error(body, attributes, context) {
+        this.log(LogSeverity.ERROR, 'ERROR', body, attributes, context);
+    }
+    /**
+     * Log a FATAL level message
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context
+     */
+    fatal(body, attributes, context) {
+        this.log(LogSeverity.FATAL, 'FATAL', body, attributes, context);
+    }
+}
+
+export { APP_CONFIG, AUTH0_CONFIG, AuthService, EventBus, LogSeverity, Logger, STORAGE_CONFIG, STORAGE_KEYS, configureAuth0, createAuthService, getStorageItem$1 as getStorageItem, removeStorageItem$1 as removeStorageItem, resetAuth0Config, setStorageItem$1 as setStorageItem };
 //# sourceMappingURL=index.mjs.map