16982792483

Committed 15 Aug 2025 04:15AM UTC coverage: 85.706% (-9.9%) from 95.62%

Build # 16982792483

Build Type

push

github

Committed by

dev-ignis

Commit Message

test: - ci;

Run Details

489 of 647 branches covered (75.58%)

Branch coverage included in aggregate %.

944 of 1025 relevant lines covered (92.1%)

357.96 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.24

/src/core/config.ts

/**
 * Configuration manager with environment-based defaults
 */

import {
  LoggerConfig,
  LogLevel,
  Environment,
  EnvConfig,
  PartialLoggerConfig,
  mergeConfig
} from './types';
import {
  detectEnvironment,
  parseLogLevel,
  parseEnvBoolean,
  getEnvVar
} from './utils';

export class ConfigManager {
  private config: LoggerConfig;
  private environment: Environment;

  constructor(initialConfig?: PartialLoggerConfig) {
    this.environment = detectEnvironment();
    this.config = this.mergeWithDefaults(initialConfig);
  }

  /**
   * Get the current configuration
   */
  getConfig(): LoggerConfig {
    return { ...this.config };
  }

  /**
   * Update configuration
   */
  updateConfig(newConfig: PartialLoggerConfig): void {
    this.config = mergeConfig(this.config, newConfig);
  }

  /**
   * Merge user config with smart defaults
   */
  private mergeWithDefaults(userConfig?: PartialLoggerConfig): LoggerConfig {
    const envConfig = this.getEnvConfig();

    // Base defaults without environment variables
    const baseDefaults: LoggerConfig = {
      enabled: true,
      minLevel: this.environment.isDevelopment ? LogLevel.DEBUG : LogLevel.WARN,
      showTimestamp: true,
      includeStackTrace: true,
      categories: {},
      colors: {
        enabled: this.getDefaultColorsEnabled(),
        browser: {
          debug: '#6EC1E4',
          info: '#4A9FCA',
          warn: '#FBC02D',
          error: '#D67C2A'
        },
        ansi: {
          debug: 36,
          info: 36,
          warn: 33,
          error: 31
        }
      },
      storage: {
        enabled: this.environment.isBrowser,
        keyPrefix: 'universal_logger'
      },
      browserControls: {
        enabled: this.environment.isBrowser && this.environment.isDevelopment,
        windowNamespace: '__universalLogger'
      }
    };

    // Environment variable overrides
    const envOverrides: PartialLoggerConfig = {};

    if (envConfig.LOGGER_ENABLED !== undefined) {
      envOverrides.enabled = parseEnvBoolean(envConfig.LOGGER_ENABLED, true);
    }

    if (envConfig.LOG_LEVEL !== undefined) {
      const envLevel = parseLogLevel(envConfig.LOG_LEVEL);
      if (envLevel !== null) {
        envOverrides.minLevel = envLevel;
      }
    }

    if (envConfig.LOGGER_TIMESTAMPS !== undefined) {
      envOverrides.showTimestamp = parseEnvBoolean(envConfig.LOGGER_TIMESTAMPS, true);
    }

    if (envConfig.LOGGER_STACK_TRACES !== undefined) {
      envOverrides.includeStackTrace = parseEnvBoolean(envConfig.LOGGER_STACK_TRACES, true);
    }

    // Handle colors configuration
    const colorsOverride: any = {};
    let hasColorOverrides = false;

    if (envConfig.LOGGER_COLORS !== undefined) {
      colorsOverride.enabled = parseEnvBoolean(envConfig.LOGGER_COLORS, this.getDefaultColorsEnabled());
      hasColorOverrides = true;
    }

    // Browser color overrides
    const browserColors: any = {};
    let hasBrowserColorOverrides = false;
    if (envConfig.LOGGER_COLOR_DEBUG) {
      browserColors.debug = envConfig.LOGGER_COLOR_DEBUG;
      hasBrowserColorOverrides = true;
    }
    if (envConfig.LOGGER_COLOR_INFO) {
      browserColors.info = envConfig.LOGGER_COLOR_INFO;
      hasBrowserColorOverrides = true;
    }
    if (envConfig.LOGGER_COLOR_WARN) {
      browserColors.warn = envConfig.LOGGER_COLOR_WARN;
      hasBrowserColorOverrides = true;
    }
    if (envConfig.LOGGER_COLOR_ERROR) {
      browserColors.error = envConfig.LOGGER_COLOR_ERROR;
      hasBrowserColorOverrides = true;
    }

    // ANSI color overrides
    const ansiColors: any = {};
    let hasAnsiColorOverrides = false;
    if (envConfig.LOGGER_ANSI_DEBUG) {
      const parsed = parseInt(envConfig.LOGGER_ANSI_DEBUG, 10);
      if (!isNaN(parsed)) {
        ansiColors.debug = parsed;
        hasAnsiColorOverrides = true;
      }
    }
    if (envConfig.LOGGER_ANSI_INFO) {
      const parsed = parseInt(envConfig.LOGGER_ANSI_INFO, 10);
      if (!isNaN(parsed)) {
        ansiColors.info = parsed;
        hasAnsiColorOverrides = true;
      }
    }
    if (envConfig.LOGGER_ANSI_WARN) {
      const parsed = parseInt(envConfig.LOGGER_ANSI_WARN, 10);
      if (!isNaN(parsed)) {
        ansiColors.warn = parsed;
        hasAnsiColorOverrides = true;
      }
    }
    if (envConfig.LOGGER_ANSI_ERROR) {
      const parsed = parseInt(envConfig.LOGGER_ANSI_ERROR, 10);
      if (!isNaN(parsed)) {
        ansiColors.error = parsed;
        hasAnsiColorOverrides = true;
      }
    }

    if (hasColorOverrides || hasBrowserColorOverrides || hasAnsiColorOverrides) {
      envOverrides.colors = {
        ...baseDefaults.colors,
        ...colorsOverride,
        browser: hasBrowserColorOverrides ? { ...baseDefaults.colors.browser, ...browserColors } : baseDefaults.colors.browser,
        ansi: hasAnsiColorOverrides ? { ...baseDefaults.colors.ansi, ...ansiColors } : baseDefaults.colors.ansi
      };
    }

    // Storage overrides
    const storageOverride: any = {};
    let hasStorageOverrides = false;
    if (envConfig.LOGGER_STORAGE_ENABLED !== undefined) {
      storageOverride.enabled = parseEnvBoolean(envConfig.LOGGER_STORAGE_ENABLED, this.environment.isBrowser);
      hasStorageOverrides = true;
    }
    if (envConfig.LOGGER_STORAGE_KEY_PREFIX) {
      storageOverride.keyPrefix = envConfig.LOGGER_STORAGE_KEY_PREFIX;
      hasStorageOverrides = true;
    }
    if (hasStorageOverrides) {
      envOverrides.storage = { ...baseDefaults.storage, ...storageOverride };
    }

    // Browser controls overrides
    const browserControlsOverride: any = {};
    let hasBrowserControlsOverrides = false;
    if (envConfig.LOGGER_BROWSER_CONTROLS !== undefined) {
      browserControlsOverride.enabled = parseEnvBoolean(envConfig.LOGGER_BROWSER_CONTROLS, this.environment.isBrowser && this.environment.isDevelopment);
      hasBrowserControlsOverrides = true;
    }
    if (envConfig.LOGGER_WINDOW_NAMESPACE) {
      browserControlsOverride.windowNamespace = envConfig.LOGGER_WINDOW_NAMESPACE;
      hasBrowserControlsOverrides = true;
    }
    if (hasBrowserControlsOverrides) {
      envOverrides.browserControls = { ...baseDefaults.browserControls, ...browserControlsOverride };
    }

    // Merge: base defaults < user config < environment variables
    let result = baseDefaults;
    if (userConfig) {
      result = mergeConfig(result, userConfig);
    }
    if (Object.keys(envOverrides).length > 0) {
      result = mergeConfig(result, envOverrides);
    }
    return result;
  }

  /**
   * Get environment configuration
   */
  private getEnvConfig(): EnvConfig {
    return {
      LOG_LEVEL: getEnvVar('LOG_LEVEL'),
      LOGGER_ENABLED: getEnvVar('LOGGER_ENABLED'),
      LOGGER_TIMESTAMPS: getEnvVar('LOGGER_TIMESTAMPS'),
      LOGGER_STACK_TRACES: getEnvVar('LOGGER_STACK_TRACES'),
      LOGGER_COLORS: getEnvVar('LOGGER_COLORS'),
      LOGGER_STORAGE_ENABLED: getEnvVar('LOGGER_STORAGE_ENABLED'),
      LOGGER_STORAGE_KEY_PREFIX: getEnvVar('LOGGER_STORAGE_KEY_PREFIX'),
      LOGGER_BROWSER_CONTROLS: getEnvVar('LOGGER_BROWSER_CONTROLS'),
      LOGGER_WINDOW_NAMESPACE: getEnvVar('LOGGER_WINDOW_NAMESPACE'),
      LOGGER_COLOR_DEBUG: getEnvVar('LOGGER_COLOR_DEBUG'),
      LOGGER_COLOR_INFO: getEnvVar('LOGGER_COLOR_INFO'),
      LOGGER_COLOR_WARN: getEnvVar('LOGGER_COLOR_WARN'),
      LOGGER_COLOR_ERROR: getEnvVar('LOGGER_COLOR_ERROR'),
      LOGGER_ANSI_DEBUG: getEnvVar('LOGGER_ANSI_DEBUG'),
      LOGGER_ANSI_INFO: getEnvVar('LOGGER_ANSI_INFO'),
      LOGGER_ANSI_WARN: getEnvVar('LOGGER_ANSI_WARN'),
      LOGGER_ANSI_ERROR: getEnvVar('LOGGER_ANSI_ERROR')
    };
  }



  /**
   * Get default colors enabled setting
   */
  private getDefaultColorsEnabled(): boolean {
    // Colors enabled in browser, or Node.js development
    return this.environment.isBrowser || this.environment.isDevelopment;
  }

  /**
   * Get environment information
   */
  getEnvironment(): Environment {
    return { ...this.environment };
  }
}

/**
 * Load configuration from environment variables
 * Utility function for creating loggers with env-based config
 */
export function loadConfigFromEnv(): PartialLoggerConfig {
  const configManager = new ConfigManager();
  return configManager.getConfig();
}

1	/**
2	* Configuration manager with environment-based defaults
3	*/
4
5	import {	39✔
6	LoggerConfig,
7	LogLevel,
8	Environment,
9	EnvConfig,
10	PartialLoggerConfig,
11	mergeConfig
12	} from './types';
13	import {	39✔
14	detectEnvironment,
15	parseLogLevel,
16	parseEnvBoolean,
17	getEnvVar
18	} from './utils';
19
20	export class ConfigManager {	39✔
21	private config: LoggerConfig;
22	private environment: Environment;
23
24	constructor(initialConfig?: PartialLoggerConfig) {
25	this.environment = detectEnvironment();	753✔
26	this.config = this.mergeWithDefaults(initialConfig);	753✔
27	}
28
29	/**
30	* Get the current configuration
31	*/
32	getConfig(): LoggerConfig {
33	return { ...this.config };	18,672✔
34	}
35
36	/**
37	* Update configuration
38	*/
39	updateConfig(newConfig: PartialLoggerConfig): void {
40	this.config = mergeConfig(this.config, newConfig);	168✔
41	}
42
43	/**
44	* Merge user config with smart defaults
45	*/
46	private mergeWithDefaults(userConfig?: PartialLoggerConfig): LoggerConfig {
47	const envConfig = this.getEnvConfig();	753✔
48
49	// Base defaults without environment variables
50	const baseDefaults: LoggerConfig = {	753✔
51	enabled: true,
52	minLevel: this.environment.isDevelopment ? LogLevel.DEBUG : LogLevel.WARN,	753✔
53	showTimestamp: true,
54	includeStackTrace: true,
55	categories: {},
56	colors: {
57	enabled: this.getDefaultColorsEnabled(),
58	browser: {
59	debug: '#6EC1E4',
60	info: '#4A9FCA',
61	warn: '#FBC02D',
62	error: '#D67C2A'
63	},
64	ansi: {
65	debug: 36,
66	info: 36,
67	warn: 33,
68	error: 31
69	}
70	},
71	storage: {
72	enabled: this.environment.isBrowser,
73	keyPrefix: 'universal_logger'
74	},
75	browserControls: {
76	enabled: this.environment.isBrowser && this.environment.isDevelopment,	864✔
77	windowNamespace: '__universalLogger'
78	}
79	};
80
81	// Environment variable overrides
82	const envOverrides: PartialLoggerConfig = {};	753✔
83
84	if (envConfig.LOGGER_ENABLED !== undefined) {	753✔
85	envOverrides.enabled = parseEnvBoolean(envConfig.LOGGER_ENABLED, true);	18✔
86	}
87
88	if (envConfig.LOG_LEVEL !== undefined) {	753✔
89	const envLevel = parseLogLevel(envConfig.LOG_LEVEL);	24✔
90	if (envLevel !== null) {	24✔
91	envOverrides.minLevel = envLevel;	18✔
92	}
93	}
94
95	if (envConfig.LOGGER_TIMESTAMPS !== undefined) {	753✔
96	envOverrides.showTimestamp = parseEnvBoolean(envConfig.LOGGER_TIMESTAMPS, true);	9✔
97	}
98
99	if (envConfig.LOGGER_STACK_TRACES !== undefined) {	753✔
100	envOverrides.includeStackTrace = parseEnvBoolean(envConfig.LOGGER_STACK_TRACES, true);	3✔
101	}
102
103	// Handle colors configuration
104	const colorsOverride: any = {};	753✔
105	let hasColorOverrides = false;	753✔
106
107	if (envConfig.LOGGER_COLORS !== undefined) {	753✔
108	colorsOverride.enabled = parseEnvBoolean(envConfig.LOGGER_COLORS, this.getDefaultColorsEnabled());	15✔
109	hasColorOverrides = true;	15✔
110	}
111
112	// Browser color overrides
113	const browserColors: any = {};	753✔
114	let hasBrowserColorOverrides = false;	753✔
115	if (envConfig.LOGGER_COLOR_DEBUG) {	753✔
116	browserColors.debug = envConfig.LOGGER_COLOR_DEBUG;	3✔
117	hasBrowserColorOverrides = true;	3✔
118	}
119	if (envConfig.LOGGER_COLOR_INFO) {	753!
120	browserColors.info = envConfig.LOGGER_COLOR_INFO;	×
121	hasBrowserColorOverrides = true;	×
122	}
123	if (envConfig.LOGGER_COLOR_WARN) {	753!
124	browserColors.warn = envConfig.LOGGER_COLOR_WARN;	×
125	hasBrowserColorOverrides = true;	×
126	}
127	if (envConfig.LOGGER_COLOR_ERROR) {	753!
128	browserColors.error = envConfig.LOGGER_COLOR_ERROR;	×
129	hasBrowserColorOverrides = true;	×
130	}
131
132	// ANSI color overrides
133	const ansiColors: any = {};	753✔
134	let hasAnsiColorOverrides = false;	753✔
135	if (envConfig.LOGGER_ANSI_DEBUG) {	753✔
136	const parsed = parseInt(envConfig.LOGGER_ANSI_DEBUG, 10);	12✔
137	if (!isNaN(parsed)) {	12✔
138	ansiColors.debug = parsed;	6✔
139	hasAnsiColorOverrides = true;	6✔
140	}
141	}
142	if (envConfig.LOGGER_ANSI_INFO) {	753✔
143	const parsed = parseInt(envConfig.LOGGER_ANSI_INFO, 10);	3✔
144	if (!isNaN(parsed)) {	3✔
145	ansiColors.info = parsed;	3✔
146	hasAnsiColorOverrides = true;	3✔
147	}
148	}
149	if (envConfig.LOGGER_ANSI_WARN) {	753✔
150	const parsed = parseInt(envConfig.LOGGER_ANSI_WARN, 10);	3✔
151	if (!isNaN(parsed)) {	3✔
152	ansiColors.warn = parsed;	3✔
153	hasAnsiColorOverrides = true;	3✔
154	}
155	}
156	if (envConfig.LOGGER_ANSI_ERROR) {	753✔
157	const parsed = parseInt(envConfig.LOGGER_ANSI_ERROR, 10);	3✔
158	if (!isNaN(parsed)) {	3✔
159	ansiColors.error = parsed;	3✔
160	hasAnsiColorOverrides = true;	3✔
161	}
162	}
163
164	if (hasColorOverrides \|\| hasBrowserColorOverrides \|\| hasAnsiColorOverrides) {	753✔
165	envOverrides.colors = {	15✔
166	...baseDefaults.colors,
167	...colorsOverride,
168	browser: hasBrowserColorOverrides ? { ...baseDefaults.colors.browser, ...browserColors } : baseDefaults.colors.browser,	15✔
169	ansi: hasAnsiColorOverrides ? { ...baseDefaults.colors.ansi, ...ansiColors } : baseDefaults.colors.ansi	15✔
170	};
171	}
172
173	// Storage overrides
174	const storageOverride: any = {};	753✔
175	let hasStorageOverrides = false;	753✔
176	if (envConfig.LOGGER_STORAGE_ENABLED !== undefined) {	753✔
177	storageOverride.enabled = parseEnvBoolean(envConfig.LOGGER_STORAGE_ENABLED, this.environment.isBrowser);	3✔
178	hasStorageOverrides = true;	3✔
179	}
180	if (envConfig.LOGGER_STORAGE_KEY_PREFIX) {	753✔
181	storageOverride.keyPrefix = envConfig.LOGGER_STORAGE_KEY_PREFIX;	6✔
182	hasStorageOverrides = true;	6✔
183	}
184	if (hasStorageOverrides) {	753✔
185	envOverrides.storage = { ...baseDefaults.storage, ...storageOverride };	6✔
186	}
187
188	// Browser controls overrides
189	const browserControlsOverride: any = {};	753✔
190	let hasBrowserControlsOverrides = false;	753✔
191	if (envConfig.LOGGER_BROWSER_CONTROLS !== undefined) {	753✔
192	browserControlsOverride.enabled = parseEnvBoolean(envConfig.LOGGER_BROWSER_CONTROLS, this.environment.isBrowser && this.environment.isDevelopment);	3!
193	hasBrowserControlsOverrides = true;	3✔
194	}
195	if (envConfig.LOGGER_WINDOW_NAMESPACE) {	753✔
196	browserControlsOverride.windowNamespace = envConfig.LOGGER_WINDOW_NAMESPACE;	3✔
197	hasBrowserControlsOverrides = true;	3✔
198	}
199	if (hasBrowserControlsOverrides) {	753✔
200	envOverrides.browserControls = { ...baseDefaults.browserControls, ...browserControlsOverride };	3✔
201	}
202
203	// Merge: base defaults < user config < environment variables
204	let result = baseDefaults;	753✔
205	if (userConfig) {	753✔
206	result = mergeConfig(result, userConfig);	453✔
207	}
208	if (Object.keys(envOverrides).length > 0) {	753✔
209	result = mergeConfig(result, envOverrides);	36✔
210	}
211	return result;	753✔
212	}
213
214	/**
215	* Get environment configuration
216	*/
217	private getEnvConfig(): EnvConfig {
218	return {	753✔
219	LOG_LEVEL: getEnvVar('LOG_LEVEL'),
220	LOGGER_ENABLED: getEnvVar('LOGGER_ENABLED'),
221	LOGGER_TIMESTAMPS: getEnvVar('LOGGER_TIMESTAMPS'),
222	LOGGER_STACK_TRACES: getEnvVar('LOGGER_STACK_TRACES'),
223	LOGGER_COLORS: getEnvVar('LOGGER_COLORS'),
224	LOGGER_STORAGE_ENABLED: getEnvVar('LOGGER_STORAGE_ENABLED'),
225	LOGGER_STORAGE_KEY_PREFIX: getEnvVar('LOGGER_STORAGE_KEY_PREFIX'),
226	LOGGER_BROWSER_CONTROLS: getEnvVar('LOGGER_BROWSER_CONTROLS'),
227	LOGGER_WINDOW_NAMESPACE: getEnvVar('LOGGER_WINDOW_NAMESPACE'),
228	LOGGER_COLOR_DEBUG: getEnvVar('LOGGER_COLOR_DEBUG'),
229	LOGGER_COLOR_INFO: getEnvVar('LOGGER_COLOR_INFO'),
230	LOGGER_COLOR_WARN: getEnvVar('LOGGER_COLOR_WARN'),
231	LOGGER_COLOR_ERROR: getEnvVar('LOGGER_COLOR_ERROR'),
232	LOGGER_ANSI_DEBUG: getEnvVar('LOGGER_ANSI_DEBUG'),
233	LOGGER_ANSI_INFO: getEnvVar('LOGGER_ANSI_INFO'),
234	LOGGER_ANSI_WARN: getEnvVar('LOGGER_ANSI_WARN'),
235	LOGGER_ANSI_ERROR: getEnvVar('LOGGER_ANSI_ERROR')
236	};
237	}
238
239
240
241	/**
242	* Get default colors enabled setting
243	*/
244	private getDefaultColorsEnabled(): boolean {
245	// Colors enabled in browser, or Node.js development
246	return this.environment.isBrowser \|\| this.environment.isDevelopment;	768✔
247	}
248
249	/**
250	* Get environment information
251	*/
252	getEnvironment(): Environment {
253	return { ...this.environment };	9✔
254	}
255	}
256
257	/**
258	* Load configuration from environment variables
259	* Utility function for creating loggers with env-based config
260	*/
261	export function loadConfigFromEnv(): PartialLoggerConfig {	39✔
262	const configManager = new ConfigManager();	×
263	return configManager.getConfig();	×
264	}

dev-ignis / cross-log / 16982792483

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous