@libredb/studio 0.9.7

package/tests/unit/llm/streaming.test.ts

@@ -0,0 +1,355 @@
+import { describe, test, expect } from 'bun:test';
+import {
+  encodeText,
+  decodeText,
+  createSSEParser,
+  createErrorStream,
+} from '@/lib/llm/utils/streaming';
+
+// ============================================================================
+// Helper: read all chunks from a ReadableStream
+// ============================================================================
+
+async function readAllChunks(stream: ReadableStream<Uint8Array>): Promise<string> {
+  const reader = stream.getReader();
+  let result = '';
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    result += decodeText(value);
+  }
+  return result;
+}
+
+async function pipeSSE(input: string): Promise<string> {
+  const parser = createSSEParser();
+  const inputStream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      controller.enqueue(encodeText(input));
+      controller.close();
+    },
+  });
+  const outputStream = inputStream.pipeThrough(parser);
+  return readAllChunks(outputStream);
+}
+
+// ============================================================================
+// encodeText / decodeText
+// ============================================================================
+
+describe('encodeText', () => {
+  test('converts string to Uint8Array', () => {
+    const result = encodeText('hello');
+    expect(result).toBeInstanceOf(Uint8Array);
+    expect(result.length).toBeGreaterThan(0);
+  });
+});
+
+describe('decodeText', () => {
+  test('converts Uint8Array back to string', () => {
+    const bytes = new Uint8Array([104, 101, 108, 108, 111]); // "hello"
+    expect(decodeText(bytes)).toBe('hello');
+  });
+});
+
+describe('encodeText + decodeText roundtrip', () => {
+  test('roundtrip preserves the string', () => {
+    const original = 'Hello, World! 123 @#$';
+    const encoded = encodeText(original);
+    const decoded = decodeText(encoded);
+    expect(decoded).toBe(original);
+  });
+
+  test('roundtrip handles unicode characters', () => {
+    const original = 'Merhaba dunya';
+    const encoded = encodeText(original);
+    const decoded = decodeText(encoded);
+    expect(decoded).toBe(original);
+  });
+});
+
+// ============================================================================
+// createSSEParser
+// ============================================================================
+
+describe('createSSEParser', () => {
+  test('parses OpenAI-format SSE data line and extracts content', async () => {
+    const input = 'data: {"choices":[{"delta":{"content":"hello"}}]}\n\n';
+    const output = await pipeSSE(input);
+    expect(output).toBe('hello');
+  });
+
+  test('handles [DONE] marker without producing output', async () => {
+    const input = 'data: {"choices":[{"delta":{"content":"hi"}}]}\ndata: [DONE]\n\n';
+    const output = await pipeSSE(input);
+    expect(output).toBe('hi');
+  });
+
+  test('skips malformed JSON lines', async () => {
+    const input = 'data: not-valid-json\ndata: {"choices":[{"delta":{"content":"ok"}}]}\n\n';
+    const output = await pipeSSE(input);
+    expect(output).toBe('ok');
+  });
+
+  test('handles multiple data chunks and concatenates content', async () => {
+    const input = [
+      'data: {"choices":[{"delta":{"content":"Hello"}}]}',
+      'data: {"choices":[{"delta":{"content":" World"}}]}',
+      'data: [DONE]',
+      '',
+    ].join('\n');
+
+    const output = await pipeSSE(input);
+    expect(output).toBe('Hello World');
+  });
+
+  test('skips comment lines starting with ":"', async () => {
+    const input = [
+      ': this is a comment',
+      'data: {"choices":[{"delta":{"content":"content"}}]}',
+      '',
+    ].join('\n');
+
+    const output = await pipeSSE(input);
+    expect(output).toBe('content');
+  });
+
+  test('skips empty lines', async () => {
+    const input = [
+      '',
+      'data: {"choices":[{"delta":{"content":"value"}}]}',
+      '',
+      '',
+    ].join('\n');
+
+    const output = await pipeSSE(input);
+    expect(output).toBe('value');
+  });
+
+  test('skips data lines where delta has no content field', async () => {
+    const input = [
+      'data: {"choices":[{"delta":{}}]}',
+      'data: {"choices":[{"delta":{"content":"real"}}]}',
+      '',
+    ].join('\n');
+
+    const output = await pipeSSE(input);
+    expect(output).toBe('real');
+  });
+});
+
+// ============================================================================
+// createErrorStream
+// ============================================================================
+
+describe('createErrorStream', () => {
+  test('emits "Error: <message>" and closes', async () => {
+    const stream = createErrorStream('something went wrong');
+    const output = await readAllChunks(stream);
+    expect(output).toBe('Error: something went wrong');
+  });
+
+  test('stream is finite (closes after emitting)', async () => {
+    const stream = createErrorStream('test');
+    const reader = stream.getReader();
+
+    const first = await reader.read();
+    expect(first.done).toBe(false);
+    expect(decodeText(first.value!)).toBe('Error: test');
+
+    const second = await reader.read();
+    expect(second.done).toBe(true);
+  });
+});
+
+// ============================================================================
+// streamFromAsyncIterable
+// ============================================================================
+
+import {
+  streamFromAsyncIterable,
+  createStreamFromSSEResponse,
+  mergeStreams,
+} from '@/lib/llm/utils/streaming';
+
+describe('streamFromAsyncIterable', () => {
+  test('transforms async iterable items into stream chunks', async () => {
+    async function* generate() {
+      yield 'hello';
+      yield ' world';
+    }
+
+    const stream = streamFromAsyncIterable(generate(), (item) => encodeText(item));
+    const output = await readAllChunks(stream);
+    expect(output).toBe('hello world');
+  });
+
+  test('skips null transform results', async () => {
+    async function* generate() {
+      yield 'keep';
+      yield 'skip';
+      yield 'also-keep';
+    }
+
+    const stream = streamFromAsyncIterable(generate(), (item) =>
+      item === 'skip' ? null : encodeText(item)
+    );
+    const output = await readAllChunks(stream);
+    expect(output).toBe('keepalso-keep');
+  });
+
+  test('handles empty iterable', async () => {
+    async function* generate(): AsyncGenerator<string> {
+      // empty
+    }
+
+    const stream = streamFromAsyncIterable(generate(), (item) => encodeText(item));
+    const output = await readAllChunks(stream);
+    expect(output).toBe('');
+  });
+
+  test('handles error in iterable', async () => {
+    async function* generate() {
+      yield 'ok';
+      throw new Error('iteration error');
+    }
+
+    const stream = streamFromAsyncIterable(generate(), (item) => encodeText(item));
+    const reader = stream.getReader();
+
+    // First chunk should be 'ok'
+    const first = await reader.read();
+    expect(first.done).toBe(false);
+    expect(decodeText(first.value!)).toBe('ok');
+
+    // Next read should error
+    try {
+      await reader.read();
+      expect(true).toBe(false);
+    } catch (error) {
+      expect((error as Error).message).toBe('iteration error');
+    }
+  });
+});
+
+// ============================================================================
+// createStreamFromSSEResponse
+// ============================================================================
+
+describe('createStreamFromSSEResponse', () => {
+  test('parses SSE response body and extracts content', async () => {
+    const sseData = [
+      'data: {"choices":[{"delta":{"content":"Hello"}}]}\n\n',
+      'data: {"choices":[{"delta":{"content":" World"}}]}\n\n',
+      'data: [DONE]\n\n',
+    ].join('');
+
+    const body = new ReadableStream({
+      start(controller) {
+        controller.enqueue(encodeText(sseData));
+        controller.close();
+      },
+    });
+
+    const response = new Response(body);
+    const stream = createStreamFromSSEResponse(response, 'openai');
+    const output = await readAllChunks(stream);
+    expect(output).toBe('Hello World');
+  });
+
+  test('throws LLMStreamError when body is null', () => {
+    const response = new Response(null);
+    // Force body to be null
+    Object.defineProperty(response, 'body', { value: null });
+
+    expect(() => createStreamFromSSEResponse(response, 'openai')).toThrow(
+      'Response body is empty'
+    );
+  });
+});
+
+// ============================================================================
+// mergeStreams
+// ============================================================================
+
+describe('mergeStreams', () => {
+  test('merges multiple streams into one', async () => {
+    const stream1 = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(encodeText('Hello'));
+        controller.close();
+      },
+    });
+
+    const stream2 = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(encodeText(' World'));
+        controller.close();
+      },
+    });
+
+    const merged = mergeStreams([stream1, stream2]);
+    const output = await readAllChunks(merged);
+    expect(output).toBe('Hello World');
+  });
+
+  test('handles empty streams array', async () => {
+    const merged = mergeStreams([]);
+    const output = await readAllChunks(merged);
+    expect(output).toBe('');
+  });
+
+  test('handles single stream', async () => {
+    const stream = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(encodeText('only'));
+        controller.close();
+      },
+    });
+
+    const merged = mergeStreams([stream]);
+    const output = await readAllChunks(merged);
+    expect(output).toBe('only');
+  });
+
+  test('preserves order of streams', async () => {
+    const streams = ['first', 'second', 'third'].map(
+      (text) =>
+        new ReadableStream<Uint8Array>({
+          start(controller) {
+            controller.enqueue(encodeText(text));
+            controller.close();
+          },
+        })
+    );
+
+    const merged = mergeStreams(streams);
+    const output = await readAllChunks(merged);
+    expect(output).toBe('firstsecondthird');
+  });
+});
+
+// ============================================================================
+// SSE Parser flush behavior
+// ============================================================================
+
+describe('createSSEParser flush', () => {
+  test('flushes remaining buffered data', async () => {
+    // Send data without trailing newline — should be flushed
+    const input = 'data: {"choices":[{"delta":{"content":"flushed"}}]}';
+    const output = await pipeSSE(input);
+    expect(output).toBe('flushed');
+  });
+
+  test('flush ignores [DONE] in buffer', async () => {
+    const input = 'data: [DONE]';
+    const output = await pipeSSE(input);
+    expect(output).toBe('');
+  });
+
+  test('flush ignores malformed JSON in buffer', async () => {
+    const input = 'data: {invalid-json}';
+    const output = await pipeSSE(input);
+    expect(output).toBe('');
+  });
+});

package/tests/unit/logger.test.ts

@@ -0,0 +1,198 @@
+import '../setup';
+import { describe, test, expect, beforeEach, afterEach, spyOn } from 'bun:test';
+import type { Mock } from 'bun:test';
+import { logger } from '@/lib/logger';
+
+describe('logger', () => {
+  let debugSpy: Mock<typeof console.debug>;
+  let infoSpy: Mock<typeof console.info>;
+  let warnSpy: Mock<typeof console.warn>;
+  let errorSpy: Mock<typeof console.error>;
+  let savedLogLevel: string | undefined;
+
+  beforeEach(() => {
+    savedLogLevel = process.env.LOG_LEVEL;
+    delete process.env.LOG_LEVEL;
+    debugSpy = spyOn(console, 'debug').mockImplementation(() => {});
+    infoSpy = spyOn(console, 'info').mockImplementation(() => {});
+    warnSpy = spyOn(console, 'warn').mockImplementation(() => {});
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    debugSpy.mockRestore();
+    infoSpy.mockRestore();
+    warnSpy.mockRestore();
+    errorSpy.mockRestore();
+    if (savedLogLevel !== undefined) {
+      process.env.LOG_LEVEL = savedLogLevel;
+    } else {
+      delete process.env.LOG_LEVEL;
+    }
+  });
+
+  // ─── Basic logging calls ──────────────────────────────────────────────────
+
+  test('logger.debug() calls console.debug with correct format', () => {
+    logger.debug('hello debug');
+    expect(debugSpy).toHaveBeenCalledTimes(1);
+    const line = debugSpy.mock.calls[0][0] as string;
+    expect(line).toContain('[DEBUG]');
+    expect(line).toContain('hello debug');
+    // Should contain an ISO timestamp
+    expect(line).toMatch(/\[\d{4}-\d{2}-\d{2}T/);
+  });
+
+  test('logger.info() calls console.info with correct format', () => {
+    logger.info('hello info');
+    expect(infoSpy).toHaveBeenCalledTimes(1);
+    const line = infoSpy.mock.calls[0][0] as string;
+    expect(line).toContain('[INFO ]');
+    expect(line).toContain('hello info');
+  });
+
+  test('logger.warn() calls console.warn with correct format', () => {
+    logger.warn('hello warn');
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    const line = warnSpy.mock.calls[0][0] as string;
+    expect(line).toContain('[WARN ]');
+    expect(line).toContain('hello warn');
+  });
+
+  test('logger.error() calls console.error with error info extracted', () => {
+    const err = new TypeError('something broke');
+    logger.error('failure', err);
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+    const line = errorSpy.mock.calls[0][0] as string;
+    expect(line).toContain('[ERROR]');
+    expect(line).toContain('failure');
+    expect(line).toContain('TypeError');
+    expect(line).toContain('something broke');
+  });
+
+  // ─── Level filtering ──────────────────────────────────────────────────────
+
+  test('when LOG_LEVEL=warn, debug and info should not log', () => {
+    process.env.LOG_LEVEL = 'warn';
+    logger.debug('should not appear');
+    logger.info('should not appear either');
+    logger.warn('should appear');
+    logger.error('should also appear');
+
+    expect(debugSpy).toHaveBeenCalledTimes(0);
+    expect(infoSpy).toHaveBeenCalledTimes(0);
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+  });
+
+  test('when LOG_LEVEL=error, only error should log', () => {
+    process.env.LOG_LEVEL = 'error';
+    logger.debug('nope');
+    logger.info('nope');
+    logger.warn('nope');
+    logger.error('yes');
+
+    expect(debugSpy).toHaveBeenCalledTimes(0);
+    expect(infoSpy).toHaveBeenCalledTimes(0);
+    expect(warnSpy).toHaveBeenCalledTimes(0);
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+  });
+
+  test('when LOG_LEVEL=debug, all levels should log', () => {
+    process.env.LOG_LEVEL = 'debug';
+    logger.debug('d');
+    logger.info('i');
+    logger.warn('w');
+    logger.error('e');
+
+    expect(debugSpy).toHaveBeenCalledTimes(1);
+    expect(infoSpy).toHaveBeenCalledTimes(1);
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+  });
+
+  // ─── Context formatting ───────────────────────────────────────────────────
+
+  test('context formatting: route appears in output', () => {
+    logger.info('request', { route: '/api/db/query' });
+    const line = infoSpy.mock.calls[0][0] as string;
+    expect(line).toContain('route=/api/db/query');
+  });
+
+  test('context formatting: provider appears in output', () => {
+    logger.info('connecting', { provider: 'postgres' });
+    const line = infoSpy.mock.calls[0][0] as string;
+    expect(line).toContain('provider=postgres');
+  });
+
+  test('context formatting: connectionId appears in output', () => {
+    logger.info('connected', { connectionId: 'abc-123' });
+    const line = infoSpy.mock.calls[0][0] as string;
+    expect(line).toContain('connId=abc-123');
+  });
+
+  test('context formatting: duration appears in output', () => {
+    logger.info('query done', { duration: 42 });
+    const line = infoSpy.mock.calls[0][0] as string;
+    expect(line).toContain('duration=42ms');
+  });
+
+  test('context formatting: all fields appear together', () => {
+    logger.info('full context', {
+      route: '/api/db/query',
+      provider: 'mysql',
+      connectionId: 'conn-1',
+      duration: 100,
+    });
+    const line = infoSpy.mock.calls[0][0] as string;
+    expect(line).toContain('route=/api/db/query');
+    expect(line).toContain('provider=mysql');
+    expect(line).toContain('connId=conn-1');
+    expect(line).toContain('duration=100ms');
+  });
+
+  test('context formatting: extra keys are included', () => {
+    logger.info('extra', { route: '/test', customKey: 'customVal' });
+    const line = infoSpy.mock.calls[0][0] as string;
+    expect(line).toContain('customKey=customVal');
+  });
+
+  // ─── Error extraction ─────────────────────────────────────────────────────
+
+  test('error extraction: Error name and message appear in output', () => {
+    const err = new RangeError('out of bounds');
+    logger.error('bad range', err);
+    const line = errorSpy.mock.calls[0][0] as string;
+    expect(line).toContain('RangeError');
+    expect(line).toContain('out of bounds');
+  });
+
+  test('non-Error argument to logger.error() is stringified', () => {
+    logger.error('weird error', 'just a string');
+    const line = errorSpy.mock.calls[0][0] as string;
+    expect(line).toContain('Unknown');
+    expect(line).toContain('just a string');
+  });
+
+  test('non-Error object argument to logger.error() is stringified', () => {
+    logger.error('object error', { code: 42 });
+    const line = errorSpy.mock.calls[0][0] as string;
+    expect(line).toContain('Unknown');
+    expect(line).toContain('[object Object]');
+  });
+
+  test('logger.error() with no error argument does not include error info', () => {
+    logger.error('simple error');
+    const line = errorSpy.mock.calls[0][0] as string;
+    expect(line).toContain('[ERROR]');
+    expect(line).toContain('simple error');
+    // No error info pipe separator
+    expect(line).not.toContain(' | ');
+  });
+
+  test('logger.error() with null error does not include error info', () => {
+    logger.error('null error', null);
+    const line = errorSpy.mock.calls[0][0] as string;
+    expect(line).not.toContain(' | ');
+  });
+});