@gguf/coder 0.3.1 → 0.3.2

package/source/utils/logging/log-query/utils/sorting.spec.ts

@@ -1,182 +0,0 @@
-/**
- * Tests for sorting utilities
- */
-
-import test from 'ava';
-import {getLevelPriority, getSortValue, sortLogEntries} from './sorting.js';
-import type {LogEntry, LogQuery} from '../types.js';
-
-// Helper to create test log entry
-function createLogEntry(overrides: Partial<LogEntry>): LogEntry {
-	return {
-		timestamp: new Date().toISOString(),
-		level: 'info',
-		message: 'Test message',
-		...overrides,
-	};
-}
-
-test('getLevelPriority: returns correct priorities', t => {
-	t.is(getLevelPriority('fatal'), 0);
-	t.is(getLevelPriority('error'), 1);
-	t.is(getLevelPriority('warn'), 2);
-	t.is(getLevelPriority('info'), 3);
-	t.is(getLevelPriority('http'), 4);
-	t.is(getLevelPriority('debug'), 5);
-	t.is(getLevelPriority('trace'), 6);
-});
-
-test('getLevelPriority: returns default for unknown level', t => {
-	t.is(getLevelPriority('unknown'), 6);
-	t.is(getLevelPriority('custom'), 6);
-});
-
-test('getSortValue: timestamp returns milliseconds', t => {
-	const timestamp = '2025-01-01T12:00:00Z';
-	const entry = createLogEntry({timestamp});
-
-	const value = getSortValue(entry, 'timestamp');
-
-	t.is(typeof value, 'number');
-	t.is(value, new Date(timestamp).getTime());
-});
-
-test('getSortValue: level returns priority number', t => {
-	const entry = createLogEntry({level: 'error'});
-
-	const value = getSortValue(entry, 'level');
-
-	t.is(value, 1); // error priority
-});
-
-test('getSortValue: duration returns performance duration', t => {
-	const entry = createLogEntry({
-		performance: {duration: 1500},
-	});
-
-	const value = getSortValue(entry, 'duration');
-
-	t.is(value, 1500);
-});
-
-test('getSortValue: duration returns 0 when missing', t => {
-	const entry = createLogEntry({});
-
-	const value = getSortValue(entry, 'duration');
-
-	t.is(value, 0);
-});
-
-test('getSortValue: memory returns heap used', t => {
-	const entry = createLogEntry({
-		performance: {memory: {heapUsed: 50000000}},
-	});
-
-	const value = getSortValue(entry, 'memory');
-
-	t.is(value, 50000000);
-});
-
-test('getSortValue: memory returns 0 when missing', t => {
-	const entry = createLogEntry({});
-
-	const value = getSortValue(entry, 'memory');
-
-	t.is(value, 0);
-});
-
-test('getSortValue: unknown sortBy returns 0', t => {
-	const entry = createLogEntry({});
-
-	const value = getSortValue(entry, 'unknown');
-
-	t.is(value, 0);
-});
-
-test('sortLogEntries: no sortBy returns original order', t => {
-	const entries = [
-		createLogEntry({message: '1'}),
-		createLogEntry({message: '2'}),
-		createLogEntry({message: '3'}),
-	];
-	const query: LogQuery = {};
-
-	const sorted = sortLogEntries([...entries], query);
-
-	t.deepEqual(sorted, entries);
-});
-
-test('sortLogEntries: timestamp ascending', t => {
-	const entries = [
-		createLogEntry({timestamp: '2025-01-03T00:00:00Z'}),
-		createLogEntry({timestamp: '2025-01-01T00:00:00Z'}),
-		createLogEntry({timestamp: '2025-01-02T00:00:00Z'}),
-	];
-	const query: LogQuery = {sortBy: 'timestamp', sortOrder: 'asc'};
-
-	const sorted = sortLogEntries([...entries], query);
-
-	t.is(sorted[0]?.timestamp, '2025-01-01T00:00:00Z');
-	t.is(sorted[1]?.timestamp, '2025-01-02T00:00:00Z');
-	t.is(sorted[2]?.timestamp, '2025-01-03T00:00:00Z');
-});
-
-test('sortLogEntries: timestamp descending', t => {
-	const entries = [
-		createLogEntry({timestamp: '2025-01-01T00:00:00Z'}),
-		createLogEntry({timestamp: '2025-01-03T00:00:00Z'}),
-		createLogEntry({timestamp: '2025-01-02T00:00:00Z'}),
-	];
-	const query: LogQuery = {sortBy: 'timestamp', sortOrder: 'desc'};
-
-	const sorted = sortLogEntries([...entries], query);
-
-	t.is(sorted[0]?.timestamp, '2025-01-03T00:00:00Z');
-	t.is(sorted[1]?.timestamp, '2025-01-02T00:00:00Z');
-	t.is(sorted[2]?.timestamp, '2025-01-01T00:00:00Z');
-});
-
-test('sortLogEntries: level ascending', t => {
-	const entries = [
-		createLogEntry({level: 'info'}),
-		createLogEntry({level: 'error'}),
-		createLogEntry({level: 'warn'}),
-	];
-	const query: LogQuery = {sortBy: 'level', sortOrder: 'asc'};
-
-	const sorted = sortLogEntries([...entries], query);
-
-	t.is(sorted[0]?.level, 'error'); // priority 1
-	t.is(sorted[1]?.level, 'warn'); // priority 2
-	t.is(sorted[2]?.level, 'info'); // priority 3
-});
-
-test('sortLogEntries: duration descending', t => {
-	const entries = [
-		createLogEntry({performance: {duration: 100}}),
-		createLogEntry({performance: {duration: 500}}),
-		createLogEntry({performance: {duration: 200}}),
-	];
-	const query: LogQuery = {sortBy: 'duration', sortOrder: 'desc'};
-
-	const sorted = sortLogEntries([...entries], query);
-
-	t.is(sorted[0]?.performance?.duration, 500);
-	t.is(sorted[1]?.performance?.duration, 200);
-	t.is(sorted[2]?.performance?.duration, 100);
-});
-
-test('sortLogEntries: memory ascending', t => {
-	const entries = [
-		createLogEntry({performance: {memory: {heapUsed: 3000000}}}),
-		createLogEntry({performance: {memory: {heapUsed: 1000000}}}),
-		createLogEntry({performance: {memory: {heapUsed: 2000000}}}),
-	];
-	const query: LogQuery = {sortBy: 'memory', sortOrder: 'asc'};
-
-	const sorted = sortLogEntries([...entries], query);
-
-	t.is(sorted[0]?.performance?.memory?.heapUsed, 1000000);
-	t.is(sorted[1]?.performance?.memory?.heapUsed, 2000000);
-	t.is(sorted[2]?.performance?.memory?.heapUsed, 3000000);
-});

package/source/utils/logging/log-query/utils/sorting.ts

@@ -1,61 +0,0 @@
-/**
- * Sorting utilities for log entries
- */
-
-import type {LogEntry, LogQuery} from '../types.js';
-
-/**
- * Get numeric value for sorting a log entry
- */
-// biome-ignore lint/suspicious/noExplicitAny: Dynamic sort value type
-export function getSortValue(entry: LogEntry, sortBy: string): any {
-	switch (sortBy) {
-		case 'timestamp':
-			return new Date(entry.timestamp).getTime();
-		case 'level':
-			return getLevelPriority(entry.level);
-		case 'duration':
-			return entry.performance?.duration || 0;
-		case 'memory':
-			return entry.performance?.memory?.heapUsed || 0;
-		default:
-			return 0;
-	}
-}
-
-/**
- * Get numeric priority for log level (for sorting)
- */
-export function getLevelPriority(level: string): number {
-	const priorities: Record<string, number> = {
-		fatal: 0,
-		error: 1,
-		warn: 2,
-		info: 3,
-		http: 4,
-		debug: 5,
-		trace: 6,
-	};
-	return priorities[level] ?? 6;
-}
-
-/**
- * Sort log entries based on query parameters
- */
-export function sortLogEntries(
-	entries: LogEntry[],
-	query: LogQuery,
-): LogEntry[] {
-	if (!query.sortBy) {
-		return entries;
-	}
-
-	return entries.sort((a, b) => {
-		// biome-ignore lint/style/noNonNullAssertion: sortBy guaranteed to exist in this block
-		const aValue = getSortValue(a, query.sortBy!);
-		// biome-ignore lint/style/noNonNullAssertion: sortBy guaranteed to exist in this block
-		const bValue = getSortValue(b, query.sortBy!);
-		const comparison = aValue < bValue ? -1 : aValue > bValue ? 1 : 0;
-		return query.sortOrder === 'desc' ? -comparison : comparison;
-	});
-}

package/source/utils/logging/logger-provider.spec.ts

@@ -1,262 +0,0 @@
-import test from 'ava';
-
-// Implementation imports
-import {LoggerProvider, loggerProvider} from './logger-provider.js';
-import type {LoggerConfig} from './types.js';
-
-test.beforeEach(() => {
-	// Reset the singleton instance before each test
-	const provider = LoggerProvider.getInstance();
-	provider.reset();
-	// Reset environment variables
-	delete process.env.NODE_ENV;
-	delete process.env.CODER_LOG_LEVEL;
-});
-
-test('LoggerProvider is a singleton', t => {
-	const provider1 = LoggerProvider.getInstance();
-	const provider2 = LoggerProvider.getInstance();
-
-	t.is(provider1, provider2, 'Should return the same instance');
-	t.true(provider1 instanceof LoggerProvider);
-});
-
-test('loggerProvider exports singleton instance', t => {
-	t.truthy(loggerProvider);
-	t.true(loggerProvider instanceof LoggerProvider);
-});
-
-test('initializeLogger creates logger with default config', t => {
-	const provider = LoggerProvider.getInstance();
-
-	const logger = provider.initializeLogger();
-
-	t.truthy(logger, 'Should create logger instance');
-	t.truthy(typeof logger.info === 'function', 'Should have info method');
-	t.truthy(typeof logger.error === 'function', 'Should have error method');
-	t.truthy(typeof logger.warn === 'function', 'Should have warn method');
-	t.truthy(typeof logger.debug === 'function', 'Should have debug method');
-	t.truthy(typeof logger.fatal === 'function', 'Should have fatal method');
-	t.truthy(typeof logger.trace === 'function', 'Should have trace method');
-	t.truthy(typeof logger.http === 'function', 'Should have http method');
-});
-
-test('initializeLogger uses provided config', t => {
-	const provider = LoggerProvider.getInstance();
-	const config: Partial<LoggerConfig> = {
-		level: 'error',
-		pretty: true,
-		correlation: false,
-	};
-
-	const logger = provider.initializeLogger(config);
-	const actualConfig = provider.getLoggerConfig();
-
-	if (actualConfig) {
-		t.is(actualConfig.level, 'error');
-		t.is(actualConfig.pretty, true);
-		t.is(actualConfig.correlation, false);
-	} else {
-		t.fail('Logger config should not be null');
-	}
-});
-
-test('initializeLogger returns same logger on subsequent calls', t => {
-	const provider = LoggerProvider.getInstance();
-
-	const logger1 = provider.initializeLogger();
-	const logger2 = provider.initializeLogger();
-
-	t.is(logger1, logger2, 'Should return the same logger instance');
-});
-
-test('getLogger auto-initializes if not initialized', t => {
-	const provider = LoggerProvider.getInstance();
-
-	const logger = provider.getLogger();
-
-	t.truthy(logger, 'Should auto-initialize and return logger');
-});
-
-test('getLogger returns existing logger if initialized', t => {
-	const provider = LoggerProvider.getInstance();
-
-	const logger1 = provider.initializeLogger({level: 'warn'});
-	const logger2 = provider.getLogger();
-
-	t.is(logger1, logger2, 'Should return the same initialized logger');
-});
-
-test('getLoggerConfig returns current configuration', t => {
-	const provider = LoggerProvider.getInstance();
-
-	// Should be null before initialization
-	t.is(provider.getLoggerConfig(), null);
-
-	const config: Partial<LoggerConfig> = {level: 'debug'};
-	provider.initializeLogger(config);
-
-	const actualConfig = provider.getLoggerConfig();
-	if (actualConfig) {
-		t.is(actualConfig.level, 'debug');
-	} else {
-		t.fail('Logger config should not be null');
-	}
-});
-
-test('createChildLogger creates child with bindings', t => {
-	const provider = LoggerProvider.getInstance();
-
-	provider.initializeLogger();
-
-	const bindings = {module: 'test', version: '1.0'};
-	const childLogger = provider.createChildLogger(bindings);
-
-	t.truthy(childLogger, 'Should create child logger');
-	t.truthy(
-		typeof childLogger.info === 'function',
-		'Child should have info method',
-	);
-	t.not(
-		childLogger === provider.getLogger(),
-		'Child should be different instance',
-	);
-});
-
-test('isLevelEnabled checks log level', t => {
-	const provider = LoggerProvider.getInstance();
-
-	provider.initializeLogger({level: 'warn'});
-
-	t.true(provider.isLevelEnabled('warn'), 'Should enable warn level');
-	t.true(provider.isLevelEnabled('error'), 'Should enable error level');
-	t.true(provider.isLevelEnabled('info'), 'Should enable info level');
-	t.true(provider.isLevelEnabled('fatal'), 'Should enable fatal level');
-	t.true(provider.isLevelEnabled('debug'), 'Should enable debug level');
-});
-
-test('reset clears all state', t => {
-	const provider = LoggerProvider.getInstance();
-
-	// Initialize and use provider
-	provider.initializeLogger({level: 'debug'});
-	t.truthy(provider.getLogger(), 'Should have logger after initialization');
-	t.truthy(
-		provider.getLoggerConfig(),
-		'Should have config after initialization',
-	);
-
-	// Reset
-	provider.reset();
-
-	t.is(provider.getLoggerConfig(), null, 'Config should be null after reset');
-
-	// Should be able to initialize again
-	const newLogger = provider.initializeLogger({level: 'error'});
-	t.truthy(newLogger, 'Should create new logger after reset');
-});
-
-test('flush and end work correctly', async t => {
-	const provider = LoggerProvider.getInstance();
-
-	provider.initializeLogger();
-
-	await t.notThrowsAsync(async () => {
-		await provider.flush();
-	}, 'Flush should complete without errors');
-
-	await t.notThrowsAsync(async () => {
-		await provider.end();
-	}, 'End should complete without errors');
-
-	// After end, logger should be null
-	t.is(provider.getLoggerConfig(), null);
-});
-
-test('createDefaultConfig handles environments correctly', t => {
-	const provider = LoggerProvider.getInstance();
-
-	// Test development environment
-	process.env.NODE_ENV = 'development';
-	provider.reset();
-	const devLogger = provider.initializeLogger();
-	const devConfig = provider.getLoggerConfig();
-	if (devConfig) {
-		t.is(devConfig.level, 'debug');
-		t.true(devConfig.pretty);
-	} else {
-		t.fail('Development config should not be null');
-	}
-
-	// Test production environment
-	process.env.NODE_ENV = 'production';
-	provider.reset();
-	const prodLogger = provider.initializeLogger();
-	const prodConfig = provider.getLoggerConfig();
-	if (prodConfig) {
-		t.is(prodConfig.level, 'silent');
-		t.false(prodConfig.pretty);
-	} else {
-		t.fail('Production config should not be null');
-	}
-
-	// Test environment
-	process.env.NODE_ENV = 'test';
-	provider.reset();
-	const testLogger = provider.initializeLogger();
-	const testConfig = provider.getLoggerConfig();
-	if (testConfig) {
-		t.is(testConfig.level, 'silent');
-	} else {
-		t.fail('Test config should not be null');
-	}
-});
-
-test('createDefaultConfig respects LOG_LEVEL environment variable', t => {
-	const provider = LoggerProvider.getInstance();
-
-	process.env.CODER_LOG_LEVEL = 'warn';
-	process.env.NODE_ENV = 'production';
-
-	provider.initializeLogger();
-	const config = provider.getLoggerConfig();
-
-	if (config) {
-		t.is(config.level, 'warn');
-	} else {
-		t.fail('Config should not be null');
-	}
-});
-
-test('multiple providers share singleton state', t => {
-	const provider1 = LoggerProvider.getInstance();
-	const provider2 = LoggerProvider.getInstance();
-
-	provider1.initializeLogger({level: 'error'});
-
-	// Both should return the same config
-	const config1 = provider1.getLoggerConfig();
-	const config2 = provider2.getLoggerConfig();
-
-	if (config1 && config2) {
-		t.is(config1.level, 'error');
-		t.is(config2.level, 'error');
-
-		// Reset should affect both
-		provider1.reset();
-		t.is(provider1.getLoggerConfig(), null);
-		t.is(provider2.getLoggerConfig(), null);
-	} else {
-		t.fail('Configs should not be null');
-	}
-});
-
-test('provider handles empty initializeLogger calls', t => {
-	const provider = LoggerProvider.getInstance();
-
-	// Should not throw when called with no arguments
-	t.notThrows(() => {
-		const logger = provider.initializeLogger();
-		t.truthy(logger);
-	});
-});