@gguf/coder 0.3.0 → 0.3.1

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

@@ -0,0 +1,182 @@
+/**
+ * Tests for query builder
+ */
+
+import test from 'ava';
+import {LogQueryBuilder, createLogQuery} from './query-builder.js';
+
+test('LogQueryBuilder: creates empty query', t => {
+	const builder = new LogQueryBuilder();
+
+	const query = builder.toJSON();
+
+	t.deepEqual(query, {});
+});
+
+test('createLogQuery: creates new builder', t => {
+	const builder = createLogQuery();
+
+	t.true(builder instanceof LogQueryBuilder);
+});
+
+test('LogQueryBuilder: timeRange sets time filters', t => {
+	const start = new Date('2025-01-01T00:00:00Z');
+	const end = new Date('2025-01-02T00:00:00Z');
+
+	const query = createLogQuery().timeRange(start, end).toJSON();
+
+	t.is(query.startTime, start);
+	t.is(query.endTime, end);
+});
+
+test('LogQueryBuilder: levels sets level filter', t => {
+	const query = createLogQuery().levels('error', 'warn').toJSON();
+
+	t.deepEqual(query.levels, ['error', 'warn']);
+});
+
+test('LogQueryBuilder: excludeLevels sets exclude filter', t => {
+	const query = createLogQuery().excludeLevels('debug', 'trace').toJSON();
+
+	t.deepEqual(query.excludeLevels, ['debug', 'trace']);
+});
+
+test('LogQueryBuilder: messageContains sets message filter', t => {
+	const query = createLogQuery().messageContains('error').toJSON();
+
+	t.is(query.messageContains, 'error');
+});
+
+test('LogQueryBuilder: messageRegex sets regex filter', t => {
+	const regex = /error.*/i;
+	const query = createLogQuery().messageRegex(regex).toJSON();
+
+	t.is(query.messageRegex, regex);
+});
+
+test('LogQueryBuilder: correlationIds sets correlation filter', t => {
+	const query = createLogQuery().correlationIds('corr-1', 'corr-2').toJSON();
+
+	t.deepEqual(query.correlationIds, ['corr-1', 'corr-2']);
+});
+
+test('LogQueryBuilder: sources sets source filter', t => {
+	const query = createLogQuery().sources('api', 'db').toJSON();
+
+	t.deepEqual(query.sources, ['api', 'db']);
+});
+
+test('LogQueryBuilder: tags sets tag filter', t => {
+	const query = createLogQuery().tags('critical', 'security').toJSON();
+
+	t.deepEqual(query.tags, ['critical', 'security']);
+});
+
+test('LogQueryBuilder: hasTags sets hasTags flag', t => {
+	const query = createLogQuery().hasTags().toJSON();
+
+	t.true(query.hasTags);
+});
+
+test('LogQueryBuilder: limit sets pagination limit', t => {
+	const query = createLogQuery().limit(50).toJSON();
+
+	t.is(query.limit, 50);
+});
+
+test('LogQueryBuilder: offset sets pagination offset', t => {
+	const query = createLogQuery().offset(10).toJSON();
+
+	t.is(query.offset, 10);
+});
+
+test('LogQueryBuilder: sortBy sets sort field and order', t => {
+	const query = createLogQuery().sortBy('timestamp', 'asc').toJSON();
+
+	t.is(query.sortBy, 'timestamp');
+	t.is(query.sortOrder, 'asc');
+});
+
+test('LogQueryBuilder: sortBy defaults to desc order', t => {
+	const query = createLogQuery().sortBy('level').toJSON();
+
+	t.is(query.sortBy, 'level');
+	t.is(query.sortOrder, 'desc');
+});
+
+test('LogQueryBuilder: durationMin sets minimum duration', t => {
+	const query = createLogQuery().durationMin(1000).toJSON();
+
+	t.is(query.durationMin, 1000);
+});
+
+test('LogQueryBuilder: memoryThreshold sets memory filter', t => {
+	const query = createLogQuery().memoryThreshold(50000000).toJSON();
+
+	t.is(query.memoryThreshold, 50000000);
+});
+
+test('LogQueryBuilder: chains multiple methods', t => {
+	const query = createLogQuery()
+		.levels('error', 'warn')
+		.messageContains('database')
+		.sources('api-server')
+		.limit(25)
+		.sortBy('timestamp', 'desc')
+		.toJSON();
+
+	t.deepEqual(query.levels, ['error', 'warn']);
+	t.is(query.messageContains, 'database');
+	t.deepEqual(query.sources, ['api-server']);
+	t.is(query.limit, 25);
+	t.is(query.sortBy, 'timestamp');
+	t.is(query.sortOrder, 'desc');
+});
+
+test('LogQueryBuilder: toJSON returns copy of query', t => {
+	const builder = createLogQuery().levels('error');
+	const query1 = builder.toJSON();
+	const query2 = builder.toJSON();
+
+	t.not(query1, query2); // Different objects
+	t.deepEqual(query1, query2); // Same content
+});
+
+test('LogQueryBuilder: fluent API returns builder instance', t => {
+	const builder = createLogQuery();
+
+	const result = builder.levels('error');
+
+	t.is(result, builder);
+});
+
+test('LogQueryBuilder: complex query construction', t => {
+	const start = new Date('2025-01-01T00:00:00Z');
+	const end = new Date('2025-01-31T23:59:59Z');
+
+	const query = createLogQuery()
+		.timeRange(start, end)
+		.levels('error', 'fatal')
+		.messageContains('timeout')
+		.sources('api-server', 'worker-server')
+		.tags('critical')
+		.hasTags()
+		.durationMin(5000)
+		.sortBy('duration', 'desc')
+		.limit(10)
+		.offset(0)
+		.toJSON();
+
+	t.is(query.startTime, start);
+	t.is(query.endTime, end);
+	t.deepEqual(query.levels, ['error', 'fatal']);
+	t.is(query.messageContains, 'timeout');
+	t.deepEqual(query.sources, ['api-server', 'worker-server']);
+	t.deepEqual(query.tags, ['critical']);
+	t.true(query.hasTags);
+	t.is(query.durationMin, 5000);
+	t.is(query.sortBy, 'duration');
+	t.is(query.sortOrder, 'desc');
+	t.is(query.limit, 10);
+	t.is(query.offset, 0);
+});

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

@@ -0,0 +1,151 @@
+/**
+ * Fluent query builder for log queries
+ */
+
+import {globalLogStorage} from '../storage/log-storage';
+import type {LogQuery, QueryResult} from '../types';
+
+/**
+ * Log query builder for fluent query construction
+ */
+export class LogQueryBuilder {
+	private query: LogQuery = {};
+
+	/**
+	 * Set time range
+	 */
+	timeRange(startTime: Date, endTime: Date): this {
+		this.query.startTime = startTime;
+		this.query.endTime = endTime;
+		return this;
+	}
+
+	/**
+	 * Set log levels
+	 */
+	levels(...levels: string[]): this {
+		this.query.levels = levels;
+		return this;
+	}
+
+	/**
+	 * Exclude log levels
+	 */
+	excludeLevels(...levels: string[]): this {
+		this.query.excludeLevels = levels;
+		return this;
+	}
+
+	/**
+	 * Filter by message content
+	 */
+	messageContains(text: string): this {
+		this.query.messageContains = text;
+		return this;
+	}
+
+	/**
+	 * Filter by message regex
+	 */
+	messageRegex(regex: RegExp): this {
+		this.query.messageRegex = regex;
+		return this;
+	}
+
+	/**
+	 * Filter by correlation IDs
+	 */
+	correlationIds(...ids: string[]): this {
+		this.query.correlationIds = ids;
+		return this;
+	}
+
+	/**
+	 * Filter by sources
+	 */
+	sources(...sources: string[]): this {
+		this.query.sources = sources;
+		return this;
+	}
+
+	/**
+	 * Filter by tags
+	 */
+	tags(...tags: string[]): this {
+		this.query.tags = tags;
+		return this;
+	}
+
+	/**
+	 * Require tags
+	 */
+	hasTags(): this {
+		this.query.hasTags = true;
+		return this;
+	}
+
+	/**
+	 * Set pagination
+	 */
+	limit(limit: number): this {
+		this.query.limit = limit;
+		return this;
+	}
+
+	/**
+	 * Set offset
+	 */
+	offset(offset: number): this {
+		this.query.offset = offset;
+		return this;
+	}
+
+	/**
+	 * Set sorting
+	 */
+	sortBy(
+		field: 'timestamp' | 'level' | 'duration' | 'memory',
+		order: 'asc' | 'desc' = 'desc',
+	): this {
+		this.query.sortBy = field;
+		this.query.sortOrder = order;
+		return this;
+	}
+
+	/**
+	 * Filter by minimum performance duration
+	 */
+	durationMin(min: number): this {
+		this.query.durationMin = min;
+		return this;
+	}
+
+	/**
+	 * Filter by memory usage threshold
+	 */
+	memoryThreshold(threshold: number): this {
+		this.query.memoryThreshold = threshold;
+		return this;
+	}
+
+	/**
+	 * Execute the query
+	 */
+	execute(): QueryResult {
+		return globalLogStorage.query(this.query);
+	}
+
+	/**
+	 * Get query as JSON
+	 */
+	toJSON(): LogQuery {
+		return {...this.query};
+	}
+}
+
+/**
+ * Create a new log query builder
+ */
+export function createLogQuery(): LogQueryBuilder {
+	return new LogQueryBuilder();
+}

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

@@ -0,0 +1,214 @@
+/**
+ * Tests for query engine
+ */
+
+import test from 'ava';
+import {executeQuery} from './query-engine.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('executeQuery: returns all entries when no filters', t => {
+	const entries = [
+		createLogEntry({message: 'Entry 1'}),
+		createLogEntry({message: 'Entry 2'}),
+		createLogEntry({message: 'Entry 3'}),
+	];
+	const query: LogQuery = {};
+
+	const result = executeQuery(entries, query, entries.length);
+
+	t.is(result.entries.length, 3);
+	t.is(result.totalCount, 3);
+	t.is(result.filteredCount, 3);
+	t.false(result.hasMore);
+});
+
+test('executeQuery: filters by level', t => {
+	const entries = [
+		createLogEntry({level: 'error'}),
+		createLogEntry({level: 'info'}),
+		createLogEntry({level: 'error'}),
+	];
+	const query: LogQuery = {levels: ['error']};
+
+	const result = executeQuery(entries, query, entries.length);
+
+	t.is(result.entries.length, 2);
+	t.is(result.filteredCount, 2);
+	t.is(result.entries[0]?.level, 'error');
+	t.is(result.entries[1]?.level, 'error');
+});
+
+test('executeQuery: applies pagination', t => {
+	const entries = Array.from({length: 10}, (_, i) =>
+		createLogEntry({message: `Entry ${i}`}),
+	);
+	const query: LogQuery = {limit: 3, offset: 2};
+
+	const result = executeQuery(entries, query, entries.length);
+
+	t.is(result.entries.length, 3);
+	t.is(result.filteredCount, 10);
+	t.true(result.hasMore);
+	t.is(result.entries[0]?.message, 'Entry 2');
+	t.is(result.entries[1]?.message, 'Entry 3');
+	t.is(result.entries[2]?.message, 'Entry 4');
+});
+
+test('executeQuery: hasMore is false when all entries returned', t => {
+	const entries = Array.from({length: 5}, (_, i) =>
+		createLogEntry({message: `Entry ${i}`}),
+	);
+	const query: LogQuery = {limit: 10};
+
+	const result = executeQuery(entries, query, entries.length);
+
+	t.is(result.entries.length, 5);
+	t.false(result.hasMore);
+});
+
+test('executeQuery: hasMore is true when more entries available', t => {
+	const entries = Array.from({length: 10}, (_, i) =>
+		createLogEntry({message: `Entry ${i}`}),
+	);
+	const query: LogQuery = {limit: 5};
+
+	const result = executeQuery(entries, query, entries.length);
+
+	t.is(result.entries.length, 5);
+	t.true(result.hasMore);
+});
+
+test('executeQuery: sorts entries', 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 result = executeQuery(entries, query, entries.length);
+
+	t.is(result.entries[0]?.timestamp, '2025-01-01T00:00:00Z');
+	t.is(result.entries[1]?.timestamp, '2025-01-02T00:00:00Z');
+	t.is(result.entries[2]?.timestamp, '2025-01-03T00:00:00Z');
+});
+
+test('executeQuery: generates facets', t => {
+	const entries = [
+		createLogEntry({level: 'error', source: 'api'}),
+		createLogEntry({level: 'error', source: 'db'}),
+		createLogEntry({level: 'info', source: 'api'}),
+	];
+	const query: LogQuery = {};
+
+	const result = executeQuery(entries, query, entries.length);
+
+	t.truthy(result.facets);
+	t.is(result.facets?.levels.error, 2);
+	t.is(result.facets?.levels.info, 1);
+	t.is(result.facets?.sources.api, 2);
+	t.is(result.facets?.sources.db, 1);
+});
+
+test('executeQuery: facets reflect filtered results', t => {
+	const entries = [
+		createLogEntry({level: 'error', source: 'api'}),
+		createLogEntry({level: 'error', source: 'db'}),
+		createLogEntry({level: 'info', source: 'api'}),
+	];
+	const query: LogQuery = {levels: ['error']};
+
+	const result = executeQuery(entries, query, entries.length);
+
+	t.is(result.facets?.levels.error, 2);
+	t.is(result.facets?.levels.info, undefined); // Filtered out
+	t.is(result.facets?.sources.api, 1);
+	t.is(result.facets?.sources.db, 1);
+});
+
+test('executeQuery: measures query time', t => {
+	const entries = Array.from({length: 100}, (_, i) =>
+		createLogEntry({message: `Entry ${i}`}),
+	);
+	const query: LogQuery = {};
+
+	const result = executeQuery(entries, query, entries.length);
+
+	t.truthy(result.queryTime);
+	t.true(result.queryTime >= 0);
+});
+
+test('executeQuery: combines filter, sort, and pagination', t => {
+	const entries = [
+		createLogEntry({
+			level: 'error',
+			timestamp: '2025-01-03T00:00:00Z',
+			message: 'Error 3',
+		}),
+		createLogEntry({
+			level: 'error',
+			timestamp: '2025-01-01T00:00:00Z',
+			message: 'Error 1',
+		}),
+		createLogEntry({
+			level: 'info',
+			timestamp: '2025-01-02T00:00:00Z',
+			message: 'Info 2',
+		}),
+		createLogEntry({
+			level: 'error',
+			timestamp: '2025-01-02T00:00:00Z',
+			message: 'Error 2',
+		}),
+	];
+	const query: LogQuery = {
+		levels: ['error'],
+		sortBy: 'timestamp',
+		sortOrder: 'asc',
+		limit: 2,
+	};
+
+	const result = executeQuery(entries, query, entries.length);
+
+	t.is(result.entries.length, 2);
+	t.is(result.entries[0]?.message, 'Error 1');
+	t.is(result.entries[1]?.message, 'Error 2');
+	t.is(result.filteredCount, 3); // Total errors
+	t.true(result.hasMore); // Third error not included
+});
+
+test('executeQuery: default limit is 100', t => {
+	const entries = Array.from({length: 150}, (_, i) =>
+		createLogEntry({message: `Entry ${i}`}),
+	);
+	const query: LogQuery = {}; // No limit specified
+
+	const result = executeQuery(entries, query, entries.length);
+
+	t.is(result.entries.length, 100); // Default limit
+	t.true(result.hasMore);
+});
+
+test('executeQuery: totalCount reflects storage size', t => {
+	const entries = [
+		createLogEntry({level: 'error'}),
+		createLogEntry({level: 'info'}),
+	];
+	const query: LogQuery = {levels: ['error']};
+	const totalCount = 1000; // Storage has 1000 total entries
+
+	const result = executeQuery(entries, query, totalCount);
+
+	t.is(result.filteredCount, 1); // Filtered results
+	t.is(result.totalCount, 1000); // Total in storage
+});

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

@@ -0,0 +1,45 @@
+/**
+ * Query engine for executing log queries
+ */
+
+import {generateFacets} from '../aggregation/facet-generator';
+import type {LogEntry, LogQuery, QueryResult} from '../types';
+import {sortLogEntries} from '../utils/sorting';
+import {matchesQuery} from './filter-predicates';
+
+/**
+ * Execute a query against log entries
+ */
+export function executeQuery(
+	entries: LogEntry[],
+	query: LogQuery,
+	totalCount: number,
+): QueryResult {
+	const startTime = performance.now();
+
+	// Filter entries
+	const filteredEntries = entries.filter(entry => matchesQuery(entry, query));
+
+	// Apply sorting
+	const sortedEntries = sortLogEntries(filteredEntries, query);
+
+	// Apply pagination
+	const offset = query.offset || 0;
+	const limit = query.limit || 100;
+	const paginatedEntries = sortedEntries.slice(offset, offset + limit);
+
+	const queryTime = performance.now() - startTime;
+
+	// Generate facets
+	const filteredCount = filteredEntries.length;
+	const facets = generateFacets(filteredEntries);
+
+	return {
+		entries: paginatedEntries,
+		totalCount,
+		filteredCount,
+		queryTime,
+		hasMore: offset + limit < filteredEntries.length,
+		facets,
+	};
+}