@libredb/studio 0.9.7

package/tests/unit/data-import-functions.test.ts

@@ -0,0 +1,320 @@
+import '../setup';
+import { describe, test, expect } from 'bun:test';
+import {
+  parseCSV,
+  parseJSON,
+  inferSqlType,
+  escapeSQL,
+  generateImportSQL,
+  type ParsedData,
+} from '@/components/DataImportModal';
+
+// ---------------------------------------------------------------------------
+// parseCSV
+// ---------------------------------------------------------------------------
+
+describe('parseCSV', () => {
+  test('parses simple CSV', () => {
+    const result = parseCSV('name,age\nAlice,30\nBob,25');
+    expect(result.headers).toEqual(['name', 'age']);
+    expect(result.rows).toEqual([['Alice', '30'], ['Bob', '25']]);
+    expect(result.totalRows).toBe(2);
+  });
+
+  test('returns empty for empty input', () => {
+    const result = parseCSV('');
+    expect(result.headers).toEqual([]);
+    expect(result.rows).toEqual([]);
+    expect(result.totalRows).toBe(0);
+  });
+
+  test('returns empty for whitespace-only input', () => {
+    const result = parseCSV('  \n  \n  ');
+    expect(result.headers).toEqual([]);
+    expect(result.rows).toEqual([]);
+    expect(result.totalRows).toBe(0);
+  });
+
+  test('handles headers-only CSV', () => {
+    const result = parseCSV('name,age,email');
+    expect(result.headers).toEqual(['name', 'age', 'email']);
+    expect(result.rows).toEqual([]);
+    expect(result.totalRows).toBe(0);
+  });
+
+  test('handles quoted fields', () => {
+    const result = parseCSV('name,bio\nAlice,"Hello, World"\nBob,"Line1"');
+    expect(result.headers).toEqual(['name', 'bio']);
+    expect(result.rows[0]).toEqual(['Alice', 'Hello, World']);
+    expect(result.rows[1]).toEqual(['Bob', 'Line1']);
+  });
+
+  test('handles escaped quotes (double-quote)', () => {
+    const result = parseCSV('name,quote\nAlice,"She said ""hello"""\nBob,simple');
+    expect(result.rows[0][1]).toBe('She said "hello"');
+    expect(result.rows[1][1]).toBe('simple');
+  });
+
+  test('handles CRLF line endings', () => {
+    const result = parseCSV('a,b\r\n1,2\r\n3,4');
+    expect(result.headers).toEqual(['a', 'b']);
+    expect(result.rows).toEqual([['1', '2'], ['3', '4']]);
+  });
+
+  test('trims values', () => {
+    const result = parseCSV('name , age \n Alice , 30 ');
+    expect(result.headers).toEqual(['name', 'age']);
+    expect(result.rows[0]).toEqual(['Alice', '30']);
+  });
+
+  test('skips blank lines', () => {
+    const result = parseCSV('a,b\n1,2\n\n3,4\n');
+    expect(result.rows.length).toBe(2);
+    expect(result.totalRows).toBe(2);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// parseJSON
+// ---------------------------------------------------------------------------
+
+describe('parseJSON', () => {
+  test('parses array of objects', () => {
+    const result = parseJSON('[{"name":"Alice","age":30},{"name":"Bob","age":25}]');
+    expect(result.headers).toEqual(['name', 'age']);
+    expect(result.rows).toEqual([['Alice', '30'], ['Bob', '25']]);
+    expect(result.totalRows).toBe(2);
+  });
+
+  test('parses single object (wraps in array)', () => {
+    const result = parseJSON('{"name":"Alice","age":30}');
+    expect(result.headers).toEqual(['name', 'age']);
+    expect(result.rows).toEqual([['Alice', '30']]);
+    expect(result.totalRows).toBe(1);
+  });
+
+  test('returns empty for empty array', () => {
+    const result = parseJSON('[]');
+    expect(result.headers).toEqual([]);
+    expect(result.rows).toEqual([]);
+    expect(result.totalRows).toBe(0);
+  });
+
+  test('handles null/undefined values as empty string', () => {
+    const result = parseJSON('[{"a":null,"b":"hello"},{"a":"world","b":null}]');
+    expect(result.rows[0]).toEqual(['', 'hello']);
+    expect(result.rows[1]).toEqual(['world', '']);
+  });
+
+  test('handles nested objects by serializing to JSON', () => {
+    const result = parseJSON('[{"name":"Alice","meta":{"role":"admin"}}]');
+    expect(result.rows[0][0]).toBe('Alice');
+    expect(result.rows[0][1]).toBe('{"role":"admin"}');
+  });
+
+  test('handles arrays as values by serializing', () => {
+    const result = parseJSON('[{"tags":["a","b"]}]');
+    expect(result.rows[0][0]).toBe('["a","b"]');
+  });
+
+  test('unions headers from all objects', () => {
+    const result = parseJSON('[{"a":1},{"b":2},{"a":3,"c":4}]');
+    expect(result.headers).toContain('a');
+    expect(result.headers).toContain('b');
+    expect(result.headers).toContain('c');
+    // Missing fields become empty string
+    expect(result.rows[0]).toEqual(['1', '', '']);
+    expect(result.rows[1]).toEqual(['', '2', '']);
+  });
+
+  test('handles boolean values', () => {
+    const result = parseJSON('[{"active":true,"deleted":false}]');
+    expect(result.rows[0]).toEqual(['true', 'false']);
+  });
+
+  test('throws on invalid JSON', () => {
+    expect(() => parseJSON('not json')).toThrow();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// inferSqlType
+// ---------------------------------------------------------------------------
+
+describe('inferSqlType', () => {
+  test('returns INTEGER for all integer values', () => {
+    expect(inferSqlType(['1', '2', '100', '-5'])).toBe('INTEGER');
+  });
+
+  test('returns NUMERIC for decimal values', () => {
+    expect(inferSqlType(['1.5', '2.3', '-0.1'])).toBe('NUMERIC');
+  });
+
+  test('returns NUMERIC for mixed integer and decimal', () => {
+    expect(inferSqlType(['1', '2.5', '3'])).toBe('NUMERIC');
+  });
+
+  test('returns BOOLEAN for boolean-like values', () => {
+    expect(inferSqlType(['true', 'false', 'TRUE', 'FALSE'])).toBe('BOOLEAN');
+    expect(inferSqlType(['0', '1'])).toBe('INTEGER'); // 0,1 are integers first
+  });
+
+  test('returns TEXT for string values', () => {
+    expect(inferSqlType(['hello', 'world'])).toBe('TEXT');
+  });
+
+  test('returns TEXT for mixed types', () => {
+    expect(inferSqlType(['1', 'hello', '3'])).toBe('TEXT');
+  });
+
+  test('returns TEXT for all empty values', () => {
+    expect(inferSqlType(['', '', ''])).toBe('TEXT');
+  });
+
+  test('returns TEXT for empty array', () => {
+    expect(inferSqlType([])).toBe('TEXT');
+  });
+
+  test('ignores empty strings when inferring type', () => {
+    expect(inferSqlType(['1', '', '2', ''])).toBe('INTEGER');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// escapeSQL
+// ---------------------------------------------------------------------------
+
+describe('escapeSQL', () => {
+  test('wraps string in single quotes', () => {
+    expect(escapeSQL('hello')).toBe("'hello'");
+  });
+
+  test('escapes single quotes', () => {
+    expect(escapeSQL("it's")).toBe("'it''s'");
+  });
+
+  test('escapes multiple single quotes', () => {
+    expect(escapeSQL("it's a 'test'")).toBe("'it''s a ''test'''");
+  });
+
+  test('returns NULL for empty string', () => {
+    expect(escapeSQL('')).toBe('NULL');
+  });
+
+  test('returns NULL for "null"', () => {
+    expect(escapeSQL('null')).toBe('NULL');
+  });
+
+  test('returns NULL for "NULL"', () => {
+    expect(escapeSQL('NULL')).toBe('NULL');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// generateImportSQL
+// ---------------------------------------------------------------------------
+
+describe('generateImportSQL', () => {
+  const sampleData: ParsedData = {
+    headers: ['name', 'age', 'active'],
+    rows: [
+      ['Alice', '30', 'true'],
+      ['Bob', '25', 'false'],
+    ],
+    totalRows: 2,
+  };
+
+  test('returns empty for null parsedData', () => {
+    expect(generateImportSQL(null, 'users', false, '', {})).toBe('');
+  });
+
+  test('returns empty when no table name (existing table mode, empty target)', () => {
+    expect(generateImportSQL(sampleData, '', false, '', {})).toBe('');
+  });
+
+  test('generates INSERT into existing table', () => {
+    const sql = generateImportSQL(sampleData, 'users', false, '', { name: 'name', age: 'age', active: 'active' });
+    expect(sql).toContain('INSERT INTO users');
+    expect(sql).toContain('name, age, active');
+    expect(sql).not.toContain('CREATE TABLE');
+  });
+
+  test('generates CREATE TABLE + INSERT for new table', () => {
+    const sql = generateImportSQL(sampleData, '', true, 'my_table', { name: 'name', age: 'age', active: 'active' });
+    expect(sql).toContain('CREATE TABLE my_table');
+    expect(sql).toContain('INSERT INTO my_table');
+  });
+
+  test('uses "imported_data" as default new table name', () => {
+    const sql = generateImportSQL(sampleData, '', true, '', { name: 'name', age: 'age', active: 'active' });
+    expect(sql).toContain('CREATE TABLE imported_data');
+    expect(sql).toContain('INSERT INTO imported_data');
+  });
+
+  test('infers column types in CREATE TABLE', () => {
+    const sql = generateImportSQL(sampleData, '', true, 'test', { name: 'name', age: 'age', active: 'active' });
+    // name is TEXT, age is INTEGER, active is BOOLEAN
+    expect(sql).toContain('name TEXT');
+    expect(sql).toContain('age INTEGER');
+    expect(sql).toContain('active BOOLEAN');
+  });
+
+  test('uses column mapping for names', () => {
+    const sql = generateImportSQL(sampleData, 'users', false, '', { name: 'full_name', age: 'user_age', active: 'is_active' });
+    expect(sql).toContain('full_name, user_age, is_active');
+  });
+
+  test('uses column mapping in CREATE TABLE', () => {
+    const sql = generateImportSQL(sampleData, '', true, 'test', { name: 'full_name', age: 'user_age', active: 'is_active' });
+    expect(sql).toContain('full_name TEXT');
+    expect(sql).toContain('user_age INTEGER');
+  });
+
+  test('formats boolean values as TRUE/FALSE', () => {
+    const sql = generateImportSQL(sampleData, 'users', false, '', { name: 'name', age: 'age', active: 'active' });
+    expect(sql).toContain('TRUE');
+    expect(sql).toContain('FALSE');
+  });
+
+  test('outputs numeric values unquoted', () => {
+    const sql = generateImportSQL(sampleData, 'users', false, '', { name: 'name', age: 'age', active: 'active' });
+    // age values should be unquoted: 30, 25
+    expect(sql).toMatch(/\b30\b/);
+    expect(sql).toMatch(/\b25\b/);
+  });
+
+  test('escapes text values in INSERT', () => {
+    const data: ParsedData = {
+      headers: ['name'],
+      rows: [["O'Brien"]],
+      totalRows: 1,
+    };
+    const sql = generateImportSQL(data, 'users', false, '', { name: 'name' });
+    expect(sql).toContain("'O''Brien'");
+  });
+
+  test('handles NULL values', () => {
+    const data: ParsedData = {
+      headers: ['name', 'bio'],
+      rows: [['Alice', ''], ['Bob', 'NULL']],
+      totalRows: 2,
+    };
+    const sql = generateImportSQL(data, 'users', false, '', { name: 'name', bio: 'bio' });
+    expect(sql).toContain('NULL');
+  });
+
+  test('batches rows in groups of 100', () => {
+    const rows = Array.from({ length: 250 }, (_, i) => [String(i)]);
+    const data: ParsedData = { headers: ['id'], rows, totalRows: 250 };
+    const sql = generateImportSQL(data, 'items', false, '', { id: 'id' });
+
+    // Should have 3 INSERT statements (100 + 100 + 50)
+    const insertCount = (sql.match(/INSERT INTO/g) || []).length;
+    expect(insertCount).toBe(3);
+  });
+
+  test('falls back to header name when mapping is empty', () => {
+    const sql = generateImportSQL(sampleData, 'users', false, '', {});
+    expect(sql).toContain('name, age, active');
+  });
+});

package/tests/unit/data-import-utils.test.ts

@@ -0,0 +1,125 @@
+import '../setup';
+import { describe, expect, test } from 'bun:test';
+
+// We test the pure utility functions from DataImportModal by extracting their logic
+// Since they're not exported, we replicate them here for unit testing
+
+function parseCSV(text: string): { headers: string[]; rows: string[][]; totalRows: number } {
+  const lines = text.split(/\r?\n/).filter(line => line.trim());
+  if (lines.length === 0) return { headers: [], rows: [], totalRows: 0 };
+
+  const parseLine = (line: string): string[] => {
+    const result: string[] = [];
+    let current = '';
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+      const ch = line[i];
+      if (ch === '"' && !inQuotes) { inQuotes = true; }
+      else if (ch === '"' && inQuotes) {
+        if (i + 1 < line.length && line[i + 1] === '"') { current += '"'; i++; }
+        else { inQuotes = false; }
+      } else if (ch === ',' && !inQuotes) { result.push(current.trim()); current = ''; }
+      else { current += ch; }
+    }
+    result.push(current.trim());
+    return result;
+  };
+
+  const headers = parseLine(lines[0]);
+  const rows = lines.slice(1).map(line => parseLine(line));
+  return { headers, rows, totalRows: rows.length };
+}
+
+function parseJSON(text: string): { headers: string[]; rows: string[][]; totalRows: number } {
+  const data = JSON.parse(text);
+  const arr = Array.isArray(data) ? data : [data];
+  if (arr.length === 0) return { headers: [], rows: [], totalRows: 0 };
+  const headers = [...new Set(arr.flatMap((obj: Record<string, unknown>) => Object.keys(obj)))];
+  const rows = arr.map((obj: Record<string, unknown>) => headers.map(h => {
+    const val = obj[h];
+    if (val === null || val === undefined) return '';
+    if (typeof val === 'object') return JSON.stringify(val);
+    return String(val);
+  }));
+  return { headers, rows, totalRows: rows.length };
+}
+
+function inferSqlType(values: string[]): string {
+  const nonEmpty = values.filter(v => v !== '' && v !== null);
+  if (nonEmpty.length === 0) return 'TEXT';
+  if (nonEmpty.every(v => /^-?\d+$/.test(v))) return 'INTEGER';
+  if (nonEmpty.every(v => /^-?\d+(\.\d+)?$/.test(v))) return 'NUMERIC';
+  if (nonEmpty.every(v => /^(true|false|0|1)$/i.test(v))) return 'BOOLEAN';
+  return 'TEXT';
+}
+
+function escapeSQL(value: string): string {
+  if (value === '' || value === 'null' || value === 'NULL') return 'NULL';
+  return `'${value.replace(/'/g, "''")}'`;
+}
+
+describe('parseCSV', () => {
+  test('parses simple CSV', () => {
+    const result = parseCSV('name,age\nAlice,30\nBob,25');
+    expect(result.headers).toEqual(['name', 'age']);
+    expect(result.rows).toEqual([['Alice', '30'], ['Bob', '25']]);
+    expect(result.totalRows).toBe(2);
+  });
+
+  test('handles quoted fields with commas', () => {
+    const result = parseCSV('name,address\nAlice,"123 Main, St"\nBob,"456 Oak, Ave"');
+    expect(result.rows[0][1]).toBe('123 Main, St');
+  });
+
+  test('handles escaped quotes', () => {
+    const result = parseCSV('name,value\ntest,"He said ""hello"""');
+    expect(result.rows[0][1]).toBe('He said "hello"');
+  });
+
+  test('returns empty for empty input', () => {
+    const result = parseCSV('');
+    expect(result.headers).toEqual([]);
+    expect(result.totalRows).toBe(0);
+  });
+});
+
+describe('parseJSON', () => {
+  test('parses JSON array', () => {
+    const result = parseJSON('[{"name":"Alice","age":30},{"name":"Bob","age":25}]');
+    expect(result.headers).toEqual(['name', 'age']);
+    expect(result.rows[0]).toEqual(['Alice', '30']);
+    expect(result.totalRows).toBe(2);
+  });
+
+  test('wraps single object', () => {
+    const result = parseJSON('{"name":"Alice"}');
+    expect(result.headers).toEqual(['name']);
+    expect(result.totalRows).toBe(1);
+  });
+
+  test('handles null values', () => {
+    const result = parseJSON('[{"a":null,"b":1}]');
+    expect(result.rows[0][0]).toBe('');
+    expect(result.rows[0][1]).toBe('1');
+  });
+
+  test('stringifies nested objects', () => {
+    const result = parseJSON('[{"data":{"x":1}}]');
+    expect(result.rows[0][0]).toBe('{"x":1}');
+  });
+});
+
+describe('inferSqlType', () => {
+  test('infers INTEGER', () => { expect(inferSqlType(['1', '2', '-3'])).toBe('INTEGER'); });
+  test('infers NUMERIC', () => { expect(inferSqlType(['1.5', '2.0', '-3.14'])).toBe('NUMERIC'); });
+  test('infers BOOLEAN', () => { expect(inferSqlType(['true', 'false', '1', '0'])).toBe('BOOLEAN'); });
+  test('defaults to TEXT', () => { expect(inferSqlType(['hello', 'world'])).toBe('TEXT'); });
+  test('empty returns TEXT', () => { expect(inferSqlType([])).toBe('TEXT'); });
+});
+
+describe('escapeSQL', () => {
+  test('wraps in quotes', () => { expect(escapeSQL('hello')).toBe("'hello'"); });
+  test('escapes single quotes', () => { expect(escapeSQL("it's")).toBe("'it''s'"); });
+  test('returns NULL for empty', () => { expect(escapeSQL('')).toBe('NULL'); });
+  test('returns NULL for null string', () => { expect(escapeSQL('null')).toBe('NULL'); });
+});