✨ Add CI workflow and tests for EnhancedQueryLogger; update bun.lock

Author: max-programming

.github/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: CI - Run Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  run-tests:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Run tests
+        run: bun test

__tests__/enhanced-query-logger.test.ts

@@ -0,0 +1,312 @@
+import { afterEach, beforeEach, describe, expect, it, jest } from "bun:test";
+import { EnhancedQueryLogger } from "../src";
+
+describe("EnhancedQueryLogger", () => {
+  let logger: EnhancedQueryLogger;
+  let mockLog: ReturnType<typeof jest.fn<(...args: string[]) => void>>;
+
+  beforeEach(() => {
+    mockLog = jest.fn();
+    logger = new EnhancedQueryLogger({
+      log: mockLog,
+    });
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("Query Type Detection", () => {
+    it("should detect SELECT queries", () => {
+      logger.logQuery("SELECT * FROM users", []);
+      expect(mockLog).toHaveBeenCalled();
+      const logCall = mockLog.mock.calls.find(call =>
+        call[0].includes("SELECT")
+      );
+      expect(logCall).toBeDefined();
+    });
+  });
+
+  it("should detect INSERT queries", () => {
+    logger.logQuery("INSERT INTO users (name) VALUES (?)", ["John Doe"]);
+    expect(mockLog).toHaveBeenCalled();
+    const logCall = mockLog.mock.calls.find(
+      call => call[0].includes("📝") && call[0].includes("INSERT")
+    );
+    expect(logCall).toBeDefined();
+  });
+
+  it("should detect UPDATE queries", () => {
+    logger.logQuery("UPDATE users SET name = ? WHERE id = ?", ["Jane", 1]);
+    const logCall = mockLog.mock.calls.find(
+      call => call[0].includes("✏️") && call[0].includes("UPDATE")
+    );
+    expect(logCall).toBeDefined();
+  });
+
+  it("should detect DELETE queries", () => {
+    logger.logQuery("DELETE FROM users WHERE id = ?", [1]);
+    const logCall = mockLog.mock.calls.find(
+      call => call[0].includes("🗑️") && call[0].includes("DELETE")
+    );
+    expect(logCall).toBeDefined();
+  });
+
+  it("should detect CREATE queries", () => {
+    logger.logQuery("CREATE TABLE users (id INT)", []);
+    const logCall = mockLog.mock.calls.find(
+      call => call[0].includes("🏗️") && call[0].includes("CREATE")
+    );
+    expect(logCall).toBeDefined();
+  });
+
+  it("should detect DROP queries", () => {
+    logger.logQuery("DROP TABLE users", []);
+    const logCall = mockLog.mock.calls.find(
+      call => call[0].includes("💥") && call[0].includes("DROP")
+    );
+    expect(logCall).toBeDefined();
+  });
+
+  it("should detect ALTER queries", () => {
+    logger.logQuery("ALTER TABLE users ADD COLUMN email VARCHAR(255)", []);
+    const logCall = mockLog.mock.calls.find(
+      call => call[0].includes("🔧") && call[0].includes("ALTER")
+    );
+    expect(logCall).toBeDefined();
+  });
+
+  it("should classify unknown queries as OTHER", () => {
+    logger.logQuery("EXPLAIN SELECT * FROM users", []);
+    const logCall = mockLog.mock.calls.find(
+      call => call[0].includes("⚡") && call[0].includes("OTHER")
+    );
+    expect(logCall).toBeDefined();
+  });
+
+  describe("Table Name Extraction", () => {
+    it("should extract table name from SELECT queries", () => {
+      logger.logQuery("SELECT * FROM users WHERE id = 1", []);
+      const logCall = mockLog.mock.calls.find(call =>
+        call[0].includes("users")
+      );
+      expect(logCall).toBeDefined();
+    });
+
+    it("should extract table name from INSERT queries", () => {
+      logger.logQuery("INSERT INTO products (name) VALUES (?)", ["Test"]);
+      const logCall = mockLog.mock.calls.find(call =>
+        call[0].includes("products")
+      );
+      expect(logCall).toBeDefined();
+    });
+
+    it("should extract table name from UPDATE queries", () => {
+      logger.logQuery("UPDATE orders SET status = ? WHERE id = ?", [
+        "completed",
+        1,
+      ]);
+      const logCall = mockLog.mock.calls.find(call =>
+        call[0].includes("orders")
+      );
+      expect(logCall).toBeDefined();
+    });
+
+    it("should extract table name from CREATE TABLE queries", () => {
+      logger.logQuery("CREATE TABLE new_table (id INT)", []);
+      const logCall = mockLog.mock.calls.find(call =>
+        call[0].includes("new_table")
+      );
+      expect(logCall).toBeDefined();
+    });
+
+    it("should handle queries with quoted table names", () => {
+      logger.logQuery("SELECT * FROM `users` WHERE id = 1", []);
+      const logCall = mockLog.mock.calls.find(call =>
+        call[0].includes("users")
+      );
+      expect(logCall).toBeDefined();
+    });
+
+    it("should handle queries without identifiable table names", () => {
+      logger.logQuery("SHOW TABLES", []);
+      // Should not crash and should log the query
+      expect(mockLog).toHaveBeenCalled();
+    });
+  });
+  describe("Parameter Formatting", () => {
+    it("should format string parameters", () => {
+      logger.logQuery("SELECT * FROM users WHERE name = ?", ["John Doe"]);
+      const logCall = mockLog.mock.calls.find(call =>
+        call[0].includes("John Doe")
+      );
+      expect(logCall).toBeDefined();
+    });
+
+    it("should format number parameters", () => {
+      logger.logQuery("SELECT * FROM users WHERE id = ?", [123]);
+      const logCall = mockLog.mock.calls.find(call => call[0].includes("123"));
+      expect(logCall).toBeDefined();
+    });
+
+    it("should format boolean parameters", () => {
+      logger.logQuery("SELECT * FROM users WHERE active = ?", [true]);
+      const logCall = mockLog.mock.calls.find(call => call[0].includes("true"));
+      expect(logCall).toBeDefined();
+    });
+
+    it("should format null parameters", () => {
+      logger.logQuery("SELECT * FROM users WHERE email = ?", [null]);
+      const logCall = mockLog.mock.calls.find(call => call[0].includes("null"));
+      expect(logCall).toBeDefined();
+    });
+
+    it("should format object parameters", () => {
+      logger.logQuery("SELECT * FROM users WHERE metadata = ?", [
+        { key: "value" },
+      ]);
+      const logCall = mockLog.mock.calls.find(
+        call => call[0].includes("key") && call[0].includes("value")
+      );
+      expect(logCall).toBeDefined();
+    });
+
+    it("should handle empty parameter arrays", () => {
+      logger.logQuery("SELECT * FROM users", []);
+      expect(mockLog).toHaveBeenCalled();
+      // Should not include parameter section
+      const parameterCall = mockLog.mock.calls.find(call =>
+        call[0].includes("Parameters:")
+      );
+      expect(parameterCall).toBeUndefined();
+    });
+  });
+
+  describe("Query Formatting", () => {
+    it("should highlight SQL keywords", () => {
+      logger.logQuery("SELECT name FROM users WHERE id = 1", []);
+      const logCall = mockLog.mock.calls.find(
+        call =>
+          call[0].includes("SELECT") ||
+          call[0].includes("FROM") ||
+          call[0].includes("WHERE")
+      );
+      expect(logCall).toBeDefined();
+    });
+
+    it("should highlight string literals", () => {
+      logger.logQuery("SELECT * FROM users WHERE name = 'John'", []);
+      const logCall = mockLog.mock.calls.find(call =>
+        call[0].includes("'John'")
+      );
+      expect(logCall).toBeDefined();
+    });
+
+    it("should highlight numbers", () => {
+      logger.logQuery("SELECT * FROM users WHERE id = 123", []);
+      const logCall = mockLog.mock.calls.find(call => call[0].includes("123"));
+      expect(logCall).toBeDefined();
+    });
+  });
+
+  describe("Logging Format", () => {
+    it("should include query count in header", () => {
+      logger.logQuery("SELECT * FROM users", []);
+      const headerCall = mockLog.mock.calls.find(call =>
+        call[0].includes("#1")
+      );
+      expect(headerCall).toBeDefined();
+    });
+
+    it("should increment query count", () => {
+      logger.logQuery("SELECT * FROM users", []);
+      logger.logQuery("SELECT * FROM products", []);
+
+      const firstQueryCall = mockLog.mock.calls.find(call =>
+        call[0].includes("#1")
+      );
+      const secondQueryCall = mockLog.mock.calls.find(call =>
+        call[0].includes("#2")
+      );
+
+      expect(firstQueryCall).toBeDefined();
+      expect(secondQueryCall).toBeDefined();
+    });
+
+    it("should include timestamp", () => {
+      logger.logQuery("SELECT * FROM users", []);
+      const timeCall = mockLog.mock.calls.find(call =>
+        call[0].includes("Time:")
+      );
+      expect(timeCall).toBeDefined();
+    });
+
+    it("should include SQL section", () => {
+      logger.logQuery("SELECT * FROM users", []);
+      const sqlCall = mockLog.mock.calls.find(call => call[0].includes("SQL:"));
+      expect(sqlCall).toBeDefined();
+    });
+
+    it("should call log function multiple times for complete output", () => {
+      logger.logQuery("SELECT * FROM users WHERE id = ?", [1]);
+      // Should have header, time, query info, SQL line, parameters, and footer
+      expect(mockLog).toHaveBeenCalledTimes(6);
+    });
+  });
+
+  describe("Constructor Options", () => {
+    it("should use console.log by default", () => {
+      const defaultLogger = new EnhancedQueryLogger();
+      // Should not throw when logging
+      expect(() => {
+        defaultLogger.logQuery("SELECT 1", []);
+      }).not.toThrow();
+    });
+
+    it("should accept custom log function", () => {
+      const customLog = jest.fn();
+      const customLogger = new EnhancedQueryLogger({ log: customLog });
+
+      customLogger.logQuery("SELECT 1", []);
+      expect(customLog).toHaveBeenCalled();
+    });
+  });
+
+  describe("Edge Cases", () => {
+    it("should handle very long queries", () => {
+      const longQuery = "SELECT " + "column,".repeat(100) + " id FROM users";
+      expect(() => {
+        logger.logQuery(longQuery, []);
+      }).not.toThrow();
+    });
+
+    it("should handle queries with special characters", () => {
+      const specialQuery =
+        "SELECT * FROM users WHERE name = 'O''Reilly' AND email LIKE '%@%.com'";
+      expect(() => {
+        logger.logQuery(specialQuery, []);
+      }).not.toThrow();
+    });
+
+    it("should handle empty queries", () => {
+      expect(() => {
+        logger.logQuery("", []);
+      }).not.toThrow();
+    });
+
+    it("should handle queries with only whitespace", () => {
+      expect(() => {
+        logger.logQuery("   \n\t  ", []);
+      }).not.toThrow();
+    });
+
+    it("should handle malformed parameters that throw JSON.stringify errors", () => {
+      const circularObj: any = { prop: "value" };
+      circularObj.circular = circularObj;
+
+      expect(() => {
+        logger.logQuery("SELECT * FROM users WHERE data = ?", [circularObj]);
+      }).not.toThrow();
+    });
+  });
+});

__tests__/index.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "bun:test";
+import { EnhancedQueryLogger } from "../src";
+
+describe("Package Exports", () => {
+  it("should export EnhancedQueryLogger class", () => {
+    expect(EnhancedQueryLogger).toBeDefined();
+    expect(typeof EnhancedQueryLogger).toBe("function");
+  });
+
+  it("shouldbe able to instantiate EnhancedQueryLogger", () => {
+    const logger = new EnhancedQueryLogger();
+    expect(logger).toBeInstanceOf(EnhancedQueryLogger);
+  });
+
+  it("should implement Logger interface methods", () => {
+    const logger = new EnhancedQueryLogger();
+    expect(typeof logger.logQuery).toBe("function");
+  });
+});

bun.lock

@@ -210,6 +210,8 @@
 
     "mz": ["[email protected]", "", { "dependencies": { "any-promise": "^1.0.0", "object-assign": "^4.0.1", "thenify-all": "^1.0.0" } }, "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q=="],
 
+    "nanoid": ["[email protected]", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w=="],
+
     "object-assign": ["[email protected]", "", {}, "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg=="],
 
     "package-json-from-dist": ["[email protected]", "", {}, "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw=="],
@@ -228,6 +230,8 @@
 
     "pkg-types": ["[email protected]", "", { "dependencies": { "confbox": "^0.1.8", "mlly": "^1.7.4", "pathe": "^2.0.1" } }, "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ=="],
 
+    "postcss": ["[email protected]", "", { "dependencies": { "nanoid": "^3.3.11", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg=="],
+
     "postcss-load-config": ["[email protected]", "", { "dependencies": { "lilconfig": "^3.1.1" }, "peerDependencies": { "jiti": ">=1.21.0", "postcss": ">=8.0.9", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["jiti", "postcss", "tsx", "yaml"] }, "sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g=="],
 
     "punycode": ["[email protected]", "", {}, "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg=="],
@@ -246,6 +250,8 @@
 
     "source-map": ["[email protected]", "", { "dependencies": { "whatwg-url": "^7.0.0" } }, "sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA=="],
 
+    "source-map-js": ["[email protected]", "", {}, "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="],
+
     "string-width": ["[email protected]", "", { "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", "strip-ansi": "^7.0.1" } }, "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA=="],
 
     "string-width-cjs": ["[email protected]", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],