nestlens 0.4.0 → 0.4.1

package/dist/__tests__/watchers/query.watcher.spec.js

@@ -1,195 +1,80 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
- * QueryWatcher Tests
+ * QueryWatcher unit tests.
+ *
+ * Covers configuration handling, query payload formatting, slow detection,
+ * ignore-pattern filtering, and the auxiliary classes (subscriber + logger)
+ * that bridge TypeORM's public API into the watcher.
  *
- * Tests for the query watcher that monitors TypeORM and Prisma queries.
- * Follows AAA (Arrange-Act-Assert) pattern.
+ * Real TypeORM end-to-end coverage lives in
+ * `src/__tests__/watchers/query/typeorm-integration.spec.ts`.
  */
 const testing_1 = require("@nestjs/testing");
+const core_1 = require("@nestjs/core");
 const collector_service_1 = require("../../core/collector.service");
 const nestlens_config_1 = require("../../nestlens.config");
 const query_watcher_1 = require("../../watchers/query/query.watcher");
-// Mock the types module
-jest.mock('../../watchers/query/types', () => ({
-    isModuleAvailable: jest.fn(),
-    tryRequire: jest.fn(),
-    isTypeORMDataSource: jest.fn(),
-    isPrismaClient: jest.fn(),
-}));
-const queryTypes = __importStar(require("../../watchers/query/types"));
+const typeorm_subscriber_1 = require("../../watchers/query/typeorm-subscriber");
+const typeorm_logger_1 = require("../../watchers/query/typeorm-logger");
 describe('QueryWatcher', () => {
-    let watcher;
-    let mockCollector;
-    let mockConfig;
-    const mockedTypes = queryTypes;
-    const createWatcher = async (config) => {
-        const module = await testing_1.Test.createTestingModule({
+    let collector;
+    const buildWatcher = async (config) => {
+        const moduleRef = await testing_1.Test.createTestingModule({
+            imports: [core_1.DiscoveryModule],
             providers: [
                 query_watcher_1.QueryWatcher,
-                { provide: collector_service_1.CollectorService, useValue: mockCollector },
+                { provide: collector_service_1.CollectorService, useValue: collector },
                 { provide: nestlens_config_1.NESTLENS_CONFIG, useValue: config },
             ],
         }).compile();
-        return module.get(query_watcher_1.QueryWatcher);
+        return moduleRef.get(query_watcher_1.QueryWatcher);
     };
     beforeEach(() => {
-        jest.clearAllMocks();
-        mockCollector = {
+        collector = {
             collect: jest.fn(),
             collectImmediate: jest.fn(),
         };
-        mockConfig = {
-            enabled: true,
-            watchers: {
-                query: { enabled: true, slowThreshold: 100 },
-            },
-        };
-        // Default mock implementations
-        mockedTypes.isModuleAvailable.mockReturnValue(false);
-        mockedTypes.tryRequire.mockReturnValue(null);
-        mockedTypes.isTypeORMDataSource.mockReturnValue(false);
-        mockedTypes.isPrismaClient.mockReturnValue(false);
     });
-    // ============================================================================
-    // Config Handling
-    // ============================================================================
-    describe('Config Handling', () => {
-        it('should be enabled when query watcher config is true', async () => {
-            // Arrange
-            mockConfig.watchers = { query: true };
-            watcher = await createWatcher(mockConfig);
-            // Act & Assert
-            // Access private config through prototype for testing
+    describe('Config handling', () => {
+        it('treats `query: true` as enabled with default slowThreshold', async () => {
+            const watcher = await buildWatcher({ watchers: { query: true } });
             expect(watcher.config.enabled).toBe(true);
-        });
-        it('should be disabled when query watcher config is false', async () => {
-            // Arrange
-            mockConfig.watchers = { query: false };
-            watcher = await createWatcher(mockConfig);
-            // Act
-            await watcher.onModuleInit();
-            // Assert - should not try to initialize adapters
-            expect(mockedTypes.isModuleAvailable).not.toHaveBeenCalled();
-        });
-        it('should use default slowThreshold of 100 when not specified', async () => {
-            // Arrange
-            mockConfig.watchers = { query: true };
-            watcher = await createWatcher(mockConfig);
-            // Assert
             expect(watcher.config.slowThreshold).toBe(100);
         });
-        it('should use custom slowThreshold from config', async () => {
-            // Arrange
-            mockConfig.watchers = { query: { enabled: true, slowThreshold: 500 } };
-            watcher = await createWatcher(mockConfig);
-            // Assert
+        it('treats `query: false` as disabled', async () => {
+            const watcher = await buildWatcher({ watchers: { query: false } });
+            watcher.onApplicationBootstrap();
+            expect(watcher.config.enabled).toBe(false);
+        });
+        it('honours custom slowThreshold from object form', async () => {
+            const watcher = await buildWatcher({
+                watchers: { query: { enabled: true, slowThreshold: 500 } },
+            });
             expect(watcher.config.slowThreshold).toBe(500);
         });
-        it('should be enabled by default when watchers config is undefined', async () => {
-            // Arrange
-            mockConfig.watchers = undefined;
-            watcher = await createWatcher(mockConfig);
-            // Assert
+        it('defaults to enabled when watchers config is undefined', async () => {
+            const watcher = await buildWatcher({});
             expect(watcher.config.enabled).toBe(true);
         });
     });
-    // ============================================================================
-    // Module Initialization
-    // ============================================================================
-    describe('Module Initialization', () => {
-        beforeEach(async () => {
-            watcher = await createWatcher(mockConfig);
-        });
-        it('should check for TypeORM module availability', async () => {
-            // Arrange
-            mockedTypes.isModuleAvailable.mockReturnValue(false);
-            // Act
-            await watcher.onModuleInit();
-            // Assert
-            expect(mockedTypes.isModuleAvailable).toHaveBeenCalledWith('typeorm');
-        });
-        it('should check for Prisma module availability', async () => {
-            // Arrange
-            mockedTypes.isModuleAvailable.mockReturnValue(false);
-            // Act
-            await watcher.onModuleInit();
-            // Assert
-            expect(mockedTypes.isModuleAvailable).toHaveBeenCalledWith('@prisma/client');
-        });
-        it('should not initialize when disabled', async () => {
-            // Arrange
-            mockConfig.watchers = { query: false };
-            watcher = await createWatcher(mockConfig);
-            // Act
-            await watcher.onModuleInit();
-            // Assert
-            expect(mockedTypes.isModuleAvailable).not.toHaveBeenCalled();
-        });
-        it('should try to require TypeORM when available', async () => {
-            // Arrange
-            mockedTypes.isModuleAvailable.mockImplementation((mod) => mod === 'typeorm');
-            mockedTypes.tryRequire.mockReturnValue(null);
-            // Act
-            await watcher.onModuleInit();
-            // Assert
-            expect(mockedTypes.tryRequire).toHaveBeenCalledWith('typeorm');
-        });
-    });
-    // ============================================================================
-    // Query Handling (via handleQuery)
-    // ============================================================================
-    describe('Query Handling', () => {
+    describe('handleQuery', () => {
+        let watcher;
         beforeEach(async () => {
-            watcher = await createWatcher(mockConfig);
+            watcher = await buildWatcher({
+                watchers: { query: { enabled: true, slowThreshold: 100 } },
+            });
         });
-        it('should collect query with all fields', async () => {
-            // Arrange
-            const queryData = {
+        it('forwards a fully-populated payload to the collector', () => {
+            watcher.handleQuery({
                 query: 'SELECT * FROM users WHERE id = ?',
                 parameters: [1],
                 duration: 50,
                 source: 'typeorm',
                 connection: 'default',
                 requestId: 'req-123',
-            };
-            // Act
-            watcher.handleQuery(queryData);
-            // Assert
-            expect(mockCollector.collect).toHaveBeenCalledWith('query', {
+            });
+            expect(collector.collect).toHaveBeenCalledWith('query', {
                 query: 'SELECT * FROM users WHERE id = ?',
                 parameters: [1],
                 duration: 50,
@@ -198,403 +83,169 @@ describe('QueryWatcher', () => {
                 connection: 'default',
             }, 'req-123');
         });
-        it('should mark queries as slow when exceeding threshold', async () => {
-            // Arrange
-            const queryData = {
-                query: 'SELECT * FROM large_table',
-                duration: 150, // Above 100ms threshold
-                source: 'typeorm',
-            };
-            // Act
-            watcher.handleQuery(queryData);
-            // Assert
-            expect(mockCollector.collect).toHaveBeenCalledWith('query', expect.objectContaining({
-                slow: true,
-            }), undefined);
-        });
-        it('should not mark queries as slow when below threshold', async () => {
-            // Arrange
-            const queryData = {
-                query: 'SELECT * FROM users',
-                duration: 50, // Below 100ms threshold
+        it('marks queries above slowThreshold as slow', () => {
+            watcher.handleQuery({
+                query: 'SELECT * FROM big',
+                duration: 250,
                 source: 'typeorm',
-            };
-            // Act
-            watcher.handleQuery(queryData);
-            // Assert
-            expect(mockCollector.collect).toHaveBeenCalledWith('query', expect.objectContaining({
-                slow: false,
-            }), undefined);
-        });
-        it('should use custom slowThreshold', async () => {
-            // Arrange
-            mockConfig.watchers = { query: { enabled: true, slowThreshold: 200 } };
-            watcher = await createWatcher(mockConfig);
-            const queryData = {
-                query: 'SELECT * FROM users',
-                duration: 150, // Below 200ms custom threshold
-                source: 'prisma',
-            };
-            // Act
-            watcher.handleQuery(queryData);
-            // Assert
-            expect(mockCollector.collect).toHaveBeenCalledWith('query', expect.objectContaining({
-                slow: false,
-            }), undefined);
+            });
+            expect(collector.collect).toHaveBeenCalledWith('query', expect.objectContaining({ slow: true }), undefined);
         });
-        it('should handle queries without parameters', async () => {
-            // Arrange
-            const queryData = {
-                query: 'SELECT COUNT(*) FROM users',
-                duration: 10,
+        it('marks queries at or below slowThreshold as not slow', () => {
+            watcher.handleQuery({
+                query: 'SELECT 1',
+                duration: 100,
                 source: 'typeorm',
-            };
-            // Act
-            watcher.handleQuery(queryData);
-            // Assert
-            expect(mockCollector.collect).toHaveBeenCalledWith('query', expect.objectContaining({
-                parameters: undefined,
-            }), undefined);
+            });
+            expect(collector.collect).toHaveBeenCalledWith('query', expect.objectContaining({ slow: false }), undefined);
         });
-        it('should handle queries without connection name', async () => {
-            // Arrange
-            const queryData = {
-                query: 'SELECT * FROM posts',
-                duration: 20,
+        it('respects custom slowThreshold', async () => {
+            const w = await buildWatcher({
+                watchers: { query: { enabled: true, slowThreshold: 200 } },
+            });
+            w.handleQuery({
+                query: 'SELECT * FROM x',
+                duration: 150,
                 source: 'prisma',
-            };
-            // Act
-            watcher.handleQuery(queryData);
-            // Assert
-            expect(mockCollector.collect).toHaveBeenCalledWith('query', expect.objectContaining({
-                connection: undefined,
-            }), undefined);
+            });
+            expect(collector.collect).toHaveBeenCalledWith('query', expect.objectContaining({ slow: false }), undefined);
         });
-    });
-    // ============================================================================
-    // Ignore Patterns
-    // ============================================================================
-    describe('Ignore Patterns', () => {
-        it('should skip queries matching ignore patterns', async () => {
-            // Arrange
-            mockConfig.watchers = {
-                query: {
-                    enabled: true,
-                    ignorePatterns: [/^PRAGMA/, /^SELECT 1/],
+        it('skips queries matching any ignore pattern', async () => {
+            const w = await buildWatcher({
+                watchers: {
+                    query: { enabled: true, ignorePatterns: [/^PRAGMA/, /information_schema/] },
                 },
-            };
-            watcher = await createWatcher(mockConfig);
-            // Act
-            watcher.handleQuery({
+            });
+            w.handleQuery({
                 query: 'PRAGMA table_info(users)',
-                duration: 5,
+                duration: 1,
                 source: 'typeorm',
             });
-            // Assert
-            expect(mockCollector.collect).not.toHaveBeenCalled();
-        });
-        it('should skip queries matching any ignore pattern', async () => {
-            // Arrange
-            mockConfig.watchers = {
-                query: {
-                    enabled: true,
-                    ignorePatterns: [/^PRAGMA/, /^SELECT 1/, /health_check/],
-                },
-            };
-            watcher = await createWatcher(mockConfig);
-            // Act
-            watcher.handleQuery({
-                query: 'SELECT 1 AS result',
-                duration: 1,
+            w.handleQuery({
+                query: 'SELECT * FROM information_schema.tables',
+                duration: 5,
                 source: 'typeorm',
             });
-            // Assert
-            expect(mockCollector.collect).not.toHaveBeenCalled();
+            expect(collector.collect).not.toHaveBeenCalled();
         });
-        it('should collect queries not matching ignore patterns', async () => {
-            // Arrange
-            mockConfig.watchers = {
-                query: {
-                    enabled: true,
-                    ignorePatterns: [/^PRAGMA/],
-                },
-            };
-            watcher = await createWatcher(mockConfig);
-            // Act
+        it('normalises whitespace and trims the query', () => {
             watcher.handleQuery({
-                query: 'SELECT * FROM users',
+                query: '   SELECT *\n   FROM   users   WHERE id = 1   ',
                 duration: 10,
                 source: 'typeorm',
             });
-            // Assert
-            expect(mockCollector.collect).toHaveBeenCalled();
-        });
-    });
-    // ============================================================================
-    // Query Formatting
-    // ============================================================================
-    describe('Query Formatting', () => {
-        beforeEach(async () => {
-            watcher = await createWatcher(mockConfig);
-        });
-        it('should normalize whitespace in queries', async () => {
-            // Arrange
-            const queryData = {
-                query: 'SELECT   *   FROM    users   WHERE   id = 1',
-                duration: 10,
-                source: 'typeorm',
-            };
-            // Act
-            const formatted = watcher.formatQuery(queryData.query);
-            // Assert
-            expect(formatted).toBe('SELECT * FROM users WHERE id = 1');
-        });
-        it('should trim leading and trailing whitespace', async () => {
-            // Arrange
-            const query = '   SELECT * FROM users   ';
-            // Act
-            const formatted = watcher.formatQuery(query);
-            // Assert
-            expect(formatted).toBe('SELECT * FROM users');
-        });
-        it('should handle newlines in queries', async () => {
-            // Arrange
-            const query = `SELECT *
-        FROM users
-        WHERE id = 1`;
-            // Act
-            const formatted = watcher.formatQuery(query);
-            // Assert
-            expect(formatted).toBe('SELECT * FROM users WHERE id = 1');
+            expect(collector.collect).toHaveBeenCalledWith('query', expect.objectContaining({ query: 'SELECT * FROM users WHERE id = 1' }), undefined);
         });
     });
-    // ============================================================================
-    // TypeORM Integration
-    // ============================================================================
-    describe('TypeORM Integration', () => {
-        it('should attach logger to initialized DataSource', async () => {
-            // Arrange
-            const mockDataSource = {
-                isInitialized: true,
-                options: { name: 'test-connection' },
-                driver: {
-                    afterQuery: jest.fn(),
-                },
-            };
-            mockedTypes.isModuleAvailable.mockImplementation((mod) => mod === 'typeorm');
-            mockedTypes.tryRequire.mockReturnValue({
-                getDataSources: () => [mockDataSource],
-            });
-            mockedTypes.isTypeORMDataSource.mockReturnValue(true);
-            watcher = await createWatcher(mockConfig);
-            // Act
-            await watcher.onModuleInit();
-            // Assert
-            expect(mockDataSource.driver.afterQuery).not.toBe(undefined);
-        });
-        it('should intercept afterQuery and collect queries', async () => {
-            // Arrange
-            let capturedAfterQuery;
-            const originalAfterQuery = jest.fn();
-            const mockDataSource = {
-                isInitialized: true,
-                options: { name: 'default' },
-                driver: {
-                    get afterQuery() {
-                        return originalAfterQuery;
-                    },
-                    set afterQuery(fn) {
-                        capturedAfterQuery = fn;
-                    },
-                },
-            };
-            mockedTypes.isModuleAvailable.mockImplementation((mod) => mod === 'typeorm');
-            mockedTypes.tryRequire.mockReturnValue({
-                getDataSources: () => [mockDataSource],
+    describe('TypeORM DataSource discovery', () => {
+        it('discovers DataSource instances exposed via DiscoveryService and dedupes by reference', async () => {
+            const fakeDataSource = {
+                constructor: { name: 'DataSource' },
+                options: { name: 'primary', type: 'better-sqlite3' },
+                subscribers: [],
+                logger: undefined,
+            };
+            // Build a wrapper that resembles NestJS's InstanceWrapper minimally.
+            const wrappers = [{ instance: fakeDataSource }, { instance: fakeDataSource }];
+            const watcher = await buildWatcher({
+                watchers: { query: { enabled: true, slowThreshold: 100 } },
             });
-            mockedTypes.isTypeORMDataSource.mockReturnValue(true);
-            watcher = await createWatcher(mockConfig);
-            await watcher.onModuleInit();
-            // Act - simulate TypeORM calling afterQuery
-            capturedAfterQuery?.call(mockDataSource.driver, 'SELECT * FROM users', [1, 2], { rows: [] }, 25);
-            // Assert
-            expect(mockCollector.collect).toHaveBeenCalledWith('query', expect.objectContaining({
-                query: 'SELECT * FROM users',
-                parameters: [1, 2],
-                duration: 25,
-                source: 'typeorm',
-                connection: 'default',
-            }), undefined);
-        });
-        it('should handle uninitialized DataSource', async () => {
-            // Arrange
-            let initializeHook;
-            const mockDataSource = {
-                isInitialized: false,
-                options: { name: 'default' },
-                driver: { afterQuery: null },
-                initialize: jest.fn().mockImplementation(async () => {
-                    mockDataSource.isInitialized = true;
-                    return mockDataSource;
-                }),
-            };
-            mockedTypes.isModuleAvailable.mockImplementation((mod) => mod === 'typeorm');
-            mockedTypes.tryRequire.mockReturnValue({
-                getDataSources: () => [mockDataSource],
+            watcher.discoveryService = {
+                getProviders: () => wrappers,
+            };
+            const found = watcher.discoverTypeORMDataSources();
+            expect(found).toHaveLength(1);
+            expect(found[0]).toBe(fakeDataSource);
+        });
+        it('attaches subscriber + wraps logger and refuses to attach twice', async () => {
+            const fakeDataSource = {
+                constructor: { name: 'DataSource' },
+                options: { name: 'default', type: 'better-sqlite3' },
+                subscribers: [],
+                logger: undefined,
+            };
+            const watcher = await buildWatcher({
+                watchers: { query: { enabled: true, slowThreshold: 100 } },
             });
-            mockedTypes.isTypeORMDataSource.mockReturnValue(true);
-            watcher = await createWatcher(mockConfig);
-            await watcher.onModuleInit();
-            // Capture the wrapped initialize function
-            initializeHook = mockDataSource.initialize;
-            // Act - call the wrapped initialize
-            await initializeHook?.();
-            // Assert - original initialize was called
-            expect(mockDataSource.isInitialized).toBe(true);
+            const first = watcher.attachToDataSource(fakeDataSource);
+            const second = watcher.attachToDataSource(fakeDataSource);
+            expect(first).toBe(true);
+            expect(second).toBe(false);
+            const subs = fakeDataSource.subscribers;
+            expect(subs).toHaveLength(1);
+            expect(subs[0]).toBeInstanceOf(typeorm_subscriber_1.NestLensQuerySubscriber);
+            expect(fakeDataSource.logger).toBeInstanceOf(typeorm_logger_1.NestLensTypeOrmLogger);
         });
     });
-    // ============================================================================
-    // Prisma Integration
-    // ============================================================================
-    describe('Prisma Integration', () => {
-        it('should attach middleware to global Prisma client', async () => {
-            // Arrange
-            const mockPrismaClient = {
-                $use: jest.fn(),
-            };
-            global.prisma = mockPrismaClient;
-            mockedTypes.isModuleAvailable.mockImplementation((mod) => mod === '@prisma/client');
-            mockedTypes.isPrismaClient.mockReturnValue(true);
-            watcher = await createWatcher(mockConfig);
-            // Act
-            await watcher.onModuleInit();
-            // Assert
-            expect(mockPrismaClient.$use).toHaveBeenCalled();
-            // Cleanup
-            delete global.prisma;
-        });
-        it('should collect Prisma queries through middleware', async () => {
-            // Arrange
-            let capturedMiddleware;
-            const mockPrismaClient = {
-                $use: jest.fn((middleware) => {
-                    capturedMiddleware = middleware;
-                }),
-            };
-            global.prisma = mockPrismaClient;
-            mockedTypes.isModuleAvailable.mockImplementation((mod) => mod === '@prisma/client');
-            mockedTypes.isPrismaClient.mockReturnValue(true);
-            watcher = await createWatcher(mockConfig);
-            await watcher.onModuleInit();
-            const mockNext = jest.fn().mockResolvedValue({ id: 1, name: 'Test' });
-            // Act - simulate Prisma middleware call
-            const startTime = Date.now();
-            await capturedMiddleware?.({ model: 'User', action: 'findMany', args: { where: { active: true } } }, mockNext);
-            // Assert
-            expect(mockNext).toHaveBeenCalled();
-            expect(mockCollector.collect).toHaveBeenCalledWith('query', expect.objectContaining({
-                query: 'User.findMany',
-                parameters: [{ where: { active: true } }],
-                source: 'prisma',
-            }), undefined);
-            // Cleanup
-            delete global.prisma;
-        });
-        it('should skip Prisma if client has no $use method', async () => {
-            // Arrange
-            const mockPrismaClient = {};
-            global.prisma = mockPrismaClient;
-            mockedTypes.isModuleAvailable.mockImplementation((mod) => mod === '@prisma/client');
-            mockedTypes.isPrismaClient.mockReturnValue(true);
-            watcher = await createWatcher(mockConfig);
-            // Act
-            await watcher.onModuleInit();
-            // Assert - should not throw
-            expect(mockCollector.collect).not.toHaveBeenCalled();
-            // Cleanup
-            delete global.prisma;
-        });
-        it('should handle missing model in Prisma params', async () => {
-            // Arrange
-            let capturedMiddleware;
-            const mockPrismaClient = {
-                $use: jest.fn((middleware) => {
-                    capturedMiddleware = middleware;
-                }),
-            };
-            global.prisma = mockPrismaClient;
-            mockedTypes.isModuleAvailable.mockImplementation((mod) => mod === '@prisma/client');
-            mockedTypes.isPrismaClient.mockReturnValue(true);
-            watcher = await createWatcher(mockConfig);
-            await watcher.onModuleInit();
-            const mockNext = jest.fn().mockResolvedValue([]);
-            // Act
-            await capturedMiddleware?.({ model: undefined, action: '$queryRaw', args: undefined }, mockNext);
-            // Assert
-            expect(mockCollector.collect).toHaveBeenCalledWith('query', expect.objectContaining({
-                query: 'unknown.$queryRaw',
-                parameters: undefined,
-            }), undefined);
-            // Cleanup
-            delete global.prisma;
-        });
-    });
-    // ============================================================================
-    // Error Handling
-    // ============================================================================
-    describe('Error Handling', () => {
-        it('should gracefully handle TypeORM initialization errors', async () => {
-            // Arrange
-            mockedTypes.isModuleAvailable.mockImplementation((mod) => mod === 'typeorm');
-            mockedTypes.tryRequire.mockImplementation(() => {
-                throw new Error('TypeORM not found');
+    describe('NestLensQuerySubscriber', () => {
+        it('translates an afterQuery event into a QueryData payload', () => {
+            const handler = jest.fn();
+            const sub = new typeorm_subscriber_1.NestLensQuerySubscriber(handler, 'main');
+            sub.afterQuery({
+                query: 'SELECT 1',
+                parameters: [],
+                executionTime: 12,
+                success: true,
             });
-            watcher = await createWatcher(mockConfig);
-            // Act & Assert - should not throw
-            await expect(watcher.onModuleInit()).resolves.not.toThrow();
-        });
-        it('should gracefully handle Prisma initialization errors', async () => {
-            // Arrange
-            mockedTypes.isModuleAvailable.mockImplementation((mod) => mod === '@prisma/client');
-            mockedTypes.isPrismaClient.mockImplementation(() => {
-                throw new Error('Prisma error');
+            expect(handler).toHaveBeenCalledWith({
+                query: 'SELECT 1',
+                parameters: [],
+                duration: 12,
+                source: 'typeorm',
+                connection: 'main',
+                success: true,
+                error: undefined,
             });
-            watcher = await createWatcher(mockConfig);
-            // Act & Assert - should not throw
-            await expect(watcher.onModuleInit()).resolves.not.toThrow();
         });
-    });
-    // ============================================================================
-    // Source Types
-    // ============================================================================
-    describe('Source Types', () => {
-        beforeEach(async () => {
-            watcher = await createWatcher(mockConfig);
+        it('ignores events without a query string', () => {
+            const handler = jest.fn();
+            const sub = new typeorm_subscriber_1.NestLensQuerySubscriber(handler, 'main');
+            sub.afterQuery({});
+            expect(handler).not.toHaveBeenCalled();
         });
-        it('should identify TypeORM queries', async () => {
-            // Arrange & Act
-            watcher.handleQuery({
-                query: 'SELECT * FROM users',
-                duration: 10,
+    });
+    describe('NestLensTypeOrmLogger', () => {
+        it('records logQueryError as a failed query and delegates to the wrapped logger', () => {
+            const handler = jest.fn();
+            const delegate = { logQueryError: jest.fn() };
+            const logger = new typeorm_logger_1.NestLensTypeOrmLogger(handler, 'default', delegate);
+            const error = new Error('boom');
+            logger.logQueryError(error, 'SELECT * FROM missing', [1]);
+            expect(handler).toHaveBeenCalledWith({
+                query: 'SELECT * FROM missing',
+                parameters: [1],
+                duration: 0,
                 source: 'typeorm',
                 connection: 'default',
+                success: false,
+                error,
             });
-            // Assert
-            expect(mockCollector.collect).toHaveBeenCalledWith('query', expect.objectContaining({
-                source: 'typeorm',
-            }), undefined);
-        });
-        it('should identify Prisma queries', async () => {
-            // Arrange & Act
-            watcher.handleQuery({
-                query: 'User.findMany',
-                duration: 15,
-                source: 'prisma',
-            });
-            // Assert
-            expect(mockCollector.collect).toHaveBeenCalledWith('query', expect.objectContaining({
-                source: 'prisma',
-            }), undefined);
+            expect(delegate.logQueryError).toHaveBeenCalledWith(error, 'SELECT * FROM missing', [1], undefined);
+        });
+        it('records logQuerySlow with the reported execution time', () => {
+            const handler = jest.fn();
+            const logger = new typeorm_logger_1.NestLensTypeOrmLogger(handler, 'default');
+            logger.logQuerySlow(450, 'SELECT * FROM big', []);
+            expect(handler).toHaveBeenCalledWith(expect.objectContaining({ duration: 450, success: true }));
+        });
+        it('forwards delegate-only methods without invoking the handler', () => {
+            const handler = jest.fn();
+            const delegate = {
+                logQuery: jest.fn(),
+                logSchemaBuild: jest.fn(),
+                logMigration: jest.fn(),
+                log: jest.fn(),
+            };
+            const logger = new typeorm_logger_1.NestLensTypeOrmLogger(handler, 'default', delegate);
+            logger.logQuery('SELECT 1', []);
+            logger.logSchemaBuild('build');
+            logger.logMigration('migrate');
+            logger.log('warn', 'hi');
+            expect(handler).not.toHaveBeenCalled();
+            expect(delegate.logQuery).toHaveBeenCalled();
+            expect(delegate.logSchemaBuild).toHaveBeenCalled();
+            expect(delegate.logMigration).toHaveBeenCalled();
+            expect(delegate.log).toHaveBeenCalled();
         });
     });
 });