@hkdigital/lib-sveltekit 0.1.70 → 0.1.72

package/dist/classes/logging/Logger.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Logger class for consistent logging across services
+ * @extends EventEmitter
+ */
+export default class Logger extends EventEmitter {
+    /**
+     * Create a new Logger instance
+     *
+     * @param {string} name - Name of the service/component for this logger
+     * @param {string} [defaultLevel=INFO] - Initial log level threshold
+     */
+    constructor(name: string, defaultLevel?: string);
+    name: string;
+    level: string;
+    /**
+     * Set the minimum log level threshold
+     *
+     * @param {string} level - New log level (DEBUG, INFO, WARN, ERROR, FATAL,
+     *                         or NONE)
+     * @returns {boolean} True if level was valid and set, false otherwise
+     */
+    setLevel(level: string): boolean;
+    /**
+     * Internal logging method
+     *
+     * @param {string} level - Log level
+     * @param {string} message - Log message
+     * @param {*} [details] - Additional details to include in the log
+     * @returns {boolean} True if the log was emitted, false if filtered
+     * @private
+     */
+    private _log;
+    /**
+     * Log a debug message
+     *
+     * @param {string} message - Log message
+     * @param {*} [details] - Additional details
+     * @returns {boolean} True if the log was emitted
+     */
+    debug(message: string, details?: any): boolean;
+    /**
+     * Log an info message
+     *
+     * @param {string} message - Log message
+     * @param {*} [details] - Additional details
+     * @returns {boolean} True if the log was emitted
+     */
+    info(message: string, details?: any): boolean;
+    /**
+     * Log a warning message
+     *
+     * @param {string} message - Log message
+     * @param {*} [details] - Additional details
+     * @returns {boolean} True if the log was emitted
+     */
+    warn(message: string, details?: any): boolean;
+    /**
+     * Log an error message
+     *
+     * @param {string} message - Log message
+     * @param {*} [details] - Additional details
+     * @returns {boolean} True if the log was emitted
+     */
+    error(message: string, details?: any): boolean;
+    /**
+     * Log a fatal error message
+     *
+     * @param {string} message - Log message
+     * @param {*} [details] - Additional details
+     * @returns {boolean} True if the log was emitted
+     */
+    fatal(message: string, details?: any): boolean;
+}
+import { EventEmitter } from '../events';

package/dist/classes/logging/Logger.js

@@ -0,0 +1,158 @@
+/**
+ * @fileoverview Logger implementation based on EventEmitter e.g.
+ * for service logging.
+ *
+ * This Logger provides consistent log level filtering and event-based
+ * distribution of log messages. It integrates with the service architecture
+ * to provide controlled, consistent logging across all services.
+ *
+ * @example
+ * // Basic usage
+ * import { Logger, INFO, DEBUG } from './Logger.js';
+ *
+ * const logger = new Logger('myService', INFO);
+ *
+ * // Log at different levels
+ * logger.debug('Detailed information', { value: 42 }); // Filtered out at INFO
+ * logger.info('Operation completed', { items: 27 });   // Will be logged
+ * logger.warn('Unusual condition detected');           // Will be logged
+ *
+ * // Listen to log events
+ * logger.on('log', (logEvent) => {
+ *   // Process all log events
+ *   saveToLogFile(logEvent);
+ * });
+ *
+ * logger.on(ERROR, (logEvent) => {
+ *   // Process only error events
+ *   sendAlertEmail(logEvent);
+ * });
+ *
+ * // Change log level at runtime
+ * logger.setLevel(DEBUG); // Now debug messages will also be logged
+ */
+
+import { EventEmitter } from '../events';
+
+import { DEBUG, INFO, WARN, ERROR, FATAL, NONE, LEVELS } from './constants.js';
+
+/**
+ * Logger class for consistent logging across services
+ * @extends EventEmitter
+ */
+export default class Logger extends EventEmitter {
+  /**
+   * Create a new Logger instance
+   *
+   * @param {string} name - Name of the service/component for this logger
+   * @param {string} [defaultLevel=INFO] - Initial log level threshold
+   */
+  constructor(name, defaultLevel = INFO) {
+    super();
+    this.name = name;
+    this.level = defaultLevel;
+  }
+
+  /**
+   * Set the minimum log level threshold
+   *
+   * @param {string} level - New log level (DEBUG, INFO, WARN, ERROR, FATAL,
+   *                         or NONE)
+   * @returns {boolean} True if level was valid and set, false otherwise
+   */
+  setLevel(level) {
+    if (LEVELS[level] !== undefined) {
+      this.level = level;
+      return true;
+    }
+
+    console.warn(`Invalid log level: ${level}`);
+    return false;
+  }
+
+  /**
+   * Internal logging method
+   *
+   * @param {string} level - Log level
+   * @param {string} message - Log message
+   * @param {*} [details] - Additional details to include in the log
+   * @returns {boolean} True if the log was emitted, false if filtered
+   * @private
+   */
+  _log(level, message, details) {
+    // Check if this log level should be filtered
+    if (LEVELS[level] < LEVELS[this.level]) {
+      return false; // Below threshold, don't emit
+    }
+
+    const timestamp = new Date();
+    const logEvent = {
+      timestamp,
+      service: this.name,
+      level,
+      message,
+      details
+    };
+
+    // Emit as both specific level event and generic 'log' event
+    this.emit(level, logEvent);
+    this.emit('log', logEvent);
+
+    return true;
+  }
+
+  /**
+   * Log a debug message
+   *
+   * @param {string} message - Log message
+   * @param {*} [details] - Additional details
+   * @returns {boolean} True if the log was emitted
+   */
+  debug(message, details) {
+    return this._log(DEBUG, message, details);
+  }
+
+  /**
+   * Log an info message
+   *
+   * @param {string} message - Log message
+   * @param {*} [details] - Additional details
+   * @returns {boolean} True if the log was emitted
+   */
+  info(message, details) {
+    return this._log(INFO, message, details);
+  }
+
+  /**
+   * Log a warning message
+   *
+   * @param {string} message - Log message
+   * @param {*} [details] - Additional details
+   * @returns {boolean} True if the log was emitted
+   */
+  warn(message, details) {
+    return this._log(WARN, message, details);
+  }
+
+  /**
+   * Log an error message
+   *
+   * @param {string} message - Log message
+   * @param {*} [details] - Additional details
+   * @returns {boolean} True if the log was emitted
+   */
+  error(message, details) {
+    return this._log(ERROR, message, details);
+  }
+
+  /**
+   * Log a fatal error message
+   *
+   * @param {string} message - Log message
+   * @param {*} [details] - Additional details
+   * @returns {boolean} True if the log was emitted
+   */
+  fatal(message, details) {
+    return this._log(FATAL, message, details);
+  }
+}

package/dist/classes/logging/constants.d.ts

@@ -0,0 +1,14 @@
+export const DEBUG: "debug";
+export const INFO: "info";
+export const WARN: "warn";
+export const ERROR: "error";
+export const FATAL: "fatal";
+export const NONE: "none";
+export namespace LEVELS {
+    let debug: number;
+    let info: number;
+    let warn: number;
+    let error: number;
+    let fatal: number;
+    let none: number;
+}

package/dist/classes/logging/constants.js

@@ -0,0 +1,18 @@
+
+// Log level names
+export const DEBUG = 'debug';
+export const INFO = 'info';
+export const WARN = 'warn';
+export const ERROR = 'error';
+export const FATAL = 'fatal';
+export const NONE = 'none';
+
+// Level values for filtering (higher = more important)
+export const LEVELS = {
+  [DEBUG]: 1,
+  [INFO]: 2,
+  [WARN]: 3,
+  [ERROR]: 4,
+  [FATAL]: 5,
+  [NONE]: 6
+};

package/dist/classes/logging/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Logger } from "./Logger.js";
+export * from "./constants.js";

package/dist/classes/logging/index.js

@@ -0,0 +1,4 @@
+
+export { default as Logger } from './Logger.js';
+
+export * from './constants.js';

package/dist/classes/services/ServiceBase.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Base class for all services
+ */
+export default class ServiceBase {
+    /**
+     * Create a new service
+     *
+     * @param {string} name - Service name
+     * @param {Object} [options] - Service options
+     * @param {string} [options.logLevel=INFO] - Initial log level
+     */
+    constructor(name: string, options?: {
+        logLevel?: string;
+    });
+    /**
+     * Service name
+     * @type {string}
+     */
+    name: string;
+    /**
+     * Event emitter for service events
+     * @type {EventEmitter}
+     */
+    events: EventEmitter;
+    /**
+     * Current service state
+     * @type {string}
+     */
+    state: string;
+    /**
+     * Last error that occurred
+     * @type {Error|null}
+     */
+    error: Error | null;
+    /**
+     * Last stable state before error
+     * @type {string|null}
+     * @private
+     */
+    private _preErrorState;
+    /**
+     * Service logger
+     * @type {Logger}
+     */
+    logger: Logger;
+    /**
+     * Set the service log level
+     *
+     * @param {string} level - New log level
+     * @returns {boolean} True if level was set, false if invalid
+     */
+    setLogLevel(level: string): boolean;
+    /**
+     * Initialize the service
+     *
+     * @param {Object} [config] - Service configuration
+     * @returns {Promise<boolean>} True if initialized successfully
+     */
+    initialize(config?: any): Promise<boolean>;
+    /**
+     * Start the service
+     *
+     * @returns {Promise<boolean>} True if started successfully
+     */
+    start(): Promise<boolean>;
+    /**
+     * Stop the service
+     *
+     * @returns {Promise<boolean>} True if stopped successfully
+     */
+    stop(): Promise<boolean>;
+    /**
+     * Recover the service
+     *
+     * @returns {Promise<boolean>} True if stopped successfully
+     */
+    recover(): Promise<boolean>;
+    /**
+     * Destroy the service
+     *
+     * @returns {Promise<boolean>} True if destroyed successfully
+     */
+    destroy(): Promise<boolean>;
+    /**
+     * Add an event listener
+     *
+     * @param {string} eventName - Event name
+     * @param {Function} handler - Event handler
+     * @returns {Function} Unsubscribe function
+     */
+    on(eventName: string, handler: Function): Function;
+    /**
+     * Emit an event
+     *
+     * @param {string} eventName - Event name
+     * @param {*} data - Event data
+     * @returns {boolean} True if event had listeners
+     */
+    emit(eventName: string, data: any): boolean;
+    /**
+     * Initialize the service (to be overridden)
+     *
+     * @protected
+     * @param {Object} config - Service configuration
+     * @returns {Promise<void>}
+     */
+    protected _init(config: any): Promise<void>;
+    /**
+     * Start the service (to be overridden)
+     *
+     * @protected
+     * @returns {Promise<void>}
+     */
+    protected _start(): Promise<void>;
+    /**
+     * Stop the service (to be overridden)
+     *
+     * @protected
+     * @returns {Promise<void>}
+     */
+    protected _stop(): Promise<void>;
+    /**
+     * Destroy the service (to be overridden)
+     *
+     * @protected
+     * @returns {Promise<void>}
+     */
+    protected _destroy(): Promise<void>;
+    /**
+     * Recover the service from an error (to be overridden)
+     *
+     * @protected
+     * @returns {Promise<void>}
+     */
+    protected _recover(): Promise<void>;
+    /**
+     * Set the service state
+     *
+     * @private
+     * @param {string} state - New state
+     */
+    private _setState;
+    /**
+     * Set an error state
+     *
+     * @private
+     * @param {string} operation - Operation that failed
+     * @param {Error} error - Error that occurred
+     */
+    private _setError;
+}
+import { EventEmitter } from '../events';
+import { Logger } from '../logging';