@libredb/studio 0.9.7

package/tests/unit/mongodb-completions.test.ts

@@ -0,0 +1,516 @@
+import '../setup';
+import { describe, test, expect } from 'bun:test';
+import type * as Monaco from 'monaco-editor';
+import { registerMongoDBCompletionProvider } from '@/lib/editor/mongodb-completions';
+import type { SchemaCompletionCache } from '@/lib/editor/sql-completions';
+
+// ---------------------------------------------------------------------------
+// Mock Monaco
+// ---------------------------------------------------------------------------
+
+function createMockMonaco() {
+  let registeredProvider: {
+    triggerCharacters: string[];
+    provideCompletionItems: (
+      model: Monaco.editor.ITextModel,
+      position: Monaco.Position
+    ) => { suggestions: Monaco.languages.CompletionItem[] };
+  } | null = null;
+
+  const mockMonaco = {
+    languages: {
+      registerCompletionItemProvider: (_lang: string, provider: typeof registeredProvider) => {
+        registeredProvider = provider;
+        return { dispose: () => { registeredProvider = null; } };
+      },
+      CompletionItemKind: {
+        Keyword: 17,
+        Enum: 14,
+        Class: 5,
+        Field: 3,
+        Snippet: 27,
+      },
+      CompletionItemInsertTextRule: {
+        InsertAsSnippet: 4,
+      },
+    },
+    _getProvider: () => registeredProvider,
+  };
+
+  return mockMonaco as unknown as typeof Monaco & { _getProvider: () => typeof registeredProvider };
+}
+
+function createMockModel(lineContent: string, fullText?: string) {
+  return {
+    getWordUntilPosition: (position: { column: number }) => {
+      const before = lineContent.substring(0, position.column - 1);
+      const match = before.match(/(\w[$\w]*)$/);
+      return {
+        word: match ? match[1] : '',
+        startColumn: match ? position.column - match[1].length : position.column,
+        endColumn: position.column,
+      };
+    },
+    getLineContent: () => lineContent,
+    getValue: () => fullText ?? lineContent,
+  } as unknown as Monaco.editor.ITextModel;
+}
+
+function createPosition(line: number, col: number) {
+  return { lineNumber: line, column: col } as Monaco.Position;
+}
+
+function createSchemaCache(): SchemaCompletionCache {
+  const columnMap = new Map();
+  columnMap.set('users', [
+    { label: '_id', labelLower: '_id', type: 'ObjectId', isPrimary: true, tableName: 'users' },
+    { label: 'name', labelLower: 'name', type: 'string', isPrimary: false, tableName: 'users' },
+    { label: 'email', labelLower: 'email', type: 'string', isPrimary: false, tableName: 'users' },
+  ]);
+  columnMap.set('orders', [
+    { label: '_id', labelLower: '_id', type: 'ObjectId', isPrimary: true, tableName: 'orders' },
+    { label: 'total', labelLower: 'total', type: 'number', isPrimary: false, tableName: 'orders' },
+  ]);
+
+  const allColumns = new Map();
+  for (const [, cols] of columnMap) {
+    for (const col of cols) {
+      allColumns.set(col.label, col);
+    }
+  }
+
+  return {
+    tableItems: [
+      { label: 'users', labelLower: 'users', rowCount: 100, columnNames: '_id, name, email' },
+      { label: 'orders', labelLower: 'orders', rowCount: 500, columnNames: '_id, total' },
+    ],
+    columnMap,
+    allColumns,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Registration
+// ---------------------------------------------------------------------------
+
+describe('registerMongoDBCompletionProvider', () => {
+  test('registers provider for json language and returns disposable', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    const disposable = registerMongoDBCompletionProvider(monaco, cache);
+    expect(disposable).toBeDefined();
+    expect(typeof disposable.dispose).toBe('function');
+    expect(monaco._getProvider()).not.toBeNull();
+  });
+
+  test('dispose removes the provider', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    const disposable = registerMongoDBCompletionProvider(monaco, cache);
+    disposable.dispose();
+    expect(monaco._getProvider()).toBeNull();
+  });
+
+  test('sets trigger characters to quote, dollar, colon', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+    expect(provider.triggerCharacters).toEqual(['"', '$', ':']);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// MQL Operators (after "$")
+// ---------------------------------------------------------------------------
+
+describe('MQL operator completions', () => {
+  test('suggests MQL operators when text contains $', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+
+    const model = createMockModel('  "$', '{ "filter": { "$" } }');
+    const position = createPosition(1, 5);
+    const result = provider.provideCompletionItems(model, position);
+
+    const labels = result.suggestions.map(s => s.label);
+    expect(labels).toContain('$match');
+    expect(labels).toContain('$eq');
+    expect(labels).toContain('$gt');
+    expect(labels).toContain('$sum');
+    expect(labels).toContain('$set');
+  });
+
+  test('MQL operators have Keyword kind and correct detail', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+
+    const model = createMockModel('  "$match', '{ "$match": {} }');
+    const position = createPosition(1, 10);
+    const result = provider.provideCompletionItems(model, position);
+
+    const matchSugg = result.suggestions.find(s => s.label === '$match');
+    expect(matchSugg).toBeDefined();
+    expect(matchSugg!.kind).toBe(17); // Keyword
+    expect((matchSugg as unknown as { detail: string }).detail).toBe('MQL Operator');
+  });
+
+  test('word starting with $ triggers MQL operators', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+
+    // getWordUntilPosition returns "$gr" — starts with $
+    const model = {
+      getWordUntilPosition: () => ({ word: '$gr', startColumn: 3, endColumn: 6 }),
+      getLineContent: () => '  $gr',
+      getValue: () => '  $gr',
+    } as unknown as Monaco.editor.ITextModel;
+
+    const position = createPosition(1, 6);
+    const result = provider.provideCompletionItems(model, position);
+
+    const labels = result.suggestions.map(s => s.label);
+    expect(labels).toContain('$group');
+    expect(labels).toContain('$gt');
+    expect(labels).toContain('$gte');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Operation names (after "operation": ")
+// ---------------------------------------------------------------------------
+
+describe('Operation name completions', () => {
+  test('suggests operations after "operation": "', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+
+    const model = createMockModel('  "operation": "fi', '{ "operation": "fi" }');
+    const position = createPosition(1, 19);
+    const result = provider.provideCompletionItems(model, position);
+
+    const labels = result.suggestions.map(s => s.label);
+    expect(labels).toContain('find');
+    expect(labels).toContain('findOne');
+    expect(labels).toContain('aggregate');
+    expect(labels).toContain('insertOne');
+    expect(labels).toContain('deleteMany');
+  });
+
+  test('operation suggestions have Enum kind', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+
+    const model = createMockModel('  "operation": "', '{ "operation": "" }');
+    const position = createPosition(1, 17);
+    const result = provider.provideCompletionItems(model, position);
+
+    const findSugg = result.suggestions.find(s => s.label === 'find');
+    expect(findSugg).toBeDefined();
+    expect(findSugg!.kind).toBe(14); // Enum
+    expect((findSugg as unknown as { detail: string }).detail).toBe('MongoDB Operation');
+  });
+
+  test('does not suggest operations without "operation" key context', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+
+    const model = createMockModel('  "filter": "', '{ "filter": "" }');
+    const position = createPosition(1, 14);
+    const result = provider.provideCompletionItems(model, position);
+
+    const labels = result.suggestions.map(s => s.label);
+    expect(labels).not.toContain('find');
+    expect(labels).not.toContain('aggregate');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Collection names (after "collection": ")
+// ---------------------------------------------------------------------------
+
+describe('Collection name completions', () => {
+  test('suggests collections after "collection": "', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+
+    const model = createMockModel('  "collection": "', '{ "collection": "" }');
+    const position = createPosition(1, 18);
+    const result = provider.provideCompletionItems(model, position);
+
+    const labels = result.suggestions.map(s => s.label);
+    expect(labels).toContain('users');
+    expect(labels).toContain('orders');
+  });
+
+  test('collection suggestions show doc count and have Class kind', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+
+    const model = createMockModel('  "collection": "', '{ "collection": "" }');
+    const position = createPosition(1, 18);
+    const result = provider.provideCompletionItems(model, position);
+
+    const usersSugg = result.suggestions.find(s => s.label === 'users');
+    expect(usersSugg).toBeDefined();
+    expect(usersSugg!.kind).toBe(5); // Class
+    expect((usersSugg as unknown as { detail: string }).detail).toBe('Collection (100 docs)');
+  });
+
+  test('does not suggest collections outside "collection" key context', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+
+    const model = createMockModel('  "filter": "', '{ "filter": "" }');
+    const position = createPosition(1, 14);
+    const result = provider.provideCompletionItems(model, position);
+
+    const kinds = result.suggestions.map(s => s.kind);
+    // No Class items (collections)
+    expect(kinds).not.toContain(5);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Field name completions
+// ---------------------------------------------------------------------------
+
+describe('Field name completions', () => {
+  test('suggests field names inside quoted string context', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+
+    // Inside filter: { "na
+    const model = createMockModel('    "na', '{ "filter": { "na" } }');
+    const position = createPosition(1, 8);
+    const result = provider.provideCompletionItems(model, position);
+
+    const labels = result.suggestions.map(s => s.label);
+    expect(labels).toContain('_id');
+    expect(labels).toContain('name');
+    expect(labels).toContain('email');
+    expect(labels).toContain('total');
+  });
+
+  test('field suggestions have Field kind and show type', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+
+    const model = createMockModel('    "na', '{ "filter": { "na" } }');
+    const position = createPosition(1, 8);
+    const result = provider.provideCompletionItems(model, position);
+
+    const nameSugg = result.suggestions.find(s => s.label === 'name');
+    expect(nameSugg).toBeDefined();
+    expect(nameSugg!.kind).toBe(3); // Field
+    expect((nameSugg as unknown as { detail: string }).detail).toBe('Field (string)');
+  });
+
+  test('does not suggest fields in "collection": context', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+
+    const model = createMockModel('  "collection": "us', '{ "collection": "us" }');
+    const position = createPosition(1, 20);
+    const result = provider.provideCompletionItems(model, position);
+
+    const fieldSuggs = result.suggestions.filter(s => s.kind === 3);
+    expect(fieldSuggs.length).toBe(0);
+  });
+
+  test('does not suggest fields in "operation": context', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+
+    const model = createMockModel('  "operation": "fi', '{ "operation": "fi" }');
+    const position = createPosition(1, 19);
+    const result = provider.provideCompletionItems(model, position);
+
+    const fieldSuggs = result.suggestions.filter(s => s.kind === 3);
+    expect(fieldSuggs.length).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Snippet completions
+// ---------------------------------------------------------------------------
+
+describe('Snippet completions', () => {
+  test('suggests snippets when editor is nearly empty', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+
+    const model = createMockModel('', '');
+    const position = createPosition(1, 1);
+    const result = provider.provideCompletionItems(model, position);
+
+    const snippetSuggs = result.suggestions.filter(s => s.kind === 27);
+    expect(snippetSuggs.length).toBe(7);
+
+    const labels = snippetSuggs.map(s => s.label);
+    expect(labels).toContain('find');
+    expect(labels).toContain('findOne');
+    expect(labels).toContain('aggregate');
+    expect(labels).toContain('count');
+    expect(labels).toContain('insertOne');
+    expect(labels).toContain('updateOne');
+    expect(labels).toContain('deleteMany');
+  });
+
+  test('suggests snippets when cursor at line start', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+
+    // textBefore is whitespace-only → matches /^\s*$/
+    const model = createMockModel('  ', '{ "collection": "users" }\n  ');
+    const position = createPosition(1, 3);
+    const result = provider.provideCompletionItems(model, position);
+
+    const snippetSuggs = result.suggestions.filter(s => s.kind === 27);
+    expect(snippetSuggs.length).toBe(7);
+  });
+
+  test('snippets have InsertAsSnippet rule and correct detail', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+
+    const model = createMockModel('', '');
+    const position = createPosition(1, 1);
+    const result = provider.provideCompletionItems(model, position);
+
+    const findSnippet = result.suggestions.find(s => s.label === 'find' && s.kind === 27);
+    expect(findSnippet).toBeDefined();
+    expect(findSnippet!.insertTextRules).toBe(4); // InsertAsSnippet
+    expect((findSnippet as unknown as { detail: string }).detail).toBe('Find documents');
+  });
+
+  test('snippets contain template placeholders', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+
+    const model = createMockModel('', '');
+    const position = createPosition(1, 1);
+    const result = provider.provideCompletionItems(model, position);
+
+    const snippetSuggs = result.suggestions.filter(s => s.kind === 27);
+    for (const snippet of snippetSuggs) {
+      expect((snippet.insertText as string)).toContain('${1:collection}');
+    }
+  });
+
+  test('does not suggest snippets when editor has substantial content', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+
+    // fullText > 5 chars and textBefore is not whitespace-only
+    const model = createMockModel('  "filter": {', '{ "collection": "users", "operation": "find", "filter": { } }');
+    const position = createPosition(1, 14);
+    const result = provider.provideCompletionItems(model, position);
+
+    const snippetSuggs = result.suggestions.filter(s => s.kind === 27);
+    expect(snippetSuggs.length).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Sort order
+// ---------------------------------------------------------------------------
+
+describe('Sort order', () => {
+  test('operators and operations sort before fields', () => {
+    const monaco = createMockMonaco();
+    const cache = createSchemaCache();
+    registerMongoDBCompletionProvider(monaco, cache);
+    const provider = monaco._getProvider()!;
+
+    // Context that triggers both operators and fields: "$
+    const model = createMockModel('    "$', '{ "filter": { "$" } }');
+    const position = createPosition(1, 7);
+    const result = provider.provideCompletionItems(model, position);
+
+    const operatorSugg = result.suggestions.find(s => s.label === '$match');
+    const fieldSugg = result.suggestions.find(s => s.label === 'name');
+    expect(operatorSugg?.sortText?.startsWith('0')).toBe(true);
+    expect(fieldSugg?.sortText?.startsWith('2')).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Empty schema cache
+// ---------------------------------------------------------------------------
+
+describe('Empty schema cache', () => {
+  test('works with empty schema cache', () => {
+    const monaco = createMockMonaco();
+    const emptyCache: SchemaCompletionCache = {
+      tableItems: [],
+      columnMap: new Map(),
+      allColumns: new Map(),
+    };
+    registerMongoDBCompletionProvider(monaco, emptyCache);
+    const provider = monaco._getProvider()!;
+
+    // Trigger $ operators — should still work
+    const model = createMockModel('  "$', '{ "$" }');
+    const position = createPosition(1, 5);
+    const result = provider.provideCompletionItems(model, position);
+
+    const labels = result.suggestions.map(s => s.label);
+    expect(labels).toContain('$match');
+    expect(labels).toContain('$group');
+  });
+
+  test('collection context with empty cache returns no collections', () => {
+    const monaco = createMockMonaco();
+    const emptyCache: SchemaCompletionCache = {
+      tableItems: [],
+      columnMap: new Map(),
+      allColumns: new Map(),
+    };
+    registerMongoDBCompletionProvider(monaco, emptyCache);
+    const provider = monaco._getProvider()!;
+
+    const model = createMockModel('  "collection": "', '{ "collection": "" }');
+    const position = createPosition(1, 18);
+    const result = provider.provideCompletionItems(model, position);
+
+    const classSuggs = result.suggestions.filter(s => s.kind === 5);
+    expect(classSuggs.length).toBe(0);
+  });
+});

package/tests/unit/pivot-table-functions.test.ts

@@ -0,0 +1,76 @@
+import { describe, test, expect } from 'bun:test';
+import { aggregate } from '@/components/PivotTable';
+
+describe('aggregate', () => {
+  test('count returns length of values array', () => {
+    expect(aggregate([1, 2, 3], 'count')).toBe('3');
+  });
+
+  test('count with mixed types', () => {
+    expect(aggregate([1, 'a', null, undefined], 'count')).toBe('4');
+  });
+
+  test('count with empty array', () => {
+    expect(aggregate([], 'count')).toBe('0');
+  });
+
+  test('sum of numbers', () => {
+    expect(aggregate([10, 20, 30], 'sum')).toBe('60.00');
+  });
+
+  test('sum with non-numeric values filtered', () => {
+    expect(aggregate([10, 'abc', 20], 'sum')).toBe('30.00');
+  });
+
+  test('sum with all non-numeric returns 0', () => {
+    expect(aggregate(['abc', 'def'], 'sum')).toBe('0');
+  });
+
+  test('sum with empty array returns 0', () => {
+    expect(aggregate([], 'sum')).toBe('0');
+  });
+
+  test('avg of numbers', () => {
+    expect(aggregate([10, 20, 30], 'avg')).toBe('20.00');
+  });
+
+  test('avg with non-numeric filtered', () => {
+    expect(aggregate([10, 'abc', 30], 'avg')).toBe('20.00');
+  });
+
+  test('avg with all non-numeric returns 0', () => {
+    expect(aggregate(['abc'], 'avg')).toBe('0');
+  });
+
+  test('min of numbers', () => {
+    expect(aggregate([30, 10, 20], 'min')).toBe('10');
+  });
+
+  test('min with negatives', () => {
+    expect(aggregate([-5, 0, 5], 'min')).toBe('-5');
+  });
+
+  test('min with all non-numeric returns dash', () => {
+    expect(aggregate(['abc'], 'min')).toBe('-');
+  });
+
+  test('max of numbers', () => {
+    expect(aggregate([30, 10, 20], 'max')).toBe('30');
+  });
+
+  test('max with negatives', () => {
+    expect(aggregate([-5, 0, 5], 'max')).toBe('5');
+  });
+
+  test('max with all non-numeric returns dash', () => {
+    expect(aggregate(['abc'], 'max')).toBe('-');
+  });
+
+  test('sum with decimal values', () => {
+    expect(aggregate([1.5, 2.5], 'sum')).toBe('4.00');
+  });
+
+  test('avg of single value', () => {
+    expect(aggregate([42], 'avg')).toBe('42.00');
+  });
+});

package/tests/unit/query-cancelled-error.test.ts

@@ -0,0 +1,81 @@
+import '../setup';
+import { describe, test, expect } from 'bun:test';
+import {
+  DatabaseError,
+  QueryCancelledError,
+  isQueryCancelledError,
+  mapDatabaseError,
+  TimeoutError,
+} from '@/lib/db/errors';
+
+describe('QueryCancelledError', () => {
+  test('has correct name, code, provider, and query', () => {
+    const err = new QueryCancelledError('Query was cancelled', 'postgres', 'SELECT 1');
+    expect(err.name).toBe('QueryCancelledError');
+    expect(err.code).toBe('QUERY_CANCELLED');
+    expect(err.provider).toBe('postgres');
+    expect(err.query).toBe('SELECT 1');
+    expect(err.message).toBe('Query was cancelled');
+    expect(err).toBeInstanceOf(Error);
+  });
+
+  test('is an instance of DatabaseError', () => {
+    const err = new QueryCancelledError('cancelled', 'mysql');
+    expect(err).toBeInstanceOf(DatabaseError);
+  });
+});
+
+describe('isQueryCancelledError', () => {
+  test('returns true for QueryCancelledError', () => {
+    const err = new QueryCancelledError('cancelled', 'postgres');
+    expect(isQueryCancelledError(err)).toBe(true);
+  });
+
+  test('returns false for a generic Error', () => {
+    expect(isQueryCancelledError(new Error('not cancelled'))).toBe(false);
+  });
+
+  test('returns false for a non-Error', () => {
+    expect(isQueryCancelledError('string')).toBe(false);
+    expect(isQueryCancelledError(null)).toBe(false);
+    expect(isQueryCancelledError(undefined)).toBe(false);
+  });
+});
+
+describe('mapDatabaseError — cancellation patterns', () => {
+  test('returns QueryCancelledError for "canceling statement" message', () => {
+    const native = new Error('ERROR: canceling statement due to user request');
+    const mapped = mapDatabaseError(native, 'postgres', 'SELECT pg_sleep(100)');
+    expect(mapped).toBeInstanceOf(QueryCancelledError);
+    expect(mapped.message).toBe('Query was cancelled');
+    expect(mapped.provider).toBe('postgres');
+  });
+
+  test('returns QueryCancelledError for "Query execution was interrupted" message', () => {
+    const native = new Error('Query execution was interrupted');
+    const mapped = mapDatabaseError(native, 'mysql', 'SELECT SLEEP(100)');
+    expect(mapped).toBeInstanceOf(QueryCancelledError);
+    expect(mapped.message).toBe('Query was cancelled');
+  });
+
+  test('returns QueryCancelledError for "query was cancelled" message', () => {
+    const native = new Error('The query was cancelled by the user');
+    const mapped = mapDatabaseError(native, 'postgres');
+    expect(mapped).toBeInstanceOf(QueryCancelledError);
+  });
+
+  test('returns TimeoutError for "timeout" (not cancelled)', () => {
+    const native = new Error('Connection timeout expired');
+    const mapped = mapDatabaseError(native, 'postgres');
+    expect(mapped).toBeInstanceOf(TimeoutError);
+    expect(mapped).not.toBeInstanceOf(QueryCancelledError);
+    expect(mapped.message).toContain('timeout');
+  });
+
+  test('returns TimeoutError for "timed out" (not cancelled)', () => {
+    const native = new Error('Query timed out after 30s');
+    const mapped = mapDatabaseError(native, 'mysql');
+    expect(mapped).toBeInstanceOf(TimeoutError);
+    expect(mapped).not.toBeInstanceOf(QueryCancelledError);
+  });
+});