@comprehend/telemetry-node 0.1.0

package/src/sql-analyzer.test.ts

@@ -0,0 +1,436 @@
+import { analyzeSQL } from './sql-analyzer';
+
+describe('SQL Analyzer - basic SQL operations', () => {
+    it('detects a simple SELECT from one table', () => {
+        const sql = `SELECT * FROM users`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ users: ['SELECT'] });
+        expect(result.presentableQuery).toEqual(sql);
+    });
+
+    it('detects an INSERT INTO ... VALUES', () => {
+        const sql = `INSERT INTO logs (message, level) VALUES ('hi', 'info')`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ logs: ['INSERT'] });
+        expect(result.presentableQuery).toEqual(sql);
+    });
+
+    it('detects an INSERT INTO ... SELECT', () => {
+        const sql = `INSERT INTO archive SELECT * FROM logs`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            archive: ['INSERT'],
+            logs: ['SELECT']
+        });
+        expect(result.presentableQuery).toEqual(sql);
+    });
+
+    it('detects a simple UPDATE', () => {
+        const sql = `UPDATE users SET last_login = NOW() WHERE id = 1`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ users: ['UPDATE'] });
+        expect(result.presentableQuery).toEqual(sql);
+    });
+
+    it('detects a simple DELETE', () => {
+        const sql = `DELETE FROM sessions WHERE expired = true`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ sessions: ['DELETE'] });
+        expect(result.presentableQuery).toEqual(sql);
+    });
+
+    it('detects tables in DELETE ... USING clause', () => {
+        const sql = `
+            DELETE FROM sessions
+            USING users
+            WHERE sessions.user_id = users.id
+          `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            sessions: ['DELETE'],
+            users: ['SELECT'],
+        });
+
+        expect(result.normalizedQuery).toMatch(/delete\s+from\s+sessions/i);
+        expect(result.normalizedQuery).toMatch(/using\s+users/i);
+        expect(result.presentableQuery).toEqual(sql);
+    });
+
+    it('detects tables with aliases in FROM clause', () => {
+        const sql = `
+            SELECT u.id, u.name
+            FROM users u
+            WHERE u.active = true
+          `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            users: ['SELECT'],
+        });
+
+        expect(result.normalizedQuery).toMatch(/from\s+users/i);
+        expect(result.presentableQuery).toEqual(sql);
+    });
+
+    it('handles multiple operations on the same table', () => {
+        const sql = `
+          INSERT INTO stats (user_id, value)
+          SELECT id, 42 FROM users;
+          UPDATE stats SET value = 99 WHERE value < 50;
+        `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            stats: ['INSERT', 'UPDATE'],
+            users: ['SELECT']
+        });
+        expect(result.presentableQuery).toEqual(sql);
+    });
+
+    it('detects tables in REPLACE INTO statements', () => {
+        const sql = `
+            REPLACE INTO users (id, name) VALUES (1, 'Alice');
+          `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            users: ['INSERT', 'UPDATE'],
+        });
+
+        expect(result.normalizedQuery).toMatch(/replace\s+into\s+users/i);
+        expect(result.presentableQuery).toEqual(sql);
+    });
+
+    it('detects operation type from MERGE WHEN clause', () => {
+        const sql = `
+            MERGE INTO inventory AS t
+            USING incoming AS s
+            ON t.sku = s.sku
+            WHEN MATCHED THEN
+              UPDATE SET t.qty = t.qty + s.qty
+            WHEN NOT MATCHED THEN
+              INSERT (sku, qty) VALUES (s.sku, s.qty);
+          `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            inventory: ['INSERT', 'UPDATE'],
+            incoming: ['SELECT'],
+        });
+
+        expect(result.normalizedQuery).toMatch(/merge\s+into\s+inventory/i);
+        expect(result.presentableQuery).toEqual(sql);
+    });
+
+    it('handles double-quoted identifiers', () => {
+        const sql = `SELECT * FROM "Users" WHERE "Users"."Id" = 42`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ users: ['SELECT'] });
+        expect(result.normalizedQuery).toMatch(/from\s+users/i);
+        expect(result.presentableQuery).toEqual(sql);
+    });
+
+    it('handles backtick-quoted identifiers (MySQL style)', () => {
+        const sql = 'SELECT * FROM `auditLogs` WHERE `eventType` = "login"';
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ auditlogs: ['SELECT'] });
+        expect(result.normalizedQuery).toMatch(/from\s+auditlogs/i);
+        expect(result.presentableQuery).toEqual(sql);
+    });
+
+    it('handles bracket-quoted identifiers (SQL Server style)', () => {
+        const sql = `SELECT [userId], [userName] FROM [Accounts]`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ accounts: ['SELECT'] });
+        expect(result.normalizedQuery).toMatch(/from\s+accounts/i);
+        expect(result.presentableQuery).toEqual(sql);
+    });
+
+    it('normalizes quoted table names and columns to lowercase', () => {
+        const sql = `SELECT "ID", "Email" FROM "Customer"`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ customer: ['SELECT'] });
+        expect(result.normalizedQuery).toMatch(/from\s+customer/i);
+        expect(result.presentableQuery).toEqual(sql);
+    });
+
+    it('detects real tables from subqueries in the FROM clause', () => {
+        const sql = `
+            SELECT sq.name
+            FROM (
+              SELECT name FROM employees WHERE active = true
+            ) sq
+          `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            employees: ['SELECT'],
+        });
+
+        expect(result.normalizedQuery).toMatch(/from\s+employees/i);
+        expect(result.presentableQuery).toEqual(sql);
+    });
+
+    it('does not treat FROM function() as a table', () => {
+        const sql = `
+            SELECT * FROM get_active_users();
+          `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({});
+        expect(result.normalizedQuery).toMatch(/from\s+get_active_users\s*\(\)/i);
+        expect(result.presentableQuery).toEqual(sql);
+    });
+
+    it('detects simple inner join', () => {
+        const sql = `
+          SELECT * FROM users
+          JOIN orders ON users.id = orders.user_id
+        `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            users: ['SELECT'],
+            orders: ['SELECT'],
+        });
+    });
+
+    it('detects LEFT JOIN', () => {
+        const sql = `
+          SELECT u.name, o.total
+          FROM users u
+          LEFT JOIN orders o ON u.id = o.user_id
+        `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            users: ['SELECT'],
+            orders: ['SELECT'],
+        });
+    });
+
+    it('detects RIGHT JOIN', () => {
+        const sql = `
+          SELECT * FROM payments
+          RIGHT JOIN invoices ON payments.invoice_id = invoices.id
+        `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            payments: ['SELECT'],
+            invoices: ['SELECT'],
+        });
+    });
+
+    it('detects FULL OUTER JOIN', () => {
+        const sql = `
+          SELECT * FROM logs l
+          FULL OUTER JOIN metrics m ON l.time = m.time
+        `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            logs: ['SELECT'],
+            metrics: ['SELECT'],
+        });
+    });
+
+    it('detects JOIN with subquery alias', () => {
+        const sql = `
+          SELECT * FROM users u
+          JOIN (SELECT * FROM events WHERE type = 'login') e ON u.id = e.user_id
+        `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            users: ['SELECT'],
+            events: ['SELECT'],
+        });
+    });
+
+    it('ignores subquery alias after JOIN', () => {
+        const sql = `
+          SELECT * FROM users
+          JOIN (SELECT * FROM sessions) AS s ON users.id = s.user_id
+        `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            users: ['SELECT'],
+            sessions: ['SELECT'],
+        });
+    });
+
+    it('handles JOIN with quoted identifiers', () => {
+        const sql = `
+          SELECT * FROM "userData"
+          JOIN "auditLogs" ON "userData"."id" = "auditLogs"."userId"
+        `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            userdata: ['SELECT'],
+            auditlogs: ['SELECT'],
+        });
+    });
+
+    it('detects tables involved in LATERAL JOINs', () => {
+        const sql = `
+            SELECT u.id, r.*
+            FROM users u
+            LEFT JOIN LATERAL (
+              SELECT * FROM reports WHERE reports.user_id = u.id ORDER BY created_at DESC LIMIT 1
+            ) r ON true
+          `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            users: ['SELECT'],
+            reports: ['SELECT'],
+        });
+
+        expect(result.normalizedQuery).toMatch(/join\s+lateral/i);
+        expect(result.normalizedQuery).toMatch(/from\s+reports/i);
+    });
+
+    it('collapses IN clauses with values to avoid cardinality explosion', () => {
+        const sql = `SELECT name FROM users WHERE id IN (1, 2, 3)`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ users: ['SELECT'] });
+        expect(result.normalizedQuery).toContain('IN(...)');
+        expect(result.presentableQuery).toEqual(`SELECT name FROM users WHERE id IN (...)`);
+    });
+
+    it('preserves and analyzes subquery in IN clause', () => {
+        const sql = `SELECT * FROM users WHERE id IN (SELECT user_id FROM events)`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ users: ['SELECT'], events: ['SELECT'] });
+        expect(result.normalizedQuery).toMatch(/IN\s*\(.*SELECT.*\)/i);
+        expect(result.presentableQuery).toEqual(sql);
+    });
+
+    it('ignores CTEs in table detection', () => {
+        const sql = `
+          WITH recent_orders AS (
+            SELECT * FROM orders
+          )
+          SELECT * FROM recent_orders JOIN users ON users.id = recent_orders.user_id
+        `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).not.toHaveProperty('recent_orders');
+        expect(result.tableOperations).toEqual({ orders: ['SELECT'], users: ['SELECT'] });
+    });
+
+    it('handles multiple CTEs and ignores them as tables', () => {
+        const sql = `
+            WITH active_users AS (
+              SELECT * FROM users WHERE active = true
+            ),
+            recent_logins AS (
+              SELECT * FROM logins WHERE login_time > NOW() - INTERVAL '7 days'
+            )
+            SELECT au.id, rl.login_time
+            FROM active_users au
+            JOIN recent_logins rl ON au.id = rl.user_id
+            JOIN sessions s ON s.user_id = au.id
+          `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            users: ['SELECT'],
+            logins: ['SELECT'],
+            sessions: ['SELECT'],
+        });
+
+        expect(result.tableOperations).not.toHaveProperty('active_users');
+        expect(result.tableOperations).not.toHaveProperty('recent_logins');
+
+        // Also check normalization keeps the CTEs in the output
+        expect(result.normalizedQuery).toMatch(/with\s+active_users/i);
+        expect(result.normalizedQuery).toMatch(/recent_logins/i);
+    });
+
+    it('handles multiple quoted CTEs and real quoted table names', () => {
+        const sql = `
+            WITH "ActiveUsers" AS (
+              SELECT * FROM "Users" WHERE "Active" = true
+            ),
+            [RecentLogins] AS (
+              SELECT * FROM [Logins] WHERE [LoginTime] > NOW() - INTERVAL '7 days'
+            )
+            SELECT au."Id", rl."LoginTime"
+            FROM "ActiveUsers" au
+            JOIN [RecentLogins] rl ON au."Id" = rl."UserId"
+            JOIN \`Sessions\` s ON s.\`UserId\` = au."Id"
+          `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            users: ['SELECT'],
+            logins: ['SELECT'],
+            sessions: ['SELECT'],
+        });
+
+        expect(result.tableOperations).not.toHaveProperty('activeusers');
+        expect(result.tableOperations).not.toHaveProperty('recentlogins');
+
+        expect(result.normalizedQuery).toMatch(/with\s+activeusers/i);
+        expect(result.normalizedQuery).toMatch(/recentlogins/i);
+        expect(result.normalizedQuery).toMatch(/from\s+activeusers/i);
+        expect(result.normalizedQuery).toMatch(/join\s+sessions/i);
+    });
+
+    it('handles recursive CTEs and ignores the CTE alias as a table', () => {
+        const sql = `
+            WITH RECURSIVE descendants AS (
+              SELECT id, parent_id FROM categories WHERE parent_id IS NULL
+              UNION ALL
+              SELECT c.id, c.parent_id
+              FROM categories c
+              JOIN descendants d ON c.parent_id = d.id
+            )
+            SELECT * FROM descendants;
+          `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            categories: ['SELECT'],
+        });
+
+        expect(result.tableOperations).not.toHaveProperty('descendants');
+
+        // Normalization check (ensure RECURSIVE appears)
+        expect(result.normalizedQuery).toMatch(/with\s+recursive\s+descendants/i);
+        expect(result.normalizedQuery).toMatch(/join\s+descendants/i);
+    });
+
+    it('ignores function argument in EXTRACT() when detecting tables', () => {
+        const sql = `
+          SELECT id, extract('epoch' FROM created) AS time, actor, changes
+          FROM transactions
+          WHERE transactions.id = $1
+        `;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            transactions: ['SELECT']
+        });
+
+        // Bonus assertion: normalized query includes EXTRACT(...) intact
+        expect(result.normalizedQuery).toMatch(/extract\s*\(.*from.*created.*\)/i);
+        expect(result.presentableQuery).toEqual(sql);
+    });
+});